diff --git a/cmake/Modules/Packages/KOKKOS.cmake b/cmake/Modules/Packages/KOKKOS.cmake
index 29beaca957885e0886d34c16437467066c06a061..9093bb775a1908dea285d807999a4b1d3198ba16 100644
--- a/cmake/Modules/Packages/KOKKOS.cmake
+++ b/cmake/Modules/Packages/KOKKOS.cmake
@@ -1,10 +1,36 @@
 if(PKG_KOKKOS)
-  # TODO: this option needs to be documented when this works with a
-  # regular release version of KOKKOS, and a version compatibility check
-  # of external KOKKOS lib versus what the KOKKOS package needs is required.
-  option(EXTERNAL_KOKKOS "Build against external kokkos library")
-  if(EXTERNAL_KOKKOS)
-    find_package(Kokkos REQUIRED)
+  option(EXTERNAL_KOKKOS "Build against external kokkos library" OFF)
+  option(DOWNLOAD_KOKKOS "Download the KOKKOS library instead of using the bundled one" OFF)
+  if(DOWNLOAD_KOKKOS)
+    if(CMAKE_VERSION VERSION_LESS 3.11)
+      message(FATAL_ERROR "Downloading kokkos currently only works with cmake-3.11 and higher")
+    endif()
+    message(STATUS "KOKKOS download requested - we will build our own")
+    # Workaround for cross compilation with MinGW where ${CMAKE_INSTALL_LIBDIR}
+    # is a full path, so we need to remove the prefix
+    string(REPLACE ${CMAKE_INSTALL_PREFIX} "" _KOKKOS_LIBDIR ${CMAKE_INSTALL_LIBDIR})
+    file(DOWNLOAD https://github.com/kokkos/kokkos/compare/3.0.00...stanmoore1:lammps.diff ${CMAKE_CURRENT_BINARY_DIR}/kokkos-lammps.patch)
+    include(ExternalProject)
+    ExternalProject_Add(kokkos_build
+      URL https://github.com/kokkos/kokkos/archive/3.0.00.tar.gz
+      URL_MD5 281c7093aa3a603276e93abdf4be23b9
+      PATCH_COMMAND patch -p1 < ${CMAKE_CURRENT_BINARY_DIR}/kokkos-lammps.patch
+      CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> ${CMAKE_REQUEST_PIC}
+      -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+      -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
+      BUILD_BYPRODUCTS <INSTALL_DIR>/${_KOKKOS_LIBDIR}/libkokkoscore.a
+    )
+    list(APPEND LAMMPS_DEPS kokkos_build)
+    ExternalProject_get_property(kokkos_build INSTALL_DIR)
+    set(KOKKOS_LIBRARIES ${INSTALL_DIR}/${_KOKKOS_LIBDIR}/libkokkoscore.a) 
+    set(KOKKOS_INCLUDE_DIRS ${INSTALL_DIR}/include)
+    include_directories(${KOKKOS_INCLUDE_DIRS})
+    list(APPEND LAMMPS_LINK_LIBS ${KOKKOS_LIBRARIES} ${CMAKE_DL_LIBS})
+  elseif(EXTERNAL_KOKKOS)
+    find_package(Kokkos 3)
+    if(NOT Kokkos_FOUND)
+      message(FATAL_ERROR "KOKKOS library not found, help CMake to find it by setting KOKKOS_LIBRARY, or set DOWNLOAD_KOKKOS=ON to download it")
+    endif()
     list(APPEND LAMMPS_LINK_LIBS Kokkos::kokkos)
   else()
     set(LAMMPS_LIB_KOKKOS_SRC_DIR ${LAMMPS_LIB_SOURCE_DIR}/kokkos)
diff --git a/doc/src/Speed_kokkos.rst b/doc/src/Speed_kokkos.rst
index 66589570068aaa1a595c2ccfc1e594c86c7c8831..ab8444b845d5e559c3c515765027b94abd9e0623 100644
--- a/doc/src/Speed_kokkos.rst
+++ b/doc/src/Speed_kokkos.rst
@@ -38,7 +38,7 @@ compatible with specific hardware.
 .. note::
 
    To build with Kokkos support for NVIDIA GPUs, NVIDIA CUDA
-   software version 7.5 or later must be installed on your system. See
+   software version 9.0 or later must be installed on your system. See
    the discussion for the :doc:`GPU package <Speed_gpu>` for details of how
    to check and do this.
 
diff --git a/doc/src/fix_adapt.rst b/doc/src/fix_adapt.rst
index eab8f92639b7b31543b985640e0d968bdc3f1e9f..b4587caf73c18ab7978a7bcb0d15af8b7290aa17 100644
--- a/doc/src/fix_adapt.rst
+++ b/doc/src/fix_adapt.rst
@@ -288,11 +288,19 @@ Currently *bond* does not support bond_style hybrid nor bond_style
 hybrid/overlay as bond styles. The only bonds that currently are
 working with fix_adapt are
 
-+---------------------------------+-------+------------+
-| :doc:`gromos <bond_gromos>`     | k, r0 | type bonds |
-+---------------------------------+-------+------------+
-| :doc:`harmonic <bond_harmonic>` | k,r0  | type bonds |
-+---------------------------------+-------+------------+
++------------------------------------+-------+------------+
+| :doc:`class2 <bond_class2>`        | r0    | type bonds |
++------------------------------------+-------+------------+
+| :doc:`fene <bond_fene>`            | k, r0 | type bonds |
++------------------------------------+-------+------------+
+| :doc:`gromos <bond_gromos>`        | k, r0 | type bonds |
++------------------------------------+-------+------------+
+| :doc:`harmonic <bond_harmonic>`    | k,r0  | type bonds |
++------------------------------------+-------+------------+
+| :doc:`morse <bond_morse>`          | r0    | type bonds |
++------------------------------------+-------+------------+
+| :doc:`nonlinear <bond_nonlinear>`  | r0    | type bonds |
++------------------------------------+-------+------------+
 
 ----------
 
diff --git a/lib/kokkos/BUILD.md b/lib/kokkos/BUILD.md
new file mode 100644
index 0000000000000000000000000000000000000000..84a1bc3b3788c2ba99c7b2ab4c992108737188db
--- /dev/null
+++ b/lib/kokkos/BUILD.md
@@ -0,0 +1,323 @@
+![Kokkos](https://avatars2.githubusercontent.com/u/10199860?s=200&v=4)
+
+# Installing and Using Kokkos
+
+## Kokkos Philosophy
+Kokkos provides a modern CMake style build system.
+As C++ continues to develop for C++20 and beyond, CMake is likely to provide the most robust support
+for C++.  Applications heavily leveraging Kokkos are strongly encouraged to use a CMake build system.
+
+You can either use Kokkos as an installed package (encouraged) or use Kokkos in-tree in your project.
+Modern CMake is exceedingly simple at a high-level (with the devil in the details).
+Once Kokkos is installed In your `CMakeLists.txt` simply use:
+````
+find_package(Kokkos REQUIRED)
+````
+Then for every executable or library in your project:
+````
+target_link_libraries(myTarget Kokkos::kokkos)
+````
+That's it! There is no checking Kokkos preprocessor, compiler, or linker flags.
+Kokkos propagates all the necessary flags to your project.
+This means not only is linking to Kokkos easy, but Kokkos itself can actually configure compiler and linker flags for *your*
+project. If building in-tree, there is no `find_package` and you link with `target_link_libraries(kokkos)`.
+
+
+## Configuring CMake
+A very basic installation is done with:
+````
+cmake ${srcdir} \
+ -DCMAKE_CXX_COMPILER=g++ \
+ -DCMAKE_INSTALL_PREFIX=${my_install_folder}
+````
+which builds and installed a default Kokkos when you run `make install`.
+There are numerous device backends, options, and architecture-specific optimizations that can be configured, e.g.
+````
+cmake ${srcdir} \
+ -DCMAKE_CXX_COMPILER=g++ \
+ -DCMAKE_INSTALL_PREFIX=${my_install_folder} \
+ -DKokkos_ENABLE_OPENMP=On
+````
+which activates the OpenMP backend. All of the options controlling device backends, options, architectures, and third-party libraries (TPLs) are given below.
+
+## Spack
+An alternative to manually building with the CMake is to use the Spack package manager.
+To do so, download the `kokkos-spack` git repo and add to the package list:
+````
+spack repo add $path-to-kokkos-spack
+````
+A basic installation would be done as:
+````
+spack install kokkos
+````
+Spack allows options and and compilers to be tuned in the install command.
+````
+spack install kokkos@3.0 %gcc@7.3.0 +openmp
+````
+This example illustrates the three most common parameters to Spack:
+* Variants: specified with, e.g. `+openmp`, this activates (or deactivates with, e.g. `~openmp`) certain options.
+* Version:  immediately following `kokkos` the `@version` can specify a particular Kokkos to build
+* Compiler: a default compiler will be chosen if not specified, but an exact compiler version can be given with the `%`option.
+
+For a complete list of Kokkos options, run:
+````
+spack info kokkos
+````
+
+#### Spack Development
+Spack currently installs packages to a location determined by a unique hash. This hash name is not really "human readable".
+Generally, Spack usage should never really require you to reference the computer-generated unique install folder.
+If you must know, you can locate Spack Kokkos installations with:
+````
+spack find -p kokkos ...
+````
+where `...` is the unique spec identifying the particular Kokkos configuration and version.
+
+A better way to use Spack for doing Kokkos development is the DIY feature of Spack.
+If you wish to develop Kokkos itself, go to the Kokkos source folder:
+````
+spack diy -u cmake kokkos@diy ...
+````
+where `...` is a Spack spec identifying the exact Kokkos configuration.
+This then creates a `spack-build` directory where you can run `make`.
+
+If doing development on a downstream project, you can do almost exactly the same thing.
+````
+spack diy -u cmake ${myproject}@${myversion} ... ^kokkos...
+````
+where the `...` are the specs for your project and the desired Kokkos configuration.
+Again, a `spack-build` directory will be created where you can run `make`.
+
+Spack has a few idiosyncracies that make building outside of Spack annoying related to Spack forcing use of a compiler wrapper. This can be worked around by having a `-DSpack_WORKAROUND=On` given your CMake. Then add the block of code to your CMakeLists.txt:
+
+````
+if (Spack_WORKAROUND)
+ set(SPACK_CXX $ENV{SPACK_CXX})
+ if(SPACK_CXX)
+   set(CMAKE_CXX_COMPILER ${SPACK_CXX} CACHE STRING "the C++ compiler" FORCE)
+   set(ENV{CXX} ${SPACK_CXX})
+ endif()
+endif()
+````
+
+# Kokkos Keyword Listing
+
+## Device Backends
+Device backends can be enabled by specifying `-DKokkos_ENABLE_X`.
+
+* Kokkos_ENABLE_CUDA
+    * Whether to build CUDA backend
+    * BOOL Default: OFF
+* Kokkos_ENABLE_HPX
+    * Whether to build HPX backend (experimental)
+    * BOOL Default: OFF
+* Kokkos_ENABLE_OPENMP
+    * Whether to build OpenMP backend
+    * BOOL Default: OFF
+* Kokkos_ENABLE_PTHREAD
+    * Whether to build Pthread backend
+    * BOOL Default: OFF
+* Kokkos_ENABLE_SERIAL
+    * Whether to build serial  backend
+    * BOOL Default: ON
+
+## Enable Options
+Options can be enabled by specifying `-DKokkos_ENABLE_X`.
+
+* Kokkos_ENABLE_AGGRESSIVE_VECTORIZATION
+    * Whether to aggressively vectorize loops
+    * BOOL Default: OFF
+* Kokkos_ENABLE_COMPILER_WARNINGS
+    * Whether to print all compiler warnings
+    * BOOL Default: OFF
+* Kokkos_ENABLE_CUDA_CONSTEXPR
+    * Whether to activate experimental relaxed constexpr functions
+    * BOOL Default: OFF
+* Kokkos_ENABLE_CUDA_LAMBDA
+    * Whether to activate experimental lambda features
+    * BOOL Default: OFF
+* Kokkos_ENABLE_CUDA_LDG_INTRINSIC
+    * Whether to use CUDA LDG intrinsics
+    * BOOL Default: OFF
+* Kokkos_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
+    * Whether to enable relocatable device code (RDC) for CUDA
+    * BOOL Default: OFF
+* Kokkos_ENABLE_CUDA_UVM
+    * Whether to use unified memory (UM) by default for CUDA
+    * BOOL Default: OFF
+* Kokkos_ENABLE_DEBUG
+    * Whether to activate extra debug features - may increase compile times
+    * BOOL Default: OFF
+* Kokkos_ENABLE_DEBUG_BOUNDS_CHECK
+    * Whether to use bounds checking - will increase runtime
+    * BOOL Default: OFF
+* Kokkos_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
+    * Debug check on dual views
+    * BOOL Default: OFF
+* Kokkos_ENABLE_DEPRECATED_CODE
+    * Whether to enable deprecated code
+    * BOOL Default: OFF
+* Kokkos_ENABLE_HPX_ASYNC_DISPATCH
+    * Whether HPX supports asynchronous dispatch
+    * BOOL Default: OFF
+* Kokkos_ENABLE_LARGE_MEM_TESTS
+    * Whether to perform extra large memory tests
+    * BOOL_Default: OFF
+* Kokkos_ENABLE_PROFILING
+    * Whether to create bindings for profiling tools
+    * BOOL Default: ON
+* Kokkos_ENABLE_PROFILING_LOAD_PRINT
+    * Whether to print information about which profiling tools gotloaded
+    * BOOL Default: OFF
+* Kokkos_ENABLE_TESTS
+    * Whether to build serial  backend
+    * BOOL Default: OFF
+
+## Other Options
+* Kokkos_CXX_STANDARD
+    * The C++ standard for Kokkos to use: c++11, c++14, c++17, or c++20. This should be given in CMake style as 11, 14, 17, or 20.
+    * STRING Default: 11
+
+## Third-party Libraries (TPLs)
+The following options control enabling TPLs:
+* Kokkos_ENABLE_HPX
+    * Whether to enable the HPX library
+    * BOOL Default: OFF
+* Kokkos_ENABLE_HWLOC
+    * Whether to enable the HWLOC library
+    * BOOL Default: Off
+* Kokkos_ENABLE_LIBNUMA
+    * Whether to enable the LIBNUMA library
+    * BOOL Default: Off
+* Kokkos_ENABLE_MEMKIND
+    * Whether to enable the MEMKIND library
+    * BOOL Default: Off
+* Kokkos_ENABLE_LIBDL
+    * Whether to enable the LIBDL library
+    * BOOL Default: On
+* Kokkos_ENABLE_LIBRT
+    * Whether to enable the LIBRT library
+    * BOOL Default: Off
+
+The following options control finding and configuring non-CMake TPLs:
+* Kokkos_CUDA_DIR or CUDA_ROOT
+    * Location of CUDA install prefix for libraries
+    * PATH Default:
+* Kokkos_HWLOC_DIR or HWLOC_ROOT
+    * Location of HWLOC install prefix
+    * PATH Default:
+* Kokkos_LIBNUMA_DIR or LIBNUMA_ROOT
+    * Location of LIBNUMA install prefix
+    * PATH Default:
+* Kokkos_MEMKIND_DIR or MEMKIND_ROOT
+    * Location of MEMKIND install prefix
+    * PATH Default:
+* Kokkos_LIBDL_DIR or LIBDL_ROOT
+    * Location of LIBDL install prefix
+    * PATH Default:
+* Kokkos_LIBRT_DIR or LIBRT_ROOT
+    * Location of LIBRT install prefix
+    * PATH Default:
+
+The following options control `find_package` paths for CMake-based TPLs:
+* HPX_DIR or HPX_ROOT
+    * Location of HPX prefix (ROOT) or CMake config file (DIR)
+    * PATH Default:
+
+## Architecture Keywords
+Architecture-specific optimizations can be enabled by specifying `-DKokkos_ARCH_X`.
+
+* Kokkos_ARCH_AMDAVX
+    * Whether to optimize for the AMDAVX architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_ARMV80
+    * Whether to optimize for the ARMV80 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_ARMV81
+    * Whether to optimize for the ARMV81 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_ARMV8_THUNDERX
+    * Whether to optimize for the ARMV8_THUNDERX architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_ARMV8_TX2
+    * Whether to optimize for the ARMV8_TX2 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_BDW
+    * Whether to optimize for the BDW architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_BGQ
+    * Whether to optimize for the BGQ architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_EPYC
+    * Whether to optimize for the EPYC architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_HSW
+    * Whether to optimize for the HSW architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_KEPLER30
+    * Whether to optimize for the KEPLER30 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_KEPLER32
+    * Whether to optimize for the KEPLER32 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_KEPLER35
+    * Whether to optimize for the KEPLER35 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_KEPLER37
+    * Whether to optimize for the KEPLER37 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_KNC
+    * Whether to optimize for the KNC architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_KNL
+    * Whether to optimize for the KNL architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_MAXWELL50
+    * Whether to optimize for the MAXWELL50 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_MAXWELL52
+    * Whether to optimize for the MAXWELL52 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_MAXWELL53
+    * Whether to optimize for the MAXWELL53 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_PASCAL60
+    * Whether to optimize for the PASCAL60 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_PASCAL61
+    * Whether to optimize for the PASCAL61 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_POWER7
+    * Whether to optimize for the POWER7 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_POWER8
+    * Whether to optimize for the POWER8 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_POWER9
+    * Whether to optimize for the POWER9 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_SKX
+    * Whether to optimize for the SKX architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_SNB
+    * Whether to optimize for the SNB architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_TURING75
+    * Whether to optimize for the TURING75 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_VOLTA70
+    * Whether to optimize for the VOLTA70 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_VOLTA72
+    * Whether to optimize for the VOLTA72 architecture
+    * BOOL Default: OFF
+* Kokkos_ARCH_WSM
+    * Whether to optimize for the WSM architecture
+    * BOOL Default: OFF
+
+##### [LICENSE](https://github.com/kokkos/kokkos/blob/devel/LICENSE)
+
+[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+
+Under the terms of Contract DE-NA0003525 with NTESS,
+the U.S. Government retains certain rights in this software.
diff --git a/lib/kokkos/CHANGELOG.md b/lib/kokkos/CHANGELOG.md
index 8d196e2c35abf8c6a8109a3a2f84cc781de67925..1d54b4c21defdcf9b19579aeef28bdfad119c94f 100644
--- a/lib/kokkos/CHANGELOG.md
+++ b/lib/kokkos/CHANGELOG.md
@@ -1,5 +1,45 @@
 # Change Log
 
+## [3.0.00](https://github.com/kokkos/kokkos/tree/3.0.00) (2020-01-27)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/2.9.00...3.0.00)
+
+**Implemented enhancements:**
+
+- BuildSystem: Standalone Modern CMake Support [\#2104](https://github.com/kokkos/kokkos/issues/2104)
+- StyleFormat: ClangFormat Style [\#2157](https://github.com/kokkos/kokkos/issues/2157)
+- Documentation: Document build system and CMake philosophy [\#2263](https://github.com/kokkos/kokkos/issues/2263)
+- BuildSystem: Add Alias with Namespace Kokkos:: to Interal Libraries [\#2530](https://github.com/kokkos/kokkos/issues/2530)
+- BuildSystem: Universal Kokkos find\_package [\#2099](https://github.com/kokkos/kokkos/issues/2099)
+- BuildSystem: Dropping support for Kokkos\_{DEVICES,OPTIONS,ARCH} in CMake [\#2329](https://github.com/kokkos/kokkos/issues/2329)
+- BuildSystem: Set Kokkos\_DEVICES and Kokkos\_ARCH variables in exported CMake configuration [\#2193](https://github.com/kokkos/kokkos/issues/2193)
+- BuildSystem: Drop support for CUDA 7 and CUDA 8 [\#2489](https://github.com/kokkos/kokkos/issues/2489)
+- BuildSystem: Drop CMake option SEPARATE\_TESTS [\#2266](https://github.com/kokkos/kokkos/issues/2266)
+- BuildSystem: Support expt-relaxed-constexpr same as expt-extended-lambda [\#2411](https://github.com/kokkos/kokkos/issues/2411)
+- BuildSystem: Add Xnvlink to command line options allowed in nvcc\_wrapper [\#2197](https://github.com/kokkos/kokkos/issues/2197)
+- BuildSystem: Install Kokkos config files and target files to lib/cmake/Kokkos [\#2162](https://github.com/kokkos/kokkos/issues/2162)
+- BuildSystem: nvcc\_wrappers and c++ 14 [\#2035](https://github.com/kokkos/kokkos/issues/2035)
+- BuildSystem: Kokkos version major/version minor \(Feature request\) [\#1930](https://github.com/kokkos/kokkos/issues/1930)
+- BuildSystem: CMake namespaces \(and other modern cmake cleanup\) [\#1924](https://github.com/kokkos/kokkos/issues/1924)
+- BuildSystem: Remove capability to install Kokkos via GNU Makefiles [\#2332](https://github.com/kokkos/kokkos/issues/2332)
+- Documentation: Remove PDF ProgrammingGuide in Kokkos replace with link [\#2244](https://github.com/kokkos/kokkos/issues/2244)
+- View: Add Method to Resize View without Initialization [\#2048](https://github.com/kokkos/kokkos/issues/2048)
+- Vector: implement “insert” method for Kokkos\_Vector  \(as a serial function on host\) [\#2437](https://github.com/kokkos/kokkos/issues/2437)
+
+**Fixed bugs:**
+
+- ParallelScan: Kokkos::parallel\scan fix race condition seen in inter-block fence [\#2681](https://github.com/kokkos/kokkos/issues/2681)
+- OffsetView: Kokkos::OffsetView missing constructor which takes pointer [\#2247](https://github.com/kokkos/kokkos/issues/2247)
+- OffsetView: Kokkos::OffsetView: allow offset=0 [\#2246](https://github.com/kokkos/kokkos/issues/2246)
+- DeepCopy: Missing DeepCopy instrumentation in Kokkos [\#2522](https://github.com/kokkos/kokkos/issues/2522)
+- nvcc\_wrapper: --host-only fails with multiple -W\* flags [\#2484](https://github.com/kokkos/kokkos/issues/2484)
+- nvcc\_wrapper: taking first -std option is counterintuitive [\#2553](https://github.com/kokkos/kokkos/issues/2553)
+- Subview: Error taking subviews of views with static_extents of min rank [\#2448](https://github.com/kokkos/kokkos/issues/2448)
+- TeamPolicy: reducers with valuetypes without += broken on CUDA [\#2410](https://github.com/kokkos/kokkos/issues/2410)
+- Libs: Fix inconsistency of Kokkos library names in Kokkos and Trilinos [\#1902](https://github.com/kokkos/kokkos/issues/1902)
+- Complex: operator\>\> for complex\<T\> uses std::ostream, not std::istream [\#2313](https://github.com/kokkos/kokkos/issues/2313)
+- Macros: Restrict not honored for non-intel compilers  [\#1922](https://github.com/kokkos/kokkos/issues/1922)
+
+
 ## [2.9.00](https://github.com/kokkos/kokkos/tree/2.9.00) (2019-06-24)
 [Full Changelog](https://github.com/kokkos/kokkos/compare/2.8.00...2.9.00)
 
diff --git a/lib/kokkos/CMakeLists.txt b/lib/kokkos/CMakeLists.txt
index 236f523aec21e30e731937c7d5118ec3d2e2a007..6a4451b2e787ebf0287b058ecf23adaea0e26894 100644
--- a/lib/kokkos/CMakeLists.txt
+++ b/lib/kokkos/CMakeLists.txt
@@ -1,128 +1,218 @@
-# Is this a build as part of Trilinos?
 
+# We want to determine if options are given with the wrong case
+# In order to detect which arguments are given to compare against
+# the list of valid arguments, at the beginning here we need to
+# form a list of all the given variables. If it begins with any 
+# case of KoKkOS, we add it to the list.
+
+
+GET_CMAKE_PROPERTY(_variableNames VARIABLES)
+SET(KOKKOS_GIVEN_VARIABLES)
+FOREACH (var ${_variableNames})
+  STRING(TOUPPER ${var} UC_VAR)
+  STRING(FIND ${UC_VAR} KOKKOS IDX)
+  IF (${IDX} EQUAL 0)
+    LIST(APPEND KOKKOS_GIVEN_VARIABLES ${var})
+  ENDIF()
+ENDFOREACH()
+
+# Basic initialization (Used in KOKKOS_SETTINGS)
+SET(Kokkos_SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR})
+SET(KOKKOS_SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR})
+SET(KOKKOS_SRC_PATH      ${Kokkos_SOURCE_DIR})
+SET(KOKKOS_PATH          ${Kokkos_SOURCE_DIR})
+SET(KOKKOS_TOP_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+# Needed to simplify syntax of if statements
+CMAKE_POLICY(SET CMP0054 NEW)
+
+# Is this a build as part of Trilinos?
 IF(COMMAND TRIBITS_PACKAGE_DECL)
-  SET(KOKKOS_HAS_TRILINOS ON CACHE BOOL "")
+  SET(KOKKOS_HAS_TRILINOS ON)
 ELSE()
-  SET(KOKKOS_HAS_TRILINOS OFF CACHE BOOL "")
+  SET(KOKKOS_HAS_TRILINOS OFF)
 ENDIF()
 
-IF(NOT KOKKOS_HAS_TRILINOS)
-  cmake_minimum_required(VERSION 3.3 FATAL_ERROR)
+INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_functions.cmake)
+INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_pick_cxx_std.cmake)
+
+SET(KOKKOS_ENABLED_OPTIONS)      #exported in config file
+SET(KOKKOS_ENABLED_DEVICES)      #exported in config file
+SET(KOKKOS_ENABLED_TPLS)         #exported in config file
+SET(KOKKOS_ENABLED_ARCH_LIST)    #exported in config file
+
+#These are helper flags used for sanity checks during config
+#Certain features should depend on other features being configured first
+SET(KOKKOS_CFG_DAG_NONE              On) #sentinel to indicate no dependencies
+SET(KOKKOS_CFG_DAG_DEVICES_DONE      Off)
+SET(KOKKOS_CFG_DAG_OPTIONS_DONE      Off)
+SET(KOKKOS_CFG_DAG_ARCH_DONE         Off)
+SET(KOKKOS_CFG_DAG_CXX_STD_DONE      Off)
+SET(KOKKOS_CFG_DAG_COMPILER_ID_DONE  Off)
+FUNCTION(KOKKOS_CFG_DEPENDS SUCCESSOR PRECURSOR)
+  SET(PRE_FLAG  KOKKOS_CFG_DAG_${PRECURSOR})
+  SET(POST_FLAG KOKKOS_CFG_DAG_${SUCCESSOR})
+  IF (NOT ${PRE_FLAG})
+    MESSAGE(FATAL_ERROR "Bad CMake refactor: feature ${SUCCESSOR} cannot be configured until ${PRECURSOR} is configured")
+  ENDIF()
+  GLOBAL_SET(${POST_FLAG} On)
+ENDFUNCTION()
 
-  # Define Project Name if this is a standalone build
+
+LIST(APPEND CMAKE_MODULE_PATH cmake/Modules)
+
+IF(NOT KOKKOS_HAS_TRILINOS)
+  cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
+  set(CMAKE_DISABLE_SOURCE_CHANGES ON)
+  set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
+  IF (Spack_WORKAROUND) 
+    #if we are explicitly using Spack for development,
+    #nuke the Spack compiler
+    SET(SPACK_CXX $ENV{SPACK_CXX})
+    IF(SPACK_CXX)
+      SET(CMAKE_CXX_COMPILER ${SPACK_CXX} CACHE STRING "the C++ compiler" FORCE)
+      SET(ENV{CXX} ${SPACK_CXX})
+    ENDIF()
+  ENDif()
   IF(NOT DEFINED ${PROJECT_NAME})
-    project(Kokkos CXX)
+    PROJECT(Kokkos CXX)
   ENDIF()
+ENDIF()
 
-  # Basic initialization (Used in KOKKOS_SETTINGS)
-  set(KOKKOS_SRC_PATH ${Kokkos_SOURCE_DIR})
-  set(KOKKOS_PATH ${KOKKOS_SRC_PATH})
-
-  #------------ COMPILER AND FEATURE CHECKS ------------------------------------
-  include(${KOKKOS_SRC_PATH}/cmake/kokkos_functions.cmake)
-  set_kokkos_cxx_compiler()
-  set_kokkos_cxx_standard()
-
-  #------------ GET OPTIONS AND KOKKOS_SETTINGS --------------------------------
-  # Add Kokkos' modules to CMake's module path.
-  set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${Kokkos_SOURCE_DIR}/cmake/Modules/")
-
-  set(KOKKOS_CMAKE_VERBOSE True)
-  include(${KOKKOS_SRC_PATH}/cmake/kokkos_options.cmake)
-
-  include(${KOKKOS_SRC_PATH}/cmake/kokkos_settings.cmake)
-
-  #------------ GENERATE HEADER AND SOURCE FILES -------------------------------
-  execute_process(
-    COMMAND ${KOKKOS_SETTINGS} make -f ${KOKKOS_SRC_PATH}/cmake/Makefile.generate_cmake_settings CXX=${CMAKE_CXX_COMPILER} PREFIX=${CMAKE_INSTALL_PREFIX} generate_build_settings
-    WORKING_DIRECTORY "${Kokkos_BINARY_DIR}"
-    OUTPUT_FILE ${Kokkos_BINARY_DIR}/core_src_make.out
-    RESULT_VARIABLE GEN_SETTINGS_RESULT
-  )
-  if (GEN_SETTINGS_RESULT)
-    message(FATAL_ERROR "Kokkos settings generation failed:\n"
-        "${KOKKOS_SETTINGS} make -f ${KOKKOS_SRC_PATH}/cmake/Makefile.generate_cmake_settings CXX=${CMAKE_CXX_COMPILER} generate_build_settings")
-  endif()
-  include(${Kokkos_BINARY_DIR}/kokkos_generated_settings.cmake)
-  install(FILES ${Kokkos_BINARY_DIR}/kokkos_generated_settings.cmake DESTINATION lib/cmake/Kokkos)
-  install(FILES ${Kokkos_BINARY_DIR}/kokkos_generated_settings.cmake DESTINATION ${CMAKE_INSTALL_PREFIX})
-  string(REPLACE " " ";" KOKKOS_TPL_INCLUDE_DIRS "${KOKKOS_GMAKE_TPL_INCLUDE_DIRS}")
-  string(REPLACE " " ";" KOKKOS_TPL_LIBRARY_DIRS "${KOKKOS_GMAKE_TPL_LIBRARY_DIRS}")
-  string(REPLACE " " ";" KOKKOS_TPL_LIBRARY_NAMES "${KOKKOS_GMAKE_TPL_LIBRARY_NAMES}")
-  list(REMOVE_ITEM KOKKOS_TPL_INCLUDE_DIRS "")
-  list(REMOVE_ITEM KOKKOS_TPL_LIBRARY_DIRS "")
-  list(REMOVE_ITEM KOKKOS_TPL_LIBRARY_NAMES "")
-  set_kokkos_srcs(KOKKOS_SRC ${KOKKOS_SRC})
-
-  #------------ NOW BUILD ------------------------------------------------------
-  include(${KOKKOS_SRC_PATH}/cmake/kokkos_build.cmake)
-
-  #------------ Add in Fake Tribits Handling to allow unit test builds- --------
-
-  include(${KOKKOS_SRC_PATH}/cmake/tribits.cmake)
-
-  TRIBITS_PACKAGE_DECL(Kokkos)
-
-  ADD_SUBDIRECTORY(core)
-  ADD_SUBDIRECTORY(containers)
-  ADD_SUBDIRECTORY(algorithms)
+IF (NOT CMAKE_SIZEOF_VOID_P)
+  STRING(FIND ${CMAKE_CXX_COMPILER} nvcc_wrapper FIND_IDX)
+  IF (NOT FIND_IDX STREQUAL -1)
+    MESSAGE(FATAL_ERROR "Kokkos did not configure correctly and failed to validate compiler. The most likely cause is CUDA linkage using nvcc_wrapper. Please ensure your CUDA environment is correctly configured.")
+  ELSE()
+    MESSAGE(FATAL_ERROR "Kokkos did not configure correctly and failed to validate compiler. The most likely cause is linkage errors during CMake compiler validation. Please consult the CMake error log shown below for the exact error during compiler validation")
+  ENDIF()
+ELSEIF (NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+  MESSAGE(FATAL_ERROR "Kokkos assumes a 64-bit build; i.e., 8-byte pointers, but found ${CMAKE_SIZEOF_VOID_P}-byte pointers instead")
+ENDIF()
 
-ELSE()
-#------------------------------------------------------------------------------
-#
-# A) Forward declare the package so that certain options are also defined for
-# subpackages
-#
 
-TRIBITS_PACKAGE_DECL(Kokkos) # ENABLE_SHADOWING_WARNINGS)
+set(Kokkos_VERSION_MAJOR 3)
+set(Kokkos_VERSION_MINOR 0)
+set(Kokkos_VERSION_PATCH 0)
+set(Kokkos_VERSION "${Kokkos_VERSION_MAJOR}.${Kokkos_VERSION_MINOR}.${Kokkos_VERSION_PATCH}")
 
+IF(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.12.0") 
+  MESSAGE(STATUS "Setting policy CMP0074 to use <Package>_ROOT variables")
+  CMAKE_POLICY(SET CMP0074 NEW)
+ENDIF()
+
+# Load either the real TriBITS or a TriBITS wrapper 
+# for certain utility functions that are universal (like GLOBAL_SET)
+INCLUDE(${KOKKOS_SRC_PATH}/cmake/fake_tribits.cmake)
+
+IF (Kokkos_ENABLE_CUDA AND ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14.0")
+  #If we are building CUDA, we have tricked CMake because we declare a CXX project
+  #If the default C++ standard for a given compiler matches the requested
+  #standard, then CMake just omits the -std flag in later versions of CMake
+  #This breaks CUDA compilation (CUDA compiler can have a different default
+  #-std then the underlying host compiler by itself). Setting this variable
+  #forces CMake to always add the -std flag even if it thinks it doesn't need it
+  GLOBAL_SET(CMAKE_CXX_STANDARD_DEFAULT 98)
+ENDIF()
+
+# These are the variables we will append to as we go
+# I really wish these were regular variables
+# but scoping issues can make it difficult
+GLOBAL_RESET(KOKKOS_COMPILE_OPTIONS)
+GLOBAL_RESET(KOKKOS_LINK_OPTIONS)
+GLOBAL_RESET(KOKKOS_CUDA_OPTIONS)
+GLOBAL_RESET(KOKKOS_CUDAFE_OPTIONS)
+GLOBAL_RESET(KOKKOS_XCOMPILER_OPTIONS)
+# We need to append text here for making sure TPLs
+# we import are available for an installed Kokkos
+GLOBAL_RESET(KOKKOS_TPL_EXPORTS)
+# We need these for controlling the exact -std flag
+GLOBAL_RESET(KOKKOS_DONT_ALLOW_EXTENSIONS)
+GLOBAL_RESET(KOKKOS_USE_CXX_EXTENSIONS)
+GLOBAL_RESET(KOKKOS_CXX_STANDARD_FEATURE)
+
+# Include a set of Kokkos-specific wrapper functions that
+# will either call raw CMake or TriBITS
+# These are functions like KOKKOS_INCLUDE_DIRECTORIES
+INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_tribits.cmake)
+
+
+# The build environment setup goes in the following steps
+# 1) Check all the enable options. This includes checking Kokkos_DEVICES
+# 2) Check the compiler ID (type and version)
+# 3) Check the CXX standard and select important CXX flags
+# 4) Check for any third-party libraries (TPLs) like hwloc
+# 5) Check if optimizing for a particular architecture and add arch-specific flags
+KOKKOS_SETUP_BUILD_ENVIRONMENT()
+
+# Finish off the build
+# 6) Recurse into subdirectories and configure individual libraries
+# 7) Export and install targets
+
+OPTION(BUILD_SHARED_LIBS "Build shared libraries" OFF)
+# Workaround for building position independent code.
+IF(BUILD_SHARED_LIBS)
+  SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
+ENDIF()
+
+SET(KOKKOS_EXT_LIBRARIES Kokkos::kokkos Kokkos::kokkoscore Kokkos::kokkoscontainers Kokkos::kokkosalgorithms)
+SET(KOKKOS_INT_LIBRARIES kokkos kokkoscore kokkoscontainers kokkosalgorithms)
+SET_PROPERTY(GLOBAL PROPERTY KOKKOS_INT_LIBRARIES ${KOKKOS_INT_LIBRARIES})
+
+GET_DIRECTORY_PROPERTY(HAS_PARENT PARENT_DIRECTORY)
+IF (KOKKOS_HAS_TRILINOS)
+  SET(TRILINOS_INCDIR ${CMAKE_INSTALL_PREFIX}/${${PROJECT_NAME}_INSTALL_INCLUDE_DIR})
+  SET(KOKKOS_HEADER_DIR ${TRILINOS_INCDIR})
+  SET(KOKKOS_IS_SUBDIRECTORY TRUE)
+ELSEIF(HAS_PARENT)
+  SET(KOKKOS_HEADER_DIR "include/kokkos")
+  SET(KOKKOS_IS_SUBDIRECTORY TRUE)
+ELSE()
+  SET(KOKKOS_HEADER_DIR "${CMAKE_INSTALL_INCLUDEDIR}")
+  SET(KOKKOS_IS_SUBDIRECTORY FALSE)
+ENDIF()
 
-#------------------------------------------------------------------------------
-#
-# B) Install Kokkos' build files
-#
-# If using the Makefile-generated files, then need to set things up.
-# Here, assume that TriBITS has been run from ProjectCompilerPostConfig.cmake
-# and already generated KokkosCore_config.h and kokkos_generated_settings.cmake
-# in the previously define Kokkos_GEN_DIR
-# We need to copy them over to the correct place and source the cmake file
-
-if(NOT KOKKOS_LEGACY_TRIBITS)
-  set(Kokkos_GEN_DIR ${CMAKE_BINARY_DIR})
-  file(COPY "${Kokkos_GEN_DIR}/KokkosCore_config.h"
-    DESTINATION "${CMAKE_CURRENT_BINARY_DIR}" USE_SOURCE_PERMISSIONS)
-  install(FILES "${Kokkos_GEN_DIR}/KokkosCore_config.h"
-    DESTINATION include)
-  file(COPY "${Kokkos_GEN_DIR}/kokkos_generated_settings.cmake"
-    DESTINATION "${CMAKE_CURRENT_BINARY_DIR}" USE_SOURCE_PERMISSIONS)
-
-  include(${CMAKE_CURRENT_BINARY_DIR}/kokkos_generated_settings.cmake)
-  # Sources come from makefile-generated kokkos_generated_settings.cmake file
-  # Enable using the individual sources if needed
-  set_kokkos_srcs(KOKKOS_SRC ${KOKKOS_SRC})
-endif ()
 
 
 #------------------------------------------------------------------------------
 #
-# C) Install Kokkos' executable scripts
-#
+# A) Forward declare the package so that certain options are also defined for
+# subpackages
 
-# nvcc_wrapper is Kokkos' wrapper for NVIDIA's NVCC CUDA compiler.
-# Kokkos needs nvcc_wrapper in order to build.  Other libraries and
-# executables also need nvcc_wrapper.  Thus, we need to install it.
-# If the argument of DESTINATION is a relative path, CMake computes it
-# as relative to ${CMAKE_INSTALL_PATH}.
+## This restores the old behavior of ProjectCompilerPostConfig.cmake
+# It sets the CMAKE_CXX_FLAGS globally to those used by Kokkos
+# We must do this before KOKKOS_PACKAGE_DECL
+IF (KOKKOS_HAS_TRILINOS)
+  # Overwrite the old flags at the top-level
+  # Because Tribits doesn't use lists, it uses spaces for the list of CXX flags
+  # we have to match the annoying behavior
+  STRING(REPLACE ";" " " KOKKOSCORE_COMPILE_OPTIONS "${KOKKOS_COMPILE_OPTIONS}")
+  STRING(REPLACE ";" " " KOKKOSCORE_CUDA_OPTIONS    "${KOKKOS_CUDA_OPTIONS}")
+  FOREACH(CUDAFE_FLAG ${KOKKOS_CUDAFE_OPTIONS})
+    SET(KOKKOSCORE_CUDAFE_OPTIONS "${KOKKOSCORE_CUDAFE_OPTIONS} -Xcudafe ${CUDAFE_FLAG}")
+  ENDFOREACH()
+  FOREACH(XCOMP_FLAG ${KOKKOS_XCOMPILER_OPTIONS})
+    SET(KOKKOSCORE_XCOMPILER_OPTIONS "${KOKKOSCORE_XCOMPILER_OPTIONS} -Xcompiler ${XCOMP_FLAG}")
+  ENDFOREACH()
+  SET(KOKKOSCORE_CXX_FLAGS "${KOKKOSCORE_COMPILE_OPTIONS} ${CMAKE_CXX${KOKKOS_CXX_STANDARD}_STANDARD_COMPILE_OPTION} ${KOKKOSCORE_CUDA_OPTIONS} ${KOKKOSCORE_CUDAFE_OPTIONS} ${KOKKOSCORE_XCOMPILER_OPTIONS}")
+  # Both parent scope and this package
+  # In ProjectCompilerPostConfig.cmake, we capture the "global" flags Trilinos wants in
+  # TRILINOS_TOPLEVEL_CXX_FLAGS
+  SET(CMAKE_CXX_FLAGS "${TRILINOS_TOPLEVEL_CXX_FLAGS} ${KOKKOSCORE_CXX_FLAGS}" PARENT_SCOPE)
+  SET(CMAKE_CXX_FLAGS "${TRILINOS_TOPLEVEL_CXX_FLAGS} ${KOKKOSCORE_CXX_FLAGS}")
+  #CMAKE_CXX_FLAGS will get added to Kokkos and Kokkos dependencies automatically here
+  #These flags get set up in KOKKOS_PACKAGE_DECL, which means they
+  #must be configured before KOKKOS_PACKAGE_DECL
+ENDIF()
 
-INSTALL(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/bin/nvcc_wrapper DESTINATION bin)
+KOKKOS_PACKAGE_DECL()
 
 
 #------------------------------------------------------------------------------
 #
-# D) Process the subpackages for Kokkos
+# D) Process the subpackages (subdirectories) for Kokkos
 #
-
-TRIBITS_PROCESS_SUBPACKAGES()
+KOKKOS_PROCESS_SUBPACKAGES()
 
 
 #------------------------------------------------------------------------------
@@ -130,10 +220,39 @@ TRIBITS_PROCESS_SUBPACKAGES()
 # E) If Kokkos itself is enabled, process the Kokkos package
 #
 
-TRIBITS_PACKAGE_DEF()
+KOKKOS_PACKAGE_DEF()
+KOKKOS_EXCLUDE_AUTOTOOLS_FILES()
+KOKKOS_PACKAGE_POSTPROCESS()
 
-TRIBITS_EXCLUDE_AUTOTOOLS_FILES()
+#We are ready to configure the header
+CONFIGURE_FILE(cmake/KokkosCore_config.h.in KokkosCore_config.h @ONLY)
 
-TRIBITS_PACKAGE_POSTPROCESS()
+IF (NOT KOKKOS_HAS_TRILINOS)
+  ADD_LIBRARY(kokkos INTERFACE)
+  #Make sure in-tree projects can reference this as Kokkos::
+  #to match the installed target names
+  ADD_LIBRARY(Kokkos::kokkos ALIAS kokkos)
+  TARGET_LINK_LIBRARIES(kokkos INTERFACE kokkoscore kokkoscontainers kokkosalgorithms)
+  KOKKOS_INTERNAL_ADD_LIBRARY_INSTALL(kokkos)
+ENDIF()
+INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_install.cmake)
 
+# nvcc_wrapper is Kokkos' wrapper for NVIDIA's NVCC CUDA compiler.
+# Kokkos needs nvcc_wrapper in order to build.  Other libraries and
+# executables also need nvcc_wrapper.  Thus, we need to install it.
+# If the argument of DESTINATION is a relative path, CMake computes it
+# as relative to ${CMAKE_INSTALL_PATH}.
+INSTALL(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/bin/nvcc_wrapper DESTINATION ${CMAKE_INSTALL_BINDIR})
+INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/KokkosCore_config.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+
+#  Finally - if we are a subproject - make sure the enabled devices are visible
+IF (HAS_PARENT)
+  FOREACH(DEV Kokkos_ENABLED_DEVICES)
+    #I would much rather not make these cache variables or global properties, but I can't
+    #make any guarantees on whether PARENT_SCOPE is good enough to make 
+    #these variables visible where I need them
+    SET(Kokkos_ENABLE_${DEV} ON PARENT_SCOPE)
+    SET_PROPERTY(GLOBAL PROPERTY Kokkos_ENABLE_${DEV} ON)
+  ENDFOREACH()
 ENDIF()
diff --git a/lib/kokkos/CONTRIBUTING.md b/lib/kokkos/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..b4f3057cef2cb707b55b3ae3331000ff4e55c0e1
--- /dev/null
+++ b/lib/kokkos/CONTRIBUTING.md
@@ -0,0 +1,14 @@
+# Contributing to Kokkos
+
+## Pull Requests
+We actively welcome pull requests.
+1. Fork the repo and create your branch from `develop`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is clear and has sufficient instructions to be able to reproduce the issue.
+
+## License
+By contributing to Kokkos, you agree that your contributions will be licensed under the LICENSE file in the root directory of this source tree.
diff --git a/lib/kokkos/Copyright.txt b/lib/kokkos/Copyright.txt
index 50b76995af47381395ba4b9d0ad72ac7f57e4655..06184796b268ee8b6edb8255aebcd0d28f8dfaa5 100644
--- a/lib/kokkos/Copyright.txt
+++ b/lib/kokkos/Copyright.txt
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 // 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 // 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 // 
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/LICENSE b/lib/kokkos/LICENSE
index c68a8a2a9f98983e6bb7e02aaae0ce705a241ffc..c6f17087d5a1b160a5fddeaab39ed9380328b485 100644
--- a/lib/kokkos/LICENSE
+++ b/lib/kokkos/LICENSE
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 // 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 // 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/Makefile.kokkos b/lib/kokkos/Makefile.kokkos
index e9ad57f0aebc71bea0f17a73b7b8c675e725fe6b..e2b34fb4538669d82477b802219c3264c1f16074 100644
--- a/lib/kokkos/Makefile.kokkos
+++ b/lib/kokkos/Makefile.kokkos
@@ -23,14 +23,16 @@ KOKKOS_DEBUG ?= "no"
 KOKKOS_USE_TPLS ?= ""
 # Options: c++11,c++14,c++1y,c++17,c++1z,c++2a
 KOKKOS_CXX_STANDARD ?= "c++11"
-# Options: aggressive_vectorization,disable_profiling,enable_deprecated_code,disable_deprecated_code,enable_large_mem_tests
+# Options: aggressive_vectorization,disable_profiling,enable_deprecated_code,disable_deprecated_code,enable_large_mem_tests,disable_complex_align
 KOKKOS_OPTIONS ?= ""
 # Option for setting ETI path
 KOKKOS_ETI_PATH ?= ${KOKKOS_PATH}/core/src/eti
 KOKKOS_CMAKE ?= "no"
+KOKKOS_TRIBITS ?= "no"
+KOKKOS_STANDALONE_CMAKE ?= "no"
 
 # Default settings specific options.
-# Options: force_uvm,use_ldg,rdc,enable_lambda
+# Options: force_uvm,use_ldg,rdc,enable_lambda,enable_constexpr
 KOKKOS_CUDA_OPTIONS ?= "enable_lambda"
 
 # Default settings specific options.
@@ -47,7 +49,8 @@ kokkos_has_string=$(if $(findstring $2,$1),1,0)
 #   Will return a 1 if /path/to/file exists
 kokkos_path_exists=$(if $(wildcard $1),1,0)
 
-# Check for general settings.
+# Check for general settings
+
 KOKKOS_INTERNAL_ENABLE_DEBUG := $(call kokkos_has_string,$(KOKKOS_DEBUG),yes)
 KOKKOS_INTERNAL_ENABLE_CXX11 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++11)
 KOKKOS_INTERNAL_ENABLE_CXX14 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++14)
@@ -67,6 +70,7 @@ KOKKOS_INTERNAL_OPT_RANGE_AGGRESSIVE_VECTORIZATION := $(call kokkos_has_string,$
 KOKKOS_INTERNAL_DISABLE_PROFILING := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_profiling)
 KOKKOS_INTERNAL_DISABLE_DEPRECATED_CODE := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_deprecated_code)
 KOKKOS_INTERNAL_ENABLE_DEPRECATED_CODE := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_deprecated_code)
+KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_complex_align)
 KOKKOS_INTERNAL_DISABLE_DUALVIEW_MODIFY_CHECK := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_dualview_modify_check)
 KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_profile_load_print)
 KOKKOS_INTERNAL_ENABLE_LARGE_MEM_TESTS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_large_mem_tests)
@@ -74,6 +78,7 @@ KOKKOS_INTERNAL_CUDA_USE_LDG := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),
 KOKKOS_INTERNAL_CUDA_USE_UVM := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),force_uvm)
 KOKKOS_INTERNAL_CUDA_USE_RELOC := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),rdc)
 KOKKOS_INTERNAL_CUDA_USE_LAMBDA := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_lambda)
+KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_constexpr)
 KOKKOS_INTERNAL_HPX_ENABLE_ASYNC_DISPATCH := $(call kokkos_has_string,$(KOKKOS_HPX_OPTIONS),enable_async_dispatch)
 KOKKOS_INTERNAL_ENABLE_ETI := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_eti)
 
@@ -123,7 +128,7 @@ KOKKOS_INTERNAL_COMPILER_INTEL       := $(call kokkos_has_string,$(KOKKOS_CXX_VE
 KOKKOS_INTERNAL_COMPILER_PGI         := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),PGI)
 KOKKOS_INTERNAL_COMPILER_XL          := $(strip $(shell $(CXX) -qversion       2>&1 | grep XL                  | wc -l))
 KOKKOS_INTERNAL_COMPILER_CRAY        := $(strip $(shell $(CXX) -craype-verbose 2>&1 | grep "CC-"               | wc -l))
-KOKKOS_INTERNAL_COMPILER_NVCC        := $(strip $(shell export OMPI_CXX=$(OMPI_CXX); export MPICH_CXX=$(MPICH_CXX); $(CXX) --version 2>&1 | grep nvcc | wc -l))
+KOKKOS_INTERNAL_COMPILER_NVCC        := $(strip $(shell echo "$(shell export OMPI_CXX=$(OMPI_CXX); export MPICH_CXX=$(MPICH_CXX); $(CXX) --version 2>&1 | grep nvcc | wc -l)>0" | bc))
 KOKKOS_INTERNAL_COMPILER_CLANG       := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),clang)
 KOKKOS_INTERNAL_COMPILER_APPLE_CLANG := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),Apple LLVM)
 KOKKOS_INTERNAL_COMPILER_HCC         := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),HCC)
@@ -383,10 +388,10 @@ endif
 
 # Generating the list of Flags.
 
-#CPPFLAGS is now unused
 KOKKOS_CPPFLAGS =
+KOKKOS_LIBDIRS =
 ifneq ($(KOKKOS_CMAKE), yes)
-  KOKKOS_CXXFLAGS = -I./ -I$(KOKKOS_PATH)/core/src -I$(KOKKOS_PATH)/containers/src -I$(KOKKOS_PATH)/algorithms/src -I$(KOKKOS_ETI_PATH)
+  KOKKOS_CPPFLAGS = -I./ -I$(KOKKOS_PATH)/core/src -I$(KOKKOS_PATH)/containers/src -I$(KOKKOS_PATH)/algorithms/src -I$(KOKKOS_ETI_PATH)
 endif
 KOKKOS_TPL_INCLUDE_DIRS =
 KOKKOS_TPL_LIBRARY_DIRS =
@@ -399,7 +404,7 @@ endif
 KOKKOS_LIBS = -ldl
 KOKKOS_TPL_LIBRARY_NAMES += dl
 ifneq ($(KOKKOS_CMAKE), yes)
-  KOKKOS_LDFLAGS = -L$(shell pwd)
+  KOKKOS_LIBDIRS = -L$(shell pwd)
   # CXXLDFLAGS is used together with CXXFLAGS in a combined compile/link command
   KOKKOS_CXXLDFLAGS = -L$(shell pwd)
 endif
@@ -492,28 +497,38 @@ ifeq ($(KOKKOS_INTERNAL_USE_ISA_POWERPCBE), 1)
   tmp := $(call kokkos_append_header,"\#endif")
 endif
 
+#only add the c++ standard flags if this is not CMake
 tmp := $(call kokkos_append_header,"/* General Settings */")
 ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX11), 1)
+ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
   KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX11_FLAG)
+endif
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX11")
 endif
 ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX14), 1)
+ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
   KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX14_FLAG)
+endif
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX14")
 endif
 ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX1Y), 1)
+  #I cannot make CMake add this in a good way - so add it here
   KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX1Y_FLAG)
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX14")
 endif
 ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX17), 1)
+ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
   KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX17_FLAG)
+endif
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX17")
 endif
 ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX1Z), 1)
+  #I cannot make CMake add this in a good way - so add it here
   KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX1Z_FLAG)
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX17")
 endif
 ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX2A), 1)
+  #I cannot make CMake add this in a good way - so add it here
   KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX2A_FLAG)
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CXX20")
 endif
@@ -531,23 +546,26 @@ ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
     tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK")
   endif
 endif
+ifeq ($(KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN), 0)
+  tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_COMPLEX_ALIGN")
+endif
 
 ifeq ($(KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT), 1)
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_PROFILING_LOAD_PRINT")
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_HWLOC), 1)
-  ifneq ($(HWLOC_PATH),)
-    ifneq ($(KOKKOS_CMAKE), yes)
-      KOKKOS_CXXFLAGS += -I$(HWLOC_PATH)/include
+  ifneq ($(KOKKOS_CMAKE), yes)
+    ifneq ($(HWLOC_PATH),)
+      KOKKOS_CPPFLAGS += -I$(HWLOC_PATH)/include
+      KOKKOS_LIBDIRS += -L$(HWLOC_PATH)/lib
+      KOKKOS_CXXLDFLAGS += -L$(HWLOC_PATH)/lib
+      KOKKOS_TPL_INCLUDE_DIRS += $(HWLOC_PATH)/include
+      KOKKOS_TPL_LIBRARY_DIRS += $(HWLOC_PATH)/lib
     endif
-    KOKKOS_LDFLAGS += -L$(HWLOC_PATH)/lib
-    KOKKOS_CXXLDFLAGS += -L$(HWLOC_PATH)/lib
-    KOKKOS_TPL_INCLUDE_DIRS += $(HWLOC_PATH)/include
-    KOKKOS_TPL_LIBRARY_DIRS += $(HWLOC_PATH)/lib
+    KOKKOS_LIBS += -lhwloc
+    KOKKOS_TPL_LIBRARY_NAMES += hwloc
   endif
-  KOKKOS_LIBS += -lhwloc
-  KOKKOS_TPL_LIBRARY_NAMES += hwloc
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_HWLOC")
 endif
 
@@ -558,17 +576,17 @@ ifeq ($(KOKKOS_INTERNAL_USE_LIBRT), 1)
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
-  ifneq ($(MEMKIND_PATH),)
-    ifneq ($(KOKKOS_CMAKE), yes)
-      KOKKOS_CXXFLAGS += -I$(MEMKIND_PATH)/include
+  ifneq ($(KOKKOS_CMAKE), yes)
+    ifneq ($(MEMKIND_PATH),)
+      KOKKOS_CPPFLAGS += -I$(MEMKIND_PATH)/include
+      KOKKOS_LIBDIRS += -L$(MEMKIND_PATH)/lib
+      KOKKOS_CXXLDFLAGS += -L$(MEMKIND_PATH)/lib
+      KOKKOS_TPL_INCLUDE_DIRS += $(MEMKIND_PATH)/include
+      KOKKOS_TPL_LIBRARY_DIRS += $(MEMKIND_PATH)/lib
     endif
-    KOKKOS_LDFLAGS += -L$(MEMKIND_PATH)/lib
-    KOKKOS_CXXLDFLAGS += -L$(MEMKIND_PATH)/lib
-    KOKKOS_TPL_INCLUDE_DIRS += $(MEMKIND_PATH)/include
-    KOKKOS_TPL_LIBRARY_DIRS += $(MEMKIND_PATH)/lib
+    KOKKOS_LIBS += -lmemkind -lnuma
+    KOKKOS_TPL_LIBRARY_NAMES += memkind numa
   endif
-  KOKKOS_LIBS += -lmemkind -lnuma
-  KOKKOS_TPL_LIBRARY_NAMES += memkind numa
   tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_HBWSPACE")
 endif
 
@@ -580,9 +598,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_HPX), 0)
   ifeq ($(KOKKOS_INTERNAL_ENABLE_DEPRECATED_CODE), 1)
     tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_DEPRECATED_CODE")
   endif
-  ifeq ($(KOKKOS_INTERNAL_DISABLE_DEPRECATED_CODE), 0)
-    tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_DEPRECATED_CODE")
-  endif
 endif
 
 ifeq ($(KOKKOS_INTERNAL_ENABLE_ETI), 1)
@@ -648,6 +663,21 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     endif
   endif
 
+  ifeq ($(KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR), 1)
+    ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
+      ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION) -ge 80; echo $$?),0)
+        tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_CONSTEXPR")
+        KOKKOS_CXXFLAGS += -expt-relaxed-constexpr
+      else
+        $(warning Warning: Cuda relaxed constexpr support was requested but NVCC version is too low. This requires NVCC for Cuda version 8.0 or higher. Disabling relaxed constexpr support now.)
+      endif
+    endif
+
+    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
+      tmp := $(call kokkos_append_header,"\#define KOKKOS_ENABLE_CUDA_CONSTEXPR")
+    endif
+  endif
+
   ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
     tmp := $(call kokkos_append_header,"\#define KOKKOS_IMPL_CUDA_CLANG_WORKAROUND")
   endif
@@ -1089,15 +1119,13 @@ ifeq ($(KOKKOS_INTERNAL_ENABLE_ETI), 1)
 endif
   KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.hpp)
   ifneq ($(CUDA_PATH),)
-    ifneq ($(KOKKOS_CMAKE), yes)
-      KOKKOS_CXXFLAGS += -I$(CUDA_PATH)/include
-    endif
+    KOKKOS_CPPLAGS += -I$(CUDA_PATH)/include
     ifeq ($(call kokkos_path_exists,$(CUDA_PATH)/lib64), 1)
-      KOKKOS_LDFLAGS += -L$(CUDA_PATH)/lib64
+      KOKKOS_LIBDIRS += -L$(CUDA_PATH)/lib64
       KOKKOS_CXXLDFLAGS += -L$(CUDA_PATH)/lib64
       KOKKOS_TPL_LIBRARY_DIRS += $(CUDA_PATH)/lib64
     else ifeq ($(call kokkos_path_exists,$(CUDA_PATH)/lib), 1)
-      KOKKOS_LDFLAGS += -L$(CUDA_PATH)/lib
+      KOKKOS_LIBDIRS += -L$(CUDA_PATH)/lib
       KOKKOS_CXXLDFLAGS += -L$(CUDA_PATH)/lib
       KOKKOS_TPL_LIBRARY_DIRS += $(CUDA_PATH)/lib
     else
@@ -1153,17 +1181,17 @@ endif
 ifeq ($(KOKKOS_INTERNAL_USE_QTHREADS), 1)
   KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/Qthreads/*.cpp)
   KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/Qthreads/*.hpp)
-  ifneq ($(QTHREADS_PATH),)
-    ifneq ($(KOKKOS_CMAKE), yes)
-      KOKKOS_CXXFLAGS += -I$(QTHREADS_PATH)/include
+  ifneq ($(KOKKOS_CMAKE), yes)
+    ifneq ($(QTHREADS_PATH),)
+      KOKKOS_CPPFLAGS += -I$(QTHREADS_PATH)/include
+      KOKKOS_LIBDIRS += -L$(QTHREADS_PATH)/lib
+      KOKKOS_CXXLDFLAGS += -L$(QTHREADS_PATH)/lib
+      KOKKOS_TPL_INCLUDE_DIRS += $(QTHREADS_PATH)/include
+      KOKKOS_TPL_LIBRARY_DIRS += $(QTHREADS_PATH)/lib64
     endif
-    KOKKOS_LDFLAGS += -L$(QTHREADS_PATH)/lib
-    KOKKOS_CXXLDFLAGS += -L$(QTHREADS_PATH)/lib
-    KOKKOS_TPL_INCLUDE_DIRS += $(QTHREADS_PATH)/include
-    KOKKOS_TPL_LIBRARY_DIRS += $(QTHREADS_PATH)/lib64
+    KOKKOS_LIBS += -lqthread
+    KOKKOS_TPL_LIBRARY_NAMES += qthread
   endif
-  KOKKOS_LIBS += -lqthread
-  KOKKOS_TPL_LIBRARY_NAMES += qthread
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
@@ -1173,21 +1201,21 @@ ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
     ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
       KOKKOS_CXXFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --cflags hpx_application_debug)
       KOKKOS_CXXLDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application_debug)
-      KOKKOS_LDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application_debug)
+      KOKKOS_LIBS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application_debug)
     else
       KOKKOS_CXXFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --cflags hpx_application)
       KOKKOS_CXXLDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application)
-      KOKKOS_LDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application)
+      KOKKOS_LIBS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application)
     endif
   else
     ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
       KOKKOS_CXXFLAGS += $(shell pkg-config --cflags hpx_application_debug)
       KOKKOS_CXXLDFLAGS += $(shell pkg-config --libs hpx_application_debug)
-      KOKKOS_LDFLAGS += $(shell pkg-config --libs hpx_application_debug)
+      KOKKOS_LIBS += $(shell pkg-config --libs hpx_application_debug)
     else
       KOKKOS_CXXFLAGS += $(shell pkg-config --cflags hpx_application)
       KOKKOS_CXXLDFLAGS += $(shell pkg-config --libs hpx_application)
-      KOKKOS_LDFLAGS += $(shell pkg-config --libs hpx_application)
+      KOKKOS_LIBS += $(shell pkg-config --libs hpx_application)
     endif
   endif
   KOKKOS_TPL_LIBRARY_NAMES += hpx
@@ -1248,4 +1276,16 @@ libkokkos.a: $(KOKKOS_OBJ_LINK) $(KOKKOS_SRC) $(KOKKOS_HEADERS)
 	ar cr libkokkos.a $(KOKKOS_OBJ_LINK)
 	ranlib libkokkos.a
 
+print-cxx-flags: 
+	echo "$(KOKKOS_CXXFLAGS)"
+
 KOKKOS_LINK_DEPENDS=libkokkos.a
+
+#we have carefully separated LDFLAGS from LIBS and LIBDIRS
+#we have also separated CPPFLAGS from CXXFLAGS
+#if this is not cmake, for backwards compatibility
+#we just jam everything together into the CXXFLAGS and LDFLAGS
+ifneq ($(KOKKOS_CMAKE), yes)
+  KOKKOS_CXXFLAGS += $(KOKKOS_CPPFLAGS)
+  KOKKOS_LDFLAGS += $(KOKKOS_LIBDIRS)
+endif
diff --git a/lib/kokkos/Makefile.targets b/lib/kokkos/Makefile.targets
index e7d5a3c90769230f31672ef9f098b42ef4bb6f7d..0a1f5220161521832e0f7736789de6e88f6f11b8 100644
--- a/lib/kokkos/Makefile.targets
+++ b/lib/kokkos/Makefile.targets
@@ -6,6 +6,8 @@ Kokkos_CPUDiscovery.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_CPUDiscovery.cpp
 Kokkos_Error.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_Error.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_Error.cpp
+Kokkos_Stacktrace.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_Stacktrace.cpp
+	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_Stacktrace.cpp
 Kokkos_ExecPolicy.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_ExecPolicy.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_ExecPolicy.cpp
 Kokkos_HostSpace.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_HostSpace.cpp
diff --git a/lib/kokkos/README b/lib/kokkos/README
deleted file mode 100644
index cb6ceb5581d58fd3841bb43c4797708c52f41a1e..0000000000000000000000000000000000000000
--- a/lib/kokkos/README
+++ /dev/null
@@ -1,193 +0,0 @@
-Kokkos Core implements a programming model in C++ for writing performance portable
-applications targeting all major HPC platforms. For that purpose it provides
-abstractions for both parallel execution of code and data management.
-Kokkos is designed to target complex node architectures with N-level memory
-hierarchies and multiple types of execution resources. It currently can use
-OpenMP, Pthreads and CUDA as backend programming models.
-
-Kokkos Core is part of the Kokkos C++ Performance Portability Programming EcoSystem,
-which also provides math kernels (https://github.com/kokkos/kokkos-kernels), as well as 
-profiling and debugging tools (https://github.com/kokkos/kokkos-tools).  
-
-# Learning about Kokkos
-
-A programming guide can be found on the Wiki, the API reference is under development.
-
-For questions find us on Slack: https://kokkosteam.slack.com or open a github issue.
-
-For non-public questions send an email to
-crtrott(at)sandia.gov
-
-A separate repository with extensive tutorial material can be found under 
-https://github.com/kokkos/kokkos-tutorials.
-
-Furthermore, the 'example/tutorial' directory provides step by step tutorial
-examples which explain many of the features of Kokkos. They work with
-simple Makefiles. To build with g++ and OpenMP simply type 'make'
-in the 'example/tutorial' directory. This will build all examples in the
-subfolders. To change the build options refer to the Programming Guide
-in the compilation section.
-
-To learn more about Kokkos consider watching one of our presentations:
-* GTC 2015:
-  - http://on-demand.gputechconf.com/gtc/2015/video/S5166.html
-  - http://on-demand.gputechconf.com/gtc/2015/presentation/S5166-H-Carter-Edwards.pdf
-
-
-# Contributing to Kokkos
-
-We are open and try to encourage contributions from external developers. 
-To do so please first open an issue describing the contribution and then issue
-a pull request against the develop branch. For larger features it may be good
-to get guidance from the core development team first through the github issue. 
-
-Note that Kokkos Core is licensed under standard 3-clause BSD terms of use. 
-Which means contributing to Kokkos allows anyone else to use your contributions
-not just for public purposes but also for closed source commercial projects.
-For specifics see the LICENSE file contained in the repository or distribution.
-
-# Requirements
-
-### Primary tested compilers on X86 are:
-  * GCC 4.8.4
-  * GCC 4.9.3
-  * GCC 5.1.0
-  * GCC 5.5.0
-  * GCC 6.1.0
-  * GCC 7.2.0
-  * GCC 7.3.0
-  * GCC 8.1.0
-  * Intel 15.0.2
-  * Intel 16.0.1
-  * Intel 17.0.1
-  * Intel 17.4.196
-  * Intel 18.2.128
-  * Clang 3.6.1
-  * Clang 3.7.1
-  * Clang 3.8.1
-  * Clang 3.9.0
-  * Clang 4.0.0
-  * Clang 6.0.0 for CUDA (CUDA Toolkit 9.0)
-  * Clang 7.0.0 for CUDA (CUDA Toolkit 9.1)
-  * PGI 18.7
-  * NVCC 7.5 for CUDA (with gcc 4.8.4)
-  * NVCC 8.0.44 for CUDA (with gcc 5.3.0)
-  * NVCC 9.1 for CUDA (with gcc 6.1.0)
-  * NVCC 9.2 for CUDA (with gcc 7.2.0)
-  * NVCC 10.0 for CUDA (with gcc 7.4.0)
-
-### Primary tested compilers on Power 8 are:
-  * GCC 6.4.0 (OpenMP,Serial)
-  * GCC 7.2.0 (OpenMP,Serial)
-  * IBM XL 16.1.0 (OpenMP, Serial)
-  * NVCC 9.2.88 for CUDA (with gcc 7.2.0 and XL 16.1.0)
-
-### Primary tested compilers on Intel KNL are:
-  * Intel 16.4.258 (with gcc 4.7.2)
-  * Intel 17.2.174 (with gcc 4.9.3)
-  * Intel 18.2.199 (with gcc 4.9.3)
-
-### Primary tested compilers on ARM (Cavium ThunderX2)
-  * GCC 7.2.0 
-  * ARM/Clang 18.4.0
-  
-### Other compilers working:
-  * X86:
-   - Cygwin 2.1.0 64bit with gcc 4.9.3
-   - GCC 8.1.0 (not warning free)
-
-### Known non-working combinations:
-  * Power8:
-   - Pthreads backend
-  * ARM
-   - Pthreads backend
-
-
-Primary tested compiler are passing in release mode
-with warnings as errors. They also are tested with a comprehensive set of 
-backend combinations (i.e. OpenMP, Pthreads, Serial, OpenMP+Serial, ...).
-We are using the following set of flags:
-GCC:   -Wall -Wshadow -pedantic -Werror -Wsign-compare -Wtype-limits
-       -Wignored-qualifiers -Wempty-body -Wclobbered -Wuninitialized
-Intel: -Wall -Wshadow -pedantic -Werror -Wsign-compare -Wtype-limits -Wuninitialized
-Clang: -Wall -Wshadow -pedantic -Werror -Wsign-compare -Wtype-limits -Wuninitialized
-NVCC:  -Wall -Wshadow -pedantic -Werror -Wsign-compare -Wtype-limits -Wuninitialized
-
-Other compilers are tested occasionally, in particular when pushing from develop to 
-master branch, without -Werror and only for a select set of backends.
-
-# Running Unit Tests
-
-To run the unit tests create a build directory and run the following commands
-
-KOKKOS_PATH/generate_makefile.bash
-make build-test
-make test
-
-Run KOKKOS_PATH/generate_makefile.bash --help for more detailed options such as
-changing the device type for which to build.
-
-# Installing the library
-
-To install Kokkos as a library create a build directory and run the following
-
-KOKKOS_PATH/generate_makefile.bash --prefix=INSTALL_PATH
-make kokkoslib
-make install
-
-KOKKOS_PATH/generate_makefile.bash --help for more detailed options such as
-changing the device type for which to build.
-
-Note that in many cases it is preferable to build Kokkos inline with an 
-application. The main reason is that you may otherwise need many different
-configurations of Kokkos installed depending on the required compile time
-features an application needs. For example there is only one default 
-execution space, which means you need different installations to have OpenMP
-or Pthreads as the default space. Also for the CUDA backend there are certain
-choices, such as allowing relocatable device code, which must be made at 
-installation time. Building Kokkos inline uses largely the same process
-as compiling an application against an installed Kokkos library. See for 
-example benchmarks/bytes_and_flops/Makefile which can be used with an installed
-library and for an inline build.  
-
-### CMake
-
-Kokkos supports being build as part of a CMake applications. An example can 
-be found in example/cmake_build. 
-
-# Kokkos and CUDA UVM
-
-Kokkos does support UVM as a specific memory space called CudaUVMSpace. 
-Allocations made with that space are accessible from host and device. 
-You can tell Kokkos to use that as the default space for Cuda allocations.
-In either case UVM comes with a number of restrictions:
-(i) You can't access allocations on the host while a kernel is potentially 
-running. This will lead to segfaults. To avoid that you either need to 
-call Kokkos::Cuda::fence() (or just Kokkos::fence()), after kernels, or
-you can set the environment variable CUDA_LAUNCH_BLOCKING=1.
-Furthermore in multi socket multi GPU machines without NVLINK, UVM defaults 
-to using zero copy allocations for technical reasons related to using multiple
-GPUs from the same process. If an executable doesn't do that (e.g. each
-MPI rank of an application uses a single GPU [can be the same GPU for 
-multiple MPI ranks]) you can set CUDA_MANAGED_FORCE_DEVICE_ALLOC=1.
-This will enforce proper UVM allocations, but can lead to errors if 
-more than a single GPU is used by a single process.
-
-
-# Citing Kokkos
-
-If you publish work which mentions Kokkos, please cite the following paper:
-
-@article{CarterEdwards20143202,
-title = "Kokkos: Enabling manycore performance portability through polymorphic memory access patterns ",
-journal = "Journal of Parallel and Distributed Computing ",
-volume = "74",
-number = "12",
-pages = "3202 - 3216",
-year = "2014",
-note = "Domain-Specific Languages and High-Level Frameworks for High-Performance Computing ",
-issn = "0743-7315",
-doi = "https://doi.org/10.1016/j.jpdc.2014.07.003",
-url = "http://www.sciencedirect.com/science/article/pii/S0743731514001257",
-author = "H. Carter Edwards and Christian R. Trott and Daniel Sunderland"
-}
diff --git a/lib/kokkos/README.md b/lib/kokkos/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..322dabfdab7745b600696b92ecb4ec7e148bc7bd
--- /dev/null
+++ b/lib/kokkos/README.md
@@ -0,0 +1,299 @@
+![Kokkos](https://avatars2.githubusercontent.com/u/10199860?s=200&v=4)
+
+# Kokkos: Core Libraries
+
+Kokkos Core implements a programming model in C++ for writing performance portable
+applications targeting all major HPC platforms. For that purpose it provides
+abstractions for both parallel execution of code and data management.
+Kokkos is designed to target complex node architectures with N-level memory
+hierarchies and multiple types of execution resources. It currently can use
+CUDA, HPX, OpenMP and Pthreads as backend programming models with several other
+backends in development.
+
+Kokkos Core is part of the Kokkos C++ Performance Portability Programming EcoSystem,
+which also provides math kernels (https://github.com/kokkos/kokkos-kernels), as well as 
+profiling and debugging tools (https://github.com/kokkos/kokkos-tools).  
+
+# Learning about Kokkos
+
+A programming guide can be found on the Wiki, the API reference is under development.
+
+For questions find us on Slack: https://kokkosteam.slack.com or open a github issue.
+
+For non-public questions send an email to
+crtrott(at)sandia.gov
+
+A separate repository with extensive tutorial material can be found under 
+https://github.com/kokkos/kokkos-tutorials.
+
+Furthermore, the 'example/tutorial' directory provides step by step tutorial
+examples which explain many of the features of Kokkos. They work with
+simple Makefiles. To build with g++ and OpenMP simply type 'make'
+in the 'example/tutorial' directory. This will build all examples in the
+subfolders. To change the build options refer to the Programming Guide
+in the compilation section.
+
+To learn more about Kokkos consider watching one of our presentations:
+* GTC 2015:
+  - http://on-demand.gputechconf.com/gtc/2015/video/S5166.html
+  - http://on-demand.gputechconf.com/gtc/2015/presentation/S5166-H-Carter-Edwards.pdf
+
+
+# Contributing to Kokkos
+
+We are open and try to encourage contributions from external developers. 
+To do so please first open an issue describing the contribution and then issue
+a pull request against the develop branch. For larger features it may be good
+to get guidance from the core development team first through the github issue. 
+
+Note that Kokkos Core is licensed under standard 3-clause BSD terms of use. 
+Which means contributing to Kokkos allows anyone else to use your contributions
+not just for public purposes but also for closed source commercial projects.
+For specifics see the LICENSE file contained in the repository or distribution.
+
+# Requirements
+
+### Primary tested compilers on X86 are:
+* GCC 4.8.4
+* GCC 4.9.3
+* GCC 5.1.0
+* GCC 5.4.0
+* GCC 5.5.0
+* GCC 6.1.0
+* GCC 7.2.0
+* GCC 7.3.0
+* GCC 8.1.0
+* Intel 15.0.2
+* Intel 16.0.1
+* Intel 17.0.1
+* Intel 17.4.196
+* Intel 18.2.128
+* Clang 3.6.1
+* Clang 3.7.1
+* Clang 3.8.1
+* Clang 3.9.0
+* Clang 4.0.0
+* Clang 6.0.0 for CUDA (CUDA Toolkit 9.0)
+* Clang 7.0.0 for CUDA (CUDA Toolkit 9.1)
+* Clang 8.0.0 for CUDA (CUDA Toolkit 9.2)
+* PGI 18.7
+* NVCC 9.1 for CUDA (with gcc 6.1.0)
+* NVCC 9.2 for CUDA (with gcc 7.2.0)
+* NVCC 10.0 for CUDA (with gcc 7.4.0)
+* NVCC 10.1 for CUDA (with gcc 7.4.0)
+
+### Primary tested compilers on Power 8 are:
+* GCC 6.4.0 (OpenMP,Serial)
+* GCC 7.2.0 (OpenMP,Serial)
+* IBM XL 16.1.0 (OpenMP, Serial)
+* NVCC 9.2.88 for CUDA (with gcc 7.2.0 and XL 16.1.0)
+
+### Primary tested compilers on Intel KNL are:
+* Intel 16.4.258 (with gcc 4.7.2)
+* Intel 17.2.174 (with gcc 4.9.3)
+* Intel 18.2.199 (with gcc 4.9.3)
+
+### Primary tested compilers on ARM (Cavium ThunderX2)
+* GCC 7.2.0 
+* ARM/Clang 18.4.0
+  
+### Other compilers working:
+* X86:
+    * Cygwin 2.1.0 64bit with gcc 4.9.3
+    * GCC 8.1.0 (not warning free)
+
+### Known non-working combinations:
+* Power8:
+    * Pthreads backend
+* ARM
+    * Pthreads backend
+
+
+Primary tested compiler are passing in release mode
+with warnings as errors. They also are tested with a comprehensive set of 
+backend combinations (i.e. OpenMP, Pthreads, Serial, OpenMP+Serial, ...).
+We are using the following set of flags:
+* GCC:   
+   ````
+      -Wall -Wshadow -pedantic 
+      -Werror -Wsign-compare -Wtype-limits
+      -Wignored-qualifiers -Wempty-body 
+      -Wclobbered -Wuninitialized
+   ````
+* Intel: 
+    ````
+      -Wall -Wshadow -pedantic 
+      -Werror -Wsign-compare -Wtype-limits 
+      -Wuninitialized
+    ````
+* Clang: 
+    ````
+      -Wall -Wshadow -pedantic 
+      -Werror -Wsign-compare -Wtype-limits 
+      -Wuninitialized
+    ````    
+
+* NVCC:  
+  ````
+    -Wall -Wshadow -pedantic 
+    -Werror -Wsign-compare -Wtype-limits 
+    -Wuninitialized
+  ````
+
+Other compilers are tested occasionally, in particular when pushing from develop to 
+master branch. These are tested less rigorously without `-Werror` and only for a select set of backends.
+
+# Building and Installing Kokkos
+Kokkos provide a CMake build system and a raw Makefile build system. 
+The CMake build system is strongly encouraged and will be the most rigorously supported in future releases.
+Full details are given in the [build instructions](BUILD.md). Basic setups are shown here:
+
+## CMake
+
+The best way to install Kokkos is using the CMake build system. Assuming Kokkos lives in `$srcdir`: 
+````
+cmake $srcdir \
+  -DCMAKE_CXX_COMPILER=$path_to_compiler \
+  -DCMAKE_INSTALL_PREFIX=$path_to_install \
+  -DKokkos_ENABLE_OPENMP=On \
+  -DKokkos_ARCH_HSW=On \
+  -DKokkos_ENABLE_HWLOC=On \
+  -DKokkos_HWLOC_DIR=$path_to_hwloc
+````
+then simply type `make install`. The Kokkos CMake package will then be installed in `$path_to_install` to be used by downstream packages.
+
+To validate the Kokkos build, configure with 
+````
+ -DKokkos_ENABLE_TESTS=On 
+````
+and run `make test` after completing the build.
+
+For your CMake project using Kokkos, code such as the following:
+
+````
+find_package(Kokkos)
+...
+target_link_libraries(myTarget Kokkos::kokkos)
+````
+should be added to your CMakeLists.txt. Your configure should additionally include
+````
+-DKokkos_DIR=$path_to_install/cmake/lib/Kokkos
+````
+or
+````
+-DKokkos_ROOT=$path_to_install
+````
+for the install location given above.
+
+## Spack
+An alternative to manually building with the CMake is to use the Spack package manager.
+To do so, download the `kokkos-spack` git repo and add to the package list:
+````
+spack repo add $path-to-kokkos-spack
+````
+A basic installation would be done as:
+````
+spack install kokkos
+````
+Spack allows options and and compilers to be tuned in the install command.
+````
+spack install kokkos@3.0 %gcc@7.3.0 +openmp
+````
+This example illustrates the three most common parameters to Spack:
+* Variants: specified with, e.g. `+openmp`, this activates (or deactivates with, e.g. `~openmp`) certain options.
+* Version:  immediately following `kokkos` the `@version` can specify a particular Kokkos to build
+* Compiler: a default compiler will be chosen if not specified, but an exact compiler version can be given with the `%`option.
+
+For a complete list of Kokkos options, run:
+````
+spack info kokkos
+````
+Spack currently installs packages to a location determined by a unique hash. This hash name is not really "human readable".
+Generally, Spack usage should never really require you to reference the computer-generated unique install folder. 
+More details are given in the [build instructions](BUILD.md). If you must know, you can locate Spack Kokkos installations with:
+````
+spack find -p kokkos ...
+````
+where `...` is the unique spec identifying the particular Kokkos configuration and version.
+
+
+## Raw Makefile 
+A bash script is provided to generate raw makefiles.
+To install Kokkos as a library create a build directory and run the following
+````
+$KOKKOS_PATH/generate_makefile.bash --prefix=$path_to_install
+````
+Once the Makefile is generated, run:
+````
+make kokkoslib
+make install
+````
+To additionally run the unit tests:
+````
+make build-test
+make test
+````
+Run `generate_makefile.bash --help` for more detailed options such as
+changing the device type for which to build.
+
+## Inline Builds vs. Installed Package
+For individual projects, it may be preferable to build Kokkos inline rather than link to an installed package.
+The main reason is that you may otherwise need many different
+configurations of Kokkos installed depending on the required compile time
+features an application needs. For example there is only one default 
+execution space, which means you need different installations to have OpenMP
+or Pthreads as the default space. Also for the CUDA backend there are certain
+choices, such as allowing relocatable device code, which must be made at 
+installation time. Building Kokkos inline uses largely the same process
+as compiling an application against an installed Kokkos library. 
+
+For CMake, this means copying over the Kokkos source code into your project and adding `add_subdirectory(kokkos)` to your CMakeLists.txt.
+
+For raw Makefiles, see the example benchmarks/bytes_and_flops/Makefile which can be used with an installed library and or an inline build.  
+
+# Kokkos and CUDA UVM
+
+Kokkos does support UVM as a specific memory space called CudaUVMSpace. 
+Allocations made with that space are accessible from host and device. 
+You can tell Kokkos to use that as the default space for Cuda allocations.
+In either case UVM comes with a number of restrictions:
+* You can't access allocations on the host while a kernel is potentially 
+running. This will lead to segfaults. To avoid that you either need to 
+call Kokkos::Cuda::fence() (or just Kokkos::fence()), after kernels, or
+you can set the environment variable CUDA_LAUNCH_BLOCKING=1.
+* In multi socket multi GPU machines without NVLINK, UVM defaults 
+to using zero copy allocations for technical reasons related to using multiple
+GPUs from the same process. If an executable doesn't do that (e.g. each
+MPI rank of an application uses a single GPU [can be the same GPU for 
+multiple MPI ranks]) you can set CUDA_MANAGED_FORCE_DEVICE_ALLOC=1.
+This will enforce proper UVM allocations, but can lead to errors if 
+more than a single GPU is used by a single process.
+
+
+# Citing Kokkos
+
+If you publish work which mentions Kokkos, please cite the following paper:
+
+````
+@article{CarterEdwards20143202,
+  title = "Kokkos: Enabling manycore performance portability through polymorphic memory access patterns ",
+  journal = "Journal of Parallel and Distributed Computing ",
+  volume = "74",
+  number = "12",
+  pages = "3202 - 3216",
+  year = "2014",
+  note = "Domain-Specific Languages and High-Level Frameworks for High-Performance Computing ",
+  issn = "0743-7315",
+  doi = "https://doi.org/10.1016/j.jpdc.2014.07.003",
+  url = "http://www.sciencedirect.com/science/article/pii/S0743731514001257",
+  author = "H. Carter Edwards and Christian R. Trott and Daniel Sunderland"
+}
+````
+
+##### [LICENSE](https://github.com/kokkos/kokkos/blob/master/LICENSE)
+
+[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+
+Under the terms of Contract DE-NA0003525 with NTESS,
+the U.S. Government retains certain rights in this software.
+
diff --git a/lib/kokkos/algorithms/CMakeLists.txt b/lib/kokkos/algorithms/CMakeLists.txt
index 507c9f2fdb70662c80f591d04737d45752be81a1..38747c152c73d450fe12431707fc438f9622e293 100644
--- a/lib/kokkos/algorithms/CMakeLists.txt
+++ b/lib/kokkos/algorithms/CMakeLists.txt
@@ -1,12 +1,12 @@
-
-
-TRIBITS_SUBPACKAGE(Algorithms)
-
-IF(KOKKOS_HAS_TRILINOS)
-  ADD_SUBDIRECTORY(src)
-ENDIF()
-
-TRIBITS_ADD_TEST_DIRECTORIES(unit_tests)
-#TRIBITS_ADD_TEST_DIRECTORIES(performance_tests)
-
-TRIBITS_SUBPACKAGE_POSTPROCESS()
+
+
+KOKKOS_SUBPACKAGE(Algorithms)
+
+ADD_SUBDIRECTORY(src)
+
+KOKKOS_ADD_TEST_DIRECTORIES(unit_tests)
+
+KOKKOS_SUBPACKAGE_POSTPROCESS()
+
+
+
diff --git a/lib/kokkos/algorithms/src/CMakeLists.txt b/lib/kokkos/algorithms/src/CMakeLists.txt
index dfbf3323c2d51953a12d8e82371d9f971aaa1e13..5afd319fcc7b0348b3401193f129897bcad11ebd 100644
--- a/lib/kokkos/algorithms/src/CMakeLists.txt
+++ b/lib/kokkos/algorithms/src/CMakeLists.txt
@@ -1,8 +1,9 @@
 
-TRIBITS_CONFIGURE_FILE(${PACKAGE_NAME}_config.h)
+KOKKOS_CONFIGURE_FILE(${PACKAGE_NAME}_config.h)
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+#I have to leave these here for tribits
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 #-----------------------------------------------------------------------------
 
@@ -12,10 +13,18 @@ LIST(APPEND HEADERS ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME}_config.h)
 
 #-----------------------------------------------------------------------------
 
-TRIBITS_ADD_LIBRARY(
-    kokkosalgorithms
-    HEADERS ${HEADERS}
-    SOURCES ${SOURCES}
-    DEPLIBS
-    )
+# We have to pass the sources in here for Tribits
+# These will get ignored for standalone CMake and a true interface library made
+KOKKOS_ADD_INTERFACE_LIBRARY(
+  kokkosalgorithms
+  HEADERS ${HEADERS}
+  SOURCES ${SOURCES}
+)
+KOKKOS_LIB_INCLUDE_DIRECTORIES(kokkosalgorithms
+  ${KOKKOS_TOP_BUILD_DIR}
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+
 
diff --git a/lib/kokkos/algorithms/src/Kokkos_Random.hpp b/lib/kokkos/algorithms/src/Kokkos_Random.hpp
index da781de4fe749d6af745a9c35e29cc20e64486cd..078db18eddf699a983503763a2de98fbc618215c 100644
--- a/lib/kokkos/algorithms/src/Kokkos_Random.hpp
+++ b/lib/kokkos/algorithms/src/Kokkos_Random.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -59,6 +60,7 @@
 
 namespace Kokkos {
 
+// clang-format off
   /*Template functions to get equidistributed random numbers from a generator for a specific Scalar type
 
        template<class Generator,Scalar>
@@ -229,1019 +231,979 @@ namespace Kokkos {
                      ViewType::value_type start, ViewType::value_type end);
 
 */
+// clang-format on
 
-  template<class Generator, class Scalar>
-  struct rand;
-
-
-  template<class Generator>
-  struct rand<Generator,char> {
-
-    KOKKOS_INLINE_FUNCTION
-    static short max(){return 127;}
-    KOKKOS_INLINE_FUNCTION
-    static short draw(Generator& gen)
-                          {return short((gen.rand()&0xff+256)%256);}
-    KOKKOS_INLINE_FUNCTION
-    static short draw(Generator& gen, const char& range)
-                          {return char(gen.rand(range));}
-    KOKKOS_INLINE_FUNCTION
-    static short draw(Generator& gen, const char& start, const char& end)
-                          {return char(gen.rand(start,end));}
-
-  };
-
-  template<class Generator>
-  struct rand<Generator,short> {
-    KOKKOS_INLINE_FUNCTION
-    static short max(){return 32767;}
-    KOKKOS_INLINE_FUNCTION
-    static short draw(Generator& gen)
-                          {return short((gen.rand()&0xffff+65536)%32768);}
-    KOKKOS_INLINE_FUNCTION
-    static short draw(Generator& gen, const short& range)
-                          {return short(gen.rand(range));}
-    KOKKOS_INLINE_FUNCTION
-    static short draw(Generator& gen, const short& start, const short& end)
-                          {return short(gen.rand(start,end));}
-
-  };
-
-  template<class Generator>
-  struct rand<Generator,int> {
-    KOKKOS_INLINE_FUNCTION
-    static int max(){return Generator::MAX_RAND;}
-    KOKKOS_INLINE_FUNCTION
-    static int draw(Generator& gen)
-                          {return gen.rand();}
-    KOKKOS_INLINE_FUNCTION
-    static int draw(Generator& gen, const int& range)
-                          {return gen.rand(range);}
-    KOKKOS_INLINE_FUNCTION
-    static int draw(Generator& gen, const int& start, const int& end)
-                          {return gen.rand(start,end);}
+template <class Generator, class Scalar>
+struct rand;
 
-  };
+template <class Generator>
+struct rand<Generator, char> {
+  KOKKOS_INLINE_FUNCTION
+  static short max() { return 127; }
+  KOKKOS_INLINE_FUNCTION
+  static short draw(Generator& gen) {
+    return short((gen.rand() & 0xff + 256) % 256);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static short draw(Generator& gen, const char& range) {
+    return char(gen.rand(range));
+  }
+  KOKKOS_INLINE_FUNCTION
+  static short draw(Generator& gen, const char& start, const char& end) {
+    return char(gen.rand(start, end));
+  }
+};
 
-  template<class Generator>
-  struct rand<Generator,unsigned int> {
-    KOKKOS_INLINE_FUNCTION
-    static unsigned int max () {
-      return Generator::MAX_URAND;
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned int draw (Generator& gen) {
-      return gen.urand ();
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned int draw(Generator& gen, const unsigned int& range) {
-      return gen.urand (range);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned int
-    draw (Generator& gen, const unsigned int& start, const unsigned int& end) {
-      return gen.urand (start, end);
-    }
-  };
+template <class Generator>
+struct rand<Generator, short> {
+  KOKKOS_INLINE_FUNCTION
+  static short max() { return 32767; }
+  KOKKOS_INLINE_FUNCTION
+  static short draw(Generator& gen) {
+    return short((gen.rand() & 0xffff + 65536) % 32768);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static short draw(Generator& gen, const short& range) {
+    return short(gen.rand(range));
+  }
+  KOKKOS_INLINE_FUNCTION
+  static short draw(Generator& gen, const short& start, const short& end) {
+    return short(gen.rand(start, end));
+  }
+};
 
-  template<class Generator>
-  struct rand<Generator,long> {
-    KOKKOS_INLINE_FUNCTION
-    static long max () {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (long) == 4 ?
-        static_cast<long> (Generator::MAX_RAND) :
-        static_cast<long> (Generator::MAX_RAND64);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static long draw (Generator& gen) {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (long) == 4 ?
-        static_cast<long> (gen.rand ()) :
-        static_cast<long> (gen.rand64 ());
-    }
-    KOKKOS_INLINE_FUNCTION
-    static long draw (Generator& gen, const long& range) {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (long) == 4 ?
-        static_cast<long> (gen.rand (static_cast<int> (range))) :
-        static_cast<long> (gen.rand64 (range));
-    }
-    KOKKOS_INLINE_FUNCTION
-    static long draw (Generator& gen, const long& start, const long& end) {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (long) == 4 ?
-        static_cast<long> (gen.rand (static_cast<int> (start),
-                                     static_cast<int> (end))) :
-        static_cast<long> (gen.rand64 (start, end));
-    }
-  };
+template <class Generator>
+struct rand<Generator, int> {
+  KOKKOS_INLINE_FUNCTION
+  static int max() { return Generator::MAX_RAND; }
+  KOKKOS_INLINE_FUNCTION
+  static int draw(Generator& gen) { return gen.rand(); }
+  KOKKOS_INLINE_FUNCTION
+  static int draw(Generator& gen, const int& range) { return gen.rand(range); }
+  KOKKOS_INLINE_FUNCTION
+  static int draw(Generator& gen, const int& start, const int& end) {
+    return gen.rand(start, end);
+  }
+};
 
-  template<class Generator>
-  struct rand<Generator,unsigned long> {
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long max () {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (unsigned long) == 4 ?
-        static_cast<unsigned long> (Generator::MAX_URAND) :
-        static_cast<unsigned long> (Generator::MAX_URAND64);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long draw (Generator& gen) {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (unsigned long) == 4 ?
-        static_cast<unsigned long> (gen.urand ()) :
-        static_cast<unsigned long> (gen.urand64 ());
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long draw(Generator& gen, const unsigned long& range) {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (unsigned long) == 4 ?
-        static_cast<unsigned long> (gen.urand (static_cast<unsigned int> (range))) :
-        static_cast<unsigned long> (gen.urand64 (range));
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long
-    draw (Generator& gen, const unsigned long& start, const unsigned long& end) {
-      // FIXME (mfh 26 Oct 2014) It would be better to select the
-      // return value at compile time, using something like enable_if.
-      return sizeof (unsigned long) == 4 ?
-        static_cast<unsigned long> (gen.urand (static_cast<unsigned int> (start),
-                                               static_cast<unsigned int> (end))) :
-        static_cast<unsigned long> (gen.urand64 (start, end));
-    }
-  };
+template <class Generator>
+struct rand<Generator, unsigned int> {
+  KOKKOS_INLINE_FUNCTION
+  static unsigned int max() { return Generator::MAX_URAND; }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned int draw(Generator& gen) { return gen.urand(); }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned int draw(Generator& gen, const unsigned int& range) {
+    return gen.urand(range);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned int draw(Generator& gen, const unsigned int& start,
+                           const unsigned int& end) {
+    return gen.urand(start, end);
+  }
+};
 
-  // NOTE (mfh 26 oct 2014) This is a partial specialization for long
-  // long, a C99 / C++11 signed type which is guaranteed to be at
-  // least 64 bits.  Do NOT write a partial specialization for
-  // int64_t!!!  This is just a typedef!  It could be either long or
-  // long long.  We don't know which a priori, and I've seen both.
-  // The types long and long long are guaranteed to differ, so it's
-  // always safe to specialize for both.
-  template<class Generator>
-  struct rand<Generator, long long> {
-    KOKKOS_INLINE_FUNCTION
-    static long long max () {
-      // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
-      return Generator::MAX_RAND64;
-    }
-    KOKKOS_INLINE_FUNCTION
-    static long long draw (Generator& gen) {
-      // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
-      return gen.rand64 ();
-    }
-    KOKKOS_INLINE_FUNCTION
-    static long long draw (Generator& gen, const long long& range) {
-      // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
-      return gen.rand64 (range);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static long long draw (Generator& gen, const long long& start, const long long& end) {
-      // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
-      return gen.rand64 (start, end);
-    }
-  };
+template <class Generator>
+struct rand<Generator, long> {
+  KOKKOS_INLINE_FUNCTION
+  static long max() {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(long) == 4 ? static_cast<long>(Generator::MAX_RAND)
+                             : static_cast<long>(Generator::MAX_RAND64);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static long draw(Generator& gen) {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(long) == 4 ? static_cast<long>(gen.rand())
+                             : static_cast<long>(gen.rand64());
+  }
+  KOKKOS_INLINE_FUNCTION
+  static long draw(Generator& gen, const long& range) {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(long) == 4
+               ? static_cast<long>(gen.rand(static_cast<int>(range)))
+               : static_cast<long>(gen.rand64(range));
+  }
+  KOKKOS_INLINE_FUNCTION
+  static long draw(Generator& gen, const long& start, const long& end) {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(long) == 4
+               ? static_cast<long>(
+                     gen.rand(static_cast<int>(start), static_cast<int>(end)))
+               : static_cast<long>(gen.rand64(start, end));
+  }
+};
 
-  // NOTE (mfh 26 oct 2014) This is a partial specialization for
-  // unsigned long long, a C99 / C++11 unsigned type which is
-  // guaranteed to be at least 64 bits.  Do NOT write a partial
-  // specialization for uint64_t!!!  This is just a typedef!  It could
-  // be either unsigned long or unsigned long long.  We don't know
-  // which a priori, and I've seen both.  The types unsigned long and
-  // unsigned long long are guaranteed to differ, so it's always safe
-  // to specialize for both.
-  template<class Generator>
-  struct rand<Generator,unsigned long long> {
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long long max () {
-      // FIXME (mfh 26 Oct 2014) It's legal for unsigned long long to be > 64 bits.
-      return Generator::MAX_URAND64;
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long long draw (Generator& gen) {
-      // FIXME (mfh 26 Oct 2014) It's legal for unsigned long long to be > 64 bits.
-      return gen.urand64 ();
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long long draw (Generator& gen, const unsigned long long& range) {
-      // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
-      return gen.urand64 (range);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static unsigned long long
-    draw (Generator& gen, const unsigned long long& start, const unsigned long long& end) {
-      // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
-      return gen.urand64 (start, end);
-    }
-  };
+template <class Generator>
+struct rand<Generator, unsigned long> {
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long max() {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(unsigned long) == 4
+               ? static_cast<unsigned long>(Generator::MAX_URAND)
+               : static_cast<unsigned long>(Generator::MAX_URAND64);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long draw(Generator& gen) {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(unsigned long) == 4
+               ? static_cast<unsigned long>(gen.urand())
+               : static_cast<unsigned long>(gen.urand64());
+  }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long draw(Generator& gen, const unsigned long& range) {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(unsigned long) == 4
+               ? static_cast<unsigned long>(
+                     gen.urand(static_cast<unsigned int>(range)))
+               : static_cast<unsigned long>(gen.urand64(range));
+  }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long draw(Generator& gen, const unsigned long& start,
+                            const unsigned long& end) {
+    // FIXME (mfh 26 Oct 2014) It would be better to select the
+    // return value at compile time, using something like enable_if.
+    return sizeof(unsigned long) == 4
+               ? static_cast<unsigned long>(
+                     gen.urand(static_cast<unsigned int>(start),
+                               static_cast<unsigned int>(end)))
+               : static_cast<unsigned long>(gen.urand64(start, end));
+  }
+};
 
-  template<class Generator>
-  struct rand<Generator,float> {
-    KOKKOS_INLINE_FUNCTION
-    static float max(){return 1.0f;}
-    KOKKOS_INLINE_FUNCTION
-    static float draw(Generator& gen)
-                          {return gen.frand();}
-    KOKKOS_INLINE_FUNCTION
-    static float draw(Generator& gen, const float& range)
-                          {return gen.frand(range);}
-    KOKKOS_INLINE_FUNCTION
-    static float draw(Generator& gen, const float& start, const float& end)
-                          {return gen.frand(start,end);}
+// NOTE (mfh 26 oct 2014) This is a partial specialization for long
+// long, a C99 / C++11 signed type which is guaranteed to be at
+// least 64 bits.  Do NOT write a partial specialization for
+// int64_t!!!  This is just a typedef!  It could be either long or
+// long long.  We don't know which a priori, and I've seen both.
+// The types long and long long are guaranteed to differ, so it's
+// always safe to specialize for both.
+template <class Generator>
+struct rand<Generator, long long> {
+  KOKKOS_INLINE_FUNCTION
+  static long long max() {
+    // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
+    return Generator::MAX_RAND64;
+  }
+  KOKKOS_INLINE_FUNCTION
+  static long long draw(Generator& gen) {
+    // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
+    return gen.rand64();
+  }
+  KOKKOS_INLINE_FUNCTION
+  static long long draw(Generator& gen, const long long& range) {
+    // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
+    return gen.rand64(range);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static long long draw(Generator& gen, const long long& start,
+                        const long long& end) {
+    // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
+    return gen.rand64(start, end);
+  }
+};
 
-  };
+// NOTE (mfh 26 oct 2014) This is a partial specialization for
+// unsigned long long, a C99 / C++11 unsigned type which is
+// guaranteed to be at least 64 bits.  Do NOT write a partial
+// specialization for uint64_t!!!  This is just a typedef!  It could
+// be either unsigned long or unsigned long long.  We don't know
+// which a priori, and I've seen both.  The types unsigned long and
+// unsigned long long are guaranteed to differ, so it's always safe
+// to specialize for both.
+template <class Generator>
+struct rand<Generator, unsigned long long> {
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long long max() {
+    // FIXME (mfh 26 Oct 2014) It's legal for unsigned long long to be > 64
+    // bits.
+    return Generator::MAX_URAND64;
+  }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long long draw(Generator& gen) {
+    // FIXME (mfh 26 Oct 2014) It's legal for unsigned long long to be > 64
+    // bits.
+    return gen.urand64();
+  }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long long draw(Generator& gen,
+                                 const unsigned long long& range) {
+    // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
+    return gen.urand64(range);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static unsigned long long draw(Generator& gen,
+                                 const unsigned long long& start,
+                                 const unsigned long long& end) {
+    // FIXME (mfh 26 Oct 2014) It's legal for long long to be > 64 bits.
+    return gen.urand64(start, end);
+  }
+};
 
-  template<class Generator>
-  struct rand<Generator,double> {
-    KOKKOS_INLINE_FUNCTION
-    static double max(){return 1.0;}
-    KOKKOS_INLINE_FUNCTION
-    static double draw(Generator& gen)
-                          {return gen.drand();}
-    KOKKOS_INLINE_FUNCTION
-    static double draw(Generator& gen, const double& range)
-                          {return gen.drand(range);}
-    KOKKOS_INLINE_FUNCTION
-    static double draw(Generator& gen, const double& start, const double& end)
-                          {return gen.drand(start,end);}
+template <class Generator>
+struct rand<Generator, float> {
+  KOKKOS_INLINE_FUNCTION
+  static float max() { return 1.0f; }
+  KOKKOS_INLINE_FUNCTION
+  static float draw(Generator& gen) { return gen.frand(); }
+  KOKKOS_INLINE_FUNCTION
+  static float draw(Generator& gen, const float& range) {
+    return gen.frand(range);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static float draw(Generator& gen, const float& start, const float& end) {
+    return gen.frand(start, end);
+  }
+};
 
-  };
+template <class Generator>
+struct rand<Generator, double> {
+  KOKKOS_INLINE_FUNCTION
+  static double max() { return 1.0; }
+  KOKKOS_INLINE_FUNCTION
+  static double draw(Generator& gen) { return gen.drand(); }
+  KOKKOS_INLINE_FUNCTION
+  static double draw(Generator& gen, const double& range) {
+    return gen.drand(range);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static double draw(Generator& gen, const double& start, const double& end) {
+    return gen.drand(start, end);
+  }
+};
 
-  template<class Generator>
-  struct rand<Generator, Kokkos::complex<float> > {
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<float> max () {
-      return Kokkos::complex<float> (1.0, 1.0);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<float> draw (Generator& gen) {
-      const float re = gen.frand ();
-      const float im = gen.frand ();
-      return Kokkos::complex<float> (re, im);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<float> draw (Generator& gen, const Kokkos::complex<float>& range) {
-      const float re = gen.frand (real (range));
-      const float im = gen.frand (imag (range));
-      return Kokkos::complex<float> (re, im);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<float> draw (Generator& gen, const Kokkos::complex<float>& start, const Kokkos::complex<float>& end) {
-      const float re = gen.frand (real (start), real (end));
-      const float im = gen.frand (imag (start), imag (end));
-      return Kokkos::complex<float> (re, im);
-    }
-  };
+template <class Generator>
+struct rand<Generator, Kokkos::complex<float> > {
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<float> max() {
+    return Kokkos::complex<float>(1.0, 1.0);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<float> draw(Generator& gen) {
+    const float re = gen.frand();
+    const float im = gen.frand();
+    return Kokkos::complex<float>(re, im);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<float> draw(Generator& gen,
+                                     const Kokkos::complex<float>& range) {
+    const float re = gen.frand(real(range));
+    const float im = gen.frand(imag(range));
+    return Kokkos::complex<float>(re, im);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<float> draw(Generator& gen,
+                                     const Kokkos::complex<float>& start,
+                                     const Kokkos::complex<float>& end) {
+    const float re = gen.frand(real(start), real(end));
+    const float im = gen.frand(imag(start), imag(end));
+    return Kokkos::complex<float>(re, im);
+  }
+};
 
-  template<class Generator>
-  struct rand<Generator, Kokkos::complex<double> > {
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<double> max () {
-      return Kokkos::complex<double> (1.0, 1.0);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<double> draw (Generator& gen) {
-      const double re = gen.drand ();
-      const double im = gen.drand ();
-      return Kokkos::complex<double> (re, im);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<double> draw (Generator& gen, const Kokkos::complex<double>& range) {
-      const double re = gen.drand (real (range));
-      const double im = gen.drand (imag (range));
-      return Kokkos::complex<double> (re, im);
-    }
-    KOKKOS_INLINE_FUNCTION
-    static Kokkos::complex<double> draw (Generator& gen, const Kokkos::complex<double>& start, const Kokkos::complex<double>& end) {
-      const double re = gen.drand (real (start), real (end));
-      const double im = gen.drand (imag (start), imag (end));
-      return Kokkos::complex<double> (re, im);
-    }
-  };
+template <class Generator>
+struct rand<Generator, Kokkos::complex<double> > {
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<double> max() {
+    return Kokkos::complex<double>(1.0, 1.0);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<double> draw(Generator& gen) {
+    const double re = gen.drand();
+    const double im = gen.drand();
+    return Kokkos::complex<double>(re, im);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<double> draw(Generator& gen,
+                                      const Kokkos::complex<double>& range) {
+    const double re = gen.drand(real(range));
+    const double im = gen.drand(imag(range));
+    return Kokkos::complex<double>(re, im);
+  }
+  KOKKOS_INLINE_FUNCTION
+  static Kokkos::complex<double> draw(Generator& gen,
+                                      const Kokkos::complex<double>& start,
+                                      const Kokkos::complex<double>& end) {
+    const double re = gen.drand(real(start), real(end));
+    const double im = gen.drand(imag(start), imag(end));
+    return Kokkos::complex<double>(re, im);
+  }
+};
 
-  template<class DeviceType>
-  class Random_XorShift64_Pool;
+template <class DeviceType>
+class Random_XorShift64_Pool;
 
-  template<class DeviceType>
-  class Random_XorShift64 {
-  private:
-    uint64_t state_;
-    const int state_idx_;
-    friend class Random_XorShift64_Pool<DeviceType>;
-  public:
+template <class DeviceType>
+class Random_XorShift64 {
+ private:
+  uint64_t state_;
+  const int state_idx_;
+  friend class Random_XorShift64_Pool<DeviceType>;
 
-    typedef DeviceType device_type;
+ public:
+  typedef DeviceType device_type;
 
-    enum {MAX_URAND = 0xffffffffU};
-    enum {MAX_URAND64 = 0xffffffffffffffffULL-1};
-    enum {MAX_RAND = static_cast<int>(0xffffffff/2)};
-    enum {MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffLL/2-1)};
+  enum { MAX_URAND = 0xffffffffU };
+  enum { MAX_URAND64 = 0xffffffffffffffffULL - 1 };
+  enum { MAX_RAND = static_cast<int>(0xffffffff / 2) };
+  enum { MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffLL / 2 - 1) };
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift64 (uint64_t state, int state_idx = 0)
-     : state_(state==0?uint64_t(1318319):state),state_idx_(state_idx){}
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift64(uint64_t state, int state_idx = 0)
+      : state_(state == 0 ? uint64_t(1318319) : state), state_idx_(state_idx) {}
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand() {
-      state_ ^= state_ >> 12;
-      state_ ^= state_ << 25;
-      state_ ^= state_ >> 27;
-
-      uint64_t tmp = state_ * 2685821657736338717ULL;
-      tmp = tmp>>16;
-      return static_cast<uint32_t>(tmp&MAX_URAND);
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand() {
+    state_ ^= state_ >> 12;
+    state_ ^= state_ << 25;
+    state_ ^= state_ >> 27;
+
+    uint64_t tmp = state_ * 2685821657736338717ULL;
+    tmp          = tmp >> 16;
+    return static_cast<uint32_t>(tmp & MAX_URAND);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64() {
-      state_ ^= state_ >> 12;
-      state_ ^= state_ << 25;
-      state_ ^= state_ >> 27;
-      return (state_ * 2685821657736338717ULL) - 1;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64() {
+    state_ ^= state_ >> 12;
+    state_ ^= state_ << 25;
+    state_ ^= state_ >> 27;
+    return (state_ * 2685821657736338717ULL) - 1;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& range) {
-      const uint32_t max_val = (MAX_URAND/range)*range;
-      uint32_t tmp = urand();
-      while(tmp>=max_val)
-        tmp = urand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& range) {
+    const uint32_t max_val = (MAX_URAND / range) * range;
+    uint32_t tmp           = urand();
+    while (tmp >= max_val) tmp = urand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& start, const uint32_t& end ) {
-      return urand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& start, const uint32_t& end) {
+    return urand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& range) {
-      const uint64_t max_val = (MAX_URAND64/range)*range;
-      uint64_t tmp = urand64();
-      while(tmp>=max_val)
-        tmp = urand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& range) {
+    const uint64_t max_val = (MAX_URAND64 / range) * range;
+    uint64_t tmp           = urand64();
+    while (tmp >= max_val) tmp = urand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& start, const uint64_t& end ) {
-      return urand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& start, const uint64_t& end) {
+    return urand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand() {
-      return static_cast<int>(urand()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand() { return static_cast<int>(urand() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& range) {
-      const int max_val = (MAX_RAND/range)*range;
-      int tmp = rand();
-      while(tmp>=max_val)
-        tmp = rand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& range) {
+    const int max_val = (MAX_RAND / range) * range;
+    int tmp           = rand();
+    while (tmp >= max_val) tmp = rand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& start, const int& end ) {
-      return rand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& start, const int& end) {
+    return rand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64() {
-      return static_cast<int64_t>(urand64()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64() { return static_cast<int64_t>(urand64() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& range) {
-      const int64_t max_val = (MAX_RAND64/range)*range;
-      int64_t tmp = rand64();
-      while(tmp>=max_val)
-        tmp = rand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& range) {
+    const int64_t max_val = (MAX_RAND64 / range) * range;
+    int64_t tmp           = rand64();
+    while (tmp >= max_val) tmp = rand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& start, const int64_t& end ) {
-      return rand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& start, const int64_t& end) {
+    return rand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand() {
-      return 1.0f * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand() { return 1.0f * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& range) { return range * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& start, const float& end ) {
-      return frand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& start, const float& end) {
+    return frand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand() {
-      return 1.0 * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand() { return 1.0 * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& range) { return range * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& start, const double& end ) {
-      return drand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& start, const double& end) {
+    return drand(end - start) + start;
+  }
 
-    //Marsaglia polar method for drawing a standard normal distributed random number
-    KOKKOS_INLINE_FUNCTION
-    double normal() {
-      double S = 2.0;
-      double U;
-      while(S>=1.0) {
-        U = 2.0*drand() - 1.0;
-        const double V = 2.0*drand() - 1.0;
-        S = U*U+V*V;
-      }
-      return U*std::sqrt(-2.0*log(S)/S);
-    }
+  // Marsaglia polar method for drawing a standard normal distributed random
+  // number
+  KOKKOS_INLINE_FUNCTION
+  double normal() {
+    double S = 2.0;
+    double U;
+    while (S >= 1.0) {
+      U              = 2.0 * drand() - 1.0;
+      const double V = 2.0 * drand() - 1.0;
+      S              = U * U + V * V;
+    }
+    return U * std::sqrt(-2.0 * log(S) / S);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double normal(const double& mean, const double& std_dev=1.0) {
-      return mean + normal()*std_dev;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double normal(const double& mean, const double& std_dev = 1.0) {
+    return mean + normal() * std_dev;
+  }
+};
 
-  };
+template <class DeviceType = Kokkos::DefaultExecutionSpace>
+class Random_XorShift64_Pool {
+ private:
+  typedef View<int*, DeviceType> lock_type;
+  typedef View<uint64_t*, DeviceType> state_data_type;
+  lock_type locks_;
+  state_data_type state_;
+  int num_states_;
 
-  template<class DeviceType = Kokkos::DefaultExecutionSpace>
-  class Random_XorShift64_Pool {
-  private:
-    typedef View<int*,DeviceType> lock_type;
-    typedef View<uint64_t*,DeviceType> state_data_type;
-    lock_type locks_;
-    state_data_type state_;
-    int num_states_;
-
-  public:
-    typedef Random_XorShift64<DeviceType> generator_type;
-    typedef DeviceType device_type;
+ public:
+  typedef Random_XorShift64<DeviceType> generator_type;
+  typedef DeviceType device_type;
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift64_Pool() {
-      num_states_ = 0;
-    }
-    Random_XorShift64_Pool(uint64_t seed) {
-      num_states_ = 0;
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift64_Pool() { num_states_ = 0; }
+  Random_XorShift64_Pool(uint64_t seed) {
+    num_states_ = 0;
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      init(seed,DeviceType::max_hardware_threads());
+    init(seed, DeviceType::max_hardware_threads());
 #else
-      init(seed,DeviceType::impl_max_hardware_threads());
+    init(seed, DeviceType::impl_max_hardware_threads());
 #endif
-    }
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift64_Pool(const Random_XorShift64_Pool& src):
-      locks_(src.locks_),
-      state_(src.state_),
-      num_states_(src.num_states_)
-    {}
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift64_Pool(const Random_XorShift64_Pool& src)
+      : locks_(src.locks_), state_(src.state_), num_states_(src.num_states_) {}
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift64_Pool operator = (const Random_XorShift64_Pool& src) {
-      locks_ = src.locks_;
-      state_ = src.state_;
-      num_states_ = src.num_states_;
-      return *this;
-    }
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift64_Pool operator=(const Random_XorShift64_Pool& src) {
+    locks_      = src.locks_;
+    state_      = src.state_;
+    num_states_ = src.num_states_;
+    return *this;
+  }
 
-    void init(uint64_t seed, int num_states) {
-      if(seed==0)
-        seed = uint64_t(1318319);
-
-      num_states_ = num_states;
-
-      locks_ = lock_type("Kokkos::Random_XorShift64::locks",num_states_);
-      state_ = state_data_type("Kokkos::Random_XorShift64::state",num_states_);
-
-      typename state_data_type::HostMirror h_state = create_mirror_view(state_);
-      typename lock_type::HostMirror h_lock = create_mirror_view(locks_);
-
-      // Execute on the HostMirror's default execution space.
-      Random_XorShift64<typename state_data_type::HostMirror::execution_space> gen(seed,0);
-      for(int i = 0; i < 17; i++)
-        gen.rand();
-      for(int i = 0; i < num_states_; i++) {
-        int n1 = gen.rand();
-        int n2 = gen.rand();
-        int n3 = gen.rand();
-        int n4 = gen.rand();
-        h_state(i) = (((static_cast<uint64_t>(n1)) & 0xffff)<<00) |
-                     (((static_cast<uint64_t>(n2)) & 0xffff)<<16) |
-                     (((static_cast<uint64_t>(n3)) & 0xffff)<<32) |
-                     (((static_cast<uint64_t>(n4)) & 0xffff)<<48);
-        h_lock(i) = 0;
-      }
-      deep_copy(state_,h_state);
-      deep_copy(locks_,h_lock);
-    }
+  void init(uint64_t seed, int num_states) {
+    if (seed == 0) seed = uint64_t(1318319);
+
+    num_states_ = num_states;
+
+    locks_ = lock_type("Kokkos::Random_XorShift64::locks", num_states_);
+    state_ = state_data_type("Kokkos::Random_XorShift64::state", num_states_);
+
+    typename state_data_type::HostMirror h_state = create_mirror_view(state_);
+    typename lock_type::HostMirror h_lock        = create_mirror_view(locks_);
+
+    // Execute on the HostMirror's default execution space.
+    Random_XorShift64<typename state_data_type::HostMirror::execution_space>
+        gen(seed, 0);
+    for (int i = 0; i < 17; i++) gen.rand();
+    for (int i = 0; i < num_states_; i++) {
+      int n1     = gen.rand();
+      int n2     = gen.rand();
+      int n3     = gen.rand();
+      int n4     = gen.rand();
+      h_state(i) = (((static_cast<uint64_t>(n1)) & 0xffff) << 00) |
+                   (((static_cast<uint64_t>(n2)) & 0xffff) << 16) |
+                   (((static_cast<uint64_t>(n3)) & 0xffff) << 32) |
+                   (((static_cast<uint64_t>(n4)) & 0xffff) << 48);
+      h_lock(i) = 0;
+    }
+    deep_copy(state_, h_state);
+    deep_copy(locks_, h_lock);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift64<DeviceType> get_state() const {
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift64<DeviceType> get_state() const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int i = DeviceType::hardware_thread_id();;
+    const int i = DeviceType::hardware_thread_id();
+    ;
 #else
-      const int i = DeviceType::impl_hardware_thread_id();;
+    const int i = DeviceType::impl_hardware_thread_id();
+    ;
 #endif
-      return Random_XorShift64<DeviceType>(state_(i),i);
-    }
-
-    // NOTE: state_idx MUST be unique and less than num_states
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift64<DeviceType> get_state(const int state_idx) const {
-      return Random_XorShift64<DeviceType>(state_(state_idx),state_idx);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void free_state(const Random_XorShift64<DeviceType>& state) const {
-      state_(state.state_idx_) = state.state_;
-    }
-  };
+    return Random_XorShift64<DeviceType>(state_(i), i);
+  }
 
+  // NOTE: state_idx MUST be unique and less than num_states
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift64<DeviceType> get_state(const int state_idx) const {
+    return Random_XorShift64<DeviceType>(state_(state_idx), state_idx);
+  }
 
-  template<class DeviceType>
-  class Random_XorShift1024_Pool;
+  KOKKOS_INLINE_FUNCTION
+  void free_state(const Random_XorShift64<DeviceType>& state) const {
+    state_(state.state_idx_) = state.state_;
+  }
+};
 
-  template<class DeviceType>
-  class Random_XorShift1024 {
-  private:
-    int p_;
-    const int state_idx_;
-    uint64_t state_[16];
-    friend class Random_XorShift1024_Pool<DeviceType>;
-  public:
+template <class DeviceType>
+class Random_XorShift1024_Pool;
 
-    typedef Random_XorShift1024_Pool<DeviceType> pool_type;
-    typedef DeviceType device_type;
+template <class DeviceType>
+class Random_XorShift1024 {
+ private:
+  int p_;
+  const int state_idx_;
+  uint64_t state_[16];
+  friend class Random_XorShift1024_Pool<DeviceType>;
 
-    enum {MAX_URAND = 0xffffffffU};
-    enum {MAX_URAND64 = 0xffffffffffffffffULL-1};
-    enum {MAX_RAND = static_cast<int>(0xffffffffU/2)};
-    enum {MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffULL/2-1)};
+ public:
+  typedef Random_XorShift1024_Pool<DeviceType> pool_type;
+  typedef DeviceType device_type;
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024 (const typename pool_type::state_data_type& state, int p, int state_idx = 0):
-      p_(p),state_idx_(state_idx){
-      for(int i=0 ; i<16; i++)
-        state_[i] = state(state_idx,i);
-    }
+  enum { MAX_URAND = 0xffffffffU };
+  enum { MAX_URAND64 = 0xffffffffffffffffULL - 1 };
+  enum { MAX_RAND = static_cast<int>(0xffffffffU / 2) };
+  enum { MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffULL / 2 - 1) };
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand() {
-      uint64_t state_0 = state_[ p_ ];
-      uint64_t state_1 = state_[ p_ = ( p_ + 1 ) & 15 ];
-      state_1 ^= state_1 << 31;
-      state_1 ^= state_1 >> 11;
-      state_0 ^= state_0 >> 30;
-      uint64_t tmp = ( state_[ p_ ] = state_0 ^ state_1 ) * 1181783497276652981ULL;
-      tmp = tmp>>16;
-      return static_cast<uint32_t>(tmp&MAX_URAND);
-    }
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024(const typename pool_type::state_data_type& state, int p,
+                      int state_idx = 0)
+      : p_(p), state_idx_(state_idx) {
+    for (int i = 0; i < 16; i++) state_[i] = state(state_idx, i);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64() {
-      uint64_t state_0 = state_[ p_ ];
-      uint64_t state_1 = state_[ p_ = ( p_ + 1 ) & 15 ];
-      state_1 ^= state_1 << 31;
-      state_1 ^= state_1 >> 11;
-      state_0 ^= state_0 >> 30;
-      return (( state_[ p_ ] = state_0 ^ state_1 ) * 1181783497276652981LL) - 1;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand() {
+    uint64_t state_0 = state_[p_];
+    uint64_t state_1 = state_[p_ = (p_ + 1) & 15];
+    state_1 ^= state_1 << 31;
+    state_1 ^= state_1 >> 11;
+    state_0 ^= state_0 >> 30;
+    uint64_t tmp = (state_[p_] = state_0 ^ state_1) * 1181783497276652981ULL;
+    tmp          = tmp >> 16;
+    return static_cast<uint32_t>(tmp & MAX_URAND);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& range) {
-      const uint32_t max_val = (MAX_URAND/range)*range;
-      uint32_t tmp = urand();
-      while(tmp>=max_val)
-        tmp = urand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64() {
+    uint64_t state_0 = state_[p_];
+    uint64_t state_1 = state_[p_ = (p_ + 1) & 15];
+    state_1 ^= state_1 << 31;
+    state_1 ^= state_1 >> 11;
+    state_0 ^= state_0 >> 30;
+    return ((state_[p_] = state_0 ^ state_1) * 1181783497276652981LL) - 1;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& start, const uint32_t& end ) {
-      return urand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& range) {
+    const uint32_t max_val = (MAX_URAND / range) * range;
+    uint32_t tmp           = urand();
+    while (tmp >= max_val) tmp = urand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& range) {
-      const uint64_t max_val = (MAX_URAND64/range)*range;
-      uint64_t tmp = urand64();
-      while(tmp>=max_val)
-        tmp = urand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& start, const uint32_t& end) {
+    return urand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& start, const uint64_t& end ) {
-      return urand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& range) {
+    const uint64_t max_val = (MAX_URAND64 / range) * range;
+    uint64_t tmp           = urand64();
+    while (tmp >= max_val) tmp = urand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand() {
-      return static_cast<int>(urand()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& start, const uint64_t& end) {
+    return urand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& range) {
-      const int max_val = (MAX_RAND/range)*range;
-      int tmp = rand();
-      while(tmp>=max_val)
-        tmp = rand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand() { return static_cast<int>(urand() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& start, const int& end ) {
-      return rand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& range) {
+    const int max_val = (MAX_RAND / range) * range;
+    int tmp           = rand();
+    while (tmp >= max_val) tmp = rand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64() {
-      return static_cast<int64_t>(urand64()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& start, const int& end) {
+    return rand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& range) {
-      const int64_t max_val = (MAX_RAND64/range)*range;
-      int64_t tmp = rand64();
-      while(tmp>=max_val)
-        tmp = rand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64() { return static_cast<int64_t>(urand64() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& start, const int64_t& end ) {
-      return rand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& range) {
+    const int64_t max_val = (MAX_RAND64 / range) * range;
+    int64_t tmp           = rand64();
+    while (tmp >= max_val) tmp = rand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand() {
-      return 1.0f * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& start, const int64_t& end) {
+    return rand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand() { return 1.0f * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& start, const float& end ) {
-      return frand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& range) { return range * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand() {
-      return 1.0 * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& start, const float& end) {
+    return frand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand() { return 1.0 * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& start, const double& end ) {
-      return frand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& range) { return range * urand64() / MAX_URAND64; }
 
-    //Marsaglia polar method for drawing a standard normal distributed random number
-    KOKKOS_INLINE_FUNCTION
-    double normal() {
-      double S = 2.0;
-      double U;
-      while(S>=1.0) {
-        U = 2.0*drand() - 1.0;
-        const double V = 2.0*drand() - 1.0;
-        S = U*U+V*V;
-      }
-      return U*std::sqrt(-2.0*log(S)/S);
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& start, const double& end) {
+    return frand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double normal(const double& mean, const double& std_dev=1.0) {
-      return mean + normal()*std_dev;
-    }
-  };
+  // Marsaglia polar method for drawing a standard normal distributed random
+  // number
+  KOKKOS_INLINE_FUNCTION
+  double normal() {
+    double S = 2.0;
+    double U;
+    while (S >= 1.0) {
+      U              = 2.0 * drand() - 1.0;
+      const double V = 2.0 * drand() - 1.0;
+      S              = U * U + V * V;
+    }
+    return U * std::sqrt(-2.0 * log(S) / S);
+  }
 
+  KOKKOS_INLINE_FUNCTION
+  double normal(const double& mean, const double& std_dev = 1.0) {
+    return mean + normal() * std_dev;
+  }
+};
 
-  template<class DeviceType = Kokkos::DefaultExecutionSpace>
-  class Random_XorShift1024_Pool {
-  private:
-    typedef View<int*,DeviceType> int_view_type;
-    typedef View<uint64_t*[16],DeviceType> state_data_type;
+template <class DeviceType = Kokkos::DefaultExecutionSpace>
+class Random_XorShift1024_Pool {
+ private:
+  typedef View<int*, DeviceType> int_view_type;
+  typedef View<uint64_t * [16], DeviceType> state_data_type;
 
-    int_view_type locks_;
-    state_data_type state_;
-    int_view_type p_;
-    int num_states_;
-    friend class Random_XorShift1024<DeviceType>;
+  int_view_type locks_;
+  state_data_type state_;
+  int_view_type p_;
+  int num_states_;
+  friend class Random_XorShift1024<DeviceType>;
 
-  public:
-    typedef Random_XorShift1024<DeviceType> generator_type;
+ public:
+  typedef Random_XorShift1024<DeviceType> generator_type;
 
-    typedef DeviceType device_type;
+  typedef DeviceType device_type;
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024_Pool() {
-      num_states_ = 0;
-    }
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024_Pool() { num_states_ = 0; }
 
-    inline
-    Random_XorShift1024_Pool(uint64_t seed){
-      num_states_ = 0;
+  inline Random_XorShift1024_Pool(uint64_t seed) {
+    num_states_ = 0;
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      init(seed,DeviceType::max_hardware_threads());
+    init(seed, DeviceType::max_hardware_threads());
 #else
-      init(seed,DeviceType::impl_max_hardware_threads());
+    init(seed, DeviceType::impl_max_hardware_threads());
 #endif
-    }
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024_Pool(const Random_XorShift1024_Pool& src):
-      locks_(src.locks_),
-      state_(src.state_),
-      p_(src.p_),
-      num_states_(src.num_states_)
-    {}
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024_Pool(const Random_XorShift1024_Pool& src)
+      : locks_(src.locks_),
+        state_(src.state_),
+        p_(src.p_),
+        num_states_(src.num_states_) {}
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024_Pool operator = (const Random_XorShift1024_Pool& src) {
-      locks_ = src.locks_;
-      state_ = src.state_;
-      p_ = src.p_;
-      num_states_ = src.num_states_;
-      return *this;
-    }
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024_Pool operator=(const Random_XorShift1024_Pool& src) {
+    locks_      = src.locks_;
+    state_      = src.state_;
+    p_          = src.p_;
+    num_states_ = src.num_states_;
+    return *this;
+  }
 
-    inline
-    void init(uint64_t seed, int num_states) {
-      if(seed==0)
-        seed = uint64_t(1318319);
-      num_states_ = num_states;
-      locks_ = int_view_type("Kokkos::Random_XorShift1024::locks",num_states_);
-      state_ = state_data_type("Kokkos::Random_XorShift1024::state",num_states_);
-      p_ = int_view_type("Kokkos::Random_XorShift1024::p",num_states_);
-
-      typename state_data_type::HostMirror h_state = create_mirror_view(state_);
-      typename int_view_type::HostMirror h_lock = create_mirror_view(locks_);
-      typename int_view_type::HostMirror h_p = create_mirror_view(p_);
-
-      // Execute on the HostMirror's default execution space.
-      Random_XorShift64<typename state_data_type::HostMirror::execution_space> gen(seed,0);
-      for(int i = 0; i < 17; i++)
-        gen.rand();
-      for(int i = 0; i < num_states_; i++) {
-        for(int j = 0; j < 16 ; j++) {
-          int n1 = gen.rand();
-          int n2 = gen.rand();
-          int n3 = gen.rand();
-          int n4 = gen.rand();
-          h_state(i,j) = (((static_cast<uint64_t>(n1)) & 0xffff)<<00) |
-                         (((static_cast<uint64_t>(n2)) & 0xffff)<<16) |
-                         (((static_cast<uint64_t>(n3)) & 0xffff)<<32) |
-                         (((static_cast<uint64_t>(n4)) & 0xffff)<<48);
-        }
-        h_p(i) = 0;
-        h_lock(i) = 0;
+  inline void init(uint64_t seed, int num_states) {
+    if (seed == 0) seed = uint64_t(1318319);
+    num_states_ = num_states;
+    locks_ = int_view_type("Kokkos::Random_XorShift1024::locks", num_states_);
+    state_ = state_data_type("Kokkos::Random_XorShift1024::state", num_states_);
+    p_     = int_view_type("Kokkos::Random_XorShift1024::p", num_states_);
+
+    typename state_data_type::HostMirror h_state = create_mirror_view(state_);
+    typename int_view_type::HostMirror h_lock    = create_mirror_view(locks_);
+    typename int_view_type::HostMirror h_p       = create_mirror_view(p_);
+
+    // Execute on the HostMirror's default execution space.
+    Random_XorShift64<typename state_data_type::HostMirror::execution_space>
+        gen(seed, 0);
+    for (int i = 0; i < 17; i++) gen.rand();
+    for (int i = 0; i < num_states_; i++) {
+      for (int j = 0; j < 16; j++) {
+        int n1        = gen.rand();
+        int n2        = gen.rand();
+        int n3        = gen.rand();
+        int n4        = gen.rand();
+        h_state(i, j) = (((static_cast<uint64_t>(n1)) & 0xffff) << 00) |
+                        (((static_cast<uint64_t>(n2)) & 0xffff) << 16) |
+                        (((static_cast<uint64_t>(n3)) & 0xffff) << 32) |
+                        (((static_cast<uint64_t>(n4)) & 0xffff) << 48);
       }
-      deep_copy(state_,h_state);
-      deep_copy(locks_,h_lock);
+      h_p(i)    = 0;
+      h_lock(i) = 0;
     }
+    deep_copy(state_, h_state);
+    deep_copy(locks_, h_lock);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024<DeviceType> get_state() const {
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024<DeviceType> get_state() const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int i = DeviceType::hardware_thread_id();
+    const int i = DeviceType::hardware_thread_id();
 #else
-      const int i = DeviceType::impl_hardware_thread_id();
+    const int i = DeviceType::impl_hardware_thread_id();
 #endif
-      return Random_XorShift1024<DeviceType>(state_,p_(i),i);
-    };
+    return Random_XorShift1024<DeviceType>(state_, p_(i), i);
+  };
 
-    // NOTE: state_idx MUST be unique and less than num_states
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024<DeviceType> get_state(const int state_idx) const {
-      return Random_XorShift1024<DeviceType>(state_,p_(state_idx),state_idx);
-    }
+  // NOTE: state_idx MUST be unique and less than num_states
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024<DeviceType> get_state(const int state_idx) const {
+    return Random_XorShift1024<DeviceType>(state_, p_(state_idx), state_idx);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void free_state(const Random_XorShift1024<DeviceType>& state) const {
-      for(int i = 0; i<16; i++)
-        state_(state.state_idx_,i) = state.state_[i];
-      p_(state.state_idx_) = state.p_;
-    }
-  };
+  KOKKOS_INLINE_FUNCTION
+  void free_state(const Random_XorShift1024<DeviceType>& state) const {
+    for (int i = 0; i < 16; i++) state_(state.state_idx_, i) = state.state_[i];
+    p_(state.state_idx_) = state.p_;
+  }
+};
 
 #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDACC__)
 
-  template<>
-  class Random_XorShift1024<Kokkos::Cuda> {
-  private:
-    int p_;
-    const int state_idx_;
-    uint64_t* state_;
-    const int stride_;
-    friend class Random_XorShift1024_Pool<Kokkos::Cuda>;
-  public:
+template <>
+class Random_XorShift1024<Kokkos::Cuda> {
+ private:
+  int p_;
+  const int state_idx_;
+  uint64_t* state_;
+  const int stride_;
+  friend class Random_XorShift1024_Pool<Kokkos::Cuda>;
 
-    typedef Kokkos::Cuda device_type;
-    typedef Random_XorShift1024_Pool<device_type> pool_type;
+ public:
+  typedef Kokkos::Cuda device_type;
+  typedef Random_XorShift1024_Pool<device_type> pool_type;
 
-    enum {MAX_URAND = 0xffffffffU};
-    enum {MAX_URAND64 = 0xffffffffffffffffULL-1};
-    enum {MAX_RAND = static_cast<int>(0xffffffffU/2)};
-    enum {MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffULL/2-1)};
+  enum { MAX_URAND = 0xffffffffU };
+  enum { MAX_URAND64 = 0xffffffffffffffffULL - 1 };
+  enum { MAX_RAND = static_cast<int>(0xffffffffU / 2) };
+  enum { MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffULL / 2 - 1) };
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024 (const typename pool_type::state_data_type& state, int p, int state_idx = 0):
-      p_(p),state_idx_(state_idx),state_(&state(state_idx,0)),stride_(state.stride_1()){
-    }
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024(const typename pool_type::state_data_type& state, int p,
+                      int state_idx = 0)
+      : p_(p),
+        state_idx_(state_idx),
+        state_(&state(state_idx, 0)),
+        stride_(state.stride_1()) {}
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand() {
-      uint64_t state_0 = state_[ p_ * stride_ ];
-      uint64_t state_1 = state_[ (p_ = ( p_ + 1 ) & 15) * stride_ ];
-      state_1 ^= state_1 << 31;
-      state_1 ^= state_1 >> 11;
-      state_0 ^= state_0 >> 30;
-      uint64_t tmp = ( state_[ p_ * stride_ ] = state_0 ^ state_1 ) * 1181783497276652981ULL;
-      tmp = tmp>>16;
-      return static_cast<uint32_t>(tmp&MAX_URAND);
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand() {
+    uint64_t state_0 = state_[p_ * stride_];
+    uint64_t state_1 = state_[(p_ = (p_ + 1) & 15) * stride_];
+    state_1 ^= state_1 << 31;
+    state_1 ^= state_1 >> 11;
+    state_0 ^= state_0 >> 30;
+    uint64_t tmp =
+        (state_[p_ * stride_] = state_0 ^ state_1) * 1181783497276652981ULL;
+    tmp = tmp >> 16;
+    return static_cast<uint32_t>(tmp & MAX_URAND);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64() {
-      uint64_t state_0 = state_[ p_ * stride_ ];
-      uint64_t state_1 = state_[ (p_ = ( p_ + 1 ) & 15) * stride_ ];
-      state_1 ^= state_1 << 31;
-      state_1 ^= state_1 >> 11;
-      state_0 ^= state_0 >> 30;
-      return (( state_[ p_ * stride_ ] = state_0 ^ state_1 ) * 1181783497276652981LL) - 1;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64() {
+    uint64_t state_0 = state_[p_ * stride_];
+    uint64_t state_1 = state_[(p_ = (p_ + 1) & 15) * stride_];
+    state_1 ^= state_1 << 31;
+    state_1 ^= state_1 >> 11;
+    state_0 ^= state_0 >> 30;
+    return ((state_[p_ * stride_] = state_0 ^ state_1) *
+            1181783497276652981LL) -
+           1;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& range) {
-      const uint32_t max_val = (MAX_URAND/range)*range;
-      uint32_t tmp = urand();
-      while(tmp>=max_val)
-        urand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& range) {
+    const uint32_t max_val = (MAX_URAND / range) * range;
+    uint32_t tmp           = urand();
+    while (tmp >= max_val) urand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& start, const uint32_t& end ) {
-      return urand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& start, const uint32_t& end) {
+    return urand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& range) {
-      const uint64_t max_val = (MAX_URAND64/range)*range;
-      uint64_t tmp = urand64();
-      while(tmp>=max_val)
-        urand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& range) {
+    const uint64_t max_val = (MAX_URAND64 / range) * range;
+    uint64_t tmp           = urand64();
+    while (tmp >= max_val) urand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& start, const uint64_t& end ) {
-      return urand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& start, const uint64_t& end) {
+    return urand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand() {
-      return static_cast<int>(urand()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand() { return static_cast<int>(urand() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& range) {
-      const int max_val = (MAX_RAND/range)*range;
-      int tmp = rand();
-      while(tmp>=max_val)
-        rand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& range) {
+    const int max_val = (MAX_RAND / range) * range;
+    int tmp           = rand();
+    while (tmp >= max_val) rand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& start, const int& end ) {
-      return rand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& start, const int& end) {
+    return rand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64() {
-      return static_cast<int64_t>(urand64()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64() { return static_cast<int64_t>(urand64() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& range) {
-      const int64_t max_val = (MAX_RAND64/range)*range;
-      int64_t tmp = rand64();
-      while(tmp>=max_val)
-        rand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& range) {
+    const int64_t max_val = (MAX_RAND64 / range) * range;
+    int64_t tmp           = rand64();
+    while (tmp >= max_val) rand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& start, const int64_t& end ) {
-      return rand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& start, const int64_t& end) {
+    return rand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand() {
-      return 1.0f * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand() { return 1.0f * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& range) { return range * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& start, const float& end ) {
-      return frand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& start, const float& end) {
+    return frand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand() {
-      return 1.0 * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand() { return 1.0 * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& range) { return range * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& start, const double& end ) {
-      return frand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& start, const double& end) {
+    return frand(end - start) + start;
+  }
 
-    //Marsaglia polar method for drawing a standard normal distributed random number
-    KOKKOS_INLINE_FUNCTION
-    double normal() {
-      double S = 2.0;
-      double U;
-      while(S>=1.0) {
-        U = 2.0*drand() - 1.0;
-        const double V = 2.0*drand() - 1.0;
-        S = U*U+V*V;
-      }
-      return U*std::sqrt(-2.0*log(S)/S);
-    }
+  // Marsaglia polar method for drawing a standard normal distributed random
+  // number
+  KOKKOS_INLINE_FUNCTION
+  double normal() {
+    double S = 2.0;
+    double U;
+    while (S >= 1.0) {
+      U              = 2.0 * drand() - 1.0;
+      const double V = 2.0 * drand() - 1.0;
+      S              = U * U + V * V;
+    }
+    return U * std::sqrt(-2.0 * log(S) / S);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double normal(const double& mean, const double& std_dev=1.0) {
-      return mean + normal()*std_dev;
-    }
-  };
+  KOKKOS_INLINE_FUNCTION
+  double normal(const double& mean, const double& std_dev = 1.0) {
+    return mean + normal() * std_dev;
+  }
+};
 
-template<>
-inline
-Random_XorShift64_Pool<Kokkos::Cuda>::Random_XorShift64_Pool(uint64_t seed) {
+template <>
+inline Random_XorShift64_Pool<Kokkos::Cuda>::Random_XorShift64_Pool(
+    uint64_t seed) {
   num_states_ = 0;
-  init(seed,4*32768);
+  init(seed, 4 * 32768);
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-Random_XorShift64<Kokkos::Cuda> Random_XorShift64_Pool<Kokkos::Cuda>::get_state() const {
+template <>
+KOKKOS_INLINE_FUNCTION Random_XorShift64<Kokkos::Cuda>
+Random_XorShift64_Pool<Kokkos::Cuda>::get_state() const {
 #ifdef __CUDA_ARCH__
-  const int i_offset = (threadIdx.x*blockDim.y + threadIdx.y)*blockDim.z+threadIdx.z;
-  int i = (((blockIdx.x*gridDim.y+blockIdx.y)*gridDim.z + blockIdx.z) *
-           blockDim.x*blockDim.y*blockDim.z + i_offset)%num_states_;
-  while(Kokkos::atomic_compare_exchange(&locks_(i),0,1)) {
-      i+=blockDim.x*blockDim.y*blockDim.z;
-      if(i>=num_states_) {i = i_offset;}
+  const int i_offset =
+      (threadIdx.x * blockDim.y + threadIdx.y) * blockDim.z + threadIdx.z;
+  int i = (((blockIdx.x * gridDim.y + blockIdx.y) * gridDim.z + blockIdx.z) *
+               blockDim.x * blockDim.y * blockDim.z +
+           i_offset) %
+          num_states_;
+  while (Kokkos::atomic_compare_exchange(&locks_(i), 0, 1)) {
+    i += blockDim.x * blockDim.y * blockDim.z;
+    if (i >= num_states_) {
+      i = i_offset;
+    }
   }
 
-  return Random_XorShift64<Kokkos::Cuda>(state_(i),i);
+  return Random_XorShift64<Kokkos::Cuda>(state_(i), i);
 #else
-  return Random_XorShift64<Kokkos::Cuda>(state_(0),0);
+  return Random_XorShift64<Kokkos::Cuda>(state_(0), 0);
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void Random_XorShift64_Pool<Kokkos::Cuda>::free_state(const Random_XorShift64<Kokkos::Cuda> &state) const {
+template <>
+KOKKOS_INLINE_FUNCTION void Random_XorShift64_Pool<Kokkos::Cuda>::free_state(
+    const Random_XorShift64<Kokkos::Cuda>& state) const {
   state_(state.state_idx_) = state.state_;
 #ifdef __CUDA_ARCH__
   locks_(state.state_idx_) = 0;
@@ -1249,24 +1211,28 @@ void Random_XorShift64_Pool<Kokkos::Cuda>::free_state(const Random_XorShift64<Ko
 #endif
 }
 
-
-template<>
-inline
-Random_XorShift1024_Pool<Kokkos::Cuda>::Random_XorShift1024_Pool(uint64_t seed) {
+template <>
+inline Random_XorShift1024_Pool<Kokkos::Cuda>::Random_XorShift1024_Pool(
+    uint64_t seed) {
   num_states_ = 0;
-  init(seed,4*32768);
+  init(seed, 4 * 32768);
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-Random_XorShift1024<Kokkos::Cuda> Random_XorShift1024_Pool<Kokkos::Cuda>::get_state() const {
+template <>
+KOKKOS_INLINE_FUNCTION Random_XorShift1024<Kokkos::Cuda>
+Random_XorShift1024_Pool<Kokkos::Cuda>::get_state() const {
 #ifdef __CUDA_ARCH__
-  const int i_offset = (threadIdx.x*blockDim.y + threadIdx.y)*blockDim.z+threadIdx.z;
-  int i = (((blockIdx.x*gridDim.y+blockIdx.y)*gridDim.z + blockIdx.z) *
-           blockDim.x*blockDim.y*blockDim.z + i_offset)%num_states_;
-  while(Kokkos::atomic_compare_exchange(&locks_(i),0,1)) {
-      i+=blockDim.x*blockDim.y*blockDim.z;
-      if(i>=num_states_) {i = i_offset;}
+  const int i_offset =
+      (threadIdx.x * blockDim.y + threadIdx.y) * blockDim.z + threadIdx.z;
+  int i = (((blockIdx.x * gridDim.y + blockIdx.y) * gridDim.z + blockIdx.z) *
+               blockDim.x * blockDim.y * blockDim.z +
+           i_offset) %
+          num_states_;
+  while (Kokkos::atomic_compare_exchange(&locks_(i), 0, 1)) {
+    i += blockDim.x * blockDim.y * blockDim.z;
+    if (i >= num_states_) {
+      i = i_offset;
+    }
   }
 
   return Random_XorShift1024<Kokkos::Cuda>(state_, p_(i), i);
@@ -1275,210 +1241,205 @@ Random_XorShift1024<Kokkos::Cuda> Random_XorShift1024_Pool<Kokkos::Cuda>::get_st
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void Random_XorShift1024_Pool<Kokkos::Cuda>::free_state(const Random_XorShift1024<Kokkos::Cuda> &state) const {
-  for(int i=0; i<16; i++)
-    state_(state.state_idx_,i) = state.state_[i];
+template <>
+KOKKOS_INLINE_FUNCTION void Random_XorShift1024_Pool<Kokkos::Cuda>::free_state(
+    const Random_XorShift1024<Kokkos::Cuda>& state) const {
+  for (int i = 0; i < 16; i++) state_(state.state_idx_, i) = state.state_[i];
 #ifdef __CUDA_ARCH__
   locks_(state.state_idx_) = 0;
   return;
 #endif
 }
 
-
 #endif
 
-#if defined(KOKKOS_ENABLE_ROCM) 
+#if defined(KOKKOS_ENABLE_ROCM)
 
-  template<>
-  class Random_XorShift1024<Kokkos::Experimental::ROCm> {
-  private:
-    int p_;
-    const int state_idx_;
-    uint64_t* state_;
-    const int stride_;
-    friend class Random_XorShift1024_Pool<Kokkos::Experimental::ROCm>;
-  public:
+template <>
+class Random_XorShift1024<Kokkos::Experimental::ROCm> {
+ private:
+  int p_;
+  const int state_idx_;
+  uint64_t* state_;
+  const int stride_;
+  friend class Random_XorShift1024_Pool<Kokkos::Experimental::ROCm>;
 
-    typedef Kokkos::Experimental::ROCm device_type;
-    typedef Random_XorShift1024_Pool<device_type> pool_type;
+ public:
+  typedef Kokkos::Experimental::ROCm device_type;
+  typedef Random_XorShift1024_Pool<device_type> pool_type;
 
-    enum {MAX_URAND = 0xffffffffU};
-    enum {MAX_URAND64 = 0xffffffffffffffffULL-1};
-    enum {MAX_RAND = static_cast<int>(0xffffffffU/2)};
-    enum {MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffULL/2-1)};
+  enum { MAX_URAND = 0xffffffffU };
+  enum { MAX_URAND64 = 0xffffffffffffffffULL - 1 };
+  enum { MAX_RAND = static_cast<int>(0xffffffffU / 2) };
+  enum { MAX_RAND64 = static_cast<int64_t>(0xffffffffffffffffULL / 2 - 1) };
 
-    KOKKOS_INLINE_FUNCTION
-    Random_XorShift1024 (const typename pool_type::state_data_type& state, int p, int state_idx = 0):
-      p_(p),state_idx_(state_idx),state_(&state(state_idx,0)),stride_(state.stride_1()){
-    }
+  KOKKOS_INLINE_FUNCTION
+  Random_XorShift1024(const typename pool_type::state_data_type& state, int p,
+                      int state_idx = 0)
+      : p_(p),
+        state_idx_(state_idx),
+        state_(&state(state_idx, 0)),
+        stride_(state.stride_1()) {}
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand() {
-      uint64_t state_0 = state_[ p_ * stride_ ];
-      uint64_t state_1 = state_[ (p_ = ( p_ + 1 ) & 15) * stride_ ];
-      state_1 ^= state_1 << 31;
-      state_1 ^= state_1 >> 11;
-      state_0 ^= state_0 >> 30;
-      uint64_t tmp = ( state_[ p_ * stride_ ] = state_0 ^ state_1 ) * 1181783497276652981ULL;
-      tmp = tmp>>16;
-      return static_cast<uint32_t>(tmp&MAX_URAND);
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand() {
+    uint64_t state_0 = state_[p_ * stride_];
+    uint64_t state_1 = state_[(p_ = (p_ + 1) & 15) * stride_];
+    state_1 ^= state_1 << 31;
+    state_1 ^= state_1 >> 11;
+    state_0 ^= state_0 >> 30;
+    uint64_t tmp =
+        (state_[p_ * stride_] = state_0 ^ state_1) * 1181783497276652981ULL;
+    tmp = tmp >> 16;
+    return static_cast<uint32_t>(tmp & MAX_URAND);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64() {
-      uint64_t state_0 = state_[ p_ * stride_ ];
-      uint64_t state_1 = state_[ (p_ = ( p_ + 1 ) & 15) * stride_ ];
-      state_1 ^= state_1 << 31;
-      state_1 ^= state_1 >> 11;
-      state_0 ^= state_0 >> 30;
-      return (( state_[ p_ * stride_ ] = state_0 ^ state_1 ) * 1181783497276652981LL) - 1;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64() {
+    uint64_t state_0 = state_[p_ * stride_];
+    uint64_t state_1 = state_[(p_ = (p_ + 1) & 15) * stride_];
+    state_1 ^= state_1 << 31;
+    state_1 ^= state_1 >> 11;
+    state_0 ^= state_0 >> 30;
+    return ((state_[p_ * stride_] = state_0 ^ state_1) *
+            1181783497276652981LL) -
+           1;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& range) {
-      const uint32_t max_val = (MAX_URAND/range)*range;
-      uint32_t tmp = urand();
-      while(tmp>=max_val)
-        urand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& range) {
+    const uint32_t max_val = (MAX_URAND / range) * range;
+    uint32_t tmp           = urand();
+    while (tmp >= max_val) urand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint32_t urand(const uint32_t& start, const uint32_t& end ) {
-      return urand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint32_t urand(const uint32_t& start, const uint32_t& end) {
+    return urand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& range) {
-      const uint64_t max_val = (MAX_URAND64/range)*range;
-      uint64_t tmp = urand64();
-      while(tmp>=max_val)
-        urand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& range) {
+    const uint64_t max_val = (MAX_URAND64 / range) * range;
+    uint64_t tmp           = urand64();
+    while (tmp >= max_val) urand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    uint64_t urand64(const uint64_t& start, const uint64_t& end ) {
-      return urand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  uint64_t urand64(const uint64_t& start, const uint64_t& end) {
+    return urand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand() {
-      return static_cast<int>(urand()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand() { return static_cast<int>(urand() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& range) {
-      const int max_val = (MAX_RAND/range)*range;
-      int tmp = rand();
-      while(tmp>=max_val)
-        rand();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& range) {
+    const int max_val = (MAX_RAND / range) * range;
+    int tmp           = rand();
+    while (tmp >= max_val) rand();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int rand(const int& start, const int& end ) {
-      return rand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int rand(const int& start, const int& end) {
+    return rand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64() {
-      return static_cast<int64_t>(urand64()/2);
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64() { return static_cast<int64_t>(urand64() / 2); }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& range) {
-      const int64_t max_val = (MAX_RAND64/range)*range;
-      int64_t tmp = rand64();
-      while(tmp>=max_val)
-        rand64();
-      return tmp%range;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& range) {
+    const int64_t max_val = (MAX_RAND64 / range) * range;
+    int64_t tmp           = rand64();
+    while (tmp >= max_val) rand64();
+    return tmp % range;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    int64_t rand64(const int64_t& start, const int64_t& end ) {
-      return rand64(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  int64_t rand64(const int64_t& start, const int64_t& end) {
+    return rand64(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand() {
-      return 1.0f * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand() { return 1.0f * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& range) { return range * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    float frand(const float& start, const float& end ) {
-      return frand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  float frand(const float& start, const float& end) {
+    return frand(end - start) + start;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand() {
-      return 1.0 * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand() { return 1.0 * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& range) {
-      return range * urand64()/MAX_URAND64;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& range) { return range * urand64() / MAX_URAND64; }
 
-    KOKKOS_INLINE_FUNCTION
-    double drand(const double& start, const double& end ) {
-      return frand(end-start)+start;
-    }
+  KOKKOS_INLINE_FUNCTION
+  double drand(const double& start, const double& end) {
+    return frand(end - start) + start;
+  }
 
-    //Marsaglia polar method for drawing a standard normal distributed random number
-    KOKKOS_INLINE_FUNCTION
-    double normal() {
-      double S = 2.0;
-      double U;
-      while(S>=1.0) {
-        U = 2.0*drand() - 1.0;
-        const double V = 2.0*drand() - 1.0;
-        S = U*U+V*V;
-      }
-      return U*std::sqrt(-2.0*log(S)/S);
-    }
+  // Marsaglia polar method for drawing a standard normal distributed random
+  // number
+  KOKKOS_INLINE_FUNCTION
+  double normal() {
+    double S = 2.0;
+    double U;
+    while (S >= 1.0) {
+      U              = 2.0 * drand() - 1.0;
+      const double V = 2.0 * drand() - 1.0;
+      S              = U * U + V * V;
+    }
+    return U * std::sqrt(-2.0 * log(S) / S);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    double normal(const double& mean, const double& std_dev=1.0) {
-      return mean + normal()*std_dev;
-    }
-  };
+  KOKKOS_INLINE_FUNCTION
+  double normal(const double& mean, const double& std_dev = 1.0) {
+    return mean + normal() * std_dev;
+  }
+};
 
-template<>
-inline
-Random_XorShift64_Pool<Kokkos::Experimental::ROCm>::Random_XorShift64_Pool(uint64_t seed) {
+template <>
+inline Random_XorShift64_Pool<
+    Kokkos::Experimental::ROCm>::Random_XorShift64_Pool(uint64_t seed) {
   num_states_ = 0;
-  init(seed,4*32768);
+  init(seed, 4 * 32768);
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-Random_XorShift64<Kokkos::Experimental::ROCm> Random_XorShift64_Pool<Kokkos::Experimental::ROCm>::get_state() const {
+template <>
+KOKKOS_INLINE_FUNCTION Random_XorShift64<Kokkos::Experimental::ROCm>
+Random_XorShift64_Pool<Kokkos::Experimental::ROCm>::get_state() const {
 #ifdef __HCC_ACCELERATOR__
-  const int i_offset = (threadIdx_x*blockDim_y + threadIdx_y)*blockDim_z+threadIdx_z;
-  int i = (((blockIdx_x*gridDim_y+blockIdx_y)*gridDim_z + blockIdx_z) *
-           blockDim_x*blockDim_y*blockDim_z + i_offset)%num_states_;
-  while(Kokkos::atomic_compare_exchange(&locks_(i),0,1)) {
-      i+=blockDim_x*blockDim_y*blockDim_z;
-      if(i>=num_states_) {i = i_offset;}
+  const int i_offset =
+      (threadIdx_x * blockDim_y + threadIdx_y) * blockDim_z + threadIdx_z;
+  int i = (((blockIdx_x * gridDim_y + blockIdx_y) * gridDim_z + blockIdx_z) *
+               blockDim_x * blockDim_y * blockDim_z +
+           i_offset) %
+          num_states_;
+  while (Kokkos::atomic_compare_exchange(&locks_(i), 0, 1)) {
+    i += blockDim_x * blockDim_y * blockDim_z;
+    if (i >= num_states_) {
+      i = i_offset;
+    }
   }
 
-  return Random_XorShift64<Kokkos::Experimental::ROCm>(state_(i),i);
+  return Random_XorShift64<Kokkos::Experimental::ROCm>(state_(i), i);
 #else
-  return Random_XorShift64<Kokkos::Experimental::ROCm>(state_(0),0);
+  return Random_XorShift64<Kokkos::Experimental::ROCm>(state_(0), 0);
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void Random_XorShift64_Pool<Kokkos::Experimental::ROCm>::free_state(const Random_XorShift64<Kokkos::Experimental::ROCm> &state) const {
+template <>
+KOKKOS_INLINE_FUNCTION void
+Random_XorShift64_Pool<Kokkos::Experimental::ROCm>::free_state(
+    const Random_XorShift64<Kokkos::Experimental::ROCm>& state) const {
 #ifdef __HCC_ACCELERATOR__
   state_(state.state_idx_) = state.state_;
   locks_(state.state_idx_) = 0;
@@ -1486,24 +1447,28 @@ void Random_XorShift64_Pool<Kokkos::Experimental::ROCm>::free_state(const Random
 #endif
 }
 
-
-template<>
-inline
-Random_XorShift1024_Pool<Kokkos::Experimental::ROCm>::Random_XorShift1024_Pool(uint64_t seed) {
+template <>
+inline Random_XorShift1024_Pool<
+    Kokkos::Experimental::ROCm>::Random_XorShift1024_Pool(uint64_t seed) {
   num_states_ = 0;
-  init(seed,4*32768);
+  init(seed, 4 * 32768);
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-Random_XorShift1024<Kokkos::Experimental::ROCm> Random_XorShift1024_Pool<Kokkos::Experimental::ROCm>::get_state() const {
+template <>
+KOKKOS_INLINE_FUNCTION Random_XorShift1024<Kokkos::Experimental::ROCm>
+Random_XorShift1024_Pool<Kokkos::Experimental::ROCm>::get_state() const {
 #ifdef __HCC_ACCELERATOR__
-  const int i_offset = (threadIdx_x*blockDim_y + threadIdx_y)*blockDim_z+threadIdx_z;
-  int i = (((blockIdx_x*gridDim_y+blockIdx_y)*gridDim_z + blockIdx_z) *
-           blockDim_x*blockDim_y*blockDim_z + i_offset)%num_states_;
-  while(Kokkos::atomic_compare_exchange(&locks_(i),0,1)) {
-      i+=blockDim_x*blockDim_y*blockDim_z;
-      if(i>=num_states_) {i = i_offset;}
+  const int i_offset =
+      (threadIdx_x * blockDim_y + threadIdx_y) * blockDim_z + threadIdx_z;
+  int i = (((blockIdx_x * gridDim_y + blockIdx_y) * gridDim_z + blockIdx_z) *
+               blockDim_x * blockDim_y * blockDim_z +
+           i_offset) %
+          num_states_;
+  while (Kokkos::atomic_compare_exchange(&locks_(i), 0, 1)) {
+    i += blockDim_x * blockDim_y * blockDim_z;
+    if (i >= num_states_) {
+      i = i_offset;
+    }
   }
 
   return Random_XorShift1024<Kokkos::Experimental::ROCm>(state_, p_(i), i);
@@ -1512,515 +1477,589 @@ Random_XorShift1024<Kokkos::Experimental::ROCm> Random_XorShift1024_Pool<Kokkos:
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void Random_XorShift1024_Pool<Kokkos::Experimental::ROCm>::free_state(const Random_XorShift1024<Kokkos::Experimental::ROCm> &state) const {
+template <>
+KOKKOS_INLINE_FUNCTION void
+Random_XorShift1024_Pool<Kokkos::Experimental::ROCm>::free_state(
+    const Random_XorShift1024<Kokkos::Experimental::ROCm>& state) const {
 #ifdef __HCC_ACCELERATOR__
-  for(int i=0; i<16; i++)
-    state_(state.state_idx_,i) = state.state_[i];
+  for (int i = 0; i < 16; i++) state_(state.state_idx_, i) = state.state_[i];
   locks_(state.state_idx_) = 0;
   return;
 #endif
 }
 
-
 #endif
 
-
 namespace Impl {
 
-template<class ViewType, class RandomPool, int loops, int rank, class IndexType>
+template <class ViewType, class RandomPool, int loops, int rank,
+          class IndexType>
 struct fill_random_functor_range;
-template<class ViewType, class RandomPool, int loops, int rank, class IndexType>
+template <class ViewType, class RandomPool, int loops, int rank,
+          class IndexType>
 struct fill_random_functor_begin_end;
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,1,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 1, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const IndexType& i) const {
+  void operator()(const IndexType& i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0)))
-        a(idx) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0)))
+        a(idx) = Rand::draw(gen, range);
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,2,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 2, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          a(idx,k) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          a(idx, k) = Rand::draw(gen, range);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,3,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 3, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            a(idx,k,l) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            a(idx, k, l) = Rand::draw(gen, range);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,4, IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 4, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              a(idx,k,l,m) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              a(idx, k, l, m) = Rand::draw(gen, range);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,5,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 5, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              for(IndexType n=0;n<static_cast<IndexType>(a.extent(4));n++)
-              a(idx,k,l,m,n) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              for (IndexType n = 0; n < static_cast<IndexType>(a.extent(4));
+                   n++)
+                a(idx, k, l, m, n) = Rand::draw(gen, range);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,6,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 6, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              for(IndexType n=0;n<static_cast<IndexType>(a.extent(4));n++)
-                for(IndexType o=0;o<static_cast<IndexType>(a.extent(5));o++)
-              a(idx,k,l,m,n,o) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              for (IndexType n = 0; n < static_cast<IndexType>(a.extent(4));
+                   n++)
+                for (IndexType o = 0; o < static_cast<IndexType>(a.extent(5));
+                     o++)
+                  a(idx, k, l, m, n, o) = Rand::draw(gen, range);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,7,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 7, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              for(IndexType n=0;n<static_cast<IndexType>(a.extent(4));n++)
-                for(IndexType o=0;o<static_cast<IndexType>(a.extent(5));o++)
-                  for(IndexType p=0;p<static_cast<IndexType>(a.extent(6));p++)
-              a(idx,k,l,m,n,o,p) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              for (IndexType n = 0; n < static_cast<IndexType>(a.extent(4));
+                   n++)
+                for (IndexType o = 0; o < static_cast<IndexType>(a.extent(5));
+                     o++)
+                  for (IndexType p = 0; p < static_cast<IndexType>(a.extent(6));
+                       p++)
+                    a(idx, k, l, m, n, o, p) = Rand::draw(gen, range);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_range<ViewType,RandomPool,loops,8,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_range<ViewType, RandomPool, loops, 8, IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
   typename ViewType::const_value_type range;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_range(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type range_):
-    a(a_),rand_pool(rand_pool_),range(range_) {}
+                            typename ViewType::const_value_type range_)
+      : a(a_), rand_pool(rand_pool_), range(range_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              for(IndexType n=0;n<static_cast<IndexType>(a.extent(4));n++)
-                for(IndexType o=0;o<static_cast<IndexType>(a.extent(5));o++)
-                  for(IndexType p=0;p<static_cast<IndexType>(a.extent(6));p++)
-                    for(IndexType q=0;q<static_cast<IndexType>(a.extent(7));q++)
-              a(idx,k,l,m,n,o,p,q) = Rand::draw(gen,range);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              for (IndexType n = 0; n < static_cast<IndexType>(a.extent(4));
+                   n++)
+                for (IndexType o = 0; o < static_cast<IndexType>(a.extent(5));
+                     o++)
+                  for (IndexType p = 0; p < static_cast<IndexType>(a.extent(6));
+                       p++)
+                    for (IndexType q = 0;
+                         q < static_cast<IndexType>(a.extent(7)); q++)
+                      a(idx, k, l, m, n, o, p, q) = Rand::draw(gen, range);
       }
     }
     rand_pool.free_state(gen);
   }
 };
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,1,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 1,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0)))
-        a(idx) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0)))
+        a(idx) = Rand::draw(gen, begin, end);
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,2,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 2,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          a(idx,k) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          a(idx, k) = Rand::draw(gen, begin, end);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,3,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 3,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            a(idx,k,l) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            a(idx, k, l) = Rand::draw(gen, begin, end);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,4,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 4,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              a(idx,k,l,m) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              a(idx, k, l, m) = Rand::draw(gen, begin, end);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,5,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 5,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))){
-        for(IndexType l=0;l<static_cast<IndexType>(a.extent(1));l++)
-          for(IndexType m=0;m<static_cast<IndexType>(a.extent(2));m++)
-            for(IndexType n=0;n<static_cast<IndexType>(a.extent(3));n++)
-              for(IndexType o=0;o<static_cast<IndexType>(a.extent(4));o++)
-          a(idx,l,m,n,o) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType l = 0; l < static_cast<IndexType>(a.extent(1)); l++)
+          for (IndexType m = 0; m < static_cast<IndexType>(a.extent(2)); m++)
+            for (IndexType n = 0; n < static_cast<IndexType>(a.extent(3)); n++)
+              for (IndexType o = 0; o < static_cast<IndexType>(a.extent(4));
+                   o++)
+                a(idx, l, m, n, o) = Rand::draw(gen, begin, end);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,6,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 6,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              for(IndexType n=0;n<static_cast<IndexType>(a.extent(4));n++)
-                for(IndexType o=0;o<static_cast<IndexType>(a.extent(5));o++)
-          a(idx,k,l,m,n,o) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              for (IndexType n = 0; n < static_cast<IndexType>(a.extent(4));
+                   n++)
+                for (IndexType o = 0; o < static_cast<IndexType>(a.extent(5));
+                     o++)
+                  a(idx, k, l, m, n, o) = Rand::draw(gen, begin, end);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,7,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 7,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              for(IndexType n=0;n<static_cast<IndexType>(a.extent(4));n++)
-                for(IndexType o=0;o<static_cast<IndexType>(a.extent(5));o++)
-                  for(IndexType p=0;p<static_cast<IndexType>(a.extent(6));p++)
-            a(idx,k,l,m,n,o,p) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              for (IndexType n = 0; n < static_cast<IndexType>(a.extent(4));
+                   n++)
+                for (IndexType o = 0; o < static_cast<IndexType>(a.extent(5));
+                     o++)
+                  for (IndexType p = 0; p < static_cast<IndexType>(a.extent(6));
+                       p++)
+                    a(idx, k, l, m, n, o, p) = Rand::draw(gen, begin, end);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-template<class ViewType, class RandomPool, int loops, class IndexType>
-struct fill_random_functor_begin_end<ViewType,RandomPool,loops,8,IndexType>{
+template <class ViewType, class RandomPool, int loops, class IndexType>
+struct fill_random_functor_begin_end<ViewType, RandomPool, loops, 8,
+                                     IndexType> {
   typedef typename ViewType::execution_space execution_space;
   ViewType a;
   RandomPool rand_pool;
-  typename ViewType::const_value_type begin,end;
+  typename ViewType::const_value_type begin, end;
 
-  typedef rand<typename RandomPool::generator_type, typename ViewType::non_const_value_type> Rand;
+  typedef rand<typename RandomPool::generator_type,
+               typename ViewType::non_const_value_type>
+      Rand;
 
   fill_random_functor_begin_end(ViewType a_, RandomPool rand_pool_,
-      typename ViewType::const_value_type begin_, typename ViewType::const_value_type end_):
-    a(a_),rand_pool(rand_pool_),begin(begin_),end(end_) {}
+                                typename ViewType::const_value_type begin_,
+                                typename ViewType::const_value_type end_)
+      : a(a_), rand_pool(rand_pool_), begin(begin_), end(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (IndexType i) const {
+  void operator()(IndexType i) const {
     typename RandomPool::generator_type gen = rand_pool.get_state();
-    for(IndexType j=0;j<loops;j++) {
-      const IndexType idx = i*loops+j;
-      if(idx<static_cast<IndexType>(a.extent(0))) {
-        for(IndexType k=0;k<static_cast<IndexType>(a.extent(1));k++)
-          for(IndexType l=0;l<static_cast<IndexType>(a.extent(2));l++)
-            for(IndexType m=0;m<static_cast<IndexType>(a.extent(3));m++)
-              for(IndexType n=0;n<static_cast<IndexType>(a.extent(4));n++)
-                for(IndexType o=0;o<static_cast<IndexType>(a.extent(5));o++)
-                  for(IndexType p=0;p<static_cast<IndexType>(a.extent(6));p++)
-                    for(IndexType q=0;q<static_cast<IndexType>(a.extent(7));q++)
-              a(idx,k,l,m,n,o,p,q) = Rand::draw(gen,begin,end);
+    for (IndexType j = 0; j < loops; j++) {
+      const IndexType idx = i * loops + j;
+      if (idx < static_cast<IndexType>(a.extent(0))) {
+        for (IndexType k = 0; k < static_cast<IndexType>(a.extent(1)); k++)
+          for (IndexType l = 0; l < static_cast<IndexType>(a.extent(2)); l++)
+            for (IndexType m = 0; m < static_cast<IndexType>(a.extent(3)); m++)
+              for (IndexType n = 0; n < static_cast<IndexType>(a.extent(4));
+                   n++)
+                for (IndexType o = 0; o < static_cast<IndexType>(a.extent(5));
+                     o++)
+                  for (IndexType p = 0; p < static_cast<IndexType>(a.extent(6));
+                       p++)
+                    for (IndexType q = 0;
+                         q < static_cast<IndexType>(a.extent(7)); q++)
+                      a(idx, k, l, m, n, o, p, q) = Rand::draw(gen, begin, end);
       }
     }
     rand_pool.free_state(gen);
   }
 };
 
-}
+}  // namespace Impl
 
-template<class ViewType, class RandomPool, class IndexType = int64_t>
-void fill_random(ViewType a, RandomPool g, typename ViewType::const_value_type range) {
+template <class ViewType, class RandomPool, class IndexType = int64_t>
+void fill_random(ViewType a, RandomPool g,
+                 typename ViewType::const_value_type range) {
   int64_t LDA = a.extent(0);
-  if(LDA>0)
-    parallel_for((LDA+127)/128,Impl::fill_random_functor_range<ViewType,RandomPool,128,ViewType::Rank,IndexType>(a,g,range));
+  if (LDA > 0)
+    parallel_for((LDA + 127) / 128,
+                 Impl::fill_random_functor_range<ViewType, RandomPool, 128,
+                                                 ViewType::Rank, IndexType>(
+                     a, g, range));
 }
 
-template<class ViewType, class RandomPool, class IndexType = int64_t>
-void fill_random(ViewType a, RandomPool g, typename ViewType::const_value_type begin,typename ViewType::const_value_type end ) {
+template <class ViewType, class RandomPool, class IndexType = int64_t>
+void fill_random(ViewType a, RandomPool g,
+                 typename ViewType::const_value_type begin,
+                 typename ViewType::const_value_type end) {
   int64_t LDA = a.extent(0);
-  if(LDA>0)
-    parallel_for((LDA+127)/128,Impl::fill_random_functor_begin_end<ViewType,RandomPool,128,ViewType::Rank,IndexType>(a,g,begin,end));
-}
+  if (LDA > 0)
+    parallel_for((LDA + 127) / 128,
+                 Impl::fill_random_functor_begin_end<ViewType, RandomPool, 128,
+                                                     ViewType::Rank, IndexType>(
+                     a, g, begin, end));
 }
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/algorithms/src/Kokkos_Sort.hpp b/lib/kokkos/algorithms/src/Kokkos_Sort.hpp
index 7fb8505fe5327470c6dac96ba17631d460443675..b7a988361f52f382263beb2725758468138fec4f 100644
--- a/lib/kokkos/algorithms/src/Kokkos_Sort.hpp
+++ b/lib/kokkos/algorithms/src/Kokkos_Sort.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,12 +37,11 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
-
 #ifndef KOKKOS_SORT_HPP_
 #define KOKKOS_SORT_HPP_
 
@@ -51,125 +51,107 @@
 
 namespace Kokkos {
 
-  namespace Impl {
+namespace Impl {
 
-  template< class DstViewType , class SrcViewType
-          , int Rank = DstViewType::Rank >
-  struct CopyOp;
+template <class DstViewType, class SrcViewType, int Rank = DstViewType::Rank>
+struct CopyOp;
 
-  template< class DstViewType , class SrcViewType >
-  struct CopyOp<DstViewType,SrcViewType,1> {
-    KOKKOS_INLINE_FUNCTION
-    static void copy(DstViewType const& dst, size_t i_dst,
-                     SrcViewType const& src, size_t i_src ) {
-      dst(i_dst) = src(i_src);
-    }
-  };
+template <class DstViewType, class SrcViewType>
+struct CopyOp<DstViewType, SrcViewType, 1> {
+  KOKKOS_INLINE_FUNCTION
+  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
+                   size_t i_src) {
+    dst(i_dst) = src(i_src);
+  }
+};
 
-  template< class DstViewType , class SrcViewType >
-  struct CopyOp<DstViewType,SrcViewType,2> {
-    KOKKOS_INLINE_FUNCTION
-    static void copy(DstViewType const& dst, size_t i_dst,
-                     SrcViewType const& src, size_t i_src ) {
-      for(int j = 0;j< (int) dst.extent(1); j++)
-        dst(i_dst,j) = src(i_src,j);
-    }
-  };
+template <class DstViewType, class SrcViewType>
+struct CopyOp<DstViewType, SrcViewType, 2> {
+  KOKKOS_INLINE_FUNCTION
+  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
+                   size_t i_src) {
+    for (int j = 0; j < (int)dst.extent(1); j++) dst(i_dst, j) = src(i_src, j);
+  }
+};
 
-  template< class DstViewType , class SrcViewType >
-  struct CopyOp<DstViewType,SrcViewType,3> {
-    KOKKOS_INLINE_FUNCTION
-    static void copy(DstViewType const& dst, size_t i_dst,
-                     SrcViewType const& src, size_t i_src ) {
-      for(int j = 0; j<dst.extent(1); j++)
-        for(int k = 0; k<dst.extent(2); k++)
-          dst(i_dst,j,k) = src(i_src,j,k);
-    }
-  };
+template <class DstViewType, class SrcViewType>
+struct CopyOp<DstViewType, SrcViewType, 3> {
+  KOKKOS_INLINE_FUNCTION
+  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
+                   size_t i_src) {
+    for (int j = 0; j < dst.extent(1); j++)
+      for (int k = 0; k < dst.extent(2); k++)
+        dst(i_dst, j, k) = src(i_src, j, k);
   }
+};
+}  // namespace Impl
 
 //----------------------------------------------------------------------------
 
-template< class KeyViewType
-        , class BinSortOp
-        , class Space = typename KeyViewType::device_type
-        , class SizeType = typename KeyViewType::memory_space::size_type
-        >
+template <class KeyViewType, class BinSortOp,
+          class Space    = typename KeyViewType::device_type,
+          class SizeType = typename KeyViewType::memory_space::size_type>
 class BinSort {
-public:
-
-  template< class DstViewType , class SrcViewType >
+ public:
+  template <class DstViewType, class SrcViewType>
   struct copy_functor {
+    typedef typename SrcViewType::const_type src_view_type;
 
-    typedef typename SrcViewType::const_type  src_view_type ;
+    typedef Impl::CopyOp<DstViewType, src_view_type> copy_op;
 
-    typedef Impl::CopyOp< DstViewType , src_view_type > copy_op ;
+    DstViewType dst_values;
+    src_view_type src_values;
+    int dst_offset;
 
-    DstViewType     dst_values ;
-    src_view_type   src_values ;
-    int             dst_offset ;
-
-    copy_functor( DstViewType  const & dst_values_
-                , int          const & dst_offset_
-                , SrcViewType  const & src_values_
-                )
-      : dst_values( dst_values_ )
-      , src_values( src_values_ )
-      , dst_offset( dst_offset_ )
-      {}
+    copy_functor(DstViewType const& dst_values_, int const& dst_offset_,
+                 SrcViewType const& src_values_)
+        : dst_values(dst_values_),
+          src_values(src_values_),
+          dst_offset(dst_offset_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator() (const int& i) const {
-      copy_op::copy(dst_values,i+dst_offset,src_values,i);
+    void operator()(const int& i) const {
+      copy_op::copy(dst_values, i + dst_offset, src_values, i);
     }
   };
 
-  template< class DstViewType
-          , class PermuteViewType
-          , class SrcViewType
-          >
+  template <class DstViewType, class PermuteViewType, class SrcViewType>
   struct copy_permute_functor {
-
     // If a Kokkos::View then can generate constant random access
     // otherwise can only use the constant type.
 
-    typedef typename std::conditional
-      < Kokkos::is_view< SrcViewType >::value
-      , Kokkos::View< typename SrcViewType::const_data_type
-                    , typename SrcViewType::array_layout
-                    , typename SrcViewType::device_type
-                    , Kokkos::MemoryTraits<Kokkos::RandomAccess>
-                    >
-      , typename SrcViewType::const_type
-      >::type src_view_type ;
-
-    typedef typename PermuteViewType::const_type  perm_view_type ;
-
-    typedef Impl::CopyOp< DstViewType , src_view_type > copy_op ;
-
-    DstViewType     dst_values ;
-    perm_view_type  sort_order ;
-    src_view_type   src_values ;
-    int             src_offset ;
-
-    copy_permute_functor( DstViewType     const & dst_values_
-                        , PermuteViewType const & sort_order_
-                        , SrcViewType     const & src_values_
-                        , int             const & src_offset_
-                        )
-      : dst_values( dst_values_ )
-      , sort_order( sort_order_ )
-      , src_values( src_values_ )
-      , src_offset( src_offset_ )
-      {}
+    typedef typename std::conditional<
+        Kokkos::is_view<SrcViewType>::value,
+        Kokkos::View<typename SrcViewType::const_data_type,
+                     typename SrcViewType::array_layout,
+                     typename SrcViewType::device_type,
+                     Kokkos::MemoryTraits<Kokkos::RandomAccess> >,
+        typename SrcViewType::const_type>::type src_view_type;
+
+    typedef typename PermuteViewType::const_type perm_view_type;
+
+    typedef Impl::CopyOp<DstViewType, src_view_type> copy_op;
+
+    DstViewType dst_values;
+    perm_view_type sort_order;
+    src_view_type src_values;
+    int src_offset;
+
+    copy_permute_functor(DstViewType const& dst_values_,
+                         PermuteViewType const& sort_order_,
+                         SrcViewType const& src_values_, int const& src_offset_)
+        : dst_values(dst_values_),
+          sort_order(sort_order_),
+          src_values(src_values_),
+          src_offset(src_offset_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator() (const int& i)  const {
-      copy_op::copy(dst_values,i,src_values,src_offset+sort_order(i));
+    void operator()(const int& i) const {
+      copy_op::copy(dst_values, i, src_values, src_offset + sort_order(i));
     }
   };
 
-  typedef typename Space::execution_space  execution_space;
+  typedef typename Space::execution_space execution_space;
   typedef BinSortOp bin_op_type;
 
   struct bin_count_tag {};
@@ -177,221 +159,236 @@ public:
   struct bin_binning_tag {};
   struct bin_sort_bins_tag {};
 
-public:
-
+ public:
   typedef SizeType size_type;
   typedef size_type value_type;
 
   typedef Kokkos::View<size_type*, Space> offset_type;
   typedef Kokkos::View<const int*, Space> bin_count_type;
 
-  typedef typename KeyViewType::const_type  const_key_view_type ;
+  typedef typename KeyViewType::const_type const_key_view_type;
 
   // If a Kokkos::View then can generate constant random access
   // otherwise can only use the constant type.
 
-  typedef typename std::conditional
-    < Kokkos::is_view< KeyViewType >::value
-    , Kokkos::View< typename KeyViewType::const_data_type,
-                    typename KeyViewType::array_layout,
-                    typename KeyViewType::device_type,
-                    Kokkos::MemoryTraits<Kokkos::RandomAccess> >
-    , const_key_view_type
-    >::type const_rnd_key_view_type;
+  typedef typename std::conditional<
+      Kokkos::is_view<KeyViewType>::value,
+      Kokkos::View<typename KeyViewType::const_data_type,
+                   typename KeyViewType::array_layout,
+                   typename KeyViewType::device_type,
+                   Kokkos::MemoryTraits<Kokkos::RandomAccess> >,
+      const_key_view_type>::type const_rnd_key_view_type;
 
   typedef typename KeyViewType::non_const_value_type non_const_key_scalar;
-  typedef typename KeyViewType::const_value_type     const_key_scalar;
-
-  typedef Kokkos::View<int*, Space, Kokkos::MemoryTraits<Kokkos::Atomic> > bin_count_atomic_type ;
+  typedef typename KeyViewType::const_value_type const_key_scalar;
 
-private:
+  typedef Kokkos::View<int*, Space, Kokkos::MemoryTraits<Kokkos::Atomic> >
+      bin_count_atomic_type;
 
+ private:
   const_key_view_type keys;
   const_rnd_key_view_type keys_rnd;
 
-public:
-
-  BinSortOp             bin_op ;
-  offset_type           bin_offsets ;
-  bin_count_atomic_type bin_count_atomic ;
-  bin_count_type        bin_count_const ;
-  offset_type           sort_order ;
+ public:
+  BinSortOp bin_op;
+  offset_type bin_offsets;
+  bin_count_atomic_type bin_count_atomic;
+  bin_count_type bin_count_const;
+  offset_type sort_order;
 
-  int                   range_begin ;
-  int                   range_end ;
-  bool                  sort_within_bins ;
-
-public:
+  int range_begin;
+  int range_end;
+  bool sort_within_bins;
 
+ public:
   BinSort() {}
 
   //----------------------------------------
-  // Constructor: takes the keys, the binning_operator and optionally whether to sort within bins (default false)
-  BinSort( const_key_view_type  keys_
-         , int                  range_begin_
-         , int                  range_end_
-         , BinSortOp            bin_op_
-         , bool                 sort_within_bins_ = false
-         )
-     : keys(keys_)
-     , keys_rnd(keys_)
-     , bin_op(bin_op_)
-     , bin_offsets()
-     , bin_count_atomic()
-     , bin_count_const()
-     , sort_order()
-     , range_begin( range_begin_ )
-     , range_end( range_end_ )
-     , sort_within_bins( sort_within_bins_ )
-  {
-    bin_count_atomic = Kokkos::View<int*, Space >("Kokkos::SortImpl::BinSortFunctor::bin_count",bin_op.max_bins());
-    bin_count_const =  bin_count_atomic;
-    bin_offsets =      offset_type(ViewAllocateWithoutInitializing("Kokkos::SortImpl::BinSortFunctor::bin_offsets"),bin_op.max_bins());
-    sort_order =       offset_type(ViewAllocateWithoutInitializing("Kokkos::SortImpl::BinSortFunctor::sort_order"),range_end-range_begin);
+  // Constructor: takes the keys, the binning_operator and optionally whether to
+  // sort within bins (default false)
+  BinSort(const_key_view_type keys_, int range_begin_, int range_end_,
+          BinSortOp bin_op_, bool sort_within_bins_ = false)
+      : keys(keys_),
+        keys_rnd(keys_),
+        bin_op(bin_op_),
+        bin_offsets(),
+        bin_count_atomic(),
+        bin_count_const(),
+        sort_order(),
+        range_begin(range_begin_),
+        range_end(range_end_),
+        sort_within_bins(sort_within_bins_) {
+    bin_count_atomic = Kokkos::View<int*, Space>(
+        "Kokkos::SortImpl::BinSortFunctor::bin_count", bin_op.max_bins());
+    bin_count_const = bin_count_atomic;
+    bin_offsets =
+        offset_type(ViewAllocateWithoutInitializing(
+                        "Kokkos::SortImpl::BinSortFunctor::bin_offsets"),
+                    bin_op.max_bins());
+    sort_order =
+        offset_type(ViewAllocateWithoutInitializing(
+                        "Kokkos::SortImpl::BinSortFunctor::sort_order"),
+                    range_end - range_begin);
   }
 
-  BinSort( const_key_view_type  keys_
-         , BinSortOp            bin_op_
-         , bool                 sort_within_bins_ = false
-         )
-     : BinSort( keys_ , 0 , keys_.extent(0), bin_op_ , sort_within_bins_ ) {}
+  BinSort(const_key_view_type keys_, BinSortOp bin_op_,
+          bool sort_within_bins_ = false)
+      : BinSort(keys_, 0, keys_.extent(0), bin_op_, sort_within_bins_) {}
 
   //----------------------------------------
-  // Create the permutation vector, the bin_offset array and the bin_count array. Can be called again if keys changed
+  // Create the permutation vector, the bin_offset array and the bin_count
+  // array. Can be called again if keys changed
   void create_permute_vector() {
-    const size_t len = range_end - range_begin ;
-    Kokkos::parallel_for ("Kokkos::Sort::BinCount",Kokkos::RangePolicy<execution_space,bin_count_tag>    (0,len),*this);
-    Kokkos::parallel_scan("Kokkos::Sort::BinOffset",Kokkos::RangePolicy<execution_space,bin_offset_tag>   (0,bin_op.max_bins()) ,*this);
-
-    Kokkos::deep_copy(bin_count_atomic,0);
-    Kokkos::parallel_for ("Kokkos::Sort::BinBinning",Kokkos::RangePolicy<execution_space,bin_binning_tag>  (0,len),*this);
-
-    if(sort_within_bins)
-      Kokkos::parallel_for ("Kokkos::Sort::BinSort",Kokkos::RangePolicy<execution_space,bin_sort_bins_tag>(0,bin_op.max_bins()) ,*this);
+    const size_t len = range_end - range_begin;
+    Kokkos::parallel_for(
+        "Kokkos::Sort::BinCount",
+        Kokkos::RangePolicy<execution_space, bin_count_tag>(0, len), *this);
+    Kokkos::parallel_scan("Kokkos::Sort::BinOffset",
+                          Kokkos::RangePolicy<execution_space, bin_offset_tag>(
+                              0, bin_op.max_bins()),
+                          *this);
+
+    Kokkos::deep_copy(bin_count_atomic, 0);
+    Kokkos::parallel_for(
+        "Kokkos::Sort::BinBinning",
+        Kokkos::RangePolicy<execution_space, bin_binning_tag>(0, len), *this);
+
+    if (sort_within_bins)
+      Kokkos::parallel_for(
+          "Kokkos::Sort::BinSort",
+          Kokkos::RangePolicy<execution_space, bin_sort_bins_tag>(
+              0, bin_op.max_bins()),
+          *this);
   }
 
-  // Sort a subset of a view with respect to the first dimension using the permutation array
-  template<class ValuesViewType>
-  void sort( ValuesViewType const & values
-           , int values_range_begin
-           , int values_range_end) const
-  {
-    typedef
-      Kokkos::View< typename ValuesViewType::data_type,
-                    typename ValuesViewType::array_layout,
-                    typename ValuesViewType::device_type >
-        scratch_view_type ;
-
-    const size_t len = range_end - range_begin ;
-    const size_t values_len = values_range_end - values_range_begin ;
+  // Sort a subset of a view with respect to the first dimension using the
+  // permutation array
+  template <class ValuesViewType>
+  void sort(ValuesViewType const& values, int values_range_begin,
+            int values_range_end) const {
+    typedef Kokkos::View<typename ValuesViewType::data_type,
+                         typename ValuesViewType::array_layout,
+                         typename ValuesViewType::device_type>
+        scratch_view_type;
+
+    const size_t len        = range_end - range_begin;
+    const size_t values_len = values_range_end - values_range_begin;
     if (len != values_len) {
-      Kokkos::abort("BinSort::sort: values range length != permutation vector length");
+      Kokkos::abort(
+          "BinSort::sort: values range length != permutation vector length");
     }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    scratch_view_type
-      sorted_values(ViewAllocateWithoutInitializing("Kokkos::SortImpl::BinSortFunctor::sorted_values"),
-                    len,
-                    values.extent(1),
-                    values.extent(2),
-                    values.extent(3),
-                    values.extent(4),
-                    values.extent(5),
-                    values.extent(6),
-                    values.extent(7));
+    scratch_view_type sorted_values(
+        ViewAllocateWithoutInitializing(
+            "Kokkos::SortImpl::BinSortFunctor::sorted_values"),
+        len, values.extent(1), values.extent(2), values.extent(3),
+        values.extent(4), values.extent(5), values.extent(6), values.extent(7));
 #else
-    scratch_view_type
-      sorted_values(ViewAllocateWithoutInitializing("Kokkos::SortImpl::BinSortFunctor::sorted_values"),
-                  values.rank_dynamic > 0 ? len : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  values.rank_dynamic > 1 ? values.extent(1) : KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-                  values.rank_dynamic > 2 ? values.extent(2) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  values.rank_dynamic > 3 ? values.extent(3) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  values.rank_dynamic > 4 ? values.extent(4) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  values.rank_dynamic > 5 ? values.extent(5) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  values.rank_dynamic > 6 ? values.extent(6) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  values.rank_dynamic > 7 ? values.extent(7) : KOKKOS_IMPL_CTOR_DEFAULT_ARG);
+    scratch_view_type sorted_values(
+        ViewAllocateWithoutInitializing(
+            "Kokkos::SortImpl::BinSortFunctor::sorted_values"),
+        values.rank_dynamic > 0 ? len : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 1 ? values.extent(1)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 2 ? values.extent(2)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 3 ? values.extent(3)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 4 ? values.extent(4)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 5 ? values.extent(5)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 6 ? values.extent(6)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 7 ? values.extent(7)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG);
 #endif
 
     {
-      copy_permute_functor< scratch_view_type /* DstViewType */
-                          , offset_type       /* PermuteViewType */
-                          , ValuesViewType    /* SrcViewType */
-                          >
-        functor( sorted_values , sort_order , values, values_range_begin - range_begin );
-
-      parallel_for("Kokkos::Sort::CopyPermute", Kokkos::RangePolicy<execution_space>(0,len),functor);
+      copy_permute_functor<scratch_view_type /* DstViewType */
+                           ,
+                           offset_type /* PermuteViewType */
+                           ,
+                           ValuesViewType /* SrcViewType */
+                           >
+          functor(sorted_values, sort_order, values,
+                  values_range_begin - range_begin);
+
+      parallel_for("Kokkos::Sort::CopyPermute",
+                   Kokkos::RangePolicy<execution_space>(0, len), functor);
     }
 
     {
-      copy_functor< ValuesViewType , scratch_view_type >
-        functor( values , range_begin , sorted_values );
+      copy_functor<ValuesViewType, scratch_view_type> functor(
+          values, range_begin, sorted_values);
 
-      parallel_for("Kokkos::Sort::Copy", Kokkos::RangePolicy<execution_space>(0,len),functor);
+      parallel_for("Kokkos::Sort::Copy",
+                   Kokkos::RangePolicy<execution_space>(0, len), functor);
     }
 
     Kokkos::fence();
   }
 
-  template<class ValuesViewType>
-  void sort( ValuesViewType const & values ) const
-  {
-    this->sort( values, 0, /*values.extent(0)*/ range_end - range_begin );
+  template <class ValuesViewType>
+  void sort(ValuesViewType const& values) const {
+    this->sort(values, 0, /*values.extent(0)*/ range_end - range_begin);
   }
 
   // Get the permutation vector
   KOKKOS_INLINE_FUNCTION
-  offset_type get_permute_vector() const { return sort_order;}
+  offset_type get_permute_vector() const { return sort_order; }
 
   // Get the start offsets for each bin
   KOKKOS_INLINE_FUNCTION
-  offset_type get_bin_offsets() const { return bin_offsets;}
+  offset_type get_bin_offsets() const { return bin_offsets; }
 
   // Get the count for each bin
   KOKKOS_INLINE_FUNCTION
-  bin_count_type get_bin_count() const {return bin_count_const;}
-
-public:
+  bin_count_type get_bin_count() const { return bin_count_const; }
 
+ public:
   KOKKOS_INLINE_FUNCTION
-  void operator() (const bin_count_tag& tag, const int& i) const {
-    const int j = range_begin + i ;
+  void operator()(const bin_count_tag& tag, const int& i) const {
+    const int j = range_begin + i;
     bin_count_atomic(bin_op.bin(keys, j))++;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const bin_offset_tag& tag, const int& i, value_type& offset, const bool& final)  const {
-    if(final) {
+  void operator()(const bin_offset_tag& tag, const int& i, value_type& offset,
+                  const bool& final) const {
+    if (final) {
       bin_offsets(i) = offset;
     }
-    offset+=bin_count_const(i);
+    offset += bin_count_const(i);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const bin_binning_tag& tag, const int& i)  const {
-    const int j     = range_begin + i ;
-    const int bin   = bin_op.bin(keys,j);
+  void operator()(const bin_binning_tag& tag, const int& i) const {
+    const int j     = range_begin + i;
+    const int bin   = bin_op.bin(keys, j);
     const int count = bin_count_atomic(bin)++;
 
-    sort_order(bin_offsets(bin) + count) = j ;
+    sort_order(bin_offsets(bin) + count) = j;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const bin_sort_bins_tag& tag, const int&i )  const {
+  void operator()(const bin_sort_bins_tag& tag, const int& i) const {
     auto bin_size = bin_count_const(i);
     if (bin_size <= 1) return;
-    int upper_bound = bin_offsets(i)+bin_size;
-    bool sorted = false;
-    while(!sorted) {
-      sorted = true;
+    int upper_bound = bin_offsets(i) + bin_size;
+    bool sorted     = false;
+    while (!sorted) {
+      sorted      = true;
       int old_idx = sort_order(bin_offsets(i));
       int new_idx;
-      for(int k=bin_offsets(i)+1; k<upper_bound; k++) {
+      for (int k = bin_offsets(i) + 1; k < upper_bound; k++) {
         new_idx = sort_order(k);
 
-        if(!bin_op(keys_rnd,old_idx,new_idx)) {
-          sort_order(k-1) = new_idx;
-          sort_order(k) = old_idx;
-          sorted = false;
+        if (!bin_op(keys_rnd, old_idx, new_idx)) {
+          sort_order(k - 1) = new_idx;
+          sort_order(k)     = old_idx;
+          sorted            = false;
         } else {
           old_idx = new_idx;
         }
@@ -403,44 +400,46 @@ public:
 
 //----------------------------------------------------------------------------
 
-template<class KeyViewType>
+template <class KeyViewType>
 struct BinOp1D {
   int max_bins_;
   double mul_;
   typename KeyViewType::const_value_type range_;
   typename KeyViewType::const_value_type min_;
 
-  BinOp1D():max_bins_(0),mul_(0.0),
-            range_(typename KeyViewType::const_value_type()),
-            min_(typename KeyViewType::const_value_type()) {}
+  BinOp1D()
+      : max_bins_(0),
+        mul_(0.0),
+        range_(typename KeyViewType::const_value_type()),
+        min_(typename KeyViewType::const_value_type()) {}
 
-  //Construct BinOp with number of bins, minimum value and maxuimum value
+  // Construct BinOp with number of bins, minimum value and maxuimum value
   BinOp1D(int max_bins__, typename KeyViewType::const_value_type min,
-                               typename KeyViewType::const_value_type max )
-     :max_bins_(max_bins__+1),mul_(1.0*max_bins__/(max-min)),range_(max-min),min_(min) {}
-
-  //Determine bin index from key value
-  template<class ViewType>
-  KOKKOS_INLINE_FUNCTION
-  int bin(ViewType& keys, const int& i) const {
-    return int(mul_*(keys(i)-min_));
+          typename KeyViewType::const_value_type max)
+      : max_bins_(max_bins__ + 1),
+        mul_(1.0 * max_bins__ / (max - min)),
+        range_(max - min),
+        min_(min) {}
+
+  // Determine bin index from key value
+  template <class ViewType>
+  KOKKOS_INLINE_FUNCTION int bin(ViewType& keys, const int& i) const {
+    return int(mul_ * (keys(i) - min_));
   }
 
-  //Return maximum bin index + 1
+  // Return maximum bin index + 1
   KOKKOS_INLINE_FUNCTION
-  int max_bins() const {
-    return max_bins_;
-  }
+  int max_bins() const { return max_bins_; }
 
-  //Compare to keys within a bin if true new_val will be put before old_val
-  template<class ViewType, typename iType1, typename iType2>
-  KOKKOS_INLINE_FUNCTION
-  bool operator()(ViewType& keys, iType1& i1, iType2& i2) const {
-    return keys(i1)<keys(i2);
+  // Compare to keys within a bin if true new_val will be put before old_val
+  template <class ViewType, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION bool operator()(ViewType& keys, iType1& i1,
+                                         iType2& i2) const {
+    return keys(i1) < keys(i2);
   }
 };
 
-template<class KeyViewType>
+template <class KeyViewType>
 struct BinOp3D {
   int max_bins_[3];
   double mul_[3];
@@ -450,43 +449,42 @@ struct BinOp3D {
   BinOp3D() {}
 
   BinOp3D(int max_bins__[], typename KeyViewType::const_value_type min[],
-                               typename KeyViewType::const_value_type max[] )
-  {
+          typename KeyViewType::const_value_type max[]) {
     max_bins_[0] = max_bins__[0];
     max_bins_[1] = max_bins__[1];
     max_bins_[2] = max_bins__[2];
-    mul_[0] = 1.0*max_bins__[0]/(max[0]-min[0]);
-    mul_[1] = 1.0*max_bins__[1]/(max[1]-min[1]);
-    mul_[2] = 1.0*max_bins__[2]/(max[2]-min[2]);
-    range_[0] = max[0]-min[0];
-    range_[1] = max[1]-min[1];
-    range_[2] = max[2]-min[2];
-    min_[0] = min[0];
-    min_[1] = min[1];
-    min_[2] = min[2];
+    mul_[0]      = 1.0 * max_bins__[0] / (max[0] - min[0]);
+    mul_[1]      = 1.0 * max_bins__[1] / (max[1] - min[1]);
+    mul_[2]      = 1.0 * max_bins__[2] / (max[2] - min[2]);
+    range_[0]    = max[0] - min[0];
+    range_[1]    = max[1] - min[1];
+    range_[2]    = max[2] - min[2];
+    min_[0]      = min[0];
+    min_[1]      = min[1];
+    min_[2]      = min[2];
   }
 
-  template<class ViewType>
-  KOKKOS_INLINE_FUNCTION
-  int bin(ViewType& keys, const int& i) const {
-    return int( (((int(mul_[0]*(keys(i,0)-min_[0]))*max_bins_[1]) +
-                   int(mul_[1]*(keys(i,1)-min_[1])))*max_bins_[2]) +
-                   int(mul_[2]*(keys(i,2)-min_[2])));
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  int max_bins() const {
-    return max_bins_[0]*max_bins_[1]*max_bins_[2];
+  template <class ViewType>
+  KOKKOS_INLINE_FUNCTION int bin(ViewType& keys, const int& i) const {
+    return int((((int(mul_[0] * (keys(i, 0) - min_[0])) * max_bins_[1]) +
+                 int(mul_[1] * (keys(i, 1) - min_[1]))) *
+                max_bins_[2]) +
+               int(mul_[2] * (keys(i, 2) - min_[2])));
   }
 
-  template<class ViewType, typename iType1, typename iType2>
   KOKKOS_INLINE_FUNCTION
-  bool operator()(ViewType& keys, iType1& i1 , iType2& i2) const {
-    if (keys(i1,0)>keys(i2,0)) return true;
-    else if (keys(i1,0)==keys(i2,0)) {
-      if (keys(i1,1)>keys(i2,1)) return true;
-      else if (keys(i1,1)==keys(i2,1)) {
-        if (keys(i1,2)>keys(i2,2)) return true;
+  int max_bins() const { return max_bins_[0] * max_bins_[1] * max_bins_[2]; }
+
+  template <class ViewType, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION bool operator()(ViewType& keys, iType1& i1,
+                                         iType2& i2) const {
+    if (keys(i1, 0) > keys(i2, 0))
+      return true;
+    else if (keys(i1, 0) == keys(i2, 0)) {
+      if (keys(i1, 1) > keys(i2, 1))
+        return true;
+      else if (keys(i1, 1) == keys(i2, 1)) {
+        if (keys(i1, 2) > keys(i2, 2)) return true;
       }
     }
     return false;
@@ -495,85 +493,80 @@ struct BinOp3D {
 
 namespace Impl {
 
-template<class ViewType>
+template <class ViewType>
 bool try_std_sort(ViewType view) {
-  bool possible = true;
-  size_t stride[8] = { view.stride_0()
-                     , view.stride_1()
-                     , view.stride_2()
-                     , view.stride_3()
-                     , view.stride_4()
-                     , view.stride_5()
-                     , view.stride_6()
-                     , view.stride_7()
-                     };
-  possible  = possible && std::is_same<typename ViewType::memory_space, HostSpace>::value;
-  possible  = possible && (ViewType::Rank == 1);
-  possible  = possible && (stride[0] == 1);
-  if(possible)  {
-   std::sort(view.data(),view.data()+view.extent(0));
+  bool possible    = true;
+  size_t stride[8] = {view.stride_0(), view.stride_1(), view.stride_2(),
+                      view.stride_3(), view.stride_4(), view.stride_5(),
+                      view.stride_6(), view.stride_7()};
+  possible         = possible &&
+             std::is_same<typename ViewType::memory_space, HostSpace>::value;
+  possible = possible && (ViewType::Rank == 1);
+  possible = possible && (stride[0] == 1);
+  if (possible) {
+    std::sort(view.data(), view.data() + view.extent(0));
   }
   return possible;
 }
 
-template<class ViewType>
+template <class ViewType>
 struct min_max_functor {
-  typedef Kokkos::MinMaxScalar<typename ViewType::non_const_value_type> minmax_scalar;
+  typedef Kokkos::MinMaxScalar<typename ViewType::non_const_value_type>
+      minmax_scalar;
 
   ViewType view;
-  min_max_functor(const ViewType& view_):view(view_) {}
+  min_max_functor(const ViewType& view_) : view(view_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const size_t& i, minmax_scalar& minmax) const {
-    if(view(i) < minmax.min_val) minmax.min_val = view(i);
-    if(view(i) > minmax.max_val) minmax.max_val = view(i);
+  void operator()(const size_t& i, minmax_scalar& minmax) const {
+    if (view(i) < minmax.min_val) minmax.min_val = view(i);
+    if (view(i) > minmax.max_val) minmax.max_val = view(i);
   }
 };
 
-}
+}  // namespace Impl
 
-template<class ViewType>
-void sort( ViewType const & view , bool const always_use_kokkos_sort = false)
-{
-  if(!always_use_kokkos_sort) {
-    if(Impl::try_std_sort(view)) return;
+template <class ViewType>
+void sort(ViewType const& view, bool const always_use_kokkos_sort = false) {
+  if (!always_use_kokkos_sort) {
+    if (Impl::try_std_sort(view)) return;
   }
   typedef BinOp1D<ViewType> CompType;
 
   Kokkos::MinMaxScalar<typename ViewType::non_const_value_type> result;
   Kokkos::MinMax<typename ViewType::non_const_value_type> reducer(result);
-  parallel_reduce("Kokkos::Sort::FindExtent",Kokkos::RangePolicy<typename ViewType::execution_space>(0,view.extent(0)),
-                  Impl::min_max_functor<ViewType>(view),reducer);
-  if(result.min_val == result.max_val) return;
-  BinSort<ViewType, CompType> bin_sort(view,CompType(view.extent(0)/2,result.min_val,result.max_val),true);
+  parallel_reduce("Kokkos::Sort::FindExtent",
+                  Kokkos::RangePolicy<typename ViewType::execution_space>(
+                      0, view.extent(0)),
+                  Impl::min_max_functor<ViewType>(view), reducer);
+  if (result.min_val == result.max_val) return;
+  BinSort<ViewType, CompType> bin_sort(
+      view, CompType(view.extent(0) / 2, result.min_val, result.max_val), true);
   bin_sort.create_permute_vector();
   bin_sort.sort(view);
 }
 
-template<class ViewType>
-void sort( ViewType view
-         , size_t const begin
-         , size_t const end
-         )
-{
-  typedef Kokkos::RangePolicy<typename ViewType::execution_space> range_policy ;
+template <class ViewType>
+void sort(ViewType view, size_t const begin, size_t const end) {
+  typedef Kokkos::RangePolicy<typename ViewType::execution_space> range_policy;
   typedef BinOp1D<ViewType> CompType;
 
   Kokkos::MinMaxScalar<typename ViewType::non_const_value_type> result;
   Kokkos::MinMax<typename ViewType::non_const_value_type> reducer(result);
 
-  parallel_reduce("Kokkos::Sort::FindExtent", range_policy( begin , end )
-                 , Impl::min_max_functor<ViewType>(view),reducer );
+  parallel_reduce("Kokkos::Sort::FindExtent", range_policy(begin, end),
+                  Impl::min_max_functor<ViewType>(view), reducer);
 
-  if(result.min_val == result.max_val) return;
+  if (result.min_val == result.max_val) return;
 
-  BinSort<ViewType, CompType>
-    bin_sort(view,begin,end,CompType((end-begin)/2,result.min_val,result.max_val),true);
+  BinSort<ViewType, CompType> bin_sort(
+      view, begin, end,
+      CompType((end - begin) / 2, result.min_val, result.max_val), true);
 
   bin_sort.create_permute_vector();
-  bin_sort.sort(view,begin,end);
+  bin_sort.sort(view, begin, end);
 }
 
-}
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/algorithms/unit_tests/CMakeLists.txt b/lib/kokkos/algorithms/unit_tests/CMakeLists.txt
index e238b37c8ec933aaec930d1896957e2739b97724..6fb08ce2edb8b8632969b00bd69fdb495ce73cf2 100644
--- a/lib/kokkos/algorithms/unit_tests/CMakeLists.txt
+++ b/lib/kokkos/algorithms/unit_tests/CMakeLists.txt
@@ -1,18 +1,12 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../src )
+#Leave these here for now - I don't need transitive deps anyway
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../src )
 
-IF(NOT KOKKOS_HAS_TRILINOS)
-  IF(KOKKOS_SEPARATE_LIBS)
-    set(TEST_LINK_TARGETS kokkoscore)
-  ELSE()
-    set(TEST_LINK_TARGETS kokkos)
-  ENDIF()
-ENDIF()
 
 SET(GTEST_SOURCE_DIR ${${PARENT_PACKAGE_NAME}_SOURCE_DIR}/tpls/gtest)
-INCLUDE_DIRECTORIES(${GTEST_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${GTEST_SOURCE_DIR})
 
 # mfh 03 Nov 2017: The gtest library used here must have a different
 # name than that of the gtest library built in KokkosCore.  We can't
@@ -20,23 +14,20 @@ INCLUDE_DIRECTORIES(${GTEST_SOURCE_DIR})
 # possible to build only (e.g.,) KokkosAlgorithms tests, without
 # building KokkosCore tests.
 
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGTEST_HAS_PTHREAD=0")
 
-TRIBITS_ADD_LIBRARY(
+KOKKOS_ADD_TEST_LIBRARY(
   kokkosalgorithms_gtest
   HEADERS ${GTEST_SOURCE_DIR}/gtest/gtest.h
   SOURCES ${GTEST_SOURCE_DIR}/gtest/gtest-all.cc
-  TESTONLY
-  )
+)
+KOKKOS_TARGET_COMPILE_DEFINITIONS(kokkosalgorithms_gtest PUBLIC "-DGTEST_HAS_PTHREAD=0")
 
 SET(SOURCES
   UnitTestMain.cpp 
   TestCuda.cpp
   )
 
-SET(LIBRARIES kokkoscore)
-
-IF(Kokkos_ENABLE_OpenMP)
+IF(Kokkos_ENABLE_OPENMP)
   LIST( APPEND SOURCES
     TestOpenMP.cpp
   )
@@ -48,23 +39,19 @@ IF(Kokkos_ENABLE_HPX)
   )
 ENDIF()
 
-IF(Kokkos_ENABLE_Serial)
+IF(Kokkos_ENABLE_SERIAL)
   LIST( APPEND SOURCES
     TestSerial.cpp
   )
 ENDIF()
 
-IF(Kokkos_ENABLE_Pthread)
+IF(Kokkos_ENABLE_PTHREAD)
   LIST( APPEND SOURCES
     TestThreads.cpp
   )
 ENDIF()
 
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
   UnitTest
   SOURCES ${SOURCES}
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  TESTONLYLIBS kokkosalgorithms_gtest ${TEST_LINK_TARGETS}
-  )
+)
diff --git a/lib/kokkos/algorithms/unit_tests/TestCuda.cpp b/lib/kokkos/algorithms/unit_tests/TestCuda.cpp
index 86fdccd0e784e8bc56472782a87a31a050f468fe..ab727b0326dd2d456845c39d5e8b5173a667d6bc 100644
--- a/lib/kokkos/algorithms/unit_tests/TestCuda.cpp
+++ b/lib/kokkos/algorithms/unit_tests/TestCuda.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,51 +58,31 @@
 
 namespace Test {
 
-class cuda : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-  }
-  static void TearDownTestCase()
-  {
-  }
-};
-
-void cuda_test_random_xorshift64( int num_draws  )
-{
+void cuda_test_random_xorshift64(int num_draws) {
   Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::Cuda> >(num_draws);
 }
 
-void cuda_test_random_xorshift1024( int num_draws  )
-{
+void cuda_test_random_xorshift1024(int num_draws) {
   Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::Cuda> >(num_draws);
 }
 
+#define CUDA_RANDOM_XORSHIFT64(num_draws) \
+  TEST(cuda, Random_XorShift64) { cuda_test_random_xorshift64(num_draws); }
 
-#define CUDA_RANDOM_XORSHIFT64( num_draws )                                \
-  TEST_F( cuda, Random_XorShift64 ) {   \
-  cuda_test_random_xorshift64(num_draws);                                   \
-  }
-
-#define CUDA_RANDOM_XORSHIFT1024( num_draws )                                \
-  TEST_F( cuda, Random_XorShift1024 ) {   \
-  cuda_test_random_xorshift1024(num_draws);                                   \
-  }
+#define CUDA_RANDOM_XORSHIFT1024(num_draws) \
+  TEST(cuda, Random_XorShift1024) { cuda_test_random_xorshift1024(num_draws); }
 
-#define CUDA_SORT_UNSIGNED( size )                                \
-  TEST_F( cuda, SortUnsigned ) {   \
-      Impl::test_sort< Kokkos::Cuda, unsigned >(size);                                   \
-  }
+#define CUDA_SORT_UNSIGNED(size) \
+  TEST(cuda, SortUnsigned) { Impl::test_sort<Kokkos::Cuda, unsigned>(size); }
 
-CUDA_RANDOM_XORSHIFT64(  132141141 )
-CUDA_RANDOM_XORSHIFT1024( 52428813 )
+CUDA_RANDOM_XORSHIFT64(132141141)
+CUDA_RANDOM_XORSHIFT1024(52428813)
 CUDA_SORT_UNSIGNED(171)
 
 #undef CUDA_RANDOM_XORSHIFT64
 #undef CUDA_RANDOM_XORSHIFT1024
 #undef CUDA_SORT_UNSIGNED
-}
+}  // namespace Test
 #else
 void KOKKOS_ALGORITHMS_UNITTESTS_TESTCUDA_PREVENT_LINK_ERROR() {}
-#endif  /* #ifdef KOKKOS_ENABLE_CUDA */
-
+#endif /* #ifdef KOKKOS_ENABLE_CUDA */
diff --git a/lib/kokkos/algorithms/unit_tests/TestHPX.cpp b/lib/kokkos/algorithms/unit_tests/TestHPX.cpp
index e5b7dbdb7a32c5cee98b33d1169bf5f49e71d1cb..2981e97945cb45065452a8f5330b0b35a9f4c65c 100644
--- a/lib/kokkos/algorithms/unit_tests/TestHPX.cpp
+++ b/lib/kokkos/algorithms/unit_tests/TestHPX.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,6 @@
 //@HEADER
 */
 
-
 #include <Kokkos_Macros.hpp>
 #ifdef KOKKOS_ENABLE_HPX
 
@@ -55,42 +55,33 @@
 
 namespace Test {
 
-class hpx : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-    std::cout << std::setprecision(5) << std::scientific;
-  }
-
-  static void TearDownTestCase()
-  {
+#define HPX_RANDOM_XORSHIFT64(num_draws)                             \
+  TEST(hpx, Random_XorShift64) {                                     \
+    Impl::test_random<                                               \
+        Kokkos::Random_XorShift64_Pool<Kokkos::Experimental::HPX> >( \
+        num_draws);                                                  \
   }
-};
 
-#define HPX_RANDOM_XORSHIFT64( num_draws )                                \
-  TEST_F( hpx, Random_XorShift64 ) {   \
-      Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::Experimental::HPX> >(num_draws); \
+#define HPX_RANDOM_XORSHIFT1024(num_draws)                             \
+  TEST(hpx, Random_XorShift1024) {                                     \
+    Impl::test_random<                                                 \
+        Kokkos::Random_XorShift1024_Pool<Kokkos::Experimental::HPX> >( \
+        num_draws);                                                    \
   }
 
-#define HPX_RANDOM_XORSHIFT1024( num_draws )                                \
-  TEST_F( hpx, Random_XorShift1024 ) {   \
-      Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::Experimental::HPX> >(num_draws); \
+#define HPX_SORT_UNSIGNED(size)                                 \
+  TEST(hpx, SortUnsigned) {                                     \
+    Impl::test_sort<Kokkos::Experimental::HPX, unsigned>(size); \
   }
 
-#define HPX_SORT_UNSIGNED( size )                                \
-  TEST_F( hpx, SortUnsigned ) {   \
-      Impl::test_sort< Kokkos::Experimental::HPX, unsigned >(size); \
-  }
-
-HPX_RANDOM_XORSHIFT64( 10240000 )
-HPX_RANDOM_XORSHIFT1024( 10130144 )
+HPX_RANDOM_XORSHIFT64(10240000)
+HPX_RANDOM_XORSHIFT1024(10130144)
 HPX_SORT_UNSIGNED(171)
 
 #undef HPX_RANDOM_XORSHIFT64
 #undef HPX_RANDOM_XORSHIFT1024
 #undef HPX_SORT_UNSIGNED
-} // namespace test
+}  // namespace Test
 #else
 void KOKKOS_ALGORITHMS_UNITTESTS_TESTHPX_PREVENT_LINK_ERROR() {}
 #endif
-
diff --git a/lib/kokkos/algorithms/unit_tests/TestOpenMP.cpp b/lib/kokkos/algorithms/unit_tests/TestOpenMP.cpp
index c4ddde7b7f71995bb25655cbbb5270b671db7f3e..3a9e306014b27a2c80b1c133b2f61873c2337325 100644
--- a/lib/kokkos/algorithms/unit_tests/TestOpenMP.cpp
+++ b/lib/kokkos/algorithms/unit_tests/TestOpenMP.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,6 @@
 //@HEADER
 */
 
-
 #include <Kokkos_Macros.hpp>
 #ifdef KOKKOS_ENABLE_OPENMP
 
@@ -55,42 +55,31 @@
 
 namespace Test {
 
-class openmp : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-    std::cout << std::setprecision(5) << std::scientific;
-  }
-
-  static void TearDownTestCase()
-  {
+#define OPENMP_RANDOM_XORSHIFT64(num_draws)                             \
+  TEST(openmp, Random_XorShift64) {                                     \
+    Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::OpenMP> >( \
+        num_draws);                                                     \
   }
-};
 
-#define OPENMP_RANDOM_XORSHIFT64( num_draws )                                \
-  TEST_F( openmp, Random_XorShift64 ) {   \
-      Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::OpenMP> >(num_draws);                                   \
+#define OPENMP_RANDOM_XORSHIFT1024(num_draws)                             \
+  TEST(openmp, Random_XorShift1024) {                                     \
+    Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::OpenMP> >( \
+        num_draws);                                                       \
   }
 
-#define OPENMP_RANDOM_XORSHIFT1024( num_draws )                                \
-  TEST_F( openmp, Random_XorShift1024 ) {   \
-      Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::OpenMP> >(num_draws);                                   \
+#define OPENMP_SORT_UNSIGNED(size)                   \
+  TEST(openmp, SortUnsigned) {                       \
+    Impl::test_sort<Kokkos::OpenMP, unsigned>(size); \
   }
 
-#define OPENMP_SORT_UNSIGNED( size )                                \
-  TEST_F( openmp, SortUnsigned ) {   \
-      Impl::test_sort< Kokkos::OpenMP, unsigned >(size);                                   \
-  }
-
-OPENMP_RANDOM_XORSHIFT64( 10240000 )
-OPENMP_RANDOM_XORSHIFT1024( 10130144 )
+OPENMP_RANDOM_XORSHIFT64(10240000)
+OPENMP_RANDOM_XORSHIFT1024(10130144)
 OPENMP_SORT_UNSIGNED(171)
 
 #undef OPENMP_RANDOM_XORSHIFT64
 #undef OPENMP_RANDOM_XORSHIFT1024
 #undef OPENMP_SORT_UNSIGNED
-} // namespace test
+}  // namespace Test
 #else
 void KOKKOS_ALGORITHMS_UNITTESTS_TESTOPENMP_PREVENT_LINK_ERROR() {}
 #endif
-
diff --git a/lib/kokkos/algorithms/unit_tests/TestROCm.cpp b/lib/kokkos/algorithms/unit_tests/TestROCm.cpp
index 15179509bbfc1fe1e193081c8387e237dfa2525c..29814cca3e6c9cc5512d83305e4a6810a781ac79 100644
--- a/lib/kokkos/algorithms/unit_tests/TestROCm.cpp
+++ b/lib/kokkos/algorithms/unit_tests/TestROCm.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,52 +58,35 @@
 
 namespace Test {
 
-class rocm : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-    std::cout << std::setprecision(5) << std::scientific;
-  }
-  static void TearDownTestCase()
-  {
-  }
-};
-
-void rocm_test_random_xorshift64( int num_draws  )
-{
-  Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::Experimental::ROCm> >(num_draws);
+void rocm_test_random_xorshift64(int num_draws) {
+  Impl::test_random<
+      Kokkos::Random_XorShift64_Pool<Kokkos::Experimental::ROCm> >(num_draws);
 }
 
-void rocm_test_random_xorshift1024( int num_draws  )
-{
-  Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::Experimental::ROCm> >(num_draws);
+void rocm_test_random_xorshift1024(int num_draws) {
+  Impl::test_random<
+      Kokkos::Random_XorShift1024_Pool<Kokkos::Experimental::ROCm> >(num_draws);
 }
 
+#define ROCM_RANDOM_XORSHIFT64(num_draws) \
+  TEST(rocm, Random_XorShift64) { rocm_test_random_xorshift64(num_draws); }
 
-#define ROCM_RANDOM_XORSHIFT64( num_draws )  \
-  TEST_F( rocm, Random_XorShift64 ) {        \
-  rocm_test_random_xorshift64(num_draws);    \
-  }
-
-#define ROCM_RANDOM_XORSHIFT1024( num_draws )  \
-  TEST_F( rocm, Random_XorShift1024 ) {        \
-  rocm_test_random_xorshift1024(num_draws);    \
-  }
+#define ROCM_RANDOM_XORSHIFT1024(num_draws) \
+  TEST(rocm, Random_XorShift1024) { rocm_test_random_xorshift1024(num_draws); }
 
-#define ROCM_SORT_UNSIGNED( size )                                    \
-  TEST_F( rocm, SortUnsigned ) {                                      \
-      Impl::test_sort< Kokkos::Experimental::ROCm, unsigned >(size);  \
+#define ROCM_SORT_UNSIGNED(size)                                 \
+  TEST(rocm, SortUnsigned) {                                     \
+    Impl::test_sort<Kokkos::Experimental::ROCm, unsigned>(size); \
   }
 
-ROCM_RANDOM_XORSHIFT64(  132141141 )
-ROCM_RANDOM_XORSHIFT1024( 52428813 )
+ROCM_RANDOM_XORSHIFT64(132141141)
+ROCM_RANDOM_XORSHIFT1024(52428813)
 ROCM_SORT_UNSIGNED(171)
 
 #undef ROCM_RANDOM_XORSHIFT64
 #undef ROCM_RANDOM_XORSHIFT1024
 #undef ROCM_SORT_UNSIGNED
-}
+}  // namespace Test
 #else
 void KOKKOS_ALGORITHMS_UNITTESTS_TESTROCM_PREVENT_LINK_ERROR() {}
-#endif  /* #ifdef KOKKOS_ENABLE_ROCM */
-
+#endif /* #ifdef KOKKOS_ENABLE_ROCM */
diff --git a/lib/kokkos/algorithms/unit_tests/TestRandom.hpp b/lib/kokkos/algorithms/unit_tests/TestRandom.hpp
index 73bd416f2aba49e311884096c31db295b41f1066..bc55ebfad355bff785ad92d115ac45cff698482f 100644
--- a/lib/kokkos/algorithms/unit_tests/TestRandom.hpp
+++ b/lib/kokkos/algorithms/unit_tests/TestRandom.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -54,18 +55,19 @@
 
 namespace Test {
 
-namespace Impl{
+namespace Impl {
 
 // This test runs the random number generators and uses some statistic tests to
 // check the 'goodness' of the random numbers:
 //    (i)   mean:         the mean is expected to be 0.5*RAND_MAX
 //    (ii)  variance:     the variance is 1/3*mean*mean
 //    (iii) covariance:   the covariance is 0
-//    (iv)  1-tupledistr: the mean, variance and covariance of a 1D Histrogram of random numbers
-//    (v)   3-tupledistr: the mean, variance and covariance of a 3D Histrogram of random numbers
+//    (iv)  1-tupledistr: the mean, variance and covariance of a 1D Histrogram
+//    of random numbers (v)   3-tupledistr: the mean, variance and covariance of
+//    a 3D Histrogram of random numbers
 
 #define HIST_DIM3D 24
-#define HIST_DIM1D (HIST_DIM3D*HIST_DIM3D*HIST_DIM3D)
+#define HIST_DIM1D (HIST_DIM3D * HIST_DIM3D * HIST_DIM3D)
 
 struct RandomProperties {
   uint64_t count;
@@ -77,37 +79,37 @@ struct RandomProperties {
 
   KOKKOS_INLINE_FUNCTION
   RandomProperties() {
-    count = 0;
-    mean = 0.0;
-    variance = 0.0;
+    count      = 0;
+    mean       = 0.0;
+    variance   = 0.0;
     covariance = 0.0;
-    min = 1e64;
-    max = -1e64;
+    min        = 1e64;
+    max        = -1e64;
   }
 
   KOKKOS_INLINE_FUNCTION
   RandomProperties& operator+=(const RandomProperties& add) {
-    count      += add.count;
-    mean       += add.mean;
-    variance   += add.variance;
+    count += add.count;
+    mean += add.mean;
+    variance += add.variance;
     covariance += add.covariance;
-    min         = add.min<min?add.min:min;
-    max         = add.max>max?add.max:max;
+    min = add.min < min ? add.min : min;
+    max = add.max > max ? add.max : max;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
   void operator+=(const volatile RandomProperties& add) volatile {
-    count      += add.count;
-    mean       += add.mean;
-    variance   += add.variance;
+    count += add.count;
+    mean += add.mean;
+    variance += add.variance;
     covariance += add.covariance;
-    min         = add.min<min?add.min:min;
-    max         = add.max>max?add.max:max;
+    min = add.min < min ? add.min : min;
+    max = add.max > max ? add.max : max;
   }
 };
 
-template<class GeneratorPool, class Scalar>
+template <class GeneratorPool, class Scalar>
 struct test_random_functor {
   typedef typename GeneratorPool::generator_type rnd_type;
 
@@ -123,38 +125,40 @@ struct test_random_functor {
   // implementations might violate this upper bound, due to rounding
   // error.  Just in case, we leave an extra space at the end of each
   // dimension, in the View types below.
-  typedef Kokkos::View<int[HIST_DIM1D+1],typename GeneratorPool::device_type> type_1d;
+  typedef Kokkos::View<int[HIST_DIM1D + 1], typename GeneratorPool::device_type>
+      type_1d;
   type_1d density_1d;
-  typedef Kokkos::View<int[HIST_DIM3D+1][HIST_DIM3D+1][HIST_DIM3D+1],typename GeneratorPool::device_type> type_3d;
+  typedef Kokkos::View<int[HIST_DIM3D + 1][HIST_DIM3D + 1][HIST_DIM3D + 1],
+                       typename GeneratorPool::device_type>
+      type_3d;
   type_3d density_3d;
 
-  test_random_functor (GeneratorPool rand_pool_, type_1d d1d, type_3d d3d) :
-    rand_pool (rand_pool_),
-    mean (0.5*Kokkos::rand<rnd_type,Scalar>::max ()),
-    density_1d (d1d),
-    density_3d (d3d)
-  {}
+  test_random_functor(GeneratorPool rand_pool_, type_1d d1d, type_3d d3d)
+      : rand_pool(rand_pool_),
+        mean(0.5 * Kokkos::rand<rnd_type, Scalar>::max()),
+        density_1d(d1d),
+        density_3d(d3d) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i, RandomProperties& prop) const {
+  void operator()(int i, RandomProperties& prop) const {
     using Kokkos::atomic_fetch_add;
 
     rnd_type rand_gen = rand_pool.get_state();
     for (int k = 0; k < 1024; ++k) {
-      const Scalar tmp = Kokkos::rand<rnd_type,Scalar>::draw(rand_gen);
+      const Scalar tmp = Kokkos::rand<rnd_type, Scalar>::draw(rand_gen);
       prop.count++;
       prop.mean += tmp;
-      prop.variance += (tmp-mean)*(tmp-mean);
-      const Scalar tmp2 = Kokkos::rand<rnd_type,Scalar>::draw(rand_gen);
+      prop.variance += (tmp - mean) * (tmp - mean);
+      const Scalar tmp2 = Kokkos::rand<rnd_type, Scalar>::draw(rand_gen);
       prop.count++;
       prop.mean += tmp2;
-      prop.variance += (tmp2-mean)*(tmp2-mean);
-      prop.covariance += (tmp-mean)*(tmp2-mean);
-      const Scalar tmp3 = Kokkos::rand<rnd_type,Scalar>::draw(rand_gen);
+      prop.variance += (tmp2 - mean) * (tmp2 - mean);
+      prop.covariance += (tmp - mean) * (tmp2 - mean);
+      const Scalar tmp3 = Kokkos::rand<rnd_type, Scalar>::draw(rand_gen);
       prop.count++;
       prop.mean += tmp3;
-      prop.variance += (tmp3-mean)*(tmp3-mean);
-      prop.covariance += (tmp2-mean)*(tmp3-mean);
+      prop.variance += (tmp3 - mean) * (tmp3 - mean);
+      prop.covariance += (tmp2 - mean) * (tmp3 - mean);
 
       // NOTE (mfh 03 Nov 2014): Kokkos::rand::max() is supposed to
       // define an exclusive upper bound on the range of random
@@ -169,26 +173,32 @@ struct test_random_functor {
       // returns values of max(), the histograms will still catch this
       // indirectly, since none of the other values will be filled in.
 
-      const Scalar theMax = Kokkos::rand<rnd_type, Scalar>::max ();
-
-      const uint64_t ind1_1d = static_cast<uint64_t> (1.0 * HIST_DIM1D * tmp / theMax);
-      const uint64_t ind2_1d = static_cast<uint64_t> (1.0 * HIST_DIM1D * tmp2 / theMax);
-      const uint64_t ind3_1d = static_cast<uint64_t> (1.0 * HIST_DIM1D * tmp3 / theMax);
-
-      const uint64_t ind1_3d = static_cast<uint64_t> (1.0 * HIST_DIM3D * tmp / theMax);
-      const uint64_t ind2_3d = static_cast<uint64_t> (1.0 * HIST_DIM3D * tmp2 / theMax);
-      const uint64_t ind3_3d = static_cast<uint64_t> (1.0 * HIST_DIM3D * tmp3 / theMax);
-
-      atomic_fetch_add (&density_1d(ind1_1d), 1);
-      atomic_fetch_add (&density_1d(ind2_1d), 1);
-      atomic_fetch_add (&density_1d(ind3_1d), 1);
-      atomic_fetch_add (&density_3d(ind1_3d, ind2_3d, ind3_3d), 1);
+      const Scalar theMax = Kokkos::rand<rnd_type, Scalar>::max();
+
+      const uint64_t ind1_1d =
+          static_cast<uint64_t>(1.0 * HIST_DIM1D * tmp / theMax);
+      const uint64_t ind2_1d =
+          static_cast<uint64_t>(1.0 * HIST_DIM1D * tmp2 / theMax);
+      const uint64_t ind3_1d =
+          static_cast<uint64_t>(1.0 * HIST_DIM1D * tmp3 / theMax);
+
+      const uint64_t ind1_3d =
+          static_cast<uint64_t>(1.0 * HIST_DIM3D * tmp / theMax);
+      const uint64_t ind2_3d =
+          static_cast<uint64_t>(1.0 * HIST_DIM3D * tmp2 / theMax);
+      const uint64_t ind3_3d =
+          static_cast<uint64_t>(1.0 * HIST_DIM3D * tmp3 / theMax);
+
+      atomic_fetch_add(&density_1d(ind1_1d), 1);
+      atomic_fetch_add(&density_1d(ind2_1d), 1);
+      atomic_fetch_add(&density_1d(ind3_1d), 1);
+      atomic_fetch_add(&density_3d(ind1_3d, ind2_3d, ind3_3d), 1);
     }
     rand_pool.free_state(rand_gen);
   }
 };
 
-template<class DeviceType>
+template <class DeviceType>
 struct test_histogram1d_functor {
   typedef RandomProperties value_type;
   typedef typename DeviceType::execution_space execution_space;
@@ -200,34 +210,29 @@ struct test_histogram1d_functor {
   // implementations might violate this upper bound, due to rounding
   // error.  Just in case, we leave an extra space at the end of each
   // dimension, in the View type below.
-  typedef Kokkos::View<int[HIST_DIM1D+1], memory_space> type_1d;
+  typedef Kokkos::View<int[HIST_DIM1D + 1], memory_space> type_1d;
   type_1d density_1d;
   double mean;
 
-  test_histogram1d_functor (type_1d d1d, int num_draws) :
-    density_1d (d1d),
-    mean (1.0*num_draws/HIST_DIM1D*3)
-  {
-  }
+  test_histogram1d_functor(type_1d d1d, int num_draws)
+      : density_1d(d1d), mean(1.0 * num_draws / HIST_DIM1D * 3) {}
 
-  KOKKOS_INLINE_FUNCTION void
-  operator() (const typename memory_space::size_type i,
-              RandomProperties& prop) const
-  {
+  KOKKOS_INLINE_FUNCTION void operator()(
+      const typename memory_space::size_type i, RandomProperties& prop) const {
     typedef typename memory_space::size_type size_type;
     const double count = density_1d(i);
     prop.mean += count;
     prop.variance += 1.0 * (count - mean) * (count - mean);
-    //prop.covariance += 1.0*count*count;
+    // prop.covariance += 1.0*count*count;
     prop.min = count < prop.min ? count : prop.min;
     prop.max = count > prop.max ? count : prop.max;
-    if (i < static_cast<size_type> (HIST_DIM1D-1)) {
-      prop.covariance += (count - mean) * (density_1d(i+1) - mean);
+    if (i < static_cast<size_type>(HIST_DIM1D - 1)) {
+      prop.covariance += (count - mean) * (density_1d(i + 1) - mean);
     }
   }
 };
 
-template<class DeviceType>
+template <class DeviceType>
 struct test_histogram3d_functor {
   typedef RandomProperties value_type;
   typedef typename DeviceType::execution_space execution_space;
@@ -239,29 +244,28 @@ struct test_histogram3d_functor {
   // implementations might violate this upper bound, due to rounding
   // error.  Just in case, we leave an extra space at the end of each
   // dimension, in the View type below.
-  typedef Kokkos::View<int[HIST_DIM3D+1][HIST_DIM3D+1][HIST_DIM3D+1], memory_space> type_3d;
+  typedef Kokkos::View<int[HIST_DIM3D + 1][HIST_DIM3D + 1][HIST_DIM3D + 1],
+                       memory_space>
+      type_3d;
   type_3d density_3d;
   double mean;
 
-  test_histogram3d_functor (type_3d d3d, int num_draws) :
-    density_3d (d3d),
-    mean (1.0*num_draws/HIST_DIM1D)
-  {}
+  test_histogram3d_functor(type_3d d3d, int num_draws)
+      : density_3d(d3d), mean(1.0 * num_draws / HIST_DIM1D) {}
 
-  KOKKOS_INLINE_FUNCTION void
-  operator() (const typename memory_space::size_type i,
-              RandomProperties& prop) const
-  {
+  KOKKOS_INLINE_FUNCTION void operator()(
+      const typename memory_space::size_type i, RandomProperties& prop) const {
     typedef typename memory_space::size_type size_type;
-    const double count = density_3d(i/(HIST_DIM3D*HIST_DIM3D),
-                                    (i % (HIST_DIM3D*HIST_DIM3D))/HIST_DIM3D,
-                                    i % HIST_DIM3D);
+    const double count = density_3d(
+        i / (HIST_DIM3D * HIST_DIM3D),
+        (i % (HIST_DIM3D * HIST_DIM3D)) / HIST_DIM3D, i % HIST_DIM3D);
     prop.mean += count;
     prop.variance += (count - mean) * (count - mean);
-    if (i < static_cast<size_type> (HIST_DIM1D-1)) {
-      const double count_next = density_3d((i+1)/(HIST_DIM3D*HIST_DIM3D),
-                                           ((i+1)%(HIST_DIM3D*HIST_DIM3D))/HIST_DIM3D,
-                                           (i+1)%HIST_DIM3D);
+    if (i < static_cast<size_type>(HIST_DIM1D - 1)) {
+      const double count_next =
+          density_3d((i + 1) / (HIST_DIM3D * HIST_DIM3D),
+                     ((i + 1) % (HIST_DIM3D * HIST_DIM3D)) / HIST_DIM3D,
+                     (i + 1) % HIST_DIM3D);
       prop.covariance += (count - mean) * (count_next - mean);
     }
   }
@@ -270,212 +274,223 @@ struct test_histogram3d_functor {
 //
 // Templated test that uses the above functors.
 //
-template <class RandomGenerator,class Scalar>
+template <class RandomGenerator, class Scalar>
 struct test_random_scalar {
   typedef typename RandomGenerator::generator_type rnd_type;
 
-  int pass_mean,pass_var,pass_covar;
-  int pass_hist1d_mean,pass_hist1d_var,pass_hist1d_covar;
-  int pass_hist3d_mean,pass_hist3d_var,pass_hist3d_covar;
+  int pass_mean, pass_var, pass_covar;
+  int pass_hist1d_mean, pass_hist1d_var, pass_hist1d_covar;
+  int pass_hist3d_mean, pass_hist3d_var, pass_hist3d_covar;
 
-  test_random_scalar (typename test_random_functor<RandomGenerator,int>::type_1d& density_1d,
-                      typename test_random_functor<RandomGenerator,int>::type_3d& density_3d,
-                      RandomGenerator& pool,
-                      unsigned int num_draws)
-  {
+  test_random_scalar(
+      typename test_random_functor<RandomGenerator, int>::type_1d& density_1d,
+      typename test_random_functor<RandomGenerator, int>::type_3d& density_3d,
+      RandomGenerator& pool, unsigned int num_draws) {
+    using Kokkos::parallel_reduce;
     using std::cout;
     using std::endl;
-    using Kokkos::parallel_reduce;
 
     {
       cout << " -- Testing randomness properties" << endl;
 
       RandomProperties result;
       typedef test_random_functor<RandomGenerator, Scalar> functor_type;
-      parallel_reduce (num_draws/1024, functor_type (pool, density_1d, density_3d), result);
-
-      //printf("Result: %lf %lf %lf\n",result.mean/num_draws/3,result.variance/num_draws/3,result.covariance/num_draws/2);
-      double tolerance = 1.6*std::sqrt(1.0/num_draws);
-      double mean_expect = 0.5*Kokkos::rand<rnd_type,Scalar>::max();
-      double variance_expect = 1.0/3.0*mean_expect*mean_expect;
-      double mean_eps = mean_expect/(result.mean/num_draws/3)-1.0;
-      double variance_eps = variance_expect/(result.variance/num_draws/3)-1.0;
-      double covariance_eps = result.covariance/num_draws/2/variance_expect;
-      pass_mean  = ((-tolerance < mean_eps) &&
-                    ( tolerance > mean_eps)) ? 1:0;
-      pass_var   = ((-1.5*tolerance < variance_eps) &&
-                    ( 1.5*tolerance > variance_eps)) ? 1:0;
-      pass_covar = ((-2.0*tolerance < covariance_eps) &&
-                    ( 2.0*tolerance > covariance_eps)) ? 1:0;
-      cout << "Pass: " << pass_mean
-           << " " << pass_var
-           << " " << mean_eps
-           << " " << variance_eps
-           << " " << covariance_eps
-           << " || " << tolerance << endl;
+      parallel_reduce(num_draws / 1024,
+                      functor_type(pool, density_1d, density_3d), result);
+
+      // printf("Result: %lf %lf
+      // %lf\n",result.mean/num_draws/3,result.variance/num_draws/3,result.covariance/num_draws/2);
+      double tolerance       = 1.6 * std::sqrt(1.0 / num_draws);
+      double mean_expect     = 0.5 * Kokkos::rand<rnd_type, Scalar>::max();
+      double variance_expect = 1.0 / 3.0 * mean_expect * mean_expect;
+      double mean_eps = mean_expect / (result.mean / num_draws / 3) - 1.0;
+      double variance_eps =
+          variance_expect / (result.variance / num_draws / 3) - 1.0;
+      double covariance_eps =
+          result.covariance / num_draws / 2 / variance_expect;
+      pass_mean = ((-tolerance < mean_eps) && (tolerance > mean_eps)) ? 1 : 0;
+      pass_var  = ((-1.5 * tolerance < variance_eps) &&
+                  (1.5 * tolerance > variance_eps))
+                     ? 1
+                     : 0;
+      pass_covar = ((-2.0 * tolerance < covariance_eps) &&
+                    (2.0 * tolerance > covariance_eps))
+                       ? 1
+                       : 0;
+      cout << "Pass: " << pass_mean << " " << pass_var << " " << mean_eps << " "
+           << variance_eps << " " << covariance_eps << " || " << tolerance
+           << endl;
     }
     {
       cout << " -- Testing 1-D histogram" << endl;
 
       RandomProperties result;
-      typedef test_histogram1d_functor<typename RandomGenerator::device_type> functor_type;
-      parallel_reduce (HIST_DIM1D, functor_type (density_1d, num_draws), result);
-
-      double tolerance = 6*std::sqrt(1.0/HIST_DIM1D);
-      double mean_expect = 1.0*num_draws*3/HIST_DIM1D;
-      double variance_expect = 1.0*num_draws*3/HIST_DIM1D*(1.0-1.0/HIST_DIM1D);
-      double covariance_expect = -1.0*num_draws*3/HIST_DIM1D/HIST_DIM1D;
-      double mean_eps = mean_expect/(result.mean/HIST_DIM1D)-1.0;
-      double variance_eps = variance_expect/(result.variance/HIST_DIM1D)-1.0;
-      double covariance_eps = (result.covariance/HIST_DIM1D - covariance_expect)/mean_expect;
-      pass_hist1d_mean  = ((-0.0001 < mean_eps) &&
-                           ( 0.0001 > mean_eps)) ? 1:0;
-      pass_hist1d_var   = ((-0.07 < variance_eps) &&
-                           ( 0.07 > variance_eps)) ? 1:0;
-      pass_hist1d_covar = ((-0.06 < covariance_eps) &&
-                           ( 0.06 > covariance_eps)) ? 1:0;
-
-      cout << "Density 1D: " << mean_eps
-           << " " << variance_eps
-           << " " << (result.covariance/HIST_DIM1D/HIST_DIM1D)
-           << " || " << tolerance
-           << " " << result.min
-           << " " << result.max
-           << " || " << result.variance/HIST_DIM1D
-           << " " << 1.0*num_draws*3/HIST_DIM1D*(1.0-1.0/HIST_DIM1D)
-           << " || " << result.covariance/HIST_DIM1D
-           << " " << -1.0*num_draws*3/HIST_DIM1D/HIST_DIM1D
-           << endl;
+      typedef test_histogram1d_functor<typename RandomGenerator::device_type>
+          functor_type;
+      parallel_reduce(HIST_DIM1D, functor_type(density_1d, num_draws), result);
+
+      double tolerance   = 6 * std::sqrt(1.0 / HIST_DIM1D);
+      double mean_expect = 1.0 * num_draws * 3 / HIST_DIM1D;
+      double variance_expect =
+          1.0 * num_draws * 3 / HIST_DIM1D * (1.0 - 1.0 / HIST_DIM1D);
+      double covariance_expect = -1.0 * num_draws * 3 / HIST_DIM1D / HIST_DIM1D;
+      double mean_eps          = mean_expect / (result.mean / HIST_DIM1D) - 1.0;
+      double variance_eps =
+          variance_expect / (result.variance / HIST_DIM1D) - 1.0;
+      double covariance_eps =
+          (result.covariance / HIST_DIM1D - covariance_expect) / mean_expect;
+      pass_hist1d_mean = ((-0.0001 < mean_eps) && (0.0001 > mean_eps)) ? 1 : 0;
+      pass_hist1d_var =
+          ((-0.07 < variance_eps) && (0.07 > variance_eps)) ? 1 : 0;
+      pass_hist1d_covar =
+          ((-0.06 < covariance_eps) && (0.06 > covariance_eps)) ? 1 : 0;
+
+      cout << "Density 1D: " << mean_eps << " " << variance_eps << " "
+           << (result.covariance / HIST_DIM1D / HIST_DIM1D) << " || "
+           << tolerance << " " << result.min << " " << result.max << " || "
+           << result.variance / HIST_DIM1D << " "
+           << 1.0 * num_draws * 3 / HIST_DIM1D * (1.0 - 1.0 / HIST_DIM1D)
+           << " || " << result.covariance / HIST_DIM1D << " "
+           << -1.0 * num_draws * 3 / HIST_DIM1D / HIST_DIM1D << endl;
     }
     {
       cout << " -- Testing 3-D histogram" << endl;
 
       RandomProperties result;
-      typedef test_histogram3d_functor<typename RandomGenerator::device_type> functor_type;
-      parallel_reduce (HIST_DIM1D, functor_type (density_3d, num_draws), result);
-
-      double tolerance = 6*std::sqrt(1.0/HIST_DIM1D);
-      double mean_expect = 1.0*num_draws/HIST_DIM1D;
-      double variance_expect = 1.0*num_draws/HIST_DIM1D*(1.0-1.0/HIST_DIM1D);
-      double covariance_expect = -1.0*num_draws/HIST_DIM1D/HIST_DIM1D;
-      double mean_eps = mean_expect/(result.mean/HIST_DIM1D)-1.0;
-      double variance_eps = variance_expect/(result.variance/HIST_DIM1D)-1.0;
-      double covariance_eps = (result.covariance/HIST_DIM1D - covariance_expect)/mean_expect;
-      pass_hist3d_mean  = ((-tolerance < mean_eps) &&
-                           ( tolerance > mean_eps)) ? 1:0;
-      pass_hist3d_var   = ((-1.2*tolerance < variance_eps) &&
-                           ( 1.2*tolerance > variance_eps)) ? 1:0;
-      pass_hist3d_covar = ((-tolerance < covariance_eps) &&
-                           ( tolerance > covariance_eps)) ? 1:0;
-
-      cout << "Density 3D: " << mean_eps
-           << " " << variance_eps
-           << " " << result.covariance/HIST_DIM1D/HIST_DIM1D
-           << " || " << tolerance
-           << " " << result.min
-           << " " << result.max << endl;
+      typedef test_histogram3d_functor<typename RandomGenerator::device_type>
+          functor_type;
+      parallel_reduce(HIST_DIM1D, functor_type(density_3d, num_draws), result);
+
+      double tolerance   = 6 * std::sqrt(1.0 / HIST_DIM1D);
+      double mean_expect = 1.0 * num_draws / HIST_DIM1D;
+      double variance_expect =
+          1.0 * num_draws / HIST_DIM1D * (1.0 - 1.0 / HIST_DIM1D);
+      double covariance_expect = -1.0 * num_draws / HIST_DIM1D / HIST_DIM1D;
+      double mean_eps          = mean_expect / (result.mean / HIST_DIM1D) - 1.0;
+      double variance_eps =
+          variance_expect / (result.variance / HIST_DIM1D) - 1.0;
+      double covariance_eps =
+          (result.covariance / HIST_DIM1D - covariance_expect) / mean_expect;
+      pass_hist3d_mean =
+          ((-tolerance < mean_eps) && (tolerance > mean_eps)) ? 1 : 0;
+      pass_hist3d_var = ((-1.2 * tolerance < variance_eps) &&
+                         (1.2 * tolerance > variance_eps))
+                            ? 1
+                            : 0;
+      pass_hist3d_covar =
+          ((-tolerance < covariance_eps) && (tolerance > covariance_eps)) ? 1
+                                                                          : 0;
+
+      cout << "Density 3D: " << mean_eps << " " << variance_eps << " "
+           << result.covariance / HIST_DIM1D / HIST_DIM1D << " || " << tolerance
+           << " " << result.min << " " << result.max << endl;
     }
   }
 };
 
 template <class RandomGenerator>
-void test_random(unsigned int num_draws)
-{
+void test_random(unsigned int num_draws) {
   using std::cout;
   using std::endl;
-  typename test_random_functor<RandomGenerator,int>::type_1d density_1d("D1d");
-  typename test_random_functor<RandomGenerator,int>::type_3d density_3d("D3d");
+  typename test_random_functor<RandomGenerator, int>::type_1d density_1d("D1d");
+  typename test_random_functor<RandomGenerator, int>::type_3d density_3d("D3d");
 
-
-  uint64_t ticks = std::chrono::high_resolution_clock::now().time_since_epoch().count();
+  uint64_t ticks =
+      std::chrono::high_resolution_clock::now().time_since_epoch().count();
   cout << "Test Seed:" << ticks << endl;
 
   RandomGenerator pool(ticks);
 
   cout << "Test Scalar=int" << endl;
-  test_random_scalar<RandomGenerator,int> test_int(density_1d,density_3d,pool,num_draws);
-  ASSERT_EQ( test_int.pass_mean,1);
-  ASSERT_EQ( test_int.pass_var,1);
-  ASSERT_EQ( test_int.pass_covar,1);
-  ASSERT_EQ( test_int.pass_hist1d_mean,1);
-  ASSERT_EQ( test_int.pass_hist1d_var,1);
-  ASSERT_EQ( test_int.pass_hist1d_covar,1);
-  ASSERT_EQ( test_int.pass_hist3d_mean,1);
-  ASSERT_EQ( test_int.pass_hist3d_var,1);
-  ASSERT_EQ( test_int.pass_hist3d_covar,1);
-  deep_copy(density_1d,0);
-  deep_copy(density_3d,0);
+  test_random_scalar<RandomGenerator, int> test_int(density_1d, density_3d,
+                                                    pool, num_draws);
+  ASSERT_EQ(test_int.pass_mean, 1);
+  ASSERT_EQ(test_int.pass_var, 1);
+  ASSERT_EQ(test_int.pass_covar, 1);
+  ASSERT_EQ(test_int.pass_hist1d_mean, 1);
+  ASSERT_EQ(test_int.pass_hist1d_var, 1);
+  ASSERT_EQ(test_int.pass_hist1d_covar, 1);
+  ASSERT_EQ(test_int.pass_hist3d_mean, 1);
+  ASSERT_EQ(test_int.pass_hist3d_var, 1);
+  ASSERT_EQ(test_int.pass_hist3d_covar, 1);
+  deep_copy(density_1d, 0);
+  deep_copy(density_3d, 0);
 
   cout << "Test Scalar=unsigned int" << endl;
-  test_random_scalar<RandomGenerator,unsigned int> test_uint(density_1d,density_3d,pool,num_draws);
-  ASSERT_EQ( test_uint.pass_mean,1);
-  ASSERT_EQ( test_uint.pass_var,1);
-  ASSERT_EQ( test_uint.pass_covar,1);
-  ASSERT_EQ( test_uint.pass_hist1d_mean,1);
-  ASSERT_EQ( test_uint.pass_hist1d_var,1);
-  ASSERT_EQ( test_uint.pass_hist1d_covar,1);
-  ASSERT_EQ( test_uint.pass_hist3d_mean,1);
-  ASSERT_EQ( test_uint.pass_hist3d_var,1);
-  ASSERT_EQ( test_uint.pass_hist3d_covar,1);
-  deep_copy(density_1d,0);
-  deep_copy(density_3d,0);
+  test_random_scalar<RandomGenerator, unsigned int> test_uint(
+      density_1d, density_3d, pool, num_draws);
+  ASSERT_EQ(test_uint.pass_mean, 1);
+  ASSERT_EQ(test_uint.pass_var, 1);
+  ASSERT_EQ(test_uint.pass_covar, 1);
+  ASSERT_EQ(test_uint.pass_hist1d_mean, 1);
+  ASSERT_EQ(test_uint.pass_hist1d_var, 1);
+  ASSERT_EQ(test_uint.pass_hist1d_covar, 1);
+  ASSERT_EQ(test_uint.pass_hist3d_mean, 1);
+  ASSERT_EQ(test_uint.pass_hist3d_var, 1);
+  ASSERT_EQ(test_uint.pass_hist3d_covar, 1);
+  deep_copy(density_1d, 0);
+  deep_copy(density_3d, 0);
 
   cout << "Test Scalar=int64_t" << endl;
-  test_random_scalar<RandomGenerator,int64_t> test_int64(density_1d,density_3d,pool,num_draws);
-  ASSERT_EQ( test_int64.pass_mean,1);
-  ASSERT_EQ( test_int64.pass_var,1);
-  ASSERT_EQ( test_int64.pass_covar,1);
-  ASSERT_EQ( test_int64.pass_hist1d_mean,1);
-  ASSERT_EQ( test_int64.pass_hist1d_var,1);
-  ASSERT_EQ( test_int64.pass_hist1d_covar,1);
-  ASSERT_EQ( test_int64.pass_hist3d_mean,1);
-  ASSERT_EQ( test_int64.pass_hist3d_var,1);
-  ASSERT_EQ( test_int64.pass_hist3d_covar,1);
-  deep_copy(density_1d,0);
-  deep_copy(density_3d,0);
+  test_random_scalar<RandomGenerator, int64_t> test_int64(
+      density_1d, density_3d, pool, num_draws);
+  ASSERT_EQ(test_int64.pass_mean, 1);
+  ASSERT_EQ(test_int64.pass_var, 1);
+  ASSERT_EQ(test_int64.pass_covar, 1);
+  ASSERT_EQ(test_int64.pass_hist1d_mean, 1);
+  ASSERT_EQ(test_int64.pass_hist1d_var, 1);
+  ASSERT_EQ(test_int64.pass_hist1d_covar, 1);
+  ASSERT_EQ(test_int64.pass_hist3d_mean, 1);
+  ASSERT_EQ(test_int64.pass_hist3d_var, 1);
+  ASSERT_EQ(test_int64.pass_hist3d_covar, 1);
+  deep_copy(density_1d, 0);
+  deep_copy(density_3d, 0);
 
   cout << "Test Scalar=uint64_t" << endl;
-  test_random_scalar<RandomGenerator,uint64_t> test_uint64(density_1d,density_3d,pool,num_draws);
-  ASSERT_EQ( test_uint64.pass_mean,1);
-  ASSERT_EQ( test_uint64.pass_var,1);
-  ASSERT_EQ( test_uint64.pass_covar,1);
-  ASSERT_EQ( test_uint64.pass_hist1d_mean,1);
-  ASSERT_EQ( test_uint64.pass_hist1d_var,1);
-  ASSERT_EQ( test_uint64.pass_hist1d_covar,1);
-  ASSERT_EQ( test_uint64.pass_hist3d_mean,1);
-  ASSERT_EQ( test_uint64.pass_hist3d_var,1);
-  ASSERT_EQ( test_uint64.pass_hist3d_covar,1);
-  deep_copy(density_1d,0);
-  deep_copy(density_3d,0);
+  test_random_scalar<RandomGenerator, uint64_t> test_uint64(
+      density_1d, density_3d, pool, num_draws);
+  ASSERT_EQ(test_uint64.pass_mean, 1);
+  ASSERT_EQ(test_uint64.pass_var, 1);
+  ASSERT_EQ(test_uint64.pass_covar, 1);
+  ASSERT_EQ(test_uint64.pass_hist1d_mean, 1);
+  ASSERT_EQ(test_uint64.pass_hist1d_var, 1);
+  ASSERT_EQ(test_uint64.pass_hist1d_covar, 1);
+  ASSERT_EQ(test_uint64.pass_hist3d_mean, 1);
+  ASSERT_EQ(test_uint64.pass_hist3d_var, 1);
+  ASSERT_EQ(test_uint64.pass_hist3d_covar, 1);
+  deep_copy(density_1d, 0);
+  deep_copy(density_3d, 0);
 
   cout << "Test Scalar=float" << endl;
-  test_random_scalar<RandomGenerator,float> test_float(density_1d,density_3d,pool,num_draws);
-  ASSERT_EQ( test_float.pass_mean,1);
-  ASSERT_EQ( test_float.pass_var,1);
-  ASSERT_EQ( test_float.pass_covar,1);
-  ASSERT_EQ( test_float.pass_hist1d_mean,1);
-  ASSERT_EQ( test_float.pass_hist1d_var,1);
-  ASSERT_EQ( test_float.pass_hist1d_covar,1);
-  ASSERT_EQ( test_float.pass_hist3d_mean,1);
-  ASSERT_EQ( test_float.pass_hist3d_var,1);
-  ASSERT_EQ( test_float.pass_hist3d_covar,1);
-  deep_copy(density_1d,0);
-  deep_copy(density_3d,0);
+  test_random_scalar<RandomGenerator, float> test_float(density_1d, density_3d,
+                                                        pool, num_draws);
+  ASSERT_EQ(test_float.pass_mean, 1);
+  ASSERT_EQ(test_float.pass_var, 1);
+  ASSERT_EQ(test_float.pass_covar, 1);
+  ASSERT_EQ(test_float.pass_hist1d_mean, 1);
+  ASSERT_EQ(test_float.pass_hist1d_var, 1);
+  ASSERT_EQ(test_float.pass_hist1d_covar, 1);
+  ASSERT_EQ(test_float.pass_hist3d_mean, 1);
+  ASSERT_EQ(test_float.pass_hist3d_var, 1);
+  ASSERT_EQ(test_float.pass_hist3d_covar, 1);
+  deep_copy(density_1d, 0);
+  deep_copy(density_3d, 0);
 
   cout << "Test Scalar=double" << endl;
-  test_random_scalar<RandomGenerator,double> test_double(density_1d,density_3d,pool,num_draws);
-  ASSERT_EQ( test_double.pass_mean,1);
-  ASSERT_EQ( test_double.pass_var,1);
-  ASSERT_EQ( test_double.pass_covar,1);
-  ASSERT_EQ( test_double.pass_hist1d_mean,1);
-  ASSERT_EQ( test_double.pass_hist1d_var,1);
-  ASSERT_EQ( test_double.pass_hist1d_covar,1);
-  ASSERT_EQ( test_double.pass_hist3d_mean,1);
-  ASSERT_EQ( test_double.pass_hist3d_var,1);
-  ASSERT_EQ( test_double.pass_hist3d_covar,1);
-}
+  test_random_scalar<RandomGenerator, double> test_double(
+      density_1d, density_3d, pool, num_draws);
+  ASSERT_EQ(test_double.pass_mean, 1);
+  ASSERT_EQ(test_double.pass_var, 1);
+  ASSERT_EQ(test_double.pass_covar, 1);
+  ASSERT_EQ(test_double.pass_hist1d_mean, 1);
+  ASSERT_EQ(test_double.pass_hist1d_var, 1);
+  ASSERT_EQ(test_double.pass_hist1d_covar, 1);
+  ASSERT_EQ(test_double.pass_hist3d_mean, 1);
+  ASSERT_EQ(test_double.pass_hist3d_var, 1);
+  ASSERT_EQ(test_double.pass_hist3d_covar, 1);
 }
+}  // namespace Impl
 
-} // namespace Test
+}  // namespace Test
 
-#endif //KOKKOS_TEST_UNORDERED_MAP_HPP
+#endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
diff --git a/lib/kokkos/algorithms/unit_tests/TestSerial.cpp b/lib/kokkos/algorithms/unit_tests/TestSerial.cpp
index 9cf998f7732628bf71e8bc8ea90fcf6e41a27f3d..2eacdc2677184988c226bbaca13827a4b55cccff 100644
--- a/lib/kokkos/algorithms/unit_tests/TestSerial.cpp
+++ b/lib/kokkos/algorithms/unit_tests/TestSerial.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,49 +53,36 @@
 #include <TestSort.hpp>
 #include <iomanip>
 
-
 //----------------------------------------------------------------------------
 
-
 namespace Test {
 
-class serial : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-  }
-
-  static void TearDownTestCase ()
-  {
+#define SERIAL_RANDOM_XORSHIFT64(num_draws)                             \
+  TEST(serial, Random_XorShift64) {                                     \
+    Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::Serial> >( \
+        num_draws);                                                     \
   }
-};
 
-#define SERIAL_RANDOM_XORSHIFT64( num_draws )  \
-  TEST_F( serial, Random_XorShift64 ) {                                \
-    Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::Serial> >(num_draws); \
+#define SERIAL_RANDOM_XORSHIFT1024(num_draws)                             \
+  TEST(serial, Random_XorShift1024) {                                     \
+    Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::Serial> >( \
+        num_draws);                                                       \
   }
 
-#define SERIAL_RANDOM_XORSHIFT1024( num_draws )        \
-  TEST_F( serial, Random_XorShift1024 ) {                              \
-    Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::Serial> >(num_draws); \
+#define SERIAL_SORT_UNSIGNED(size)                   \
+  TEST(serial, SortUnsigned) {                       \
+    Impl::test_sort<Kokkos::Serial, unsigned>(size); \
   }
 
-#define SERIAL_SORT_UNSIGNED( size )                                \
-  TEST_F( serial, SortUnsigned ) {   \
-      Impl::test_sort< Kokkos::Serial, unsigned >(size);                                   \
-  }
-
-SERIAL_RANDOM_XORSHIFT64( 10240000 )
-SERIAL_RANDOM_XORSHIFT1024( 10130144 )
+SERIAL_RANDOM_XORSHIFT64(10240000)
+SERIAL_RANDOM_XORSHIFT1024(10130144)
 SERIAL_SORT_UNSIGNED(171)
 
 #undef SERIAL_RANDOM_XORSHIFT64
 #undef SERIAL_RANDOM_XORSHIFT1024
 #undef SERIAL_SORT_UNSIGNED
 
-} // namespace Test
+}  // namespace Test
 #else
 void KOKKOS_ALGORITHMS_UNITTESTS_TESTSERIAL_PREVENT_LINK_ERROR() {}
-#endif // KOKKOS_ENABLE_SERIAL
-
-
+#endif  // KOKKOS_ENABLE_SERIAL
diff --git a/lib/kokkos/algorithms/unit_tests/TestSort.hpp b/lib/kokkos/algorithms/unit_tests/TestSort.hpp
index 5fd7f09b50ef617b797f39305a3318e71ea354da..310a93c93d1d55baad4d33d9d34540ca523c9433 100644
--- a/lib/kokkos/algorithms/unit_tests/TestSort.hpp
+++ b/lib/kokkos/algorithms/unit_tests/TestSort.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,235 +44,248 @@
 #define KOKKOS_ALGORITHMS_UNITTESTS_TESTSORT_HPP
 
 #include <gtest/gtest.h>
-#include<Kokkos_Core.hpp>
-#include<Kokkos_DynamicView.hpp>
-#include<Kokkos_Random.hpp>
-#include<Kokkos_Sort.hpp>
+#include <Kokkos_Core.hpp>
+#include <Kokkos_DynamicView.hpp>
+#include <Kokkos_Random.hpp>
+#include <Kokkos_Sort.hpp>
 
 namespace Test {
 
-namespace Impl{
+namespace Impl {
 
-template<class ExecutionSpace, class Scalar>
+template <class ExecutionSpace, class Scalar>
 struct is_sorted_struct {
   typedef unsigned int value_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View<Scalar*,ExecutionSpace> keys;
+  Kokkos::View<Scalar*, ExecutionSpace> keys;
 
-  is_sorted_struct(Kokkos::View<Scalar*,ExecutionSpace> keys_):keys(keys_) {}
+  is_sorted_struct(Kokkos::View<Scalar*, ExecutionSpace> keys_) : keys(keys_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i, unsigned int& count) const {
-    if(keys(i)>keys(i+1)) count++;
+  void operator()(int i, unsigned int& count) const {
+    if (keys(i) > keys(i + 1)) count++;
   }
 };
 
-template<class ExecutionSpace, class Scalar>
+template <class ExecutionSpace, class Scalar>
 struct sum {
   typedef double value_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View<Scalar*,ExecutionSpace> keys;
+  Kokkos::View<Scalar*, ExecutionSpace> keys;
 
-  sum(Kokkos::View<Scalar*,ExecutionSpace> keys_):keys(keys_) {}
+  sum(Kokkos::View<Scalar*, ExecutionSpace> keys_) : keys(keys_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i, double& count) const {
-    count+=keys(i);
-  }
+  void operator()(int i, double& count) const { count += keys(i); }
 };
 
-template<class ExecutionSpace, class Scalar>
+template <class ExecutionSpace, class Scalar>
 struct bin3d_is_sorted_struct {
   typedef unsigned int value_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View<Scalar*[3],ExecutionSpace> keys;
+  Kokkos::View<Scalar * [3], ExecutionSpace> keys;
 
   int max_bins;
   Scalar min;
   Scalar max;
 
-  bin3d_is_sorted_struct(Kokkos::View<Scalar*[3],ExecutionSpace> keys_,int max_bins_,Scalar min_,Scalar max_):
-    keys(keys_),max_bins(max_bins_),min(min_),max(max_) {
-  }
+  bin3d_is_sorted_struct(Kokkos::View<Scalar * [3], ExecutionSpace> keys_,
+                         int max_bins_, Scalar min_, Scalar max_)
+      : keys(keys_), max_bins(max_bins_), min(min_), max(max_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i, unsigned int& count) const {
-    int ix1 = int ((keys(i,0)-min)/max * max_bins);
-    int iy1 = int ((keys(i,1)-min)/max * max_bins);
-    int iz1 = int ((keys(i,2)-min)/max * max_bins);
-    int ix2 = int ((keys(i+1,0)-min)/max * max_bins);
-    int iy2 = int ((keys(i+1,1)-min)/max * max_bins);
-    int iz2 = int ((keys(i+1,2)-min)/max * max_bins);
-
-    if (ix1>ix2)  count++;
-    else if(ix1==ix2) {
-      if (iy1>iy2)  count++;
-      else if ((iy1==iy2) && (iz1>iz2))  count++;
+  void operator()(int i, unsigned int& count) const {
+    int ix1 = int((keys(i, 0) - min) / max * max_bins);
+    int iy1 = int((keys(i, 1) - min) / max * max_bins);
+    int iz1 = int((keys(i, 2) - min) / max * max_bins);
+    int ix2 = int((keys(i + 1, 0) - min) / max * max_bins);
+    int iy2 = int((keys(i + 1, 1) - min) / max * max_bins);
+    int iz2 = int((keys(i + 1, 2) - min) / max * max_bins);
+
+    if (ix1 > ix2)
+      count++;
+    else if (ix1 == ix2) {
+      if (iy1 > iy2)
+        count++;
+      else if ((iy1 == iy2) && (iz1 > iz2))
+        count++;
     }
   }
 };
 
-template<class ExecutionSpace, class Scalar>
+template <class ExecutionSpace, class Scalar>
 struct sum3D {
   typedef double value_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View<Scalar*[3],ExecutionSpace> keys;
+  Kokkos::View<Scalar * [3], ExecutionSpace> keys;
 
-  sum3D(Kokkos::View<Scalar*[3],ExecutionSpace> keys_):keys(keys_) {}
+  sum3D(Kokkos::View<Scalar * [3], ExecutionSpace> keys_) : keys(keys_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i, double& count) const {
-    count+=keys(i,0);
-    count+=keys(i,1);
-    count+=keys(i,2);
+  void operator()(int i, double& count) const {
+    count += keys(i, 0);
+    count += keys(i, 1);
+    count += keys(i, 2);
   }
 };
 
-template<class ExecutionSpace, typename KeyType>
-void test_1D_sort(unsigned int n,bool force_kokkos) {
-  typedef Kokkos::View<KeyType*,ExecutionSpace> KeyViewType;
-  KeyViewType keys("Keys",n);
+template <class ExecutionSpace, typename KeyType>
+void test_1D_sort(unsigned int n, bool force_kokkos) {
+  typedef Kokkos::View<KeyType*, ExecutionSpace> KeyViewType;
+  KeyViewType keys("Keys", n);
 
   // Test sorting array with all numbers equal
-  Kokkos::deep_copy(keys,KeyType(1));
-  Kokkos::sort(keys,force_kokkos);
+  Kokkos::deep_copy(keys, KeyType(1));
+  Kokkos::sort(keys, force_kokkos);
 
   Kokkos::Random_XorShift64_Pool<ExecutionSpace> g(1931);
-  Kokkos::fill_random(keys,g,Kokkos::Random_XorShift64_Pool<ExecutionSpace>::generator_type::MAX_URAND);
+  Kokkos::fill_random(keys, g,
+                      Kokkos::Random_XorShift64_Pool<
+                          ExecutionSpace>::generator_type::MAX_URAND);
 
-  double sum_before = 0.0;
-  double sum_after = 0.0;
+  double sum_before       = 0.0;
+  double sum_after        = 0.0;
   unsigned int sort_fails = 0;
 
-  Kokkos::parallel_reduce(n,sum<ExecutionSpace, KeyType>(keys),sum_before);
+  Kokkos::parallel_reduce(n, sum<ExecutionSpace, KeyType>(keys), sum_before);
 
-  Kokkos::sort(keys,force_kokkos);
+  Kokkos::sort(keys, force_kokkos);
 
-  Kokkos::parallel_reduce(n,sum<ExecutionSpace, KeyType>(keys),sum_after);
-  Kokkos::parallel_reduce(n-1,is_sorted_struct<ExecutionSpace, KeyType>(keys),sort_fails);
+  Kokkos::parallel_reduce(n, sum<ExecutionSpace, KeyType>(keys), sum_after);
+  Kokkos::parallel_reduce(
+      n - 1, is_sorted_struct<ExecutionSpace, KeyType>(keys), sort_fails);
 
-  double ratio = sum_before/sum_after;
+  double ratio   = sum_before / sum_after;
   double epsilon = 1e-10;
-  unsigned int equal_sum = (ratio > (1.0-epsilon)) && (ratio < (1.0+epsilon)) ? 1 : 0;
+  unsigned int equal_sum =
+      (ratio > (1.0 - epsilon)) && (ratio < (1.0 + epsilon)) ? 1 : 0;
 
-  ASSERT_EQ(sort_fails,0);
-  ASSERT_EQ(equal_sum,1);
+  ASSERT_EQ(sort_fails, 0);
+  ASSERT_EQ(equal_sum, 1);
 }
 
-template<class ExecutionSpace, typename KeyType>
+template <class ExecutionSpace, typename KeyType>
 void test_3D_sort(unsigned int n) {
-  typedef Kokkos::View<KeyType*[3],ExecutionSpace > KeyViewType;
+  typedef Kokkos::View<KeyType * [3], ExecutionSpace> KeyViewType;
 
-  KeyViewType keys("Keys",n*n*n);
+  KeyViewType keys("Keys", n * n * n);
 
   Kokkos::Random_XorShift64_Pool<ExecutionSpace> g(1931);
-  Kokkos::fill_random(keys,g,100.0);
+  Kokkos::fill_random(keys, g, 100.0);
 
-  double sum_before = 0.0;
-  double sum_after = 0.0;
+  double sum_before       = 0.0;
+  double sum_after        = 0.0;
   unsigned int sort_fails = 0;
 
-  Kokkos::parallel_reduce(keys.extent(0),sum3D<ExecutionSpace, KeyType>(keys),sum_before);
+  Kokkos::parallel_reduce(keys.extent(0), sum3D<ExecutionSpace, KeyType>(keys),
+                          sum_before);
 
   int bin_1d = 1;
-  while( bin_1d*bin_1d*bin_1d*4< (int) keys.extent(0) ) bin_1d*=2;
-  int bin_max[3] = {bin_1d,bin_1d,bin_1d};
-  typename KeyViewType::value_type min[3] = {0,0,0};
-  typename KeyViewType::value_type max[3] = {100,100,100};
-
-  typedef Kokkos::BinOp3D< KeyViewType > BinOp;
-  BinOp bin_op(bin_max,min,max);
-  Kokkos::BinSort< KeyViewType , BinOp >
-    Sorter(keys,bin_op,false);
+  while (bin_1d * bin_1d * bin_1d * 4 < (int)keys.extent(0)) bin_1d *= 2;
+  int bin_max[3]                          = {bin_1d, bin_1d, bin_1d};
+  typename KeyViewType::value_type min[3] = {0, 0, 0};
+  typename KeyViewType::value_type max[3] = {100, 100, 100};
+
+  typedef Kokkos::BinOp3D<KeyViewType> BinOp;
+  BinOp bin_op(bin_max, min, max);
+  Kokkos::BinSort<KeyViewType, BinOp> Sorter(keys, bin_op, false);
   Sorter.create_permute_vector();
-  Sorter.template sort< KeyViewType >(keys);
+  Sorter.template sort<KeyViewType>(keys);
 
-  Kokkos::parallel_reduce(keys.extent(0),sum3D<ExecutionSpace, KeyType>(keys),sum_after);
-  Kokkos::parallel_reduce(keys.extent(0)-1,bin3d_is_sorted_struct<ExecutionSpace, KeyType>(keys,bin_1d,min[0],max[0]),sort_fails);
+  Kokkos::parallel_reduce(keys.extent(0), sum3D<ExecutionSpace, KeyType>(keys),
+                          sum_after);
+  Kokkos::parallel_reduce(keys.extent(0) - 1,
+                          bin3d_is_sorted_struct<ExecutionSpace, KeyType>(
+                              keys, bin_1d, min[0], max[0]),
+                          sort_fails);
 
-  double ratio = sum_before/sum_after;
+  double ratio   = sum_before / sum_after;
   double epsilon = 1e-10;
-  unsigned int equal_sum = (ratio > (1.0-epsilon)) && (ratio < (1.0+epsilon)) ? 1 : 0;
+  unsigned int equal_sum =
+      (ratio > (1.0 - epsilon)) && (ratio < (1.0 + epsilon)) ? 1 : 0;
 
-  if ( sort_fails )
-    printf("3D Sort Sum: %f %f Fails: %u\n",sum_before,sum_after,sort_fails);
+  if (sort_fails)
+    printf("3D Sort Sum: %f %f Fails: %u\n", sum_before, sum_after, sort_fails);
 
-  ASSERT_EQ(sort_fails,0);
-  ASSERT_EQ(equal_sum,1);
+  ASSERT_EQ(sort_fails, 0);
+  ASSERT_EQ(equal_sum, 1);
 }
 
 //----------------------------------------------------------------------------
 
-template<class ExecutionSpace, typename KeyType>
-void test_dynamic_view_sort(unsigned int n )
-{
-  typedef Kokkos::Experimental::DynamicView<KeyType*,ExecutionSpace> KeyDynamicViewType;
-  typedef Kokkos::View<KeyType*,ExecutionSpace> KeyViewType;
+template <class ExecutionSpace, typename KeyType>
+void test_dynamic_view_sort(unsigned int n) {
+  typedef Kokkos::Experimental::DynamicView<KeyType*, ExecutionSpace>
+      KeyDynamicViewType;
+  typedef Kokkos::View<KeyType*, ExecutionSpace> KeyViewType;
 
-  const size_t upper_bound = 2 * n ;
+  const size_t upper_bound    = 2 * n;
   const size_t min_chunk_size = 1024;
 
   KeyDynamicViewType keys("Keys", min_chunk_size, upper_bound);
 
   keys.resize_serial(n);
 
-  KeyViewType keys_view("KeysTmp", n );
+  KeyViewType keys_view("KeysTmp", n);
 
   // Test sorting array with all numbers equal
-  Kokkos::deep_copy(keys_view,KeyType(1));
-  Kokkos::deep_copy(keys,keys_view);
-  Kokkos::sort(keys, 0 /* begin */ , n /* end */ );
+  Kokkos::deep_copy(keys_view, KeyType(1));
+  Kokkos::deep_copy(keys, keys_view);
+  Kokkos::sort(keys, 0 /* begin */, n /* end */);
 
   Kokkos::Random_XorShift64_Pool<ExecutionSpace> g(1931);
-  Kokkos::fill_random(keys_view,g,Kokkos::Random_XorShift64_Pool<ExecutionSpace>::generator_type::MAX_URAND);
+  Kokkos::fill_random(keys_view, g,
+                      Kokkos::Random_XorShift64_Pool<
+                          ExecutionSpace>::generator_type::MAX_URAND);
 
   ExecutionSpace().fence();
-  Kokkos::deep_copy(keys,keys_view);
-  //ExecutionSpace().fence();
+  Kokkos::deep_copy(keys, keys_view);
+  // ExecutionSpace().fence();
 
-  double sum_before = 0.0;
-  double sum_after = 0.0;
+  double sum_before       = 0.0;
+  double sum_after        = 0.0;
   unsigned int sort_fails = 0;
 
-  Kokkos::parallel_reduce(n,sum<ExecutionSpace, KeyType>(keys_view),sum_before);
+  Kokkos::parallel_reduce(n, sum<ExecutionSpace, KeyType>(keys_view),
+                          sum_before);
 
-  Kokkos::sort(keys, 0 /* begin */ , n /* end */ );
+  Kokkos::sort(keys, 0 /* begin */, n /* end */);
 
-  ExecutionSpace().fence(); // Need this fence to prevent BusError with Cuda
-  Kokkos::deep_copy( keys_view , keys );
-  //ExecutionSpace().fence();
+  ExecutionSpace().fence();  // Need this fence to prevent BusError with Cuda
+  Kokkos::deep_copy(keys_view, keys);
+  // ExecutionSpace().fence();
 
-  Kokkos::parallel_reduce(n,sum<ExecutionSpace, KeyType>(keys_view),sum_after);
-  Kokkos::parallel_reduce(n-1,is_sorted_struct<ExecutionSpace, KeyType>(keys_view),sort_fails);
+  Kokkos::parallel_reduce(n, sum<ExecutionSpace, KeyType>(keys_view),
+                          sum_after);
+  Kokkos::parallel_reduce(
+      n - 1, is_sorted_struct<ExecutionSpace, KeyType>(keys_view), sort_fails);
 
-  double ratio = sum_before/sum_after;
+  double ratio   = sum_before / sum_after;
   double epsilon = 1e-10;
-  unsigned int equal_sum = (ratio > (1.0-epsilon)) && (ratio < (1.0+epsilon)) ? 1 : 0;
-
-  if ( sort_fails != 0 || equal_sum != 1 ) {
-    std::cout << " N = " << n
-              << " ; sum_before = " << sum_before
-              << " ; sum_after = " << sum_after
-              << " ; ratio = " << ratio
-              << std::endl ;
+  unsigned int equal_sum =
+      (ratio > (1.0 - epsilon)) && (ratio < (1.0 + epsilon)) ? 1 : 0;
+
+  if (sort_fails != 0 || equal_sum != 1) {
+    std::cout << " N = " << n << " ; sum_before = " << sum_before
+              << " ; sum_after = " << sum_after << " ; ratio = " << ratio
+              << std::endl;
   }
 
-  ASSERT_EQ(sort_fails,0);
-  ASSERT_EQ(equal_sum,1);
+  ASSERT_EQ(sort_fails, 0);
+  ASSERT_EQ(equal_sum, 1);
 }
 
 //----------------------------------------------------------------------------
 
-template<class ExecutionSpace>
-void test_issue_1160()
-{
+template <class ExecutionSpace>
+void test_issue_1160() {
   Kokkos::View<int*, ExecutionSpace> element_("element", 10);
   Kokkos::View<double*, ExecutionSpace> x_("x", 10);
   Kokkos::View<double*, ExecutionSpace> v_("y", 10);
 
   auto h_element = Kokkos::create_mirror_view(element_);
-  auto h_x = Kokkos::create_mirror_view(x_);
-  auto h_v = Kokkos::create_mirror_view(v_);
+  auto h_x       = Kokkos::create_mirror_view(x_);
+  auto h_v       = Kokkos::create_mirror_view(v_);
 
   h_element(0) = 9;
   h_element(1) = 8;
@@ -292,20 +306,21 @@ void test_issue_1160()
   Kokkos::deep_copy(v_, h_v);
 
   typedef decltype(element_) KeyViewType;
-  typedef Kokkos::BinOp1D< KeyViewType > BinOp;
+  typedef Kokkos::BinOp1D<KeyViewType> BinOp;
 
   int begin = 3;
-  int end = 8;
-  auto max = h_element(begin);
-  auto min = h_element(end - 1);
+  int end   = 8;
+  auto max  = h_element(begin);
+  auto min  = h_element(end - 1);
   BinOp binner(end - begin, min, max);
 
-  Kokkos::BinSort<KeyViewType , BinOp > Sorter(element_,begin,end,binner,false);
+  Kokkos::BinSort<KeyViewType, BinOp> Sorter(element_, begin, end, binner,
+                                             false);
   Sorter.create_permute_vector();
-  Sorter.sort(element_,begin,end);
+  Sorter.sort(element_, begin, end);
 
-  Sorter.sort(x_,begin,end);
-  Sorter.sort(v_,begin,end);
+  Sorter.sort(x_, begin, end);
+  Sorter.sort(v_, begin, end);
 
   Kokkos::deep_copy(h_element, element_);
   Kokkos::deep_copy(h_x, x_);
@@ -330,18 +345,17 @@ void test_issue_1160()
 
 //----------------------------------------------------------------------------
 
-template<class ExecutionSpace, typename KeyType>
-void test_sort(unsigned int N)
-{
-  test_1D_sort<ExecutionSpace,KeyType>(N*N*N, true);
-  test_1D_sort<ExecutionSpace,KeyType>(N*N*N, false);
+template <class ExecutionSpace, typename KeyType>
+void test_sort(unsigned int N) {
+  test_1D_sort<ExecutionSpace, KeyType>(N * N * N, true);
+  test_1D_sort<ExecutionSpace, KeyType>(N * N * N, false);
 #if !defined(KOKKOS_ENABLE_ROCM)
-  test_3D_sort<ExecutionSpace,KeyType>(N);
-  test_dynamic_view_sort<ExecutionSpace,KeyType>(N*N);
+  test_3D_sort<ExecutionSpace, KeyType>(N);
+  test_dynamic_view_sort<ExecutionSpace, KeyType>(N * N);
 #endif
   test_issue_1160<ExecutionSpace>();
 }
 
-}
-}
+}  // namespace Impl
+}  // namespace Test
 #endif /* KOKKOS_ALGORITHMS_UNITTESTS_TESTSORT_HPP */
diff --git a/lib/kokkos/algorithms/unit_tests/TestThreads.cpp b/lib/kokkos/algorithms/unit_tests/TestThreads.cpp
index 99cdb7da92a253d9469b956c27ee06f212421c0d..c75e6e8dfba9f8d69617b8ff44b4c095a9e55537 100644
--- a/lib/kokkos/algorithms/unit_tests/TestThreads.cpp
+++ b/lib/kokkos/algorithms/unit_tests/TestThreads.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,51 +53,36 @@
 #include <TestSort.hpp>
 #include <iomanip>
 
-
 //----------------------------------------------------------------------------
 
-
 namespace Test {
 
-class threads : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-    std::cout << std::setprecision(5) << std::scientific;
+#define THREADS_RANDOM_XORSHIFT64(num_draws)                             \
+  TEST(threads, Random_XorShift64) {                                     \
+    Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::Threads> >( \
+        num_draws);                                                      \
   }
 
-  static void TearDownTestCase()
-  {
+#define THREADS_RANDOM_XORSHIFT1024(num_draws)                             \
+  TEST(threads, Random_XorShift1024) {                                     \
+    Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::Threads> >( \
+        num_draws);                                                        \
   }
-};
 
-#define THREADS_RANDOM_XORSHIFT64( num_draws )                                \
-  TEST_F( threads, Random_XorShift64 ) {   \
-      Impl::test_random<Kokkos::Random_XorShift64_Pool<Kokkos::Threads> >(num_draws);                                   \
+#define THREADS_SORT_UNSIGNED(size)                 \
+  TEST(threads, SortUnsigned) {                     \
+    Impl::test_sort<Kokkos::Threads, double>(size); \
   }
 
-#define THREADS_RANDOM_XORSHIFT1024( num_draws )                                \
-  TEST_F( threads, Random_XorShift1024 ) {   \
-      Impl::test_random<Kokkos::Random_XorShift1024_Pool<Kokkos::Threads> >(num_draws);                                   \
-  }
-
-#define THREADS_SORT_UNSIGNED( size )                                \
-  TEST_F( threads, SortUnsigned ) {   \
-      Impl::test_sort< Kokkos::Threads, double >(size);                                   \
-  }
-
-
-THREADS_RANDOM_XORSHIFT64( 10240000 )
-THREADS_RANDOM_XORSHIFT1024( 10130144 )
+THREADS_RANDOM_XORSHIFT64(10240000)
+THREADS_RANDOM_XORSHIFT1024(10130144)
 THREADS_SORT_UNSIGNED(171)
 
 #undef THREADS_RANDOM_XORSHIFT64
 #undef THREADS_RANDOM_XORSHIFT1024
 #undef THREADS_SORT_UNSIGNED
 
-} // namespace Test
+}  // namespace Test
 #else
 void KOKKOS_ALGORITHMS_UNITTESTS_TESTTHREADS_PREVENT_LINK_ERROR() {}
 #endif
-
-
diff --git a/lib/kokkos/algorithms/unit_tests/UnitTestMain.cpp b/lib/kokkos/algorithms/unit_tests/UnitTestMain.cpp
index 8feb08332fa4d976395edfaf59b8e8653484c0f2..e245aad35fc33a595a16f711dbd4a63a0c7f8948 100644
--- a/lib/kokkos/algorithms/unit_tests/UnitTestMain.cpp
+++ b/lib/kokkos/algorithms/unit_tests/UnitTestMain.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,10 +46,9 @@
 #include <Kokkos_Core.hpp>
 
 int main(int argc, char *argv[]) {
-  Kokkos::initialize(argc,argv);
-  ::testing::InitGoogleTest(&argc,argv);
+  Kokkos::initialize(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
   int result = RUN_ALL_TESTS();
   Kokkos::finalize();
   return result;
 }
-
diff --git a/lib/kokkos/benchmarks/atomic/main.cpp b/lib/kokkos/benchmarks/atomic/main.cpp
index d86d196249b337882993544101d93df35e6ccb22..5f0977f75484e4103e74c4ecaf2d0ad6ec2f3acb 100644
--- a/lib/kokkos/benchmarks/atomic/main.cpp
+++ b/lib/kokkos/benchmarks/atomic/main.cpp
@@ -1,124 +1,120 @@
-#include<Kokkos_Core.hpp>
-#include<impl/Kokkos_Timer.hpp>
-#include<Kokkos_Random.hpp>
+#include <Kokkos_Core.hpp>
+#include <impl/Kokkos_Timer.hpp>
+#include <Kokkos_Random.hpp>
 
-template<class Scalar>
-double test_atomic(int L, int N, int M,int K,int R,Kokkos::View<const int*> offsets) {
-  Kokkos::View<Scalar*> output("Output",N);
+template <class Scalar>
+double test_atomic(int L, int N, int M, int K, int R,
+                   Kokkos::View<const int*> offsets) {
+  Kokkos::View<Scalar*> output("Output", N);
   Kokkos::Impl::Timer timer;
 
-  for(int r = 0; r<R; r++)
-  Kokkos::parallel_for(L, KOKKOS_LAMBDA (const int&i) {
-    Scalar s = 2;
-    for(int m=0;m<M;m++) {
-      for(int k=0;k<K;k++)
-        s=s*s+s;
-      const int idx = (i+offsets(i,m))%N;
-      Kokkos::atomic_add(&output(idx),s);
-    }
-  }); 
+  for (int r = 0; r < R; r++)
+    Kokkos::parallel_for(
+        L, KOKKOS_LAMBDA(const int& i) {
+          Scalar s = 2;
+          for (int m = 0; m < M; m++) {
+            for (int k = 0; k < K; k++) s = s * s + s;
+            const int idx = (i + offsets(i, m)) % N;
+            Kokkos::atomic_add(&output(idx), s);
+          }
+        });
   Kokkos::fence();
   double time = timer.seconds();
- 
+
   return time;
 }
 
-template<class Scalar>
-double test_no_atomic(int L, int N, int M,int K,int R,Kokkos::View<const int*> offsets) {
-  Kokkos::View<Scalar*> output("Output",N);
+template <class Scalar>
+double test_no_atomic(int L, int N, int M, int K, int R,
+                      Kokkos::View<const int*> offsets) {
+  Kokkos::View<Scalar*> output("Output", N);
   Kokkos::Impl::Timer timer;
-  for(int r = 0; r<R; r++)
-  Kokkos::parallel_for(L, KOKKOS_LAMBDA (const int&i) {
-    Scalar s = 2;
-    for(int m=0;m<M;m++) {
-      for(int k=0;k<K;k++)
-        s=s*s+s;
-      const int idx = (i+offsets(i,m))%N;
-      output(idx) += s;
-    }
-  });
+  for (int r = 0; r < R; r++)
+    Kokkos::parallel_for(
+        L, KOKKOS_LAMBDA(const int& i) {
+          Scalar s = 2;
+          for (int m = 0; m < M; m++) {
+            for (int k = 0; k < K; k++) s = s * s + s;
+            const int idx = (i + offsets(i, m)) % N;
+            output(idx) += s;
+          }
+        });
   Kokkos::fence();
-  double time =  timer.seconds();
+  double time = timer.seconds();
   return time;
 }
 
 int main(int argc, char* argv[]) {
-  Kokkos::initialize(argc,argv);
-{
-  if(argc<8) {
-    printf("Arguments: L N M D K R T\n");
-    printf("  L:   Number of iterations to run\n");
-    printf("  N:   Length of array to do atomics into\n");
-    printf("  M:   Number of atomics per iteration to do\n");
-    printf("  D:   Distance from index i to do atomics into (randomly)\n");
-    printf("  K:   Number of FMAD per atomic\n");
-    printf("  R:   Number of repeats of the experiments\n");
-    printf("  T:   Type of atomic\n");
-    printf("       1 - int\n");
-    printf("       2 - long\n");
-    printf("       3 - float\n");
-    printf("       4 - double\n");
-    printf("       5 - complex<double>\n");
-    printf("Example Input GPU:\n");
-    printf("  Histogram : 1000000 1000 1 1000 1 10 1\n");
-    printf("  MD Force : 100000 100000 100 1000 20 10 4\n");
-    printf("  Matrix Assembly : 100000 1000000 50 1000 20 10 4\n");
-    Kokkos::finalize();
-    return 0;
-  }
+  Kokkos::initialize(argc, argv);
+  {
+    if (argc < 8) {
+      printf("Arguments: L N M D K R T\n");
+      printf("  L:   Number of iterations to run\n");
+      printf("  N:   Length of array to do atomics into\n");
+      printf("  M:   Number of atomics per iteration to do\n");
+      printf("  D:   Distance from index i to do atomics into (randomly)\n");
+      printf("  K:   Number of FMAD per atomic\n");
+      printf("  R:   Number of repeats of the experiments\n");
+      printf("  T:   Type of atomic\n");
+      printf("       1 - int\n");
+      printf("       2 - long\n");
+      printf("       3 - float\n");
+      printf("       4 - double\n");
+      printf("       5 - complex<double>\n");
+      printf("Example Input GPU:\n");
+      printf("  Histogram : 1000000 1000 1 1000 1 10 1\n");
+      printf("  MD Force : 100000 100000 100 1000 20 10 4\n");
+      printf("  Matrix Assembly : 100000 1000000 50 1000 20 10 4\n");
+      Kokkos::finalize();
+      return 0;
+    }
 
+    int L    = atoi(argv[1]);
+    int N    = atoi(argv[2]);
+    int M    = atoi(argv[3]);
+    int D    = atoi(argv[4]);
+    int K    = atoi(argv[5]);
+    int R    = atoi(argv[6]);
+    int type = atoi(argv[7]);
 
-  int L = atoi(argv[1]);
-  int N = atoi(argv[2]);
-  int M = atoi(argv[3]);
-  int D = atoi(argv[4]); 
-  int K = atoi(argv[5]);
-  int R = atoi(argv[6]); 
-  int type = atoi(argv[7]);
- 
-  Kokkos::View<int*> offsets("Offsets",L,M);
-  Kokkos::Random_XorShift64_Pool<> pool(12371);
-  Kokkos::fill_random(offsets,pool,D);
-  double time = 0;
-  if(type==1)
-    time  = test_atomic<int>(L,N,M,K,R,offsets);
-  if(type==2)
-    time = test_atomic<long>(L,N,M,K,R,offsets);
-  if(type==3)
-    time = test_atomic<float>(L,N,M,K,R,offsets);
-  if(type==4)
-    time = test_atomic<double>(L,N,M,K,R,offsets);
-  if(type==5)
-    time = test_atomic<Kokkos::complex<double> >(L,N,M,K,R,offsets);
+    Kokkos::View<int*> offsets("Offsets", L, M);
+    Kokkos::Random_XorShift64_Pool<> pool(12371);
+    Kokkos::fill_random(offsets, pool, D);
+    double time = 0;
+    if (type == 1) time = test_atomic<int>(L, N, M, K, R, offsets);
+    if (type == 2) time = test_atomic<long>(L, N, M, K, R, offsets);
+    if (type == 3) time = test_atomic<float>(L, N, M, K, R, offsets);
+    if (type == 4) time = test_atomic<double>(L, N, M, K, R, offsets);
+    if (type == 5)
+      time = test_atomic<Kokkos::complex<double> >(L, N, M, K, R, offsets);
 
-  double time2 = 1;
-  if(type==1)
-    time2 = test_no_atomic<int>(L,N,M,K,R,offsets);
-  if(type==2)
-    time2 = test_no_atomic<long>(L,N,M,K,R,offsets);
-  if(type==3)
-    time2 = test_no_atomic<float>(L,N,M,K,R,offsets);
-  if(type==4)
-    time2 = test_no_atomic<double>(L,N,M,K,R,offsets);
-  if(type==5)
-    time2 = test_no_atomic<Kokkos::complex<double> >(L,N,M,K,R,offsets);
+    double time2 = 1;
+    if (type == 1) time2 = test_no_atomic<int>(L, N, M, K, R, offsets);
+    if (type == 2) time2 = test_no_atomic<long>(L, N, M, K, R, offsets);
+    if (type == 3) time2 = test_no_atomic<float>(L, N, M, K, R, offsets);
+    if (type == 4) time2 = test_no_atomic<double>(L, N, M, K, R, offsets);
+    if (type == 5)
+      time2 = test_no_atomic<Kokkos::complex<double> >(L, N, M, K, R, offsets);
 
-  int size = 0;
-  if(type==1) size = sizeof(int);
-  if(type==2) size = sizeof(long);
-  if(type==3) size = sizeof(float);
-  if(type==4) size = sizeof(double);
-  if(type==5) size = sizeof(Kokkos::complex<double>);
+    int size = 0;
+    if (type == 1) size = sizeof(int);
+    if (type == 2) size = sizeof(long);
+    if (type == 3) size = sizeof(float);
+    if (type == 4) size = sizeof(double);
+    if (type == 5) size = sizeof(Kokkos::complex<double>);
 
-  printf("%i\n",size);
-  printf("Time: %s %i %i %i %i %i %i (t_atomic: %e t_nonatomic: %e ratio: %lf )( GUpdates/s: %lf GB/s: %lf )\n",
-    (type==1)?"int": (
-    (type==2)?"long": (
-    (type==3)?"float": (
-    (type==4)?"double":"complex"))),
-    L,N,M,D,K,R,time,time2,time/time2,
-    1.e-9*L*R*M/time, 1.0*L*R*M*2*size/time/1024/1024/1024);
-}
+    printf("%i\n", size);
+    printf(
+        "Time: %s %i %i %i %i %i %i (t_atomic: %e t_nonatomic: %e ratio: %lf "
+        ")( GUpdates/s: %lf GB/s: %lf )\n",
+        (type == 1)
+            ? "int"
+            : ((type == 2)
+                   ? "long"
+                   : ((type == 3) ? "float"
+                                  : ((type == 4) ? "double" : "complex"))),
+        L, N, M, D, K, R, time, time2, time / time2, 1.e-9 * L * R * M / time,
+        1.0 * L * R * M * 2 * size / time / 1024 / 1024 / 1024);
+  }
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/benchmarks/bytes_and_flops/bench.hpp b/lib/kokkos/benchmarks/bytes_and_flops/bench.hpp
index 59b4d50c441eb5d4c58c99c53eee7f9c6b9adbd1..62d7ef4a4cf387191c6d0276c4ea360c289d4de5 100644
--- a/lib/kokkos/benchmarks/bytes_and_flops/bench.hpp
+++ b/lib/kokkos/benchmarks/bytes_and_flops/bench.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,59 +42,52 @@
 //@HEADER
 */
 
-#include<Kokkos_Core.hpp>
-#include<impl/Kokkos_Timer.hpp>
+#include <Kokkos_Core.hpp>
+#include <impl/Kokkos_Timer.hpp>
 
-template<class Scalar, int Unroll,int Stride>
+template <class Scalar, int Unroll, int Stride>
 struct Run {
-static void run(int N, int K, int R, int F, int T, int S);
+  static void run(int N, int K, int R, int F, int T, int S);
 };
 
-template<class Scalar, int Stride>
+template <class Scalar, int Stride>
 struct RunStride {
-static void run_1(int N, int K, int R, int F, int T, int S);
-static void run_2(int N, int K, int R, int F, int T, int S);
-static void run_3(int N, int K, int R, int F, int T, int S);
-static void run_4(int N, int K, int R, int F, int T, int S);
-static void run_5(int N, int K, int R, int F, int T, int S);
-static void run_6(int N, int K, int R, int F, int T, int S);
-static void run_7(int N, int K, int R, int F, int T, int S);
-static void run_8(int N, int K, int R, int F, int T, int S);
-static void run(int N, int K, int R, int U, int F, int T, int S);
+  static void run_1(int N, int K, int R, int F, int T, int S);
+  static void run_2(int N, int K, int R, int F, int T, int S);
+  static void run_3(int N, int K, int R, int F, int T, int S);
+  static void run_4(int N, int K, int R, int F, int T, int S);
+  static void run_5(int N, int K, int R, int F, int T, int S);
+  static void run_6(int N, int K, int R, int F, int T, int S);
+  static void run_7(int N, int K, int R, int F, int T, int S);
+  static void run_8(int N, int K, int R, int F, int T, int S);
+  static void run(int N, int K, int R, int U, int F, int T, int S);
 };
 
 #define STRIDE 1
-#include<bench_stride.hpp>
+#include <bench_stride.hpp>
 #undef STRIDE
 #define STRIDE 2
-#include<bench_stride.hpp>
+#include <bench_stride.hpp>
 #undef STRIDE
 #define STRIDE 4
-#include<bench_stride.hpp>
+#include <bench_stride.hpp>
 #undef STRIDE
 #define STRIDE 8
-#include<bench_stride.hpp>
+#include <bench_stride.hpp>
 #undef STRIDE
 #define STRIDE 16
-#include<bench_stride.hpp>
+#include <bench_stride.hpp>
 #undef STRIDE
 #define STRIDE 32
-#include<bench_stride.hpp>
+#include <bench_stride.hpp>
 #undef STRIDE
 
-template<class Scalar>
+template <class Scalar>
 void run_stride_unroll(int N, int K, int R, int D, int U, int F, int T, int S) {
- if(D == 1)
-   RunStride<Scalar,1>::run(N,K,R,U,F,T,S);
- if(D == 2)
-   RunStride<Scalar,2>::run(N,K,R,U,F,T,S);
- if(D == 4)
-   RunStride<Scalar,4>::run(N,K,R,U,F,T,S);
- if(D == 8)
-   RunStride<Scalar,8>::run(N,K,R,U,F,T,S);
- if(D == 16)
-   RunStride<Scalar,16>::run(N,K,R,U,F,T,S);
- if(D == 32)
-   RunStride<Scalar,32>::run(N,K,R,U,F,T,S);
+  if (D == 1) RunStride<Scalar, 1>::run(N, K, R, U, F, T, S);
+  if (D == 2) RunStride<Scalar, 2>::run(N, K, R, U, F, T, S);
+  if (D == 4) RunStride<Scalar, 4>::run(N, K, R, U, F, T, S);
+  if (D == 8) RunStride<Scalar, 8>::run(N, K, R, U, F, T, S);
+  if (D == 16) RunStride<Scalar, 16>::run(N, K, R, U, F, T, S);
+  if (D == 32) RunStride<Scalar, 32>::run(N, K, R, U, F, T, S);
 }
-
diff --git a/lib/kokkos/benchmarks/bytes_and_flops/bench_stride.hpp b/lib/kokkos/benchmarks/bytes_and_flops/bench_stride.hpp
index 6509c654e71b4fdfd5366e4699972d7d19fe7807..64817fe9dc4b5d1efcad168d9b2e0915da6d492a 100644
--- a/lib/kokkos/benchmarks/bytes_and_flops/bench_stride.hpp
+++ b/lib/kokkos/benchmarks/bytes_and_flops/bench_stride.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,84 +42,82 @@
 //@HEADER
 */
 
-
 #define UNROLL 1
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 #define UNROLL 2
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 #define UNROLL 3
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 #define UNROLL 4
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 #define UNROLL 5
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 #define UNROLL 6
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 #define UNROLL 7
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 #define UNROLL 8
-#include<bench_unroll_stride.hpp>
+#include <bench_unroll_stride.hpp>
 #undef UNROLL
 
-template<class Scalar>
-struct RunStride<Scalar,STRIDE> {
-static void run_1(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,1,STRIDE>::run(N,K,R,F,T,S);
-}
-static void run_2(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,2,STRIDE>::run(N,K,R,F,T,S);
-}
-static void run_3(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,3,STRIDE>::run(N,K,R,F,T,S);
-}
-static void run_4(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,4,STRIDE>::run(N,K,R,F,T,S);
-}
-static void run_5(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,5,STRIDE>::run(N,K,R,F,T,S);
-}
-static void run_6(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,6,STRIDE>::run(N,K,R,F,T,S);
-}
-static void run_7(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,7,STRIDE>::run(N,K,R,F,T,S);
-}
-static void run_8(int N, int K, int R, int F, int T, int S) {
-  Run<Scalar,8,STRIDE>::run(N,K,R,F,T,S);
-}
-
-static void run(int N, int K, int R, int U, int F, int T, int S) {
-  if(U==1) {
-    run_1(N,K,R,F,T,S);
+template <class Scalar>
+struct RunStride<Scalar, STRIDE> {
+  static void run_1(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 1, STRIDE>::run(N, K, R, F, T, S);
   }
-  if(U==2) {
-    run_2(N,K,R,F,T,S);
+  static void run_2(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 2, STRIDE>::run(N, K, R, F, T, S);
   }
-  if(U==3) {
-    run_3(N,K,R,F,T,S);
+  static void run_3(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 3, STRIDE>::run(N, K, R, F, T, S);
   }
-  if(U==4) {
-    run_4(N,K,R,F,T,S);
+  static void run_4(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 4, STRIDE>::run(N, K, R, F, T, S);
   }
-  if(U==5) {
-    run_5(N,K,R,F,T,S);
+  static void run_5(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 5, STRIDE>::run(N, K, R, F, T, S);
   }
-  if(U==6) {
-    run_6(N,K,R,F,T,S);
+  static void run_6(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 6, STRIDE>::run(N, K, R, F, T, S);
   }
-  if(U==7) {
-    run_7(N,K,R,F,T,S);
+  static void run_7(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 7, STRIDE>::run(N, K, R, F, T, S);
+  }
+  static void run_8(int N, int K, int R, int F, int T, int S) {
+    Run<Scalar, 8, STRIDE>::run(N, K, R, F, T, S);
   }
-  if(U==8) {
-    run_8(N,K,R,F,T,S);
-  } 
-}
-};
 
+  static void run(int N, int K, int R, int U, int F, int T, int S) {
+    if (U == 1) {
+      run_1(N, K, R, F, T, S);
+    }
+    if (U == 2) {
+      run_2(N, K, R, F, T, S);
+    }
+    if (U == 3) {
+      run_3(N, K, R, F, T, S);
+    }
+    if (U == 4) {
+      run_4(N, K, R, F, T, S);
+    }
+    if (U == 5) {
+      run_5(N, K, R, F, T, S);
+    }
+    if (U == 6) {
+      run_6(N, K, R, F, T, S);
+    }
+    if (U == 7) {
+      run_7(N, K, R, F, T, S);
+    }
+    if (U == 8) {
+      run_8(N, K, R, F, T, S);
+    }
+  }
+};
diff --git a/lib/kokkos/benchmarks/bytes_and_flops/bench_unroll_stride.hpp b/lib/kokkos/benchmarks/bytes_and_flops/bench_unroll_stride.hpp
index c6651da1e7cf2e6d1a233dc90e9adf1211decf69..00ce635a489f677ff43b05c782856dcdfa1cafa9 100644
--- a/lib/kokkos/benchmarks/bytes_and_flops/bench_unroll_stride.hpp
+++ b/lib/kokkos/benchmarks/bytes_and_flops/bench_unroll_stride.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,108 +42,110 @@
 //@HEADER
 */
 
-template<class Scalar>
-struct Run<Scalar,UNROLL,STRIDE> {
-static void run(int N, int K, int R, int F, int T, int S) {
-  Kokkos::View<Scalar**[STRIDE],Kokkos::LayoutRight> A("A",N,K);
-  Kokkos::View<Scalar**[STRIDE],Kokkos::LayoutRight> B("B",N,K);
-  Kokkos::View<Scalar**[STRIDE],Kokkos::LayoutRight> C("C",N,K);
+template <class Scalar>
+struct Run<Scalar, UNROLL, STRIDE> {
+  static void run(int N, int K, int R, int F, int T, int S) {
+    Kokkos::View<Scalar* * [STRIDE], Kokkos::LayoutRight> A("A", N, K);
+    Kokkos::View<Scalar* * [STRIDE], Kokkos::LayoutRight> B("B", N, K);
+    Kokkos::View<Scalar* * [STRIDE], Kokkos::LayoutRight> C("C", N, K);
 
-  Kokkos::deep_copy(A,Scalar(1.5));
-  Kokkos::deep_copy(B,Scalar(2.5));
-  Kokkos::deep_copy(C,Scalar(3.5));
+    Kokkos::deep_copy(A, Scalar(1.5));
+    Kokkos::deep_copy(B, Scalar(2.5));
+    Kokkos::deep_copy(C, Scalar(3.5));
 
-  Kokkos::Timer timer;
-  Kokkos::parallel_for("BenchmarkKernel",Kokkos::TeamPolicy<>(N,T).set_scratch_size(0,Kokkos::PerTeam(S)),
-    KOKKOS_LAMBDA ( const Kokkos::TeamPolicy<>::member_type& team) {
-    const int n = team.league_rank();
-    for(int r=0; r<R; r++) {
-      Kokkos::parallel_for(Kokkos::TeamThreadRange(team,0,K), [&] (const int& i) {
-        Scalar a1 = A(n,i,0); 
-        const Scalar b = B(n,i,0);
-#if(UNROLL>1)
-        Scalar a2 = a1*1.3;
-#endif
-#if(UNROLL>2)
-        Scalar a3 = a2*1.1;
-#endif
-#if(UNROLL>3)
-        Scalar a4 = a3*1.1;
-#endif
-#if(UNROLL>4)
-        Scalar a5 = a4*1.3;
-#endif
-#if(UNROLL>5)
-        Scalar a6 = a5*1.1;
-#endif
-#if(UNROLL>6)
-        Scalar a7 = a6*1.1;
-#endif
-#if(UNROLL>7)
-        Scalar a8 = a7*1.1;
+    Kokkos::Timer timer;
+    Kokkos::parallel_for(
+        "BenchmarkKernel",
+        Kokkos::TeamPolicy<>(N, T).set_scratch_size(0, Kokkos::PerTeam(S)),
+        KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team) {
+          const int n = team.league_rank();
+          for (int r = 0; r < R; r++) {
+            Kokkos::parallel_for(
+                Kokkos::TeamThreadRange(team, 0, K), [&](const int& i) {
+                  Scalar a1      = A(n, i, 0);
+                  const Scalar b = B(n, i, 0);
+#if (UNROLL > 1)
+                  Scalar a2 = a1 * 1.3;
+#endif
+#if (UNROLL > 2)
+                  Scalar a3 = a2 * 1.1;
+#endif
+#if (UNROLL > 3)
+                  Scalar a4 = a3 * 1.1;
+#endif
+#if (UNROLL > 4)
+                  Scalar a5 = a4 * 1.3;
+#endif
+#if (UNROLL > 5)
+                  Scalar a6 = a5 * 1.1;
+#endif
+#if (UNROLL > 6)
+                  Scalar a7 = a6 * 1.1;
+#endif
+#if (UNROLL > 7)
+                  Scalar a8 = a7 * 1.1;
 #endif
 
-
-        for(int f = 0; f<F; f++) {
-          a1 += b*a1;
-#if(UNROLL>1)
-          a2 += b*a2;
+                  for (int f = 0; f < F; f++) {
+                    a1 += b * a1;
+#if (UNROLL > 1)
+                    a2 += b * a2;
 #endif
-#if(UNROLL>2)
-          a3 += b*a3;
+#if (UNROLL > 2)
+                    a3 += b * a3;
 #endif
-#if(UNROLL>3)
-          a4 += b*a4;
+#if (UNROLL > 3)
+                    a4 += b * a4;
 #endif
-#if(UNROLL>4)
-          a5 += b*a5;
+#if (UNROLL > 4)
+                    a5 += b * a5;
 #endif
-#if(UNROLL>5)
-          a6 += b*a6;
+#if (UNROLL > 5)
+                    a6 += b * a6;
 #endif
-#if(UNROLL>6)
-          a7 += b*a7;
+#if (UNROLL > 6)
+                    a7 += b * a7;
 #endif
-#if(UNROLL>7)
-          a8 += b*a8;
+#if (UNROLL > 7)
+                    a8 += b * a8;
 #endif
-
-
-        }
-#if(UNROLL==1)
-        C(n,i,0) = a1; 
+                  }
+#if (UNROLL == 1)
+                  C(n, i, 0) = a1;
 #endif
-#if(UNROLL==2)
-        C(n,i,0) = a1+a2; 
+#if (UNROLL == 2)
+                  C(n, i, 0) = a1 + a2;
 #endif
-#if(UNROLL==3)
-        C(n,i,0) = a1+a2+a3; 
+#if (UNROLL == 3)
+                  C(n, i, 0) = a1 + a2 + a3;
 #endif
-#if(UNROLL==4)
-        C(n,i,0) = a1+a2+a3+a4; 
+#if (UNROLL == 4)
+                  C(n, i, 0) = a1 + a2 + a3 + a4;
 #endif
-#if(UNROLL==5)
-        C(n,i,0) = a1+a2+a3+a4+a5;
+#if (UNROLL == 5)
+                  C(n, i, 0) = a1 + a2 + a3 + a4 + a5;
 #endif
-#if(UNROLL==6)
-        C(n,i,0) = a1+a2+a3+a4+a5+a6;
+#if (UNROLL == 6)
+                  C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6;
 #endif
-#if(UNROLL==7)
-        C(n,i,0) = a1+a2+a3+a4+a5+a6+a7;
+#if (UNROLL == 7)
+                  C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6 + a7;
 #endif
-#if(UNROLL==8)
-        C(n,i,0) = a1+a2+a3+a4+a5+a6+a7+a8;
+#if (UNROLL == 8)
+                  C(n, i, 0) = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8;
 #endif
+                });
+          }
+        });
+    Kokkos::fence();
+    double seconds = timer.seconds();
 
-      });
-    }
-  });
-  Kokkos::fence(); 
-  double seconds = timer.seconds();
-
-  double bytes = 1.0*N*K*R*3*sizeof(Scalar);
-  double flops = 1.0*N*K*R*(F*2*UNROLL + 2*(UNROLL-1));
-  printf("NKRUFTS: %i %i %i %i %i %i %i Time: %lfs Bandwidth: %lfGiB/s GFlop/s: %lf\n",N,K,R,UNROLL,F,T,S,seconds,1.0*bytes/seconds/1024/1024/1024,1.e-9*flops/seconds);
-}
+    double bytes = 1.0 * N * K * R * 3 * sizeof(Scalar);
+    double flops = 1.0 * N * K * R * (F * 2 * UNROLL + 2 * (UNROLL - 1));
+    printf(
+        "NKRUFTS: %i %i %i %i %i %i %i Time: %lfs Bandwidth: %lfGiB/s GFlop/s: "
+        "%lf\n",
+        N, K, R, UNROLL, F, T, S, seconds,
+        1.0 * bytes / seconds / 1024 / 1024 / 1024, 1.e-9 * flops / seconds);
+  }
 };
-
diff --git a/lib/kokkos/benchmarks/bytes_and_flops/main.cpp b/lib/kokkos/benchmarks/bytes_and_flops/main.cpp
index 4f46b38717df237f0d33c0ac101d105f41f3e9d8..c21a16200e4ed0cf48e8d9e4b1dd25d9753e95c5 100644
--- a/lib/kokkos/benchmarks/bytes_and_flops/main.cpp
+++ b/lib/kokkos/benchmarks/bytes_and_flops/main.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,25 +42,27 @@
 //@HEADER
 */
 
-#include<Kokkos_Core.hpp>
-#include<impl/Kokkos_Timer.hpp>
-#include<bench.hpp>
-#include<cstdlib>
+#include <Kokkos_Core.hpp>
+#include <impl/Kokkos_Timer.hpp>
+#include <bench.hpp>
+#include <cstdlib>
 
 int main(int argc, char* argv[]) {
   Kokkos::initialize();
 
-
-  if(argc<10) {
+  if (argc < 10) {
     printf("Arguments: N K R D U F T S\n");
     printf("  P:   Precision (1==float, 2==double)\n");
     printf("  N,K: dimensions of the 2D array to allocate\n");
     printf("  R:   how often to loop through the K dimension with each team\n");
     printf("  D:   distance between loaded elements (stride)\n");
     printf("  U:   how many independent flops to do per load\n");
-    printf("  F:   how many times to repeat the U unrolled operations before reading next element\n");
+    printf(
+        "  F:   how many times to repeat the U unrolled operations before "
+        "reading next element\n");
     printf("  T:   team size\n");
-    printf("  S:   shared memory per team (used to control occupancy on GPUs)\n");
+    printf(
+        "  S:   shared memory per team (used to control occupancy on GPUs)\n");
     printf("Example Input GPU:\n");
     printf("  Bandwidth Bound : 2 100000 1024 1 1 1 1 256 6000\n");
     printf("  Cache Bound     : 2 100000 1024 64 1 1 1 512 20000\n");
@@ -70,7 +73,6 @@ int main(int argc, char* argv[]) {
     return 0;
   }
 
-
   int P = atoi(argv[1]);
   int N = atoi(argv[2]);
   int K = atoi(argv[3]);
@@ -81,17 +83,25 @@ int main(int argc, char* argv[]) {
   int T = atoi(argv[8]);
   int S = atoi(argv[9]);
 
-  if(U>8) {printf("U must be 1-8\n"); return 0;}
-  if( (D!=1) && (D!=2) && (D!=4) && (D!=8) && (D!=16) && (D!=32)) {printf("D must be one of 1,2,4,8,16,32\n"); return 0;}
-  if( (P!=1) && (P!=2) ) {printf("P must be one of 1,2\n"); return 0;}
+  if (U > 8) {
+    printf("U must be 1-8\n");
+    return 0;
+  }
+  if ((D != 1) && (D != 2) && (D != 4) && (D != 8) && (D != 16) && (D != 32)) {
+    printf("D must be one of 1,2,4,8,16,32\n");
+    return 0;
+  }
+  if ((P != 1) && (P != 2)) {
+    printf("P must be one of 1,2\n");
+    return 0;
+  }
 
-  if(P==1) {
-    run_stride_unroll<float>(N,K,R,D,U,F,T,S);
+  if (P == 1) {
+    run_stride_unroll<float>(N, K, R, D, U, F, T, S);
   }
-  if(P==2) {
-    run_stride_unroll<double>(N,K,R,D,U,F,T,S);
+  if (P == 2) {
+    run_stride_unroll<double>(N, K, R, D, U, F, T, S);
   }
 
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/benchmarks/gather/gather.hpp b/lib/kokkos/benchmarks/gather/gather.hpp
index bbbd65850f75c00a928383d3c6ae2f9af27d7d95..239614184ba13aad35fe54190ce5eaf507c61fde 100644
--- a/lib/kokkos/benchmarks/gather/gather.hpp
+++ b/lib/kokkos/benchmarks/gather/gather.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,52 +42,44 @@
 //@HEADER
 */
 
-template<class Scalar, int UNROLL>
+template <class Scalar, int UNROLL>
 struct RunGather {
   static void run(int N, int K, int D, int R, int F);
 };
 
 #define UNROLL 1
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 #define UNROLL 2
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 #define UNROLL 3
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 #define UNROLL 4
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 #define UNROLL 5
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 #define UNROLL 6
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 #define UNROLL 7
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 #define UNROLL 8
-#include<gather_unroll.hpp>
+#include <gather_unroll.hpp>
 #undef UNROLL
 
-template<class Scalar>
+template <class Scalar>
 void run_gather_test(int N, int K, int D, int R, int U, int F) {
- if(U == 1)
-   RunGather<Scalar,1>::run(N,K,D,R,F);
- if(U == 2)
-   RunGather<Scalar,2>::run(N,K,D,R,F);
- if(U == 3)
-   RunGather<Scalar,3>::run(N,K,D,R,F);
- if(U == 4)
-   RunGather<Scalar,4>::run(N,K,D,R,F);
- if(U == 5)
-   RunGather<Scalar,5>::run(N,K,D,R,F);
- if(U == 6)
-   RunGather<Scalar,6>::run(N,K,D,R,F);
- if(U == 7)
-   RunGather<Scalar,7>::run(N,K,D,R,F);
- if(U == 8)
-   RunGather<Scalar,8>::run(N,K,D,R,F);
+  if (U == 1) RunGather<Scalar, 1>::run(N, K, D, R, F);
+  if (U == 2) RunGather<Scalar, 2>::run(N, K, D, R, F);
+  if (U == 3) RunGather<Scalar, 3>::run(N, K, D, R, F);
+  if (U == 4) RunGather<Scalar, 4>::run(N, K, D, R, F);
+  if (U == 5) RunGather<Scalar, 5>::run(N, K, D, R, F);
+  if (U == 6) RunGather<Scalar, 6>::run(N, K, D, R, F);
+  if (U == 7) RunGather<Scalar, 7>::run(N, K, D, R, F);
+  if (U == 8) RunGather<Scalar, 8>::run(N, K, D, R, F);
 }
diff --git a/lib/kokkos/benchmarks/gather/gather_unroll.hpp b/lib/kokkos/benchmarks/gather/gather_unroll.hpp
index 1d9c99adf9e9909a21be2899f60000713e0208a4..4dc046f99c33125f86d7674f61b38b77caff99c2 100644
--- a/lib/kokkos/benchmarks/gather/gather_unroll.hpp
+++ b/lib/kokkos/benchmarks/gather/gather_unroll.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,129 +42,132 @@
 //@HEADER
 */
 
-#include<Kokkos_Core.hpp>
-#include<Kokkos_Random.hpp>
+#include <Kokkos_Core.hpp>
+#include <Kokkos_Random.hpp>
 
-template<class Scalar>
-struct RunGather<Scalar,UNROLL> {
-static void run(int N, int K, int D, int R, int F) {
-  Kokkos::View<int**> connectivity("Connectivity",N,K);
-  Kokkos::View<Scalar*> A_in("Input",N);
-  Kokkos::View<Scalar*> B_in("Input",N);
-  Kokkos::View<Scalar*> C("Output",N);
+template <class Scalar>
+struct RunGather<Scalar, UNROLL> {
+  static void run(int N, int K, int D, int R, int F) {
+    Kokkos::View<int**> connectivity("Connectivity", N, K);
+    Kokkos::View<Scalar*> A_in("Input", N);
+    Kokkos::View<Scalar*> B_in("Input", N);
+    Kokkos::View<Scalar*> C("Output", N);
 
-  Kokkos::Random_XorShift64_Pool<> rand_pool(12313);
+    Kokkos::Random_XorShift64_Pool<> rand_pool(12313);
 
-  Kokkos::deep_copy(A_in,1.5);
-  Kokkos::deep_copy(B_in,2.0);
+    Kokkos::deep_copy(A_in, 1.5);
+    Kokkos::deep_copy(B_in, 2.0);
 
-  Kokkos::View<const Scalar*, Kokkos::MemoryTraits<Kokkos::RandomAccess> > A(A_in);
-  Kokkos::View<const Scalar*, Kokkos::MemoryTraits<Kokkos::RandomAccess> > B(B_in);
-
-  Kokkos::parallel_for("InitKernel",N,
-      KOKKOS_LAMBDA (const int& i) {
-    auto rand_gen = rand_pool.get_state();
-    for( int jj=0; jj<K; jj++) {
-      connectivity(i,jj) = (rand_gen.rand(D) + i - D/2 + N)%N;
-    }
-    rand_pool.free_state(rand_gen);
-  });
-  Kokkos::fence();
+    Kokkos::View<const Scalar*, Kokkos::MemoryTraits<Kokkos::RandomAccess> > A(
+        A_in);
+    Kokkos::View<const Scalar*, Kokkos::MemoryTraits<Kokkos::RandomAccess> > B(
+        B_in);
 
+    Kokkos::parallel_for(
+        "InitKernel", N, KOKKOS_LAMBDA(const int& i) {
+          auto rand_gen = rand_pool.get_state();
+          for (int jj = 0; jj < K; jj++) {
+            connectivity(i, jj) = (rand_gen.rand(D) + i - D / 2 + N) % N;
+          }
+          rand_pool.free_state(rand_gen);
+        });
+    Kokkos::fence();
 
-  Kokkos::Timer timer;
-  for(int r = 0; r<R; r++) {
-  Kokkos::parallel_for("BenchmarkKernel",N,
-      KOKKOS_LAMBDA (const int& i) {
-      Scalar c = Scalar(0.0);
-      for( int jj=0; jj<K; jj++) {
-        const int j = connectivity(i,jj);
-        Scalar a1 = A(j);
-        const Scalar b = B(j);
-#if(UNROLL>1)
-        Scalar a2 = a1*Scalar(1.3);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          "BenchmarkKernel", N, KOKKOS_LAMBDA(const int& i) {
+            Scalar c = Scalar(0.0);
+            for (int jj = 0; jj < K; jj++) {
+              const int j    = connectivity(i, jj);
+              Scalar a1      = A(j);
+              const Scalar b = B(j);
+#if (UNROLL > 1)
+              Scalar a2 = a1 * Scalar(1.3);
 #endif
-#if(UNROLL>2)
-        Scalar a3 = a2*Scalar(1.1);
+#if (UNROLL > 2)
+              Scalar a3 = a2 * Scalar(1.1);
 #endif
-#if(UNROLL>3)
-        Scalar a4 = a3*Scalar(1.1);
+#if (UNROLL > 3)
+              Scalar a4 = a3 * Scalar(1.1);
 #endif
-#if(UNROLL>4)
-        Scalar a5 = a4*Scalar(1.3);
+#if (UNROLL > 4)
+              Scalar a5 = a4 * Scalar(1.3);
 #endif
-#if(UNROLL>5)
-        Scalar a6 = a5*Scalar(1.1);
+#if (UNROLL > 5)
+              Scalar a6 = a5 * Scalar(1.1);
 #endif
-#if(UNROLL>6)
-        Scalar a7 = a6*Scalar(1.1);
+#if (UNROLL > 6)
+              Scalar a7 = a6 * Scalar(1.1);
 #endif
-#if(UNROLL>7)
-        Scalar a8 = a7*Scalar(1.1);
+#if (UNROLL > 7)
+              Scalar a8 = a7 * Scalar(1.1);
 #endif
 
-
-        for(int f = 0; f<F; f++) {
-          a1 += b*a1;
-#if(UNROLL>1)
-          a2 += b*a2;
+              for (int f = 0; f < F; f++) {
+                a1 += b * a1;
+#if (UNROLL > 1)
+                a2 += b * a2;
 #endif
-#if(UNROLL>2)
-          a3 += b*a3;
+#if (UNROLL > 2)
+                a3 += b * a3;
 #endif
-#if(UNROLL>3)
-          a4 += b*a4;
+#if (UNROLL > 3)
+                a4 += b * a4;
 #endif
-#if(UNROLL>4)
-          a5 += b*a5;
+#if (UNROLL > 4)
+                a5 += b * a5;
 #endif
-#if(UNROLL>5)
-          a6 += b*a6;
+#if (UNROLL > 5)
+                a6 += b * a6;
 #endif
-#if(UNROLL>6)
-          a7 += b*a7;
+#if (UNROLL > 6)
+                a7 += b * a7;
 #endif
-#if(UNROLL>7)
-          a8 += b*a8;
+#if (UNROLL > 7)
+                a8 += b * a8;
 #endif
-
-
-        }
-#if(UNROLL==1)
-        c += a1;
+              }
+#if (UNROLL == 1)
+              c += a1;
 #endif
-#if(UNROLL==2)
-        c += a1+a2;
+#if (UNROLL == 2)
+              c += a1 + a2;
 #endif
-#if(UNROLL==3)
-        c += a1+a2+a3;
+#if (UNROLL == 3)
+              c += a1 + a2 + a3;
 #endif
-#if(UNROLL==4)
-        c += a1+a2+a3+a4;
+#if (UNROLL == 4)
+              c += a1 + a2 + a3 + a4;
 #endif
-#if(UNROLL==5)
-        c += a1+a2+a3+a4+a5;
+#if (UNROLL == 5)
+              c += a1 + a2 + a3 + a4 + a5;
 #endif
-#if(UNROLL==6)
-        c += a1+a2+a3+a4+a5+a6;
+#if (UNROLL == 6)
+              c += a1 + a2 + a3 + a4 + a5 + a6;
 #endif
-#if(UNROLL==7)
-        c += a1+a2+a3+a4+a5+a6+a7;
+#if (UNROLL == 7)
+              c += a1 + a2 + a3 + a4 + a5 + a6 + a7;
 #endif
-#if(UNROLL==8)
-        c += a1+a2+a3+a4+a5+a6+a7+a8;
+#if (UNROLL == 8)
+              c += a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8;
 #endif
+            }
+            C(i) = c;
+          });
+      Kokkos::fence();
+    }
+    double seconds = timer.seconds();
 
-      }
-      C(i) = c ;
-  });
-  Kokkos::fence();
+    double bytes = 1.0 * N * K * R * (2 * sizeof(Scalar) + sizeof(int)) +
+                   1.0 * N * R * sizeof(Scalar);
+    double flops      = 1.0 * N * K * R * (F * 2 * UNROLL + 2 * (UNROLL - 1));
+    double gather_ops = 1.0 * N * K * R * 2;
+    printf(
+        "SNKDRUF: %i %i %i %i %i %i %i Time: %lfs Bandwidth: %lfGiB/s GFlop/s: "
+        "%lf GGather/s: %lf\n",
+        sizeof(Scalar) / 4, N, K, D, R, UNROLL, F, seconds,
+        1.0 * bytes / seconds / 1024 / 1024 / 1024, 1.e-9 * flops / seconds,
+        1.e-9 * gather_ops / seconds);
   }
-  double seconds = timer.seconds();
-
-  double bytes = 1.0*N*K*R*(2*sizeof(Scalar)+sizeof(int)) + 1.0*N*R*sizeof(Scalar);
-  double flops = 1.0*N*K*R*(F*2*UNROLL + 2*(UNROLL-1));
-  double gather_ops = 1.0*N*K*R*2;
-  printf("SNKDRUF: %i %i %i %i %i %i %i Time: %lfs Bandwidth: %lfGiB/s GFlop/s: %lf GGather/s: %lf\n",sizeof(Scalar)/4,N,K,D,R,UNROLL,F,seconds,1.0*bytes/seconds/1024/1024/1024,1.e-9*flops/seconds,1.e-9*gather_ops/seconds);
-}
 };
diff --git a/lib/kokkos/benchmarks/gather/main.cpp b/lib/kokkos/benchmarks/gather/main.cpp
index ca5238e7fdb527e56080f5b76eb6fa7c9487fcd3..6a2db3e024dff5f338aebf2260fc8910aa9764bc 100644
--- a/lib/kokkos/benchmarks/gather/main.cpp
+++ b/lib/kokkos/benchmarks/gather/main.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,23 +42,26 @@
 //@HEADER
 */
 
-#include<Kokkos_Core.hpp>
-#include<impl/Kokkos_Timer.hpp>
-#include<gather.hpp>
-#include<cstdlib>
+#include <Kokkos_Core.hpp>
+#include <impl/Kokkos_Timer.hpp>
+#include <gather.hpp>
+#include <cstdlib>
 
 int main(int argc, char* argv[]) {
-  Kokkos::initialize(argc,argv);
+  Kokkos::initialize(argc, argv);
 
-  if(argc<8) {
+  if (argc < 8) {
     printf("Arguments: S N K D\n");
-    printf("  S:   Scalar Type Size (1==float, 2==double, 4=complex<double>)\n");
+    printf(
+        "  S:   Scalar Type Size (1==float, 2==double, 4=complex<double>)\n");
     printf("  N:   Number of entities\n");
     printf("  K:   Number of things to gather per entity\n");
     printf("  D:   Max distance of gathered things of an entity\n");
     printf("  R:   how often to loop through the K dimension with each team\n");
     printf("  U:   how many independent flops to do per load\n");
-    printf("  F:   how many times to repeat the U unrolled operations before reading next element\n");
+    printf(
+        "  F:   how many times to repeat the U unrolled operations before "
+        "reading next element\n");
     printf("Example Input GPU:\n");
     printf("  Bandwidth Bound : 2 10000000 1 1 10 1 1\n");
     printf("  Cache Bound     : 2 10000000 64 1 10 1 1\n");
@@ -68,7 +72,6 @@ int main(int argc, char* argv[]) {
     return 0;
   }
 
-
   int S = atoi(argv[1]);
   int N = atoi(argv[2]);
   int K = atoi(argv[3]);
@@ -77,17 +80,22 @@ int main(int argc, char* argv[]) {
   int U = atoi(argv[6]);
   int F = atoi(argv[7]);
 
-  if( (S!=1) && (S!=2) && (S!=4)) {printf("S must be one of 1,2,4\n"); return 0;}
-  if( N<D ) {printf("N must be larger or equal to D\n"); return 0; }
-  if(S==1) {
-    run_gather_test<float>(N,K,D,R,U,F);
+  if ((S != 1) && (S != 2) && (S != 4)) {
+    printf("S must be one of 1,2,4\n");
+    return 0;
+  }
+  if (N < D) {
+    printf("N must be larger or equal to D\n");
+    return 0;
+  }
+  if (S == 1) {
+    run_gather_test<float>(N, K, D, R, U, F);
   }
-  if(S==2) {
-    run_gather_test<double>(N,K,D,R,U,F);
+  if (S == 2) {
+    run_gather_test<double>(N, K, D, R, U, F);
   }
-  if(S==4) {
-    run_gather_test<Kokkos::complex<double> >(N,K,D,R,U,F);
+  if (S == 4) {
+    run_gather_test<Kokkos::complex<double> >(N, K, D, R, U, F);
   }
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/benchmarks/gups/gups-kokkos.cc b/lib/kokkos/benchmarks/gups/gups-kokkos.cc
index 4602adda7937cc0dfc8939527353f8936961fed3..9ac59be4a6b348d28d19757f8f0acb7c59686fe2 100644
--- a/lib/kokkos/benchmarks/gups/gups-kokkos.cc
+++ b/lib/kokkos/benchmarks/gups/gups-kokkos.cc
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/benchmarks/policy_performance/main.cpp b/lib/kokkos/benchmarks/policy_performance/main.cpp
index 2f5395734afdcfce41cc43c9b2322de4615a74b1..332e5574dabe3a22e0834f351524ba09487730a5 100644
--- a/lib/kokkos/benchmarks/policy_performance/main.cpp
+++ b/lib/kokkos/benchmarks/policy_performance/main.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,67 +45,86 @@
 #include <Kokkos_Core.hpp>
 #include "policy_perf_test.hpp"
 
-int main(int argc, char* argv[] ) {
-  Kokkos::initialize(argc,argv);
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
 
-  if(argc<10) {
+  if (argc < 10) {
     printf("  Ten arguments are needed to run this program:\n");
-    printf("    (1)team_range, (2)thread_range, (3)vector_range, (4)outer_repeat, (5)thread_repeat, (6)vector_repeat, (7)team_size, (8)vector_size, (9)schedule, (10)test_type\n");
+    printf(
+        "    (1)team_range, (2)thread_range, (3)vector_range, (4)outer_repeat, "
+        "(5)thread_repeat, (6)vector_repeat, (7)team_size, (8)vector_size, "
+        "(9)schedule, (10)test_type\n");
     printf("  team_range:     number of teams (league_size)\n");
     printf("  thread_range:   range for nested TeamThreadRange parallel_*\n");
     printf("  vector_range:   range for nested ThreadVectorRange parallel_*\n");
     printf("  outer_repeat:   number of repeats for outer parallel_* call\n");
-    printf("  thread_repeat:  number of repeats for TeamThreadRange parallel_* call\n");
-    printf("  vector_repeat:  number of repeats for ThreadVectorRange parallel_* call\n");
+    printf(
+        "  thread_repeat:  number of repeats for TeamThreadRange parallel_* "
+        "call\n");
+    printf(
+        "  vector_repeat:  number of repeats for ThreadVectorRange parallel_* "
+        "call\n");
     printf("  team_size:      number of team members (team_size)\n");
     printf("  vector_size:    desired vectorization (if possible)\n");
     printf("  schedule:       1 == Static  2 == Dynamic\n");
-    printf("  test_type:      3-digit code XYZ for testing (nested) parallel_*\n");
-    printf("  code key:       XYZ    X in {1,2,3,4,5}, Y in {0,1,2}, Z in {0,1,2}\n");
+    printf(
+        "  test_type:      3-digit code XYZ for testing (nested) parallel_*\n");
+    printf(
+        "  code key:       XYZ    X in {1,2,3,4,5}, Y in {0,1,2}, Z in "
+        "{0,1,2}\n");
     printf("                  TeamPolicy:\n");
-    printf("                    X: 0 = none (never used, makes no sense); 1 = parallel_for; 2 = parallel_reduce\n");
-    printf("                    Y: 0 = none; 1 = parallel_for; 2 = parallel_reduce\n");
-    printf("                    Z: 0 = none; 1 = parallel_for; 2 = parallel_reduce\n");
+    printf(
+        "                    X: 0 = none (never used, makes no sense); 1 = "
+        "parallel_for; 2 = parallel_reduce\n");
+    printf(
+        "                    Y: 0 = none; 1 = parallel_for; 2 = "
+        "parallel_reduce\n");
+    printf(
+        "                    Z: 0 = none; 1 = parallel_for; 2 = "
+        "parallel_reduce\n");
     printf("                  RangePolicy:\n");
-    printf("                    X: 3 = parallel_for; 4 = parallel_reduce; 5 = parallel_scan\n");
+    printf(
+        "                    X: 3 = parallel_for; 4 = parallel_reduce; 5 = "
+        "parallel_scan\n");
     printf("                    Y: 0 = none\n");
     printf("                    Z: 0 = none\n");
     printf("  Example Input:\n");
-    printf("  100000 32 32 100 100 100 8 1 1 100\n"); 
+    printf("  100000 32 32 100 100 100 8 1 1 100\n");
     Kokkos::finalize();
     return 0;
   }
 
-  int team_range = atoi(argv[1]);
+  int team_range   = atoi(argv[1]);
   int thread_range = atoi(argv[2]);
   int vector_range = atoi(argv[3]);
 
-  int outer_repeat = atoi(argv[4]);
+  int outer_repeat  = atoi(argv[4]);
   int thread_repeat = atoi(argv[5]);
   int vector_repeat = atoi(argv[6]);
 
-  int team_size = atoi(argv[7]);
+  int team_size   = atoi(argv[7]);
   int vector_size = atoi(argv[8]);
-  int schedule = atoi(argv[9]);
-  int test_type = atoi(argv[10]);
+  int schedule    = atoi(argv[9]);
+  int test_type   = atoi(argv[10]);
 
-  int disable_verbose_output = 0; 
-  if ( argc > 11 ) {
+  int disable_verbose_output = 0;
+  if (argc > 11) {
     disable_verbose_output = atoi(argv[11]);
   }
 
-  if ( schedule != 1 && schedule != 2 ) {
+  if (schedule != 1 && schedule != 2) {
     printf("schedule: %d\n", schedule);
     printf("Options for schedule are: 1 == Static  2 == Dynamic\n");
     Kokkos::finalize();
     return -1;
   }
 
-  if ( test_type != 100 && test_type != 110 && test_type != 111 && test_type != 112 && test_type != 120  && test_type != 121  && test_type != 122
-     && test_type != 200 && test_type != 210 && test_type != 211 && test_type != 212 && test_type != 220  && test_type != 221  && test_type != 222
-     && test_type != 300 && test_type != 400 && test_type != 500
-     )
-  {
+  if (test_type != 100 && test_type != 110 && test_type != 111 &&
+      test_type != 112 && test_type != 120 && test_type != 121 &&
+      test_type != 122 && test_type != 200 && test_type != 210 &&
+      test_type != 211 && test_type != 212 && test_type != 220 &&
+      test_type != 221 && test_type != 222 && test_type != 300 &&
+      test_type != 400 && test_type != 500) {
     printf("Incorrect test_type option\n");
     Kokkos::finalize();
     return -2;
@@ -112,56 +132,85 @@ int main(int argc, char* argv[] ) {
 
   double result = 0.0;
 
-  Kokkos::parallel_reduce( "parallel_reduce warmup", Kokkos::TeamPolicy<>(10,1), 
-    KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type team, double& lval) {
-      lval += 1;
-    }, result);
+  Kokkos::parallel_reduce(
+      "parallel_reduce warmup", Kokkos::TeamPolicy<>(10, 1),
+      KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type team,
+                    double& lval) { lval += 1; },
+      result);
 
-  typedef Kokkos::View<double*, Kokkos::LayoutRight>   view_type_1d;
-  typedef Kokkos::View<double**, Kokkos::LayoutRight>  view_type_2d;
+  typedef Kokkos::View<double*, Kokkos::LayoutRight> view_type_1d;
+  typedef Kokkos::View<double**, Kokkos::LayoutRight> view_type_2d;
   typedef Kokkos::View<double***, Kokkos::LayoutRight> view_type_3d;
 
   // Allocate view without initializing
-  // Call a 'warmup' test with 1 repeat - this will initialize the corresponding view appropriately for test and should obey first-touch etc
-  // Second call to test is the one we actually care about and time
-  view_type_1d v_1( Kokkos::ViewAllocateWithoutInitializing("v_1"), team_range*team_size);
-  view_type_2d v_2( Kokkos::ViewAllocateWithoutInitializing("v_2"), team_range*team_size, thread_range);
-  view_type_3d v_3( Kokkos::ViewAllocateWithoutInitializing("v_3"), team_range*team_size, thread_range, vector_range);
+  // Call a 'warmup' test with 1 repeat - this will initialize the corresponding
+  // view appropriately for test and should obey first-touch etc Second call to
+  // test is the one we actually care about and time
+  view_type_1d v_1(Kokkos::ViewAllocateWithoutInitializing("v_1"),
+                   team_range * team_size);
+  view_type_2d v_2(Kokkos::ViewAllocateWithoutInitializing("v_2"),
+                   team_range * team_size, thread_range);
+  view_type_3d v_3(Kokkos::ViewAllocateWithoutInitializing("v_3"),
+                   team_range * team_size, thread_range, vector_range);
 
   double result_computed = 0.0;
-  double result_expect = 0.0;
-  double time = 0.0;
+  double result_expect   = 0.0;
+  double time            = 0.0;
 
-  if(schedule==1) {
-    if ( test_type != 500 ) {
+  if (schedule == 1) {
+    if (test_type != 500) {
       // warmup - no repeat of loops
-      test_policy<Kokkos::Schedule<Kokkos::Static>,int>(team_range,thread_range,vector_range,1,1,1,team_size,vector_size,test_type,v_1,v_2,v_3,result_computed,result_expect,time);
-      test_policy<Kokkos::Schedule<Kokkos::Static>,int>(team_range,thread_range,vector_range,outer_repeat,thread_repeat,vector_repeat,team_size,vector_size,test_type,v_1,v_2,v_3,result_computed,result_expect,time);
-    }
-    else {
+      test_policy<Kokkos::Schedule<Kokkos::Static>, int>(
+          team_range, thread_range, vector_range, 1, 1, 1, team_size,
+          vector_size, test_type, v_1, v_2, v_3, result_computed, result_expect,
+          time);
+      test_policy<Kokkos::Schedule<Kokkos::Static>, int>(
+          team_range, thread_range, vector_range, outer_repeat, thread_repeat,
+          vector_repeat, team_size, vector_size, test_type, v_1, v_2, v_3,
+          result_computed, result_expect, time);
+    } else {
       // parallel_scan: initialize 1d view for parallel_scan
-      test_policy<Kokkos::Schedule<Kokkos::Static>,int>(team_range,thread_range,vector_range,1,1,1,team_size,vector_size,100,v_1,v_2,v_3,result_computed,result_expect,time);
-      test_policy<Kokkos::Schedule<Kokkos::Static>,int>(team_range,thread_range,vector_range,outer_repeat,thread_repeat,vector_repeat,team_size,vector_size,test_type,v_1,v_2,v_3,result_computed,result_expect,time);
+      test_policy<Kokkos::Schedule<Kokkos::Static>, int>(
+          team_range, thread_range, vector_range, 1, 1, 1, team_size,
+          vector_size, 100, v_1, v_2, v_3, result_computed, result_expect,
+          time);
+      test_policy<Kokkos::Schedule<Kokkos::Static>, int>(
+          team_range, thread_range, vector_range, outer_repeat, thread_repeat,
+          vector_repeat, team_size, vector_size, test_type, v_1, v_2, v_3,
+          result_computed, result_expect, time);
     }
   }
-  if(schedule==2) {
-    if ( test_type != 500 ) {
+  if (schedule == 2) {
+    if (test_type != 500) {
       // warmup - no repeat of loops
-      test_policy<Kokkos::Schedule<Kokkos::Dynamic>,int>(team_range,thread_range,vector_range,1,1,1,team_size,vector_size,test_type,v_1,v_2,v_3,result_computed,result_expect,time);
-      test_policy<Kokkos::Schedule<Kokkos::Dynamic>,int>(team_range,thread_range,vector_range,outer_repeat,thread_repeat,vector_repeat,team_size,vector_size,test_type,v_1,v_2,v_3,result_computed,result_expect,time);
-    }
-    else {
+      test_policy<Kokkos::Schedule<Kokkos::Dynamic>, int>(
+          team_range, thread_range, vector_range, 1, 1, 1, team_size,
+          vector_size, test_type, v_1, v_2, v_3, result_computed, result_expect,
+          time);
+      test_policy<Kokkos::Schedule<Kokkos::Dynamic>, int>(
+          team_range, thread_range, vector_range, outer_repeat, thread_repeat,
+          vector_repeat, team_size, vector_size, test_type, v_1, v_2, v_3,
+          result_computed, result_expect, time);
+    } else {
       // parallel_scan: initialize 1d view for parallel_scan
-      test_policy<Kokkos::Schedule<Kokkos::Static>,int>(team_range,thread_range,vector_range,1,1,1,team_size,vector_size,100,v_1,v_2,v_3,result_computed,result_expect,time);
-      test_policy<Kokkos::Schedule<Kokkos::Static>,int>(team_range,thread_range,vector_range,outer_repeat,thread_repeat,vector_repeat,team_size,vector_size,test_type,v_1,v_2,v_3,result_computed,result_expect,time);
+      test_policy<Kokkos::Schedule<Kokkos::Static>, int>(
+          team_range, thread_range, vector_range, 1, 1, 1, team_size,
+          vector_size, 100, v_1, v_2, v_3, result_computed, result_expect,
+          time);
+      test_policy<Kokkos::Schedule<Kokkos::Static>, int>(
+          team_range, thread_range, vector_range, outer_repeat, thread_repeat,
+          vector_repeat, team_size, vector_size, test_type, v_1, v_2, v_3,
+          result_computed, result_expect, time);
     }
   }
 
-  if ( disable_verbose_output == 0 ) {
-    printf("%7i %4i %2i %9i %4i %4i %4i %2i %1i %3i %e %e %lf\n",team_range,thread_range,vector_range,outer_repeat,thread_repeat,vector_repeat,team_size,vector_size,schedule,test_type,result_computed,result_expect,time);
-  }
-  else {
-    printf("%lf\n",time);
+  if (disable_verbose_output == 0) {
+    printf("%7i %4i %2i %9i %4i %4i %4i %2i %1i %3i %e %e %lf\n", team_range,
+           thread_range, vector_range, outer_repeat, thread_repeat,
+           vector_repeat, team_size, vector_size, schedule, test_type,
+           result_computed, result_expect, time);
+  } else {
+    printf("%lf\n", time);
   }
 
   Kokkos::finalize();
diff --git a/lib/kokkos/benchmarks/policy_performance/policy_perf_test.hpp b/lib/kokkos/benchmarks/policy_performance/policy_perf_test.hpp
index 1ab437928de761bed614efc8a22d8c4d38fcf38f..7a1500891f7af1d2ff5ce61ebb83637d20c43cb4 100644
--- a/lib/kokkos/benchmarks/policy_performance/policy_perf_test.hpp
+++ b/lib/kokkos/benchmarks/policy_performance/policy_perf_test.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,297 +44,375 @@
 
 #include <Kokkos_Core.hpp>
 
-template < class ViewType >
+template <class ViewType>
 struct ParallelScanFunctor {
   using value_type = double;
   ViewType v;
 
-  ParallelScanFunctor( const ViewType & v_ )
-    : v(v_)
-  {}
+  ParallelScanFunctor(const ViewType& v_) : v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-    void operator()( const int idx, value_type& val, const bool& final ) const
-    {
-      // inclusive scan
-      val += v(idx);
-      if ( final ) {
-        v(idx) = val;
-      }
+  void operator()(const int idx, value_type& val, const bool& final) const {
+    // inclusive scan
+    val += v(idx);
+    if (final) {
+      v(idx) = val;
     }
+  }
 };
 
-template<class ScheduleType,class IndexType,class ViewType1, class ViewType2, class ViewType3>
+template <class ScheduleType, class IndexType, class ViewType1, class ViewType2,
+          class ViewType3>
 void test_policy(int team_range, int thread_range, int vector_range,
-          int outer_repeat, int thread_repeat, int inner_repeat,
-          int team_size, int vector_size, int test_type,
-          ViewType1 &v1, ViewType2 &v2, ViewType3 &v3,
-          double &result, double &result_expect, double &time) {
-
-  typedef Kokkos::TeamPolicy<ScheduleType,IndexType> t_policy;
+                 int outer_repeat, int thread_repeat, int inner_repeat,
+                 int team_size, int vector_size, int test_type, ViewType1& v1,
+                 ViewType2& v2, ViewType3& v3, double& result,
+                 double& result_expect, double& time) {
+  typedef Kokkos::TeamPolicy<ScheduleType, IndexType> t_policy;
   typedef typename t_policy::member_type t_team;
   Kokkos::Timer timer;
 
-  for(int orep = 0; orep<outer_repeat; orep++) {
-
+  for (int orep = 0; orep < outer_repeat; orep++) {
     if (test_type == 100) {
-      Kokkos::parallel_for("100 outer for", t_policy(team_range,team_size),
-        KOKKOS_LAMBDA (const t_team& team) {
-          long idx = team.league_rank()*team.team_size() + team.team_rank();
-          v1(idx) = idx;
-          // prevent compiler optimizing loop away
-      });
+      Kokkos::parallel_for(
+          "100 outer for", t_policy(team_range, team_size),
+          KOKKOS_LAMBDA(const t_team& team) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            v1(idx)  = idx;
+            // prevent compiler optimizing loop away
+          });
     }
 
     if (test_type == 110) {
-      Kokkos::parallel_for("110 outer for", t_policy(team_range,team_size),
-        KOKKOS_LAMBDA (const t_team& team) {
-          long idx = team.league_rank()*team.team_size() + team.team_rank();
-          for (int tr = 0; tr<thread_repeat; ++tr) {
-            // Each team launches a parallel_for; thread_range is partitioned among team members
-            Kokkos::parallel_for(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t) {
-              v2( idx, t ) = t;
-              // prevent compiler optimizing loop away
-            });
-          }
-      });
+      Kokkos::parallel_for(
+          "110 outer for", t_policy(team_range, team_size),
+          KOKKOS_LAMBDA(const t_team& team) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            for (int tr = 0; tr < thread_repeat; ++tr) {
+              // Each team launches a parallel_for; thread_range is partitioned
+              // among team members
+              Kokkos::parallel_for(Kokkos::TeamThreadRange(team, thread_range),
+                                   [&](const int t) {
+                                     v2(idx, t) = t;
+                                     // prevent compiler optimizing loop away
+                                   });
+            }
+          });
     }
     if (test_type == 111) {
-      Kokkos::parallel_for("111 outer for", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team) {
-          long idx = team.league_rank()*team.team_size() + team.team_rank();
-          for (int tr = 0; tr<thread_repeat; ++tr) {
-            // Each team launches a parallel_for; thread_range is partitioned among team members
-            Kokkos::parallel_for(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t) {
-              for (int vr = 0; vr<inner_repeat; ++vr)
-                Kokkos::parallel_for(Kokkos::ThreadVectorRange(team,vector_range), [&] (const int vi) {
-                  v3( idx, t, vi ) = vi;
-                  // prevent compiler optimizing loop away
-                });
-            });
-          }
-      });
+      Kokkos::parallel_for(
+          "111 outer for", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            for (int tr = 0; tr < thread_repeat; ++tr) {
+              // Each team launches a parallel_for; thread_range is partitioned
+              // among team members
+              Kokkos::parallel_for(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t) {
+                    for (int vr = 0; vr < inner_repeat; ++vr)
+                      Kokkos::parallel_for(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi) {
+                            v3(idx, t, vi) = vi;
+                            // prevent compiler optimizing loop away
+                          });
+                  });
+            }
+          });
     }
     if (test_type == 112) {
-      Kokkos::parallel_for("112 outer for", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team) {
-          long idx = team.league_rank()*team.team_size() + team.team_rank();
-          for (int tr = 0; tr<thread_repeat; ++tr) {
-            // Each team launches a parallel_for; thread_range is partitioned among team members
-            Kokkos::parallel_for(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t) {
-              double vector_result = 0.0;
-              for (int vr = 0; vr<inner_repeat; ++vr) {
-                vector_result = 0.0;
-                Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(team,vector_range), [&] (const int vi, double &vval) {
-                  vval += 1;
-                }, vector_result);
-              }
-              v2( idx, t ) = vector_result;
-              // prevent compiler optimizing loop away
-            });
-          }
-      });
+      Kokkos::parallel_for(
+          "112 outer for", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            for (int tr = 0; tr < thread_repeat; ++tr) {
+              // Each team launches a parallel_for; thread_range is partitioned
+              // among team members
+              Kokkos::parallel_for(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t) {
+                    double vector_result = 0.0;
+                    for (int vr = 0; vr < inner_repeat; ++vr) {
+                      vector_result = 0.0;
+                      Kokkos::parallel_reduce(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi, double& vval) { vval += 1; },
+                          vector_result);
+                    }
+                    v2(idx, t) = vector_result;
+                    // prevent compiler optimizing loop away
+                  });
+            }
+          });
     }
     if (test_type == 120) {
-      Kokkos::parallel_for("120 outer for", t_policy(team_range,team_size),
-        KOKKOS_LAMBDA (const t_team& team) {
-          long idx = team.league_rank()*team.team_size() + team.team_rank();
-          double team_result = 0.0;
-          for (int tr = 0; tr<thread_repeat; ++tr) {
-            team_result = 0.0;
-            Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t, double &lval) {
-              lval += 1;
-            }, team_result);
-          }
-          v1(idx) = team_result;
-          // prevent compiler optimizing loop away
-      });
+      Kokkos::parallel_for(
+          "120 outer for", t_policy(team_range, team_size),
+          KOKKOS_LAMBDA(const t_team& team) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            double team_result = 0.0;
+            for (int tr = 0; tr < thread_repeat; ++tr) {
+              team_result = 0.0;
+              Kokkos::parallel_reduce(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t, double& lval) { lval += 1; }, team_result);
+            }
+            v1(idx) = team_result;
+            // prevent compiler optimizing loop away
+          });
     }
     if (test_type == 121) {
-      Kokkos::parallel_for("121 outer for", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team) {
-          long idx = team.league_rank()*team.team_size() + team.team_rank();
-          double team_result = 0.0;
-          for (int tr = 0; tr<thread_repeat; ++tr) {
-            team_result = 0.0;
-            Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t, double &lval) {
-              lval += 1;
-              for (int vr = 0; vr<inner_repeat; ++vr) {
-                Kokkos::parallel_for(Kokkos::ThreadVectorRange(team,vector_range), [&] (const int vi) {
-                  v3( idx, t, vi ) = vi;
-                  // prevent compiler optimizing loop away
-                });
-              }
-            }, team_result);
-          }
-          v3( idx, 0, 0 ) = team_result;
-          // prevent compiler optimizing loop away
-      });
+      Kokkos::parallel_for(
+          "121 outer for", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            double team_result = 0.0;
+            for (int tr = 0; tr < thread_repeat; ++tr) {
+              team_result = 0.0;
+              Kokkos::parallel_reduce(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t, double& lval) {
+                    lval += 1;
+                    for (int vr = 0; vr < inner_repeat; ++vr) {
+                      Kokkos::parallel_for(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi) {
+                            v3(idx, t, vi) = vi;
+                            // prevent compiler optimizing loop away
+                          });
+                    }
+                  },
+                  team_result);
+            }
+            v3(idx, 0, 0) = team_result;
+            // prevent compiler optimizing loop away
+          });
     }
     if (test_type == 122) {
-      Kokkos::parallel_for("122 outer for", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team) {
-          long idx = team.league_rank()*team.team_size() + team.team_rank();
-          double team_result = 0.0;
-          for (int tr = 0; tr<thread_repeat; ++tr) {
-            Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t, double &lval) {
-              double vector_result = 0.0;
-              for (int vr = 0; vr<inner_repeat; ++vr) {
-                vector_result = 0.0;
-                Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(team,vector_range), [&] (const int vi, double &vval) {
-                  vval += 1;
-                }, vector_result);
-                lval += vector_result;
-              }
-            }, team_result);
-          }
-          v1(idx) = team_result;
-          // prevent compiler optimizing loop away
-      });
+      Kokkos::parallel_for(
+          "122 outer for", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            double team_result = 0.0;
+            for (int tr = 0; tr < thread_repeat; ++tr) {
+              Kokkos::parallel_reduce(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t, double& lval) {
+                    double vector_result = 0.0;
+                    for (int vr = 0; vr < inner_repeat; ++vr) {
+                      vector_result = 0.0;
+                      Kokkos::parallel_reduce(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi, double& vval) { vval += 1; },
+                          vector_result);
+                      lval += vector_result;
+                    }
+                  },
+                  team_result);
+            }
+            v1(idx) = team_result;
+            // prevent compiler optimizing loop away
+          });
     }
     if (test_type == 200) {
-      Kokkos::parallel_reduce("200 outer reduce", t_policy(team_range,team_size),
-        KOKKOS_LAMBDA (const t_team& team, double& lval) {
-          lval+=team.team_size()*team.league_rank() + team.team_rank();
-      },result);
-      result_expect = 0.5* (team_range*team_size)*(team_range*team_size-1);
+      Kokkos::parallel_reduce(
+          "200 outer reduce", t_policy(team_range, team_size),
+          KOKKOS_LAMBDA(const t_team& team, double& lval) {
+            lval += team.team_size() * team.league_rank() + team.team_rank();
+          },
+          result);
+      result_expect =
+          0.5 * (team_range * team_size) * (team_range * team_size - 1);
       // sum ( seq( [0, team_range*team_size) )
     }
     if (test_type == 210) {
-      Kokkos::parallel_reduce("210 outer reduce", t_policy(team_range,team_size),
-        KOKKOS_LAMBDA (const t_team& team, double& lval) {
-        long idx = team.league_rank()*team.team_size() + team.team_rank();
-        double thread_for = 1.0;
-        for(int tr = 0; tr<thread_repeat; tr++) {
-          Kokkos::parallel_for(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t) {
-            v2(idx,t) = t;
-            // prevent compiler optimizing loop away
-          });
-        }
-        lval+=(team.team_size()*team.league_rank() + team.team_rank() + thread_for);
-      },result);
-      result_expect = 0.5* (team_range*team_size)*(team_range*team_size-1) + (team_range*team_size);
-      // sum ( seq( [0, team_range*team_size) + 1 per team_member (total of team_range*team_size) )
+      Kokkos::parallel_reduce(
+          "210 outer reduce", t_policy(team_range, team_size),
+          KOKKOS_LAMBDA(const t_team& team, double& lval) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            double thread_for = 1.0;
+            for (int tr = 0; tr < thread_repeat; tr++) {
+              Kokkos::parallel_for(Kokkos::TeamThreadRange(team, thread_range),
+                                   [&](const int t) {
+                                     v2(idx, t) = t;
+                                     // prevent compiler optimizing loop away
+                                   });
+            }
+            lval += (team.team_size() * team.league_rank() + team.team_rank() +
+                     thread_for);
+          },
+          result);
+      result_expect =
+          0.5 * (team_range * team_size) * (team_range * team_size - 1) +
+          (team_range * team_size);
+      // sum ( seq( [0, team_range*team_size) + 1 per team_member (total of
+      // team_range*team_size) )
     }
     if (test_type == 211) {
-      Kokkos::parallel_reduce("211 outer reduce", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team, double& lval) {
-        long idx = team.league_rank()*team.team_size() + team.team_rank();
-        double thread_for = 1.0;
-        for(int tr = 0; tr<thread_repeat; tr++) {
-          Kokkos::parallel_for(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t) {
-            for (int vr = 0; vr<inner_repeat; ++vr)
-              Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, vector_range), [&] (const int vi) {
-                v3(idx, t, vi) = vi;
-                // prevent compiler optimizing loop away
-              });
-          });
-        }
-        lval+=idx+thread_for;
-      },result);
-      result_expect = 0.5*(team_range*team_size)*(team_range*team_size-1) + (team_range*team_size);
-      // sum ( seq( [0, team_range*team_size) + 1 per team_member (total of team_range*team_size) )
+      Kokkos::parallel_reduce(
+          "211 outer reduce", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team, double& lval) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            double thread_for = 1.0;
+            for (int tr = 0; tr < thread_repeat; tr++) {
+              Kokkos::parallel_for(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t) {
+                    for (int vr = 0; vr < inner_repeat; ++vr)
+                      Kokkos::parallel_for(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi) {
+                            v3(idx, t, vi) = vi;
+                            // prevent compiler optimizing loop away
+                          });
+                  });
+            }
+            lval += idx + thread_for;
+          },
+          result);
+      result_expect =
+          0.5 * (team_range * team_size) * (team_range * team_size - 1) +
+          (team_range * team_size);
+      // sum ( seq( [0, team_range*team_size) + 1 per team_member (total of
+      // team_range*team_size) )
     }
     if (test_type == 212) {
-      Kokkos::parallel_reduce("212 outer reduce", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team, double& lval) {
-        long idx = team.league_rank()*team.team_size() + team.team_rank();
-        double vector_result = 0.0;
-        for(int tr = 0; tr<thread_repeat; tr++) {
-          // This parallel_for is executed by each team; the thread_range is partitioned among the team members
-          Kokkos::parallel_for(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t) {
-            v2(idx,t) = t;
-            // prevent compiler optimizing loop away
-            for (int vr = 0; vr<inner_repeat; ++vr) {
-              vector_result = 0.0;
-              Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(team, vector_range), [&] (const int vi, double &vval) {
-                vval += vi;
-              }, vector_result );
+      Kokkos::parallel_reduce(
+          "212 outer reduce", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team, double& lval) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            double vector_result = 0.0;
+            for (int tr = 0; tr < thread_repeat; tr++) {
+              // This parallel_for is executed by each team; the thread_range is
+              // partitioned among the team members
+              Kokkos::parallel_for(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t) {
+                    v2(idx, t) = t;
+                    // prevent compiler optimizing loop away
+                    for (int vr = 0; vr < inner_repeat; ++vr) {
+                      vector_result = 0.0;
+                      Kokkos::parallel_reduce(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi, double& vval) { vval += vi; },
+                          vector_result);
+                    }
+                  });
             }
-          });
-        }
-        lval+= idx + vector_result;
-      },result);
-      result_expect = 0.5*(team_range*team_size)*(team_range*team_size-1) + (0.5*vector_range*(vector_range-1)*team_range*team_size);
-      // sum ( seq( [0, team_range*team_size) + sum( seq( [0, vector_range) ) per team_member (total of team_range*team_size) )
+            lval += idx + vector_result;
+          },
+          result);
+      result_expect =
+          0.5 * (team_range * team_size) * (team_range * team_size - 1) +
+          (0.5 * vector_range * (vector_range - 1) * team_range * team_size);
+      // sum ( seq( [0, team_range*team_size) + sum( seq( [0, vector_range) )
+      // per team_member (total of team_range*team_size) )
     }
     if (test_type == 220) {
-      Kokkos::parallel_reduce("220 outer reduce", t_policy(team_range,team_size),
-        KOKKOS_LAMBDA (const t_team& team, double& lval) {
-        double team_result = 0.0;
-        for(int tr = 0; tr<thread_repeat; tr++) {
-          Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t, double& tval) {
-            tval += t;
-          },team_result);
-        }
-        lval+=team_result*team.league_rank(); // constant * league_rank
-      },result);
-      result_expect = 0.5*(team_range)*(team_range-1) * team_size * 0.5*(thread_range)*(thread_range-1);
-      // sum ( seq( [0, team_range) * constant ); constant = sum( seq( [0, thread_range) )*team_size (1 per member, result for each team)
+      Kokkos::parallel_reduce(
+          "220 outer reduce", t_policy(team_range, team_size),
+          KOKKOS_LAMBDA(const t_team& team, double& lval) {
+            double team_result = 0.0;
+            for (int tr = 0; tr < thread_repeat; tr++) {
+              Kokkos::parallel_reduce(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t, double& tval) { tval += t; }, team_result);
+            }
+            lval += team_result * team.league_rank();  // constant * league_rank
+          },
+          result);
+      result_expect = 0.5 * (team_range) * (team_range - 1) * team_size * 0.5 *
+                      (thread_range) * (thread_range - 1);
+      // sum ( seq( [0, team_range) * constant ); constant = sum( seq( [0,
+      // thread_range) )*team_size (1 per member, result for each team)
     }
     if (test_type == 221) {
-      Kokkos::parallel_reduce("221 outer reduce", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team, double& lval) {
-        long idx = team.league_rank()*team.team_size() + team.team_rank();
-        double team_result = 0;
-        for(int tr = 0; tr<thread_repeat; tr++) {
-          Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t, double& tval) {
-            double vector_for = 1.0;
-            for (int vr = 0; vr<inner_repeat; ++vr) {
-              Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, vector_range), [&] (const int vi) {
-                v3(idx, t, vi) = vi;
-                // prevent compiler optimizing loop away
-              });
+      Kokkos::parallel_reduce(
+          "221 outer reduce", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team, double& lval) {
+            long idx = team.league_rank() * team.team_size() + team.team_rank();
+            double team_result = 0;
+            for (int tr = 0; tr < thread_repeat; tr++) {
+              Kokkos::parallel_reduce(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t, double& tval) {
+                    double vector_for = 1.0;
+                    for (int vr = 0; vr < inner_repeat; ++vr) {
+                      Kokkos::parallel_for(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi) {
+                            v3(idx, t, vi) = vi;
+                            // prevent compiler optimizing loop away
+                          });
+                    }
+                    tval += t + vector_for;
+                  },
+                  team_result);
             }
-            tval += t + vector_for;
-          },team_result);
-        }
-        lval+=team_result*team.league_rank();
-      },result);
-      result_expect = 0.5* (team_range)*(team_range-1) * team_size * (0.5*(thread_range) * (thread_range-1) + thread_range);
-      // sum ( seq( [0, team_range) * constant ) + 1 per member per team; constant = sum( seq( [0, thread_range) )*team_size (1 per member, result for each team)
+            lval += team_result * team.league_rank();
+          },
+          result);
+      result_expect =
+          0.5 * (team_range) * (team_range - 1) * team_size *
+          (0.5 * (thread_range) * (thread_range - 1) + thread_range);
+      // sum ( seq( [0, team_range) * constant ) + 1 per member per team;
+      // constant = sum( seq( [0, thread_range) )*team_size (1 per member,
+      // result for each team)
     }
     if (test_type == 222) {
-      Kokkos::parallel_reduce("222 outer reduce", t_policy(team_range,team_size,vector_size),
-        KOKKOS_LAMBDA (const t_team& team, double& lval) {
-        double team_result = 0.0;
-        for(int tr = 0; tr<thread_repeat; tr++) {
-          Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,thread_range), [&] (const int t, double& tval) {
-            double vector_result = 0.0;
-            for (int vr = 0; vr<inner_repeat; ++vr) {
-              Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(team, vector_range), [&] (const int vi, double& vval) {
-                vval += vi;
-              }, vector_result);
+      Kokkos::parallel_reduce(
+          "222 outer reduce", t_policy(team_range, team_size, vector_size),
+          KOKKOS_LAMBDA(const t_team& team, double& lval) {
+            double team_result = 0.0;
+            for (int tr = 0; tr < thread_repeat; tr++) {
+              Kokkos::parallel_reduce(
+                  Kokkos::TeamThreadRange(team, thread_range),
+                  [&](const int t, double& tval) {
+                    double vector_result = 0.0;
+                    for (int vr = 0; vr < inner_repeat; ++vr) {
+                      Kokkos::parallel_reduce(
+                          Kokkos::ThreadVectorRange(team, vector_range),
+                          [&](const int vi, double& vval) { vval += vi; },
+                          vector_result);
+                    }
+                    tval += t + vector_result;
+                  },
+                  team_result);
             }
-            tval += t + vector_result;
-          },team_result);
-        }
-        lval+=team_result*team.league_rank();
-      },result);
-      result_expect = 0.5* (team_range)*(team_range-1) * team_size * (0.5*(thread_range) * (thread_range-1) + thread_range*0.5*(vector_range)*(vector_range-1));
-      // sum ( seq( [0, team_range) * constant ) + 1 + sum( seq([0,vector_range) ) per member per team; constant = sum( seq( [0, thread_range) )*team_size (1 per member, result for each team)
+            lval += team_result * team.league_rank();
+          },
+          result);
+      result_expect =
+          0.5 * (team_range) * (team_range - 1) * team_size *
+          (0.5 * (thread_range) * (thread_range - 1) +
+           thread_range * 0.5 * (vector_range) * (vector_range - 1));
+      // sum ( seq( [0, team_range) * constant ) + 1 + sum( seq([0,vector_range)
+      // ) per member per team; constant = sum( seq( [0, thread_range)
+      // )*team_size (1 per member, result for each team)
     }
 
     // parallel_for RangePolicy: range = team_size*team_range
     if (test_type == 300) {
-      Kokkos::parallel_for("300 outer for", team_size*team_range,
-        KOKKOS_LAMBDA (const int idx) {
-          v1(idx) = idx;
-          // prevent compiler from optimizing away the loop
-      });
+      Kokkos::parallel_for(
+          "300 outer for", team_size * team_range,
+          KOKKOS_LAMBDA(const int idx) {
+            v1(idx) = idx;
+            // prevent compiler from optimizing away the loop
+          });
     }
     // parallel_reduce RangePolicy: range = team_size*team_range
     if (test_type == 400) {
-      Kokkos::parallel_reduce("400 outer reduce", team_size*team_range,
-        KOKKOS_LAMBDA (const int idx, double& val) {
-          val += idx;
-      }, result);
-      result_expect = 0.5*(team_size*team_range)*(team_size*team_range-1);
+      Kokkos::parallel_reduce(
+          "400 outer reduce", team_size * team_range,
+          KOKKOS_LAMBDA(const int idx, double& val) { val += idx; }, result);
+      result_expect =
+          0.5 * (team_size * team_range) * (team_size * team_range - 1);
     }
     // parallel_scan RangePolicy: range = team_size*team_range
     if (test_type == 500) {
-      Kokkos::parallel_scan("500 outer scan", team_size*team_range,
-        ParallelScanFunctor<ViewType1>(v1)
+      Kokkos::parallel_scan("500 outer scan", team_size * team_range,
+                            ParallelScanFunctor<ViewType1>(v1)
 #if 0
         // This does not compile with pre Cuda 8.0 - see Github Issue #913 for explanation
         KOKKOS_LAMBDA (const int idx, double& val, const bool& final) {
@@ -345,11 +424,12 @@ void test_policy(int team_range, int thread_range, int vector_range,
         }
 #endif
       );
-      // result = v1( team_size*team_range - 1 ); // won't work with Cuda - need to copy result back to host to print
-      // result_expect = 0.5*(team_size*team_range)*(team_size*team_range-1);
+      // result = v1( team_size*team_range - 1 ); // won't work with Cuda - need
+      // to copy result back to host to print result_expect =
+      // 0.5*(team_size*team_range)*(team_size*team_range-1);
     }
 
-  } // end outer for loop
+  }  // end outer for loop
 
   time = timer.seconds();
-} //end test_policy
+}  // end test_policy
diff --git a/lib/kokkos/benchmarks/stream/stream-kokkos.cc b/lib/kokkos/benchmarks/stream/stream-kokkos.cc
index 370995432e5833490b5cd7b42331d676ef5b8f63..6ce789dd82049a81bf9ed2ff5ba2318093c948af 100644
--- a/lib/kokkos/benchmarks/stream/stream-kokkos.cc
+++ b/lib/kokkos/benchmarks/stream/stream-kokkos.cc
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/bin/nvcc_wrapper b/lib/kokkos/bin/nvcc_wrapper
index 94bc72854e74211cd3ed1c2876100731311dddfe..8a23d0d620508529bef99f0e74b80a2a0093cb6f 100755
--- a/lib/kokkos/bin/nvcc_wrapper
+++ b/lib/kokkos/bin/nvcc_wrapper
@@ -85,11 +85,11 @@ first_xcompiler_arg=1
 
 temp_dir=${TMPDIR:-/tmp}
 
-# Check if we have an optimization argument already
-optimization_applied=0
+# optimization flag added as a command-line argument
+optimization_flag=""
 
-# Check if we have -std=c++X  or --std=c++X already
-stdcxx_applied=0
+# std standard flag added as a command-line argument
+std_flag=""
 
 # Run nvcc a second time to generate dependencies if needed
 depfile_separate=0
@@ -99,6 +99,10 @@ depfile_target_arg=""
 # Option to remove duplicate libraries and object files
 remove_duplicate_link_files=0
 
+function warn_std_flag() {
+  echo "nvcc_wrapper - *warning* you have set multiple standard flags (-std=c++1* or --std=c++1*), only the last is used because nvcc can only accept a single std setting"
+}
+
 #echo "Arguments: $# $@"
 
 while [ $# -gt 0 ]
@@ -130,12 +134,16 @@ do
     ;;
    # Ensure we only have one optimization flag because NVCC doesn't allow muliple
   -O*)
-    if [ $optimization_applied -eq 1 ]; then
-       echo "nvcc_wrapper - *warning* you have set multiple optimization flags (-O*), only the first is used because nvcc can only accept a single optimization setting."
+    if [ -n "$optimization_flag" ]; then
+       echo "nvcc_wrapper - *warning* you have set multiple optimization flags (-O*), only the last is used because nvcc can only accept a single optimization setting."
+       shared_args=${shared_args/ $optimization_flag/}
+    fi
+    if [ "$1" = "-O" ]; then
+      optimization_flag="-O2"
     else
-       shared_args="$shared_args $1"
-       optimization_applied=1
+      optimization_flag=$1
     fi
+    shared_args="$shared_args $optimization_flag"
     ;;
   #Handle shared args (valid for both nvcc and the host compiler)
   -D*)
@@ -171,7 +179,7 @@ do
     shift
     ;;
   #Handle known nvcc args
-  --dryrun|--verbose|--keep|--keep-dir*|-G|--relocatable-device-code*|-lineinfo|-expt-extended-lambda|--resource-usage|-Xptxas*)
+  --dryrun|--verbose|--keep|--keep-dir*|-G|--relocatable-device-code*|-lineinfo|-expt-extended-lambda|--resource-usage|-Xptxas*|--fmad*)
     cuda_args="$cuda_args $1"
     ;;
   #Handle more known nvcc args
@@ -179,21 +187,43 @@ do
     cuda_args="$cuda_args $1"
     ;;
   #Handle known nvcc args that have an argument
-  -rdc|-maxrregcount|--default-stream)
+  -rdc|-maxrregcount|--default-stream|-Xnvlink|--fmad)
     cuda_args="$cuda_args $1 $2"
     shift
     ;;
   -rdc=*|-maxrregcount*|--maxrregcount*)
     cuda_args="$cuda_args $1"
     ;;
-  #Handle c++11
-  --std=c++11|-std=c++11|--std=c++14|-std=c++14|--std=c++1y|-std=c++1y|--std=c++17|-std=c++17|--std=c++1z|-std=c++1z)
-    if [ $stdcxx_applied -eq 1 ]; then
-       echo "nvcc_wrapper - *warning* you have set multiple optimization flags (-std=c++1* or --std=c++1*), only the first is used because nvcc can only accept a single std setting"
-    else
-       shared_args="$shared_args $1"
-       stdcxx_applied=1
+  #Handle unsupported standard flags
+  --std=c++1y|-std=c++1y|--std=c++1z|-std=c++1z|--std=gnu++1y|-std=gnu++1y|--std=gnu++1z|-std=gnu++1z|--std=c++2a|-std=c++2a|--std=c++17|-std=c++17)
+    fallback_std_flag="-std=c++14"
+    # this is hopefully just occurring in a downstream project during CMake feature tests
+    # we really have no choice here but to accept the flag and change  to an accepted C++ standard
+    echo "nvcc_wrapper does not accept standard flags $1 since partial standard flags and standards after C++14 are not supported. nvcc_wrapper will use $fallback_std_flag instead. It is undefined behavior to use this flag. This should only be occurring during CMake configuration."
+    if [ -n "$std_flag" ]; then
+       warn_std_flag
+       shared_args=${shared_args/ $std_flag/}
+    fi
+    std_flag=$fallback_std_flag
+    shared_args="$shared_args $std_flag"
+    ;;
+  -std=gnu*)
+    corrected_std_flag=${1/gnu/c}
+    echo "nvcc_wrapper has been given GNU extension standard flag $1 - reverting flag to $corrected_std_flag"
+    if [ -n "$std_flag" ]; then
+       warn_std_flag
+       shared_args=${shared_args/ $std_flag/}
+    fi
+    std_flag=$corrected_std_flag
+    shared_args="$shared_args $std_flag"
+  ;;
+  --std=c++11|-std=c++11|--std=c++14|-std=c++14)
+    if [ -n "$std_flag" ]; then
+       warn_std_flag
+       shared_args=${shared_args/ $std_flag/}
     fi
+    std_flag=$1
+    shared_args="$shared_args $std_flag"
     ;;
 
   #strip of -std=c++98 due to nvcc warnings and Tribits will place both -std=c++11 and -std=c++98
@@ -308,16 +338,6 @@ do
   shift
 done
 
-#Check if nvcc exists
-if [ $host_only -ne 1 ]; then
-  var=$(which nvcc )
-  if [ $? -gt 0 ]; then
-    echo "Could not find nvcc in PATH"
-    exit $?
-  fi
-fi
-
-
 # Only print host compiler version
 if [ $get_host_version -eq 1 ]; then
   $host_compiler --version
@@ -372,6 +392,9 @@ if [ $first_xcompiler_arg -eq 0 ]; then
   nvcc_command="$nvcc_command -Xcompiler $xcompiler_args"
 fi
 
+#Replace all commas in xcompiler_args with a space for the host only command
+xcompiler_args=${xcompiler_args//,/" "}
+
 #Compose host only command
 host_command="$host_compiler $shared_args $host_only_args $compile_arg $output_arg $xcompiler_args $host_linker_args $shared_versioned_libraries_host"
 
diff --git a/lib/kokkos/cm_generate_makefile.bash b/lib/kokkos/cm_generate_makefile.bash
new file mode 100755
index 0000000000000000000000000000000000000000..fd7cfe2d325bb817aeeaa0027fcb99d0169de95c
--- /dev/null
+++ b/lib/kokkos/cm_generate_makefile.bash
@@ -0,0 +1,339 @@
+#!/bin/bash
+
+update_kokkos_devices() {
+   SEARCH_TEXT="*$1*"
+   if [[ $KOKKOS_DEVICES == $SEARCH_TEXT ]]; then
+      echo kokkos devices already includes $SEARCH_TEXT
+   else
+      if [ "$KOKKOS_DEVICES" = "" ]; then
+         KOKKOS_DEVICES="$1"
+         echo reseting kokkos devices to $KOKKOS_DEVICES
+      else
+         KOKKOS_DEVICES="${KOKKOS_DEVICES},$1"
+         echo appending to kokkos devices $KOKKOS_DEVICES
+      fi
+   fi
+}
+
+get_kokkos_device_list() {
+  KOKKOS_DEVICE_CMD=
+  PARSE_DEVICES_LST=$(echo $KOKKOS_DEVICES | tr "," "\n")
+  for DEVICE_ in $PARSE_DEVICES_LST
+  do 
+     UC_DEVICE=$(echo $DEVICE_ | tr "[:lower:]" "[:upper:]")
+     KOKKOS_DEVICE_CMD="-DKokkos_ENABLE_${UC_DEVICE}=ON ${KOKKOS_DEVICE_CMD}"
+  done
+}
+
+get_kokkos_arch_list() {
+  KOKKOS_ARCH_CMD=
+  PARSE_ARCH_LST=$(echo $KOKKOS_ARCH | tr "," "\n")
+  for ARCH_ in $PARSE_ARCH_LST
+  do 
+     UC_ARCH=$(echo $ARCH_ | tr "[:lower:]" "[:upper:]")
+     KOKKOS_ARCH_CMD="-DKokkos_ARCH_${UC_ARCH}=ON ${KOKKOS_ARCH_CMD}"
+  done
+}
+
+get_kokkos_cuda_option_list() {
+  echo parsing KOKKOS_CUDA_OPTIONS=$KOKKOS_CUDA_OPTIONS
+  KOKKOS_CUDA_OPTION_CMD=
+  PARSE_CUDA_LST=$(echo $KOKKOS_CUDA_OPTIONS | tr "," "\n")
+  for CUDA_ in $PARSE_CUDA_LST
+  do 
+     CUDA_OPT_NAME=
+     if [ "${CUDA_}" == "enable_lambda" ]; then
+        CUDA_OPT_NAME=CUDA_LAMBDA
+     elif  [ "${CUDA_}" == "rdc" ]; then	
+        CUDA_OPT_NAME=CUDA_RELOCATABLE_DEVICE_CODE
+     elif  [ "${CUDA_}" == "force_uvm" ]; then
+        CUDA_OPT_NAME=CUDA_UVM
+     elif  [ "${CUDA_}" == "use_ldg" ]; then
+        CUDA_OPT_NAME=CUDA_LDG_INTRINSIC
+     else
+        echo "${CUDA_} is not a valid cuda options..."
+     fi
+     if [ "${CUDA_OPT_NAME}" != "" ]; then
+        KOKKOS_CUDA_OPTION_CMD="-DKokkos_ENABLE_${CUDA_OPT_NAME}=ON ${KOKKOS_CUDA_OPTION_CMD}"
+     fi
+  done
+}
+
+get_kokkos_option_list() {
+  echo parsing KOKKOS_OPTIONS=$KOKKOS_OPTIONS
+  KOKKOS_OPTION_CMD=
+  PARSE_OPTIONS_LST=$(echo $KOKKOS_OPTIONS | tr "," "\n")
+  for OPT_ in $PARSE_OPTIONS_LST
+  do 
+     UC_OPT_=$(echo $OPT_ | tr "[:lower:]" "[:upper:]")
+     if [[ "$UC_OPT_" == *DISABLE* ]]; then
+        FLIP_OPT_=${UC_OPT_/DISABLE/ENABLE}
+        KOKKOS_OPTION_CMD="-DKokkos_${FLIP_OPT_}=OFF ${KOKKOS_OPTION_CMD}"
+     elif [[ "$UC_OPT_" == *ENABLE* ]]; then
+        KOKKOS_OPTION_CMD="-DKokkos_${UC_OPT_}=ON ${KOKKOS_OPTION_CMD}"
+     else
+        KOKKOS_OPTION_CMD="-DKokkos_ENABLE_${UC_OPT_}=ON ${KOKKOS_OPTION_CMD}"
+     fi
+  done
+}
+
+display_help_text() {
+
+      echo "Kokkos configure options:"
+      echo ""
+      echo "--kokkos-path=/Path/To/Kokkos:        Path to the Kokkos root directory."
+      echo "--prefix=/Install/Path:               Path to install the Kokkos library."
+      echo ""
+      echo "--with-cuda[=/Path/To/Cuda]:          Enable Cuda and set path to Cuda Toolkit."
+      echo "--with-openmp:                        Enable OpenMP backend."
+      echo "--with-pthread:                       Enable Pthreads backend."
+      echo "--with-serial:                        Enable Serial backend."
+      echo "--with-devices:                       Explicitly add a set of backends."
+      echo ""
+      echo "--arch=[OPT]:  Set target architectures. Options are:"
+      echo "               [AMD]"
+      echo "                 AMDAVX          = AMD CPU"
+      echo "                 EPYC            = AMD EPYC Zen-Core CPU"
+      echo "               [ARM]"
+      echo "                 ARMv80          = ARMv8.0 Compatible CPU"
+      echo "                 ARMv81          = ARMv8.1 Compatible CPU"
+      echo "                 ARMv8-ThunderX  = ARMv8 Cavium ThunderX CPU"
+      echo "                 ARMv8-TX2       = ARMv8 Cavium ThunderX2 CPU"
+      echo "               [IBM]"
+      echo "                 BGQ             = IBM Blue Gene Q"
+      echo "                 Power7          = IBM POWER7 and POWER7+ CPUs"
+      echo "                 Power8          = IBM POWER8 CPUs"
+      echo "                 Power9          = IBM POWER9 CPUs"
+      echo "               [Intel]"
+      echo "                 WSM             = Intel Westmere CPUs"
+      echo "                 SNB             = Intel Sandy/Ivy Bridge CPUs"
+      echo "                 HSW             = Intel Haswell CPUs"
+      echo "                 BDW             = Intel Broadwell Xeon E-class CPUs"
+      echo "                 SKX             = Intel Sky Lake Xeon E-class HPC CPUs (AVX512)"
+      echo "               [Intel Xeon Phi]"
+      echo "                 KNC             = Intel Knights Corner Xeon Phi"
+      echo "                 KNL             = Intel Knights Landing Xeon Phi"
+      echo "               [NVIDIA]"
+      echo "                 Kepler30        = NVIDIA Kepler generation CC 3.0"
+      echo "                 Kepler32        = NVIDIA Kepler generation CC 3.2"
+      echo "                 Kepler35        = NVIDIA Kepler generation CC 3.5"
+      echo "                 Kepler37        = NVIDIA Kepler generation CC 3.7"
+      echo "                 Maxwell50       = NVIDIA Maxwell generation CC 5.0"
+      echo "                 Maxwell52       = NVIDIA Maxwell generation CC 5.2"
+      echo "                 Maxwell53       = NVIDIA Maxwell generation CC 5.3"
+      echo "                 Pascal60        = NVIDIA Pascal generation CC 6.0"
+      echo "                 Pascal61        = NVIDIA Pascal generation CC 6.1"
+      echo "                 Volta70         = NVIDIA Volta generation CC 7.0"
+      echo "                 Volta72         = NVIDIA Volta generation CC 7.2"
+      echo ""
+      echo "--compiler=/Path/To/Compiler  Set the compiler."
+      echo "--debug,-dbg:                 Enable Debugging."
+      echo "--cxxflags=[FLAGS]            Overwrite CXXFLAGS for library build and test"
+      echo "                                build.  This will still set certain required"
+      echo "                                flags via KOKKOS_CXXFLAGS (such as -fopenmp,"
+      echo "                                --std=c++11, etc.)."
+      echo "--cxxstandard=[FLAGS]         Overwrite KOKKOS_CXX_STANDARD for library build and test"
+      echo "                                c++11 (default), c++14, c++17, c++1y, c++1z, c++2a"
+      echo "--ldflags=[FLAGS]             Overwrite LDFLAGS for library build and test"
+      echo "                                build. This will still set certain required"
+      echo "                                flags via KOKKOS_LDFLAGS (such as -fopenmp,"
+      echo "                                -lpthread, etc.)."
+      echo "--with-gtest=/Path/To/Gtest:  Set path to gtest.  (Used in unit and performance"
+      echo "                                tests.)"
+      echo "--with-hwloc=/Path/To/Hwloc:  Set path to hwloc library."
+      echo "--with-memkind=/Path/To/MemKind:  Set path to memkind library."
+      echo "--with-options=[OPT]:         Additional options to Kokkos:"
+      echo "                                compiler_warnings"
+      echo "                                aggressive_vectorization = add ivdep on loops"
+      echo "                                disable_profiling = do not compile with profiling hooks"
+      echo "                                "
+      echo "--with-cuda-options=[OPT]:    Additional options to CUDA:"
+      echo "                                force_uvm, use_ldg, enable_lambda, rdc"
+      echo "--with-hpx-options=[OPT]:     Additional options to HPX:"
+      echo "                                enable_async_dispatch"
+      echo "--gcc-toolchain=/Path/To/GccRoot:  Set the gcc toolchain to use with clang (e.g. /usr)" 
+      echo "--make-j=[NUM]:               DEPRECATED: call make with appropriate"
+      echo "                                -j flag"
+
+}
+
+while [[ $# > 0 ]]
+do
+  key="$1"
+
+  case $key in
+    --kokkos-path*)
+      KOKKOS_PATH="${key#*=}"
+      ;;
+    --hpx-path*)
+      HPX_PATH="${key#*=}"
+      ;;
+    --prefix*)
+      PREFIX="${key#*=}"
+      ;;
+    --with-cuda)
+      update_kokkos_devices Cuda
+      CUDA_PATH_NVCC=$(command -v nvcc)
+      CUDA_PATH=${CUDA_PATH_NVCC%/bin/nvcc}
+      ;;
+    # Catch this before '--with-cuda*'
+    --with-cuda-options*)
+      KOKKOS_CUDA_OPTIONS="${key#*=}"
+      ;;
+    --with-cuda*)
+      update_kokkos_devices Cuda
+      CUDA_PATH="${key#*=}"
+      ;;
+    --with-openmp)
+      update_kokkos_devices OpenMP
+      ;;
+    --with-pthread)
+      update_kokkos_devices Pthread
+      ;;
+    --with-serial)
+      update_kokkos_devices Serial
+      ;;
+    --with-hpx-options*)
+      KOKKOS_HPX_OPT="${key#*=}"
+      ;;
+    --with-hpx*)
+      update_kokkos_devices HPX
+      if [ -z "$HPX_PATH" ]; then
+        HPX_PATH="${key#*=}"
+      fi
+      ;;
+    --with-devices*)
+      DEVICES="${key#*=}"
+      PARSE_DEVICES=$(echo $DEVICES | tr "," "\n")
+      for DEVICE_ in $PARSE_DEVICES
+      do 
+         update_kokkos_devices $DEVICE_
+      done
+      ;;
+    --with-gtest*)
+      GTEST_PATH="${key#*=}"
+      ;;
+    --with-hwloc*)
+      HWLOC_PATH="${key#*=}"
+      ;;
+    --with-memkind*)
+      MEMKIND_PATH="${key#*=}"
+      ;;
+    --arch*)
+      KOKKOS_ARCH="${key#*=}"
+      ;;
+    --cxxflags*)
+      KOKKOS_CXXFLAGS="${key#*=}"
+      KOKKOS_CXXFLAGS=${KOKKOS_CXXFLAGS//,/ }
+      ;;
+    --cxxstandard*)
+      KOKKOS_CXX_STANDARD="${key#*=}"
+      ;;
+    --ldflags*)
+      KOKKOS_LDFLAGS="${key#*=}"
+      ;;
+    --debug|-dbg)
+      KOKKOS_DEBUG=yes
+      ;;
+    --make-j*)
+      echo "Warning: ${key} is deprecated"
+      echo "Call make with appropriate -j flag"
+      ;;
+    --compiler*)
+      COMPILER="${key#*=}"
+      CNUM=$(command -v ${COMPILER} 2>&1 >/dev/null | grep "no ${COMPILER}" | wc -l)
+      if [ ${CNUM} -gt 0 ]; then
+        echo "Invalid compiler by --compiler command: '${COMPILER}'"
+        exit
+      fi
+      if [[ ! -n  ${COMPILER} ]]; then
+        echo "Empty compiler specified by --compiler command."
+        exit
+      fi
+      CNUM=$(command -v ${COMPILER} | grep ${COMPILER} | wc -l)
+      if [ ${CNUM} -eq 0 ]; then
+        echo "Invalid compiler by --compiler command: '${COMPILER}'"
+        exit
+      fi
+      # ... valid compiler, ensure absolute path set 
+      WCOMPATH=$(command -v $COMPILER)
+      COMPDIR=$(dirname $WCOMPATH)
+      COMPNAME=$(basename $WCOMPATH)
+      COMPILER=${COMPDIR}/${COMPNAME}
+      ;;
+    --with-options*)
+      KOKKOS_OPTIONS="${key#*=}"
+      ;;
+    --gcc-toolchain*)
+      KOKKOS_GCC_TOOLCHAIN="${key#*=}"
+      ;;
+    --help)
+      display_help_text
+      exit 0
+      ;;
+    *)
+      echo "warning: ignoring unknown option $key"
+      ;;
+  esac
+
+  shift
+done
+
+
+if [ "$COMPILER" == "" ]; then
+    COMPILER_CMD=
+else
+    COMPILER_CMD=-DCMAKE_CXX_COMPILER=$COMPILER
+fi
+
+if [ "$KOKKOS_DEBUG" == "" ]; then
+    KOKKOS_DEBUG_CMD=-DCMAKE_BUILD_TYPE=RELEASE
+else
+    KOKKOS_DEBUG_CMD=-DCMAKE_BUILD_TYPE=DEBUG
+fi
+
+if [ ! -e ${KOKKOS_PATH}/CMakeLists.txt ]; then
+   if [ "${KOKKOS_PATH}" == "" ]; then
+      CM_SCRIPT=$0
+      KOKKOS_PATH=`dirname $CM_SCRIPT`
+      if [ ! -e ${KOKKOS_PATH}/CMakeLists.txt ]; then
+         echo "${KOKKOS_PATH} repository appears to not be complete.  please verify and try again"
+         exit 0
+      fi
+   else
+      echo "KOKKOS_PATH does not appear to be set properly. please specify in location of CMakeLists.txt"   
+      display_help_text
+      exit 0
+   fi
+fi
+
+get_kokkos_device_list
+get_kokkos_option_list
+get_kokkos_arch_list
+get_kokkos_cuda_option_list
+
+## if HPX is enabled, we need to enforce cxx standard = 14
+if [[ ${KOKKOS_DEVICE_CMD} == *Kokkos_ENABLE_HPX* ]]; then
+   if [ "${KOKKOS_CXX_STANDARD}" == "" ] || [ ${#KOKKOS_CXX_STANDARD} -lt 14 ]; then
+      echo CXX Standard must be 14 or higher for HPX to work.
+      KOKKOS_CXX_STANDARD=14
+   fi
+fi
+
+if [ "$KOKKOS_CXX_STANDARD" == "" ]; then
+    STANDARD_CMD=
+else
+    STANDARD_CMD=-DKokkos_CXX_STANDARD=${KOKKOS_CXX_STANDARD}
+fi
+
+if [[ ${COMPILER} == *clang* ]]; then
+   gcc_path=$(which g++ | awk --field-separator='/bin/g++' '{printf $1}' )
+   KOKKOS_CXXFLAGS="${KOKKOS_CXXFLAGS} --gcc-toolchain=${gcc_path}"
+
+   if [ ! "${CUDA_PATH}" == "" ]; then
+      KOKKOS_CXXFLAGS="${KOKKOS_CXXFLAGS} --cuda-path=${CUDA_PATH}"
+   fi 
+fi
+ 
+echo cmake $COMPILER_CMD  -DCMAKE_CXX_FLAGS="${KOKKOS_CXXFLAGS}" -DCMAKE_EXE_LINKER_FLAGS="${KOKKOS_LDFLAGS}" -DCMAKE_INSTALL_PREFIX=${PREFIX} ${KOKKOS_DEVICE_CMD} ${KOKKOS_ARCH_CMD} -DKokkos_ENABLE_TESTS=ON ${KOKKOS_OPTION_CMD} ${KOKKOS_CUDA_OPTION_CMD} -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_CXX_EXTENSIONS=OFF ${STANDARD_CMD} ${KOKKOS_DEBUG_CMD} ${KOKKOS_PATH}
+cmake $COMPILER_CMD  -DCMAKE_CXX_FLAGS="${KOKKOS_CXXFLAGS//\"}" -DCMAKE_EXE_LINKER_FLAGS="${KOKKOS_LDFLAGS//\"}" -DCMAKE_INSTALL_PREFIX=${PREFIX} ${KOKKOS_DEVICE_CMD} ${KOKKOS_ARCH_CMD} -DKokkos_ENABLE_TESTS=ON ${KOKKOS_OPTION_CMD} ${KOKKOS_CUDA_OPTION_CMD} -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_CXX_EXTENSIONS=OFF ${STANDARD_CMD} ${KOKKOS_DEBUG_CMD} ${KOKKOS_PATH}
diff --git a/lib/kokkos/cmake/KokkosConfig.cmake.in b/lib/kokkos/cmake/KokkosConfig.cmake.in
index fc099a494ce25af9068e113a688904e06458fcbe..6f4607687e066b3a1bee5d467803d0f39c99810c 100644
--- a/lib/kokkos/cmake/KokkosConfig.cmake.in
+++ b/lib/kokkos/cmake/KokkosConfig.cmake.in
@@ -1,18 +1,14 @@
-# - Config file for the Kokkos package
-# It defines the following variables
-#  Kokkos_INCLUDE_DIRS - include directories for Kokkos
-#  Kokkos_LIBRARIES    - libraries to link against
-
 # Compute paths
-GET_FILENAME_COMPONENT(Kokkos_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
-SET(Kokkos_INCLUDE_DIRS "@CONF_INCLUDE_DIRS@")
+@PACKAGE_INIT@
 
-# Our library dependencies (contains definitions for IMPORTED targets)
-IF(NOT TARGET kokkos AND NOT Kokkos_BINARY_DIR)
-  INCLUDE("${Kokkos_CMAKE_DIR}/KokkosTargets.cmake")
-ENDIF()
+#Find dependencies
+INCLUDE(CMakeFindDependencyMacro)
 
-# These are IMPORTED targets created by KokkosTargets.cmake
-SET(Kokkos_LIBRARY_DIRS @INSTALL_LIB_DIR@)
-SET(Kokkos_LIBRARIES @Kokkos_LIBRARIES_NAMES@)
-SET(Kokkos_TPL_LIBRARIES @KOKKOS_LIBS@)
+#This needs to go above the KokkosTargets in case
+#the Kokkos targets depend in some way on the TPL imports
+@KOKKOS_TPL_EXPORTS@
+
+GET_FILENAME_COMPONENT(Kokkos_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+INCLUDE("${Kokkos_CMAKE_DIR}/KokkosTargets.cmake")
+INCLUDE("${Kokkos_CMAKE_DIR}/KokkosConfigCommon.cmake")
+UNSET(Kokkos_CMAKE_DIR)
diff --git a/lib/kokkos/cmake/KokkosConfigCommon.cmake.in b/lib/kokkos/cmake/KokkosConfigCommon.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..da9c61976c596e7318bd7a055ced6c6b527d2f60
--- /dev/null
+++ b/lib/kokkos/cmake/KokkosConfigCommon.cmake.in
@@ -0,0 +1,87 @@
+SET(Kokkos_DEVICES @KOKKOS_ENABLED_DEVICES@)
+SET(Kokkos_OPTIONS @KOKKOS_ENABLED_OPTIONS@)
+SET(Kokkos_TPLS @KOKKOS_ENABLED_TPLS@)
+SET(Kokkos_ARCH @KOKKOS_ENABLED_ARCH_LIST@)
+
+# These are needed by KokkosKernels
+FOREACH(DEV ${Kokkos_DEVICES})
+  SET(Kokkos_ENABLE_${DEV} ON)
+ENDFOREACH()
+
+IF(NOT Kokkos_FIND_QUIETLY)
+  MESSAGE(STATUS "Enabled Kokkos devices: ${Kokkos_DEVICES}")
+ENDIF()
+
+IF (Kokkos_ENABLE_CUDA AND ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14.0")
+  #If we are building CUDA, we have tricked CMake because we declare a CXX project
+  #If the default C++ standard for a given compiler matches the requested
+  #standard, then CMake just omits the -std flag in later versions of CMake
+  #This breaks CUDA compilation (CUDA compiler can have a different default
+  #-std then the underlying host compiler by itself). Setting this variable
+  #forces CMake to always add the -std flag even if it thinks it doesn't need it
+  SET(CMAKE_CXX_STANDARD_DEFAULT 98 CACHE INTERNAL "" FORCE)
+ENDIF()
+
+SET(KOKKOS_USE_CXX_EXTENSIONS @KOKKOS_USE_CXX_EXTENSIONS@)
+IF (NOT DEFINED CMAKE_CXX_EXTENSIONS OR CMAKE_CXX_EXTENSIONS)
+  IF (NOT KOKKOS_USE_CXX_EXTENSIONS)
+    MESSAGE(WARNING "The installed Kokkos configuration does not support CXX extensions. Forcing -DCMAKE_CXX_EXTENSIONS=Off")
+    SET(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "" FORCE)
+  ENDIF()
+ENDIF()
+
+include(FindPackageHandleStandardArgs)
+
+#   This function makes sure that Kokkos was built with the requested backends
+#   and target architectures and generates a fatal error if it was not.
+#
+#   kokkos_check(
+#     [DEVICES <devices>...]   # Set of backends (e.g. "OpenMP" and/or "Cuda")
+#     [ARCH <archs>...]        # Target architectures (e.g. "Power9" and/or "Volta70")
+#     [OPTIONS <options>...]   # Optional settings (e.g. "PROFILING")
+#     [TPLS <tpls>...]         # Third party libraries
+#     [RETURN_VALUE <result>]  # Set a variable that indicates the result of the
+#                              # check instead of a fatal error
+#   )
+function(kokkos_check)
+  set(ALLOWED_ARGS DEVICES ARCH OPTIONS TPLS)
+  cmake_parse_arguments(KOKKOS_CHECK "" "RETURN_VALUE" "${ALLOWED_ARGS}" ${ARGN})
+  foreach(_arg ${KOKKOS_CHECK_UNPARSED_ARGUMENTS})
+    message(SEND_ERROR "Argument '${_arg}' passed to kokkos_check() was not recognized")
+  endforeach()
+  # Get the list of keywords that were actually passed to the function.
+  set(REQUESTED_ARGS)
+  foreach(arg ${ALLOWED_ARGS})
+    if(KOKKOS_CHECK_${arg})
+      list(APPEND REQUESTED_ARGS ${arg})
+    endif()
+  endforeach()
+  set(KOKKOS_CHECK_SUCCESS TRUE)
+  foreach(arg ${REQUESTED_ARGS})
+    # Define variables named after the required arguments that are provided by
+    # the Kokkos install.
+    foreach(requested ${KOKKOS_CHECK_${arg}})
+      foreach(provided ${Kokkos_${arg}})
+        STRING(TOUPPER ${requested} REQUESTED_UC)
+        STRING(TOUPPER ${provided}  PROVIDED_UC)
+        if(PROVIDED_UC STREQUAL REQUESTED_UC)
+          string(REPLACE ";" " " ${requested} "${KOKKOS_CHECK_${arg}}")
+        endif()
+      endforeach()
+    endforeach()
+    # Somewhat divert the CMake function below from its original purpose and
+    # use it to check that there are variables defined for all required
+    # arguments. Success or failure messages will be displayed but we are
+    # responsible for signaling failure and skip the build system generation.
+    find_package_handle_standard_args("Kokkos_${arg}" DEFAULT_MSG
+            ${KOKKOS_CHECK_${arg}})
+    if(NOT Kokkos_${arg}_FOUND)
+      set(KOKKOS_CHECK_SUCCESS FALSE)
+    endif()
+  endforeach()
+  if(NOT KOKKOS_CHECK_SUCCESS AND NOT KOKKOS_CHECK_RETURN_VALUE)
+    message(FATAL_ERROR "Kokkos does NOT provide all backends and/or architectures requested")
+  else()
+    set(${KOKKOS_CHECK_RETURN_VALUE} ${KOKKOS_CHECK_SUCCESS} PARENT_SCOPE)
+  endif()
+endfunction()
diff --git a/lib/kokkos/cmake/KokkosCore_config.h.in b/lib/kokkos/cmake/KokkosCore_config.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..084afba8a803b16031fdd6b1fb9e96c419d90fff
--- /dev/null
+++ b/lib/kokkos/cmake/KokkosCore_config.h.in
@@ -0,0 +1,89 @@
+
+#if !defined(KOKKOS_MACROS_HPP) || defined(KOKKOS_CORE_CONFIG_H)
+#error "Do not include KokkosCore_config.h directly; include Kokkos_Macros.hpp instead."
+#else
+#define KOKKOS_CORE_CONFIG_H
+#endif
+
+/* Execution Spaces */
+#cmakedefine KOKKOS_ENABLE_SERIAL
+#cmakedefine KOKKOS_ENABLE_OPENMP
+#cmakedefine KOKKOS_ENABLE_THREADS
+#cmakedefine KOKKOS_ENABLE_CUDA
+#cmakedefine KOKKOS_ENABLE_HPX
+#cmakedefine KOKKOS_ENABLE_MEMKIND
+#cmakedefine KOKKOS_ENABLE_LIBRT
+
+#ifndef __CUDA_ARCH__
+#cmakedefine KOKKOS_ENABLE_TM
+#cmakedefine KOKKOS_USE_ISA_X86_64
+#cmakedefine KOKKOS_USE_ISA_KNC
+#cmakedefine KOKKOS_USE_ISA_POWERPCLE
+#cmakedefine KOKKOS_USE_ISA_POWERPCBE
+#endif
+
+/* General Settings */
+#cmakedefine KOKKOS_ENABLE_CXX11
+#cmakedefine KOKKOS_ENABLE_CXX14
+#cmakedefine KOKKOS_ENABLE_CXX17
+#cmakedefine KOKKOS_ENABLE_CXX20
+
+#cmakedefine KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
+#cmakedefine KOKKOS_ENABLE_CUDA_UVM
+#cmakedefine KOKKOS_ENABLE_CUDA_LAMBDA
+#cmakedefine KOKKOS_ENABLE_CUDA_CONSTEXPR
+#cmakedefine KOKKOS_ENABLE_CUDA_LDG_INTRINSIC
+#cmakedefine KOKKOS_ENABLE_HPX_ASYNC_DISPATCH
+#cmakedefine KOKKOS_ENABLE_DEBUG
+#cmakedefine KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
+#cmakedefine KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
+#cmakedefine KOKKOS_ENABLE_COMPILER_WARNINGS
+#cmakedefine KOKKOS_ENABLE_PROFILING
+#cmakedefine KOKKOS_ENABLE_PROFILING_LOAD_PRINT
+#cmakedefine KOKKOS_ENABLE_DEPRECATED_CODE
+#cmakedefine KOKKOS_ENABLE_ETI
+#cmakedefine KOKKOS_ENABLE_LARGE_MEM_TESTS
+#cmakedefine KOKKOS_ENABLE_DUALVIEW_MODIFY_CHECK
+#cmakedefine KOKKOS_ENABLE_COMPLEX_ALIGN
+#cmakedefine KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
+
+/* TPL Settings */
+#cmakedefine KOKKOS_ENABLE_HWLOC
+#cmakedefine KOKKOS_USE_LIBRT
+#cmakedefine KOKKOS_ENABLE_HWBSPACE
+
+#cmakedefine KOKKOS_IMPL_CUDA_CLANG_WORKAROUND
+
+#cmakedefine KOKKOS_COMPILER_CUDA_VERSION @KOKKOS_COMPILER_CUDA_VERSION@
+
+#cmakedefine KOKKOS_ARCH_SSE42
+#cmakedefine KOKKOS_ARCH_ARMV80
+#cmakedefine KOKKOS_ARCH_ARMV8_THUNDERX
+#cmakedefine KOKKOS_ARCH_ARMV81
+#cmakedefine KOKKOS_ARCH_ARMV8_THUNDERX2
+#cmakedefine KOKKOS_ARCH_AMD_AVX2
+#cmakedefine KOKKOS_ARCH_AVX
+#cmakedefine KOKKOS_ARCH_AVX2
+#cmakedefine KOKKOS_ARCH_AVX512XEON
+#cmakedefine KOKKOS_ARCH_KNC
+#cmakedefine KOKKOS_ARCH_AVX512MIC
+#cmakedefine KOKKOS_ARCH_POWER7
+#cmakedefine KOKKOS_ARCH_POWER8
+#cmakedefine KOKKOS_ARCH_POWER9
+#cmakedefine KOKKOS_ARCH_KEPLER
+#cmakedefine KOKKOS_ARCH_KEPLER30
+#cmakedefine KOKKOS_ARCH_KEPLER32
+#cmakedefine KOKKOS_ARCH_KEPLER35
+#cmakedefine KOKKOS_ARCH_KEPLER37
+#cmakedefine KOKKOS_ARCH_MAXWELL
+#cmakedefine KOKKOS_ARCH_MAXWELL50
+#cmakedefine KOKKOS_ARCH_MAXWELL52
+#cmakedefine KOKKOS_ARCH_MAXWELL53
+#cmakedefine KOKKOS_ARCH_PASCAL
+#cmakedefine KOKKOS_ARCH_PASCAL60
+#cmakedefine KOKKOS_ARCH_PASCAL61
+#cmakedefine KOKKOS_ARCH_VOLTA
+#cmakedefine KOKKOS_ARCH_VOLTA70
+#cmakedefine KOKKOS_ARCH_VOLTA72
+#cmakedefine KOKKOS_ARCH_TURING75
+#cmakedefine KOKKOS_ARCH_AMD_EPYC
diff --git a/lib/kokkos/cmake/Makefile.generate_cmake_settings b/lib/kokkos/cmake/Makefile.generate_cmake_settings
deleted file mode 100644
index da076b23db2697f4abb874cd5c154c08e99ad6cb..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/Makefile.generate_cmake_settings
+++ /dev/null
@@ -1,8 +0,0 @@
-ifndef KOKKOS_PATH
-  MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-  KOKKOS_PATH = $(subst Makefile,,$(MAKEFILE_PATH))..
-endif
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-include $(KOKKOS_PATH)/core/src/Makefile.generate_header_lists
-include $(KOKKOS_PATH)/core/src/Makefile.generate_build_files
diff --git a/lib/kokkos/cmake/Modules/FindHWLOC.cmake b/lib/kokkos/cmake/Modules/FindHWLOC.cmake
deleted file mode 100644
index 60df8084d80815f79f0215c17b40f80db4c791c0..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/Modules/FindHWLOC.cmake
+++ /dev/null
@@ -1,20 +0,0 @@
-#.rst:
-# FindHWLOC
-# ----------
-#
-# Try to find HWLOC, based on KOKKOS_HWLOC_DIR
-#
-# The following variables are defined:
-#
-#   HWLOC_FOUND - System has HWLOC
-#   HWLOC_INCLUDE_DIR - HWLOC include directory
-#   HWLOC_LIBRARIES - Libraries needed to use HWLOC
-
-find_path(HWLOC_INCLUDE_DIR hwloc.h PATHS "${KOKKOS_HWLOC_DIR}/include")
-find_library(HWLOC_LIBRARIES hwloc PATHS "${KOKKOS_HWLOC_DIR}/lib")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(HWLOC DEFAULT_MSG
-                                  HWLOC_INCLUDE_DIR HWLOC_LIBRARIES)
-
-mark_as_advanced(HWLOC_INCLUDE_DIR HWLOC_LIBRARIES)
diff --git a/lib/kokkos/cmake/Modules/FindMemkind.cmake b/lib/kokkos/cmake/Modules/FindMemkind.cmake
deleted file mode 100644
index 245fb44c19a2ff71a389c5f139cb3f6ac38f924e..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/Modules/FindMemkind.cmake
+++ /dev/null
@@ -1,20 +0,0 @@
-#.rst:
-# FindMemkind
-# ----------
-#
-# Try to find Memkind.
-#
-# The following variables are defined:
-#
-#   MEMKIND_FOUND - System has Memkind
-#   MEMKIND_INCLUDE_DIR - Memkind include directory
-#   MEMKIND_LIBRARIES - Libraries needed to use Memkind
-
-find_path(MEMKIND_INCLUDE_DIR memkind.h)
-find_library(MEMKIND_LIBRARIES memkind)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Memkind DEFAULT_MSG
-  MEMKIND_INCLUDE_DIR MEMKIND_LIBRARIES)
-
-mark_as_advanced(MEMKIND_INCLUDE_DIR MEMKIND_LIBRARIES)
diff --git a/lib/kokkos/cmake/Modules/FindQthreads.cmake b/lib/kokkos/cmake/Modules/FindQthreads.cmake
deleted file mode 100644
index a254b0e996d23e01897f5f186a316c285f64e9ee..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/Modules/FindQthreads.cmake
+++ /dev/null
@@ -1,20 +0,0 @@
-#.rst:
-# FindQthreads
-# ----------
-#
-# Try to find Qthreads.
-#
-# The following variables are defined:
-#
-#   QTHREADS_FOUND - System has Qthreads
-#   QTHREADS_INCLUDE_DIR - Qthreads include directory
-#   QTHREADS_LIBRARIES - Libraries needed to use Qthreads
-
-find_path(QTHREADS_INCLUDE_DIR qthread.h)
-find_library(QTHREADS_LIBRARIES qthread)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Qthreads DEFAULT_MSG
-                                  QTHREADS_INCLUDE_DIR QTHREADS_LIBRARIES)
-
-mark_as_advanced(QTHREADS_INCLUDE_DIR QTHREADS_LIBRARIES)
diff --git a/lib/kokkos/cmake/Modules/FindTPLCUDA.cmake b/lib/kokkos/cmake/Modules/FindTPLCUDA.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..36aefcdb44fdc52c2ee62b50973ad28b02a8fbf5
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLCUDA.cmake
@@ -0,0 +1,13 @@
+
+IF (KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
+   KOKKOS_FIND_IMPORTED(CUDA INTERFACE
+    LIBRARIES cudart cuda
+    LIBRARY_PATHS ENV LD_LIBRARY_PATH ENV CUDA_PATH
+    ALLOW_SYSTEM_PATH_FALLBACK
+   )
+ELSE()
+   KOKKOS_CREATE_IMPORTED_TPL(CUDA INTERFACE
+    LINK_LIBRARIES cuda
+   )
+ENDIF()
+
diff --git a/lib/kokkos/cmake/Modules/FindTPLHPX.cmake b/lib/kokkos/cmake/Modules/FindTPLHPX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c8b3bc4c9b84505eceff8ba3453501f9bb5d1e01
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLHPX.cmake
@@ -0,0 +1,15 @@
+
+FIND_PACKAGE(HPX REQUIRED)
+#as of right now, HPX doesn't export correctly
+#so let's convert it to an interface target
+KOKKOS_CREATE_IMPORTED_TPL(HPX INTERFACE
+  LINK_LIBRARIES ${HPX_LIBRARIES}
+  INCLUDES ${HPX_INCLUDE_DIRS}
+)
+#this is a bit funky since this is a CMake target
+#but HPX doesn't export itself correctly
+KOKKOS_EXPORT_CMAKE_TPL(HPX)
+
+#I would prefer all of this gets replaced with
+#KOKKOS_IMPORT_CMAKE_TPL(HPX)
+
diff --git a/lib/kokkos/cmake/Modules/FindTPLHWLOC.cmake b/lib/kokkos/cmake/Modules/FindTPLHWLOC.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..cf763b7e5bb585ed77e8dc1fb3b015566a0326f9
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLHWLOC.cmake
@@ -0,0 +1 @@
+KOKKOS_FIND_IMPORTED(HWLOC  HEADER hwloc.h  LIBRARY hwloc)
diff --git a/lib/kokkos/cmake/Modules/FindTPLLIBDL.cmake b/lib/kokkos/cmake/Modules/FindTPLLIBDL.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5fc6a693035cea5e05b379f5fac9d50bcaeb3f7a
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLLIBDL.cmake
@@ -0,0 +1 @@
+KOKKOS_FIND_IMPORTED(LIBDL HEADER dlfcn.h  LIBRARY dl)
diff --git a/lib/kokkos/cmake/Modules/FindTPLLIBNUMA.cmake b/lib/kokkos/cmake/Modules/FindTPLLIBNUMA.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..811db5851b9ee359ad996a743bf8a0ac283512f6
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLLIBNUMA.cmake
@@ -0,0 +1 @@
+KOKKOS_FIND_IMPORTED(LIBNUMA HEADER numa.h   LIBRARY numa)
diff --git a/lib/kokkos/cmake/Modules/FindTPLLIBRT.cmake b/lib/kokkos/cmake/Modules/FindTPLLIBRT.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e75da56b5b5324050236ee0ee4c6847452d5b3cf
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLLIBRT.cmake
@@ -0,0 +1 @@
+KOKKOS_FIND_IMPORTED(LIBRT HEADER time.h   LIBRARY rt)
diff --git a/lib/kokkos/cmake/Modules/FindTPLMEMKIND.cmake b/lib/kokkos/cmake/Modules/FindTPLMEMKIND.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..20aaff22955ce9ad026c51b870bf04b7d8b0df42
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLMEMKIND.cmake
@@ -0,0 +1 @@
+KOKKOS_FIND_IMPORTED(MEMKIND HEADER memkind.h LIBRARY memkind)
diff --git a/lib/kokkos/cmake/Modules/FindTPLPTHREAD.cmake b/lib/kokkos/cmake/Modules/FindTPLPTHREAD.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b4b8c34122a67ba73fc991ed52e35176c7df2fa1
--- /dev/null
+++ b/lib/kokkos/cmake/Modules/FindTPLPTHREAD.cmake
@@ -0,0 +1,17 @@
+
+TRY_COMPILE(KOKKOS_HAS_PTHREAD_ARG
+  ${KOKKOS_TOP_BUILD_DIR}/tpl_tests
+  ${KOKKOS_SOURCE_DIR}/cmake/compile_tests/pthread.cpp
+  LINK_LIBRARIES -pthread
+  COMPILE_DEFINITIONS -pthread)
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(PTHREAD DEFAULT_MSG KOKKOS_HAS_PTHREAD_ARG)
+
+KOKKOS_CREATE_IMPORTED_TPL(PTHREAD
+  INTERFACE   #this is not a real library with a real location
+  COMPILE_OPTIONS -pthread
+  LINK_OPTIONS    -pthread)
+
+
+
diff --git a/lib/kokkos/cmake/README.md b/lib/kokkos/cmake/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0543a18e89cc9ed70472ee3381d2fc2834e14d7b
--- /dev/null
+++ b/lib/kokkos/cmake/README.md
@@ -0,0 +1,331 @@
+![Kokkos](https://avatars2.githubusercontent.com/u/10199860?s=200&v=4)
+
+# Developing Kokkos
+
+This document contains a build system overview for developers with information on adding new CMake options that could influence
+* Header configuration macros
+* Optional features
+* Third-partly libraries
+* Compiler and linker flags
+For build system details for users, refer to the [build instructions](../BUILD.md).
+
+## Build System
+
+Kokkos uses CMake to configure, build, and install.
+Rather than being a completely straightforward use of modern CMake,
+Kokkos has several extra complications, primarily due to:
+* Kokkos must support linking to an installed version or in-tree builds as a subdirectory of a larger project.
+* Kokkos must configure a special compiler `nvcc_wrapper` that allows `nvcc` to accept all C++ flags (which `nvcc` currently does not).
+* Kokkos must work as a part of TriBITS, a CMake library providing a particular build idiom for Trilinos.
+* Kokkos has many pre-existing users. We need to be careful about breaking previous versions or generating meaningful error messags if we do break backwards compatibility.
+
+If you are looking at the build system code wondering why certain decisions were made: we have had to balance many competing requirements and certain technical debt. Everything in the build system was done for a reason, trying to adhere as closely as possible to modern CMake best practices while meeting all pre-existing. customer requirements.
+
+### Modern CMake Philosophy
+
+Modern CMake relies on understanding the principle of *building* and *using* a code project.
+What preprocessor, compiler, and linker flags do I need to *build* my project?
+What flags does a downstream project that links to me need to *use* my project?
+In CMake terms, flags that are only needed for building are `PRIVATE`.
+Only Kokkos needs these flags, not a package that depends on Kokkos.
+Flags that must be used in a downstream project are `PUBLIC`.
+Kokkos must tell other projects to use them.
+
+In Kokkos, almost everything is a public flag since Kokkos is driven by headers and Kokkos is in charge of optimizing your code to achieve performance portability!
+Include paths, C++ standard flags, architecture-specific optimizations, or OpenMP and CUDA flags are all examples of flags that Kokkos configures and adds to your project.
+
+Modern CMake now automatically propagates flags through the `target_link_libraries` command.
+Suppose you have a library `stencil` that needs to build with Kokkos.
+Consider the following CMake code:
+
+````
+find_package(Kokkos)
+add_library(stencil stencil.cpp)
+target_link_libraries(stencil Kokkos::kokkos)
+````
+
+This locates the Kokkos package, adds your library, and tells CMake to link Kokkos to your library.
+All public build flags get added automatically through the `target_link_libraries` command.
+There is nothing to do. You can be happily oblivious to how Kokkos was configured.
+Everything should just work.
+
+As a Kokkos developer who wants to add new public compiler flags, how do you ensure that CMake does this properly? Modern CMake works through targets and properties.
+Each target has a set of standard properties:
+* `INTERFACE_COMPILE_OPTIONS` contains all the compiler options that Kokkos should add to downstream projects
+* `INTERFACE_INCLUDE_DIRECTORIES` contains all the directories downstream projects must include from Kokkos
+* `INTERFACE_COMPILE_DEFINITIONS` contains the list of preprocessor `-D` flags
+* `INTERFACE_LINK_LIBRARIES` contains all the libraries downstream projects need to link
+* `INTERFACE_COMPILE_FEATURES` essentially adds compiler flags, but with extra complications. Features names are specific to CMake. More later.
+
+CMake makes it easy to append to these properties using:
+* `target_compile_options(kokkos PUBLIC -fmyflag)`
+* `target_include_directories(kokkos PUBLIC mySpecialFolder)`
+* `target_compile_definitions(kokkos PUBLIC -DmySpecialFlag=0)`
+* `target_link_libraries(kokkos PUBLIC mySpecialLibrary)`
+* `target_compile_features(kokkos PUBLIC mySpecialFeature)`
+Note that all of these use `PUBLIC`! Almost every Kokkos flag is not private to Kokkos, but must also be used by downstream projects.
+
+
+### Compiler Features and Compiler Options
+Compiler options are flags like `-fopenmp` that do not need to be "resolved." 
+The flag is either on or off.
+Compiler features are more fine-grained and require conflicting requests to be resolved.
+Suppose I have
+````
+add_library(A a.cpp)
+target_compile_features(A PUBLIC cxx_std_11)
+````
+then another target
+````
+add_library(B b.cpp)
+target_compile_features(B PUBLIC cxx_std_14)
+target_link_libraries(A B)
+````
+I have requested two different features.
+CMake understands the requests and knows that `cxx_std_11` is a subset of `cxx_std_14`.
+CMake then picks C++14 for library `B`.
+CMake would not have been able to do feature resolution if we had directly done:
+````
+target_compile_options(A PUBLIC -std=c++11)
+````
+
+### Adding Kokkos Options
+After configuring for the first time,
+CMake creates a cache of configure variables in `CMakeCache.txt`.
+Reconfiguring in the folder "restarts" from those variables.
+All flags passed as `-DKokkos_SOME_OPTION=X` to `cmake` become variables in the cache.
+All Kokkos options begin with camel case `Kokkos_` followed by an upper case option name.
+
+CMake best practice is to avoid cache variables, if possible.
+In essence, you want the minimal amount of state cached between configurations.
+And never, ever have behavior influenced by multiple cache variables.
+If you want to change the Kokkos configuration, have a single unique variable that needs to be changed.
+Never require two cache variables to be changed.
+
+Kokkos provides a function `KOKKOS_OPTION` for defining valid cache-level variables,
+proofreading them, and defining local project variables.
+The most common variables are called `Kokkos_ENABLE_X`,
+for which a helper function `KOKKOS_ENABLE_OPTION` is provided, e.g.
+````
+KOKKOS_ENABLE_OPTION(TESTS OFF  "Whether to build tests")
+````
+The function checks if `-DKokkos_ENABLE_TESTS` was given,
+whether it was given with the wrong case, e.g. `-DKokkos_Enable_Tests`,
+and then defines a regular (non-cache) variable `KOKKOS_ENABLE_TESTS` to `ON` or `OFF`
+depending on the given default and whether the option was specified.
+
+### Defining Kokkos Config Macros
+
+Sometimes you may want to add `#define Kokkos_X` macros to the config header.
+This is straightforward with CMake.
+Suppose you want to define an optional macro `KOKKOS_SUPER_SCIENCE`.
+Simply go into `KokkosCore_config.h.in` and add
+````
+#cmakedefine KOKKOS_SUPER_SCIENCE
+````
+I can either add
+````
+KOKKOS_OPTION(SUPER_SCIENCE ON "Whether to do some super science")
+````
+to directly set the variable as a command-line `-D` option.
+Alternatively, based on other logic, I could add to a `CMakeLists.txt`
+````
+SET(KOKKOS_SUPER_SCIENCE ON)
+````
+If not set as a command-line option (cache variable), you must make sure the variable is visible in the top-level scope.
+If set in a function, you would need:
+````
+SET(KOKKOS_SUPER_SCIENCE ON PARENT_SCOPE)
+````
+
+### Third-Party Libraries
+In much the same way that compiler flags transitively propagate to dependent projects,
+modern CMake allows us to propagate dependent libraries.
+If Kokkos depends on, e.g. `hwloc` the downstream project will also need to link `hwloc`.
+There are three stages in adding a new third-party library (TPL):
+* Finding: find the desired library on the system and verify the installation is correct
+* Importing: create a CMake target, if necessary, that is compatible with `target_link_libraries`. This is mostly relevant for TPLs not installed with CMake.
+* Exporting: make the desired library visible to downstream projects 
+
+TPLs are somewhat complicated by whether the library was installed with CMake or some other build system.
+If CMake, our lives are greatly simplified. We simply use `find_package` to locate the installed CMake project then call `target_link_libraries(kokkoscore PUBLIC/PRIVATE TPL)`. For libaries not installed with CMake, the process is a bit more complex.
+It is up to the Kokkos developers to "convert" the library into a CMake target as if it had been installed as a valid modern CMake target with properties.  
+There are helper functions for simplifying the process of importing TPLs in Kokkos, but we walk through the process in detail to clearly illustrate the steps involved.
+
+#### TPL Search Order
+
+There are several options for where CMake could try to find a TPL.
+If there are multiple installations of the same TPL on the system,
+the search order is critical for making sure the correct TPL is found.
+There are 3 possibilities that could be used:
+
+1. Default system paths like /usr
+1. User-provided paths through options `<NAME>_ROOT` and `Kokkos_<NAME>_DIR`
+1. Additional paths not in the CMake default list or provided by the user that Kokkos decides to add. For example, Kokkos may query `nvcc` or `LD_LIBRARY_PATH` for where to find CUDA libraries.
+
+The following is the search order that Kokkos follows. Note: This differs from the default search order used by CMake `find_library` and `find_header`. CMake prefers default system paths over user-provided paths.
+For Kokkos (and package managers in general), it is better to prefer user-provided paths since this usually indicates a specific version we want.
+
+1. `<NAME>_ROOT`
+1. `Kokkos_<NAME>_DIR`
+1.  Paths added by Kokkos CMake logic
+1.  Default system paths (if allowed)
+
+Default system paths are allowed in two cases. First, none of the other options are given so the only place to look is system paths. Second, if explicitly given permission, configure will look in system paths.
+The rationale for this logic is that if you specify a custom location, you usually *only* want to look in that location.
+If you do not find the TPL where you expect it, you should error out rather than grab another random match.
+
+
+#### Finding TPLs
+
+If finding a TPL that is not a modern CMake project, refer to the `FindHWLOC.cmake` file in `cmake/Modules` for an example.
+You will usually need to verify expected headers with `find_path`
+````
+find_path(TPL_INCLUDE_DIR mytpl.h PATHS "${KOKKOS_MYTPL_DIR}/include")
+````
+This insures that the library header is in the expected include directory and defines the variable `TPL_INCLUDE_DIR` with a valid path if successful.
+Similarly, you can verify a library
+````
+find_library(TPL_LIBRARY mytpl PATHS "${KOKKOS_MYTPL_DIR/lib")
+````
+that then defines the variable `TPL_LIBRARY` with a valid path if successful.
+CMake provides a utility for checking if the `find_path` and `find_library` calls were successful that emulates the behavior of `find_package` for a CMake target.
+````
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MYTPL DEFAULT_MSG
+                                  MYTPL_INCLUDE_DIR MYTPL_LIBRARY)
+````
+If the find failed, CMake will print standard error messages explaining the failure.
+
+#### Importing TPLs
+
+The installed TPL must be adapted into a CMake target.
+CMake allows libraries to be added that are built externally as follows:
+````
+add_library(Kokkos::mytpl UNKNOWN IMPORTED)
+````
+Importantly, we use a `Kokkos::` namespace to avoid name conflicts and identify this specifically as the version imported by Kokkos.
+Because we are importing a non-CMake target, we must populate all the target properties that would have been automatically populated for a CMake target.
+````
+set_target_properties(Kokkos::mytpl PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${MYTPL_INCLUDE_DIR}"
+  IMPORTED_LOCATION "${MYTPL_LIBRARY}"
+)
+````
+
+#### Exporting TPLs
+
+Kokkos may now depend on the target `Kokkos::mytpl` as a `PUBLIC` library (remember building and using).
+This means that downstream projects must also know about `Kokkos::myptl` - so Kokkos must export them.
+In the `KokkosConfig.cmake.in` file, we need to add code like the following:
+````
+set(MYTPL_LIBRARY @MYTPL_LIBRARY@)
+set(MYTPL_INCLUDE_DIR @MYTPL_INCLUDE_DIR@)
+add_library(Kokkos::mytpl UNKNOWN IMPORTED)
+set_target_properties(Kokkos::mytpl PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${MYTPL_INCLUDE_DIR}"
+  IMPORTED_LOCATION "${MYTPL_LIBRARY}"
+)
+````
+If this looks familiar, that's because it is exactly the same code as above for importing the TPL.
+Exporting a TPL really just means importing the TPL when Kokkos is loaded by an external project.
+We will describe helper functions that simplify this process.
+
+#### Interface TPLs
+
+If a TPL is just a library and set of headers, we can make a simple `IMPORTED` target.
+However, a TPL is actually completely flexible and need not be limited to just headers and libraries.
+TPLs can configure compiler flags, linker flags, or multiple different libraries.
+For this, we use a special type of CMake target: `INTERFACE` libraries.
+These libraries don't build anything.
+They simply populate properties that will configure flags for dependent targets.
+We consider the example:
+````
+add_library(PTHREAD INTERFACE)
+target_compile_options(PTHREAD PUBLIC -pthread)
+````
+Kokkos uses the compiler flag `-pthread` to define compiler macros for re-entrant functions rather than treating it simply as a library with header `pthread.h` and library `-lpthread`.
+Any property can be configured, e.g.
+````
+target_link_libraries(MYTPL ...)
+````
+In contrast to imported TPLs which require direct modification of `KokkosConfig.cmake.in`,
+we can use CMake's built-in export functions:
+````
+INSTALL(
+  TARGETS MYTPL
+  EXPORT KokkosTargets
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+````
+These interface targets will be automatically populated in the config file.
+
+#### Linking the TPL
+After finishing the import process, it still remains to link the imported target as needed.
+For example,
+````
+target_link_libraries(kokkoscore PUBLIC Kokkos::HWLOC)
+````
+The complexity of which includes, options, and libraries the TPL requires
+should be encapsulated in the CMake target.
+
+#### TPL Helper Functions
+##### KOKKOS_IMPORT_TPL
+This function can be invoked as, e.g.
+````
+KOKKOS_IMPORT_TPL(HWLOC)
+````
+This function checks if the TPL was enabled by a `-DKokkos_ENABLE_HWLOC=On` flag.
+If so, it calls `find_package(TPLHWLOC)`.
+This invokes the file `FindTPLHWLOC.cmake` which should be contained in the `cmake/Modules` folder.
+If successful, another function `KOKKOS_EXPORT_CMAKE_TPL` gets invoked.
+This automatically adds all the necessary import commands to `KokkosConfig.cmake`.
+
+##### KOKKOS_FIND_IMPORTED
+Inside a `FindTPLX.cmake` file, the simplest way to import a library is to call, e.g.
+````
+KOKKOS_FIND_IMPORTED(HWLOC LIBRARY hwloc HEADER hwloc.h)
+````
+This finds the location of the library and header and creates an imported target `Kokkos::HWLOC`
+that can be linked against.
+The library/header find can be guided with `-DHWLOC_ROOT=` or `-DKokkos_HWLOC_DIR=` during CMake configure.
+These both specify the install prefix.
+
+##### KOKKOS_LINK_TPL
+This function checks if the TPL has been enabled.
+If so, it links a given library against the imported (or interface) TPL target.
+
+##### KOKKOS_CREATE_IMPORTED_TPL
+This helper function is best understood by reading the actual code.
+This function takes arguments specifying the properties and creates the actual TPL target.
+The most important thing to understand for this function is whether you call this function with the optional `INTERFACE` keyword.
+This tells the project to either create the target as an imported target or interface target, as discussed above.
+
+##### KOKKOS_EXPORT_CMAKE_TPL
+Even if the TPL just loads a valid CMake target, we still must "export" it into the config file.
+When Kokkos is loaded by a downstream project, this TPL must be loaded.
+Calling this function simply appends text recording the location where the TPL was found
+and adding a `find_dependency(...)` call that will reload the CMake target.
+
+### The Great TriBITS Compromise
+
+TriBITS was a masterpiece of CMake version 2 before the modern CMake idioms of building and using.
+TriBITS greatly limited verbosity of CMake files, handled complicated dependency trees between packages, and handled automatically setting up include and linker paths for dependent libraries.
+
+Kokkos is now used by numerous projects that don't (and won't) depend on TriBITS for their build systems.
+Kokkos has to work outside of TriBITS and provide a standard CMake 3+ build system.
+At the same time, Kokkos is used by numerous projects that depend on TriBITS and don't (and won't) switch to a standard CMake 3+ build system.
+
+Instead of calling functions `TRIBITS_X(...)`, the CMake calls wrapper functions `KOKKOS_X(...)`.
+If TriBITS is available (as in Trilinos), `KOKKOS_X` will just be a thin wrapper around `TRIBITS_X`.
+If TriBITS is not available, Kokkos maps `KOKKOS_X` calls to native CMake that complies with CMake 3 idioms.
+For the time being, this seems the most sensible way to handle the competing requirements of a standalone modern CMake and TriBITS build system.
+
+##### [LICENSE](https://github.com/kokkos/kokkos/blob/devel/LICENSE)
+
+[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+
+Under the terms of Contract DE-NA0003525 with NTESS,
+the U.S. Government retains certain rights in this software.
diff --git a/lib/kokkos/cmake/compile_tests/clang_omp.cpp b/lib/kokkos/cmake/compile_tests/clang_omp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce3bbfb262377248628385f56578db9d8c5b6a33
--- /dev/null
+++ b/lib/kokkos/cmake/compile_tests/clang_omp.cpp
@@ -0,0 +1,9 @@
+#include <omp.h>
+
+int main(int argc, char** argv) {
+  int thr = omp_get_num_threads();
+  if (thr > 0)
+    return thr;
+  else
+    return 0;
+}
diff --git a/lib/kokkos/cmake/compile_tests/pthread.cpp b/lib/kokkos/cmake/compile_tests/pthread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3b13f7ba357f6c05ffad30a61b01620fb33666b0
--- /dev/null
+++ b/lib/kokkos/cmake/compile_tests/pthread.cpp
@@ -0,0 +1,10 @@
+#include <pthread.h>
+
+void* kokkos_test(void* args) { return args; }
+
+int main(void) {
+  pthread_t thread;
+  pthread_create(&thread, NULL, kokkos_test, NULL);
+  pthread_join(thread, NULL);
+  return 0;
+}
diff --git a/lib/kokkos/cmake/cray.cmake b/lib/kokkos/cmake/cray.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..08912f5130f92fec97a4bdb6abb90e860d0b9cda
--- /dev/null
+++ b/lib/kokkos/cmake/cray.cmake
@@ -0,0 +1,9 @@
+
+
+function(kokkos_set_cray_flags full_standard int_standard)
+  STRING(TOLOWER ${full_standard} FULL_LC_STANDARD)
+  STRING(TOLOWER ${int_standard} INT_LC_STANDARD)
+  SET(KOKKOS_CXX_STANDARD_FLAG "-hstd=c++${FULL_LC_STANDARD}", PARENT_SCOPE)
+  SET(KOKKOS_CXX_INTERMDIATE_STANDARD_FLAG "-hstd=c++${INT_LC_STANDARD}" PARENT_SCOPE)
+endfunction()
+
diff --git a/lib/kokkos/cmake/deps/CUDA.cmake b/lib/kokkos/cmake/deps/CUDA.cmake
index 801c20067b9195db5ba5e6cd6fdd62a426e6e294..4876bca25907eb632a8f12d01352ddaa854fd341 100644
--- a/lib/kokkos/cmake/deps/CUDA.cmake
+++ b/lib/kokkos/cmake/deps/CUDA.cmake
@@ -73,7 +73,7 @@ IF(NOT _CUDA_FAILURE)
   GLOBAL_SET(TPL_CUDA_LIBRARY_DIRS)
   GLOBAL_SET(TPL_CUDA_INCLUDE_DIRS ${CUDA_TOOLKIT_INCLUDE})
   GLOBAL_SET(TPL_CUDA_LIBRARIES ${CUDA_CUDART_LIBRARY} ${CUDA_cublas_LIBRARY} ${CUDA_cufft_LIBRARY})
-  TIBITS_CREATE_IMPORTED_TPL_LIBRARY(CUSPARSE)
+  KOKKOS_CREATE_IMPORTED_TPL_LIBRARY(CUSPARSE)
 ELSE()
   SET(TPL_ENABLE_CUDA OFF)
 ENDIF()
diff --git a/lib/kokkos/cmake/deps/CUSPARSE.cmake b/lib/kokkos/cmake/deps/CUSPARSE.cmake
index 6f26d857c09acf7bb24c2c5449a54f5d507deae8..b2420d1168e55d7ce990ff5380ba638996888a09 100644
--- a/lib/kokkos/cmake/deps/CUSPARSE.cmake
+++ b/lib/kokkos/cmake/deps/CUSPARSE.cmake
@@ -59,6 +59,6 @@
 #  GLOBAL_SET(TPL_CUSPARSE_LIBRARY_DIRS)
 #  GLOBAL_SET(TPL_CUSPARSE_INCLUDE_DIRS ${TPL_CUDA_INCLUDE_DIRS})
 #  GLOBAL_SET(TPL_CUSPARSE_LIBRARIES    ${CUDA_cusparse_LIBRARY})
-#  TIBITS_CREATE_IMPORTED_TPL_LIBRARY(CUSPARSE)
+#  KOKKOS_CREATE_IMPORTED_TPL_LIBRARY(CUSPARSE)
 #ENDIF()
 
diff --git a/lib/kokkos/cmake/deps/HWLOC.cmake b/lib/kokkos/cmake/deps/HWLOC.cmake
index 275abd3a5d4ecfb3ce3b207f978959f6f9019061..ed89c8c1e511593663a4565316f596aa36317baa 100644
--- a/lib/kokkos/cmake/deps/HWLOC.cmake
+++ b/lib/kokkos/cmake/deps/HWLOC.cmake
@@ -64,7 +64,7 @@
 #    Version:       1.3
 #
 
-TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( HWLOC
+KOKKOS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( HWLOC
   REQUIRED_HEADERS hwloc.h
   REQUIRED_LIBS_NAMES "hwloc"
   )
diff --git a/lib/kokkos/cmake/deps/Pthread.cmake b/lib/kokkos/cmake/deps/Pthread.cmake
index 46d0a939cad0e6c5479cb20da1d37ba5ca509b8c..5f835fc3002f752f0aae5a5a54894b3f1d16451b 100644
--- a/lib/kokkos/cmake/deps/Pthread.cmake
+++ b/lib/kokkos/cmake/deps/Pthread.cmake
@@ -74,9 +74,9 @@ IF(USE_THREADS)
   SET(TPL_Pthread_INCLUDE_DIRS "")
   SET(TPL_Pthread_LIBRARIES "${CMAKE_THREAD_LIBS_INIT}")
   SET(TPL_Pthread_LIBRARY_DIRS "")
-  TIBITS_CREATE_IMPORTED_TPL_LIBRARY(Pthread)
+  KOKKOS_CREATE_IMPORTED_TPL_LIBRARY(Pthread)
 ELSE()
-  TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( Pthread
+  KOKKOS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( Pthread
     REQUIRED_HEADERS pthread.h
     REQUIRED_LIBS_NAMES pthread
       )
diff --git a/lib/kokkos/cmake/deps/QTHREADS.cmake b/lib/kokkos/cmake/deps/QTHREADS.cmake
deleted file mode 100644
index c312f2590bcd29197a0cf3fbd5e0b484579a09c2..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/deps/QTHREADS.cmake
+++ /dev/null
@@ -1,69 +0,0 @@
-# @HEADER
-# ************************************************************************
-#
-#            Trilinos: An Object-Oriented Solver Framework
-#                 Copyright (2001) Sandia Corporation
-#
-#
-# Copyright (2001) Sandia Corporation. Under the terms of Contract
-# DE-AC04-94AL85000, there is a non-exclusive license for use of this
-# work by or on behalf of the U.S. Government.  Export of this program
-# may require a license from the United States Government.
-#
-# 1. Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in the
-# documentation and/or other materials provided with the distribution.
-#
-# 3. Neither the name of the Corporation nor the names of the
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-# NOTICE:  The United States Government is granted for itself and others
-# acting on its behalf a paid-up, nonexclusive, irrevocable worldwide
-# license in this data to reproduce, prepare derivative works, and
-# perform publicly and display publicly.  Beginning five (5) years from
-# July 25, 2001, the United States Government is granted for itself and
-# others acting on its behalf a paid-up, nonexclusive, irrevocable
-# worldwide license in this data to reproduce, prepare derivative works,
-# distribute copies to the public, perform publicly and display
-# publicly, and to permit others to do so.
-#
-# NEITHER THE UNITED STATES GOVERNMENT, NOR THE UNITED STATES DEPARTMENT
-# OF ENERGY, NOR SANDIA CORPORATION, NOR ANY OF THEIR EMPLOYEES, MAKES
-# ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL LIABILITY OR
-# RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR USEFULNESS OF ANY
-# INFORMATION, APPARATUS, PRODUCT, OR PROCESS DISCLOSED, OR REPRESENTS
-# THAT ITS USE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS.
-#
-# ************************************************************************
-# @HEADER
-
-
-#-----------------------------------------------------------------------------
-#  Hardware locality detection and control library.
-#
-#  Acquisition information:
-#    Date checked:  July 2014
-#    Checked by:    H. Carter Edwards <hcedwar AT sandia.gov>
-#    Source:        https://code.google.com/p/qthreads
-#
-
-TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( QTHREADS
-  REQUIRED_HEADERS qthread.h
-  REQUIRED_LIBS_NAMES "qthread"
-  )
diff --git a/lib/kokkos/cmake/fake_tribits.cmake b/lib/kokkos/cmake/fake_tribits.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..26948d2cfbbd3bf724703447a81e66ee29ea000e
--- /dev/null
+++ b/lib/kokkos/cmake/fake_tribits.cmake
@@ -0,0 +1,338 @@
+#These are tribits wrappers used by all projects in the Kokkos ecosystem
+
+INCLUDE(CMakeParseArguments)
+INCLUDE(CTest)
+
+cmake_policy(SET CMP0054 NEW)
+
+FUNCTION(ASSERT_DEFINED VARS)
+  FOREACH(VAR ${VARS})
+    IF(NOT DEFINED ${VAR})
+      MESSAGE(SEND_ERROR "Error, the variable ${VAR} is not defined!")
+    ENDIF()
+  ENDFOREACH()
+ENDFUNCTION()
+
+MACRO(KOKKOS_ADD_OPTION_AND_DEFINE USER_OPTION_NAME MACRO_DEFINE_NAME DOCSTRING DEFAULT_VALUE )
+SET( ${USER_OPTION_NAME} "${DEFAULT_VALUE}" CACHE BOOL "${DOCSTRING}" )
+IF(NOT ${MACRO_DEFINE_NAME} STREQUAL "")
+  IF(${USER_OPTION_NAME})
+    GLOBAL_SET(${MACRO_DEFINE_NAME} ON)
+  ELSE()
+    GLOBAL_SET(${MACRO_DEFINE_NAME} OFF)
+  ENDIF()
+ENDIF()
+ENDMACRO()
+
+MACRO(GLOBAL_RESET VARNAME)
+  SET(${VARNAME} "" CACHE INTERNAL "" FORCE)
+ENDMACRO()
+
+MACRO(GLOBAL_OVERWRITE VARNAME VALUE TYPE)
+  SET(${VARNAME} ${VALUE} CACHE ${TYPE} "" FORCE)
+ENDMACRO()
+
+IF (NOT KOKKOS_HAS_TRILINOS)
+MACRO(APPEND_GLOB VAR)
+  FILE(GLOB LOCAL_TMP_VAR ${ARGN})
+  LIST(APPEND ${VAR} ${LOCAL_TMP_VAR})
+ENDMACRO()
+
+MACRO(GLOBAL_SET VARNAME)
+  SET(${VARNAME} ${ARGN} CACHE INTERNAL "" FORCE)
+ENDMACRO()
+
+FUNCTION(VERIFY_EMPTY CONTEXT)
+if(${ARGN})
+MESSAGE(FATAL_ERROR "Kokkos does not support all of Tribits. Unhandled arguments in ${CONTEXT}:\n${ARGN}")
+endif()
+ENDFUNCTION()
+
+MACRO(PREPEND_GLOBAL_SET VARNAME)
+  ASSERT_DEFINED(${VARNAME})
+  GLOBAL_SET(${VARNAME} ${ARGN} ${${VARNAME}})
+ENDMACRO()
+
+MACRO(PREPEND_TARGET_SET VARNAME TARGET_NAME TYPE)
+  IF(TYPE STREQUAL "REQUIRED")
+    SET(REQUIRED TRUE)
+  ELSE()
+    SET(REQUIRED FALSE)
+  ENDIF()
+  IF(TARGET ${TARGET_NAME})
+    PREPEND_GLOBAL_SET(${VARNAME} ${TARGET_NAME})
+  ELSE()
+    IF(REQUIRED)
+      MESSAGE(FATAL_ERROR "Missing dependency ${TARGET_NAME}")
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+endif()
+
+
+FUNCTION(KOKKOS_CONFIGURE_FILE  PACKAGE_NAME_CONFIG_FILE)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_CONFIGURE_FILE(${PACKAGE_NAME_CONFIG_FILE})
+  else()
+    # Configure the file
+    CONFIGURE_FILE(
+      ${PACKAGE_SOURCE_DIR}/cmake/${PACKAGE_NAME_CONFIG_FILE}.in
+      ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME_CONFIG_FILE}
+      )
+  endif()
+ENDFUNCTION()
+
+MACRO(ADD_INTERFACE_LIBRARY LIB_NAME)
+  FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp "")
+  ADD_LIBRARY(${LIB_NAME} STATIC ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp)
+  SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES INTERFACE TRUE)
+ENDMACRO()
+
+IF(NOT TARGET check)
+  ADD_CUSTOM_TARGET(check COMMAND ${CMAKE_CTEST_COMMAND} -VV -C ${CMAKE_CFG_INTDIR})
+ENDIF()
+
+FUNCTION(KOKKOS_ADD_TEST)
+  if (KOKKOS_HAS_TRILINOS)
+    CMAKE_PARSE_ARGUMENTS(TEST 
+      ""
+      "EXE;NAME"
+      ""
+      ${ARGN})
+    IF(TEST_EXE)
+      SET(EXE_ROOT ${TEST_EXE})
+    ELSE()
+      SET(EXE_ROOT ${TEST_NAME})
+    ENDIF()
+
+    TRIBITS_ADD_TEST(
+      ${EXE_ROOT}
+      NAME ${TEST_NAME}
+      ${ARGN} 
+      COMM serial mpi
+      NUM_MPI_PROCS 1
+      ${TEST_UNPARSED_ARGUMENTS}
+    )
+  else()
+    CMAKE_PARSE_ARGUMENTS(TEST 
+      "WILL_FAIL"
+      "FAIL_REGULAR_EXPRESSION;PASS_REGULAR_EXPRESSION;EXE;NAME"
+      "CATEGORIES;CMD_ARGS"
+      ${ARGN})
+    IF(TEST_EXE)
+      SET(EXE ${TEST_EXE})
+    ELSE()
+      SET(EXE ${TEST_NAME})
+    ENDIF()
+    IF(WIN32)
+      ADD_TEST(NAME ${TEST_NAME} WORKING_DIRECTORY ${LIBRARY_OUTPUT_PATH} COMMAND ${EXE}${CMAKE_EXECUTABLE_SUFFIX} ${TEST_CMD_ARGS})
+    ELSE()
+      ADD_TEST(NAME ${TEST_NAME} COMMAND ${EXE} ${TEST_CMD_ARGS})
+    ENDIF()
+    IF(TEST_WILL_FAIL)
+      SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES WILL_FAIL ${TEST_WILL_FAIL})
+    ENDIF()
+    IF(TEST_FAIL_REGULAR_EXPRESSION)
+      SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES FAIL_REGULAR_EXPRESSION ${TEST_FAIL_REGULAR_EXPRESSION})
+    ENDIF()
+    IF(TEST_PASS_REGULAR_EXPRESSION)
+      SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES PASS_REGULAR_EXPRESSION ${TEST_PASS_REGULAR_EXPRESSION})
+    ENDIF()
+    VERIFY_EMPTY(KOKKOS_ADD_TEST ${TEST_UNPARSED_ARGUMENTS})
+  endif()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_ADD_ADVANCED_TEST)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_ADD_ADVANCED_TEST(${ARGN})
+  else()
+    # TODO Write this
+  endif()
+ENDFUNCTION()
+
+MACRO(KOKKOS_CREATE_IMPORTED_TPL_LIBRARY TPL_NAME)
+  ADD_INTERFACE_LIBRARY(TPL_LIB_${TPL_NAME})
+  TARGET_LINK_LIBRARIES(TPL_LIB_${TPL_NAME} LINK_PUBLIC ${TPL_${TPL_NAME}_LIBRARIES})
+  TARGET_INCLUDE_DIRECTORIES(TPL_LIB_${TPL_NAME} INTERFACE ${TPL_${TPL_NAME}_INCLUDE_DIRS})
+ENDMACRO()
+
+FUNCTION(KOKKOS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES TPL_NAME)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES(${TPL_NAME} ${ARGN})
+  else()
+    CMAKE_PARSE_ARGUMENTS(PARSE 
+      ""
+      ""
+      "REQUIRED_HEADERS;REQUIRED_LIBS_NAMES"
+      ${ARGN})
+
+    SET(_${TPL_NAME}_ENABLE_SUCCESS TRUE)
+    IF (PARSE_REQUIRED_LIBS_NAMES)
+      FIND_LIBRARY(TPL_${TPL_NAME}_LIBRARIES NAMES ${PARSE_REQUIRED_LIBS_NAMES})
+      IF(NOT TPL_${TPL_NAME}_LIBRARIES)
+        SET(_${TPL_NAME}_ENABLE_SUCCESS FALSE)
+      ENDIF()
+    ENDIF()
+    IF (PARSE_REQUIRED_HEADERS)
+      FIND_PATH(TPL_${TPL_NAME}_INCLUDE_DIRS NAMES ${PARSE_REQUIRED_HEADERS})
+      IF(NOT TPL_${TPL_NAME}_INCLUDE_DIRS)
+        SET(_${TPL_NAME}_ENABLE_SUCCESS FALSE)
+      ENDIF()
+    ENDIF()
+    IF (_${TPL_NAME}_ENABLE_SUCCESS)
+      KOKKOS_CREATE_IMPORTED_TPL_LIBRARY(${TPL_NAME})
+    ENDIF()
+    VERIFY_EMPTY(KOKKOS_CREATE_IMPORTED_TPL_LIBRARY ${PARSE_UNPARSED_ARGUMENTS})
+  endif()
+ENDFUNCTION()
+
+MACRO(KOKKOS_TARGET_COMPILE_OPTIONS TARGET)
+if(KOKKOS_HAS_TRILINOS)
+  TARGET_COMPILE_OPTIONS(${TARGET} ${ARGN})
+else()
+  TARGET_COMPILE_OPTIONS(${TARGET} ${ARGN})
+endif()
+ENDMACRO()
+
+
+MACRO(KOKKOS_EXCLUDE_AUTOTOOLS_FILES)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_EXCLUDE_AUTOTOOLS_FILES()
+  else()
+    #do nothing
+  endif()
+ENDMACRO()
+
+FUNCTION(KOKKOS_LIB_TYPE LIB RET)
+GET_TARGET_PROPERTY(PROP ${LIB} TYPE)
+IF (${PROP} STREQUAL "INTERFACE_LIBRARY")
+  SET(${RET} "INTERFACE" PARENT_SCOPE)
+ELSE()
+  SET(${RET} "PUBLIC" PARENT_SCOPE)
+ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_TARGET_INCLUDE_DIRECTORIES TARGET)
+IF(KOKKOS_HAS_TRILINOS)
+  KOKKOS_LIB_TYPE(${TARGET} INCTYPE) 
+  #don't trust tribits to do this correctly - but need to add package name
+  TARGET_INCLUDE_DIRECTORIES(${TARGET} ${INCTYPE} ${ARGN})
+ELSEIF(TARGET ${TARGET}) 
+  #the target actually exists - this means we are doing separate libs
+  #or this a test library
+  KOKKOS_LIB_TYPE(${TARGET} INCTYPE) 
+  TARGET_INCLUDE_DIRECTORIES(${TARGET} ${INCTYPE} ${ARGN})
+ELSE()
+  GET_PROPERTY(LIBS GLOBAL PROPERTY KOKKOS_LIBRARIES_NAMES)
+  IF (${TARGET} IN_LIST LIBS)
+     SET_PROPERTY(GLOBAL APPEND PROPERTY KOKKOS_LIBRARY_INCLUDES ${ARGN})
+  ELSE()
+    MESSAGE(FATAL_ERROR "Trying to set include directories on unknown target ${TARGET}")
+  ENDIF()
+ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_LINK_INTERNAL_LIBRARY TARGET DEPLIB)
+IF(KOKKOS_HAS_TRILINOS)
+  #do nothing
+ELSE()
+  SET(options INTERFACE)
+  SET(oneValueArgs)
+  SET(multiValueArgs)
+  CMAKE_PARSE_ARGUMENTS(PARSE 
+    "INTERFACE"
+    ""
+    ""
+    ${ARGN})
+  SET(LINK_TYPE)
+  IF(PARSE_INTERFACE)
+    SET(LINK_TYPE INTERFACE)
+  ELSE()
+    SET(LINK_TYPE PUBLIC)
+  ENDIF()
+  TARGET_LINK_LIBRARIES(${TARGET} ${LINK_TYPE} ${DEPLIB})
+  VERIFY_EMPTY(KOKKOS_LINK_INTERNAL_LIBRARY ${PARSE_UNPARSED_ARGUMENTS})
+ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_ADD_TEST_LIBRARY NAME)
+IF (KOKKOS_HAS_TRILINOS)
+  TRIBITS_ADD_LIBRARY(${NAME} ${ARGN} TESTONLY
+   ADDED_LIB_TARGET_NAME_OUT ${NAME}
+  )
+ELSE()
+  SET(oneValueArgs)
+  SET(multiValueArgs HEADERS SOURCES)
+
+  CMAKE_PARSE_ARGUMENTS(PARSE 
+    "STATIC;SHARED"
+    ""
+    "HEADERS;SOURCES"
+    ${ARGN})
+
+  IF(PARSE_HEADERS)
+    LIST(REMOVE_DUPLICATES PARSE_HEADERS)
+  ENDIF()
+  IF(PARSE_SOURCES)
+    LIST(REMOVE_DUPLICATES PARSE_SOURCES)
+  ENDIF()
+  ADD_LIBRARY(${NAME} ${PARSE_SOURCES})
+  target_link_libraries(
+    ${NAME}
+    PUBLIC kokkos
+  )
+ENDIF()
+ENDFUNCTION()
+
+
+FUNCTION(KOKKOS_TARGET_COMPILE_DEFINITIONS)
+  IF (KOKKOS_HAS_TRILINOS)
+    TARGET_COMPILE_DEFINITIONS(${TARGET} ${ARGN})
+  ELSE()
+    TARGET_COMPILE_DEFINITIONS(${TARGET} ${ARGN})
+  ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_INCLUDE_DIRECTORIES)
+IF(KOKKOS_HAS_TRILINOS)
+  TRIBITS_INCLUDE_DIRECTORIES(${ARGN})
+ELSE()
+  CMAKE_PARSE_ARGUMENTS(
+    INC
+    "REQUIRED_DURING_INSTALLATION_TESTING"
+    ""
+    ""
+    ${ARGN}
+  )
+  INCLUDE_DIRECTORIES(${INC_UNPARSED_ARGUMENTS})
+ENDIF()
+ENDFUNCTION()
+
+
+MACRO(KOKKOS_ADD_COMPILE_OPTIONS)
+ADD_COMPILE_OPTIONS(${ARGN})
+ENDMACRO()
+
+MACRO(PRINTALL match)
+get_cmake_property(_variableNames VARIABLES)
+list (SORT _variableNames)
+foreach (_variableName ${_variableNames})
+  if("${_variableName}" MATCHES "${match}")
+    message(STATUS "${_variableName}=${${_variableName}}")
+  endif()
+endforeach()
+ENDMACRO()
+
+MACRO(SET_GLOBAL_REPLACE SUBSTR VARNAME)
+  STRING(REPLACE ${SUBSTR} ${${VARNAME}} TEMP)
+  GLOBAL_SET(${VARNAME} ${TEMP})
+ENDMACRO()
+
+FUNCTION(GLOBAL_APPEND VARNAME)
+  #We make this a function since we are setting variables
+  #and want to use scope to avoid overwriting local variables
+  SET(TEMP ${${VARNAME}})
+  LIST(APPEND TEMP ${ARGN})
+  GLOBAL_SET(${VARNAME} ${TEMP})
+ENDFUNCTION()
+
diff --git a/lib/kokkos/cmake/gnu.cmake b/lib/kokkos/cmake/gnu.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..aa11fe87b111970ea440a3765c06d0b31b402d15
--- /dev/null
+++ b/lib/kokkos/cmake/gnu.cmake
@@ -0,0 +1,23 @@
+
+FUNCTION(kokkos_set_gnu_flags full_standard int_standard)
+  STRING(TOLOWER ${full_standard} FULL_LC_STANDARD)
+  STRING(TOLOWER ${int_standard} INT_LC_STANDARD)
+  # The following three blocks of code were copied from
+  # /Modules/Compiler/Intel-CXX.cmake from CMake 3.7.2 and then modified.
+  IF(CMAKE_CXX_SIMULATE_ID STREQUAL MSVC)
+    SET(_std -Qstd)
+    SET(_ext c++)
+  ELSE()
+    SET(_std -std)
+    SET(_ext gnu++)
+  ENDIF()
+
+  IF (CMAKE_CXX_EXTENSIONS)
+    SET(KOKKOS_CXX_STANDARD_FLAG "-std=gnu++${FULL_LC_STANDARD}" PARENT_SCOPE)
+    SET(KOKKOS_CXX_INTERMEDIATE_STANDARD_FLAG "-std=gnu++${INT_LC_STANDARD}" PARENT_SCOPE)
+  ELSE()
+    SET(KOKKOS_CXX_STANDARD_FLAG "-std=c++${FULL_LC_STANDARD}" PARENT_SCOPE)
+    SET(KOKKOS_CXX_INTERMEDIATE_STANDARD_FLAG "-std=c++${INT_LC_STANDARD}" PARENT_SCOPE)
+  ENDIF()
+ENDFUNCTION()
+
diff --git a/lib/kokkos/cmake/intel.cmake b/lib/kokkos/cmake/intel.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f36f01d8ca669780c01c2a4145d3e3c78241b2b3
--- /dev/null
+++ b/lib/kokkos/cmake/intel.cmake
@@ -0,0 +1,30 @@
+
+FUNCTION(kokkos_set_intel_flags full_standard int_standard)
+  STRING(TOLOWER ${full_standard} FULL_LC_STANDARD)
+  STRING(TOLOWER ${int_standard} INT_LC_STANDARD)
+  # The following three blocks of code were copied from
+  # /Modules/Compiler/Intel-CXX.cmake from CMake 3.7.2 and then modified.
+  IF(CMAKE_CXX_SIMULATE_ID STREQUAL MSVC)
+    SET(_std -Qstd)
+    SET(_ext c++)
+  ELSE()
+    SET(_std -std)
+    SET(_ext gnu++)
+  ENDIF()
+
+  IF(NOT KOKKOS_CXX_STANDARD STREQUAL 11 AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0.2)
+    #There is no gnu++14 value supported; figure out what to do.
+    SET(KOKKOS_CXX_STANDARD_FLAG "${_std}=c++${FULL_LC_STANDARD}" PARENT_SCOPE)
+    SET(KOKKOS_CXX_INTERMEDIATE_STANDARD_FLAG "${_std}=c++${INT_LC_STANDARD}" PARENT_SCOPE)
+  ELSEIF(KOKKOS_CXX_STANDARD STREQUAL 11 AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+    IF (CMAKE_CXX_EXTENSIONS)
+      SET(KOKKOS_CXX_STANDARD_FLAG "${_std}=${_ext}c++11" PARENT_SCOPE)
+    ELSE()
+      SET(KOKKOS_CXX_STANDARD_FLAG "${_std}=c++11" PARENT_SCOPE)
+    ENDIF()
+  ELSE()
+    MESSAGE(FATAL_ERROR "Intel compiler version too low - need 13.0 for C++11 and 15.0 for C++14")
+  ENDIF()
+
+ENDFUNCTION()
+
diff --git a/lib/kokkos/cmake/kokkos_arch.cmake b/lib/kokkos/cmake/kokkos_arch.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c33247c9550f026d3ac5f611ecb049fe82333b03
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_arch.cmake
@@ -0,0 +1,438 @@
+
+FUNCTION(KOKKOS_ARCH_OPTION SUFFIX DEV_TYPE DESCRIPTION)
+  #all optimizations off by default
+  KOKKOS_OPTION(ARCH_${SUFFIX} OFF BOOL "Optimize for ${DESCRIPTION} (${DEV_TYPE})")
+  IF (KOKKOS_ARCH_${SUFFIX})
+    LIST(APPEND KOKKOS_ENABLED_ARCH_LIST ${SUFFIX})
+    SET(KOKKOS_ENABLED_ARCH_LIST ${KOKKOS_ENABLED_ARCH_LIST} PARENT_SCOPE)
+  ENDIF()
+  SET(KOKKOS_ARCH_${SUFFIX} ${KOKKOS_ARCH_${SUFFIX}} PARENT_SCOPE)
+ENDFUNCTION()
+
+FUNCTION(ARCH_FLAGS)
+  SET(COMPILERS NVIDIA PGI XL DEFAULT Cray Intel Clang AppleClang GNU)
+  CMAKE_PARSE_ARGUMENTS(
+    PARSE
+    "LINK_ONLY;COMPILE_ONLY"
+    ""
+    "${COMPILERS}"
+    ${ARGN})
+
+  SET(COMPILER ${KOKKOS_CXX_COMPILER_ID})
+
+  SET(FLAGS)
+  SET(NEW_COMPILE_OPTIONS)
+  SET(NEW_XCOMPILER_OPTIONS)
+  SET(NEW_LINK_OPTIONS)
+  LIST(APPEND NEW_XCOMPILER_OPTIONS ${KOKKOS_XCOMPILER_OPTIONS})
+  LIST(APPEND NEW_COMPILE_OPTIONS ${KOKKOS_COMPILE_OPTIONS})
+  LIST(APPEND NEW_LINK_OPTIONS ${KOKKOS_LINK_OPTIONS})
+  FOREACH(COMP ${COMPILERS})
+    IF (COMPILER STREQUAL "${COMP}")
+      IF (PARSE_${COMPILER})
+        IF (NOT "${PARSE_${COMPILER}}" STREQUAL "NO-VALUE-SPECIFIED")
+           SET(FLAGS ${PARSE_${COMPILER}})
+        ENDIF()
+      ELSEIF(PARSE_DEFAULT)
+        SET(FLAGS ${PARSE_DEFAULT})
+      ENDIF()
+    ENDIF()
+  ENDFOREACH()
+
+  IF (NOT LINK_ONLY)
+    # The funky logic here is for future handling of argument deduplication
+    # If we naively pass multiple -Xcompiler flags to target_compile_options
+    # -Xcompiler will get deduplicated and break the build
+    IF ("-Xcompiler" IN_LIST FLAGS)
+      LIST(REMOVE_ITEM FLAGS "-Xcompiler")
+      GLOBAL_APPEND(KOKKOS_XCOMPILER_OPTIONS ${FLAGS})
+    ELSE()
+      GLOBAL_APPEND(KOKKOS_COMPILE_OPTIONS ${FLAGS})
+    ENDIF()
+  ENDIF()
+
+  IF (NOT COMPILE_ONLY)
+    GLOBAL_APPEND(KOKKOS_LINK_OPTIONS ${FLAGS})
+  ENDIF()
+ENDFUNCTION()
+
+# Make sure devices and compiler ID are done
+KOKKOS_CFG_DEPENDS(ARCH COMPILER_ID)
+KOKKOS_CFG_DEPENDS(ARCH DEVICES)
+KOKKOS_CFG_DEPENDS(ARCH OPTIONS)
+
+
+#-------------------------------------------------------------------------------
+# List of possible host architectures.
+#-------------------------------------------------------------------------------
+SET(KOKKOS_ARCH_LIST)
+
+
+KOKKOS_DEPRECATED_LIST(ARCH ARCH)
+KOKKOS_ARCH_OPTION(AMDAVX          HOST "AMD chip")
+KOKKOS_ARCH_OPTION(ARMV80          HOST "ARMv8.0 Compatible CPU")
+KOKKOS_ARCH_OPTION(ARMV81          HOST "ARMv8.1 Compatible CPU")
+KOKKOS_ARCH_OPTION(ARMV8_THUNDERX  HOST "ARMv8 Cavium ThunderX CPU")
+KOKKOS_ARCH_OPTION(ARMV8_THUNDERX2 HOST "ARMv8 Cavium ThunderX2 CPU")
+KOKKOS_ARCH_OPTION(WSM             HOST "Intel Westmere CPU")
+KOKKOS_ARCH_OPTION(SNB             HOST "Intel Sandy/Ivy Bridge CPUs")
+KOKKOS_ARCH_OPTION(HSW             HOST "Intel Haswell CPUs")
+KOKKOS_ARCH_OPTION(BDW             HOST "Intel Broadwell Xeon E-class CPUs")
+KOKKOS_ARCH_OPTION(SKX             HOST "Intel Sky Lake Xeon E-class HPC CPUs (AVX512)")
+KOKKOS_ARCH_OPTION(KNC             HOST "Intel Knights Corner Xeon Phi")
+KOKKOS_ARCH_OPTION(KNL             HOST "Intel Knights Landing Xeon Phi")
+KOKKOS_ARCH_OPTION(BGQ             HOST "IBM Blue Gene Q")
+KOKKOS_ARCH_OPTION(POWER7          HOST "IBM POWER7 CPUs")
+KOKKOS_ARCH_OPTION(POWER8          HOST "IBM POWER8 CPUs")
+KOKKOS_ARCH_OPTION(POWER9          HOST "IBM POWER9 CPUs")
+KOKKOS_ARCH_OPTION(KEPLER30        GPU  "NVIDIA Kepler generation CC 3.0")
+KOKKOS_ARCH_OPTION(KEPLER32        GPU  "NVIDIA Kepler generation CC 3.2")
+KOKKOS_ARCH_OPTION(KEPLER35        GPU  "NVIDIA Kepler generation CC 3.5")
+KOKKOS_ARCH_OPTION(KEPLER37        GPU  "NVIDIA Kepler generation CC 3.7")
+KOKKOS_ARCH_OPTION(MAXWELL50       GPU  "NVIDIA Maxwell generation CC 5.0")
+KOKKOS_ARCH_OPTION(MAXWELL52       GPU  "NVIDIA Maxwell generation CC 5.2")
+KOKKOS_ARCH_OPTION(MAXWELL53       GPU  "NVIDIA Maxwell generation CC 5.3")
+KOKKOS_ARCH_OPTION(PASCAL60        GPU  "NVIDIA Pascal generation CC 6.0")
+KOKKOS_ARCH_OPTION(PASCAL61        GPU  "NVIDIA Pascal generation CC 6.1")
+KOKKOS_ARCH_OPTION(VOLTA70         GPU  "NVIDIA Volta generation CC 7.0")
+KOKKOS_ARCH_OPTION(VOLTA72         GPU  "NVIDIA Volta generation CC 7.2")
+KOKKOS_ARCH_OPTION(TURING75        GPU  "NVIDIA Turing generation CC 7.5")
+KOKKOS_ARCH_OPTION(EPYC            HOST "AMD Epyc architecture")
+
+
+IF (KOKKOS_ENABLE_CUDA)
+ #Regardless of version, make sure we define the general architecture name
+ IF (KOKKOS_ARCH_KEPLER30 OR KOKKOS_ARCH_KEPLER32 OR KOKKOS_ARCH_KEPLER35 OR KOKKOS_ARCH_KEPLER37)
+   SET(KOKKOS_ARCH_KEPLER ON)
+ ENDIF()
+ 
+ #Regardless of version, make sure we define the general architecture name
+ IF (KOKKOS_ARCH_MAXWELL50 OR KOKKOS_ARCH_MAXWELL52 OR KOKKOS_ARCH_MAXWELL53)
+   SET(KOKKOS_ARCH_MAXWELL ON)
+ ENDIF()
+
+ #Regardless of version, make sure we define the general architecture name
+ IF (KOKKOS_ARCH_PASCAL60 OR KOKKOS_ARCH_PASCAL61)
+   SET(KOKKOS_ARCH_PASCAL ON)
+ ENDIF()
+
+  #Regardless of version, make sure we define the general architecture name
+  IF (KOKKOS_ARCH_VOLTA70 OR KOKKOS_ARCH_VOLTA72)
+    SET(KOKKOS_ARCH_VOLTA ON)
+  ENDIF()
+ENDIF()
+
+
+
+IF(KOKKOS_ENABLE_COMPILER_WARNINGS)
+  SET(COMMON_WARNINGS
+    "-Wall" "-Wshadow" "-pedantic" 
+    "-Wsign-compare" "-Wtype-limits" "-Wuninitialized")
+
+  SET(GNU_WARNINGS "-Wempty-body" "-Wclobbered" "-Wignored-qualifiers"
+    ${COMMON_WARNINGS})
+
+  ARCH_FLAGS(
+    PGI NO-VALUE-SPECIFIED
+    GNU     ${GNU_WARNINGS}
+    DEFAULT ${COMMON_WARNINGS}
+  )
+ENDIF()
+
+
+#------------------------------- KOKKOS_CUDA_OPTIONS ---------------------------
+GLOBAL_RESET(KOKKOS_CUDA_OPTIONS)
+# Construct the Makefile options
+IF (KOKKOS_ENABLE_CUDA_LAMBDA)
+  IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+    GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "-expt-extended-lambda")
+  ENDIF()
+ENDIF()
+
+IF (KOKKOS_ENABLE_CUDA_CONSTEXPR)
+  IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+    GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "-expt-relaxed-constexpr")
+  ENDIF()
+ENDIF()
+
+IF (KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
+  SET(CUDA_ARCH_FLAG "--cuda-gpu-arch")
+  GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS -x cuda)
+  IF (KOKKOS_ENABLE_CUDA)
+     SET(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND ON CACHE BOOL "enable CUDA Clang workarounds" FORCE)
+  ENDIF()
+ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+  SET(CUDA_ARCH_FLAG "-arch")
+ENDIF()
+
+IF (KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+  STRING(TOUPPER "${CMAKE_BUILD_TYPE}" _UPPERCASE_CMAKE_BUILD_TYPE)
+  IF (KOKKOS_ENABLE_DEBUG OR _UPPERCASE_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+    GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS -lineinfo)
+  ENDIF()
+  UNSET(_UPPERCASE_CMAKE_BUILD_TYPE)
+  IF (KOKKOS_CXX_COMPILER_VERSION VERSION_GREATER 9.0 OR KOKKOS_CXX_COMPILER_VERSION VERSION_EQUAL 9.0)
+    GLOBAL_APPEND(KOKKOS_CUDAFE_OPTIONS --diag_suppress=esa_on_defaulted_function_ignored) 
+  ENDIF()
+ENDIF()
+
+IF(KOKKOS_ENABLE_OPENMP)
+  IF (KOKKOS_CXX_COMPILER_ID STREQUAL AppleClang)
+    MESSAGE(FATAL_ERROR "Apple Clang does not support OpenMP. Use native Clang instead")
+  ENDIF()
+  ARCH_FLAGS(
+    Clang      -fopenmp=libomp
+    PGI        -mp
+    NVIDIA     -Xcompiler -fopenmp
+    Cray       NO-VALUE-SPECIFIED
+    XL         -qsmp=omp
+    DEFAULT    -fopenmp 
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_ARMV80)
+  ARCH_FLAGS(
+    Cray NO-VALUE-SPECIFIED
+    PGI  NO-VALUE-SPECIFIED
+    DEFAULT -march=armv8-a
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_ARMV81)
+  ARCH_FLAGS(
+    Cray NO-VALUE-SPECIFIED
+    PGI  NO-VALUE-SPECIFIED
+    DEFAULT -march=armv8.1-a
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_ARMV8_THUNDERX)
+  SET(KOKKOS_ARCH_ARMV80 ON) #Not a cache variable
+  ARCH_FLAGS(
+    Cray NO-VALUE-SPECIFIED
+    PGI  NO-VALUE-SPECIFIED
+    DEFAULT -march=armv8-a -mtune=thunderx
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_ARMV8_THUNDERX2)
+  SET(KOKKOS_ARCH_ARMV81 ON) #Not a cache variable
+  ARCH_FLAGS(
+    Cray NO-VALUE-SPECIFIED
+    PGI  NO-VALUE-SPECIFIED
+    DEFAULT -mcpu=thunderx2t99 -mtune=thunderx2t99
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_EPYC)
+  ARCH_FLAGS(
+    Intel   -mavx2
+    DEFAULT -march=znver1 -mtune=znver1
+  )
+  SET(KOKKOS_ARCH_AMD_EPYC ON)
+  SET(KOKKOS_ARCH_AMD_AVX2 ON)
+ENDIF()
+
+IF (KOKKOS_ARCH_WSM)
+  ARCH_FLAGS(
+    Intel   -xSSE4.2
+    PGI     -tp=nehalem
+    Cray    NO-VALUE-SPECIFIED
+    DEFAULT -msse4.2
+  )
+  SET(KOKKOS_ARCH_SSE42 ON)
+ENDIF()
+
+IF (KOKKOS_ARCH_SNB OR KOKKOS_ARCH_AMDAVX)
+  SET(KOKKOS_ARCH_AVX ON)
+  ARCH_FLAGS(
+    Intel   -mavx
+    PGI     -tp=sandybridge
+    Cray    NO-VALUE-SPECIFIED
+    DEFAULT -mavx
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_HSW)
+  SET(KOKKOS_ARCH_AVX2 ON)
+  ARCH_FLAGS(
+    Intel   -xCORE-AVX2
+    PGI     -tp=haswell
+    Cray    NO-VALUE-SPECIFIED
+    DEFAULT -march=core-avx2 -mtune=core-avx2
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_BDW)
+  SET(KOKKOS_ARCH_AVX2 ON)
+  ARCH_FLAGS(
+    Intel   -xCORE-AVX2
+    PGI     -tp=haswell
+    Cray    NO-VALUE-SPECIFIED
+    DEFAULT -march=core-avx2 -mtune=core-avx2 -mrtm
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_EPYC)
+  SET(KOKKOS_ARCH_AMD_AVX2 ON)
+  ARCH_FLAGS(
+    Intel   -mvax2
+    DEFAULT  -march=znver1 -mtune=znver1
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_KNL)
+  #avx512-mic
+  SET(KOKKOS_ARCH_AVX512MIC ON) #not a cache variable
+  ARCH_FLAGS(
+    Intel   -xMIC-AVX512
+    PGI     NO-VALUE-SPECIFIED
+    Cray    NO-VALUE-SPECIFIED
+    DEFAULT -march=knl -mtune=knl
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_KNC)
+  SET(KOKKOS_USE_ISA_KNC ON)
+  ARCH_FLAGS(
+    DEFAULT -mmic
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_SKX)
+  #avx512-xeon
+  SET(KOKKOS_ARCH_AVX512XEON ON)
+  ARCH_FLAGS(
+    Intel   -xCORE-AVX512
+    PGI     NO-VALUE-SPECIFIED
+    Cray    NO-VALUE-SPECIFIED
+    DEFAULT -march=skylake-avx512 -mtune=skylake-avx512 -mrtm
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_WSM OR KOKKOS_ARCH_SNB OR KOKKOS_ARCH_HSW OR KOKKOS_ARCH_BDW OR KOKKOS_ARCH_KNL OR KOKKOS_ARCH_SKX OR KOKKOS_ARCH_EPYC)
+  SET(KOKKOS_USE_ISA_X86_64 ON)
+ENDIF()
+
+IF (KOKKOS_ARCH_BDW OR KOKKOS_ARCH_SKX)
+  SET(KOKKOS_ENABLE_TM ON) #not a cache variable
+ENDIF()
+
+IF (KOKKOS_ARCH_POWER7)
+  ARCH_FLAGS(
+    PGI     NO-VALUE-SPECIFIED
+    DEFAULT -mcpu=power7 -mtune=power7
+  )
+  SET(KOKKOS_USE_ISA_POWERPCBE ON)
+ENDIF()
+
+IF (KOKKOS_ARCH_POWER8)
+  ARCH_FLAGS(
+    PGI     NO-VALUE-SPECIFIED
+    NVIDIA  NO-VALUE-SPECIFIED
+    DEFAULT -mcpu=power8 -mtune=power8
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_POWER9)
+  ARCH_FLAGS(
+    PGI     NO-VALUE-SPECIFIED
+    NVIDIA  NO-VALUE-SPECIFIED
+    DEFAULT -mcpu=power9 -mtune=power9
+  )
+ENDIF()
+
+IF (KOKKOS_ARCH_POWER8 OR KOKKOS_ARCH_POWER9)
+  SET(KOKKOS_USE_ISA_POWERPCLE ON)
+ENDIF()
+
+IF (Kokkos_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
+  ARCH_FLAGS(
+    Clang  -fcuda-rdc
+    NVIDIA --relocatable-device-code=true
+  )
+ENDIF()
+
+
+SET(CUDA_ARCH_ALREADY_SPECIFIED "")
+FUNCTION(CHECK_CUDA_ARCH ARCH FLAG)
+IF(KOKKOS_ARCH_${ARCH})
+  IF(CUDA_ARCH_ALREADY_SPECIFIED)
+    MESSAGE(FATAL_ERROR "Multiple GPU architectures given! Already have ${CUDA_ARCH_ALREADY_SPECIFIED}, but trying to add ${ARCH}. If you are re-running CMake, try clearing the cache and running again.")
+  ENDIF()
+  SET(CUDA_ARCH_ALREADY_SPECIFIED ${ARCH} PARENT_SCOPE)
+  IF (NOT KOKKOS_ENABLE_CUDA)
+    MESSAGE(WARNING "Given CUDA arch ${ARCH}, but Kokkos_ENABLE_CUDA is OFF. Option will be ignored.")
+    UNSET(KOKKOS_ARCH_${ARCH} PARENT_SCOPE)
+  ELSE()
+    GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "${CUDA_ARCH_FLAG}=${FLAG}")
+    IF(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
+       GLOBAL_APPEND(KOKKOS_LINK_OPTIONS "${CUDA_ARCH_FLAG}=${FLAG}")
+    ENDIF()
+  ENDIF()
+ENDIF()
+ENDFUNCTION()
+
+
+CHECK_CUDA_ARCH(KEPLER30  sm_30)
+CHECK_CUDA_ARCH(KEPLER32  sm_32)
+CHECK_CUDA_ARCH(KEPLER35  sm_35)
+CHECK_CUDA_ARCH(KEPLER37  sm_37)
+CHECK_CUDA_ARCH(MAXWELL50 sm_50)
+CHECK_CUDA_ARCH(MAXWELL52 sm_52)
+CHECK_CUDA_ARCH(MAXWELL53 sm_53)
+CHECK_CUDA_ARCH(PASCAL60  sm_60)
+CHECK_CUDA_ARCH(PASCAL61  sm_61)
+CHECK_CUDA_ARCH(VOLTA70  sm_70)
+CHECK_CUDA_ARCH(VOLTA72  sm_72)
+CHECK_CUDA_ARCH(TURING75  sm_75)
+
+#CMake verbose is kind of pointless
+#Let's just always print things
+MESSAGE(STATUS "Execution Spaces:")
+IF(KOKKOS_ENABLE_CUDA)
+  MESSAGE(STATUS "  Device Parallel: CUDA")
+ELSE()
+  MESSAGE(STATUS "  Device Parallel: NONE")
+ENDIF()
+
+FOREACH (_BACKEND OPENMP PTHREAD HPX)
+  IF(KOKKOS_ENABLE_${_BACKEND})
+    IF(_HOST_PARALLEL)
+      MESSAGE(FATAL_ERROR "Multiple host parallel execution spaces are not allowed! "
+                          "Trying to enable execution space ${_BACKEND}, "
+                          "but execution space ${_HOST_PARALLEL} is already enabled. "
+                          "Remove the CMakeCache.txt file and re-configure.")
+    ENDIF()
+    SET(_HOST_PARALLEL ${_BACKEND})
+  ENDIF()
+ENDFOREACH()
+
+IF(NOT _HOST_PARALLEL AND NOT KOKKOS_ENABLE_SERIAL)
+  MESSAGE(FATAL_ERROR "At least one host execution space must be enabled, "
+                      "but no host parallel execution space was requested "
+                      "and Kokkos_ENABLE_SERIAL=OFF.")
+ENDIF()
+
+IF(NOT _HOST_PARALLEL)
+  SET(_HOST_PARALLEL "NONE")
+ENDIF()
+MESSAGE(STATUS "    Host Parallel: ${_HOST_PARALLEL}")
+UNSET(_HOST_PARALLEL)
+
+IF(KOKKOS_ENABLE_PTHREAD)
+  SET(KOKKOS_ENABLE_THREADS ON)
+ENDIF()
+
+IF(KOKKOS_ENABLE_SERIAL)
+  MESSAGE(STATUS "      Host Serial: SERIAL")
+ELSE()
+  MESSAGE(STATUS "      Host Serial: NONE")
+ENDIF()
+
+MESSAGE(STATUS "")
+MESSAGE(STATUS "Architectures:")
+FOREACH(Arch ${KOKKOS_ENABLED_ARCH_LIST})
+  MESSAGE(STATUS " ${Arch}")
+ENDFOREACH()
+
diff --git a/lib/kokkos/cmake/kokkos_build.cmake b/lib/kokkos/cmake/kokkos_build.cmake
deleted file mode 100644
index f9b995baae4f9b319adb0dbe7527f301de8d3a9e..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/kokkos_build.cmake
+++ /dev/null
@@ -1,261 +0,0 @@
-############################ Detect if submodule ###############################
-#
-# With thanks to StackOverflow:  
-#      http://stackoverflow.com/questions/25199677/how-to-detect-if-current-scope-has-a-parent-in-cmake
-#
-get_directory_property(HAS_PARENT PARENT_DIRECTORY)
-if(HAS_PARENT)
-  message(STATUS "Submodule build")
-  SET(KOKKOS_HEADER_DIR "include/kokkos")
-else()
-  message(STATUS "Standalone build")
-  SET(KOKKOS_HEADER_DIR "include")
-endif()
-
-################################ Handle the actual build #######################
-
-SET(INSTALL_LIB_DIR lib CACHE PATH "Installation directory for libraries")
-SET(INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
-SET(INSTALL_INCLUDE_DIR ${KOKKOS_HEADER_DIR} CACHE PATH
-  "Installation directory for header files")
-IF(WIN32 AND NOT CYGWIN)
-  SET(DEF_INSTALL_CMAKE_DIR CMake)
-ELSE()
-  SET(DEF_INSTALL_CMAKE_DIR lib/CMake/Kokkos)
-ENDIF()
-
-SET(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH
-    "Installation directory for CMake files")
-
-# Make relative paths absolute (needed later on)
-FOREACH(p LIB BIN INCLUDE CMAKE)
-  SET(var INSTALL_${p}_DIR)
-  IF(NOT IS_ABSOLUTE "${${var}}")
-    SET(${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
-  ENDIF()
-ENDFOREACH()
-
-# set up include-directories
-SET (Kokkos_INCLUDE_DIRS
-    ${Kokkos_SOURCE_DIR}/core/src
-    ${Kokkos_SOURCE_DIR}/containers/src
-    ${Kokkos_SOURCE_DIR}/algorithms/src
-    ${Kokkos_BINARY_DIR}  # to find KokkosCore_config.h
-    ${KOKKOS_INCLUDE_DIRS}
-)
-
-# pass include dirs back to parent scope
-if(HAS_PARENT)
-SET(Kokkos_INCLUDE_DIRS_RET ${Kokkos_INCLUDE_DIRS} PARENT_SCOPE)
-else()
-SET(Kokkos_INCLUDE_DIRS_RET ${Kokkos_INCLUDE_DIRS})
-endif()
-
-INCLUDE_DIRECTORIES(${Kokkos_INCLUDE_DIRS})
-
-IF(KOKKOS_SEPARATE_LIBS)
-  # Sources come from makefile-generated kokkos_generated_settings.cmake file
-  # Separate libs need to separate the sources
-  set_kokkos_srcs(KOKKOS_SRC ${KOKKOS_SRC})
-
-  # kokkoscore
-  ADD_LIBRARY(
-    kokkoscore
-    ${KOKKOS_CORE_SRCS}
-  )
-
-  target_compile_options(
-    kokkoscore
-    PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${KOKKOS_CXX_FLAGS}>
-  )
-
-  target_include_directories(
-    kokkoscore
-    PUBLIC
-    ${KOKKOS_TPL_INCLUDE_DIRS}
-  )
-
-  foreach(lib IN LISTS KOKKOS_TPL_LIBRARY_NAMES)
-    if (("${lib}" STREQUAL "cuda") AND (NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"))
-      set(LIB_cuda "-lcuda")
-    elseif ("${lib}" STREQUAL "hpx")
-      find_package(HPX REQUIRED)
-      if(${HPX_FOUND})
-        target_link_libraries(kokkoscore PUBLIC ${HPX_LIBRARIES})
-        target_link_libraries(kokkoscontainers PUBLIC ${HPX_LIBRARIES})
-        target_link_libraries(kokkosalgorithms PUBLIC ${HPX_LIBRARIES})
-        target_include_directories(kokkoscore PUBLIC ${HPX_INCLUDE_DIRS})
-        target_include_directories(kokkoscontainers PUBLIC ${HPX_INCLUDE_DIRS})
-        target_include_directories(kokkosalgorithms PUBLIC ${HPX_INCLUDE_DIRS})
-      else()
-        message(ERROR "HPX not found. Check the value of HPX_DIR (= ${HPX_DIR}) or CMAKE_PREFIX_PATH (= ${CMAKE_PREFIX_PATH}).")
-      endif()
-    else()
-      find_library(LIB_${lib} ${lib} PATHS ${KOKKOS_TPL_LIBRARY_DIRS})
-    endif()
-    target_link_libraries(kokkoscore PUBLIC ${LIB_${lib}})
-  endforeach()
-
-  target_link_libraries(kokkoscore PUBLIC "${KOKKOS_LINK_FLAGS}")
-
-  # Install the kokkoscore library
-  INSTALL (TARGETS kokkoscore
-           EXPORT KokkosTargets
-           ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin
-  )
-
-  # kokkoscontainers
-  if (DEFINED KOKKOS_CONTAINERS_SRCS)
-    ADD_LIBRARY(
-      kokkoscontainers
-      ${KOKKOS_CONTAINERS_SRCS}
-    )
-  endif()
-
-  TARGET_LINK_LIBRARIES(
-    kokkoscontainers
-    kokkoscore
-  )
-
-  # Install the kokkocontainers library
-  INSTALL (TARGETS kokkoscontainers
-           EXPORT KokkosTargets
-           ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
-
-  # kokkosalgorithms - Build as interface library since no source files.
-  ADD_LIBRARY(
-    kokkosalgorithms
-    INTERFACE
-  )
-
-  target_include_directories(
-    kokkosalgorithms
-    INTERFACE ${Kokkos_SOURCE_DIR}/algorithms/src
-  )
-
-  TARGET_LINK_LIBRARIES(
-    kokkosalgorithms
-    INTERFACE kokkoscore
-  )
-
-  # Install the kokkoalgorithms library
-  INSTALL (TARGETS kokkosalgorithms
-           ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
-
-  SET (Kokkos_LIBRARIES_NAMES kokkoscore kokkoscontainers kokkosalgorithms)
-
-ELSE()
-  # kokkos
-  ADD_LIBRARY(
-    kokkos
-    ${KOKKOS_CORE_SRCS}
-    ${KOKKOS_CONTAINERS_SRCS}
-  )
-
-  target_compile_options(
-    kokkos
-    PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${KOKKOS_CXX_FLAGS}>
-  )
-
-  target_include_directories(
-    kokkos
-    PUBLIC
-    ${KOKKOS_TPL_INCLUDE_DIRS}
-  )
-
-  foreach(lib IN LISTS KOKKOS_TPL_LIBRARY_NAMES)
-    if (("${lib}" STREQUAL "cuda") AND (NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"))
-      set(LIB_cuda "-lcuda")
-    elseif ("${lib}" STREQUAL "hpx")
-      find_package(HPX REQUIRED)
-      if(${HPX_FOUND})
-        target_link_libraries(kokkos PUBLIC ${HPX_LIBRARIES})
-        target_include_directories(kokkos PUBLIC ${HPX_INCLUDE_DIRS})
-      else()
-        message(ERROR "HPX not found. Check the value of HPX_DIR (= ${HPX_DIR}) or CMAKE_PREFIX_PATH (= ${CMAKE_PREFIX_PATH}).")
-      endif()
-    else()
-      find_library(LIB_${lib} ${lib} PATHS ${KOKKOS_TPL_LIBRARY_DIRS})
-    endif()
-    target_link_libraries(kokkos PUBLIC ${LIB_${lib}})
-  endforeach()
-
-  target_link_libraries(kokkos PUBLIC "${KOKKOS_LINK_FLAGS}")
-
-  # Install the kokkos library
-  INSTALL (TARGETS kokkos
-           EXPORT KokkosTargets
-           ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
-           RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
-
-
-  SET (Kokkos_LIBRARIES_NAMES kokkos)
-
-endif()  # KOKKOS_SEPARATE_LIBS
-
-# Install the kokkos headers
-INSTALL (DIRECTORY
-         EXPORT KokkosTargets
-         ${Kokkos_SOURCE_DIR}/core/src/
-         DESTINATION ${KOKKOS_HEADER_DIR}
-         FILES_MATCHING PATTERN "*.hpp"
-)
-INSTALL (DIRECTORY
-         EXPORT KokkosTargets
-         ${Kokkos_SOURCE_DIR}/containers/src/
-         DESTINATION ${KOKKOS_HEADER_DIR}
-         FILES_MATCHING PATTERN "*.hpp"
-)
-INSTALL (DIRECTORY
-         EXPORT KokkosTargets
-         ${Kokkos_SOURCE_DIR}/algorithms/src/
-         DESTINATION ${KOKKOS_HEADER_DIR}
-         FILES_MATCHING PATTERN "*.hpp"
-)
-
-INSTALL (FILES
-         ${Kokkos_BINARY_DIR}/KokkosCore_config.h
-         DESTINATION ${KOKKOS_HEADER_DIR}
-)
-
-# Add all targets to the build-tree export set
-export(TARGETS ${Kokkos_LIBRARIES_NAMES}
-  FILE "${Kokkos_BINARY_DIR}/KokkosTargets.cmake")
-
-# Export the package for use from the build-tree
-# (this registers the build-tree with a global CMake-registry)
-export(PACKAGE Kokkos)
-
-# Create the KokkosConfig.cmake and KokkosConfigVersion files
-file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}"
-   "${INSTALL_INCLUDE_DIR}")
-# ... for the build tree
-set(CONF_INCLUDE_DIRS "${Kokkos_SOURCE_DIR}" "${Kokkos_BINARY_DIR}")
-configure_file(${Kokkos_SOURCE_DIR}/cmake/KokkosConfig.cmake.in
-  "${Kokkos_BINARY_DIR}/KokkosConfig.cmake" @ONLY)
-# ... for the install tree
-set(CONF_INCLUDE_DIRS "\${Kokkos_CMAKE_DIR}/${REL_INCLUDE_DIR}")
-configure_file(${Kokkos_SOURCE_DIR}/cmake/KokkosConfig.cmake.in
-  "${Kokkos_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/KokkosConfig.cmake" @ONLY)
-
-# Install the KokkosConfig.cmake and KokkosConfigVersion.cmake
-install(FILES
-  "${Kokkos_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/KokkosConfig.cmake"
-  DESTINATION "${INSTALL_CMAKE_DIR}")
-
-#This seems not to do anything?
-#message(STATUS "KokkosTargets: " ${KokkosTargets})
-# Install the export set for use with the install-tree
-INSTALL(EXPORT KokkosTargets DESTINATION
-       "${INSTALL_CMAKE_DIR}")
-
-# build and install pkgconfig file
-CONFIGURE_FILE(core/src/kokkos.pc.in kokkos.pc @ONLY)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/kokkos.pc DESTINATION lib/pkgconfig)
diff --git a/lib/kokkos/cmake/kokkos_compiler_id.cmake b/lib/kokkos/cmake/kokkos_compiler_id.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d239c3b32e5d2d853a6a5ad9705a49aec895c5a5
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_compiler_id.cmake
@@ -0,0 +1,80 @@
+KOKKOS_CFG_DEPENDS(COMPILER_ID NONE)
+
+SET(KOKKOS_CXX_COMPILER ${CMAKE_CXX_COMPILER})
+SET(KOKKOS_CXX_COMPILER_ID ${CMAKE_CXX_COMPILER_ID})
+SET(KOKKOS_CXX_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION})
+
+# Check if the compiler is nvcc (which really means nvcc_wrapper).
+EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER} --version
+                COMMAND grep nvcc
+                COMMAND wc -l
+                OUTPUT_VARIABLE INTERNAL_HAVE_COMPILER_NVCC
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+
+STRING(REGEX REPLACE "^ +" ""
+       INTERNAL_HAVE_COMPILER_NVCC ${INTERNAL_HAVE_COMPILER_NVCC})
+
+
+IF(INTERNAL_HAVE_COMPILER_NVCC)
+  # SET the compiler id to nvcc.  We use the value used by CMake 3.8.
+  SET(KOKKOS_CXX_COMPILER_ID NVIDIA CACHE STRING INTERNAL FORCE)
+
+  # SET nvcc's compiler version.
+  EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER} --version
+                  COMMAND grep release
+                  OUTPUT_VARIABLE INTERNAL_CXX_COMPILER_VERSION
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  STRING(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+$"
+         TEMP_CXX_COMPILER_VERSION ${INTERNAL_CXX_COMPILER_VERSION})
+  SET(KOKKOS_CXX_COMPILER_VERSION ${TEMP_CXX_COMPILER_VERSION} CACHE STRING INTERNAL FORCE)
+ENDIF()
+
+IF(KOKKOS_CXX_COMPILER_ID STREQUAL Cray)
+
+  # SET nvcc's compiler version.
+  EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER} --version
+                  OUTPUT_VARIABLE INTERNAL_CXX_COMPILER_VERSION
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  STRING(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+$"
+         TEMP_CXX_COMPILER_VERSION ${INTERNAL_CXX_COMPILER_VERSION})
+  SET(KOKKOS_CXX_COMPILER_VERSION ${TEMP_CXX_COMPILER_VERSION} CACHE STRING INTERNAL FORCE)
+ENDIF()
+
+# Enforce the minimum compilers supported by Kokkos.
+SET(KOKKOS_MESSAGE_TEXT "Compiler not supported by Kokkos.  Required compiler versions:")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang      3.5.2 or higher")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    GCC        4.8.4 or higher")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Intel     15.0.2 or higher")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    NVCC      9.0.69 or higher")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    PGI         17.1 or higher\n")
+
+IF(KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 3.5.2)
+    MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
+  ENDIF()
+ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL GNU)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 4.8.4)
+    MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
+  ENDIF()
+ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL Intel)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 15.0.2)
+    MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
+  ENDIF()
+ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 9.0.69)
+    MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
+  ENDIF()
+  SET(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Kokkos turns off CXX extensions" FORCE)
+ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL PGI)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 17.1)
+    MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
+  ENDIF()
+ENDIF()
+
+STRING(REPLACE "." ";" VERSION_LIST ${KOKKOS_CXX_COMPILER_VERSION})
+LIST(GET VERSION_LIST 0 KOKKOS_COMPILER_VERSION_MAJOR)
+LIST(GET VERSION_LIST 1 KOKKOS_COMPILER_VERSION_MINOR)
+LIST(GET VERSION_LIST 2 KOKKOS_COMPILER_VERSION_PATCH)
diff --git a/lib/kokkos/cmake/kokkos_corner_cases.cmake b/lib/kokkos/cmake/kokkos_corner_cases.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c03c385faf69a533fd0f91107fd07668fbb9cdab
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_corner_cases.cmake
@@ -0,0 +1,35 @@
+IF(KOKKOS_CXX_COMPILER_ID STREQUAL Clang AND KOKKOS_ENABLE_OPENMP)
+  # The clang "version" doesn't actually tell you what runtimes and tools
+  # were built into Clang. We should therefore make sure that libomp
+  # was actually built into Clang. Otherwise the user will get nonsensical
+  # errors when they try to build.
+
+  #Try compile is the height of CMake nonsense
+  #I can't just give it compiler and link flags
+  #I have to hackily pretend that compiler flags are compiler definitions
+  #and that linker flags are libraries
+  #also - this is easier to use than CMakeCheckCXXSourceCompiles
+  TRY_COMPILE(CLANG_HAS_OMP
+    ${KOKKOS_TOP_BUILD_DIR}/corner_cases
+    ${KOKKOS_SOURCE_DIR}/cmake/compile_tests/clang_omp.cpp 
+    COMPILE_DEFINITIONS -fopenmp=libomp
+    LINK_LIBRARIES -fopenmp=libomp
+  )
+  IF (NOT CLANG_HAS_OMP)
+    UNSET(CLANG_HAS_OMP CACHE) #make sure CMake always re-runs this
+    MESSAGE(FATAL_ERROR "Clang failed OpenMP check. You have requested -DKokkos_ENABLE_OPENMP=ON, but the Clang compiler does not appear to have been built with OpenMP support")
+  ENDIF()
+  UNSET(CLANG_HAS_OMP CACHE) #make sure CMake always re-runs this
+ENDIF()
+
+
+IF (KOKKOS_CXX_STANDARD STREQUAL 17)
+  IF (KOKKOS_CXX_COMPILER_ID STREQUAL GNU AND KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 7)
+    MESSAGE(FATAL_ERROR "You have requested c++17 support for GCC ${KOKKOS_CXX_COMPILER_VERSION}. Although CMake has allowed this and GCC accepts -std=c++1z/c++17, GCC <= 6 does not properly support *this capture. Please reduce the C++ standard to 14 or upgrade the compiler if you do need 17 support")
+  ENDIF()
+
+  IF (KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+    MESSAGE(FATAL_ERROR "You have requested c++17 support for NVCC. Please reduce the C++ standard to 14. No versions of NVCC currently support 17.")
+  ENDIF()
+ENDIF()
+
diff --git a/lib/kokkos/cmake/kokkos_enable_devices.cmake b/lib/kokkos/cmake/kokkos_enable_devices.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ff098766736dd80efb121fb691c8466e5f99f404
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_enable_devices.cmake
@@ -0,0 +1,61 @@
+
+FUNCTION(KOKKOS_DEVICE_OPTION SUFFIX DEFAULT DEV_TYPE DOCSTRING)
+  KOKKOS_OPTION(ENABLE_${SUFFIX} ${DEFAULT} BOOL ${DOCSTRING})
+  STRING(TOUPPER ${SUFFIX} UC_NAME)
+  IF (KOKKOS_ENABLE_${UC_NAME})
+    LIST(APPEND KOKKOS_ENABLED_DEVICES    ${SUFFIX})
+    #I hate that CMake makes me do this
+    SET(KOKKOS_ENABLED_DEVICES    ${KOKKOS_ENABLED_DEVICES}    PARENT_SCOPE)
+  ENDIF()
+  SET(KOKKOS_ENABLE_${UC_NAME} ${KOKKOS_ENABLE_${UC_NAME}} PARENT_SCOPE)
+  IF (KOKKOS_ENABLE_${UC_NAME} AND DEV_TYPE STREQUAL "HOST")
+    SET(KOKKOS_HAS_HOST ON PARENT_SCOPE)
+  ENDIF()
+ENDFUNCTION()
+
+KOKKOS_CFG_DEPENDS(DEVICES NONE)
+
+# Put a check in just in case people are using this option
+KOKKOS_DEPRECATED_LIST(DEVICES ENABLE)
+
+
+KOKKOS_DEVICE_OPTION(PTHREAD       OFF HOST "Whether to build Pthread backend")
+IF (KOKKOS_ENABLE_PTHREAD)
+  #patch the naming here
+  SET(KOKKOS_ENABLE_THREADS ON)
+ENDIF()
+
+IF(Trilinos_ENABLE_Kokkos AND Trilinos_ENABLE_OpenMP)
+  SET(OMP_DEFAULT ON)
+ELSE()
+  SET(OMP_DEFAULT OFF)
+ENDIF()
+KOKKOS_DEVICE_OPTION(OPENMP ${OMP_DEFAULT} HOST "Whether to build OpenMP backend")
+
+IF(Trilinos_ENABLE_Kokkos AND TPL_ENABLE_CUDA)
+  SET(CUDA_DEFAULT ON)
+ELSE()
+  SET(CUDA_DEFAULT OFF)
+ENDIF()
+KOKKOS_DEVICE_OPTION(CUDA ${CUDA_DEFAULT} DEVICE "Whether to build CUDA backend")
+
+IF (KOKKOS_ENABLE_CUDA)
+  GLOBAL_SET(KOKKOS_DONT_ALLOW_EXTENSIONS "CUDA enabled")
+ENDIF()
+
+# We want this to default to OFF for cache reasons, but if no
+# host space is given, then activate serial
+IF (KOKKOS_HAS_TRILINOS)
+  #However, Trilinos always wants Serial ON
+  SET(SERIAL_DEFAULT ON)
+ELSEIF (KOKKOS_HAS_HOST)
+  SET(SERIAL_DEFAULT OFF)
+ELSE()
+  SET(SERIAL_DEFAULT ON)
+  IF (NOT DEFINED Kokkos_ENABLE_SERIAL)
+    MESSAGE(STATUS "SERIAL backend is being turned on to ensure there is at least one Host space. To change this, you must enable another host execution space and configure with -DKokkos_ENABLE_SERIAL=OFF or change CMakeCache.txt")
+  ENDIF()
+ENDIF()
+KOKKOS_DEVICE_OPTION(SERIAL ${SERIAL_DEFAULT} HOST "Whether to build serial backend")
+
+KOKKOS_DEVICE_OPTION(HPX OFF HOST "Whether to build HPX backend (experimental)")
diff --git a/lib/kokkos/cmake/kokkos_enable_options.cmake b/lib/kokkos/cmake/kokkos_enable_options.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c0e49482b66c51de0f897bf9730c7db35436e787
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_enable_options.cmake
@@ -0,0 +1,92 @@
+########################## NOTES ###############################################
+#  List the options for configuring kokkos using CMake method of doing it.
+#  These options then get mapped onto KOKKOS_SETTINGS environment variable by
+#  kokkos_settings.cmake.  It is separate to allow other packages to override
+#  these variables (e.g., TriBITS).
+
+########################## AVAILABLE OPTIONS ###################################
+# Use lists for documentation, verification, and programming convenience
+
+
+FUNCTION(KOKKOS_ENABLE_OPTION SUFFIX DEFAULT DOCSTRING)
+  KOKKOS_OPTION(ENABLE_${SUFFIX} ${DEFAULT} BOOL ${DOCSTRING})
+  STRING(TOUPPER ${SUFFIX} UC_NAME)
+  IF (KOKKOS_ENABLE_${UC_NAME})
+    LIST(APPEND KOKKOS_ENABLED_OPTIONS ${UC_NAME})
+    #I hate that CMake makes me do this
+    SET(KOKKOS_ENABLED_OPTIONS ${KOKKOS_ENABLED_OPTIONS} PARENT_SCOPE)
+  ENDIF()
+  SET(KOKKOS_ENABLE_${UC_NAME} ${KOKKOS_ENABLE_${UC_NAME}} PARENT_SCOPE)
+ENDFUNCTION()
+
+# Certain defaults will depend on knowing the enabled devices
+KOKKOS_CFG_DEPENDS(OPTIONS DEVICES)
+
+# Put a check in just in case people are using this option
+KOKKOS_DEPRECATED_LIST(OPTIONS ENABLE)
+
+KOKKOS_ENABLE_OPTION(CUDA_RELOCATABLE_DEVICE_CODE  OFF "Whether to enable relocatable device code (RDC) for CUDA")
+KOKKOS_ENABLE_OPTION(CUDA_UVM             OFF "Whether to use unified memory (UM) for CUDA by default")
+KOKKOS_ENABLE_OPTION(CUDA_LDG_INTRINSIC   OFF "Whether to use CUDA LDG intrinsics")
+KOKKOS_ENABLE_OPTION(HPX_ASYNC_DISPATCH   OFF "Whether HPX supports asynchronous dispatch")
+KOKKOS_ENABLE_OPTION(TESTS         OFF  "Whether to build the unit tests")
+STRING(TOUPPER "${CMAKE_BUILD_TYPE}" UPPERCASE_CMAKE_BUILD_TYPE)
+IF(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+  KOKKOS_ENABLE_OPTION(DEBUG                ON "Whether to activate extra debug features - may increase compile times")
+  KOKKOS_ENABLE_OPTION(DEBUG_DUALVIEW_MODIFY_CHECK ON "Debug check on dual views")
+ELSE()
+  KOKKOS_ENABLE_OPTION(DEBUG                OFF "Whether to activate extra debug features - may increase compile times")
+  KOKKOS_ENABLE_OPTION(DEBUG_DUALVIEW_MODIFY_CHECK OFF "Debug check on dual views")
+ENDIF()
+UNSET(_UPPERCASE_CMAKE_BUILD_TYPE)
+KOKKOS_ENABLE_OPTION(LARGE_MEM_TESTS      OFF "Whether to perform extra large memory tests")
+KOKKOS_ENABLE_OPTION(DEBUG_BOUNDS_CHECK   OFF "Whether to use bounds checking - will increase runtime")
+KOKKOS_ENABLE_OPTION(COMPILER_WARNINGS    OFF "Whether to print all compiler warnings")
+KOKKOS_ENABLE_OPTION(PROFILING            ON  "Whether to create bindings for profiling tools")
+KOKKOS_ENABLE_OPTION(PROFILING_LOAD_PRINT OFF "Whether to print information about which profiling tools got loaded")
+KOKKOS_ENABLE_OPTION(AGGRESSIVE_VECTORIZATION OFF "Whether to aggressively vectorize loops")
+KOKKOS_ENABLE_OPTION(DEPRECATED_CODE          OFF "Whether to enable deprecated code")
+
+IF (KOKKOS_ENABLE_CUDA)
+  SET(KOKKOS_COMPILER_CUDA_VERSION "${KOKKOS_COMPILER_VERSION_MAJOR}${KOKKOS_COMPILER_VERSION_MINOR}")
+ENDIF()
+
+IF (Trilinos_ENABLE_Kokkos AND TPL_ENABLE_CUDA AND DEFINED KOKKOS_COMPILER_CUDA_VERSION AND KOKKOS_COMPILER_CUDA_VERSION GREATER 70)
+  SET(LAMBDA_DEFAULT ON)
+ELSE()
+  SET(LAMBDA_DEFAULT OFF)
+ENDIF()
+KOKKOS_ENABLE_OPTION(CUDA_LAMBDA ${LAMBDA_DEFAULT} "Whether to activate experimental lambda features")
+IF (Trilinos_ENABLE_Kokkos)
+  SET(COMPLEX_ALIGN_DEFAULT OFF)
+ELSE()
+  SET(COMPLEX_ALIGN_DEFAULT ON)
+ENDIF()
+KOKKOS_ENABLE_OPTION(COMPLEX_ALIGN ${COMPLEX_ALIGN_DEFAULT}  "Whether to align Kokkos::complex to 2*alignof(RealType)")
+
+KOKKOS_ENABLE_OPTION(CUDA_CONSTEXPR OFF "Whether to activate experimental relaxed constexpr functions")
+
+FUNCTION(check_device_specific_options)
+  CMAKE_PARSE_ARGUMENTS(SOME "" "DEVICE" "OPTIONS" ${ARGN})
+  IF(NOT KOKKOS_ENABLE_${SOME_DEVICE})
+    FOREACH(OPTION ${SOME_OPTIONS})
+      IF(CMAKE_VERSION VERSION_GREATER_EQUAL 3.14)
+        IF(NOT DEFINED CACHE{Kokkos_ENABLE_${OPTION}} OR NOT DEFINED CACHE{Kokkos_ENABLE_${SOME_DEVICE}})
+          MESSAGE(FATAL_ERROR "Internal logic error: option '${OPTION}' or device '${SOME_DEVICE}' not recognized.")
+        ENDIF()
+      ENDIF()
+      IF(KOKKOS_ENABLE_${OPTION})
+        MESSAGE(WARNING "Kokkos_ENABLE_${OPTION} is ON but ${SOME_DEVICE} backend is not enabled. Option will be ignored.")
+        UNSET(KOKKOS_ENABLE_${OPTION} PARENT_SCOPE)
+      ENDIF()
+    ENDFOREACH()
+  ENDIF()
+ENDFUNCTION()
+
+CHECK_DEVICE_SPECIFIC_OPTIONS(DEVICE CUDA OPTIONS CUDA_UVM CUDA_RELOCATABLE_DEVICE_CODE CUDA_LAMBDA CUDA_CONSTEXPR CUDA_LDG_INTRINSIC)
+CHECK_DEVICE_SPECIFIC_OPTIONS(DEVICE HPX OPTIONS HPX_ASYNC_DISPATCH)
+
+# Needed due to change from deprecated name to new header define name
+IF (KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION)
+  SET(KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION ON)
+ENDIF()
diff --git a/lib/kokkos/cmake/kokkos_functions.cmake b/lib/kokkos/cmake/kokkos_functions.cmake
index 616618753b11544367ead73b725884cbf9affee8..3644c48ddde7c861e29727805323cbb21ac37d33 100644
--- a/lib/kokkos/cmake/kokkos_functions.cmake
+++ b/lib/kokkos/cmake/kokkos_functions.cmake
@@ -1,345 +1,700 @@
 ################################### FUNCTIONS ##################################
 # List of functions
-#   set_kokkos_cxx_compiler
-#   set_kokkos_cxx_standard
-#   set_kokkos_srcs
-
-#-------------------------------------------------------------------------------
-# function(set_kokkos_cxx_compiler)
-# Sets the following compiler variables that are analogous to the CMAKE_*
-# versions.  We add the ability to detect NVCC (really nvcc_wrapper).
-#   KOKKOS_CXX_COMPILER
-#   KOKKOS_CXX_COMPILER_ID
-#   KOKKOS_CXX_COMPILER_VERSION
-#
-# Inputs:
-#   KOKKOS_ENABLE_CUDA
-#   CMAKE_CXX_COMPILER
-#   CMAKE_CXX_COMPILER_ID
-#   CMAKE_CXX_COMPILER_VERSION
-#
-# Also verifies the compiler version meets the minimum required by Kokkos.
-function(set_kokkos_cxx_compiler)
-  # Since CMake doesn't recognize the nvcc compiler until 3.8, we use our own
-  # version of the CMake variables and detect nvcc ourselves.  Initially set to
-  # the CMake variable values.
-  set(INTERNAL_CXX_COMPILER ${CMAKE_CXX_COMPILER})
-  set(INTERNAL_CXX_COMPILER_ID ${CMAKE_CXX_COMPILER_ID})
-  set(INTERNAL_CXX_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION})
-
-  # Check if the compiler is nvcc (which really means nvcc_wrapper).
-  execute_process(COMMAND ${INTERNAL_CXX_COMPILER} --version
-                  COMMAND grep nvcc
-                  COMMAND wc -l
-                  OUTPUT_VARIABLE INTERNAL_HAVE_COMPILER_NVCC
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-  string(REGEX REPLACE "^ +" ""
-         INTERNAL_HAVE_COMPILER_NVCC ${INTERNAL_HAVE_COMPILER_NVCC})
-
-  if(INTERNAL_HAVE_COMPILER_NVCC)
-    # Set the compiler id to nvcc.  We use the value used by CMake 3.8.
-    set(INTERNAL_CXX_COMPILER_ID NVIDIA)
-
-    # Set nvcc's compiler version.
-    execute_process(COMMAND ${INTERNAL_CXX_COMPILER} --version
-                    COMMAND grep release
-                    OUTPUT_VARIABLE INTERNAL_CXX_COMPILER_VERSION
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-    string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+$"
-           INTERNAL_CXX_COMPILER_VERSION ${INTERNAL_CXX_COMPILER_VERSION})
-  endif()
-
-  # Enforce the minimum compilers supported by Kokkos.
-  set(KOKKOS_MESSAGE_TEXT "Compiler not supported by Kokkos.  Required compiler versions:")
-  set(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang      3.5.2 or higher")
-  set(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    GCC        4.8.4 or higher")
-  set(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Intel     15.0.2 or higher")
-  set(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    NVCC      7.0.28 or higher")
-  set(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    PGI         17.1 or higher\n")
-
-  if(INTERNAL_CXX_COMPILER_ID STREQUAL Clang)
-    if(INTERNAL_CXX_COMPILER_VERSION VERSION_LESS 3.5.2)
-      message(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
-    endif()
-  elseif(INTERNAL_CXX_COMPILER_ID STREQUAL GNU)
-    if(INTERNAL_CXX_COMPILER_VERSION VERSION_LESS 4.8.4)
-      message(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
-    endif()
-  elseif(INTERNAL_CXX_COMPILER_ID STREQUAL Intel)
-    if(INTERNAL_CXX_COMPILER_VERSION VERSION_LESS 15.0.2)
-      message(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
-    endif()
-  elseif(INTERNAL_CXX_COMPILER_ID STREQUAL NVIDIA)
-    if(INTERNAL_CXX_COMPILER_VERSION VERSION_LESS 7.0.28)
-      message(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
-    endif()
-  elseif(INTERNAL_CXX_COMPILER_ID STREQUAL PGI)
-    if(INTERNAL_CXX_COMPILER_VERSION VERSION_LESS 17.1)
-      message(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
-    endif()
-  endif()
-
-  # Enforce that extensions are turned off for nvcc_wrapper.
-  if(INTERNAL_CXX_COMPILER_ID STREQUAL NVIDIA)
-    if(DEFINED CMAKE_CXX_EXTENSIONS AND CMAKE_CXX_EXTENSIONS STREQUAL ON)
-      message(FATAL_ERROR "NVCC doesn't support C++ extensions.  Set CMAKE_CXX_EXTENSIONS to OFF in your CMakeLists.txt.")
-    endif()
-  endif()
-
-  if(KOKKOS_ENABLE_CUDA)
-    # Enforce that the compiler can compile CUDA code.
-    if(INTERNAL_CXX_COMPILER_ID STREQUAL Clang)
-      if(INTERNAL_CXX_COMPILER_VERSION VERSION_LESS 4.0.0)
-        message(FATAL_ERROR "Compiling CUDA code directly with Clang requires version 4.0.0 or higher.")
-      endif()
-    elseif(NOT INTERNAL_CXX_COMPILER_ID STREQUAL NVIDIA)
-      message(FATAL_ERROR "Invalid compiler for CUDA.  The compiler must be nvcc_wrapper or Clang, but compiler ID was ${INTERNAL_CXX_COMPILER_ID}")
-    endif()
-  endif()
-
-  set(KOKKOS_CXX_COMPILER ${INTERNAL_CXX_COMPILER} PARENT_SCOPE)
-  set(KOKKOS_CXX_COMPILER_ID ${INTERNAL_CXX_COMPILER_ID} PARENT_SCOPE)
-  set(KOKKOS_CXX_COMPILER_VERSION ${INTERNAL_CXX_COMPILER_VERSION} PARENT_SCOPE)
-endfunction()
-
-#-------------------------------------------------------------------------------
-# function(set_kokkos_cxx_standard)
-#  Transitively enforces that the appropriate CXX standard compile flags (C++11
-#  or above) are added to targets that use the Kokkos library.  Compile features
-#  are used if possible.  Otherwise, the appropriate flags are added to
-#  KOKKOS_CXX_FLAGS.  Values set by the user to CMAKE_CXX_STANDARD and
-#  CMAKE_CXX_EXTENSIONS are honored.
-#
-# Outputs:
-#   KOKKOS_CXX11_FEATURES
-#   KOKKOS_CXX_FLAGS
-#
-# Inputs:
-#  KOKKOS_CXX_COMPILER
-#  KOKKOS_CXX_COMPILER_ID
-#  KOKKOS_CXX_COMPILER_VERSION
-#
-function(set_kokkos_cxx_standard)
-  # The following table lists the versions of CMake that supports CXX_STANDARD
-  # and the CXX compile features for different compilers.  The versions are
-  # based on CMake documentation, looking at CMake code, and verifying by
-  # testing with specific CMake versions.
-  #
-  #   COMPILER                      CXX_STANDARD     Compile Features
-  #   ---------------------------------------------------------------
-  #   Clang                             3.1                3.1
-  #   GNU                               3.1                3.2
-  #   AppleClang                        3.2                3.2
-  #   Intel                             3.6                3.6
-  #   Cray                              No                 No
-  #   PGI                               No                 No
-  #   XL                                No                 No
-  #
-  # For compiling CUDA code using nvcc_wrapper, we will use the host compiler's
-  # flags for turning on C++11.  Since for compiler ID and versioning purposes
-  # CMake recognizes the host compiler when calling nvcc_wrapper, this just
-  # works.  Both NVCC and nvcc_wrapper only recognize '-std=c++11' which means
-  # that we can only use host compilers for CUDA builds that use those flags.
-  # It also means that extensions (gnu++11) can't be turned on for CUDA builds.
-
-  # Check if we can use compile features.
-  if(NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
-    if(CMAKE_CXX_COMPILER_ID STREQUAL Clang)
-      if(NOT CMAKE_VERSION VERSION_LESS 3.1)
-        set(INTERNAL_USE_COMPILE_FEATURES ON)
-      endif()
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL AppleClang OR CMAKE_CXX_COMPILER_ID STREQUAL GNU)
-      if(NOT CMAKE_VERSION VERSION_LESS 3.2)
-        set(INTERNAL_USE_COMPILE_FEATURES ON)
-      endif()
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
-      if(NOT CMAKE_VERSION VERSION_LESS 3.6)
-        set(INTERNAL_USE_COMPILE_FEATURES ON)
-      endif()
-    endif()
-  endif()
-
-  if(INTERNAL_USE_COMPILE_FEATURES)
-    # Use the compile features aspect of CMake to transitively cause C++ flags
-    # to populate to user code.
-
-    # I'm using a hack by requiring features that I know force the lowest version
-    # of the compilers we want to support.  Clang 3.3 and later support all of
-    # the C++11 standard.  With CMake 3.8 and higher, we could switch to using
-    # cxx_std_11.
-    set(KOKKOS_CXX11_FEATURES
-        cxx_nonstatic_member_init # Forces GCC 4.7 or later and Intel 14.0 or later.
-        PARENT_SCOPE
-       )
-  else()
-    # CXX compile features are not yet implemented for this combination of
-    # compiler and version of CMake.
-
-    if(CMAKE_CXX_COMPILER_ID STREQUAL AppleClang)
-      # Versions of CMAKE before 3.2 don't support CXX_STANDARD or C++ compile
-      # features for the AppleClang compiler.  Set compiler flags transitively
-      # here such that they trickle down to a call to target_compile_options().
-
-      # The following two blocks of code were copied from
-      # /Modules/Compiler/AppleClang-CXX.cmake from CMake 3.7.2 and then
-      # modified.
-      if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0)
-        set(INTERNAL_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
-        set(INTERNAL_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
-      endif()
-
-      if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.1)
-        set(INTERNAL_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
-        set(INTERNAL_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
-      elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
-        # AppleClang 5.0 knows this flag, but does not set a __cplusplus macro
-        # greater than 201103L.
-        set(INTERNAL_CXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
-        set(INTERNAL_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
-      endif()
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
-      # Versions of CMAKE before 3.6 don't support CXX_STANDARD or C++ compile
-      # features for the Intel compiler.  Set compiler flags transitively here
-      # such that they trickle down to a call to target_compile_options().
-
-      # The following three blocks of code were copied from
-      # /Modules/Compiler/Intel-CXX.cmake from CMake 3.7.2 and then modified.
-      if("x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
-        set(_std -Qstd)
-        set(_ext c++)
-      else()
-        set(_std -std)
-        set(_ext gnu++)
-      endif()
-
-      if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0.2)
-        set(INTERNAL_CXX14_STANDARD_COMPILE_OPTION "${_std}=c++14")
-        # TODO: There is no gnu++14 value supported; figure out what to do.
-        set(INTERNAL_CXX14_EXTENSION_COMPILE_OPTION "${_std}=c++14")
-      elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0.0)
-        set(INTERNAL_CXX14_STANDARD_COMPILE_OPTION "${_std}=c++1y")
-        # TODO: There is no gnu++14 value supported; figure out what to do.
-        set(INTERNAL_CXX14_EXTENSION_COMPILE_OPTION "${_std}=c++1y")
-      endif()
-
-      if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
-        set(INTERNAL_CXX11_STANDARD_COMPILE_OPTION "${_std}=c++11")
-        set(INTERNAL_CXX11_EXTENSION_COMPILE_OPTION "${_std}=${_ext}11")
-      elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.1)
-        set(INTERNAL_CXX11_STANDARD_COMPILE_OPTION "${_std}=c++0x")
-        set(INTERNAL_CXX11_EXTENSION_COMPILE_OPTION "${_std}=${_ext}0x")
-      endif()
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL Cray)
-      # CMAKE doesn't support CXX_STANDARD or C++ compile features for the Cray
-      # compiler.  Set compiler options transitively here such that they trickle
-      # down to a call to target_compile_options().
-      set(INTERNAL_CXX11_STANDARD_COMPILE_OPTION "-hstd=c++11")
-      set(INTERNAL_CXX11_EXTENSION_COMPILE_OPTION "-hstd=c++11")
-      set(INTERNAL_CXX14_STANDARD_COMPILE_OPTION "-hstd=c++11")
-      set(INTERNAL_CXX14_EXTENSION_COMPILE_OPTION "-hstd=c++11")
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL PGI)
-      # CMAKE doesn't support CXX_STANDARD or C++ compile features for the PGI
-      # compiler.  Set compiler options transitively here such that they trickle
-      # down to a call to target_compile_options().
-      set(INTERNAL_CXX11_STANDARD_COMPILE_OPTION "--c++11")
-      set(INTERNAL_CXX11_EXTENSION_COMPILE_OPTION "--c++11")
-      set(INTERNAL_CXX14_STANDARD_COMPILE_OPTION "--c++11")
-      set(INTERNAL_CXX14_EXTENSION_COMPILE_OPTION "--c++11")
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL XL)
-      # CMAKE doesn't support CXX_STANDARD or C++ compile features for the XL
-      # compiler.  Set compiler options transitively here such that they trickle
-      # down to a call to target_compile_options().
-      set(INTERNAL_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
-      set(INTERNAL_CXX11_EXTENSION_COMPILE_OPTION "-std=c++11")
-      set(INTERNAL_CXX14_STANDARD_COMPILE_OPTION "-std=c++11")
-      set(INTERNAL_CXX14_EXTENSION_COMPILE_OPTION "-std=c++11")
-    else()
-      # Assume GNU.  CMAKE_CXX_STANDARD is handled correctly by CMake 3.1 and
-      # above for this compiler.  If the user explicitly requests a C++
-      # standard, CMake takes care of it.  If not, transitively require C++11.
-      if(NOT CMAKE_CXX_STANDARD)
-        set(INTERNAL_CXX11_STANDARD_COMPILE_OPTION ${CMAKE_CXX11_STANDARD_COMPILE_OPTION})
-        set(INTERNAL_CXX11_EXTENSION_COMPILE_OPTION ${CMAKE_CXX11_EXTENSION_COMPILE_OPTION})
-      endif()
-    endif()
-
-    # Set the C++ standard info for Kokkos respecting user set values for
-    # CMAKE_CXX_STANDARD and CMAKE_CXX_EXTENSIONS.
-    # Only use cxx extension if explicitly requested
-    if(CMAKE_CXX_STANDARD EQUAL 14)
-      if(DEFINED CMAKE_CXX_EXTENSIONS AND CMAKE_CXX_EXTENSIONS STREQUAL ON)
-        set(INTERNAL_CXX_FLAGS ${INTERNAL_CXX14_EXTENSION_COMPILE_OPTION})
-      else()
-        set(INTERNAL_CXX_FLAGS ${INTERNAL_CXX14_STANDARD_COMPILE_OPTION})
-      endif()
-    elseif(CMAKE_CXX_STANDARD EQUAL 11)
-      if(DEFINED CMAKE_CXX_EXTENSIONS AND CMAKE_CXX_EXTENSIONS STREQUAL ON)
-        set(INTERNAL_CXX_FLAGS ${INTERNAL_CXX11_EXTENSION_COMPILE_OPTION})
-      else()
-        set(INTERNAL_CXX_FLAGS ${INTERNAL_CXX11_STANDARD_COMPILE_OPTION})
-      endif()
-    else()
-      # The user didn't explicitly request a standard, transitively require
-      # C++11 respecting CMAKE_CXX_EXTENSIONS.
-      if(DEFINED CMAKE_CXX_EXTENSIONS AND CMAKE_CXX_EXTENSIONS STREQUAL ON)
-        set(INTERNAL_CXX_FLAGS ${INTERNAL_CXX11_EXTENSION_COMPILE_OPTION})
-      else()
-        set(INTERNAL_CXX_FLAGS ${INTERNAL_CXX11_STANDARD_COMPILE_OPTION})
-      endif()
-    endif()
-
-    set(KOKKOS_CXX_FLAGS ${INTERNAL_CXX_FLAGS} PARENT_SCOPE)
-  endif()
-endfunction()
-
-
-#-------------------------------------------------------------------------------
-# function(set_kokkos_sources)
-# Takes a list of sources for kokkos (e.g., KOKKOS_SRC from Makefile.kokkos and
-# put it into kokkos_generated_settings.cmake) and sorts the files into the subpackages or
-# separate_libraries.  This is core and containers (algorithms is pure header
-# files).
-#
-# Inputs:
-#   KOKKOS_SRC
+#   kokkos_option
+
+# Validate options are given with correct case and define an internal
+# upper-case version for use within 
+
 # 
-# Outputs:
-#   KOKKOS_CORE_SRCS
-#   KOKKOS_CONTAINERS_SRCS
-#
-function(set_kokkos_srcs)
-  set(opts ) # no-value args
-  set(oneValArgs )
-  set(multValArgs KOKKOS_SRC) # e.g., lists
-  cmake_parse_arguments(IN "${opts}" "${oneValArgs}" "${multValArgs}" ${ARGN})
-
-  foreach(sfile ${IN_KOKKOS_SRC})
-     string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" stripfile "${sfile}")
-     string(REPLACE "/" ";" striplist "${stripfile}")
-     list(GET striplist 0 firstdir)
-     if(${firstdir} STREQUAL "core")
-       list(APPEND KOKKOS_CORE_SRCS ${sfile})
-     else()
-       list(APPEND KOKKOS_CONTAINERS_SRCS ${sfile})
-     endif()
-  endforeach()
-  set(KOKKOS_CORE_SRCS ${KOKKOS_CORE_SRCS} PARENT_SCOPE)
-  set(KOKKOS_CONTAINERS_SRCS ${KOKKOS_CONTAINERS_SRCS} PARENT_SCOPE)
-  return()
-endfunction()
-
-# Setting a default value if it is not already set
-macro(set_kokkos_default_default VARIABLE DEFAULT)
-  IF( "${KOKKOS_INTERNAL_ENABLE_${VARIABLE}_DEFAULT}" STREQUAL "" )
-    IF( "${KOKKOS_ENABLE_${VARIABLE}}" STREQUAL "" )
-      set(KOKKOS_INTERNAL_ENABLE_${VARIABLE}_DEFAULT ${DEFAULT})
-  #    MESSAGE(WARNING "Set: KOKKOS_INTERNAL_ENABLE_${VARIABLE}_DEFAULT to ${KOKKOS_INTERNAL_ENABLE_${VARIABLE}_DEFAULT}")
+#
+# @FUNCTION: kokkos_deprecated_list
+#
+# Function that checks if a deprecated list option like Kokkos_ARCH was given.
+# This prints an error and prevents configure from completing.
+# It attempts to print a helpful message about updating the options for the new CMake.
+# Kokkos_${SUFFIX} is the name of the option (like Kokkos_ARCH) being checked.
+# Kokkos_${PREFIX}_X is the name of new option to be defined from a list X,Y,Z,...
+FUNCTION(kokkos_deprecated_list SUFFIX PREFIX)
+  SET(CAMEL_NAME Kokkos_${SUFFIX})
+  STRING(TOUPPER ${CAMEL_NAME} UC_NAME)
+
+  #I don't love doing it this way but better to be safe
+  FOREACH(opt ${KOKKOS_GIVEN_VARIABLES})
+    STRING(TOUPPER ${opt} OPT_UC)
+    IF ("${OPT_UC}" STREQUAL "${UC_NAME}")
+      STRING(REPLACE "," ";" optlist "${${opt}}")
+      SET(ERROR_MSG "Given deprecated option list ${opt}. This must now be given as separate -D options, which assuming you spelled options correctly would be:")
+      FOREACH(entry ${optlist})
+        STRING(TOUPPER ${entry} ENTRY_UC)
+        STRING(APPEND ERROR_MSG "\n  -DKokkos_${PREFIX}_${ENTRY_UC}=ON")
+      ENDFOREACH()
+      STRING(APPEND ERROR_MSG "\nRemove CMakeCache.txt and re-run. For a list of valid options, refer to BUILD.md or even look at CMakeCache.txt (before deleting it).")
+      IF (KOKKOS_HAS_TRILINOS)
+        MESSAGE(WARNING ${ERROR_MSG})
+        FOREACH(entry ${optlist})
+          STRING(TOUPPER ${entry} ENTRY_UC)
+          SET(${CAMEL_NAME}_${ENTRY_UC} ON CACHE BOOL "Deprecated Trilinos translation")
+        ENDFOREACH()
+        UNSET(${opt} CACHE)
+      ELSE()
+        MESSAGE(SEND_ERROR ${ERROR_MSG})
+      ENDIF()
+    ENDIF()
+  ENDFOREACH()
+ENDFUNCTION()
+
+FUNCTION(kokkos_option CAMEL_SUFFIX DEFAULT TYPE DOCSTRING)
+  SET(CAMEL_NAME Kokkos_${CAMEL_SUFFIX})
+  STRING(TOUPPER ${CAMEL_NAME} UC_NAME)
+
+  # Make sure this appears in the cache with the appropriate DOCSTRING
+  SET(${CAMEL_NAME} ${DEFAULT} CACHE ${TYPE} ${DOCSTRING})
+
+  #I don't love doing it this way because it's N^2 in number options, but cest la vie
+  FOREACH(opt ${KOKKOS_GIVEN_VARIABLES})
+    STRING(TOUPPER ${opt} OPT_UC)
+    IF ("${OPT_UC}" STREQUAL "${UC_NAME}")
+      IF (NOT "${opt}" STREQUAL "${CAMEL_NAME}")
+        IF (KOKKOS_HAS_TRILINOS)
+          #Allow this for now if Trilinos... we need to bootstrap our way to integration
+          MESSAGE(WARNING "Deprecated option ${opt} found - please change spelling to ${CAMEL_NAME}")
+          SET(${CAMEL_NAME} "${${opt}}" CACHE ${TYPE} ${DOCSTRING} FORCE)
+          UNSET(${opt} CACHE)
+        ELSE()
+          MESSAGE(FATAL_ERROR "Matching option found for ${CAMEL_NAME} with the wrong case ${opt}. Please delete your CMakeCache.txt and change option to -D${CAMEL_NAME}=${${opt}}. This is now enforced to avoid hard-to-debug CMake cache inconsistencies.")
+	ENDIF()
+      ENDIF()
+    ENDIF()
+  ENDFOREACH()
+
+  #okay, great, we passed the validation test - use the default
+  IF (DEFINED ${CAMEL_NAME})
+    SET(${UC_NAME} ${${CAMEL_NAME}} PARENT_SCOPE)
+  ELSE()
+    SET(${UC_NAME} ${DEFAULT} PARENT_SCOPE)
+  ENDIF()
+
+ENDFUNCTION()
+
+FUNCTION(kokkos_append_config_line LINE)
+  GLOBAL_APPEND(KOKKOS_TPL_EXPORTS "${LINE}")
+ENDFUNCTION()
+
+MACRO(kokkos_export_cmake_tpl NAME)
+  #CMake TPLs are located with a call to find_package
+  #find_package locates XConfig.cmake files through
+  #X_DIR or X_ROOT variables set prior to calling find_package
+
+  #If Kokkos was configured to find the TPL through a _DIR variable
+  #make sure thar DIR variable is available to downstream packages
+  IF (DEFINED ${NAME}_DIR)
+    #The downstream project may override the TPL location that Kokkos used
+    #Check if the downstream project chose its own TPL location
+    #If not, make the Kokkos found location available
+    KOKKOS_APPEND_CONFIG_LINE("IF(NOT DEFINED ${NAME}_DIR)")
+    KOKKOS_APPEND_CONFIG_LINE("  SET(${NAME}_DIR  ${${NAME}_DIR})")
+    KOKKOS_APPEND_CONFIG_LINE("ENDIF()")
+  ENDIF()
+
+  IF (DEFINED ${NAME}_ROOT)
+    #The downstream project may override the TPL location that Kokkos used
+    #Check if the downstream project chose its own TPL location
+    #If not, make the Kokkos found location available
+    KOKKOS_APPEND_CONFIG_LINE("IF(NOT DEFINED ${NAME}_ROOT)")
+    KOKKOS_APPEND_CONFIG_LINE("  SET(${NAME}_ROOT  ${${NAME}_ROOT})")
+    KOKKOS_APPEND_CONFIG_LINE("ENDIF()")
+  ENDIF()
+  KOKKOS_APPEND_CONFIG_LINE("FIND_DEPENDENCY(${NAME})")
+ENDMACRO()
+
+MACRO(kokkos_export_imported_tpl NAME)
+  IF (NOT KOKKOS_HAS_TRILINOS)
+    GET_TARGET_PROPERTY(LIB_TYPE ${NAME} TYPE)
+    IF (${LIB_TYPE} STREQUAL "INTERFACE_LIBRARY")
+      # This is not an imported target
+      # This an interface library that we created
+      INSTALL(
+        TARGETS ${NAME}
+        EXPORT KokkosTargets
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+      )
     ELSE()
-      set(KOKKOS_INTERNAL_ENABLE_${VARIABLE}_DEFAULT ${KOKKOS_ENABLE_${VARIABLE}})
-   #   MESSAGE(WARNING "Set: KOKKOS_INTERNAL_ENABLE_${VARIABLE}_DEFAULT to ${KOKKOS_INTERNAL_ENABLE_${VARIABLE}_DEFAULT}")
+      #make sure this also gets "exported" in the config file
+      KOKKOS_APPEND_CONFIG_LINE("IF(NOT TARGET ${NAME})")
+      KOKKOS_APPEND_CONFIG_LINE("ADD_LIBRARY(${NAME} UNKNOWN IMPORTED)")
+      KOKKOS_APPEND_CONFIG_LINE("SET_TARGET_PROPERTIES(${NAME} PROPERTIES")
+      
+      GET_TARGET_PROPERTY(TPL_LIBRARY ${NAME} IMPORTED_LOCATION)
+      IF(TPL_LIBRARY)
+        KOKKOS_APPEND_CONFIG_LINE("IMPORTED_LOCATION ${TPL_LIBRARY}")
+      ENDIF()
+
+      GET_TARGET_PROPERTY(TPL_INCLUDES ${NAME} INTERFACE_INCLUDE_DIRECTORIES)
+      IF(TPL_INCLUDES)
+        KOKKOS_APPEND_CONFIG_LINE("INTERFACE_INCLUDE_DIRECTORIES ${TPL_INCLUDES}")
+      ENDIF()
+
+      GET_TARGET_PROPERTY(TPL_COMPILE_OPTIONS ${NAME} INTERFACE_COMPILE_OPTIONS)
+      IF(TPL_COMPILE_OPTIONS)
+        KOKKOS_APPEND_CONFIG_LINE("INTERFACE_COMPILE_OPTIONS ${TPL_COMPILE_OPTIONS}")
+      ENDIF()
+
+      SET(TPL_LINK_OPTIONS)
+      IF(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.13.0")
+        GET_TARGET_PROPERTY(TPL_LINK_OPTIONS ${NAME} INTERFACE_LINK_OPTIONS)
+      ENDIF()
+      IF(TPL_LINK_OPTIONS)
+        KOKKOS_APPEND_CONFIG_LINE("INTERFACE_LINK_OPTIONS ${TPL_LINK_OPTIONS}")
+      ENDIF()
+
+      GET_TARGET_PROPERTY(TPL_LINK_LIBRARIES  ${NAME} INTERFACE_LINK_LIBRARIES)
+      IF(TPL_LINK_LIBRARIES)
+        KOKKOS_APPEND_CONFIG_LINE("INTERFACE_LINK_LIBRARIES ${TPL_LINK_LIBRARIES}")
+      ENDIF()
+      KOKKOS_APPEND_CONFIG_LINE(")")
+      KOKKOS_APPEND_CONFIG_LINE("ENDIF()")
     ENDIF()
   ENDIF()
-  UNSET(KOKKOS_ENABLE_${VARIABLE} CACHE)
-endmacro()
+ENDMACRO()
+
+
+#
+# @MACRO: KOKKOS_IMPORT_TPL()
+#
+# Function that checks if a third-party library (TPL) has been enabled and calls `find_package`
+# to create an imported target encapsulating all the flags and libraries
+# needed to use the TPL
+#
+# Usage::
+#
+#   KOKKOS_IMPORT_TPL(
+#     <NAME>
+#     NO_EXPORT
+#     INTERFACE
+#
+#   ``NO_EXPORT``
+#
+#     If specified, this TPL will not be added to KokkosConfig.cmake as an export
+#
+#   ``INTERFACE``
+#
+#     If specified, this TPL will build an INTERFACE library rather than an
+#     IMPORTED target
+MACRO(kokkos_import_tpl NAME)
+  CMAKE_PARSE_ARGUMENTS(TPL
+   "NO_EXPORT;INTERFACE"
+   ""
+   ""
+   ${ARGN})
+  IF (TPL_INTERFACE)
+    SET(TPL_IMPORTED_NAME ${NAME})
+  ELSE()
+    SET(TPL_IMPORTED_NAME Kokkos::${NAME})
+  ENDIF()
+
+  # Even though this policy gets set in the top-level CMakeLists.txt,
+  # I have still been getting errors about ROOT variables being ignored
+  # I'm not sure if this is a scope issue - but make sure
+  # the policy is set before we do any find_package calls
+  IF(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.12.0") 
+    CMAKE_POLICY(SET CMP0074 NEW)
+  ENDIF()
+
+  IF (KOKKOS_ENABLE_${NAME})
+    #Tack on a TPL here to make sure we avoid using anyone else's find
+    FIND_PACKAGE(TPL${NAME} REQUIRED MODULE)
+    IF(NOT TARGET ${TPL_IMPORTED_NAME})
+      MESSAGE(FATAL_ERROR "Find module succeeded for ${NAME}, but did not produce valid target ${TPL_IMPORTED_NAME}")
+    ENDIF()
+    IF(NOT TPL_NO_EXPORT)
+      KOKKOS_EXPORT_IMPORTED_TPL(${TPL_IMPORTED_NAME})
+    ENDIF()
+    LIST(APPEND KOKKOS_ENABLED_TPLS ${NAME})
+  ENDIF()
+ENDMACRO(kokkos_import_tpl)
+
+MACRO(kokkos_import_cmake_tpl MODULE_NAME)
+  kokkos_import_tpl(${MODULE_NAME} ${ARGN} NO_EXPORT)
+  CMAKE_PARSE_ARGUMENTS(TPL
+   "NO_EXPORT"
+   "OPTION_NAME"
+   ""
+   ${ARGN})
+
+  IF (NOT TPL_OPTION_NAME)
+    SET(TPL_OPTION_NAME ${MODULE_NAME})
+  ENDIF()
+
+  IF (NOT TPL_NO_EXPORT)
+    KOKKOS_EXPORT_CMAKE_TPL(${MODULE_NAME})
+  ENDIF()
+ENDMACRO()
+
+#
+# @MACRO: KOKKOS_CREATE_IMPORTED_TPL()
+#
+# Function that creates an imported target encapsulating all the flags
+# and libraries needed to use the TPL
+#
+# Usage::
+#
+#   KOKKOS_CREATE_IMPORTED_TPL(
+#     <NAME>
+#     INTERFACE
+#     LIBRARY <path_to_librarY>
+#     LINK_LIBRARIES <lib1> <lib2> ...
+#     COMPILE_OPTIONS <opt1> <opt2> ...
+#     LINK_OPTIONS <opt1> <opt2> ...
+#
+#   ``INTERFACE``
+#
+#     If specified, this TPL will build an INTERFACE library rather than an
+#     IMPORTED target
+#
+#   ``LIBRARY <path_to_library>``
+#
+#     If specified, this gives the IMPORTED_LOCATION of the library.
+#
+#   ``LINK_LIBRARIES <lib1> <lib2> ...``
+#
+#     If specified, this gives a list of dependent libraries that also
+#     need to be linked against. Each entry can be a library path or
+#     the name of a valid CMake target.
+#
+#   ``INCLUDES <path1> <path2> ...``
+#
+#     If specified, this gives a list of directories that must be added
+#     to the include path for using this library.
+#
+#   ``COMPILE_OPTIONS <opt1> <opt2> ...``
+#
+#     If specified, this gives a list of compiler flags that must be used
+#     for using this library.
+#
+#   ``LINK_OPTIONS <opt1> <opt2> ...``
+#
+#     If specified, this gives a list of linker flags that must be used
+#     for using this library.
+MACRO(kokkos_create_imported_tpl NAME)
+  CMAKE_PARSE_ARGUMENTS(TPL
+   "INTERFACE"
+   "LIBRARY"
+   "LINK_LIBRARIES;INCLUDES;COMPILE_OPTIONS;LINK_OPTIONS"
+   ${ARGN})
+
+
+  IF (KOKKOS_HAS_TRILINOS)
+    #TODO: we need to set a bunch of cache variables here
+  ELSEIF (TPL_INTERFACE)
+    ADD_LIBRARY(${NAME} INTERFACE)
+    #Give this an importy-looking name
+    ADD_LIBRARY(Kokkos::${NAME} ALIAS ${NAME})
+    IF (TPL_LIBRARY)
+      MESSAGE(SEND_ERROR "TPL Interface library ${NAME} should not have an IMPORTED_LOCATION")
+    ENDIF()
+    #Things have to go in quoted in case we have multiple list entries
+    IF(TPL_LINK_LIBRARIES)
+      TARGET_LINK_LIBRARIES(${NAME} INTERFACE ${TPL_LINK_LIBRARIES})
+    ENDIF()
+    IF(TPL_INCLUDES)
+      TARGET_INCLUDE_DIRECTORIES(${NAME} INTERFACE ${TPL_INCLUDES})
+    ENDIF()
+    IF(TPL_COMPILE_OPTIONS)
+      TARGET_COMPILE_OPTIONS(${NAME} INTERFACE ${TPL_COMPILE_OPTIONS})
+    ENDIF()
+    IF(TPL_LINK_OPTIONS)
+      TARGET_LINK_LIBRARIES(${NAME} INTERFACE ${TPL_LINK_OPTIONS})
+    ENDIF()
+  ELSE()
+    ADD_LIBRARY(${NAME} UNKNOWN IMPORTED)
+    IF(TPL_LIBRARY)
+      SET_TARGET_PROPERTIES(${NAME} PROPERTIES
+        IMPORTED_LOCATION ${TPL_LIBRARY})
+    ENDIF()
+    #Things have to go in quoted in case we have multiple list entries
+    IF(TPL_LINK_LIBRARIES)
+      SET_TARGET_PROPERTIES(${NAME} PROPERTIES
+        INTERFACE_LINK_LIBRARIES "${TPL_LINK_LIBRARIES}")
+    ENDIF()
+    IF(TPL_INCLUDES)
+      SET_TARGET_PROPERTIES(${NAME} PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${TPL_INCLUDES}")
+    ENDIF()
+    IF(TPL_COMPILE_OPTIONS)
+      SET_TARGET_PROPERTIES(${NAME} PROPERTIES
+        INTERFACE_COMPILE_OPTIONS "${TPL_COMPILE_OPTIONS}")
+    ENDIF()
+    IF(TPL_LINK_OPTIONS)
+      SET_TARGET_PROPERTIES(${NAME} PROPERTIES
+        INTERFACE_LINK_LIBRARIES "${TPL_LINK_OPTIONS}")
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+
+#
+# @MACRO: KOKKOS_FIND_HEADER
+#
+# Function that finds a particular header. This searches custom paths
+# or default system paths depending on options. In constrast to CMake
+# default, custom paths are prioritized over system paths. The searched
+# order is:
+# 1. <NAME>_ROOT variable
+# 2. Kokkos_<NAME>_DIR variable
+# 3. Locations in the PATHS option
+# 4. Default system paths, if allowed.
+#
+# Default system paths are allowed if none of options (1)-(3) are specified
+# or if default paths are specifically allowed via ALLOW_SYSTEM_PATH_FALLBACK
+#
+# Usage::
+#
+#   KOKKOS_FIND_HEADER(
+#     <VAR_NAME>
+#     <HEADER>
+#     <TPL_NAME>
+#    [ALLOW_SYSTEM_PATH_FALLBACK]
+#    [PATHS path1 [path2 ...]]
+#   )
+#
+#   ``<VAR_NAME>``
+#
+#   The variable to define with the success or failure of the find
+#
+#   ``<HEADER>``
+#
+#   The name of the header to find
+#
+#   ``<TPL_NAME>``
+#
+#   The name of the TPL the header corresponds to
+#
+#   ``[ALLOW_SYSTEM_PATH_FALLBACK]``
+#
+#   If custom paths are given and the header is not found
+#   should we be allowed to search default system paths
+#   or error out if not found in given paths
+#
+#   ``[PATHS path1 [path2 ...]]``
+#
+#   Custom paths to search for the header
+#
+MACRO(kokkos_find_header VAR_NAME HEADER TPL_NAME)
+  CMAKE_PARSE_ARGUMENTS(TPL
+   "ALLOW_SYSTEM_PATH_FALLBACK"
+   ""
+   "PATHS"
+   ${ARGN})
+
+  SET(${HEADER}_FOUND FALSE)
+  SET(HAVE_CUSTOM_PATHS FALSE)
+  IF(NOT ${HEADER}_FOUND AND DEFINED ${TPL_NAME}_ROOT)
+    #ONLY look in the root directory
+    FIND_PATH(${VAR_NAME} ${HEADER} PATHS ${${TPL_NAME}_ROOT}/include NO_DEFAULT_PATH)
+    SET(HAVE_CUSTOM_PATHS TRUE)
+  ENDIF()
+
+  IF(NOT ${HEADER}_FOUND AND DEFINED KOKKOS_${TPL_NAME}_DIR)
+    #ONLY look in the root directory
+    FIND_PATH(${VAR_NAME} ${HEADER} PATHS ${KOKKOS_${TPL_NAME}_DIR}/include NO_DEFAULT_PATH)
+    SET(HAVE_CUSTOM_PATHS TRUE)
+  ENDIF()
+
+  IF (NOT ${HEADER}_FOUND AND TPL_PATHS)
+    #we got custom paths
+    #ONLY look in these paths and nowhere else
+    FIND_PATH(${VAR_NAME} ${HEADER} PATHS ${TPL_PATHS} NO_DEFAULT_PATH)
+    SET(HAVE_CUSTOM_PATHS TRUE)
+  ENDIF()
+
+  IF (NOT HAVE_CUSTOM_PATHS OR TPL_ALLOW_SYSTEM_PATH_FALLBACK)
+    #Now go ahead and look in system paths
+    IF (NOT ${HEADER}_FOUND)
+      FIND_PATH(${VAR_NAME} ${HEADER})
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+
+#
+# @MACRO: KOKKOS_FIND_LIBRARY
+#
+# Function that find a particular library. This searches custom paths
+# or default system paths depending on options. In constrast to CMake
+# default, custom paths are prioritized over system paths. The search
+# order is:
+# 1. <NAME>_ROOT variable
+# 2. Kokkos_<NAME>_DIR variable
+# 3. Locations in the PATHS option
+# 4. Default system paths, if allowed.
+#
+# Default system paths are allowed if none of options (1)-(3) are specified
+# or if default paths are specifically allowed via ALLOW_SYSTEM_PATH_FALLBACK
+#
+# Usage::
+#
+#   KOKKOS_FIND_LIBRARY(
+#     <VAR_NAME>
+#     <HEADER>
+#     <TPL_NAME>
+#    [ALLOW_SYSTEM_PATH_FALLBACK]
+#    [PATHS path1 [path2 ...]]
+#   )
+#
+#   ``<VAR_NAME>``
+#
+#   The variable to define with the success or failure of the find
+#
+#   ``<LIBRARY>``
+#
+#   The name of the library to find (NOT prefixed with -l)
+#
+#   ``<TPL_NAME>``
+#
+#   The name of the TPL the library corresponds to
+#
+#   ``ALLOW_SYSTEM_PATH_FALLBACK``
+#
+#   If custom paths are given and the library is not found
+#   should we be allowed to search default system paths
+#   or error out if not found in given paths
+#
+#   ``PATHS``
+#
+#   Custom paths to search for the library
+#
+MACRO(kokkos_find_library VAR_NAME LIB TPL_NAME)
+  CMAKE_PARSE_ARGUMENTS(TPL
+   "ALLOW_SYSTEM_PATH_FALLBACK"
+   ""
+   "PATHS"
+   ${ARGN})
+
+  SET(${LIB}_FOUND FALSE)
+  SET(HAVE_CUSTOM_PATHS FALSE)
+  IF(NOT ${LIB}_FOUND AND DEFINED ${TPL_NAME}_ROOT)
+    FIND_LIBRARY(${VAR_NAME} ${LIB} PATHS ${${TPL_NAME}_ROOT}/lib ${${TPL_NAME}_ROOT}/lib64 NO_DEFAULT_PATH)
+    SET(HAVE_CUSTOM_PATHS TRUE)
+  ENDIF()
+
+  IF(NOT ${LIB}_FOUND AND DEFINED KOKKOS_${TPL_NAME}_DIR)
+    #we got root paths, only look in these paths and nowhere else
+    FIND_LIBRARY(${VAR_NAME} ${LIB} PATHS ${KOKKOS_${TPL_NAME}_DIR}/lib ${KOKKOS_${TPL_NAME}_DIR}/lib64 NO_DEFAULT_PATH)
+    SET(HAVE_CUSTOM_PATHS TRUE)
+  ENDIF()
+
+  IF (NOT ${LIB}_FOUND AND TPL_PATHS)
+    #we got custom paths, only look in these paths and nowhere else
+    FIND_LIBRARY(${VAR_NAME} ${LIB} PATHS ${TPL_PATHS} NO_DEFAULT_PATH)
+    SET(HAVE_CUSTOM_PATHS TRUE)
+  ENDIF()
+
+
+  IF (NOT HAVE_CUSTOM_PATHS OR TPL_ALLOW_SYSTEM_PATH_FALLBACK)
+    IF (NOT ${LIB}_FOUND)
+      #Now go ahead and look in system paths
+      FIND_LIBRARY(${VAR_NAME} ${LIB})
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+
+#
+# @MACRO: KOKKOS_FIND_IMPORTED
+#
+# Function that finds all libraries and headers needed for the tpl
+# and creates an imported target encapsulating all the flags and libraries
+#
+# Usage::
+#
+#   KOKKOS_FIND_IMPORTED(
+#     <NAME>
+#     INTERFACE
+#     ALLOW_SYSTEM_PATH_FALLBACK
+#     LIBRARY <path_to_librarY>
+#     LINK_LIBRARIES <lib1> <lib2> ...
+#     COMPILE_OPTIONS <opt1> <opt2> ...
+#     LINK_OPTIONS <opt1> <opt2> ...
+#
+#   ``INTERFACE``
+#
+#     If specified, this TPL will build an INTERFACE library rather than an
+#     IMPORTED target
+#
+#   ``ALLOW_SYSTEM_PATH_FALLBACK"
+#
+#     If custom paths are given and the library is not found
+#     should we be allowed to search default system paths
+#     or error out if not found in given paths.
+#
+#   ``LIBRARY <name>``
+#
+#     If specified, this gives the name of the library to look for
+#
+#   ``MODULE_NAME <name>``
+#
+#     If specified, the name of the enclosing module passed to
+#     FIND_PACKAGE(<MODULE_NAME>). Defaults to TPL${NAME} if not
+#     given.
+#
+#   ``IMPORTED_NAME <name>``
+#
+#     If specified, this gives the name of the target to build.
+#     Defaults to Kokkos::<NAME>
+#
+#   ``LIBRARY_PATHS <path1> <path2> ...``
+#
+#     If specified, this gives a list of paths to search for the library
+#     If not given, <NAME>_ROOT/lib and <NAME>_ROOT/lib64 will be searched.
+#
+#   ``HEADER_PATHS <path1> <path2> ...``
+#
+#     If specified, this gives a list of paths to search for the headers
+#     If not given, <NAME>_ROOT/include and <NAME>_ROOT/include will be searched.
+#
+#   ``HEADERS <name1> <name2> ...``
+#
+#     If specified, this gives a list of headers to find for the package
+#
+#   ``LIBRARIES <name1> <name2> ...``
+#
+#     If specified, this gives a list of libraries to find for the package
+#
+MACRO(kokkos_find_imported NAME)
+  CMAKE_PARSE_ARGUMENTS(TPL
+   "INTERFACE;ALLOW_SYSTEM_PATH_FALLBACK"
+   "HEADER;LIBRARY;IMPORTED_NAME;MODULE_NAME"
+   "HEADER_PATHS;LIBRARY_PATHS;HEADERS;LIBRARIES"
+   ${ARGN})
+
+  IF(NOT TPL_MODULE_NAME)
+    SET(TPL_MODULE_NAME TPL${NAME})
+  ENDIF()
+
+  IF (TPL_ALLOW_SYSTEM_PATH_FALLBACK)
+    SET(ALLOW_PATH_FALLBACK_OPT ALLOW_SYSTEM_PATH_FALLBACK)
+  ELSE()
+    SET(ALLOW_PATH_FALLBACK_OPT)
+  ENDIF()
+
+  IF (NOT TPL_IMPORTED_NAME)
+    IF (TPL_INTERFACE)
+      SET(TPL_IMPORTED_NAME ${NAME})
+    ELSE()
+      SET(TPL_IMPORTED_NAME Kokkos::${NAME})
+    ENDIF()
+  ENDIF()
+
+  SET(${NAME}_INCLUDE_DIRS)
+  IF (TPL_HEADER)
+    KOKKOS_FIND_HEADER(${NAME}_INCLUDE_DIRS ${TPL_HEADER} ${NAME} ${ALLOW_PATH_FALLBACK_OPT} PATHS ${TPL_HEADER_PATHS})
+  ENDIF()
+
+  FOREACH(HEADER ${TPL_HEADERS})
+    KOKKOS_FIND_HEADER(HEADER_FIND_TEMP ${HEADER} ${NAME} ${ALLOW_PATH_FALLBACK_OPT} PATHS ${TPL_HEADER_PATHS})
+    IF(HEADER_FIND_TEMP)
+      LIST(APPEND ${NAME}_INCLUDE_DIRS ${HEADER_FIND_TEMP})
+    ENDIF()
+  ENDFOREACH()
+
+  SET(${NAME}_LIBRARY)
+  IF(TPL_LIBRARY)
+    KOKKOS_FIND_LIBRARY(${NAME}_LIBRARY ${TPL_LIBRARY} ${NAME} ${ALLOW_PATH_FALLBACK_OPT} PATHS ${TPL_LIBRARY_PATHS})
+  ENDIF()
+
+  SET(${NAME}_FOUND_LIBRARIES)
+  FOREACH(LIB ${TPL_LIBRARIES})
+    KOKKOS_FIND_LIBRARY(${LIB}_LOCATION ${LIB} ${NAME} ${ALLOW_PATH_FALLBACK_OPT} PATHS ${TPL_LIBRARY_PATHS})
+    IF(${LIB}_LOCATION)
+      LIST(APPEND ${NAME}_FOUND_LIBRARIES ${${LIB}_LOCATION})
+    ELSE()
+      SET(${NAME}_FOUND_LIBRARIES ${${LIB}_LOCATION}) 
+      BREAK()
+    ENDIF()
+  ENDFOREACH()
+
+  INCLUDE(FindPackageHandleStandardArgs)
+  #Collect all the variables we need to be valid for
+  #find_package to have succeeded
+  SET(TPL_VARS_NEEDED)
+  IF (TPL_LIBRARY)
+    LIST(APPEND TPL_VARS_NEEDED ${NAME}_LIBRARY)
+  ENDIF()
+  IF(TPL_HEADER)
+    LIST(APPEND TPL_VARS_NEEDED ${NAME}_INCLUDE_DIRS)
+  ENDIF()
+  IF(TPL_LIBRARIES)
+    LIST(APPEND TPL_VARS_NEEDED ${NAME}_FOUND_LIBRARIES)
+  ENDIF()
+  FIND_PACKAGE_HANDLE_STANDARD_ARGS(${TPL_MODULE_NAME} REQUIRED_VARS ${TPL_VARS_NEEDED})
+
+  MARK_AS_ADVANCED(${NAME}_INCLUDE_DIRS ${NAME}_FOUND_LIBRARIES ${NAME}_LIBRARY)
+
+  IF (${TPL_MODULE_NAME}_FOUND)
+    SET(IMPORT_TYPE)
+    IF (TPL_INTERFACE)
+      SET(IMPORT_TYPE "INTERFACE")
+    ENDIF()
+    KOKKOS_CREATE_IMPORTED_TPL(${TPL_IMPORTED_NAME}
+      ${IMPORT_TYPE}
+      INCLUDES "${${NAME}_INCLUDE_DIRS}"
+      LIBRARY  "${${NAME}_LIBRARY}"
+      LINK_LIBRARIES "${${NAME}_FOUND_LIBRARIES}")
+  ENDIF()
+ENDMACRO(kokkos_find_imported)
+
+#
+# @MACRO: KOKKOS_LINK_TPL()
+#
+# Function that checks if a third-party library (TPL) has been enabled and
+# calls target_link_libraries on the given target
+#
+# Usage::
+#
+#   KOKKOS_LINK_TPL(
+#     <TARGET>
+#     PUBLIC
+#     PRIVATE
+#     INTERFACE
+#     IMPORTED_NAME  <name>
+#     <TPL_NAME>
+#
+#   Checks if Kokkos_ENABLE_<TPL_NAME>=ON and if so links the library
+#
+#   ``PUBLIC/PRIVATE/INTERFACE``
+#
+#     Specifies the linkage mode. One of these arguments should be given.
+#     This will then invoke target_link_libraries(<TARGET> PUBLIC/PRIVATE/INTERFACE <TPL_NAME>)
+#
+#   ``IMPORTED_NAME <name>``
+#
+#     If specified, this gives the exact name of the target to link against
+#     target_link_libraries(<TARGET> <IMPORTED_NAME>)
+#
+FUNCTION(kokkos_link_tpl TARGET)
+  CMAKE_PARSE_ARGUMENTS(TPL
+   "PUBLIC;PRIVATE;INTERFACE"
+   "IMPORTED_NAME"
+   ""
+   ${ARGN})
+  #the name of the TPL
+  SET(TPL ${TPL_UNPARSED_ARGUMENTS})
+  IF (KOKKOS_HAS_TRILINOS)
+    #Do nothing, they will have already been linked
+  ELSE()
+    IF (NOT TPL_IMPORTED_NAME)
+      SET(TPL_IMPORTED_NAME Kokkos::${TPL})
+    ENDIF()
+    IF (KOKKOS_ENABLE_${TPL})
+      IF (TPL_PUBLIC)
+        TARGET_LINK_LIBRARIES(${TARGET} PUBLIC ${TPL_IMPORTED_NAME})
+      ELSEIF (TPL_PRIVATE)
+        TARGET_LINK_LIBRARIES(${TARGET} PRIVATE ${TPL_IMPORTED_NAME})
+      ELSEIF (TPL_INTERFACE)
+        TARGET_LINK_LIBRARIES(${TARGET} INTERFACE ${TPL_IMPORTED_NAME})
+      ELSE()
+        TARGET_LINK_LIBRARIES(${TARGET} ${TPL_IMPORTED_NAME})
+      ENDIF()
+    ENDIF()
+  ENDIF()
+ENDFUNCTION()
+
diff --git a/lib/kokkos/cmake/kokkos_install.cmake b/lib/kokkos/cmake/kokkos_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1e4a5a2aad7e2dfd1eb7fd7d804fd175fef9d564
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_install.cmake
@@ -0,0 +1,42 @@
+IF (NOT KOKKOS_HAS_TRILINOS)
+  INCLUDE(GNUInstallDirs)
+
+  #Set all the variables needed for KokkosConfig.cmake
+  GET_PROPERTY(KOKKOS_PROP_LIBS GLOBAL PROPERTY KOKKOS_LIBRARIES_NAMES)
+  SET(KOKKOS_LIBRARIES ${KOKKOS_PROP_LIBS})
+
+  INCLUDE(CMakePackageConfigHelpers)
+  CONFIGURE_PACKAGE_CONFIG_FILE(
+    cmake/KokkosConfig.cmake.in
+    "${Kokkos_BINARY_DIR}/KokkosConfig.cmake"
+    INSTALL_DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}/cmake)
+
+  INCLUDE(CMakePackageConfigHelpers)
+  CONFIGURE_PACKAGE_CONFIG_FILE(
+	  cmake/KokkosConfigCommon.cmake.in
+	  "${Kokkos_BINARY_DIR}/KokkosConfigCommon.cmake"
+    INSTALL_DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}/cmake)
+
+  WRITE_BASIC_PACKAGE_VERSION_FILE("${Kokkos_BINARY_DIR}/KokkosConfigVersion.cmake"
+      VERSION "${Kokkos_VERSION}"
+      COMPATIBILITY SameMajorVersion)
+
+  # Install the KokkosConfig*.cmake files
+  install(FILES
+    "${Kokkos_BINARY_DIR}/KokkosConfig.cmake"
+    "${Kokkos_BINARY_DIR}/KokkosConfigCommon.cmake"
+    "${Kokkos_BINARY_DIR}/KokkosConfigVersion.cmake"
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Kokkos)
+  install(EXPORT KokkosTargets NAMESPACE Kokkos:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Kokkos)
+ELSE()
+  CONFIGURE_FILE(cmake/KokkosConfigCommon.cmake.in ${Kokkos_BINARY_DIR}/KokkosConfigCommon.cmake @ONLY)
+  file(READ ${Kokkos_BINARY_DIR}/KokkosConfigCommon.cmake KOKKOS_CONFIG_COMMON)
+  file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/KokkosConfig_install.cmake" ${KOKKOS_CONFIG_COMMON})
+ENDIF()
+
+# build and install pkgconfig file
+CONFIGURE_FILE(core/src/kokkos.pc.in kokkos.pc @ONLY)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/kokkos.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/KokkosCore_config.h DESTINATION ${KOKKOS_HEADER_DIR})
+
diff --git a/lib/kokkos/cmake/kokkos_options.cmake b/lib/kokkos/cmake/kokkos_options.cmake
deleted file mode 100644
index 239301925cfebb79a8e60bd504afcf349b58d6ea..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/kokkos_options.cmake
+++ /dev/null
@@ -1,419 +0,0 @@
-########################## NOTES ###############################################
-#  List the options for configuring kokkos using CMake method of doing it.
-#  These options then get mapped onto KOKKOS_SETTINGS environment variable by
-#  kokkos_settings.cmake.  It is separate to allow other packages to override
-#  these variables (e.g., TriBITS).
-
-########################## AVAILABLE OPTIONS ###################################
-# Use lists for documentation, verification, and programming convenience
-
-# All CMake options of the type KOKKOS_ENABLE_*
-set(KOKKOS_INTERNAL_ENABLE_OPTIONS_LIST)
-list(APPEND KOKKOS_INTERNAL_ENABLE_OPTIONS_LIST
-     Serial
-     OpenMP
-     Pthread
-     Qthread
-     HPX
-     Cuda
-     ROCm
-     HWLOC
-     MEMKIND
-     LIBRT
-     Cuda_Lambda
-     Cuda_Relocatable_Device_Code
-     Cuda_UVM
-     Cuda_LDG_Intrinsic
-     HPX_ASYNC_DISPATCH
-     Debug
-     Debug_DualView_Modify_Check
-     Debug_Bounds_Check
-     Compiler_Warnings
-     Profiling
-     Profiling_Load_Print
-     Aggressive_Vectorization
-     Deprecated_Code
-     Explicit_Instantiation
-     )
-
-#-------------------------------------------------------------------------------
-#------------------------------- Recognize CamelCase Options ---------------------------
-#-------------------------------------------------------------------------------
-
-foreach(opt ${KOKKOS_INTERNAL_ENABLE_OPTIONS_LIST})
-  string(TOUPPER ${opt} OPT )
-  IF(DEFINED Kokkos_ENABLE_${opt})
-    IF(DEFINED KOKKOS_ENABLE_${OPT})
-      IF(NOT ("${KOKKOS_ENABLE_${OPT}}" STREQUAL "${Kokkos_ENABLE_${opt}}"))
-        IF(DEFINED KOKKOS_ENABLE_${OPT}_INTERNAL)
-          MESSAGE(WARNING  "Defined both Kokkos_ENABLE_${opt}=[${Kokkos_ENABLE_${opt}}] and KOKKOS_ENABLE_${OPT}=[${KOKKOS_ENABLE_${OPT}}] and they differ! Could be caused by old CMakeCache Variable. Run CMake again and warning should disappear. If not you are truly setting both variables.")
-          IF(NOT ("${Kokkos_ENABLE_${opt}}" STREQUAL "${KOKKOS_ENABLE_${OPT}_INTERNAL}"))
-            UNSET(KOKKOS_ENABLE_${OPT} CACHE)
-            SET(KOKKOS_ENABLE_${OPT} ${Kokkos_ENABLE_${opt}})
-            MESSAGE(WARNING "SET BOTH VARIABLES KOKKOS_ENABLE_${OPT}: ${KOKKOS_ENABLE_${OPT}}")
-          ELSE()
-            SET(Kokkos_ENABLE_${opt} ${KOKKOS_ENABLE_${OPT}})
-          ENDIF()
-        ELSE()
-          MESSAGE(FATAL_ERROR "Defined both Kokkos_ENABLE_${opt}=[${Kokkos_ENABLE_${opt}}] and KOKKOS_ENABLE_${OPT}=[${KOKKOS_ENABLE_${OPT}}] and they differ!")
-        ENDIF()
-      ENDIF()
-    ELSE()
-      SET(KOKKOS_INTERNAL_ENABLE_${OPT}_DEFAULT ${Kokkos_ENABLE_${opt}})
-    ENDIF()
-  ENDIF()
-endforeach()
-
-IF(DEFINED Kokkos_ARCH)
-  MESSAGE(FATAL_ERROR "Defined Kokkos_ARCH, use KOKKOS_ARCH instead!")
-ENDIF()
-IF(DEFINED Kokkos_Arch)
-  MESSAGE(FATAL_ERROR "Defined Kokkos_Arch, use KOKKOS_ARCH instead!")
-ENDIF()
-  
-#-------------------------------------------------------------------------------
-# List of possible host architectures.
-#-------------------------------------------------------------------------------
-set(KOKKOS_ARCH_LIST)
-list(APPEND KOKKOS_ARCH_LIST
-     None            # No architecture optimization
-     AMDAVX          # (HOST) AMD chip
-     EPYC            # (HOST) AMD EPYC Zen-Core CPU
-     ARMv80          # (HOST) ARMv8.0 Compatible CPU
-     ARMv81          # (HOST) ARMv8.1 Compatible CPU
-     ARMv8-ThunderX  # (HOST) ARMv8 Cavium ThunderX CPU
-     ARMv8-TX2       # (HOST) ARMv8 Cavium ThunderX2 CPU
-     WSM             # (HOST) Intel Westmere CPU
-     SNB             # (HOST) Intel Sandy/Ivy Bridge CPUs
-     HSW             # (HOST) Intel Haswell CPUs
-     BDW             # (HOST) Intel Broadwell Xeon E-class CPUs
-     SKX             # (HOST) Intel Sky Lake Xeon E-class HPC CPUs (AVX512)
-     KNC             # (HOST) Intel Knights Corner Xeon Phi
-     KNL             # (HOST) Intel Knights Landing Xeon Phi
-     BGQ             # (HOST) IBM Blue Gene Q
-     Power7          # (HOST) IBM POWER7 CPUs
-     Power8          # (HOST) IBM POWER8 CPUs
-     Power9          # (HOST) IBM POWER9 CPUs
-     Kepler          # (GPU) NVIDIA Kepler default (generation CC 3.5)
-     Kepler30        # (GPU) NVIDIA Kepler generation CC 3.0
-     Kepler32        # (GPU) NVIDIA Kepler generation CC 3.2
-     Kepler35        # (GPU) NVIDIA Kepler generation CC 3.5
-     Kepler37        # (GPU) NVIDIA Kepler generation CC 3.7
-     Maxwell         # (GPU) NVIDIA Maxwell default (generation CC 5.0)
-     Maxwell50       # (GPU) NVIDIA Maxwell generation CC 5.0
-     Maxwell52       # (GPU) NVIDIA Maxwell generation CC 5.2
-     Maxwell53       # (GPU) NVIDIA Maxwell generation CC 5.3
-     Pascal60        # (GPU) NVIDIA Pascal generation CC 6.0
-     Pascal61        # (GPU) NVIDIA Pascal generation CC 6.1
-     Volta70         # (GPU) NVIDIA Volta generation CC 7.0
-     Volta72         # (GPU) NVIDIA Volta generation CC 7.2
-     Turing75         # (GPU) NVIDIA Turing generation CC 7.5
-    )
-
-# List of possible device architectures.
-# The case and spelling here needs to match Makefile.kokkos
-set(KOKKOS_DEVICES_LIST)
-# Options: Cuda,ROCm,OpenMP,Pthread,Qthreads,Serial
-list(APPEND KOKKOS_DEVICES_LIST
-    Cuda          # NVIDIA GPU -- see below
-    OpenMP        # OpenMP
-    Pthread       # pthread
-    Qthreads      # qthreads
-    HPX           # HPX
-    Serial        # serial
-    ROCm          # Relocatable device code
-    )
-
-# List of possible TPLs for Kokkos
-# From Makefile.kokkos: Options: hwloc,librt,experimental_memkind
-set(KOKKOS_USE_TPLS_LIST)
-if(APPLE)
-list(APPEND KOKKOS_USE_TPLS_LIST
-    HWLOC          # hwloc
-    MEMKIND        # experimental_memkind
-    )
-else()
-list(APPEND KOKKOS_USE_TPLS_LIST
-    HWLOC          # hwloc
-    LIBRT          # librt
-    MEMKIND        # experimental_memkind
-    )
-endif()
-# Map of cmake variables to Makefile variables
-set(KOKKOS_INTERNAL_HWLOC hwloc)
-set(KOKKOS_INTERNAL_LIBRT librt)
-set(KOKKOS_INTERNAL_MEMKIND experimental_memkind)
-
-# List of possible Advanced options
-set(KOKKOS_OPTIONS_LIST)
-list(APPEND KOKKOS_OPTIONS_LIST
-       AGGRESSIVE_VECTORIZATION    
-       DISABLE_PROFILING          
-       DISABLE_DUALVIEW_MODIFY_CHECK
-       ENABLE_PROFILE_LOAD_PRINT   
-    )
-# Map of cmake variables to Makefile variables
-set(KOKKOS_INTERNAL_LDG_INTRINSIC use_ldg)
-set(KOKKOS_INTERNAL_UVM librt)
-set(KOKKOS_INTERNAL_RELOCATABLE_DEVICE_CODE rdc)
-
-
-#-------------------------------------------------------------------------------
-# List of possible Options for CUDA
-#-------------------------------------------------------------------------------
-# From Makefile.kokkos: Options: use_ldg,force_uvm,rdc
-set(KOKKOS_CUDA_OPTIONS_LIST)
-list(APPEND KOKKOS_CUDA_OPTIONS_LIST
-    LDG_INTRINSIC              # use_ldg
-    UVM                        # force_uvm
-    RELOCATABLE_DEVICE_CODE    # rdc
-    LAMBDA                     # enable_lambda
-    )
-    
-# Map of cmake variables to Makefile variables
-set(KOKKOS_INTERNAL_LDG_INTRINSIC use_ldg)
-set(KOKKOS_INTERNAL_UVM force_uvm)
-set(KOKKOS_INTERNAL_RELOCATABLE_DEVICE_CODE rdc)
-set(KOKKOS_INTERNAL_LAMBDA enable_lambda)
-
-
-#-------------------------------------------------------------------------------
-# List of possible Options for HPX
-#-------------------------------------------------------------------------------
-# From Makefile.kokkos: Options: enable_async_dispatch
-set(KOKKOS_HPX_OPTIONS_LIST)
-list(APPEND KOKKOS_HPX_OPTIONS_LIST
-    ASYNC_DISPATCH # enable_async_dispatch
-    )
-
-# Map of cmake variables to Makefile variables
-set(KOKKOS_INTERNAL_ENABLE_ASYNC_DISPATCH enable_async_dispatch)
-
-
-#-------------------------------------------------------------------------------
-#------------------------------- Create doc strings ----------------------------
-#-------------------------------------------------------------------------------
-
-set(tmpr "\n       ")
-string(REPLACE ";" ${tmpr} KOKKOS_INTERNAL_ARCH_DOCSTR "${KOKKOS_ARCH_LIST}")
-set(KOKKOS_INTERNAL_ARCH_DOCSTR "${tmpr}${KOKKOS_INTERNAL_ARCH_DOCSTR}")
-# This would be useful, but we use Foo_ENABLE mechanisms
-#string(REPLACE ";" ${tmpr} KOKKOS_INTERNAL_DEVICES_DOCSTR "${KOKKOS_DEVICES_LIST}")
-#string(REPLACE ";" ${tmpr} KOKKOS_INTERNAL_USE_TPLS_DOCSTR "${KOKKOS_USE_TPLS_LIST}")
-#string(REPLACE ";" ${tmpr} KOKKOS_INTERNAL_CUDA_OPTIONS_DOCSTR "${KOKKOS_CUDA_OPTIONS_LIST}")
-
-#-------------------------------------------------------------------------------
-#------------------------------- GENERAL OPTIONS -------------------------------
-#-------------------------------------------------------------------------------
-
-# Setting this variable to a value other than "None" can improve host
-# performance by turning on architecture specific code.
-# NOT SET is used to determine if the option is passed in.  It is reset to
-# default "None" down below.
-set(KOKKOS_ARCH "NOT_SET" CACHE STRING 
-      "Optimize for specific host architecture. Options are: ${KOKKOS_INTERNAL_ARCH_DOCSTR}")
-
-# Whether to build separate libraries or now
-set(KOKKOS_SEPARATE_LIBS OFF CACHE BOOL "OFF = kokkos.  ON = kokkoscore, kokkoscontainers, and kokkosalgorithms.")
-
-# Qthreads options.
-set(KOKKOS_QTHREADS_DIR "" CACHE PATH "Location of Qthreads library.")
-
-# HPX options.
-set(KOKKOS_HPX_DIR "" CACHE PATH "Location of HPX library.")
-
-# Whether to build separate libraries or now
-set(KOKKOS_SEPARATE_TESTS OFF CACHE BOOL "Provide unit test targets with finer granularity.")
-
-#-------------------------------------------------------------------------------
-#------------------------------- KOKKOS_DEVICES --------------------------------
-#-------------------------------------------------------------------------------
-# Figure out default settings
-IF(Trilinos_ENABLE_Kokkos)             
-  set_kokkos_default_default(SERIAL ON)
-  set_kokkos_default_default(PTHREAD OFF)
-  IF(TPL_ENABLE_QTHREAD)
-    set_kokkos_default_default(QTHREADS ${TPL_ENABLE_QTHREAD})
-  ELSE()
-    set_kokkos_default_default(QTHREADS OFF)
-  ENDIF()
-  IF(TPL_ENABLE_HPX)
-    set_kokkos_default_default(HPX ON)
-  ELSE()
-    set_kokkos_default_default(HPX OFF)
-  ENDIF()
-  IF(Trilinos_ENABLE_OpenMP)
-    set_kokkos_default_default(OPENMP ${Trilinos_ENABLE_OpenMP})
-  ELSE()
-    set_kokkos_default_default(OPENMP OFF)
-  ENDIF()
-  IF(TPL_ENABLE_CUDA)
-    set_kokkos_default_default(CUDA ${TPL_ENABLE_CUDA})
-  ELSE()
-    set_kokkos_default_default(CUDA OFF)
-  ENDIF()
-  set_kokkos_default_default(ROCM OFF)
-ELSE()
-  set_kokkos_default_default(SERIAL ON)
-  set_kokkos_default_default(OPENMP OFF)
-  set_kokkos_default_default(PTHREAD OFF)
-  set_kokkos_default_default(QTHREAD OFF)
-  set_kokkos_default_default(HPX OFF)
-  set_kokkos_default_default(CUDA OFF)
-  set_kokkos_default_default(ROCM OFF)
-ENDIF()
-
-# Set which Kokkos backend to use.
-# These are the actual options that define the settings.
-set(KOKKOS_ENABLE_SERIAL ${KOKKOS_INTERNAL_ENABLE_SERIAL_DEFAULT} CACHE BOOL "Whether to enable the Kokkos::Serial device.  This device executes \"parallel\" kernels sequentially on a single CPU thread.  It is enabled by default.  If you disable this device, please enable at least one other CPU device, such as Kokkos::OpenMP or Kokkos::Threads.")
-set(KOKKOS_ENABLE_OPENMP ${KOKKOS_INTERNAL_ENABLE_OPENMP_DEFAULT} CACHE BOOL "Enable OpenMP support in Kokkos." FORCE)
-set(KOKKOS_ENABLE_PTHREAD ${KOKKOS_INTERNAL_ENABLE_PTHREAD_DEFAULT} CACHE BOOL "Enable Pthread support in Kokkos.")
-set(KOKKOS_ENABLE_QTHREADS ${KOKKOS_INTERNAL_ENABLE_QTHREADS_DEFAULT} CACHE BOOL "Enable Qthreads support in Kokkos.")
-set(KOKKOS_ENABLE_HPX ${KOKKOS_INTERNAL_ENABLE_HPX_DEFAULT} CACHE BOOL "Enable HPX support in Kokkos.")
-set(KOKKOS_ENABLE_CUDA ${KOKKOS_INTERNAL_ENABLE_CUDA_DEFAULT} CACHE BOOL "Enable CUDA support in Kokkos.")
-set(KOKKOS_ENABLE_ROCM ${KOKKOS_INTERNAL_ENABLE_ROCM_DEFAULT} CACHE BOOL "Enable ROCm support in Kokkos.")
-
-
-
-#-------------------------------------------------------------------------------
-#------------------------------- KOKKOS DEBUG and PROFILING --------------------
-#-------------------------------------------------------------------------------
-
-# Debug related options enable compiler warnings
-
-set_kokkos_default_default(DEBUG OFF)
-set(KOKKOS_ENABLE_DEBUG ${KOKKOS_INTERNAL_ENABLE_DEBUG_DEFAULT} CACHE BOOL "Enable Kokkos Debug.")
-
-# From Makefile.kokkos: Advanced Options: 
-#compiler_warnings, aggressive_vectorization, disable_profiling, disable_dualview_modify_check, enable_profile_load_print
-set_kokkos_default_default(COMPILER_WARNINGS OFF)
-set(KOKKOS_ENABLE_COMPILER_WARNINGS ${KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS_DEFAULT} CACHE BOOL "Enable compiler warnings.")
-
-set_kokkos_default_default(DEBUG_DUALVIEW_MODIFY_CHECK OFF)
-set(KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK ${KOKKOS_INTERNAL_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK_DEFAULT} CACHE BOOL "Enable dualview modify check.")
-
-# Enable aggressive vectorization.
-set_kokkos_default_default(AGGRESSIVE_VECTORIZATION OFF)
-set(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ${KOKKOS_INTERNAL_ENABLE_AGGRESSIVE_VECTORIZATION_DEFAULT} CACHE BOOL "Enable aggressive vectorization.")
-
-# Enable profiling.
-set_kokkos_default_default(PROFILING ON)
-set(KOKKOS_ENABLE_PROFILING ${KOKKOS_INTERNAL_ENABLE_PROFILING_DEFAULT} CACHE BOOL "Enable profiling.")
-
-set_kokkos_default_default(PROFILING_LOAD_PRINT OFF)
-set(KOKKOS_ENABLE_PROFILING_LOAD_PRINT ${KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT_DEFAULT} CACHE BOOL "Enable profile load print.")
-
-set_kokkos_default_default(DEPRECATED_CODE ON)
-set(KOKKOS_ENABLE_DEPRECATED_CODE ${KOKKOS_INTERNAL_ENABLE_DEPRECATED_CODE_DEFAULT} CACHE BOOL "Enable deprecated code.")
-
-set_kokkos_default_default(EXPLICIT_INSTANTIATION OFF)
-set(KOKKOS_ENABLE_EXPLICIT_INSTANTIATION ${KOKKOS_INTERNAL_ENABLE_EXPLICIT_INSTANTIATION_DEFAULT} CACHE BOOL "Enable explicit template instantiation.")
-
-#-------------------------------------------------------------------------------
-#------------------------------- KOKKOS_USE_TPLS -------------------------------
-#-------------------------------------------------------------------------------
-# Enable hwloc library.
-# Figure out default:
-IF(Trilinos_ENABLE_Kokkos AND TPL_ENABLE_HWLOC)
-  set_kokkos_default_default(HWLOC ON)
-ELSE()
-  set_kokkos_default_default(HWLOC OFF)
-ENDIF()
-set(KOKKOS_ENABLE_HWLOC ${KOKKOS_INTERNAL_ENABLE_HWLOC_DEFAULT} CACHE BOOL "Enable hwloc for better process placement.")
-set(KOKKOS_HWLOC_DIR "" CACHE PATH "Location of hwloc library. (kokkos tpl)")
-
-# Enable memkind library.
-set_kokkos_default_default(MEMKIND OFF)
-set(KOKKOS_ENABLE_MEMKIND ${KOKKOS_INTERNAL_ENABLE_MEMKIND_DEFAULT} CACHE BOOL "Enable memkind. (kokkos tpl)")
-set(KOKKOS_MEMKIND_DIR "" CACHE PATH "Location of memkind library. (kokkos tpl)")
-
-# Enable rt library.
-IF(Trilinos_ENABLE_Kokkos)
-  IF(DEFINED TPL_ENABLE_LIBRT)
-    set_kokkos_default_default(LIBRT ${TPL_ENABLE_LIBRT})
-  ELSE()
-    set_kokkos_default_default(LIBRT OFF)
-  ENDIF()
-ELSE()
-  set_kokkos_default_default(LIBRT ON)
-ENDIF()
-set(KOKKOS_ENABLE_LIBRT ${KOKKOS_INTERNAL_ENABLE_LIBRT_DEFAULT} CACHE BOOL "Enable librt for more precise timer.  (kokkos tpl)")
-
-
-#-------------------------------------------------------------------------------
-#------------------------------- KOKKOS_CUDA_OPTIONS ---------------------------
-#-------------------------------------------------------------------------------
-
-# CUDA options.
-# Set Defaults
-set_kokkos_default_default(CUDA_LDG_INTRINSIC_DEFAULT OFF)
-set_kokkos_default_default(CUDA_UVM_DEFAULT OFF)
-set_kokkos_default_default(CUDA_RELOCATABLE_DEVICE_CODE OFF)
-IF(Trilinos_ENABLE_Kokkos)
-  IF(KOKKOS_ENABLE_CUDA)
-    find_package(CUDA)
-  ENDIF()
-  IF (DEFINED CUDA_VERSION)
-    IF (CUDA_VERSION VERSION_GREATER "7.0")
-      set_kokkos_default_default(CUDA_LAMBDA ON)
-    ELSE()
-      set_kokkos_default_default(CUDA_LAMBDA OFF)
-    ENDIF()
-  ENDIF()
-ELSE()
-  set_kokkos_default_default(CUDA_LAMBDA OFF)
-ENDIF()
-
-# Set actual options
-set(KOKKOS_CUDA_DIR "" CACHE PATH "Location of CUDA library.  Defaults to where nvcc installed.")
-set(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC ${KOKKOS_INTERNAL_ENABLE_CUDA_LDG_INTRINSIC_DEFAULT} CACHE BOOL "Enable CUDA LDG. (cuda option)") 
-set(KOKKOS_ENABLE_CUDA_UVM ${KOKKOS_INTERNAL_ENABLE_CUDA_UVM_DEFAULT} CACHE BOOL "Enable CUDA unified virtual memory.")
-set(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE ${KOKKOS_INTERNAL_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE_DEFAULT} CACHE BOOL "Enable relocatable device code for CUDA. (cuda option)")
-set(KOKKOS_ENABLE_CUDA_LAMBDA ${KOKKOS_INTERNAL_ENABLE_CUDA_LAMBDA_DEFAULT} CACHE BOOL "Enable lambdas for CUDA. (cuda option)")
-
-
-#-------------------------------------------------------------------------------
-#------------------------------- KOKKOS_HPX_OPTIONS ----------------------------
-#-------------------------------------------------------------------------------
-
-# HPX options.
-# Set Defaults
-set_kokkos_default_default(HPX_ASYNC_DISPATCH OFF)
-
-# Set actual options
-set(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH ${KOKKOS_INTERNAL_ENABLE_HPX_ASYNC_DISPATCH_DEFAULT} CACHE BOOL "Enable HPX async dispatch.")
-
-
-#-------------------------------------------------------------------------------
-#----------------------- HOST ARCH AND LEGACY TRIBITS --------------------------
-#-------------------------------------------------------------------------------
-
-# This defines the previous legacy TriBITS builds. 
-set(KOKKOS_LEGACY_TRIBITS False)
-IF ("${KOKKOS_ARCH}" STREQUAL "NOT_SET")
-  set(KOKKOS_ARCH "None")
-  IF(KOKKOS_HAS_TRILINOS)
-    set(KOKKOS_LEGACY_TRIBITS True)
-  ENDIF()
-ENDIF()
-IF (KOKKOS_HAS_TRILINOS)
-  IF (KOKKOS_LEGACY_TRIBITS)
-    message(STATUS "Using the legacy tribits build because KOKKOS_ARCH not set")
-  ELSE()
-    message(STATUS "NOT using the legacy tribits build because KOKKOS_ARCH *is* set")
-  ENDIF()
-ENDIF()
-
-#-------------------------------------------------------------------------------
-#----------------------- Set CamelCase Options if they are not yet set ---------
-#-------------------------------------------------------------------------------
-
-foreach(opt ${KOKKOS_INTERNAL_ENABLE_OPTIONS_LIST})
-  string(TOUPPER ${opt} OPT )
-  UNSET(KOKKOS_ENABLE_${OPT}_INTERNAL CACHE)
-  SET(KOKKOS_ENABLE_${OPT}_INTERNAL ${KOKKOS_ENABLE_${OPT}} CACHE BOOL INTERNAL)
-  IF(DEFINED KOKKOS_ENABLE_${OPT})
-    UNSET(Kokkos_ENABLE_${opt} CACHE)
-    SET(Kokkos_ENABLE_${opt} ${KOKKOS_ENABLE_${OPT}} CACHE BOOL "CamelCase Compatibility setting for KOKKOS_ENABLE_${OPT}")
-  ENDIF()
-endforeach()
diff --git a/lib/kokkos/cmake/kokkos_pick_cxx_std.cmake b/lib/kokkos/cmake/kokkos_pick_cxx_std.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..cf14948f43f26b089078f994817a2c3e1230744f
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_pick_cxx_std.cmake
@@ -0,0 +1,46 @@
+# From CMake 3.10 documentation
+
+#This can run at any time
+KOKKOS_OPTION(CXX_STANDARD "" STRING "The C++ standard for Kokkos to use: 11, 14, 17, or 20. If empty, this will default to CMAKE_CXX_STANDARD. If both CMAKE_CXX_STANDARD and Kokkos_CXX_STANDARD are empty, this will default to 11")
+
+# Set CXX standard flags
+SET(KOKKOS_ENABLE_CXX11 OFF)
+SET(KOKKOS_ENABLE_CXX14 OFF)
+SET(KOKKOS_ENABLE_CXX17 OFF)
+SET(KOKKOS_ENABLE_CXX20 OFF)
+IF (KOKKOS_CXX_STANDARD)
+  IF (${KOKKOS_CXX_STANDARD} STREQUAL "c++98")
+    MESSAGE(FATAL_ERROR "Kokkos no longer supports C++98 - minimum C++11")
+  ELSEIF (${KOKKOS_CXX_STANDARD} STREQUAL "c++11")
+    MESSAGE(WARNING "Deprecated Kokkos C++ standard set as 'c++11'. Use '11' instead.")
+    SET(KOKKOS_CXX_STANDARD "11")
+  ELSEIF(${KOKKOS_CXX_STANDARD} STREQUAL "c++14")
+    MESSAGE(WARNING "Deprecated Kokkos C++ standard set as 'c++14'. Use '14' instead.")
+    SET(KOKKOS_CXX_STANDARD "14")
+  ELSEIF(${KOKKOS_CXX_STANDARD} STREQUAL "c++17")
+    MESSAGE(WARNING "Deprecated Kokkos C++ standard set as 'c++17'. Use '17' instead.")
+    SET(KOKKOS_CXX_STANDARD "17")
+  ELSEIF(${KOKKOS_CXX_STANDARD} STREQUAL "c++1y")
+    MESSAGE(WARNING "Deprecated Kokkos C++ standard set as 'c++1y'. Use '1Y' instead.")
+    SET(KOKKOS_CXX_STANDARD "1Y")
+  ELSEIF(${KOKKOS_CXX_STANDARD} STREQUAL "c++1z")
+    MESSAGE(WARNING "Deprecated Kokkos C++ standard set as 'c++1z'. Use '1Z' instead.")
+    SET(KOKKOS_CXX_STANDARD "1Z")
+  ELSEIF(${KOKKOS_CXX_STANDARD} STREQUAL "c++2a")
+    MESSAGE(WARNING "Deprecated Kokkos C++ standard set as 'c++2a'. Use '2A' instead.")
+    SET(KOKKOS_CXX_STANDARD "2A")
+  ENDIF()
+ENDIF()
+
+IF (NOT KOKKOS_CXX_STANDARD AND NOT CMAKE_CXX_STANDARD)
+  MESSAGE(STATUS "Setting default Kokkos CXX standard to 11")
+  SET(KOKKOS_CXX_STANDARD "11")
+ELSEIF(NOT KOKKOS_CXX_STANDARD)
+  MESSAGE(STATUS "Setting default Kokkos CXX standard to ${CMAKE_CXX_STANDARD}")
+  SET(KOKKOS_CXX_STANDARD ${CMAKE_CXX_STANDARD})
+ENDIF()
+
+
+
+
+
diff --git a/lib/kokkos/cmake/kokkos_settings.cmake b/lib/kokkos/cmake/kokkos_settings.cmake
deleted file mode 100644
index 2c622d0de91f87f59f78a598820b80bc294d0b19..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/kokkos_settings.cmake
+++ /dev/null
@@ -1,259 +0,0 @@
-########################## NOTES ###############################################
-# This files goal is to take CMake options found in kokkos_options.cmake but 
-# possibly set from elsewhere 
-#   (see: trilinos/cmake/ProjectCOmpilerPostConfig.cmake) 
-# using CMake idioms and map them onto the KOKKOS_SETTINGS variables that gets 
-# passed to the kokkos makefile configuration:
-#  make -f ${CMAKE_SOURCE_DIR}/core/src/Makefile ${KOKKOS_SETTINGS} build-makefile-cmake-kokkos
-# that generates KokkosCore_config.h and kokkos_generated_settings.cmake
-# To understand how to form KOKKOS_SETTINGS, see
-#     <KOKKOS_PATH>/Makefile.kokkos
-
-#-------------------------------------------------------------------------------
-#------------------------------- GENERAL OPTIONS -------------------------------
-#-------------------------------------------------------------------------------
-
-# Ensure that KOKKOS_ARCH is in the ARCH_LIST
-if (KOKKOS_ARCH MATCHES ",")
-  message("-- Detected a comma in: KOKKOS_ARCH=`${KOKKOS_ARCH}`")
-  message("-- Although we prefer KOKKOS_ARCH to be semicolon-delimited, we do allow")
-  message("-- comma-delimited values for compatibility with scripts (see github.com/trilinos/Trilinos/issues/2330)")
-  string(REPLACE "," ";" KOKKOS_ARCH "${KOKKOS_ARCH}")
-  message("-- Commas were changed to semicolons, now KOKKOS_ARCH=`${KOKKOS_ARCH}`")
-endif()
-foreach(arch ${KOKKOS_ARCH})
-  list(FIND KOKKOS_ARCH_LIST ${arch} indx)
-  if (indx EQUAL -1)
-    message(FATAL_ERROR "`${arch}` is not an accepted value in KOKKOS_ARCH=`${KOKKOS_ARCH}`."
-      "  Please pick from these choices: ${KOKKOS_INTERNAL_ARCH_DOCSTR}")
-  endif ()
-endforeach()
-
-# KOKKOS_SETTINGS uses KOKKOS_ARCH
-string(REPLACE ";" "," KOKKOS_GMAKE_ARCH "${KOKKOS_ARCH}")
-
-# From Makefile.kokkos: Options: yes,no
-if(${KOKKOS_ENABLE_DEBUG})
-  set(KOKKOS_GMAKE_DEBUG yes)
-else()
-  set(KOKKOS_GMAKE_DEBUG no)
-endif()
-
-#------------------------------- KOKKOS_DEVICES --------------------------------
-# Can have multiple devices 
-set(KOKKOS_DEVICESl)
-foreach(devopt ${KOKKOS_DEVICES_LIST})
-  string(TOUPPER ${devopt} devoptuc)
-  if (${KOKKOS_ENABLE_${devoptuc}}) 
-    list(APPEND KOKKOS_DEVICESl ${devopt})
-  endif ()
-endforeach()
-# List needs to be comma-delmitted
-string(REPLACE ";" "," KOKKOS_GMAKE_DEVICES "${KOKKOS_DEVICESl}")
-
-#------------------------------- KOKKOS_OPTIONS --------------------------------
-# From Makefile.kokkos: Options: aggressive_vectorization,disable_profiling,disable_deprecated_code
-#compiler_warnings, aggressive_vectorization, disable_profiling, disable_dualview_modify_check, enable_profile_load_print
-
-set(KOKKOS_OPTIONSl)
-if(${KOKKOS_ENABLE_COMPILER_WARNINGS})
-      list(APPEND KOKKOS_OPTIONSl compiler_warnings)
-endif()
-if(${KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION})
-      list(APPEND KOKKOS_OPTIONSl aggressive_vectorization)
-endif()
-if(NOT ${KOKKOS_ENABLE_PROFILING})
-      list(APPEND KOKKOS_OPTIONSl disable_profiling)
-endif()
-if(NOT ${KOKKOS_ENABLE_DEPRECATED_CODE})
-      list(APPEND KOKKOS_OPTIONSl disable_deprecated_code)
-endif()
-if(NOT ${KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK})
-      list(APPEND KOKKOS_OPTIONSl disable_dualview_modify_check)
-endif()
-if(${KOKKOS_ENABLE_PROFILING_LOAD_PRINT})
-      list(APPEND KOKKOS_OPTIONSl enable_profile_load_print)
-endif()
-if(${KOKKOS_ENABLE_EXPLICIT_INSTANTIATION})
-      list(APPEND KOKKOS_OPTIONSl enable_eti)
-endif()
-# List needs to be comma-delimitted
-string(REPLACE ";" "," KOKKOS_GMAKE_OPTIONS "${KOKKOS_OPTIONSl}")
-
-
-#------------------------------- KOKKOS_USE_TPLS -------------------------------
-# Construct the Makefile options
-set(KOKKOS_USE_TPLSl)
-foreach(tplopt ${KOKKOS_USE_TPLS_LIST})
-  if (${KOKKOS_ENABLE_${tplopt}}) 
-    list(APPEND KOKKOS_USE_TPLSl ${KOKKOS_INTERNAL_${tplopt}})
-  endif ()
-endforeach()
-# List needs to be comma-delimitted
-string(REPLACE ";" "," KOKKOS_GMAKE_USE_TPLS "${KOKKOS_USE_TPLSl}")
-
-
-#------------------------------- KOKKOS_CUDA_OPTIONS ---------------------------
-# Construct the Makefile options
-set(KOKKOS_CUDA_OPTIONSl)
-foreach(cudaopt ${KOKKOS_CUDA_OPTIONS_LIST})
-  if (${KOKKOS_ENABLE_CUDA_${cudaopt}})
-    list(APPEND KOKKOS_CUDA_OPTIONSl ${KOKKOS_INTERNAL_${cudaopt}})
-  endif ()
-endforeach()
-# List needs to be comma-delmitted
-string(REPLACE ";" "," KOKKOS_GMAKE_CUDA_OPTIONS "${KOKKOS_CUDA_OPTIONSl}")
-
-#------------------------------- PATH VARIABLES --------------------------------
-#  Want makefile to use same executables specified which means modifying
-#  the path so the $(shell ...) commands in the makefile see the right exec
-#  Also, the Makefile's use FOO_PATH naming scheme for -I/-L construction
-#TODO:  Makefile.kokkos allows this to be overwritten? ROCM_HCC_PATH
-
-set(KOKKOS_INTERNAL_PATHS)
-set(addpathl)
-foreach(kvar IN LISTS KOKKOS_USE_TPLS_LIST ITEMS CUDA QTHREADS)
-  if(${KOKKOS_ENABLE_${kvar}})
-    if(DEFINED KOKKOS_${kvar}_DIR)
-      set(KOKKOS_INTERNAL_PATHS ${KOKKOS_INTERNAL_PATHS} "${kvar}_PATH=${KOKKOS_${kvar}_DIR}")
-      if(IS_DIRECTORY ${KOKKOS_${kvar}_DIR}/bin)
-        list(APPEND addpathl ${KOKKOS_${kvar}_DIR}/bin)
-      endif()
-    endif()
-  endif()
-endforeach()
-# Path env is : delimitted
-string(REPLACE ";" ":" KOKKOS_INTERNAL_ADDTOPATH "${addpathl}")
-
-
-######################### SET KOKKOS_SETTINGS ##################################
-# Set the KOKKOS_SETTINGS String -- this is the primary communication with the
-# makefile configuration.  See Makefile.kokkos
-
-set(KOKKOS_SETTINGS KOKKOS_CMAKE=yes)
-set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} KOKKOS_SRC_PATH=${KOKKOS_SRC_PATH})
-set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} KOKKOS_PATH=${KOKKOS_PATH})
-set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} KOKKOS_INSTALL_PATH=${CMAKE_INSTALL_PREFIX})
-
-# Form of KOKKOS_foo=$KOKKOS_foo
-foreach(kvar ARCH;DEVICES;DEBUG;OPTIONS;CUDA_OPTIONS;USE_TPLS)
-  if(DEFINED KOKKOS_GMAKE_${kvar})
-    if (NOT "${KOKKOS_GMAKE_${kvar}}" STREQUAL "")
-      set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} KOKKOS_${kvar}=${KOKKOS_GMAKE_${kvar}})
-    endif()
-  endif()
-endforeach()
-
-# Form of VAR=VAL
-#TODO:  Makefile supports MPICH_CXX, OMPI_CXX as well
-foreach(ovar CXX;CXXFLAGS;LDFLAGS)
-  if(DEFINED ${ovar})
-    if (NOT "${${ovar}}" STREQUAL "")
-      set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} ${ovar}=${${ovar}})
-    endif()
-  endif()
-endforeach()
-
-# Finally, do the paths
-if (NOT "${KOKKOS_INTERNAL_PATHS}" STREQUAL "")
-  set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} ${KOKKOS_INTERNAL_PATHS})
-endif()
-if (NOT "${KOKKOS_INTERNAL_ADDTOPATH}" STREQUAL "")
-  set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} "PATH=${KOKKOS_INTERNAL_ADDTOPATH}:$ENV{PATH}")
-endif()
-
-if (CMAKE_CXX_STANDARD)
-  if (CMAKE_CXX_STANDARD STREQUAL "98")
-    message(FATAL_ERROR "Kokkos requires C++11 or newer!")
-  endif()
-  set(KOKKOS_CXX_STANDARD "c++${CMAKE_CXX_STANDARD}")
-  if (CMAKE_CXX_EXTENSIONS)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-      set(KOKKOS_CXX_STANDARD "gnu++${CMAKE_CXX_STANDARD}")
-    endif()
-  endif()
-  set(KOKKOS_SETTINGS ${KOKKOS_SETTINGS} "KOKKOS_CXX_STANDARD=\"${KOKKOS_CXX_STANDARD}\"")
-endif()
-
-# Final form that gets passed to make
-set(KOKKOS_SETTINGS env ${KOKKOS_SETTINGS})
-
-
-############################ PRINT CONFIGURE STATUS ############################
-
-if(KOKKOS_CMAKE_VERBOSE)
-  message(STATUS "")
-  message(STATUS "****************** Kokkos Settings ******************")
-  message(STATUS "Execution Spaces")
-
-  if(KOKKOS_ENABLE_CUDA)
-    message(STATUS "  Device Parallel: Cuda")
-  else()
-    message(STATUS "  Device Parallel: None")
-  endif()
-
-  if(KOKKOS_ENABLE_OPENMP)
-    message(STATUS "    Host Parallel: OpenMP")
-  elseif(KOKKOS_ENABLE_PTHREAD)
-    message(STATUS "    Host Parallel: Pthread")
-  elseif(KOKKOS_ENABLE_QTHREADS)
-    message(STATUS "    Host Parallel: Qthreads")
-  elseif(KOKKOS_ENABLE_HPX)
-    message(STATUS "    Host Parallel: HPX")
-  else()
-    message(STATUS "    Host Parallel: None")
-  endif()
-
-  if(KOKKOS_ENABLE_SERIAL)
-    message(STATUS "      Host Serial: Serial")
-  else()
-    message(STATUS "      Host Serial: None")
-  endif()
-
-  message(STATUS "")
-  message(STATUS "Architectures:")
-  message(STATUS "    ${KOKKOS_GMAKE_ARCH}")
-
-  message(STATUS "")
-  message(STATUS "Enabled options")
-
-  if(KOKKOS_SEPARATE_LIBS)
-    message(STATUS "  KOKKOS_SEPARATE_LIBS")
-  endif()
-
-  foreach(opt IN LISTS KOKKOS_INTERNAL_ENABLE_OPTIONS_LIST)
-    string(TOUPPER ${opt} OPT)
-    if (KOKKOS_ENABLE_${OPT})
-      message(STATUS "  KOKKOS_ENABLE_${OPT}")
-    endif()
-  endforeach()
-
-  if(KOKKOS_ENABLE_CUDA)
-    if(KOKKOS_CUDA_DIR)
-      message(STATUS "  KOKKOS_CUDA_DIR: ${KOKKOS_CUDA_DIR}")
-    endif()
-  endif()
-
-  if(KOKKOS_QTHREADS_DIR)
-    message(STATUS "  KOKKOS_QTHREADS_DIR: ${KOKKOS_QTHREADS_DIR}")
-  endif()
-
-  if(KOKKOS_HWLOC_DIR)
-    message(STATUS "  KOKKOS_HWLOC_DIR: ${KOKKOS_HWLOC_DIR}")
-  endif()
-
-  if(KOKKOS_MEMKIND_DIR)
-    message(STATUS "  KOKKOS_MEMKIND_DIR: ${KOKKOS_MEMKIND_DIR}")
-  endif()
-
-  if(KOKKOS_HPX_DIR)
-    message(STATUS "  KOKKOS_HPX_DIR: ${KOKKOS_HPX_DIR}")
-  endif()
-
-  message(STATUS "")
-  message(STATUS "Final kokkos settings variable:")
-  message(STATUS "  ${KOKKOS_SETTINGS}")
-
-  message(STATUS "*****************************************************")
-  message(STATUS "")
-endif()
diff --git a/lib/kokkos/cmake/kokkos_test_cxx_std.cmake b/lib/kokkos/cmake/kokkos_test_cxx_std.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c264517abe114bc306a19ca3459f584548506dd5
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_test_cxx_std.cmake
@@ -0,0 +1,144 @@
+KOKKOS_CFG_DEPENDS(CXX_STD COMPILER_ID)
+
+FUNCTION(kokkos_set_cxx_standard_feature standard)
+  SET(EXTENSION_NAME CMAKE_CXX${standard}_EXTENSION_COMPILE_OPTION)
+  SET(STANDARD_NAME  CMAKE_CXX${standard}_STANDARD_COMPILE_OPTION)
+  SET(FEATURE_NAME   cxx_std_${standard})
+  #CMake's way of telling us that the standard (or extension)
+  #flags are supported is the extension/standard variables
+  IF (NOT DEFINED CMAKE_CXX_EXTENSIONS)
+    IF(KOKKOS_DONT_ALLOW_EXTENSIONS)
+      GLOBAL_SET(KOKKOS_USE_CXX_EXTENSIONS OFF)
+    ELSE()
+      GLOBAL_SET(KOKKOS_USE_CXX_EXTENSIONS ON)
+    ENDIF()
+  ELSEIF(CMAKE_CXX_EXTENSIONS)
+    IF(KOKKOS_DONT_ALLOW_EXTENSIONS)
+      MESSAGE(FATAL_ERROR "The chosen configuration does not support CXX extensions flags: ${KOKKOS_DONT_ALLOW_EXTENSIONS}. Must set CMAKE_CXX_EXTENSIONS=OFF to continue") 
+    ELSE()
+      GLOBAL_SET(KOKKOS_USE_CXX_EXTENSIONS ON)
+    ENDIF()
+  ELSE()
+    #For trilinos, we need to make sure downstream projects 
+    GLOBAL_SET(KOKKOS_USE_CXX_EXTENSIONS OFF)
+  ENDIF()
+
+  IF (KOKKOS_USE_CXX_EXTENSIONS AND ${EXTENSION_NAME})
+    MESSAGE(STATUS "Using ${${EXTENSION_NAME}} for C++${standard} extensions as feature")
+    GLOBAL_SET(KOKKOS_CXX_STANDARD_FEATURE ${FEATURE_NAME})
+  ELSEIF(NOT KOKKOS_USE_CXX_EXTENSIONS AND ${STANDARD_NAME})
+    MESSAGE(STATUS "Using ${${STANDARD_NAME}} for C++${standard} standard as feature")
+    GLOBAL_SET(KOKKOS_CXX_STANDARD_FEATURE ${FEATURE_NAME})
+  ELSE()
+    #nope, we can't do anything here
+    MESSAGE(WARNING "C++${standard} is not supported as a compiler feature. We will choose custom flags for now, but this behavior has been deprecated. Please open an issue at https://github.com/kokkos/kokkos/issues reporting that ${KOKKOS_CXX_COMPILER_ID} ${KOKKOS_CXX_COMPILER_VERSION} failed for ${KOKKOS_CXX_STANDARD}, preferrably including your CMake command.")
+    GLOBAL_SET(KOKKOS_CXX_STANDARD_FEATURE "")
+  ENDIF()
+
+  IF(NOT ${FEATURE_NAME} IN_LIST CMAKE_CXX_COMPILE_FEATURES)
+    MESSAGE(FATAL_ERROR "Compiler ${KOKKOS_CXX_COMPILER_ID} should support ${FEATURE_NAME}, but CMake reports feature not supported")
+  ENDIF()
+ENDFUNCTION()
+
+
+IF (KOKKOS_CXX_STANDARD AND CMAKE_CXX_STANDARD)
+  #make sure these are consistent
+  IF (NOT KOKKOS_CXX_STANDARD STREQUAL CMAKE_CXX_STANDARD)
+    MESSAGE(WARNING "Specified both CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD} and KOKKOS_CXX_STANDARD=${KOKKOS_CXX_STANDARD}, but they don't match")
+    SET(CMAKE_CXX_STANDARD ${KOKKOS_CXX_STANDARD} CACHE STRING "C++ standard" FORCE)
+  ENDIF()
+ENDIF()
+
+
+IF (KOKKOS_CXX_STANDARD STREQUAL "11" )
+  kokkos_set_cxx_standard_feature(11)
+  SET(KOKKOS_ENABLE_CXX11 ON)
+  SET(KOKKOS_CXX_INTERMEDIATE_STANDARD "11")
+ELSEIF(KOKKOS_CXX_STANDARD STREQUAL "14")
+  kokkos_set_cxx_standard_feature(14)
+  SET(KOKKOS_CXX_INTERMEDIATE_STANDARD "1Y")
+  SET(KOKKOS_ENABLE_CXX14 ON)
+ELSEIF(KOKKOS_CXX_STANDARD STREQUAL "17")
+  kokkos_set_cxx_standard_feature(17)
+  SET(KOKKOS_CXX_INTERMEDIATE_STANDARD "1Z")
+  SET(KOKKOS_ENABLE_CXX17 ON)
+ELSEIF(KOKKOS_CXX_STANDARD STREQUAL "20")
+  kokkos_set_cxx_standard_feature(20)
+  SET(KOKKOS_CXX_INTERMEDIATE_STANDARD "2A")
+  SET(KOKKOS_ENABLE_CXX20 ON)
+ELSEIF(KOKKOS_CXX_STANDARD STREQUAL "98")
+  MESSAGE(FATAL_ERROR "Kokkos requires C++11 or newer!")
+ELSE()
+  MESSAGE(FATAL_ERROR "Unknown C++ standard ${KOKKOS_CXX_STANDARD} - must be 11, 14, 17, or 20")
+ENDIF()
+
+
+
+# Enforce that extensions are turned off for nvcc_wrapper.
+# For compiling CUDA code using nvcc_wrapper, we will use the host compiler's
+# flags for turning on C++11.  Since for compiler ID and versioning purposes
+# CMake recognizes the host compiler when calling nvcc_wrapper, this just
+# works.  Both NVCC and nvcc_wrapper only recognize '-std=c++11' which means
+# that we can only use host compilers for CUDA builds that use those flags.
+# It also means that extensions (gnu++11) can't be turned on for CUDA builds.
+
+IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+  IF(NOT DEFINED CMAKE_CXX_EXTENSIONS)
+    SET(CMAKE_CXX_EXTENSIONS OFF)
+  ELSEIF(CMAKE_CXX_EXTENSIONS)
+    MESSAGE(FATAL_ERROR "NVCC doesn't support C++ extensions.  Set -DCMAKE_CXX_EXTENSIONS=OFF")
+  ENDIF()
+ENDIF()
+
+IF(KOKKOS_ENABLE_CUDA)
+  # ENFORCE that the compiler can compile CUDA code.
+  IF(KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
+    IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 4.0.0)
+      MESSAGE(FATAL_ERROR "Compiling CUDA code directly with Clang requires version 4.0.0 or higher.")
+    ENDIF()
+    IF(NOT DEFINED CMAKE_CXX_EXTENSIONS)
+      SET(CMAKE_CXX_EXTENSIONS OFF)
+    ELSEIF(CMAKE_CXX_EXTENSIONS)
+      MESSAGE(FATAL_ERROR "Compiling CUDA code with clang doesn't support C++ extensions.  Set -DCMAKE_CXX_EXTENSIONS=OFF")
+    ENDIF()
+  ELSEIF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+    MESSAGE(FATAL_ERROR "Invalid compiler for CUDA.  The compiler must be nvcc_wrapper or Clang, but compiler ID was ${KOKKOS_CXX_COMPILER_ID}")
+  ENDIF()
+ENDIF()
+
+IF (NOT KOKKOS_CXX_STANDARD_FEATURE)
+  #we need to pick the C++ flags ourselves
+  UNSET(CMAKE_CXX_STANDARD)
+  UNSET(CMAKE_CXX_STANDARD CACHE)
+  IF(KOKKOS_CXX_COMPILER_ID STREQUAL Cray)
+    INCLUDE(${KOKKOS_SRC_PATH}/cmake/cray.cmake)
+    kokkos_set_cray_flags(${KOKKOS_CXX_STANDARD} ${KOKKOS_CXX_INTERMEDIATE_STANDARD})
+  ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL PGI)
+    INCLUDE(${KOKKOS_SRC_PATH}/cmake/pgi.cmake)
+    kokkos_set_pgi_flags(${KOKKOS_CXX_STANDARD} ${KOKKOS_CXX_INTERMEDIATE_STANDARD})
+  ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL Intel)
+    INCLUDE(${KOKKOS_SRC_PATH}/cmake/intel.cmake)
+    kokkos_set_intel_flags(${KOKKOS_CXX_STANDARD} ${KOKKOS_CXX_INTERMEDIATE_STANDARD})
+  ELSE()
+    INCLUDE(${KOKKOS_SRC_PATH}/cmake/gnu.cmake)
+    kokkos_set_gnu_flags(${KOKKOS_CXX_STANDARD} ${KOKKOS_CXX_INTERMEDIATE_STANDARD})
+  ENDIF()
+  #check that the compiler accepts the C++ standard flag
+  INCLUDE(CheckCXXCompilerFlag)
+  IF (DEFINED CXX_STD_FLAGS_ACCEPTED)
+    UNSET(CXX_STD_FLAGS_ACCEPTED CACHE)
+  ENDIF()
+  CHECK_CXX_COMPILER_FLAG(${KOKKOS_CXX_STANDARD_FLAG} CXX_STD_FLAGS_ACCEPTED)
+  IF (NOT CXX_STD_FLAGS_ACCEPTED)
+    CHECK_CXX_COMPILER_FLAG(${KOKKOS_CXX_INTERMEDIATE_STANDARD_FLAG} CXX_INT_STD_FLAGS_ACCEPTED)
+    IF (NOT CXX_INT_STD_FLAGS_ACCEPTED)
+      MESSAGE(FATAL_ERROR "${KOKKOS_CXX_COMPILER_ID} did not accept ${KOKKOS_CXX_STANDARD_FLAG} or ${KOKKOS_CXX_INTERMEDIATE_STANDARD_FLAG}. You likely need to reduce the level of the C++ standard from ${KOKKOS_CXX_STANDARD}")
+    ENDIF()
+    SET(KOKKOS_CXX_STANDARD_FLAG ${KOKKOS_CXX_INTERMEDIATE_STANDARD_FLAG})
+  ENDIF()
+  MESSAGE(STATUS "Compiler features not supported, but ${KOKKOS_CXX_COMPILER_ID} accepts ${KOKKOS_CXX_STANDARD_FLAG}")
+ENDIF()
+
+
+
+
diff --git a/lib/kokkos/cmake/kokkos_tpls.cmake b/lib/kokkos/cmake/kokkos_tpls.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..181a497d52a0e5f579e4a5ffbe05c1c1591edc29
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_tpls.cmake
@@ -0,0 +1,47 @@
+KOKKOS_CFG_DEPENDS(TPLS OPTIONS)
+KOKKOS_CFG_DEPENDS(TPLS DEVICES)
+
+FUNCTION(KOKKOS_TPL_OPTION PKG DEFAULT)
+  KOKKOS_ENABLE_OPTION(${PKG} ${DEFAULT} "Whether to enable the ${PKG} library")
+  KOKKOS_OPTION(${PKG}_DIR "" PATH "Location of ${PKG} library")
+  SET(KOKKOS_ENABLE_${PKG} ${KOKKOS_ENABLE_${PKG}} PARENT_SCOPE)
+  SET(KOKKOS_${PKG}_DIR  ${KOKKOS_${PKG}_DIR} PARENT_SCOPE)
+ENDFUNCTION()
+
+KOKKOS_TPL_OPTION(HWLOC   Off)
+KOKKOS_TPL_OPTION(LIBNUMA Off)
+KOKKOS_TPL_OPTION(MEMKIND Off)
+KOKKOS_TPL_OPTION(CUDA    Off)
+KOKKOS_TPL_OPTION(LIBRT   Off)
+KOKKOS_TPL_OPTION(LIBDL   On)
+
+IF(Trilinos_ENABLE_Kokkos AND TPL_ENABLE_HPX)
+SET(HPX_DEFAULT ON)
+ELSE()
+SET(HPX_DEFAULT OFF)
+ENDIF()
+KOKKOS_TPL_OPTION(HPX ${HPX_DEFAULT})
+
+IF(Trilinos_ENABLE_Kokkos AND TPL_ENABLE_PTHREAD)
+SET(PTHREAD_DEFAULT ON)
+ELSE()
+SET(PTHREAD_DEFAULT OFF)
+ENDIF()
+KOKKOS_TPL_OPTION(PTHREAD ${PTHREAD_DEFAULT})
+
+
+#Make sure we use our local FindKokkosCuda.cmake
+KOKKOS_IMPORT_TPL(HPX INTERFACE)
+KOKKOS_IMPORT_TPL(CUDA INTERFACE)
+KOKKOS_IMPORT_TPL(HWLOC)
+KOKKOS_IMPORT_TPL(LIBNUMA)
+KOKKOS_IMPORT_TPL(LIBRT)
+KOKKOS_IMPORT_TPL(LIBDL)
+KOKKOS_IMPORT_TPL(MEMKIND)
+KOKKOS_IMPORT_TPL(PTHREAD INTERFACE)
+
+#Convert list to newlines (which CMake doesn't always like in cache variables)
+STRING(REPLACE ";" "\n" KOKKOS_TPL_EXPORT_TEMP "${KOKKOS_TPL_EXPORTS}")
+#Convert to a regular variable
+UNSET(KOKKOS_TPL_EXPORTS CACHE)
+SET(KOKKOS_TPL_EXPORTS ${KOKKOS_TPL_EXPORT_TEMP})
diff --git a/lib/kokkos/cmake/kokkos_tribits.cmake b/lib/kokkos/cmake/kokkos_tribits.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d2317d2446ffdbf2626fff6117941af7510db865
--- /dev/null
+++ b/lib/kokkos/cmake/kokkos_tribits.cmake
@@ -0,0 +1,392 @@
+#These are tribits wrappers only ever called by Kokkos itself
+
+INCLUDE(CMakeParseArguments)
+INCLUDE(CTest)
+INCLUDE(GNUInstallDirs)
+
+MESSAGE(STATUS "The project name is: ${PROJECT_NAME}")
+
+#Leave this here for now - but only do for tribits
+#This breaks the standalone CMake
+IF (KOKKOS_HAS_TRILINOS)
+  IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_OpenMP)
+    SET(${PROJECT_NAME}_ENABLE_OpenMP OFF)
+  ENDIF()
+
+  IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_HPX)
+    SET(${PROJECT_NAME}_ENABLE_HPX OFF)
+  ENDIF()
+
+  IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_DEBUG)
+    SET(${PROJECT_NAME}_ENABLE_DEBUG OFF)
+  ENDIF()
+
+  IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_CXX11)
+    SET(${PROJECT_NAME}_ENABLE_CXX11 ON)
+  ENDIF()
+
+  IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_TESTS)
+    SET(${PROJECT_NAME}_ENABLE_TESTS OFF)
+  ENDIF()
+
+  IF(NOT DEFINED TPL_ENABLE_Pthread)
+    SET(TPL_ENABLE_Pthread OFF)
+  ENDIF()
+ENDIF()
+
+MACRO(KOKKOS_SUBPACKAGE NAME)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_SUBPACKAGE(${NAME})
+  else()
+    SET(PACKAGE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+    SET(PARENT_PACKAGE_NAME ${PACKAGE_NAME})
+    SET(PACKAGE_NAME ${PACKAGE_NAME}${NAME})
+    STRING(TOUPPER ${PACKAGE_NAME} PACKAGE_NAME_UC)
+    SET(${PACKAGE_NAME}_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+  endif()
+ENDMACRO()
+
+MACRO(KOKKOS_SUBPACKAGE_POSTPROCESS)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_SUBPACKAGE_POSTPROCESS()
+  endif()
+ENDMACRO()
+
+MACRO(KOKKOS_PACKAGE_DECL)
+
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_PACKAGE_DECL(Kokkos)
+  else()
+    SET(PACKAGE_NAME Kokkos)
+    SET(${PACKAGE_NAME}_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+    STRING(TOUPPER ${PACKAGE_NAME} PACKAGE_NAME_UC)
+  endif()
+
+  #SET(TRIBITS_DEPS_DIR "${CMAKE_SOURCE_DIR}/cmake/deps")
+  #FILE(GLOB TPLS_FILES "${TRIBITS_DEPS_DIR}/*.cmake")
+  #FOREACH(TPL_FILE ${TPLS_FILES})
+  #  TRIBITS_PROCESS_TPL_DEP_FILE(${TPL_FILE})
+  #ENDFOREACH()
+
+ENDMACRO()
+
+
+MACRO(KOKKOS_PROCESS_SUBPACKAGES)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_PROCESS_SUBPACKAGES()
+  else()
+    ADD_SUBDIRECTORY(core)
+    ADD_SUBDIRECTORY(containers)
+    ADD_SUBDIRECTORY(algorithms)
+    ADD_SUBDIRECTORY(example)
+  endif()
+ENDMACRO()
+
+MACRO(KOKKOS_PACKAGE_DEF)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_PACKAGE_DEF()
+  else()
+    #do nothing
+  endif()
+ENDMACRO()
+
+MACRO(KOKKOS_INTERNAL_ADD_LIBRARY_INSTALL LIBRARY_NAME)
+  KOKKOS_LIB_TYPE(${LIBRARY_NAME} INCTYPE)
+  TARGET_INCLUDE_DIRECTORIES(${LIBRARY_NAME} ${INCTYPE} $<INSTALL_INTERFACE:${KOKKOS_HEADER_DIR}>)
+
+  INSTALL(
+    TARGETS ${LIBRARY_NAME}
+    EXPORT ${PROJECT_NAME}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    COMPONENT ${PACKAGE_NAME}
+  )
+
+  INSTALL(
+    TARGETS ${LIBRARY_NAME}
+    EXPORT KokkosTargets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  )
+
+  VERIFY_EMPTY(KOKKOS_ADD_LIBRARY ${PARSE_UNPARSED_ARGUMENTS})
+ENDMACRO()
+
+FUNCTION(KOKKOS_ADD_EXECUTABLE EXE_NAME)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_ADD_EXECUTABLE(${EXE_NAME} ${ARGN})
+  else()
+    CMAKE_PARSE_ARGUMENTS(PARSE 
+      "TESTONLY"
+      ""
+      "SOURCES;TESTONLYLIBS"
+      ${ARGN})
+
+    ADD_EXECUTABLE(${EXE_NAME} ${PARSE_SOURCES})
+    IF (PARSE_TESTONLYLIBS)
+      TARGET_LINK_LIBRARIES(${EXE_NAME} ${PARSE_TESTONLYLIBS})
+    ENDIF()
+    VERIFY_EMPTY(KOKKOS_ADD_EXECUTABLE ${PARSE_UNPARSED_ARGUMENTS})
+  endif()
+ENDFUNCTION()
+
+IF(NOT TARGET check)
+  ADD_CUSTOM_TARGET(check COMMAND ${CMAKE_CTEST_COMMAND} -VV -C ${CMAKE_CFG_INTDIR})
+ENDIF()
+
+
+FUNCTION(KOKKOS_ADD_EXECUTABLE_AND_TEST ROOT_NAME)
+IF (KOKKOS_HAS_TRILINOS)
+  TRIBITS_ADD_EXECUTABLE_AND_TEST(
+    ${ROOT_NAME} 
+    TESTONLYLIBS kokkos_gtest 
+    ${ARGN}
+    NUM_MPI_PROCS 1
+    COMM serial mpi
+    FAIL_REGULAR_EXPRESSION "  FAILED  "
+  )
+ELSE()
+  CMAKE_PARSE_ARGUMENTS(PARSE 
+    ""
+    ""
+    "SOURCES;CATEGORIES"
+    ${ARGN})
+  VERIFY_EMPTY(KOKKOS_ADD_EXECUTABLE_AND_TEST ${PARSE_UNPARSED_ARGUMENTS})
+  SET(EXE_NAME ${PACKAGE_NAME}_${ROOT_NAME})
+  KOKKOS_ADD_TEST_EXECUTABLE(${EXE_NAME}
+    SOURCES ${PARSE_SOURCES}
+  )
+  KOKKOS_ADD_TEST(NAME ${ROOT_NAME} 
+    EXE ${EXE_NAME}
+    FAIL_REGULAR_EXPRESSION "  FAILED  "
+  )
+ENDIF()
+ENDFUNCTION()
+
+MACRO(KOKKOS_SETUP_BUILD_ENVIRONMENT)
+ INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_compiler_id.cmake)
+ INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_enable_devices.cmake)
+ INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_enable_options.cmake)
+ INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_test_cxx_std.cmake)
+ INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_arch.cmake)
+ IF (NOT KOKKOS_HAS_TRILINOS)
+  SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${Kokkos_SOURCE_DIR}/cmake/Modules/")
+  INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_tpls.cmake)
+ ENDIF()
+ INCLUDE(${KOKKOS_SRC_PATH}/cmake/kokkos_corner_cases.cmake)
+ENDMACRO()
+
+MACRO(KOKKOS_ADD_TEST_EXECUTABLE EXE_NAME)
+  CMAKE_PARSE_ARGUMENTS(PARSE 
+    ""
+    ""
+    "SOURCES"
+    ${ARGN})
+  KOKKOS_ADD_EXECUTABLE(${EXE_NAME}
+    SOURCES ${PARSE_SOURCES}
+    ${PARSE_UNPARSED_ARGUMENTS}
+    TESTONLYLIBS kokkos_gtest
+  )
+  IF (NOT KOKKOS_HAS_TRILINOS)
+    ADD_DEPENDENCIES(check ${EXE_NAME})
+  ENDIF()
+ENDMACRO()
+
+MACRO(KOKKOS_PACKAGE_POSTPROCESS)
+  if (KOKKOS_HAS_TRILINOS)
+    TRIBITS_PACKAGE_POSTPROCESS()
+  endif()
+ENDMACRO()
+
+FUNCTION(KOKKOS_SET_LIBRARY_PROPERTIES LIBRARY_NAME)
+  CMAKE_PARSE_ARGUMENTS(PARSE 
+    "PLAIN_STYLE"
+    ""
+    ""
+    ${ARGN})
+
+  IF(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.13")
+    #great, this works the "right" way
+    TARGET_LINK_OPTIONS(
+      ${LIBRARY_NAME} PUBLIC ${KOKKOS_LINK_OPTIONS}
+    )
+  ELSE()
+    IF (PARSE_PLAIN_STYLE)
+      TARGET_LINK_LIBRARIES(
+        ${LIBRARY_NAME} ${KOKKOS_LINK_OPTIONS}
+      )
+    ELSE()
+      #well, have to do it the wrong way for now
+      TARGET_LINK_LIBRARIES(
+        ${LIBRARY_NAME} PUBLIC ${KOKKOS_LINK_OPTIONS}
+      )
+    ENDIF()
+  ENDIF()
+
+  TARGET_COMPILE_OPTIONS(
+    ${LIBRARY_NAME} PUBLIC
+    $<$<COMPILE_LANGUAGE:CXX>:${KOKKOS_COMPILE_OPTIONS}>
+  )
+
+  IF (KOKKOS_ENABLE_CUDA)
+    TARGET_COMPILE_OPTIONS(
+      ${LIBRARY_NAME}
+      PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${KOKKOS_CUDA_OPTIONS}>
+    )
+    SET(NODEDUP_CUDAFE_OPTIONS)
+    FOREACH(OPT ${KOKKOS_CUDAFE_OPTIONS})
+      LIST(APPEND NODEDUP_CUDAFE_OPTIONS -Xcudafe ${OPT})
+    ENDFOREACH()
+    TARGET_COMPILE_OPTIONS(
+      ${LIBRARY_NAME} 
+      PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${NODEDUP_CUDAFE_OPTIONS}>
+    )
+  ENDIF()
+
+  LIST(LENGTH KOKKOS_XCOMPILER_OPTIONS XOPT_LENGTH)
+  IF (XOPT_LENGTH GREATER 1)
+    MESSAGE(FATAL_ERROR "CMake deduplication does not allow multiple -Xcompiler flags (${KOKKOS_XCOMPILER_OPTIONS}): will require Kokkos to upgrade to minimum 3.12")
+  ENDIF()
+  IF(KOKKOS_XCOMPILER_OPTIONS)
+    SET(NODEDUP_XCOMPILER_OPTIONS)
+    FOREACH(OPT ${KOKKOS_XCOMPILER_OPTIONS})
+      #I have to do this for now because we can't guarantee 3.12 support
+      #I really should do this with the shell option 
+      LIST(APPEND NODEDUP_XCOMPILER_OPTIONS -Xcompiler) 
+      LIST(APPEND NODEDUP_XCOMPILER_OPTIONS ${OPT}) 
+    ENDFOREACH()
+    TARGET_COMPILE_OPTIONS(
+      ${LIBRARY_NAME} 
+      PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${NODEDUP_XCOMPILER_OPTIONS}>
+    )
+  ENDIF()
+
+  IF (KOKKOS_CXX_STANDARD_FEATURE)
+    #GREAT! I can do this the right way
+    TARGET_COMPILE_FEATURES(${LIBRARY_NAME} PUBLIC ${KOKKOS_CXX_STANDARD_FEATURE})
+    IF (NOT KOKKOS_USE_CXX_EXTENSIONS)
+      SET_TARGET_PROPERTIES(${LIBRARY_NAME} PROPERTIES CXX_EXTENSIONS OFF)
+    ENDIF()
+  ELSE()
+    #OH, well, no choice but the wrong way
+    TARGET_COMPILE_OPTIONS(${LIBRARY_NAME} PUBLIC ${KOKKOS_CXX_STANDARD_FLAG})
+  ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_INTERNAL_ADD_LIBRARY LIBRARY_NAME)
+  CMAKE_PARSE_ARGUMENTS(PARSE 
+    "STATIC;SHARED"
+    ""
+    "HEADERS;SOURCES"
+    ${ARGN})
+
+  IF(PARSE_HEADERS)
+    LIST(REMOVE_DUPLICATES PARSE_HEADERS)
+  ENDIF()
+  IF(PARSE_SOURCES)
+    LIST(REMOVE_DUPLICATES PARSE_SOURCES)
+  ENDIF()
+
+  ADD_LIBRARY(
+    ${LIBRARY_NAME}
+    ${PARSE_HEADERS}
+    ${PARSE_SOURCES}
+  )
+
+  KOKKOS_INTERNAL_ADD_LIBRARY_INSTALL(${LIBRARY_NAME})
+
+  INSTALL(
+    FILES  ${PARSE_HEADERS}
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    COMPONENT ${PACKAGE_NAME}
+  )
+
+  #In case we are building in-tree, add an alias name
+  #that matches the install Kokkos:: name
+  ADD_LIBRARY(Kokkos::${LIBRARY_NAME} ALIAS ${LIBRARY_NAME})
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_ADD_LIBRARY LIBRARY_NAME)
+  IF (KOKKOS_HAS_TRILINOS)
+    TRIBITS_ADD_LIBRARY(${LIBRARY_NAME} ${ARGN})
+    #Stolen from Tribits - it can add prefixes
+    SET(TRIBITS_LIBRARY_NAME_PREFIX "${${PROJECT_NAME}_LIBRARY_NAME_PREFIX}")
+    SET(TRIBITS_LIBRARY_NAME ${TRIBITS_LIBRARY_NAME_PREFIX}${LIBRARY_NAME})
+    #Tribits has way too much techinical debt and baggage to even
+    #allow PUBLIC target_compile_options to be used. It forces C++ flags on projects
+    #as a giant blob of space-separated strings. We end up with duplicated
+    #flags between the flags implicitly forced on Kokkos-dependent and those Kokkos
+    #has in its public INTERFACE_COMPILE_OPTIONS.
+    #These do NOT get de-deduplicated because Tribits
+    #creates flags as a giant monolithic space-separated string
+    #Do not set any transitive properties and keep everything working as before
+    #KOKKOS_SET_LIBRARY_PROPERTIES(${TRIBITS_LIBRARY_NAME} PLAIN_STYLE)
+  ELSE()
+    KOKKOS_INTERNAL_ADD_LIBRARY(
+      ${LIBRARY_NAME} ${ARGN})
+    KOKKOS_SET_LIBRARY_PROPERTIES(${LIBRARY_NAME})
+  ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_ADD_INTERFACE_LIBRARY NAME)
+IF (KOKKOS_HAS_TRILINOS)
+  TRIBITS_ADD_LIBRARY(${NAME} ${ARGN})
+ELSE()
+  CMAKE_PARSE_ARGUMENTS(PARSE
+    ""
+    ""
+    "HEADERS;SOURCES"
+    ${ARGN}
+  )
+
+  ADD_LIBRARY(${NAME} INTERFACE)
+  KOKKOS_INTERNAL_ADD_LIBRARY_INSTALL(${NAME})
+
+  INSTALL(
+    FILES  ${PARSE_HEADERS}
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  )
+
+  INSTALL(
+    FILES  ${PARSE_HEADERS}
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    COMPONENT ${PACKAGE_NAME}
+  )
+ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_LIB_INCLUDE_DIRECTORIES TARGET)
+  IF(KOKKOS_HAS_TRILINOS)
+    #ignore the target, tribits doesn't do anything directly with targets
+    TRIBITS_INCLUDE_DIRECTORIES(${ARGN})
+  ELSE() #append to a list for later
+    KOKKOS_LIB_TYPE(${TARGET} INCTYPE) 
+    FOREACH(DIR ${ARGN})
+      TARGET_INCLUDE_DIRECTORIES(${TARGET} ${INCTYPE} $<BUILD_INTERFACE:${DIR}>)
+    ENDFOREACH()
+  ENDIF()
+ENDFUNCTION()
+
+FUNCTION(KOKKOS_LIB_COMPILE_OPTIONS TARGET)
+  IF(KOKKOS_HAS_TRILINOS)
+    #don't trust tribits to do this correctly
+    KOKKOS_TARGET_COMPILE_OPTIONS(${TARGET} ${ARGN})
+  ELSE()
+    KOKKOS_LIB_TYPE(${TARGET} INCTYPE)
+    KOKKOS_TARGET_COMPILE_OPTIONS(${${PROJECT_NAME}_LIBRARY_NAME_PREFIX}${TARGET} ${INCTYPE} ${ARGN})
+  ENDIF()
+ENDFUNCTION()
+
+MACRO(KOKKOS_ADD_TEST_DIRECTORIES)
+  IF (KOKKOS_HAS_TRILINOS)
+    TRIBITS_ADD_TEST_DIRECTORIES(${ARGN})
+  ELSE()
+    IF(KOKKOS_ENABLE_TESTS)
+      FOREACH(TEST_DIR ${ARGN})
+        ADD_SUBDIRECTORY(${TEST_DIR})
+      ENDFOREACH()
+    ENDIF()
+  ENDIF()
+ENDMACRO()
diff --git a/lib/kokkos/cmake/pgi.cmake b/lib/kokkos/cmake/pgi.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e98e84955888496225e9268c7db47ef514f08a48
--- /dev/null
+++ b/lib/kokkos/cmake/pgi.cmake
@@ -0,0 +1,8 @@
+
+function(kokkos_set_pgi_flags full_standard int_standard)
+  STRING(TOLOWER ${full_standard} FULL_LC_STANDARD)
+  STRING(TOLOWER ${int_standard} INT_LC_STANDARD)
+  SET(KOKKOS_CXX_STANDARD_FLAG "--c++${FULL_LC_STANDARD}" PARENT_SCOPE)
+  SET(KOKKOS_CXX_INTERMDIATE_STANDARD_FLAG "--c++${INT_LC_STANDARD}" PARENT_SCOPE)
+endfunction()
+
diff --git a/lib/kokkos/cmake/tpls/FindTPLCUSPARSE.cmake b/lib/kokkos/cmake/tpls/FindTPLCUSPARSE.cmake
index aad1e2bad7629f3f43ca91135752253a20ac9523..b8cee04804cd6cbfdb475b2631c1b1beddfa7b41 100644
--- a/lib/kokkos/cmake/tpls/FindTPLCUSPARSE.cmake
+++ b/lib/kokkos/cmake/tpls/FindTPLCUSPARSE.cmake
@@ -67,7 +67,7 @@ ELSE()
     IF(CUDA_cusparse_LIBRARY STREQUAL "CUDA_cusparse_LIBRARY-NOTFOUND") 
       MESSAGE(FATAL_ERROR "\nCUSPARSE: could not find cuspasre library.")
     ENDIF()
-  ENDIF(CMAKE_VERSION VERSION_LESS "2.8.8")
+  ENDIF()
   GLOBAL_SET(TPL_CUSPARSE_LIBRARY_DIRS)
   GLOBAL_SET(TPL_CUSPARSE_INCLUDE_DIRS ${TPL_CUDA_INCLUDE_DIRS})
   GLOBAL_SET(TPL_CUSPARSE_LIBRARIES    ${CUDA_cusparse_LIBRARY})
diff --git a/lib/kokkos/cmake/tpls/FindTPLHWLOC.cmake b/lib/kokkos/cmake/tpls/FindTPLHWLOC.cmake
index 715b3e9bde59379c632fbec7926b425e6189e74d..a4c55e1d7b695697b458a4c00e5cb5a72a531353 100644
--- a/lib/kokkos/cmake/tpls/FindTPLHWLOC.cmake
+++ b/lib/kokkos/cmake/tpls/FindTPLHWLOC.cmake
@@ -64,7 +64,7 @@
 #    Version:       1.3
 #
 
-TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( HWLOC
+KOKKOS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( HWLOC
   REQUIRED_HEADERS hwloc.h
   REQUIRED_LIBS_NAMES "hwloc"
   )
diff --git a/lib/kokkos/cmake/tpls/FindTPLPthread.cmake b/lib/kokkos/cmake/tpls/FindTPLPthread.cmake
index fc401d7543357f18d225a33efe0cf3bb489170d7..4dc1a87e18681d1c84b0706b48c8d09731b21732 100644
--- a/lib/kokkos/cmake/tpls/FindTPLPthread.cmake
+++ b/lib/kokkos/cmake/tpls/FindTPLPthread.cmake
@@ -75,7 +75,7 @@ IF(USE_THREADS)
   SET(TPL_Pthread_LIBRARIES "${CMAKE_THREAD_LIBS_INIT}")
   SET(TPL_Pthread_LIBRARY_DIRS "")
 ELSE()
-  TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( Pthread
+  KOKKOS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( Pthread
     REQUIRED_HEADERS pthread.h
     REQUIRED_LIBS_NAMES pthread
       )
diff --git a/lib/kokkos/cmake/tpls/FindTPLQTHREADS.cmake b/lib/kokkos/cmake/tpls/FindTPLQTHREADS.cmake
deleted file mode 100644
index c312f2590bcd29197a0cf3fbd5e0b484579a09c2..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/tpls/FindTPLQTHREADS.cmake
+++ /dev/null
@@ -1,69 +0,0 @@
-# @HEADER
-# ************************************************************************
-#
-#            Trilinos: An Object-Oriented Solver Framework
-#                 Copyright (2001) Sandia Corporation
-#
-#
-# Copyright (2001) Sandia Corporation. Under the terms of Contract
-# DE-AC04-94AL85000, there is a non-exclusive license for use of this
-# work by or on behalf of the U.S. Government.  Export of this program
-# may require a license from the United States Government.
-#
-# 1. Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in the
-# documentation and/or other materials provided with the distribution.
-#
-# 3. Neither the name of the Corporation nor the names of the
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-# NOTICE:  The United States Government is granted for itself and others
-# acting on its behalf a paid-up, nonexclusive, irrevocable worldwide
-# license in this data to reproduce, prepare derivative works, and
-# perform publicly and display publicly.  Beginning five (5) years from
-# July 25, 2001, the United States Government is granted for itself and
-# others acting on its behalf a paid-up, nonexclusive, irrevocable
-# worldwide license in this data to reproduce, prepare derivative works,
-# distribute copies to the public, perform publicly and display
-# publicly, and to permit others to do so.
-#
-# NEITHER THE UNITED STATES GOVERNMENT, NOR THE UNITED STATES DEPARTMENT
-# OF ENERGY, NOR SANDIA CORPORATION, NOR ANY OF THEIR EMPLOYEES, MAKES
-# ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL LIABILITY OR
-# RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR USEFULNESS OF ANY
-# INFORMATION, APPARATUS, PRODUCT, OR PROCESS DISCLOSED, OR REPRESENTS
-# THAT ITS USE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS.
-#
-# ************************************************************************
-# @HEADER
-
-
-#-----------------------------------------------------------------------------
-#  Hardware locality detection and control library.
-#
-#  Acquisition information:
-#    Date checked:  July 2014
-#    Checked by:    H. Carter Edwards <hcedwar AT sandia.gov>
-#    Source:        https://code.google.com/p/qthreads
-#
-
-TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES( QTHREADS
-  REQUIRED_HEADERS qthread.h
-  REQUIRED_LIBS_NAMES "qthread"
-  )
diff --git a/lib/kokkos/cmake/tribits.cmake b/lib/kokkos/cmake/tribits.cmake
deleted file mode 100644
index 1f467f0662e0c2154a53a0c5fcb46aea8be5de43..0000000000000000000000000000000000000000
--- a/lib/kokkos/cmake/tribits.cmake
+++ /dev/null
@@ -1,531 +0,0 @@
-INCLUDE(CMakeParseArguments)
-INCLUDE(CTest)
-
-cmake_policy(SET CMP0054 NEW)
-
-MESSAGE(STATUS "The project name is: ${PROJECT_NAME}")
-
-IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_OpenMP)
-  SET(${PROJECT_NAME}_ENABLE_OpenMP OFF)
-ENDIF()
-
-IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_HPX)
-  SET(${PROJECT_NAME}_ENABLE_HPX OFF)
-ENDIF()
-
-IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_DEBUG)
-  SET(${PROJECT_NAME}_ENABLE_DEBUG OFF)
-ENDIF()
-
-IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_CXX11)
-  SET(${PROJECT_NAME}_ENABLE_CXX11 ON)
-ENDIF()
-
-IF(NOT DEFINED ${PROJECT_NAME}_ENABLE_TESTS)
-  SET(${PROJECT_NAME}_ENABLE_TESTS OFF)
-ENDIF()
-
-IF(NOT DEFINED TPL_ENABLE_Pthread)
-  SET(TPL_ENABLE_Pthread OFF)
-ENDIF()
-
-FUNCTION(ASSERT_DEFINED VARS)
-  FOREACH(VAR ${VARS})
-    IF(NOT DEFINED ${VAR})
-      MESSAGE(SEND_ERROR "Error, the variable ${VAR} is not defined!")
-    ENDIF()
-  ENDFOREACH()
-ENDFUNCTION()
-
-MACRO(GLOBAL_SET VARNAME)
-  SET(${VARNAME} ${ARGN} CACHE INTERNAL "")
-ENDMACRO()
-
-MACRO(PREPEND_GLOBAL_SET VARNAME)
-  ASSERT_DEFINED(${VARNAME})
-  GLOBAL_SET(${VARNAME} ${ARGN} ${${VARNAME}})
-ENDMACRO()
-
-#FUNCTION(REMOVE_GLOBAL_DUPLICATES VARNAME)
-#  ASSERT_DEFINED(${VARNAME})
-#  IF (${VARNAME})
-#    SET(TMP ${${VARNAME}})
-#    LIST(REMOVE_DUPLICATES TMP)
-#    GLOBAL_SET(${VARNAME} ${TMP})
-#  ENDIF()
-#ENDFUNCTION()
-
-#MACRO(TRIBITS_ADD_OPTION_AND_DEFINE  USER_OPTION_NAME  MACRO_DEFINE_NAME DOCSTRING  DEFAULT_VALUE)
-#  MESSAGE(STATUS "TRIBITS_ADD_OPTION_AND_DEFINE: '${USER_OPTION_NAME}' '${MACRO_DEFINE_NAME}' '${DEFAULT_VALUE}'")
-#  SET( ${USER_OPTION_NAME} "${DEFAULT_VALUE}" CACHE BOOL "${DOCSTRING}" )
-#  IF(NOT ${MACRO_DEFINE_NAME} STREQUAL "")
-#    IF(${USER_OPTION_NAME})
-#      GLOBAL_SET(${MACRO_DEFINE_NAME} ON)
-#    ELSE()
-#      GLOBAL_SET(${MACRO_DEFINE_NAME} OFF)
-#    ENDIF()
-#  ENDIF()
-#ENDMACRO()
-
-FUNCTION(TRIBITS_CONFIGURE_FILE  PACKAGE_NAME_CONFIG_FILE)
-
-  # Configure the file
-  CONFIGURE_FILE(
-    ${PACKAGE_SOURCE_DIR}/cmake/${PACKAGE_NAME_CONFIG_FILE}.in
-    ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME_CONFIG_FILE}
-    )
-
-ENDFUNCTION()
-
-#MACRO(TRIBITS_ADD_DEBUG_OPTION)
-#  TRIBITS_ADD_OPTION_AND_DEFINE(
-#    ${PROJECT_NAME}_ENABLE_DEBUG
-#    HAVE_${PROJECT_NAME_UC}_DEBUG
-#    "Enable a host of runtime debug checking."
-#    OFF
-#    )
-#ENDMACRO()
-
-
-MACRO(TRIBITS_ADD_TEST_DIRECTORIES)
-  IF(${${PROJECT_NAME}_ENABLE_TESTS})
-    FOREACH(TEST_DIR ${ARGN})
-      ADD_SUBDIRECTORY(${TEST_DIR})
-    ENDFOREACH()
-  ENDIF()
-ENDMACRO()
-
-MACRO(TRIBITS_ADD_EXAMPLE_DIRECTORIES)
-  IF(${PACKAGE_NAME}_ENABLE_EXAMPLES OR ${PARENT_PACKAGE_NAME}_ENABLE_EXAMPLES)
-    FOREACH(EXAMPLE_DIR ${ARGN})
-      ADD_SUBDIRECTORY(${EXAMPLE_DIR})
-    ENDFOREACH()
-  ENDIF()
-ENDMACRO()
-
-
-function(INCLUDE_DIRECTORIES)
-  cmake_parse_arguments(INCLUDE_DIRECTORIES "REQUIRED_DURING_INSTALLATION_TESTING" "" "" ${ARGN})
-  _INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES_UNPARSED_ARGUMENTS})
-endfunction()
-
-
-MACRO(TARGET_TRANSFER_PROPERTY TARGET_NAME PROP_IN PROP_OUT)
-  SET(PROP_VALUES)
-  FOREACH(TARGET_X ${ARGN})
-    LIST(APPEND PROP_VALUES "$<TARGET_PROPERTY:${TARGET_X},${PROP_IN}>")
-  ENDFOREACH()
-  SET_TARGET_PROPERTIES(${TARGET_NAME} PROPERTIES ${PROP_OUT} "${PROP_VALUES}")
-ENDMACRO()
-
-MACRO(ADD_INTERFACE_LIBRARY LIB_NAME)
-  FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp "")
-  ADD_LIBRARY(${LIB_NAME} STATIC ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp)
-  SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES INTERFACE TRUE)
-ENDMACRO()
-
-# Older versions of cmake does not make include directories transitive
-MACRO(TARGET_LINK_AND_INCLUDE_LIBRARIES TARGET_NAME)
-  TARGET_LINK_LIBRARIES(${TARGET_NAME} LINK_PUBLIC ${ARGN})
-  FOREACH(DEP_LIB ${ARGN})
-    TARGET_INCLUDE_DIRECTORIES(${TARGET_NAME} PUBLIC $<TARGET_PROPERTY:${DEP_LIB},INTERFACE_INCLUDE_DIRECTORIES>)
-    TARGET_INCLUDE_DIRECTORIES(${TARGET_NAME} PUBLIC $<TARGET_PROPERTY:${DEP_LIB},INCLUDE_DIRECTORIES>)
-  ENDFOREACH()
-ENDMACRO()
-
-FUNCTION(TRIBITS_ADD_LIBRARY LIBRARY_NAME)
-
-  SET(options STATIC SHARED TESTONLY NO_INSTALL_LIB_OR_HEADERS CUDALIBRARY)
-  SET(oneValueArgs)
-  SET(multiValueArgs HEADERS HEADERS_INSTALL_SUBDIR NOINSTALLHEADERS SOURCES DEPLIBS IMPORTEDLIBS DEFINES ADDED_LIB_TARGET_NAME_OUT)
-
-  CMAKE_PARSE_ARGUMENTS(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  IF(PARSE_HEADERS)
-    LIST(REMOVE_DUPLICATES PARSE_HEADERS)
-  ENDIF()
-  IF(PARSE_SOURCES)
-    LIST(REMOVE_DUPLICATES PARSE_SOURCES)
-  ENDIF()
-
-  # Local variable to hold all of the libraries that will be directly linked
-  # to this library.
-  SET(LINK_LIBS ${${PACKAGE_NAME}_DEPS})
-
-  # Add dependent libraries passed directly in
-
-  IF (PARSE_IMPORTEDLIBS)
-    LIST(APPEND LINK_LIBS ${PARSE_IMPORTEDLIBS})
-  ENDIF()
-
-  IF (PARSE_DEPLIBS)
-    LIST(APPEND LINK_LIBS ${PARSE_DEPLIBS})
-  ENDIF()
-
-  # Add the library and all the dependencies
-
-  IF (PARSE_DEFINES)
-    ADD_DEFINITIONS(${PARSE_DEFINES})
-  ENDIF()
-
-  IF (PARSE_STATIC)
-    SET(STATIC_KEYWORD "STATIC")
-  ELSE()
-    SET(STATIC_KEYWORD)
-  ENDIF()
-
-  IF (PARSE_SHARED)
-    SET(SHARED_KEYWORD "SHARED")
-  ELSE()
-    SET(SHARED_KEYWORD)
-  ENDIF()
-
-  IF (PARSE_TESTONLY)
-    SET(EXCLUDE_FROM_ALL_KEYWORD "EXCLUDE_FROM_ALL")
-  ELSE()
-    SET(EXCLUDE_FROM_ALL_KEYWORD)
-  ENDIF()
-  IF (NOT PARSE_CUDALIBRARY)
-    ADD_LIBRARY(
-      ${LIBRARY_NAME}
-      ${STATIC_KEYWORD}
-      ${SHARED_KEYWORD}
-      ${EXCLUDE_FROM_ALL_KEYWORD}
-      ${PARSE_HEADERS}
-      ${PARSE_NOINSTALLHEADERS}
-      ${PARSE_SOURCES}
-      )
-  ELSE()
-    CUDA_ADD_LIBRARY(
-      ${LIBRARY_NAME}
-      ${PARSE_HEADERS}
-      ${PARSE_NOINSTALLHEADERS}
-      ${PARSE_SOURCES}
-      )
-  ENDIF()
-
-  TARGET_LINK_AND_INCLUDE_LIBRARIES(${LIBRARY_NAME} ${LINK_LIBS})
-
-  IF (NOT PARSE_TESTONLY OR PARSE_NO_INSTALL_LIB_OR_HEADERS)
-
-    INSTALL(
-      TARGETS ${LIBRARY_NAME}
-      EXPORT ${PROJECT_NAME}
-      RUNTIME DESTINATION bin
-      LIBRARY DESTINATION lib
-      ARCHIVE DESTINATION lib
-      COMPONENT ${PACKAGE_NAME}
-      )
-
-    INSTALL(
-      FILES  ${PARSE_HEADERS}
-      EXPORT ${PROJECT_NAME}
-      DESTINATION include
-      COMPONENT ${PACKAGE_NAME}
-      )
-
-      INSTALL(
-      DIRECTORY  ${PARSE_HEADERS_INSTALL_SUBDIR}
-      EXPORT ${PROJECT_NAME}
-      DESTINATION include
-      COMPONENT ${PACKAGE_NAME}
-      )
-
-  ENDIF()
-
-  IF (NOT PARSE_TESTONLY)
-    PREPEND_GLOBAL_SET(${PACKAGE_NAME}_LIBS ${LIBRARY_NAME})
-    REMOVE_GLOBAL_DUPLICATES(${PACKAGE_NAME}_LIBS)
-  ENDIF()
-
-ENDFUNCTION()
-
-FUNCTION(TRIBITS_ADD_EXECUTABLE EXE_NAME)
-
-  SET(options NOEXEPREFIX NOEXESUFFIX ADD_DIR_TO_NAME INSTALLABLE TESTONLY)
-  SET(oneValueArgs ADDED_EXE_TARGET_NAME_OUT)
-  SET(multiValueArgs SOURCES CATEGORIES HOST XHOST HOSTTYPE XHOSTTYPE DIRECTORY TESTONLYLIBS IMPORTEDLIBS DEPLIBS COMM LINKER_LANGUAGE TARGET_DEFINES DEFINES)
-
-  CMAKE_PARSE_ARGUMENTS(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  IF (PARSE_TARGET_DEFINES)
-    TARGET_COMPILE_DEFINITIONS(${EXE_NAME} PUBLIC ${PARSE_TARGET_DEFINES})
-  ENDIF()
-
-  SET(LINK_LIBS PACKAGE_${PACKAGE_NAME})
-
-  IF (PARSE_TESTONLYLIBS)
-    LIST(APPEND LINK_LIBS ${PARSE_TESTONLYLIBS})
-  ENDIF()
-
-  IF (PARSE_IMPORTEDLIBS)
-    LIST(APPEND LINK_LIBS ${PARSE_IMPORTEDLIBS})
-  ENDIF()
-
-  SET (EXE_SOURCES)
-  IF(PARSE_DIRECTORY)
-    FOREACH( SOURCE_FILE ${PARSE_SOURCES} )
-      IF(IS_ABSOLUTE ${SOURCE_FILE})
-        SET (EXE_SOURCES ${EXE_SOURCES} ${SOURCE_FILE})
-      ELSE()
-        SET (EXE_SOURCES ${EXE_SOURCES} ${PARSE_DIRECTORY}/${SOURCE_FILE})
-      ENDIF()
-    ENDFOREACH( )
-  ELSE()
-    FOREACH( SOURCE_FILE ${PARSE_SOURCES} )
-      SET (EXE_SOURCES ${EXE_SOURCES} ${SOURCE_FILE})
-    ENDFOREACH( )
-  ENDIF()
-
-  SET(EXE_BINARY_NAME ${EXE_NAME})
-  IF(DEFINED PACKAGE_NAME AND NOT PARSE_NOEXEPREFIX)
-    SET(EXE_BINARY_NAME ${PACKAGE_NAME}_${EXE_BINARY_NAME})
-  ENDIF()
-
-  # IF (PARSE_TESTONLY)
-  #   SET(EXCLUDE_FROM_ALL_KEYWORD "EXCLUDE_FROM_ALL")
-  # ELSE()
-  #   SET(EXCLUDE_FROM_ALL_KEYWORD)
-  # ENDIF()
-  ADD_EXECUTABLE(${EXE_BINARY_NAME} ${EXCLUDE_FROM_ALL_KEYWORD} ${EXE_SOURCES})
-
-  TARGET_LINK_AND_INCLUDE_LIBRARIES(${EXE_BINARY_NAME} ${LINK_LIBS})
-
-  IF(PARSE_ADDED_EXE_TARGET_NAME_OUT)
-    SET(${PARSE_ADDED_EXE_TARGET_NAME_OUT} ${EXE_BINARY_NAME} PARENT_SCOPE)
-  ENDIF()
-
-  IF(PARSE_INSTALLABLE)
-    INSTALL(
-      TARGETS ${EXE_BINARY_NAME}
-      EXPORT ${PROJECT_NAME}
-        DESTINATION bin
-    )
-  ENDIF()
-ENDFUNCTION()
-
-IF(NOT TARGET check)
-  ADD_CUSTOM_TARGET(check COMMAND ${CMAKE_CTEST_COMMAND} -VV -C ${CMAKE_CFG_INTDIR})
-ENDIF()
-
-FUNCTION(TRIBITS_ADD_TEST)
-ENDFUNCTION()
-FUNCTION(TRIBITS_TPL_TENTATIVELY_ENABLE)
-ENDFUNCTION()
-
-FUNCTION(TRIBITS_ADD_ADVANCED_TEST)
-  # TODO Write this
-ENDFUNCTION()
-
-FUNCTION(TRIBITS_ADD_EXECUTABLE_AND_TEST EXE_NAME)
-
-  SET(options STANDARD_PASS_OUTPUT WILL_FAIL)
-  SET(oneValueArgs PASS_REGULAR_EXPRESSION FAIL_REGULAR_EXPRESSION ENVIRONMENT TIMEOUT CATEGORIES ADDED_TESTS_NAMES_OUT ADDED_EXE_TARGET_NAME_OUT)
-  SET(multiValueArgs)
-
-  CMAKE_PARSE_ARGUMENTS(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  TRIBITS_ADD_EXECUTABLE(${EXE_NAME} TESTONLY ADDED_EXE_TARGET_NAME_OUT TEST_NAME ${PARSE_UNPARSED_ARGUMENTS})
-
-  IF(WIN32)
-    ADD_TEST(NAME ${TEST_NAME} WORKING_DIRECTORY ${LIBRARY_OUTPUT_PATH} COMMAND ${TEST_NAME}${CMAKE_EXECUTABLE_SUFFIX})
-  ELSE()
-    ADD_TEST(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
-  ENDIF()
-  ADD_DEPENDENCIES(check ${TEST_NAME})
-
-  IF(PARSE_FAIL_REGULAR_EXPRESSION)
-    SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES FAIL_REGULAR_EXPRESSION ${PARSE_FAIL_REGULAR_EXPRESSION})
-  ENDIF()
-
-  IF(PARSE_PASS_REGULAR_EXPRESSION)
-    SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES PASS_REGULAR_EXPRESSION ${PARSE_PASS_REGULAR_EXPRESSION})
-  ENDIF()
-
-  IF(PARSE_WILL_FAIL)
-    SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES WILL_FAIL ${PARSE_WILL_FAIL})
-  ENDIF()
-
-  IF(PARSE_ADDED_TESTS_NAMES_OUT)
-    SET(${PARSE_ADDED_TESTS_NAMES_OUT} ${TEST_NAME} PARENT_SCOPE)
-  ENDIF()
-
-  IF(PARSE_ADDED_EXE_TARGET_NAME_OUT)
-    SET(${PARSE_ADDED_EXE_TARGET_NAME_OUT} ${TEST_NAME} PARENT_SCOPE)
-  ENDIF()
-
-ENDFUNCTION()
-
-MACRO(TIBITS_CREATE_IMPORTED_TPL_LIBRARY TPL_NAME)
-  ADD_INTERFACE_LIBRARY(TPL_LIB_${TPL_NAME})
-  TARGET_LINK_LIBRARIES(TPL_LIB_${TPL_NAME} LINK_PUBLIC ${TPL_${TPL_NAME}_LIBRARIES})
-  TARGET_INCLUDE_DIRECTORIES(TPL_LIB_${TPL_NAME} INTERFACE ${TPL_${TPL_NAME}_INCLUDE_DIRS})
-ENDMACRO()
-
-FUNCTION(TRIBITS_TPL_FIND_INCLUDE_DIRS_AND_LIBRARIES TPL_NAME)
-
-  SET(options MUST_FIND_ALL_LIBS MUST_FIND_ALL_HEADERS NO_PRINT_ENABLE_SUCCESS_FAIL)
-  SET(oneValueArgs)
-  SET(multiValueArgs REQUIRED_HEADERS REQUIRED_LIBS_NAMES)
-
-  CMAKE_PARSE_ARGUMENTS(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  SET(_${TPL_NAME}_ENABLE_SUCCESS TRUE)
-  IF (PARSE_REQUIRED_LIBS_NAMES)
-    FIND_LIBRARY(TPL_${TPL_NAME}_LIBRARIES NAMES ${PARSE_REQUIRED_LIBS_NAMES})
-    IF(NOT TPL_${TPL_NAME}_LIBRARIES)
-      SET(_${TPL_NAME}_ENABLE_SUCCESS FALSE)
-    ENDIF()
-  ENDIF()
-  IF (PARSE_REQUIRED_HEADERS)
-    FIND_PATH(TPL_${TPL_NAME}_INCLUDE_DIRS NAMES ${PARSE_REQUIRED_HEADERS})
-    IF(NOT TPL_${TPL_NAME}_INCLUDE_DIRS)
-      SET(_${TPL_NAME}_ENABLE_SUCCESS FALSE)
-    ENDIF()
-  ENDIF()
-
-
-  IF (_${TPL_NAME}_ENABLE_SUCCESS)
-    TIBITS_CREATE_IMPORTED_TPL_LIBRARY(${TPL_NAME})
-  ENDIF()
-
-ENDFUNCTION()
-
-#MACRO(TRIBITS_PROCESS_TPL_DEP_FILE TPL_FILE)
-#  GET_FILENAME_COMPONENT(TPL_NAME ${TPL_FILE} NAME_WE)
-#  INCLUDE("${TPL_FILE}")
-#  IF(TARGET TPL_LIB_${TPL_NAME})
-#    MESSAGE(STATUS "Found tpl library: ${TPL_NAME}")
-#    SET(TPL_ENABLE_${TPL_NAME} TRUE)
-#  ELSE()
-#    MESSAGE(STATUS "Tpl library not found: ${TPL_NAME}")
-#    SET(TPL_ENABLE_${TPL_NAME} FALSE)
-#  ENDIF()
-#ENDMACRO()
-
-MACRO(PREPEND_TARGET_SET VARNAME TARGET_NAME TYPE)
-  IF(TYPE STREQUAL "REQUIRED")
-    SET(REQUIRED TRUE)
-  ELSE()
-    SET(REQUIRED FALSE)
-  ENDIF()
-  IF(TARGET ${TARGET_NAME})
-    PREPEND_GLOBAL_SET(${VARNAME} ${TARGET_NAME})
-  ELSE()
-    IF(REQUIRED)
-      MESSAGE(FATAL_ERROR "Missing dependency ${TARGET_NAME}")
-    ENDIF()
-  ENDIF()
-ENDMACRO()
-
-MACRO(TRIBITS_APPEND_PACKAGE_DEPS DEP_LIST TYPE)
-  FOREACH(DEP ${ARGN})
-    PREPEND_GLOBAL_SET(${DEP_LIST} PACKAGE_${DEP})
-  ENDFOREACH()
-ENDMACRO()
-
-MACRO(TRIBITS_APPEND_TPLS_DEPS DEP_LIST TYPE)
-  FOREACH(DEP ${ARGN})
-    PREPEND_TARGET_SET(${DEP_LIST} TPL_LIB_${DEP} ${TYPE})
-  ENDFOREACH()
-ENDMACRO()
-
-MACRO(TRIBITS_ENABLE_TPLS)
-  FOREACH(TPL ${ARGN})
-    IF(TARGET ${TPL})
-      GLOBAL_SET(${PACKAGE_NAME}_ENABLE_${TPL} TRUE)
-    ELSE()
-      GLOBAL_SET(${PACKAGE_NAME}_ENABLE_${TPL} FALSE)
-    ENDIF()
-  ENDFOREACH()
-ENDMACRO()
-
-MACRO(TRIBITS_PACKAGE_DEFINE_DEPENDENCIES)
-
-  SET(options)
-  SET(oneValueArgs)
-  SET(multiValueArgs 
-    LIB_REQUIRED_PACKAGES
-    LIB_OPTIONAL_PACKAGES
-    TEST_REQUIRED_PACKAGES
-    TEST_OPTIONAL_PACKAGES
-    LIB_REQUIRED_TPLS
-    LIB_OPTIONAL_TPLS
-    TEST_REQUIRED_TPLS
-    TEST_OPTIONAL_TPLS
-    REGRESSION_EMAIL_LIST
-    SUBPACKAGES_DIRS_CLASSIFICATIONS_OPTREQS
-  )
-  CMAKE_PARSE_ARGUMENTS(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  GLOBAL_SET(${PACKAGE_NAME}_DEPS "")
-  TRIBITS_APPEND_PACKAGE_DEPS(${PACKAGE_NAME}_DEPS REQUIRED ${PARSE_LIB_REQUIRED_PACKAGES})
-  TRIBITS_APPEND_PACKAGE_DEPS(${PACKAGE_NAME}_DEPS OPTIONAL ${PARSE_LIB_OPTIONAL_PACKAGES})
-  TRIBITS_APPEND_TPLS_DEPS(${PACKAGE_NAME}_DEPS REQUIRED ${PARSE_LIB_REQUIRED_TPLS})
-  TRIBITS_APPEND_TPLS_DEPS(${PACKAGE_NAME}_DEPS OPTIONAL ${PARSE_LIB_OPTIONAL_TPLS})
-
-  GLOBAL_SET(${PACKAGE_NAME}_TEST_DEPS "")
-  TRIBITS_APPEND_PACKAGE_DEPS(${PACKAGE_NAME}_TEST_DEPS REQUIRED ${PARSE_TEST_REQUIRED_PACKAGES})
-  TRIBITS_APPEND_PACKAGE_DEPS(${PACKAGE_NAME}_TEST_DEPS OPTIONAL ${PARSE_TEST_OPTIONAL_PACKAGES})
-  TRIBITS_APPEND_TPLS_DEPS(${PACKAGE_NAME}_TEST_DEPS REQUIRED ${PARSE_TEST_REQUIRED_TPLS})
-  TRIBITS_APPEND_TPLS_DEPS(${PACKAGE_NAME}_TEST_DEPS OPTIONAL ${PARSE_TEST_OPTIONAL_TPLS})
-
-  TRIBITS_ENABLE_TPLS(${PARSE_LIB_REQUIRED_TPLS} ${PARSE_LIB_OPTIONAL_TPLS} ${PARSE_TEST_REQUIRED_TPLS} ${PARSE_TEST_OPTIONAL_TPLS})
-
-ENDMACRO()
-
-MACRO(TRIBITS_SUBPACKAGE NAME)
-  SET(PACKAGE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-  SET(PARENT_PACKAGE_NAME ${PACKAGE_NAME})
-  SET(PACKAGE_NAME ${PACKAGE_NAME}${NAME})
-  STRING(TOUPPER ${PACKAGE_NAME} PACKAGE_NAME_UC)
-  SET(${PACKAGE_NAME}_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-
-  ADD_INTERFACE_LIBRARY(PACKAGE_${PACKAGE_NAME})
-
-  GLOBAL_SET(${PACKAGE_NAME}_LIBS "")
-
-  INCLUDE(${PACKAGE_SOURCE_DIR}/cmake/Dependencies.cmake)
-
-ENDMACRO(TRIBITS_SUBPACKAGE)
-
-MACRO(TRIBITS_SUBPACKAGE_POSTPROCESS)
-  TARGET_LINK_AND_INCLUDE_LIBRARIES(PACKAGE_${PACKAGE_NAME} ${${PACKAGE_NAME}_LIBS})
-ENDMACRO(TRIBITS_SUBPACKAGE_POSTPROCESS)
-
-MACRO(TRIBITS_PACKAGE_DECL NAME)
-
-  SET(PACKAGE_NAME ${NAME})
-  SET(${PACKAGE_NAME}_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-  STRING(TOUPPER ${PACKAGE_NAME} PACKAGE_NAME_UC)
-
-  #SET(TRIBITS_DEPS_DIR "${CMAKE_SOURCE_DIR}/cmake/deps")
-  #FILE(GLOB TPLS_FILES "${TRIBITS_DEPS_DIR}/*.cmake")
-  #FOREACH(TPL_FILE ${TPLS_FILES})
-  #  TRIBITS_PROCESS_TPL_DEP_FILE(${TPL_FILE})
-  #ENDFOREACH()
-
-ENDMACRO()
-
-
-MACRO(TRIBITS_PROCESS_SUBPACKAGES)
-  FILE(GLOB SUBPACKAGES RELATIVE ${CMAKE_SOURCE_DIR} */cmake/Dependencies.cmake)
-  FOREACH(SUBPACKAGE ${SUBPACKAGES})
-    GET_FILENAME_COMPONENT(SUBPACKAGE_CMAKE ${SUBPACKAGE} DIRECTORY)
-    GET_FILENAME_COMPONENT(SUBPACKAGE_DIR ${SUBPACKAGE_CMAKE} DIRECTORY)
-    ADD_SUBDIRECTORY(${CMAKE_BINARY_DIR}/../${SUBPACKAGE_DIR})
-  ENDFOREACH()
-ENDMACRO(TRIBITS_PROCESS_SUBPACKAGES)
-
-MACRO(TRIBITS_PACKAGE_DEF)
-ENDMACRO(TRIBITS_PACKAGE_DEF)
-
-MACRO(TRIBITS_EXCLUDE_AUTOTOOLS_FILES)
-ENDMACRO(TRIBITS_EXCLUDE_AUTOTOOLS_FILES)
-
-MACRO(TRIBITS_EXCLUDE_FILES)
-ENDMACRO(TRIBITS_EXCLUDE_FILES)
-
-MACRO(TRIBITS_PACKAGE_POSTPROCESS)
-ENDMACRO(TRIBITS_PACKAGE_POSTPROCESS)
-
diff --git a/lib/kokkos/containers/CMakeLists.txt b/lib/kokkos/containers/CMakeLists.txt
index c37aa3e3e21e22ef1a1e8160d885d91884d9a62d..2bfaea7a13ebca4d3f971afe36b8935ebed21e13 100644
--- a/lib/kokkos/containers/CMakeLists.txt
+++ b/lib/kokkos/containers/CMakeLists.txt
@@ -1,13 +1,10 @@
-
-
-TRIBITS_SUBPACKAGE(Containers)
-
-
-IF(KOKKOS_HAS_TRILINOS)
-  ADD_SUBDIRECTORY(src)
-ENDIF()
-
-TRIBITS_ADD_TEST_DIRECTORIES(unit_tests)
-TRIBITS_ADD_TEST_DIRECTORIES(performance_tests)
-
-TRIBITS_SUBPACKAGE_POSTPROCESS()
+
+
+KOKKOS_SUBPACKAGE(Containers)
+
+ADD_SUBDIRECTORY(src)
+
+KOKKOS_ADD_TEST_DIRECTORIES(unit_tests)
+KOKKOS_ADD_TEST_DIRECTORIES(performance_tests)
+
+KOKKOS_SUBPACKAGE_POSTPROCESS()
diff --git a/lib/kokkos/containers/performance_tests/CMakeLists.txt b/lib/kokkos/containers/performance_tests/CMakeLists.txt
index 3c6584bc346b9e48a245e39038a99396a10c1a14..ca76808190d43be58fccd9bceb58b9faaa7fc167 100644
--- a/lib/kokkos/containers/performance_tests/CMakeLists.txt
+++ b/lib/kokkos/containers/performance_tests/CMakeLists.txt
@@ -1,49 +1,62 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../src )
-
-IF(NOT KOKKOS_HAS_TRILINOS)
-  IF(KOKKOS_SEPARATE_LIBS)
-    set(TEST_LINK_TARGETS kokkoscore)
-  ELSE()
-    set(TEST_LINK_TARGETS kokkos)
-  ENDIF()
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../src )
+
+IF(Kokkos_ENABLE_CUDA)
+   SET(SOURCES
+     TestMain.cpp 
+     TestCuda.cpp
+     )
+
+   KOKKOS_ADD_TEST_EXECUTABLE( PerfTestExec_Cuda
+                               SOURCES ${SOURCES}
+                             )
+
+   KOKKOS_ADD_TEST( NAME PerformanceTest_Cuda
+                    EXE  PerfTestExec_Cuda
+                  )
 ENDIF()
 
-SET(SOURCES
-  TestMain.cpp 
-  TestCuda.cpp
-  )
-
-IF(Kokkos_ENABLE_Pthread)
-  LIST( APPEND SOURCES TestThreads.cpp)
+IF(Kokkos_ENABLE_PTHREAD)
+   SET(SOURCES
+     TestMain.cpp 
+     TestThreads.cpp
+   )
+   KOKKOS_ADD_TEST_EXECUTABLE( PerfTestExec_Threads
+                               SOURCES ${SOURCES}
+                             )
+
+   KOKKOS_ADD_TEST( NAME PerformanceTest_Threads
+                    EXE  PerfTestExec_Threads
+                  )
 ENDIF()
 
-IF(Kokkos_ENABLE_OpenMP)
-  LIST( APPEND SOURCES TestOpenMP.cpp)
+IF(Kokkos_ENABLE_OPENMP)
+   SET(SOURCES
+     TestMain.cpp 
+     TestOpenMP.cpp
+   )
+   KOKKOS_ADD_TEST_EXECUTABLE( PerfTestExec_OpenMP
+                               SOURCES ${SOURCES}
+                             )
+
+   KOKKOS_ADD_TEST( NAME PerformanceTest_OpenMP
+                    EXE  PerfTestExec_OpenMP
+                  )
 ENDIF()
 
 IF(Kokkos_ENABLE_HPX)
-  LIST( APPEND SOURCES TestHPX.cpp)
+   SET(SOURCES
+     TestMain.cpp 
+     TestHPX.cpp
+   )
+   KOKKOS_ADD_TEST_EXECUTABLE( PerfTestExec_HPX
+                               SOURCES ${SOURCES}
+                             )
+
+   KOKKOS_ADD_TEST( NAME PerformanceTest_HPX
+                    EXE  PerfTestExec_HPX
+                  )
 ENDIF()
 
-# Per #374, we always want to build this test, but we only want to run
-# it as a PERFORMANCE test.  That's why we separate building the test
-# from running the test.
-
-TRIBITS_ADD_EXECUTABLE(
-  PerfTestExec
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-
-TRIBITS_ADD_TEST(
-  PerformanceTest
-  NAME PerfTestExec
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  CATEGORIES PERFORMANCE
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  )
diff --git a/lib/kokkos/containers/performance_tests/TestCuda.cpp b/lib/kokkos/containers/performance_tests/TestCuda.cpp
index 351fb86df3d48836ff45286401e52a6f1f684fd7..697a006c3c05f373cc9bdbcfa1efd18a46f2b516 100644
--- a/lib/kokkos/containers/performance_tests/TestCuda.cpp
+++ b/lib/kokkos/containers/performance_tests/TestCuda.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 
 #include <cstdint>
 #include <string>
@@ -66,45 +67,38 @@
 namespace Performance {
 
 class cuda : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
+ protected:
+  static void SetUpTestCase() {
     std::cout << std::setprecision(5) << std::scientific;
     Kokkos::InitArguments args(-1, -1, 0);
     Kokkos::initialize(args);
   }
-  static void TearDownTestCase()
-  {
-    Kokkos::finalize();
-  }
+  static void TearDownTestCase() { Kokkos::finalize(); }
 };
 
-TEST_F( cuda, dynrankview_perf )
-{
+TEST_F(cuda, dynrankview_perf) {
   std::cout << "Cuda" << std::endl;
   std::cout << " DynRankView vs View: Initialization Only " << std::endl;
-  test_dynrankview_op_perf<Kokkos::Cuda>( 40960 );
+  test_dynrankview_op_perf<Kokkos::Cuda>(40960);
 }
 
-TEST_F( cuda, global_2_local)
-{
+TEST_F(cuda, global_2_local) {
   std::cout << "Cuda" << std::endl;
   std::cout << "size, create, generate, fill, find" << std::endl;
-  for (unsigned i=Performance::begin_id_size; i<=Performance::end_id_size; i *= Performance::id_step)
+  for (unsigned i = Performance::begin_id_size; i <= Performance::end_id_size;
+       i *= Performance::id_step)
     test_global_to_local_ids<Kokkos::Cuda>(i);
 }
 
-TEST_F( cuda, unordered_map_performance_near)
-{
-  Perf::run_performance_tests<Kokkos::Cuda,true>("cuda-near");
+TEST_F(cuda, unordered_map_performance_near) {
+  Perf::run_performance_tests<Kokkos::Cuda, true>("cuda-near");
 }
 
-TEST_F( cuda, unordered_map_performance_far)
-{
-  Perf::run_performance_tests<Kokkos::Cuda,false>("cuda-far");
+TEST_F(cuda, unordered_map_performance_far) {
+  Perf::run_performance_tests<Kokkos::Cuda, false>("cuda-far");
 }
 
-}
+}  // namespace Performance
 #else
 void KOKKOS_CONTAINERS_PERFORMANCE_TESTS_TESTCUDA_PREVENT_EMPTY_LINK_ERROR() {}
-#endif  /* #if defined( KOKKOS_ENABLE_CUDA ) */
+#endif /* #if defined( KOKKOS_ENABLE_CUDA ) */
diff --git a/lib/kokkos/containers/performance_tests/TestDynRankView.hpp b/lib/kokkos/containers/performance_tests/TestDynRankView.hpp
index db6274e0579747079f3274b454ade63ad1a051b3..ee13f7e58ba2bcbf530a2d1234ef43e84ddc3c99 100644
--- a/lib/kokkos/containers/performance_tests/TestDynRankView.hpp
+++ b/lib/kokkos/containers/performance_tests/TestDynRankView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,109 +50,102 @@
 
 #include <impl/Kokkos_Timer.hpp>
 
-// Compare performance of DynRankView to View, specific focus on the parenthesis operators
+// Compare performance of DynRankView to View, specific focus on the parenthesis
+// operators
 
 namespace Performance {
 
-//View functor
+// View functor
 template <typename DeviceType>
 struct InitViewFunctor {
-  typedef Kokkos::View<double***, DeviceType> inviewtype;
+  typedef Kokkos::View<double ***, DeviceType> inviewtype;
   inviewtype _inview;
 
-  InitViewFunctor( inviewtype &inview_ ) : _inview(inview_)
-  {}
+  InitViewFunctor(inviewtype &inview_) : _inview(inview_) {}
 
   KOKKOS_INLINE_FUNCTION
   void operator()(const int i) const {
     for (unsigned j = 0; j < _inview.extent(1); ++j) {
       for (unsigned k = 0; k < _inview.extent(2); ++k) {
-        _inview(i,j,k) = i/2 -j*j + k/3;
+        _inview(i, j, k) = i / 2 - j * j + k / 3;
       }
     }
   }
 
-  struct SumComputationTest
-  {
-    typedef Kokkos::View<double***, DeviceType> inviewtype;
+  struct SumComputationTest {
+    typedef Kokkos::View<double ***, DeviceType> inviewtype;
     inviewtype _inview;
 
-    typedef Kokkos::View<double*, DeviceType> outviewtype;
+    typedef Kokkos::View<double *, DeviceType> outviewtype;
     outviewtype _outview;
 
     KOKKOS_INLINE_FUNCTION
-    SumComputationTest(inviewtype &inview_ , outviewtype &outview_) : _inview(inview_), _outview(outview_) {}
+    SumComputationTest(inviewtype &inview_, outviewtype &outview_)
+        : _inview(inview_), _outview(outview_) {}
 
     KOKKOS_INLINE_FUNCTION
     void operator()(const int i) const {
       for (unsigned j = 0; j < _inview.extent(1); ++j) {
         for (unsigned k = 0; k < _inview.extent(2); ++k) {
-          _outview(i) += _inview(i,j,k) ;
+          _outview(i) += _inview(i, j, k);
         }
       }
     }
   };
-
 };
 
 template <typename DeviceType>
 struct InitStrideViewFunctor {
-  typedef Kokkos::View<double***, Kokkos::LayoutStride, DeviceType> inviewtype;
+  typedef Kokkos::View<double ***, Kokkos::LayoutStride, DeviceType> inviewtype;
   inviewtype _inview;
 
-  InitStrideViewFunctor( inviewtype &inview_ ) : _inview(inview_)
-  {}
+  InitStrideViewFunctor(inviewtype &inview_) : _inview(inview_) {}
 
   KOKKOS_INLINE_FUNCTION
   void operator()(const int i) const {
     for (unsigned j = 0; j < _inview.extent(1); ++j) {
       for (unsigned k = 0; k < _inview.extent(2); ++k) {
-        _inview(i,j,k) = i/2 -j*j + k/3;
+        _inview(i, j, k) = i / 2 - j * j + k / 3;
       }
     }
   }
-
 };
 
 template <typename DeviceType>
 struct InitViewRank7Functor {
-  typedef Kokkos::View<double*******, DeviceType> inviewtype;
+  typedef Kokkos::View<double *******, DeviceType> inviewtype;
   inviewtype _inview;
 
-  InitViewRank7Functor( inviewtype &inview_ ) : _inview(inview_)
-  {}
+  InitViewRank7Functor(inviewtype &inview_) : _inview(inview_) {}
 
   KOKKOS_INLINE_FUNCTION
   void operator()(const int i) const {
     for (unsigned j = 0; j < _inview.extent(1); ++j) {
       for (unsigned k = 0; k < _inview.extent(2); ++k) {
-        _inview(i,j,k,0,0,0,0) = i/2 -j*j + k/3;
+        _inview(i, j, k, 0, 0, 0, 0) = i / 2 - j * j + k / 3;
       }
     }
   }
-
 };
 
-//DynRankView functor
+// DynRankView functor
 template <typename DeviceType>
 struct InitDynRankViewFunctor {
   typedef Kokkos::DynRankView<double, DeviceType> inviewtype;
   inviewtype _inview;
 
-  InitDynRankViewFunctor( inviewtype &inview_ ) : _inview(inview_)
-  {}
+  InitDynRankViewFunctor(inviewtype &inview_) : _inview(inview_) {}
 
   KOKKOS_INLINE_FUNCTION
   void operator()(const int i) const {
     for (unsigned j = 0; j < _inview.extent(1); ++j) {
       for (unsigned k = 0; k < _inview.extent(2); ++k) {
-        _inview(i,j,k) = i/2 -j*j + k/3;
+        _inview(i, j, k) = i / 2 - j * j + k / 3;
       }
     }
   }
 
-  struct SumComputationTest
-  {
+  struct SumComputationTest {
     typedef Kokkos::DynRankView<double, DeviceType> inviewtype;
     inviewtype _inview;
 
@@ -159,108 +153,121 @@ struct InitDynRankViewFunctor {
     outviewtype _outview;
 
     KOKKOS_INLINE_FUNCTION
-    SumComputationTest(inviewtype &inview_ , outviewtype &outview_) : _inview(inview_), _outview(outview_) {}
+    SumComputationTest(inviewtype &inview_, outviewtype &outview_)
+        : _inview(inview_), _outview(outview_) {}
 
     KOKKOS_INLINE_FUNCTION
     void operator()(const int i) const {
       for (unsigned j = 0; j < _inview.extent(1); ++j) {
         for (unsigned k = 0; k < _inview.extent(2); ++k) {
-          _outview(i) += _inview(i,j,k) ;
+          _outview(i) += _inview(i, j, k);
         }
       }
     }
   };
-
 };
 
-
 template <typename DeviceType>
-void test_dynrankview_op_perf( const int par_size )
-{
-
+void test_dynrankview_op_perf(const int par_size) {
   typedef DeviceType execution_space;
   typedef typename execution_space::size_type size_type;
   const size_type dim_2 = 90;
   const size_type dim_3 = 30;
 
-  double elapsed_time_view = 0;
-  double elapsed_time_compview = 0;
+  double elapsed_time_view       = 0;
+  double elapsed_time_compview   = 0;
   double elapsed_time_strideview = 0;
   double elapsed_time_view_rank7 = 0;
-  double elapsed_time_drview = 0;
+  double elapsed_time_drview     = 0;
   double elapsed_time_compdrview = 0;
   Kokkos::Timer timer;
   {
-    Kokkos::View<double***,DeviceType> testview("testview",par_size,dim_2,dim_3);
+    Kokkos::View<double ***, DeviceType> testview("testview", par_size, dim_2,
+                                                  dim_3);
     typedef InitViewFunctor<DeviceType> FunctorType;
 
     timer.reset();
-    Kokkos::RangePolicy<DeviceType> policy(0,par_size);
-    Kokkos::parallel_for( policy , FunctorType(testview) );
+    Kokkos::RangePolicy<DeviceType> policy(0, par_size);
+    Kokkos::parallel_for(policy, FunctorType(testview));
     DeviceType().fence();
     elapsed_time_view = timer.seconds();
     std::cout << " View time (init only): " << elapsed_time_view << std::endl;
 
-
     timer.reset();
-    Kokkos::View<double*,DeviceType> sumview("sumview",par_size);
-    Kokkos::parallel_for( policy , typename FunctorType::SumComputationTest(testview, sumview) );
+    Kokkos::View<double *, DeviceType> sumview("sumview", par_size);
+    Kokkos::parallel_for(
+        policy, typename FunctorType::SumComputationTest(testview, sumview));
     DeviceType().fence();
     elapsed_time_compview = timer.seconds();
-    std::cout << " View sum computation time: " << elapsed_time_view << std::endl;
-
+    std::cout << " View sum computation time: " << elapsed_time_view
+              << std::endl;
 
-    Kokkos::View<double***,Kokkos::LayoutStride, DeviceType> teststrideview = Kokkos::subview(testview, Kokkos::ALL, Kokkos::ALL,Kokkos::ALL);
+    Kokkos::View<double ***, Kokkos::LayoutStride, DeviceType> teststrideview =
+        Kokkos::subview(testview, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL);
     typedef InitStrideViewFunctor<DeviceType> FunctorStrideType;
 
     timer.reset();
-    Kokkos::parallel_for( policy , FunctorStrideType(teststrideview) );
+    Kokkos::parallel_for(policy, FunctorStrideType(teststrideview));
     DeviceType().fence();
     elapsed_time_strideview = timer.seconds();
-    std::cout << " Strided View time (init only): " << elapsed_time_strideview << std::endl;
+    std::cout << " Strided View time (init only): " << elapsed_time_strideview
+              << std::endl;
   }
   {
-    Kokkos::View<double*******,DeviceType> testview("testview",par_size,dim_2,dim_3,1,1,1,1);
+    Kokkos::View<double *******, DeviceType> testview("testview", par_size,
+                                                      dim_2, dim_3, 1, 1, 1, 1);
     typedef InitViewRank7Functor<DeviceType> FunctorType;
 
     timer.reset();
-    Kokkos::RangePolicy<DeviceType> policy(0,par_size);
-    Kokkos::parallel_for( policy , FunctorType(testview) );
+    Kokkos::RangePolicy<DeviceType> policy(0, par_size);
+    Kokkos::parallel_for(policy, FunctorType(testview));
     DeviceType().fence();
     elapsed_time_view_rank7 = timer.seconds();
-    std::cout << " View Rank7 time (init only): " << elapsed_time_view_rank7 << std::endl;
+    std::cout << " View Rank7 time (init only): " << elapsed_time_view_rank7
+              << std::endl;
   }
   {
-    Kokkos::DynRankView<double,DeviceType> testdrview("testdrview",par_size,dim_2,dim_3);
+    Kokkos::DynRankView<double, DeviceType> testdrview("testdrview", par_size,
+                                                       dim_2, dim_3);
     typedef InitDynRankViewFunctor<DeviceType> FunctorType;
 
     timer.reset();
-    Kokkos::RangePolicy<DeviceType> policy(0,par_size);
-    Kokkos::parallel_for( policy , FunctorType(testdrview) );
+    Kokkos::RangePolicy<DeviceType> policy(0, par_size);
+    Kokkos::parallel_for(policy, FunctorType(testdrview));
     DeviceType().fence();
     elapsed_time_drview = timer.seconds();
-    std::cout << " DynRankView time (init only): " << elapsed_time_drview << std::endl;
+    std::cout << " DynRankView time (init only): " << elapsed_time_drview
+              << std::endl;
 
     timer.reset();
-    Kokkos::DynRankView<double,DeviceType> sumview("sumview",par_size);
-    Kokkos::parallel_for( policy , typename FunctorType::SumComputationTest(testdrview, sumview) );
+    Kokkos::DynRankView<double, DeviceType> sumview("sumview", par_size);
+    Kokkos::parallel_for(
+        policy, typename FunctorType::SumComputationTest(testdrview, sumview));
     DeviceType().fence();
     elapsed_time_compdrview = timer.seconds();
-    std::cout << " DynRankView sum computation time: " << elapsed_time_compdrview << std::endl;
-
+    std::cout << " DynRankView sum computation time: "
+              << elapsed_time_compdrview << std::endl;
   }
 
-  std::cout << " Ratio of View to DynRankView time: " << elapsed_time_view / elapsed_time_drview << std::endl; //expect < 1
-  std::cout << " Ratio of View to DynRankView sum computation time: " << elapsed_time_compview / elapsed_time_compdrview << std::endl; //expect < 1
-  std::cout << " Ratio of View to View Rank7  time: " << elapsed_time_view / elapsed_time_view_rank7 << std::endl; //expect < 1
-  std::cout << " Ratio of StrideView to DynRankView time: " << elapsed_time_strideview / elapsed_time_drview << std::endl; //expect < 1
-  std::cout << " Ratio of DynRankView to View Rank7  time: " << elapsed_time_drview / elapsed_time_view_rank7 << std::endl; //expect ?
+  std::cout << " Ratio of View to DynRankView time: "
+            << elapsed_time_view / elapsed_time_drview
+            << std::endl;  // expect < 1
+  std::cout << " Ratio of View to DynRankView sum computation time: "
+            << elapsed_time_compview / elapsed_time_compdrview
+            << std::endl;  // expect < 1
+  std::cout << " Ratio of View to View Rank7  time: "
+            << elapsed_time_view / elapsed_time_view_rank7
+            << std::endl;  // expect < 1
+  std::cout << " Ratio of StrideView to DynRankView time: "
+            << elapsed_time_strideview / elapsed_time_drview
+            << std::endl;  // expect < 1
+  std::cout << " Ratio of DynRankView to View Rank7  time: "
+            << elapsed_time_drview / elapsed_time_view_rank7
+            << std::endl;  // expect ?
 
   timer.reset();
 
-} //end test_dynrankview
-
+}  // end test_dynrankview
 
-} //end Performance
+}  // namespace Performance
 #endif
-
diff --git a/lib/kokkos/containers/performance_tests/TestGlobal2LocalIds.hpp b/lib/kokkos/containers/performance_tests/TestGlobal2LocalIds.hpp
index 98997b32394b7a9d71a1e78e3041993e25bd4193..0d2ee4bc8d0ccff968363e81e3b6bb353a79492f 100644
--- a/lib/kokkos/containers/performance_tests/TestGlobal2LocalIds.hpp
+++ b/lib/kokkos/containers/performance_tests/TestGlobal2LocalIds.hpp
@@ -1,12 +1,13 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -35,7 +36,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
@@ -54,153 +55,137 @@
 namespace Performance {
 
 static const unsigned begin_id_size = 256u;
-static const unsigned end_id_size = 1u << 22;
-static const unsigned id_step = 2u;
+static const unsigned end_id_size   = 1u << 22;
+static const unsigned id_step       = 2u;
 
-union helper
-{
+union helper {
   uint32_t word;
   uint8_t byte[4];
 };
 
-
 template <typename Device>
-struct generate_ids
-{
+struct generate_ids {
   typedef Device execution_space;
   typedef typename execution_space::size_type size_type;
-  typedef Kokkos::View<uint32_t*,execution_space> local_id_view;
+  typedef Kokkos::View<uint32_t*, execution_space> local_id_view;
 
   local_id_view local_2_global;
 
-  generate_ids( local_id_view & ids)
-    : local_2_global(ids)
-  {
+  generate_ids(local_id_view& ids) : local_2_global(ids) {
     Kokkos::parallel_for(local_2_global.extent(0), *this);
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void operator()(size_type i) const
-  {
-
+  void operator()(size_type i) const {
     helper x = {static_cast<uint32_t>(i)};
 
     // shuffle the bytes of i to create a unique, semi-random global_id
     x.word = ~x.word;
 
     uint8_t tmp = x.byte[3];
-    x.byte[3] = x.byte[1];
-    x.byte[1] = tmp;
+    x.byte[3]   = x.byte[1];
+    x.byte[1]   = tmp;
 
-    tmp = x.byte[2];
+    tmp       = x.byte[2];
     x.byte[2] = x.byte[0];
     x.byte[0] = tmp;
 
     local_2_global[i] = x.word;
   }
-
 };
 
 template <typename Device>
-struct fill_map
-{
+struct fill_map {
   typedef Device execution_space;
   typedef typename execution_space::size_type size_type;
-  typedef Kokkos::View<const uint32_t*,execution_space, Kokkos::MemoryRandomAccess> local_id_view;
-  typedef Kokkos::UnorderedMap<uint32_t,size_type,execution_space> global_id_view;
+  typedef Kokkos::View<const uint32_t*, execution_space,
+                       Kokkos::MemoryRandomAccess>
+      local_id_view;
+  typedef Kokkos::UnorderedMap<uint32_t, size_type, execution_space>
+      global_id_view;
 
   global_id_view global_2_local;
   local_id_view local_2_global;
 
-  fill_map( global_id_view gIds, local_id_view lIds)
-    : global_2_local(gIds) , local_2_global(lIds)
-  {
+  fill_map(global_id_view gIds, local_id_view lIds)
+      : global_2_local(gIds), local_2_global(lIds) {
     Kokkos::parallel_for(local_2_global.extent(0), *this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(size_type i) const
-  {
-    global_2_local.insert( local_2_global[i], i);
+  void operator()(size_type i) const {
+    global_2_local.insert(local_2_global[i], i);
   }
-
 };
 
 template <typename Device>
-struct find_test
-{
+struct find_test {
   typedef Device execution_space;
   typedef typename execution_space::size_type size_type;
-  typedef Kokkos::View<const uint32_t*,execution_space, Kokkos::MemoryRandomAccess> local_id_view;
-  typedef Kokkos::UnorderedMap<const uint32_t, const size_type,execution_space> global_id_view;
+  typedef Kokkos::View<const uint32_t*, execution_space,
+                       Kokkos::MemoryRandomAccess>
+      local_id_view;
+  typedef Kokkos::UnorderedMap<const uint32_t, const size_type, execution_space>
+      global_id_view;
 
   global_id_view global_2_local;
   local_id_view local_2_global;
 
   typedef size_t value_type;
 
-  find_test( global_id_view gIds, local_id_view lIds, value_type & num_errors)
-    : global_2_local(gIds) , local_2_global(lIds)
-  {
+  find_test(global_id_view gIds, local_id_view lIds, value_type& num_errors)
+      : global_2_local(gIds), local_2_global(lIds) {
     Kokkos::parallel_reduce(local_2_global.extent(0), *this, num_errors);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init(value_type & v) const
-  { v = 0; }
+  void init(value_type& v) const { v = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join(volatile value_type & dst, volatile value_type const & src) const
-  { dst += src; }
+  void join(volatile value_type& dst, volatile value_type const& src) const {
+    dst += src;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(size_type i, value_type & num_errors) const
-  {
-    uint32_t index = global_2_local.find( local_2_global[i] );
+  void operator()(size_type i, value_type& num_errors) const {
+    uint32_t index = global_2_local.find(local_2_global[i]);
 
-    if ( global_2_local.value_at(index) != i) ++num_errors;
+    if (global_2_local.value_at(index) != i) ++num_errors;
   }
-
 };
 
 template <typename Device>
-void test_global_to_local_ids(unsigned num_ids)
-{
-
+void test_global_to_local_ids(unsigned num_ids) {
   typedef Device execution_space;
   typedef typename execution_space::size_type size_type;
 
-  typedef Kokkos::View<uint32_t*,execution_space> local_id_view;
-  typedef Kokkos::UnorderedMap<uint32_t,size_type,execution_space> global_id_view;
+  typedef Kokkos::View<uint32_t*, execution_space> local_id_view;
+  typedef Kokkos::UnorderedMap<uint32_t, size_type, execution_space>
+      global_id_view;
 
-  //size
+  // size
   std::cout << num_ids << ", ";
 
   double elasped_time = 0;
   Kokkos::Timer timer;
 
   local_id_view local_2_global("local_ids", num_ids);
-  global_id_view global_2_local((3u*num_ids)/2u);
+  global_id_view global_2_local((3u * num_ids) / 2u);
 
-  //create
+  // create
   elasped_time = timer.seconds();
   std::cout << elasped_time << ", ";
   timer.reset();
 
   // generate unique ids
-  {
-    generate_ids<Device> gen(local_2_global);
-  }
+  { generate_ids<Device> gen(local_2_global); }
   Device().fence();
   // generate
   elasped_time = timer.seconds();
   std::cout << elasped_time << ", ";
   timer.reset();
 
-  {
-    fill_map<Device> fill(global_2_local, local_2_global);
-  }
+  { fill_map<Device> fill(global_2_local, local_2_global); }
   Device().fence();
 
   // fill
@@ -208,11 +193,9 @@ void test_global_to_local_ids(unsigned num_ids)
   std::cout << elasped_time << ", ";
   timer.reset();
 
-
   size_t num_errors = 0;
-  for (int i=0; i<100; ++i)
-  {
-    find_test<Device> find(global_2_local, local_2_global,num_errors);
+  for (int i = 0; i < 100; ++i) {
+    find_test<Device> find(global_2_local, local_2_global, num_errors);
   }
   Device().fence();
 
@@ -220,12 +203,9 @@ void test_global_to_local_ids(unsigned num_ids)
   elasped_time = timer.seconds();
   std::cout << elasped_time << std::endl;
 
-  ASSERT_EQ( num_errors, 0u);
+  ASSERT_EQ(num_errors, 0u);
 }
 
+}  // namespace Performance
 
-} // namespace Performance
-
-
-#endif //KOKKOS_TEST_GLOBAL_TO_LOCAL_IDS_HPP
-
+#endif  // KOKKOS_TEST_GLOBAL_TO_LOCAL_IDS_HPP
diff --git a/lib/kokkos/containers/performance_tests/TestHPX.cpp b/lib/kokkos/containers/performance_tests/TestHPX.cpp
index 0f43377cee499f04d14736663c92aa32e49c0a58..48be466bfa9c8f73eac25187a665d46230667faf 100644
--- a/lib/kokkos/containers/performance_tests/TestHPX.cpp
+++ b/lib/kokkos/containers/performance_tests/TestHPX.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_HPX )
+#if defined(KOKKOS_ENABLE_HPX)
 
 #include <gtest/gtest.h>
 
@@ -61,70 +62,63 @@
 #include <string>
 #include <fstream>
 
-
 namespace Performance {
 
 class hpx : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
+ protected:
+  static void SetUpTestCase() {
     std::cout << std::setprecision(5) << std::scientific;
 
     Kokkos::initialize();
-    Kokkos::print_configuration( std::cout );
+    Kokkos::print_configuration(std::cout);
   }
 
-  static void TearDownTestCase()
-  {
-    Kokkos::finalize();
-  }
+  static void TearDownTestCase() { Kokkos::finalize(); }
 };
 
-TEST_F( hpx, dynrankview_perf )
-{
+TEST_F(hpx, dynrankview_perf) {
   std::cout << "HPX" << std::endl;
   std::cout << " DynRankView vs View: Initialization Only " << std::endl;
-  test_dynrankview_op_perf<Kokkos::Experimental::HPX>( 8192 );
+  test_dynrankview_op_perf<Kokkos::Experimental::HPX>(8192);
 }
 
-TEST_F( hpx, global_2_local)
-{
+TEST_F(hpx, global_2_local) {
   std::cout << "HPX" << std::endl;
   std::cout << "size, create, generate, fill, find" << std::endl;
-  for (unsigned i=Performance::begin_id_size; i<=Performance::end_id_size; i *= Performance::id_step)
+  for (unsigned i = Performance::begin_id_size; i <= Performance::end_id_size;
+       i *= Performance::id_step)
     test_global_to_local_ids<Kokkos::Experimental::HPX>(i);
 }
 
-TEST_F( hpx, unordered_map_performance_near)
-{
+TEST_F(hpx, unordered_map_performance_near) {
   unsigned num_hpx = 4;
   std::ostringstream base_file_name;
   base_file_name << "hpx-" << num_hpx << "-near";
-  Perf::run_performance_tests<Kokkos::Experimental::HPX,true>(base_file_name.str());
+  Perf::run_performance_tests<Kokkos::Experimental::HPX, true>(
+      base_file_name.str());
 }
 
-TEST_F( hpx, unordered_map_performance_far)
-{
+TEST_F(hpx, unordered_map_performance_far) {
   unsigned num_hpx = 4;
   std::ostringstream base_file_name;
   base_file_name << "hpx-" << num_hpx << "-far";
-  Perf::run_performance_tests<Kokkos::Experimental::HPX,false>(base_file_name.str());
+  Perf::run_performance_tests<Kokkos::Experimental::HPX, false>(
+      base_file_name.str());
 }
 
-TEST_F( hpx, scatter_view)
-{
+TEST_F(hpx, scatter_view) {
   std::cout << "ScatterView data-duplicated test:\n";
   Perf::test_scatter_view<Kokkos::Experimental::HPX, Kokkos::LayoutRight,
-    Kokkos::Experimental::ScatterDuplicated,
-    Kokkos::Experimental::ScatterNonAtomic>(10, 1000 * 1000);
-//std::cout << "ScatterView atomics test:\n";
-//Perf::test_scatter_view<Kokkos::Experimental::HPX, Kokkos::LayoutRight,
-//  Kokkos::Experimental::ScatterNonDuplicated,
-//  Kokkos::Experimental::ScatterAtomic>(10, 1000 * 1000);
+                          Kokkos::Experimental::ScatterDuplicated,
+                          Kokkos::Experimental::ScatterNonAtomic>(10,
+                                                                  1000 * 1000);
+  // std::cout << "ScatterView atomics test:\n";
+  // Perf::test_scatter_view<Kokkos::Experimental::HPX, Kokkos::LayoutRight,
+  //  Kokkos::Experimental::ScatterNonDuplicated,
+  //  Kokkos::Experimental::ScatterAtomic>(10, 1000 * 1000);
 }
 
-} // namespace test
+}  // namespace Performance
 #else
 void KOKKOS_CONTAINERS_PERFORMANCE_TESTS_TESTHPX_PREVENT_EMPTY_LINK_ERROR() {}
 #endif
-
diff --git a/lib/kokkos/containers/performance_tests/TestMain.cpp b/lib/kokkos/containers/performance_tests/TestMain.cpp
index 217b01a57afccf1bc7658ce41214d77fbffffd67..e3c8edb0457d2cc0bcaffdf0449da008b47d5dcb 100644
--- a/lib/kokkos/containers/performance_tests/TestMain.cpp
+++ b/lib/kokkos/containers/performance_tests/TestMain.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,6 @@
 #include <Kokkos_Macros.hpp>
 
 int main(int argc, char *argv[]) {
-  ::testing::InitGoogleTest(&argc,argv);
+  ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-
diff --git a/lib/kokkos/containers/performance_tests/TestOpenMP.cpp b/lib/kokkos/containers/performance_tests/TestOpenMP.cpp
index e6218074eafd965554c3ebe60136386c488fd882..a9c8639ed4b03eab0eaca89a4139c5262af942eb 100644
--- a/lib/kokkos/containers/performance_tests/TestOpenMP.cpp
+++ b/lib/kokkos/containers/performance_tests/TestOpenMP.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP )
+#if defined(KOKKOS_ENABLE_OPENMP)
 
 #include <gtest/gtest.h>
 
@@ -61,82 +62,72 @@
 #include <string>
 #include <fstream>
 
-
 namespace Performance {
 
 class openmp : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
+ protected:
+  static void SetUpTestCase() {
     std::cout << std::setprecision(5) << std::scientific;
 
     Kokkos::initialize();
-    Kokkos::OpenMP::print_configuration( std::cout );
+    Kokkos::OpenMP::print_configuration(std::cout);
   }
 
-  static void TearDownTestCase()
-  {
-    Kokkos::finalize();
-  }
+  static void TearDownTestCase() { Kokkos::finalize(); }
 };
 
-TEST_F( openmp, dynrankview_perf )
-{
+TEST_F(openmp, dynrankview_perf) {
   std::cout << "OpenMP" << std::endl;
   std::cout << " DynRankView vs View: Initialization Only " << std::endl;
-  test_dynrankview_op_perf<Kokkos::OpenMP>( 8192 );
+  test_dynrankview_op_perf<Kokkos::OpenMP>(8192);
 }
 
-TEST_F( openmp, global_2_local)
-{
+TEST_F(openmp, global_2_local) {
   std::cout << "OpenMP" << std::endl;
   std::cout << "size, create, generate, fill, find" << std::endl;
-  for (unsigned i=Performance::begin_id_size; i<=Performance::end_id_size; i *= Performance::id_step)
+  for (unsigned i = Performance::begin_id_size; i <= Performance::end_id_size;
+       i *= Performance::id_step)
     test_global_to_local_ids<Kokkos::OpenMP>(i);
 }
 
-TEST_F( openmp, unordered_map_performance_near)
-{
+TEST_F(openmp, unordered_map_performance_near) {
   unsigned num_openmp = 4;
   if (Kokkos::hwloc::available()) {
     num_openmp = Kokkos::hwloc::get_available_numa_count() *
-                  Kokkos::hwloc::get_available_cores_per_numa() *
-                  Kokkos::hwloc::get_available_threads_per_core();
-
+                 Kokkos::hwloc::get_available_cores_per_numa() *
+                 Kokkos::hwloc::get_available_threads_per_core();
   }
   std::ostringstream base_file_name;
   base_file_name << "openmp-" << num_openmp << "-near";
-  Perf::run_performance_tests<Kokkos::OpenMP,true>(base_file_name.str());
+  Perf::run_performance_tests<Kokkos::OpenMP, true>(base_file_name.str());
 }
 
-TEST_F( openmp, unordered_map_performance_far)
-{
+TEST_F(openmp, unordered_map_performance_far) {
   unsigned num_openmp = 4;
   if (Kokkos::hwloc::available()) {
     num_openmp = Kokkos::hwloc::get_available_numa_count() *
-                  Kokkos::hwloc::get_available_cores_per_numa() *
-                  Kokkos::hwloc::get_available_threads_per_core();
-
+                 Kokkos::hwloc::get_available_cores_per_numa() *
+                 Kokkos::hwloc::get_available_threads_per_core();
   }
   std::ostringstream base_file_name;
   base_file_name << "openmp-" << num_openmp << "-far";
-  Perf::run_performance_tests<Kokkos::OpenMP,false>(base_file_name.str());
+  Perf::run_performance_tests<Kokkos::OpenMP, false>(base_file_name.str());
 }
 
-TEST_F( openmp, scatter_view)
-{
+TEST_F(openmp, scatter_view) {
   std::cout << "ScatterView data-duplicated test:\n";
   Perf::test_scatter_view<Kokkos::OpenMP, Kokkos::LayoutRight,
-    Kokkos::Experimental::ScatterDuplicated,
-    Kokkos::Experimental::ScatterNonAtomic>(10, 1000 * 1000);
-//std::cout << "ScatterView atomics test:\n";
-//Perf::test_scatter_view<Kokkos::OpenMP, Kokkos::LayoutRight,
-//  Kokkos::Experimental::ScatterNonDuplicated,
-//  Kokkos::Experimental::ScatterAtomic>(10, 1000 * 1000);
+                          Kokkos::Experimental::ScatterDuplicated,
+                          Kokkos::Experimental::ScatterNonAtomic>(10,
+                                                                  1000 * 1000);
+  // std::cout << "ScatterView atomics test:\n";
+  // Perf::test_scatter_view<Kokkos::OpenMP, Kokkos::LayoutRight,
+  //  Kokkos::Experimental::ScatterNonDuplicated,
+  //  Kokkos::Experimental::ScatterAtomic>(10, 1000 * 1000);
 }
 
-} // namespace test
+}  // namespace Performance
 #else
-void KOKKOS_CONTAINERS_PERFORMANCE_TESTS_TESTOPENMP_PREVENT_EMPTY_LINK_ERROR() {}
+void KOKKOS_CONTAINERS_PERFORMANCE_TESTS_TESTOPENMP_PREVENT_EMPTY_LINK_ERROR() {
+}
 #endif
-
diff --git a/lib/kokkos/containers/performance_tests/TestROCm.cpp b/lib/kokkos/containers/performance_tests/TestROCm.cpp
index 3cf9f3bd143c5848af12e7ddb717ab8e4d59ce8e..55b770b49cb9bef5ed78003530b421800e66370b 100644
--- a/lib/kokkos/containers/performance_tests/TestROCm.cpp
+++ b/lib/kokkos/containers/performance_tests/TestROCm.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_ROCM )
+#if defined(KOKKOS_ENABLE_ROCM)
 
 #include <cstdint>
 #include <string>
@@ -66,15 +67,14 @@
 namespace Performance {
 
 class rocm : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
+ protected:
+  static void SetUpTestCase() {
     std::cout << std::setprecision(5) << std::scientific;
     Kokkos::HostSpace::execution_space::initialize();
-    Kokkos::Experimental::ROCm::initialize( Kokkos::Experimental::ROCm::SelectDevice(0) );
+    Kokkos::Experimental::ROCm::initialize(
+        Kokkos::Experimental::ROCm::SelectDevice(0));
   }
-  static void TearDownTestCase()
-  {
+  static void TearDownTestCase() {
     Kokkos::Experimental::ROCm::finalize();
     Kokkos::HostSpace::execution_space::finalize();
   }
@@ -97,17 +97,15 @@ TEST_F( rocm, global_2_local)
 }
 
 #endif
-TEST_F( rocm, unordered_map_performance_near)
-{
-  Perf::run_performance_tests<Kokkos::Experimental::ROCm,true>("rocm-near");
+TEST_F(rocm, unordered_map_performance_near) {
+  Perf::run_performance_tests<Kokkos::Experimental::ROCm, true>("rocm-near");
 }
 
-TEST_F( rocm, unordered_map_performance_far)
-{
-  Perf::run_performance_tests<Kokkos::Experimental::ROCm,false>("rocm-far");
+TEST_F(rocm, unordered_map_performance_far) {
+  Perf::run_performance_tests<Kokkos::Experimental::ROCm, false>("rocm-far");
 }
 
-}
+}  // namespace Performance
 #else
 void KOKKOS_CONTAINERS_PERFORMANCE_TESTS_TESTROCM_PREVENT_EMPTY_LINK_ERROR() {}
-#endif  /* #if defined( KOKKOS_ENABLE_ROCM ) */
+#endif /* #if defined( KOKKOS_ENABLE_ROCM ) */
diff --git a/lib/kokkos/containers/performance_tests/TestScatterView.hpp b/lib/kokkos/containers/performance_tests/TestScatterView.hpp
index bd9121bb829a903bc8cb6e78b51668bcc45448e4..3d4c57f3e2c844e21fc0a1a491fc1fe3608c8f2b 100644
--- a/lib/kokkos/containers/performance_tests/TestScatterView.hpp
+++ b/lib/kokkos/containers/performance_tests/TestScatterView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,67 +50,68 @@
 
 namespace Perf {
 
-template <typename ExecSpace, typename Layout, int duplication, int contribution>
-void test_scatter_view(int m, int n)
-{
-  Kokkos::View<double *[3], Layout, ExecSpace> original_view("original_view", n);
+template <typename ExecSpace, typename Layout, int duplication,
+          int contribution>
+void test_scatter_view(int m, int n) {
+  Kokkos::View<double * [3], Layout, ExecSpace> original_view("original_view",
+                                                              n);
   {
-    auto scatter_view = Kokkos::Experimental::create_scatter_view
-      < Kokkos::Experimental::ScatterSum
-      , duplication
-      , contribution
-      > (original_view);
+    auto scatter_view = Kokkos::Experimental::create_scatter_view<
+        Kokkos::Experimental::ScatterSum, duplication, contribution>(
+        original_view);
     Kokkos::Experimental::UniqueToken<
-      ExecSpace, Kokkos::Experimental::UniqueTokenScope::Global>
-      unique_token{ExecSpace()};
-  //auto internal_view = scatter_view.internal_view;
+        ExecSpace, Kokkos::Experimental::UniqueTokenScope::Global>
+        unique_token{ExecSpace()};
+    // auto internal_view = scatter_view.internal_view;
     auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
     for (int foo = 0; foo < 5; ++foo) {
-    {
-      auto num_threads = unique_token.size();
-      std::cout << "num_threads " << num_threads << '\n';
-      Kokkos::View<double **[3], Layout, ExecSpace> hand_coded_duplicate_view("hand_coded_duplicate", num_threads, n);
-      auto f2 = KOKKOS_LAMBDA(int i) {
-        auto thread_id = unique_token.acquire();
-        for (int j = 0; j < 10; ++j) {
-          auto k = (i + j) % n;
-          hand_coded_duplicate_view(thread_id, k, 0) += 4.2;
-          hand_coded_duplicate_view(thread_id, k, 1) += 2.0;
-          hand_coded_duplicate_view(thread_id, k, 2) += 1.0;
+      {
+        auto num_threads = unique_token.size();
+        std::cout << "num_threads " << num_threads << '\n';
+        Kokkos::View<double* * [3], Layout, ExecSpace>
+            hand_coded_duplicate_view("hand_coded_duplicate", num_threads, n);
+        auto f2 = KOKKOS_LAMBDA(int i) {
+          auto thread_id = unique_token.acquire();
+          for (int j = 0; j < 10; ++j) {
+            auto k = (i + j) % n;
+            hand_coded_duplicate_view(thread_id, k, 0) += 4.2;
+            hand_coded_duplicate_view(thread_id, k, 1) += 2.0;
+            hand_coded_duplicate_view(thread_id, k, 2) += 1.0;
+          }
+        };
+        Kokkos::Timer timer;
+        timer.reset();
+        for (int k = 0; k < m; ++k) {
+          Kokkos::parallel_for(policy, f2,
+                               "hand_coded_duplicate_scatter_view_test");
         }
-      };
-      Kokkos::Timer timer;
-      timer.reset();
-      for (int k = 0; k < m; ++k) {
-        Kokkos::parallel_for(policy, f2, "hand_coded_duplicate_scatter_view_test");
+        Kokkos::fence();
+        auto t = timer.seconds();
+        std::cout << "hand-coded test took " << t << " seconds\n";
       }
-      Kokkos::fence();
-      auto t = timer.seconds();
-      std::cout << "hand-coded test took " << t << " seconds\n";
-    }
-    {
-      auto f = KOKKOS_LAMBDA(int i) {
-        auto scatter_access = scatter_view.access();
-        for (int j = 0; j < 10; ++j) {
-          auto k = (i + j) % n;
-          scatter_access(k, 0) += 4.2;
-          scatter_access(k, 1) += 2.0;
-          scatter_access(k, 2) += 1.0;
+      {
+        auto f = KOKKOS_LAMBDA(int i) {
+          auto scatter_access = scatter_view.access();
+          for (int j = 0; j < 10; ++j) {
+            auto k = (i + j) % n;
+            scatter_access(k, 0) += 4.2;
+            scatter_access(k, 1) += 2.0;
+            scatter_access(k, 2) += 1.0;
+          }
+        };
+        Kokkos::Timer timer;
+        timer.reset();
+        for (int k = 0; k < m; ++k) {
+          Kokkos::parallel_for(policy, f, "scatter_view_test");
         }
-      };
-      Kokkos::Timer timer;
-      timer.reset();
-      for (int k = 0; k < m; ++k) {
-        Kokkos::parallel_for(policy, f, "scatter_view_test");
+        Kokkos::fence();
+        auto t = timer.seconds();
+        std::cout << "test took " << t << " seconds\n";
       }
-      Kokkos::fence();
-      auto t = timer.seconds();
-      std::cout << "test took " << t << " seconds\n";
     }
   }
-  }
 }
 
-}
+}  // namespace Perf
 
 #endif
diff --git a/lib/kokkos/containers/performance_tests/TestThreads.cpp b/lib/kokkos/containers/performance_tests/TestThreads.cpp
index 6a02e67b252781f7320223ad8fb87cadfef3355e..2f3740453966700655e37ecbf1e46552d7b18ae7 100644
--- a/lib/kokkos/containers/performance_tests/TestThreads.cpp
+++ b/lib/kokkos/containers/performance_tests/TestThreads.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 
 #include <gtest/gtest.h>
 
@@ -65,9 +66,8 @@
 namespace Performance {
 
 class threads : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
+ protected:
+  static void SetUpTestCase() {
     std::cout << std::setprecision(5) << std::scientific;
 
     unsigned num_threads = 4;
@@ -76,66 +76,57 @@ protected:
       num_threads = Kokkos::hwloc::get_available_numa_count() *
                     Kokkos::hwloc::get_available_cores_per_numa() *
                     Kokkos::hwloc::get_available_threads_per_core();
-
     }
 
     std::cout << "Threads: " << num_threads << std::endl;
 
-    Kokkos::initialize( Kokkos::InitArguments(num_threads) );
+    Kokkos::initialize(Kokkos::InitArguments(num_threads));
   }
 
-  static void TearDownTestCase()
-  {
-    Kokkos::finalize();
-  }
+  static void TearDownTestCase() { Kokkos::finalize(); }
 };
 
-TEST_F( threads, dynrankview_perf )
-{
+TEST_F(threads, dynrankview_perf) {
   std::cout << "Threads" << std::endl;
   std::cout << " DynRankView vs View: Initialization Only " << std::endl;
-  test_dynrankview_op_perf<Kokkos::Threads>( 8192 );
+  test_dynrankview_op_perf<Kokkos::Threads>(8192);
 }
 
-TEST_F( threads, global_2_local)
-{
+TEST_F(threads, global_2_local) {
   std::cout << "Threads" << std::endl;
   std::cout << "size, create, generate, fill, find" << std::endl;
-  for (unsigned i=Performance::begin_id_size; i<=Performance::end_id_size; i *= Performance::id_step)
+  for (unsigned i = Performance::begin_id_size; i <= Performance::end_id_size;
+       i *= Performance::id_step)
     test_global_to_local_ids<Kokkos::Threads>(i);
 }
 
-TEST_F( threads, unordered_map_performance_near)
-{
+TEST_F(threads, unordered_map_performance_near) {
   unsigned num_threads = 4;
   if (Kokkos::hwloc::available()) {
     num_threads = Kokkos::hwloc::get_available_numa_count() *
                   Kokkos::hwloc::get_available_cores_per_numa() *
                   Kokkos::hwloc::get_available_threads_per_core();
-
   }
   std::ostringstream base_file_name;
   base_file_name << "threads-" << num_threads << "-near";
-  Perf::run_performance_tests<Kokkos::Threads,true>(base_file_name.str());
+  Perf::run_performance_tests<Kokkos::Threads, true>(base_file_name.str());
 }
 
-TEST_F( threads, unordered_map_performance_far)
-{
+TEST_F(threads, unordered_map_performance_far) {
   unsigned num_threads = 4;
   if (Kokkos::hwloc::available()) {
     num_threads = Kokkos::hwloc::get_available_numa_count() *
                   Kokkos::hwloc::get_available_cores_per_numa() *
                   Kokkos::hwloc::get_available_threads_per_core();
-
   }
   std::ostringstream base_file_name;
   base_file_name << "threads-" << num_threads << "-far";
-  Perf::run_performance_tests<Kokkos::Threads,false>(base_file_name.str());
+  Perf::run_performance_tests<Kokkos::Threads, false>(base_file_name.str());
 }
 
-} // namespace Performance
+}  // namespace Performance
 
 #else
-void KOKKOS_CONTAINERS_PERFORMANCE_TESTS_TESTTHREADS_PREVENT_EMPTY_LINK_ERROR() {}
+void KOKKOS_CONTAINERS_PERFORMANCE_TESTS_TESTTHREADS_PREVENT_EMPTY_LINK_ERROR() {
+}
 #endif
-
diff --git a/lib/kokkos/containers/performance_tests/TestUnorderedMapPerformance.hpp b/lib/kokkos/containers/performance_tests/TestUnorderedMapPerformance.hpp
index 8d09281ed36cc99690c40784397a448cf1c8e1d8..9057842340bc7bfd6f59f57b35b5c9536918d554 100644
--- a/lib/kokkos/containers/performance_tests/TestUnorderedMapPerformance.hpp
+++ b/lib/kokkos/containers/performance_tests/TestUnorderedMapPerformance.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,12 +51,10 @@
 #include <string>
 #include <sstream>
 
-
 namespace Perf {
 
 template <typename Device, bool Near>
-struct UnorderedMapTest
-{
+struct UnorderedMapTest {
   typedef Device execution_space;
   typedef Kokkos::UnorderedMap<uint32_t, uint32_t, execution_space> map_type;
   typedef typename map_type::histogram_type histogram_type;
@@ -68,22 +67,22 @@ struct UnorderedMapTest
   uint32_t capacity;
   uint32_t inserts;
   uint32_t collisions;
-  double   seconds;
+  double seconds;
   map_type map;
   histogram_type histogram;
 
-  UnorderedMapTest( uint32_t arg_capacity, uint32_t arg_inserts, uint32_t arg_collisions)
-    : capacity(arg_capacity)
-    , inserts(arg_inserts)
-    , collisions(arg_collisions)
-    , seconds(0)
-    , map(capacity)
-    , histogram(map.get_histogram())
-  {
-    Kokkos::Timer wall_clock ;
+  UnorderedMapTest(uint32_t arg_capacity, uint32_t arg_inserts,
+                   uint32_t arg_collisions)
+      : capacity(arg_capacity),
+        inserts(arg_inserts),
+        collisions(arg_collisions),
+        seconds(0),
+        map(capacity),
+        histogram(map.get_histogram()) {
+    Kokkos::Timer wall_clock;
     wall_clock.reset();
 
-    value_type v = {};
+    value_type v   = {};
     int loop_count = 0;
     do {
       ++loop_count;
@@ -92,81 +91,79 @@ struct UnorderedMapTest
       Kokkos::parallel_reduce(inserts, *this, v);
 
       if (v.failed_count > 0u) {
-        const uint32_t new_capacity = map.capacity() + ((map.capacity()*3ull)/20u) + v.failed_count/collisions ;
-        map.rehash( new_capacity );
+        const uint32_t new_capacity = map.capacity() +
+                                      ((map.capacity() * 3ull) / 20u) +
+                                      v.failed_count / collisions;
+        map.rehash(new_capacity);
       }
     } while (v.failed_count > 0u);
 
     seconds = wall_clock.seconds();
 
-    switch (loop_count)
-    {
-    case 1u: std::cout << " \033[0;32m" << loop_count << "\033[0m "; break;
-    case 2u: std::cout << " \033[1;31m" << loop_count << "\033[0m "; break;
-    default: std::cout << " \033[0;31m" << loop_count << "\033[0m "; break;
+    switch (loop_count) {
+      case 1u: std::cout << " \033[0;32m" << loop_count << "\033[0m "; break;
+      case 2u: std::cout << " \033[1;31m" << loop_count << "\033[0m "; break;
+      default: std::cout << " \033[0;31m" << loop_count << "\033[0m "; break;
     }
-    std::cout << std::setprecision(2) << std::fixed << std::setw(5) << (1e9*(seconds/(inserts))) << "; " << std::flush;
+    std::cout << std::setprecision(2) << std::fixed << std::setw(5)
+              << (1e9 * (seconds / (inserts))) << "; " << std::flush;
 
     histogram.calculate();
     Device().fence();
   }
 
-  void print(std::ostream & metrics_out, std::ostream & length_out, std::ostream & distance_out, std::ostream & block_distance_out)
-  {
+  void print(std::ostream& metrics_out, std::ostream& length_out,
+             std::ostream& distance_out, std::ostream& block_distance_out) {
     metrics_out << map.capacity() << " , ";
-    metrics_out << inserts/collisions << " , ";
-    metrics_out << (100.0 * inserts/collisions) / map.capacity() << " , ";
+    metrics_out << inserts / collisions << " , ";
+    metrics_out << (100.0 * inserts / collisions) / map.capacity() << " , ";
     metrics_out << inserts << " , ";
     metrics_out << (map.failed_insert() ? "true" : "false") << " , ";
     metrics_out << collisions << " , ";
-    metrics_out << 1e9*(seconds/inserts) << " , ";
+    metrics_out << 1e9 * (seconds / inserts) << " , ";
     metrics_out << seconds << std::endl;
 
     length_out << map.capacity() << " , ";
-    length_out << ((100.0 *inserts/collisions) / map.capacity()) << " , ";
+    length_out << ((100.0 * inserts / collisions) / map.capacity()) << " , ";
     length_out << collisions << " , ";
     histogram.print_length(length_out);
 
     distance_out << map.capacity() << " , ";
-    distance_out << ((100.0 *inserts/collisions) / map.capacity()) << " , ";
+    distance_out << ((100.0 * inserts / collisions) / map.capacity()) << " , ";
     distance_out << collisions << " , ";
     histogram.print_distance(distance_out);
 
     block_distance_out << map.capacity() << " , ";
-    block_distance_out << ((100.0 *inserts/collisions) / map.capacity()) << " , ";
+    block_distance_out << ((100.0 * inserts / collisions) / map.capacity())
+                       << " , ";
     block_distance_out << collisions << " , ";
     histogram.print_block_distance(block_distance_out);
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & v ) const
-  {
+  void init(value_type& v) const {
     v.failed_count = 0;
-    v.max_list = 0;
+    v.max_list     = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & dst, const volatile value_type & src ) const
-  {
+  void join(volatile value_type& dst, const volatile value_type& src) const {
     dst.failed_count += src.failed_count;
     dst.max_list = src.max_list < dst.max_list ? dst.max_list : src.max_list;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(uint32_t i, value_type & v) const
-  {
-    const uint32_t key = Near ? i/collisions : i%(inserts/collisions);
-    typename map_type::insert_result result = map.insert(key,i);
+  void operator()(uint32_t i, value_type& v) const {
+    const uint32_t key = Near ? i / collisions : i % (inserts / collisions);
+    typename map_type::insert_result result = map.insert(key, i);
     v.failed_count += !result.failed() ? 0 : 1;
-    v.max_list = result.list_position() < v.max_list ? v.max_list : result.list_position();
+    v.max_list = result.list_position() < v.max_list ? v.max_list
+                                                     : result.list_position();
   }
-
 };
 
 template <typename Device, bool Near>
-void run_performance_tests(std::string const & base_file_name)
-{
+void run_performance_tests(std::string const& base_file_name) {
 #if 0
   std::string metrics_file_name = base_file_name + std::string("-metrics.csv");
   std::string length_file_name = base_file_name  + std::string("-length.csv");
@@ -254,7 +251,6 @@ void run_performance_tests(std::string const & base_file_name)
 #endif
 }
 
+}  // namespace Perf
 
-} // namespace Perf
-
-#endif //KOKKOS_TEST_UNORDERED_MAP_PERFORMANCE_HPP
+#endif  // KOKKOS_TEST_UNORDERED_MAP_PERFORMANCE_HPP
diff --git a/lib/kokkos/containers/src/CMakeLists.txt b/lib/kokkos/containers/src/CMakeLists.txt
index e68fcad5e945fce8010cd3b0a6ff62298eb77de0..0c9d24d641bb61d99514a0a78a8405f5b7a86f3d 100644
--- a/lib/kokkos/containers/src/CMakeLists.txt
+++ b/lib/kokkos/containers/src/CMakeLists.txt
@@ -1,47 +1,34 @@
-
-TRIBITS_CONFIGURE_FILE(${PACKAGE_NAME}_config.h)
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-#-----------------------------------------------------------------------------
-
-SET(TRILINOS_INCDIR ${CMAKE_INSTALL_PREFIX}/${${PROJECT_NAME}_INSTALL_INCLUDE_DIR})
-
-if(KOKKOS_LEGACY_TRIBITS)
-
-  SET(HEADERS "")
-  SET(SOURCES "")
-
-  SET(HEADERS_IMPL "")
-
-  FILE(GLOB HEADERS *.hpp)
-  FILE(GLOB HEADERS_IMPL impl/*.hpp)
-  FILE(GLOB SOURCES impl/*.cpp)
-
-  INSTALL(FILES ${HEADERS_IMPL} DESTINATION ${TRILINOS_INCDIR}/impl/)
-
-  TRIBITS_ADD_LIBRARY(
-      kokkoscontainers
-      HEADERS ${HEADERS}
-      NOINSTALLHEADERS ${HEADERS_IMPL}
-      SOURCES ${SOURCES}
-      DEPLIBS
-      )
-
-else()
-
-  INSTALL (
-      DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/"
-      DESTINATION ${TRILINOS_INCDIR}
-      FILES_MATCHING PATTERN "*.hpp"
-      )
-
-  TRIBITS_ADD_LIBRARY(
-      kokkoscontainers
-      SOURCES ${KOKKOS_CONTAINERS_SRCS}
-      DEPLIBS
-      )
-
-endif()
-#-----------------------------------------------------------------------------
+
+KOKKOS_CONFIGURE_FILE(${PACKAGE_NAME}_config.h)
+
+#need these here for now
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+
+#-----------------------------------------------------------------------------
+
+SET(KOKKOS_CONTAINERS_SRCS)
+APPEND_GLOB(KOKKOS_CONTAINERS_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/impl/*.cpp)
+
+INSTALL (
+  DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/"
+  DESTINATION ${KOKKOS_HEADER_DIR}
+  FILES_MATCHING PATTERN "*.hpp"
+)
+
+KOKKOS_ADD_LIBRARY(
+  kokkoscontainers
+  SOURCES ${KOKKOS_CONTAINERS_SRCS}
+)
+
+SET_TARGET_PROPERTIES(kokkoscontainers PROPERTIES VERSION ${Kokkos_VERSION})
+
+KOKKOS_LIB_INCLUDE_DIRECTORIES(kokkoscontainers
+  ${KOKKOS_TOP_BUILD_DIR}
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+KOKKOS_LINK_INTERNAL_LIBRARY(kokkoscontainers kokkoscore)
+
+#-----------------------------------------------------------------------------
+
diff --git a/lib/kokkos/containers/src/Kokkos_Bitset.hpp b/lib/kokkos/containers/src/Kokkos_Bitset.hpp
index 4d78430fc634ed7dad2a904a4dc5282e16501637..3596c7653ac1de08f748ef35de2070af4f16630f 100644
--- a/lib/kokkos/containers/src/Kokkos_Bitset.hpp
+++ b/lib/kokkos/containers/src/Kokkos_Bitset.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,27 +54,25 @@
 
 namespace Kokkos {
 
-template <typename Device = Kokkos::DefaultExecutionSpace >
+template <typename Device = Kokkos::DefaultExecutionSpace>
 class Bitset;
 
-template <typename Device = Kokkos::DefaultExecutionSpace >
+template <typename Device = Kokkos::DefaultExecutionSpace>
 class ConstBitset;
 
 template <typename DstDevice, typename SrcDevice>
-void deep_copy( Bitset<DstDevice> & dst, Bitset<SrcDevice> const& src);
+void deep_copy(Bitset<DstDevice>& dst, Bitset<SrcDevice> const& src);
 
 template <typename DstDevice, typename SrcDevice>
-void deep_copy( Bitset<DstDevice> & dst, ConstBitset<SrcDevice> const& src);
+void deep_copy(Bitset<DstDevice>& dst, ConstBitset<SrcDevice> const& src);
 
 template <typename DstDevice, typename SrcDevice>
-void deep_copy( ConstBitset<DstDevice> & dst, ConstBitset<SrcDevice> const& src);
-
+void deep_copy(ConstBitset<DstDevice>& dst, ConstBitset<SrcDevice> const& src);
 
 /// A thread safe view to a bitset
 template <typename Device>
-class Bitset
-{
-public:
+class Bitset {
+ public:
   typedef Device execution_space;
   typedef unsigned size_type;
 
@@ -81,98 +80,88 @@ public:
   enum { MOVE_HINT_BACKWARD = 2u };
 
   enum {
-      BIT_SCAN_FORWARD_MOVE_HINT_FORWARD = 0u
-    , BIT_SCAN_REVERSE_MOVE_HINT_FORWARD = BIT_SCAN_REVERSE
-    , BIT_SCAN_FORWARD_MOVE_HINT_BACKWARD = MOVE_HINT_BACKWARD
-    , BIT_SCAN_REVERSE_MOVE_HINT_BACKWARD = BIT_SCAN_REVERSE | MOVE_HINT_BACKWARD
+    BIT_SCAN_FORWARD_MOVE_HINT_FORWARD  = 0u,
+    BIT_SCAN_REVERSE_MOVE_HINT_FORWARD  = BIT_SCAN_REVERSE,
+    BIT_SCAN_FORWARD_MOVE_HINT_BACKWARD = MOVE_HINT_BACKWARD,
+    BIT_SCAN_REVERSE_MOVE_HINT_BACKWARD = BIT_SCAN_REVERSE | MOVE_HINT_BACKWARD
   };
 
-private:
-  enum { block_size = static_cast<unsigned>(sizeof(unsigned)*CHAR_BIT) };
-  enum { block_mask = block_size-1u };
+ private:
+  enum { block_size = static_cast<unsigned>(sizeof(unsigned) * CHAR_BIT) };
+  enum { block_mask = block_size - 1u };
   enum { block_shift = Kokkos::Impl::integral_power_of_two(block_size) };
 
-public:
-
-
+ public:
   /// constructor
   /// arg_size := number of bit in set
   Bitset(unsigned arg_size = 0u)
-    : m_size(arg_size)
-    , m_last_block_mask(0u)
-    , m_blocks("Bitset", ((m_size + block_mask) >> block_shift) )
-  {
-    for (int i=0, end = static_cast<int>(m_size & block_mask); i < end; ++i) {
+      : m_size(arg_size),
+        m_last_block_mask(0u),
+        m_blocks("Bitset", ((m_size + block_mask) >> block_shift)) {
+    for (int i = 0, end = static_cast<int>(m_size & block_mask); i < end; ++i) {
       m_last_block_mask |= 1u << i;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  Bitset (const Bitset<Device>&) = default;
+  Bitset(const Bitset<Device>&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  Bitset& operator= (const Bitset<Device>&) = default;
+  Bitset& operator=(const Bitset<Device>&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  Bitset (Bitset<Device>&&) = default;
+  Bitset(Bitset<Device>&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  Bitset& operator= (Bitset<Device>&&) = default;
-  
+  Bitset& operator=(Bitset<Device>&&) = default;
+
   KOKKOS_INLINE_FUNCTION
-  ~Bitset () = default;
+  ~Bitset() = default;
 
   /// number of bits in the set
   /// can be call from the host or the device
   KOKKOS_FORCEINLINE_FUNCTION
-  unsigned size() const
-  { return m_size; }
+  unsigned size() const { return m_size; }
 
   /// number of bits which are set to 1
   /// can only be called from the host
-  unsigned count() const
-  {
-    Impl::BitsetCount< Bitset<Device> > f(*this);
+  unsigned count() const {
+    Impl::BitsetCount<Bitset<Device> > f(*this);
     return f.apply();
   }
 
   /// set all bits to 1
   /// can only be called from the host
-  void set()
-  {
-    Kokkos::deep_copy(m_blocks, ~0u );
+  void set() {
+    Kokkos::deep_copy(m_blocks, ~0u);
 
     if (m_last_block_mask) {
-      //clear the unused bits in the last block
-      typedef Kokkos::Impl::DeepCopy< typename execution_space::memory_space, Kokkos::HostSpace > raw_deep_copy;
-      raw_deep_copy( m_blocks.data() + (m_blocks.extent(0) -1u), &m_last_block_mask, sizeof(unsigned));
+      // clear the unused bits in the last block
+      typedef Kokkos::Impl::DeepCopy<typename execution_space::memory_space,
+                                     Kokkos::HostSpace>
+          raw_deep_copy;
+      raw_deep_copy(m_blocks.data() + (m_blocks.extent(0) - 1u),
+                    &m_last_block_mask, sizeof(unsigned));
     }
   }
 
   /// set all bits to 0
   /// can only be called from the host
-  void reset()
-  {
-    Kokkos::deep_copy(m_blocks, 0u );
-  }
+  void reset() { Kokkos::deep_copy(m_blocks, 0u); }
 
   /// set all bits to 0
   /// can only be called from the host
-  void clear()
-  {
-    Kokkos::deep_copy(m_blocks, 0u );
-  }
+  void clear() { Kokkos::deep_copy(m_blocks, 0u); }
 
   /// set i'th bit to 1
   /// can only be called from the device
   KOKKOS_FORCEINLINE_FUNCTION
-  bool set( unsigned i ) const
-  {
-    if ( i < m_size ) {
-      unsigned * block_ptr = &m_blocks[ i >> block_shift ];
-      const unsigned mask = 1u << static_cast<int>( i & block_mask );
+  bool set(unsigned i) const {
+    if (i < m_size) {
+      unsigned* block_ptr = &m_blocks[i >> block_shift];
+      const unsigned mask = 1u << static_cast<int>(i & block_mask);
 
-      return !( atomic_fetch_or( block_ptr, mask ) & mask );
+      return !(atomic_fetch_or(block_ptr, mask) & mask);
     }
     return false;
   }
@@ -180,13 +169,12 @@ public:
   /// set i'th bit to 0
   /// can only be called from the device
   KOKKOS_FORCEINLINE_FUNCTION
-  bool reset( unsigned i ) const
-  {
-    if ( i < m_size ) {
-      unsigned * block_ptr = &m_blocks[ i >> block_shift ];
-      const unsigned mask = 1u << static_cast<int>( i & block_mask );
+  bool reset(unsigned i) const {
+    if (i < m_size) {
+      unsigned* block_ptr = &m_blocks[i >> block_shift];
+      const unsigned mask = 1u << static_cast<int>(i & block_mask);
 
-      return atomic_fetch_and( block_ptr, ~mask ) & mask;
+      return atomic_fetch_and(block_ptr, ~mask) & mask;
     }
     return false;
   }
@@ -194,11 +182,10 @@ public:
   /// return true if the i'th bit set to 1
   /// can only be called from the device
   KOKKOS_FORCEINLINE_FUNCTION
-  bool test( unsigned i ) const
-  {
-    if ( i < m_size ) {
-      const unsigned block = volatile_load(&m_blocks[ i >> block_shift ]);
-      const unsigned mask = 1u << static_cast<int>( i & block_mask );
+  bool test(unsigned i) const {
+    if (i < m_size) {
+      const unsigned block = volatile_load(&m_blocks[i >> block_shift]);
+      const unsigned mask  = 1u << static_cast<int>(i & block_mask);
       return block & mask;
     }
     return false;
@@ -208,90 +195,93 @@ public:
   /// returns the max number of times those functions should be call
   /// when searching for an available bit
   KOKKOS_FORCEINLINE_FUNCTION
-  unsigned max_hint() const
-  {
-    return m_blocks.extent(0);
-  }
+  unsigned max_hint() const { return m_blocks.extent(0); }
 
   /// find a bit set to 1 near the hint
-  /// returns a pair< bool, unsigned> where if result.first is true then result.second is the bit found
-  /// and if result.first is false the result.second is a new hint
+  /// returns a pair< bool, unsigned> where if result.first is true then
+  /// result.second is the bit found and if result.first is false the
+  /// result.second is a new hint
   KOKKOS_INLINE_FUNCTION
-  Kokkos::pair<bool, unsigned> find_any_set_near( unsigned hint , unsigned scan_direction = BIT_SCAN_FORWARD_MOVE_HINT_FORWARD ) const
-  {
-    const unsigned block_idx = (hint >> block_shift) < m_blocks.extent(0) ? (hint >> block_shift) : 0;
+  Kokkos::pair<bool, unsigned> find_any_set_near(
+      unsigned hint,
+      unsigned scan_direction = BIT_SCAN_FORWARD_MOVE_HINT_FORWARD) const {
+    const unsigned block_idx =
+        (hint >> block_shift) < m_blocks.extent(0) ? (hint >> block_shift) : 0;
     const unsigned offset = hint & block_mask;
-    unsigned block = volatile_load(&m_blocks[ block_idx ]);
-    block = !m_last_block_mask || (block_idx < (m_blocks.extent(0)-1)) ? block : block & m_last_block_mask ;
+    unsigned block        = volatile_load(&m_blocks[block_idx]);
+    block = !m_last_block_mask || (block_idx < (m_blocks.extent(0) - 1))
+                ? block
+                : block & m_last_block_mask;
 
     return find_any_helper(block_idx, offset, block, scan_direction);
   }
 
   /// find a bit set to 0 near the hint
-  /// returns a pair< bool, unsigned> where if result.first is true then result.second is the bit found
-  /// and if result.first is false the result.second is a new hint
+  /// returns a pair< bool, unsigned> where if result.first is true then
+  /// result.second is the bit found and if result.first is false the
+  /// result.second is a new hint
   KOKKOS_INLINE_FUNCTION
-  Kokkos::pair<bool, unsigned> find_any_unset_near( unsigned hint , unsigned scan_direction = BIT_SCAN_FORWARD_MOVE_HINT_FORWARD ) const
-  {
+  Kokkos::pair<bool, unsigned> find_any_unset_near(
+      unsigned hint,
+      unsigned scan_direction = BIT_SCAN_FORWARD_MOVE_HINT_FORWARD) const {
     const unsigned block_idx = hint >> block_shift;
-    const unsigned offset = hint & block_mask;
-    unsigned block = volatile_load(&m_blocks[ block_idx ]);
-    block = !m_last_block_mask || (block_idx < (m_blocks.extent(0)-1) ) ? ~block : ~block & m_last_block_mask ;
+    const unsigned offset    = hint & block_mask;
+    unsigned block           = volatile_load(&m_blocks[block_idx]);
+    block = !m_last_block_mask || (block_idx < (m_blocks.extent(0) - 1))
+                ? ~block
+                : ~block & m_last_block_mask;
 
     return find_any_helper(block_idx, offset, block, scan_direction);
   }
 
-private:
-
+ private:
   KOKKOS_FORCEINLINE_FUNCTION
-  Kokkos::pair<bool, unsigned> find_any_helper(unsigned block_idx, unsigned offset, unsigned block, unsigned scan_direction) const
-  {
-    Kokkos::pair<bool, unsigned> result( block > 0u, 0);
+  Kokkos::pair<bool, unsigned> find_any_helper(unsigned block_idx,
+                                               unsigned offset, unsigned block,
+                                               unsigned scan_direction) const {
+    Kokkos::pair<bool, unsigned> result(block > 0u, 0);
 
     if (!result.first) {
-      result.second = update_hint( block_idx, offset, scan_direction );
-    }
-    else {
-      result.second = scan_block(  (block_idx << block_shift)
-                                 , offset
-                                 , block
-                                 , scan_direction
-                                );
+      result.second = update_hint(block_idx, offset, scan_direction);
+    } else {
+      result.second =
+          scan_block((block_idx << block_shift), offset, block, scan_direction);
     }
     return result;
   }
 
-
   KOKKOS_FORCEINLINE_FUNCTION
-  unsigned scan_block(unsigned block_start, int offset, unsigned block, unsigned scan_direction ) const
-  {
-    offset = !(scan_direction & BIT_SCAN_REVERSE) ? offset : (offset + block_mask) & block_mask;
+  unsigned scan_block(unsigned block_start, int offset, unsigned block,
+                      unsigned scan_direction) const {
+    offset = !(scan_direction & BIT_SCAN_REVERSE)
+                 ? offset
+                 : (offset + block_mask) & block_mask;
     block = Impl::rotate_right(block, offset);
-    return ((( !(scan_direction & BIT_SCAN_REVERSE) ?
-               Impl::bit_scan_forward(block) :
-               ::Kokkos::log2(block)
-             ) + offset
-            ) & block_mask
-           ) + block_start;
+    return (((!(scan_direction & BIT_SCAN_REVERSE)
+                  ? Impl::bit_scan_forward(block)
+                  : ::Kokkos::log2(block)) +
+             offset) &
+            block_mask) +
+           block_start;
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  unsigned update_hint( long long block_idx, unsigned offset, unsigned scan_direction ) const
-  {
+  unsigned update_hint(long long block_idx, unsigned offset,
+                       unsigned scan_direction) const {
     block_idx += scan_direction & MOVE_HINT_BACKWARD ? -1 : 1;
     block_idx = block_idx >= 0 ? block_idx : m_blocks.extent(0) - 1;
-    block_idx = block_idx < static_cast<long long>(m_blocks.extent(0)) ? block_idx : 0;
+    block_idx =
+        block_idx < static_cast<long long>(m_blocks.extent(0)) ? block_idx : 0;
 
-    return static_cast<unsigned>(block_idx)*block_size + offset;
+    return static_cast<unsigned>(block_idx) * block_size + offset;
   }
 
-private:
-
+ private:
   unsigned m_size;
   unsigned m_last_block_mask;
-  View< unsigned *, execution_space, MemoryTraits<RandomAccess> > m_blocks;
+  View<unsigned*, execution_space, MemoryTraits<RandomAccess> > m_blocks;
 
-private:
+ private:
   template <typename DDevice>
   friend class Bitset;
 
@@ -302,87 +292,72 @@ private:
   friend struct Impl::BitsetCount;
 
   template <typename DstDevice, typename SrcDevice>
-  friend void deep_copy( Bitset<DstDevice> & dst, Bitset<SrcDevice> const& src);
+  friend void deep_copy(Bitset<DstDevice>& dst, Bitset<SrcDevice> const& src);
 
   template <typename DstDevice, typename SrcDevice>
-  friend void deep_copy( Bitset<DstDevice> & dst, ConstBitset<SrcDevice> const& src);
+  friend void deep_copy(Bitset<DstDevice>& dst,
+                        ConstBitset<SrcDevice> const& src);
 };
 
 /// a thread-safe view to a const bitset
 /// i.e. can only test bits
 template <typename Device>
-class ConstBitset
-{
-public:
+class ConstBitset {
+ public:
   typedef Device execution_space;
   typedef unsigned size_type;
 
-private:
-  enum { block_size = static_cast<unsigned>(sizeof(unsigned)*CHAR_BIT) };
-  enum { block_mask = block_size -1u };
+ private:
+  enum { block_size = static_cast<unsigned>(sizeof(unsigned) * CHAR_BIT) };
+  enum { block_mask = block_size - 1u };
   enum { block_shift = Kokkos::Impl::integral_power_of_two(block_size) };
 
-public:
-  ConstBitset()
-    : m_size (0)
-  {}
+ public:
+  ConstBitset() : m_size(0) {}
 
   ConstBitset(Bitset<Device> const& rhs)
-    : m_size(rhs.m_size)
-    , m_blocks(rhs.m_blocks)
-  {}
+      : m_size(rhs.m_size), m_blocks(rhs.m_blocks) {}
 
   ConstBitset(ConstBitset<Device> const& rhs)
-    : m_size( rhs.m_size )
-    , m_blocks( rhs.m_blocks )
-  {}
+      : m_size(rhs.m_size), m_blocks(rhs.m_blocks) {}
 
-  ConstBitset<Device> & operator = (Bitset<Device> const & rhs)
-  {
-    this->m_size = rhs.m_size;
+  ConstBitset<Device>& operator=(Bitset<Device> const& rhs) {
+    this->m_size   = rhs.m_size;
     this->m_blocks = rhs.m_blocks;
 
     return *this;
   }
 
-  ConstBitset<Device> & operator = (ConstBitset<Device> const & rhs)
-  {
-    this->m_size = rhs.m_size;
+  ConstBitset<Device>& operator=(ConstBitset<Device> const& rhs) {
+    this->m_size   = rhs.m_size;
     this->m_blocks = rhs.m_blocks;
 
     return *this;
   }
 
-
   KOKKOS_FORCEINLINE_FUNCTION
-  unsigned size() const
-  {
-    return m_size;
-  }
+  unsigned size() const { return m_size; }
 
-  unsigned count() const
-  {
-    Impl::BitsetCount< ConstBitset<Device> > f(*this);
+  unsigned count() const {
+    Impl::BitsetCount<ConstBitset<Device> > f(*this);
     return f.apply();
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool test( unsigned i ) const
-  {
-    if ( i < m_size ) {
-      const unsigned block = m_blocks[ i >> block_shift ];
-      const unsigned mask = 1u << static_cast<int>( i & block_mask );
+  bool test(unsigned i) const {
+    if (i < m_size) {
+      const unsigned block = m_blocks[i >> block_shift];
+      const unsigned mask  = 1u << static_cast<int>(i & block_mask);
       return block & mask;
     }
     return false;
   }
 
-private:
-
+ private:
   unsigned m_size;
-  View< const unsigned *, execution_space, MemoryTraits<RandomAccess> > m_blocks;
+  View<const unsigned*, execution_space, MemoryTraits<RandomAccess> > m_blocks;
 
-private:
+ private:
   template <typename DDevice>
   friend class ConstBitset;
 
@@ -390,47 +365,56 @@ private:
   friend struct Impl::BitsetCount;
 
   template <typename DstDevice, typename SrcDevice>
-  friend void deep_copy( Bitset<DstDevice> & dst, ConstBitset<SrcDevice> const& src);
+  friend void deep_copy(Bitset<DstDevice>& dst,
+                        ConstBitset<SrcDevice> const& src);
 
   template <typename DstDevice, typename SrcDevice>
-  friend void deep_copy( ConstBitset<DstDevice> & dst, ConstBitset<SrcDevice> const& src);
+  friend void deep_copy(ConstBitset<DstDevice>& dst,
+                        ConstBitset<SrcDevice> const& src);
 };
 
-
 template <typename DstDevice, typename SrcDevice>
-void deep_copy( Bitset<DstDevice> & dst, Bitset<SrcDevice> const& src)
-{
+void deep_copy(Bitset<DstDevice>& dst, Bitset<SrcDevice> const& src) {
   if (dst.size() != src.size()) {
-    throw std::runtime_error("Error: Cannot deep_copy bitsets of different sizes!");
+    throw std::runtime_error(
+        "Error: Cannot deep_copy bitsets of different sizes!");
   }
 
-  typedef Kokkos::Impl::DeepCopy< typename DstDevice::memory_space, typename SrcDevice::memory_space > raw_deep_copy;
-  raw_deep_copy(dst.m_blocks.data(), src.m_blocks.data(), sizeof(unsigned)*src.m_blocks.extent(0));
+  typedef Kokkos::Impl::DeepCopy<typename DstDevice::memory_space,
+                                 typename SrcDevice::memory_space>
+      raw_deep_copy;
+  raw_deep_copy(dst.m_blocks.data(), src.m_blocks.data(),
+                sizeof(unsigned) * src.m_blocks.extent(0));
 }
 
 template <typename DstDevice, typename SrcDevice>
-void deep_copy( Bitset<DstDevice> & dst, ConstBitset<SrcDevice> const& src)
-{
+void deep_copy(Bitset<DstDevice>& dst, ConstBitset<SrcDevice> const& src) {
   if (dst.size() != src.size()) {
-    throw std::runtime_error("Error: Cannot deep_copy bitsets of different sizes!");
+    throw std::runtime_error(
+        "Error: Cannot deep_copy bitsets of different sizes!");
   }
 
-  typedef Kokkos::Impl::DeepCopy< typename DstDevice::memory_space, typename SrcDevice::memory_space > raw_deep_copy;
-  raw_deep_copy(dst.m_blocks.data(), src.m_blocks.data(), sizeof(unsigned)*src.m_blocks.extent(0));
+  typedef Kokkos::Impl::DeepCopy<typename DstDevice::memory_space,
+                                 typename SrcDevice::memory_space>
+      raw_deep_copy;
+  raw_deep_copy(dst.m_blocks.data(), src.m_blocks.data(),
+                sizeof(unsigned) * src.m_blocks.extent(0));
 }
 
 template <typename DstDevice, typename SrcDevice>
-void deep_copy( ConstBitset<DstDevice> & dst, ConstBitset<SrcDevice> const& src)
-{
+void deep_copy(ConstBitset<DstDevice>& dst, ConstBitset<SrcDevice> const& src) {
   if (dst.size() != src.size()) {
-    throw std::runtime_error("Error: Cannot deep_copy bitsets of different sizes!");
+    throw std::runtime_error(
+        "Error: Cannot deep_copy bitsets of different sizes!");
   }
 
-  typedef Kokkos::Impl::DeepCopy< typename DstDevice::memory_space, typename SrcDevice::memory_space > raw_deep_copy;
-  raw_deep_copy(dst.m_blocks.data(), src.m_blocks.data(), sizeof(unsigned)*src.m_blocks.extent(0));
+  typedef Kokkos::Impl::DeepCopy<typename DstDevice::memory_space,
+                                 typename SrcDevice::memory_space>
+      raw_deep_copy;
+  raw_deep_copy(dst.m_blocks.data(), src.m_blocks.data(),
+                sizeof(unsigned) * src.m_blocks.extent(0));
 }
 
-} // namespace Kokkos
-
-#endif //KOKKOS_BITSET_HPP
+}  // namespace Kokkos
 
+#endif  // KOKKOS_BITSET_HPP
diff --git a/lib/kokkos/containers/src/Kokkos_DualView.hpp b/lib/kokkos/containers/src/Kokkos_DualView.hpp
index d9b14d67a2f02854962c2f3d127f1d80da67a46d..d8a3ebc1ae947b6ef617d106de8d954ca4bfbc77 100644
--- a/lib/kokkos/containers/src/Kokkos_DualView.hpp
+++ b/lib/kokkos/containers/src/Kokkos_DualView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -90,47 +91,41 @@ namespace Kokkos {
  *     behavior.  Please see the documentation of Kokkos::View for
  *     examples.  The default suffices for most users.
  */
-template< class DataType ,
-          class Arg1Type = void ,
-          class Arg2Type = void ,
+template <class DataType, class Arg1Type = void, class Arg2Type = void,
           class Arg3Type = void>
-class DualView : public ViewTraits< DataType , Arg1Type , Arg2Type, Arg3Type >
-{
-template< class , class , class , class > friend class DualView ;
-public:
+class DualView : public ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type> {
+  template <class, class, class, class>
+  friend class DualView;
+
+ public:
   //! \name Typedefs for device types and various Kokkos::View specializations.
   //@{
-  typedef ViewTraits< DataType , Arg1Type , Arg2Type, Arg3Type > traits ;
+  typedef ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type> traits;
 
   //! The Kokkos Host Device type;
-  typedef typename traits::host_mirror_space host_mirror_space ;
+  typedef typename traits::host_mirror_space host_mirror_space;
 
   //! The type of a Kokkos::View on the device.
-  typedef View< typename traits::data_type ,
-                Arg1Type ,
-                Arg2Type ,
-                Arg3Type > t_dev ;
+  typedef View<typename traits::data_type, Arg1Type, Arg2Type, Arg3Type> t_dev;
 
   /// \typedef t_host
   /// \brief The type of a Kokkos::View host mirror of \c t_dev.
-  typedef typename t_dev::HostMirror t_host ;
+  typedef typename t_dev::HostMirror t_host;
 
   //! The type of a const View on the device.
   //! The type of a Kokkos::View on the device.
-  typedef View< typename traits::const_data_type ,
-                Arg1Type ,
-                Arg2Type ,
-                Arg3Type > t_dev_const ;
+  typedef View<typename traits::const_data_type, Arg1Type, Arg2Type, Arg3Type>
+      t_dev_const;
 
   /// \typedef t_host_const
   /// \brief The type of a const View host mirror of \c t_dev_const.
   typedef typename t_dev_const::HostMirror t_host_const;
 
   //! The type of a const, random-access View on the device.
-  typedef View< typename traits::const_data_type ,
-                typename traits::array_layout ,
-                typename traits::device_type ,
-                Kokkos::MemoryTraits<Kokkos::RandomAccess> > t_dev_const_randomread ;
+  typedef View<typename traits::const_data_type, typename traits::array_layout,
+               typename traits::device_type,
+               Kokkos::MemoryTraits<Kokkos::RandomAccess> >
+      t_dev_const_randomread;
 
   /// \typedef t_host_const_randomread
   /// \brief The type of a const, random-access View host mirror of
@@ -138,39 +133,36 @@ public:
   typedef typename t_dev_const_randomread::HostMirror t_host_const_randomread;
 
   //! The type of an unmanaged View on the device.
-  typedef View< typename traits::data_type ,
-                typename traits::array_layout ,
-                typename traits::device_type ,
-                MemoryUnmanaged> t_dev_um;
+  typedef View<typename traits::data_type, typename traits::array_layout,
+               typename traits::device_type, MemoryUnmanaged>
+      t_dev_um;
 
   //! The type of an unmanaged View host mirror of \c t_dev_um.
-  typedef View< typename t_host::data_type ,
-                typename t_host::array_layout ,
-                typename t_host::device_type ,
-                MemoryUnmanaged> t_host_um;
+  typedef View<typename t_host::data_type, typename t_host::array_layout,
+               typename t_host::device_type, MemoryUnmanaged>
+      t_host_um;
 
   //! The type of a const unmanaged View on the device.
-  typedef View< typename traits::const_data_type ,
-                typename traits::array_layout ,
-                typename traits::device_type ,
-                MemoryUnmanaged> t_dev_const_um;
+  typedef View<typename traits::const_data_type, typename traits::array_layout,
+               typename traits::device_type, MemoryUnmanaged>
+      t_dev_const_um;
 
   //! The type of a const unmanaged View host mirror of \c t_dev_const_um.
-  typedef View<typename t_host::const_data_type,
-               typename t_host::array_layout,
-               typename t_host::device_type,
-               MemoryUnmanaged> t_host_const_um;
+  typedef View<typename t_host::const_data_type, typename t_host::array_layout,
+               typename t_host::device_type, MemoryUnmanaged>
+      t_host_const_um;
 
   //! The type of a const, random-access View on the device.
-  typedef View< typename t_host::const_data_type ,
-                typename t_host::array_layout ,
-                typename t_host::device_type ,
-                Kokkos::MemoryTraits<Kokkos::Unmanaged|Kokkos::RandomAccess> > t_dev_const_randomread_um ;
+  typedef View<typename t_host::const_data_type, typename t_host::array_layout,
+               typename t_host::device_type,
+               Kokkos::MemoryTraits<Kokkos::Unmanaged | Kokkos::RandomAccess> >
+      t_dev_const_randomread_um;
 
   /// \typedef t_host_const_randomread
   /// \brief The type of a const, random-access View host mirror of
   ///   \c t_dev_const_randomread.
-  typedef typename t_dev_const_randomread::HostMirror t_host_const_randomread_um;
+  typedef
+      typename t_dev_const_randomread::HostMirror t_host_const_randomread_um;
 
   //@}
   //! \name The two View instances.
@@ -184,18 +176,20 @@ public:
   //@{
 
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-protected:
+ protected:
   // modified_flags[0] -> host
   // modified_flags[1] -> device
-  typedef View<unsigned int[2],LayoutLeft,Kokkos::HostSpace> t_modified_flags;
+  typedef View<unsigned int[2], LayoutLeft, Kokkos::HostSpace> t_modified_flags;
   t_modified_flags modified_flags;
 
-public:
+ public:
 #else
-  typedef View<unsigned int[2],LayoutLeft,typename t_host::execution_space> t_modified_flags;
-  typedef View<unsigned int,LayoutLeft,typename t_host::execution_space> t_modified_flag;
+  typedef View<unsigned int[2], LayoutLeft, typename t_host::execution_space>
+      t_modified_flags;
+  typedef View<unsigned int, LayoutLeft, typename t_host::execution_space>
+      t_modified_flag;
   t_modified_flags modified_flags;
-  t_modified_flag modified_host,modified_device;
+  t_modified_flag modified_host, modified_device;
 #endif
 
   //@}
@@ -208,11 +202,11 @@ public:
   /// default constructors.  The "modified" flags are both initialized
   /// to "unmodified."
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-  DualView () = default;
+  DualView() = default;
 #else
-  DualView ():modified_flags (t_modified_flags("DualView::modified_flags")) {
-    modified_host = t_modified_flag(modified_flags,0);
-    modified_device = t_modified_flag(modified_flags,1);
+  DualView() : modified_flags(t_modified_flags("DualView::modified_flags")) {
+    modified_host   = t_modified_flag(modified_flags, 0);
+    modified_device = t_modified_flag(modified_flags, 1);
   }
 #endif
 
@@ -225,52 +219,52 @@ public:
   /// View objects.  For example, if the View has three dimensions,
   /// the first three integer arguments will be nonzero, and you may
   /// omit the integer arguments that follow.
-  DualView (const std::string& label,
-            const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-            const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-            const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-            const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-            const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-            const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-            const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-            const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
-    : d_view (label, n0, n1, n2, n3, n4, n5, n6, n7)
-    , h_view (create_mirror_view (d_view)) // without UVM, host View mirrors
-    , modified_flags (t_modified_flags("DualView::modified_flags"))
-  {
+  DualView(const std::string& label,
+           const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+           const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+           const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+           const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+           const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+           const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+           const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+           const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+      : d_view(label, n0, n1, n2, n3, n4, n5, n6, n7),
+        h_view(create_mirror_view(d_view))  // without UVM, host View mirrors
+        ,
+        modified_flags(t_modified_flags("DualView::modified_flags")) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    modified_host = t_modified_flag(modified_flags,0);
-    modified_device = t_modified_flag(modified_flags,1);
+    modified_host   = t_modified_flag(modified_flags, 0);
+    modified_device = t_modified_flag(modified_flags, 1);
 #endif
   }
 
   //! Copy constructor (shallow copy)
-  template<class SS, class LS, class DS, class MS>
-  DualView (const DualView<SS,LS,DS,MS>& src) :
-    d_view (src.d_view),
-    h_view (src.h_view),
-    modified_flags (src.modified_flags)
+  template <class SS, class LS, class DS, class MS>
+  DualView(const DualView<SS, LS, DS, MS>& src)
+      : d_view(src.d_view),
+        h_view(src.h_view),
+        modified_flags(src.modified_flags)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    , modified_host(src.modified_host)
-    , modified_device(src.modified_device)
+        ,
+        modified_host(src.modified_host),
+        modified_device(src.modified_device)
 #endif
-  {}
+  {
+  }
 
   //! Subview constructor
-  template< class SD, class S1 , class S2 , class S3
-          , class Arg0 , class ... Args >
-  DualView( const DualView<SD,S1,S2,S3> & src
-          , const Arg0 & arg0
-          , Args ... args
-          )
-    : d_view( Kokkos::subview( src.d_view , arg0 , args ... ) )
-    , h_view( Kokkos::subview( src.h_view , arg0 , args ... ) )
-    , modified_flags (src.modified_flags)
+  template <class SD, class S1, class S2, class S3, class Arg0, class... Args>
+  DualView(const DualView<SD, S1, S2, S3>& src, const Arg0& arg0, Args... args)
+      : d_view(Kokkos::subview(src.d_view, arg0, args...)),
+        h_view(Kokkos::subview(src.h_view, arg0, args...)),
+        modified_flags(src.modified_flags)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    , modified_host(src.modified_host)
-    , modified_device(src.modified_device)
+        ,
+        modified_host(src.modified_host),
+        modified_device(src.modified_device)
 #endif
-    {}
+  {
+  }
 
   /// \brief Create DualView from existing device and host View objects.
   ///
@@ -282,34 +276,34 @@ public:
   ///
   /// \param d_view_ Device View
   /// \param h_view_ Host View (must have type t_host = t_dev::HostMirror)
-  DualView (const t_dev& d_view_, const t_host& h_view_) :
-    d_view (d_view_),
-    h_view (h_view_),
-    modified_flags (t_modified_flags("DualView::modified_flags"))
-  {
-    if ( int(d_view.rank)     != int(h_view.rank) ||
-         d_view.extent(0) != h_view.extent(0) ||
-         d_view.extent(1) != h_view.extent(1) ||
-         d_view.extent(2) != h_view.extent(2) ||
-         d_view.extent(3) != h_view.extent(3) ||
-         d_view.extent(4) != h_view.extent(4) ||
-         d_view.extent(5) != h_view.extent(5) ||
-         d_view.extent(6) != h_view.extent(6) ||
-         d_view.extent(7) != h_view.extent(7) ||
-         d_view.stride_0()    != h_view.stride_0() ||
-         d_view.stride_1()    != h_view.stride_1() ||
-         d_view.stride_2()    != h_view.stride_2() ||
-         d_view.stride_3()    != h_view.stride_3() ||
-         d_view.stride_4()    != h_view.stride_4() ||
-         d_view.stride_5()    != h_view.stride_5() ||
-         d_view.stride_6()    != h_view.stride_6() ||
-         d_view.stride_7()    != h_view.stride_7() ||
-         d_view.span()        != h_view.span() ) {
-      Kokkos::Impl::throw_runtime_exception("DualView constructed with incompatible views");
+  DualView(const t_dev& d_view_, const t_host& h_view_)
+      : d_view(d_view_),
+        h_view(h_view_),
+        modified_flags(t_modified_flags("DualView::modified_flags")) {
+    if (int(d_view.rank) != int(h_view.rank) ||
+        d_view.extent(0) != h_view.extent(0) ||
+        d_view.extent(1) != h_view.extent(1) ||
+        d_view.extent(2) != h_view.extent(2) ||
+        d_view.extent(3) != h_view.extent(3) ||
+        d_view.extent(4) != h_view.extent(4) ||
+        d_view.extent(5) != h_view.extent(5) ||
+        d_view.extent(6) != h_view.extent(6) ||
+        d_view.extent(7) != h_view.extent(7) ||
+        d_view.stride_0() != h_view.stride_0() ||
+        d_view.stride_1() != h_view.stride_1() ||
+        d_view.stride_2() != h_view.stride_2() ||
+        d_view.stride_3() != h_view.stride_3() ||
+        d_view.stride_4() != h_view.stride_4() ||
+        d_view.stride_5() != h_view.stride_5() ||
+        d_view.stride_6() != h_view.stride_6() ||
+        d_view.stride_7() != h_view.stride_7() ||
+        d_view.span() != h_view.span()) {
+      Kokkos::Impl::throw_runtime_exception(
+          "DualView constructed with incompatible views");
     }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    modified_host = t_modified_flag(modified_flags,0);
-    modified_device = t_modified_flag(modified_flags,1);
+    modified_host   = t_modified_flag(modified_flags, 0);
+    modified_device = t_modified_flag(modified_flags, 1);
 #endif
   }
 
@@ -326,119 +320,133 @@ public:
   ///
   /// For example, suppose you create a DualView on Cuda, like this:
   /// \code
-  /// typedef Kokkos::DualView<float, Kokkos::LayoutRight, Kokkos::Cuda> dual_view_type;
-  /// dual_view_type DV ("my dual view", 100);
-  /// \endcode
-  /// If you want to get the CUDA device View, do this:
-  /// \code
-  /// typename dual_view_type::t_dev cudaView = DV.view<Kokkos::Cuda> ();
-  /// \endcode
-  /// and if you want to get the host mirror of that View, do this:
-  /// \code
-  /// typedef typename Kokkos::HostSpace::execution_space host_device_type;
-  /// typename dual_view_type::t_host hostView = DV.view<host_device_type> ();
-  /// \endcode
-  template< class Device >
-  KOKKOS_INLINE_FUNCTION
-  const typename Impl::if_c<
-    std::is_same<typename t_dev::memory_space,
-                          typename Device::memory_space>::value,
-    t_dev,
-    t_host>::type& view () const
-  {
-    #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-    constexpr bool device_is_memspace  = std::is_same<Device,typename Device::memory_space>::value;
-    constexpr bool device_is_execspace = std::is_same<Device,typename Device::execution_space>::value;
-    constexpr bool device_exec_is_t_dev_exec  = std::is_same<typename Device::execution_space,typename t_dev::execution_space>::value;
-    constexpr bool device_mem_is_t_dev_mem    = std::is_same<typename Device::memory_space,typename t_dev::memory_space>::value;
-    constexpr bool device_exec_is_t_host_exec  = std::is_same<typename Device::execution_space,typename t_host::execution_space>::value;
-    constexpr bool device_mem_is_t_host_mem    = std::is_same<typename Device::memory_space,typename t_host::memory_space>::value;
-    constexpr bool device_is_t_host_device  = std::is_same<typename Device::execution_space,typename t_host::device_type>::value;
-    constexpr bool device_is_t_dev_device    = std::is_same<typename Device::memory_space,typename t_host::device_type>::value;
+  /// typedef Kokkos::DualView<float, Kokkos::LayoutRight, Kokkos::Cuda>
+  /// dual_view_type; dual_view_type DV ("my dual view", 100); \endcode If you
+  /// want to get the CUDA device View, do this: \code typename
+  /// dual_view_type::t_dev cudaView = DV.view<Kokkos::Cuda> (); \endcode and if
+  /// you want to get the host mirror of that View, do this: \code typedef
+  /// typename Kokkos::HostSpace::execution_space host_device_type; typename
+  /// dual_view_type::t_host hostView = DV.view<host_device_type> (); \endcode
+  template <class Device>
+  KOKKOS_INLINE_FUNCTION const typename Impl::if_c<
+      std::is_same<typename t_dev::memory_space,
+                   typename Device::memory_space>::value,
+      t_dev, t_host>::type&
+  view() const {
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE
+    constexpr bool device_is_memspace =
+        std::is_same<Device, typename Device::memory_space>::value;
+    constexpr bool device_is_execspace =
+        std::is_same<Device, typename Device::execution_space>::value;
+    constexpr bool device_exec_is_t_dev_exec =
+        std::is_same<typename Device::execution_space,
+                     typename t_dev::execution_space>::value;
+    constexpr bool device_mem_is_t_dev_mem =
+        std::is_same<typename Device::memory_space,
+                     typename t_dev::memory_space>::value;
+    constexpr bool device_exec_is_t_host_exec =
+        std::is_same<typename Device::execution_space,
+                     typename t_host::execution_space>::value;
+    constexpr bool device_mem_is_t_host_mem =
+        std::is_same<typename Device::memory_space,
+                     typename t_host::memory_space>::value;
+    constexpr bool device_is_t_host_device =
+        std::is_same<typename Device::execution_space,
+                     typename t_host::device_type>::value;
+    constexpr bool device_is_t_dev_device =
+        std::is_same<typename Device::memory_space,
+                     typename t_host::device_type>::value;
 
     static_assert(
         device_is_t_dev_device || device_is_t_host_device ||
-        (device_is_memspace  && (device_mem_is_t_dev_mem   || device_mem_is_t_host_mem) ) ||
-        (device_is_execspace && (device_exec_is_t_dev_exec || device_exec_is_t_host_exec) ) ||
-        (
-          (!device_is_execspace && !device_is_memspace) && (
-            (device_mem_is_t_dev_mem   || device_mem_is_t_host_mem)  ||
-            (device_exec_is_t_dev_exec || device_exec_is_t_host_exec)
-          )
-        )
-        ,
-        "Template parameter to .view() must exactly match one of the DualView's device types or one of the execution or memory spaces");
-    #endif
-
-    return Impl::if_c<
-      std::is_same<
-        typename t_dev::memory_space,
-        typename Device::memory_space>::value,
-      t_dev,
-      t_host >::select (d_view , h_view);
+            (device_is_memspace &&
+             (device_mem_is_t_dev_mem || device_mem_is_t_host_mem)) ||
+            (device_is_execspace &&
+             (device_exec_is_t_dev_exec || device_exec_is_t_host_exec)) ||
+            ((!device_is_execspace && !device_is_memspace) &&
+             ((device_mem_is_t_dev_mem || device_mem_is_t_host_mem) ||
+              (device_exec_is_t_dev_exec || device_exec_is_t_host_exec))),
+        "Template parameter to .view() must exactly match one of the "
+        "DualView's device types or one of the execution or memory spaces");
+#endif
+
+    return Impl::if_c<std::is_same<typename t_dev::memory_space,
+                                   typename Device::memory_space>::value,
+                      t_dev, t_host>::select(d_view, h_view);
   }
 
   KOKKOS_INLINE_FUNCTION
-  t_host view_host() const {
-    return h_view;
-  }
+  t_host view_host() const { return h_view; }
 
   KOKKOS_INLINE_FUNCTION
-  t_dev view_device() const {
-    return d_view;
-  }
+  t_dev view_device() const { return d_view; }
 
-  template<class Device>
+  template <class Device>
   static int get_device_side() {
-    constexpr bool device_is_memspace  = std::is_same<Device,typename Device::memory_space>::value;
-    constexpr bool device_is_execspace = std::is_same<Device,typename Device::execution_space>::value;
-    constexpr bool device_exec_is_t_dev_exec  = std::is_same<typename Device::execution_space,typename t_dev::execution_space>::value;
-    constexpr bool device_mem_is_t_dev_mem    = std::is_same<typename Device::memory_space,typename t_dev::memory_space>::value;
-    constexpr bool device_exec_is_t_host_exec  = std::is_same<typename Device::execution_space,typename t_host::execution_space>::value;
-    constexpr bool device_mem_is_t_host_mem    = std::is_same<typename Device::memory_space,typename t_host::memory_space>::value;
-    constexpr bool device_is_t_host_device  = std::is_same<typename Device::execution_space,typename t_host::device_type>::value;
-    constexpr bool device_is_t_dev_device    = std::is_same<typename Device::memory_space,typename t_host::device_type>::value;
-
-    #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
+    constexpr bool device_is_memspace =
+        std::is_same<Device, typename Device::memory_space>::value;
+    constexpr bool device_is_execspace =
+        std::is_same<Device, typename Device::execution_space>::value;
+    constexpr bool device_exec_is_t_dev_exec =
+        std::is_same<typename Device::execution_space,
+                     typename t_dev::execution_space>::value;
+    constexpr bool device_mem_is_t_dev_mem =
+        std::is_same<typename Device::memory_space,
+                     typename t_dev::memory_space>::value;
+    constexpr bool device_exec_is_t_host_exec =
+        std::is_same<typename Device::execution_space,
+                     typename t_host::execution_space>::value;
+    constexpr bool device_mem_is_t_host_mem =
+        std::is_same<typename Device::memory_space,
+                     typename t_host::memory_space>::value;
+    constexpr bool device_is_t_host_device =
+        std::is_same<typename Device::execution_space,
+                     typename t_host::device_type>::value;
+    constexpr bool device_is_t_dev_device =
+        std::is_same<typename Device::memory_space,
+                     typename t_host::device_type>::value;
+
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE
     static_assert(
         device_is_t_dev_device || device_is_t_host_device ||
-        (device_is_memspace  && (device_mem_is_t_dev_mem   || device_mem_is_t_host_mem) ) ||
-        (device_is_execspace && (device_exec_is_t_dev_exec || device_exec_is_t_host_exec) ) ||
-        (
-          (!device_is_execspace && !device_is_memspace) && (
-            (device_mem_is_t_dev_mem   || device_mem_is_t_host_mem)  ||
-            (device_exec_is_t_dev_exec || device_exec_is_t_host_exec)
-          )
-        )
-        ,
-        "Template parameter to .sync() must exactly match one of the DualView's device types or one of the execution or memory spaces");
-    #endif
+            (device_is_memspace &&
+             (device_mem_is_t_dev_mem || device_mem_is_t_host_mem)) ||
+            (device_is_execspace &&
+             (device_exec_is_t_dev_exec || device_exec_is_t_host_exec)) ||
+            ((!device_is_execspace && !device_is_memspace) &&
+             ((device_mem_is_t_dev_mem || device_mem_is_t_host_mem) ||
+              (device_exec_is_t_dev_exec || device_exec_is_t_host_exec))),
+        "Template parameter to .sync() must exactly match one of the "
+        "DualView's device types or one of the execution or memory spaces");
+#endif
 
-    #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE
     int dev = -1;
-    #else
+#else
     int dev = 0;
-    #endif
-    if(device_is_t_dev_device) dev = 1;
-    else if(device_is_t_host_device) dev = 0;
+#endif
+    if (device_is_t_dev_device)
+      dev = 1;
+    else if (device_is_t_host_device)
+      dev = 0;
     else {
-      if(device_is_memspace) {
-        if(device_mem_is_t_dev_mem) dev = 1;
-        if(device_mem_is_t_host_mem) dev = 0;
-        if(device_mem_is_t_host_mem && device_mem_is_t_dev_mem) dev = -1;
+      if (device_is_memspace) {
+        if (device_mem_is_t_dev_mem) dev = 1;
+        if (device_mem_is_t_host_mem) dev = 0;
+        if (device_mem_is_t_host_mem && device_mem_is_t_dev_mem) dev = -1;
       }
-      if(device_is_execspace) {
-        if(device_exec_is_t_dev_exec) dev = 1;
-        if(device_exec_is_t_host_exec) dev = 0;
-        if(device_exec_is_t_host_exec && device_exec_is_t_dev_exec) dev = -1;
+      if (device_is_execspace) {
+        if (device_exec_is_t_dev_exec) dev = 1;
+        if (device_exec_is_t_host_exec) dev = 0;
+        if (device_exec_is_t_host_exec && device_exec_is_t_dev_exec) dev = -1;
       }
-      if(!device_is_execspace && !device_is_memspace) {
-        if(device_mem_is_t_dev_mem) dev = 1;
-        if(device_mem_is_t_host_mem) dev = 0;
-        if(device_mem_is_t_host_mem && device_mem_is_t_dev_mem) dev = -1;
-        if(device_exec_is_t_dev_exec) dev = 1;
-        if(device_exec_is_t_host_exec) dev = 0;
-        if(device_exec_is_t_host_exec && device_exec_is_t_dev_exec) dev = -1;
+      if (!device_is_execspace && !device_is_memspace) {
+        if (device_mem_is_t_dev_mem) dev = 1;
+        if (device_mem_is_t_host_mem) dev = 0;
+        if (device_mem_is_t_host_mem && device_mem_is_t_dev_mem) dev = -1;
+        if (device_exec_is_t_dev_exec) dev = 1;
+        if (device_exec_is_t_host_exec) dev = 0;
+        if (device_exec_is_t_host_exec && device_exec_is_t_dev_exec) dev = -1;
       }
     }
     return dev;
@@ -461,88 +469,94 @@ public:
   ///   the data in either View.  You must manually mark modified data
   ///   as modified, by calling the modify() method with the
   ///   appropriate template parameter.
-  template<class Device>
-  void sync( const typename Impl::enable_if<
-        ( std::is_same< typename traits::data_type , typename traits::non_const_data_type>::value) ||
-        ( std::is_same< Device , int>::value)
-        , int >::type& = 0)
-  {
-    if(modified_flags.data()==NULL) return;
+  template <class Device>
+  void sync(const typename Impl::enable_if<
+                (std::is_same<typename traits::data_type,
+                              typename traits::non_const_data_type>::value) ||
+                    (std::is_same<Device, int>::value),
+                int>::type& = 0) {
+    if (modified_flags.data() == NULL) return;
 
     int dev = get_device_side<Device>();
 
-    if (dev == 1) { // if Device is the same as DualView's device type
+    if (dev == 1) {  // if Device is the same as DualView's device type
       if ((modified_flags(0) > 0) && (modified_flags(0) >= modified_flags(1))) {
-        deep_copy (d_view, h_view);
+        deep_copy(d_view, h_view);
         modified_flags(0) = modified_flags(1) = 0;
       }
     }
-    if (dev == 0) { // hopefully Device is the same as DualView's host type
+    if (dev == 0) {  // hopefully Device is the same as DualView's host type
       if ((modified_flags(1) > 0) && (modified_flags(1) >= modified_flags(0))) {
-        deep_copy (h_view, d_view);
+        deep_copy(h_view, d_view);
         modified_flags(0) = modified_flags(1) = 0;
       }
     }
-    if(std::is_same<typename t_host::memory_space,typename t_dev::memory_space>::value) {
+    if (std::is_same<typename t_host::memory_space,
+                     typename t_dev::memory_space>::value) {
       typename t_dev::execution_space().fence();
       typename t_host::execution_space().fence();
     }
   }
 
-  template<class Device>
-  void sync ( const typename Impl::enable_if<
-      ( ! std::is_same< typename traits::data_type , typename traits::non_const_data_type>::value ) ||
-      ( std::is_same< Device , int>::value)
-      , int >::type& = 0 )
-  {
-    if(modified_flags.data()==NULL) return;
+  template <class Device>
+  void sync(const typename Impl::enable_if<
+                (!std::is_same<typename traits::data_type,
+                               typename traits::non_const_data_type>::value) ||
+                    (std::is_same<Device, int>::value),
+                int>::type& = 0) {
+    if (modified_flags.data() == NULL) return;
 
     int dev = get_device_side<Device>();
 
-    if (dev == 1) { // if Device is the same as DualView's device type
+    if (dev == 1) {  // if Device is the same as DualView's device type
       if ((modified_flags(0) > 0) && (modified_flags(0) >= modified_flags(1))) {
-        Impl::throw_runtime_exception("Calling sync on a DualView with a const datatype.");
+        Impl::throw_runtime_exception(
+            "Calling sync on a DualView with a const datatype.");
       }
     }
-    if (dev == 0){ // hopefully Device is the same as DualView's host type
+    if (dev == 0) {  // hopefully Device is the same as DualView's host type
       if ((modified_flags(1) > 0) && (modified_flags(1) >= modified_flags(0))) {
-        Impl::throw_runtime_exception("Calling sync on a DualView with a const datatype.");
+        Impl::throw_runtime_exception(
+            "Calling sync on a DualView with a const datatype.");
       }
     }
   }
 
   void sync_host() {
-    if( ! std::is_same< typename traits::data_type , typename traits::non_const_data_type>::value )
-      Impl::throw_runtime_exception("Calling sync_host on a DualView with a const datatype.");
-    if(modified_flags.data()==NULL) return;
-    if(modified_flags(1) > modified_flags(0)) {
-      deep_copy (h_view, d_view);
+    if (!std::is_same<typename traits::data_type,
+                      typename traits::non_const_data_type>::value)
+      Impl::throw_runtime_exception(
+          "Calling sync_host on a DualView with a const datatype.");
+    if (modified_flags.data() == NULL) return;
+    if (modified_flags(1) > modified_flags(0)) {
+      deep_copy(h_view, d_view);
       modified_flags(1) = modified_flags(0) = 0;
     }
   }
 
   void sync_device() {
-    if( ! std::is_same< typename traits::data_type , typename traits::non_const_data_type>::value )
-      Impl::throw_runtime_exception("Calling sync_device on a DualView with a const datatype.");
-    if(modified_flags.data()==NULL) return;
-    if(modified_flags(0) > modified_flags(1)) {
-      deep_copy (d_view, h_view);
+    if (!std::is_same<typename traits::data_type,
+                      typename traits::non_const_data_type>::value)
+      Impl::throw_runtime_exception(
+          "Calling sync_device on a DualView with a const datatype.");
+    if (modified_flags.data() == NULL) return;
+    if (modified_flags(0) > modified_flags(1)) {
+      deep_copy(d_view, h_view);
       modified_flags(1) = modified_flags(0) = 0;
     }
   }
 
-  template<class Device>
-  bool need_sync() const
-  {
-    if(modified_flags.data()==NULL) return false;
+  template <class Device>
+  bool need_sync() const {
+    if (modified_flags.data() == NULL) return false;
     int dev = get_device_side<Device>();
 
-    if (dev == 1) { // if Device is the same as DualView's device type
+    if (dev == 1) {  // if Device is the same as DualView's device type
       if ((modified_flags(0) > 0) && (modified_flags(0) >= modified_flags(1))) {
         return true;
       }
     }
-    if (dev == 0){ // hopefully Device is the same as DualView's host type
+    if (dev == 0) {  // hopefully Device is the same as DualView's host type
       if ((modified_flags(1) > 0) && (modified_flags(1) >= modified_flags(0))) {
         return true;
       }
@@ -551,13 +565,13 @@ public:
   }
 
   inline bool need_sync_host() const {
-    if(modified_flags.data()==NULL) return false;
-    return modified_flags(0)<modified_flags(1);
+    if (modified_flags.data() == NULL) return false;
+    return modified_flags(0) < modified_flags(1);
   }
 
   inline bool need_sync_device() const {
-    if(modified_flags.data()==NULL) return false;
-    return modified_flags(1)<modified_flags(0);
+    if (modified_flags.data() == NULL) return false;
+    return modified_flags(1) < modified_flags(0);
   }
 
   /// \brief Mark data as modified on the given device \c Device.
@@ -565,20 +579,24 @@ public:
   /// If \c Device is the same as this DualView's device type, then
   /// mark the device's data as modified.  Otherwise, mark the host's
   /// data as modified.
-  template<class Device>
-  void modify () {
-    if(modified_flags.data()==NULL) return;
+  template <class Device>
+  void modify() {
+    if (modified_flags.data() == NULL) return;
     int dev = get_device_side<Device>();
 
-    if (dev == 1) { // if Device is the same as DualView's device type
+    if (dev == 1) {  // if Device is the same as DualView's device type
       // Increment the device's modified count.
-      modified_flags(1) = (modified_flags(1) > modified_flags(0) ?
-                            modified_flags(1) : modified_flags(0)) + 1;
+      modified_flags(1) =
+          (modified_flags(1) > modified_flags(0) ? modified_flags(1)
+                                                 : modified_flags(0)) +
+          1;
     }
-    if (dev == 0) { // hopefully Device is the same as DualView's host type
+    if (dev == 0) {  // hopefully Device is the same as DualView's host type
       // Increment the host's modified count.
-      modified_flags(0) = (modified_flags(1) > modified_flags(0) ?
-                          modified_flags(1) : modified_flags(0))  + 1;
+      modified_flags(0) =
+          (modified_flags(1) > modified_flags(0) ? modified_flags(1)
+                                                 : modified_flags(0)) +
+          1;
     }
 
 #ifdef KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
@@ -594,10 +612,12 @@ public:
   }
 
   inline void modify_host() {
-    if(modified_flags.data()!=NULL) {
-      modified_flags(0) = (modified_flags(1) > modified_flags(0) ?
-          modified_flags(1) : modified_flags(0))  + 1;
-      #ifdef KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
+    if (modified_flags.data() != NULL) {
+      modified_flags(0) =
+          (modified_flags(1) > modified_flags(0) ? modified_flags(1)
+                                                 : modified_flags(0)) +
+          1;
+#ifdef KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
       if (modified_flags(0) && modified_flags(1)) {
         std::string msg = "Kokkos::DualView::modify_host ERROR: ";
         msg += "Concurrent modification of host and device views ";
@@ -606,15 +626,17 @@ public:
         msg += "\"\n";
         Kokkos::abort(msg.c_str());
       }
-    #endif
+#endif
     }
   }
 
   inline void modify_device() {
-    if(modified_flags.data()!=NULL) {
-      modified_flags(1) = (modified_flags(1) > modified_flags(0) ?
-          modified_flags(1) : modified_flags(0))  + 1;
-      #ifdef KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
+    if (modified_flags.data() != NULL) {
+      modified_flags(1) =
+          (modified_flags(1) > modified_flags(0) ? modified_flags(1)
+                                                 : modified_flags(0)) +
+          1;
+#ifdef KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
       if (modified_flags(0) && modified_flags(1)) {
         std::string msg = "Kokkos::DualView::modify_device ERROR: ";
         msg += "Concurrent modification of host and device views ";
@@ -623,12 +645,12 @@ public:
         msg += "\"\n";
         Kokkos::abort(msg.c_str());
       }
-      #endif
+#endif
     }
   }
 
   inline void clear_sync_state() {
-    if(modified_flags.data()!=NULL) 
+    if (modified_flags.data() != NULL)
       modified_flags(1) = modified_flags(0) = 0;
   }
 
@@ -641,75 +663,72 @@ public:
   /// This discards any existing contents of the objects, and resets
   /// their modified flags.  It does <i>not</i> copy the old contents
   /// of either View into the new View objects.
-  void realloc( const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ) {
-    ::Kokkos::realloc(d_view,n0,n1,n2,n3,n4,n5,n6,n7);
-     h_view = create_mirror_view( d_view );
-
-     /* Reset dirty flags */
-     if(modified_flags.data()==NULL) {
-       modified_flags = t_modified_flags("DualView::modified_flags");
-     } else
-       modified_flags(1) = modified_flags(0) = 0;
+  void realloc(const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+               const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+               const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+               const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+               const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+               const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+               const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+               const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
+    ::Kokkos::realloc(d_view, n0, n1, n2, n3, n4, n5, n6, n7);
+    h_view = create_mirror_view(d_view);
+
+    /* Reset dirty flags */
+    if (modified_flags.data() == NULL) {
+      modified_flags = t_modified_flags("DualView::modified_flags");
+    } else
+      modified_flags(1) = modified_flags(0) = 0;
   }
 
   /// \brief Resize both views, copying old contents into new if necessary.
   ///
   /// This method only copies the old contents into the new View
   /// objects for the device which was last marked as modified.
-  void resize( const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-           const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ) {
-   if(modified_flags.data()==NULL) {
-     modified_flags = t_modified_flags("DualView::modified_flags");
-   }
-   if(modified_flags(1) >= modified_flags(0)) {
-     /* Resize on Device */
-     ::Kokkos::resize(d_view,n0,n1,n2,n3,n4,n5,n6,n7);
-     h_view = create_mirror_view( d_view );
-
-     /* Mark Device copy as modified */
-     modified_flags(1) = modified_flags(1)+1;
-
-   } else {
-     /* Realloc on Device */
-
-     ::Kokkos::realloc(d_view,n0,n1,n2,n3,n4,n5,n6,n7);
-
-     const bool sizeMismatch = ( h_view.extent(0) != n0 ) ||
-         ( h_view.extent(1) != n1 ) ||
-         ( h_view.extent(2) != n2 ) ||
-         ( h_view.extent(3) != n3 ) ||
-         ( h_view.extent(4) != n4 ) ||
-         ( h_view.extent(5) != n5 ) ||
-         ( h_view.extent(6) != n6 ) ||
-         ( h_view.extent(7) != n7 );
-     if ( sizeMismatch )
-       ::Kokkos::resize(h_view,n0,n1,n2,n3,n4,n5,n6,n7);
-
-     t_host temp_view = create_mirror_view( d_view );
-
-     /* Remap on Host */
-     Kokkos::deep_copy( temp_view , h_view );
-
-     h_view = temp_view;
-
-     d_view = create_mirror_view( typename t_dev::execution_space(), h_view );
-
-     /* Mark Host copy as modified */
-     modified_flags(0) = modified_flags(0)+1;
-   }
+  void resize(const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+              const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+              const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+              const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+              const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+              const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+              const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+              const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
+    if (modified_flags.data() == NULL) {
+      modified_flags = t_modified_flags("DualView::modified_flags");
+    }
+    if (modified_flags(1) >= modified_flags(0)) {
+      /* Resize on Device */
+      ::Kokkos::resize(d_view, n0, n1, n2, n3, n4, n5, n6, n7);
+      h_view = create_mirror_view(d_view);
+
+      /* Mark Device copy as modified */
+      modified_flags(1) = modified_flags(1) + 1;
+
+    } else {
+      /* Realloc on Device */
+
+      ::Kokkos::realloc(d_view, n0, n1, n2, n3, n4, n5, n6, n7);
+
+      const bool sizeMismatch =
+          (h_view.extent(0) != n0) || (h_view.extent(1) != n1) ||
+          (h_view.extent(2) != n2) || (h_view.extent(3) != n3) ||
+          (h_view.extent(4) != n4) || (h_view.extent(5) != n5) ||
+          (h_view.extent(6) != n6) || (h_view.extent(7) != n7);
+      if (sizeMismatch)
+        ::Kokkos::resize(h_view, n0, n1, n2, n3, n4, n5, n6, n7);
+
+      t_host temp_view = create_mirror_view(d_view);
+
+      /* Remap on Host */
+      Kokkos::deep_copy(temp_view, h_view);
+
+      h_view = temp_view;
+
+      d_view = create_mirror_view(typename t_dev::execution_space(), h_view);
+
+      /* Mark Host copy as modified */
+      modified_flags(0) = modified_flags(0) + 1;
+    }
   }
 
   //@}
@@ -718,37 +737,35 @@ public:
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   //! The allocation size (same as Kokkos::View::capacity).
-  size_t capacity() const {
-    return d_view.span();
-  }
+  size_t capacity() const { return d_view.span(); }
 #endif
 
   //! The allocation size (same as Kokkos::View::span).
-  KOKKOS_INLINE_FUNCTION constexpr size_t span() const {
-    return d_view.span();
-  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return d_view.span(); }
 
-  KOKKOS_INLINE_FUNCTION bool span_is_contiguous() const { 
-    return d_view.span_is_contiguous(); 
+  KOKKOS_INLINE_FUNCTION bool span_is_contiguous() const {
+    return d_view.span_is_contiguous();
   }
 
   //! Get stride(s) for each dimension.
-  template< typename iType>
+  template <typename iType>
   void stride(iType* stride_) const {
     d_view.stride(stride_);
   }
 
-  template< typename iType >
-   KOKKOS_INLINE_FUNCTION constexpr
-   typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-   extent( const iType & r ) const
-     { return d_view.extent(r); }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION constexpr
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      extent(const iType& r) const {
+    return d_view.extent(r);
+  }
 
-   template< typename iType >
-   KOKKOS_INLINE_FUNCTION constexpr
-   typename std::enable_if< std::is_integral<iType>::value , int >::type
-   extent_int( const iType & r ) const
-     { return static_cast<int>(d_view.extent(r)); }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION constexpr
+      typename std::enable_if<std::is_integral<iType>::value, int>::type
+      extent_int(const iType& r) const {
+    return static_cast<int>(d_view.extent(r));
+  }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /*  Deprecate all 'dimension' functions in favor of
@@ -756,27 +773,27 @@ public:
    */
 
   /* \brief return size of dimension 0 */
-  size_t dimension_0() const {return d_view.extent(0);}
+  size_t dimension_0() const { return d_view.extent(0); }
   /* \brief return size of dimension 1 */
-  size_t dimension_1() const {return d_view.extent(1);}
+  size_t dimension_1() const { return d_view.extent(1); }
   /* \brief return size of dimension 2 */
-  size_t dimension_2() const {return d_view.extent(2);}
+  size_t dimension_2() const { return d_view.extent(2); }
   /* \brief return size of dimension 3 */
-  size_t dimension_3() const {return d_view.extent(3);}
+  size_t dimension_3() const { return d_view.extent(3); }
   /* \brief return size of dimension 4 */
-  size_t dimension_4() const {return d_view.extent(4);}
+  size_t dimension_4() const { return d_view.extent(4); }
   /* \brief return size of dimension 5 */
-  size_t dimension_5() const {return d_view.extent(5);}
+  size_t dimension_5() const { return d_view.extent(5); }
   /* \brief return size of dimension 6 */
-  size_t dimension_6() const {return d_view.extent(6);}
+  size_t dimension_6() const { return d_view.extent(6); }
   /* \brief return size of dimension 7 */
-  size_t dimension_7() const {return d_view.extent(7);}
+  size_t dimension_7() const { return d_view.extent(7); }
 #endif
 
   //@}
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -787,32 +804,24 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class D, class A1, class A2, class A3, class ... Args >
+template <class D, class A1, class A2, class A3, class... Args>
 struct DualViewSubview {
+  typedef typename Kokkos::Impl::ViewMapping<
+      void, Kokkos::ViewTraits<D, A1, A2, A3>, Args...>::traits_type dst_traits;
 
-  typedef typename Kokkos::Impl::ViewMapping
-    < void
-    , Kokkos::ViewTraits< D, A1, A2, A3 >
-    , Args ...
-    >::traits_type dst_traits ;
-
-  typedef Kokkos::DualView
-    < typename dst_traits::data_type
-    , typename dst_traits::array_layout
-    , typename dst_traits::device_type
-    , typename dst_traits::memory_traits
-    > type ;
+  typedef Kokkos::DualView<
+      typename dst_traits::data_type, typename dst_traits::array_layout,
+      typename dst_traits::device_type, typename dst_traits::memory_traits>
+      type;
 };
 
 } /* namespace Impl */
 
-
-template< class D , class A1 , class A2 , class A3 , class ... Args >
-typename Impl::DualViewSubview<D,A1,A2,A3,Args...>::type
-subview( const DualView<D,A1,A2,A3> & src , Args ... args )
-{
-  return typename
-    Impl::DualViewSubview<D,A1,A2,A3,Args...>::type( src , args ... );
+template <class D, class A1, class A2, class A3, class... Args>
+typename Impl::DualViewSubview<D, A1, A2, A3, Args...>::type subview(
+    const DualView<D, A1, A2, A3>& src, Args... args) {
+  return typename Impl::DualViewSubview<D, A1, A2, A3, Args...>::type(src,
+                                                                      args...);
 }
 
 } /* namespace Kokkos */
@@ -826,40 +835,35 @@ namespace Kokkos {
 // Partial specialization of Kokkos::deep_copy() for DualView objects.
 //
 
-template< class DT , class DL , class DD , class DM ,
-          class ST , class SL , class SD , class SM >
-void
-deep_copy (DualView<DT,DL,DD,DM> dst, // trust me, this must not be a reference
-           const DualView<ST,SL,SD,SM>& src )
-{
-  if ( src.need_sync_device() ) {
-    deep_copy (dst.h_view, src.h_view);
+template <class DT, class DL, class DD, class DM, class ST, class SL, class SD,
+          class SM>
+void deep_copy(
+    DualView<DT, DL, DD, DM> dst,  // trust me, this must not be a reference
+    const DualView<ST, SL, SD, SM>& src) {
+  if (src.need_sync_device()) {
+    deep_copy(dst.h_view, src.h_view);
     dst.modify_host();
-  }
-  else {
-    deep_copy (dst.d_view, src.d_view);
+  } else {
+    deep_copy(dst.d_view, src.d_view);
     dst.modify_device();
-  } 
+  }
 }
 
-template< class ExecutionSpace ,
-          class DT , class DL , class DD , class DM ,
-          class ST , class SL , class SD , class SM >
-void
-deep_copy (const ExecutionSpace& exec ,
-           DualView<DT,DL,DD,DM> dst, // trust me, this must not be a reference
-           const DualView<ST,SL,SD,SM>& src )
-{
-  if ( src.need_sync_device() ) {
-    deep_copy (exec, dst.h_view, src.h_view);
+template <class ExecutionSpace, class DT, class DL, class DD, class DM,
+          class ST, class SL, class SD, class SM>
+void deep_copy(
+    const ExecutionSpace& exec,
+    DualView<DT, DL, DD, DM> dst,  // trust me, this must not be a reference
+    const DualView<ST, SL, SD, SM>& src) {
+  if (src.need_sync_device()) {
+    deep_copy(exec, dst.h_view, src.h_view);
     dst.modify_host();
   } else {
-    deep_copy (exec, dst.d_view, src.d_view);
+    deep_copy(exec, dst.d_view, src.d_view);
     dst.modify_device();
   }
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/containers/src/Kokkos_DynRankView.hpp b/lib/kokkos/containers/src/Kokkos_DynRankView.hpp
index d1e6704a573dfd3c26ad5eaa37d69ab1dc678459..0ceb9d5d397e77fcfc8ef0a119e99cd6386a184b 100644
--- a/lib/kokkos/containers/src/Kokkos_DynRankView.hpp
+++ b/lib/kokkos/containers/src/Kokkos_DynRankView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -56,255 +57,240 @@
 
 namespace Kokkos {
 
-template< typename DataType , class ... Properties >
-class DynRankView;  //forward declare
+template <typename DataType, class... Properties>
+class DynRankView;  // forward declare
 
 namespace Impl {
 
 template <typename Specialize>
 struct DynRankDimTraits {
-
-  enum : size_t{unspecified = KOKKOS_INVALID_INDEX};
+  enum : size_t { unspecified = KOKKOS_INVALID_INDEX };
 
   // Compute the rank of the view from the nonzero dimension arguments.
   KOKKOS_INLINE_FUNCTION
-  static size_t computeRank( const size_t N0
-                           , const size_t N1
-                           , const size_t N2
-                           , const size_t N3
-                           , const size_t N4
-                           , const size_t N5
-                           , const size_t N6
-                           , const size_t /* N7 */)
-  {
-    return
-      (   (N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified && N2 == unspecified && N1 == unspecified && N0 == unspecified) ? 0
-      : ( (N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified && N2 == unspecified && N1 == unspecified) ? 1
-      : ( (N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified && N2 == unspecified) ? 2
-      : ( (N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified) ? 3
-      : ( (N6 == unspecified && N5 == unspecified && N4 == unspecified) ? 4
-      : ( (N6 == unspecified && N5 == unspecified) ? 5
-      : ( (N6 == unspecified) ? 6
-      : 7 ) ) ) ) ) ) );
+  static size_t computeRank(const size_t N0, const size_t N1, const size_t N2,
+                            const size_t N3, const size_t N4, const size_t N5,
+                            const size_t N6, const size_t /* N7 */) {
+    return (
+        (N6 == unspecified && N5 == unspecified && N4 == unspecified &&
+         N3 == unspecified && N2 == unspecified && N1 == unspecified &&
+         N0 == unspecified)
+            ? 0
+            : ((N6 == unspecified && N5 == unspecified && N4 == unspecified &&
+                N3 == unspecified && N2 == unspecified && N1 == unspecified)
+                   ? 1
+                   : ((N6 == unspecified && N5 == unspecified &&
+                       N4 == unspecified && N3 == unspecified &&
+                       N2 == unspecified)
+                          ? 2
+                          : ((N6 == unspecified && N5 == unspecified &&
+                              N4 == unspecified && N3 == unspecified)
+                                 ? 3
+                                 : ((N6 == unspecified && N5 == unspecified &&
+                                     N4 == unspecified)
+                                        ? 4
+                                        : ((N6 == unspecified &&
+                                            N5 == unspecified)
+                                               ? 5
+                                               : ((N6 == unspecified)
+                                                      ? 6
+                                                      : 7)))))));
   }
 
   // Compute the rank of the view from the nonzero layout arguments.
   template <typename Layout>
-  KOKKOS_INLINE_FUNCTION
-  static size_t computeRank( const Layout& layout )
-  {
-    return computeRank( layout.dimension[0]
-                      , layout.dimension[1]
-                      , layout.dimension[2]
-                      , layout.dimension[3]
-                      , layout.dimension[4]
-                      , layout.dimension[5]
-                      , layout.dimension[6]
-                      , layout.dimension[7] );
+  KOKKOS_INLINE_FUNCTION static size_t computeRank(const Layout& layout) {
+    return computeRank(layout.dimension[0], layout.dimension[1],
+                       layout.dimension[2], layout.dimension[3],
+                       layout.dimension[4], layout.dimension[5],
+                       layout.dimension[6], layout.dimension[7]);
   }
 
   // Extra overload to match that for specialize types v2
-  template <typename Layout, typename ... P>
-  KOKKOS_INLINE_FUNCTION
-  static size_t computeRank( const Kokkos::Impl::ViewCtorProp<P...>& /* prop */, const Layout& layout )
-  {
+  template <typename Layout, typename... P>
+  KOKKOS_INLINE_FUNCTION static size_t computeRank(
+      const Kokkos::Impl::ViewCtorProp<P...>& /* prop */,
+      const Layout& layout) {
     return computeRank(layout);
   }
 
   // Create the layout for the rank-7 view.
   // Non-strided Layout
   template <typename Layout>
-  KOKKOS_INLINE_FUNCTION
-  static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutRight>::value || std::is_same<Layout , Kokkos::LayoutLeft>::value) , Layout >::type createLayout( const Layout& layout )
-  {
-    return Layout( layout.dimension[0] != unspecified ? layout.dimension[0] : 1
-                 , layout.dimension[1] != unspecified ? layout.dimension[1] : 1
-                 , layout.dimension[2] != unspecified ? layout.dimension[2] : 1
-                 , layout.dimension[3] != unspecified ? layout.dimension[3] : 1
-                 , layout.dimension[4] != unspecified ? layout.dimension[4] : 1
-                 , layout.dimension[5] != unspecified ? layout.dimension[5] : 1
-                 , layout.dimension[6] != unspecified ? layout.dimension[6] : 1
-                 , layout.dimension[7] != unspecified ? layout.dimension[7] : 1
-                 );
+  KOKKOS_INLINE_FUNCTION static typename std::enable_if<
+      (std::is_same<Layout, Kokkos::LayoutRight>::value ||
+       std::is_same<Layout, Kokkos::LayoutLeft>::value),
+      Layout>::type
+  createLayout(const Layout& layout) {
+    return Layout(layout.dimension[0] != unspecified ? layout.dimension[0] : 1,
+                  layout.dimension[1] != unspecified ? layout.dimension[1] : 1,
+                  layout.dimension[2] != unspecified ? layout.dimension[2] : 1,
+                  layout.dimension[3] != unspecified ? layout.dimension[3] : 1,
+                  layout.dimension[4] != unspecified ? layout.dimension[4] : 1,
+                  layout.dimension[5] != unspecified ? layout.dimension[5] : 1,
+                  layout.dimension[6] != unspecified ? layout.dimension[6] : 1,
+                  layout.dimension[7] != unspecified ? layout.dimension[7] : 1);
   }
 
   // LayoutStride
   template <typename Layout>
-  KOKKOS_INLINE_FUNCTION
-  static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutStride>::value) , Layout>::type createLayout( const Layout& layout )
-  {
-    return Layout( layout.dimension[0] != unspecified ? layout.dimension[0] : 1
-                 , layout.stride[0]
-                 , layout.dimension[1] != unspecified ? layout.dimension[1] : 1
-                 , layout.stride[1]
-                 , layout.dimension[2] != unspecified ? layout.dimension[2] : 1
-                 , layout.stride[2]
-                 , layout.dimension[3] != unspecified ? layout.dimension[3] : 1
-                 , layout.stride[3]
-                 , layout.dimension[4] != unspecified ? layout.dimension[4] : 1
-                 , layout.stride[4]
-                 , layout.dimension[5] != unspecified ? layout.dimension[5] : 1
-                 , layout.stride[5]
-                 , layout.dimension[6] != unspecified ? layout.dimension[6] : 1
-                 , layout.stride[6]
-                 , layout.dimension[7] != unspecified ? layout.dimension[7] : 1
-                 , layout.stride[7]
-                 );
+  KOKKOS_INLINE_FUNCTION static typename std::enable_if<
+      (std::is_same<Layout, Kokkos::LayoutStride>::value), Layout>::type
+  createLayout(const Layout& layout) {
+    return Layout(layout.dimension[0] != unspecified ? layout.dimension[0] : 1,
+                  layout.stride[0],
+                  layout.dimension[1] != unspecified ? layout.dimension[1] : 1,
+                  layout.stride[1],
+                  layout.dimension[2] != unspecified ? layout.dimension[2] : 1,
+                  layout.stride[2],
+                  layout.dimension[3] != unspecified ? layout.dimension[3] : 1,
+                  layout.stride[3],
+                  layout.dimension[4] != unspecified ? layout.dimension[4] : 1,
+                  layout.stride[4],
+                  layout.dimension[5] != unspecified ? layout.dimension[5] : 1,
+                  layout.stride[5],
+                  layout.dimension[6] != unspecified ? layout.dimension[6] : 1,
+                  layout.stride[6],
+                  layout.dimension[7] != unspecified ? layout.dimension[7] : 1,
+                  layout.stride[7]);
   }
 
   // Extra overload to match that for specialize types
-  template <typename Traits, typename ... P>
-  KOKKOS_INLINE_FUNCTION
-  static typename std::enable_if< (std::is_same<typename Traits::array_layout , Kokkos::LayoutRight>::value || std::is_same<typename Traits::array_layout , Kokkos::LayoutLeft>::value || std::is_same<typename Traits::array_layout , Kokkos::LayoutStride>::value) , typename Traits::array_layout >::type createLayout( const Kokkos::Impl::ViewCtorProp<P...>& /* prop */, const typename Traits::array_layout& layout )
-  {
-    return createLayout( layout );
+  template <typename Traits, typename... P>
+  KOKKOS_INLINE_FUNCTION static typename std::enable_if<
+      (std::is_same<typename Traits::array_layout,
+                    Kokkos::LayoutRight>::value ||
+       std::is_same<typename Traits::array_layout, Kokkos::LayoutLeft>::value ||
+       std::is_same<typename Traits::array_layout,
+                    Kokkos::LayoutStride>::value),
+      typename Traits::array_layout>::type
+  createLayout(const Kokkos::Impl::ViewCtorProp<P...>& /* prop */,
+               const typename Traits::array_layout& layout) {
+    return createLayout(layout);
   }
 
   // Create a view from the given dimension arguments.
   // This is only necessary because the shmem constructor doesn't take a layout.
-  //   NDE shmem View's are not compatible with the added view_alloc value_type / fad_dim deduction functionality
+  //   NDE shmem View's are not compatible with the added view_alloc value_type
+  //   / fad_dim deduction functionality
   template <typename ViewType, typename ViewArg>
-  static ViewType createView( const ViewArg& arg
-                            , const size_t N0
-                            , const size_t N1
-                            , const size_t N2
-                            , const size_t N3
-                            , const size_t N4
-                            , const size_t N5
-                            , const size_t N6
-                            , const size_t N7 )
-  {
-    return ViewType( arg
-                   , N0 != unspecified ? N0 : 1
-                   , N1 != unspecified ? N1 : 1
-                   , N2 != unspecified ? N2 : 1
-                   , N3 != unspecified ? N3 : 1
-                   , N4 != unspecified ? N4 : 1
-                   , N5 != unspecified ? N5 : 1
-                   , N6 != unspecified ? N6 : 1
-                   , N7 != unspecified ? N7 : 1 );
+  static ViewType createView(const ViewArg& arg, const size_t N0,
+                             const size_t N1, const size_t N2, const size_t N3,
+                             const size_t N4, const size_t N5, const size_t N6,
+                             const size_t N7) {
+    return ViewType(arg, N0 != unspecified ? N0 : 1, N1 != unspecified ? N1 : 1,
+                    N2 != unspecified ? N2 : 1, N3 != unspecified ? N3 : 1,
+                    N4 != unspecified ? N4 : 1, N5 != unspecified ? N5 : 1,
+                    N6 != unspecified ? N6 : 1, N7 != unspecified ? N7 : 1);
   }
 };
 
-  // Non-strided Layout
-  template <typename Layout , typename iType>
-  KOKKOS_INLINE_FUNCTION
-  static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutRight>::value || std::is_same<Layout , Kokkos::LayoutLeft>::value) && std::is_integral<iType>::value , Layout >::type
-  reconstructLayout( const Layout& layout , iType dynrank )
-  {
-    return Layout( dynrank > 0 ? layout.dimension[0] :KOKKOS_INVALID_INDEX
-                 , dynrank > 1 ? layout.dimension[1] :KOKKOS_INVALID_INDEX
-                 , dynrank > 2 ? layout.dimension[2] :KOKKOS_INVALID_INDEX
-                 , dynrank > 3 ? layout.dimension[3] :KOKKOS_INVALID_INDEX
-                 , dynrank > 4 ? layout.dimension[4] :KOKKOS_INVALID_INDEX
-                 , dynrank > 5 ? layout.dimension[5] :KOKKOS_INVALID_INDEX
-                 , dynrank > 6 ? layout.dimension[6] :KOKKOS_INVALID_INDEX
-                 , dynrank > 7 ? layout.dimension[7] :KOKKOS_INVALID_INDEX
-                 );
-  }
-
-  // LayoutStride
-  template <typename Layout , typename iType>
-  KOKKOS_INLINE_FUNCTION
-  static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutStride>::value) && std::is_integral<iType>::value , Layout >::type
-  reconstructLayout( const Layout& layout , iType dynrank )
-  {
-    return Layout( dynrank > 0 ? layout.dimension[0] :KOKKOS_INVALID_INDEX
-                 , dynrank > 0 ? layout.stride[0] : (0)
-                 , dynrank > 1 ? layout.dimension[1] :KOKKOS_INVALID_INDEX
-                 , dynrank > 1 ? layout.stride[1] : (0)
-                 , dynrank > 2 ? layout.dimension[2] :KOKKOS_INVALID_INDEX
-                 , dynrank > 2 ? layout.stride[2] : (0)
-                 , dynrank > 3 ? layout.dimension[3] :KOKKOS_INVALID_INDEX
-                 , dynrank > 3 ? layout.stride[3] : (0)
-                 , dynrank > 4 ? layout.dimension[4] :KOKKOS_INVALID_INDEX
-                 , dynrank > 4 ? layout.stride[4] : (0)
-                 , dynrank > 5 ? layout.dimension[5] :KOKKOS_INVALID_INDEX
-                 , dynrank > 5 ? layout.stride[5] : (0)
-                 , dynrank > 6 ? layout.dimension[6] :KOKKOS_INVALID_INDEX
-                 , dynrank > 6 ? layout.stride[6] : (0)
-                 , dynrank > 7 ? layout.dimension[7] :KOKKOS_INVALID_INDEX
-                 , dynrank > 7 ? layout.stride[7] : (0)
-                 );
-  }
+// Non-strided Layout
+template <typename Layout, typename iType>
+KOKKOS_INLINE_FUNCTION static
+    typename std::enable_if<(std::is_same<Layout, Kokkos::LayoutRight>::value ||
+                             std::is_same<Layout, Kokkos::LayoutLeft>::value) &&
+                                std::is_integral<iType>::value,
+                            Layout>::type
+    reconstructLayout(const Layout& layout, iType dynrank) {
+  return Layout(dynrank > 0 ? layout.dimension[0] : KOKKOS_INVALID_INDEX,
+                dynrank > 1 ? layout.dimension[1] : KOKKOS_INVALID_INDEX,
+                dynrank > 2 ? layout.dimension[2] : KOKKOS_INVALID_INDEX,
+                dynrank > 3 ? layout.dimension[3] : KOKKOS_INVALID_INDEX,
+                dynrank > 4 ? layout.dimension[4] : KOKKOS_INVALID_INDEX,
+                dynrank > 5 ? layout.dimension[5] : KOKKOS_INVALID_INDEX,
+                dynrank > 6 ? layout.dimension[6] : KOKKOS_INVALID_INDEX,
+                dynrank > 7 ? layout.dimension[7] : KOKKOS_INVALID_INDEX);
+}
 
+// LayoutStride
+template <typename Layout, typename iType>
+KOKKOS_INLINE_FUNCTION static typename std::enable_if<
+    (std::is_same<Layout, Kokkos::LayoutStride>::value) &&
+        std::is_integral<iType>::value,
+    Layout>::type
+reconstructLayout(const Layout& layout, iType dynrank) {
+  return Layout(dynrank > 0 ? layout.dimension[0] : KOKKOS_INVALID_INDEX,
+                dynrank > 0 ? layout.stride[0] : (0),
+                dynrank > 1 ? layout.dimension[1] : KOKKOS_INVALID_INDEX,
+                dynrank > 1 ? layout.stride[1] : (0),
+                dynrank > 2 ? layout.dimension[2] : KOKKOS_INVALID_INDEX,
+                dynrank > 2 ? layout.stride[2] : (0),
+                dynrank > 3 ? layout.dimension[3] : KOKKOS_INVALID_INDEX,
+                dynrank > 3 ? layout.stride[3] : (0),
+                dynrank > 4 ? layout.dimension[4] : KOKKOS_INVALID_INDEX,
+                dynrank > 4 ? layout.stride[4] : (0),
+                dynrank > 5 ? layout.dimension[5] : KOKKOS_INVALID_INDEX,
+                dynrank > 5 ? layout.stride[5] : (0),
+                dynrank > 6 ? layout.dimension[6] : KOKKOS_INVALID_INDEX,
+                dynrank > 6 ? layout.stride[6] : (0),
+                dynrank > 7 ? layout.dimension[7] : KOKKOS_INVALID_INDEX,
+                dynrank > 7 ? layout.stride[7] : (0));
+}
 
 /** \brief  Debug bounds-checking routines */
 // Enhanced debug checking - most infrastructure matches that of functions in
 // Kokkos_ViewMapping; additional checks for extra arguments beyond rank are 0
-template< unsigned ,  typename iType0 , class MapType >
-KOKKOS_INLINE_FUNCTION
-bool dyn_rank_view_verify_operator_bounds( const iType0 & , const MapType & )
-{ return true ; }
-
-template< unsigned R , typename iType0 ,  class MapType , typename iType1 , class ... Args >
-KOKKOS_INLINE_FUNCTION
-bool dyn_rank_view_verify_operator_bounds
-  ( const iType0  & rank
-  , const MapType & map
-  , const iType1  & i
-  , Args ... args
-  )
-{
-  if ( static_cast<iType0>(R) < rank ) {
-    return ( size_t(i) < map.extent(R) )
-       && dyn_rank_view_verify_operator_bounds<R+1>( rank , map , args ... );
-  }
-  else if ( i != 0 ) {
-    printf("DynRankView Debug Bounds Checking Error: at rank %u\n  Extra arguments beyond the rank must be zero \n",R);
-    return ( false )
-       && dyn_rank_view_verify_operator_bounds<R+1>( rank , map , args ... );
-  }
-  else {
-    return ( true )
-       && dyn_rank_view_verify_operator_bounds<R+1>( rank , map , args ... );
+template <unsigned, typename iType0, class MapType>
+KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(
+    const iType0&, const MapType&) {
+  return true;
+}
+
+template <unsigned R, typename iType0, class MapType, typename iType1,
+          class... Args>
+KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(
+    const iType0& rank, const MapType& map, const iType1& i, Args... args) {
+  if (static_cast<iType0>(R) < rank) {
+    return (size_t(i) < map.extent(R)) &&
+           dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
+  } else if (i != 0) {
+    printf(
+        "DynRankView Debug Bounds Checking Error: at rank %u\n  Extra "
+        "arguments beyond the rank must be zero \n",
+        R);
+    return (false) &&
+           dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
+  } else {
+    return (true) &&
+           dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
   }
 }
 
-template< unsigned , class MapType >
-inline
-void dyn_rank_view_error_operator_bounds( char * , int , const MapType & )
-{}
-
-template< unsigned R , class MapType , class iType , class ... Args >
-inline
-void dyn_rank_view_error_operator_bounds
-  ( char * buf
-  , int len
-  , const MapType & map
-  , const iType   & i
-  , Args ... args
-  )
-{
-  const int n =
-    snprintf(buf,len," %ld < %ld %c"
-            , static_cast<unsigned long>(i)
-            , static_cast<unsigned long>( map.extent(R) )
-            , ( sizeof...(Args) ? ',' : ')' )
-            );
-  dyn_rank_view_error_operator_bounds<R+1>(buf+n,len-n,map,args...);
+template <unsigned, class MapType>
+inline void dyn_rank_view_error_operator_bounds(char*, int, const MapType&) {}
+
+template <unsigned R, class MapType, class iType, class... Args>
+inline void dyn_rank_view_error_operator_bounds(char* buf, int len,
+                                                const MapType& map,
+                                                const iType& i, Args... args) {
+  const int n = snprintf(
+      buf, len, " %ld < %ld %c", static_cast<unsigned long>(i),
+      static_cast<unsigned long>(map.extent(R)), (sizeof...(Args) ? ',' : ')'));
+  dyn_rank_view_error_operator_bounds<R + 1>(buf + n, len - n, map, args...);
 }
 
 // op_rank = rank of the operator version that was called
-template< typename MemorySpace
-        , typename iType0 , typename iType1 ,  class MapType , class ... Args >
-KOKKOS_INLINE_FUNCTION
-void dyn_rank_view_verify_operator_bounds
-  ( const iType0 & op_rank , const iType1 & rank
-  , const Kokkos::Impl::SharedAllocationTracker & tracker
-  , const MapType & map , Args ... args )
-{
-  if ( static_cast<iType0>(rank) > op_rank ) {
-    Kokkos::abort( "DynRankView Bounds Checking Error: Need at least rank arguments to the operator()" );
-  }
-
-  if ( ! dyn_rank_view_verify_operator_bounds<0>( rank , map , args ... ) ) {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+template <typename MemorySpace, typename iType0, typename iType1, class MapType,
+          class... Args>
+KOKKOS_INLINE_FUNCTION void dyn_rank_view_verify_operator_bounds(
+    const iType0& op_rank, const iType1& rank,
+    const Kokkos::Impl::SharedAllocationTracker& tracker, const MapType& map,
+    Args... args) {
+  if (static_cast<iType0>(rank) > op_rank) {
+    Kokkos::abort(
+        "DynRankView Bounds Checking Error: Need at least rank arguments to "
+        "the operator()");
+  }
+
+  if (!dyn_rank_view_verify_operator_bounds<0>(rank, map, args...)) {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
     enum { LEN = 1024 };
-    char buffer[ LEN ];
+    char buffer[LEN];
     const std::string label = tracker.template get_label<MemorySpace>();
-    int n = snprintf(buffer,LEN,"DynRankView bounds error of view %s (", label.c_str());
-    dyn_rank_view_error_operator_bounds<0>( buffer + n , LEN - n , map , args ... );
+    int n = snprintf(buffer, LEN, "DynRankView bounds error of view %s (",
+                     label.c_str());
+    dyn_rank_view_error_operator_bounds<0>(buffer + n, LEN - n, map, args...);
     Kokkos::Impl::throw_runtime_exception(std::string(buffer));
 #else
     Kokkos::abort("DynRankView bounds error");
@@ -312,86 +298,84 @@ void dyn_rank_view_verify_operator_bounds
   }
 }
 
-
 /** \brief  Assign compatible default mappings */
 struct ViewToDynRankViewTag {};
 
-} // namespace Impl
+}  // namespace Impl
 
 namespace Impl {
 
-template< class DstTraits , class SrcTraits >
-class ViewMapping< DstTraits , SrcTraits ,
-  typename std::enable_if<(
-    std::is_same< typename DstTraits::memory_space , typename SrcTraits::memory_space >::value
-    &&
-    std::is_same< typename DstTraits::specialize , void >::value
-    &&
-    std::is_same< typename SrcTraits::specialize , void >::value
-    &&
-    (
-      std::is_same< typename DstTraits::array_layout , typename SrcTraits::array_layout >::value
-      ||
-      (
-        (
-          std::is_same< typename DstTraits::array_layout , Kokkos::LayoutLeft >::value ||
-          std::is_same< typename DstTraits::array_layout , Kokkos::LayoutRight >::value ||
-          std::is_same< typename DstTraits::array_layout , Kokkos::LayoutStride >::value
-        )
-        &&
-        (
-          std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value ||
-          std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value ||
-          std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutStride >::value
-        )
-      )
-    )
-  ) , Kokkos::Impl::ViewToDynRankViewTag >::type >
-{
-private:
-
-  enum { is_assignable_value_type =
-    std::is_same< typename DstTraits::value_type
-                , typename SrcTraits::value_type >::value ||
-    std::is_same< typename DstTraits::value_type
-                , typename SrcTraits::const_value_type >::value };
-
-  enum { is_assignable_layout =
-    std::is_same< typename DstTraits::array_layout
-                , typename SrcTraits::array_layout >::value ||
-    std::is_same< typename DstTraits::array_layout
-                , Kokkos::LayoutStride >::value
-    };
+template <class DstTraits, class SrcTraits>
+class ViewMapping<
+    DstTraits, SrcTraits,
+    typename std::enable_if<
+        (std::is_same<typename DstTraits::memory_space,
+                      typename SrcTraits::memory_space>::value &&
+         std::is_same<typename DstTraits::specialize, void>::value &&
+         std::is_same<typename SrcTraits::specialize, void>::value &&
+         (std::is_same<typename DstTraits::array_layout,
+                       typename SrcTraits::array_layout>::value ||
+          ((std::is_same<typename DstTraits::array_layout,
+                         Kokkos::LayoutLeft>::value ||
+            std::is_same<typename DstTraits::array_layout,
+                         Kokkos::LayoutRight>::value ||
+            std::is_same<typename DstTraits::array_layout,
+                         Kokkos::LayoutStride>::value) &&
+           (std::is_same<typename SrcTraits::array_layout,
+                         Kokkos::LayoutLeft>::value ||
+            std::is_same<typename SrcTraits::array_layout,
+                         Kokkos::LayoutRight>::value ||
+            std::is_same<typename SrcTraits::array_layout,
+                         Kokkos::LayoutStride>::value)))),
+        Kokkos::Impl::ViewToDynRankViewTag>::type> {
+ private:
+  enum {
+    is_assignable_value_type =
+        std::is_same<typename DstTraits::value_type,
+                     typename SrcTraits::value_type>::value ||
+        std::is_same<typename DstTraits::value_type,
+                     typename SrcTraits::const_value_type>::value
+  };
 
-public:
+  enum {
+    is_assignable_layout =
+        std::is_same<typename DstTraits::array_layout,
+                     typename SrcTraits::array_layout>::value ||
+        std::is_same<typename DstTraits::array_layout,
+                     Kokkos::LayoutStride>::value
+  };
 
-  enum { is_assignable = is_assignable_value_type &&
-                         is_assignable_layout };
+ public:
+  enum { is_assignable = is_assignable_value_type && is_assignable_layout };
 
-  typedef ViewMapping< DstTraits , typename DstTraits::specialize >  DstType ;
-  typedef ViewMapping< SrcTraits , typename SrcTraits::specialize >  SrcType ;
+  typedef ViewMapping<DstTraits, typename DstTraits::specialize> DstType;
+  typedef ViewMapping<SrcTraits, typename SrcTraits::specialize> SrcType;
 
-  template < typename DT , typename ... DP , typename ST , typename ... SP >
-  KOKKOS_INLINE_FUNCTION
-  static void assign( Kokkos::DynRankView< DT , DP...> & dst ,  const Kokkos::View< ST , SP... > & src )
-    {
-      static_assert( is_assignable_value_type
-                   , "View assignment must have same value type or const = non-const" );
+  template <typename DT, typename... DP, typename ST, typename... SP>
+  KOKKOS_INLINE_FUNCTION static void assign(
+      Kokkos::DynRankView<DT, DP...>& dst, const Kokkos::View<ST, SP...>& src) {
+    static_assert(
+        is_assignable_value_type,
+        "View assignment must have same value type or const = non-const");
 
-      static_assert( is_assignable_layout
-                   , "View assignment must have compatible layout or have rank <= 1" );
+    static_assert(
+        is_assignable_layout,
+        "View assignment must have compatible layout or have rank <= 1");
 
     // Removed dimension checks...
 
-      typedef typename DstType::offset_type  dst_offset_type ;
-      dst.m_map.m_impl_offset = dst_offset_type(std::integral_constant<unsigned,0>() , src.layout() ); //Check this for integer input1 for padding, etc
-      dst.m_map.m_impl_handle = Kokkos::Impl::ViewDataHandle< DstTraits >::assign( src.m_map.m_impl_handle , src.m_track );
-      dst.m_track.assign( src.m_track , DstTraits::is_managed );
-      dst.m_rank = src.Rank ;
-    }
+    typedef typename DstType::offset_type dst_offset_type;
+    dst.m_map.m_impl_offset = dst_offset_type(
+        std::integral_constant<unsigned, 0>(),
+        src.layout());  // Check this for integer input1 for padding, etc
+    dst.m_map.m_impl_handle = Kokkos::Impl::ViewDataHandle<DstTraits>::assign(
+        src.m_map.m_impl_handle, src.m_track);
+    dst.m_track.assign(src.m_track, DstTraits::is_managed);
+    dst.m_rank = src.Rank;
+  }
 };
 
-} //end Impl
+}  // namespace Impl
 
 /* \class DynRankView
  * \brief Container that creates a Kokkos view with rank determined at runtime.
@@ -400,7 +384,8 @@ public:
  *   Changes from View
  *   1. The rank of the DynRankView is returned by the method rank()
  *   2. Max rank of a DynRankView is 7
- *   3. subview called with 'subview(...)' or 'subdynrankview(...)' (backward compatibility) 
+ *   3. subview called with 'subview(...)' or 'subdynrankview(...)' (backward
+ * compatibility)
  *   4. Every subview is returned with LayoutStride
  *   5. Copy and Copy-Assign View to DynRankView
  *   6. deep_copy between Views and DynRankViews
@@ -408,93 +393,99 @@ public:
  *
  */
 
-template< class > struct is_dyn_rank_view : public std::false_type {};
-
-template< class D, class ... P >
-struct is_dyn_rank_view< Kokkos::DynRankView<D,P...> > : public std::true_type {};
+template <class>
+struct is_dyn_rank_view : public std::false_type {};
 
+template <class D, class... P>
+struct is_dyn_rank_view<Kokkos::DynRankView<D, P...> > : public std::true_type {
+};
 
-template< typename DataType , class ... Properties >
-class DynRankView : public ViewTraits< DataType , Properties ... >
-{
-  static_assert( !std::is_array<DataType>::value && !std::is_pointer<DataType>::value , "Cannot template DynRankView with array or pointer datatype - must be pod" );
-
-private:
-  template < class , class ... > friend class DynRankView ;
-  template < class , class ... > friend class Kokkos::Impl::ViewMapping ;
+template <typename DataType, class... Properties>
+class DynRankView : public ViewTraits<DataType, Properties...> {
+  static_assert(!std::is_array<DataType>::value &&
+                    !std::is_pointer<DataType>::value,
+                "Cannot template DynRankView with array or pointer datatype - "
+                "must be pod");
 
-public:
-  typedef ViewTraits< DataType , Properties ... > drvtraits ;
+ private:
+  template <class, class...>
+  friend class DynRankView;
+  template <class, class...>
+  friend class Kokkos::Impl::ViewMapping;
 
-  typedef View< DataType******* , Properties...> view_type ;
+ public:
+  typedef ViewTraits<DataType, Properties...> drvtraits;
 
-  typedef ViewTraits< DataType******* , Properties ... > traits ;
+  typedef View<DataType*******, Properties...> view_type;
 
+  typedef ViewTraits<DataType*******, Properties...> traits;
 
-private:
-  typedef Kokkos::Impl::ViewMapping< traits , typename traits::specialize > map_type ;
-  typedef Kokkos::Impl::SharedAllocationTracker      track_type ;
+ private:
+  typedef Kokkos::Impl::ViewMapping<traits, typename traits::specialize>
+      map_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
 
-  track_type  m_track ;
-  map_type    m_map ;
+  track_type m_track;
+  map_type m_map;
   unsigned m_rank;
 
-public:
+ public:
   KOKKOS_INLINE_FUNCTION
-  view_type & DownCast() const { return ( view_type & ) (*this); }
+  view_type& DownCast() const { return (view_type&)(*this); }
   KOKKOS_INLINE_FUNCTION
-  const view_type & ConstDownCast() const { return (const view_type & ) (*this); }
+  const view_type& ConstDownCast() const { return (const view_type&)(*this); }
 
-  //Types below - at least the HostMirror requires the value_type, NOT the rank 7 data_type of the traits
+  // Types below - at least the HostMirror requires the value_type, NOT the rank
+  // 7 data_type of the traits
 
   /** \brief  Compatible view of array of scalar types */
-  typedef DynRankView< typename drvtraits::scalar_array_type ,
-                typename drvtraits::array_layout ,
-                typename drvtraits::device_type ,
-                typename drvtraits::memory_traits >
-    array_type ;
+  typedef DynRankView<
+      typename drvtraits::scalar_array_type, typename drvtraits::array_layout,
+      typename drvtraits::device_type, typename drvtraits::memory_traits>
+      array_type;
 
   /** \brief  Compatible view of const data type */
-  typedef DynRankView< typename drvtraits::const_data_type ,
-                typename drvtraits::array_layout ,
-                typename drvtraits::device_type ,
-                typename drvtraits::memory_traits >
-    const_type ;
+  typedef DynRankView<
+      typename drvtraits::const_data_type, typename drvtraits::array_layout,
+      typename drvtraits::device_type, typename drvtraits::memory_traits>
+      const_type;
 
   /** \brief  Compatible view of non-const data type */
-  typedef DynRankView< typename drvtraits::non_const_data_type ,
-                typename drvtraits::array_layout ,
-                typename drvtraits::device_type ,
-                typename drvtraits::memory_traits >
-    non_const_type ;
+  typedef DynRankView<
+      typename drvtraits::non_const_data_type, typename drvtraits::array_layout,
+      typename drvtraits::device_type, typename drvtraits::memory_traits>
+      non_const_type;
 
   /** \brief  Compatible HostMirror view */
-  typedef DynRankView< typename drvtraits::non_const_data_type ,
-                typename drvtraits::array_layout ,
-                typename drvtraits::host_mirror_space >
-    HostMirror ;
-
+  typedef DynRankView<typename drvtraits::non_const_data_type,
+                      typename drvtraits::array_layout,
+                      typename drvtraits::host_mirror_space>
+      HostMirror;
 
   //----------------------------------------
   // Domain rank and extents
 
-//  enum { Rank = map_type::Rank }; //Will be dyn rank of 7 always, keep the enum?
+  //  enum { Rank = map_type::Rank }; //Will be dyn rank of 7 always, keep the
+  //  enum?
 
-  template< typename iType >
+  template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr
-  typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-  extent( const iType & r ) const
-    { return m_map.extent(r); }
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      extent(const iType& r) const {
+    return m_map.extent(r);
+  }
 
-  template< typename iType >
+  template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr
-  typename std::enable_if< std::is_integral<iType>::value , int >::type
-  extent_int( const iType & r ) const
-    { return static_cast<int>(m_map.extent(r)); }
+      typename std::enable_if<std::is_integral<iType>::value, int>::type
+      extent_int(const iType& r) const {
+    return static_cast<int>(m_map.extent(r));
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr
-  typename traits::array_layout layout() const
-    { return m_map.layout(); }
+  KOKKOS_INLINE_FUNCTION constexpr typename traits::array_layout layout()
+      const {
+    return m_map.layout();
+  }
 
   //----------------------------------------
   /*  Deprecate all 'dimension' functions in favor of
@@ -502,421 +493,572 @@ public:
    */
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  template< typename iType >
+  template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr
-  typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-  dimension( const iType & r ) const { return extent( r ); }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const { return m_map.dimension_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return m_map.dimension_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return m_map.dimension_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return m_map.dimension_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return m_map.dimension_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return m_map.dimension_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return m_map.dimension_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return m_map.dimension_7(); }
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      dimension(const iType& r) const {
+    return extent(r);
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const {
+    return m_map.dimension_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const {
+    return m_map.dimension_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const {
+    return m_map.dimension_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const {
+    return m_map.dimension_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const {
+    return m_map.dimension_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const {
+    return m_map.dimension_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const {
+    return m_map.dimension_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const {
+    return m_map.dimension_7();
+  }
 #endif
 
   //----------------------------------------
 
-  KOKKOS_INLINE_FUNCTION constexpr size_t size() const { return m_map.extent(0) *
-                                                                m_map.extent(1) *
-                                                                m_map.extent(2) *
-                                                                m_map.extent(3) *
-                                                                m_map.extent(4) *
-                                                                m_map.extent(5) *
-                                                                m_map.extent(6) *
-                                                                m_map.extent(7); }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return m_map.stride_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return m_map.stride_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return m_map.stride_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return m_map.stride_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return m_map.stride_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return m_map.stride_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return m_map.stride_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return m_map.stride_7(); }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION void stride( iType * const s ) const { m_map.stride(s); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t size() const {
+    return m_map.extent(0) * m_map.extent(1) * m_map.extent(2) *
+           m_map.extent(3) * m_map.extent(4) * m_map.extent(5) *
+           m_map.extent(6) * m_map.extent(7);
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const {
+    return m_map.stride_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const {
+    return m_map.stride_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const {
+    return m_map.stride_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const {
+    return m_map.stride_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const {
+    return m_map.stride_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const {
+    return m_map.stride_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const {
+    return m_map.stride_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const {
+    return m_map.stride_7();
+  }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    m_map.stride(s);
+  }
 
   //----------------------------------------
   // Range span is the span which contains all members.
 
-  typedef typename map_type::reference_type  reference_type ;
-  typedef typename map_type::pointer_type    pointer_type ;
+  typedef typename map_type::reference_type reference_type;
+  typedef typename map_type::pointer_type pointer_type;
 
-  enum { reference_type_is_lvalue_reference = std::is_lvalue_reference< reference_type >::value };
+  enum {
+    reference_type_is_lvalue_reference =
+        std::is_lvalue_reference<reference_type>::value
+  };
 
   KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return m_map.span(); }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   // Deprecated, use 'span()' instead
-  KOKKOS_INLINE_FUNCTION constexpr size_t capacity() const { return m_map.span(); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t capacity() const {
+    return m_map.span();
+  }
 #endif
-  KOKKOS_INLINE_FUNCTION constexpr bool   span_is_contiguous() const { return m_map.span_is_contiguous(); }
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return m_map.data(); }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return m_map.span_is_contiguous();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const {
+    return m_map.data();
+  }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   // Deprecated, use 'span_is_contigous()' instead
-  KOKKOS_INLINE_FUNCTION constexpr bool   is_contiguous() const { return m_map.span_is_contiguous(); }
+  KOKKOS_INLINE_FUNCTION constexpr bool is_contiguous() const {
+    return m_map.span_is_contiguous();
+  }
   // Deprecated, use 'data()' instead
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type ptr_on_device() const { return m_map.data(); }
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type ptr_on_device() const {
+    return m_map.data();
+  }
 #endif
 
   //----------------------------------------
   // Allow specializations to query their specialized map
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   KOKKOS_INLINE_FUNCTION
-  const Kokkos::Impl::ViewMapping< traits , typename traits::specialize > &
-  implementation_map() const { return m_map ; }
+  const Kokkos::Impl::ViewMapping<traits, typename traits::specialize>&
+  implementation_map() const {
+    return m_map;
+  }
 #endif
   KOKKOS_INLINE_FUNCTION
-  const Kokkos::Impl::ViewMapping< traits , typename traits::specialize > &
-  impl_map() const { return m_map ; }
+  const Kokkos::Impl::ViewMapping<traits, typename traits::specialize>&
+  impl_map() const {
+    return m_map;
+  }
 
   //----------------------------------------
 
-private:
-
+ private:
   enum {
-    is_layout_left = std::is_same< typename traits::array_layout
-                                  , Kokkos::LayoutLeft >::value ,
+    is_layout_left =
+        std::is_same<typename traits::array_layout, Kokkos::LayoutLeft>::value,
 
-    is_layout_right = std::is_same< typename traits::array_layout
-                                  , Kokkos::LayoutRight >::value ,
+    is_layout_right =
+        std::is_same<typename traits::array_layout, Kokkos::LayoutRight>::value,
 
-    is_layout_stride = std::is_same< typename traits::array_layout
-                                   , Kokkos::LayoutStride >::value ,
+    is_layout_stride = std::is_same<typename traits::array_layout,
+                                    Kokkos::LayoutStride>::value,
 
-    is_default_map =
-      std::is_same< typename traits::specialize , void >::value &&
-      ( is_layout_left || is_layout_right || is_layout_stride )
+    is_default_map = std::is_same<typename traits::specialize, void>::value &&
+                     (is_layout_left || is_layout_right || is_layout_stride)
   };
 
-  template< class Space , bool = Kokkos::Impl::MemorySpaceAccess< Space , typename traits::memory_space >::accessible > struct verify_space
-    { KOKKOS_FORCEINLINE_FUNCTION static void check() {} };
+  template <class Space, bool = Kokkos::Impl::MemorySpaceAccess<
+                             Space, typename traits::memory_space>::accessible>
+  struct verify_space {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {}
+  };
 
-  template< class Space > struct verify_space<Space,false>
-    { KOKKOS_FORCEINLINE_FUNCTION static void check()
-        { Kokkos::abort("Kokkos::DynRankView ERROR: attempt to access inaccessible memory space"); };
+  template <class Space>
+  struct verify_space<Space, false> {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {
+      Kokkos::abort(
+          "Kokkos::DynRankView ERROR: attempt to access inaccessible memory "
+          "space");
     };
+  };
 
 // Bounds checking macros
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
 
 // rank of the calling operator - included as first argument in ARG
-#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( ARG ) \
-  DynRankView::template verify_space< Kokkos::Impl::ActiveExecutionMemorySpace >::check(); \
-  Kokkos::Impl::dyn_rank_view_verify_operator_bounds< typename traits::memory_space > ARG ;
+#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG)             \
+  DynRankView::template verify_space<                     \
+      Kokkos::Impl::ActiveExecutionMemorySpace>::check(); \
+  Kokkos::Impl::dyn_rank_view_verify_operator_bounds<     \
+      typename traits::memory_space>                      \
+      ARG;
 
 #else
 
-#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( ARG ) \
-  DynRankView::template verify_space< Kokkos::Impl::ActiveExecutionMemorySpace >::check();
+#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG) \
+  DynRankView::template verify_space<         \
+      Kokkos::Impl::ActiveExecutionMemorySpace>::check();
 
 #endif
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
   constexpr unsigned rank() const { return m_rank; }
 
-
-  //operators ()
+  // operators ()
   // Rank 0
   KOKKOS_INLINE_FUNCTION
-  reference_type operator()() const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (0 , this->rank(), m_track, m_map) )
-      return impl_map().reference();
-      //return m_map.reference(0,0,0,0,0,0,0);
-    }
+  reference_type operator()() const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((0, this->rank(), m_track, m_map))
+    return impl_map().reference();
+    // return m_map.reference(0,0,0,0,0,0,0);
+  }
 
   // Rank 1
-  // This assumes a contiguous underlying memory (i.e. no padding, no striding...)
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< std::is_same<typename drvtraits::value_type, typename drvtraits::scalar_array_type>::value && std::is_integral<iType>::value, reference_type>::type
-  operator[](const iType & i0) const
-    {
-      //Phalanx is violating this, since they use the operator to access ALL elements in the allocation
-      //KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (1 , this->rank(), m_track, m_map) )
-      return data()[i0];
-    }
+  // This assumes a contiguous underlying memory (i.e. no padding, no
+  // striding...)
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      std::is_same<typename drvtraits::value_type,
+                   typename drvtraits::scalar_array_type>::value &&
+          std::is_integral<iType>::value,
+      reference_type>::type
+  operator[](const iType& i0) const {
+    // Phalanx is violating this, since they use the operator to access ALL
+    // elements in the allocation KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (1 ,
+    // this->rank(), m_track, m_map) )
+    return data()[i0];
+  }
 
-  // This assumes a contiguous underlying memory (i.e. no padding, no striding...
-  // AND a Trilinos/Sacado scalar type )
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !std::is_same<typename drvtraits::value_type, typename drvtraits::scalar_array_type>::value && std::is_integral<iType>::value, reference_type>::type
-  operator[](const iType & i0) const
-    {
-//      auto map = impl_map();
-      const size_t dim_scalar = m_map.dimension_scalar();
-      const size_t bytes = this->span() / dim_scalar;
-
-      typedef Kokkos::View<DataType*, typename traits::array_layout, typename traits::device_type, Kokkos::MemoryTraits<traits::memory_traits::is_unmanaged | traits::memory_traits::is_random_access | traits::memory_traits::is_atomic> > tmp_view_type;
-      tmp_view_type rankone_view(this->data(), bytes, dim_scalar);
-      return rankone_view(i0);
-    }
+  // This assumes a contiguous underlying memory (i.e. no padding, no
+  // striding... AND a Trilinos/Sacado scalar type )
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !std::is_same<typename drvtraits::value_type,
+                    typename drvtraits::scalar_array_type>::value &&
+          std::is_integral<iType>::value,
+      reference_type>::type
+  operator[](const iType& i0) const {
+    //      auto map = impl_map();
+    const size_t dim_scalar = m_map.dimension_scalar();
+    const size_t bytes      = this->span() / dim_scalar;
+
+    typedef Kokkos::View<
+        DataType*, typename traits::array_layout, typename traits::device_type,
+        Kokkos::MemoryTraits<traits::memory_traits::is_unmanaged |
+                             traits::memory_traits::is_random_access |
+                             traits::memory_traits::is_atomic> >
+        tmp_view_type;
+    tmp_view_type rankone_view(this->data(), bytes, dim_scalar);
+    return rankone_view(i0);
+  }
 
   // Rank 1 parenthesis
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType>::value), reference_type>::type
-  operator()(const iType & i0 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (1 , this->rank(), m_track, m_map, i0) )
-      return m_map.reference(i0);
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType>::value),
+      reference_type>::type
+  operator()(const iType& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
+    return m_map.reference(i0);
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename traits::specialize , void>::value && std::is_integral<iType>::value), reference_type>::type
-  operator()(const iType & i0 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (1 , this->rank(), m_track, m_map, i0) )
-      return m_map.reference(i0,0,0,0,0,0,0);
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename traits::specialize, void>::value &&
+        std::is_integral<iType>::value),
+      reference_type>::type
+  operator()(const iType& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
+    return m_map.reference(i0, 0, 0, 0, 0, 0, 0);
+  }
 
   // Rank 2
-  template< typename iType0 , typename iType1 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (2 , this->rank(), m_track, m_map, i0, i1) )
-      return m_map.reference(i0,i1);
-    }
+  template <typename iType0, typename iType1>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
+    return m_map.reference(i0, i1);
+  }
 
-  template< typename iType0 , typename iType1 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (2 , this->rank(), m_track, m_map, i0, i1) )
-      return m_map.reference(i0,i1,0,0,0,0,0);
-    }
+  template <typename iType0, typename iType1>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
+    return m_map.reference(i0, i1, 0, 0, 0, 0, 0);
+  }
 
   // Rank 3
-  template< typename iType0 , typename iType1 , typename iType2 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (3 , this->rank(), m_track, m_map, i0, i1, i2) )
-      return m_map.reference(i0,i1,i2);
-    }
+  template <typename iType0, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (3, this->rank(), m_track, m_map, i0, i1, i2))
+    return m_map.reference(i0, i1, i2);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (3 , this->rank(), m_track, m_map, i0, i1, i2) )
-      return m_map.reference(i0,i1,i2,0,0,0,0);
-    }
+  template <typename iType0, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (3, this->rank(), m_track, m_map, i0, i1, i2))
+    return m_map.reference(i0, i1, i2, 0, 0, 0, 0);
+  }
 
   // Rank 4
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (4 , this->rank(), m_track, m_map, i0, i1, i2, i3) )
-      return m_map.reference(i0,i1,i2,i3);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2,
+             const iType3& i3) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
+    return m_map.reference(i0, i1, i2, i3);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (4 , this->rank(), m_track, m_map, i0, i1, i2, i3) )
-      return m_map.reference(i0,i1,i2,i3,0,0,0);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2,
+             const iType3& i3) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
+    return m_map.reference(i0, i1, i2, i3, 0, 0, 0);
+  }
 
   // Rank 5
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value && std::is_integral<iType4>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (5 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4) )
-      return m_map.reference(i0,i1,i2,i3,i4);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
+       std::is_integral<iType4>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2,
+             const iType3& i3, const iType4& i4) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
+    return m_map.reference(i0, i1, i2, i3, i4);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (5 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4) )
-      return m_map.reference(i0,i1,i2,i3,i4,0,0);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2,
+             const iType3& i3, const iType4& i4) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
+    return m_map.reference(i0, i1, i2, i3, i4, 0, 0);
+  }
 
   // Rank 6
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value && std::is_integral<iType4>::value && std::is_integral<iType5>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (6 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4, typename iType5>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
+       std::is_integral<iType4>::value && std::is_integral<iType5>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2,
+             const iType3& i3, const iType4& i4, const iType5& i5) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
+    return m_map.reference(i0, i1, i2, i3, i4, i5);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (6 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5,0);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4, typename iType5>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2,
+             const iType3& i3, const iType4& i4, const iType5& i5) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, 0);
+  }
 
   // Rank 7
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 , typename iType6 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value && std::is_integral<iType4>::value && std::is_integral<iType5>::value && std::is_integral<iType6>::value), reference_type>::type
-  operator()(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 , const iType6 & i6 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (7 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5, i6) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5,i6);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4, typename iType5, typename iType6>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
+       std::is_integral<iType4>::value && std::is_integral<iType5>::value &&
+       std::is_integral<iType6>::value),
+      reference_type>::type
+  operator()(const iType0& i0, const iType1& i1, const iType2& i2,
+             const iType3& i3, const iType4& i4, const iType5& i5,
+             const iType6& i6) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (7, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5, i6))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
+  }
 
   // Rank 0
   KOKKOS_INLINE_FUNCTION
-  reference_type access() const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (0 , this->rank(), m_track, m_map) )
-      return impl_map().reference();
-      //return m_map.reference(0,0,0,0,0,0,0);
-    }
+  reference_type access() const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((0, this->rank(), m_track, m_map))
+    return impl_map().reference();
+    // return m_map.reference(0,0,0,0,0,0,0);
+  }
 
   // Rank 1
-   // Rank 1 parenthesis
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType>::value), reference_type>::type
-  access(const iType & i0 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (1 , this->rank(), m_track, m_map, i0) )
-      return m_map.reference(i0);
-    }
+  // Rank 1 parenthesis
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType>::value),
+      reference_type>::type
+  access(const iType& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
+    return m_map.reference(i0);
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename traits::specialize , void>::value && std::is_integral<iType>::value), reference_type>::type
-  access(const iType & i0 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (1 , this->rank(), m_track, m_map, i0) )
-      return m_map.reference(i0,0,0,0,0,0,0);
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename traits::specialize, void>::value &&
+        std::is_integral<iType>::value),
+      reference_type>::type
+  access(const iType& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
+    return m_map.reference(i0, 0, 0, 0, 0, 0, 0);
+  }
 
   // Rank 2
-  template< typename iType0 , typename iType1 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value), reference_type>::type
- access(const iType0 & i0 , const iType1 & i1 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (2 , this->rank(), m_track, m_map, i0, i1) )
-      return m_map.reference(i0,i1);
-    }
+  template <typename iType0, typename iType1>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
+    return m_map.reference(i0, i1);
+  }
 
-  template< typename iType0 , typename iType1 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (2 , this->rank(), m_track, m_map, i0, i1) )
-      return m_map.reference(i0,i1,0,0,0,0,0);
-    }
+  template <typename iType0, typename iType1>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
+    return m_map.reference(i0, i1, 0, 0, 0, 0, 0);
+  }
 
   // Rank 3
-  template< typename iType0 , typename iType1 , typename iType2 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (3 , this->rank(), m_track, m_map, i0, i1, i2) )
-      return m_map.reference(i0,i1,i2);
-    }
+  template <typename iType0, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (3, this->rank(), m_track, m_map, i0, i1, i2))
+    return m_map.reference(i0, i1, i2);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (3 , this->rank(), m_track, m_map, i0, i1, i2) )
-      return m_map.reference(i0,i1,i2,0,0,0,0);
-    }
+  template <typename iType0, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (3, this->rank(), m_track, m_map, i0, i1, i2))
+    return m_map.reference(i0, i1, i2, 0, 0, 0, 0);
+  }
 
   // Rank 4
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (4 , this->rank(), m_track, m_map, i0, i1, i2, i3) )
-      return m_map.reference(i0,i1,i2,i3);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2,
+         const iType3& i3) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
+    return m_map.reference(i0, i1, i2, i3);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (4 , this->rank(), m_track, m_map, i0, i1, i2, i3) )
-      return m_map.reference(i0,i1,i2,i3,0,0,0);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2,
+         const iType3& i3) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
+    return m_map.reference(i0, i1, i2, i3, 0, 0, 0);
+  }
 
   // Rank 5
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value && std::is_integral<iType4>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (5 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4) )
-      return m_map.reference(i0,i1,i2,i3,i4);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
+       std::is_integral<iType4>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
+         const iType4& i4) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
+    return m_map.reference(i0, i1, i2, i3, i4);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (5 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4) )
-      return m_map.reference(i0,i1,i2,i3,i4,0,0);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
+         const iType4& i4) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
+    return m_map.reference(i0, i1, i2, i3, i4, 0, 0);
+  }
 
   // Rank 6
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_same<typename traits::specialize , void>::value && std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value && std::is_integral<iType4>::value && std::is_integral<iType5>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (6 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4, typename iType5>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_same<typename traits::specialize, void>::value &&
+       std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
+       std::is_integral<iType4>::value && std::is_integral<iType5>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
+         const iType4& i4, const iType5& i5) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
+    return m_map.reference(i0, i1, i2, i3, i4, i5);
+  }
 
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !(std::is_same<typename drvtraits::specialize , void>::value && std::is_integral<iType0>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (6 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5,0);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4, typename iType5>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      !(std::is_same<typename drvtraits::specialize, void>::value &&
+        std::is_integral<iType0>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
+         const iType4& i4, const iType5& i5) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, 0);
+  }
 
   // Rank 7
-  template< typename iType0 , typename iType1 , typename iType2 , typename iType3, typename iType4 , typename iType5 , typename iType6 >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< (std::is_integral<iType0>::value  && std::is_integral<iType1>::value && std::is_integral<iType2>::value && std::is_integral<iType3>::value && std::is_integral<iType4>::value && std::is_integral<iType5>::value && std::is_integral<iType6>::value), reference_type>::type
-  access(const iType0 & i0 , const iType1 & i1 , const iType2 & i2 , const iType3 & i3 , const iType4 & i4 , const iType5 & i5 , const iType6 & i6 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (7 , this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5, i6) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5,i6);
-    }
+  template <typename iType0, typename iType1, typename iType2, typename iType3,
+            typename iType4, typename iType5, typename iType6>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      (std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
+       std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
+       std::is_integral<iType4>::value && std::is_integral<iType5>::value &&
+       std::is_integral<iType6>::value),
+      reference_type>::type
+  access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
+         const iType4& i4, const iType5& i5, const iType6& i6) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (7, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5, i6))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
+  }
 
 #undef KOKKOS_IMPL_VIEW_OPERATOR_VERIFY
 
@@ -927,405 +1069,393 @@ public:
   ~DynRankView() {}
 
   KOKKOS_INLINE_FUNCTION
-  DynRankView() : m_track(), m_map(), m_rank() {} //Default ctor
+  DynRankView() : m_track(), m_map(), m_rank() {}  // Default ctor
 
   KOKKOS_INLINE_FUNCTION
-  DynRankView( const DynRankView & rhs ) : m_track( rhs.m_track ), m_map( rhs.m_map ), m_rank(rhs.m_rank) {}
+  DynRankView(const DynRankView& rhs)
+      : m_track(rhs.m_track), m_map(rhs.m_map), m_rank(rhs.m_rank) {}
 
   KOKKOS_INLINE_FUNCTION
-  DynRankView( DynRankView && rhs ) : m_track( rhs.m_track ), m_map( rhs.m_map ), m_rank(rhs.m_rank) {}
+  DynRankView(DynRankView&& rhs)
+      : m_track(rhs.m_track), m_map(rhs.m_map), m_rank(rhs.m_rank) {}
 
   KOKKOS_INLINE_FUNCTION
-  DynRankView & operator = ( const DynRankView & rhs ) { m_track = rhs.m_track; m_map = rhs.m_map; m_rank = rhs.m_rank; return *this; }
+  DynRankView& operator=(const DynRankView& rhs) {
+    m_track = rhs.m_track;
+    m_map   = rhs.m_map;
+    m_rank  = rhs.m_rank;
+    return *this;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  DynRankView & operator = ( DynRankView && rhs ) { m_track = rhs.m_track; m_map = rhs.m_map; m_rank = rhs.m_rank; return *this; }
+  DynRankView& operator=(DynRankView&& rhs) {
+    m_track = rhs.m_track;
+    m_map   = rhs.m_map;
+    m_rank  = rhs.m_rank;
+    return *this;
+  }
 
   //----------------------------------------
   // Compatible view copy constructor and assignment
   // may assign unmanaged from managed.
-  template< class RT , class ... RP >
-  KOKKOS_INLINE_FUNCTION
-  DynRankView( const DynRankView<RT,RP...> & rhs )
-    : m_track( rhs.m_track , traits::is_managed )
-    , m_map()
-    , m_rank(rhs.m_rank)
-    {
-      typedef typename DynRankView<RT,RP...> ::traits SrcTraits ;
-      typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , typename traits::specialize > Mapping ;
-      static_assert( Mapping::is_assignable , "Incompatible DynRankView copy construction" );
-      Mapping::assign( m_map , rhs.m_map , rhs.m_track );
-    }
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION DynRankView(const DynRankView<RT, RP...>& rhs)
+      : m_track(rhs.m_track, traits::is_managed), m_map(), m_rank(rhs.m_rank) {
+    typedef typename DynRankView<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits,
+                                      typename traits::specialize>
+        Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible DynRankView copy construction");
+    Mapping::assign(m_map, rhs.m_map, rhs.m_track);
+  }
 
-  template< class RT , class ... RP >
-  KOKKOS_INLINE_FUNCTION
-  DynRankView & operator = (const DynRankView<RT,RP...> & rhs )
-    {
-      typedef typename DynRankView<RT,RP...> ::traits SrcTraits ;
-      typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , typename traits::specialize > Mapping ;
-      static_assert( Mapping::is_assignable , "Incompatible DynRankView copy construction" );
-      Mapping::assign( m_map , rhs.m_map , rhs.m_track );
-      m_track.assign( rhs.m_track , traits::is_managed );
-      m_rank = rhs.rank();
-      return *this;
-    }
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION DynRankView& operator=(
+      const DynRankView<RT, RP...>& rhs) {
+    typedef typename DynRankView<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits,
+                                      typename traits::specialize>
+        Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible DynRankView copy construction");
+    Mapping::assign(m_map, rhs.m_map, rhs.m_track);
+    m_track.assign(rhs.m_track, traits::is_managed);
+    m_rank = rhs.rank();
+    return *this;
+  }
 
-// Copy/Assign View to DynRankView
-  template< class RT , class ... RP >
-  KOKKOS_INLINE_FUNCTION
-  DynRankView( const View<RT,RP...> & rhs )
-    : m_track()
-    , m_map()
-    , m_rank( rhs.Rank )
-    {
-      typedef typename View<RT,RP...>::traits  SrcTraits ;
-      typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , Kokkos::Impl::ViewToDynRankViewTag >  Mapping ;
-      static_assert( Mapping::is_assignable , "Incompatible View to DynRankView copy construction" );
-      Mapping::assign( *this , rhs );
-    }
+  // Copy/Assign View to DynRankView
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION DynRankView(const View<RT, RP...>& rhs)
+      : m_track(), m_map(), m_rank(rhs.Rank) {
+    typedef typename View<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits,
+                                      Kokkos::Impl::ViewToDynRankViewTag>
+        Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible View to DynRankView copy construction");
+    Mapping::assign(*this, rhs);
+  }
 
-  template< class RT , class ... RP >
-  KOKKOS_INLINE_FUNCTION
-  DynRankView & operator = ( const View<RT,RP...> & rhs )
-    {
-      typedef typename View<RT,RP...>::traits  SrcTraits ;
-      typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , Kokkos::Impl::ViewToDynRankViewTag >  Mapping ;
-      static_assert( Mapping::is_assignable , "Incompatible View to DynRankView copy assignment" );
-      Mapping::assign( *this , rhs );
-      return *this ;
-    }
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION DynRankView& operator=(const View<RT, RP...>& rhs) {
+    typedef typename View<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits,
+                                      Kokkos::Impl::ViewToDynRankViewTag>
+        Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible View to DynRankView copy assignment");
+    Mapping::assign(*this, rhs);
+    return *this;
+  }
 
   //----------------------------------------
   // Allocation tracking properties
 
   KOKKOS_INLINE_FUNCTION
-  int use_count() const
-    { return m_track.use_count(); }
+  int use_count() const { return m_track.use_count(); }
 
-  inline
-  const std::string label() const
-    { return m_track.template get_label< typename traits::memory_space >(); }
+  inline const std::string label() const {
+    return m_track.template get_label<typename traits::memory_space>();
+  }
 
   //----------------------------------------
   // Allocation according to allocation properties and array layout
-  // unused arg_layout dimensions must be set to KOKKOS_INVALID_INDEX so that rank deduction can properly take place
-  template< class ... P >
-  explicit inline
-  DynRankView( const Kokkos::Impl::ViewCtorProp< P ... > & arg_prop
-             , typename std::enable_if< ! Kokkos::Impl::ViewCtorProp< P... >::has_pointer
-                               , typename traits::array_layout
-                               >::type const & arg_layout
-      )
-      : m_track()
-      , m_map()
-      , m_rank( Impl::DynRankDimTraits<typename traits::specialize>::template computeRank< typename traits::array_layout, P...>(arg_prop, arg_layout) )
-    {
-      // Append layout and spaces if not input
-      typedef Kokkos::Impl::ViewCtorProp< P ... > alloc_prop_input ;
-
-      // use 'std::integral_constant<unsigned,I>' for non-types
-      // to avoid duplicate class error.
-      typedef Kokkos::Impl::ViewCtorProp
-        < P ...
-        , typename std::conditional
-            < alloc_prop_input::has_label
-            , std::integral_constant<unsigned,0>
-            , typename std::string
-            >::type
-        , typename std::conditional
-            < alloc_prop_input::has_memory_space
-            , std::integral_constant<unsigned,1>
-            , typename traits::device_type::memory_space
-            >::type
-        , typename std::conditional
-            < alloc_prop_input::has_execution_space
-            , std::integral_constant<unsigned,2>
-            , typename traits::device_type::execution_space
-            >::type
-        > alloc_prop ;
-
-      static_assert( traits::is_managed
-                   , "View allocation constructor requires managed memory" );
-
-      if ( alloc_prop::initialize &&
+  // unused arg_layout dimensions must be set to KOKKOS_INVALID_INDEX so that
+  // rank deduction can properly take place
+  template <class... P>
+  explicit inline DynRankView(
+      const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
+                              typename traits::array_layout>::type const&
+          arg_layout)
+      : m_track(),
+        m_map(),
+        m_rank(Impl::DynRankDimTraits<typename traits::specialize>::
+                   template computeRank<typename traits::array_layout, P...>(
+                       arg_prop, arg_layout)) {
+    // Append layout and spaces if not input
+    typedef Kokkos::Impl::ViewCtorProp<P...> alloc_prop_input;
+
+    // use 'std::integral_constant<unsigned,I>' for non-types
+    // to avoid duplicate class error.
+    typedef Kokkos::Impl::ViewCtorProp<
+        P...,
+        typename std::conditional<alloc_prop_input::has_label,
+                                  std::integral_constant<unsigned, 0>,
+                                  typename std::string>::type,
+        typename std::conditional<
+            alloc_prop_input::has_memory_space,
+            std::integral_constant<unsigned, 1>,
+            typename traits::device_type::memory_space>::type,
+        typename std::conditional<
+            alloc_prop_input::has_execution_space,
+            std::integral_constant<unsigned, 2>,
+            typename traits::device_type::execution_space>::type>
+        alloc_prop;
+
+    static_assert(traits::is_managed,
+                  "View allocation constructor requires managed memory");
+
+    if (alloc_prop::initialize &&
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-           ! alloc_prop::execution_space::is_initialized()
+        !alloc_prop::execution_space::is_initialized()
 #else
-           ! alloc_prop::execution_space::impl_is_initialized()
+        !alloc_prop::execution_space::impl_is_initialized()
 #endif
-           ) {
-        // If initializing view data then
-        // the execution space must be initialized.
-        Kokkos::Impl::throw_runtime_exception("Constructing DynRankView and initializing data with uninitialized execution space");
-      }
+    ) {
+      // If initializing view data then
+      // the execution space must be initialized.
+      Kokkos::Impl::throw_runtime_exception(
+          "Constructing DynRankView and initializing data with uninitialized "
+          "execution space");
+    }
 
-      // Copy the input allocation properties with possibly defaulted properties
-      alloc_prop prop_copy( arg_prop );
+    // Copy the input allocation properties with possibly defaulted properties
+    alloc_prop prop_copy(arg_prop);
 
 //------------------------------------------------------------
-#if defined( KOKKOS_ENABLE_CUDA )
-      // If allocating in CudaUVMSpace must fence before and after
-      // the allocation to protect against possible concurrent access
-      // on the CPU and the GPU.
-      // Fence using the trait's executon space (which will be Kokkos::Cuda)
-      // to avoid incomplete type errors from usng Kokkos::Cuda directly.
-      if ( std::is_same< Kokkos::CudaUVMSpace , typename traits::device_type::memory_space >::value ) {
-        typename traits::device_type::memory_space::execution_space().fence();
-      }
+#if defined(KOKKOS_ENABLE_CUDA)
+    // If allocating in CudaUVMSpace must fence before and after
+    // the allocation to protect against possible concurrent access
+    // on the CPU and the GPU.
+    // Fence using the trait's executon space (which will be Kokkos::Cuda)
+    // to avoid incomplete type errors from usng Kokkos::Cuda directly.
+    if (std::is_same<Kokkos::CudaUVMSpace,
+                     typename traits::device_type::memory_space>::value) {
+      typename traits::device_type::memory_space::execution_space().fence();
+    }
 #endif
-//------------------------------------------------------------
+    //------------------------------------------------------------
 
-      Kokkos::Impl::SharedAllocationRecord<> *
-        record = m_map.allocate_shared( prop_copy, Impl::DynRankDimTraits<typename traits::specialize>::template createLayout<traits, P...>(arg_prop, arg_layout) );
+    Kokkos::Impl::SharedAllocationRecord<>* record = m_map.allocate_shared(
+        prop_copy,
+        Impl::DynRankDimTraits<typename traits::specialize>::
+            template createLayout<traits, P...>(arg_prop, arg_layout));
 
 //------------------------------------------------------------
-#if defined( KOKKOS_ENABLE_CUDA )
-      if ( std::is_same< Kokkos::CudaUVMSpace , typename traits::device_type::memory_space >::value ) {
-        typename traits::device_type::memory_space::execution_space().fence();
-      }
-#endif
-//------------------------------------------------------------
-
-      // Setup and initialization complete, start tracking
-      m_track.assign_allocated_record_to_uninitialized( record );
+#if defined(KOKKOS_ENABLE_CUDA)
+    if (std::is_same<Kokkos::CudaUVMSpace,
+                     typename traits::device_type::memory_space>::value) {
+      typename traits::device_type::memory_space::execution_space().fence();
     }
+#endif
+    //------------------------------------------------------------
 
+    // Setup and initialization complete, start tracking
+    m_track.assign_allocated_record_to_uninitialized(record);
+  }
 
   // Wrappers
-  template< class ... P >
-  explicit KOKKOS_INLINE_FUNCTION
-  DynRankView( const Kokkos::Impl::ViewCtorProp< P ... > & arg_prop
-      , typename std::enable_if< Kokkos::Impl::ViewCtorProp< P... >::has_pointer
-                               , typename traits::array_layout
-                               >::type const & arg_layout
-      )
-      : m_track() // No memory tracking
-      , m_map( arg_prop , Impl::DynRankDimTraits<typename traits::specialize>::template createLayout<traits, P...>(arg_prop, arg_layout) )
-      , m_rank( Impl::DynRankDimTraits<typename traits::specialize>::template computeRank< typename traits::array_layout, P...>(arg_prop, arg_layout) )
-    {
-      static_assert(
-        std::is_same< pointer_type
-                    , typename Impl::ViewCtorProp< P... >::pointer_type
-                    >::value ,
-        "Constructing DynRankView to wrap user memory must supply matching pointer type" );
-    }
+  template <class... P>
+  explicit KOKKOS_INLINE_FUNCTION DynRankView(
+      const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
+                              typename traits::array_layout>::type const&
+          arg_layout)
+      : m_track()  // No memory tracking
+        ,
+        m_map(arg_prop,
+              Impl::DynRankDimTraits<typename traits::specialize>::
+                  template createLayout<traits, P...>(arg_prop, arg_layout)),
+        m_rank(Impl::DynRankDimTraits<typename traits::specialize>::
+                   template computeRank<typename traits::array_layout, P...>(
+                       arg_prop, arg_layout)) {
+    static_assert(
+        std::is_same<pointer_type,
+                     typename Impl::ViewCtorProp<P...>::pointer_type>::value,
+        "Constructing DynRankView to wrap user memory must supply matching "
+        "pointer type");
+  }
 
   //----------------------------------------
-  //Constructor(s)
+  // Constructor(s)
 
   // Simple dimension-only layout
-  template< class ... P >
-  explicit inline
-  DynRankView( const Kokkos::Impl::ViewCtorProp< P ... > & arg_prop
-      , typename std::enable_if< ! Kokkos::Impl::ViewCtorProp< P... >::has_pointer
-                               , size_t
-                               >::type const arg_N0 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N1 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N2 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N3 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N4 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N5 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N6 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N7 =KOKKOS_INVALID_INDEX
-      )
-    : DynRankView( arg_prop
-    , typename traits::array_layout
-          ( arg_N0 , arg_N1 , arg_N2 , arg_N3 , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-      )
-    {}
-
-  template< class ... P >
-  explicit KOKKOS_INLINE_FUNCTION
-  DynRankView( const Kokkos::Impl::ViewCtorProp< P ... > & arg_prop
-      , typename std::enable_if< Kokkos::Impl::ViewCtorProp< P... >::has_pointer
-                               , size_t
-                               >::type const arg_N0 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N1 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N2 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N3 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N4 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N5 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N6 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N7 =KOKKOS_INVALID_INDEX
-      )
-    : DynRankView( arg_prop
-    , typename traits::array_layout
-          ( arg_N0 , arg_N1 , arg_N2 , arg_N3 , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-      )
-    {}
+  template <class... P>
+  explicit inline DynRankView(
+      const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
+                              size_t>::type const arg_N0 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N1                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N2                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N3                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N4                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N5                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N6                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N7                                = KOKKOS_INVALID_INDEX)
+      : DynRankView(arg_prop, typename traits::array_layout(
+                                  arg_N0, arg_N1, arg_N2, arg_N3, arg_N4,
+                                  arg_N5, arg_N6, arg_N7)) {}
+
+  template <class... P>
+  explicit KOKKOS_INLINE_FUNCTION DynRankView(
+      const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
+                              size_t>::type const arg_N0 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N1                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N2                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N3                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N4                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N5                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N6                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N7                                = KOKKOS_INVALID_INDEX)
+      : DynRankView(arg_prop, typename traits::array_layout(
+                                  arg_N0, arg_N1, arg_N2, arg_N3, arg_N4,
+                                  arg_N5, arg_N6, arg_N7)) {}
 
   // Allocate with label and layout
-  template< typename Label >
-  explicit inline
-  DynRankView( const Label & arg_label
-      , typename std::enable_if<
-          Kokkos::Impl::is_view_label<Label>::value ,
-          typename traits::array_layout >::type const & arg_layout
-      )
-    : DynRankView( Kokkos::Impl::ViewCtorProp< std::string >( arg_label ) , arg_layout )
-    {}
+  template <typename Label>
+  explicit inline DynRankView(
+      const Label& arg_label,
+      typename std::enable_if<Kokkos::Impl::is_view_label<Label>::value,
+                              typename traits::array_layout>::type const&
+          arg_layout)
+      : DynRankView(Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
+                    arg_layout) {}
 
   // Allocate label and layout, must disambiguate from subview constructor
-  template< typename Label >
-  explicit inline
-  DynRankView( const Label & arg_label
-      , typename std::enable_if<
-          Kokkos::Impl::is_view_label<Label>::value ,
-        const size_t >::type arg_N0 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N1 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N2 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N3 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N4 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N5 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N6 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N7 =KOKKOS_INVALID_INDEX
-      )
-    : DynRankView( Kokkos::Impl::ViewCtorProp< std::string >( arg_label )
-    , typename traits::array_layout
-          ( arg_N0 , arg_N1 , arg_N2 , arg_N3 , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-      )
-    {}
+  template <typename Label>
+  explicit inline DynRankView(
+      const Label& arg_label,
+      typename std::enable_if<Kokkos::Impl::is_view_label<Label>::value,
+                              const size_t>::type arg_N0 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N1                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N2                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N3                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N4                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N5                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N6                                = KOKKOS_INVALID_INDEX,
+      const size_t arg_N7                                = KOKKOS_INVALID_INDEX)
+      : DynRankView(
+            Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
+            typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                          arg_N4, arg_N5, arg_N6, arg_N7)) {}
 
   // For backward compatibility
-  // NDE This ctor does not take ViewCtorProp argument - should not use alternative createLayout call
-  explicit inline
-  DynRankView( const ViewAllocateWithoutInitializing & arg_prop
-      , const typename traits::array_layout & arg_layout
-      )
-    : DynRankView( Kokkos::Impl::ViewCtorProp< std::string , Kokkos::Impl::WithoutInitializing_t >( arg_prop.label , Kokkos::WithoutInitializing )
-                 , arg_layout
-      )
-    {}
-
-  explicit inline
-  DynRankView( const ViewAllocateWithoutInitializing & arg_prop
-      , const size_t arg_N0 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N1 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N2 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N3 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N4 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N5 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N6 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N7 =KOKKOS_INVALID_INDEX
-      )
-    : DynRankView(Kokkos::Impl::ViewCtorProp< std::string , Kokkos::Impl::WithoutInitializing_t >( arg_prop.label , Kokkos::WithoutInitializing )
-      , typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7)
-      )
-    {}
+  // NDE This ctor does not take ViewCtorProp argument - should not use
+  // alternative createLayout call
+  explicit inline DynRankView(const ViewAllocateWithoutInitializing& arg_prop,
+                              const typename traits::array_layout& arg_layout)
+      : DynRankView(
+            Kokkos::Impl::ViewCtorProp<std::string,
+                                       Kokkos::Impl::WithoutInitializing_t>(
+                arg_prop.label, Kokkos::WithoutInitializing),
+            arg_layout) {}
+
+  explicit inline DynRankView(const ViewAllocateWithoutInitializing& arg_prop,
+                              const size_t arg_N0 = KOKKOS_INVALID_INDEX,
+                              const size_t arg_N1 = KOKKOS_INVALID_INDEX,
+                              const size_t arg_N2 = KOKKOS_INVALID_INDEX,
+                              const size_t arg_N3 = KOKKOS_INVALID_INDEX,
+                              const size_t arg_N4 = KOKKOS_INVALID_INDEX,
+                              const size_t arg_N5 = KOKKOS_INVALID_INDEX,
+                              const size_t arg_N6 = KOKKOS_INVALID_INDEX,
+                              const size_t arg_N7 = KOKKOS_INVALID_INDEX)
+      : DynRankView(
+            Kokkos::Impl::ViewCtorProp<std::string,
+                                       Kokkos::Impl::WithoutInitializing_t>(
+                arg_prop.label, Kokkos::WithoutInitializing),
+            typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                          arg_N4, arg_N5, arg_N6, arg_N7)) {}
 
   //----------------------------------------
   // Memory span required to wrap these dimensions.
   static constexpr size_t required_allocation_size(
-                                       const size_t arg_N0 = 0
-                                     , const size_t arg_N1 = 0
-                                     , const size_t arg_N2 = 0
-                                     , const size_t arg_N3 = 0
-                                     , const size_t arg_N4 = 0
-                                     , const size_t arg_N5 = 0
-                                     , const size_t arg_N6 = 0
-                                     , const size_t arg_N7 = 0
-                                     )
-    {
-      return map_type::memory_span(
-        typename traits::array_layout
-          ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-          , arg_N4 , arg_N5 , arg_N6 , arg_N7 ) );
-    }
-
-  explicit KOKKOS_INLINE_FUNCTION
-  DynRankView( pointer_type arg_ptr
-      , const size_t arg_N0 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N1 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N2 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N3 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N4 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N5 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N6 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N7 =KOKKOS_INVALID_INDEX
-      )
-    : DynRankView( Kokkos::Impl::ViewCtorProp<pointer_type>(arg_ptr) , arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7 )
-    {}
-
-  explicit KOKKOS_INLINE_FUNCTION
-  DynRankView( pointer_type arg_ptr
-      , typename traits::array_layout & arg_layout
-      )
-    : DynRankView( Kokkos::Impl::ViewCtorProp<pointer_type>(arg_ptr) , arg_layout )
-    {}
+      const size_t arg_N0 = 0, const size_t arg_N1 = 0, const size_t arg_N2 = 0,
+      const size_t arg_N3 = 0, const size_t arg_N4 = 0, const size_t arg_N5 = 0,
+      const size_t arg_N6 = 0, const size_t arg_N7 = 0) {
+    return map_type::memory_span(typename traits::array_layout(
+        arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
+  }
 
+  explicit KOKKOS_INLINE_FUNCTION DynRankView(
+      pointer_type arg_ptr, const size_t arg_N0 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N1 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N2 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N3 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N4 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N5 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N6 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N7 = KOKKOS_INVALID_INDEX)
+      : DynRankView(Kokkos::Impl::ViewCtorProp<pointer_type>(arg_ptr), arg_N0,
+                    arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7) {}
+
+  explicit KOKKOS_INLINE_FUNCTION DynRankView(
+      pointer_type arg_ptr, typename traits::array_layout& arg_layout)
+      : DynRankView(Kokkos::Impl::ViewCtorProp<pointer_type>(arg_ptr),
+                    arg_layout) {}
 
   //----------------------------------------
   // Shared scratch memory constructor
 
-  static inline
-  size_t shmem_size( const size_t arg_N0 =KOKKOS_INVALID_INDEX ,
-                     const size_t arg_N1 =KOKKOS_INVALID_INDEX ,
-                     const size_t arg_N2 =KOKKOS_INVALID_INDEX ,
-                     const size_t arg_N3 =KOKKOS_INVALID_INDEX ,
-                     const size_t arg_N4 =KOKKOS_INVALID_INDEX ,
-                     const size_t arg_N5 =KOKKOS_INVALID_INDEX ,
-                     const size_t arg_N6 =KOKKOS_INVALID_INDEX ,
-                     const size_t arg_N7 =KOKKOS_INVALID_INDEX )
-  {
+  static inline size_t shmem_size(const size_t arg_N0 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N1 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N2 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N3 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N4 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N5 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N6 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N7 = KOKKOS_INVALID_INDEX) {
     const size_t num_passed_args =
-      ( arg_N0 !=KOKKOS_INVALID_INDEX ) + ( arg_N1 !=KOKKOS_INVALID_INDEX ) + ( arg_N2 !=KOKKOS_INVALID_INDEX ) +
-      ( arg_N3 !=KOKKOS_INVALID_INDEX ) + ( arg_N4 !=KOKKOS_INVALID_INDEX ) + ( arg_N5 !=KOKKOS_INVALID_INDEX ) +
-      ( arg_N6 !=KOKKOS_INVALID_INDEX ) + ( arg_N7 !=KOKKOS_INVALID_INDEX );
-
-    if ( std::is_same<typename traits::specialize , void>::value && num_passed_args != traits::rank_dynamic ) {
-      Kokkos::abort( "Kokkos::View::shmem_size() rank_dynamic != number of arguments.\n" );
+        (arg_N0 != KOKKOS_INVALID_INDEX) + (arg_N1 != KOKKOS_INVALID_INDEX) +
+        (arg_N2 != KOKKOS_INVALID_INDEX) + (arg_N3 != KOKKOS_INVALID_INDEX) +
+        (arg_N4 != KOKKOS_INVALID_INDEX) + (arg_N5 != KOKKOS_INVALID_INDEX) +
+        (arg_N6 != KOKKOS_INVALID_INDEX) + (arg_N7 != KOKKOS_INVALID_INDEX);
+
+    if (std::is_same<typename traits::specialize, void>::value &&
+        num_passed_args != traits::rank_dynamic) {
+      Kokkos::abort(
+          "Kokkos::View::shmem_size() rank_dynamic != number of arguments.\n");
     }
     {}
 
-    return map_type::memory_span(
-           typename traits::array_layout
-            ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-            , arg_N4 , arg_N5 , arg_N6 , arg_N7 ) );
-  }
-
-  explicit KOKKOS_INLINE_FUNCTION
-  DynRankView( const typename traits::execution_space::scratch_memory_space & arg_space
-      , const typename traits::array_layout & arg_layout )
-    : DynRankView( Kokkos::Impl::ViewCtorProp<pointer_type>(
-              reinterpret_cast<pointer_type>(
-                arg_space.get_shmem( map_type::memory_span(
-                  Impl::DynRankDimTraits<typename traits::specialize>::createLayout( arg_layout ) //is this correct?
-                ) ) ) )
-         , arg_layout )
-     {}
-
-  explicit KOKKOS_INLINE_FUNCTION
-  DynRankView( const typename traits::execution_space::scratch_memory_space & arg_space
-      , const size_t arg_N0 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N1 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N2 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N3 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N4 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N5 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N6 =KOKKOS_INVALID_INDEX
-      , const size_t arg_N7 =KOKKOS_INVALID_INDEX )
-
-    : DynRankView( Kokkos::Impl::ViewCtorProp<pointer_type>(
-                   reinterpret_cast<pointer_type>(
-                     arg_space.get_shmem(
-                       map_type::memory_span(
-                       Impl::DynRankDimTraits<typename traits::specialize>::createLayout(
-                       typename traits::array_layout
-                       ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-                       , arg_N4 , arg_N5 , arg_N6 , arg_N7 ) ) ) ) )
-                    )
-                  , typename traits::array_layout
-                    ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-                    , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-        )
-    {}
+    return map_type::memory_span(typename traits::array_layout(
+        arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
+  }
 
+  explicit KOKKOS_INLINE_FUNCTION DynRankView(
+      const typename traits::execution_space::scratch_memory_space& arg_space,
+      const typename traits::array_layout& arg_layout)
+      : DynRankView(
+            Kokkos::Impl::ViewCtorProp<pointer_type>(
+                reinterpret_cast<pointer_type>(
+                    arg_space.get_shmem(map_type::memory_span(
+                        Impl::DynRankDimTraits<typename traits::specialize>::
+                            createLayout(arg_layout)  // is this correct?
+                        )))),
+            arg_layout) {}
+
+  explicit KOKKOS_INLINE_FUNCTION DynRankView(
+      const typename traits::execution_space::scratch_memory_space& arg_space,
+      const size_t arg_N0 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N1 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N2 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N3 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N4 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N5 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N6 = KOKKOS_INVALID_INDEX,
+      const size_t arg_N7 = KOKKOS_INVALID_INDEX)
+
+      : DynRankView(
+            Kokkos::Impl::ViewCtorProp<pointer_type>(
+                reinterpret_cast<pointer_type>(
+                    arg_space.get_shmem(map_type::memory_span(
+                        Impl::DynRankDimTraits<typename traits::specialize>::
+                            createLayout(typename traits::array_layout(
+                                arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5,
+                                arg_N6, arg_N7)))))),
+            typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                          arg_N4, arg_N5, arg_N6, arg_N7)) {}
 };
 
-
-  template < typename D , class ... P >
-  KOKKOS_INLINE_FUNCTION
-  constexpr unsigned rank( const DynRankView<D , P...> & DRV ) { return DRV.rank(); } //needed for transition to common constexpr method in view and dynrankview to return rank
+template <typename D, class... P>
+KOKKOS_INLINE_FUNCTION constexpr unsigned rank(
+    const DynRankView<D, P...>& DRV) {
+  return DRV.rank();
+}  // needed for transition to common constexpr method in view and dynrankview
+   // to return rank
 
 //----------------------------------------------------------------------------
 // Subview mapping.
@@ -1335,253 +1465,238 @@ namespace Impl {
 
 struct DynRankSubviewTag {};
 
-} // namespace Impl
+}  // namespace Impl
 
 namespace Impl {
 
-template< class SrcTraits , class ... Args >
-struct ViewMapping
-  < typename std::enable_if<(
-      std::is_same< typename SrcTraits::specialize , void >::value
-      &&
-      (
-        std::is_same< typename SrcTraits::array_layout
-                    , Kokkos::LayoutLeft >::value ||
-        std::is_same< typename SrcTraits::array_layout
-                    , Kokkos::LayoutRight >::value ||
-        std::is_same< typename SrcTraits::array_layout
-                    , Kokkos::LayoutStride >::value
-      )
-    ), Kokkos::Impl::DynRankSubviewTag >::type
-  , SrcTraits
-  , Args ... >
-{
-private:
-
-  enum
-    { RZ = false
-    , R0 = bool(is_integral_extent<0,Args...>::value)
-    , R1 = bool(is_integral_extent<1,Args...>::value)
-    , R2 = bool(is_integral_extent<2,Args...>::value)
-    , R3 = bool(is_integral_extent<3,Args...>::value)
-    , R4 = bool(is_integral_extent<4,Args...>::value)
-    , R5 = bool(is_integral_extent<5,Args...>::value)
-    , R6 = bool(is_integral_extent<6,Args...>::value)
-    };
-
-  enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
-              + unsigned(R4) + unsigned(R5) + unsigned(R6) };
-
-  typedef Kokkos::LayoutStride array_layout ;
+template <class SrcTraits, class... Args>
+struct ViewMapping<
+    typename std::enable_if<
+        (std::is_same<typename SrcTraits::specialize, void>::value &&
+         (std::is_same<typename SrcTraits::array_layout,
+                       Kokkos::LayoutLeft>::value ||
+          std::is_same<typename SrcTraits::array_layout,
+                       Kokkos::LayoutRight>::value ||
+          std::is_same<typename SrcTraits::array_layout,
+                       Kokkos::LayoutStride>::value)),
+        Kokkos::Impl::DynRankSubviewTag>::type,
+    SrcTraits, Args...> {
+ private:
+  enum {
+    RZ = false,
+    R0 = bool(is_integral_extent<0, Args...>::value),
+    R1 = bool(is_integral_extent<1, Args...>::value),
+    R2 = bool(is_integral_extent<2, Args...>::value),
+    R3 = bool(is_integral_extent<3, Args...>::value),
+    R4 = bool(is_integral_extent<4, Args...>::value),
+    R5 = bool(is_integral_extent<5, Args...>::value),
+    R6 = bool(is_integral_extent<6, Args...>::value)
+  };
 
-  typedef typename SrcTraits::value_type  value_type ;
+  enum {
+    rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3) +
+           unsigned(R4) + unsigned(R5) + unsigned(R6)
+  };
 
-  typedef value_type******* data_type ;
+  typedef Kokkos::LayoutStride array_layout;
 
-public:
+  typedef typename SrcTraits::value_type value_type;
 
-  typedef Kokkos::ViewTraits
-    < data_type
-    , array_layout
-    , typename SrcTraits::device_type
-    , typename SrcTraits::memory_traits > traits_type ;
+  typedef value_type******* data_type;
 
-  typedef Kokkos::View
-    < data_type
-    , array_layout
-    , typename SrcTraits::device_type
-    , typename SrcTraits::memory_traits > type ;
+ public:
+  typedef Kokkos::ViewTraits<data_type, array_layout,
+                             typename SrcTraits::device_type,
+                             typename SrcTraits::memory_traits>
+      traits_type;
 
+  typedef Kokkos::View<data_type, array_layout, typename SrcTraits::device_type,
+                       typename SrcTraits::memory_traits>
+      type;
 
-  template< class MemoryTraits >
+  template <class MemoryTraits>
   struct apply {
+    static_assert(Kokkos::Impl::is_memory_traits<MemoryTraits>::value, "");
 
-    static_assert( Kokkos::Impl::is_memory_traits< MemoryTraits >::value , "" );
-
-    typedef Kokkos::ViewTraits
-      < data_type
-      , array_layout
-      , typename SrcTraits::device_type
-      , MemoryTraits > traits_type ;
+    typedef Kokkos::ViewTraits<data_type, array_layout,
+                               typename SrcTraits::device_type, MemoryTraits>
+        traits_type;
 
-    typedef Kokkos::View
-      < data_type
-      , array_layout
-      , typename SrcTraits::device_type
-      , MemoryTraits > type ;
+    typedef Kokkos::View<data_type, array_layout,
+                         typename SrcTraits::device_type, MemoryTraits>
+        type;
   };
 
+  typedef typename SrcTraits::dimension dimension;
 
-  typedef typename SrcTraits::dimension dimension ;
-
-  template < class Arg0 = int, class Arg1 = int, class Arg2 = int, class Arg3 = int, class Arg4 = int, class Arg5 = int, class Arg6 = int >
+  template <class Arg0 = int, class Arg1 = int, class Arg2 = int,
+            class Arg3 = int, class Arg4 = int, class Arg5 = int,
+            class Arg6 = int>
   struct ExtentGenerator {
     KOKKOS_INLINE_FUNCTION
-    static SubviewExtents< 7 , rank > generator ( const dimension & dim , Arg0 arg0 = Arg0(), Arg1 arg1 = Arg1(), Arg2 arg2 = Arg2(), Arg3 arg3 = Arg3(), Arg4 arg4 = Arg4(), Arg5 arg5 = Arg5(), Arg6 arg6 = Arg6() )
-    {
-       return SubviewExtents< 7 , rank>( dim , arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
+    static SubviewExtents<7, rank> generator(
+        const dimension& dim, Arg0 arg0 = Arg0(), Arg1 arg1 = Arg1(),
+        Arg2 arg2 = Arg2(), Arg3 arg3 = Arg3(), Arg4 arg4 = Arg4(),
+        Arg5 arg5 = Arg5(), Arg6 arg6 = Arg6()) {
+      return SubviewExtents<7, rank>(dim, arg0, arg1, arg2, arg3, arg4, arg5,
+                                     arg6);
     }
   };
 
-
-  typedef Kokkos::DynRankView< value_type , array_layout , typename SrcTraits::device_type , typename SrcTraits::memory_traits >  ret_type;
-
-  template < typename T , class ... P >
-  KOKKOS_INLINE_FUNCTION
-  static ret_type subview( const unsigned src_rank , Kokkos::DynRankView< T , P...> const & src
-                    , Args ... args )
-    {
-
-       typedef ViewMapping< traits_type, typename traits_type::specialize >  DstType ;
-
-       typedef typename std::conditional< (rank==0) , ViewDimension<>
-                                                    , typename std::conditional< (rank==1) , ViewDimension<0>
-                                                    , typename std::conditional< (rank==2) , ViewDimension<0,0>
-                                                    , typename std::conditional< (rank==3) , ViewDimension<0,0,0>
-                                                    , typename std::conditional< (rank==4) , ViewDimension<0,0,0,0>
-                                                    , typename std::conditional< (rank==5) , ViewDimension<0,0,0,0,0>
-                                                    , typename std::conditional< (rank==6) , ViewDimension<0,0,0,0,0,0>
-                                                                                           , ViewDimension<0,0,0,0,0,0,0>
-                                                    >::type >::type >::type >::type >::type >::type >::type  DstDimType ;
-
-      typedef ViewOffset< DstDimType , Kokkos::LayoutStride > dst_offset_type ;
-      typedef typename DstType::handle_type  dst_handle_type ;
-
-      ret_type dst ;
-
-      const SubviewExtents< 7 , rank > extents =
-        ExtentGenerator< Args ... >::generator( src.m_map.m_impl_offset.m_dim , args... ) ;
-
-      dst_offset_type tempdst( src.m_map.m_impl_offset , extents ) ;
-
-      dst.m_track = src.m_track ;
-
-      dst.m_map.m_impl_offset.m_dim.N0 = tempdst.m_dim.N0 ;
-      dst.m_map.m_impl_offset.m_dim.N1 = tempdst.m_dim.N1 ;
-      dst.m_map.m_impl_offset.m_dim.N2 = tempdst.m_dim.N2 ;
-      dst.m_map.m_impl_offset.m_dim.N3 = tempdst.m_dim.N3 ;
-      dst.m_map.m_impl_offset.m_dim.N4 = tempdst.m_dim.N4 ;
-      dst.m_map.m_impl_offset.m_dim.N5 = tempdst.m_dim.N5 ;
-      dst.m_map.m_impl_offset.m_dim.N6 = tempdst.m_dim.N6 ;
-
-      dst.m_map.m_impl_offset.m_stride.S0 = tempdst.m_stride.S0 ;
-      dst.m_map.m_impl_offset.m_stride.S1 = tempdst.m_stride.S1 ;
-      dst.m_map.m_impl_offset.m_stride.S2 = tempdst.m_stride.S2 ;
-      dst.m_map.m_impl_offset.m_stride.S3 = tempdst.m_stride.S3 ;
-      dst.m_map.m_impl_offset.m_stride.S4 = tempdst.m_stride.S4 ;
-      dst.m_map.m_impl_offset.m_stride.S5 = tempdst.m_stride.S5 ;
-      dst.m_map.m_impl_offset.m_stride.S6 = tempdst.m_stride.S6 ;
-
-      dst.m_map.m_impl_handle = dst_handle_type( src.m_map.m_impl_handle +
-                                      src.m_map.m_impl_offset( extents.domain_offset(0)
-                                                  , extents.domain_offset(1)
-                                                  , extents.domain_offset(2)
-                                                  , extents.domain_offset(3)
-                                                  , extents.domain_offset(4)
-                                                  , extents.domain_offset(5)
-                                                  , extents.domain_offset(6)
-                                                  ) );
-
-      dst.m_rank = ( src_rank > 0 ? unsigned(R0) : 0 )
-                 + ( src_rank > 1 ? unsigned(R1) : 0 )
-                 + ( src_rank > 2 ? unsigned(R2) : 0 )
-                 + ( src_rank > 3 ? unsigned(R3) : 0 )
-                 + ( src_rank > 4 ? unsigned(R4) : 0 )
-                 + ( src_rank > 5 ? unsigned(R5) : 0 )
-                 + ( src_rank > 6 ? unsigned(R6) : 0 ) ;
-
-      return dst ;
-    }
+  typedef Kokkos::DynRankView<value_type, array_layout,
+                              typename SrcTraits::device_type,
+                              typename SrcTraits::memory_traits>
+      ret_type;
+
+  template <typename T, class... P>
+  KOKKOS_INLINE_FUNCTION static ret_type subview(
+      const unsigned src_rank, Kokkos::DynRankView<T, P...> const& src,
+      Args... args) {
+    typedef ViewMapping<traits_type, typename traits_type::specialize> DstType;
+
+    typedef typename std::conditional<
+        (rank == 0), ViewDimension<>,
+        typename std::conditional<
+            (rank == 1), ViewDimension<0>,
+            typename std::conditional<
+                (rank == 2), ViewDimension<0, 0>,
+                typename std::conditional<
+                    (rank == 3), ViewDimension<0, 0, 0>,
+                    typename std::conditional<
+                        (rank == 4), ViewDimension<0, 0, 0, 0>,
+                        typename std::conditional<
+                            (rank == 5), ViewDimension<0, 0, 0, 0, 0>,
+                            typename std::conditional<
+                                (rank == 6), ViewDimension<0, 0, 0, 0, 0, 0>,
+                                ViewDimension<0, 0, 0, 0, 0, 0, 0> >::type>::
+                            type>::type>::type>::type>::type>::type DstDimType;
+
+    typedef ViewOffset<DstDimType, Kokkos::LayoutStride> dst_offset_type;
+    typedef typename DstType::handle_type dst_handle_type;
+
+    ret_type dst;
+
+    const SubviewExtents<7, rank> extents = ExtentGenerator<Args...>::generator(
+        src.m_map.m_impl_offset.m_dim, args...);
+
+    dst_offset_type tempdst(src.m_map.m_impl_offset, extents);
+
+    dst.m_track = src.m_track;
+
+    dst.m_map.m_impl_offset.m_dim.N0 = tempdst.m_dim.N0;
+    dst.m_map.m_impl_offset.m_dim.N1 = tempdst.m_dim.N1;
+    dst.m_map.m_impl_offset.m_dim.N2 = tempdst.m_dim.N2;
+    dst.m_map.m_impl_offset.m_dim.N3 = tempdst.m_dim.N3;
+    dst.m_map.m_impl_offset.m_dim.N4 = tempdst.m_dim.N4;
+    dst.m_map.m_impl_offset.m_dim.N5 = tempdst.m_dim.N5;
+    dst.m_map.m_impl_offset.m_dim.N6 = tempdst.m_dim.N6;
+
+    dst.m_map.m_impl_offset.m_stride.S0 = tempdst.m_stride.S0;
+    dst.m_map.m_impl_offset.m_stride.S1 = tempdst.m_stride.S1;
+    dst.m_map.m_impl_offset.m_stride.S2 = tempdst.m_stride.S2;
+    dst.m_map.m_impl_offset.m_stride.S3 = tempdst.m_stride.S3;
+    dst.m_map.m_impl_offset.m_stride.S4 = tempdst.m_stride.S4;
+    dst.m_map.m_impl_offset.m_stride.S5 = tempdst.m_stride.S5;
+    dst.m_map.m_impl_offset.m_stride.S6 = tempdst.m_stride.S6;
+
+    dst.m_map.m_impl_handle =
+        dst_handle_type(src.m_map.m_impl_handle +
+                        src.m_map.m_impl_offset(
+                            extents.domain_offset(0), extents.domain_offset(1),
+                            extents.domain_offset(2), extents.domain_offset(3),
+                            extents.domain_offset(4), extents.domain_offset(5),
+                            extents.domain_offset(6)));
+
+    dst.m_rank =
+        (src_rank > 0 ? unsigned(R0) : 0) + (src_rank > 1 ? unsigned(R1) : 0) +
+        (src_rank > 2 ? unsigned(R2) : 0) + (src_rank > 3 ? unsigned(R3) : 0) +
+        (src_rank > 4 ? unsigned(R4) : 0) + (src_rank > 5 ? unsigned(R5) : 0) +
+        (src_rank > 6 ? unsigned(R6) : 0);
+
+    return dst;
+  }
 };
 
-} // end Impl
-
+}  // namespace Impl
 
-template< class V , class ... Args >
-using Subdynrankview = typename Kokkos::Impl::ViewMapping< Kokkos::Impl::DynRankSubviewTag , V , Args... >::ret_type ;
+template <class V, class... Args>
+using Subdynrankview =
+    typename Kokkos::Impl::ViewMapping<Kokkos::Impl::DynRankSubviewTag, V,
+                                       Args...>::ret_type;
 
-template< class D , class ... P , class ...Args >
-KOKKOS_INLINE_FUNCTION
-Subdynrankview< ViewTraits<D******* , P...> , Args... >
-subdynrankview( const Kokkos::DynRankView< D , P... > &src , Args...args)
+template <class D, class... P, class... Args>
+KOKKOS_INLINE_FUNCTION Subdynrankview<ViewTraits<D*******, P...>, Args...>
+subdynrankview(const Kokkos::DynRankView<D, P...>& src, Args... args) {
+  if (src.rank() > sizeof...(Args))  // allow sizeof...(Args) >= src.rank(),
+                                     // ignore the remaining args
   {
-    if ( src.rank() > sizeof...(Args) ) //allow sizeof...(Args) >= src.rank(), ignore the remaining args
-      { Kokkos::abort("subdynrankview: num of args must be >= rank of the source DynRankView"); }
+    Kokkos::abort(
+        "subdynrankview: num of args must be >= rank of the source "
+        "DynRankView");
+  }
 
-    typedef Kokkos::Impl::ViewMapping< Kokkos::Impl::DynRankSubviewTag , Kokkos::ViewTraits< D*******, P... > , Args... > metafcn ;
+  typedef Kokkos::Impl::ViewMapping<Kokkos::Impl::DynRankSubviewTag,
+                                    Kokkos::ViewTraits<D*******, P...>, Args...>
+      metafcn;
 
-    return metafcn::subview( src.rank() , src , args... );
-  }
+  return metafcn::subview(src.rank(), src, args...);
+}
 
-//Wrapper to allow subview function name
-template< class D , class ... P , class ...Args >
-KOKKOS_INLINE_FUNCTION
-Subdynrankview< ViewTraits<D******* , P...> , Args... >
-subview( const Kokkos::DynRankView< D , P... > &src , Args...args)
-  {
-    return subdynrankview( src , args... );
-  }
+// Wrapper to allow subview function name
+template <class D, class... P, class... Args>
+KOKKOS_INLINE_FUNCTION Subdynrankview<ViewTraits<D*******, P...>, Args...>
+subview(const Kokkos::DynRankView<D, P...>& src, Args... args) {
+  return subdynrankview(src, args...);
+}
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
 // overload == and !=
-template< class LT , class ... LP , class RT , class ... RP >
-KOKKOS_INLINE_FUNCTION
-bool operator == ( const DynRankView<LT,LP...> & lhs ,
-                   const DynRankView<RT,RP...> & rhs )
-{
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator==(const DynRankView<LT, LP...>& lhs,
+                                       const DynRankView<RT, RP...>& rhs) {
   // Same data, layout, dimensions
-  typedef ViewTraits<LT,LP...>  lhs_traits ;
-  typedef ViewTraits<RT,RP...>  rhs_traits ;
-
-  return
-    std::is_same< typename lhs_traits::const_value_type ,
-                  typename rhs_traits::const_value_type >::value &&
-    std::is_same< typename lhs_traits::array_layout ,
-                  typename rhs_traits::array_layout >::value &&
-    std::is_same< typename lhs_traits::memory_space ,
-                  typename rhs_traits::memory_space >::value &&
-    lhs.rank()       ==  rhs.rank() &&
-    lhs.data()       == rhs.data() &&
-    lhs.span()       == rhs.span() &&
-    lhs.extent(0) == rhs.extent(0) &&
-    lhs.extent(1) == rhs.extent(1) &&
-    lhs.extent(2) == rhs.extent(2) &&
-    lhs.extent(3) == rhs.extent(3) &&
-    lhs.extent(4) == rhs.extent(4) &&
-    lhs.extent(5) == rhs.extent(5) &&
-    lhs.extent(6) == rhs.extent(6) &&
-    lhs.extent(7) == rhs.extent(7);
+  typedef ViewTraits<LT, LP...> lhs_traits;
+  typedef ViewTraits<RT, RP...> rhs_traits;
+
+  return std::is_same<typename lhs_traits::const_value_type,
+                      typename rhs_traits::const_value_type>::value &&
+         std::is_same<typename lhs_traits::array_layout,
+                      typename rhs_traits::array_layout>::value &&
+         std::is_same<typename lhs_traits::memory_space,
+                      typename rhs_traits::memory_space>::value &&
+         lhs.rank() == rhs.rank() && lhs.data() == rhs.data() &&
+         lhs.span() == rhs.span() && lhs.extent(0) == rhs.extent(0) &&
+         lhs.extent(1) == rhs.extent(1) && lhs.extent(2) == rhs.extent(2) &&
+         lhs.extent(3) == rhs.extent(3) && lhs.extent(4) == rhs.extent(4) &&
+         lhs.extent(5) == rhs.extent(5) && lhs.extent(6) == rhs.extent(6) &&
+         lhs.extent(7) == rhs.extent(7);
 }
 
-template< class LT , class ... LP , class RT , class ... RP >
-KOKKOS_INLINE_FUNCTION
-bool operator != ( const DynRankView<LT,LP...> & lhs ,
-                   const DynRankView<RT,RP...> & rhs )
-{
-  return ! ( operator==(lhs,rhs) );
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator!=(const DynRankView<LT, LP...>& lhs,
+                                       const DynRankView<RT, RP...>& rhs) {
+  return !(operator==(lhs, rhs));
 }
 
-} //end Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 namespace Kokkos {
 namespace Impl {
 
-template< class OutputView , typename Enable = void >
+template <class OutputView, typename Enable = void>
 struct DynRankViewFill {
+  typedef typename OutputView::traits::const_value_type const_value_type;
 
-  typedef typename OutputView::traits::const_value_type  const_value_type ;
-
-  const OutputView output ;
-  const_value_type input ;
+  const OutputView output;
+  const_value_type input;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_t i0 ) const
-  {
+  void operator()(const size_t i0) const {
     const size_t n1 = output.extent(1);
     const size_t n2 = output.extent(2);
     const size_t n3 = output.extent(3);
@@ -1589,268 +1704,251 @@ struct DynRankViewFill {
     const size_t n5 = output.extent(5);
     const size_t n6 = output.extent(6);
 
-    for ( size_t i1 = 0 ; i1 < n1 ; ++i1 ) {
-    for ( size_t i2 = 0 ; i2 < n2 ; ++i2 ) {
-    for ( size_t i3 = 0 ; i3 < n3 ; ++i3 ) {
-    for ( size_t i4 = 0 ; i4 < n4 ; ++i4 ) {
-    for ( size_t i5 = 0 ; i5 < n5 ; ++i5 ) {
-    for ( size_t i6 = 0 ; i6 < n6 ; ++i6 ) {
-      output.access(i0,i1,i2,i3,i4,i5,i6) = input ;
-    }}}}}}
+    for (size_t i1 = 0; i1 < n1; ++i1) {
+      for (size_t i2 = 0; i2 < n2; ++i2) {
+        for (size_t i3 = 0; i3 < n3; ++i3) {
+          for (size_t i4 = 0; i4 < n4; ++i4) {
+            for (size_t i5 = 0; i5 < n5; ++i5) {
+              for (size_t i6 = 0; i6 < n6; ++i6) {
+                output.access(i0, i1, i2, i3, i4, i5, i6) = input;
+              }
+            }
+          }
+        }
+      }
+    }
   }
 
-  DynRankViewFill( const OutputView & arg_out , const_value_type & arg_in )
-    : output( arg_out ), input( arg_in )
-    {
-      typedef typename OutputView::execution_space  execution_space ;
-      typedef Kokkos::RangePolicy< execution_space > Policy ;
+  DynRankViewFill(const OutputView& arg_out, const_value_type& arg_in)
+      : output(arg_out), input(arg_in) {
+    typedef typename OutputView::execution_space execution_space;
+    typedef Kokkos::RangePolicy<execution_space> Policy;
 
-      const Kokkos::Impl::ParallelFor< DynRankViewFill , Policy > closure( *this , Policy( 0 , output.extent(0) ) );
+    const Kokkos::Impl::ParallelFor<DynRankViewFill, Policy> closure(
+        *this, Policy(0, output.extent(0)));
 
-      closure.execute();
+    closure.execute();
 
-      execution_space().fence();
-    }
+    execution_space().fence();
+  }
 };
 
-template< class OutputView >
-struct DynRankViewFill< OutputView , typename std::enable_if< OutputView::Rank == 0 >::type > {
-  DynRankViewFill( const OutputView & dst , const typename OutputView::const_value_type & src )
-    {
-      Kokkos::Impl::DeepCopy< typename OutputView::memory_space , Kokkos::HostSpace >
-        ( dst.data() , & src , sizeof(typename OutputView::const_value_type) );
-    }
+template <class OutputView>
+struct DynRankViewFill<OutputView,
+                       typename std::enable_if<OutputView::Rank == 0>::type> {
+  DynRankViewFill(const OutputView& dst,
+                  const typename OutputView::const_value_type& src) {
+    Kokkos::Impl::DeepCopy<typename OutputView::memory_space,
+                           Kokkos::HostSpace>(
+        dst.data(), &src, sizeof(typename OutputView::const_value_type));
+  }
 };
 
-template< class OutputView , class InputView , class ExecSpace = typename OutputView::execution_space >
+template <class OutputView, class InputView,
+          class ExecSpace = typename OutputView::execution_space>
 struct DynRankViewRemap {
-
-  const OutputView output ;
-  const InputView  input ;
-  const size_t n0 ;
-  const size_t n1 ;
-  const size_t n2 ;
-  const size_t n3 ;
-  const size_t n4 ;
-  const size_t n5 ;
-  const size_t n6 ;
-  const size_t n7 ;
-
-  DynRankViewRemap( const OutputView & arg_out , const InputView & arg_in )
-    : output( arg_out ), input( arg_in )
-    , n0( std::min( (size_t)arg_out.extent(0) , (size_t)arg_in.extent(0) ) )
-    , n1( std::min( (size_t)arg_out.extent(1) , (size_t)arg_in.extent(1) ) )
-    , n2( std::min( (size_t)arg_out.extent(2) , (size_t)arg_in.extent(2) ) )
-    , n3( std::min( (size_t)arg_out.extent(3) , (size_t)arg_in.extent(3) ) )
-    , n4( std::min( (size_t)arg_out.extent(4) , (size_t)arg_in.extent(4) ) )
-    , n5( std::min( (size_t)arg_out.extent(5) , (size_t)arg_in.extent(5) ) )
-    , n6( std::min( (size_t)arg_out.extent(6) , (size_t)arg_in.extent(6) ) )
-    , n7( std::min( (size_t)arg_out.extent(7) , (size_t)arg_in.extent(7) ) )
-    {
-      typedef Kokkos::RangePolicy< ExecSpace > Policy ;
-      const Kokkos::Impl::ParallelFor< DynRankViewRemap , Policy > closure( *this , Policy( 0 , n0 ) );
-      closure.execute();
-      // Kokkos::fence(); // ??
-    }
+  const OutputView output;
+  const InputView input;
+  const size_t n0;
+  const size_t n1;
+  const size_t n2;
+  const size_t n3;
+  const size_t n4;
+  const size_t n5;
+  const size_t n6;
+  const size_t n7;
+
+  DynRankViewRemap(const OutputView& arg_out, const InputView& arg_in)
+      : output(arg_out),
+        input(arg_in),
+        n0(std::min((size_t)arg_out.extent(0), (size_t)arg_in.extent(0))),
+        n1(std::min((size_t)arg_out.extent(1), (size_t)arg_in.extent(1))),
+        n2(std::min((size_t)arg_out.extent(2), (size_t)arg_in.extent(2))),
+        n3(std::min((size_t)arg_out.extent(3), (size_t)arg_in.extent(3))),
+        n4(std::min((size_t)arg_out.extent(4), (size_t)arg_in.extent(4))),
+        n5(std::min((size_t)arg_out.extent(5), (size_t)arg_in.extent(5))),
+        n6(std::min((size_t)arg_out.extent(6), (size_t)arg_in.extent(6))),
+        n7(std::min((size_t)arg_out.extent(7), (size_t)arg_in.extent(7))) {
+    typedef Kokkos::RangePolicy<ExecSpace> Policy;
+    const Kokkos::Impl::ParallelFor<DynRankViewRemap, Policy> closure(
+        *this, Policy(0, n0));
+    closure.execute();
+    // Kokkos::fence(); // ??
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_t i0 ) const
-  {
-    for ( size_t i1 = 0 ; i1 < n1 ; ++i1 ) {
-    for ( size_t i2 = 0 ; i2 < n2 ; ++i2 ) {
-    for ( size_t i3 = 0 ; i3 < n3 ; ++i3 ) {
-    for ( size_t i4 = 0 ; i4 < n4 ; ++i4 ) {
-    for ( size_t i5 = 0 ; i5 < n5 ; ++i5 ) {
-    for ( size_t i6 = 0 ; i6 < n6 ; ++i6 ) {
-      output.access(i0,i1,i2,i3,i4,i5,i6) = input.access(i0,i1,i2,i3,i4,i5,i6);
-    }}}}}}
+  void operator()(const size_t i0) const {
+    for (size_t i1 = 0; i1 < n1; ++i1) {
+      for (size_t i2 = 0; i2 < n2; ++i2) {
+        for (size_t i3 = 0; i3 < n3; ++i3) {
+          for (size_t i4 = 0; i4 < n4; ++i4) {
+            for (size_t i5 = 0; i5 < n5; ++i5) {
+              for (size_t i6 = 0; i6 < n6; ++i6) {
+                output.access(i0, i1, i2, i3, i4, i5, i6) =
+                    input.access(i0, i1, i2, i3, i4, i5, i6);
+              }
+            }
+          }
+        }
+      }
+    }
   }
 };
 
 } /* namespace Impl */
 } /* namespace Kokkos */
 
-
 namespace Kokkos {
 
 /** \brief  Deep copy a value from Host memory into a view.  */
-template< class DT , class ... DP >
-inline
-void deep_copy
-  ( const DynRankView<DT,DP...> & dst
-  , typename ViewTraits<DT,DP...>::const_value_type & value
-  , typename std::enable_if<
-    std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value
-    >::type * = 0 )
-{
+template <class DT, class... DP>
+inline void deep_copy(
+    const DynRankView<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<DT, DP...>::specialize, void>::value>::type* = 0) {
   static_assert(
-    std::is_same< typename ViewTraits<DT,DP...>::non_const_value_type ,
-                  typename ViewTraits<DT,DP...>::value_type >::value
-    , "deep_copy requires non-const type" );
+      std::is_same<typename ViewTraits<DT, DP...>::non_const_value_type,
+                   typename ViewTraits<DT, DP...>::value_type>::value,
+      "deep_copy requires non-const type");
 
-  Kokkos::Impl::DynRankViewFill< DynRankView<DT,DP...> >( dst , value );
+  Kokkos::Impl::DynRankViewFill<DynRankView<DT, DP...> >(dst, value);
 }
 
 /** \brief  Deep copy into a value in Host memory from a view.  */
-template< class ST , class ... SP >
-inline
-void deep_copy
-  ( typename ViewTraits<ST,SP...>::non_const_value_type & dst
-  , const DynRankView<ST,SP...> & src
-  , typename std::enable_if<
-    std::is_same< typename ViewTraits<ST,SP...>::specialize , void >::value
-    >::type * = 0 )
-{
-  if ( src.rank() != 0 )
-  {
+template <class ST, class... SP>
+inline void deep_copy(
+    typename ViewTraits<ST, SP...>::non_const_value_type& dst,
+    const DynRankView<ST, SP...>& src,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<ST, SP...>::specialize, void>::value>::type* = 0) {
+  if (src.rank() != 0) {
     Kokkos::abort("");
   }
 
-  typedef ViewTraits<ST,SP...>               src_traits ;
-  typedef typename src_traits::memory_space  src_memory_space ;
-  Kokkos::Impl::DeepCopy< HostSpace , src_memory_space >( & dst , src.data() , sizeof(ST) );
+  typedef ViewTraits<ST, SP...> src_traits;
+  typedef typename src_traits::memory_space src_memory_space;
+  Kokkos::Impl::DeepCopy<HostSpace, src_memory_space>(&dst, src.data(),
+                                                      sizeof(ST));
 }
 
 //----------------------------------------------------------------------------
-/** \brief  A deep copy between views of the default specialization, compatible type,
- *          same rank, same contiguous layout.
+/** \brief  A deep copy between views of the default specialization, compatible
+ * type, same rank, same contiguous layout.
  */
-template< class DstType , class SrcType >
-inline
-void deep_copy
-  ( const DstType & dst
-  , const SrcType & src
-  , typename std::enable_if<(
-    std::is_same< typename DstType::traits::specialize , void >::value &&
-    std::is_same< typename SrcType::traits::specialize , void >::value
-    &&
-    ( Kokkos::is_dyn_rank_view<DstType>::value || Kokkos::is_dyn_rank_view<SrcType>::value)
-  )>::type * = 0 )
-{
+template <class DstType, class SrcType>
+inline void deep_copy(
+    const DstType& dst, const SrcType& src,
+    typename std::enable_if<
+        (std::is_same<typename DstType::traits::specialize, void>::value &&
+         std::is_same<typename SrcType::traits::specialize, void>::value &&
+         (Kokkos::is_dyn_rank_view<DstType>::value ||
+          Kokkos::is_dyn_rank_view<SrcType>::value))>::type* = 0) {
   static_assert(
-    std::is_same< typename DstType::traits::value_type ,
-                  typename DstType::traits::non_const_value_type >::value
-    , "deep_copy requires non-const destination type" );
-
-  typedef DstType  dst_type ;
-  typedef SrcType  src_type ;
+      std::is_same<typename DstType::traits::value_type,
+                   typename DstType::traits::non_const_value_type>::value,
+      "deep_copy requires non-const destination type");
 
-  typedef typename dst_type::execution_space  dst_execution_space ;
-  typedef typename src_type::execution_space  src_execution_space ;
-  typedef typename dst_type::memory_space     dst_memory_space ;
-  typedef typename src_type::memory_space     src_memory_space ;
+  typedef DstType dst_type;
+  typedef SrcType src_type;
 
-  enum { DstExecCanAccessSrc =
-   Kokkos::Impl::SpaceAccessibility< dst_execution_space , src_memory_space >::accessible };
+  typedef typename dst_type::execution_space dst_execution_space;
+  typedef typename src_type::execution_space src_execution_space;
+  typedef typename dst_type::memory_space dst_memory_space;
+  typedef typename src_type::memory_space src_memory_space;
 
-  enum { SrcExecCanAccessDst =
-   Kokkos::Impl::SpaceAccessibility< src_execution_space , dst_memory_space >::accessible };
+  enum {
+    DstExecCanAccessSrc =
+        Kokkos::Impl::SpaceAccessibility<dst_execution_space,
+                                         src_memory_space>::accessible
+  };
 
-  if ( (void *) dst.data() != (void*) src.data() ) {
+  enum {
+    SrcExecCanAccessDst =
+        Kokkos::Impl::SpaceAccessibility<src_execution_space,
+                                         dst_memory_space>::accessible
+  };
 
+  if ((void*)dst.data() != (void*)src.data()) {
     // Concern: If overlapping views then a parallel copy will be erroneous.
     // ...
 
-    // If same type, equal layout, equal dimensions, equal span, and contiguous memory then can byte-wise copy
-    if ( rank(src) == 0 && rank(dst) == 0 )
-    {
-      typedef typename dst_type::value_type    value_type ;
-      Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >( dst.data() , src.data() , sizeof(value_type) );
-    }
-    else if ( std::is_same< typename DstType::traits::value_type ,
-                       typename SrcType::traits::non_const_value_type >::value &&
-         (
-           ( std::is_same< typename DstType::traits::array_layout ,
-                           typename SrcType::traits::array_layout >::value
-             &&
-             ( std::is_same< typename DstType::traits::array_layout ,
-                             typename Kokkos::LayoutLeft>::value
-             ||
-               std::is_same< typename DstType::traits::array_layout ,
-                             typename Kokkos::LayoutRight>::value
-             )
-           )
-           ||
-           (
-             rank(dst) == 1
-             &&
-             rank(src) == 1
-           )
-         ) &&
-         dst.span_is_contiguous() &&
-         src.span_is_contiguous() &&
-         dst.span() == src.span() &&
-         dst.extent(0) == src.extent(0) &&
-
-         dst.extent(1) == src.extent(1) &&
-         dst.extent(2) == src.extent(2) &&
-         dst.extent(3) == src.extent(3) &&
-         dst.extent(4) == src.extent(4) &&
-         dst.extent(5) == src.extent(5) &&
-         dst.extent(6) == src.extent(6) &&
-         dst.extent(7) == src.extent(7) ) {
-
+    // If same type, equal layout, equal dimensions, equal span, and contiguous
+    // memory then can byte-wise copy
+    if (rank(src) == 0 && rank(dst) == 0) {
+      typedef typename dst_type::value_type value_type;
+      Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space>(
+          dst.data(), src.data(), sizeof(value_type));
+    } else if (std::is_same<
+                   typename DstType::traits::value_type,
+                   typename SrcType::traits::non_const_value_type>::value &&
+               ((std::is_same<typename DstType::traits::array_layout,
+                              typename SrcType::traits::array_layout>::value &&
+                 (std::is_same<typename DstType::traits::array_layout,
+                               typename Kokkos::LayoutLeft>::value ||
+                  std::is_same<typename DstType::traits::array_layout,
+                               typename Kokkos::LayoutRight>::value)) ||
+                (rank(dst) == 1 && rank(src) == 1)) &&
+               dst.span_is_contiguous() && src.span_is_contiguous() &&
+               dst.span() == src.span() && dst.extent(0) == src.extent(0) &&
+
+               dst.extent(1) == src.extent(1) &&
+               dst.extent(2) == src.extent(2) &&
+               dst.extent(3) == src.extent(3) &&
+               dst.extent(4) == src.extent(4) &&
+               dst.extent(5) == src.extent(5) &&
+               dst.extent(6) == src.extent(6) &&
+               dst.extent(7) == src.extent(7)) {
       const size_t nbytes = sizeof(typename dst_type::value_type) * dst.span();
 
-      Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >( dst.data() , src.data() , nbytes );
-    }
-    else if ( std::is_same< typename DstType::traits::value_type ,
-                            typename SrcType::traits::non_const_value_type >::value &&
-         (
-           ( std::is_same< typename DstType::traits::array_layout ,
-                           typename SrcType::traits::array_layout >::value
-             &&
-             std::is_same< typename DstType::traits::array_layout ,
-                          typename Kokkos::LayoutStride>::value
-           )
-           ||
-           (
-             rank(dst) == 1
-             &&
-             rank(src) == 1
-           )
-         ) &&
-         dst.span_is_contiguous() &&
-         src.span_is_contiguous() &&
-         dst.span() == src.span() &&
-         dst.extent(0) == src.extent(0) &&
-         dst.extent(1) == src.extent(1) &&
-         dst.extent(2) == src.extent(2) &&
-         dst.extent(3) == src.extent(3) &&
-         dst.extent(4) == src.extent(4) &&
-         dst.extent(5) == src.extent(5) &&
-         dst.extent(6) == src.extent(6) &&
-         dst.extent(7) == src.extent(7) &&
-         dst.stride_0() == src.stride_0() &&
-         dst.stride_1() == src.stride_1() &&
-         dst.stride_2() == src.stride_2() &&
-         dst.stride_3() == src.stride_3() &&
-         dst.stride_4() == src.stride_4() &&
-         dst.stride_5() == src.stride_5() &&
-         dst.stride_6() == src.stride_6() &&
-         dst.stride_7() == src.stride_7()
-         ) {
-
+      Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space>(
+          dst.data(), src.data(), nbytes);
+    } else if (std::is_same<
+                   typename DstType::traits::value_type,
+                   typename SrcType::traits::non_const_value_type>::value &&
+               ((std::is_same<typename DstType::traits::array_layout,
+                              typename SrcType::traits::array_layout>::value &&
+                 std::is_same<typename DstType::traits::array_layout,
+                              typename Kokkos::LayoutStride>::value) ||
+                (rank(dst) == 1 && rank(src) == 1)) &&
+               dst.span_is_contiguous() && src.span_is_contiguous() &&
+               dst.span() == src.span() && dst.extent(0) == src.extent(0) &&
+               dst.extent(1) == src.extent(1) &&
+               dst.extent(2) == src.extent(2) &&
+               dst.extent(3) == src.extent(3) &&
+               dst.extent(4) == src.extent(4) &&
+               dst.extent(5) == src.extent(5) &&
+               dst.extent(6) == src.extent(6) &&
+               dst.extent(7) == src.extent(7) &&
+               dst.stride_0() == src.stride_0() &&
+               dst.stride_1() == src.stride_1() &&
+               dst.stride_2() == src.stride_2() &&
+               dst.stride_3() == src.stride_3() &&
+               dst.stride_4() == src.stride_4() &&
+               dst.stride_5() == src.stride_5() &&
+               dst.stride_6() == src.stride_6() &&
+               dst.stride_7() == src.stride_7()) {
       const size_t nbytes = sizeof(typename dst_type::value_type) * dst.span();
 
-      Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >( dst.data() , src.data() , nbytes );
-    }
-    else if ( DstExecCanAccessSrc ) {
-      // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-      Kokkos::Impl::DynRankViewRemap< dst_type , src_type >( dst , src );
-    }
-    else if ( SrcExecCanAccessDst ) {
-      // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-      Kokkos::Impl::DynRankViewRemap< dst_type , src_type , src_execution_space >( dst , src );
-    }
-    else {
-      Kokkos::Impl::throw_runtime_exception("deep_copy given views that would require a temporary allocation");
+      Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space>(
+          dst.data(), src.data(), nbytes);
+    } else if (DstExecCanAccessSrc) {
+      // Copying data between views in accessible memory spaces and either
+      // non-contiguous or incompatible shape.
+      Kokkos::Impl::DynRankViewRemap<dst_type, src_type>(dst, src);
+    } else if (SrcExecCanAccessDst) {
+      // Copying data between views in accessible memory spaces and either
+      // non-contiguous or incompatible shape.
+      Kokkos::Impl::DynRankViewRemap<dst_type, src_type, src_execution_space>(
+          dst, src);
+    } else {
+      Kokkos::Impl::throw_runtime_exception(
+          "deep_copy given views that would require a temporary allocation");
     }
   }
 }
 
-} //end Kokkos
-
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1858,223 +1956,219 @@ void deep_copy
 namespace Kokkos {
 namespace Impl {
 
-
 // Deduce Mirror Types
-template<class Space, class T, class ... P>
+template <class Space, class T, class... P>
 struct MirrorDRViewType {
   // The incoming view_type
-  typedef typename Kokkos::DynRankView<T,P...> src_view_type;
+  typedef typename Kokkos::DynRankView<T, P...> src_view_type;
   // The memory space for the mirror view
   typedef typename Space::memory_space memory_space;
   // Check whether it is the same memory space
-  enum { is_same_memspace = std::is_same<memory_space,typename src_view_type::memory_space>::value };
+  enum {
+    is_same_memspace =
+        std::is_same<memory_space, typename src_view_type::memory_space>::value
+  };
   // The array_layout
   typedef typename src_view_type::array_layout array_layout;
-  // The data type (we probably want it non-const since otherwise we can't even deep_copy to it.
+  // The data type (we probably want it non-const since otherwise we can't even
+  // deep_copy to it.
   typedef typename src_view_type::non_const_data_type data_type;
   // The destination view type if it is not the same memory space
-  typedef Kokkos::DynRankView<data_type,array_layout,Space> dest_view_type;
+  typedef Kokkos::DynRankView<data_type, array_layout, Space> dest_view_type;
   // If it is the same memory_space return the existsing view_type
   // This will also keep the unmanaged trait if necessary
-  typedef typename std::conditional<is_same_memspace,src_view_type,dest_view_type>::type view_type;
+  typedef typename std::conditional<is_same_memspace, src_view_type,
+                                    dest_view_type>::type view_type;
 };
 
-template<class Space, class T, class ... P>
+template <class Space, class T, class... P>
 struct MirrorDRVType {
   // The incoming view_type
-  typedef typename Kokkos::DynRankView<T,P...> src_view_type;
+  typedef typename Kokkos::DynRankView<T, P...> src_view_type;
   // The memory space for the mirror view
   typedef typename Space::memory_space memory_space;
   // Check whether it is the same memory space
-  enum { is_same_memspace = std::is_same<memory_space,typename src_view_type::memory_space>::value };
+  enum {
+    is_same_memspace =
+        std::is_same<memory_space, typename src_view_type::memory_space>::value
+  };
   // The array_layout
   typedef typename src_view_type::array_layout array_layout;
-  // The data type (we probably want it non-const since otherwise we can't even deep_copy to it.
+  // The data type (we probably want it non-const since otherwise we can't even
+  // deep_copy to it.
   typedef typename src_view_type::non_const_data_type data_type;
   // The destination view type if it is not the same memory space
-  typedef Kokkos::DynRankView<data_type,array_layout,Space> view_type;
+  typedef Kokkos::DynRankView<data_type, array_layout, Space> view_type;
 };
 
-}
-
-template< class T , class ... P >
-inline
-typename DynRankView<T,P...>::HostMirror
-create_mirror( const DynRankView<T,P...> & src
-             , typename std::enable_if<
-                 std::is_same< typename ViewTraits<T,P...>::specialize , void >::value &&
-                 ! std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
-                               , Kokkos::LayoutStride >::value
-               >::type * = 0
-             )
-{
-  typedef DynRankView<T,P...>                   src_type ;
-  typedef typename src_type::HostMirror  dst_type ;
-
-  return dst_type( std::string( src.label() ).append("_mirror")
-                 , Impl::reconstructLayout(src.layout(), src.rank()) );
-}
+}  // namespace Impl
 
+template <class T, class... P>
+inline typename DynRankView<T, P...>::HostMirror create_mirror(
+    const DynRankView<T, P...>& src,
+    typename std::enable_if<
+        std::is_same<typename ViewTraits<T, P...>::specialize, void>::value &&
+        !std::is_same<typename Kokkos::ViewTraits<T, P...>::array_layout,
+                      Kokkos::LayoutStride>::value>::type* = 0) {
+  typedef DynRankView<T, P...> src_type;
+  typedef typename src_type::HostMirror dst_type;
 
-template< class T , class ... P >
-inline
-typename DynRankView<T,P...>::HostMirror
-create_mirror( const DynRankView<T,P...> & src
-             , typename std::enable_if<
-                 std::is_same< typename ViewTraits<T,P...>::specialize , void >::value &&
-                 std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
-                             , Kokkos::LayoutStride >::value
-               >::type * = 0
-             )
-{
-  typedef DynRankView<T,P...>                   src_type ;
-  typedef typename src_type::HostMirror  dst_type ;
-
-  return dst_type( std::string( src.label() ).append("_mirror")
-                 , Impl::reconstructLayout(src.layout(), src.rank()) );
+  return dst_type(std::string(src.label()).append("_mirror"),
+                  Impl::reconstructLayout(src.layout(), src.rank()));
 }
 
+template <class T, class... P>
+inline typename DynRankView<T, P...>::HostMirror create_mirror(
+    const DynRankView<T, P...>& src,
+    typename std::enable_if<
+        std::is_same<typename ViewTraits<T, P...>::specialize, void>::value &&
+        std::is_same<typename Kokkos::ViewTraits<T, P...>::array_layout,
+                     Kokkos::LayoutStride>::value>::type* = 0) {
+  typedef DynRankView<T, P...> src_type;
+  typedef typename src_type::HostMirror dst_type;
+
+  return dst_type(std::string(src.label()).append("_mirror"),
+                  Impl::reconstructLayout(src.layout(), src.rank()));
+}
 
 // Create a mirror in a new space (specialization for different space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorDRVType<Space,T,P ...>::view_type
-create_mirror(const Space& , const Kokkos::DynRankView<T,P...> & src
-             , typename std::enable_if<
-                 std::is_same< typename ViewTraits<T,P...>::specialize , void >::value
-               >::type * = 0) {
-  return typename Impl::MirrorDRVType<Space,T,P ...>::view_type(src.label(), Impl::reconstructLayout(src.layout(), src.rank()) );
+template <class Space, class T, class... P>
+typename Impl::MirrorDRVType<Space, T, P...>::view_type create_mirror(
+    const Space&, const Kokkos::DynRankView<T, P...>& src,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<T, P...>::specialize, void>::value>::type* = 0) {
+  return typename Impl::MirrorDRVType<Space, T, P...>::view_type(
+      src.label(), Impl::reconstructLayout(src.layout(), src.rank()));
 }
 
-template< class T , class ... P >
-inline
-typename DynRankView<T,P...>::HostMirror
-create_mirror_view( const DynRankView<T,P...> & src
-                  , typename std::enable_if<(
-                      std::is_same< typename DynRankView<T,P...>::memory_space
-                                  , typename DynRankView<T,P...>::HostMirror::memory_space
-                                  >::value
-                      &&
-                      std::is_same< typename DynRankView<T,P...>::data_type
-                                  , typename DynRankView<T,P...>::HostMirror::data_type
-                                  >::value
-                    )>::type * = 0
-                  )
-{
-  return src ;
+template <class T, class... P>
+inline typename DynRankView<T, P...>::HostMirror create_mirror_view(
+    const DynRankView<T, P...>& src,
+    typename std::enable_if<
+        (std::is_same<
+             typename DynRankView<T, P...>::memory_space,
+             typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
+         std::is_same<typename DynRankView<T, P...>::data_type,
+                      typename DynRankView<T, P...>::HostMirror::data_type>::
+             value)>::type* = 0) {
+  return src;
 }
 
-template< class T , class ... P >
-inline
-typename DynRankView<T,P...>::HostMirror
-create_mirror_view( const DynRankView<T,P...> & src
-                  , typename std::enable_if< ! (
-                      std::is_same< typename DynRankView<T,P...>::memory_space
-                                  , typename DynRankView<T,P...>::HostMirror::memory_space
-                                  >::value
-                      &&
-                      std::is_same< typename DynRankView<T,P...>::data_type
-                                  , typename DynRankView<T,P...>::HostMirror::data_type
-                                  >::value
-                    )>::type * = 0
-                  )
-{
-  return Kokkos::create_mirror( src );
+template <class T, class... P>
+inline typename DynRankView<T, P...>::HostMirror create_mirror_view(
+    const DynRankView<T, P...>& src,
+    typename std::enable_if<
+        !(std::is_same<
+              typename DynRankView<T, P...>::memory_space,
+              typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
+          std::is_same<typename DynRankView<T, P...>::data_type,
+                       typename DynRankView<T, P...>::HostMirror::data_type>::
+              value)>::type* = 0) {
+  return Kokkos::create_mirror(src);
 }
 
 // Create a mirror view in a new space (specialization for same space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorDRViewType<Space,T,P ...>::view_type
-create_mirror_view(const Space& , const Kokkos::DynRankView<T,P...> & src
-  , typename std::enable_if<Impl::MirrorDRViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
+template <class Space, class T, class... P>
+typename Impl::MirrorDRViewType<Space, T, P...>::view_type create_mirror_view(
+    const Space&, const Kokkos::DynRankView<T, P...>& src,
+    typename std::enable_if<
+        Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
   return src;
 }
 
 // Create a mirror view in a new space (specialization for different space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorDRViewType<Space,T,P ...>::view_type
-create_mirror_view(const Space& , const Kokkos::DynRankView<T,P...> & src
-  , typename std::enable_if<!Impl::MirrorDRViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-  return typename Impl::MirrorDRViewType<Space,T,P ...>::view_type(src.label(), Impl::reconstructLayout(src.layout(), src.rank()) );
+template <class Space, class T, class... P>
+typename Impl::MirrorDRViewType<Space, T, P...>::view_type create_mirror_view(
+    const Space&, const Kokkos::DynRankView<T, P...>& src,
+    typename std::enable_if<
+        !Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
+  return typename Impl::MirrorDRViewType<Space, T, P...>::view_type(
+      src.label(), Impl::reconstructLayout(src.layout(), src.rank()));
 }
 
-// Create a mirror view and deep_copy in a new space (specialization for same space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorDRViewType<Space,T,P ...>::view_type
-create_mirror_view_and_copy(const Space& , const Kokkos::DynRankView<T,P...> & src
-  , std::string const& name = ""
-  , typename std::enable_if<Impl::MirrorDRViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
+// Create a mirror view and deep_copy in a new space (specialization for same
+// space)
+template <class Space, class T, class... P>
+typename Impl::MirrorDRViewType<Space, T, P...>::view_type
+create_mirror_view_and_copy(
+    const Space&, const Kokkos::DynRankView<T, P...>& src,
+    std::string const& name = "",
+    typename std::enable_if<
+        Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
   (void)name;
   return src;
 }
 
-// Create a mirror view and deep_copy in a new space (specialization for different space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorDRViewType<Space,T,P ...>::view_type
-create_mirror_view_and_copy(const Space& , const Kokkos::DynRankView<T,P...> & src
-  , std::string const& name = ""
-  , typename std::enable_if<!Impl::MirrorDRViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-  using Mirror = typename Impl::MirrorDRViewType<Space,T,P ...>::view_type;
+// Create a mirror view and deep_copy in a new space (specialization for
+// different space)
+template <class Space, class T, class... P>
+typename Impl::MirrorDRViewType<Space, T, P...>::view_type
+create_mirror_view_and_copy(
+    const Space&, const Kokkos::DynRankView<T, P...>& src,
+    std::string const& name = "",
+    typename std::enable_if<
+        !Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
+  using Mirror = typename Impl::MirrorDRViewType<Space, T, P...>::view_type;
   std::string label = name.empty() ? src.label() : name;
-  auto mirror = Mirror( Kokkos::ViewAllocateWithoutInitializing(label), Impl::reconstructLayout(src.layout(), src.rank()) );
+  auto mirror       = Mirror(Kokkos::ViewAllocateWithoutInitializing(label),
+                       Impl::reconstructLayout(src.layout(), src.rank()));
   deep_copy(mirror, src);
   return mirror;
 }
 
-} //end Kokkos
-
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
-/** \brief  Resize a view with copying old data to new data at the corresponding indices. */
-template< class T , class ... P >
-inline
-void resize( DynRankView<T,P...> & v ,
-             const size_t n0 =KOKKOS_INVALID_INDEX ,
-             const size_t n1 =KOKKOS_INVALID_INDEX ,
-             const size_t n2 =KOKKOS_INVALID_INDEX ,
-             const size_t n3 =KOKKOS_INVALID_INDEX ,
-             const size_t n4 =KOKKOS_INVALID_INDEX ,
-             const size_t n5 =KOKKOS_INVALID_INDEX ,
-             const size_t n6 =KOKKOS_INVALID_INDEX ,
-             const size_t n7 =KOKKOS_INVALID_INDEX )
-{
-  typedef DynRankView<T,P...> drview_type ;
-
-  static_assert( Kokkos::ViewTraits<T,P...>::is_managed , "Can only resize managed views" );
-
-  drview_type v_resized( v.label(), n0, n1, n2, n3, n4, n5, n6 );
-
-  Kokkos::Impl::DynRankViewRemap< drview_type , drview_type >( v_resized, v );
-
-  v = v_resized ;
+/** \brief  Resize a view with copying old data to new data at the corresponding
+ * indices. */
+template <class T, class... P>
+inline void resize(DynRankView<T, P...>& v,
+                   const size_t n0 = KOKKOS_INVALID_INDEX,
+                   const size_t n1 = KOKKOS_INVALID_INDEX,
+                   const size_t n2 = KOKKOS_INVALID_INDEX,
+                   const size_t n3 = KOKKOS_INVALID_INDEX,
+                   const size_t n4 = KOKKOS_INVALID_INDEX,
+                   const size_t n5 = KOKKOS_INVALID_INDEX,
+                   const size_t n6 = KOKKOS_INVALID_INDEX,
+                   const size_t n7 = KOKKOS_INVALID_INDEX) {
+  typedef DynRankView<T, P...> drview_type;
+
+  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
+                "Can only resize managed views");
+
+  drview_type v_resized(v.label(), n0, n1, n2, n3, n4, n5, n6);
+
+  Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(v_resized, v);
+
+  v = v_resized;
 }
 
-/** \brief  Resize a view with copying old data to new data at the corresponding indices. */
-template< class T , class ... P >
-inline
-void realloc( DynRankView<T,P...> & v ,
-              const size_t n0 =KOKKOS_INVALID_INDEX ,
-              const size_t n1 =KOKKOS_INVALID_INDEX ,
-              const size_t n2 =KOKKOS_INVALID_INDEX ,
-              const size_t n3 =KOKKOS_INVALID_INDEX ,
-              const size_t n4 =KOKKOS_INVALID_INDEX ,
-              const size_t n5 =KOKKOS_INVALID_INDEX ,
-              const size_t n6 =KOKKOS_INVALID_INDEX ,
-              const size_t n7 =KOKKOS_INVALID_INDEX )
-{
-  typedef DynRankView<T,P...>  drview_type ;
-
-  static_assert( Kokkos::ViewTraits<T,P...>::is_managed , "Can only realloc managed views" );
+/** \brief  Resize a view with copying old data to new data at the corresponding
+ * indices. */
+template <class T, class... P>
+inline void realloc(DynRankView<T, P...>& v,
+                    const size_t n0 = KOKKOS_INVALID_INDEX,
+                    const size_t n1 = KOKKOS_INVALID_INDEX,
+                    const size_t n2 = KOKKOS_INVALID_INDEX,
+                    const size_t n3 = KOKKOS_INVALID_INDEX,
+                    const size_t n4 = KOKKOS_INVALID_INDEX,
+                    const size_t n5 = KOKKOS_INVALID_INDEX,
+                    const size_t n6 = KOKKOS_INVALID_INDEX,
+                    const size_t n7 = KOKKOS_INVALID_INDEX) {
+  typedef DynRankView<T, P...> drview_type;
+
+  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
+                "Can only realloc managed views");
 
   const std::string label = v.label();
 
-  v = drview_type(); // Deallocate first, if the only view to allocation
-  v = drview_type( label, n0, n1, n2, n3, n4, n5, n6 );
+  v = drview_type();  // Deallocate first, if the only view to allocation
+  v = drview_type(label, n0, n1, n2, n3, n4, n5, n6);
 }
 
-} //end Kokkos
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/containers/src/Kokkos_DynamicView.hpp b/lib/kokkos/containers/src/Kokkos_DynamicView.hpp
index 37d56e7cfb02d8071bc79a4bee1fc4b06bb4f692..35a64d164fa10055f3de165939581c83fe5bf97f 100644
--- a/lib/kokkos/containers/src/Kokkos_DynamicView.hpp
+++ b/lib/kokkos/containers/src/Kokkos_DynamicView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,355 +54,360 @@ namespace Kokkos {
 namespace Experimental {
 
 // Simple metafunction for choosing memory space
-// In the current implementation, if memory_space == CudaSpace, 
+// In the current implementation, if memory_space == CudaSpace,
 // use CudaUVMSpace for the chunk 'array' allocation, which
-// contains will contain pointers to chunks of memory allocated 
+// contains will contain pointers to chunks of memory allocated
 // in CudaSpace
 namespace Impl {
-template < class MemSpace >
+template <class MemSpace>
 struct ChunkArraySpace {
   using memory_space = MemSpace;
 };
 
 #ifdef KOKKOS_ENABLE_CUDA
 template <>
-struct ChunkArraySpace< Kokkos::CudaSpace > {
+struct ChunkArraySpace<Kokkos::CudaSpace> {
   using memory_space = typename Kokkos::CudaUVMSpace;
 };
 #endif
 #ifdef KOKKOS_ENABLE_ROCM
 template <>
-struct ChunkArraySpace< Kokkos::Experimental::ROCmSpace > {
+struct ChunkArraySpace<Kokkos::Experimental::ROCmSpace> {
   using memory_space = typename Kokkos::Experimental::ROCmHostPinnedSpace;
 };
 #endif
-} // end namespace Impl
+}  // end namespace Impl
 
 /** \brief Dynamic views are restricted to rank-one and no layout.
  *         Resize only occurs on host outside of parallel_regions.
  *         Subviews are not allowed.
  */
-template< typename DataType , typename ... P >
-class DynamicView : public Kokkos::ViewTraits< DataType , P ... >
-{
-public:
+template <typename DataType, typename... P>
+class DynamicView : public Kokkos::ViewTraits<DataType, P...> {
+ public:
+  typedef Kokkos::ViewTraits<DataType, P...> traits;
 
-  typedef Kokkos::ViewTraits< DataType , P ... >  traits ;
+ private:
+  template <class, class...>
+  friend class DynamicView;
 
-private:
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
 
-  template< class , class ... > friend class DynamicView ;
+  static_assert(traits::rank == 1 && traits::rank_dynamic == 1,
+                "DynamicView must be rank-one");
 
-  typedef Kokkos::Impl::SharedAllocationTracker   track_type ;
-
-  static_assert( traits::rank == 1 && traits::rank_dynamic == 1
-               , "DynamicView must be rank-one" );
-
-  // It is assumed that the value_type is trivially copyable; 
+  // It is assumed that the value_type is trivially copyable;
   // when this is not the case, potential problems can occur.
-  static_assert( std::is_same< typename traits::specialize , void >::value
-               , "DynamicView only implemented for non-specialized View type");
+  static_assert(std::is_same<typename traits::specialize, void>::value,
+                "DynamicView only implemented for non-specialized View type");
 
+  template <class Space, bool = Kokkos::Impl::MemorySpaceAccess<
+                             Space, typename traits::memory_space>::accessible>
+  struct verify_space {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {}
+  };
 
-  template< class Space , bool = Kokkos::Impl::MemorySpaceAccess< Space , typename traits::memory_space >::accessible > struct verify_space
-    { KOKKOS_FORCEINLINE_FUNCTION static void check() {} };
-
-  template< class Space > struct verify_space<Space,false>
-    { KOKKOS_FORCEINLINE_FUNCTION static void check()
-        { Kokkos::abort("Kokkos::DynamicView ERROR: attempt to access inaccessible memory space"); };
+  template <class Space>
+  struct verify_space<Space, false> {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {
+      Kokkos::abort(
+          "Kokkos::DynamicView ERROR: attempt to access inaccessible memory "
+          "space");
     };
+  };
 
-private:
-
-  track_type                     m_track ;
-  typename traits::value_type ** m_chunks ;      // array of pointers to 'chunks' of memory
-  unsigned                       m_chunk_shift ; // ceil(log2(m_chunk_size))
-  unsigned                       m_chunk_mask ;  // m_chunk_size - 1
-  unsigned                       m_chunk_max ;   // number of entries in the chunk array - each pointing to a chunk of extent == m_chunk_size entries
-  unsigned                       m_chunk_size ;  // 2 << (m_chunk_shift - 1)
-
-public:
-
+ private:
+  track_type m_track;
+  typename traits::value_type**
+      m_chunks;            // array of pointers to 'chunks' of memory
+  unsigned m_chunk_shift;  // ceil(log2(m_chunk_size))
+  unsigned m_chunk_mask;   // m_chunk_size - 1
+  unsigned m_chunk_max;  // number of entries in the chunk array - each pointing
+                         // to a chunk of extent == m_chunk_size entries
+  unsigned m_chunk_size;  // 2 << (m_chunk_shift - 1)
+
+ public:
   //----------------------------------------------------------------------
 
   /** \brief  Compatible view of array of scalar types */
-  typedef DynamicView< typename traits::data_type ,
-                       typename traits::device_type >
-    array_type ;
+  typedef DynamicView<typename traits::data_type, typename traits::device_type>
+      array_type;
 
   /** \brief  Compatible view of const data type */
-  typedef DynamicView< typename traits::const_data_type ,
-                       typename traits::device_type >
-    const_type ;
+  typedef DynamicView<typename traits::const_data_type,
+                      typename traits::device_type>
+      const_type;
 
   /** \brief  Compatible view of non-const data type */
-  typedef DynamicView< typename traits::non_const_data_type ,
-                       typename traits::device_type >
-    non_const_type ;
+  typedef DynamicView<typename traits::non_const_data_type,
+                      typename traits::device_type>
+      non_const_type;
 
   /** \brief  Must be accessible everywhere */
-  typedef DynamicView  HostMirror ;
+  typedef DynamicView HostMirror;
 
   /** \brief Unified types */
-  typedef Kokkos::Device<typename traits::device_type::execution_space, Kokkos::AnonymousSpace> uniform_device;
+  typedef Kokkos::Device<typename traits::device_type::execution_space,
+                         Kokkos::AnonymousSpace>
+      uniform_device;
   typedef array_type uniform_type;
   typedef const_type uniform_const_type;
   typedef array_type uniform_runtime_type;
   typedef const_type uniform_runtime_const_type;
-  typedef DynamicView<typename traits::data_type, uniform_device> uniform_nomemspace_type;
-  typedef DynamicView<typename traits::const_data_type, uniform_device> uniform_const_nomemspace_type;
-  typedef DynamicView<typename traits::data_type, uniform_device> uniform_runtime_nomemspace_type;
-  typedef DynamicView<typename traits::const_data_type, uniform_device> uniform_runtime_const_nomemspace_type;
+  typedef DynamicView<typename traits::data_type, uniform_device>
+      uniform_nomemspace_type;
+  typedef DynamicView<typename traits::const_data_type, uniform_device>
+      uniform_const_nomemspace_type;
+  typedef DynamicView<typename traits::data_type, uniform_device>
+      uniform_runtime_nomemspace_type;
+  typedef DynamicView<typename traits::const_data_type, uniform_device>
+      uniform_runtime_const_nomemspace_type;
 
   //----------------------------------------------------------------------
 
   enum { Rank = 1 };
 
   KOKKOS_INLINE_FUNCTION
-  size_t allocation_extent() const noexcept
-    {
-      uintptr_t n = *reinterpret_cast<const uintptr_t*>( m_chunks + m_chunk_max );
-      return (n << m_chunk_shift);
-    }
+  size_t allocation_extent() const noexcept {
+    uintptr_t n = *reinterpret_cast<const uintptr_t*>(m_chunks + m_chunk_max);
+    return (n << m_chunk_shift);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  size_t chunk_size() const noexcept
-    {
-      return m_chunk_size;
-    }
+  size_t chunk_size() const noexcept { return m_chunk_size; }
 
   KOKKOS_INLINE_FUNCTION
-  size_t size() const noexcept
-    {
-      size_t extent_0 = *reinterpret_cast<const size_t*>( m_chunks + m_chunk_max +1 );
-      return extent_0;
-    }
+  size_t size() const noexcept {
+    size_t extent_0 =
+        *reinterpret_cast<const size_t*>(m_chunks + m_chunk_max + 1);
+    return extent_0;
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  size_t extent( const iType & r ) const
-    { return r == 0 ? size() : 1 ; }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION size_t extent(const iType& r) const {
+    return r == 0 ? size() : 1;
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  size_t extent_int( const iType & r ) const
-    { return r == 0 ? size() : 1 ; }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION size_t extent_int(const iType& r) const {
+    return r == 0 ? size() : 1;
+  }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   KOKKOS_INLINE_FUNCTION size_t dimension_0() const { return size(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return 1 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return 1; }
 #endif
 
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return 0 ; }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION void stride( iType * const s ) const { *s = 0 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return 0; }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    *s = 0;
+  }
 
   //----------------------------------------
   // Allocation tracking properties
 
   KOKKOS_INLINE_FUNCTION
-  int use_count() const
-    { return m_track.use_count(); }
+  int use_count() const { return m_track.use_count(); }
 
-  inline
-  const std::string label() const
-    { return m_track.template get_label< typename traits::memory_space >(); }
+  inline const std::string label() const {
+    return m_track.template get_label<typename traits::memory_space>();
+  }
 
   //----------------------------------------------------------------------
   // Range span is the span which contains all members.
 
-  typedef typename traits::value_type &  reference_type ;
-  typedef typename traits::value_type *  pointer_type ;
+  typedef typename traits::value_type& reference_type;
+  typedef typename traits::value_type* pointer_type;
 
-  enum { reference_type_is_lvalue_reference = std::is_lvalue_reference< reference_type >::value };
+  enum {
+    reference_type_is_lvalue_reference =
+        std::is_lvalue_reference<reference_type>::value
+  };
 
-  KOKKOS_INLINE_FUNCTION constexpr bool   span_is_contiguous() const { return false ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return 0 ; }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return false;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return 0; }
 
   //----------------------------------------
 
-  template< typename I0 , class ... Args >
-  KOKKOS_INLINE_FUNCTION
-  reference_type operator()( const I0 & i0 , const Args & ... args ) const
-    {
-      static_assert( Kokkos::Impl::are_integral<I0,Args...>::value
-                   , "Indices must be integral type" );
+  template <typename I0, class... Args>
+  KOKKOS_INLINE_FUNCTION reference_type operator()(const I0& i0,
+                                                   const Args&... args) const {
+    static_assert(Kokkos::Impl::are_integral<I0, Args...>::value,
+                  "Indices must be integral type");
 
-      DynamicView::template verify_space< Kokkos::Impl::ActiveExecutionMemorySpace >::check();
+    DynamicView::template verify_space<
+        Kokkos::Impl::ActiveExecutionMemorySpace>::check();
 
-      // Which chunk is being indexed.
-      const uintptr_t ic = uintptr_t( i0 >> m_chunk_shift );
+    // Which chunk is being indexed.
+    const uintptr_t ic = uintptr_t(i0 >> m_chunk_shift);
 
-      typename traits::value_type * volatile * const ch = m_chunks + ic ;
+    typename traits::value_type* volatile* const ch = m_chunks + ic;
 
-      // Do bounds checking if enabled or if the chunk pointer is zero.
-      // If not bounds checking then we assume a non-zero pointer is valid.
+    // Do bounds checking if enabled or if the chunk pointer is zero.
+    // If not bounds checking then we assume a non-zero pointer is valid.
 
-#if ! defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-      if ( 0 == *ch )
+#if !defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+    if (0 == *ch)
 #endif
-      {
-        // Verify that allocation of the requested chunk in in progress.
-
-        // The allocated chunk counter is m_chunks[ m_chunk_max ]
-        const uintptr_t n =
-          *reinterpret_cast<uintptr_t volatile *>( m_chunks + m_chunk_max );
+    {
+      // Verify that allocation of the requested chunk in in progress.
 
-        if ( n <= ic ) {
-          Kokkos::abort("Kokkos::DynamicView array bounds error");
-        }
+      // The allocated chunk counter is m_chunks[ m_chunk_max ]
+      const uintptr_t n =
+          *reinterpret_cast<uintptr_t volatile*>(m_chunks + m_chunk_max);
 
-        // Allocation of this chunk is in progress
-        // so wait for allocation to complete.
-        while ( 0 == *ch );
+      if (n <= ic) {
+        Kokkos::abort("Kokkos::DynamicView array bounds error");
       }
 
-      return (*ch)[ i0 & m_chunk_mask ];
+      // Allocation of this chunk is in progress
+      // so wait for allocation to complete.
+      while (0 == *ch)
+        ;
     }
 
+    return (*ch)[i0 & m_chunk_mask];
+  }
+
   //----------------------------------------
   /** \brief  Resizing in serial can grow or shrink the array size
    *          up to the maximum number of chunks
    * */
-  template< typename IntType >
-  inline
-  typename std::enable_if
-    < std::is_integral<IntType>::value &&
-      Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace
-                                     , typename Impl::ChunkArraySpace< typename traits::memory_space >::memory_space 
-                                     >::accessible
-    >::type
-  resize_serial( IntType const & n )
-    {
-      typedef typename traits::value_type local_value_type ;
-      typedef local_value_type * value_pointer_type ;
-
-      const uintptr_t NC = ( n + m_chunk_mask ) >> m_chunk_shift ; // New total number of chunks needed for resize
+  template <typename IntType>
+  inline typename std::enable_if<
+      std::is_integral<IntType>::value &&
+      Kokkos::Impl::MemorySpaceAccess<
+          Kokkos::HostSpace,
+          typename Impl::ChunkArraySpace<
+              typename traits::memory_space>::memory_space>::accessible>::type
+  resize_serial(IntType const& n) {
+    typedef typename traits::value_type local_value_type;
+    typedef local_value_type* value_pointer_type;
+
+    const uintptr_t NC =
+        (n + m_chunk_mask) >>
+        m_chunk_shift;  // New total number of chunks needed for resize
+
+    if (m_chunk_max < NC) {
+      Kokkos::abort("DynamicView::resize_serial exceeded maximum size");
+    }
 
-      if ( m_chunk_max < NC ) {
-        Kokkos::abort("DynamicView::resize_serial exceeded maximum size");
-      }
+    // *m_chunks[m_chunk_max] stores the current number of chunks being used
+    uintptr_t* const pc = reinterpret_cast<uintptr_t*>(m_chunks + m_chunk_max);
 
-      // *m_chunks[m_chunk_max] stores the current number of chunks being used
-      uintptr_t * const pc =
-        reinterpret_cast<uintptr_t*>( m_chunks + m_chunk_max );
-
-      if ( *pc < NC ) {
-        while ( *pc < NC ) {
-          m_chunks[*pc] = reinterpret_cast<value_pointer_type>
-            (
-             typename traits::memory_space().allocate( sizeof(local_value_type) << m_chunk_shift )
-            );
-          ++*pc ;
-        }
+    if (*pc < NC) {
+      while (*pc < NC) {
+        m_chunks[*pc] = reinterpret_cast<value_pointer_type>(
+            typename traits::memory_space().allocate(sizeof(local_value_type)
+                                                     << m_chunk_shift));
+        ++*pc;
       }
-      else {
-        while ( NC + 1 <= *pc ) {
-          --*pc ;
-          typename traits::memory_space().deallocate( m_chunks[*pc]
-                                         , sizeof(local_value_type) << m_chunk_shift );
-          m_chunks[*pc] = 0 ;
-        }
+    } else {
+      while (NC + 1 <= *pc) {
+        --*pc;
+        typename traits::memory_space().deallocate(
+            m_chunks[*pc], sizeof(local_value_type) << m_chunk_shift);
+        m_chunks[*pc] = 0;
       }
-      // *m_chunks[m_chunk_max+1] stores the 'extent' requested by resize
-      *(pc+1) = n;
     }
+    // *m_chunks[m_chunk_max+1] stores the 'extent' requested by resize
+    *(pc + 1) = n;
+  }
 
   //----------------------------------------------------------------------
 
-  ~DynamicView() = default ;
-  DynamicView() = default ;
-  DynamicView( DynamicView && ) = default ;
-  DynamicView( const DynamicView & ) = default ;
-  DynamicView & operator = ( DynamicView && ) = default ;
-  DynamicView & operator = ( const DynamicView & ) = default ;
-
-  template< class RT , class ... RP >
-  DynamicView( const DynamicView<RT,RP...> & rhs )
-    : m_track( rhs.m_track )
-    , m_chunks( (typename traits::value_type **) rhs.m_chunks )
-    , m_chunk_shift( rhs.m_chunk_shift )
-    , m_chunk_mask( rhs.m_chunk_mask )
-    , m_chunk_max( rhs.m_chunk_max )
-    , m_chunk_size( rhs.m_chunk_size )
-    {
-      typedef typename DynamicView<RT,RP...>::traits  SrcTraits ;
-      typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , void >  Mapping ;
-      static_assert( Mapping::is_assignable , "Incompatible DynamicView copy construction" );
-    }
+  ~DynamicView()                  = default;
+  DynamicView()                   = default;
+  DynamicView(DynamicView&&)      = default;
+  DynamicView(const DynamicView&) = default;
+  DynamicView& operator=(DynamicView&&) = default;
+  DynamicView& operator=(const DynamicView&) = default;
+
+  template <class RT, class... RP>
+  DynamicView(const DynamicView<RT, RP...>& rhs)
+      : m_track(rhs.m_track),
+        m_chunks((typename traits::value_type**)rhs.m_chunks),
+        m_chunk_shift(rhs.m_chunk_shift),
+        m_chunk_mask(rhs.m_chunk_mask),
+        m_chunk_max(rhs.m_chunk_max),
+        m_chunk_size(rhs.m_chunk_size) {
+    typedef typename DynamicView<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits, void> Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible DynamicView copy construction");
+  }
 
   //----------------------------------------------------------------------
 
   struct Destroy {
-    typename traits::value_type ** m_chunks ;
-    unsigned                       m_chunk_max ;
-    bool                           m_destroy ;
-    unsigned                       m_chunk_size ;
+    typename traits::value_type** m_chunks;
+    unsigned m_chunk_max;
+    bool m_destroy;
+    unsigned m_chunk_size;
 
     // Initialize or destroy array of chunk pointers.
     // Two entries beyond the max chunks are allocation counters.
-    inline
-    void operator()( unsigned i ) const
-      {
-        if ( m_destroy && i < m_chunk_max && 0 != m_chunks[i] ) {
-          typename traits::memory_space().deallocate( m_chunks[i], m_chunk_size );
-        }
-        m_chunks[i] = 0 ;
+    inline void operator()(unsigned i) const {
+      if (m_destroy && i < m_chunk_max && 0 != m_chunks[i]) {
+        typename traits::memory_space().deallocate(m_chunks[i], m_chunk_size);
       }
+      m_chunks[i] = 0;
+    }
 
-    void execute( bool arg_destroy )
-      {
-        typedef Kokkos::RangePolicy< typename HostSpace::execution_space > Range ;
-        //typedef Kokkos::RangePolicy< typename Impl::ChunkArraySpace< typename traits::memory_space >::memory_space::execution_space > Range ;
+    void execute(bool arg_destroy) {
+      typedef Kokkos::RangePolicy<typename HostSpace::execution_space> Range;
+      // typedef Kokkos::RangePolicy< typename Impl::ChunkArraySpace< typename
+      // traits::memory_space >::memory_space::execution_space > Range ;
 
-        m_destroy = arg_destroy ;
+      m_destroy = arg_destroy;
 
-        Kokkos::Impl::ParallelFor<Destroy,Range>
-          closure( *this , Range(0, m_chunk_max + 2) ); // Add 2 to 'destroy' extra slots storing num_chunks and extent; previously + 1
+      Kokkos::Impl::ParallelFor<Destroy, Range> closure(
+          *this,
+          Range(0, m_chunk_max + 2));  // Add 2 to 'destroy' extra slots storing
+                                       // num_chunks and extent; previously + 1
 
-        closure.execute();
+      closure.execute();
 
-        typename traits::execution_space().fence();
-        //Impl::ChunkArraySpace< typename traits::memory_space >::memory_space::execution_space().fence(); 
-      }
+      typename traits::execution_space().fence();
+      // Impl::ChunkArraySpace< typename traits::memory_space
+      // >::memory_space::execution_space().fence();
+    }
 
-    void construct_shared_allocation()
-      { execute( false ); }
-
-    void destroy_shared_allocation()
-      { execute( true ); }
-
-    Destroy() = default ;
-    Destroy( Destroy && ) = default ;
-    Destroy( const Destroy & ) = default ;
-    Destroy & operator = ( Destroy && ) = default ;
-    Destroy & operator = ( const Destroy & ) = default ;
-
-    Destroy( typename traits::value_type ** arg_chunk
-           , const unsigned arg_chunk_max 
-           , const unsigned arg_chunk_size )
-     : m_chunks( arg_chunk )
-     , m_chunk_max( arg_chunk_max )
-     , m_destroy( false )
-     , m_chunk_size( arg_chunk_size )
-     {}
-  };
+    void construct_shared_allocation() { execute(false); }
+
+    void destroy_shared_allocation() { execute(true); }
 
+    Destroy()               = default;
+    Destroy(Destroy&&)      = default;
+    Destroy(const Destroy&) = default;
+    Destroy& operator=(Destroy&&) = default;
+    Destroy& operator=(const Destroy&) = default;
+
+    Destroy(typename traits::value_type** arg_chunk,
+            const unsigned arg_chunk_max, const unsigned arg_chunk_size)
+        : m_chunks(arg_chunk),
+          m_chunk_max(arg_chunk_max),
+          m_destroy(false),
+          m_chunk_size(arg_chunk_size) {}
+  };
 
   /**\brief  Allocation constructor
    *
@@ -409,180 +415,189 @@ public:
    *  A maximum size is required in order to allocate a
    *  chunk-pointer array.
    */
-  explicit inline
-  DynamicView( const std::string & arg_label
-             , const unsigned min_chunk_size
-             , const unsigned max_extent ) 
-    : m_track()
-    , m_chunks(0)
-    // The chunk size is guaranteed to be a power of two
-    , m_chunk_shift(
-        Kokkos::Impl::integral_power_of_two_that_contains( min_chunk_size ) ) // div ceil(log2(min_chunk_size))
-    , m_chunk_mask( ( 1 << m_chunk_shift ) - 1 )                              // mod
-    , m_chunk_max( ( max_extent + m_chunk_mask ) >> m_chunk_shift )           // max num pointers-to-chunks in array
-    , m_chunk_size ( 2 << (m_chunk_shift - 1) )
-    {
-      typedef typename Impl::ChunkArraySpace< typename traits::memory_space >::memory_space chunk_array_memory_space;
-      // A functor to deallocate all of the chunks upon final destruction
-      typedef Kokkos::Impl::SharedAllocationRecord< chunk_array_memory_space , Destroy > record_type ;
-
-      // Allocate chunk pointers and allocation counter
-      record_type * const record =
-        record_type::allocate( chunk_array_memory_space()
-                             , arg_label
-                             , ( sizeof(pointer_type) * ( m_chunk_max + 2 ) ) ); 
-      // Allocate + 2 extra slots so that *m_chunk[m_chunk_max] == num_chunks_alloc and *m_chunk[m_chunk_max+1] == extent
-      // This must match in Destroy's execute(...) method
-
-      m_chunks = reinterpret_cast<pointer_type*>( record->data() );
-
-      record->m_destroy = Destroy( m_chunks , m_chunk_max, m_chunk_size );
-
-      // Initialize to zero
-      record->m_destroy.construct_shared_allocation();
-
-      m_track.assign_allocated_record_to_uninitialized( record );
-    }
-
+  explicit inline DynamicView(const std::string& arg_label,
+                              const unsigned min_chunk_size,
+                              const unsigned max_extent)
+      : m_track(),
+        m_chunks(0)
+        // The chunk size is guaranteed to be a power of two
+        ,
+        m_chunk_shift(Kokkos::Impl::integral_power_of_two_that_contains(
+            min_chunk_size))  // div ceil(log2(min_chunk_size))
+        ,
+        m_chunk_mask((1 << m_chunk_shift) - 1)  // mod
+        ,
+        m_chunk_max((max_extent + m_chunk_mask) >>
+                    m_chunk_shift)  // max num pointers-to-chunks in array
+        ,
+        m_chunk_size(2 << (m_chunk_shift - 1)) {
+    typedef typename Impl::ChunkArraySpace<
+        typename traits::memory_space>::memory_space chunk_array_memory_space;
+    // A functor to deallocate all of the chunks upon final destruction
+    typedef Kokkos::Impl::SharedAllocationRecord<chunk_array_memory_space,
+                                                 Destroy>
+        record_type;
+
+    // Allocate chunk pointers and allocation counter
+    record_type* const record =
+        record_type::allocate(chunk_array_memory_space(), arg_label,
+                              (sizeof(pointer_type) * (m_chunk_max + 2)));
+    // Allocate + 2 extra slots so that *m_chunk[m_chunk_max] ==
+    // num_chunks_alloc and *m_chunk[m_chunk_max+1] == extent This must match in
+    // Destroy's execute(...) method
+
+    m_chunks = reinterpret_cast<pointer_type*>(record->data());
+
+    record->m_destroy = Destroy(m_chunks, m_chunk_max, m_chunk_size);
+
+    // Initialize to zero
+    record->m_destroy.construct_shared_allocation();
+
+    m_track.assign_allocated_record_to_uninitialized(record);
+  }
 };
 
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template< class T , class ... P >
-inline
-typename Kokkos::Experimental::DynamicView<T,P...>::HostMirror
-create_mirror_view( const Kokkos::Experimental::DynamicView<T,P...> & src )
-{
-  return src ;
+template <class T, class... P>
+inline typename Kokkos::Experimental::DynamicView<T, P...>::HostMirror
+create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src) {
+  return src;
 }
 
-template< class T , class ... DP , class ... SP >
-inline
-void deep_copy( const View<T,DP...> & dst
-              , const Kokkos::Experimental::DynamicView<T,SP...> & src
-              )
-{
-  typedef View<T,DP...>        dst_type ;
-  typedef Kokkos::Experimental::DynamicView<T,SP...> src_type ;
+template <class T, class... DP, class... SP>
+inline void deep_copy(const View<T, DP...>& dst,
+                      const Kokkos::Experimental::DynamicView<T, SP...>& src) {
+  typedef View<T, DP...> dst_type;
+  typedef Kokkos::Experimental::DynamicView<T, SP...> src_type;
 
-  typedef typename ViewTraits<T,DP...>::execution_space  dst_execution_space ;
-  typedef typename ViewTraits<T,SP...>::memory_space     src_memory_space ;
+  typedef typename ViewTraits<T, DP...>::execution_space dst_execution_space;
+  typedef typename ViewTraits<T, SP...>::memory_space src_memory_space;
 
-  enum { DstExecCanAccessSrc =
-   Kokkos::Impl::SpaceAccessibility< dst_execution_space , src_memory_space >::accessible };
+  enum {
+    DstExecCanAccessSrc =
+        Kokkos::Impl::SpaceAccessibility<dst_execution_space,
+                                         src_memory_space>::accessible
+  };
 
-  if ( DstExecCanAccessSrc ) {
-    // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-    Kokkos::Impl::ViewRemap< dst_type , src_type >( dst , src );
-  }
-  else {
-    Kokkos::Impl::throw_runtime_exception("deep_copy given views that would require a temporary allocation");
+  if (DstExecCanAccessSrc) {
+    // Copying data between views in accessible memory spaces and either
+    // non-contiguous or incompatible shape.
+    Kokkos::Impl::ViewRemap<dst_type, src_type>(dst, src);
+  } else {
+    Kokkos::Impl::throw_runtime_exception(
+        "deep_copy given views that would require a temporary allocation");
   }
 }
 
-template< class T , class ... DP , class ... SP >
-inline
-void deep_copy( const Kokkos::Experimental::DynamicView<T,DP...> & dst
-              , const View<T,SP...> & src
-              )
-{
-  typedef Kokkos::Experimental::DynamicView<T,SP...> dst_type ;
-  typedef View<T,DP...>        src_type ;
+template <class T, class... DP, class... SP>
+inline void deep_copy(const Kokkos::Experimental::DynamicView<T, DP...>& dst,
+                      const View<T, SP...>& src) {
+  typedef Kokkos::Experimental::DynamicView<T, SP...> dst_type;
+  typedef View<T, DP...> src_type;
 
-  typedef typename ViewTraits<T,DP...>::execution_space  dst_execution_space ;
-  typedef typename ViewTraits<T,SP...>::memory_space     src_memory_space ;
+  typedef typename ViewTraits<T, DP...>::execution_space dst_execution_space;
+  typedef typename ViewTraits<T, SP...>::memory_space src_memory_space;
 
-  enum { DstExecCanAccessSrc =
-   Kokkos::Impl::SpaceAccessibility< dst_execution_space , src_memory_space >::accessible };
+  enum {
+    DstExecCanAccessSrc =
+        Kokkos::Impl::SpaceAccessibility<dst_execution_space,
+                                         src_memory_space>::accessible
+  };
 
-  if ( DstExecCanAccessSrc ) {
-    // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-    Kokkos::Impl::ViewRemap< dst_type , src_type >( dst , src );
-  }
-  else {
-    Kokkos::Impl::throw_runtime_exception("deep_copy given views that would require a temporary allocation");
+  if (DstExecCanAccessSrc) {
+    // Copying data between views in accessible memory spaces and either
+    // non-contiguous or incompatible shape.
+    Kokkos::Impl::ViewRemap<dst_type, src_type>(dst, src);
+  } else {
+    Kokkos::Impl::throw_runtime_exception(
+        "deep_copy given views that would require a temporary allocation");
   }
 }
 
 namespace Impl {
-template<class Arg0, class ... DP , class ... SP>
-struct CommonSubview<Kokkos::Experimental::DynamicView<DP...>,Kokkos::Experimental::DynamicView<SP...>,1,Arg0> {
+template <class Arg0, class... DP, class... SP>
+struct CommonSubview<Kokkos::Experimental::DynamicView<DP...>,
+                     Kokkos::Experimental::DynamicView<SP...>, 1, Arg0> {
   typedef Kokkos::Experimental::DynamicView<DP...> DstType;
   typedef Kokkos::Experimental::DynamicView<SP...> SrcType;
   typedef DstType dst_subview_type;
   typedef SrcType src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0):
-    dst_sub(dst),src_sub(src) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0)
+      : dst_sub(dst), src_sub(src) {}
 };
 
-template<class ...DP, class SrcType, class Arg0>
-struct CommonSubview<Kokkos::Experimental::DynamicView<DP...>,SrcType,1,Arg0> {
+template <class... DP, class SrcType, class Arg0>
+struct CommonSubview<Kokkos::Experimental::DynamicView<DP...>, SrcType, 1,
+                     Arg0> {
   typedef Kokkos::Experimental::DynamicView<DP...> DstType;
   typedef DstType dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0> src_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0> src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0):
-    dst_sub(dst),src_sub(src,arg0) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0)
+      : dst_sub(dst), src_sub(src, arg0) {}
 };
 
-template<class DstType, class ...SP, class Arg0>
-struct CommonSubview<DstType,Kokkos::Experimental::DynamicView<SP...>,1,Arg0> {
+template <class DstType, class... SP, class Arg0>
+struct CommonSubview<DstType, Kokkos::Experimental::DynamicView<SP...>, 1,
+                     Arg0> {
   typedef Kokkos::Experimental::DynamicView<SP...> SrcType;
-  typedef typename Kokkos::Subview<DstType,Arg0> dst_subview_type;
+  typedef typename Kokkos::Subview<DstType, Arg0> dst_subview_type;
   typedef SrcType src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0):
-    dst_sub(dst,arg0),src_sub(src) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0)
+      : dst_sub(dst, arg0), src_sub(src) {}
 };
 
-template<class ...DP,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<Kokkos::Experimental::DynamicView<DP...>,ViewTypeB,Layout,ExecSpace,1,iType,false> {
+template <class... DP, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<Kokkos::Experimental::DynamicView<DP...>, ViewTypeB, Layout,
+                ExecSpace, 1, iType, false> {
   Kokkos::Experimental::DynamicView<DP...> a;
   ViewTypeB b;
 
-  typedef Kokkos::RangePolicy<ExecSpace,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<iType>> policy_type;
 
-  ViewCopy(const Kokkos::Experimental::DynamicView<DP...>& a_, const ViewTypeB& b_):a(a_),b(b_) {
-    Kokkos::parallel_for("Kokkos::ViewCopy-1D",
-       policy_type(0,b.extent(0)),*this);
+  ViewCopy(const Kokkos::Experimental::DynamicView<DP...>& a_,
+           const ViewTypeB& b_)
+      : a(a_), b(b_) {
+    Kokkos::parallel_for("Kokkos::ViewCopy-1D", policy_type(0, b.extent(0)),
+                         *this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0) const {
-      a(i0) = b(i0);
-  };
+  void operator()(const iType& i0) const { a(i0) = b(i0); };
 };
 
-template<class ...DP,class ...SP, class Layout, class ExecSpace,typename iType>
+template <class... DP, class... SP, class Layout, class ExecSpace,
+          typename iType>
 struct ViewCopy<Kokkos::Experimental::DynamicView<DP...>,
-                Kokkos::Experimental::DynamicView<SP...>,Layout,ExecSpace,1,iType,false> {
+                Kokkos::Experimental::DynamicView<SP...>, Layout, ExecSpace, 1,
+                iType, false> {
   Kokkos::Experimental::DynamicView<DP...> a;
   Kokkos::Experimental::DynamicView<SP...> b;
 
-  typedef Kokkos::RangePolicy<ExecSpace,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<iType>> policy_type;
 
   ViewCopy(const Kokkos::Experimental::DynamicView<DP...>& a_,
-           const Kokkos::Experimental::DynamicView<SP...>& b_):a(a_),b(b_) {
-    const iType n = std::min(a.extent(0),b.extent(0));
-    Kokkos::parallel_for("Kokkos::ViewCopy-1D",
-       policy_type(0,n),*this);
+           const Kokkos::Experimental::DynamicView<SP...>& b_)
+      : a(a_), b(b_) {
+    const iType n = std::min(a.extent(0), b.extent(0));
+    Kokkos::parallel_for("Kokkos::ViewCopy-1D", policy_type(0, n), *this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0) const {
-      a(i0) = b(i0);
-  };
+  void operator()(const iType& i0) const { a(i0) = b(i0); };
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_DYNAMIC_VIEW_HPP */
-
diff --git a/lib/kokkos/containers/src/Kokkos_ErrorReporter.hpp b/lib/kokkos/containers/src/Kokkos_ErrorReporter.hpp
index e05ea1a9d5be4a550ed177348fe4d4c62289ace4..25335771e4cced618e960dad39da90a9acebf56e 100644
--- a/lib/kokkos/containers/src/Kokkos_ErrorReporter.hpp
+++ b/lib/kokkos/containers/src/Kokkos_ErrorReporter.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,19 +54,16 @@ namespace Kokkos {
 namespace Experimental {
 
 template <typename ReportType, typename DeviceType>
-class ErrorReporter
-{
-public:
-
-  typedef ReportType                                      report_type;
-  typedef DeviceType                                      device_type;
-  typedef typename device_type::execution_space           execution_space;
+class ErrorReporter {
+ public:
+  typedef ReportType report_type;
+  typedef DeviceType device_type;
+  typedef typename device_type::execution_space execution_space;
 
   ErrorReporter(int max_results)
-    : m_numReportsAttempted(""),
-      m_reports("", max_results),
-      m_reporters("", max_results)
-  {
+      : m_numReportsAttempted(""),
+        m_reports("", max_results),
+        m_reporters("", max_results) {
     clear();
   }
 
@@ -75,49 +73,49 @@ public:
 
   int getNumReportAttempts();
 
-  void getReports(std::vector<int> &reporters_out, std::vector<report_type> &reports_out);
-  void getReports( typename Kokkos::View<int*, typename DeviceType::execution_space >::HostMirror &reporters_out,
-                   typename Kokkos::View<report_type*, typename DeviceType::execution_space >::HostMirror &reports_out);
+  void getReports(std::vector<int> &reporters_out,
+                  std::vector<report_type> &reports_out);
+  void getReports(
+      typename Kokkos::View<int *,
+                            typename DeviceType::execution_space>::HostMirror
+          &reporters_out,
+      typename Kokkos::View<report_type *,
+                            typename DeviceType::execution_space>::HostMirror
+          &reports_out);
 
   void clear();
 
   void resize(const size_t new_size);
 
-  bool full() {return (getNumReportAttempts() >= getCapacity()); }
+  bool full() { return (getNumReportAttempts() >= getCapacity()); }
 
   KOKKOS_INLINE_FUNCTION
-  bool add_report(int reporter_id, report_type report) const
-  {
+  bool add_report(int reporter_id, report_type report) const {
     int idx = Kokkos::atomic_fetch_add(&m_numReportsAttempted(), 1);
 
     if (idx >= 0 && (idx < static_cast<int>(m_reports.d_view.extent(0)))) {
       m_reporters.d_view(idx) = reporter_id;
       m_reports.d_view(idx)   = report;
       return true;
-    }
-    else {
+    } else {
       return false;
     }
   }
 
-private:
-
-  typedef Kokkos::View<report_type *, execution_space>        reports_view_t;
-  typedef Kokkos::DualView<report_type *, execution_space>    reports_dualview_t;
+ private:
+  typedef Kokkos::View<report_type *, execution_space> reports_view_t;
+  typedef Kokkos::DualView<report_type *, execution_space> reports_dualview_t;
 
-  typedef typename reports_dualview_t::host_mirror_space  host_mirror_space;
-  Kokkos::View<int, execution_space>   m_numReportsAttempted;
-  reports_dualview_t                   m_reports;
+  typedef typename reports_dualview_t::host_mirror_space host_mirror_space;
+  Kokkos::View<int, execution_space> m_numReportsAttempted;
+  reports_dualview_t m_reports;
   Kokkos::DualView<int *, execution_space> m_reporters;
-
 };
 
-
 template <typename ReportType, typename DeviceType>
-inline int ErrorReporter<ReportType, DeviceType>::getNumReports()
-{
+inline int ErrorReporter<ReportType, DeviceType>::getNumReports() {
   int num_reports = 0;
-  Kokkos::deep_copy(num_reports,m_numReportsAttempted);
+  Kokkos::deep_copy(num_reports, m_numReportsAttempted);
   if (num_reports > static_cast<int>(m_reports.h_view.extent(0))) {
     num_reports = m_reports.h_view.extent(0);
   }
@@ -125,16 +123,15 @@ inline int ErrorReporter<ReportType, DeviceType>::getNumReports()
 }
 
 template <typename ReportType, typename DeviceType>
-inline int ErrorReporter<ReportType, DeviceType>::getNumReportAttempts()
-{
+inline int ErrorReporter<ReportType, DeviceType>::getNumReportAttempts() {
   int num_reports = 0;
-  Kokkos::deep_copy(num_reports,m_numReportsAttempted);
+  Kokkos::deep_copy(num_reports, m_numReportsAttempted);
   return num_reports;
 }
 
 template <typename ReportType, typename DeviceType>
-void ErrorReporter<ReportType, DeviceType>::getReports(std::vector<int> &reporters_out, std::vector<report_type> &reports_out)
-{
+void ErrorReporter<ReportType, DeviceType>::getReports(
+    std::vector<int> &reporters_out, std::vector<report_type> &reports_out) {
   int num_reports = getNumReports();
   reporters_out.clear();
   reporters_out.reserve(num_reports);
@@ -154,12 +151,18 @@ void ErrorReporter<ReportType, DeviceType>::getReports(std::vector<int> &reporte
 
 template <typename ReportType, typename DeviceType>
 void ErrorReporter<ReportType, DeviceType>::getReports(
-    typename Kokkos::View<int*, typename DeviceType::execution_space >::HostMirror &reporters_out,
-    typename Kokkos::View<report_type*, typename DeviceType::execution_space >::HostMirror &reports_out)
-{
+    typename Kokkos::View<
+        int *, typename DeviceType::execution_space>::HostMirror &reporters_out,
+    typename Kokkos::View<report_type *,
+                          typename DeviceType::execution_space>::HostMirror
+        &reports_out) {
   int num_reports = getNumReports();
-  reporters_out = typename Kokkos::View<int*, typename DeviceType::execution_space >::HostMirror("ErrorReport::reporters_out",num_reports);
-  reports_out = typename Kokkos::View<report_type*, typename DeviceType::execution_space >::HostMirror("ErrorReport::reports_out",num_reports);
+  reporters_out =
+      typename Kokkos::View<int *, typename DeviceType::execution_space>::
+          HostMirror("ErrorReport::reporters_out", num_reports);
+  reports_out = typename Kokkos::
+      View<report_type *, typename DeviceType::execution_space>::HostMirror(
+          "ErrorReport::reports_out", num_reports);
 
   if (num_reports > 0) {
     m_reports.template sync<host_mirror_space>();
@@ -167,31 +170,27 @@ void ErrorReporter<ReportType, DeviceType>::getReports(
 
     for (int i = 0; i < num_reports; ++i) {
       reporters_out(i) = m_reporters.h_view(i);
-      reports_out(i) = m_reports.h_view(i);
+      reports_out(i)   = m_reports.h_view(i);
     }
   }
 }
 
 template <typename ReportType, typename DeviceType>
-void ErrorReporter<ReportType, DeviceType>::clear()
-{
-  int num_reports=0;
+void ErrorReporter<ReportType, DeviceType>::clear() {
+  int num_reports = 0;
   Kokkos::deep_copy(m_numReportsAttempted, num_reports);
   m_reports.template modify<execution_space>();
   m_reporters.template modify<execution_space>();
 }
 
 template <typename ReportType, typename DeviceType>
-void ErrorReporter<ReportType, DeviceType>::resize(const size_t new_size)
-{
+void ErrorReporter<ReportType, DeviceType>::resize(const size_t new_size) {
   m_reports.resize(new_size);
   m_reporters.resize(new_size);
   Kokkos::fence();
 }
 
-
-} // namespace Experimental
-} // namespace kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/containers/src/Kokkos_Functional.hpp b/lib/kokkos/containers/src/Kokkos_Functional.hpp
index 4d256cce270d8edf728dfe84611230e5160c5a3c..d908458518e1b5331c1553e7f252cab310c1b766 100644
--- a/lib/kokkos/containers/src/Kokkos_Functional.hpp
+++ b/lib/kokkos/containers/src/Kokkos_Functional.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,123 +51,107 @@ namespace Kokkos {
 // These should work for most types
 
 template <typename T>
-struct pod_hash
-{
+struct pod_hash {
   typedef T argument_type;
   typedef T first_argument_type;
   typedef uint32_t second_argument_type;
   typedef uint32_t result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  uint32_t operator()(T const & t) const
-  { return Impl::MurmurHash3_x86_32( &t, sizeof(T), 0); }
+  uint32_t operator()(T const& t) const {
+    return Impl::MurmurHash3_x86_32(&t, sizeof(T), 0);
+  }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  uint32_t operator()(T const & t, uint32_t seed) const
-  { return Impl::MurmurHash3_x86_32( &t, sizeof(T), seed); }
+  uint32_t operator()(T const& t, uint32_t seed) const {
+    return Impl::MurmurHash3_x86_32(&t, sizeof(T), seed);
+  }
 };
 
 template <typename T>
-struct pod_equal_to
-{
+struct pod_equal_to {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return Impl::bitwise_equal(&a,&b); }
+  bool operator()(T const& a, T const& b) const {
+    return Impl::bitwise_equal(&a, &b);
+  }
 };
 
 template <typename T>
-struct pod_not_equal_to
-{
+struct pod_not_equal_to {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return !Impl::bitwise_equal(&a,&b); }
+  bool operator()(T const& a, T const& b) const {
+    return !Impl::bitwise_equal(&a, &b);
+  }
 };
 
 template <typename T>
-struct equal_to
-{
+struct equal_to {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return a == b; }
+  bool operator()(T const& a, T const& b) const { return a == b; }
 };
 
 template <typename T>
-struct not_equal_to
-{
+struct not_equal_to {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return a != b; }
+  bool operator()(T const& a, T const& b) const { return a != b; }
 };
 
-
 template <typename T>
-struct greater
-{
+struct greater {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return a > b; }
+  bool operator()(T const& a, T const& b) const { return a > b; }
 };
 
-
 template <typename T>
-struct less
-{
+struct less {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return a < b; }
+  bool operator()(T const& a, T const& b) const { return a < b; }
 };
 
 template <typename T>
-struct greater_equal
-{
+struct greater_equal {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return a >= b; }
+  bool operator()(T const& a, T const& b) const { return a >= b; }
 };
 
-
 template <typename T>
-struct less_equal
-{
+struct less_equal {
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool operator()(T const & a, T const & b) const
-  { return a <= b; }
+  bool operator()(T const& a, T const& b) const { return a <= b; }
 };
 
-} // namespace Kokkos
-
-
-#endif //KOKKOS_FUNCTIONAL_HPP
+}  // namespace Kokkos
 
+#endif  // KOKKOS_FUNCTIONAL_HPP
diff --git a/lib/kokkos/containers/src/Kokkos_OffsetView.hpp b/lib/kokkos/containers/src/Kokkos_OffsetView.hpp
index 4ce1f4d84fa51cb2419706c39ccabbf5c26048d3..a1fe793cc5447c1436a9b455f4ede5eab9a59367 100644
--- a/lib/kokkos/containers/src/Kokkos_OffsetView.hpp
+++ b/lib/kokkos/containers/src/Kokkos_OffsetView.hpp
@@ -8,1890 +8,2092 @@
 #ifndef KOKKOS_OFFSETVIEW_HPP_
 #define KOKKOS_OFFSETVIEW_HPP_
 
-
 #include <Kokkos_Core.hpp>
 
 #include <Kokkos_View.hpp>
 
 namespace Kokkos {
 
-   namespace Experimental {
-      //----------------------------------------------------------------------------
-      //----------------------------------------------------------------------------
-
-      template< class DataType , class ... Properties >
-      class OffsetView ;
-
-      template< class > struct is_offset_view : public std::false_type {};
-
-      template< class D, class ... P >
-      struct is_offset_view< OffsetView<D,P...> > : public std::true_type {};
-
-      template< class D, class ... P >
-      struct is_offset_view< const OffsetView<D,P...> > : public std::true_type {};
-
-#define KOKKOS_INVALID_OFFSET int64_t(0)
-#define KOKKOS_INVALID_INDEX_RANGE {KOKKOS_INVALID_OFFSET, KOKKOS_INVALID_OFFSET}
-
-      template <typename iType, typename std::enable_if< std::is_integral<iType>::value &&
-      std::is_signed<iType>::value, iType >::type = 0>
-      using IndexRange  = Kokkos::Array<iType, 2>;
-
-
-      using index_list_type = std::initializer_list<int64_t>;
-
-
-      //  template <typename iType,
-      //    typename std::enable_if< std::is_integral<iType>::value &&
-      //      std::is_signed<iType>::value, iType >::type = 0> using min_index_type = std::initializer_list<iType>;
-
-      namespace Impl {
-
-         template<class ViewType>
-         struct GetOffsetViewTypeFromViewType {
-
-            typedef OffsetView<typename ViewType::data_type,typename ViewType::array_layout,
-                  typename ViewType::device_type,typename ViewType::memory_traits> type;
-
-         };
-
-         template< unsigned , class MapType, class BeginsType >
-         KOKKOS_INLINE_FUNCTION
-         bool offsetview_verify_operator_bounds( const MapType &, const BeginsType & )
-         { return true ; }
-
-         template< unsigned R , class MapType , class BeginsType, class iType , class ... Args >
-         KOKKOS_INLINE_FUNCTION
-         bool offsetview_verify_operator_bounds
-         ( const MapType & map
-           , const BeginsType & begins
-           , const iType   & i
-           , Args ... args
-         )
-         {
-
-           const bool legalIndex =  ( int64_t(i) >=  begins[R]  ) &&
-               ( int64_t(i) <= int64_t(begins[R] + map.extent(R) - 1) );
-           return  legalIndex
-               && offsetview_verify_operator_bounds<R+1>( map , begins,  args ... );
-         }
-         template< unsigned , class MapType, class BeginsType >
-         inline
-         void offsetview_error_operator_bounds( char * , int , const MapType & , const BeginsType &)
-         {}
-
-         template< unsigned R , class MapType , class BeginsType , class iType , class ... Args >
-         inline
-         void offsetview_error_operator_bounds
-           ( char * buf
-           , int len
-           , const MapType & map
-           , const  BeginsType begins
-           , const iType   & i
-           , Args ... args
-           )
-         {
-           const int64_t b = begins[R];
-           const int64_t e = b + map.extent(R) - 1;
-           const int n =
-             snprintf(buf,len," %ld <= %ld <= %ld %c"
-                     , static_cast<unsigned long>(b)
-                     , static_cast<unsigned long>(i)
-                     , static_cast<unsigned long>(e)
-                     , ( sizeof...(Args) ? ',' : ')' )
-                     );
-           offsetview_error_operator_bounds<R+1>(buf+n,len-n,map,begins,args...);
-         }
-
-         template< class MemorySpace , class MapType , class BeginsType, class ... Args >
-         KOKKOS_INLINE_FUNCTION
-         void offsetview_verify_operator_bounds
-           ( Kokkos::Impl::SharedAllocationTracker const & tracker
-           , const MapType & map , const BeginsType & begins, Args ... args )
-         {
-           if ( ! offsetview_verify_operator_bounds<0>( map , begins, args ... ) ) {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-              enum { LEN = 1024 };
-              char buffer[ LEN ];
-              const std::string label = tracker.template get_label<MemorySpace>();
-              int n = snprintf(buffer,LEN,"OffsetView bounds error of view labeled %s (",label.c_str());
-              offsetview_error_operator_bounds<0>( buffer + n , LEN - n , map ,begins, args ... );
-              Kokkos::Impl::throw_runtime_exception(std::string(buffer));
-#else
-              /* Check #1: is there a SharedAllocationRecord?
-                (we won't use it, but if its not there then there isn't
-                 a corresponding SharedAllocationHeader containing a label).
-                This check should cover the case of Views that don't
-                have the Unmanaged trait but were initialized by pointer. */
-              if (tracker.has_record()) {
-		Kokkos::Impl::operator_bounds_error_on_device<MapType>(
-			      map, Kokkos::Impl::has_printable_label_typedef<MapType>());
-              } else {
-                 Kokkos::abort("OffsetView bounds error");
-              }
-#endif
-           }
-         }
+namespace Experimental {
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 
-#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-         KOKKOS_INLINE_FUNCTION
-         void runtime_check_rank_host(const size_t rank_dynamic, const size_t rank,
-               const index_list_type minIndices, const std::string & label)
-         {
-            bool isBad = false;
-            std::string message = "Kokkos::Experimental::OffsetView ERROR: for OffsetView labeled '" + label + "':";
-            if (rank_dynamic != rank) {
-               message += "The full rank must be the same as the dynamic rank. full rank = ";
-               message += std::to_string(rank) + " dynamic rank = " + std::to_string(rank_dynamic) + "\n";
-               isBad = true;
-            }
-
-            size_t numOffsets = 0;
-            for(size_t i = 0; i < minIndices.size(); ++i ){
-               if( minIndices.begin()[i] != -KOKKOS_INVALID_OFFSET) numOffsets++;
-            }
-            if (numOffsets != rank_dynamic) {
-               message += "The number of offsets provided ( " + std::to_string(numOffsets) +
-                     " ) must equal the dynamic rank ( " + std::to_string(rank_dynamic) + " ).";
-               isBad = true;
-            }
-
-            if(isBad) Kokkos::abort(message.c_str());
-         }
-#endif
+template <class DataType, class... Properties>
+class OffsetView;
 
-         KOKKOS_INLINE_FUNCTION
-         void runtime_check_rank_device(const size_t rank_dynamic, const size_t rank,
-               const index_list_type minIndices)
-         {
-            if (rank_dynamic != rank) {
-               Kokkos::abort("The full rank of an OffsetView must be the same as the dynamic rank.");
-            }
-            size_t numOffsets = 0;
-            for(size_t i = 0; i < minIndices.size(); ++i ){
-               if( minIndices.begin()[i] != -KOKKOS_INVALID_OFFSET) numOffsets++;
-            }
-            if (numOffsets != rank) {
-               Kokkos::abort("The number of offsets provided to an OffsetView constructor must equal the dynamic rank.");
-            }
-
-         }
-      }
+template <class>
+struct is_offset_view : public std::false_type {};
 
-      template< class DataType , class ... Properties >
-      class OffsetView : public ViewTraits< DataType , Properties ... > {
-      public:
-
-         typedef ViewTraits< DataType , Properties ... > traits ;
-
-
-
-      private:
-
-         template< class , class ... > friend class OffsetView ;
-         template< class , class ... > friend class View ;  //FIXME delete this line
-         template< class , class ... > friend class Kokkos::Impl::ViewMapping ;
-
-
-         typedef Kokkos::Impl::ViewMapping< traits , void > map_type ;
-         typedef Kokkos::Impl::SharedAllocationTracker      track_type ;
-      public:
-         enum { Rank = map_type::Rank };
-         typedef Kokkos::Array<int64_t, Rank>  begins_type ;
-
-
-         template <typename iType, typename std::enable_if< std::is_integral<iType>::value, iType>::type = 0>
-         KOKKOS_INLINE_FUNCTION
-         int64_t begin(const iType local_dimension) const {
-             return local_dimension < Rank ? m_begins[local_dimension] : 0;
-         }
-
-         KOKKOS_INLINE_FUNCTION
-         begins_type begins() const { return m_begins;}
-
-         template <typename iType, typename std::enable_if< std::is_integral<iType>::value, iType>::type = 0>
-         KOKKOS_INLINE_FUNCTION
-         int64_t end(const iType local_dimension) const {
-             return begin(local_dimension) + m_map.extent(local_dimension);
-         }
-
-
-      private:
-         track_type  m_track ;
-         map_type    m_map ;
-         begins_type  m_begins;
-
-      public:
-         //----------------------------------------
-         /** \brief  Compatible view of array of scalar types */
-         typedef OffsetView< typename traits::scalar_array_type ,
-               typename traits::array_layout ,
-               typename traits::device_type ,
-               typename traits::memory_traits >
-         array_type ;
-
-         /** \brief  Compatible view of const data type */
-         typedef OffsetView< typename traits::const_data_type ,
-               typename traits::array_layout ,
-               typename traits::device_type ,
-               typename traits::memory_traits >
-         const_type ;
-
-         /** \brief  Compatible view of non-const data type */
-         typedef OffsetView< typename traits::non_const_data_type ,
-               typename traits::array_layout ,
-               typename traits::device_type ,
-               typename traits::memory_traits >
-         non_const_type ;
-
-         /** \brief  Compatible HostMirror view */
-         typedef OffsetView< typename traits::non_const_data_type ,
-               typename traits::array_layout ,
-               typename traits::host_mirror_space >
-         HostMirror ;
-
-         //----------------------------------------
-         // Domain rank and extents
-
-         /** \brief rank() to be implemented
-          */
-         //KOKKOS_INLINE_FUNCTION
-         //static
-         //constexpr unsigned rank() { return map_type::Rank; }
-
-         template< typename iType >
-         KOKKOS_INLINE_FUNCTION constexpr
-         typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-         extent( const iType & r ) const
-         { return m_map.extent(r); }
-
-         template< typename iType >
-         KOKKOS_INLINE_FUNCTION constexpr
-         typename std::enable_if< std::is_integral<iType>::value , int >::type
-         extent_int( const iType & r ) const
-         { return static_cast<int>(m_map.extent(r)); }
-
-         KOKKOS_INLINE_FUNCTION constexpr
-         typename traits::array_layout layout() const
-         { return m_map.layout(); }
-
-
-         KOKKOS_INLINE_FUNCTION constexpr size_t size() const { return m_map.dimension_0() *
-               m_map.dimension_1() *
-               m_map.dimension_2() *
-               m_map.dimension_3() *
-               m_map.dimension_4() *
-               m_map.dimension_5() *
-               m_map.dimension_6() *
-               m_map.dimension_7(); }
-
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return m_map.stride_0(); }
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return m_map.stride_1(); }
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return m_map.stride_2(); }
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return m_map.stride_3(); }
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return m_map.stride_4(); }
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return m_map.stride_5(); }
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return m_map.stride_6(); }
-         KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return m_map.stride_7(); }
-
-         template< typename iType >
-         KOKKOS_INLINE_FUNCTION constexpr
-         typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-         stride(iType r) const {
-            return (r == 0 ? m_map.stride_0() :
-                  (r == 1 ? m_map.stride_1() :
-                        (r == 2 ? m_map.stride_2() :
-                              (r == 3 ? m_map.stride_3() :
-                                    (r == 4 ? m_map.stride_4() :
-                                          (r == 5 ? m_map.stride_5() :
-                                                (r == 6 ? m_map.stride_6() :
-                                                      m_map.stride_7())))))));
-         }
-
-         template< typename iType >
-         KOKKOS_INLINE_FUNCTION void stride( iType * const s ) const { m_map.stride(s); }
-
-         //----------------------------------------
-         // Range span is the span which contains all members.
-
-         typedef typename map_type::reference_type  reference_type ;
-         typedef typename map_type::pointer_type    pointer_type ;
-
-         enum { reference_type_is_lvalue_reference = std::is_lvalue_reference< reference_type >::value };
-
-         KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return m_map.span(); }
-         KOKKOS_INLINE_FUNCTION bool span_is_contiguous() const { return m_map.span_is_contiguous(); }
-         KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return m_map.data(); }
-
-         //----------------------------------------
-         // Allow specializations to query their specialized map
-
-         KOKKOS_INLINE_FUNCTION
-         const Kokkos::Impl::ViewMapping< traits , void > &
-         implementation_map() const { return m_map ; }
-
-         //----------------------------------------
-
-      private:
-
-         enum {
-            is_layout_left = std::is_same< typename traits::array_layout
-            , Kokkos::LayoutLeft >::value ,
-
-            is_layout_right = std::is_same< typename traits::array_layout
-            , Kokkos::LayoutRight >::value ,
-
-            is_layout_stride = std::is_same< typename traits::array_layout
-            , Kokkos::LayoutStride >::value ,
-
-            is_default_map =
-                  std::is_same< typename traits::specialize , void >::value &&
-                  ( is_layout_left || is_layout_right || is_layout_stride )
-         };
-
-         template< class Space , bool = Kokkos::Impl::MemorySpaceAccess< Space , typename traits::memory_space >::accessible > struct verify_space
-               { KOKKOS_FORCEINLINE_FUNCTION static void check() {} };
-
-         template< class Space > struct verify_space<Space,false>
-         { KOKKOS_FORCEINLINE_FUNCTION static void check()
-         { Kokkos::abort("Kokkos::View ERROR: attempt to access inaccessible memory space");
-         };
-         };
-
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-
-#define KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( ARG ) \
-      OffsetView::template verify_space< Kokkos::Impl::ActiveExecutionMemorySpace >::check(); \
-      Kokkos::Experimental::Impl::offsetview_verify_operator_bounds< typename traits::memory_space > ARG ;
+template <class D, class... P>
+struct is_offset_view<OffsetView<D, P...> > : public std::true_type {};
 
-#else
+template <class D, class... P>
+struct is_offset_view<const OffsetView<D, P...> > : public std::true_type {};
 
-#define KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( ARG ) \
-      OffsetView::template verify_space< Kokkos::Impl::ActiveExecutionMemorySpace >::check();
+#define KOKKOS_INVALID_OFFSET int64_t(0x7FFFFFFFFFFFFFFFLL)
+#define KOKKOS_INVALID_INDEX_RANGE \
+  { KOKKOS_INVALID_OFFSET, KOKKOS_INVALID_OFFSET }
 
-#endif
-      public:
-
-         //------------------------------
-         // Rank 0 operator()
-
-         KOKKOS_FORCEINLINE_FUNCTION
-         reference_type
-         operator()() const
-         {
-            return m_map.reference();
-         }
-         //------------------------------
-         // Rank 1 operator()
-
-
-         template< typename I0>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0>::value
-               && ( 1 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0) const
-         {
-
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0) )
-                          const size_t j0 = i0 - m_begins[0];
-            return m_map.reference(j0);
-         }
-
-         template< typename I0>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0>::value
-               && ( 1 == Rank )
-               && is_default_map
-               && ! is_layout_stride
-         ), reference_type >::type
-         operator()( const I0 & i0 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0) )
-                          const size_t j0 = i0 - m_begins[0];
-            return m_map.m_impl_handle[ j0 ];
-         }
-
-         template< typename I0 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0>::value
-               && ( 1 == Rank )
-               && is_default_map
-               && is_layout_stride
-         ), reference_type >::type
-         operator()( const I0 & i0) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0) )
-                          const size_t j0 = i0 - m_begins[0];
-            return m_map.m_impl_handle[ m_map.m_impl_offset.m_stride.S0 * j0 ];
-         }
-         //------------------------------
-         // Rank 1 operator[]
-
-         template< typename I0 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0>::value
-               && ( 1 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator[]( const I0 & i0 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0) )
-                          const size_t j0 = i0 - m_begins[0];
-            return m_map.reference(j0);
-         }
-
-         template< typename I0 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0>::value
-               && ( 1 == Rank )
-               && is_default_map
-               && ! is_layout_stride
-         ), reference_type >::type
-         operator[]( const I0 & i0 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0) )
-                          const size_t j0 = i0 - m_begins[0];
-            return m_map.m_impl_handle[ j0 ];
-         }
-
-         template< typename I0 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0>::value
-               && ( 1 == Rank )
-               && is_default_map
-               && is_layout_stride
-         ), reference_type >::type
-         operator[]( const I0 & i0 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0) )
-                          const size_t j0 = i0 - m_begins[0];
-            return m_map.m_impl_handle[ m_map.m_impl_offset.m_stride.S0 * j0 ];
-         }
-
-
-         //------------------------------
-         // Rank 2
-
-         template< typename I0 , typename I1 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1>::value
-               && ( 2 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            return m_map.reference(j0,j1);
-         }
-
-         template< typename I0 , typename I1 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1>::value
-               && ( 2 == Rank )
-               && is_default_map
-               && is_layout_left && ( traits::rank_dynamic == 0 )
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            return m_map.m_impl_handle[ j0 + m_map.m_impl_offset.m_dim.N0 * j1 ];
-         }
-
-         template< typename I0 , typename I1>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1>::value
-               && ( 2 == Rank )
-               && is_default_map
-               && is_layout_left && ( traits::rank_dynamic != 0 )
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            return m_map.m_impl_handle[ j0 + m_map.m_impl_offset.m_stride * j1 ];
-         }
-
-         template< typename I0 , typename I1 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1>::value
-               && ( 2 == Rank )
-               && is_default_map
-               && is_layout_right && ( traits::rank_dynamic == 0 )
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            return m_map.m_impl_handle[ j1 + m_map.m_impl_offset.m_dim.N1 * j0 ];
-         }
-
-         template< typename I0 , typename I1 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1>::value
-               && ( 2 == Rank )
-               && is_default_map
-               && is_layout_right && ( traits::rank_dynamic != 0 )
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            return m_map.m_impl_handle[ j1 + m_map.m_impl_offset.m_stride * j0 ];
-         }
-
-         template< typename I0 , typename I1>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1>::value
-               && ( 2 == Rank )
-               && is_default_map
-               && is_layout_stride
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            return m_map.m_impl_handle[ j0 * m_map.m_impl_offset.m_stride.S0 +
-                                        j1 * m_map.m_impl_offset.m_stride.S1 ];
-         }
-
-         //------------------------------
-         // Rank 3
-
-         template< typename I0 , typename I1 , typename I2 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2>::value
-               && ( 3 == Rank )
-               && is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1, i2) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            return m_map.m_impl_handle[ m_map.m_impl_offset(j0, j1, j2) ];
-         }
-
-         template< typename I0 , typename I1 , typename I2>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2>::value
-               && ( 3 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map,m_begins, i0,i1, i2) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            return m_map.reference(j0, j1, j2);
-         }
-
-         //------------------------------
-         // Rank 4
-
-         template< typename I0 , typename I1 , typename I2 , typename I3>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3>::value
-               && ( 4 == Rank )
-               && is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1, i2, i3) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            return m_map.m_impl_handle[ m_map.m_impl_offset(j0,j1,j2,j3) ];
-         }
-
-         template< typename I0 , typename I1 , typename I2 , typename I3 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3>::value
-               && ( 4 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1, i2, i3) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            return m_map.reference(j0,j1,j2,j3);
-         }
-
-         //------------------------------
-         // Rank 5
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4>::value
-               && ( 5 == Rank )
-               && is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1, i2, i3, i4) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            return m_map.m_impl_handle[ m_map.m_impl_offset(j0, j1,j2, j3, j4) ];
-         }
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4>::value
-               && ( 5 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map, m_begins, i0,i1, i2, i3, i4) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            return m_map.reference(j0,j1,j2,j3,j4);
-         }
-
-         //------------------------------
-         // Rank 6
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4 , typename I5 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5>::value
-               && ( 6 == Rank )
-               && is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4 , const I5 & i5 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map,m_begins, i0,i1, i2, i3, i4, i5) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            const size_t j5 = i5 - m_begins[5];
-            return m_map.m_impl_handle[ m_map.m_impl_offset(j0,j1,j2,j3,j4,j5) ];
-         }
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4 , typename I5>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5>::value
-               && ( 6 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4 , const I5 & i5) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map,m_begins, i0,i1, i2, i3, i4, i5) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            const size_t j5 = i5 - m_begins[5];
-            return m_map.reference(j0,j1,j2,j3,j4,j5);
-         }
-
-         //------------------------------
-         // Rank 7
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4 , typename I5 , typename I6>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6>::value
-               && ( 7 == Rank )
-               && is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4 , const I5 & i5 , const I6 & i6) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map,m_begins, i0,i1, i2, i3, i4, i5, i6) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            const size_t j5 = i5 - m_begins[5];
-            const size_t j6 = i6 - m_begins[6];
-            return m_map.m_impl_handle[ m_map.m_impl_offset(j0,j1,j2,j3,j4,j5,j6) ];
-         }
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4 , typename I5 , typename I6 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6>::value
-               && ( 7 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4 , const I5 & i5 , const I6 & i6) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map,m_begins, i0,i1, i2, i3, i4, i5, i6) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            const size_t j5 = i5 - m_begins[5];
-            const size_t j6 = i6 - m_begins[6];
-            return m_map.reference(j0,j1,j2,j3,j4,j5,j6);
-         }
-
-         //------------------------------
-         // Rank 8
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4 , typename I5 , typename I6 , typename I7 >
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7>::value
-               && ( 8 == Rank )
-               && is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map,m_begins, i0,i1, i2, i3, i4, i5, i6, i7) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            const size_t j5 = i5 - m_begins[5];
-            const size_t j6 = i6 - m_begins[6];
-            const size_t j7 = i7 - m_begins[7];
-            return m_map.m_impl_handle[ m_map.m_impl_offset(j0,j1,j2,j3,j4,j5,j6,j7) ];
-         }
-
-         template< typename I0 , typename I1 , typename I2 , typename I3
-         , typename I4 , typename I5 , typename I6 , typename I7>
-         KOKKOS_FORCEINLINE_FUNCTION
-         typename std::enable_if<
-         ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7>::value
-               && ( 8 == Rank )
-               && ! is_default_map
-         ), reference_type >::type
-         operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-               , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7 ) const
-         {
-            KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY( (m_track,m_map,m_begins, i0,i1, i2, i3, i4, i5, i6, i7) )
-                          const size_t j0 = i0 - m_begins[0];
-            const size_t j1 = i1 - m_begins[1];
-            const size_t j2 = i2 - m_begins[2];
-            const size_t j3 = i3 - m_begins[3];
-            const size_t j4 = i4 - m_begins[4];
-            const size_t j5 = i5 - m_begins[5];
-            const size_t j6 = i6 - m_begins[6];
-            const size_t j7 = i7 - m_begins[7];
-            return m_map.reference(j0,j1,j2,j3,j4,j5,j6,j7);
-         }
+template <typename iType,
+          typename std::enable_if<std::is_integral<iType>::value &&
+                                      std::is_signed<iType>::value,
+                                  iType>::type = 0>
+using IndexRange = Kokkos::Array<iType, 2>;
 
+using index_list_type = std::initializer_list<int64_t>;
 
-#undef KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY
+//  template <typename iType,
+//    typename std::enable_if< std::is_integral<iType>::value &&
+//      std::is_signed<iType>::value, iType >::type = 0> using min_index_type =
+//      std::initializer_list<iType>;
 
-         //----------------------------------------
-         // Standard destructor, constructors, and assignment operators
-
-         KOKKOS_INLINE_FUNCTION
-         ~OffsetView() {}
-
-         KOKKOS_INLINE_FUNCTION
-         OffsetView() : m_track(), m_map() {
-
-            for(size_t i = 0; i < Rank; ++i) m_begins[i] = KOKKOS_INVALID_INDEX;
-         }
-
-         KOKKOS_INLINE_FUNCTION
-         OffsetView( const OffsetView & rhs ) : m_track( rhs.m_track, traits::is_managed ), m_map( rhs.m_map ),
-         m_begins(rhs.m_begins) {}
-
-         KOKKOS_INLINE_FUNCTION
-         OffsetView( OffsetView && rhs ) : m_track( std::move(rhs.m_track) ),
-         m_map( std::move(rhs.m_map)), m_begins(std::move(rhs.m_begins)) {}
-
-         KOKKOS_INLINE_FUNCTION
-         OffsetView & operator = ( const OffsetView & rhs ) {
-            m_track = rhs.m_track ;
-            m_map = rhs.m_map ;
-            m_begins = rhs.m_begins;
-            return *this ;
-         }
-
-         KOKKOS_INLINE_FUNCTION
-         OffsetView & operator = ( OffsetView && rhs ) {
-            m_track = std::move(rhs.m_track) ;
-            m_map = std::move(rhs.m_map) ;
-            m_begins = std::move(rhs.m_begins) ;
-            return *this ;
-         }
-
-         //interoperability with View
-      private:
-         typedef View< typename traits::scalar_array_type ,
-               typename traits::array_layout ,
-               typename traits::device_type ,
-               typename traits::memory_traits > view_type;
-      public:
-
-         KOKKOS_INLINE_FUNCTION
-         view_type view() const {
-
-            view_type v(m_track, m_map);
-            return v ;
-         }
-
-         template<class RT, class ... RP>
-         KOKKOS_INLINE_FUNCTION
-         OffsetView( const View<RT, RP...> & aview) :
-         m_track(aview.impl_track()), m_map(){
-
-            typedef typename OffsetView<RT,RP...>::traits  SrcTraits ;
-            typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , void >  Mapping ;
-            static_assert( Mapping::is_assignable , "Incompatible OffsetView copy construction" );
-            Mapping::assign( m_map , aview.impl_map() , m_track );
-
-            for (int i = 0; i < aview.Rank; ++i) {
-               m_begins[i] = 0;
-            }
-         }
-
-         template<class RT, class ... RP>
-         KOKKOS_INLINE_FUNCTION
-         OffsetView( const View<RT, RP...> & aview
-               ,const index_list_type & minIndices) :
-               m_track(aview.impl_track()), m_map(){
-
-            typedef typename OffsetView<RT,RP...>::traits  SrcTraits ;
-            typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , void >  Mapping ;
-            static_assert( Mapping::is_assignable , "Incompatible OffsetView copy construction" );
-            Mapping::assign( m_map , aview.impl_map() , m_track );
+namespace Impl {
 
-#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-            Kokkos::Experimental::Impl::runtime_check_rank_host(traits::rank_dynamic, Rank, minIndices, label());
-#else
-            Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic, Rank, minIndices);
+template <class ViewType>
+struct GetOffsetViewTypeFromViewType {
+  typedef OffsetView<
+      typename ViewType::data_type, typename ViewType::array_layout,
+      typename ViewType::device_type, typename ViewType::memory_traits>
+      type;
+};
 
-#endif
+template <unsigned, class MapType, class BeginsType>
+KOKKOS_INLINE_FUNCTION bool offsetview_verify_operator_bounds(
+    const MapType&, const BeginsType&) {
+  return true;
+}
 
-            for (size_t i = 0; i < minIndices.size(); ++i) {
-               m_begins[i] = minIndices.begin()[i];
-            }
-         }
-         template<class RT, class ... RP>
-         KOKKOS_INLINE_FUNCTION
-         OffsetView( const View<RT, RP...> & aview
-               ,const begins_type & beg) :
-               m_track(aview.impl_track()), m_map(), m_begins(beg){
-
-            typedef typename OffsetView<RT,RP...>::traits  SrcTraits ;
-            typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , void >  Mapping ;
-            static_assert( Mapping::is_assignable , "Incompatible OffsetView copy construction" );
-            Mapping::assign( m_map , aview.impl_map() , m_track );
-
-
-            //#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-            //        Kokkos::Experimental::Impl::runtime_check_rank_host(traits::rank_dynamic, Rank, minIndices, label());
-            //#else
-            //        Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic, Rank, minIndices);
-            //
-            //#endif
-
-         }
-
-         // may assign unmanaged from managed.
-
-
-         template< class RT , class ... RP >
-         KOKKOS_INLINE_FUNCTION
-         OffsetView( const OffsetView<RT,RP...> & rhs )
-         : m_track( rhs.m_track , traits::is_managed )
-         , m_map()
-         , m_begins(rhs.m_begins)
-         {
-            typedef typename OffsetView<RT,RP...>::traits  SrcTraits ;
-            typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , void >  Mapping ;
-            static_assert( Mapping::is_assignable , "Incompatible OffsetView copy construction" );
-            Mapping::assign( m_map , rhs.m_map , rhs.m_track );  //swb what about assign?
-         }
-
-
-         //----------------------------------------
-         // Allocation tracking properties
-         KOKKOS_INLINE_FUNCTION
-         int use_count() const
-         { return m_track.use_count(); }
-
-         inline
-         const std::string label() const
-         { return m_track.template get_label< typename traits::memory_space >(); }
-
-
-         template< typename Label>
-         explicit inline
-         OffsetView( const Label & arg_label
-               ,typename std::enable_if<Kokkos::Impl::is_view_label<Label>::value , const index_list_type >::type
-               range0
-               ,const index_list_type range1 = KOKKOS_INVALID_INDEX_RANGE
-               ,const index_list_type range2 = KOKKOS_INVALID_INDEX_RANGE
-               ,const index_list_type range3 = KOKKOS_INVALID_INDEX_RANGE
-               ,const index_list_type range4 = KOKKOS_INVALID_INDEX_RANGE
-               ,const index_list_type range5 = KOKKOS_INVALID_INDEX_RANGE
-               ,const index_list_type range6 = KOKKOS_INVALID_INDEX_RANGE
-               ,const index_list_type range7 = KOKKOS_INVALID_INDEX_RANGE
-
-         ) : OffsetView( Kokkos::Impl::ViewCtorProp< std::string >( arg_label ),
-               typename traits::array_layout
-               ( range0.begin()[1] - range0.begin()[0] + 1, range1.begin()[1] - range1.begin()[0] + 1 ,
-                     range2.begin()[1] - range2.begin()[0] + 1, range3.begin()[1] - range3.begin()[0] + 1,
-                     range4.begin()[1] - range4.begin()[0] + 1, range5.begin()[1] - range5.begin()[0] + 1 ,
-                     range6.begin()[1] - range6.begin()[0] + 1, range7.begin()[1] - range7.begin()[0] + 1 ),
-                     {range0.begin()[0], range1.begin()[0], range2.begin()[0], range3.begin()[0], range4.begin()[0],
-                           range5.begin()[0], range6.begin()[0], range7.begin()[0] })
-         {
-
-         }
-
-
-
-         template<class ... P >
-         explicit KOKKOS_INLINE_FUNCTION
-         OffsetView( const Kokkos::Impl::ViewCtorProp< P ... > & arg_prop
-               ,typename std::enable_if< Kokkos::Impl::ViewCtorProp< P... >::has_pointer , typename traits::array_layout >::type const & arg_layout
-               ,const index_list_type minIndices
-         )
-         : m_track() // No memory tracking
-         , m_map( arg_prop , arg_layout )
-         {
-
-
-            for (size_t i = 0; i < minIndices.size(); ++i) {
-               m_begins[i] = minIndices.begin()[i];
-            }
-            static_assert(
-                  std::is_same< pointer_type
-                  , typename Kokkos::Impl::ViewCtorProp< P... >::pointer_type
-                  >::value ,
-                  "When constructing OffsetView to wrap user memory, you must supply matching pointer type" );
-         }
-
-         template<class ... P >
-         explicit inline
-         OffsetView( const Kokkos::Impl::ViewCtorProp< P ... > & arg_prop
-               , typename std::enable_if< ! Kokkos::Impl::ViewCtorProp< P... >::has_pointer , typename traits::array_layout>::type const & arg_layout
-               ,const index_list_type minIndices
-         )
-         : m_track()
-         , m_map()
-
-         {
-
-            for(size_t i = 0; i < Rank; ++i)
-               m_begins[i] = minIndices.begin()[i];
-
-            // Append layout and spaces if not input
-            typedef Kokkos::Impl::ViewCtorProp< P ... > alloc_prop_input ;
-
-            // use 'std::integral_constant<unsigned,I>' for non-types
-            // to avoid duplicate class error.
-            typedef Kokkos::Impl::ViewCtorProp
-                  < P ..., typename std::conditional < alloc_prop_input::has_label
-                  , std::integral_constant<unsigned,0>, typename std::string >::type
-                  , typename std::conditional
-                  < alloc_prop_input::has_memory_space
-                  , std::integral_constant<unsigned,1>
-            , typename traits::device_type::memory_space
-            >::type
-            , typename std::conditional
-            < alloc_prop_input::has_execution_space
-            , std::integral_constant<unsigned,2>
-            , typename traits::device_type::execution_space
-            >::type
-            > alloc_prop ;
-
-            static_assert( traits::is_managed
-                  , "OffsetView allocation constructor requires managed memory" );
-
-            if ( alloc_prop::initialize &&
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-                  ! alloc_prop::execution_space::is_initialized()
+template <unsigned R, class MapType, class BeginsType, class iType,
+          class... Args>
+KOKKOS_INLINE_FUNCTION bool offsetview_verify_operator_bounds(
+    const MapType& map, const BeginsType& begins, const iType& i,
+    Args... args) {
+  const bool legalIndex =
+      (int64_t(i) >= begins[R]) &&
+      (int64_t(i) <= int64_t(begins[R] + map.extent(R) - 1));
+  return legalIndex &&
+         offsetview_verify_operator_bounds<R + 1>(map, begins, args...);
+}
+template <unsigned, class MapType, class BeginsType>
+inline void offsetview_error_operator_bounds(char*, int, const MapType&,
+                                             const BeginsType&) {}
+
+template <unsigned R, class MapType, class BeginsType, class iType,
+          class... Args>
+inline void offsetview_error_operator_bounds(char* buf, int len,
+                                             const MapType& map,
+                                             const BeginsType begins,
+                                             const iType& i, Args... args) {
+  const int64_t b = begins[R];
+  const int64_t e = b + map.extent(R) - 1;
+  const int n =
+      snprintf(buf, len, " %ld <= %ld <= %ld %c", static_cast<unsigned long>(b),
+               static_cast<unsigned long>(i), static_cast<unsigned long>(e),
+               (sizeof...(Args) ? ',' : ')'));
+  offsetview_error_operator_bounds<R + 1>(buf + n, len - n, map, begins,
+                                          args...);
+}
+
+template <class MemorySpace, class MapType, class BeginsType, class... Args>
+KOKKOS_INLINE_FUNCTION void offsetview_verify_operator_bounds(
+    Kokkos::Impl::SharedAllocationTracker const& tracker, const MapType& map,
+    const BeginsType& begins, Args... args) {
+  if (!offsetview_verify_operator_bounds<0>(map, begins, args...)) {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    enum { LEN = 1024 };
+    char buffer[LEN];
+    const std::string label = tracker.template get_label<MemorySpace>();
+    int n =
+        snprintf(buffer, LEN, "OffsetView bounds error of view labeled %s (",
+                 label.c_str());
+    offsetview_error_operator_bounds<0>(buffer + n, LEN - n, map, begins,
+                                        args...);
+    Kokkos::Impl::throw_runtime_exception(std::string(buffer));
 #else
-            ! alloc_prop::execution_space::impl_is_initialized()
+    /* Check #1: is there a SharedAllocationRecord?
+      (we won't use it, but if its not there then there isn't
+       a corresponding SharedAllocationHeader containing a label).
+      This check should cover the case of Views that don't
+      have the Unmanaged trait but were initialized by pointer. */
+    if (tracker.has_record()) {
+      Kokkos::Impl::operator_bounds_error_on_device<MapType>(
+          map, Kokkos::Impl::has_printable_label_typedef<MapType>());
+    } else {
+      Kokkos::abort("OffsetView bounds error");
+    }
 #endif
-            ) {
-               // If initializing view data then
-               // the execution space must be initialized.
-               Kokkos::Impl::throw_runtime_exception("Constructing OffsetView and initializing data with uninitialized execution space");
-            }
-
-            // Copy the input allocation properties with possibly defaulted properties
-            alloc_prop prop_copy( arg_prop );
-
-            //------------------------------------------------------------
-#if defined( KOKKOS_ENABLE_CUDA )
-            // If allocating in CudaUVMSpace must fence before and after
-            // the allocation to protect against possible concurrent access
-            // on the CPU and the GPU.
-            // Fence using the trait's executon space (which will be Kokkos::Cuda)
-            // to avoid incomplete type errors from usng Kokkos::Cuda directly.
-            if ( std::is_same< Kokkos::CudaUVMSpace , typename traits::device_type::memory_space >::value ) {
-               typename traits::device_type::memory_space::execution_space().fence();
-            }
-#endif
-            //------------------------------------------------------------
-
-            Kokkos::Impl::SharedAllocationRecord<> *
-            record = m_map.allocate_shared( prop_copy , arg_layout );
+  }
+}
 
-            //------------------------------------------------------------
-#if defined( KOKKOS_ENABLE_CUDA )
-            if ( std::is_same< Kokkos::CudaUVMSpace , typename traits::device_type::memory_space >::value ) {
-               typename traits::device_type::memory_space::execution_space().fence();
-            }
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+KOKKOS_INLINE_FUNCTION
+void runtime_check_rank_host(const size_t rank_dynamic, const size_t rank,
+                             const index_list_type minIndices,
+                             const std::string& label) {
+  bool isBad = false;
+  std::string message =
+      "Kokkos::Experimental::OffsetView ERROR: for OffsetView labeled '" +
+      label + "':";
+  if (rank_dynamic != rank) {
+    message +=
+        "The full rank must be the same as the dynamic rank. full rank = ";
+    message += std::to_string(rank) +
+               " dynamic rank = " + std::to_string(rank_dynamic) + "\n";
+    isBad = true;
+  }
+
+  size_t numOffsets = 0;
+  for (size_t i = 0; i < minIndices.size(); ++i) {
+    if (minIndices.begin()[i] != KOKKOS_INVALID_OFFSET) numOffsets++;
+  }
+  if (numOffsets != rank_dynamic) {
+    message += "The number of offsets provided ( " +
+               std::to_string(numOffsets) +
+               " ) must equal the dynamic rank ( " +
+               std::to_string(rank_dynamic) + " ).";
+    isBad = true;
+  }
+
+  if (isBad) Kokkos::abort(message.c_str());
+}
 #endif
-            //------------------------------------------------------------
 
-            // Setup and initialization complete, start tracking
-            m_track.assign_allocated_record_to_uninitialized( record );
+KOKKOS_INLINE_FUNCTION
+void runtime_check_rank_device(const size_t rank_dynamic, const size_t rank,
+                               const index_list_type minIndices) {
+  if (rank_dynamic != rank) {
+    Kokkos::abort(
+        "The full rank of an OffsetView must be the same as the dynamic rank.");
+  }
+  size_t numOffsets = 0;
+  for (size_t i = 0; i < minIndices.size(); ++i) {
+    if (minIndices.begin()[i] != KOKKOS_INVALID_OFFSET) numOffsets++;
+  }
+  if (numOffsets != rank) {
+    Kokkos::abort(
+        "The number of offsets provided to an OffsetView constructor must "
+        "equal the dynamic rank.");
+  }
+}
+}  // namespace Impl
+
+template <class DataType, class... Properties>
+class OffsetView : public ViewTraits<DataType, Properties...> {
+ public:
+  typedef ViewTraits<DataType, Properties...> traits;
+
+ private:
+  template <class, class...>
+  friend class OffsetView;
+  template <class, class...>
+  friend class View;  // FIXME delete this line
+  template <class, class...>
+  friend class Kokkos::Impl::ViewMapping;
+
+  typedef Kokkos::Impl::ViewMapping<traits, void> map_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
+
+ public:
+  enum { Rank = map_type::Rank };
+  typedef Kokkos::Array<int64_t, Rank> begins_type;
+
+  template <
+      typename iType,
+      typename std::enable_if<std::is_integral<iType>::value, iType>::type = 0>
+  KOKKOS_INLINE_FUNCTION int64_t begin(const iType local_dimension) const {
+    return local_dimension < Rank ? m_begins[local_dimension]
+                                  : KOKKOS_INVALID_OFFSET;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  begins_type begins() const { return m_begins; }
+
+  template <
+      typename iType,
+      typename std::enable_if<std::is_integral<iType>::value, iType>::type = 0>
+  KOKKOS_INLINE_FUNCTION int64_t end(const iType local_dimension) const {
+    return begin(local_dimension) + m_map.extent(local_dimension);
+  }
+
+ private:
+  track_type m_track;
+  map_type m_map;
+  begins_type m_begins;
+
+ public:
+  //----------------------------------------
+  /** \brief  Compatible view of array of scalar types */
+  typedef OffsetView<
+      typename traits::scalar_array_type, typename traits::array_layout,
+      typename traits::device_type, typename traits::memory_traits>
+      array_type;
+
+  /** \brief  Compatible view of const data type */
+  typedef OffsetView<
+      typename traits::const_data_type, typename traits::array_layout,
+      typename traits::device_type, typename traits::memory_traits>
+      const_type;
+
+  /** \brief  Compatible view of non-const data type */
+  typedef OffsetView<
+      typename traits::non_const_data_type, typename traits::array_layout,
+      typename traits::device_type, typename traits::memory_traits>
+      non_const_type;
+
+  /** \brief  Compatible HostMirror view */
+  typedef OffsetView<typename traits::non_const_data_type,
+                     typename traits::array_layout,
+                     typename traits::host_mirror_space>
+      HostMirror;
+
+  //----------------------------------------
+  // Domain rank and extents
+
+  /** \brief rank() to be implemented
+   */
+  // KOKKOS_INLINE_FUNCTION
+  // static
+  // constexpr unsigned rank() { return map_type::Rank; }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION constexpr
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      extent(const iType& r) const {
+    return m_map.extent(r);
+  }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION constexpr
+      typename std::enable_if<std::is_integral<iType>::value, int>::type
+      extent_int(const iType& r) const {
+    return static_cast<int>(m_map.extent(r));
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr typename traits::array_layout layout()
+      const {
+    return m_map.layout();
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_t size() const {
+    return m_map.dimension_0() * m_map.dimension_1() * m_map.dimension_2() *
+           m_map.dimension_3() * m_map.dimension_4() * m_map.dimension_5() *
+           m_map.dimension_6() * m_map.dimension_7();
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const {
+    return m_map.stride_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const {
+    return m_map.stride_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const {
+    return m_map.stride_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const {
+    return m_map.stride_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const {
+    return m_map.stride_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const {
+    return m_map.stride_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const {
+    return m_map.stride_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const {
+    return m_map.stride_7();
+  }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION constexpr
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      stride(iType r) const {
+    return (
+        r == 0
+            ? m_map.stride_0()
+            : (r == 1
+                   ? m_map.stride_1()
+                   : (r == 2
+                          ? m_map.stride_2()
+                          : (r == 3
+                                 ? m_map.stride_3()
+                                 : (r == 4
+                                        ? m_map.stride_4()
+                                        : (r == 5
+                                               ? m_map.stride_5()
+                                               : (r == 6
+                                                      ? m_map.stride_6()
+                                                      : m_map.stride_7())))))));
+  }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    m_map.stride(s);
+  }
+
+  //----------------------------------------
+  // Range span is the span which contains all members.
+
+  typedef typename map_type::reference_type reference_type;
+  typedef typename map_type::pointer_type pointer_type;
+
+  enum {
+    reference_type_is_lvalue_reference =
+        std::is_lvalue_reference<reference_type>::value
+  };
+
+  KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return m_map.span(); }
+  KOKKOS_INLINE_FUNCTION bool span_is_contiguous() const {
+    return m_map.span_is_contiguous();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const {
+    return m_map.data();
+  }
+
+  //----------------------------------------
+  // Allow specializations to query their specialized map
+
+  KOKKOS_INLINE_FUNCTION
+  const Kokkos::Impl::ViewMapping<traits, void>& implementation_map() const {
+    return m_map;
+  }
+
+  //----------------------------------------
+
+ private:
+  enum {
+    is_layout_left =
+        std::is_same<typename traits::array_layout, Kokkos::LayoutLeft>::value,
+
+    is_layout_right =
+        std::is_same<typename traits::array_layout, Kokkos::LayoutRight>::value,
+
+    is_layout_stride = std::is_same<typename traits::array_layout,
+                                    Kokkos::LayoutStride>::value,
+
+    is_default_map = std::is_same<typename traits::specialize, void>::value &&
+                     (is_layout_left || is_layout_right || is_layout_stride)
+  };
+
+  template <class Space, bool = Kokkos::Impl::MemorySpaceAccess<
+                             Space, typename traits::memory_space>::accessible>
+  struct verify_space {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {}
+  };
+
+  template <class Space>
+  struct verify_space<Space, false> {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {
+      Kokkos::abort(
+          "Kokkos::View ERROR: attempt to access inaccessible memory space");
+    };
+  };
+
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+
+#define KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(ARG)              \
+  OffsetView::template verify_space<                             \
+      Kokkos::Impl::ActiveExecutionMemorySpace>::check();        \
+  Kokkos::Experimental::Impl::offsetview_verify_operator_bounds< \
+      typename traits::memory_space>                             \
+      ARG;
 
-#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-            Kokkos::Experimental::Impl::runtime_check_rank_host(traits::rank_dynamic, Rank, minIndices, label());
 #else
-            Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic, Rank, minIndices);
-
-#endif
 
-         }
+#define KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(ARG) \
+  OffsetView::template verify_space<                \
+      Kokkos::Impl::ActiveExecutionMemorySpace>::check();
 
+#endif
+ public:
+  //------------------------------
+  // Rank 0 operator()
+
+  KOKKOS_FORCEINLINE_FUNCTION
+  reference_type operator()() const { return m_map.reference(); }
+  //------------------------------
+  // Rank 1 operator()
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
+    const size_t j0 = i0 - m_begins[0];
+    return m_map.reference(j0);
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               !is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
+    const size_t j0 = i0 - m_begins[0];
+    return m_map.m_impl_handle[j0];
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
+    const size_t j0 = i0 - m_begins[0];
+    return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * j0];
+  }
+  //------------------------------
+  // Rank 1 operator[]
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
+    const size_t j0 = i0 - m_begins[0];
+    return m_map.reference(j0);
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               !is_layout_stride),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
+    const size_t j0 = i0 - m_begins[0];
+    return m_map.m_impl_handle[j0];
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
+    const size_t j0 = i0 - m_begins[0];
+    return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * j0];
+  }
+
+  //------------------------------
+  // Rank 2
+
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    return m_map.reference(j0, j1);
+  }
+
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_left && (traits::rank_dynamic == 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_dim.N0 * j1];
+  }
+
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_left && (traits::rank_dynamic != 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_stride * j1];
+  }
+
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_right && (traits::rank_dynamic == 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_dim.N1 * j0];
+  }
+
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_right && (traits::rank_dynamic != 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_stride * j0];
+  }
+
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    return m_map.m_impl_handle[j0 * m_map.m_impl_offset.m_stride.S0 +
+                               j1 * m_map.m_impl_offset.m_stride.S1];
+  }
+
+  //------------------------------
+  // Rank 3
+
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1, I2>::value &&
+                               (3 == Rank) && is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1, const I2& i2) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2)];
+  }
+
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1, I2>::value &&
+                               (3 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1, const I2& i2) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    return m_map.reference(j0, j1, j2);
+  }
+
+  //------------------------------
+  // Rank 4
+
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3>::value && (4 == Rank) &&
+       is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3>::value && (4 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    return m_map.reference(j0, j1, j2, j3);
+  }
+
+  //------------------------------
+  // Rank 5
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4>::value && (5 == Rank) &&
+       is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4>::value && (5 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    return m_map.reference(j0, j1, j2, j3, j4);
+  }
+
+  //------------------------------
+  // Rank 6
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5>::value &&
+       (6 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    const size_t j5 = i5 - m_begins[5];
+    return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4, j5)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5>::value &&
+       (6 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    const size_t j5 = i5 - m_begins[5];
+    return m_map.reference(j0, j1, j2, j3, j4, j5);
+  }
+
+  //------------------------------
+  // Rank 7
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6>::value &&
+       (7 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    const size_t j5 = i5 - m_begins[5];
+    const size_t j6 = i6 - m_begins[6];
+    return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4, j5, j6)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6>::value &&
+       (7 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    const size_t j5 = i5 - m_begins[5];
+    const size_t j6 = i6 - m_begins[6];
+    return m_map.reference(j0, j1, j2, j3, j4, j5, j6);
+  }
+
+  //------------------------------
+  // Rank 8
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7>::value &&
+       (8 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, const I7& i7) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6, i7))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    const size_t j5 = i5 - m_begins[5];
+    const size_t j6 = i6 - m_begins[6];
+    const size_t j7 = i7 - m_begins[7];
+    return m_map
+        .m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4, j5, j6, j7)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7>::value &&
+       (8 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, const I7& i7) const {
+    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
+        (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6, i7))
+    const size_t j0 = i0 - m_begins[0];
+    const size_t j1 = i1 - m_begins[1];
+    const size_t j2 = i2 - m_begins[2];
+    const size_t j3 = i3 - m_begins[3];
+    const size_t j4 = i4 - m_begins[4];
+    const size_t j5 = i5 - m_begins[5];
+    const size_t j6 = i6 - m_begins[6];
+    const size_t j7 = i7 - m_begins[7];
+    return m_map.reference(j0, j1, j2, j3, j4, j5, j6, j7);
+  }
 
-      };
-
+#undef KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY
 
+  //----------------------------------------
+  // Standard destructor, constructors, and assignment operators
+
+  KOKKOS_INLINE_FUNCTION
+  ~OffsetView() {}
+
+  KOKKOS_INLINE_FUNCTION
+  OffsetView() : m_track(), m_map() {
+    for (size_t i = 0; i < Rank; ++i) m_begins[i] = KOKKOS_INVALID_OFFSET;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  OffsetView(const OffsetView& rhs)
+      : m_track(rhs.m_track, traits::is_managed),
+        m_map(rhs.m_map),
+        m_begins(rhs.m_begins) {}
+
+  KOKKOS_INLINE_FUNCTION
+  OffsetView(OffsetView&& rhs)
+      : m_track(std::move(rhs.m_track)),
+        m_map(std::move(rhs.m_map)),
+        m_begins(std::move(rhs.m_begins)) {}
+
+  KOKKOS_INLINE_FUNCTION
+  OffsetView& operator=(const OffsetView& rhs) {
+    m_track  = rhs.m_track;
+    m_map    = rhs.m_map;
+    m_begins = rhs.m_begins;
+    return *this;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  OffsetView& operator=(OffsetView&& rhs) {
+    m_track  = std::move(rhs.m_track);
+    m_map    = std::move(rhs.m_map);
+    m_begins = std::move(rhs.m_begins);
+    return *this;
+  }
+
+  // interoperability with View
+ private:
+  typedef View<typename traits::scalar_array_type,
+               typename traits::array_layout, typename traits::device_type,
+               typename traits::memory_traits>
+      view_type;
+
+ public:
+  KOKKOS_INLINE_FUNCTION
+  view_type view() const {
+    view_type v(m_track, m_map);
+    return v;
+  }
+
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION OffsetView(const View<RT, RP...>& aview)
+      : m_track(aview.impl_track()), m_map() {
+    typedef typename OffsetView<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits, void> Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible OffsetView copy construction");
+    Mapping::assign(m_map, aview.impl_map(), m_track);
+
+    for (int i = 0; i < aview.Rank; ++i) {
+      m_begins[i] = 0;
+    }
+  }
+
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION OffsetView(const View<RT, RP...>& aview,
+                                    const index_list_type& minIndices)
+      : m_track(aview.impl_track()), m_map() {
+    typedef typename OffsetView<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits, void> Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible OffsetView copy construction");
+    Mapping::assign(m_map, aview.impl_map(), m_track);
 
-      /** \brief Temporary free function rank()
-       *         until rank() is implemented
-       *         in the View
-       */
-      template < typename D , class ... P >
-      KOKKOS_INLINE_FUNCTION
-      constexpr unsigned rank( const OffsetView<D , P...> & V ) { return V.Rank; } //Temporary until added to view
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+    Kokkos::Experimental::Impl::runtime_check_rank_host(
+        traits::rank_dynamic, Rank, minIndices, label());
+#else
+    Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic,
+                                                          Rank, minIndices);
 
-      //----------------------------------------------------------------------------
-      //----------------------------------------------------------------------------
-      namespace Impl {
+#endif
 
-         template< class T >
-         KOKKOS_INLINE_FUNCTION
-         typename  std::enable_if< std::is_integral<T>::value, T>::type
-         shift_input(const T arg, const int64_t offset)
-         {
-            return arg - offset;
-         }
+    for (size_t i = 0; i < minIndices.size(); ++i) {
+      m_begins[i] = minIndices.begin()[i];
+    }
+  }
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION OffsetView(const View<RT, RP...>& aview,
+                                    const begins_type& beg)
+      : m_track(aview.impl_track()), m_map(), m_begins(beg) {
+    typedef typename OffsetView<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits, void> Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible OffsetView copy construction");
+    Mapping::assign(m_map, aview.impl_map(), m_track);
+
+    //#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+    //        Kokkos::Experimental::Impl::runtime_check_rank_host(traits::rank_dynamic,
+    //        Rank, minIndices, label());
+    //#else
+    //        Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic,
+    //        Rank, minIndices);
+    //
+    //#endif
+  }
+
+  // may assign unmanaged from managed.
+
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION OffsetView(const OffsetView<RT, RP...>& rhs)
+      : m_track(rhs.m_track, traits::is_managed),
+        m_map(),
+        m_begins(rhs.m_begins) {
+    typedef typename OffsetView<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits, void> Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible OffsetView copy construction");
+    Mapping::assign(m_map, rhs.m_map, rhs.m_track);  // swb what about assign?
+  }
+
+ private:
+  enum class subtraction_failure {
+    none,
+    negative,
+    overflow,
+  };
+
+  // Subtraction should return a non-negative number and not overflow
+  KOKKOS_INLINE_FUNCTION static subtraction_failure check_subtraction(
+      int64_t lhs, int64_t rhs) {
+    if (lhs < rhs) return subtraction_failure::negative;
+
+    if (static_cast<uint64_t>(-1) / static_cast<uint64_t>(2) <
+        static_cast<uint64_t>(lhs) - static_cast<uint64_t>(rhs))
+      return subtraction_failure::overflow;
+
+    return subtraction_failure::none;
+  }
+
+  // Need a way to get at an element from both begins_type (aka Kokkos::Array
+  // which doesn't have iterators) and index_list_type (aka
+  // std::initializer_list which doesn't have .data() or operator[]).
+  // Returns by value
+  KOKKOS_INLINE_FUNCTION
+  static int64_t at(const begins_type& a, size_t pos) { return a[pos]; }
+
+  KOKKOS_INLINE_FUNCTION
+  static int64_t at(index_list_type a, size_t pos) {
+    return *(a.begin() + pos);
+  }
 
-         KOKKOS_INLINE_FUNCTION
-         Kokkos::Impl::ALL_t
-         shift_input(const Kokkos::Impl::ALL_t arg, const int64_t offset)
-         {
-            return arg;
-         }
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+  // Check that begins < ends for all elements
+  // B, E can be begins_type and/or index_list_type
+  template <typename B, typename E>
+  KOKKOS_INLINE_FUNCTION static subtraction_failure
+  runtime_check_begins_ends_host(const B& begins, const E& ends) {
+    std::string message;
+    if (begins.size() != Rank)
+      message +=
+          "begins.size() "
+          "(" +
+          std::to_string(begins.size()) +
+          ")"
+          " != Rank "
+          "(" +
+          std::to_string(Rank) +
+          ")"
+          "\n";
+
+    if (ends.size() != Rank)
+      message +=
+          "ends.size() "
+          "(" +
+          std::to_string(begins.size()) +
+          ")"
+          " != Rank "
+          "(" +
+          std::to_string(Rank) +
+          ")"
+          "\n";
+
+    // If there are no errors so far, then rank == Rank
+    // Otherwise, check as much as possible
+    size_t rank = begins.size() < ends.size() ? begins.size() : ends.size();
+    for (size_t i = 0; i != rank; ++i) {
+      subtraction_failure sf = check_subtraction(at(ends, i), at(begins, i));
+      if (sf != subtraction_failure::none) {
+        message +=
+            "("
+            "ends[" +
+            std::to_string(i) +
+            "]"
+            " "
+            "(" +
+            std::to_string(at(ends, i)) +
+            ")"
+            " - "
+            "begins[" +
+            std::to_string(i) +
+            "]"
+            " "
+            "(" +
+            std::to_string(at(begins, i)) +
+            ")"
+            ")";
+        switch (sf) {
+          case subtraction_failure::negative:
+            message += " must be non-negative\n";
+            break;
+          case subtraction_failure::overflow: message += " overflows\n"; break;
+          default: break;
+        }
+      }
+    }
+
+    if (!message.empty()) {
+      message =
+          "Kokkos::Experimental::OffsetView ERROR: for unmanaged OffsetView\n" +
+          message;
+      Kokkos::Impl::throw_runtime_exception(message);
+    }
+
+    return subtraction_failure::none;
+  }
+#endif  // KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+
+  // Check the begins < ends for all elements
+  template <typename B, typename E>
+  KOKKOS_INLINE_FUNCTION static subtraction_failure
+  runtime_check_begins_ends_device(const B& begins, const E& ends) {
+    if (begins.size() != Rank)
+      Kokkos::abort(
+          "Kokkos::Experimental::OffsetView ERROR: for unmanaged "
+          "OffsetView: begins has bad Rank");
+    if (ends.size() != Rank)
+      Kokkos::abort(
+          "Kokkos::Experimental::OffsetView ERROR: for unmanaged "
+          "OffsetView: ends has bad Rank");
+
+    for (size_t i = 0; i != begins.size(); ++i) {
+      switch (check_subtraction(at(ends, i), at(begins, i))) {
+        case subtraction_failure::negative:
+          Kokkos::abort(
+              "Kokkos::Experimental::OffsetView ERROR: for unmanaged "
+              "OffsetView: bad range");
+          break;
+        case subtraction_failure::overflow:
+          Kokkos::abort(
+              "Kokkos::Experimental::OffsetView ERROR: for unmanaged "
+              "OffsetView: range overflows");
+          break;
+        default: break;
+      }
+    }
+
+    return subtraction_failure::none;
+  }
+
+  // Constructor around unmanaged data after checking begins < ends for all
+  // elements
+  // Each of B, E can be begins_type and/or index_list_type
+  // Precondition: begins.size() == ends.size() == m_begins.size() == Rank
+  template <typename B, typename E>
+  KOKKOS_INLINE_FUNCTION OffsetView(const pointer_type& p, const B& begins_,
+                                    const E& ends_,
+                                    subtraction_failure)
+      : m_track()  // no tracking
+        ,
+        m_map(Kokkos::Impl::ViewCtorProp<pointer_type>(p),
+              typename traits::array_layout(
+                  Rank > 0 ? at(ends_, 0) - at(begins_, 0) : 0,
+                  Rank > 1 ? at(ends_, 1) - at(begins_, 1) : 0,
+                  Rank > 2 ? at(ends_, 2) - at(begins_, 2) : 0,
+                  Rank > 3 ? at(ends_, 3) - at(begins_, 3) : 0,
+                  Rank > 4 ? at(ends_, 4) - at(begins_, 4) : 0,
+                  Rank > 5 ? at(ends_, 5) - at(begins_, 5) : 0,
+                  Rank > 6 ? at(ends_, 6) - at(begins_, 6) : 0,
+                  Rank > 7 ? at(ends_, 7) - at(begins_, 7) : 0)) {
+    for (size_t i = 0; i != m_begins.size(); ++i) {
+      m_begins[i] = at(begins_, i);
+    };
+  }
+
+ public:
+  // Constructor around unmanaged data
+  // Four overloads, as both begins and ends can be either
+  // begins_type or index_list_type
+  KOKKOS_INLINE_FUNCTION
+  OffsetView(const pointer_type& p, const begins_type& begins_,
+             const begins_type& ends_)
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_host(begins_, ends_))
+#else
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_device(begins_, ends_))
+#endif
+  {
+  }
 
-         template< class T >
-         KOKKOS_INLINE_FUNCTION
-         typename  std::enable_if< std::is_integral<T>::value, Kokkos::pair<T,T> >::type
-         shift_input(const Kokkos::pair<T, T> arg, const int64_t offset)
-         {
+  KOKKOS_INLINE_FUNCTION
+  OffsetView(const pointer_type& p, const begins_type& begins_,
+             index_list_type ends_)
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_host(begins_, ends_))
+#else
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_device(begins_, ends_))
+#endif
+  {
+  }
 
-            return Kokkos::make_pair<T,T>(arg.first - offset, arg.second - offset);
+  KOKKOS_INLINE_FUNCTION
+  OffsetView(const pointer_type& p, index_list_type begins_,
+             const begins_type& ends_)
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_host(begins_, ends_))
+#else
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_device(begins_, ends_))
+#endif
+  {
+  }
 
-         }
-         template< class T >
-	 inline
-         typename  std::enable_if< std::is_integral<T>::value, std::pair<T,T> >::type
-         shift_input(const std::pair<T, T> arg, const int64_t offset)
-         {
+  KOKKOS_INLINE_FUNCTION
+  OffsetView(const pointer_type& p, index_list_type begins_,
+             index_list_type ends_)
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_host(begins_, ends_))
+#else
+      : OffsetView(p, begins_, ends_,
+                   runtime_check_begins_ends_device(begins_, ends_))
+#endif
+  {
+  }
+
+  //----------------------------------------
+  // Allocation tracking properties
+  KOKKOS_INLINE_FUNCTION
+  int use_count() const { return m_track.use_count(); }
+
+  inline const std::string label() const {
+    return m_track.template get_label<typename traits::memory_space>();
+  }
+
+  template <typename Label>
+  explicit inline OffsetView(
+      const Label& arg_label,
+      typename std::enable_if<Kokkos::Impl::is_view_label<Label>::value,
+                              const index_list_type>::type range0,
+      const index_list_type range1 = KOKKOS_INVALID_INDEX_RANGE,
+      const index_list_type range2 = KOKKOS_INVALID_INDEX_RANGE,
+      const index_list_type range3 = KOKKOS_INVALID_INDEX_RANGE,
+      const index_list_type range4 = KOKKOS_INVALID_INDEX_RANGE,
+      const index_list_type range5 = KOKKOS_INVALID_INDEX_RANGE,
+      const index_list_type range6 = KOKKOS_INVALID_INDEX_RANGE,
+      const index_list_type range7 = KOKKOS_INVALID_INDEX_RANGE
 
-            return std::make_pair<T,T>(arg.first - offset, arg.second - offset);
+      )
+      : OffsetView(Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
+                   typename traits::array_layout(
+                       range0.begin()[1] - range0.begin()[0] + 1,
+                       range1.begin()[1] - range1.begin()[0] + 1,
+                       range2.begin()[1] - range2.begin()[0] + 1,
+                       range3.begin()[1] - range3.begin()[0] + 1,
+                       range4.begin()[1] - range4.begin()[0] + 1,
+                       range5.begin()[1] - range5.begin()[0] + 1,
+                       range6.begin()[1] - range6.begin()[0] + 1,
+                       range7.begin()[1] - range7.begin()[0] + 1),
+                   {range0.begin()[0], range1.begin()[0], range2.begin()[0],
+                    range3.begin()[0], range4.begin()[0], range5.begin()[0],
+                    range6.begin()[0], range7.begin()[0]}) {}
+
+  template <class... P>
+  explicit KOKKOS_INLINE_FUNCTION OffsetView(
+      const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
+                              typename traits::array_layout>::type const&
+          arg_layout,
+      const index_list_type minIndices)
+      : m_track()  // No memory tracking
+        ,
+        m_map(arg_prop, arg_layout) {
+    for (size_t i = 0; i < minIndices.size(); ++i) {
+      m_begins[i] = minIndices.begin()[i];
+    }
+    static_assert(
+        std::is_same<pointer_type, typename Kokkos::Impl::ViewCtorProp<
+                                       P...>::pointer_type>::value,
+        "When constructing OffsetView to wrap user memory, you must supply "
+        "matching pointer type");
+  }
+
+  template <class... P>
+  explicit inline OffsetView(
+      const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
+                              typename traits::array_layout>::type const&
+          arg_layout,
+      const index_list_type minIndices)
+      : m_track(),
+        m_map()
+
+  {
+    for (size_t i = 0; i < Rank; ++i) m_begins[i] = minIndices.begin()[i];
+
+    // Append layout and spaces if not input
+    typedef Kokkos::Impl::ViewCtorProp<P...> alloc_prop_input;
+
+    // use 'std::integral_constant<unsigned,I>' for non-types
+    // to avoid duplicate class error.
+    typedef Kokkos::Impl::ViewCtorProp<
+        P...,
+        typename std::conditional<alloc_prop_input::has_label,
+                                  std::integral_constant<unsigned, 0>,
+                                  typename std::string>::type,
+        typename std::conditional<
+            alloc_prop_input::has_memory_space,
+            std::integral_constant<unsigned, 1>,
+            typename traits::device_type::memory_space>::type,
+        typename std::conditional<
+            alloc_prop_input::has_execution_space,
+            std::integral_constant<unsigned, 2>,
+            typename traits::device_type::execution_space>::type>
+        alloc_prop;
+
+    static_assert(traits::is_managed,
+                  "OffsetView allocation constructor requires managed memory");
+
+    if (alloc_prop::initialize &&
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
+        !alloc_prop::execution_space::is_initialized()
+#else
+        !alloc_prop::execution_space::impl_is_initialized()
+#endif
+    ) {
+      // If initializing view data then
+      // the execution space must be initialized.
+      Kokkos::Impl::throw_runtime_exception(
+          "Constructing OffsetView and initializing data with uninitialized "
+          "execution space");
+    }
+
+    // Copy the input allocation properties with possibly defaulted properties
+    alloc_prop prop_copy(arg_prop);
+
+    //------------------------------------------------------------
+#if defined(KOKKOS_ENABLE_CUDA)
+    // If allocating in CudaUVMSpace must fence before and after
+    // the allocation to protect against possible concurrent access
+    // on the CPU and the GPU.
+    // Fence using the trait's executon space (which will be Kokkos::Cuda)
+    // to avoid incomplete type errors from usng Kokkos::Cuda directly.
+    if (std::is_same<Kokkos::CudaUVMSpace,
+                     typename traits::device_type::memory_space>::value) {
+      typename traits::device_type::memory_space::execution_space().fence();
+    }
+#endif
+    //------------------------------------------------------------
 
-         }
+    Kokkos::Impl::SharedAllocationRecord<>* record =
+        m_map.allocate_shared(prop_copy, arg_layout);
 
-         template <size_t N, class Arg, class A>
-         KOKKOS_INLINE_FUNCTION
-         void
-         map_arg_to_new_begin(const size_t i,
-               Kokkos::Array<int64_t, N> &subviewBegins, typename std::enable_if< N != 0, const Arg>::type shiftedArg,
-               const Arg arg, const A viewBegins, size_t & counter) {
+    //------------------------------------------------------------
+#if defined(KOKKOS_ENABLE_CUDA)
+    if (std::is_same<Kokkos::CudaUVMSpace,
+                     typename traits::device_type::memory_space>::value) {
+      typename traits::device_type::memory_space::execution_space().fence();
+    }
+#endif
+    //------------------------------------------------------------
 
-            if( !std::is_integral<Arg>::value) {
-               subviewBegins[counter] = shiftedArg == arg ? viewBegins[i] : 0;
-               counter++;
-            }
-         }
+    // Setup and initialization complete, start tracking
+    m_track.assign_allocated_record_to_uninitialized(record);
 
-         template <size_t N, class Arg, class A>
-         KOKKOS_INLINE_FUNCTION
-         void
-         map_arg_to_new_begin(const size_t i,
-               Kokkos::Array<int64_t, N> &subviewBegins, typename std::enable_if< N == 0, const Arg>::type shiftedArg,
-               const Arg arg, const A viewBegins, size_t & counter) {
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+    Kokkos::Experimental::Impl::runtime_check_rank_host(
+        traits::rank_dynamic, Rank, minIndices, label());
+#else
+    Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic,
+                                                          Rank, minIndices);
 
-         }
+#endif
+  }
+};
 
+/** \brief Temporary free function rank()
+ *         until rank() is implemented
+ *         in the View
+ */
+template <typename D, class... P>
+KOKKOS_INLINE_FUNCTION constexpr unsigned rank(const OffsetView<D, P...>& V) {
+  return V.Rank;
+}  // Temporary until added to view
 
-         template< class D, class ... P , class T >
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T
-         >::type >::type
-         subview_offset(const OffsetView< D, P... > & src, T arg) {
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+namespace Impl {
 
-            auto theView = src.view();
-            auto begins = src.begins();
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    typename std::enable_if<std::is_integral<T>::value, T>::type
+    shift_input(const T arg, const int64_t offset) {
+  return arg - offset;
+}
 
-            T shiftedArg = shift_input(arg, begins[0]);
+KOKKOS_INLINE_FUNCTION
+Kokkos::Impl::ALL_t shift_input(const Kokkos::Impl::ALL_t arg,
+                                const int64_t offset) {
+  return arg;
+}
 
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T>::type::Rank;
+template <class T>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<std::is_integral<T>::value,
+                                               Kokkos::pair<T, T> >::type
+shift_input(const Kokkos::pair<T, T> arg, const int64_t offset) {
+  return Kokkos::make_pair<T, T>(arg.first - offset, arg.second - offset);
+}
+template <class T>
+inline
+    typename std::enable_if<std::is_integral<T>::value, std::pair<T, T> >::type
+    shift_input(const std::pair<T, T> arg, const int64_t offset) {
+  return std::make_pair<T, T>(arg.first - offset, arg.second - offset);
+}
 
-            auto theSubview = Kokkos::subview( theView , shiftedArg);
+template <size_t N, class Arg, class A>
+KOKKOS_INLINE_FUNCTION void map_arg_to_new_begin(
+    const size_t i, Kokkos::Array<int64_t, N>& subviewBegins,
+    typename std::enable_if<N != 0, const Arg>::type shiftedArg, const Arg arg,
+    const A viewBegins, size_t& counter) {
+  if (!std::is_integral<Arg>::value) {
+    subviewBegins[counter] = shiftedArg == arg ? viewBegins[i] : 0;
+    counter++;
+  }
+}
 
-            Kokkos::Array<int64_t, rank> subviewBegins;
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg, arg, begins, counter);
+template <size_t N, class Arg, class A>
+KOKKOS_INLINE_FUNCTION void map_arg_to_new_begin(
+    const size_t i, Kokkos::Array<int64_t, N>& subviewBegins,
+    typename std::enable_if<N == 0, const Arg>::type shiftedArg, const Arg arg,
+    const A viewBegins, size_t& counter) {}
+
+template <class D, class... P, class T>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<void /* deduce subview type from
+                                                   source view traits */
+                                           ,
+                                           ViewTraits<D, P...>, T>::type>::type
+    subview_offset(const OffsetView<D, P...>& src, T arg) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T shiftedArg = shift_input(arg, begins[0]);
+
+  constexpr size_t rank =
+      Kokkos::Impl::ViewMapping<void /* deduce subview type from source view
+                                        traits */
+                                ,
+                                ViewTraits<D, P...>, T>::type::Rank;
+
+  auto theSubview = Kokkos::subview(theView, shiftedArg);
+
+  Kokkos::Array<int64_t, rank> subviewBegins;
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg,
+                                                   arg, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<void /* deduce subview type from source
+                                                 view traits */
+                                         ,
+                                         ViewTraits<D, P...>, T>::type>::type
+      offsetView(theSubview, subviewBegins);
+
+  return offsetView;
+}
 
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
+template <class D, class... P, class T0, class T1>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
             void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T >::type >::type offsetView(theSubview, subviewBegins);
-
-            return offsetView;
-
-         }
-
-         template< class D, class ... P , class T0, class T1 >
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T0, T1
-         >::type >::type
-         subview_offset(const Kokkos::Experimental::OffsetView< D, P... > & src, T0 arg0, T1 arg1) {
-
-            auto theView = src.view();
-            auto begins = src.begins();
-
-            T0 shiftedArg0 = shift_input(arg0, begins[0]);
-            T1 shiftedArg1 = shift_input(arg1, begins[1]);
-
-            auto theSubview = Kokkos::subview(theView , shiftedArg0, shiftedArg1);
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T0, T1>::type::Rank;
-
-            Kokkos::Array<int64_t, rank> subviewBegins;
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg0, arg0, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(1, subviewBegins, shiftedArg1, arg1, begins, counter);
+            ,
+            ViewTraits<D, P...>, T0, T1>::type>::type
+    subview_offset(const Kokkos::Experimental::OffsetView<D, P...>& src,
+                   T0 arg0, T1 arg1) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T0 shiftedArg0 = shift_input(arg0, begins[0]);
+  T1 shiftedArg1 = shift_input(arg1, begins[1]);
+
+  auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1);
+  constexpr size_t rank =
+      Kokkos::Impl::ViewMapping<void /* deduce subview type from source view
+                                        traits */
+                                ,
+                                ViewTraits<D, P...>, T0, T1>::type::Rank;
+
+  Kokkos::Array<int64_t, rank> subviewBegins;
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      0, subviewBegins, shiftedArg0, arg0, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      1, subviewBegins, shiftedArg1, arg1, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<
+          void /* deduce subview type from source view traits */
+          ,
+          ViewTraits<D, P...>, T0, T1>::type>::type offsetView(theSubview,
+                                                               subviewBegins);
+
+  return offsetView;
+}
 
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
+template <class D, class... P, class T0, class T1, class T2>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
             void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T0, T1 >::type >::type offsetView(theSubview, subviewBegins);
-
-            return offsetView;
-
-         }
-
-         template< class D, class ... P , class T0, class T1, class T2 >
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T0, T1, T2
-         >::type >::type
-         subview_offset(const OffsetView< D, P... > & src, T0 arg0, T1 arg1, T2 arg2) {
-
-            auto theView = src.view();
-            auto begins = src.begins();
-
-            T0 shiftedArg0 = shift_input(arg0, begins[0]);
-            T1 shiftedArg1 = shift_input(arg1, begins[1]);
-            T2 shiftedArg2 = shift_input(arg2, begins[2]);
-
-            auto theSubview = Kokkos::subview( theView , shiftedArg0, shiftedArg1, shiftedArg2);
-
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T0, T1, T2>::type::Rank;
-
-            Kokkos::Array<int64_t, rank> subviewBegins;
-
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg0, arg0, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(1, subviewBegins, shiftedArg1, arg1, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(2, subviewBegins, shiftedArg2, arg2, begins, counter);
+            ,
+            ViewTraits<D, P...>, T0, T1, T2>::type>::type
+    subview_offset(const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T0 shiftedArg0 = shift_input(arg0, begins[0]);
+  T1 shiftedArg1 = shift_input(arg1, begins[1]);
+  T2 shiftedArg2 = shift_input(arg2, begins[2]);
+
+  auto theSubview =
+      Kokkos::subview(theView, shiftedArg0, shiftedArg1, shiftedArg2);
+
+  constexpr size_t rank =
+      Kokkos::Impl::ViewMapping<void /* deduce subview type from source view
+                                        traits */
+                                ,
+                                ViewTraits<D, P...>, T0, T1, T2>::type::Rank;
+
+  Kokkos::Array<int64_t, rank> subviewBegins;
+
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      0, subviewBegins, shiftedArg0, arg0, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      1, subviewBegins, shiftedArg1, arg1, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      2, subviewBegins, shiftedArg2, arg2, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<
+          void /* deduce subview type from source view traits */
+          ,
+          ViewTraits<D, P...>, T0, T1, T2>::type>::type
+      offsetView(theSubview, subviewBegins);
+
+  return offsetView;
+}
 
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
-            void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T0, T1, T2 >::type >::type offsetView(theSubview, subviewBegins);
-
-            return offsetView;
-         }
-
-         template< class D, class ... P , class T0, class T1, class T2, class T3 >
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T0, T1, T2, T3
-         >::type >::type
-         subview_offset(const OffsetView< D, P... > & src, T0 arg0, T1 arg1, T2 arg2, T3 arg3) {
-
-            auto theView = src.view();
-            auto begins = src.begins();
-
-            T0 shiftedArg0 = shift_input(arg0, begins[0]);
-            T1 shiftedArg1 = shift_input(arg1, begins[1]);
-            T2 shiftedArg2 = shift_input(arg2, begins[2]);
-            T3 shiftedArg3 = shift_input(arg3, begins[3]);
-
-            auto theSubview = Kokkos::subview( theView , shiftedArg0, shiftedArg1, shiftedArg2, shiftedArg3);
-
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T0, T1, T2, T3>::type::Rank;
-            Kokkos::Array<int64_t, rank> subviewBegins;
-
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg0, arg0, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(1, subviewBegins, shiftedArg1, arg1, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(2, subviewBegins, shiftedArg2, arg2, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(3, subviewBegins, shiftedArg3, arg3, begins, counter);
-
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
+template <class D, class... P, class T0, class T1, class T2, class T3>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
             void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T0, T1, T2, T3 >::type >::type offsetView(theSubview, subviewBegins);
-
-            return offsetView;
-         }
-
-         template< class D, class ... P , class T0, class T1, class T2, class T3, class T4 >
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T0, T1, T2, T3, T4
-         >::type >::type
-         subview_offset(const OffsetView< D, P... > & src, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-
-            auto theView = src.view();
-            auto begins = src.begins();
-
-            T0 shiftedArg0 = shift_input(arg0, begins[0]);
-            T1 shiftedArg1 = shift_input(arg1, begins[1]);
-            T2 shiftedArg2 = shift_input(arg2, begins[2]);
-            T3 shiftedArg3 = shift_input(arg3, begins[3]);
-            T4 shiftedArg4 = shift_input(arg4, begins[4]);
-
-            auto theSubview = Kokkos::subview( theView , shiftedArg0, shiftedArg1, shiftedArg2, shiftedArg3, shiftedArg4);
-
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T0, T1, T2, T3, T4>::type::Rank;
-            Kokkos::Array<int64_t, rank> subviewBegins;
-
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg0, arg0, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(1, subviewBegins, shiftedArg1, arg1, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(2, subviewBegins, shiftedArg2, arg2, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(3, subviewBegins, shiftedArg3, arg3, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(4, subviewBegins, shiftedArg4, arg4, begins, counter);
-
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
-            void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T0, T1, T2, T3, T4 >::type >::type offsetView(theSubview, subviewBegins);
-
-            return offsetView;
-         }
-
-         template< class D, class ... P , class T0, class T1, class T2, class T3, class T4,
-         class T5 >
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T0, T1, T2, T3, T4, T5
-         >::type >::type
-         subview_offset(const OffsetView< D, P... > & src, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) {
-
-            auto theView = src.view();
-            auto begins = src.begins();
-
-            T0 shiftedArg0 = shift_input(arg0, begins[0]);
-            T1 shiftedArg1 = shift_input(arg1, begins[1]);
-            T2 shiftedArg2 = shift_input(arg2, begins[2]);
-            T3 shiftedArg3 = shift_input(arg3, begins[3]);
-            T4 shiftedArg4 = shift_input(arg4, begins[4]);
-            T5 shiftedArg5 = shift_input(arg5, begins[5]);
-
-            auto theSubview = Kokkos::subview( theView , shiftedArg0, shiftedArg1, shiftedArg2, shiftedArg3, shiftedArg4, shiftedArg5);
-
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T0, T1, T2, T3, T4, T5>::type::Rank;
-
-            Kokkos::Array<int64_t, rank> subviewBegins;
-
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg0, arg0, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(1, subviewBegins, shiftedArg1, arg1, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(2, subviewBegins, shiftedArg2, arg2, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(3, subviewBegins, shiftedArg3, arg3, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(4, subviewBegins, shiftedArg4, arg4, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(5, subviewBegins, shiftedArg5, arg5, begins, counter);
-
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
+            ,
+            ViewTraits<D, P...>, T0, T1, T2, T3>::type>::type
+    subview_offset(const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
+                   T3 arg3) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T0 shiftedArg0 = shift_input(arg0, begins[0]);
+  T1 shiftedArg1 = shift_input(arg1, begins[1]);
+  T2 shiftedArg2 = shift_input(arg2, begins[2]);
+  T3 shiftedArg3 = shift_input(arg3, begins[3]);
+
+  auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1,
+                                    shiftedArg2, shiftedArg3);
+
+  constexpr size_t rank = Kokkos::Impl::ViewMapping<
+      void /* deduce subview type from source view traits */
+      ,
+      ViewTraits<D, P...>, T0, T1, T2, T3>::type::Rank;
+  Kokkos::Array<int64_t, rank> subviewBegins;
+
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      0, subviewBegins, shiftedArg0, arg0, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      1, subviewBegins, shiftedArg1, arg1, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      2, subviewBegins, shiftedArg2, arg2, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      3, subviewBegins, shiftedArg3, arg3, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<
+          void /* deduce subview type from source view traits */
+          ,
+          ViewTraits<D, P...>, T0, T1, T2, T3>::type>::type
+      offsetView(theSubview, subviewBegins);
+
+  return offsetView;
+}
+
+template <class D, class... P, class T0, class T1, class T2, class T3, class T4>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
             void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T0, T1, T2, T3, T4, T5 >::type >::type offsetView(theSubview, subviewBegins);
-
-            return offsetView;
-         }
-         template< class D, class ... P , class T0, class T1, class T2, class T3, class T4,
-         class T5, class T6>
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T0, T1, T2, T3, T4, T5, T6
-         >::type >::type
-         subview_offset(const OffsetView< D, P... > & src, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
-               T6 arg6) {
-
-            auto theView = src.view();
-            auto begins = src.begins();
-
-            T0 shiftedArg0 = shift_input(arg0, begins[0]);
-            T1 shiftedArg1 = shift_input(arg1, begins[1]);
-            T2 shiftedArg2 = shift_input(arg2, begins[2]);
-            T3 shiftedArg3 = shift_input(arg3, begins[3]);
-            T4 shiftedArg4 = shift_input(arg4, begins[4]);
-            T5 shiftedArg5 = shift_input(arg5, begins[5]);
-            T6 shiftedArg6 = shift_input(arg6, begins[6]);
-
-            auto theSubview = Kokkos::subview( theView , shiftedArg0, shiftedArg1, shiftedArg2, shiftedArg3, shiftedArg4, shiftedArg5,
-                  shiftedArg6);
-
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T0, T1, T2, T3, T4, T5, T6>::type::Rank;
-
-            Kokkos::Array<int64_t, rank> subviewBegins;
-
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg0, arg0, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(1, subviewBegins, shiftedArg1, arg1, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(2, subviewBegins, shiftedArg2, arg2, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(3, subviewBegins, shiftedArg3, arg3, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(4, subviewBegins, shiftedArg4, arg4, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(5, subviewBegins, shiftedArg5, arg5, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(6, subviewBegins, shiftedArg6, arg6, begins, counter);
-
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
+            ,
+            ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type>::type
+    subview_offset(const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
+                   T3 arg3, T4 arg4) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T0 shiftedArg0 = shift_input(arg0, begins[0]);
+  T1 shiftedArg1 = shift_input(arg1, begins[1]);
+  T2 shiftedArg2 = shift_input(arg2, begins[2]);
+  T3 shiftedArg3 = shift_input(arg3, begins[3]);
+  T4 shiftedArg4 = shift_input(arg4, begins[4]);
+
+  auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1,
+                                    shiftedArg2, shiftedArg3, shiftedArg4);
+
+  constexpr size_t rank = Kokkos::Impl::ViewMapping<
+      void /* deduce subview type from source view traits */
+      ,
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type::Rank;
+  Kokkos::Array<int64_t, rank> subviewBegins;
+
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      0, subviewBegins, shiftedArg0, arg0, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      1, subviewBegins, shiftedArg1, arg1, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      2, subviewBegins, shiftedArg2, arg2, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      3, subviewBegins, shiftedArg3, arg3, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      4, subviewBegins, shiftedArg4, arg4, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<
+          void /* deduce subview type from source view traits */
+          ,
+          ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type>::type
+      offsetView(theSubview, subviewBegins);
+
+  return offsetView;
+}
+
+template <class D, class... P, class T0, class T1, class T2, class T3, class T4,
+          class T5>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
             void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T0, T1, T2, T3, T4, T5,
-            T6 >::type >::type offsetView(theSubview, subviewBegins);
-
-            return offsetView;
-         }
-
-         template< class D, class ... P , class T0, class T1, class T2, class T3, class T4,
-         class T5, class T6, class T7>
-         KOKKOS_INLINE_FUNCTION
-         typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-         < void /* deduce subview type from source view traits */
-         , ViewTraits< D , P... >
-         , T0, T1, T2, T3, T4, T5, T6, T7
-         >::type >::type
-         subview_offset(const OffsetView< D, P... > & src, T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
-               T6 arg6, T7 arg7) {
-
-            auto theView = src.view();
-            auto begins = src.begins();
-
-            T0 shiftedArg0 = shift_input(arg0, begins[0]);
-            T1 shiftedArg1 = shift_input(arg1, begins[1]);
-            T2 shiftedArg2 = shift_input(arg2, begins[2]);
-            T3 shiftedArg3 = shift_input(arg3, begins[3]);
-            T4 shiftedArg4 = shift_input(arg4, begins[4]);
-            T5 shiftedArg5 = shift_input(arg5, begins[5]);
-            T6 shiftedArg6 = shift_input(arg6, begins[6]);
-            T7 shiftedArg7 = shift_input(arg7, begins[7]);
-
-            auto theSubview = Kokkos::subview( theView , shiftedArg0, shiftedArg1, shiftedArg2, shiftedArg3, shiftedArg4, shiftedArg5,
-                  shiftedArg6, shiftedArg7);
-
-            constexpr size_t rank = Kokkos::Impl::ViewMapping
-                  < void /* deduce subview type from source view traits */
-                  , ViewTraits< D , P... >
-            , T0, T1, T2, T3, T4, T5, T6, T7>::type::Rank;
-
-            Kokkos::Array<int64_t, rank> subviewBegins;
-
-            size_t counter = 0;
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg0, arg0, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(1, subviewBegins, shiftedArg1, arg1, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(2, subviewBegins, shiftedArg2, arg2, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(3, subviewBegins, shiftedArg3, arg3, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(4, subviewBegins, shiftedArg4, arg4, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(5, subviewBegins, shiftedArg5, arg5, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(6, subviewBegins, shiftedArg6, arg6, begins, counter);
-            Kokkos::Experimental::Impl::map_arg_to_new_begin(7, subviewBegins, shiftedArg7, arg7, begins, counter);
-
-            typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping<
+            ,
+            ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type>::type
+    subview_offset(const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
+                   T3 arg3, T4 arg4, T5 arg5) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T0 shiftedArg0 = shift_input(arg0, begins[0]);
+  T1 shiftedArg1 = shift_input(arg1, begins[1]);
+  T2 shiftedArg2 = shift_input(arg2, begins[2]);
+  T3 shiftedArg3 = shift_input(arg3, begins[3]);
+  T4 shiftedArg4 = shift_input(arg4, begins[4]);
+  T5 shiftedArg5 = shift_input(arg5, begins[5]);
+
+  auto theSubview =
+      Kokkos::subview(theView, shiftedArg0, shiftedArg1, shiftedArg2,
+                      shiftedArg3, shiftedArg4, shiftedArg5);
+
+  constexpr size_t rank = Kokkos::Impl::ViewMapping<
+      void /* deduce subview type from source view traits */
+      ,
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type::Rank;
+
+  Kokkos::Array<int64_t, rank> subviewBegins;
+
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      0, subviewBegins, shiftedArg0, arg0, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      1, subviewBegins, shiftedArg1, arg1, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      2, subviewBegins, shiftedArg2, arg2, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      3, subviewBegins, shiftedArg3, arg3, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      4, subviewBegins, shiftedArg4, arg4, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      5, subviewBegins, shiftedArg5, arg5, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<
+          void /* deduce subview type from source view traits */
+          ,
+          ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type>::type
+      offsetView(theSubview, subviewBegins);
+
+  return offsetView;
+}
+template <class D, class... P, class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
             void /* deduce subview type from source view traits */
-            , ViewTraits< D , P... > , T0, T1, T2, T3, T4, T5,
-            T6, T7 >::type >::type offsetView(theSubview, subviewBegins);
+            ,
+            ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type>::type
+    subview_offset(const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
+                   T3 arg3, T4 arg4, T5 arg5, T6 arg6) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T0 shiftedArg0 = shift_input(arg0, begins[0]);
+  T1 shiftedArg1 = shift_input(arg1, begins[1]);
+  T2 shiftedArg2 = shift_input(arg2, begins[2]);
+  T3 shiftedArg3 = shift_input(arg3, begins[3]);
+  T4 shiftedArg4 = shift_input(arg4, begins[4]);
+  T5 shiftedArg5 = shift_input(arg5, begins[5]);
+  T6 shiftedArg6 = shift_input(arg6, begins[6]);
+
+  auto theSubview =
+      Kokkos::subview(theView, shiftedArg0, shiftedArg1, shiftedArg2,
+                      shiftedArg3, shiftedArg4, shiftedArg5, shiftedArg6);
+
+  constexpr size_t rank = Kokkos::Impl::ViewMapping<
+      void /* deduce subview type from source view traits */
+      ,
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type::Rank;
+
+  Kokkos::Array<int64_t, rank> subviewBegins;
+
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      0, subviewBegins, shiftedArg0, arg0, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      1, subviewBegins, shiftedArg1, arg1, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      2, subviewBegins, shiftedArg2, arg2, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      3, subviewBegins, shiftedArg3, arg3, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      4, subviewBegins, shiftedArg4, arg4, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      5, subviewBegins, shiftedArg5, arg5, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      6, subviewBegins, shiftedArg6, arg6, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<
+          void /* deduce subview type from source view traits */
+          ,
+          ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type>::type
+      offsetView(theSubview, subviewBegins);
+
+  return offsetView;
+}
 
-            return offsetView;
-         }
-      }
+template <class D, class... P, class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
+            void /* deduce subview type from source view traits */
+            ,
+            ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type>::type
+    subview_offset(const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
+                   T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) {
+  auto theView = src.view();
+  auto begins  = src.begins();
+
+  T0 shiftedArg0 = shift_input(arg0, begins[0]);
+  T1 shiftedArg1 = shift_input(arg1, begins[1]);
+  T2 shiftedArg2 = shift_input(arg2, begins[2]);
+  T3 shiftedArg3 = shift_input(arg3, begins[3]);
+  T4 shiftedArg4 = shift_input(arg4, begins[4]);
+  T5 shiftedArg5 = shift_input(arg5, begins[5]);
+  T6 shiftedArg6 = shift_input(arg6, begins[6]);
+  T7 shiftedArg7 = shift_input(arg7, begins[7]);
+
+  auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1,
+                                    shiftedArg2, shiftedArg3, shiftedArg4,
+                                    shiftedArg5, shiftedArg6, shiftedArg7);
+
+  constexpr size_t rank = Kokkos::Impl::ViewMapping<
+      void /* deduce subview type from source view traits */
+      ,
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type::Rank;
+
+  Kokkos::Array<int64_t, rank> subviewBegins;
+
+  size_t counter = 0;
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      0, subviewBegins, shiftedArg0, arg0, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      1, subviewBegins, shiftedArg1, arg1, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      2, subviewBegins, shiftedArg2, arg2, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      3, subviewBegins, shiftedArg3, arg3, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      4, subviewBegins, shiftedArg4, arg4, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      5, subviewBegins, shiftedArg5, arg5, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      6, subviewBegins, shiftedArg6, arg6, begins, counter);
+  Kokkos::Experimental::Impl::map_arg_to_new_begin(
+      7, subviewBegins, shiftedArg7, arg7, begins, counter);
+
+  typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+      typename Kokkos::Impl::ViewMapping<
+          void /* deduce subview type from source view traits */
+          ,
+          ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type>::type
+      offsetView(theSubview, subviewBegins);
+
+  return offsetView;
+}
+}  // namespace Impl
 
-      template< class D, class ... P , class ... Args >
-      KOKKOS_INLINE_FUNCTION
-      typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<typename Kokkos::Impl::ViewMapping
-      < void /* deduce subview type from source view traits */
-      , ViewTraits< D , P... >
-      , Args ...
-      >::type >::type
-      subview( const OffsetView< D, P... > & src , Args ... args )
-      {
-         static_assert( OffsetView< D , P... >::Rank == sizeof...(Args) ,
-               "subview requires one argument for each source OffsetView rank" );
+template <class D, class... P, class... Args>
+KOKKOS_INLINE_FUNCTION
+    typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
+        typename Kokkos::Impl::ViewMapping<
+            void /* deduce subview type from source view traits */
+            ,
+            ViewTraits<D, P...>, Args...>::type>::type
+    subview(const OffsetView<D, P...>& src, Args... args) {
+  static_assert(
+      OffsetView<D, P...>::Rank == sizeof...(Args),
+      "subview requires one argument for each source OffsetView rank");
+
+  return Kokkos::Experimental::Impl::subview_offset(src, args...);
+}
 
+}  // namespace Experimental
+}  // namespace Kokkos
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 
-         return Kokkos::Experimental::Impl::subview_offset(src, args...);
+namespace Kokkos {
+namespace Experimental {
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator==(const OffsetView<LT, LP...>& lhs,
+                                       const OffsetView<RT, RP...>& rhs) {
+  // Same data, layout, dimensions
+  typedef ViewTraits<LT, LP...> lhs_traits;
+  typedef ViewTraits<RT, RP...> rhs_traits;
+
+  return std::is_same<typename lhs_traits::const_value_type,
+                      typename rhs_traits::const_value_type>::value &&
+         std::is_same<typename lhs_traits::array_layout,
+                      typename rhs_traits::array_layout>::value &&
+         std::is_same<typename lhs_traits::memory_space,
+                      typename rhs_traits::memory_space>::value &&
+         unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
+         lhs.data() == rhs.data() && lhs.span() == rhs.span() &&
+         lhs.extent(0) == rhs.extent(0) && lhs.extent(1) == rhs.extent(1) &&
+         lhs.extent(2) == rhs.extent(2) && lhs.extent(3) == rhs.extent(3) &&
+         lhs.extent(4) == rhs.extent(4) && lhs.extent(5) == rhs.extent(5) &&
+         lhs.extent(6) == rhs.extent(6) && lhs.extent(7) == rhs.extent(7) &&
+         lhs.begin(0) == rhs.begin(0) && lhs.begin(1) == rhs.begin(1) &&
+         lhs.begin(2) == rhs.begin(2) && lhs.begin(3) == rhs.begin(3) &&
+         lhs.begin(4) == rhs.begin(4) && lhs.begin(5) == rhs.begin(5) &&
+         lhs.begin(6) == rhs.begin(6) && lhs.begin(7) == rhs.begin(7);
+}
 
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator!=(const OffsetView<LT, LP...>& lhs,
+                                       const OffsetView<RT, RP...>& rhs) {
+  return !(operator==(lhs, rhs));
+}
 
-      }
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator==(const View<LT, LP...>& lhs,
+                                       const OffsetView<RT, RP...>& rhs) {
+  // Same data, layout, dimensions
+  typedef ViewTraits<LT, LP...> lhs_traits;
+  typedef ViewTraits<RT, RP...> rhs_traits;
+
+  return std::is_same<typename lhs_traits::const_value_type,
+                      typename rhs_traits::const_value_type>::value &&
+         std::is_same<typename lhs_traits::array_layout,
+                      typename rhs_traits::array_layout>::value &&
+         std::is_same<typename lhs_traits::memory_space,
+                      typename rhs_traits::memory_space>::value &&
+         unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
+         lhs.data() == rhs.data() && lhs.span() == rhs.span() &&
+         lhs.extent(0) == rhs.extent(0) && lhs.extent(1) == rhs.extent(1) &&
+         lhs.extent(2) == rhs.extent(2) && lhs.extent(3) == rhs.extent(3) &&
+         lhs.extent(4) == rhs.extent(4) && lhs.extent(5) == rhs.extent(5) &&
+         lhs.extent(6) == rhs.extent(6) && lhs.extent(7) == rhs.extent(7);
+}
 
-   }
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator==(const OffsetView<LT, LP...>& lhs,
+                                       const View<RT, RP...>& rhs) {
+  return rhs == lhs;
 }
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
 
-namespace Kokkos {
-   namespace Experimental {
-      template< class LT , class ... LP , class RT , class ... RP >
-      KOKKOS_INLINE_FUNCTION
-      bool operator == ( const OffsetView<LT,LP...> & lhs ,
-            const OffsetView<RT,RP...> & rhs )
-            {
-         // Same data, layout, dimensions
-         typedef ViewTraits<LT,LP...>  lhs_traits ;
-         typedef ViewTraits<RT,RP...>  rhs_traits ;
-
-         return
-               std::is_same< typename lhs_traits::const_value_type ,
-               typename rhs_traits::const_value_type >::value &&
-               std::is_same< typename lhs_traits::array_layout ,
-               typename rhs_traits::array_layout >::value &&
-               std::is_same< typename lhs_traits::memory_space ,
-               typename rhs_traits::memory_space >::value &&
-               unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
-               lhs.data()        == rhs.data() &&
-               lhs.span()        == rhs.span() &&
-               lhs.extent(0) == rhs.extent(0) &&
-               lhs.extent(1) == rhs.extent(1) &&
-               lhs.extent(2) == rhs.extent(2) &&
-               lhs.extent(3) == rhs.extent(3) &&
-               lhs.extent(4) == rhs.extent(4) &&
-               lhs.extent(5) == rhs.extent(5) &&
-               lhs.extent(6) == rhs.extent(6) &&
-               lhs.extent(7) == rhs.extent(7) &&
-               lhs.begin(0) == rhs.begin(0) &&
-               lhs.begin(1) == rhs.begin(1) &&
-               lhs.begin(2) == rhs.begin(2) &&
-               lhs.begin(3) == rhs.begin(3) &&
-               lhs.begin(4) == rhs.begin(4) &&
-               lhs.begin(5) == rhs.begin(5) &&
-               lhs.begin(6) == rhs.begin(6) &&
-               lhs.begin(7) == rhs.begin(7)
-               ;
-            }
-
-      template< class LT , class ... LP , class RT , class ... RP >
-      KOKKOS_INLINE_FUNCTION
-      bool operator != ( const OffsetView<LT,LP...> & lhs ,
-            const OffsetView<RT,RP...> & rhs )
-            {
-         return ! ( operator==(lhs,rhs) );
-            }
-
-      template< class LT , class ... LP , class RT , class ... RP >
-      KOKKOS_INLINE_FUNCTION
-      bool operator == ( const View<LT,LP...> & lhs ,
-            const OffsetView<RT,RP...> & rhs )
-            {
-         // Same data, layout, dimensions
-         typedef ViewTraits<LT,LP...>  lhs_traits ;
-         typedef ViewTraits<RT,RP...>  rhs_traits ;
-
-         return
-               std::is_same< typename lhs_traits::const_value_type ,
-               typename rhs_traits::const_value_type >::value &&
-               std::is_same< typename lhs_traits::array_layout ,
-               typename rhs_traits::array_layout >::value &&
-               std::is_same< typename lhs_traits::memory_space ,
-               typename rhs_traits::memory_space >::value &&
-               unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
-               lhs.data()        == rhs.data() &&
-               lhs.span()        == rhs.span() &&
-               lhs.extent(0) == rhs.extent(0) &&
-               lhs.extent(1) == rhs.extent(1) &&
-               lhs.extent(2) == rhs.extent(2) &&
-               lhs.extent(3) == rhs.extent(3) &&
-               lhs.extent(4) == rhs.extent(4) &&
-               lhs.extent(5) == rhs.extent(5) &&
-               lhs.extent(6) == rhs.extent(6) &&
-               lhs.extent(7) == rhs.extent(7)
-               ;
-            }
-
-      template< class LT , class ... LP , class RT , class ... RP >
-      KOKKOS_INLINE_FUNCTION
-      bool operator == ( const OffsetView<LT,LP...> & lhs ,
-            const View<RT,RP...> & rhs )
-            { return rhs == lhs;}
-
-   }
+}  // namespace Experimental
 } /* namespace Kokkos */
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
 namespace Kokkos {
-   namespace Experimental {
-      template< class DT , class ... DP >
-      inline
-      void deep_copy
-      ( const OffsetView<DT,DP...> & dst
-            , typename ViewTraits<DT,DP...>::const_value_type & value
-            , typename std::enable_if<
-            std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value
-            >::type * = 0 )
-      {
-         static_assert(
-               std::is_same< typename ViewTraits<DT,DP...>::non_const_value_type ,
-               typename ViewTraits<DT,DP...>::value_type >::value
-               , "deep_copy requires non-const type" );
-
-         auto dstView = dst.view();
-         Kokkos::deep_copy( dstView , value );
-
-      }
-
-      template< class DT , class ... DP , class ST , class ... SP >
-      inline
-      void deep_copy
-      ( const OffsetView<DT,DP...> & dst
-            , const OffsetView<ST,SP...> & value
-            , typename std::enable_if<
-            std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value
-            >::type * = 0 )
-      {
-         static_assert(
-               std::is_same< typename ViewTraits<DT,DP...>::value_type ,
-               typename ViewTraits<ST,SP...>::non_const_value_type >::value
-               , "deep_copy requires matching non-const destination type" );
-
-         auto dstView = dst.view();
-         Kokkos::deep_copy( dstView , value.view() );
-
-      }
-      template< class DT , class ... DP , class ST , class ... SP >
-      inline
-      void deep_copy
-      ( const OffsetView<DT,DP...> & dst
-            , const View<ST,SP...> & value
-            , typename std::enable_if<
-            std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value
-            >::type * = 0 )
-      {
-         static_assert(
-               std::is_same< typename ViewTraits<DT,DP...>::value_type ,
-               typename ViewTraits<ST,SP...>::non_const_value_type >::value
-               , "deep_copy requires matching non-const destination type" );
-
-         auto dstView = dst.view();
-         Kokkos::deep_copy( dstView , value);
-
-      }
-
-      template< class DT , class ... DP , class ST , class ... SP >
-      inline
-      void deep_copy
-      ( const View<DT,DP...> & dst
-            , const OffsetView<ST,SP...> & value
-            , typename std::enable_if<
-            std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value
-            >::type * = 0 )
-      {
-         static_assert(
-               std::is_same< typename ViewTraits<DT,DP...>::value_type ,
-               typename ViewTraits<ST,SP...>::non_const_value_type >::value
-               , "deep_copy requires matching non-const destination type" );
-
-         Kokkos::deep_copy( dst , value.view() );
-
-      }
-      namespace Impl {
-
-         // Deduce Mirror Types
-         template<class Space, class T, class ... P>
-         struct MirrorOffsetViewType {
-            // The incoming view_type
-            typedef typename Kokkos::Experimental::OffsetView<T,P...> src_view_type;
-            // The memory space for the mirror view
-            typedef typename Space::memory_space memory_space;
-            // Check whether it is the same memory space
-            enum { is_same_memspace = std::is_same<memory_space,typename src_view_type::memory_space>::value };
-            // The array_layout
-            typedef typename src_view_type::array_layout array_layout;
-            // The data type (we probably want it non-const since otherwise we can't even deep_copy to it.
-            typedef typename src_view_type::non_const_data_type data_type;
-            // The destination view type if it is not the same memory space
-            typedef Kokkos::Experimental::OffsetView<data_type,array_layout,Space> dest_view_type;
-            // If it is the same memory_space return the existsing view_type
-            // This will also keep the unmanaged trait if necessary
-            typedef typename std::conditional<is_same_memspace,src_view_type,dest_view_type>::type view_type;
-         };
-
-         template<class Space, class T, class ... P>
-         struct MirrorOffsetType {
-            // The incoming view_type
-            typedef typename Kokkos::Experimental::OffsetView<T,P...> src_view_type;
-            // The memory space for the mirror view
-            typedef typename Space::memory_space memory_space;
-            // Check whether it is the same memory space
-            enum { is_same_memspace = std::is_same<memory_space,typename src_view_type::memory_space>::value };
-            // The array_layout
-            typedef typename src_view_type::array_layout array_layout;
-            // The data type (we probably want it non-const since otherwise we can't even deep_copy to it.
-            typedef typename src_view_type::non_const_data_type data_type;
-            // The destination view type if it is not the same memory space
-            typedef Kokkos::Experimental::OffsetView<data_type,array_layout,Space> view_type;
-         };
-
-      }
-
-      template< class T , class ... P >
-      inline
-      typename Kokkos::Experimental::OffsetView<T,P...>::HostMirror
-      create_mirror( const Kokkos::Experimental::OffsetView<T,P...> & src
-            , typename std::enable_if<
-            ! std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
-            , Kokkos::LayoutStride >::value
-            >::type * = 0
-      )
-      {
-         typedef OffsetView<T,P...>             src_type ;
-         typedef typename src_type::HostMirror  dst_type ;
-
-         return dst_type( Kokkos::Impl::ViewCtorProp< std::string >(std::string( src.label() ).append("_mirror") ),
-               typename Kokkos::ViewTraits<T,P...>::array_layout
-               ( src.extent(0), src.extent(1), src.extent(2), src.extent(3), src.extent(4),
-                     src.extent(5), src.extent(6), src.extent(7) ),
-                     { src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
-                           src.begin(5), src.begin(6), src.begin(7) });
-      }
+namespace Experimental {
+template <class DT, class... DP>
+inline void deep_copy(
+    const OffsetView<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<DT, DP...>::specialize, void>::value>::type* = 0) {
+  static_assert(
+      std::is_same<typename ViewTraits<DT, DP...>::non_const_value_type,
+                   typename ViewTraits<DT, DP...>::value_type>::value,
+      "deep_copy requires non-const type");
+
+  auto dstView = dst.view();
+  Kokkos::deep_copy(dstView, value);
+}
 
-      template< class T , class ... P >
-      inline
-      typename Kokkos::Experimental::OffsetView<T,P...>::HostMirror
-      create_mirror( const Kokkos::Experimental::OffsetView<T,P...> & src
-            , typename std::enable_if<
-            std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
-            , Kokkos::LayoutStride >::value
-            >::type * = 0
-      )
-      {
-         typedef OffsetView<T,P...>             src_type ;
-         typedef typename src_type::HostMirror  dst_type ;
-
-         Kokkos::LayoutStride layout ;
-
-         layout.dimension[0] = src.extent(0);
-         layout.dimension[1] = src.extent(1);
-         layout.dimension[2] = src.extent(2);
-         layout.dimension[3] = src.extent(3);
-         layout.dimension[4] = src.extent(4);
-         layout.dimension[5] = src.extent(5);
-         layout.dimension[6] = src.extent(6);
-         layout.dimension[7] = src.extent(7);
-
-         layout.stride[0] = src.stride_0();
-         layout.stride[1] = src.stride_1();
-         layout.stride[2] = src.stride_2();
-         layout.stride[3] = src.stride_3();
-         layout.stride[4] = src.stride_4();
-         layout.stride[5] = src.stride_5();
-         layout.stride[6] = src.stride_6();
-         layout.stride[7] = src.stride_7();
-
-         return dst_type( std::string( src.label() ).append("_mirror") , layout,
-               { src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
-                     src.begin(5), src.begin(6), src.begin(7) } );
-      }
+template <class DT, class... DP, class ST, class... SP>
+inline void deep_copy(
+    const OffsetView<DT, DP...>& dst, const OffsetView<ST, SP...>& value,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<DT, DP...>::specialize, void>::value>::type* = 0) {
+  static_assert(
+      std::is_same<typename ViewTraits<DT, DP...>::value_type,
+                   typename ViewTraits<ST, SP...>::non_const_value_type>::value,
+      "deep_copy requires matching non-const destination type");
+
+  auto dstView = dst.view();
+  Kokkos::deep_copy(dstView, value.view());
+}
+template <class DT, class... DP, class ST, class... SP>
+inline void deep_copy(
+    const OffsetView<DT, DP...>& dst, const View<ST, SP...>& value,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<DT, DP...>::specialize, void>::value>::type* = 0) {
+  static_assert(
+      std::is_same<typename ViewTraits<DT, DP...>::value_type,
+                   typename ViewTraits<ST, SP...>::non_const_value_type>::value,
+      "deep_copy requires matching non-const destination type");
+
+  auto dstView = dst.view();
+  Kokkos::deep_copy(dstView, value);
+}
 
+template <class DT, class... DP, class ST, class... SP>
+inline void deep_copy(
+    const View<DT, DP...>& dst, const OffsetView<ST, SP...>& value,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<DT, DP...>::specialize, void>::value>::type* = 0) {
+  static_assert(
+      std::is_same<typename ViewTraits<DT, DP...>::value_type,
+                   typename ViewTraits<ST, SP...>::non_const_value_type>::value,
+      "deep_copy requires matching non-const destination type");
+
+  Kokkos::deep_copy(dst, value.view());
+}
+namespace Impl {
+
+// Deduce Mirror Types
+template <class Space, class T, class... P>
+struct MirrorOffsetViewType {
+  // The incoming view_type
+  typedef typename Kokkos::Experimental::OffsetView<T, P...> src_view_type;
+  // The memory space for the mirror view
+  typedef typename Space::memory_space memory_space;
+  // Check whether it is the same memory space
+  enum {
+    is_same_memspace =
+        std::is_same<memory_space, typename src_view_type::memory_space>::value
+  };
+  // The array_layout
+  typedef typename src_view_type::array_layout array_layout;
+  // The data type (we probably want it non-const since otherwise we can't even
+  // deep_copy to it.
+  typedef typename src_view_type::non_const_data_type data_type;
+  // The destination view type if it is not the same memory space
+  typedef Kokkos::Experimental::OffsetView<data_type, array_layout, Space>
+      dest_view_type;
+  // If it is the same memory_space return the existsing view_type
+  // This will also keep the unmanaged trait if necessary
+  typedef typename std::conditional<is_same_memspace, src_view_type,
+                                    dest_view_type>::type view_type;
+};
+
+template <class Space, class T, class... P>
+struct MirrorOffsetType {
+  // The incoming view_type
+  typedef typename Kokkos::Experimental::OffsetView<T, P...> src_view_type;
+  // The memory space for the mirror view
+  typedef typename Space::memory_space memory_space;
+  // Check whether it is the same memory space
+  enum {
+    is_same_memspace =
+        std::is_same<memory_space, typename src_view_type::memory_space>::value
+  };
+  // The array_layout
+  typedef typename src_view_type::array_layout array_layout;
+  // The data type (we probably want it non-const since otherwise we can't even
+  // deep_copy to it.
+  typedef typename src_view_type::non_const_data_type data_type;
+  // The destination view type if it is not the same memory space
+  typedef Kokkos::Experimental::OffsetView<data_type, array_layout, Space>
+      view_type;
+};
+
+}  // namespace Impl
+
+template <class T, class... P>
+inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
+create_mirror(
+    const Kokkos::Experimental::OffsetView<T, P...>& src,
+    typename std::enable_if<
+        !std::is_same<typename Kokkos::ViewTraits<T, P...>::array_layout,
+                      Kokkos::LayoutStride>::value>::type* = 0) {
+  typedef OffsetView<T, P...> src_type;
+  typedef typename src_type::HostMirror dst_type;
+
+  return dst_type(
+      Kokkos::Impl::ViewCtorProp<std::string>(
+          std::string(src.label()).append("_mirror")),
+      typename Kokkos::ViewTraits<T, P...>::array_layout(
+          src.extent(0), src.extent(1), src.extent(2), src.extent(3),
+          src.extent(4), src.extent(5), src.extent(6), src.extent(7)),
+      {src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
+       src.begin(5), src.begin(6), src.begin(7)});
+}
 
-      // Create a mirror in a new space (specialization for different space)
-      template<class Space, class T, class ... P>
-      typename Kokkos::Experimental::Impl::MirrorOffsetType<Space,T,P ...>::view_type
-      create_mirror(const Space& , const Kokkos::Experimental::OffsetView<T,P...> & src) {
-         return typename Kokkos::Experimental::Impl::MirrorOffsetType<Space,T,P ...>::view_type(src.label(),src.layout(),
-               { src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
-                     src.begin(5), src.begin(6), src.begin(7) } );
-      }
+template <class T, class... P>
+inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
+create_mirror(
+    const Kokkos::Experimental::OffsetView<T, P...>& src,
+    typename std::enable_if<
+        std::is_same<typename Kokkos::ViewTraits<T, P...>::array_layout,
+                     Kokkos::LayoutStride>::value>::type* = 0) {
+  typedef OffsetView<T, P...> src_type;
+  typedef typename src_type::HostMirror dst_type;
+
+  Kokkos::LayoutStride layout;
+
+  layout.dimension[0] = src.extent(0);
+  layout.dimension[1] = src.extent(1);
+  layout.dimension[2] = src.extent(2);
+  layout.dimension[3] = src.extent(3);
+  layout.dimension[4] = src.extent(4);
+  layout.dimension[5] = src.extent(5);
+  layout.dimension[6] = src.extent(6);
+  layout.dimension[7] = src.extent(7);
+
+  layout.stride[0] = src.stride_0();
+  layout.stride[1] = src.stride_1();
+  layout.stride[2] = src.stride_2();
+  layout.stride[3] = src.stride_3();
+  layout.stride[4] = src.stride_4();
+  layout.stride[5] = src.stride_5();
+  layout.stride[6] = src.stride_6();
+  layout.stride[7] = src.stride_7();
+
+  return dst_type(std::string(src.label()).append("_mirror"), layout,
+                  {src.begin(0), src.begin(1), src.begin(2), src.begin(3),
+                   src.begin(4), src.begin(5), src.begin(6), src.begin(7)});
+}
 
+// Create a mirror in a new space (specialization for different space)
+template <class Space, class T, class... P>
+typename Kokkos::Experimental::Impl::MirrorOffsetType<Space, T, P...>::view_type
+create_mirror(const Space&,
+              const Kokkos::Experimental::OffsetView<T, P...>& src) {
+  return typename Kokkos::Experimental::Impl::MirrorOffsetType<
+      Space, T, P...>::view_type(src.label(), src.layout(),
+                                 {src.begin(0), src.begin(1), src.begin(2),
+                                  src.begin(3), src.begin(4), src.begin(5),
+                                  src.begin(6), src.begin(7)});
+}
 
-      template< class T , class ... P >
-      inline
-      typename Kokkos::Experimental::OffsetView< T, P... >::HostMirror
-      create_mirror_view( const typename Kokkos::Experimental::OffsetView< T,P... > & src
-            , typename std::enable_if<(
-                  std::is_same< typename Kokkos::Experimental::OffsetView<T,P...>::memory_space
-                  , typename Kokkos::Experimental::OffsetView<T,P...>::HostMirror::memory_space
-                  >::value
-                  &&
-                  std::is_same< typename Kokkos::Experimental::OffsetView<T,P...>::data_type
-                  , typename Kokkos::Experimental::OffsetView<T,P...>::HostMirror::data_type
-                  >::value
-            )>::type * = 0
-      )
-      {
-         return src ;
-      }
+template <class T, class... P>
+inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
+create_mirror_view(
+    const typename Kokkos::Experimental::OffsetView<T, P...>& src,
+    typename std::enable_if<
+        (std::is_same<
+             typename Kokkos::Experimental::OffsetView<T, P...>::memory_space,
+             typename Kokkos::Experimental::OffsetView<
+                 T, P...>::HostMirror::memory_space>::value &&
+         std::is_same<
+             typename Kokkos::Experimental::OffsetView<T, P...>::data_type,
+             typename Kokkos::Experimental::OffsetView<
+                 T, P...>::HostMirror::data_type>::value)>::type* = 0) {
+  return src;
+}
 
-      template< class T , class ... P >
-      inline
-      typename Kokkos::Experimental::OffsetView<T,P...>::HostMirror
-      create_mirror_view( const Kokkos::Experimental::OffsetView<T,P...> & src
-            , typename std::enable_if< ! (
-                  std::is_same< typename Kokkos::Experimental::OffsetView<T,P...>::memory_space
-                  , typename Kokkos::Experimental::OffsetView<T,P...>::HostMirror::memory_space
-                  >::value
-                  &&
-                  std::is_same< typename Kokkos::Experimental::OffsetView<T,P...>::data_type
-                  , typename Kokkos::Experimental::OffsetView<T,P...>::HostMirror::data_type
-                  >::value
-            )>::type * = 0
-      )
-      {
-	return Kokkos::Experimental::create_mirror( src );
-      }
+template <class T, class... P>
+inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
+create_mirror_view(
+    const Kokkos::Experimental::OffsetView<T, P...>& src,
+    typename std::enable_if<
+        !(std::is_same<
+              typename Kokkos::Experimental::OffsetView<T, P...>::memory_space,
+              typename Kokkos::Experimental::OffsetView<
+                  T, P...>::HostMirror::memory_space>::value &&
+          std::is_same<
+              typename Kokkos::Experimental::OffsetView<T, P...>::data_type,
+              typename Kokkos::Experimental::OffsetView<
+                  T, P...>::HostMirror::data_type>::value)>::type* = 0) {
+  return Kokkos::Experimental::create_mirror(src);
+}
 
-      // Create a mirror view in a new space (specialization for same space)
-      template<class Space, class T, class ... P>
-      typename Kokkos::Experimental::Impl::MirrorOffsetViewType<Space,T,P ...>::view_type
-      create_mirror_view(const Space& , const Kokkos::Experimental::OffsetView<T,P...> & src
-            , typename std::enable_if<Impl::MirrorOffsetViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-         return src;
-      }
+// Create a mirror view in a new space (specialization for same space)
+template <class Space, class T, class... P>
+typename Kokkos::Experimental::Impl::MirrorOffsetViewType<Space, T,
+                                                          P...>::view_type
+create_mirror_view(const Space&,
+                   const Kokkos::Experimental::OffsetView<T, P...>& src,
+                   typename std::enable_if<Impl::MirrorOffsetViewType<
+                       Space, T, P...>::is_same_memspace>::type* = 0) {
+  return src;
+}
 
-      // Create a mirror view in a new space (specialization for different space)
-      template<class Space, class T, class ... P>
-      typename Kokkos::Experimental::Impl::MirrorOffsetViewType<Space,T,P ...>::view_type
-      create_mirror_view(const Space& , const Kokkos::Experimental::OffsetView<T,P...> & src
-            , typename std::enable_if<!Impl::MirrorOffsetViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-         return typename Kokkos::Experimental::Impl::MirrorOffsetViewType<Space,T,P ...>::view_type(src.label(),src.layout(),
-               { src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
-                     src.begin(5), src.begin(6), src.begin(7) } );
-      }
-      //
-      //  // Create a mirror view and deep_copy in a new space (specialization for same space)
-      //  template<class Space, class T, class ... P>
-      //  typename Kokkos::Experimental::Impl::MirrorViewType<Space,T,P ...>::view_type
-      //  create_mirror_view_and_copy(const Space& , const Kokkos::Experimental::OffsetView<T,P...> & src
-      //                              , std::string const& name = ""
-      //                                  , typename std::enable_if<Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-      //    (void)name;
-      //    return src;
-      //  }
-      //
-      //  // Create a mirror view and deep_copy in a new space (specialization for different space)
-      //  template<class Space, class T, class ... P>
-      //  typename Kokkos::Experimental::Impl::MirrorViewType<Space,T,P ...>::view_type
-      //  create_mirror_view_and_copy(const Space& , const Kokkos::Experimental::OffsetView<T,P...> & src
-      //                              , std::string const& name = ""
-      //                                  , typename std::enable_if<!Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-      //    using Mirror = typename Kokkos::Experimental::Impl::MirrorViewType<Space,T,P ...>::view_type;
-      //    std::string label = name.empty() ? src.label() : name;
-      //    auto mirror = Mirror(ViewAllocateWithoutInitializing(label), src.layout(),
-      //                         { src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
-      //                             src.begin(5), src.begin(6), src.begin(7) });
-      //    deep_copy(mirror, src);
-      //    return mirror;
-      //  }
-
-   }
+// Create a mirror view in a new space (specialization for different space)
+template <class Space, class T, class... P>
+typename Kokkos::Experimental::Impl::MirrorOffsetViewType<Space, T,
+                                                          P...>::view_type
+create_mirror_view(const Space&,
+                   const Kokkos::Experimental::OffsetView<T, P...>& src,
+                   typename std::enable_if<!Impl::MirrorOffsetViewType<
+                       Space, T, P...>::is_same_memspace>::type* = 0) {
+  return typename Kokkos::Experimental::Impl::MirrorOffsetViewType<
+      Space, T, P...>::view_type(src.label(), src.layout(),
+                                 {src.begin(0), src.begin(1), src.begin(2),
+                                  src.begin(3), src.begin(4), src.begin(5),
+                                  src.begin(6), src.begin(7)});
+}
+//
+//  // Create a mirror view and deep_copy in a new space (specialization for
+//  same space) template<class Space, class T, class ... P> typename
+//  Kokkos::Experimental::Impl::MirrorViewType<Space,T,P ...>::view_type
+//  create_mirror_view_and_copy(const Space& , const
+//  Kokkos::Experimental::OffsetView<T,P...> & src
+//                              , std::string const& name = ""
+//                                  , typename
+//                                  std::enable_if<Impl::MirrorViewType<Space,T,P
+//                                  ...>::is_same_memspace>::type* = 0 ) {
+//    (void)name;
+//    return src;
+//  }
+//
+//  // Create a mirror view and deep_copy in a new space (specialization for
+//  different space) template<class Space, class T, class ... P> typename
+//  Kokkos::Experimental::Impl::MirrorViewType<Space,T,P ...>::view_type
+//  create_mirror_view_and_copy(const Space& , const
+//  Kokkos::Experimental::OffsetView<T,P...> & src
+//                              , std::string const& name = ""
+//                                  , typename
+//                                  std::enable_if<!Impl::MirrorViewType<Space,T,P
+//                                  ...>::is_same_memspace>::type* = 0 ) {
+//    using Mirror = typename
+//    Kokkos::Experimental::Impl::MirrorViewType<Space,T,P ...>::view_type;
+//    std::string label = name.empty() ? src.label() : name;
+//    auto mirror = Mirror(ViewAllocateWithoutInitializing(label), src.layout(),
+//                         { src.begin(0), src.begin(1), src.begin(2),
+//                         src.begin(3), src.begin(4),
+//                             src.begin(5), src.begin(6), src.begin(7) });
+//    deep_copy(mirror, src);
+//    return mirror;
+//  }
+
+}  // namespace Experimental
 } /* namespace Kokkos */
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
 #endif /* KOKKOS_OFFSETVIEW_HPP_ */
diff --git a/lib/kokkos/containers/src/Kokkos_ScatterView.hpp b/lib/kokkos/containers/src/Kokkos_ScatterView.hpp
index a8c05e3f363162f10bdaa50d8af9409924f96b89..ec3a9663259c15c9cb27b736af3749dc79edcb94 100644
--- a/lib/kokkos/containers/src/Kokkos_ScatterView.hpp
+++ b/lib/kokkos/containers/src/Kokkos_ScatterView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,6 @@
 //@HEADER
 */
 
-
 /// \file Kokkos_ScatterView.hpp
 /// \brief Declaration and definition of Kokkos::ScatterView.
 ///
@@ -69,17 +69,12 @@ enum : int {
   ScatterMin,
 };
 
-enum : int {
-  ScatterNonDuplicated = 0,
-  ScatterDuplicated    = 1
-};
+enum : int { ScatterNonDuplicated = 0, ScatterDuplicated = 1 };
 
-enum : int {
-  ScatterNonAtomic = 0,
-  ScatterAtomic    = 1
-};
+enum : int { ScatterNonAtomic = 0, ScatterAtomic = 1 };
 
-}} // Kokkos::Experimental
+}  // namespace Experimental
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
@@ -97,11 +92,13 @@ struct DefaultDuplication<Kokkos::Serial> {
   enum : int { value = Kokkos::Experimental::ScatterNonDuplicated };
 };
 template <>
-struct DefaultContribution<Kokkos::Serial, Kokkos::Experimental::ScatterNonDuplicated> {
+struct DefaultContribution<Kokkos::Serial,
+                           Kokkos::Experimental::ScatterNonDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterNonAtomic };
 };
 template <>
-struct DefaultContribution<Kokkos::Serial, Kokkos::Experimental::ScatterDuplicated> {
+struct DefaultContribution<Kokkos::Serial,
+                           Kokkos::Experimental::ScatterDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterNonAtomic };
 };
 #endif
@@ -112,11 +109,13 @@ struct DefaultDuplication<Kokkos::OpenMP> {
   enum : int { value = Kokkos::Experimental::ScatterDuplicated };
 };
 template <>
-struct DefaultContribution<Kokkos::OpenMP, Kokkos::Experimental::ScatterNonDuplicated> {
+struct DefaultContribution<Kokkos::OpenMP,
+                           Kokkos::Experimental::ScatterNonDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterAtomic };
 };
 template <>
-struct DefaultContribution<Kokkos::OpenMP, Kokkos::Experimental::ScatterDuplicated> {
+struct DefaultContribution<Kokkos::OpenMP,
+                           Kokkos::Experimental::ScatterDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterNonAtomic };
 };
 #endif
@@ -127,11 +126,13 @@ struct DefaultDuplication<Kokkos::Experimental::HPX> {
   enum : int { value = Kokkos::Experimental::ScatterDuplicated };
 };
 template <>
-struct DefaultContribution<Kokkos::Experimental::HPX, Kokkos::Experimental::ScatterNonDuplicated> {
+struct DefaultContribution<Kokkos::Experimental::HPX,
+                           Kokkos::Experimental::ScatterNonDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterAtomic };
 };
 template <>
-struct DefaultContribution<Kokkos::Experimental::HPX, Kokkos::Experimental::ScatterDuplicated> {
+struct DefaultContribution<Kokkos::Experimental::HPX,
+                           Kokkos::Experimental::ScatterDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterNonAtomic };
 };
 #endif
@@ -142,11 +143,13 @@ struct DefaultDuplication<Kokkos::Threads> {
   enum : int { value = Kokkos::Experimental::ScatterDuplicated };
 };
 template <>
-struct DefaultContribution<Kokkos::Threads, Kokkos::Experimental::ScatterNonDuplicated> {
+struct DefaultContribution<Kokkos::Threads,
+                           Kokkos::Experimental::ScatterNonDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterAtomic };
 };
 template <>
-struct DefaultContribution<Kokkos::Threads, Kokkos::Experimental::ScatterDuplicated> {
+struct DefaultContribution<Kokkos::Threads,
+                           Kokkos::Experimental::ScatterDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterNonAtomic };
 };
 #endif
@@ -157,313 +160,313 @@ struct DefaultDuplication<Kokkos::Cuda> {
   enum : int { value = Kokkos::Experimental::ScatterNonDuplicated };
 };
 template <>
-struct DefaultContribution<Kokkos::Cuda, Kokkos::Experimental::ScatterNonDuplicated> {
+struct DefaultContribution<Kokkos::Cuda,
+                           Kokkos::Experimental::ScatterNonDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterAtomic };
 };
 template <>
-struct DefaultContribution<Kokkos::Cuda, Kokkos::Experimental::ScatterDuplicated> {
+struct DefaultContribution<Kokkos::Cuda,
+                           Kokkos::Experimental::ScatterDuplicated> {
   enum : int { value = Kokkos::Experimental::ScatterAtomic };
 };
 #endif
 
-/* ScatterValue <Op=ScatterSum, contribution=ScatterNonAtomic> is the object returned by the access operator() of ScatterAccess,
-   This class inherits from the Sum<> reducer and it wraps join(dest, src) with convenient operator+=, etc. 
-   Note the addition of update(ValueType const& rhs) and reset()  so that all reducers can have common functions
-   See ReduceDuplicates and ResetDuplicates ) */
+/* ScatterValue <Op=ScatterSum, contribution=ScatterNonAtomic> is the object
+   returned by the access operator() of ScatterAccess, This class inherits from
+   the Sum<> reducer and it wraps join(dest, src) with convenient operator+=,
+   etc. Note the addition of update(ValueType const& rhs) and reset()  so that
+   all reducers can have common functions See ReduceDuplicates and
+   ResetDuplicates ) */
 template <typename ValueType, int Op, int contribution>
 struct ScatterValue;
 
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonAtomic> :
-  Sum<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Sum<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other) : 
-       Sum<ValueType,Kokkos::DefaultExecutionSpace>(other.reference())
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION void operator+=(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void operator-=(ValueType const& rhs) {
-      this->join( this->reference(), -rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterSum,
+                    Kokkos::Experimental::ScatterNonAtomic>
+    : Sum<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Sum<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other)
+      : Sum<ValueType, Kokkos::DefaultExecutionSpace>(other.reference()) {}
+  KOKKOS_FORCEINLINE_FUNCTION void operator+=(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void operator-=(ValueType const& rhs) {
+    this->join(this->reference(), -rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
-/* ScatterValue <Op=ScatterSum, contribution=ScatterAtomic> is the object returned by the access operator() 
- * of ScatterAccess, similar to that returned by an Atomic View, it wraps Kokkos::atomic_add with convenient
-   operator+=, etc. This version also has the update(rhs) and reset() functions. */
+/* ScatterValue <Op=ScatterSum, contribution=ScatterAtomic> is the object
+ returned by the access operator()
+ * of ScatterAccess, similar to that returned by an Atomic View, it wraps
+ Kokkos::atomic_add with convenient operator+=, etc. This version also has the
+ update(rhs) and reset() functions. */
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterAtomic> :
-  Sum<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Sum<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-
-    KOKKOS_FORCEINLINE_FUNCTION void operator+=(ValueType const& rhs) {
-     this->join(this->reference(), rhs);
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void operator-=(ValueType const& rhs) {
-      this->join(this->reference(), -rhs);
-    }
-    
-    KOKKOS_INLINE_FUNCTION
-    void join(ValueType& dest, const ValueType& src)  const {
-      Kokkos::atomic_add(&dest, src);
-    }
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterSum,
+                    Kokkos::Experimental::ScatterAtomic>
+    : Sum<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Sum<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+
+  KOKKOS_FORCEINLINE_FUNCTION void operator+=(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void operator-=(ValueType const& rhs) {
+    this->join(this->reference(), -rhs);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void join(volatile ValueType& dest, const volatile ValueType& src) const {
-      Kokkos::atomic_add(&dest, src);
-    } 
+  KOKKOS_INLINE_FUNCTION
+  void join(ValueType& dest, const ValueType& src) const {
+    Kokkos::atomic_add(&dest, src);
+  }
 
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(volatile ValueType& dest, const volatile ValueType& src) const {
+    Kokkos::atomic_add(&dest, src);
+  }
 
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
-/* ScatterValue <Op=ScatterProd, contribution=ScatterNonAtomic> is the object returned by the access operator() of ScatterAccess,
-   This class inherits from the Prod<> reducer and it wraps join(dest, src) with convenient operator*=, etc. 
-   Note the addition of update(ValueType const& rhs) and reset()  so that all reducers can have common functions
-   See ReduceDuplicates and ResetDuplicates ) */
+/* ScatterValue <Op=ScatterProd, contribution=ScatterNonAtomic> is the object
+   returned by the access operator() of ScatterAccess, This class inherits from
+   the Prod<> reducer and it wraps join(dest, src) with convenient operator*=,
+   etc. Note the addition of update(ValueType const& rhs) and reset()  so that
+   all reducers can have common functions See ReduceDuplicates and
+   ResetDuplicates ) */
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterProd, Kokkos::Experimental::ScatterNonAtomic> :
-  Prod<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Prod<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other) : 
-       Prod<ValueType,Kokkos::DefaultExecutionSpace>(other.reference())
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION void operator*=(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void operator/=(ValueType const& rhs) {
-      this->join( this->reference(), static_cast<ValueType>(1)/rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterProd,
+                    Kokkos::Experimental::ScatterNonAtomic>
+    : Prod<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Prod<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other)
+      : Prod<ValueType, Kokkos::DefaultExecutionSpace>(other.reference()) {}
+  KOKKOS_FORCEINLINE_FUNCTION void operator*=(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void operator/=(ValueType const& rhs) {
+    this->join(this->reference(), static_cast<ValueType>(1) / rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
-/* ScatterValue <Op=ScatterProd, contribution=ScatterAtomic> is the object returned by the access operator() 
- * of ScatterAccess, similar to that returned by an Atomic View, it wraps and atomic_prod with convenient
-   operator*=, etc. atomic_prod uses the atomic_compare_exchange. This version also has the update(rhs) and reset() functions. */
+/* ScatterValue <Op=ScatterProd, contribution=ScatterAtomic> is the object
+ returned by the access operator()
+ * of ScatterAccess, similar to that returned by an Atomic View, it wraps and
+ atomic_prod with convenient operator*=, etc. atomic_prod uses the
+ atomic_compare_exchange. This version also has the update(rhs) and reset()
+ functions. */
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterProd, Kokkos::Experimental::ScatterAtomic> :
-  Prod<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Prod<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-
-    KOKKOS_FORCEINLINE_FUNCTION void operator*=(ValueType const& rhs) {
-     this->join(this->reference(), rhs);
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void operator/=(ValueType const& rhs) {
-      this->join(this->reference(), static_cast<ValueType>(1)/rhs);
-    }
-
-    KOKKOS_FORCEINLINE_FUNCTION 
-    void atomic_prod(ValueType & dest, const ValueType& src) const {
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterProd,
+                    Kokkos::Experimental::ScatterAtomic>
+    : Prod<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Prod<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+
+  KOKKOS_FORCEINLINE_FUNCTION void operator*=(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void operator/=(ValueType const& rhs) {
+    this->join(this->reference(), static_cast<ValueType>(1) / rhs);
+  }
 
-        bool success = false;
-        while(!success) {
-            ValueType dest_old = dest;
-            ValueType dest_new = dest_old * src;
-            dest_new = Kokkos::atomic_compare_exchange<ValueType>(&dest,dest_old,dest_new);
-            success = ( (dest_new - dest_old)/dest_old <= 1e-15 );
-        }
-    }
-    
-    KOKKOS_INLINE_FUNCTION
-    void join(ValueType& dest, const ValueType& src)  const {
-      atomic_prod(dest, src);
+  KOKKOS_FORCEINLINE_FUNCTION
+  void atomic_prod(ValueType& dest, const ValueType& src) const {
+    bool success = false;
+    while (!success) {
+      ValueType dest_old = dest;
+      ValueType dest_new = dest_old * src;
+      dest_new =
+          Kokkos::atomic_compare_exchange<ValueType>(&dest, dest_old, dest_new);
+      success = ((dest_new - dest_old) / dest_old <= 1e-15);
     }
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void join(volatile ValueType& dest, const volatile ValueType& src) const {
-      atomic_prod(dest, src);
-    } 
+  KOKKOS_INLINE_FUNCTION
+  void join(ValueType& dest, const ValueType& src) const {
+    atomic_prod(dest, src);
+  }
 
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(volatile ValueType& dest, const volatile ValueType& src) const {
+    atomic_prod(dest, src);
+  }
 
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
-/* ScatterValue <Op=ScatterMin, contribution=ScatterNonAtomic> is the object returned by the access operator() of ScatterAccess,
-   This class inherits from the Min<> reducer and it wraps join(dest, src) with convenient update(rhs). 
-   Note the addition of update(ValueType const& rhs) and reset() are so that all reducers can have a common update function
-   See ReduceDuplicates and ResetDuplicates ) */
+/* ScatterValue <Op=ScatterMin, contribution=ScatterNonAtomic> is the object
+   returned by the access operator() of ScatterAccess, This class inherits from
+   the Min<> reducer and it wraps join(dest, src) with convenient update(rhs).
+   Note the addition of update(ValueType const& rhs) and reset() are so that all
+   reducers can have a common update function See ReduceDuplicates and
+   ResetDuplicates ) */
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMin, Kokkos::Experimental::ScatterNonAtomic> :
-  Min<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Min<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other) : 
-       Min<ValueType,Kokkos::DefaultExecutionSpace>(other.reference())
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMin,
+                    Kokkos::Experimental::ScatterNonAtomic>
+    : Min<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Min<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other)
+      : Min<ValueType, Kokkos::DefaultExecutionSpace>(other.reference()) {}
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
-/* ScatterValue <Op=ScatterMin, contribution=ScatterAtomic> is the object returned by the access operator() 
- * of ScatterAccess, similar to that returned by an Atomic View, it wraps and atomic_min with the update(rhs)
-   function. atomic_min uses the atomic_compare_exchange. This version also has the reset() function */
+/* ScatterValue <Op=ScatterMin, contribution=ScatterAtomic> is the object
+ returned by the access operator()
+ * of ScatterAccess, similar to that returned by an Atomic View, it wraps and
+ atomic_min with the update(rhs) function. atomic_min uses the
+ atomic_compare_exchange. This version also has the reset() function */
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMin, Kokkos::Experimental::ScatterAtomic> :
-  Min<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Min<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-
-    KOKKOS_FORCEINLINE_FUNCTION 
-    void atomic_min(ValueType & dest, const ValueType& src) const {
-
-        bool success = false;
-        while(!success) {
-            ValueType dest_old = dest;
-            ValueType dest_new = ( dest_old > src ) ? src : dest_old;
-            dest_new = Kokkos::atomic_compare_exchange<ValueType>(&dest,dest_old,dest_new);
-            success = ( (dest_new - dest_old)/dest_old <= 1e-15 );
-        }
-    }
-    
-    KOKKOS_INLINE_FUNCTION
-    void join(ValueType& dest, const ValueType& src)  const {
-      atomic_min(dest, src);
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMin,
+                    Kokkos::Experimental::ScatterAtomic>
+    : Min<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Min<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+
+  KOKKOS_FORCEINLINE_FUNCTION
+  void atomic_min(ValueType& dest, const ValueType& src) const {
+    bool success = false;
+    while (!success) {
+      ValueType dest_old = dest;
+      ValueType dest_new = (dest_old > src) ? src : dest_old;
+      dest_new =
+          Kokkos::atomic_compare_exchange<ValueType>(&dest, dest_old, dest_new);
+      success = ((dest_new - dest_old) / dest_old <= 1e-15);
     }
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void join(volatile ValueType& dest, const volatile ValueType& src) const {
-      atomic_min(dest, src);
-    } 
+  KOKKOS_INLINE_FUNCTION
+  void join(ValueType& dest, const ValueType& src) const {
+    atomic_min(dest, src);
+  }
 
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(volatile ValueType& dest, const volatile ValueType& src) const {
+    atomic_min(dest, src);
+  }
 
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
-/* ScatterValue <Op=ScatterMax, contribution=ScatterNonAtomic> is the object returned by the access operataor() of ScatterAccess,
-   This class inherits from the Max<> reducer and it wraps join(dest, src) with convenient update(rhs). 
-   Note the addition of update(ValueType const& rhs) and reset() are so that all reducers can have a common update function
-   See ReduceDuplicates and ResetDuplicates ) */
+/* ScatterValue <Op=ScatterMax, contribution=ScatterNonAtomic> is the object
+   returned by the access operataor() of ScatterAccess, This class inherits from
+   the Max<> reducer and it wraps join(dest, src) with convenient update(rhs).
+   Note the addition of update(ValueType const& rhs) and reset() are so that all
+   reducers can have a common update function See ReduceDuplicates and
+   ResetDuplicates ) */
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMax, Kokkos::Experimental::ScatterNonAtomic> :
-  Max<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Max<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other) : 
-       Max<ValueType,Kokkos::DefaultExecutionSpace>(other.reference())
-    {}
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMax,
+                    Kokkos::Experimental::ScatterNonAtomic>
+    : Max<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Max<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ScatterValue&& other)
+      : Max<ValueType, Kokkos::DefaultExecutionSpace>(other.reference()) {}
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
-/* ScatterValue <Op=ScatterMax, contribution=ScatterAtomic> is the object returned by the access operator() 
- * of ScatterAccess, similar to that returned by an Atomic View, it wraps and atomic_max with the update(rhs)
-   function. atomic_max uses the atomic_compare_exchange. This version also has the reset() function  */
+/* ScatterValue <Op=ScatterMax, contribution=ScatterAtomic> is the object
+ returned by the access operator()
+ * of ScatterAccess, similar to that returned by an Atomic View, it wraps and
+ atomic_max with the update(rhs) function. atomic_max uses the
+ atomic_compare_exchange. This version also has the reset() function  */
 template <typename ValueType>
-struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMax, Kokkos::Experimental::ScatterAtomic> :
-  Max<ValueType,Kokkos::DefaultExecutionSpace> {
-  public:
-    KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in) : 
-       Max<ValueType,Kokkos::DefaultExecutionSpace>(value_in)
-    {}
-
-    KOKKOS_FORCEINLINE_FUNCTION 
-    void atomic_max(ValueType & dest, const ValueType& src) const {
-
-        bool success = false;
-        while(!success) {
-            ValueType dest_old = dest;
-            ValueType dest_new = ( dest_old < src ) ? src : dest_old;
-            dest_new = Kokkos::atomic_compare_exchange<ValueType>(&dest,dest_old,dest_new);
-            success = ( (dest_new - dest_old)/dest_old <= 1e-15 );
-        }
-    }
-    
-    KOKKOS_INLINE_FUNCTION
-    void join(ValueType& dest, const ValueType& src)  const {
-      atomic_max(dest, src);
+struct ScatterValue<ValueType, Kokkos::Experimental::ScatterMax,
+                    Kokkos::Experimental::ScatterAtomic>
+    : Max<ValueType, Kokkos::DefaultExecutionSpace> {
+ public:
+  KOKKOS_FORCEINLINE_FUNCTION ScatterValue(ValueType& value_in)
+      : Max<ValueType, Kokkos::DefaultExecutionSpace>(value_in) {}
+
+  KOKKOS_FORCEINLINE_FUNCTION
+  void atomic_max(ValueType& dest, const ValueType& src) const {
+    bool success = false;
+    while (!success) {
+      ValueType dest_old = dest;
+      ValueType dest_new = (dest_old < src) ? src : dest_old;
+      dest_new =
+          Kokkos::atomic_compare_exchange<ValueType>(&dest, dest_old, dest_new);
+      success = ((dest_new - dest_old) / dest_old <= 1e-15);
     }
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void join(volatile ValueType& dest, const volatile ValueType& src) const {
-      atomic_max(dest, src);
-    } 
+  KOKKOS_INLINE_FUNCTION
+  void join(ValueType& dest, const ValueType& src) const {
+    atomic_max(dest, src);
+  }
 
-    KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
-      this->join( this->reference(), rhs );
-    }
-    KOKKOS_FORCEINLINE_FUNCTION void reset() {
-      this->init( this->reference() );
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(volatile ValueType& dest, const volatile ValueType& src) const {
+    atomic_max(dest, src);
+  }
 
+  KOKKOS_FORCEINLINE_FUNCTION void update(ValueType const& rhs) {
+    this->join(this->reference(), rhs);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION void reset() { this->init(this->reference()); }
 };
 
 /* DuplicatedDataType, given a View DataType, will create a new DataType
    that has a new runtime dimension which becomes the largest-stride dimension.
-   In the case of LayoutLeft, due to the limitation induced by the design of DataType
-   itself, it must convert any existing compile-time dimensions into runtime dimensions. */
+   In the case of LayoutLeft, due to the limitation induced by the design of
+   DataType itself, it must convert any existing compile-time dimensions into
+   runtime dimensions. */
 template <typename T, typename Layout>
 struct DuplicatedDataType;
 
 template <typename T>
 struct DuplicatedDataType<T, Kokkos::LayoutRight> {
-  typedef T* value_type; // For LayoutRight, add a star all the way on the left
+  typedef T* value_type;  // For LayoutRight, add a star all the way on the left
 };
 
 template <typename T, size_t N>
 struct DuplicatedDataType<T[N], Kokkos::LayoutRight> {
-  typedef typename DuplicatedDataType<T, Kokkos::LayoutRight>::value_type value_type[N];
+  typedef typename DuplicatedDataType<T, Kokkos::LayoutRight>::value_type
+      value_type[N];
 };
 
 template <typename T>
 struct DuplicatedDataType<T[], Kokkos::LayoutRight> {
-  typedef typename DuplicatedDataType<T, Kokkos::LayoutRight>::value_type value_type[];
+  typedef typename DuplicatedDataType<T, Kokkos::LayoutRight>::value_type
+      value_type[];
 };
 
 template <typename T>
 struct DuplicatedDataType<T*, Kokkos::LayoutRight> {
-  typedef typename DuplicatedDataType<T, Kokkos::LayoutRight>::value_type* value_type;
+  typedef typename DuplicatedDataType<T, Kokkos::LayoutRight>::value_type*
+      value_type;
 };
 
 template <typename T>
@@ -473,69 +476,63 @@ struct DuplicatedDataType<T, Kokkos::LayoutLeft> {
 
 template <typename T, size_t N>
 struct DuplicatedDataType<T[N], Kokkos::LayoutLeft> {
-  typedef typename DuplicatedDataType<T, Kokkos::LayoutLeft>::value_type* value_type;
+  typedef typename DuplicatedDataType<T, Kokkos::LayoutLeft>::value_type*
+      value_type;
 };
 
 template <typename T>
 struct DuplicatedDataType<T[], Kokkos::LayoutLeft> {
-  typedef typename DuplicatedDataType<T, Kokkos::LayoutLeft>::value_type* value_type;
+  typedef typename DuplicatedDataType<T, Kokkos::LayoutLeft>::value_type*
+      value_type;
 };
 
 template <typename T>
 struct DuplicatedDataType<T*, Kokkos::LayoutLeft> {
-  typedef typename DuplicatedDataType<T, Kokkos::LayoutLeft>::value_type* value_type;
+  typedef typename DuplicatedDataType<T, Kokkos::LayoutLeft>::value_type*
+      value_type;
 };
 
 /* Insert integer argument pack into array */
 
-template<class T>
+template <class T>
 void args_to_array(size_t* array, int pos, T dim0) {
   array[pos] = dim0;
 }
-template<class T, class ... Dims>
-void args_to_array(size_t* array, int pos, T dim0, Dims ... dims) {
+template <class T, class... Dims>
+void args_to_array(size_t* array, int pos, T dim0, Dims... dims) {
   array[pos] = dim0;
-  args_to_array(array,pos+1,dims...);
+  args_to_array(array, pos + 1, dims...);
 }
 
 /* Slice is just responsible for stuffing the correct number of Kokkos::ALL
    arguments on the correct side of the index in a call to subview() to get a
    subview where the index specified is the largest-stride one. */
-template <typename Layout, int rank, typename V, typename ... Args>
+template <typename Layout, int rank, typename V, typename... Args>
 struct Slice {
   typedef Slice<Layout, rank - 1, V, Kokkos::Impl::ALL_t, Args...> next;
   typedef typename next::value_type value_type;
 
-  static
-  value_type get(V const& src, const size_t i, Args ... args) {
+  static value_type get(V const& src, const size_t i, Args... args) {
     return next::get(src, i, Kokkos::ALL, args...);
   }
 };
 
-template <typename V, typename ... Args>
+template <typename V, typename... Args>
 struct Slice<Kokkos::LayoutRight, 1, V, Args...> {
-  typedef typename Kokkos::Impl::ViewMapping
-                          < void
-                          , V
-                          , const size_t
-                          , Args ...
-                          >::type value_type;
-  static
-  value_type get(V const& src, const size_t i, Args ... args) {
+  typedef
+      typename Kokkos::Impl::ViewMapping<void, V, const size_t, Args...>::type
+          value_type;
+  static value_type get(V const& src, const size_t i, Args... args) {
     return Kokkos::subview(src, i, args...);
   }
 };
 
-template <typename V, typename ... Args>
+template <typename V, typename... Args>
 struct Slice<Kokkos::LayoutLeft, 1, V, Args...> {
-  typedef typename Kokkos::Impl::ViewMapping
-                          < void
-                          , V
-                          , Args ...
-                          , const size_t
-                          >::type value_type;
-  static
-  value_type get(V const& src, const size_t i, Args ... args) {
+  typedef
+      typename Kokkos::Impl::ViewMapping<void, V, Args..., const size_t>::type
+          value_type;
+  static value_type get(V const& src, const size_t i, Args... args) {
     return Kokkos::subview(src, args..., i);
   }
 };
@@ -551,51 +548,49 @@ struct ReduceDuplicatesBase {
   size_t stride;
   size_t start;
   size_t n;
-  ReduceDuplicatesBase(ValueType const* src_in, ValueType* dest_in, size_t stride_in, size_t start_in, size_t n_in, std::string const& name)
-    : src(src_in)
-    , dst(dest_in)
-    , stride(stride_in)
-    , start(start_in)
-    , n(n_in)
-  {
+  ReduceDuplicatesBase(ValueType const* src_in, ValueType* dest_in,
+                       size_t stride_in, size_t start_in, size_t n_in,
+                       std::string const& name)
+      : src(src_in), dst(dest_in), stride(stride_in), start(start_in), n(n_in) {
 #if defined(KOKKOS_ENABLE_PROFILING)
     uint64_t kpID = 0;
-    if(Kokkos::Profiling::profileLibraryLoaded()) {
-      Kokkos::Profiling::beginParallelFor(std::string("reduce_") + name, 0, &kpID);
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::beginParallelFor(std::string("reduce_") + name, 0,
+                                          &kpID);
     }
 #endif
     typedef RangePolicy<ExecSpace, size_t> policy_type;
     typedef Kokkos::Impl::ParallelFor<Derived, policy_type> closure_type;
-    const closure_type closure(*(static_cast<Derived*>(this)), policy_type(0, stride));
+    const closure_type closure(*(static_cast<Derived*>(this)),
+                               policy_type(0, stride));
     closure.execute();
 #if defined(KOKKOS_ENABLE_PROFILING)
-    if(Kokkos::Profiling::profileLibraryLoaded()) {
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
       Kokkos::Profiling::endParallelFor(kpID);
     }
 #endif
   }
 };
 
-/* ReduceDuplicates -- Perform reduction on destination array using strided source 
- *    Use ScatterValue<> specific to operation to wrap destination array so that
- *    the reduction operation can be accessed via the update(rhs) function */
+/* ReduceDuplicates -- Perform reduction on destination array using strided
+ * source Use ScatterValue<> specific to operation to wrap destination array so
+ * that the reduction operation can be accessed via the update(rhs) function */
 template <typename ExecSpace, typename ValueType, int Op>
-struct ReduceDuplicates :
-  public ReduceDuplicatesBase<ExecSpace, ValueType, Op>
-{
+struct ReduceDuplicates
+    : public ReduceDuplicatesBase<ExecSpace, ValueType, Op> {
   typedef ReduceDuplicatesBase<ExecSpace, ValueType, Op> Base;
-  ReduceDuplicates(ValueType const* src_in, ValueType* dst_in, size_t stride_in, size_t start_in, size_t n_in, std::string const& name):
-    Base(src_in, dst_in, stride_in, start_in, n_in, name)
-  {}
+  ReduceDuplicates(ValueType const* src_in, ValueType* dst_in, size_t stride_in,
+                   size_t start_in, size_t n_in, std::string const& name)
+      : Base(src_in, dst_in, stride_in, start_in, n_in, name) {}
   KOKKOS_FORCEINLINE_FUNCTION void operator()(size_t i) const {
     for (size_t j = Base::start; j < Base::n; ++j) {
-      ScatterValue<ValueType, Op, Kokkos::Experimental::ScatterNonAtomic> sv(Base::dst[i]);
-      sv.update( Base::src[i + Base::stride * j] );
+      ScatterValue<ValueType, Op, Kokkos::Experimental::ScatterNonAtomic> sv(
+          Base::dst[i]);
+      sv.update(Base::src[i + Base::stride * j]);
     }
   }
 };
 
-
 template <typename ExecSpace, typename ValueType, int Op>
 struct ResetDuplicates;
 
@@ -603,21 +598,23 @@ template <typename ExecSpace, typename ValueType, int Op>
 struct ResetDuplicatesBase {
   typedef ResetDuplicates<ExecSpace, ValueType, Op> Derived;
   ValueType* data;
-  ResetDuplicatesBase(ValueType* data_in, size_t size_in, std::string const& name)
-    : data(data_in)
-  {
+  ResetDuplicatesBase(ValueType* data_in, size_t size_in,
+                      std::string const& name)
+      : data(data_in) {
 #if defined(KOKKOS_ENABLE_PROFILING)
     uint64_t kpID = 0;
-    if(Kokkos::Profiling::profileLibraryLoaded()) {
-      Kokkos::Profiling::beginParallelFor(std::string("reduce_") + name, 0, &kpID);
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::beginParallelFor(std::string("reduce_") + name, 0,
+                                          &kpID);
     }
 #endif
     typedef RangePolicy<ExecSpace, size_t> policy_type;
     typedef Kokkos::Impl::ParallelFor<Derived, policy_type> closure_type;
-    const closure_type closure(*(static_cast<Derived*>(this)), policy_type(0, size_in));
+    const closure_type closure(*(static_cast<Derived*>(this)),
+                               policy_type(0, size_in));
     closure.execute();
 #if defined(KOKKOS_ENABLE_PROFILING)
-    if(Kokkos::Profiling::profileLibraryLoaded()) {
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
       Kokkos::Profiling::endParallelFor(kpID);
     }
 #endif
@@ -628,606 +625,599 @@ struct ResetDuplicatesBase {
  *    Use ScatterValue<> specific to operation to wrap destination array so that
  *    the reset operation can be accessed via the reset() function */
 template <typename ExecSpace, typename ValueType, int Op>
-struct ResetDuplicates :
-  public ResetDuplicatesBase<ExecSpace, ValueType, Op>
-{
+struct ResetDuplicates : public ResetDuplicatesBase<ExecSpace, ValueType, Op> {
   typedef ResetDuplicatesBase<ExecSpace, ValueType, Op> Base;
-  ResetDuplicates(ValueType* data_in, size_t size_in, std::string const& name):
-    Base(data_in, size_in, name)
-  {}
+  ResetDuplicates(ValueType* data_in, size_t size_in, std::string const& name)
+      : Base(data_in, size_in, name) {}
   KOKKOS_FORCEINLINE_FUNCTION void operator()(size_t i) const {
-    ScatterValue<ValueType, Op, Kokkos::Experimental::ScatterNonAtomic> sv(Base::data[i]);
+    ScatterValue<ValueType, Op, Kokkos::Experimental::ScatterNonAtomic> sv(
+        Base::data[i]);
     sv.reset();
   }
 };
 
-
-}}} // Kokkos::Impl::Experimental
+}  // namespace Experimental
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Experimental {
 
-template <typename DataType
-         ,typename Layout = Kokkos::DefaultExecutionSpace::array_layout
-         ,typename ExecSpace = Kokkos::DefaultExecutionSpace
-         ,int Op = ScatterSum
-         ,int duplication = Kokkos::Impl::Experimental::DefaultDuplication<ExecSpace>::value
-         ,int contribution = Kokkos::Impl::Experimental::DefaultContribution<ExecSpace, duplication>::value
-         >
+template <typename DataType,
+          typename Layout     = Kokkos::DefaultExecutionSpace::array_layout,
+          typename DeviceType = Kokkos::DefaultExecutionSpace,
+          int Op              = ScatterSum,
+          int duplication     = Kokkos::Impl::Experimental::DefaultDuplication<
+              typename DeviceType::execution_space>::value,
+          int contribution = Kokkos::Impl::Experimental::DefaultContribution<
+              typename DeviceType::execution_space, duplication>::value>
 class ScatterView;
 
-template <typename DataType
-         ,int Op
-         ,typename ExecSpace
-         ,typename Layout
-         ,int duplication
-         ,int contribution
-         ,int override_contribution
-         >
+template <typename DataType, int Op, typename DeviceType, typename Layout,
+          int duplication, int contribution, int override_contribution>
 class ScatterAccess;
 
 // non-duplicated implementation
-template <typename DataType
-         ,int Op
-         ,typename ExecSpace
-         ,typename Layout
-         ,int contribution
-         >
-class ScatterView<DataType
-                   ,Layout
-                   ,ExecSpace
-                   ,Op
-                   ,ScatterNonDuplicated
-                   ,contribution>
-{
-public:
-  typedef Kokkos::View<DataType, Layout, ExecSpace> original_view_type;
+template <typename DataType, int Op, typename DeviceType, typename Layout,
+          int contribution>
+class ScatterView<DataType, Layout, DeviceType, Op, ScatterNonDuplicated,
+                  contribution> {
+ public:
+  using execution_space = typename DeviceType::execution_space;
+  using memory_space    = typename DeviceType::memory_space;
+  using device_type     = Kokkos::Device<execution_space, memory_space>;
+  typedef Kokkos::View<DataType, Layout, device_type> original_view_type;
   typedef typename original_view_type::value_type original_value_type;
   typedef typename original_view_type::reference_type original_reference_type;
-  friend class ScatterAccess<DataType, Op, ExecSpace, Layout, ScatterNonDuplicated, contribution, ScatterNonAtomic>;
-  friend class ScatterAccess<DataType, Op, ExecSpace, Layout, ScatterNonDuplicated, contribution, ScatterAtomic>;
+  friend class ScatterAccess<DataType, Op, DeviceType, Layout,
+                             ScatterNonDuplicated, contribution,
+                             ScatterNonAtomic>;
+  friend class ScatterAccess<DataType, Op, DeviceType, Layout,
+                             ScatterNonDuplicated, contribution, ScatterAtomic>;
+  template <class, class, class, int, int, int>
+  friend class ScatterView;
 
-  ScatterView()
-  {
-  }
+  ScatterView() = default;
 
-  template <typename RT, typename ... RP>
+  template <typename RT, typename... RP>
   ScatterView(View<RT, RP...> const& original_view)
-  : internal_view(original_view)
-  {
-  }
-
-  template <typename ... Dims>
-  ScatterView(std::string const& name, Dims ... dims)
-  : internal_view(name, dims ...)
-  {
+      : internal_view(original_view) {}
+
+  template <typename... Dims>
+  ScatterView(std::string const& name, Dims... dims)
+      : internal_view(name, dims...) {}
+
+  template <typename OtherDataType, typename OtherDeviceType>
+  KOKKOS_FUNCTION ScatterView(
+      const ScatterView<OtherDataType, Layout, OtherDeviceType, Op,
+                        ScatterNonDuplicated, contribution>& other_view)
+      : internal_view(other_view.internal_view) {}
+
+  template <typename OtherDataType, typename OtherDeviceType>
+  KOKKOS_FUNCTION void operator=(
+      const ScatterView<OtherDataType, Layout, OtherDeviceType, Op,
+                        ScatterNonDuplicated, contribution>& other_view) {
+    internal_view = other_view.internal_view;
   }
 
   template <int override_contrib = contribution>
   KOKKOS_FORCEINLINE_FUNCTION
-  ScatterAccess<DataType, Op, ExecSpace, Layout, ScatterNonDuplicated, contribution, override_contrib>
-  access() const {
-    return ScatterAccess<DataType, Op, ExecSpace, Layout, ScatterNonDuplicated, contribution, override_contrib>{*this};
+      ScatterAccess<DataType, Op, DeviceType, Layout, ScatterNonDuplicated,
+                    contribution, override_contrib>
+      access() const {
+    return ScatterAccess<DataType, Op, DeviceType, Layout, ScatterNonDuplicated,
+                         contribution, override_contrib>(*this);
   }
 
-  original_view_type subview() const {
-    return internal_view;
-  }
+  original_view_type subview() const { return internal_view; }
 
-  template <typename DT, typename ... RP>
-  void contribute_into(View<DT, RP...> const& dest) const
-  {
+  template <typename DT, typename... RP>
+  void contribute_into(View<DT, RP...> const& dest) const {
     typedef View<DT, RP...> dest_type;
-    static_assert(std::is_same<
-        typename dest_type::array_layout,
-        Layout>::value,
-        "ScatterView contribute destination has different layout");
-    static_assert(Kokkos::Impl::VerifyExecutionCanAccessMemorySpace<
-        typename ExecSpace::memory_space,
-        typename dest_type::memory_space>::value,
+    static_assert(std::is_same<typename dest_type::array_layout, Layout>::value,
+                  "ScatterView contribute destination has different layout");
+    static_assert(
+        Kokkos::Impl::VerifyExecutionCanAccessMemorySpace<
+            memory_space, typename dest_type::memory_space>::value,
         "ScatterView contribute destination memory space not accessible");
     if (dest.data() == internal_view.data()) return;
-    Kokkos::Impl::Experimental::ReduceDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data(),
-        dest.data(),
-        0,
-        0,
-        1,
-        internal_view.label());
+    Kokkos::Impl::Experimental::ReduceDuplicates<execution_space,
+                                                 original_value_type, Op>(
+        internal_view.data(), dest.data(), 0, 0, 1, internal_view.label());
   }
 
   void reset() {
-    Kokkos::Impl::Experimental::ResetDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data(),
-        internal_view.size(),
-        internal_view.label());
+    Kokkos::Impl::Experimental::ResetDuplicates<execution_space,
+                                                original_value_type, Op>(
+        internal_view.data(), internal_view.size(), internal_view.label());
   }
-  template <typename DT, typename ... RP>
+  template <typename DT, typename... RP>
   void reset_except(View<DT, RP...> const& view) {
     if (view.data() != internal_view.data()) reset();
   }
 
-  void resize(const size_t n0 = 0,
-           const size_t n1 = 0,
-           const size_t n2 = 0,
-           const size_t n3 = 0,
-           const size_t n4 = 0,
-           const size_t n5 = 0,
-           const size_t n6 = 0,
-           const size_t n7 = 0) {
-    ::Kokkos::resize(internal_view,n0,n1,n2,n3,n4,n5,n6,n7);
+  void resize(const size_t n0 = 0, const size_t n1 = 0, const size_t n2 = 0,
+              const size_t n3 = 0, const size_t n4 = 0, const size_t n5 = 0,
+              const size_t n6 = 0, const size_t n7 = 0) {
+    ::Kokkos::resize(internal_view, n0, n1, n2, n3, n4, n5, n6, n7);
   }
 
-  void realloc(const size_t n0 = 0,
-           const size_t n1 = 0,
-           const size_t n2 = 0,
-           const size_t n3 = 0,
-           const size_t n4 = 0,
-           const size_t n5 = 0,
-           const size_t n6 = 0,
-           const size_t n7 = 0) {
-    ::Kokkos::realloc(internal_view,n0,n1,n2,n3,n4,n5,n6,n7);
+  void realloc(const size_t n0 = 0, const size_t n1 = 0, const size_t n2 = 0,
+               const size_t n3 = 0, const size_t n4 = 0, const size_t n5 = 0,
+               const size_t n6 = 0, const size_t n7 = 0) {
+    ::Kokkos::realloc(internal_view, n0, n1, n2, n3, n4, n5, n6, n7);
   }
 
-protected:
-  template <typename ... Args>
-  KOKKOS_FORCEINLINE_FUNCTION
-  original_reference_type at(Args ... args) const {
+ protected:
+  template <typename... Args>
+  KOKKOS_FORCEINLINE_FUNCTION original_reference_type at(Args... args) const {
     return internal_view(args...);
   }
-private:
+
+ private:
   typedef original_view_type internal_view_type;
   internal_view_type internal_view;
 };
 
-template <typename DataType
-         ,int Op
-         ,typename ExecSpace
-         ,typename Layout
-         ,int contribution
-         ,int override_contribution
-         >
-class ScatterAccess<DataType
-                   ,Op
-                   ,ExecSpace
-                   ,Layout
-                   ,ScatterNonDuplicated
-                   ,contribution
-                   ,override_contribution>
-{
-public:
-  typedef ScatterView<DataType, Layout, ExecSpace, Op, ScatterNonDuplicated, contribution> view_type;
+template <typename DataType, int Op, typename DeviceType, typename Layout,
+          int contribution, int override_contribution>
+class ScatterAccess<DataType, Op, DeviceType, Layout, ScatterNonDuplicated,
+                    contribution, override_contribution> {
+ public:
+  typedef ScatterView<DataType, Layout, DeviceType, Op, ScatterNonDuplicated,
+                      contribution>
+      view_type;
   typedef typename view_type::original_value_type original_value_type;
-  typedef Kokkos::Impl::Experimental::ScatterValue<
-      original_value_type, Op, override_contribution> value_type;
+  typedef Kokkos::Impl::Experimental::ScatterValue<original_value_type, Op,
+                                                   override_contribution>
+      value_type;
 
   KOKKOS_INLINE_FUNCTION
-  ScatterAccess() :
-    view(view_type())  {
-  }
+  ScatterAccess() : view(view_type()) {}
 
   KOKKOS_INLINE_FUNCTION
-  ScatterAccess(view_type const& view_in)
-    : view(view_in)
-  {
-  }
+  ScatterAccess(view_type const& view_in) : view(view_in) {}
 
+//  KOKKOS_DEFAULTED_FUNCTION
+//  ~ScatterAccess() = default;
   KOKKOS_INLINE_FUNCTION
   ~ScatterAccess()
   {
   }
 
-  template <typename ... Args>
-  KOKKOS_FORCEINLINE_FUNCTION
-  value_type operator()(Args ... args) const {
+  template <typename... Args>
+  KOKKOS_FORCEINLINE_FUNCTION value_type operator()(Args... args) const {
     return view.at(args...);
   }
 
   template <typename Arg>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<view_type::original_view_type::rank == 1 &&
-  std::is_integral<Arg>::value, value_type>::type
-  operator[](Arg arg) const {
+      typename std::enable_if<view_type::original_view_type::rank == 1 &&
+                                  std::is_integral<Arg>::value,
+                              value_type>::type
+      operator[](Arg arg) const {
     return view.at(arg);
   }
 
-private:
+ private:
   view_type const& view;
 };
 
 // duplicated implementation
-// LayoutLeft and LayoutRight are different enough that we'll just specialize each
-
-template <typename DataType
-         ,int Op
-         ,typename ExecSpace
-         ,int contribution
-         >
-class ScatterView<DataType
-                   ,Kokkos::LayoutRight
-                   ,ExecSpace
-                   ,Op
-                   ,ScatterDuplicated
-                   ,contribution>
-{
-public:
-  typedef Kokkos::View<DataType, Kokkos::LayoutRight, ExecSpace> original_view_type;
+// LayoutLeft and LayoutRight are different enough that we'll just specialize
+// each
+
+template <typename DataType, int Op, typename DeviceType, int contribution>
+class ScatterView<DataType, Kokkos::LayoutRight, DeviceType, Op,
+                  ScatterDuplicated, contribution> {
+ public:
+  using execution_space = typename DeviceType::execution_space;
+  using memory_space    = typename DeviceType::memory_space;
+  using device_type     = Kokkos::Device<execution_space, memory_space>;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, device_type>
+      original_view_type;
   typedef typename original_view_type::value_type original_value_type;
   typedef typename original_view_type::reference_type original_reference_type;
-  friend class ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutRight, ScatterDuplicated, contribution, ScatterNonAtomic>;
-  friend class ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutRight, ScatterDuplicated, contribution, ScatterAtomic>;
-  typedef typename Kokkos::Impl::Experimental::DuplicatedDataType<DataType, Kokkos::LayoutRight> data_type_info;
+  friend class ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutRight,
+                             ScatterDuplicated, contribution, ScatterNonAtomic>;
+  friend class ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutRight,
+                             ScatterDuplicated, contribution, ScatterAtomic>;
+  template <class, class, class, int, int, int>
+  friend class ScatterView;
+
+  typedef typename Kokkos::Impl::Experimental::DuplicatedDataType<
+      DataType, Kokkos::LayoutRight>
+      data_type_info;
   typedef typename data_type_info::value_type internal_data_type;
-  typedef Kokkos::View<internal_data_type, Kokkos::LayoutRight, ExecSpace> internal_view_type;
-
-  ScatterView()
-  {
+  typedef Kokkos::View<internal_data_type, Kokkos::LayoutRight, device_type>
+      internal_view_type;
+
+  ScatterView() = default;
+
+  template <typename OtherDataType, typename OtherDeviceType>
+  KOKKOS_FUNCTION ScatterView(
+      const ScatterView<OtherDataType, Kokkos::LayoutRight, OtherDeviceType, Op,
+                        ScatterDuplicated, contribution>& other_view)
+      : unique_token(other_view.unique_token),
+        internal_view(other_view.internal_view) {}
+
+  template <typename OtherDataType, typename OtherDeviceType>
+  KOKKOS_FUNCTION void operator=(
+      const ScatterView<OtherDataType, Kokkos::LayoutRight, OtherDeviceType, Op,
+                        ScatterDuplicated, contribution>& other_view) {
+    unique_token  = other_view.unique_token;
+    internal_view = other_view.internal_view;
   }
 
-  template <typename RT, typename ... RP >
+  template <typename RT, typename... RP>
   ScatterView(View<RT, RP...> const& original_view)
-  : unique_token()
-  , internal_view(Kokkos::ViewAllocateWithoutInitializing(
-                    std::string("duplicated_") + original_view.label()),
-                  unique_token.size(),
+      : unique_token(),
+        internal_view(Kokkos::ViewAllocateWithoutInitializing(
+                          std::string("duplicated_") + original_view.label()),
+                      unique_token.size(),
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-                  original_view.extent(0),
-                  original_view.extent(1),
-                  original_view.extent(2),
-                  original_view.extent(3),
-                  original_view.extent(4),
-                  original_view.extent(5),
-                  original_view.extent(6) )
+                      original_view.extent(0), original_view.extent(1),
+                      original_view.extent(2), original_view.extent(3),
+                      original_view.extent(4), original_view.extent(5),
+                      original_view.extent(6))
 #else
-                  original_view.rank_dynamic > 0 ? original_view.extent(0): KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  original_view.rank_dynamic > 1 ? original_view.extent(1): KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  original_view.rank_dynamic > 2 ? original_view.extent(2): KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  original_view.rank_dynamic > 3 ? original_view.extent(3): KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  original_view.rank_dynamic > 4 ? original_view.extent(4): KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  original_view.rank_dynamic > 5 ? original_view.extent(5): KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-                  original_view.rank_dynamic > 6 ? original_view.extent(6): KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+                      original_view.rank_dynamic > 0
+                          ? original_view.extent(0)
+                          : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                      original_view.rank_dynamic > 1
+                          ? original_view.extent(1)
+                          : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                      original_view.rank_dynamic > 2
+                          ? original_view.extent(2)
+                          : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                      original_view.rank_dynamic > 3
+                          ? original_view.extent(3)
+                          : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                      original_view.rank_dynamic > 4
+                          ? original_view.extent(4)
+                          : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                      original_view.rank_dynamic > 5
+                          ? original_view.extent(5)
+                          : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                      original_view.rank_dynamic > 6
+                          ? original_view.extent(6)
+                          : KOKKOS_IMPL_CTOR_DEFAULT_ARG)
 
 #endif
   {
     reset();
   }
 
-  template <typename ... Dims>
-  ScatterView(std::string const& name, Dims ... dims)
-  : internal_view(Kokkos::ViewAllocateWithoutInitializing(name), unique_token.size(), dims ...)
-  {
+  template <typename... Dims>
+  ScatterView(std::string const& name, Dims... dims)
+      : internal_view(Kokkos::ViewAllocateWithoutInitializing(name),
+                      unique_token.size(), dims...) {
     reset();
   }
 
   template <int override_contribution = contribution>
   KOKKOS_FORCEINLINE_FUNCTION
-  ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutRight, ScatterDuplicated, contribution, override_contribution>
-  access() const {
-    return ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutRight, ScatterDuplicated, contribution, override_contribution>{*this};
+      ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutRight,
+                    ScatterDuplicated, contribution, override_contribution>
+      access() const {
+    return ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutRight,
+                         ScatterDuplicated, contribution,
+                         override_contribution>(*this);
   }
 
-  typename Kokkos::Impl::Experimental::Slice<
-    Kokkos::LayoutRight, internal_view_type::rank, internal_view_type>::value_type
-  subview() const
-  {
+  typename Kokkos::Impl::Experimental::Slice<Kokkos::LayoutRight,
+                                             internal_view_type::rank,
+                                             internal_view_type>::value_type
+  subview() const {
     return Kokkos::Impl::Experimental::Slice<
-      Kokkos::LayoutRight, internal_view_type::Rank, internal_view_type>::get(internal_view, 0);
+        Kokkos::LayoutRight, internal_view_type::Rank,
+        internal_view_type>::get(internal_view, 0);
   }
 
-  template <typename DT, typename ... RP>
-  void contribute_into(View<DT, RP...> const& dest) const
-  {
+  template <typename DT, typename... RP>
+  void contribute_into(View<DT, RP...> const& dest) const {
     typedef View<DT, RP...> dest_type;
-    static_assert(std::is_same<
-        typename dest_type::array_layout,
-        Kokkos::LayoutRight>::value,
-        "ScatterView deep_copy destination has different layout");
-    static_assert(Kokkos::Impl::VerifyExecutionCanAccessMemorySpace<
-        typename ExecSpace::memory_space,
-        typename dest_type::memory_space>::value,
+    static_assert(std::is_same<typename dest_type::array_layout,
+                               Kokkos::LayoutRight>::value,
+                  "ScatterView deep_copy destination has different layout");
+    static_assert(
+        Kokkos::Impl::VerifyExecutionCanAccessMemorySpace<
+            memory_space, typename dest_type::memory_space>::value,
         "ScatterView deep_copy destination memory space not accessible");
     bool is_equal = (dest.data() == internal_view.data());
-    size_t start = is_equal ? 1 : 0;
-    Kokkos::Impl::Experimental::ReduceDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data(),
-        dest.data(),
-        internal_view.stride(0),
-        start,
-        internal_view.extent(0),
-        internal_view.label());
+    size_t start  = is_equal ? 1 : 0;
+    Kokkos::Impl::Experimental::ReduceDuplicates<execution_space,
+                                                 original_value_type, Op>(
+        internal_view.data(), dest.data(), internal_view.stride(0), start,
+        internal_view.extent(0), internal_view.label());
   }
 
   void reset() {
-    Kokkos::Impl::Experimental::ResetDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data(),
-        internal_view.size(),
-        internal_view.label());
+    Kokkos::Impl::Experimental::ResetDuplicates<execution_space,
+                                                original_value_type, Op>(
+        internal_view.data(), internal_view.size(), internal_view.label());
   }
-  template <typename DT, typename ... RP>
+  template <typename DT, typename... RP>
   void reset_except(View<DT, RP...> const& view) {
     if (view.data() != internal_view.data()) {
       reset();
       return;
     }
-    Kokkos::Impl::Experimental::ResetDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data() + view.size(),
-        internal_view.size() - view.size(),
+    Kokkos::Impl::Experimental::ResetDuplicates<execution_space,
+                                                original_value_type, Op>(
+        internal_view.data() + view.size(), internal_view.size() - view.size(),
         internal_view.label());
   }
 
-  void resize(const size_t n0 = 0,
-           const size_t n1 = 0,
-           const size_t n2 = 0,
-           const size_t n3 = 0,
-           const size_t n4 = 0,
-           const size_t n5 = 0,
-           const size_t n6 = 0) {
-    ::Kokkos::resize(internal_view,unique_token.size(),n0,n1,n2,n3,n4,n5,n6);
+  void resize(const size_t n0 = 0, const size_t n1 = 0, const size_t n2 = 0,
+              const size_t n3 = 0, const size_t n4 = 0, const size_t n5 = 0,
+              const size_t n6 = 0) {
+    ::Kokkos::resize(internal_view, unique_token.size(), n0, n1, n2, n3, n4, n5,
+                     n6);
   }
 
-  void realloc(const size_t n0 = 0,
-           const size_t n1 = 0,
-           const size_t n2 = 0,
-           const size_t n3 = 0,
-           const size_t n4 = 0,
-           const size_t n5 = 0,
-           const size_t n6 = 0) {
-    ::Kokkos::realloc(internal_view,unique_token.size(),n0,n1,n2,n3,n4,n5,n6);
+  void realloc(const size_t n0 = 0, const size_t n1 = 0, const size_t n2 = 0,
+               const size_t n3 = 0, const size_t n4 = 0, const size_t n5 = 0,
+               const size_t n6 = 0) {
+    ::Kokkos::realloc(internal_view, unique_token.size(), n0, n1, n2, n3, n4,
+                      n5, n6);
   }
 
-protected:
-  template <typename ... Args>
-  KOKKOS_FORCEINLINE_FUNCTION
-  original_reference_type at(int rank, Args ... args) const {
+ protected:
+  template <typename... Args>
+  KOKKOS_FORCEINLINE_FUNCTION original_reference_type at(int rank,
+                                                         Args... args) const {
     return internal_view(rank, args...);
   }
 
-protected:
+ protected:
   typedef Kokkos::Experimental::UniqueToken<
-      ExecSpace, Kokkos::Experimental::UniqueTokenScope::Global> unique_token_type;
+      execution_space, Kokkos::Experimental::UniqueTokenScope::Global>
+      unique_token_type;
 
   unique_token_type unique_token;
   internal_view_type internal_view;
 };
 
-template <typename DataType
-         ,int Op
-         ,typename ExecSpace
-         ,int contribution
-         >
-class ScatterView<DataType
-                   ,Kokkos::LayoutLeft
-                   ,ExecSpace
-                   ,Op
-                   ,ScatterDuplicated
-                   ,contribution>
-{
-public:
-  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, ExecSpace> original_view_type;
+template <typename DataType, int Op, typename DeviceType, int contribution>
+class ScatterView<DataType, Kokkos::LayoutLeft, DeviceType, Op,
+                  ScatterDuplicated, contribution> {
+ public:
+  using execution_space = typename DeviceType::execution_space;
+  using memory_space    = typename DeviceType::memory_space;
+  using device_type     = Kokkos::Device<execution_space, memory_space>;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, device_type>
+      original_view_type;
   typedef typename original_view_type::value_type original_value_type;
   typedef typename original_view_type::reference_type original_reference_type;
-  friend class ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutLeft, ScatterDuplicated, contribution, ScatterNonAtomic>;
-  friend class ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutLeft, ScatterDuplicated, contribution, ScatterAtomic>;
-  typedef typename Kokkos::Impl::Experimental::DuplicatedDataType<DataType, Kokkos::LayoutLeft> data_type_info;
+  friend class ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutLeft,
+                             ScatterDuplicated, contribution, ScatterNonAtomic>;
+  friend class ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutLeft,
+                             ScatterDuplicated, contribution, ScatterAtomic>;
+  template <class, class, class, int, int, int>
+  friend class ScatterView;
+
+  typedef typename Kokkos::Impl::Experimental::DuplicatedDataType<
+      DataType, Kokkos::LayoutLeft>
+      data_type_info;
   typedef typename data_type_info::value_type internal_data_type;
-  typedef Kokkos::View<internal_data_type, Kokkos::LayoutLeft, ExecSpace> internal_view_type;
-
-  ScatterView()
-  {
-  }
-
-  template <typename RT, typename ... RP >
-  ScatterView(View<RT, RP...> const& original_view)
-  : unique_token()
-  {
-    size_t arg_N[8] = {
-      original_view.rank>0?original_view.extent(0):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>1?original_view.extent(1):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>2?original_view.extent(2):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>3?original_view.extent(3):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>4?original_view.extent(4):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>5?original_view.extent(5):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>6?original_view.extent(6):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      KOKKOS_IMPL_CTOR_DEFAULT_ARG
-    };
+  typedef Kokkos::View<internal_data_type, Kokkos::LayoutLeft, device_type>
+      internal_view_type;
+
+  ScatterView() = default;
+
+  template <typename RT, typename... RP>
+  ScatterView(View<RT, RP...> const& original_view) : unique_token() {
+    size_t arg_N[8] = {original_view.rank > 0 ? original_view.extent(0)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 1 ? original_view.extent(1)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 2 ? original_view.extent(2)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 3 ? original_view.extent(3)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 4 ? original_view.extent(4)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 5 ? original_view.extent(5)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 6 ? original_view.extent(6)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       KOKKOS_IMPL_CTOR_DEFAULT_ARG};
     arg_N[internal_view_type::rank - 1] = unique_token.size();
-    internal_view = internal_view_type(
-        Kokkos::ViewAllocateWithoutInitializing(
-          std::string("duplicated_") + original_view.label()),
-        arg_N[0], arg_N[1], arg_N[2], arg_N[3],
-        arg_N[4], arg_N[5], arg_N[6], arg_N[7]);
+    internal_view                       = internal_view_type(
+        Kokkos::ViewAllocateWithoutInitializing(std::string("duplicated_") +
+                                                original_view.label()),
+        arg_N[0], arg_N[1], arg_N[2], arg_N[3], arg_N[4], arg_N[5], arg_N[6],
+        arg_N[7]);
     reset();
   }
 
-  template <typename ... Dims>
-  ScatterView(std::string const& name, Dims ... dims) {
+  template <typename... Dims>
+  ScatterView(std::string const& name, Dims... dims) {
     original_view_type original_view;
-    size_t arg_N[8] = {
-      original_view.rank>0?original_view.static_extent(0):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>1?original_view.static_extent(1):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>2?original_view.static_extent(2):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>3?original_view.static_extent(3):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>4?original_view.static_extent(4):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>5?original_view.static_extent(5):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      original_view.rank>6?original_view.static_extent(6):KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-      KOKKOS_IMPL_CTOR_DEFAULT_ARG
-    };
-    Kokkos::Impl::Experimental::args_to_array(arg_N,0,dims ...);
+    size_t arg_N[8] = {original_view.rank > 0 ? original_view.static_extent(0)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 1 ? original_view.static_extent(1)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 2 ? original_view.static_extent(2)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 3 ? original_view.static_extent(3)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 4 ? original_view.static_extent(4)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 5 ? original_view.static_extent(5)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       original_view.rank > 6 ? original_view.static_extent(6)
+                                              : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       KOKKOS_IMPL_CTOR_DEFAULT_ARG};
+    Kokkos::Impl::Experimental::args_to_array(arg_N, 0, dims...);
     arg_N[internal_view_type::rank - 1] = unique_token.size();
-    internal_view = internal_view_type(Kokkos::ViewAllocateWithoutInitializing(name),
-     arg_N[0], arg_N[1], arg_N[2], arg_N[3],
-     arg_N[4], arg_N[5], arg_N[6], arg_N[7]);
+    internal_view                       = internal_view_type(
+        Kokkos::ViewAllocateWithoutInitializing(name), arg_N[0], arg_N[1],
+        arg_N[2], arg_N[3], arg_N[4], arg_N[5], arg_N[6], arg_N[7]);
     reset();
   }
 
+  template <typename OtherDataType, typename OtherDeviceType>
+  KOKKOS_FUNCTION ScatterView(
+      const ScatterView<OtherDataType, Kokkos::LayoutLeft, OtherDeviceType, Op,
+                        ScatterDuplicated, contribution>& other_view)
+      : unique_token(other_view.unique_token),
+        internal_view(other_view.internal_view) {}
+
+  template <typename OtherDataType, typename OtherDeviceType>
+  KOKKOS_FUNCTION void operator=(
+      const ScatterView<OtherDataType, Kokkos::LayoutLeft, OtherDeviceType, Op,
+                        ScatterDuplicated, contribution>& other_view) {
+    unique_token  = other_view.unique_token;
+    internal_view = other_view.internal_view;
+  }
+
   template <int override_contribution = contribution>
   KOKKOS_FORCEINLINE_FUNCTION
-  ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutLeft, ScatterDuplicated, contribution, override_contribution>
-  access() const {
-    return ScatterAccess<DataType, Op, ExecSpace, Kokkos::LayoutLeft, ScatterDuplicated, contribution, override_contribution>{*this};
+      ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutLeft,
+                    ScatterDuplicated, contribution, override_contribution>
+      access() const {
+    return ScatterAccess<DataType, Op, DeviceType, Kokkos::LayoutLeft,
+                         ScatterDuplicated, contribution,
+                         override_contribution>(*this);
   }
 
-  typename Kokkos::Impl::Experimental::Slice<
-    Kokkos::LayoutLeft, internal_view_type::rank, internal_view_type>::value_type
-  subview() const
-  {
+  typename Kokkos::Impl::Experimental::Slice<Kokkos::LayoutLeft,
+                                             internal_view_type::rank,
+                                             internal_view_type>::value_type
+  subview() const {
     return Kokkos::Impl::Experimental::Slice<
-      Kokkos::LayoutLeft, internal_view_type::rank, internal_view_type>::get(internal_view, 0);
+        Kokkos::LayoutLeft, internal_view_type::rank,
+        internal_view_type>::get(internal_view, 0);
   }
 
-  template <typename ... RP>
-  void contribute_into(View<RP...> const& dest) const
-  {
+  template <typename... RP>
+  void contribute_into(View<RP...> const& dest) const {
     typedef View<RP...> dest_type;
-    static_assert(std::is_same<
-        typename dest_type::value_type,
-        typename original_view_type::non_const_value_type>::value,
+    static_assert(
+        std::is_same<typename dest_type::value_type,
+                     typename original_view_type::non_const_value_type>::value,
         "ScatterView deep_copy destination has wrong value_type");
-    static_assert(std::is_same<
-        typename dest_type::array_layout,
-        Kokkos::LayoutLeft>::value,
-        "ScatterView deep_copy destination has different layout");
-    static_assert(Kokkos::Impl::VerifyExecutionCanAccessMemorySpace<
-        typename ExecSpace::memory_space,
-        typename dest_type::memory_space>::value,
+    static_assert(std::is_same<typename dest_type::array_layout,
+                               Kokkos::LayoutLeft>::value,
+                  "ScatterView deep_copy destination has different layout");
+    static_assert(
+        Kokkos::Impl::VerifyExecutionCanAccessMemorySpace<
+            memory_space, typename dest_type::memory_space>::value,
         "ScatterView deep_copy destination memory space not accessible");
-    auto extent = internal_view.extent(
-        internal_view_type::rank - 1);
+    auto extent   = internal_view.extent(internal_view_type::rank - 1);
     bool is_equal = (dest.data() == internal_view.data());
-    size_t start = is_equal ? 1 : 0;
-    Kokkos::Impl::Experimental::ReduceDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data(),
-        dest.data(),
-        internal_view.stride(internal_view_type::rank - 1),
-        start,
-        extent,
+    size_t start  = is_equal ? 1 : 0;
+    Kokkos::Impl::Experimental::ReduceDuplicates<execution_space,
+                                                 original_value_type, Op>(
+        internal_view.data(), dest.data(),
+        internal_view.stride(internal_view_type::rank - 1), start, extent,
         internal_view.label());
   }
 
   void reset() {
-    Kokkos::Impl::Experimental::ResetDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data(),
-        internal_view.size(),
-        internal_view.label());
+    Kokkos::Impl::Experimental::ResetDuplicates<execution_space,
+                                                original_value_type, Op>(
+        internal_view.data(), internal_view.size(), internal_view.label());
   }
-  template <typename DT, typename ... RP>
+  template <typename DT, typename... RP>
   void reset_except(View<DT, RP...> const& view) {
     if (view.data() != internal_view.data()) {
       reset();
       return;
     }
-    Kokkos::Impl::Experimental::ResetDuplicates<ExecSpace, original_value_type, Op>(
-        internal_view.data() + view.size(),
-        internal_view.size() - view.size(),
+    Kokkos::Impl::Experimental::ResetDuplicates<execution_space,
+                                                original_value_type, Op>(
+        internal_view.data() + view.size(), internal_view.size() - view.size(),
         internal_view.label());
   }
 
-  void resize(const size_t n0 = 0,
-           const size_t n1 = 0,
-           const size_t n2 = 0,
-           const size_t n3 = 0,
-           const size_t n4 = 0,
-           const size_t n5 = 0,
-           const size_t n6 = 0) {
-
-    size_t arg_N[8] = {n0,n1,n2,n3,n4,n5,n6,0};
-    const int i = internal_view.rank-1;
-    arg_N[i] = unique_token.size();
+  void resize(const size_t n0 = 0, const size_t n1 = 0, const size_t n2 = 0,
+              const size_t n3 = 0, const size_t n4 = 0, const size_t n5 = 0,
+              const size_t n6 = 0) {
+    size_t arg_N[8] = {n0, n1, n2, n3, n4, n5, n6, 0};
+    const int i     = internal_view.rank - 1;
+    arg_N[i]        = unique_token.size();
 
-    ::Kokkos::resize(internal_view,
-        arg_N[0], arg_N[1], arg_N[2], arg_N[3],
-        arg_N[4], arg_N[5], arg_N[6], arg_N[7]);
+    ::Kokkos::resize(internal_view, arg_N[0], arg_N[1], arg_N[2], arg_N[3],
+                     arg_N[4], arg_N[5], arg_N[6], arg_N[7]);
   }
 
-  void realloc(const size_t n0 = 0,
-           const size_t n1 = 0,
-           const size_t n2 = 0,
-           const size_t n3 = 0,
-           const size_t n4 = 0,
-           const size_t n5 = 0,
-           const size_t n6 = 0) {
+  void realloc(const size_t n0 = 0, const size_t n1 = 0, const size_t n2 = 0,
+               const size_t n3 = 0, const size_t n4 = 0, const size_t n5 = 0,
+               const size_t n6 = 0) {
+    size_t arg_N[8] = {n0, n1, n2, n3, n4, n5, n6, 0};
+    const int i     = internal_view.rank - 1;
+    arg_N[i]        = unique_token.size();
 
-    size_t arg_N[8] = {n0,n1,n2,n3,n4,n5,n6,0};
-    const int i = internal_view.rank-1;
-    arg_N[i] = unique_token.size();
-
-    ::Kokkos::realloc(internal_view,
-        arg_N[0], arg_N[1], arg_N[2], arg_N[3],
-        arg_N[4], arg_N[5], arg_N[6], arg_N[7]);
+    ::Kokkos::realloc(internal_view, arg_N[0], arg_N[1], arg_N[2], arg_N[3],
+                      arg_N[4], arg_N[5], arg_N[6], arg_N[7]);
   }
 
-protected:
-  template <typename ... Args>
-  inline original_reference_type at(int thread_id, Args ... args) const {
+ protected:
+  template <typename... Args>
+  KOKKOS_FORCEINLINE_FUNCTION original_reference_type at(int thread_id,
+                                                         Args... args) const {
     return internal_view(args..., thread_id);
   }
 
-protected:
+ protected:
   typedef Kokkos::Experimental::UniqueToken<
-      ExecSpace, Kokkos::Experimental::UniqueTokenScope::Global> unique_token_type;
+      execution_space, Kokkos::Experimental::UniqueTokenScope::Global>
+      unique_token_type;
 
   unique_token_type unique_token;
   internal_view_type internal_view;
 };
 
-
 /* This object has to be separate in order to store the thread ID, which cannot
    be obtained until one is inside a parallel construct, and may be relatively
    expensive to obtain at every contribution
    (calls a non-inlined function, looks up a thread-local variable).
-   Due to the expense, it is sensible to query it at most once per parallel iterate
-   (ideally once per thread, but parallel_for doesn't expose that)
-   and then store it in a stack variable.
-   ScatterAccess serves as a non-const object on the stack which can store the thread ID */
-
-template <typename DataType
-         ,int Op
-         ,typename ExecSpace
-         ,typename Layout
-         ,int contribution
-         ,int override_contribution
-         >
-class ScatterAccess<DataType
-                   ,Op
-                   ,ExecSpace
-                   ,Layout
-                   ,ScatterDuplicated
-                   ,contribution
-                   ,override_contribution>
-{
-public:
-  typedef ScatterView<DataType, Layout, ExecSpace, Op, ScatterDuplicated, contribution> view_type;
+   Due to the expense, it is sensible to query it at most once per parallel
+   iterate (ideally once per thread, but parallel_for doesn't expose that) and
+   then store it in a stack variable.
+   ScatterAccess serves as a non-const object on the stack which can store the
+   thread ID */
+
+template <typename DataType, int Op, typename DeviceType, typename Layout,
+          int contribution, int override_contribution>
+class ScatterAccess<DataType, Op, DeviceType, Layout, ScatterDuplicated,
+                    contribution, override_contribution> {
+ public:
+  typedef ScatterView<DataType, Layout, DeviceType, Op, ScatterDuplicated,
+                      contribution>
+      view_type;
   typedef typename view_type::original_value_type original_value_type;
-  typedef Kokkos::Impl::Experimental::ScatterValue<
-      original_value_type, Op, override_contribution> value_type;
+  typedef Kokkos::Impl::Experimental::ScatterValue<original_value_type, Op,
+                                                   override_contribution>
+      value_type;
 
   KOKKOS_FORCEINLINE_FUNCTION
   ScatterAccess(view_type const& view_in)
-    : view(view_in)
-    , thread_id(view_in.unique_token.acquire()) {
-  }
+      : view(view_in), thread_id(view_in.unique_token.acquire()) {}
 
   KOKKOS_FORCEINLINE_FUNCTION
   ~ScatterAccess() {
     if (thread_id != ~thread_id_type(0)) view.unique_token.release(thread_id);
   }
 
-  template <typename ... Args>
-  KOKKOS_FORCEINLINE_FUNCTION
-  value_type operator()(Args ... args) const {
+  template <typename... Args>
+  KOKKOS_FORCEINLINE_FUNCTION value_type operator()(Args... args) const {
     return view.at(thread_id, args...);
   }
 
   template <typename Arg>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<view_type::original_view_type::rank == 1 &&
-  std::is_integral<Arg>::value, value_type>::type
-  operator[](Arg arg) const {
+      typename std::enable_if<view_type::original_view_type::rank == 1 &&
+                                  std::is_integral<Arg>::value,
+                              value_type>::type
+      operator[](Arg arg) const {
     return view.at(thread_id, arg);
   }
 
-private:
-
+ private:
   view_type const& view;
 
   // simplify RAII by disallowing copies
@@ -1235,84 +1225,83 @@ private:
   ScatterAccess& operator=(ScatterAccess const& other) = delete;
   ScatterAccess& operator=(ScatterAccess&& other) = delete;
 
-public:
+ public:
   // do need to allow moves though, for the common
   // auto b = a.access();
-  // that assignments turns into a move constructor call  
+  // that assignments turns into a move constructor call
   KOKKOS_FORCEINLINE_FUNCTION
   ScatterAccess(ScatterAccess&& other)
-    : view(other.view)
-    , thread_id(other.thread_id)
-  {
+      : view(other.view), thread_id(other.thread_id) {
     other.thread_id = ~thread_id_type(0);
   }
 
-private:
-
+ private:
   typedef typename view_type::unique_token_type unique_token_type;
   typedef typename unique_token_type::size_type thread_id_type;
   thread_id_type thread_id;
 };
 
-template <int Op = Kokkos::Experimental::ScatterSum,
-          int duplication = -1,
-          int contribution = -1,
-          typename RT, typename ... RP>
-ScatterView
-  < RT
-  , typename ViewTraits<RT, RP...>::array_layout
-  , typename ViewTraits<RT, RP...>::execution_space
-  , Op
-  /* just setting defaults if not specified... things got messy because the view type
-     does not come before the duplication/contribution settings in the
-     template parameter list */
-  , duplication == -1 ? Kokkos::Impl::Experimental::DefaultDuplication<typename ViewTraits<RT, RP...>::execution_space>::value : duplication
-  , contribution == -1 ?
-      Kokkos::Impl::Experimental::DefaultContribution<
-                        typename ViewTraits<RT, RP...>::execution_space,
-                        (duplication == -1 ?
-                           Kokkos::Impl::Experimental::DefaultDuplication<
-                             typename ViewTraits<RT, RP...>::execution_space
-                             >::value
-                                           : duplication
-                        )
-                        >::value
-                       : contribution
-  >
+template <int Op = Kokkos::Experimental::ScatterSum, int duplication = -1,
+          int contribution = -1, typename RT, typename... RP>
+ScatterView<
+    RT, typename ViewTraits<RT, RP...>::array_layout,
+    typename ViewTraits<RT, RP...>::device_type,
+    Op
+    /* just setting defaults if not specified... things got messy because the
+       view type does not come before the duplication/contribution settings in
+       the template parameter list */
+    ,
+    duplication == -1
+        ? Kokkos::Impl::Experimental::DefaultDuplication<
+              typename ViewTraits<RT, RP...>::execution_space>::value
+        : duplication,
+    contribution == -1
+        ? Kokkos::Impl::Experimental::DefaultContribution<
+              typename ViewTraits<RT, RP...>::execution_space,
+              (duplication == -1
+                   ? Kokkos::Impl::Experimental::DefaultDuplication<
+                         typename ViewTraits<RT, RP...>::execution_space>::value
+                   : duplication)>::value
+        : contribution>
 create_scatter_view(View<RT, RP...> const& original_view) {
-  return original_view; // implicit ScatterView constructor call
+  return original_view;  // implicit ScatterView constructor call
 }
 
-}} // namespace Kokkos::Experimental
+}  // namespace Experimental
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Experimental {
 
-template <typename DT1, typename DT2, typename LY, typename ES,  int OP, int CT, int DP, typename ... VP>
-void
-contribute(View<DT1, VP...>& dest, Kokkos::Experimental::ScatterView<DT2, LY, ES, OP, CT, DP> const& src)
-{
+template <typename DT1, typename DT2, typename LY, typename ES, int OP, int CT,
+          int DP, typename... VP>
+void contribute(
+    View<DT1, VP...>& dest,
+    Kokkos::Experimental::ScatterView<DT2, LY, ES, OP, CT, DP> const& src) {
   src.contribute_into(dest);
 }
 
-}} // namespace Kokkos::Experimental
+}  // namespace Experimental
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template <typename DT, typename LY, typename ES,  int OP, int CT, int DP, typename ... IS>
-void
-realloc(Kokkos::Experimental::ScatterView<DT, LY, ES, OP, CT, DP>& scatter_view, IS ... is)
-{
-  scatter_view.realloc(is ...);
+template <typename DT, typename LY, typename ES, int OP, int CT, int DP,
+          typename... IS>
+void realloc(
+    Kokkos::Experimental::ScatterView<DT, LY, ES, OP, CT, DP>& scatter_view,
+    IS... is) {
+  scatter_view.realloc(is...);
 }
 
-template <typename DT, typename LY, typename ES,  int OP, int CT, int DP, typename ... IS>
-void
-resize(Kokkos::Experimental::ScatterView<DT, LY, ES, OP, CT, DP>& scatter_view, IS ... is)
-{
-  scatter_view.resize(is ...);
+template <typename DT, typename LY, typename ES, int OP, int CT, int DP,
+          typename... IS>
+void resize(
+    Kokkos::Experimental::ScatterView<DT, LY, ES, OP, CT, DP>& scatter_view,
+    IS... is) {
+  scatter_view.resize(is...);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/containers/src/Kokkos_StaticCrsGraph.hpp b/lib/kokkos/containers/src/Kokkos_StaticCrsGraph.hpp
index f63ce4b880268fb7e0ebdfa073b16485118bb337..26c16c4e003df7c7f68746a79be70917d20dd9de 100644
--- a/lib/kokkos/containers/src/Kokkos_StaticCrsGraph.hpp
+++ b/lib/kokkos/containers/src/Kokkos_StaticCrsGraph.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -54,82 +55,87 @@
 namespace Kokkos {
 
 namespace Impl {
-  template<class RowOffsetsType, class RowBlockOffsetsType>
-  struct StaticCrsGraphBalancerFunctor {
-    typedef typename RowOffsetsType::non_const_value_type int_type;
-    RowOffsetsType row_offsets;
-    RowBlockOffsetsType row_block_offsets;
-
-    int_type cost_per_row, num_blocks;
-
-    StaticCrsGraphBalancerFunctor(RowOffsetsType row_offsets_,
-                                  RowBlockOffsetsType row_block_offsets_,
-                                  int_type cost_per_row_, int_type num_blocks_):
-                                    row_offsets(row_offsets_),
-                                    row_block_offsets(row_block_offsets_),
-                                    cost_per_row(cost_per_row_),
-                                    num_blocks(num_blocks_){}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const int_type& iRow) const {
-      const int_type num_rows = row_offsets.extent(0)-1;
-      const int_type num_entries = row_offsets(num_rows);
-      const int_type total_cost = num_entries + num_rows*cost_per_row;
-
-      const double cost_per_workset = 1.0*total_cost/num_blocks;
-
-      const int_type row_cost = row_offsets(iRow+1)-row_offsets(iRow) + cost_per_row;
-
-      int_type count = row_offsets(iRow+1) + cost_per_row*iRow;
-
-      if(iRow == num_rows-1) row_block_offsets(num_blocks) = num_rows;
-
-      if(true) {
-        int_type current_block = (count-row_cost-cost_per_row)/cost_per_workset;
-        int_type end_block = count/cost_per_workset;
-
-        // Handle some corner cases for the last two blocks.
-        if(current_block >= num_blocks-2) {
-          if((current_block == num_blocks-2) && (count >= (current_block + 1) * cost_per_workset)) {
-            int_type row = iRow;
-            int_type cc = count-row_cost-cost_per_row;
-            int_type block = cc/cost_per_workset;
-            while((block>0) && (block==current_block)) {
-              cc = row_offsets(row)+row*cost_per_row;
-              block = cc/cost_per_workset;
-              row--;
-            }
-            if((count-cc-row_cost-cost_per_row) < num_entries-row_offsets(iRow+1)) {
-              row_block_offsets(current_block+1) = iRow+1;
-            } else {
-              row_block_offsets(current_block+1) = iRow;
-            }
+template <class RowOffsetsType, class RowBlockOffsetsType>
+struct StaticCrsGraphBalancerFunctor {
+  typedef typename RowOffsetsType::non_const_value_type int_type;
+  RowOffsetsType row_offsets;
+  RowBlockOffsetsType row_block_offsets;
+
+  int_type cost_per_row, num_blocks;
+
+  StaticCrsGraphBalancerFunctor(RowOffsetsType row_offsets_,
+                                RowBlockOffsetsType row_block_offsets_,
+                                int_type cost_per_row_, int_type num_blocks_)
+      : row_offsets(row_offsets_),
+        row_block_offsets(row_block_offsets_),
+        cost_per_row(cost_per_row_),
+        num_blocks(num_blocks_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int_type& iRow) const {
+    const int_type num_rows    = row_offsets.extent(0) - 1;
+    const int_type num_entries = row_offsets(num_rows);
+    const int_type total_cost  = num_entries + num_rows * cost_per_row;
+
+    const double cost_per_workset = 1.0 * total_cost / num_blocks;
+
+    const int_type row_cost =
+        row_offsets(iRow + 1) - row_offsets(iRow) + cost_per_row;
+
+    int_type count = row_offsets(iRow + 1) + cost_per_row * iRow;
+
+    if (iRow == num_rows - 1) row_block_offsets(num_blocks) = num_rows;
+
+    if (true) {
+      int_type current_block =
+          (count - row_cost - cost_per_row) / cost_per_workset;
+      int_type end_block = count / cost_per_workset;
+
+      // Handle some corner cases for the last two blocks.
+      if (current_block >= num_blocks - 2) {
+        if ((current_block == num_blocks - 2) &&
+            (count >= (current_block + 1) * cost_per_workset)) {
+          int_type row   = iRow;
+          int_type cc    = count - row_cost - cost_per_row;
+          int_type block = cc / cost_per_workset;
+          while ((block > 0) && (block == current_block)) {
+            cc    = row_offsets(row) + row * cost_per_row;
+            block = cc / cost_per_workset;
+            row--;
           }
-        } else {
-          if((count >= (current_block + 1) * cost_per_workset) ||
-             (iRow+2 == row_offsets.extent(0))) {
-            if(end_block>current_block+1) {
-              int_type num_block = end_block-current_block;
-              row_block_offsets(current_block+1) = iRow;
-              for(int_type block = current_block+2; block <= end_block; block++)
-                if((block<current_block+2+(num_block-1)/2))
-                  row_block_offsets(block) = iRow;
-                else
-                  row_block_offsets(block) = iRow+1;
-            } else {
-              row_block_offsets(current_block+1) = iRow+1;
-            }
+          if ((count - cc - row_cost - cost_per_row) <
+              num_entries - row_offsets(iRow + 1)) {
+            row_block_offsets(current_block + 1) = iRow + 1;
+          } else {
+            row_block_offsets(current_block + 1) = iRow;
+          }
+        }
+      } else {
+        if ((count >= (current_block + 1) * cost_per_workset) ||
+            (iRow + 2 == row_offsets.extent(0))) {
+          if (end_block > current_block + 1) {
+            int_type num_block                   = end_block - current_block;
+            row_block_offsets(current_block + 1) = iRow;
+            for (int_type block = current_block + 2; block <= end_block;
+                 block++)
+              if ((block < current_block + 2 + (num_block - 1) / 2))
+                row_block_offsets(block) = iRow;
+              else
+                row_block_offsets(block) = iRow + 1;
+          } else {
+            row_block_offsets(current_block + 1) = iRow + 1;
           }
         }
-
       }
     }
-  };
-}
+  }
+};
+}  // namespace Impl
 
 /// \class GraphRowViewConst
 /// \brief View of a row of a sparse graph.
-/// \tparam GraphType Sparse graph type, such as (but not limited to) StaticCrsGraph.
+/// \tparam GraphType Sparse graph type, such as (but not limited to)
+/// StaticCrsGraph.
 ///
 /// This class provides a generic view of a row of a sparse graph.
 /// We intended this class to view a row of a StaticCrsGraph, but
@@ -137,7 +143,8 @@ namespace Impl {
 ///
 /// The row view is suited for computational kernels like sparse
 /// matrix-vector multiply, as well as for modifying entries in the
-/// sparse matrix.  The view is always const as it does not allow graph modification.
+/// sparse matrix.  The view is always const as it does not allow graph
+/// modification.
 ///
 /// Here is an example loop over the entries in the row:
 /// \code
@@ -160,12 +167,12 @@ namespace Impl {
 /// The stride is one for the compressed sparse row storage format (as
 /// is used by CrsMatrix), but may be greater than one for other
 /// sparse matrix storage formats (e.g., ELLPACK or jagged diagonal).
-template<class GraphType>
+template <class GraphType>
 struct GraphRowViewConst {
   //! The type of the column indices in the row.
   typedef const typename GraphType::data_type ordinal_type;
 
-private:
+ private:
   //! Array of (local) column indices in the row.
   ordinal_type* colidx_;
   /// \brief Stride between successive entries in the row.
@@ -177,7 +184,7 @@ private:
   /// \c ordinal_type is the correct type.
   const ordinal_type stride_;
 
-public:
+ public:
   /// \brief Constructor
   ///
   /// \param values [in] Array of the row's values.
@@ -186,11 +193,9 @@ public:
   ///   each of the above arrays.
   /// \param count [in] Number of entries in the row.
   KOKKOS_INLINE_FUNCTION
-  GraphRowViewConst ( ordinal_type* const colidx_in,
-                      const ordinal_type& stride,
-                      const ordinal_type& count) :
-    colidx_ (colidx_in), stride_ (stride), length (count)
-  {}
+  GraphRowViewConst(ordinal_type* const colidx_in, const ordinal_type& stride,
+                    const ordinal_type& count)
+      : colidx_(colidx_in), stride_(stride), length(count) {}
 
   /// \brief Constructor with offset into \c colidx array
   ///
@@ -204,15 +209,14 @@ public:
   ///   built-in integer type.  This may differ from ordinal_type.
   ///   For example, the matrix may have dimensions that fit in int,
   ///   but a number of entries that does not fit in int.
-  template<class OffsetType>
-  KOKKOS_INLINE_FUNCTION
-  GraphRowViewConst ( const typename GraphType::entries_type& colidx_in,
-                      const ordinal_type& stride,
-                      const ordinal_type& count,
-                      const OffsetType& idx,
-                      const typename std::enable_if<std::is_integral<OffsetType>::value, int>::type& = 0) :
-    colidx_ (&colidx_in(idx)), stride_ (stride), length (count)
-  {}
+  template <class OffsetType>
+  KOKKOS_INLINE_FUNCTION GraphRowViewConst(
+      const typename GraphType::entries_type& colidx_in,
+      const ordinal_type& stride, const ordinal_type& count,
+      const OffsetType& idx,
+      const typename std::enable_if<std::is_integral<OffsetType>::value,
+                                    int>::type& = 0)
+      : colidx_(&colidx_in(idx)), stride_(stride), length(count) {}
 
   /// \brief Number of entries in the row.
   ///
@@ -232,18 +236,15 @@ public:
   /// "Entry i" is not necessarily the entry with column index i, nor
   /// does i necessarily correspond to the (local) row index.
   KOKKOS_INLINE_FUNCTION
-  ordinal_type& colidx (const ordinal_type& i) const {
-    return colidx_[i*stride_];
+  ordinal_type& colidx(const ordinal_type& i) const {
+    return colidx_[i * stride_];
   }
 
   /// \brief An alias for colidx
   KOKKOS_INLINE_FUNCTION
-  ordinal_type& operator()(const ordinal_type& i) const {
-    return colidx(i);
-  }
+  ordinal_type& operator()(const ordinal_type& i) const { return colidx(i); }
 };
 
-
 /// \class StaticCrsGraph
 /// \brief Compressed row storage array.
 ///
@@ -277,39 +278,50 @@ public:
 /// <li> <tt> entries( entry ,            i2 , i3 , ... ); </tt> </li>
 /// <li> <tt> entries( row_map[i0] + i1 , i2 , i3 , ... ); </tt> </li>
 /// </ul>
-template< class DataType,
-          class Arg1Type,
-          class Arg2Type = void,
+template <class DataType, class Arg1Type, class Arg2Type = void,
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-          typename SizeType = typename ViewTraits<DataType*, Arg1Type, Arg2Type >::size_type,
+          typename SizeType =
+              typename ViewTraits<DataType*, Arg1Type, Arg2Type>::size_type,
           class Arg3Type = void>
 #else
-          class Arg3Type = void,
-          typename SizeType = typename ViewTraits<DataType*, Arg1Type, Arg2Type, Arg3Type >::size_type>
+          class Arg3Type    = void,
+          typename SizeType = typename ViewTraits<DataType*, Arg1Type, Arg2Type,
+                                                  Arg3Type>::size_type>
 #endif
 class StaticCrsGraph {
-private:
+ private:
   typedef ViewTraits<DataType*, Arg1Type, Arg2Type, Arg3Type> traits;
 
-public:
-  typedef DataType                                            data_type;
-  typedef typename traits::array_layout                       array_layout;
-  typedef typename traits::execution_space                    execution_space;
-  typedef typename traits::device_type                        device_type;
-  typedef typename traits::memory_traits                      memory_traits;
-  typedef SizeType                                            size_type;
+ public:
+  typedef DataType data_type;
+  typedef typename traits::array_layout array_layout;
+  typedef typename traits::execution_space execution_space;
+  typedef typename traits::device_type device_type;
+  typedef typename traits::memory_traits memory_traits;
+  typedef SizeType size_type;
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  typedef StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type > staticcrsgraph_type;
-  typedef StaticCrsGraph< data_type , array_layout , typename traits::host_mirror_space , size_type, memory_traits > HostMirror;
+  typedef StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType, Arg3Type>
+      staticcrsgraph_type;
+  typedef StaticCrsGraph<data_type, array_layout,
+                         typename traits::host_mirror_space, size_type,
+                         memory_traits>
+      HostMirror;
 #else
-  typedef StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type, SizeType > staticcrsgraph_type;
-  typedef StaticCrsGraph< data_type , array_layout , typename traits::host_mirror_space , memory_traits, size_type > HostMirror;
+  typedef StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type, SizeType>
+      staticcrsgraph_type;
+  typedef StaticCrsGraph<data_type, array_layout,
+                         typename traits::host_mirror_space, memory_traits,
+                         size_type>
+      HostMirror;
 #endif
 
-  typedef View< const size_type* , array_layout, device_type , memory_traits >  row_map_type;
-  typedef View<       data_type* , array_layout, device_type , memory_traits >  entries_type;
-  typedef View< const size_type* , array_layout, device_type , memory_traits >  row_block_type;
+  typedef View<const size_type*, array_layout, device_type, memory_traits>
+      row_map_type;
+  typedef View<data_type*, array_layout, device_type, memory_traits>
+      entries_type;
+  typedef View<const size_type*, array_layout, device_type, memory_traits>
+      row_block_type;
 
   entries_type entries;
   row_map_type row_map;
@@ -317,28 +329,28 @@ public:
 
   //! Construct an empty view.
   KOKKOS_INLINE_FUNCTION
-  StaticCrsGraph () : entries(), row_map(), row_block_offsets() {}
+  StaticCrsGraph() : entries(), row_map(), row_block_offsets() {}
 
   //! Copy constructor (shallow copy).
   KOKKOS_INLINE_FUNCTION
-  StaticCrsGraph (const StaticCrsGraph& rhs) : entries (rhs.entries), row_map (rhs.row_map),
-                                               row_block_offsets(rhs.row_block_offsets)
-  {}
+  StaticCrsGraph(const StaticCrsGraph& rhs)
+      : entries(rhs.entries),
+        row_map(rhs.row_map),
+        row_block_offsets(rhs.row_block_offsets) {}
 
-  template<class EntriesType, class RowMapType>
-  KOKKOS_INLINE_FUNCTION
-  StaticCrsGraph (const EntriesType& entries_,const RowMapType& row_map_) : entries (entries_), row_map (row_map_),
-  row_block_offsets()
-  {}
+  template <class EntriesType, class RowMapType>
+  KOKKOS_INLINE_FUNCTION StaticCrsGraph(const EntriesType& entries_,
+                                        const RowMapType& row_map_)
+      : entries(entries_), row_map(row_map_), row_block_offsets() {}
 
   /** \brief  Assign to a view of the rhs array.
    *          If the old view is the last view
    *          then allocated memory is deallocated.
    */
   KOKKOS_INLINE_FUNCTION
-  StaticCrsGraph& operator= (const StaticCrsGraph& rhs) {
-    entries = rhs.entries;
-    row_map = rhs.row_map;
+  StaticCrsGraph& operator=(const StaticCrsGraph& rhs) {
+    entries           = rhs.entries;
+    row_map           = rhs.row_map;
     row_block_offsets = rhs.row_block_offsets;
     return *this;
   }
@@ -353,9 +365,9 @@ public:
    */
   KOKKOS_INLINE_FUNCTION
   size_type numRows() const {
-    return (row_map.extent(0) != 0) ?
-      row_map.extent(0) - static_cast<size_type> (1) :
-      static_cast<size_type> (0);
+    return (row_map.extent(0) != 0)
+               ? row_map.extent(0) - static_cast<size_type>(1)
+               : static_cast<size_type>(0);
   }
 
   /// \brief Return a const view of row i of the graph.
@@ -377,30 +389,33 @@ public:
   /// ELLPACK or Jagged Diagonal) that we may wish to support in the
   /// future.
   KOKKOS_INLINE_FUNCTION
-  GraphRowViewConst<StaticCrsGraph> rowConst (const data_type i) const {
+  GraphRowViewConst<StaticCrsGraph> rowConst(const data_type i) const {
     const size_type start = row_map(i);
     // count is guaranteed to fit in ordinal_type, as long as no row
     // has duplicate entries.
-    const data_type count = static_cast<data_type> (row_map(i+1) - start);
+    const data_type count = static_cast<data_type>(row_map(i + 1) - start);
 
     if (count == 0) {
-      return GraphRowViewConst<StaticCrsGraph> (NULL, 1, 0);
+      return GraphRowViewConst<StaticCrsGraph>(NULL, 1, 0);
     } else {
-      return GraphRowViewConst<StaticCrsGraph> (entries, 1, count, start);
+      return GraphRowViewConst<StaticCrsGraph>(entries, 1, count, start);
     }
   }
 
   /**  \brief  Create a row partitioning into a given number of blocks
    *           balancing non-zeros + a fixed cost per row.
    */
-  void create_block_partitioning(size_type num_blocks, size_type fix_cost_per_row = 4) {
-    View< size_type* , array_layout, device_type >
-      block_offsets("StatisCrsGraph::load_balance_offsets",num_blocks+1);
+  void create_block_partitioning(size_type num_blocks,
+                                 size_type fix_cost_per_row = 4) {
+    View<size_type*, array_layout, device_type> block_offsets(
+        "StatisCrsGraph::load_balance_offsets", num_blocks + 1);
 
-    Impl::StaticCrsGraphBalancerFunctor<row_map_type,View< size_type* , array_layout, device_type > >
-      partitioner(row_map,block_offsets,fix_cost_per_row,num_blocks);
+    Impl::StaticCrsGraphBalancerFunctor<
+        row_map_type, View<size_type*, array_layout, device_type> >
+        partitioner(row_map, block_offsets, fix_cost_per_row, num_blocks);
 
-    Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0,numRows()),partitioner);
+    Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, numRows()),
+                         partitioner);
     Kokkos::fence();
 
     row_block_offsets = block_offsets;
@@ -409,49 +424,48 @@ public:
 
 //----------------------------------------------------------------------------
 
-template< class StaticCrsGraphType , class InputSizeType >
-typename StaticCrsGraphType::staticcrsgraph_type
-create_staticcrsgraph( const std::string & label ,
-                 const std::vector< InputSizeType > & input );
+template <class StaticCrsGraphType, class InputSizeType>
+typename StaticCrsGraphType::staticcrsgraph_type create_staticcrsgraph(
+    const std::string& label, const std::vector<InputSizeType>& input);
 
-template< class StaticCrsGraphType , class InputSizeType >
-typename StaticCrsGraphType::staticcrsgraph_type
-create_staticcrsgraph( const std::string & label ,
-                 const std::vector< std::vector< InputSizeType > > & input );
+template <class StaticCrsGraphType, class InputSizeType>
+typename StaticCrsGraphType::staticcrsgraph_type create_staticcrsgraph(
+    const std::string& label,
+    const std::vector<std::vector<InputSizeType> >& input);
 
 //----------------------------------------------------------------------------
 
-template< class DataType ,
-          class Arg1Type ,
-          class Arg2Type ,
+template <class DataType, class Arg1Type, class Arg2Type,
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-          typename SizeType ,
-          class Arg3Type >
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type >::HostMirror
-create_mirror_view( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,SizeType,Arg3Type > & input );
+          typename SizeType, class Arg3Type>
+typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                        Arg3Type>::HostMirror
+create_mirror_view(const StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                                        Arg3Type>& input);
 #else
-          class Arg3Type ,
-          typename SizeType >
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type , SizeType >::HostMirror
-create_mirror_view( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,Arg3Type,SizeType > & input );
+          class Arg3Type, typename SizeType>
+typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                        SizeType>::HostMirror
+create_mirror_view(const StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                                        SizeType>& input);
 #endif
 
-template< class DataType ,
-          class Arg1Type ,
-          class Arg2Type ,
+template <class DataType, class Arg1Type, class Arg2Type,
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-          typename SizeType ,
-          class Arg3Type >
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type >::HostMirror
-create_mirror_view( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,SizeType,Arg3Type > & input );
+          typename SizeType, class Arg3Type>
+typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                        Arg3Type>::HostMirror
+create_mirror_view(const StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                                        Arg3Type>& input);
 #else
-          class Arg3Type ,
-          typename SizeType >
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type , SizeType >::HostMirror
-create_mirror( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,Arg3Type,SizeType > & input );
+          class Arg3Type, typename SizeType>
+typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                        SizeType>::HostMirror
+create_mirror(const StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                                   SizeType>& input);
 #endif
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -464,55 +478,57 @@ create_mirror( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,Arg3Type,SizeType
 namespace Kokkos {
 namespace Impl {
 
-template< class GraphType >
+template <class GraphType>
 struct StaticCrsGraphMaximumEntry {
+  typedef typename GraphType::execution_space execution_space;
+  typedef typename GraphType::data_type value_type;
 
-  typedef typename GraphType::execution_space execution_space ;
-  typedef typename GraphType::data_type value_type ;
+  const typename GraphType::entries_type entries;
 
-  const typename GraphType::entries_type entries ;
-
-  StaticCrsGraphMaximumEntry( const GraphType & graph ) : entries( graph.entries ) {}
+  StaticCrsGraphMaximumEntry(const GraphType& graph) : entries(graph.entries) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned i , value_type & update ) const
-    { if ( update < entries(i) ) update = entries(i); }
+  void operator()(const unsigned i, value_type& update) const {
+    if (update < entries(i)) update = entries(i);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & update ) const
-    { update = 0 ; }
+  void init(value_type& update) const { update = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & update ,
-             volatile const value_type & input ) const
-    { if ( update < input ) update = input ; }
+  void join(volatile value_type& update,
+            volatile const value_type& input) const {
+    if (update < input) update = input;
+  }
 };
 
-}
+}  // namespace Impl
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-template< class DataType, class Arg1Type, class Arg2Type, typename SizeType , class Arg3Type >
-DataType maximum_entry( const StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type > & graph )
-{
-  typedef StaticCrsGraph<DataType,Arg1Type,Arg2Type,SizeType,Arg3Type> GraphType ;
+template <class DataType, class Arg1Type, class Arg2Type, typename SizeType,
+          class Arg3Type>
+DataType maximum_entry(const StaticCrsGraph<DataType, Arg1Type, Arg2Type,
+                                            SizeType, Arg3Type>& graph) {
+  typedef StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType, Arg3Type>
+      GraphType;
 #else
-template< class DataType, class Arg1Type, class Arg2Type, class Arg3Type, typename SizeType >
-DataType maximum_entry( const StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type , SizeType > & graph )
-{
-  typedef StaticCrsGraph<DataType,Arg1Type,Arg2Type,Arg3Type,SizeType> GraphType ;
+template <class DataType, class Arg1Type, class Arg2Type, class Arg3Type,
+          typename SizeType>
+DataType maximum_entry(const StaticCrsGraph<DataType, Arg1Type, Arg2Type,
+                                            Arg3Type, SizeType>& graph) {
+  typedef StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type, SizeType>
+      GraphType;
 #endif
-  typedef Impl::StaticCrsGraphMaximumEntry< GraphType > FunctorType ;
+  typedef Impl::StaticCrsGraphMaximumEntry<GraphType> FunctorType;
 
-  DataType result = 0 ;
-  Kokkos::parallel_reduce( graph.entries.extent(0),
-                           FunctorType(graph), result );
-  return result ;
+  DataType result = 0;
+  Kokkos::parallel_reduce(graph.entries.extent(0), FunctorType(graph), result);
+  return result;
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_CRSARRAY_HPP */
-
diff --git a/lib/kokkos/containers/src/Kokkos_UnorderedMap.hpp b/lib/kokkos/containers/src/Kokkos_UnorderedMap.hpp
index 1406116e265b9f15464619b6f1efee50621c9d30..32c04996bb4225fca860fc8ee6fac49f2557f3fa 100644
--- a/lib/kokkos/containers/src/Kokkos_UnorderedMap.hpp
+++ b/lib/kokkos/containers/src/Kokkos_UnorderedMap.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -58,13 +59,11 @@
 #include <impl/Kokkos_Traits.hpp>
 #include <impl/Kokkos_UnorderedMap_impl.hpp>
 
-
 #include <iostream>
 
 #include <cstdint>
 #include <stdexcept>
 
-
 namespace Kokkos {
 
 enum { UnorderedMapInvalidIndex = ~0u };
@@ -83,17 +82,16 @@ enum { UnorderedMapInvalidIndex = ~0u };
 ///      ignored and the old value was left in place. </li>
 /// </ol>
 
-class UnorderedMapInsertResult
-{
-private:
-  enum Status{
-     SUCCESS = 1u << 31
-   , EXISTING = 1u << 30
-   , FREED_EXISTING = 1u << 29
-   , LIST_LENGTH_MASK = ~(SUCCESS | EXISTING | FREED_EXISTING)
+class UnorderedMapInsertResult {
+ private:
+  enum Status {
+    SUCCESS          = 1u << 31,
+    EXISTING         = 1u << 30,
+    FREED_EXISTING   = 1u << 29,
+    LIST_LENGTH_MASK = ~(SUCCESS | EXISTING | FREED_EXISTING)
   };
 
-public:
+ public:
   /// Did the map successful insert the key/value pair
   KOKKOS_FORCEINLINE_FUNCTION
   bool success() const { return (m_status & SUCCESS); }
@@ -121,32 +119,27 @@ public:
   uint32_t index() const { return m_index; }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  UnorderedMapInsertResult()
-    : m_index(UnorderedMapInvalidIndex)
-    , m_status(0)
-  {}
+  UnorderedMapInsertResult() : m_index(UnorderedMapInvalidIndex), m_status(0) {}
 
   KOKKOS_FORCEINLINE_FUNCTION
-  void increment_list_position()
-  {
+  void increment_list_position() {
     m_status += (list_position() < LIST_LENGTH_MASK) ? 1u : 0u;
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  void set_existing(uint32_t i, bool arg_freed_existing)
-  {
+  void set_existing(uint32_t i, bool arg_freed_existing) {
     m_index = i;
-    m_status = EXISTING | (arg_freed_existing ? FREED_EXISTING : 0u) | list_position();
+    m_status =
+        EXISTING | (arg_freed_existing ? FREED_EXISTING : 0u) | list_position();
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  void set_success(uint32_t i)
-  {
-    m_index = i;
+  void set_success(uint32_t i) {
+    m_index  = i;
     m_status = SUCCESS | list_position();
   }
 
-private:
+ private:
   uint32_t m_index;
   uint32_t m_status;
 };
@@ -206,26 +199,26 @@ private:
 /// \tparam EqualTo Definition of the equality function for instances of
 ///   <tt>Key</tt>.  The default will do a bitwise equality comparison.
 ///
-template <   typename Key
-           , typename Value
-           , typename Device = Kokkos::DefaultExecutionSpace
-           , typename Hasher = pod_hash<typename Impl::remove_const<Key>::type>
-           , typename EqualTo = pod_equal_to<typename Impl::remove_const<Key>::type>
-        >
-class UnorderedMap
-{
-private:
-  typedef typename ViewTraits<Key,Device,void,void>::host_mirror_space host_mirror_space ;
-public:
+template <typename Key, typename Value,
+          typename Device = Kokkos::DefaultExecutionSpace,
+          typename Hasher = pod_hash<typename Impl::remove_const<Key>::type>,
+          typename EqualTo =
+              pod_equal_to<typename Impl::remove_const<Key>::type> >
+class UnorderedMap {
+ private:
+  typedef typename ViewTraits<Key, Device, void, void>::host_mirror_space
+      host_mirror_space;
+
+ public:
   //! \name Public types and constants
   //@{
 
-  //key_types
+  // key_types
   typedef Key declared_key_type;
   typedef typename Impl::remove_const<declared_key_type>::type key_type;
   typedef typename Impl::add_const<key_type>::type const_key_type;
 
-  //value_types
+  // value_types
   typedef Value declared_value_type;
   typedef typename Impl::remove_const<declared_value_type>::type value_type;
   typedef typename Impl::add_const<value_type>::type const_value_type;
@@ -233,116 +226,126 @@ public:
   typedef Device device_type;
   typedef typename Device::execution_space execution_space;
   typedef Hasher hasher_type;
-  typedef EqualTo  equal_to_type;
+  typedef EqualTo equal_to_type;
   typedef uint32_t size_type;
 
-  //map_types
-  typedef UnorderedMap<declared_key_type,declared_value_type,device_type,hasher_type,equal_to_type> declared_map_type;
-  typedef UnorderedMap<key_type,value_type,device_type,hasher_type,equal_to_type>                   insertable_map_type;
-  typedef UnorderedMap<const_key_type,value_type,device_type,hasher_type,equal_to_type>             modifiable_map_type;
-  typedef UnorderedMap<const_key_type,const_value_type,device_type,hasher_type,equal_to_type>       const_map_type;
-
-  static const bool is_set = std::is_same<void,value_type>::value;
-  static const bool has_const_key = std::is_same<const_key_type,declared_key_type>::value;
-  static const bool has_const_value = is_set || std::is_same<const_value_type,declared_value_type>::value;
-
-  static const bool is_insertable_map = !has_const_key && (is_set || !has_const_value);
+  // map_types
+  typedef UnorderedMap<declared_key_type, declared_value_type, device_type,
+                       hasher_type, equal_to_type>
+      declared_map_type;
+  typedef UnorderedMap<key_type, value_type, device_type, hasher_type,
+                       equal_to_type>
+      insertable_map_type;
+  typedef UnorderedMap<const_key_type, value_type, device_type, hasher_type,
+                       equal_to_type>
+      modifiable_map_type;
+  typedef UnorderedMap<const_key_type, const_value_type, device_type,
+                       hasher_type, equal_to_type>
+      const_map_type;
+
+  static const bool is_set = std::is_same<void, value_type>::value;
+  static const bool has_const_key =
+      std::is_same<const_key_type, declared_key_type>::value;
+  static const bool has_const_value =
+      is_set || std::is_same<const_value_type, declared_value_type>::value;
+
+  static const bool is_insertable_map =
+      !has_const_key && (is_set || !has_const_value);
   static const bool is_modifiable_map = has_const_key && !has_const_value;
-  static const bool is_const_map = has_const_key && has_const_value;
-
+  static const bool is_const_map      = has_const_key && has_const_value;
 
   typedef UnorderedMapInsertResult insert_result;
 
-  typedef UnorderedMap<Key,Value,host_mirror_space,Hasher,EqualTo> HostMirror;
+  typedef UnorderedMap<Key, Value, host_mirror_space, Hasher, EqualTo>
+      HostMirror;
 
   typedef Impl::UnorderedMapHistogram<const_map_type> histogram_type;
 
   //@}
 
-private:
+ private:
   enum { invalid_index = ~static_cast<size_type>(0) };
 
-  typedef typename Impl::if_c< is_set, int, declared_value_type>::type impl_value_type;
+  typedef typename Impl::if_c<is_set, int, declared_value_type>::type
+      impl_value_type;
 
-  typedef typename Impl::if_c<   is_insertable_map
-                               , View< key_type *, device_type>
-                               , View< const key_type *, device_type, MemoryTraits<RandomAccess> >
-                             >::type key_type_view;
+  typedef typename Impl::if_c<
+      is_insertable_map, View<key_type *, device_type>,
+      View<const key_type *, device_type, MemoryTraits<RandomAccess> > >::type
+      key_type_view;
 
-  typedef typename Impl::if_c<   is_insertable_map || is_modifiable_map
-                               , View< impl_value_type *, device_type>
-                               , View< const impl_value_type *, device_type, MemoryTraits<RandomAccess> >
-                             >::type value_type_view;
+  typedef typename Impl::if_c<is_insertable_map || is_modifiable_map,
+                              View<impl_value_type *, device_type>,
+                              View<const impl_value_type *, device_type,
+                                   MemoryTraits<RandomAccess> > >::type
+      value_type_view;
 
-  typedef typename Impl::if_c<   is_insertable_map
-                               , View< size_type *, device_type>
-                               , View< const size_type *, device_type, MemoryTraits<RandomAccess> >
-                             >::type size_type_view;
+  typedef typename Impl::if_c<
+      is_insertable_map, View<size_type *, device_type>,
+      View<const size_type *, device_type, MemoryTraits<RandomAccess> > >::type
+      size_type_view;
 
-  typedef typename Impl::if_c<   is_insertable_map
-                               , Bitset< execution_space >
-                               , ConstBitset< execution_space>
-                             >::type bitset_type;
+  typedef typename Impl::if_c<is_insertable_map, Bitset<execution_space>,
+                              ConstBitset<execution_space> >::type bitset_type;
 
   enum { modified_idx = 0, erasable_idx = 1, failed_insert_idx = 2 };
   enum { num_scalars = 3 };
-  typedef View< int[num_scalars], LayoutLeft, device_type> scalars_view;
+  typedef View<int[num_scalars], LayoutLeft, device_type> scalars_view;
 
-public:
+ public:
   //! \name Public member functions
   //@{
 
   UnorderedMap()
-    : m_bounded_insert()
-    , m_hasher()
-    , m_equal_to()
-    , m_size()
-    , m_available_indexes()
-    , m_hash_lists()
-    , m_next_index()
-    , m_keys()
-    , m_values()
-    , m_scalars()
-  {}
+      : m_bounded_insert(),
+        m_hasher(),
+        m_equal_to(),
+        m_size(),
+        m_available_indexes(),
+        m_hash_lists(),
+        m_next_index(),
+        m_keys(),
+        m_values(),
+        m_scalars() {}
 
   /// \brief Constructor
   ///
-  /// \param capacity_hint [in] Initial guess of how many unique keys will be inserted into the map
-  /// \param hash [in] Hasher function for \c Key instances.  The
+  /// \param capacity_hint [in] Initial guess of how many unique keys will be
+  /// inserted into the map \param hash [in] Hasher function for \c Key
+  /// instances.  The
   ///   default value usually suffices.
-  UnorderedMap(  size_type capacity_hint, hasher_type hasher = hasher_type(), equal_to_type equal_to = equal_to_type() )
-    : m_bounded_insert(true)
-    , m_hasher(hasher)
-    , m_equal_to(equal_to)
-    , m_size()
-    , m_available_indexes(calculate_capacity(capacity_hint))
-    , m_hash_lists(ViewAllocateWithoutInitializing("UnorderedMap hash list"), Impl::find_hash_size(capacity()))
-    , m_next_index(ViewAllocateWithoutInitializing("UnorderedMap next index"), capacity()+1) // +1 so that the *_at functions can always return a valid reference
-    , m_keys("UnorderedMap keys",capacity()+1)
-    , m_values("UnorderedMap values",(is_set? 1 : capacity()+1))
-    , m_scalars("UnorderedMap scalars")
-  {
+  UnorderedMap(size_type capacity_hint, hasher_type hasher = hasher_type(),
+               equal_to_type equal_to = equal_to_type())
+      : m_bounded_insert(true),
+        m_hasher(hasher),
+        m_equal_to(equal_to),
+        m_size(),
+        m_available_indexes(calculate_capacity(capacity_hint)),
+        m_hash_lists(ViewAllocateWithoutInitializing("UnorderedMap hash list"),
+                     Impl::find_hash_size(capacity())),
+        m_next_index(ViewAllocateWithoutInitializing("UnorderedMap next index"),
+                     capacity() + 1)  // +1 so that the *_at functions can
+                                      // always return a valid reference
+        ,
+        m_keys("UnorderedMap keys", capacity() + 1),
+        m_values("UnorderedMap values", (is_set ? 1 : capacity() + 1)),
+        m_scalars("UnorderedMap scalars") {
     if (!is_insertable_map) {
-      throw std::runtime_error("Cannot construct a non-insertable (i.e. const key_type) unordered_map");
+      throw std::runtime_error(
+          "Cannot construct a non-insertable (i.e. const key_type) "
+          "unordered_map");
     }
 
     Kokkos::deep_copy(m_hash_lists, invalid_index);
     Kokkos::deep_copy(m_next_index, invalid_index);
   }
 
-  void reset_failed_insert_flag()
-  {
-    reset_flag(failed_insert_idx);
-  }
+  void reset_failed_insert_flag() { reset_flag(failed_insert_idx); }
 
-  histogram_type get_histogram()
-  {
-    return histogram_type(*this);
-  }
+  histogram_type get_histogram() { return histogram_type(*this); }
 
   //! Clear all entries in the table.
-  void clear()
-  {
+  void clear() {
     m_bounded_insert = true;
 
     if (capacity() == 0) return;
@@ -353,15 +356,13 @@ public:
     Kokkos::deep_copy(m_next_index, invalid_index);
     {
       const key_type tmp = key_type();
-      Kokkos::deep_copy(m_keys,tmp);
+      Kokkos::deep_copy(m_keys, tmp);
     }
-    if (is_set){
+    if (is_set) {
       const impl_value_type tmp = impl_value_type();
-      Kokkos::deep_copy(m_values,tmp);
-    }
-    {
-      Kokkos::deep_copy(m_scalars, 0);
+      Kokkos::deep_copy(m_values, tmp);
     }
+    { Kokkos::deep_copy(m_scalars, 0); }
   }
 
   /// \brief Change the capacity of the the map
@@ -374,24 +375,23 @@ public:
   ///
   /// This is <i>not</i> a device function; it may <i>not</i> be
   /// called in a parallel kernel.
-  bool rehash(size_type requested_capacity = 0)
-  {
+  bool rehash(size_type requested_capacity = 0) {
     const bool bounded_insert = (capacity() == 0) || (size() == 0u);
-    return rehash(requested_capacity, bounded_insert );
+    return rehash(requested_capacity, bounded_insert);
   }
 
-  bool rehash(size_type requested_capacity, bool bounded_insert)
-  {
-    if(!is_insertable_map) return false;
+  bool rehash(size_type requested_capacity, bool bounded_insert) {
+    if (!is_insertable_map) return false;
 
     const size_type curr_size = size();
-    requested_capacity = (requested_capacity < curr_size) ? curr_size : requested_capacity;
+    requested_capacity =
+        (requested_capacity < curr_size) ? curr_size : requested_capacity;
 
     insertable_map_type tmp(requested_capacity, m_hasher, m_equal_to);
 
     if (curr_size) {
       tmp.m_bounded_insert = false;
-      Impl::UnorderedMapRehash<insertable_map_type> f(tmp,*this);
+      Impl::UnorderedMapRehash<insertable_map_type> f(tmp, *this);
       f.apply();
     }
     tmp.m_bounded_insert = bounded_insert;
@@ -408,9 +408,8 @@ public:
   /// Note that this is not a device function; it cannot be called in
   /// a parallel kernel.  The value is not stored as a variable; it
   /// must be computed.
-  size_type size() const
-  {
-    if( capacity() == 0u ) return 0u;
+  size_type size() const {
+    if (capacity() == 0u) return 0u;
     if (modified()) {
       m_size = m_available_indexes.count();
       reset_flag(modified_idx);
@@ -423,18 +422,13 @@ public:
   /// This is <i>not</i> a device function; it may <i>not</i> be
   /// called in a parallel kernel.  The value is not stored as a
   /// variable; it must be computed.
-  bool failed_insert() const
-  {
-    return get_flag(failed_insert_idx);
-  }
+  bool failed_insert() const { return get_flag(failed_insert_idx); }
 
-  bool erasable() const
-  {
+  bool erasable() const {
     return is_insertable_map ? get_flag(erasable_idx) : false;
   }
 
-  bool begin_erase()
-  {
+  bool begin_erase() {
     bool result = !erasable();
     if (is_insertable_map && result) {
       execution_space().fence();
@@ -444,8 +438,7 @@ public:
     return result;
   }
 
-  bool end_erase()
-  {
+  bool end_erase() {
     bool result = erasable();
     if (is_insertable_map && result) {
       execution_space().fence();
@@ -462,8 +455,7 @@ public:
   /// This <i>is</i> a device function; it may be called in a parallel
   /// kernel.
   KOKKOS_FORCEINLINE_FUNCTION
-  size_type capacity() const
-  { return m_available_indexes.size(); }
+  size_type capacity() const { return m_available_indexes.size(); }
 
   /// \brief The number of hash table "buckets."
   ///
@@ -476,13 +468,11 @@ public:
   /// This <i>is</i> a device function; it may be called in a parallel
   /// kernel.
   KOKKOS_INLINE_FUNCTION
-  size_type hash_capacity() const
-  { return m_hash_lists.extent(0); }
+  size_type hash_capacity() const { return m_hash_lists.extent(0); }
 
   //---------------------------------------------------------------------------
   //---------------------------------------------------------------------------
 
-
   /// This <i>is</i> a device function; it may be called in a parallel
   /// kernel.  As discussed in the class documentation, it need not
   /// succeed.  The return value tells you if it did.
@@ -492,136 +482,138 @@ public:
   ///   using this class as a set (with Value = void), then you need not
   ///   provide this value.
   KOKKOS_INLINE_FUNCTION
-  insert_result insert(key_type const& k, impl_value_type const&v = impl_value_type()) const
-  {
+  insert_result insert(key_type const &k,
+                       impl_value_type const &v = impl_value_type()) const {
     insert_result result;
 
-    if ( !is_insertable_map || capacity() == 0u || m_scalars((int)erasable_idx) ) {
+    if (!is_insertable_map || capacity() == 0u ||
+        m_scalars((int)erasable_idx)) {
       return result;
     }
 
-    if ( !m_scalars((int)modified_idx) ) {
+    if (!m_scalars((int)modified_idx)) {
       m_scalars((int)modified_idx) = true;
     }
 
-    int volatile & failed_insert_ref = m_scalars((int)failed_insert_idx) ;
+    int volatile &failed_insert_ref = m_scalars((int)failed_insert_idx);
 
     const size_type hash_value = m_hasher(k);
-    const size_type hash_list = hash_value % m_hash_lists.extent(0);
+    const size_type hash_list  = hash_value % m_hash_lists.extent(0);
 
-    size_type * curr_ptr   = & m_hash_lists[ hash_list ];
-    size_type new_index    = invalid_index ;
+    size_type *curr_ptr = &m_hash_lists[hash_list];
+    size_type new_index = invalid_index;
 
     // Force integer multiply to long
-    size_type index_hint = static_cast<size_type>( (static_cast<double>(hash_list) * capacity()) / m_hash_lists.extent(0));
+    size_type index_hint = static_cast<size_type>(
+        (static_cast<double>(hash_list) * capacity()) / m_hash_lists.extent(0));
 
     size_type find_attempts = 0;
 
     enum : unsigned { bounded_find_attempts = 32u };
-    const size_type max_attempts = (m_bounded_insert && (bounded_find_attempts < m_available_indexes.max_hint()) ) ?
-                                    bounded_find_attempts :
-                                    m_available_indexes.max_hint();
+    const size_type max_attempts =
+        (m_bounded_insert &&
+         (bounded_find_attempts < m_available_indexes.max_hint()))
+            ? bounded_find_attempts
+            : m_available_indexes.max_hint();
 
-    bool not_done = true ;
+    bool not_done = true;
 
-#if defined( __MIC__ )
-      #pragma noprefetch
+#if defined(__MIC__)
+#pragma noprefetch
 #endif
-    while ( not_done ) {
-
+    while (not_done) {
       // Continue searching the unordered list for this key,
       // list will only be appended during insert phase.
       // Need volatile_load as other threads may be appending.
       size_type curr = volatile_load(curr_ptr);
 
-      KOKKOS_NONTEMPORAL_PREFETCH_LOAD(&m_keys[curr != invalid_index ? curr : 0]);
-#if defined( __MIC__ )
-      #pragma noprefetch
+      KOKKOS_NONTEMPORAL_PREFETCH_LOAD(
+          &m_keys[curr != invalid_index ? curr : 0]);
+#if defined(__MIC__)
+#pragma noprefetch
 #endif
-      while ( curr != invalid_index && ! m_equal_to( volatile_load(&m_keys[curr]), k) ) {
+      while (curr != invalid_index &&
+             !m_equal_to(volatile_load(&m_keys[curr]), k)) {
         result.increment_list_position();
         index_hint = curr;
-        curr_ptr = &m_next_index[curr];
-        curr = volatile_load(curr_ptr);
-        KOKKOS_NONTEMPORAL_PREFETCH_LOAD(&m_keys[curr != invalid_index ? curr : 0]);
+        curr_ptr   = &m_next_index[curr];
+        curr       = volatile_load(curr_ptr);
+        KOKKOS_NONTEMPORAL_PREFETCH_LOAD(
+            &m_keys[curr != invalid_index ? curr : 0]);
       }
 
       //------------------------------------------------------------
       // If key already present then return that index.
-      if ( curr != invalid_index ) {
-
+      if (curr != invalid_index) {
         const bool free_existing = new_index != invalid_index;
-        if ( free_existing ) {
+        if (free_existing) {
           // Previously claimed an unused entry that was not inserted.
           // Release this unused entry immediately.
-          if (!m_available_indexes.reset(new_index) ) {
+          if (!m_available_indexes.reset(new_index)) {
             printf("Unable to free existing\n");
           }
-
         }
 
         result.set_existing(curr, free_existing);
-        not_done = false ;
+        not_done = false;
       }
       //------------------------------------------------------------
       // Key is not currently in the map.
       // If the thread has claimed an entry try to insert now.
       else {
-
         //------------------------------------------------------------
         // If have not already claimed an unused entry then do so now.
         if (new_index == invalid_index) {
-
           bool found = false;
           // use the hash_list as the flag for the search direction
-          Kokkos::tie(found, index_hint) = m_available_indexes.find_any_unset_near( index_hint, hash_list );
+          Kokkos::tie(found, index_hint) =
+              m_available_indexes.find_any_unset_near(index_hint, hash_list);
 
           // found and index and this thread set it
-          if ( !found && ++find_attempts >= max_attempts ) {
+          if (!found && ++find_attempts >= max_attempts) {
             failed_insert_ref = true;
-            not_done = false ;
-          }
-          else if (m_available_indexes.set(index_hint) ) {
+            not_done          = false;
+          } else if (m_available_indexes.set(index_hint)) {
             new_index = index_hint;
             // Set key and value
             KOKKOS_NONTEMPORAL_PREFETCH_STORE(&m_keys[new_index]);
-            m_keys[new_index] = k ;
+            m_keys[new_index] = k;
 
             if (!is_set) {
               KOKKOS_NONTEMPORAL_PREFETCH_STORE(&m_values[new_index]);
-              m_values[new_index] = v ;
+              m_values[new_index] = v;
             }
 
             // Do not proceed until key and value are updated in global memory
             memory_fence();
           }
-        }
-        else if (failed_insert_ref) {
+        } else if (failed_insert_ref) {
           not_done = false;
         }
 
         // Attempt to append claimed entry into the list.
-        // Another thread may also be trying to append the same list so protect with atomic.
-        if ( new_index != invalid_index &&
-             curr ==  atomic_compare_exchange(curr_ptr, static_cast<size_type>(invalid_index), new_index) ) {
+        // Another thread may also be trying to append the same list so protect
+        // with atomic.
+        if (new_index != invalid_index &&
+            curr == atomic_compare_exchange(
+                        curr_ptr, static_cast<size_type>(invalid_index),
+                        new_index)) {
           // Succeeded in appending
           result.set_success(new_index);
-          not_done = false ;
+          not_done = false;
         }
       }
-    } // while ( not_done )
+    }  // while ( not_done )
 
-    return result ;
+    return result;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool erase(key_type const& k) const
-  {
+  bool erase(key_type const &k) const {
     bool result = false;
 
-    if(is_insertable_map && 0u < capacity() && m_scalars((int)erasable_idx)) {
-
-      if ( ! m_scalars((int)modified_idx) ) {
+    if (is_insertable_map && 0u < capacity() && m_scalars((int)erasable_idx)) {
+      if (!m_scalars((int)modified_idx)) {
         m_scalars((int)modified_idx) = true;
       }
 
@@ -643,13 +635,15 @@ public:
   /// This <i>is</i> a device function; it may be called in a parallel
   /// kernel.
   KOKKOS_INLINE_FUNCTION
-  size_type find( const key_type & k) const
-  {
-    size_type curr = 0u < capacity() ? m_hash_lists( m_hasher(k) % m_hash_lists.extent(0) ) : invalid_index ;
+  size_type find(const key_type &k) const {
+    size_type curr = 0u < capacity()
+                         ? m_hash_lists(m_hasher(k) % m_hash_lists.extent(0))
+                         : invalid_index;
 
     KOKKOS_NONTEMPORAL_PREFETCH_LOAD(&m_keys[curr != invalid_index ? curr : 0]);
-    while (curr != invalid_index && !m_equal_to( m_keys[curr], k) ) {
-      KOKKOS_NONTEMPORAL_PREFETCH_LOAD(&m_keys[curr != invalid_index ? curr : 0]);
+    while (curr != invalid_index && !m_equal_to(m_keys[curr], k)) {
+      KOKKOS_NONTEMPORAL_PREFETCH_LOAD(
+          &m_keys[curr != invalid_index ? curr : 0]);
       curr = m_next_index[curr];
     }
 
@@ -661,11 +655,7 @@ public:
   /// This <i>is</i> a device function; it may be called in a parallel
   /// kernel.
   KOKKOS_INLINE_FUNCTION
-  bool exists( const key_type & k) const
-  {
-    return valid_at(find(k));
-  }
-
+  bool exists(const key_type &k) const { return valid_at(find(k)); }
 
   /// \brief Get the value with \c i as its direct index.
   ///
@@ -676,10 +666,10 @@ public:
   ///
   /// 'const value_type' via Cuda texture fetch must return by value.
   KOKKOS_FORCEINLINE_FUNCTION
-  typename Impl::if_c< (is_set || has_const_value), impl_value_type, impl_value_type &>::type
-  value_at(size_type i) const
-  {
-    return m_values[ is_set ? 0 : (i < capacity() ? i : capacity()) ];
+  typename Impl::if_c<(is_set || has_const_value), impl_value_type,
+                      impl_value_type &>::type
+  value_at(size_type i) const {
+    return m_values[is_set ? 0 : (i < capacity() ? i : capacity())];
   }
 
   /// \brief Get the key with \c i as its direct index.
@@ -689,138 +679,154 @@ public:
   /// This <i>is</i> a device function; it may be called in a parallel
   /// kernel.
   KOKKOS_FORCEINLINE_FUNCTION
-  key_type key_at(size_type i) const
-  {
-    return m_keys[ i < capacity() ? i : capacity() ];
+  key_type key_at(size_type i) const {
+    return m_keys[i < capacity() ? i : capacity()];
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  bool valid_at(size_type i) const
-  {
-    return m_available_indexes.test(i);
-  }
+  bool valid_at(size_type i) const { return m_available_indexes.test(i); }
 
   template <typename SKey, typename SValue>
-  UnorderedMap( UnorderedMap<SKey,SValue,Device,Hasher,EqualTo> const& src,
-                typename Impl::enable_if< Impl::UnorderedMapCanAssign<declared_key_type,declared_value_type,SKey,SValue>::value,int>::type = 0
-              )
-    : m_bounded_insert(src.m_bounded_insert)
-    , m_hasher(src.m_hasher)
-    , m_equal_to(src.m_equal_to)
-    , m_size(src.m_size)
-    , m_available_indexes(src.m_available_indexes)
-    , m_hash_lists(src.m_hash_lists)
-    , m_next_index(src.m_next_index)
-    , m_keys(src.m_keys)
-    , m_values(src.m_values)
-    , m_scalars(src.m_scalars)
-  {}
-
+  UnorderedMap(
+      UnorderedMap<SKey, SValue, Device, Hasher, EqualTo> const &src,
+      typename Impl::enable_if<
+          Impl::UnorderedMapCanAssign<declared_key_type, declared_value_type,
+                                      SKey, SValue>::value,
+          int>::type = 0)
+      : m_bounded_insert(src.m_bounded_insert),
+        m_hasher(src.m_hasher),
+        m_equal_to(src.m_equal_to),
+        m_size(src.m_size),
+        m_available_indexes(src.m_available_indexes),
+        m_hash_lists(src.m_hash_lists),
+        m_next_index(src.m_next_index),
+        m_keys(src.m_keys),
+        m_values(src.m_values),
+        m_scalars(src.m_scalars) {}
 
   template <typename SKey, typename SValue>
-  typename Impl::enable_if< Impl::UnorderedMapCanAssign<declared_key_type,declared_value_type,SKey,SValue>::value
-                           ,declared_map_type & >::type
-  operator=( UnorderedMap<SKey,SValue,Device,Hasher,EqualTo> const& src)
-  {
-    m_bounded_insert = src.m_bounded_insert;
-    m_hasher = src.m_hasher;
-    m_equal_to = src.m_equal_to;
-    m_size = src.m_size;
+  typename Impl::enable_if<
+      Impl::UnorderedMapCanAssign<declared_key_type, declared_value_type, SKey,
+                                  SValue>::value,
+      declared_map_type &>::type
+  operator=(UnorderedMap<SKey, SValue, Device, Hasher, EqualTo> const &src) {
+    m_bounded_insert    = src.m_bounded_insert;
+    m_hasher            = src.m_hasher;
+    m_equal_to          = src.m_equal_to;
+    m_size              = src.m_size;
     m_available_indexes = src.m_available_indexes;
-    m_hash_lists = src.m_hash_lists;
-    m_next_index = src.m_next_index;
-    m_keys = src.m_keys;
-    m_values = src.m_values;
-    m_scalars = src.m_scalars;
+    m_hash_lists        = src.m_hash_lists;
+    m_next_index        = src.m_next_index;
+    m_keys              = src.m_keys;
+    m_values            = src.m_values;
+    m_scalars           = src.m_scalars;
     return *this;
   }
 
   template <typename SKey, typename SValue, typename SDevice>
-  typename Impl::enable_if< std::is_same< typename Impl::remove_const<SKey>::type, key_type>::value &&
-                            std::is_same< typename Impl::remove_const<SValue>::type, value_type>::value
-                          >::type
-  create_copy_view( UnorderedMap<SKey, SValue, SDevice, Hasher,EqualTo> const& src)
-  {
+  typename Impl::enable_if<
+      std::is_same<typename Impl::remove_const<SKey>::type, key_type>::value &&
+      std::is_same<typename Impl::remove_const<SValue>::type,
+                   value_type>::value>::type
+  create_copy_view(
+      UnorderedMap<SKey, SValue, SDevice, Hasher, EqualTo> const &src) {
     if (m_hash_lists.data() != src.m_hash_lists.data()) {
-
       insertable_map_type tmp;
 
-      tmp.m_bounded_insert = src.m_bounded_insert;
-      tmp.m_hasher = src.m_hasher;
-      tmp.m_equal_to = src.m_equal_to;
-      tmp.m_size = src.size();
-      tmp.m_available_indexes = bitset_type( src.capacity() );
-      tmp.m_hash_lists        = size_type_view( ViewAllocateWithoutInitializing("UnorderedMap hash list"), src.m_hash_lists.extent(0) );
-      tmp.m_next_index        = size_type_view( ViewAllocateWithoutInitializing("UnorderedMap next index"), src.m_next_index.extent(0) );
-      tmp.m_keys              = key_type_view( ViewAllocateWithoutInitializing("UnorderedMap keys"), src.m_keys.extent(0) );
-      tmp.m_values            = value_type_view( ViewAllocateWithoutInitializing("UnorderedMap values"), src.m_values.extent(0) );
-      tmp.m_scalars           = scalars_view("UnorderedMap scalars");
+      tmp.m_bounded_insert    = src.m_bounded_insert;
+      tmp.m_hasher            = src.m_hasher;
+      tmp.m_equal_to          = src.m_equal_to;
+      tmp.m_size              = src.size();
+      tmp.m_available_indexes = bitset_type(src.capacity());
+      tmp.m_hash_lists        = size_type_view(
+          ViewAllocateWithoutInitializing("UnorderedMap hash list"),
+          src.m_hash_lists.extent(0));
+      tmp.m_next_index = size_type_view(
+          ViewAllocateWithoutInitializing("UnorderedMap next index"),
+          src.m_next_index.extent(0));
+      tmp.m_keys =
+          key_type_view(ViewAllocateWithoutInitializing("UnorderedMap keys"),
+                        src.m_keys.extent(0));
+      tmp.m_values = value_type_view(
+          ViewAllocateWithoutInitializing("UnorderedMap values"),
+          src.m_values.extent(0));
+      tmp.m_scalars = scalars_view("UnorderedMap scalars");
 
       Kokkos::deep_copy(tmp.m_available_indexes, src.m_available_indexes);
 
-      typedef Kokkos::Impl::DeepCopy< typename device_type::memory_space, typename SDevice::memory_space > raw_deep_copy;
+      typedef Kokkos::Impl::DeepCopy<typename device_type::memory_space,
+                                     typename SDevice::memory_space>
+          raw_deep_copy;
 
-      raw_deep_copy(tmp.m_hash_lists.data(), src.m_hash_lists.data(), sizeof(size_type)*src.m_hash_lists.extent(0));
-      raw_deep_copy(tmp.m_next_index.data(), src.m_next_index.data(), sizeof(size_type)*src.m_next_index.extent(0));
-      raw_deep_copy(tmp.m_keys.data(), src.m_keys.data(), sizeof(key_type)*src.m_keys.extent(0));
+      raw_deep_copy(tmp.m_hash_lists.data(), src.m_hash_lists.data(),
+                    sizeof(size_type) * src.m_hash_lists.extent(0));
+      raw_deep_copy(tmp.m_next_index.data(), src.m_next_index.data(),
+                    sizeof(size_type) * src.m_next_index.extent(0));
+      raw_deep_copy(tmp.m_keys.data(), src.m_keys.data(),
+                    sizeof(key_type) * src.m_keys.extent(0));
       if (!is_set) {
-        raw_deep_copy(tmp.m_values.data(), src.m_values.data(), sizeof(impl_value_type)*src.m_values.extent(0));
+        raw_deep_copy(tmp.m_values.data(), src.m_values.data(),
+                      sizeof(impl_value_type) * src.m_values.extent(0));
       }
-      raw_deep_copy(tmp.m_scalars.data(), src.m_scalars.data(), sizeof(int)*num_scalars );
+      raw_deep_copy(tmp.m_scalars.data(), src.m_scalars.data(),
+                    sizeof(int) * num_scalars);
 
       *this = tmp;
     }
   }
 
   //@}
-private: // private member functions
+ private:  // private member functions
+  bool modified() const { return get_flag(modified_idx); }
 
-  bool modified() const
-  {
-    return get_flag(modified_idx);
-  }
-
-  void set_flag(int flag) const
-  {
-    typedef Kokkos::Impl::DeepCopy< typename device_type::memory_space, Kokkos::HostSpace > raw_deep_copy;
+  void set_flag(int flag) const {
+    typedef Kokkos::Impl::DeepCopy<typename device_type::memory_space,
+                                   Kokkos::HostSpace>
+        raw_deep_copy;
     const int true_ = true;
     raw_deep_copy(m_scalars.data() + flag, &true_, sizeof(int));
   }
 
-  void reset_flag(int flag) const
-  {
-    typedef Kokkos::Impl::DeepCopy< typename device_type::memory_space, Kokkos::HostSpace > raw_deep_copy;
+  void reset_flag(int flag) const {
+    typedef Kokkos::Impl::DeepCopy<typename device_type::memory_space,
+                                   Kokkos::HostSpace>
+        raw_deep_copy;
     const int false_ = false;
     raw_deep_copy(m_scalars.data() + flag, &false_, sizeof(int));
   }
 
-  bool get_flag(int flag) const
-  {
-    typedef Kokkos::Impl::DeepCopy< Kokkos::HostSpace, typename device_type::memory_space > raw_deep_copy;
+  bool get_flag(int flag) const {
+    typedef Kokkos::Impl::DeepCopy<Kokkos::HostSpace,
+                                   typename device_type::memory_space>
+        raw_deep_copy;
     int result = false;
     raw_deep_copy(&result, m_scalars.data() + flag, sizeof(int));
     return result;
   }
 
-  static uint32_t calculate_capacity(uint32_t capacity_hint)
-  {
+  static uint32_t calculate_capacity(uint32_t capacity_hint) {
     // increase by 16% and round to nears multiple of 128
-    return capacity_hint ? ((static_cast<uint32_t>(7ull*capacity_hint/6u) + 127u)/128u)*128u : 128u;
+    return capacity_hint
+               ? ((static_cast<uint32_t>(7ull * capacity_hint / 6u) + 127u) /
+                  128u) *
+                     128u
+               : 128u;
   }
 
-private: // private members
-  bool              m_bounded_insert;
-  hasher_type       m_hasher;
-  equal_to_type     m_equal_to;
+ private:  // private members
+  bool m_bounded_insert;
+  hasher_type m_hasher;
+  equal_to_type m_equal_to;
   mutable size_type m_size;
-  bitset_type       m_available_indexes;
-  size_type_view    m_hash_lists;
-  size_type_view    m_next_index;
-  key_type_view     m_keys;
-  value_type_view   m_values;
-  scalars_view      m_scalars;
-
-  template <typename KKey, typename VValue, typename DDevice, typename HHash, typename EEqualTo>
+  bitset_type m_available_indexes;
+  size_type_view m_hash_lists;
+  size_type_view m_next_index;
+  key_type_view m_keys;
+  value_type_view m_values;
+  scalars_view m_scalars;
+
+  template <typename KKey, typename VValue, typename DDevice, typename HHash,
+            typename EEqualTo>
   friend class UnorderedMap;
 
   template <typename UMap>
@@ -834,17 +840,14 @@ private: // private members
 };
 
 // Specialization of deep_copy for two UnorderedMap objects.
-template <  typename DKey, typename DT, typename DDevice
-          , typename SKey, typename ST, typename SDevice
-          , typename Hasher, typename EqualTo >
-inline void deep_copy(         UnorderedMap<DKey, DT, DDevice, Hasher, EqualTo> & dst
-                       , const UnorderedMap<SKey, ST, SDevice, Hasher, EqualTo> & src )
-{
+template <typename DKey, typename DT, typename DDevice, typename SKey,
+          typename ST, typename SDevice, typename Hasher, typename EqualTo>
+inline void deep_copy(
+    UnorderedMap<DKey, DT, DDevice, Hasher, EqualTo> &dst,
+    const UnorderedMap<SKey, ST, SDevice, Hasher, EqualTo> &src) {
   dst.create_copy_view(src);
 }
 
+}  // namespace Kokkos
 
-} // namespace Kokkos
-
-#endif //KOKKOS_UNORDERED_MAP_HPP
-
+#endif  // KOKKOS_UNORDERED_MAP_HPP
diff --git a/lib/kokkos/containers/src/Kokkos_Vector.hpp b/lib/kokkos/containers/src/Kokkos_Vector.hpp
index a44d1f58b52b06a4d1443bbb27fb6af29c869667..0641eeba82fb6a0444f58f3d4c47495f1c31aec6 100644
--- a/lib/kokkos/containers/src/Kokkos_Vector.hpp
+++ b/lib/kokkos/containers/src/Kokkos_Vector.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,15 +49,15 @@
 #include <Kokkos_DualView.hpp>
 
 /* Drop in replacement for std::vector based on Kokkos::DualView
- * Most functions only work on the host (it will not compile if called from device kernel)
+ * Most functions only work on the host (it will not compile if called from
+ * device kernel)
  *
  */
-  namespace Kokkos {
+namespace Kokkos {
 
-template< class Scalar, class Arg1Type = void>
-class vector : public DualView<Scalar*,LayoutLeft,Arg1Type> {
-
-public:
+template <class Scalar, class Arg1Type = void>
+class vector : public DualView<Scalar*, LayoutLeft, Arg1Type> {
+ public:
   typedef Scalar value_type;
   typedef Scalar* pointer;
   typedef const Scalar* const_pointer;
@@ -64,213 +65,259 @@ public:
   typedef const Scalar& const_reference;
   typedef Scalar* iterator;
   typedef const Scalar* const_iterator;
+  typedef size_t size_type;
 
-private:
+ private:
   size_t _size;
-  typedef size_t size_type;
   float _extra_storage;
-  typedef DualView<Scalar*,LayoutLeft,Arg1Type> DV;
+  typedef DualView<Scalar*, LayoutLeft, Arg1Type> DV;
 
-
-public:
+ public:
 #ifdef KOKKOS_ENABLE_CUDA_UVM
-  KOKKOS_INLINE_FUNCTION reference operator() (int i) const {return DV::h_view(i);};
-  KOKKOS_INLINE_FUNCTION reference operator[] (int i) const {return DV::h_view(i);};
+  KOKKOS_INLINE_FUNCTION reference operator()(int i) const {
+    return DV::h_view(i);
+  };
+  KOKKOS_INLINE_FUNCTION reference operator[](int i) const {
+    return DV::h_view(i);
+  };
 #else
-  inline reference operator() (int i) const {return DV::h_view(i);};
-  inline reference operator[] (int i) const {return DV::h_view(i);};
+  inline reference operator()(int i) const { return DV::h_view(i); };
+  inline reference operator[](int i) const { return DV::h_view(i); };
 #endif
 
   /* Member functions which behave like std::vector functions */
 
-  vector():DV() {
-    _size = 0;
+  vector() : DV() {
+    _size          = 0;
     _extra_storage = 1.1;
   }
 
-
-  vector(int n, Scalar val=Scalar()):DualView<Scalar*,LayoutLeft,Arg1Type>("Vector",size_t(n*(1.1))) {
-    _size = n;
-    _extra_storage = 1.1;
+  vector(int n, Scalar val = Scalar())
+      : DualView<Scalar*, LayoutLeft, Arg1Type>("Vector", size_t(n * (1.1))) {
+    _size                 = n;
+    _extra_storage        = 1.1;
     DV::modified_flags(0) = 1;
 
-    assign(n,val);
+    assign(n, val);
   }
 
-
   void resize(size_t n) {
-    if(n>=span())
-      DV::resize(size_t (n*_extra_storage));
+    if (n >= span()) DV::resize(size_t(n * _extra_storage));
     _size = n;
   }
 
-  void resize(size_t n, const Scalar& val) {
-    assign(n,val);
-  }
-
-  void assign (size_t n, const Scalar& val) {
+  void resize(size_t n, const Scalar& val) { assign(n, val); }
 
+  void assign(size_t n, const Scalar& val) {
     /* Resize if necessary (behavior of std:vector) */
 
-    if(n>span())
-      DV::resize(size_t (n*_extra_storage));
+    if (n > span()) DV::resize(size_t(n * _extra_storage));
     _size = n;
 
-          /* Assign value either on host or on device */
+    /* Assign value either on host or on device */
 
-    if( DV::template need_sync<typename DV::t_dev::device_type>() ) {
-      set_functor_host f(DV::h_view,val);
-      parallel_for(n,f);
+    if (DV::template need_sync<typename DV::t_dev::device_type>()) {
+      set_functor_host f(DV::h_view, val);
+      parallel_for(n, f);
       typename DV::t_host::execution_space().fence();
       DV::template modify<typename DV::t_host::device_type>();
     } else {
-      set_functor f(DV::d_view,val);
-      parallel_for(n,f);
+      set_functor f(DV::d_view, val);
+      parallel_for(n, f);
       typename DV::t_dev::execution_space().fence();
       DV::template modify<typename DV::t_dev::device_type>();
     }
   }
 
-  void reserve(size_t n) {
-    DV::resize(size_t (n*_extra_storage));
-  }
+  void reserve(size_t n) { DV::resize(size_t(n * _extra_storage)); }
 
   void push_back(Scalar val) {
     DV::template sync<typename DV::t_host::device_type>();
     DV::template modify<typename DV::t_host::device_type>();
-    if(_size == span()) {
-      size_t new_size = _size*_extra_storage;
-      if(new_size == _size) new_size++;
+    if (_size == span()) {
+      size_t new_size = _size * _extra_storage;
+      if (new_size == _size) new_size++;
       DV::resize(new_size);
     }
 
     DV::h_view(_size) = val;
     _size++;
+  }
+
+  void pop_back() { _size--; }
 
+  void clear() { _size = 0; }
+
+  iterator insert(iterator it, const value_type& val) {
+    return insert(it, 1, val);
   }
 
-  void pop_back() {
-    _size--;
+  iterator insert(iterator it, size_type count, const value_type& val) {
+    if ((size() == 0) && (it == begin())) {
+      resize(count, val);
+      DV::sync_host();
+      return begin();
+    }
+    DV::sync_host();
+    DV::modify_host();
+    if (it < begin() || it > end())
+      Kokkos::abort("Kokkos::vector::insert : invalid insert iterator");
+    if (count == 0) return it;
+    ptrdiff_t start = std::distance(begin(), it);
+    auto org_size   = size();
+    resize(size() + count);
+
+    std::copy_backward(begin() + start, begin() + org_size,
+                       begin() + org_size + count);
+    std::fill_n(begin() + start, count, val);
+
+    return begin() + start;
   }
 
-  void clear() {
-    _size = 0;
+ private:
+  template <class T>
+  struct impl_is_input_iterator
+      : /* TODO replace this */ std::integral_constant<
+            bool, !std::is_convertible<T, size_type>::value> {};
+
+ public:
+  // TODO: can use detection idiom to generate better error message here later
+  template <typename InputIterator>
+  typename std::enable_if<impl_is_input_iterator<InputIterator>::value,
+                          iterator>::type
+  insert(iterator it, InputIterator b, InputIterator e) {
+    ptrdiff_t count = std::distance(b, e);
+    if (count == 0) return it;
+
+    DV::sync_host();
+    DV::modify_host();
+    if (it < begin() || it > end())
+      Kokkos::abort("Kokkos::vector::insert : invalid insert iterator");
+
+    bool resized = false;
+    if ((size() == 0) && (it == begin())) {
+      resize(count);
+      it      = begin();
+      resized = true;
+    }
+    ptrdiff_t start = std::distance(begin(), it);
+    auto org_size   = size();
+    if (!resized) resize(size() + count);
+    it = begin() + start;
+
+    std::copy_backward(begin() + start, begin() + org_size,
+                       begin() + org_size + count);
+    std::copy(b, e, it);
+
+    return begin() + start;
   }
 
-  size_type size() const {return _size;}
-  size_type max_size() const {return 2000000000;}
+  size_type size() const { return _size; }
+  size_type max_size() const { return 2000000000; }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  size_type capacity() const {return DV::capacity();}
+  size_type capacity() const { return DV::capacity(); }
 #endif
-  size_type span() const {return DV::span();}
-  bool empty() const {return _size==0;}
+  size_type span() const { return DV::span(); }
+  bool empty() const { return _size == 0; }
 
-  iterator begin() const {return &DV::h_view(0);}
+  iterator begin() const { return DV::h_view.data(); }
 
-  iterator end() const {return &DV::h_view(_size);}
+  iterator end() const {
+    return _size > 0 ? DV::h_view.data() + _size : DV::h_view.data();
+  }
 
-  reference front() {return DV::h_view(0);}
+  reference front() { return DV::h_view(0); }
 
-  reference back() {return DV::h_view(_size - 1);}
+  reference back() { return DV::h_view(_size - 1); }
 
-  const_reference front() const {return DV::h_view(0);}
+  const_reference front() const { return DV::h_view(0); }
 
-  const_reference back() const {return DV::h_view(_size - 1);}
+  const_reference back() const { return DV::h_view(_size - 1); }
 
-  /* std::algorithms which work originally with iterators, here they are implemented as member functions */
+  /* std::algorithms which work originally with iterators, here they are
+   * implemented as member functions */
 
-  size_t
-  lower_bound (const size_t& start,
-               const size_t& theEnd,
-               const Scalar& comp_val) const
-  {
-    int lower = start; // FIXME (mfh 24 Apr 2014) narrowing conversion
-    int upper = _size > theEnd? theEnd : _size-1; // FIXME (mfh 24 Apr 2014) narrowing conversion
+  size_t lower_bound(const size_t& start, const size_t& theEnd,
+                     const Scalar& comp_val) const {
+    int lower = start;  // FIXME (mfh 24 Apr 2014) narrowing conversion
+    int upper =
+        _size > theEnd
+            ? theEnd
+            : _size - 1;  // FIXME (mfh 24 Apr 2014) narrowing conversion
     if (upper <= lower) {
       return theEnd;
     }
 
     Scalar lower_val = DV::h_view(lower);
     Scalar upper_val = DV::h_view(upper);
-    size_t idx = (upper+lower)/2;
-    Scalar val = DV::h_view(idx);
-    if(val>upper_val) return upper;
-    if(val<lower_val) return start;
+    size_t idx       = (upper + lower) / 2;
+    Scalar val       = DV::h_view(idx);
+    if (val > upper_val) return upper;
+    if (val < lower_val) return start;
 
-    while(upper>lower) {
-      if(comp_val>val) {
+    while (upper > lower) {
+      if (comp_val > val) {
         lower = ++idx;
       } else {
         upper = idx;
       }
-      idx = (upper+lower)/2;
+      idx = (upper + lower) / 2;
       val = DV::h_view(idx);
     }
     return idx;
   }
 
   bool is_sorted() {
-    for(int i=0;i<_size-1;i++) {
-      if(DV::h_view(i)>DV::h_view(i+1)) return false;
+    for (int i = 0; i < _size - 1; i++) {
+      if (DV::h_view(i) > DV::h_view(i + 1)) return false;
     }
     return true;
   }
 
   iterator find(Scalar val) const {
-    if(_size == 0) return end();
+    if (_size == 0) return end();
 
-    int upper,lower,current;
-    current = _size/2;
-    upper = _size-1;
-    lower = 0;
+    int upper, lower, current;
+    current = _size / 2;
+    upper   = _size - 1;
+    lower   = 0;
 
-    if((val<DV::h_view(0)) || (val>DV::h_view(_size-1)) ) return end();
+    if ((val < DV::h_view(0)) || (val > DV::h_view(_size - 1))) return end();
 
-    while(upper>lower)
-    {
-      if(val>DV::h_view(current)) lower = current+1;
-      else upper = current;
-      current = (upper+lower)/2;
+    while (upper > lower) {
+      if (val > DV::h_view(current))
+        lower = current + 1;
+      else
+        upper = current;
+      current = (upper + lower) / 2;
     }
 
-    if(val==DV::h_view(current)) return &DV::h_view(current);
-    else return end();
+    if (val == DV::h_view(current))
+      return &DV::h_view(current);
+    else
+      return end();
   }
 
   /* Additional functions for data management */
 
-  void device_to_host(){
-    deep_copy(DV::h_view,DV::d_view);
-  }
-  void host_to_device() const {
-    deep_copy(DV::d_view,DV::h_view);
-  }
-
-  void on_host() {
-    DV::template modify<typename DV::t_host::device_type>();
-  }
-  void on_device() {
-    DV::template modify<typename DV::t_dev::device_type>();
-  }
+  void device_to_host() { deep_copy(DV::h_view, DV::d_view); }
+  void host_to_device() const { deep_copy(DV::d_view, DV::h_view); }
 
-  void set_overallocation(float extra) {
-    _extra_storage = 1.0 + extra;
-  }
+  void on_host() { DV::template modify<typename DV::t_host::device_type>(); }
+  void on_device() { DV::template modify<typename DV::t_dev::device_type>(); }
 
+  void set_overallocation(float extra) { _extra_storage = 1.0 + extra; }
 
-public:
+ public:
   struct set_functor {
     typedef typename DV::t_dev::execution_space execution_space;
     typename DV::t_dev _data;
     Scalar _val;
 
-    set_functor(typename DV::t_dev data, Scalar val) :
-      _data(data),_val(val) {}
+    set_functor(typename DV::t_dev data, Scalar val) : _data(data), _val(val) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator() (const int &i) const {
-      _data(i) = _val;
-    }
+    void operator()(const int& i) const { _data(i) = _val; }
   };
 
   struct set_functor_host {
@@ -278,18 +325,13 @@ public:
     typename DV::t_host _data;
     Scalar _val;
 
-    set_functor_host(typename DV::t_host data, Scalar val) :
-      _data(data),_val(val) {}
+    set_functor_host(typename DV::t_host data, Scalar val)
+        : _data(data), _val(val) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator() (const int &i) const {
-      _data(i) = _val;
-    }
+    void operator()(const int& i) const { _data(i) = _val; }
   };
-
 };
 
-
-}
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/containers/src/impl/Kokkos_Bitset_impl.hpp b/lib/kokkos/containers/src/impl/Kokkos_Bitset_impl.hpp
index 7ea2e102cec501bd88a3d872c280c84380aedce0..f5fa4d518a07744162078bfbb37244cf3f0cfb99 100644
--- a/lib/kokkos/containers/src/impl/Kokkos_Bitset_impl.hpp
+++ b/lib/kokkos/containers/src/impl/Kokkos_Bitset_impl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,53 +58,44 @@ namespace Kokkos {
 namespace Impl {
 
 KOKKOS_FORCEINLINE_FUNCTION
-unsigned rotate_right( unsigned i, int r )
-{
-  enum { size = static_cast<int>( sizeof(unsigned) * CHAR_BIT ) };
-  return r ? ( ( i >> r ) | ( i << ( size - r ) ) ) : i ;
+unsigned rotate_right(unsigned i, int r) {
+  enum { size = static_cast<int>(sizeof(unsigned) * CHAR_BIT) };
+  return r ? ((i >> r) | (i << (size - r))) : i;
 }
 
-template < typename Bitset >
-struct BitsetCount
-{
-  typedef Bitset                                                  bitset_type;
-  typedef typename bitset_type::execution_space::execution_space  execution_space;
-  typedef typename bitset_type::size_type                         size_type;
-  typedef size_type                                               value_type;
+template <typename Bitset>
+struct BitsetCount {
+  typedef Bitset bitset_type;
+  typedef
+      typename bitset_type::execution_space::execution_space execution_space;
+  typedef typename bitset_type::size_type size_type;
+  typedef size_type value_type;
 
   bitset_type m_bitset;
 
-  BitsetCount( bitset_type const& bitset )
-    : m_bitset(bitset)
-  {}
+  BitsetCount(bitset_type const& bitset) : m_bitset(bitset) {}
 
-  size_type apply() const
-  {
+  size_type apply() const {
     size_type count = 0u;
-    parallel_reduce( m_bitset.m_blocks.extent(0), *this, count );
+    parallel_reduce(m_bitset.m_blocks.extent(0), *this, count);
     return count;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & count ) const
-  {
-    count = 0u;
-  }
+  void init(value_type& count) const { count = 0u; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & count, const volatile size_type & incr ) const
-  {
+  void join(volatile value_type& count, const volatile size_type& incr) const {
     count += incr;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type i, value_type & count ) const
-  {
-    count += bit_count( m_bitset.m_blocks[i] );
+  void operator()(size_type i, value_type& count) const {
+    count += bit_count(m_bitset.m_blocks[i]);
   }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
-#endif // KOKKOS_BITSET_IMPL_HPP
+#endif  // KOKKOS_BITSET_IMPL_HPP
diff --git a/lib/kokkos/containers/src/impl/Kokkos_Functional_impl.hpp b/lib/kokkos/containers/src/impl/Kokkos_Functional_impl.hpp
index 8b17dcce4b487aa371bfa1a311f562d7ad402c24..6ba67766aa826089c71233a893f6451538f31bb6 100644
--- a/lib/kokkos/containers/src/impl/Kokkos_Functional_impl.hpp
+++ b/lib/kokkos/containers/src/impl/Kokkos_Functional_impl.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,28 +46,24 @@
 #include <Kokkos_Macros.hpp>
 #include <cstdint>
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 // MurmurHash3 was written by Austin Appleby, and is placed in the public
 // domain. The author hereby disclaims copyright to this source code.
 KOKKOS_FORCEINLINE_FUNCTION
-uint32_t getblock32 ( const uint8_t * p, int i )
-{
-// used to avoid aliasing error which could cause errors with
-// forced inlining
-  return    ((uint32_t)p[i*4+0])
-          | ((uint32_t)p[i*4+1] << 8)
-          | ((uint32_t)p[i*4+2] << 16)
-          | ((uint32_t)p[i*4+3] << 24);
+uint32_t getblock32(const uint8_t* p, int i) {
+  // used to avoid aliasing error which could cause errors with
+  // forced inlining
+  return ((uint32_t)p[i * 4 + 0]) | ((uint32_t)p[i * 4 + 1] << 8) |
+         ((uint32_t)p[i * 4 + 2] << 16) | ((uint32_t)p[i * 4 + 3] << 24);
 }
 
 KOKKOS_FORCEINLINE_FUNCTION
-uint32_t rotl32 ( uint32_t x, int8_t r )
-{ return (x << r) | (x >> (32 - r)); }
+uint32_t rotl32(uint32_t x, int8_t r) { return (x << r) | (x >> (32 - r)); }
 
 KOKKOS_FORCEINLINE_FUNCTION
-uint32_t fmix32 ( uint32_t h )
-{
+uint32_t fmix32(uint32_t h) {
   h ^= h >> 16;
   h *= 0x85ebca6b;
   h ^= h >> 13;
@@ -77,10 +74,9 @@ uint32_t fmix32 ( uint32_t h )
 }
 
 KOKKOS_INLINE_FUNCTION
-uint32_t MurmurHash3_x86_32 ( const void * key, int len, uint32_t seed )
-{
-  const uint8_t * data = (const uint8_t*)key;
-  const int nblocks = len / 4;
+uint32_t MurmurHash3_x86_32(const void* key, int len, uint32_t seed) {
+  const uint8_t* data = (const uint8_t*)key;
+  const int nblocks   = len / 4;
 
   uint32_t h1 = seed;
 
@@ -90,32 +86,34 @@ uint32_t MurmurHash3_x86_32 ( const void * key, int len, uint32_t seed )
   //----------
   // body
 
-  for(int i=0; i<nblocks; ++i)
-  {
-    uint32_t k1 = getblock32(data,i);
+  for (int i = 0; i < nblocks; ++i) {
+    uint32_t k1 = getblock32(data, i);
 
     k1 *= c1;
-    k1 = rotl32(k1,15);
+    k1 = rotl32(k1, 15);
     k1 *= c2;
 
     h1 ^= k1;
-    h1 = rotl32(h1,13);
-    h1 = h1*5+0xe6546b64;
+    h1 = rotl32(h1, 13);
+    h1 = h1 * 5 + 0xe6546b64;
   }
 
   //----------
   // tail
 
-  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+  const uint8_t* tail = (const uint8_t*)(data + nblocks * 4);
 
   uint32_t k1 = 0;
 
-  switch(len & 3)
-  {
-  case 3: k1 ^= tail[2] << 16;
-  case 2: k1 ^= tail[1] << 8;
-  case 1: k1 ^= tail[0];
-          k1 *= c1; k1 = rotl32(k1,15); k1 *= c2; h1 ^= k1;
+  switch (len & 3) {
+    case 3: k1 ^= tail[2] << 16;
+    case 2: k1 ^= tail[1] << 8;
+    case 1:
+      k1 ^= tail[0];
+      k1 *= c1;
+      k1 = rotl32(k1, 15);
+      k1 *= c2;
+      h1 ^= k1;
   };
 
   //----------
@@ -128,10 +126,8 @@ uint32_t MurmurHash3_x86_32 ( const void * key, int len, uint32_t seed )
   return h1;
 }
 
-
-#if defined( __GNUC__ ) /* GNU C   */ || \
-    defined( __GNUG__ ) /* GNU C++ */ || \
-    defined( __clang__ )
+#if defined(__GNUC__) /* GNU C   */ || defined(__GNUG__) /* GNU C++ */ || \
+    defined(__clang__)
 
 #define KOKKOS_IMPL_MAY_ALIAS __attribute__((__may_alias__))
 
@@ -142,13 +138,12 @@ uint32_t MurmurHash3_x86_32 ( const void * key, int len, uint32_t seed )
 #endif
 
 template <typename T>
-KOKKOS_FORCEINLINE_FUNCTION
-bool bitwise_equal(T const * const a_ptr, T const * const b_ptr)
-{
+KOKKOS_FORCEINLINE_FUNCTION bool bitwise_equal(T const* const a_ptr,
+                                               T const* const b_ptr) {
   typedef uint64_t KOKKOS_IMPL_MAY_ALIAS T64;
   typedef uint32_t KOKKOS_IMPL_MAY_ALIAS T32;
   typedef uint16_t KOKKOS_IMPL_MAY_ALIAS T16;
-  typedef uint8_t  KOKKOS_IMPL_MAY_ALIAS T8;
+  typedef uint8_t KOKKOS_IMPL_MAY_ALIAS T8;
 
   enum {
     NUM_8  = sizeof(T),
@@ -158,39 +153,37 @@ bool bitwise_equal(T const * const a_ptr, T const * const b_ptr)
   };
 
   union {
-    T   const * const ptr;
-    T64 const * const ptr64;
-    T32 const * const ptr32;
-    T16 const * const ptr16;
-    T8  const * const ptr8;
+    T const* const ptr;
+    T64 const* const ptr64;
+    T32 const* const ptr32;
+    T16 const* const ptr16;
+    T8 const* const ptr8;
   } a = {a_ptr}, b = {b_ptr};
 
   bool result = true;
 
-  for (int i=0; i < NUM_64; ++i) {
+  for (int i = 0; i < NUM_64; ++i) {
     result = result && a.ptr64[i] == b.ptr64[i];
   }
 
-  if ( NUM_64*2 < NUM_32 ) {
-    result = result && a.ptr32[NUM_64*2] == b.ptr32[NUM_64*2];
+  if (NUM_64 * 2 < NUM_32) {
+    result = result && a.ptr32[NUM_64 * 2] == b.ptr32[NUM_64 * 2];
   }
 
-  if ( NUM_32*2 < NUM_16 ) {
-    result = result && a.ptr16[NUM_32*2] == b.ptr16[NUM_32*2];
+  if (NUM_32 * 2 < NUM_16) {
+    result = result && a.ptr16[NUM_32 * 2] == b.ptr16[NUM_32 * 2];
   }
 
-  if ( NUM_16*2 < NUM_8 ) {
-    result = result && a.ptr8[NUM_16*2] == b.ptr8[NUM_16*2];
+  if (NUM_16 * 2 < NUM_8) {
+    result = result && a.ptr8[NUM_16 * 2] == b.ptr8[NUM_16 * 2];
   }
 
   return result;
 }
 
-
-
 #undef KOKKOS_IMPL_MAY_ALIAS
 
-}} // namespace Kokkos::Impl
-
-#endif //KOKKOS_FUNCTIONAL_IMPL_HPP
+}  // namespace Impl
+}  // namespace Kokkos
 
+#endif  // KOKKOS_FUNCTIONAL_IMPL_HPP
diff --git a/lib/kokkos/containers/src/impl/Kokkos_StaticCrsGraph_factory.hpp b/lib/kokkos/containers/src/impl/Kokkos_StaticCrsGraph_factory.hpp
index 743c345b45ab35f2c60539e25f305644049903d1..d644c57c0ac1c4a57623aefbd7a31dfba6076134 100644
--- a/lib/kokkos/containers/src/impl/Kokkos_StaticCrsGraph_factory.hpp
+++ b/lib/kokkos/containers/src/impl/Kokkos_StaticCrsGraph_factory.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -50,193 +51,207 @@
 namespace Kokkos {
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-template< class DataType , class Arg1Type , class Arg2Type , typename SizeType , class Arg3Type>
-inline
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type >::HostMirror
-create_mirror_view( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,SizeType,Arg3Type > & view ,
-                    typename Impl::enable_if< ViewTraits<DataType,Arg1Type,Arg2Type,Arg3Type>::is_hostspace >::type * = 0 )
-{
-  return view ;
+template <class DataType, class Arg1Type, class Arg2Type, typename SizeType,
+          class Arg3Type>
+inline typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                               Arg3Type>::HostMirror
+create_mirror_view(
+    const StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType, Arg3Type>&
+        view,
+    typename Impl::enable_if<ViewTraits<DataType, Arg1Type, Arg2Type,
+                                        Arg3Type>::is_hostspace>::type* = 0) {
+  return view;
 }
 #else
-template< class DataType , class Arg1Type , class Arg2Type , class Arg3Type, typename SizeType >
-inline
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type , SizeType >::HostMirror
-create_mirror_view( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,Arg3Type,SizeType > & view ,
-                    typename Impl::enable_if< ViewTraits<DataType,Arg1Type,Arg2Type,Arg3Type>::is_hostspace >::type * = 0 )
-{
-  return view ;
+template <class DataType, class Arg1Type, class Arg2Type, class Arg3Type,
+          typename SizeType>
+inline typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                               SizeType>::HostMirror
+create_mirror_view(
+    const StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type, SizeType>&
+        view,
+    typename Impl::enable_if<ViewTraits<DataType, Arg1Type, Arg2Type,
+                                        Arg3Type>::is_hostspace>::type* = 0) {
+  return view;
 }
 #endif
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-template< class DataType , class Arg1Type , class Arg2Type , typename SizeType , class Arg3Type>
-inline
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type >::HostMirror
-create_mirror( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,SizeType,Arg3Type > & view )
-{
+template <class DataType, class Arg1Type, class Arg2Type, typename SizeType,
+          class Arg3Type>
+inline typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                               Arg3Type>::HostMirror
+create_mirror(const StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                                   Arg3Type>& view) {
   // Force copy:
-  //typedef Impl::ViewAssignment< Impl::ViewDefault > alloc ; // unused
-  typedef StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type >  staticcrsgraph_type ;
+  // typedef Impl::ViewAssignment< Impl::ViewDefault > alloc ; // unused
+  typedef StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType, Arg3Type>
+      staticcrsgraph_type;
 #else
-template< class DataType , class Arg1Type , class Arg2Type , class Arg3Type, typename SizeType >
-inline
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type , SizeType >::HostMirror
-create_mirror( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,Arg3Type,SizeType > & view )
-{
+template <class DataType, class Arg1Type, class Arg2Type, class Arg3Type,
+          typename SizeType>
+inline typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                               SizeType>::HostMirror
+create_mirror(const StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                                   SizeType>& view) {
   // Force copy:
-  //typedef Impl::ViewAssignment< Impl::ViewDefault > alloc ; // unused
-  typedef StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type , SizeType >  staticcrsgraph_type ;
+  // typedef Impl::ViewAssignment< Impl::ViewDefault > alloc ; // unused
+  typedef StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type, SizeType>
+      staticcrsgraph_type;
 #endif
 
-  typename staticcrsgraph_type::HostMirror               tmp ;
-  typename staticcrsgraph_type::row_map_type::HostMirror tmp_row_map = create_mirror( view.row_map);
-  typename staticcrsgraph_type::row_block_type::HostMirror tmp_row_block_offsets = create_mirror( view.row_block_offsets);
+  typename staticcrsgraph_type::HostMirror tmp;
+  typename staticcrsgraph_type::row_map_type::HostMirror tmp_row_map =
+      create_mirror(view.row_map);
+  typename staticcrsgraph_type::row_block_type::HostMirror
+      tmp_row_block_offsets = create_mirror(view.row_block_offsets);
 
   // Allocation to match:
-  tmp.row_map = tmp_row_map ; // Assignment of 'const' from 'non-const'
-  tmp.entries = create_mirror( view.entries );
-  tmp.row_block_offsets = tmp_row_block_offsets ; // Assignment of 'const' from 'non-const'
+  tmp.row_map = tmp_row_map;  // Assignment of 'const' from 'non-const'
+  tmp.entries = create_mirror(view.entries);
+  tmp.row_block_offsets =
+      tmp_row_block_offsets;  // Assignment of 'const' from 'non-const'
 
   // Deep copy:
-  deep_copy( tmp_row_map , view.row_map );
-  deep_copy( tmp.entries , view.entries );
-  deep_copy( tmp_row_block_offsets , view.row_block_offsets );
+  deep_copy(tmp_row_map, view.row_map);
+  deep_copy(tmp.entries, view.entries);
+  deep_copy(tmp_row_block_offsets, view.row_block_offsets);
 
-  return tmp ;
+  return tmp;
 }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-template< class DataType , class Arg1Type , class Arg2Type , typename SizeType , class Arg3Type>
-inline
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , SizeType , Arg3Type >::HostMirror
-create_mirror_view( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,SizeType,Arg3Type > & view ,
-                    typename Impl::enable_if< ! ViewTraits<DataType,Arg1Type,Arg2Type,Arg3Type>::is_hostspace >::type * = 0 )
+template <class DataType, class Arg1Type, class Arg2Type, typename SizeType,
+          class Arg3Type>
+inline typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType,
+                               Arg3Type>::HostMirror
+create_mirror_view(
+    const StaticCrsGraph<DataType, Arg1Type, Arg2Type, SizeType, Arg3Type>&
+        view,
+    typename Impl::enable_if<!ViewTraits<DataType, Arg1Type, Arg2Type,
+                                         Arg3Type>::is_hostspace>::type* = 0)
 #else
-template< class DataType , class Arg1Type , class Arg2Type , class Arg3Type, typename SizeType >
-inline
-typename StaticCrsGraph< DataType , Arg1Type , Arg2Type , Arg3Type , SizeType >::HostMirror
-create_mirror_view( const StaticCrsGraph<DataType,Arg1Type,Arg2Type,Arg3Type,SizeType > & view ,
-                    typename Impl::enable_if< ! ViewTraits<DataType,Arg1Type,Arg2Type,Arg3Type>::is_hostspace >::type * = 0 )
+template <class DataType, class Arg1Type, class Arg2Type, class Arg3Type,
+          typename SizeType>
+inline typename StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type,
+                               SizeType>::HostMirror
+create_mirror_view(
+    const StaticCrsGraph<DataType, Arg1Type, Arg2Type, Arg3Type, SizeType>&
+        view,
+    typename Impl::enable_if<!ViewTraits<DataType, Arg1Type, Arg2Type,
+                                         Arg3Type>::is_hostspace>::type* = 0)
 #endif
 {
-  return create_mirror( view );
+  return create_mirror(view);
 }
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-template< class StaticCrsGraphType , class InputSizeType >
-inline
-typename StaticCrsGraphType::staticcrsgraph_type
-create_staticcrsgraph( const std::string & label ,
-                 const std::vector< InputSizeType > & input )
-{
-  typedef StaticCrsGraphType                  output_type ;
-  //typedef std::vector< InputSizeType >  input_type ; // unused
+template <class StaticCrsGraphType, class InputSizeType>
+inline typename StaticCrsGraphType::staticcrsgraph_type create_staticcrsgraph(
+    const std::string& label, const std::vector<InputSizeType>& input) {
+  typedef StaticCrsGraphType output_type;
+  // typedef std::vector< InputSizeType >  input_type ; // unused
 
-  typedef typename output_type::entries_type   entries_type ;
+  typedef typename output_type::entries_type entries_type;
 
-  typedef View< typename output_type::size_type [] ,
-                typename output_type::array_layout ,
-                typename output_type::execution_space,
-                typename output_type::memory_traits > work_type ;
+  typedef View<typename output_type::size_type[],
+               typename output_type::array_layout,
+               typename output_type::execution_space,
+               typename output_type::memory_traits>
+      work_type;
 
-  output_type output ;
+  output_type output;
 
   // Create the row map:
 
   const size_t length = input.size();
 
   {
-    work_type row_work( "tmp" , length + 1 );
+    work_type row_work("tmp", length + 1);
 
-    typename work_type::HostMirror row_work_host =
-      create_mirror_view( row_work );
+    typename work_type::HostMirror row_work_host = create_mirror_view(row_work);
 
-    size_t sum = 0 ;
-    row_work_host[0] = 0 ;
-    for ( size_t i = 0 ; i < length ; ++i ) {
-      row_work_host[i+1] = sum += input[i];
+    size_t sum       = 0;
+    row_work_host[0] = 0;
+    for (size_t i = 0; i < length; ++i) {
+      row_work_host[i + 1] = sum += input[i];
     }
 
-    deep_copy( row_work , row_work_host );
+    deep_copy(row_work, row_work_host);
 
-    output.entries   = entries_type( label , sum );
-    output.row_map   = row_work ;
+    output.entries = entries_type(label, sum);
+    output.row_map = row_work;
   }
 
-  return output ;
+  return output;
 }
 
 //----------------------------------------------------------------------------
 
-template< class StaticCrsGraphType , class InputSizeType >
-inline
-typename StaticCrsGraphType::staticcrsgraph_type
-create_staticcrsgraph( const std::string & label ,
-                 const std::vector< std::vector< InputSizeType > > & input )
-{
-  typedef StaticCrsGraphType                  output_type ;
-  typedef typename output_type::entries_type  entries_type ;
+template <class StaticCrsGraphType, class InputSizeType>
+inline typename StaticCrsGraphType::staticcrsgraph_type create_staticcrsgraph(
+    const std::string& label,
+    const std::vector<std::vector<InputSizeType> >& input) {
+  typedef StaticCrsGraphType output_type;
+  typedef typename output_type::entries_type entries_type;
 
-  static_assert( entries_type::rank == 1
-               , "Graph entries view must be rank one" );
+  static_assert(entries_type::rank == 1, "Graph entries view must be rank one");
 
-  typedef View< typename output_type::size_type [] ,
-                typename output_type::array_layout ,
-                typename output_type::execution_space,
-                typename output_type::memory_traits > work_type ;
+  typedef View<typename output_type::size_type[],
+               typename output_type::array_layout,
+               typename output_type::execution_space,
+               typename output_type::memory_traits>
+      work_type;
 
-  output_type output ;
+  output_type output;
 
-    // Create the row map:
+  // Create the row map:
 
   const size_t length = input.size();
 
   {
-    work_type row_work( "tmp" , length + 1 );
+    work_type row_work("tmp", length + 1);
 
-    typename work_type::HostMirror row_work_host =
-      create_mirror_view( row_work );
+    typename work_type::HostMirror row_work_host = create_mirror_view(row_work);
 
-    size_t sum = 0 ;
-    row_work_host[0] = 0 ;
-    for ( size_t i = 0 ; i < length ; ++i ) {
-      row_work_host[i+1] = sum += input[i].size();
+    size_t sum       = 0;
+    row_work_host[0] = 0;
+    for (size_t i = 0; i < length; ++i) {
+      row_work_host[i + 1] = sum += input[i].size();
     }
 
-    deep_copy( row_work , row_work_host );
+    deep_copy(row_work, row_work_host);
 
-    output.entries   = entries_type( label , sum );
-    output.row_map   = row_work ;
+    output.entries = entries_type(label, sum);
+    output.row_map = row_work;
   }
 
   // Fill in the entries:
   {
     typename entries_type::HostMirror host_entries =
-      create_mirror_view( output.entries );
+        create_mirror_view(output.entries);
 
-    size_t sum = 0 ;
-    for ( size_t i = 0 ; i < length ; ++i ) {
-      for ( size_t j = 0 ; j < input[i].size() ; ++j , ++sum ) {
-        host_entries( sum ) = input[i][j] ;
+    size_t sum = 0;
+    for (size_t i = 0; i < length; ++i) {
+      for (size_t j = 0; j < input[i].size(); ++j, ++sum) {
+        host_entries(sum) = input[i][j];
       }
     }
 
-    deep_copy( output.entries , host_entries );
+    deep_copy(output.entries, host_entries);
   }
 
-  return output ;
+  return output;
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_IMPL_CRSARRAY_FACTORY_HPP */
-
diff --git a/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.cpp b/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.cpp
index 88ca200daf3004fb80d08c19a304ac8e7dfef9e7..e10e256b6a8d1e6e48f8e80b205cd097a3486723 100644
--- a/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.cpp
+++ b/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,58 +37,62 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
 #include <Kokkos_UnorderedMap.hpp>
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
-uint32_t find_hash_size(uint32_t size)
-{
+uint32_t find_hash_size(uint32_t size) {
   if (size == 0u) return 0u;
 
   // these primes try to preserve randomness of hash
-  static const uint32_t primes [] = {
-        3, 7, 13, 23, 53, 97, 193, 389, 769, 1543
-      , 2237, 2423, 2617, 2797, 2999, 3167, 3359, 3539
-      , 3727, 3911, 4441 , 4787 , 5119 , 5471 , 5801 , 6143 , 6521 , 6827
-      , 7177 , 7517 , 7853 , 8887 , 9587 , 10243 , 10937 , 11617 , 12289
-      , 12967 , 13649 , 14341 , 15013 , 15727
-      , 17749 , 19121 , 20479 , 21859 , 23209 , 24593 , 25939 , 27329
-      , 28669 , 30047 , 31469 , 35507 , 38231 , 40961 , 43711 , 46439
-      , 49157 , 51893 , 54617 , 57347 , 60077 , 62801 , 70583 , 75619
-      , 80669 , 85703 , 90749 , 95783 , 100823 , 105871 , 110909 , 115963
-      , 120997 , 126031 , 141157 , 151237 , 161323 , 171401 , 181499 , 191579
-      , 201653 , 211741 , 221813 , 231893 , 241979 , 252079
-      , 282311 , 302483 , 322649 , 342803 , 362969 , 383143 , 403301 , 423457
-      , 443629 , 463787 , 483953 , 504121 , 564617 , 604949 , 645313 , 685609
-      , 725939 , 766273 , 806609 , 846931 , 887261 , 927587 , 967919 , 1008239
-      , 1123477 , 1198397 , 1273289 , 1348177 , 1423067 , 1497983 , 1572869
-      , 1647761 , 1722667 , 1797581 , 1872461 , 1947359 , 2022253
-      , 2246953 , 2396759 , 2546543 , 2696363 , 2846161 , 2995973 , 3145739
-      , 3295541 , 3445357 , 3595117 , 3744941 , 3894707 , 4044503
-      , 4493921 , 4793501 , 5093089 , 5392679 , 5692279 , 5991883 , 6291469
-      , 6591059 , 6890641 , 7190243 , 7489829 , 7789447 , 8089033
-      , 8987807 , 9586981 , 10186177 , 10785371 , 11384539 , 11983729
-      , 12582917 , 13182109 , 13781291 , 14380469 , 14979667 , 15578861
-      , 16178053 , 17895707 , 19014187 , 20132683 , 21251141 , 22369661
-      , 23488103 , 24606583 , 25725083 , 26843549 , 27962027 , 29080529
-      , 30198989 , 31317469 , 32435981 , 35791397 , 38028379 , 40265327
-      , 42502283 , 44739259 , 46976221 , 49213237 , 51450131 , 53687099
-      , 55924061 , 58161041 , 60397993 , 62634959 , 64871921
-      , 71582857 , 76056727 , 80530643 , 85004567 , 89478503 , 93952427
-      , 98426347 , 102900263 , 107374217 , 111848111 , 116322053 , 120795971
-      , 125269877 , 129743807 , 143165587 , 152113427 , 161061283 , 170009141
-      , 178956983 , 187904819 , 196852693 , 205800547 , 214748383 , 223696237
-      , 232644089 , 241591943 , 250539763 , 259487603 , 268435399
-  };
+  static const uint32_t primes[] = {
+      3,         7,         13,        23,        53,        97,
+      193,       389,       769,       1543,      2237,      2423,
+      2617,      2797,      2999,      3167,      3359,      3539,
+      3727,      3911,      4441,      4787,      5119,      5471,
+      5801,      6143,      6521,      6827,      7177,      7517,
+      7853,      8887,      9587,      10243,     10937,     11617,
+      12289,     12967,     13649,     14341,     15013,     15727,
+      17749,     19121,     20479,     21859,     23209,     24593,
+      25939,     27329,     28669,     30047,     31469,     35507,
+      38231,     40961,     43711,     46439,     49157,     51893,
+      54617,     57347,     60077,     62801,     70583,     75619,
+      80669,     85703,     90749,     95783,     100823,    105871,
+      110909,    115963,    120997,    126031,    141157,    151237,
+      161323,    171401,    181499,    191579,    201653,    211741,
+      221813,    231893,    241979,    252079,    282311,    302483,
+      322649,    342803,    362969,    383143,    403301,    423457,
+      443629,    463787,    483953,    504121,    564617,    604949,
+      645313,    685609,    725939,    766273,    806609,    846931,
+      887261,    927587,    967919,    1008239,   1123477,   1198397,
+      1273289,   1348177,   1423067,   1497983,   1572869,   1647761,
+      1722667,   1797581,   1872461,   1947359,   2022253,   2246953,
+      2396759,   2546543,   2696363,   2846161,   2995973,   3145739,
+      3295541,   3445357,   3595117,   3744941,   3894707,   4044503,
+      4493921,   4793501,   5093089,   5392679,   5692279,   5991883,
+      6291469,   6591059,   6890641,   7190243,   7489829,   7789447,
+      8089033,   8987807,   9586981,   10186177,  10785371,  11384539,
+      11983729,  12582917,  13182109,  13781291,  14380469,  14979667,
+      15578861,  16178053,  17895707,  19014187,  20132683,  21251141,
+      22369661,  23488103,  24606583,  25725083,  26843549,  27962027,
+      29080529,  30198989,  31317469,  32435981,  35791397,  38028379,
+      40265327,  42502283,  44739259,  46976221,  49213237,  51450131,
+      53687099,  55924061,  58161041,  60397993,  62634959,  64871921,
+      71582857,  76056727,  80530643,  85004567,  89478503,  93952427,
+      98426347,  102900263, 107374217, 111848111, 116322053, 120795971,
+      125269877, 129743807, 143165587, 152113427, 161061283, 170009141,
+      178956983, 187904819, 196852693, 205800547, 214748383, 223696237,
+      232644089, 241591943, 250539763, 259487603, 268435399};
 
-  const uint32_t num_primes = sizeof(primes)/sizeof(uint32_t);
+  const uint32_t num_primes = sizeof(primes) / sizeof(uint32_t);
 
-  uint32_t hsize = primes[num_primes-1] ;
+  uint32_t hsize = primes[num_primes - 1];
   for (uint32_t i = 0; i < num_primes; ++i) {
     if (size <= primes[i]) {
       hsize = primes[i];
@@ -97,5 +102,5 @@ uint32_t find_hash_size(uint32_t size)
   return hsize;
 }
 
-}} // namespace Kokkos::Impl
-
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.hpp b/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.hpp
index f97c1fc0468f7049b03770749ae678270d812e1d..55e76c424df86746db72c9451844aa8e9c4107f7 100644
--- a/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.hpp
+++ b/lib/kokkos/containers/src/impl/Kokkos_UnorderedMap_impl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,42 +53,34 @@
 #include <iostream>
 #include <iomanip>
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
-uint32_t find_hash_size( uint32_t size );
+uint32_t find_hash_size(uint32_t size);
 
 template <typename Map>
-struct UnorderedMapRehash
-{
+struct UnorderedMapRehash {
   typedef Map map_type;
   typedef typename map_type::const_map_type const_map_type;
   typedef typename map_type::execution_space execution_space;
   typedef typename map_type::size_type size_type;
 
-  map_type       m_dst;
+  map_type m_dst;
   const_map_type m_src;
 
-  UnorderedMapRehash( map_type const& dst, const_map_type const& src)
-    : m_dst(dst), m_src(src)
-  {}
+  UnorderedMapRehash(map_type const& dst, const_map_type const& src)
+      : m_dst(dst), m_src(src) {}
 
-  void apply() const
-  {
-    parallel_for(m_src.capacity(), *this);
-  }
+  void apply() const { parallel_for(m_src.capacity(), *this); }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(size_type i) const
-  {
-    if ( m_src.valid_at(i) )
-      m_dst.insert(m_src.key_at(i), m_src.value_at(i));
+  void operator()(size_type i) const {
+    if (m_src.valid_at(i)) m_dst.insert(m_src.key_at(i), m_src.value_at(i));
   }
-
 };
 
 template <typename UMap>
-struct UnorderedMapErase
-{
+struct UnorderedMapErase {
   typedef UMap map_type;
   typedef typename map_type::execution_space execution_space;
   typedef typename map_type::size_type size_type;
@@ -96,18 +89,12 @@ struct UnorderedMapErase
 
   map_type m_map;
 
-  UnorderedMapErase( map_type const& map)
-    : m_map(map)
-  {}
+  UnorderedMapErase(map_type const& map) : m_map(map) {}
 
-  void apply() const
-  {
-    parallel_for(m_map.m_hash_lists.extent(0), *this);
-  }
+  void apply() const { parallel_for(m_map.m_hash_lists.extent(0), *this); }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type i ) const
-  {
+  void operator()(size_type i) const {
     const size_type invalid_index = map_type::invalid_index;
 
     size_type curr = m_map.m_hash_lists(i);
@@ -115,29 +102,28 @@ struct UnorderedMapErase
 
     // remove erased head of the linked-list
     while (curr != invalid_index && !m_map.valid_at(curr)) {
-      next = m_map.m_next_index[curr];
+      next                     = m_map.m_next_index[curr];
       m_map.m_next_index[curr] = invalid_index;
-      m_map.m_keys[curr] = key_type();
+      m_map.m_keys[curr]       = key_type();
       if (m_map.is_set) m_map.m_values[curr] = value_type();
-      curr = next;
+      curr                  = next;
       m_map.m_hash_lists(i) = next;
     }
 
     // if the list is non-empty and the head is valid
-    if (curr != invalid_index && m_map.valid_at(curr) ) {
+    if (curr != invalid_index && m_map.valid_at(curr)) {
       size_type prev = curr;
-      curr = m_map.m_next_index[prev];
+      curr           = m_map.m_next_index[prev];
 
       while (curr != invalid_index) {
         next = m_map.m_next_index[curr];
         if (m_map.valid_at(curr)) {
           prev = curr;
-        }
-        else {
+        } else {
           // remove curr from list
           m_map.m_next_index[prev] = next;
           m_map.m_next_index[curr] = invalid_index;
-          m_map.m_keys[curr] = key_type();
+          m_map.m_keys[curr]       = key_type();
           if (map_type::is_set) m_map.m_values[curr] = value_type();
         }
         curr = next;
@@ -147,8 +133,7 @@ struct UnorderedMapErase
 };
 
 template <typename UMap>
-struct UnorderedMapHistogram
-{
+struct UnorderedMapHistogram {
   typedef UMap map_type;
   typedef typename map_type::execution_space execution_space;
   typedef typename map_type::size_type size_type;
@@ -161,117 +146,100 @@ struct UnorderedMapHistogram
   histogram_view m_distance;
   histogram_view m_block_distance;
 
-  UnorderedMapHistogram( map_type const& map)
-    : m_map(map)
-    , m_length("UnorderedMap Histogram")
-    , m_distance("UnorderedMap Histogram")
-    , m_block_distance("UnorderedMap Histogram")
-  {}
+  UnorderedMapHistogram(map_type const& map)
+      : m_map(map),
+        m_length("UnorderedMap Histogram"),
+        m_distance("UnorderedMap Histogram"),
+        m_block_distance("UnorderedMap Histogram") {}
 
-  void calculate()
-  {
-    parallel_for(m_map.m_hash_lists.extent(0), *this);
-  }
+  void calculate() { parallel_for(m_map.m_hash_lists.extent(0), *this); }
 
-  void clear()
-  {
+  void clear() {
     Kokkos::deep_copy(m_length, 0);
     Kokkos::deep_copy(m_distance, 0);
     Kokkos::deep_copy(m_block_distance, 0);
   }
 
-  void print_length(std::ostream &out)
-  {
+  void print_length(std::ostream& out) {
     host_histogram_view host_copy = create_mirror_view(m_length);
     Kokkos::deep_copy(host_copy, m_length);
 
-    for (int i=0, size = host_copy.extent(0); i<size; ++i)
-    {
+    for (int i = 0, size = host_copy.extent(0); i < size; ++i) {
       out << host_copy[i] << " , ";
     }
     out << "\b\b\b   " << std::endl;
   }
 
-  void print_distance(std::ostream &out)
-  {
+  void print_distance(std::ostream& out) {
     host_histogram_view host_copy = create_mirror_view(m_distance);
     Kokkos::deep_copy(host_copy, m_distance);
 
-    for (int i=0, size = host_copy.extent(0); i<size; ++i)
-    {
+    for (int i = 0, size = host_copy.extent(0); i < size; ++i) {
       out << host_copy[i] << " , ";
     }
     out << "\b\b\b   " << std::endl;
   }
 
-  void print_block_distance(std::ostream &out)
-  {
+  void print_block_distance(std::ostream& out) {
     host_histogram_view host_copy = create_mirror_view(m_block_distance);
     Kokkos::deep_copy(host_copy, m_block_distance);
 
-    for (int i=0, size = host_copy.extent(0); i<size; ++i)
-    {
+    for (int i = 0, size = host_copy.extent(0); i < size; ++i) {
       out << host_copy[i] << " , ";
     }
     out << "\b\b\b   " << std::endl;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type i ) const
-  {
+  void operator()(size_type i) const {
     const size_type invalid_index = map_type::invalid_index;
 
-    uint32_t length = 0;
+    uint32_t length     = 0;
     size_type min_index = ~0u, max_index = 0;
-    for (size_type curr = m_map.m_hash_lists(i); curr != invalid_index; curr = m_map.m_next_index[curr]) {
+    for (size_type curr = m_map.m_hash_lists(i); curr != invalid_index;
+         curr           = m_map.m_next_index[curr]) {
       ++length;
       min_index = (curr < min_index) ? curr : min_index;
       max_index = (max_index < curr) ? curr : max_index;
     }
 
     size_type distance = (0u < length) ? max_index - min_index : 0u;
-    size_type blocks = (0u < length) ? max_index/32u - min_index/32u : 0u;
+    size_type blocks   = (0u < length) ? max_index / 32u - min_index / 32u : 0u;
 
     // normalize data
-    length   = length   < 100u ? length   : 99u;
+    length   = length < 100u ? length : 99u;
     distance = distance < 100u ? distance : 99u;
-    blocks   = blocks   < 100u ? blocks   : 99u;
+    blocks   = blocks < 100u ? blocks : 99u;
 
-    if (0u < length)
-    {
-      atomic_fetch_add( &m_length(length), 1);
-      atomic_fetch_add( &m_distance(distance), 1);
-      atomic_fetch_add( &m_block_distance(blocks), 1);
+    if (0u < length) {
+      atomic_fetch_add(&m_length(length), 1);
+      atomic_fetch_add(&m_distance(distance), 1);
+      atomic_fetch_add(&m_block_distance(blocks), 1);
     }
   }
 };
 
 template <typename UMap>
-struct UnorderedMapPrint
-{
+struct UnorderedMapPrint {
   typedef UMap map_type;
   typedef typename map_type::execution_space execution_space;
   typedef typename map_type::size_type size_type;
 
   map_type m_map;
 
-  UnorderedMapPrint( map_type const& map)
-    : m_map(map)
-  {}
+  UnorderedMapPrint(map_type const& map) : m_map(map) {}
 
-  void apply()
-  {
-    parallel_for(m_map.m_hash_lists.extent(0), *this);
-  }
+  void apply() { parallel_for(m_map.m_hash_lists.extent(0), *this); }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type i ) const
-  {
+  void operator()(size_type i) const {
     const size_type invalid_index = map_type::invalid_index;
 
     uint32_t list = m_map.m_hash_lists(i);
-    for (size_type curr = list, ii=0; curr != invalid_index; curr = m_map.m_next_index[curr], ++ii) {
-      printf("%d[%d]: %d->%d\n", list, ii, m_map.key_at(curr), m_map.value_at(curr));
+    for (size_type curr = list, ii = 0; curr != invalid_index;
+         curr = m_map.m_next_index[curr], ++ii) {
+      printf("%d[%d]: %d->%d\n", list, ii, m_map.key_at(curr),
+             m_map.value_at(curr));
     }
   }
 };
@@ -280,19 +248,20 @@ template <typename DKey, typename DValue, typename SKey, typename SValue>
 struct UnorderedMapCanAssign : public false_ {};
 
 template <typename Key, typename Value>
-struct UnorderedMapCanAssign<Key,Value,Key,Value> : public true_ {};
+struct UnorderedMapCanAssign<Key, Value, Key, Value> : public true_ {};
 
 template <typename Key, typename Value>
-struct UnorderedMapCanAssign<const Key,Value,Key,Value> : public true_ {};
+struct UnorderedMapCanAssign<const Key, Value, Key, Value> : public true_ {};
 
 template <typename Key, typename Value>
-struct UnorderedMapCanAssign<const Key,const Value,Key,Value> : public true_ {};
+struct UnorderedMapCanAssign<const Key, const Value, Key, Value>
+    : public true_ {};
 
 template <typename Key, typename Value>
-struct UnorderedMapCanAssign<const Key,const Value,const Key,Value> : public true_ {};
-
-
-}} //Kokkos::Impl
+struct UnorderedMapCanAssign<const Key, const Value, const Key, Value>
+    : public true_ {};
 
-#endif // KOKKOS_UNORDERED_MAP_IMPL_HPP
+}  // namespace Impl
+}  // namespace Kokkos
 
+#endif  // KOKKOS_UNORDERED_MAP_IMPL_HPP
diff --git a/lib/kokkos/containers/unit_tests/CMakeLists.txt b/lib/kokkos/containers/unit_tests/CMakeLists.txt
index 8564bd9ddd652af73d834dd784fd3598b9801f56..a83ab1293c19d257106012e0f879a83bebbd42e8 100644
--- a/lib/kokkos/containers/unit_tests/CMakeLists.txt
+++ b/lib/kokkos/containers/unit_tests/CMakeLists.txt
@@ -1,138 +1,35 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../src )
-
-IF(NOT KOKKOS_HAS_TRILINOS)
-  IF(KOKKOS_SEPARATE_LIBS)
-    set(TEST_LINK_TARGETS kokkoscore)
-  ELSE()
-    set(TEST_LINK_TARGETS kokkos)
-  ENDIF()
-ENDIF()
-
-IF(Kokkos_ENABLE_Pthread)
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_Threads
-  SOURCES
-    UnitTestMain.cpp
-    threads/TestThreads_BitSet.cpp
-    threads/TestThreads_DualView.cpp
-    threads/TestThreads_DynamicView.cpp
-    threads/TestThreads_DynRankViewAPI_generic.cpp
-    threads/TestThreads_DynRankViewAPI_rank12345.cpp
-    threads/TestThreads_DynRankViewAPI_rank67.cpp
-    threads/TestThreads_ErrorReporter.cpp
-    threads/TestThreads_OffsetView.cpp
-    threads/TestThreads_ScatterView.cpp
-    threads/TestThreads_StaticCrsGraph.cpp
-    threads/TestThreads_UnorderedMap.cpp
-    threads/TestThreads_Vector.cpp
-    threads/TestThreads_ViewCtorPropEmbeddedDim.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-ENDIF()
-
-IF(Kokkos_ENABLE_Serial)
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_Serial
-  SOURCES
-    UnitTestMain.cpp
-    serial/TestSerial_BitSet.cpp
-    serial/TestSerial_DualView.cpp
-    serial/TestSerial_DynamicView.cpp
-    serial/TestSerial_DynRankViewAPI_generic.cpp
-    serial/TestSerial_DynRankViewAPI_rank12345.cpp
-    serial/TestSerial_DynRankViewAPI_rank67.cpp
-    serial/TestSerial_ErrorReporter.cpp
-    serial/TestSerial_OffsetView.cpp
-    serial/TestSerial_ScatterView.cpp
-    serial/TestSerial_StaticCrsGraph.cpp
-    serial/TestSerial_UnorderedMap.cpp
-    serial/TestSerial_Vector.cpp
-    serial/TestSerial_ViewCtorPropEmbeddedDim.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-ENDIF()
-
-IF(Kokkos_ENABLE_OpenMP)
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_OpenMP
-  SOURCES
-    UnitTestMain.cpp
-    openmp/TestOpenMP_BitSet.cpp
-    openmp/TestOpenMP_DualView.cpp
-    openmp/TestOpenMP_DynamicView.cpp
-    openmp/TestOpenMP_DynRankViewAPI_generic.cpp
-    openmp/TestOpenMP_DynRankViewAPI_rank12345.cpp
-    openmp/TestOpenMP_DynRankViewAPI_rank67.cpp
-    openmp/TestOpenMP_ErrorReporter.cpp
-    openmp/TestOpenMP_OffsetView.cpp
-    openmp/TestOpenMP_ScatterView.cpp
-    openmp/TestOpenMP_StaticCrsGraph.cpp
-    openmp/TestOpenMP_UnorderedMap.cpp
-    openmp/TestOpenMP_Vector.cpp
-    openmp/TestOpenMP_ViewCtorPropEmbeddedDim.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-ENDIF()
-
-IF(Kokkos_ENABLE_HPX)
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_HPX
-  SOURCES
-    UnitTestMain.cpp
-    hpx/TestHPX_BitSet.cpp
-    hpx/TestHPX_DualView.cpp
-    hpx/TestHPX_DynamicView.cpp
-    hpx/TestHPX_DynRankViewAPI_generic.cpp
-    hpx/TestHPX_DynRankViewAPI_rank12345.cpp
-    hpx/TestHPX_DynRankViewAPI_rank67.cpp
-    hpx/TestHPX_ErrorReporter.cpp
-    hpx/TestHPX_OffsetView.cpp
-    hpx/TestHPX_ScatterView.cpp
-    hpx/TestHPX_StaticCrsGraph.cpp
-    hpx/TestHPX_UnorderedMap.cpp
-    hpx/TestHPX_Vector.cpp
-    hpx/TestHPX_ViewCtorPropEmbeddedDim.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-ENDIF()
-
-IF(Kokkos_ENABLE_Cuda)
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_Cuda
-  SOURCES
-    UnitTestMain.cpp
-    cuda/TestCuda_BitSet.cpp
-    cuda/TestCuda_DualView.cpp
-    cuda/TestCuda_DynamicView.cpp
-    cuda/TestCuda_DynRankViewAPI_generic.cpp
-    cuda/TestCuda_DynRankViewAPI_rank12345.cpp
-    cuda/TestCuda_DynRankViewAPI_rank67.cpp
-    cuda/TestCuda_ErrorReporter.cpp
-    cuda/TestCuda_OffsetView.cpp
-    cuda/TestCuda_ScatterView.cpp
-    cuda/TestCuda_StaticCrsGraph.cpp
-    cuda/TestCuda_UnorderedMap.cpp
-    cuda/TestCuda_Vector.cpp
-    cuda/TestCuda_ViewCtorPropEmbeddedDim.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-ENDIF()
-
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../src )
+
+foreach(Tag Threads;Serial;OpenMP;HPX;Cuda)
+  # Because there is always an exception to the rule
+  if(Tag STREQUAL "Threads")
+    set(DEVICE "PTHREAD")
+  else()
+    string(TOUPPER ${Tag} DEVICE)
+  endif()
+  string(TOLOWER ${Tag} dir)
+  # Add test for that backend if it is enabled
+  if(Kokkos_ENABLE_${DEVICE})
+    KOKKOS_ADD_EXECUTABLE_AND_TEST(
+      UnitTest_${Tag}
+      SOURCES
+        UnitTestMain.cpp
+        ${dir}/Test${Tag}_BitSet.cpp
+        ${dir}/Test${Tag}_DualView.cpp
+        ${dir}/Test${Tag}_DynamicView.cpp
+        ${dir}/Test${Tag}_DynRankViewAPI_generic.cpp
+        ${dir}/Test${Tag}_DynRankViewAPI_rank12345.cpp
+        ${dir}/Test${Tag}_DynRankViewAPI_rank67.cpp
+        ${dir}/Test${Tag}_ErrorReporter.cpp
+        ${dir}/Test${Tag}_OffsetView.cpp
+        ${dir}/Test${Tag}_ScatterView.cpp
+        ${dir}/Test${Tag}_StaticCrsGraph.cpp
+        ${dir}/Test${Tag}_UnorderedMap.cpp
+        ${dir}/Test${Tag}_Vector.cpp
+        ${dir}/Test${Tag}_ViewCtorPropEmbeddedDim.cpp
+      )
+  endif()
+endforeach()
diff --git a/lib/kokkos/containers/unit_tests/TestBitset.hpp b/lib/kokkos/containers/unit_tests/TestBitset.hpp
index 55d0e8b938a12a06a29ab516ddec810a2320e3c3..ebd35d3ae721e5fbdceddea39cff7d675f74acac 100644
--- a/lib/kokkos/containers/unit_tests/TestBitset.hpp
+++ b/lib/kokkos/containers/unit_tests/TestBitset.hpp
@@ -1,12 +1,13 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -35,7 +36,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
@@ -52,240 +53,208 @@ namespace Test {
 namespace Impl {
 
 template <typename Bitset, bool Set>
-struct TestBitset
-{
+struct TestBitset {
   typedef Bitset bitset_type;
   typedef typename bitset_type::execution_space execution_space;
   typedef uint32_t value_type;
 
   bitset_type m_bitset;
 
-  TestBitset( bitset_type const& bitset)
-    : m_bitset(bitset)
-  {}
+  TestBitset(bitset_type const& bitset) : m_bitset(bitset) {}
 
-  unsigned testit(unsigned collisions)
-  {
+  unsigned testit(unsigned collisions) {
     execution_space().fence();
 
     unsigned count = 0;
-    Kokkos::parallel_reduce( m_bitset.size()*collisions, *this, count);
+    Kokkos::parallel_reduce(m_bitset.size() * collisions, *this, count);
     return count;
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & v ) const { v = 0; }
+  void init(value_type& v) const { v = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & dst, const volatile value_type & src ) const
-  { dst += src; }
+  void join(volatile value_type& dst, const volatile value_type& src) const {
+    dst += src;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(uint32_t i, value_type & v) const
-  {
+  void operator()(uint32_t i, value_type& v) const {
     i = i % m_bitset.size();
     if (Set) {
       if (m_bitset.set(i)) {
         if (m_bitset.test(i)) ++v;
       }
-    }
-    else {
+    } else {
       if (m_bitset.reset(i)) {
         if (!m_bitset.test(i)) ++v;
       }
     }
   }
-
 };
 
 template <typename Bitset>
-struct TestBitsetTest
-{
+struct TestBitsetTest {
   typedef Bitset bitset_type;
   typedef typename bitset_type::execution_space execution_space;
   typedef uint32_t value_type;
 
   bitset_type m_bitset;
 
-  TestBitsetTest( bitset_type const& bitset)
-    : m_bitset(bitset)
-  {}
+  TestBitsetTest(bitset_type const& bitset) : m_bitset(bitset) {}
 
-  unsigned testit()
-  {
+  unsigned testit() {
     execution_space().fence();
 
     unsigned count = 0;
-    Kokkos::parallel_reduce( m_bitset.size(), *this, count);
+    Kokkos::parallel_reduce(m_bitset.size(), *this, count);
     return count;
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & v ) const { v = 0; }
+  void init(value_type& v) const { v = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & dst, const volatile value_type & src ) const
-  { dst += src; }
+  void join(volatile value_type& dst, const volatile value_type& src) const {
+    dst += src;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(uint32_t i, value_type & v) const
-  {
-    if (m_bitset.test( i )) ++v;
+  void operator()(uint32_t i, value_type& v) const {
+    if (m_bitset.test(i)) ++v;
   }
 };
 
 template <typename Bitset, bool Set>
-struct TestBitsetAny
-{
+struct TestBitsetAny {
   typedef Bitset bitset_type;
   typedef typename bitset_type::execution_space execution_space;
   typedef uint32_t value_type;
 
   bitset_type m_bitset;
 
-  TestBitsetAny( bitset_type const& bitset)
-    : m_bitset(bitset)
-  {}
+  TestBitsetAny(bitset_type const& bitset) : m_bitset(bitset) {}
 
-  unsigned testit()
-  {
+  unsigned testit() {
     execution_space().fence();
 
     unsigned count = 0;
-    Kokkos::parallel_reduce( m_bitset.size(), *this, count);
+    Kokkos::parallel_reduce(m_bitset.size(), *this, count);
     return count;
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & v ) const { v = 0; }
+  void init(value_type& v) const { v = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & dst, const volatile value_type & src ) const
-  { dst += src; }
+  void join(volatile value_type& dst, const volatile value_type& src) const {
+    dst += src;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(uint32_t i, value_type & v) const
-  {
-    bool result = false;
+  void operator()(uint32_t i, value_type& v) const {
+    bool result       = false;
     unsigned attempts = 0;
-    uint32_t hint = (i >> 4) << 4;
+    uint32_t hint     = (i >> 4) << 4;
     while (attempts < m_bitset.max_hint()) {
       if (Set) {
         Kokkos::tie(result, hint) = m_bitset.find_any_unset_near(hint, i);
         if (result && m_bitset.set(hint)) {
           ++v;
           break;
-        }
-        else if (!result) {
+        } else if (!result) {
           ++attempts;
         }
-      }
-      else {
+      } else {
         Kokkos::tie(result, hint) = m_bitset.find_any_set_near(hint, i);
         if (result && m_bitset.reset(hint)) {
           ++v;
           break;
-        }
-        else if (!result) {
+        } else if (!result) {
           ++attempts;
         }
       }
     }
   }
-
 };
-} // namespace Impl
-
-
+}  // namespace Impl
 
 template <typename Device>
-void test_bitset()
-{
-  typedef Kokkos::Bitset< Device > bitset_type;
-  typedef Kokkos::ConstBitset< Device > const_bitset_type;
+void test_bitset() {
+  typedef Kokkos::Bitset<Device> bitset_type;
+  typedef Kokkos::ConstBitset<Device> const_bitset_type;
 
-  //unsigned test_sizes[] = { 0u, 1000u, 1u<<14, 1u<<16, 10000001 };
-  unsigned test_sizes[] = { 1000u, 1u<<14, 1u<<16, 10000001 };
+  // unsigned test_sizes[] = { 0u, 1000u, 1u<<14, 1u<<16, 10000001 };
+  unsigned test_sizes[] = {1000u, 1u << 14, 1u << 16, 10000001};
 
-  for (int i=0, end = sizeof(test_sizes)/sizeof(unsigned); i<end; ++i) {
-
-    //std::cout << "Bitset " << test_sizes[i] << std::endl;
+  for (int i = 0, end = sizeof(test_sizes) / sizeof(unsigned); i < end; ++i) {
+    // std::cout << "Bitset " << test_sizes[i] << std::endl;
 
     bitset_type bitset(test_sizes[i]);
 
-    //std::cout << "  Check initial count " << std::endl;
+    // std::cout << "  Check initial count " << std::endl;
     // nothing should be set
     {
-      Impl::TestBitsetTest< bitset_type > f(bitset);
+      Impl::TestBitsetTest<bitset_type> f(bitset);
       uint32_t count = f.testit();
       EXPECT_EQ(0u, count);
       EXPECT_EQ(count, bitset.count());
     }
 
-    //std::cout << "  Check set() " << std::endl;
+    // std::cout << "  Check set() " << std::endl;
     bitset.set();
     // everything should be set
     {
-      Impl::TestBitsetTest< const_bitset_type > f(bitset);
+      Impl::TestBitsetTest<const_bitset_type> f(bitset);
       uint32_t count = f.testit();
       EXPECT_EQ(bitset.size(), count);
       EXPECT_EQ(count, bitset.count());
     }
 
-    //std::cout << "  Check reset() " << std::endl;
+    // std::cout << "  Check reset() " << std::endl;
     bitset.reset();
     EXPECT_EQ(0u, bitset.count());
 
-    //std::cout << "  Check set(i) " << std::endl;
+    // std::cout << "  Check set(i) " << std::endl;
     // test setting bits
     {
-      Impl::TestBitset< bitset_type, true > f(bitset);
+      Impl::TestBitset<bitset_type, true> f(bitset);
       uint32_t count = f.testit(10u);
-      EXPECT_EQ( bitset.size(), bitset.count());
-      EXPECT_EQ( bitset.size(), count );
+      EXPECT_EQ(bitset.size(), bitset.count());
+      EXPECT_EQ(bitset.size(), count);
     }
 
-    //std::cout << "  Check reset(i) " << std::endl;
+    // std::cout << "  Check reset(i) " << std::endl;
     // test resetting bits
     {
-      Impl::TestBitset< bitset_type, false > f(bitset);
+      Impl::TestBitset<bitset_type, false> f(bitset);
       uint32_t count = f.testit(10u);
-      EXPECT_EQ( bitset.size(), count);
-      EXPECT_EQ( 0u, bitset.count() );
+      EXPECT_EQ(bitset.size(), count);
+      EXPECT_EQ(0u, bitset.count());
     }
 
-
-    //std::cout << "  Check find_any_set(i) " << std::endl;
+    // std::cout << "  Check find_any_set(i) " << std::endl;
     // test setting any bits
     {
-      Impl::TestBitsetAny< bitset_type, true > f(bitset);
+      Impl::TestBitsetAny<bitset_type, true> f(bitset);
       uint32_t count = f.testit();
-      EXPECT_EQ( bitset.size(), bitset.count());
-      EXPECT_EQ( bitset.size(), count );
+      EXPECT_EQ(bitset.size(), bitset.count());
+      EXPECT_EQ(bitset.size(), count);
     }
 
-    //std::cout << "  Check find_any_unset(i) " << std::endl;
+    // std::cout << "  Check find_any_unset(i) " << std::endl;
     // test resetting any bits
     {
-      Impl::TestBitsetAny< bitset_type, false > f(bitset);
+      Impl::TestBitsetAny<bitset_type, false> f(bitset);
       uint32_t count = f.testit();
-      EXPECT_EQ( bitset.size(), count);
-      EXPECT_EQ( 0u, bitset.count() );
+      EXPECT_EQ(bitset.size(), count);
+      EXPECT_EQ(0u, bitset.count());
     }
-
   }
-
-}
-
-TEST_F( TEST_CATEGORY, bitset )
-{
-  test_bitset<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+TEST(TEST_CATEGORY, bitset) { test_bitset<TEST_EXECSPACE>(); }
 
-#endif //KOKKOS_TEST_BITSET_HPP
+}  // namespace Test
 
+#endif  // KOKKOS_TEST_BITSET_HPP
diff --git a/lib/kokkos/containers/unit_tests/TestDualView.hpp b/lib/kokkos/containers/unit_tests/TestDualView.hpp
index 767f93c093c48b27bef9819a78e333aa29dd7495..572ef48839f6c1f92127028e44e8d52dc47a2771 100644
--- a/lib/kokkos/containers/unit_tests/TestDualView.hpp
+++ b/lib/kokkos/containers/unit_tests/TestDualView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -55,169 +56,159 @@ namespace Test {
 
 namespace Impl {
 
-  template <typename Scalar, class Device>
-  struct test_dualview_combinations
-  {
-    typedef test_dualview_combinations<Scalar,Device> self_type;
+template <typename Scalar, class Device>
+struct test_dualview_combinations {
+  typedef test_dualview_combinations<Scalar, Device> self_type;
 
-    typedef Scalar scalar_type;
-    typedef Device execution_space;
+  typedef Scalar scalar_type;
+  typedef Device execution_space;
 
-    Scalar reference;
-    Scalar result;
+  Scalar reference;
+  Scalar result;
 
-    template <typename ViewType>
-    Scalar run_me(unsigned int n,unsigned int m){
-      if(n<10) n = 10;
-      if(m<3) m = 3;
-      ViewType a("A",n,m);
+  template <typename ViewType>
+  Scalar run_me(unsigned int n, unsigned int m) {
+    if (n < 10) n = 10;
+    if (m < 3) m = 3;
+    ViewType a("A", n, m);
 
-      Kokkos::deep_copy( a.d_view , 1 );
+    Kokkos::deep_copy(a.d_view, 1);
 
-      a.template modify<typename ViewType::execution_space>();
-      a.template sync<typename ViewType::host_mirror_space>();
+    a.template modify<typename ViewType::execution_space>();
+    a.template sync<typename ViewType::host_mirror_space>();
 
-      a.h_view(5,1) = 3;
-      a.h_view(6,1) = 4;
-      a.h_view(7,2) = 5;
-      a.template modify<typename ViewType::host_mirror_space>();
-      ViewType b = Kokkos::subview(a,std::pair<unsigned int, unsigned int>(6,9),std::pair<unsigned int, unsigned int>(0,1));
-      a.template sync<typename ViewType::execution_space>();
-      b.template modify<typename ViewType::execution_space>();
+    a.h_view(5, 1) = 3;
+    a.h_view(6, 1) = 4;
+    a.h_view(7, 2) = 5;
+    a.template modify<typename ViewType::host_mirror_space>();
+    ViewType b = Kokkos::subview(a, std::pair<unsigned int, unsigned int>(6, 9),
+                                 std::pair<unsigned int, unsigned int>(0, 1));
+    a.template sync<typename ViewType::execution_space>();
+    b.template modify<typename ViewType::execution_space>();
 
-      Kokkos::deep_copy( b.d_view , 2 );
+    Kokkos::deep_copy(b.d_view, 2);
 
-      a.template sync<typename ViewType::host_mirror_space>();
-      Scalar count = 0;
-      for(unsigned int i = 0; i<a.d_view.extent(0); i++)
-        for(unsigned int j = 0; j<a.d_view.extent(1); j++)
-          count += a.h_view(i,j);
-      return count -  a.d_view.extent(0)*a.d_view.extent(1)-2-4-3*2;
-    }
-
-
-    test_dualview_combinations(unsigned int size)
-    {
-      result = run_me< Kokkos::DualView<Scalar**,Kokkos::LayoutLeft,Device> >(size,3);
-    }
+    a.template sync<typename ViewType::host_mirror_space>();
+    Scalar count = 0;
+    for (unsigned int i = 0; i < a.d_view.extent(0); i++)
+      for (unsigned int j = 0; j < a.d_view.extent(1); j++)
+        count += a.h_view(i, j);
+    return count - a.d_view.extent(0) * a.d_view.extent(1) - 2 - 4 - 3 * 2;
+  }
 
-  };
+  test_dualview_combinations(unsigned int size) {
+    result = run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(
+        size, 3);
+  }
+};
 
-  template < typename Scalar, class ViewType >
-  struct SumViewEntriesFunctor {
+template <typename Scalar, class ViewType>
+struct SumViewEntriesFunctor {
+  typedef Scalar value_type;
 
-    typedef Scalar value_type;
+  ViewType fv;
 
-    ViewType fv;
+  SumViewEntriesFunctor(const ViewType& fv_) : fv(fv_) {}
 
-    SumViewEntriesFunctor ( const ViewType & fv_ ) : fv(fv_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() ( const int i , value_type & total ) const {
-      for ( size_t j = 0; j < fv.extent(1); ++j ) {
-        total += fv(i,j);
-      }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int i, value_type& total) const {
+    for (size_t j = 0; j < fv.extent(1); ++j) {
+      total += fv(i, j);
     }
+  }
+};
+
+template <typename Scalar, class Device>
+struct test_dual_view_deep_copy {
+  typedef Scalar scalar_type;
+  typedef Device execution_space;
+
+  template <typename ViewType>
+  void run_me() {
+    const unsigned int n         = 10;
+    const unsigned int m         = 5;
+    const unsigned int sum_total = n * m;
+
+    ViewType a("A", n, m);
+    ViewType b("B", n, m);
+
+    Kokkos::deep_copy(a.d_view, 1);
+
+    a.template modify<typename ViewType::execution_space>();
+    a.template sync<typename ViewType::host_mirror_space>();
+
+    // Check device view is initialized as expected
+    scalar_type a_d_sum = 0;
+    // Execute on the execution_space associated with t_dev's memory space
+    typedef typename ViewType::t_dev::memory_space::execution_space
+        t_dev_exec_space;
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<t_dev_exec_space>(0, n),
+        SumViewEntriesFunctor<scalar_type, typename ViewType::t_dev>(a.d_view),
+        a_d_sum);
+    ASSERT_EQ(a_d_sum, sum_total);
+
+    // Check host view is synced as expected
+    scalar_type a_h_sum = 0;
+    for (size_t i = 0; i < a.h_view.extent(0); ++i)
+      for (size_t j = 0; j < a.h_view.extent(1); ++j) {
+        a_h_sum += a.h_view(i, j);
+      }
 
-  };
-  
-
-  template <typename Scalar, class Device>
-  struct test_dual_view_deep_copy
-  {
-    typedef Scalar scalar_type;
-    typedef Device execution_space;
-
-    template <typename ViewType>
-    void run_me() {
-
-      const unsigned int n = 10;
-      const unsigned int m = 5;
-      const unsigned int sum_total = n * m;
-
-      ViewType a("A",n,m);
-      ViewType b("B",n,m);
-
-      Kokkos::deep_copy( a.d_view , 1 );
-
-      a.template modify<typename ViewType::execution_space>();
-      a.template sync<typename ViewType::host_mirror_space>();
-
-      // Check device view is initialized as expected
-      scalar_type a_d_sum = 0;
-      // Execute on the execution_space associated with t_dev's memory space
-      typedef typename ViewType::t_dev::memory_space::execution_space t_dev_exec_space;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<t_dev_exec_space>(0,n), SumViewEntriesFunctor<scalar_type, typename ViewType::t_dev>(a.d_view), a_d_sum );
-      ASSERT_EQ(a_d_sum, sum_total);
-
-      // Check host view is synced as expected
-      scalar_type a_h_sum = 0;
-      for ( size_t i = 0; i < a.h_view.extent(0); ++i )
-        for ( size_t j = 0; j < a.h_view.extent(1); ++j ) {
-          a_h_sum += a.h_view(i,j);
-        }
-
-      ASSERT_EQ(a_h_sum, sum_total);
-
-
-      // Test deep_copy
-      Kokkos::deep_copy( b, a );
-      b.template sync<typename ViewType::host_mirror_space>();
-
-      // Perform same checks on b as done on a
-      // Check device view is initialized as expected
-      scalar_type b_d_sum = 0;
-      // Execute on the execution_space associated with t_dev's memory space
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<t_dev_exec_space>(0,n), SumViewEntriesFunctor<scalar_type, typename ViewType::t_dev>(b.d_view), b_d_sum );
-      ASSERT_EQ(b_d_sum, sum_total);
-
-      // Check host view is synced as expected
-      scalar_type b_h_sum = 0;
-      for ( size_t i = 0; i < b.h_view.extent(0); ++i )
-        for ( size_t j = 0; j < b.h_view.extent(1); ++j ) {
-          b_h_sum += b.h_view(i,j);
-        }
-
-      ASSERT_EQ(b_h_sum, sum_total);
-
-    } // end run_me
-
-    test_dual_view_deep_copy()
-    {
-      run_me< Kokkos::DualView<Scalar**,Kokkos::LayoutLeft,Device> >();
-    }
+    ASSERT_EQ(a_h_sum, sum_total);
+
+    // Test deep_copy
+    Kokkos::deep_copy(b, a);
+    b.template sync<typename ViewType::host_mirror_space>();
+
+    // Perform same checks on b as done on a
+    // Check device view is initialized as expected
+    scalar_type b_d_sum = 0;
+    // Execute on the execution_space associated with t_dev's memory space
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<t_dev_exec_space>(0, n),
+        SumViewEntriesFunctor<scalar_type, typename ViewType::t_dev>(b.d_view),
+        b_d_sum);
+    ASSERT_EQ(b_d_sum, sum_total);
+
+    // Check host view is synced as expected
+    scalar_type b_h_sum = 0;
+    for (size_t i = 0; i < b.h_view.extent(0); ++i)
+      for (size_t j = 0; j < b.h_view.extent(1); ++j) {
+        b_h_sum += b.h_view(i, j);
+      }
 
-  };
+    ASSERT_EQ(b_h_sum, sum_total);
 
-} // namespace Impl
+  }  // end run_me
 
+  test_dual_view_deep_copy() {
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >();
+  }
+};
 
+}  // namespace Impl
 
 template <typename Scalar, typename Device>
-void test_dualview_combinations(unsigned int size)
-{
-  Impl::test_dualview_combinations<Scalar,Device> test(size);
-  ASSERT_EQ( test.result,0);
-
+void test_dualview_combinations(unsigned int size) {
+  Impl::test_dualview_combinations<Scalar, Device> test(size);
+  ASSERT_EQ(test.result, 0);
 }
 
 template <typename Scalar, typename Device>
-void test_dualview_deep_copy()
-{
-  Impl::test_dual_view_deep_copy<Scalar,Device> ();
+void test_dualview_deep_copy() {
+  Impl::test_dual_view_deep_copy<Scalar, Device>();
 }
 
-TEST_F( TEST_CATEGORY, dualview_combination) {
-    test_dualview_combinations<int,TEST_EXECSPACE>(10);
+TEST(TEST_CATEGORY, dualview_combination) {
+  test_dualview_combinations<int, TEST_EXECSPACE>(10);
 }
 
-TEST_F( TEST_CATEGORY, dualview_deep_copy) {
-    test_dualview_deep_copy<int,TEST_EXECSPACE>();
-    test_dualview_deep_copy<double,TEST_EXECSPACE>();
+TEST(TEST_CATEGORY, dualview_deep_copy) {
+  test_dualview_deep_copy<int, TEST_EXECSPACE>();
+  test_dualview_deep_copy<double, TEST_EXECSPACE>();
 }
 
+}  // namespace Test
 
-} // namespace Test
-
-#endif //KOKKOS_TEST_UNORDERED_MAP_HPP
-
+#endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
diff --git a/lib/kokkos/containers/unit_tests/TestDynViewAPI.hpp b/lib/kokkos/containers/unit_tests/TestDynViewAPI.hpp
index 13e56c9f8d7a47f17c9f75ab5076bd039fc091bd..3692aa8a125240407b0331158dd9a1d7febed6c4 100644
--- a/lib/kokkos/containers/unit_tests/TestDynViewAPI.hpp
+++ b/lib/kokkos/containers/unit_tests/TestDynViewAPI.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -51,680 +52,661 @@
 
 /*--------------------------------------------------------------------------*/
 
-
 /*--------------------------------------------------------------------------*/
 
 namespace Test {
 
-template< class T , class ... P >
-size_t allocation_count( const Kokkos::DynRankView<T,P...> & view )
-{
+template <class T, class... P>
+size_t allocation_count(const Kokkos::DynRankView<T, P...>& view) {
   const size_t card  = view.size();
   const size_t alloc = view.span();
 
-  return card <= alloc ? alloc : 0 ;
+  return card <= alloc ? alloc : 0;
 }
 
 /*--------------------------------------------------------------------------*/
 
-template< typename T, class DeviceType>
-struct TestViewOperator
-{
-  typedef DeviceType  execution_space ;
+template <typename T, class DeviceType>
+struct TestViewOperator {
+  typedef DeviceType execution_space;
 
-  static const unsigned N = 100 ;
-  static const unsigned D = 3 ;
+  static const unsigned N = 100;
+  static const unsigned D = 3;
 
-  typedef Kokkos::DynRankView< T , execution_space > view_type ;
+  typedef Kokkos::DynRankView<T, execution_space> view_type;
 
-  const view_type v1 ;
-  const view_type v2 ;
+  const view_type v1;
+  const view_type v2;
 
-  TestViewOperator()
-    : v1( "v1" , N , D )
-    , v2( "v2" , N , D )
-    {}
+  TestViewOperator() : v1("v1", N, D), v2("v2", N, D) {}
 
-  static void testit()
-  {
-    Kokkos::parallel_for( N , TestViewOperator() );
-  }
+  static void testit() { Kokkos::parallel_for(N, TestViewOperator()); }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned i ) const
-  {
-    const unsigned X = 0 ;
-    const unsigned Y = 1 ;
-    const unsigned Z = 2 ;
-
-    v2(i,X) = v1(i,X);
-    v2(i,Y) = v1(i,Y);
-    v2(i,Z) = v1(i,Z);
+  void operator()(const unsigned i) const {
+    const unsigned X = 0;
+    const unsigned Y = 1;
+    const unsigned Z = 2;
+
+    v2(i, X) = v1(i, X);
+    v2(i, Y) = v1(i, Y);
+    v2(i, Z) = v1(i, Z);
   }
 };
 
 /*--------------------------------------------------------------------------*/
 
-template< class DataType ,
-          class DeviceType ,
-          unsigned Rank >
-struct TestViewOperator_LeftAndRight ;
+template <class DataType, class DeviceType, unsigned Rank>
+struct TestViewOperator_LeftAndRight;
 
-template< class DataType , class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType , DeviceType , 7 >
-{
-  typedef DeviceType                          execution_space ;
-  typedef typename execution_space::memory_space  memory_space ;
-  typedef typename execution_space::size_type     size_type ;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 7> {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef int value_type ;
+  typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & input )
-    { update |= input ; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
+  static void init(value_type& update) { update = 0; }
 
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutLeft, execution_space>
+      left_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutRight, execution_space > right_view ;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
-  left_view    left ;
-  right_view   right ;
-  long         left_alloc ;
-  long         right_alloc ;
+  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2,
+                                unsigned N3, unsigned N4, unsigned N5,
+                                unsigned N6)
+      : left("left", N0, N1, N2, N3, N4, N5, N6),
+        right("right", N0, N1, N2, N3, N4, N5, N6),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
-  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4, unsigned N5, unsigned N6 )
-    : left(  "left" , N0, N1, N2, N3, N4, N5, N6 )
-    , right( "right" , N0, N1, N2, N3, N4, N5, N6 )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
+  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3,
+                     unsigned N4, unsigned N5, unsigned N6) {
+    TestViewOperator_LeftAndRight driver(N0, N1, N2, N3, N4, N5, N6);
 
-  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4, unsigned N5, unsigned N6 )
-  {
-    TestViewOperator_LeftAndRight driver(N0, N1, N2, N3, N4, N5, N6 );
+    int error_flag = 0;
 
-    int error_flag = 0 ;
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    Kokkos::parallel_reduce( 1 , driver , error_flag );
-
-    ASSERT_EQ( error_flag , 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type , value_type & update ) const
-  {
-    long offset ;
-
-    offset = -1 ;
-    for ( unsigned i6 = 0 ; i6 < unsigned(left.extent(6)) ; ++i6 )
-    for ( unsigned i5 = 0 ; i5 < unsigned(left.extent(5)) ; ++i5 )
-    for ( unsigned i4 = 0 ; i4 < unsigned(left.extent(4)) ; ++i4 )
-    for ( unsigned i3 = 0 ; i3 < unsigned(left.extent(3)) ; ++i3 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(left.extent(2)) ; ++i2 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3, i4, i5, i6 ) -
-                     & left(  0,  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
-      offset = j ;
-    }
-
-    offset = -1 ;
-    for ( unsigned i0 = 0 ; i0 < unsigned(right.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(right.extent(1)) ; ++i1 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(right.extent(2)) ; ++i2 )
-    for ( unsigned i3 = 0 ; i3 < unsigned(right.extent(3)) ; ++i3 )
-    for ( unsigned i4 = 0 ; i4 < unsigned(right.extent(4)) ; ++i4 )
-    for ( unsigned i5 = 0 ; i5 < unsigned(right.extent(5)) ; ++i5 )
-    for ( unsigned i6 = 0 ; i6 < unsigned(right.extent(6)) ; ++i6 )
-    {
-      const long j = & right( i0, i1, i2, i3, i4, i5, i6 ) -
-                     & right(  0,  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
-      offset = j ;
-    }
+  void operator()(const size_type, value_type& update) const {
+    long offset;
+
+    offset = -1;
+    for (unsigned i6 = 0; i6 < unsigned(left.extent(6)); ++i6)
+      for (unsigned i5 = 0; i5 < unsigned(left.extent(5)); ++i5)
+        for (unsigned i4 = 0; i4 < unsigned(left.extent(4)); ++i4)
+          for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+            for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+              for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+                for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+                  const long j = &left(i0, i1, i2, i3, i4, i5, i6) -
+                                 &left(0, 0, 0, 0, 0, 0, 0);
+                  if (j <= offset || left_alloc <= j) {
+                    update |= 1;
+                  }
+                  offset = j;
+                }
+
+    offset = -1;
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3)
+            for (unsigned i4 = 0; i4 < unsigned(right.extent(4)); ++i4)
+              for (unsigned i5 = 0; i5 < unsigned(right.extent(5)); ++i5)
+                for (unsigned i6 = 0; i6 < unsigned(right.extent(6)); ++i6) {
+                  const long j = &right(i0, i1, i2, i3, i4, i5, i6) -
+                                 &right(0, 0, 0, 0, 0, 0, 0);
+                  if (j <= offset || right_alloc <= j) {
+                    update |= 2;
+                  }
+                  offset = j;
+                }
   }
 };
 
-template< class DataType , class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType , DeviceType , 6 >
-{
-  typedef DeviceType                          execution_space ;
-  typedef typename execution_space::memory_space  memory_space ;
-  typedef typename execution_space::size_type     size_type ;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 6> {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef int value_type ;
+  typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & input )
-    { update |= input ; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
+  static void init(value_type& update) { update = 0; }
 
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutLeft, execution_space>
+      left_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutRight, execution_space > right_view ;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
-  left_view    left ;
-  right_view   right ;
-  long         left_alloc ;
-  long         right_alloc ;
+  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2,
+                                unsigned N3, unsigned N4, unsigned N5)
+      : left("left", N0, N1, N2, N3, N4, N5),
+        right("right", N0, N1, N2, N3, N4, N5),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
-  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4, unsigned N5 )
-    : left(  "left" , N0, N1, N2, N3, N4, N5 )
-    , right( "right" , N0, N1, N2, N3, N4, N5 )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
+  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3,
+                     unsigned N4, unsigned N5) {
+    TestViewOperator_LeftAndRight driver(N0, N1, N2, N3, N4, N5);
 
-  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4, unsigned N5)
-  {
-    TestViewOperator_LeftAndRight driver (N0, N1, N2, N3, N4, N5);
+    int error_flag = 0;
 
-    int error_flag = 0 ;
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    Kokkos::parallel_reduce( 1 , driver , error_flag );
-
-    ASSERT_EQ( error_flag , 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type , value_type & update ) const
-  {
-    long offset ;
-
-    offset = -1 ;
-    for ( unsigned i5 = 0 ; i5 < unsigned(left.extent(5)) ; ++i5 )
-    for ( unsigned i4 = 0 ; i4 < unsigned(left.extent(4)) ; ++i4 )
-    for ( unsigned i3 = 0 ; i3 < unsigned(left.extent(3)) ; ++i3 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(left.extent(2)) ; ++i2 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3, i4, i5 ) -
-                     & left(  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
-      offset = j ;
-    }
-
-    offset = -1 ;
-    for ( unsigned i0 = 0 ; i0 < unsigned(right.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(right.extent(1)) ; ++i1 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(right.extent(2)) ; ++i2 )
-    for ( unsigned i3 = 0 ; i3 < unsigned(right.extent(3)) ; ++i3 )
-    for ( unsigned i4 = 0 ; i4 < unsigned(right.extent(4)) ; ++i4 )
-    for ( unsigned i5 = 0 ; i5 < unsigned(right.extent(5)) ; ++i5 )
-    {
-      const long j = & right( i0, i1, i2, i3, i4, i5 ) -
-                     & right(  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
-      offset = j ;
-    }
+  void operator()(const size_type, value_type& update) const {
+    long offset;
+
+    offset = -1;
+    for (unsigned i5 = 0; i5 < unsigned(left.extent(5)); ++i5)
+      for (unsigned i4 = 0; i4 < unsigned(left.extent(4)); ++i4)
+        for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+          for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+            for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+              for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+                const long j =
+                    &left(i0, i1, i2, i3, i4, i5) - &left(0, 0, 0, 0, 0, 0);
+                if (j <= offset || left_alloc <= j) {
+                  update |= 1;
+                }
+                offset = j;
+              }
+
+    offset = -1;
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3)
+            for (unsigned i4 = 0; i4 < unsigned(right.extent(4)); ++i4)
+              for (unsigned i5 = 0; i5 < unsigned(right.extent(5)); ++i5) {
+                const long j =
+                    &right(i0, i1, i2, i3, i4, i5) - &right(0, 0, 0, 0, 0, 0);
+                if (j <= offset || right_alloc <= j) {
+                  update |= 2;
+                }
+                offset = j;
+              }
   }
 };
 
-template< class DataType , class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType , DeviceType , 5 >
-{
-  typedef DeviceType                          execution_space ;
-  typedef typename execution_space::memory_space  memory_space ;
-  typedef typename execution_space::size_type     size_type ;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 5> {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef int value_type ;
+  typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & input )
-    { update |= input ; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
-
-
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
-
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutRight, execution_space > right_view ;
-
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutStride, execution_space > stride_view ;
-
-  left_view    left ;
-  right_view   right ;
-  stride_view  left_stride ;
-  stride_view  right_stride ;
-  long         left_alloc ;
-  long         right_alloc ;
-
-  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4 )
-    : left(  "left" , N0, N1, N2, N3, N4 )
-    , right( "right" , N0, N1, N2, N3, N4 )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4)
-  {
+  static void init(value_type& update) { update = 0; }
+
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutLeft, execution_space>
+      left_view;
+
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
+
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutStride, execution_space>
+      stride_view;
+
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
+
+  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2,
+                                unsigned N3, unsigned N4)
+      : left("left", N0, N1, N2, N3, N4),
+        right("right", N0, N1, N2, N3, N4),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
+
+  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3,
+                     unsigned N4) {
     TestViewOperator_LeftAndRight driver(N0, N1, N2, N3, N4);
 
-    int error_flag = 0 ;
+    int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1 , driver , error_flag );
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    ASSERT_EQ( error_flag , 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type , value_type & update ) const
-  {
-    long offset ;
-
-    offset = -1 ;
-    for ( unsigned i4 = 0 ; i4 < unsigned(left.extent(4)) ; ++i4 )
-    for ( unsigned i3 = 0 ; i3 < unsigned(left.extent(3)) ; ++i3 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(left.extent(2)) ; ++i2 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3, i4 ) -
-                     & left(  0,  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
-      offset = j ;
-
-      if ( & left( i0, i1, i2, i3, i4 ) !=
-           & left_stride( i0, i1, i2, i3, i4 ) ) { update |= 4 ; }
-    }
-
-    offset = -1 ;
-    for ( unsigned i0 = 0 ; i0 < unsigned(right.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(right.extent(1)) ; ++i1 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(right.extent(2)) ; ++i2 )
-    for ( unsigned i3 = 0 ; i3 < unsigned(right.extent(3)) ; ++i3 )
-    for ( unsigned i4 = 0 ; i4 < unsigned(right.extent(4)) ; ++i4 )
-    {
-      const long j = & right( i0, i1, i2, i3, i4 ) -
-                     & right(  0,  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
-      offset = j ;
-
-      if ( & right( i0, i1, i2, i3, i4 ) !=
-           & right_stride( i0, i1, i2, i3, i4 ) ) { update |= 8 ; }
-    }
+  void operator()(const size_type, value_type& update) const {
+    long offset;
+
+    offset = -1;
+    for (unsigned i4 = 0; i4 < unsigned(left.extent(4)); ++i4)
+      for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+        for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+          for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+            for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+              const long j = &left(i0, i1, i2, i3, i4) - &left(0, 0, 0, 0, 0);
+              if (j <= offset || left_alloc <= j) {
+                update |= 1;
+              }
+              offset = j;
+
+              if (&left(i0, i1, i2, i3, i4) !=
+                  &left_stride(i0, i1, i2, i3, i4)) {
+                update |= 4;
+              }
+            }
+
+    offset = -1;
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3)
+            for (unsigned i4 = 0; i4 < unsigned(right.extent(4)); ++i4) {
+              const long j = &right(i0, i1, i2, i3, i4) - &right(0, 0, 0, 0, 0);
+              if (j <= offset || right_alloc <= j) {
+                update |= 2;
+              }
+              offset = j;
+
+              if (&right(i0, i1, i2, i3, i4) !=
+                  &right_stride(i0, i1, i2, i3, i4)) {
+                update |= 8;
+              }
+            }
   }
 };
 
-template< class DataType , class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType , DeviceType , 4 >
-{
-  typedef DeviceType                          execution_space ;
-  typedef typename execution_space::memory_space  memory_space ;
-  typedef typename execution_space::size_type     size_type ;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 4> {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef int value_type ;
+  typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & input )
-    { update |= input ; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
-
+  static void init(value_type& update) { update = 0; }
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutLeft, execution_space>
+      left_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutRight, execution_space > right_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  left_view    left ;
-  right_view   right ;
-  long         left_alloc ;
-  long         right_alloc ;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
-  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2, unsigned N3)
-    : left(  "left" , N0, N1, N2, N3 )
-    , right( "right" , N0, N1, N2, N3 )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
+  TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2,
+                                unsigned N3)
+      : left("left", N0, N1, N2, N3),
+        right("right", N0, N1, N2, N3),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
-  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3)
-  {
-    TestViewOperator_LeftAndRight driver (N0, N1, N2, N3);
+  static void testit(unsigned N0, unsigned N1, unsigned N2, unsigned N3) {
+    TestViewOperator_LeftAndRight driver(N0, N1, N2, N3);
 
-    int error_flag = 0 ;
+    int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1 , driver , error_flag );
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    ASSERT_EQ( error_flag , 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type , value_type & update ) const
-  {
-    long offset ;
-
-    offset = -1 ;
-    for ( unsigned i3 = 0 ; i3 < unsigned(left.extent(3)) ; ++i3 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(left.extent(2)) ; ++i2 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3 ) -
-                     & left(  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
-      offset = j ;
-    }
-
-    offset = -1 ;
-    for ( unsigned i0 = 0 ; i0 < unsigned(right.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(right.extent(1)) ; ++i1 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(right.extent(2)) ; ++i2 )
-    for ( unsigned i3 = 0 ; i3 < unsigned(right.extent(3)) ; ++i3 )
-    {
-      const long j = & right( i0, i1, i2, i3 ) -
-                     & right(  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
-      offset = j ;
-    }
+  void operator()(const size_type, value_type& update) const {
+    long offset;
+
+    offset = -1;
+    for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+      for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+        for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+          for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+            const long j = &left(i0, i1, i2, i3) - &left(0, 0, 0, 0);
+            if (j <= offset || left_alloc <= j) {
+              update |= 1;
+            }
+            offset = j;
+          }
+
+    offset = -1;
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3) {
+            const long j = &right(i0, i1, i2, i3) - &right(0, 0, 0, 0);
+            if (j <= offset || right_alloc <= j) {
+              update |= 2;
+            }
+            offset = j;
+          }
   }
 };
 
-template< class DataType , class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType , DeviceType , 3 >
-{
-  typedef DeviceType                          execution_space ;
-  typedef typename execution_space::memory_space  memory_space ;
-  typedef typename execution_space::size_type     size_type ;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 3> {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef int value_type ;
+  typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & input )
-    { update |= input ; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
-
+  static void init(value_type& update) { update = 0; }
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutLeft, execution_space>
+      left_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutRight, execution_space > right_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutStride, execution_space > stride_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutStride, execution_space>
+      stride_view;
 
-  left_view    left ;
-  right_view   right ;
-  stride_view  left_stride ;
-  stride_view  right_stride ;
-  long         left_alloc ;
-  long         right_alloc ;
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight(unsigned N0, unsigned N1, unsigned N2)
-    : left(  std::string("left") , N0, N1, N2 )
-    , right( std::string("right") , N0, N1, N2 )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
+      : left(std::string("left"), N0, N1, N2),
+        right(std::string("right"), N0, N1, N2),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
-  static void testit(unsigned N0, unsigned N1, unsigned N2)
-  {
-    TestViewOperator_LeftAndRight driver (N0, N1, N2);
+  static void testit(unsigned N0, unsigned N1, unsigned N2) {
+    TestViewOperator_LeftAndRight driver(N0, N1, N2);
 
-    int error_flag = 0 ;
+    int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1 , driver , error_flag );
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    ASSERT_EQ( error_flag , 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type , value_type & update ) const
-  {
-    long offset ;
-
-    offset = -1 ;
-    for ( unsigned i2 = 0 ; i2 < unsigned(left.extent(2)) ; ++i2 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    {
-      const long j = & left( i0, i1, i2 ) -
-                     & left(  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
-      offset = j ;
-
-      if ( & left(i0,i1,i2) != & left_stride(i0,i1,i2) ) { update |= 4 ; }
-    }
-
-    offset = -1 ;
-    for ( unsigned i0 = 0 ; i0 < unsigned(right.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(right.extent(1)) ; ++i1 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(right.extent(2)) ; ++i2 )
-    {
-      const long j = & right( i0, i1, i2 ) -
-                     & right(  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
-      offset = j ;
-
-      if ( & right(i0,i1,i2) != & right_stride(i0,i1,i2) ) { update |= 8 ; }
-    }
-
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    for ( unsigned i2 = 0 ; i2 < unsigned(left.extent(2)) ; ++i2 )
-    {
-      if ( & left(i0,i1,i2)  != & left(i0,i1,i2,0,0,0,0) )  { update |= 3 ; }
-      if ( & right(i0,i1,i2) != & right(i0,i1,i2,0,0,0,0) ) { update |= 3 ; }
-    }
+  void operator()(const size_type, value_type& update) const {
+    long offset;
+
+    offset = -1;
+    for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+      for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+        for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+          const long j = &left(i0, i1, i2) - &left(0, 0, 0);
+          if (j <= offset || left_alloc <= j) {
+            update |= 1;
+          }
+          offset = j;
+
+          if (&left(i0, i1, i2) != &left_stride(i0, i1, i2)) {
+            update |= 4;
+          }
+        }
+
+    offset = -1;
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2) {
+          const long j = &right(i0, i1, i2) - &right(0, 0, 0);
+          if (j <= offset || right_alloc <= j) {
+            update |= 2;
+          }
+          offset = j;
+
+          if (&right(i0, i1, i2) != &right_stride(i0, i1, i2)) {
+            update |= 8;
+          }
+        }
+
+    for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2) {
+          if (&left(i0, i1, i2) != &left(i0, i1, i2, 0, 0, 0, 0)) {
+            update |= 3;
+          }
+          if (&right(i0, i1, i2) != &right(i0, i1, i2, 0, 0, 0, 0)) {
+            update |= 3;
+          }
+        }
   }
 };
 
-template< class DataType , class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType , DeviceType , 2 >
-{
-  typedef DeviceType                          execution_space ;
-  typedef typename execution_space::memory_space  memory_space ;
-  typedef typename execution_space::size_type     size_type ;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 2> {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef int value_type ;
+  typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & input )
-    { update |= input ; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
+  static void init(value_type& update) { update = 0; }
 
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutLeft, execution_space>
+      left_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutRight, execution_space > right_view ;
-
-  left_view    left ;
-  right_view   right ;
-  long         left_alloc ;
-  long         right_alloc ;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight(unsigned N0, unsigned N1)
-    : left(  "left" , N0, N1 )
-    , right( "right" , N0, N1 )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  static void testit(unsigned N0, unsigned N1)
-  {
+      : left("left", N0, N1),
+        right("right", N0, N1),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
+
+  static void testit(unsigned N0, unsigned N1) {
     TestViewOperator_LeftAndRight driver(N0, N1);
 
-    int error_flag = 0 ;
+    int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1 , driver , error_flag );
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    ASSERT_EQ( error_flag , 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type , value_type & update ) const
-  {
-    long offset ;
-
-    offset = -1 ;
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    {
-      const long j = & left( i0, i1 ) -
-                     & left(  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1 ; }
-      offset = j ;
-    }
-
-    offset = -1 ;
-    for ( unsigned i0 = 0 ; i0 < unsigned(right.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(right.extent(1)) ; ++i1 )
-    {
-      const long j = & right( i0, i1 ) -
-                     & right(  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2 ; }
-      offset = j ;
-    }
-
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    for ( unsigned i1 = 0 ; i1 < unsigned(left.extent(1)) ; ++i1 )
-    {
-      if ( & left(i0,i1)  != & left(i0,i1,0,0,0,0,0) )  { update |= 3 ; }
-      if ( & right(i0,i1) != & right(i0,i1,0,0,0,0,0) ) { update |= 3 ; }
-    }
+  void operator()(const size_type, value_type& update) const {
+    long offset;
+
+    offset = -1;
+    for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+      for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+        const long j = &left(i0, i1) - &left(0, 0);
+        if (j <= offset || left_alloc <= j) {
+          update |= 1;
+        }
+        offset = j;
+      }
+
+    offset = -1;
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1) {
+        const long j = &right(i0, i1) - &right(0, 0);
+        if (j <= offset || right_alloc <= j) {
+          update |= 2;
+        }
+        offset = j;
+      }
+
+    for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1) {
+        if (&left(i0, i1) != &left(i0, i1, 0, 0, 0, 0, 0)) {
+          update |= 3;
+        }
+        if (&right(i0, i1) != &right(i0, i1, 0, 0, 0, 0, 0)) {
+          update |= 3;
+        }
+      }
   }
 };
 
-template< class DataType , class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType , DeviceType , 1 >
-{
-  typedef DeviceType                          execution_space ;
-  typedef typename execution_space::memory_space  memory_space ;
-  typedef typename execution_space::size_type     size_type ;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 1> {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef int value_type ;
+  typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & input )
-    { update |= input ; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
+  static void init(value_type& update) { update = 0; }
 
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutLeft, execution_space>
+      left_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutLeft, execution_space > left_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutRight, execution_space > right_view ;
+  typedef Kokkos::DynRankView<DataType, Kokkos::LayoutStride, execution_space>
+      stride_view;
 
-  typedef Kokkos::
-    DynRankView< DataType, Kokkos::LayoutStride, execution_space > stride_view ;
-
-  left_view    left ;
-  right_view   right ;
-  stride_view  left_stride ;
-  stride_view  right_stride ;
-  long         left_alloc ;
-  long         right_alloc ;
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight(unsigned N0)
-    : left(  "left" , N0 )
-    , right( "right" , N0 )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
+      : left("left", N0),
+        right("right", N0),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
-  static void testit(unsigned N0)
-  {
-    TestViewOperator_LeftAndRight driver (N0) ;
+  static void testit(unsigned N0) {
+    TestViewOperator_LeftAndRight driver(N0);
 
-    int error_flag = 0 ;
+    int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1 , driver , error_flag );
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    ASSERT_EQ( error_flag , 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type , value_type & update ) const
-  {
-    for ( unsigned i0 = 0 ; i0 < unsigned(left.extent(0)) ; ++i0 )
-    {
-      if ( & left(i0)  != & left(i0,0,0,0,0,0,0) )  { update |= 3 ; }
-      if ( & right(i0) != & right(i0,0,0,0,0,0,0) ) { update |= 3 ; }
-      if ( & left(i0)  != & left_stride(i0) ) { update |= 4 ; }
-      if ( & right(i0) != & right_stride(i0) ) { update |= 8 ; }
+  void operator()(const size_type, value_type& update) const {
+    for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+      if (&left(i0) != &left(i0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
+      if (&right(i0) != &right(i0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
+      if (&left(i0) != &left_stride(i0)) {
+        update |= 4;
+      }
+      if (&right(i0) != &right_stride(i0)) {
+        update |= 8;
+      }
     }
   }
 };
 
 /*--------------------------------------------------------------------------*/
 
-template< typename T, class DeviceType >
-class TestDynViewAPI
-{
-public:
-  typedef DeviceType        device ;
+template <typename T, class DeviceType>
+class TestDynViewAPI {
+ public:
+  typedef DeviceType device;
 
-  enum { N0 = 1000 ,
-         N1 = 3 ,
-         N2 = 5 ,
-         N3 = 7 };
+  enum { N0 = 1000, N1 = 3, N2 = 5, N3 = 7 };
 
-  typedef Kokkos::DynRankView< T , device > dView0 ;
-  typedef Kokkos::DynRankView< const T , device > const_dView0 ;
+  typedef Kokkos::DynRankView<T, device> dView0;
+  typedef Kokkos::DynRankView<const T, device> const_dView0;
 
-  typedef Kokkos::DynRankView< T, device, Kokkos::MemoryUnmanaged > dView0_unmanaged ;
-  typedef typename dView0::host_mirror_space host_drv_space ;
+  typedef Kokkos::DynRankView<T, device, Kokkos::MemoryUnmanaged>
+      dView0_unmanaged;
+  typedef typename dView0::host_mirror_space host_drv_space;
 
-  typedef Kokkos::View< T , device >        View0 ;
-  typedef Kokkos::View< T* , device >       View1 ;
-  typedef Kokkos::View< T******* , device > View7 ;
+  typedef Kokkos::View<T, device> View0;
+  typedef Kokkos::View<T*, device> View1;
+  typedef Kokkos::View<T*******, device> View7;
 
-  typedef typename View0::host_mirror_space  host_view_space ;
+  typedef typename View0::host_mirror_space host_view_space;
 
-  TestDynViewAPI()
-  {
-  }
+  TestDynViewAPI() {}
 
   static void run_tests() {
     run_test_resize_realloc();
@@ -738,459 +720,475 @@ public:
     run_test_vector();
   }
 
-  static void run_operator_test_rank12345 () {
-    TestViewOperator< T , device >::testit();
-    TestViewOperator_LeftAndRight< int , device , 5 >::testit(2,3,4,2,3);
-    TestViewOperator_LeftAndRight< int , device , 4 >::testit(2,3,4,2);
-    TestViewOperator_LeftAndRight< int , device , 3 >::testit(2,3,4);
-    TestViewOperator_LeftAndRight< int , device , 2 >::testit(2,3);
-    TestViewOperator_LeftAndRight< int , device , 1 >::testit(2);
+  static void run_operator_test_rank12345() {
+    TestViewOperator<T, device>::testit();
+    TestViewOperator_LeftAndRight<int, device, 5>::testit(2, 3, 4, 2, 3);
+    TestViewOperator_LeftAndRight<int, device, 4>::testit(2, 3, 4, 2);
+    TestViewOperator_LeftAndRight<int, device, 3>::testit(2, 3, 4);
+    TestViewOperator_LeftAndRight<int, device, 2>::testit(2, 3);
+    TestViewOperator_LeftAndRight<int, device, 1>::testit(2);
   }
 
-  static void run_operator_test_rank67 () {
-    TestViewOperator_LeftAndRight< int , device , 7 >::testit(2,3,4,2,3,4,2);
-    TestViewOperator_LeftAndRight< int , device , 6 >::testit(2,3,4,2,3,4);
+  static void run_operator_test_rank67() {
+    TestViewOperator_LeftAndRight<int, device, 7>::testit(2, 3, 4, 2, 3, 4, 2);
+    TestViewOperator_LeftAndRight<int, device, 6>::testit(2, 3, 4, 2, 3, 4);
   }
 
-  static void run_test_resize_realloc()
-  {
+  static void run_test_resize_realloc() {
     dView0 drv0("drv0", 10, 20, 30);
-    ASSERT_EQ( drv0.rank(), 3);
+    ASSERT_EQ(drv0.rank(), 3);
 
     Kokkos::resize(drv0, 5, 10);
-    ASSERT_EQ( drv0.rank(), 2);
-    ASSERT_EQ( drv0.extent(0), 5);
-    ASSERT_EQ( drv0.extent(1), 10);
-    ASSERT_EQ( drv0.extent(2), 1);
+    ASSERT_EQ(drv0.rank(), 2);
+    ASSERT_EQ(drv0.extent(0), 5);
+    ASSERT_EQ(drv0.extent(1), 10);
+    ASSERT_EQ(drv0.extent(2), 1);
 
     Kokkos::realloc(drv0, 10, 20);
-    ASSERT_EQ( drv0.rank(), 2);
-    ASSERT_EQ( drv0.extent(0), 10);
-    ASSERT_EQ( drv0.extent(1), 20);
-    ASSERT_EQ( drv0.extent(2), 1);
-
+    ASSERT_EQ(drv0.rank(), 2);
+    ASSERT_EQ(drv0.extent(0), 10);
+    ASSERT_EQ(drv0.extent(1), 20);
+    ASSERT_EQ(drv0.extent(2), 1);
   }
 
-  static void run_test_mirror()
-  {
-    typedef Kokkos::DynRankView< int , host_drv_space > view_type ;
-    typedef typename view_type::HostMirror mirror_type ;
+  static void run_test_mirror() {
+    typedef Kokkos::DynRankView<int, host_drv_space> view_type;
+    typedef typename view_type::HostMirror mirror_type;
     view_type a("a");
     mirror_type am = Kokkos::create_mirror_view(a);
     mirror_type ax = Kokkos::create_mirror(a);
-    ASSERT_EQ( & a() , & am() );
-    ASSERT_EQ( a.rank() , am.rank() );
-    ASSERT_EQ( ax.rank() , am.rank() );
+    ASSERT_EQ(&a(), &am());
+    ASSERT_EQ(a.rank(), am.rank());
+    ASSERT_EQ(ax.rank(), am.rank());
 
     {
-      Kokkos::DynRankView<double, Kokkos::LayoutLeft, Kokkos::HostSpace> a_h("A",1000);
-      auto a_h2 = Kokkos::create_mirror(Kokkos::HostSpace(),a_h);
-      auto a_d = Kokkos::create_mirror(typename device::memory_space(),a_h);
-
-      int equal_ptr_h_h2  = (a_h.data() ==a_h2.data())?1:0;
-      int equal_ptr_h_d   = (a_h.data() ==a_d. data())?1:0;
-      int equal_ptr_h2_d  = (a_h2.data()==a_d. data())?1:0;
-
-      ASSERT_EQ(equal_ptr_h_h2,0);
-      ASSERT_EQ(equal_ptr_h_d ,0);
-      ASSERT_EQ(equal_ptr_h2_d,0);
-  
-      ASSERT_EQ(a_h.extent(0),a_h2.extent(0));
-      ASSERT_EQ(a_h.extent(0),a_d .extent(0));
-
-      ASSERT_EQ(a_h.rank(),a_h2.rank());
-      ASSERT_EQ(a_h.rank(),a_d.rank());
-    }
-    {
-      Kokkos::DynRankView<double, Kokkos::LayoutRight, Kokkos::HostSpace> a_h("A",1000);
-      auto a_h2 = Kokkos::create_mirror(Kokkos::HostSpace(),a_h);
-      auto a_d = Kokkos::create_mirror(typename device::memory_space(),a_h);
-
-      int equal_ptr_h_h2  = (a_h.data() ==a_h2.data())?1:0;
-      int equal_ptr_h_d   = (a_h.data() ==a_d. data())?1:0;
-      int equal_ptr_h2_d  = (a_h2.data()==a_d. data())?1:0;
-
-      ASSERT_EQ(equal_ptr_h_h2,0);
-      ASSERT_EQ(equal_ptr_h_d ,0);
-      ASSERT_EQ(equal_ptr_h2_d,0);
-  
-      ASSERT_EQ(a_h.extent(0),a_h2.extent(0));
-      ASSERT_EQ(a_h.extent(0),a_d .extent(0));
-
-      ASSERT_EQ(a_h.rank(),a_h2.rank());
-      ASSERT_EQ(a_h.rank(),a_d.rank());
-    }
+      Kokkos::DynRankView<double, Kokkos::LayoutLeft, Kokkos::HostSpace> a_h(
+          "A", 1000);
+      auto a_h2 = Kokkos::create_mirror(Kokkos::HostSpace(), a_h);
+      auto a_d  = Kokkos::create_mirror(typename device::memory_space(), a_h);
 
-    {
-      Kokkos::DynRankView<double, Kokkos::LayoutLeft, Kokkos::HostSpace> a_h("A",1000);
-      auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(),a_h);
-      auto a_d = Kokkos::create_mirror_view(typename device::memory_space(),a_h);
-
-      int equal_ptr_h_h2  = a_h.data() ==a_h2.data()?1:0;
-      int equal_ptr_h_d   = a_h.data() ==a_d. data()?1:0;
-      int equal_ptr_h2_d  = a_h2.data()==a_d. data()?1:0;
+      int equal_ptr_h_h2 = (a_h.data() == a_h2.data()) ? 1 : 0;
+      int equal_ptr_h_d  = (a_h.data() == a_d.data()) ? 1 : 0;
+      int equal_ptr_h2_d = (a_h2.data() == a_d.data()) ? 1 : 0;
 
-      int is_same_memspace = std::is_same<Kokkos::HostSpace,typename device::memory_space>::value?1:0;
-      ASSERT_EQ(equal_ptr_h_h2,1);
-      ASSERT_EQ(equal_ptr_h_d ,is_same_memspace);
-      ASSERT_EQ(equal_ptr_h2_d ,is_same_memspace);
+      ASSERT_EQ(equal_ptr_h_h2, 0);
+      ASSERT_EQ(equal_ptr_h_d, 0);
+      ASSERT_EQ(equal_ptr_h2_d, 0);
 
-      ASSERT_EQ(a_h.extent(0),a_h2.extent(0));
-      ASSERT_EQ(a_h.extent(0),a_d .extent(0));
+      ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_d.extent(0));
 
-      ASSERT_EQ(a_h.rank(),a_h2.rank());
-      ASSERT_EQ(a_h.rank(),a_d.rank());
+      ASSERT_EQ(a_h.rank(), a_h2.rank());
+      ASSERT_EQ(a_h.rank(), a_d.rank());
     }
     {
-      Kokkos::DynRankView<double, Kokkos::LayoutRight, Kokkos::HostSpace> a_h("A",1000);
-      auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(),a_h);
-      auto a_d = Kokkos::create_mirror_view(typename device::memory_space(),a_h);
+      Kokkos::DynRankView<double, Kokkos::LayoutRight, Kokkos::HostSpace> a_h(
+          "A", 1000);
+      auto a_h2 = Kokkos::create_mirror(Kokkos::HostSpace(), a_h);
+      auto a_d  = Kokkos::create_mirror(typename device::memory_space(), a_h);
 
-      int equal_ptr_h_h2  = a_h.data() ==a_h2.data()?1:0;
-      int equal_ptr_h_d   = a_h.data() ==a_d. data()?1:0;
-      int equal_ptr_h2_d  = a_h2.data()==a_d. data()?1:0;
+      int equal_ptr_h_h2 = (a_h.data() == a_h2.data()) ? 1 : 0;
+      int equal_ptr_h_d  = (a_h.data() == a_d.data()) ? 1 : 0;
+      int equal_ptr_h2_d = (a_h2.data() == a_d.data()) ? 1 : 0;
 
-      int is_same_memspace = std::is_same<Kokkos::HostSpace,typename device::memory_space>::value?1:0;
-      ASSERT_EQ(equal_ptr_h_h2,1);
-      ASSERT_EQ(equal_ptr_h_d ,is_same_memspace);
-      ASSERT_EQ(equal_ptr_h2_d ,is_same_memspace);
+      ASSERT_EQ(equal_ptr_h_h2, 0);
+      ASSERT_EQ(equal_ptr_h_d, 0);
+      ASSERT_EQ(equal_ptr_h2_d, 0);
 
-  
-      ASSERT_EQ(a_h.extent(0),a_h2.extent(0));
-      ASSERT_EQ(a_h.extent(0),a_d .extent(0));
+      ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_d.extent(0));
 
-      ASSERT_EQ(a_h.rank(),a_h2.rank());
-      ASSERT_EQ(a_h.rank(),a_d.rank());
+      ASSERT_EQ(a_h.rank(), a_h2.rank());
+      ASSERT_EQ(a_h.rank(), a_d.rank());
     }
+
     {
-      typedef Kokkos::DynRankView< int , Kokkos::LayoutStride , Kokkos::HostSpace > view_stride_type ;
-      unsigned order[] = { 6,5,4,3,2,1,0 }, dimen[] = { N0, N1, N2, 2, 2, 2, 2 }; //LayoutRight equivalent
-      view_stride_type a_h( "a" , Kokkos::LayoutStride::order_dimensions(7, order, dimen) );
-      auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(),a_h);
-      auto a_d = Kokkos::create_mirror_view(typename device::memory_space(),a_h);
-
-      int equal_ptr_h_h2  = a_h.data() ==a_h2.data()?1:0;
-      int equal_ptr_h_d   = a_h.data() ==a_d. data()?1:0;
-      int equal_ptr_h2_d  = a_h2.data()==a_d. data()?1:0;
-
-      int is_same_memspace = std::is_same<Kokkos::HostSpace,typename device::memory_space>::value?1:0;
-      ASSERT_EQ(equal_ptr_h_h2,1);
-      ASSERT_EQ(equal_ptr_h_d ,is_same_memspace);
-      ASSERT_EQ(equal_ptr_h2_d ,is_same_memspace);
-
-      ASSERT_EQ(a_h.extent(0),a_h2.extent(0));
-      ASSERT_EQ(a_h.extent(0),a_d .extent(0));
-
-      ASSERT_EQ(a_h.rank(),a_h2.rank());
-      ASSERT_EQ(a_h.rank(),a_d.rank());
+      Kokkos::DynRankView<double, Kokkos::LayoutLeft, Kokkos::HostSpace> a_h(
+          "A", 1000);
+      auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(), a_h);
+      auto a_d =
+          Kokkos::create_mirror_view(typename device::memory_space(), a_h);
+
+      int equal_ptr_h_h2 = a_h.data() == a_h2.data() ? 1 : 0;
+      int equal_ptr_h_d  = a_h.data() == a_d.data() ? 1 : 0;
+      int equal_ptr_h2_d = a_h2.data() == a_d.data() ? 1 : 0;
+
+      int is_same_memspace =
+          std::is_same<Kokkos::HostSpace, typename device::memory_space>::value
+              ? 1
+              : 0;
+      ASSERT_EQ(equal_ptr_h_h2, 1);
+      ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
+      ASSERT_EQ(equal_ptr_h2_d, is_same_memspace);
+
+      ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_d.extent(0));
+
+      ASSERT_EQ(a_h.rank(), a_h2.rank());
+      ASSERT_EQ(a_h.rank(), a_d.rank());
+    }
+    {
+      Kokkos::DynRankView<double, Kokkos::LayoutRight, Kokkos::HostSpace> a_h(
+          "A", 1000);
+      auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(), a_h);
+      auto a_d =
+          Kokkos::create_mirror_view(typename device::memory_space(), a_h);
+
+      int equal_ptr_h_h2 = a_h.data() == a_h2.data() ? 1 : 0;
+      int equal_ptr_h_d  = a_h.data() == a_d.data() ? 1 : 0;
+      int equal_ptr_h2_d = a_h2.data() == a_d.data() ? 1 : 0;
+
+      int is_same_memspace =
+          std::is_same<Kokkos::HostSpace, typename device::memory_space>::value
+              ? 1
+              : 0;
+      ASSERT_EQ(equal_ptr_h_h2, 1);
+      ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
+      ASSERT_EQ(equal_ptr_h2_d, is_same_memspace);
+
+      ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_d.extent(0));
+
+      ASSERT_EQ(a_h.rank(), a_h2.rank());
+      ASSERT_EQ(a_h.rank(), a_d.rank());
+    }
+    {
+      typedef Kokkos::DynRankView<int, Kokkos::LayoutStride, Kokkos::HostSpace>
+          view_stride_type;
+      unsigned order[] = {6, 5, 4, 3, 2, 1, 0},
+               dimen[] = {N0, N1, N2, 2, 2, 2, 2};  // LayoutRight equivalent
+      view_stride_type a_h(
+          "a", Kokkos::LayoutStride::order_dimensions(7, order, dimen));
+      auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(), a_h);
+      auto a_d =
+          Kokkos::create_mirror_view(typename device::memory_space(), a_h);
+
+      int equal_ptr_h_h2 = a_h.data() == a_h2.data() ? 1 : 0;
+      int equal_ptr_h_d  = a_h.data() == a_d.data() ? 1 : 0;
+      int equal_ptr_h2_d = a_h2.data() == a_d.data() ? 1 : 0;
+
+      int is_same_memspace =
+          std::is_same<Kokkos::HostSpace, typename device::memory_space>::value
+              ? 1
+              : 0;
+      ASSERT_EQ(equal_ptr_h_h2, 1);
+      ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
+      ASSERT_EQ(equal_ptr_h2_d, is_same_memspace);
+
+      ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_d.extent(0));
+
+      ASSERT_EQ(a_h.rank(), a_h2.rank());
+      ASSERT_EQ(a_h.rank(), a_d.rank());
     }
   }
 
-  static void run_test_mirror_and_copy()
-  {
+  static void run_test_mirror_and_copy() {
     // LayoutLeft
     {
-      Kokkos::DynRankView< double, Kokkos::LayoutLeft, Kokkos::HostSpace > a_org( "A", 10 );
+      Kokkos::DynRankView<double, Kokkos::LayoutLeft, Kokkos::HostSpace> a_org(
+          "A", 10);
       a_org(5) = 42.0;
-      Kokkos::DynRankView< double, Kokkos::LayoutLeft, Kokkos::HostSpace > a_h = a_org;
-      auto a_h2 = Kokkos::create_mirror_view_and_copy( Kokkos::HostSpace(), a_h );
-      auto a_d = Kokkos::create_mirror_view_and_copy( DeviceType(), a_h );
-      auto a_h3 = Kokkos::create_mirror_view_and_copy( Kokkos::HostSpace(), a_d );
-
-      int equal_ptr_h_h2 = a_h.data()  == a_h2.data() ? 1 : 0;
-      int equal_ptr_h_d  = a_h.data()  ==  a_d.data() ? 1 : 0;
-      int equal_ptr_h2_d = a_h2.data() ==  a_d.data() ? 1 : 0;
-      int equal_ptr_h3_d = a_h3.data() ==  a_d.data() ? 1 : 0;
-
-      int is_same_memspace = std::is_same< Kokkos::HostSpace, typename DeviceType::memory_space >::value ? 1 : 0;
-      ASSERT_EQ( equal_ptr_h_h2, 1 );
-      ASSERT_EQ( equal_ptr_h_d, is_same_memspace );
-      ASSERT_EQ( equal_ptr_h2_d, is_same_memspace );
-      ASSERT_EQ( equal_ptr_h3_d, is_same_memspace );
-
-      ASSERT_EQ( a_h.extent(0), a_h3.extent(0) );
-      ASSERT_EQ( a_h.extent(0), a_h2.extent(0) );
-      ASSERT_EQ( a_h.extent(0), a_d .extent(0) );
-      ASSERT_EQ( a_h.extent(0), a_h3.extent(0) );
-      ASSERT_EQ( a_h.rank(), a_org.rank() );
-      ASSERT_EQ( a_h.rank(), a_h2.rank() );
-      ASSERT_EQ( a_h.rank(), a_h3.rank() );
-      ASSERT_EQ( a_h.rank(), a_d.rank() );
-      ASSERT_EQ( a_org(5), a_h3(5) );
+      Kokkos::DynRankView<double, Kokkos::LayoutLeft, Kokkos::HostSpace> a_h =
+          a_org;
+      auto a_h2 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), a_h);
+      auto a_d  = Kokkos::create_mirror_view_and_copy(DeviceType(), a_h);
+      auto a_h3 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), a_d);
+
+      int equal_ptr_h_h2 = a_h.data() == a_h2.data() ? 1 : 0;
+      int equal_ptr_h_d  = a_h.data() == a_d.data() ? 1 : 0;
+      int equal_ptr_h2_d = a_h2.data() == a_d.data() ? 1 : 0;
+      int equal_ptr_h3_d = a_h3.data() == a_d.data() ? 1 : 0;
+
+      int is_same_memspace =
+          std::is_same<Kokkos::HostSpace,
+                       typename DeviceType::memory_space>::value
+              ? 1
+              : 0;
+      ASSERT_EQ(equal_ptr_h_h2, 1);
+      ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
+      ASSERT_EQ(equal_ptr_h2_d, is_same_memspace);
+      ASSERT_EQ(equal_ptr_h3_d, is_same_memspace);
+
+      ASSERT_EQ(a_h.extent(0), a_h3.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_d.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_h3.extent(0));
+      ASSERT_EQ(a_h.rank(), a_org.rank());
+      ASSERT_EQ(a_h.rank(), a_h2.rank());
+      ASSERT_EQ(a_h.rank(), a_h3.rank());
+      ASSERT_EQ(a_h.rank(), a_d.rank());
+      ASSERT_EQ(a_org(5), a_h3(5));
     }
     // LayoutRight
     {
-      Kokkos::DynRankView< double, Kokkos::LayoutRight, Kokkos::HostSpace > a_org( "A", 10 );
+      Kokkos::DynRankView<double, Kokkos::LayoutRight, Kokkos::HostSpace> a_org(
+          "A", 10);
       a_org(5) = 42.0;
-      Kokkos::DynRankView< double, Kokkos::LayoutRight, Kokkos::HostSpace > a_h = a_org;
-      auto a_h2 = Kokkos::create_mirror_view_and_copy( Kokkos::HostSpace(), a_h );
-      auto a_d = Kokkos::create_mirror_view_and_copy( DeviceType(), a_h );
-      auto a_h3 = Kokkos::create_mirror_view_and_copy( Kokkos::HostSpace(), a_d );
-
-      int equal_ptr_h_h2 = a_h.data()  == a_h2.data() ? 1 : 0;
-      int equal_ptr_h_d  = a_h.data()  ==  a_d.data() ? 1 : 0;
-      int equal_ptr_h2_d = a_h2.data() ==  a_d.data() ? 1 : 0;
-      int equal_ptr_h3_d = a_h3.data() ==  a_d.data() ? 1 : 0;
-
-      int is_same_memspace = std::is_same< Kokkos::HostSpace, typename DeviceType::memory_space >::value ? 1 : 0;
-      ASSERT_EQ( equal_ptr_h_h2, 1 );
-      ASSERT_EQ( equal_ptr_h_d, is_same_memspace );
-      ASSERT_EQ( equal_ptr_h2_d, is_same_memspace );
-      ASSERT_EQ( equal_ptr_h3_d, is_same_memspace );
-
-      ASSERT_EQ( a_h.extent(0), a_h3.extent(0) );
-      ASSERT_EQ( a_h.extent(0), a_h2.extent(0) );
-      ASSERT_EQ( a_h.extent(0), a_d .extent(0) );
-      ASSERT_EQ( a_h.rank(), a_org.rank() );
-      ASSERT_EQ( a_h.rank(), a_h2.rank() );
-      ASSERT_EQ( a_h.rank(), a_h3.rank() );
-      ASSERT_EQ( a_h.rank(), a_d.rank() );
-      ASSERT_EQ( a_org(5), a_h3(5) );
+      Kokkos::DynRankView<double, Kokkos::LayoutRight, Kokkos::HostSpace> a_h =
+          a_org;
+      auto a_h2 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), a_h);
+      auto a_d  = Kokkos::create_mirror_view_and_copy(DeviceType(), a_h);
+      auto a_h3 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), a_d);
+
+      int equal_ptr_h_h2 = a_h.data() == a_h2.data() ? 1 : 0;
+      int equal_ptr_h_d  = a_h.data() == a_d.data() ? 1 : 0;
+      int equal_ptr_h2_d = a_h2.data() == a_d.data() ? 1 : 0;
+      int equal_ptr_h3_d = a_h3.data() == a_d.data() ? 1 : 0;
+
+      int is_same_memspace =
+          std::is_same<Kokkos::HostSpace,
+                       typename DeviceType::memory_space>::value
+              ? 1
+              : 0;
+      ASSERT_EQ(equal_ptr_h_h2, 1);
+      ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
+      ASSERT_EQ(equal_ptr_h2_d, is_same_memspace);
+      ASSERT_EQ(equal_ptr_h3_d, is_same_memspace);
+
+      ASSERT_EQ(a_h.extent(0), a_h3.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+      ASSERT_EQ(a_h.extent(0), a_d.extent(0));
+      ASSERT_EQ(a_h.rank(), a_org.rank());
+      ASSERT_EQ(a_h.rank(), a_h2.rank());
+      ASSERT_EQ(a_h.rank(), a_h3.rank());
+      ASSERT_EQ(a_h.rank(), a_d.rank());
+      ASSERT_EQ(a_org(5), a_h3(5));
     }
   }
 
-  static void run_test_scalar()
-  {
-    typedef typename dView0::HostMirror  hView0 ; //HostMirror of DynRankView is a DynRankView
+  static void run_test_scalar() {
+    typedef typename dView0::HostMirror
+        hView0;  // HostMirror of DynRankView is a DynRankView
 
-    dView0 dx , dy ;
-    hView0 hx , hy ;
+    dView0 dx, dy;
+    hView0 hx, hy;
 
-    dx = dView0( "dx" );
-    dy = dView0( "dy" );
+    dx = dView0("dx");
+    dy = dView0("dy");
 
-    hx = Kokkos::create_mirror( dx );
-    hy = Kokkos::create_mirror( dy );
+    hx = Kokkos::create_mirror(dx);
+    hy = Kokkos::create_mirror(dy);
 
-    hx() = 1 ;
+    hx() = 1;
 
-    Kokkos::deep_copy( dx , hx );
-    Kokkos::deep_copy( dy , dx );
-    Kokkos::deep_copy( hy , dy );
+    Kokkos::deep_copy(dx, hx);
+    Kokkos::deep_copy(dy, dx);
+    Kokkos::deep_copy(hy, dy);
 
-    ASSERT_EQ( hx(), hy() );
-    ASSERT_EQ( dx.rank() , hx.rank() );
-    ASSERT_EQ( dy.rank() , hy.rank() );
+    ASSERT_EQ(hx(), hy());
+    ASSERT_EQ(dx.rank(), hx.rank());
+    ASSERT_EQ(dy.rank(), hy.rank());
 
-  //View - DynRankView Interoperability tests
-  // deep_copy DynRankView to View
+    // View - DynRankView Interoperability tests
+    // deep_copy DynRankView to View
     View0 vx("vx");
-    Kokkos::deep_copy( vx , dx );
-    ASSERT_EQ( rank(dx) , rank(vx) );
+    Kokkos::deep_copy(vx, dx);
+    ASSERT_EQ(rank(dx), rank(vx));
 
     View0 vy("vy");
-    Kokkos::deep_copy( vy , dy );
-    ASSERT_EQ( rank(dy) , rank(vy) );
+    Kokkos::deep_copy(vy, dy);
+    ASSERT_EQ(rank(dy), rank(vy));
 
-  // deep_copy View to DynRankView 
+    // deep_copy View to DynRankView
     dView0 dxx("dxx");
-    Kokkos::deep_copy( dxx , vx );
-    ASSERT_EQ( rank(dxx) , rank(vx) );
-
+    Kokkos::deep_copy(dxx, vx);
+    ASSERT_EQ(rank(dxx), rank(vx));
 
     View7 vcast = dx.ConstDownCast();
-    ASSERT_EQ( dx.extent(0) , vcast.extent(0) );
-    ASSERT_EQ( dx.extent(1) , vcast.extent(1) );
-    ASSERT_EQ( dx.extent(2) , vcast.extent(2) );
-    ASSERT_EQ( dx.extent(3) , vcast.extent(3) );
-    ASSERT_EQ( dx.extent(4) , vcast.extent(4) );
-
-    View7 vcast1( dy.ConstDownCast() );
-    ASSERT_EQ( dy.extent(0) , vcast1.extent(0) );
-    ASSERT_EQ( dy.extent(1) , vcast1.extent(1) );
-    ASSERT_EQ( dy.extent(2) , vcast1.extent(2) );
-    ASSERT_EQ( dy.extent(3) , vcast1.extent(3) );
-    ASSERT_EQ( dy.extent(4) , vcast1.extent(4) );
-
-  //View - DynRankView Interoperability tests
-  // copy View to DynRankView
-    dView0 dfromvx( vx );
-    auto hmx = Kokkos::create_mirror_view(dfromvx) ;
-    Kokkos::deep_copy(hmx , dfromvx);
-    auto hvx = Kokkos::create_mirror_view(vx) ;
-    Kokkos::deep_copy(hvx , vx);
-    ASSERT_EQ( rank(hvx) , rank(hmx) );
-    ASSERT_EQ( hvx.extent(0) , hmx.extent(0) );
-    ASSERT_EQ( hvx.extent(1) , hmx.extent(1) );
-
-  // copy-assign View to DynRankView
-    dView0 dfromvy = vy ;
-    auto hmy = Kokkos::create_mirror_view(dfromvy) ;
-    Kokkos::deep_copy(hmy , dfromvy);
-    auto hvy = Kokkos::create_mirror_view(vy) ;
-    Kokkos::deep_copy(hvy , vy);
-    ASSERT_EQ( rank(hvy) , rank(hmy) );
-    ASSERT_EQ( hvy.extent(0) , hmy.extent(0) );
-    ASSERT_EQ( hvy.extent(1) , hmy.extent(1) );
-
-
-    View7 vtest1("vtest1",2,2,2,2,2,2,2);
-    dView0 dfromv1( vtest1 );
-    ASSERT_EQ( dfromv1.rank() , vtest1.Rank );
-    ASSERT_EQ( dfromv1.extent(0) , vtest1.extent(0) );
-    ASSERT_EQ( dfromv1.extent(1) , vtest1.extent(1) );
-    ASSERT_EQ( dfromv1.use_count() , vtest1.use_count() );
-
-    dView0 dfromv2( vcast );
-    ASSERT_EQ( dfromv2.rank() , vcast.Rank );
-    ASSERT_EQ( dfromv2.extent(0) , vcast.extent(0) );
-    ASSERT_EQ( dfromv2.extent(1) , vcast.extent(1) );
-    ASSERT_EQ( dfromv2.use_count() , vcast.use_count() );
+    ASSERT_EQ(dx.extent(0), vcast.extent(0));
+    ASSERT_EQ(dx.extent(1), vcast.extent(1));
+    ASSERT_EQ(dx.extent(2), vcast.extent(2));
+    ASSERT_EQ(dx.extent(3), vcast.extent(3));
+    ASSERT_EQ(dx.extent(4), vcast.extent(4));
+
+    View7 vcast1(dy.ConstDownCast());
+    ASSERT_EQ(dy.extent(0), vcast1.extent(0));
+    ASSERT_EQ(dy.extent(1), vcast1.extent(1));
+    ASSERT_EQ(dy.extent(2), vcast1.extent(2));
+    ASSERT_EQ(dy.extent(3), vcast1.extent(3));
+    ASSERT_EQ(dy.extent(4), vcast1.extent(4));
+
+    // View - DynRankView Interoperability tests
+    // copy View to DynRankView
+    dView0 dfromvx(vx);
+    auto hmx = Kokkos::create_mirror_view(dfromvx);
+    Kokkos::deep_copy(hmx, dfromvx);
+    auto hvx = Kokkos::create_mirror_view(vx);
+    Kokkos::deep_copy(hvx, vx);
+    ASSERT_EQ(rank(hvx), rank(hmx));
+    ASSERT_EQ(hvx.extent(0), hmx.extent(0));
+    ASSERT_EQ(hvx.extent(1), hmx.extent(1));
+
+    // copy-assign View to DynRankView
+    dView0 dfromvy = vy;
+    auto hmy       = Kokkos::create_mirror_view(dfromvy);
+    Kokkos::deep_copy(hmy, dfromvy);
+    auto hvy = Kokkos::create_mirror_view(vy);
+    Kokkos::deep_copy(hvy, vy);
+    ASSERT_EQ(rank(hvy), rank(hmy));
+    ASSERT_EQ(hvy.extent(0), hmy.extent(0));
+    ASSERT_EQ(hvy.extent(1), hmy.extent(1));
+
+    View7 vtest1("vtest1", 2, 2, 2, 2, 2, 2, 2);
+    dView0 dfromv1(vtest1);
+    ASSERT_EQ(dfromv1.rank(), vtest1.Rank);
+    ASSERT_EQ(dfromv1.extent(0), vtest1.extent(0));
+    ASSERT_EQ(dfromv1.extent(1), vtest1.extent(1));
+    ASSERT_EQ(dfromv1.use_count(), vtest1.use_count());
+
+    dView0 dfromv2(vcast);
+    ASSERT_EQ(dfromv2.rank(), vcast.Rank);
+    ASSERT_EQ(dfromv2.extent(0), vcast.extent(0));
+    ASSERT_EQ(dfromv2.extent(1), vcast.extent(1));
+    ASSERT_EQ(dfromv2.use_count(), vcast.use_count());
 
     dView0 dfromv3 = vcast1;
-    ASSERT_EQ( dfromv3.rank() , vcast1.Rank );
-    ASSERT_EQ( dfromv3.extent(0) , vcast1.extent(0) );
-    ASSERT_EQ( dfromv3.extent(1) , vcast1.extent(1) );
-    ASSERT_EQ( dfromv3.use_count() , vcast1.use_count() );
+    ASSERT_EQ(dfromv3.rank(), vcast1.Rank);
+    ASSERT_EQ(dfromv3.extent(0), vcast1.extent(0));
+    ASSERT_EQ(dfromv3.extent(1), vcast1.extent(1));
+    ASSERT_EQ(dfromv3.use_count(), vcast1.use_count());
   }
 
-  static void run_test()
-  {
+  static void run_test() {
     // mfh 14 Feb 2014: This test doesn't actually create instances of
     // these types.  In order to avoid "declared but unused typedef"
     // warnings, we declare empty instances of these types, with the
     // usual "(void)" marker to avoid compiler warnings for unused
     // variables.
 
-    typedef typename dView0::HostMirror  hView0 ;
+    typedef typename dView0::HostMirror hView0;
 
     {
       hView0 thing;
-      (void) thing;
+      (void)thing;
     }
 
-    dView0 d_uninitialized(Kokkos::ViewAllocateWithoutInitializing("uninit"),10,20);
-    ASSERT_TRUE( d_uninitialized.data() != nullptr );
-    ASSERT_EQ( d_uninitialized.rank() , 2 );
-    ASSERT_EQ( d_uninitialized.extent(0) , 10 );
-    ASSERT_EQ( d_uninitialized.extent(1) , 20 );
-    ASSERT_EQ( d_uninitialized.extent(2) , 1  );
-
-    dView0 dx , dy , dz ;
-    hView0 hx , hy , hz ;
-
-    ASSERT_TRUE( Kokkos::is_dyn_rank_view<dView0>::value );
-    ASSERT_FALSE( Kokkos::is_dyn_rank_view< Kokkos::View<double> >::value );
-
-    ASSERT_TRUE( dx.data() == 0 ); //Okay with UVM
-    ASSERT_TRUE( dy.data() == 0 );  //Okay with UVM
-    ASSERT_TRUE( dz.data() == 0 ); //Okay with UVM
-    ASSERT_TRUE( hx.data() == 0 );
-    ASSERT_TRUE( hy.data() == 0 );
-    ASSERT_TRUE( hz.data() == 0 );
-    ASSERT_EQ( dx.extent(0) , 0u ); //Okay with UVM
-    ASSERT_EQ( dy.extent(0) , 0u ); //Okay with UVM
-    ASSERT_EQ( dz.extent(0) , 0u ); //Okay with UVM
-    ASSERT_EQ( hx.extent(0) , 0u );
-    ASSERT_EQ( hy.extent(0) , 0u );
-    ASSERT_EQ( hz.extent(0) , 0u );
-    ASSERT_EQ( dx.rank() , 0u ); //Okay with UVM
-    ASSERT_EQ( hx.rank() , 0u );
-
-    dx = dView0( "dx" , N1 , N2 , N3 );
-    dy = dView0( "dy" , N1 , N2 , N3 );
-
-    hx = hView0( "hx" , N1 , N2 , N3 );
-    hy = hView0( "hy" , N1 , N2 , N3 );
-
-    ASSERT_EQ( dx.extent(0) , unsigned(N1) ); //Okay with UVM
-    ASSERT_EQ( dy.extent(0) , unsigned(N1) ); //Okay with UVM
-    ASSERT_EQ( hx.extent(0) , unsigned(N1) );
-    ASSERT_EQ( hy.extent(0) , unsigned(N1) );
-    ASSERT_EQ( dx.rank() , 3 ); //Okay with UVM
-    ASSERT_EQ( hx.rank() , 3 );
-
-    dx = dView0( "dx" , N0 , N1 , N2 , N3 );
-    dy = dView0( "dy" , N0 , N1 , N2 , N3 );
-    hx = hView0( "hx" , N0 , N1 , N2 , N3 );
-    hy = hView0( "hy" , N0 , N1 , N2 , N3 );
-
-    ASSERT_EQ( dx.extent(0) , unsigned(N0) );
-    ASSERT_EQ( dy.extent(0) , unsigned(N0) );
-    ASSERT_EQ( hx.extent(0) , unsigned(N0) );
-    ASSERT_EQ( hy.extent(0) , unsigned(N0) );
-    ASSERT_EQ( dx.rank() , 4 );
-    ASSERT_EQ( dy.rank() , 4 );
-    ASSERT_EQ( hx.rank() , 4 );
-    ASSERT_EQ( hy.rank() , 4 );
-
-    ASSERT_EQ( dx.use_count() , size_t(1) );
+    dView0 d_uninitialized(Kokkos::ViewAllocateWithoutInitializing("uninit"),
+                           10, 20);
+    ASSERT_TRUE(d_uninitialized.data() != nullptr);
+    ASSERT_EQ(d_uninitialized.rank(), 2);
+    ASSERT_EQ(d_uninitialized.extent(0), 10);
+    ASSERT_EQ(d_uninitialized.extent(1), 20);
+    ASSERT_EQ(d_uninitialized.extent(2), 1);
+
+    dView0 dx, dy, dz;
+    hView0 hx, hy, hz;
+
+    ASSERT_TRUE(Kokkos::is_dyn_rank_view<dView0>::value);
+    ASSERT_FALSE(Kokkos::is_dyn_rank_view<Kokkos::View<double> >::value);
+
+    ASSERT_TRUE(dx.data() == 0);  // Okay with UVM
+    ASSERT_TRUE(dy.data() == 0);  // Okay with UVM
+    ASSERT_TRUE(dz.data() == 0);  // Okay with UVM
+    ASSERT_TRUE(hx.data() == 0);
+    ASSERT_TRUE(hy.data() == 0);
+    ASSERT_TRUE(hz.data() == 0);
+    ASSERT_EQ(dx.extent(0), 0u);  // Okay with UVM
+    ASSERT_EQ(dy.extent(0), 0u);  // Okay with UVM
+    ASSERT_EQ(dz.extent(0), 0u);  // Okay with UVM
+    ASSERT_EQ(hx.extent(0), 0u);
+    ASSERT_EQ(hy.extent(0), 0u);
+    ASSERT_EQ(hz.extent(0), 0u);
+    ASSERT_EQ(dx.rank(), 0u);  // Okay with UVM
+    ASSERT_EQ(hx.rank(), 0u);
+
+    dx = dView0("dx", N1, N2, N3);
+    dy = dView0("dy", N1, N2, N3);
+
+    hx = hView0("hx", N1, N2, N3);
+    hy = hView0("hy", N1, N2, N3);
+
+    ASSERT_EQ(dx.extent(0), unsigned(N1));  // Okay with UVM
+    ASSERT_EQ(dy.extent(0), unsigned(N1));  // Okay with UVM
+    ASSERT_EQ(hx.extent(0), unsigned(N1));
+    ASSERT_EQ(hy.extent(0), unsigned(N1));
+    ASSERT_EQ(dx.rank(), 3);  // Okay with UVM
+    ASSERT_EQ(hx.rank(), 3);
+
+    dx = dView0("dx", N0, N1, N2, N3);
+    dy = dView0("dy", N0, N1, N2, N3);
+    hx = hView0("hx", N0, N1, N2, N3);
+    hy = hView0("hy", N0, N1, N2, N3);
+
+    ASSERT_EQ(dx.extent(0), unsigned(N0));
+    ASSERT_EQ(dy.extent(0), unsigned(N0));
+    ASSERT_EQ(hx.extent(0), unsigned(N0));
+    ASSERT_EQ(hy.extent(0), unsigned(N0));
+    ASSERT_EQ(dx.rank(), 4);
+    ASSERT_EQ(dy.rank(), 4);
+    ASSERT_EQ(hx.rank(), 4);
+    ASSERT_EQ(hy.rank(), 4);
+
+    ASSERT_EQ(dx.use_count(), size_t(1));
 
     dView0_unmanaged unmanaged_dx = dx;
-    ASSERT_EQ( dx.use_count() , size_t(1) );
-
-
-    dView0_unmanaged unmanaged_from_ptr_dx = dView0_unmanaged(dx.data(),
-                                                              dx.extent(0),
-                                                              dx.extent(1),
-                                                              dx.extent(2),
-                                                              dx.extent(3));
+    ASSERT_EQ(dx.use_count(), size_t(1));
 
+    dView0_unmanaged unmanaged_from_ptr_dx = dView0_unmanaged(
+        dx.data(), dx.extent(0), dx.extent(1), dx.extent(2), dx.extent(3));
 
     {
       // Destruction of this view should be harmless
-      const_dView0 unmanaged_from_ptr_const_dx( dx.data() ,
-                                                dx.extent(0) ,
-                                                dx.extent(1) ,
-                                                dx.extent(2) ,
-                                                dx.extent(3) );
+      const_dView0 unmanaged_from_ptr_const_dx(
+          dx.data(), dx.extent(0), dx.extent(1), dx.extent(2), dx.extent(3));
     }
 
-    const_dView0 const_dx = dx ;
-    ASSERT_EQ( dx.use_count() , size_t(2) );
+    const_dView0 const_dx = dx;
+    ASSERT_EQ(dx.use_count(), size_t(2));
 
     {
       const_dView0 const_dx2;
       const_dx2 = const_dx;
-      ASSERT_EQ( dx.use_count() , size_t(3) );
+      ASSERT_EQ(dx.use_count(), size_t(3));
 
       const_dx2 = dy;
-      ASSERT_EQ( dx.use_count() , size_t(2) );
+      ASSERT_EQ(dx.use_count(), size_t(2));
 
       const_dView0 const_dx3(dx);
-      ASSERT_EQ( dx.use_count() , size_t(3) );
-      
+      ASSERT_EQ(dx.use_count(), size_t(3));
+
       dView0_unmanaged dx4_unmanaged(dx);
-      ASSERT_EQ( dx.use_count() , size_t(3) );
+      ASSERT_EQ(dx.use_count(), size_t(3));
     }
 
-    ASSERT_EQ( dx.use_count() , size_t(2) );
-
+    ASSERT_EQ(dx.use_count(), size_t(2));
 
-    ASSERT_FALSE( dx.data() == 0 );
-    ASSERT_FALSE( const_dx.data() == 0 );
-    ASSERT_FALSE( unmanaged_dx.data() == 0 );
-    ASSERT_FALSE( unmanaged_from_ptr_dx.data() == 0 );
-    ASSERT_FALSE( dy.data() == 0 );
-    ASSERT_NE( dx , dy );
+    ASSERT_FALSE(dx.data() == 0);
+    ASSERT_FALSE(const_dx.data() == 0);
+    ASSERT_FALSE(unmanaged_dx.data() == 0);
+    ASSERT_FALSE(unmanaged_from_ptr_dx.data() == 0);
+    ASSERT_FALSE(dy.data() == 0);
+    ASSERT_NE(dx, dy);
 
-    ASSERT_EQ( dx.extent(0) , unsigned(N0) );
-    ASSERT_EQ( dx.extent(1) , unsigned(N1) );
-    ASSERT_EQ( dx.extent(2) , unsigned(N2) );
-    ASSERT_EQ( dx.extent(3) , unsigned(N3) );
+    ASSERT_EQ(dx.extent(0), unsigned(N0));
+    ASSERT_EQ(dx.extent(1), unsigned(N1));
+    ASSERT_EQ(dx.extent(2), unsigned(N2));
+    ASSERT_EQ(dx.extent(3), unsigned(N3));
 
-    ASSERT_EQ( dy.extent(0) , unsigned(N0) );
-    ASSERT_EQ( dy.extent(1) , unsigned(N1) );
-    ASSERT_EQ( dy.extent(2) , unsigned(N2) );
-    ASSERT_EQ( dy.extent(3) , unsigned(N3) );
+    ASSERT_EQ(dy.extent(0), unsigned(N0));
+    ASSERT_EQ(dy.extent(1), unsigned(N1));
+    ASSERT_EQ(dy.extent(2), unsigned(N2));
+    ASSERT_EQ(dy.extent(3), unsigned(N3));
 
-    ASSERT_EQ( unmanaged_from_ptr_dx.span(),unsigned(N0)*unsigned(N1)*unsigned(N2)*unsigned(N3) );
+    ASSERT_EQ(unmanaged_from_ptr_dx.span(),
+              unsigned(N0) * unsigned(N1) * unsigned(N2) * unsigned(N3));
 
-    hx = Kokkos::create_mirror( dx );
-    hy = Kokkos::create_mirror( dy );
+    hx = Kokkos::create_mirror(dx);
+    hy = Kokkos::create_mirror(dy);
 
-    ASSERT_EQ( hx.rank() , dx.rank() );
-    ASSERT_EQ( hy.rank() , dy.rank() );
+    ASSERT_EQ(hx.rank(), dx.rank());
+    ASSERT_EQ(hy.rank(), dy.rank());
 
-    ASSERT_EQ( hx.extent(0) , unsigned(N0) );
-    ASSERT_EQ( hx.extent(1) , unsigned(N1) );
-    ASSERT_EQ( hx.extent(2) , unsigned(N2) );
-    ASSERT_EQ( hx.extent(3) , unsigned(N3) );
+    ASSERT_EQ(hx.extent(0), unsigned(N0));
+    ASSERT_EQ(hx.extent(1), unsigned(N1));
+    ASSERT_EQ(hx.extent(2), unsigned(N2));
+    ASSERT_EQ(hx.extent(3), unsigned(N3));
 
-    ASSERT_EQ( hy.extent(0) , unsigned(N0) );
-    ASSERT_EQ( hy.extent(1) , unsigned(N1) );
-    ASSERT_EQ( hy.extent(2) , unsigned(N2) );
-    ASSERT_EQ( hy.extent(3) , unsigned(N3) );
+    ASSERT_EQ(hy.extent(0), unsigned(N0));
+    ASSERT_EQ(hy.extent(1), unsigned(N1));
+    ASSERT_EQ(hy.extent(2), unsigned(N2));
+    ASSERT_EQ(hy.extent(3), unsigned(N3));
 
     // T v1 = hx() ;    // Generates compile error as intended
     // T v2 = hx(0,0) ; // Generates compile error as intended
@@ -1265,365 +1263,422 @@ public:
 
     // Testing with synchronous deep copy
     {
-      size_t count = 0 ;
-      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
-      for ( size_t i1 = 0 ; i1 < hx.extent(1) ; ++i1 ) {
-      for ( size_t i2 = 0 ; i2 < hx.extent(2) ; ++i2 ) {
-      for ( size_t i3 = 0 ; i3 < hx.extent(3) ; ++i3 ) {
-        hx(ip,i1,i2,i3) = ++count ;
-      }}}}
-
-      Kokkos::deep_copy( dx , hx );
-      Kokkos::deep_copy( dy , dx );
-      Kokkos::deep_copy( hy , dy );
+      size_t count = 0;
+      for (size_t ip = 0; ip < N0; ++ip) {
+        for (size_t i1 = 0; i1 < hx.extent(1); ++i1) {
+          for (size_t i2 = 0; i2 < hx.extent(2); ++i2) {
+            for (size_t i3 = 0; i3 < hx.extent(3); ++i3) {
+              hx(ip, i1, i2, i3) = ++count;
+            }
+          }
+        }
+      }
+
+      Kokkos::deep_copy(dx, hx);
+      Kokkos::deep_copy(dy, dx);
+      Kokkos::deep_copy(hy, dy);
       Kokkos::fence();
 
-      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
-      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
-      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
-      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
-        { ASSERT_EQ( hx(ip,i1,i2,i3) , hy(ip,i1,i2,i3) ); }
-      }}}}
-
-      Kokkos::deep_copy( dx , T(0) );
-      Kokkos::deep_copy( hx , dx );
+      for (size_t ip = 0; ip < N0; ++ip) {
+        for (size_t i1 = 0; i1 < N1; ++i1) {
+          for (size_t i2 = 0; i2 < N2; ++i2) {
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              {
+                ASSERT_EQ(hx(ip, i1, i2, i3), hy(ip, i1, i2, i3));
+              }
+            }
+          }
+        }
+      }
+
+      Kokkos::deep_copy(dx, T(0));
+      Kokkos::deep_copy(hx, dx);
       Kokkos::fence();
 
-      for ( size_t ip = 0 ; ip < N0 ; ++ip ) {
-      for ( size_t i1 = 0 ; i1 < N1 ; ++i1 ) {
-      for ( size_t i2 = 0 ; i2 < N2 ; ++i2 ) {
-      for ( size_t i3 = 0 ; i3 < N3 ; ++i3 ) {
-        { ASSERT_EQ( hx(ip,i1,i2,i3) , T(0) ); }
-      }}}}
-//    ASSERT_EQ( hx(0,0,0,0,0,0,0,0) , T(0) ); //Test rank8 op behaves properly - if implemented
+      for (size_t ip = 0; ip < N0; ++ip) {
+        for (size_t i1 = 0; i1 < N1; ++i1) {
+          for (size_t i2 = 0; i2 < N2; ++i2) {
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              {
+                ASSERT_EQ(hx(ip, i1, i2, i3), T(0));
+              }
+            }
+          }
+        }
+      }
+      //    ASSERT_EQ( hx(0,0,0,0,0,0,0,0) , T(0) ); //Test rank8 op behaves
+      //    properly - if implemented
     }
 
-    dz = dx ; ASSERT_EQ( dx, dz); ASSERT_NE( dy, dz);
-    dz = dy ; ASSERT_EQ( dy, dz); ASSERT_NE( dx, dz);
+    dz = dx;
+    ASSERT_EQ(dx, dz);
+    ASSERT_NE(dy, dz);
+    dz = dy;
+    ASSERT_EQ(dy, dz);
+    ASSERT_NE(dx, dz);
 
     dx = dView0();
-    ASSERT_TRUE( dx.data() == 0 );
-    ASSERT_FALSE( dy.data() == 0 );
-    ASSERT_FALSE( dz.data() == 0 );
+    ASSERT_TRUE(dx.data() == 0);
+    ASSERT_FALSE(dy.data() == 0);
+    ASSERT_FALSE(dz.data() == 0);
     dy = dView0();
-    ASSERT_TRUE( dx.data() == 0 );
-    ASSERT_TRUE( dy.data() == 0 );
-    ASSERT_FALSE( dz.data() == 0 );
+    ASSERT_TRUE(dx.data() == 0);
+    ASSERT_TRUE(dy.data() == 0);
+    ASSERT_FALSE(dz.data() == 0);
     dz = dView0();
-    ASSERT_TRUE( dx.data() == 0 );
-    ASSERT_TRUE( dy.data() == 0 );
-    ASSERT_TRUE( dz.data() == 0 );
+    ASSERT_TRUE(dx.data() == 0);
+    ASSERT_TRUE(dy.data() == 0);
+    ASSERT_TRUE(dz.data() == 0);
 
-  //View - DynRankView Interoperability tests
+    // View - DynRankView Interoperability tests
     // deep_copy from view to dynrankview
     const int testdim = 4;
-    dView0 dxx("dxx",testdim);
-    View1  vxx("vxx",testdim);
-    auto hvxx = Kokkos::create_mirror_view(vxx); 
-    for (int i = 0; i < testdim; ++i)
-      { hvxx(i) = i; }
-    Kokkos::deep_copy(vxx,hvxx);
-    Kokkos::deep_copy(dxx,vxx);
+    dView0 dxx("dxx", testdim);
+    View1 vxx("vxx", testdim);
+    auto hvxx = Kokkos::create_mirror_view(vxx);
+    for (int i = 0; i < testdim; ++i) {
+      hvxx(i) = i;
+    }
+    Kokkos::deep_copy(vxx, hvxx);
+    Kokkos::deep_copy(dxx, vxx);
     auto hdxx = Kokkos::create_mirror_view(dxx);
-    Kokkos::deep_copy(hdxx,dxx);
-    for (int i = 0; i < testdim; ++i)
-      { ASSERT_EQ( hvxx(i) , hdxx(i) ); }
+    Kokkos::deep_copy(hdxx, dxx);
+    for (int i = 0; i < testdim; ++i) {
+      ASSERT_EQ(hvxx(i), hdxx(i));
+    }
 
-    ASSERT_EQ( rank(hdxx) , rank(hvxx) );
-    ASSERT_EQ( hdxx.extent(0) , testdim );
-    ASSERT_EQ( hdxx.extent(0) , hvxx.extent(0) );
+    ASSERT_EQ(rank(hdxx), rank(hvxx));
+    ASSERT_EQ(hdxx.extent(0), testdim);
+    ASSERT_EQ(hdxx.extent(0), hvxx.extent(0));
 
     // deep_copy from dynrankview to view
-    View1 vdxx("vdxx",testdim);
+    View1 vdxx("vdxx", testdim);
     auto hvdxx = Kokkos::create_mirror_view(vdxx);
-    Kokkos::deep_copy(hvdxx , hdxx);
-    ASSERT_EQ( rank(hdxx) , rank(hvdxx) );
-    ASSERT_EQ( hvdxx.extent(0) , testdim );
-    ASSERT_EQ( hdxx.extent(0) , hvdxx.extent(0) );
-    for (int i = 0; i < testdim; ++i)
-      { ASSERT_EQ( hvxx(i) , hvdxx(i) ); }
+    Kokkos::deep_copy(hvdxx, hdxx);
+    ASSERT_EQ(rank(hdxx), rank(hvdxx));
+    ASSERT_EQ(hvdxx.extent(0), testdim);
+    ASSERT_EQ(hdxx.extent(0), hvdxx.extent(0));
+    for (int i = 0; i < testdim; ++i) {
+      ASSERT_EQ(hvxx(i), hvdxx(i));
+    }
   }
 
-  typedef T DataType ;
+  typedef T DataType;
 
-  static void
-  check_auto_conversion_to_const(
-     const Kokkos::DynRankView< const DataType , device > & arg_const ,
-     const Kokkos::DynRankView< DataType , device > & arg )
-  {
-    ASSERT_TRUE( arg_const == arg );
+  static void check_auto_conversion_to_const(
+      const Kokkos::DynRankView<const DataType, device>& arg_const,
+      const Kokkos::DynRankView<DataType, device>& arg) {
+    ASSERT_TRUE(arg_const == arg);
   }
 
-  static void run_test_const()
-  {
-    typedef Kokkos::DynRankView< DataType , device > typeX ;
-    typedef Kokkos::DynRankView< const DataType , device > const_typeX ;
-    typedef Kokkos::DynRankView< const DataType , device , Kokkos::MemoryRandomAccess > const_typeR ;
-    typeX x( "X", 2 );
-    const_typeX xc = x ;
-    const_typeR xr = x ;
+  static void run_test_const() {
+    typedef Kokkos::DynRankView<DataType, device> typeX;
+    typedef Kokkos::DynRankView<const DataType, device> const_typeX;
+    typedef Kokkos::DynRankView<const DataType, device,
+                                Kokkos::MemoryRandomAccess>
+        const_typeR;
+    typeX x("X", 2);
+    const_typeX xc = x;
+    const_typeR xr = x;
 
-    ASSERT_TRUE( xc == x );
-    ASSERT_TRUE( x == xc );
+    ASSERT_TRUE(xc == x);
+    ASSERT_TRUE(x == xc);
 
     // For CUDA the constant random access View does not return
     // an lvalue reference due to retrieving through texture cache
     // therefore not allowed to query the underlying pointer.
 #if defined(KOKKOS_ENABLE_CUDA)
-    if ( ! std::is_same< typename device::execution_space , Kokkos::Cuda >::value )
+    if (!std::is_same<typename device::execution_space, Kokkos::Cuda>::value)
 #endif
     {
-      ASSERT_TRUE( x.data() == xr.data() );
+      ASSERT_TRUE(x.data() == xr.data());
     }
 
     // typeX xf = xc ; // setting non-const from const must not compile
 
-    check_auto_conversion_to_const( x , x );
+    check_auto_conversion_to_const(x, x);
   }
 
-
-  static void run_test_subview()
-  {
-    typedef Kokkos::DynRankView< const T , device > cdView ;
-    typedef Kokkos::DynRankView< T , device > dView ;
-  // LayoutStride required for all returned DynRankView subdynrankview's
-    typedef Kokkos::DynRankView< T , Kokkos::LayoutStride , device > sdView ; 
-
-    dView0 d0( "d0" );
-    cdView s0 = d0 ;
-
-  //  N0 = 1000,N1 = 3,N2 = 5,N3 = 7 
-    unsigned order[] = { 6,5,4,3,2,1,0 }, dimen[] = { N0, N1, N2, 2, 2, 2, 2 }; //LayoutRight equivalent
-    sdView d7( "d7" , Kokkos::LayoutStride::order_dimensions(7, order, dimen) );
-    ASSERT_EQ( d7.rank() , 7 );
-
-    sdView ds0 = Kokkos::subdynrankview( d7 , 1 , 1 , 1 , 1 , 1 , 1 , 1 ); 
-    ASSERT_EQ( ds0.rank() , 0 );
-
-//Basic test - ALL
-    sdView dsALL = Kokkos::subdynrankview( d7 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() ); 
-    ASSERT_EQ( dsALL.rank() , 7 );
-
-//  Send a value to final rank returning rank 6 subview
-    sdView dsm1 = Kokkos::subdynrankview( d7 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , 1 );
-    ASSERT_EQ( dsm1.rank() , 6 );
-
-//  Send a std::pair as argument to a rank
-    sdView dssp = Kokkos::subdynrankview( d7 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , std::pair<unsigned,unsigned>(1,2) );
-    ASSERT_EQ( dssp.rank() , 7 );
-
-//  Send a kokkos::pair as argument to a rank; take default layout as input
-    dView0 dd0("dd0" , N0 , N1 , N2 , 2 , 2 , 2 , 2 ); //default layout
-    ASSERT_EQ( dd0.rank() , 7 );
-    sdView dtkp = Kokkos::subdynrankview( dd0 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::pair<unsigned,unsigned>(0,1) );
-    ASSERT_EQ( dtkp.rank() , 7 );
-
-// Return rank 7 subview, taking a pair as one argument, layout stride input
-    sdView ds7 = Kokkos::subdynrankview( d7 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::pair<unsigned,unsigned>(0,1) );
-    ASSERT_EQ( ds7.rank() , 7 );
-
-// Default Layout DynRankView
-    dView dv6("dv6" , N0 , N1 , N2 , N3 , 2 , 2 );
-    ASSERT_EQ( dv6.rank() , 6 );
-
-// DynRankView with LayoutRight
-    typedef Kokkos::DynRankView< T , Kokkos::LayoutRight , device > drView ;
-    drView dr5( "dr5" , N0 , N1 , N2 , 2 , 2 );
-    ASSERT_EQ( dr5.rank() , 5 );
-
-// LayoutStride but arranged as LayoutRight
-  // NOTE: unused arg_layout dimensions must be set toKOKKOS_INVALID_INDEX so that 
-  //  rank deduction can properly take place
-    unsigned order5[] = { 4,3,2,1,0 }, dimen5[] = { N0, N1, N2, 2, 2 };
-    Kokkos::LayoutStride ls = Kokkos::LayoutStride::order_dimensions(5, order5, dimen5);
-    ls.dimension[5] =KOKKOS_INVALID_INDEX;
-    ls.dimension[6] =KOKKOS_INVALID_INDEX;
-    ls.dimension[7] =KOKKOS_INVALID_INDEX;
+  static void run_test_subview() {
+    typedef Kokkos::DynRankView<const T, device> cdView;
+    typedef Kokkos::DynRankView<T, device> dView;
+    // LayoutStride required for all returned DynRankView subdynrankview's
+    typedef Kokkos::DynRankView<T, Kokkos::LayoutStride, device> sdView;
+
+    dView0 d0("d0");
+    cdView s0 = d0;
+
+    //  N0 = 1000,N1 = 3,N2 = 5,N3 = 7
+    unsigned order[] = {6, 5, 4, 3, 2, 1, 0},
+             dimen[] = {N0, N1, N2, 2, 2, 2, 2};  // LayoutRight equivalent
+    sdView d7("d7", Kokkos::LayoutStride::order_dimensions(7, order, dimen));
+    ASSERT_EQ(d7.rank(), 7);
+
+    sdView ds0 = Kokkos::subdynrankview(d7, 1, 1, 1, 1, 1, 1, 1);
+    ASSERT_EQ(ds0.rank(), 0);
+
+    // Basic test - ALL
+    sdView dsALL = Kokkos::subdynrankview(
+        d7, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+        Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+    ASSERT_EQ(dsALL.rank(), 7);
+
+    //  Send a value to final rank returning rank 6 subview
+    sdView dsm1 =
+        Kokkos::subdynrankview(d7, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                               Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), 1);
+    ASSERT_EQ(dsm1.rank(), 6);
+
+    //  Send a std::pair as argument to a rank
+    sdView dssp = Kokkos::subdynrankview(
+        d7, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+        Kokkos::ALL(), Kokkos::ALL(), std::pair<unsigned, unsigned>(1, 2));
+    ASSERT_EQ(dssp.rank(), 7);
+
+    //  Send a kokkos::pair as argument to a rank; take default layout as input
+    dView0 dd0("dd0", N0, N1, N2, 2, 2, 2, 2);  // default layout
+    ASSERT_EQ(dd0.rank(), 7);
+    sdView dtkp = Kokkos::subdynrankview(
+        dd0, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+        Kokkos::ALL(), Kokkos::ALL(), Kokkos::pair<unsigned, unsigned>(0, 1));
+    ASSERT_EQ(dtkp.rank(), 7);
+
+    // Return rank 7 subview, taking a pair as one argument, layout stride input
+    sdView ds7 = Kokkos::subdynrankview(
+        d7, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+        Kokkos::ALL(), Kokkos::ALL(), Kokkos::pair<unsigned, unsigned>(0, 1));
+    ASSERT_EQ(ds7.rank(), 7);
+
+    // Default Layout DynRankView
+    dView dv6("dv6", N0, N1, N2, N3, 2, 2);
+    ASSERT_EQ(dv6.rank(), 6);
+
+    // DynRankView with LayoutRight
+    typedef Kokkos::DynRankView<T, Kokkos::LayoutRight, device> drView;
+    drView dr5("dr5", N0, N1, N2, 2, 2);
+    ASSERT_EQ(dr5.rank(), 5);
+
+    // LayoutStride but arranged as LayoutRight
+    // NOTE: unused arg_layout dimensions must be set toKOKKOS_INVALID_INDEX so
+    // that
+    //  rank deduction can properly take place
+    unsigned order5[] = {4, 3, 2, 1, 0}, dimen5[] = {N0, N1, N2, 2, 2};
+    Kokkos::LayoutStride ls =
+        Kokkos::LayoutStride::order_dimensions(5, order5, dimen5);
+    ls.dimension[5] = KOKKOS_INVALID_INDEX;
+    ls.dimension[6] = KOKKOS_INVALID_INDEX;
+    ls.dimension[7] = KOKKOS_INVALID_INDEX;
     sdView d5("d5", ls);
-    ASSERT_EQ( d5.rank() , 5 );
-
-//  LayoutStride arranged as LayoutRight - commented out as example that fails unit test
-//    unsigned order5[] = { 4,3,2,1,0 }, dimen5[] = { N0, N1, N2, 2, 2 };
-//    sdView d5( "d5" , Kokkos::LayoutStride::order_dimensions(5, order5, dimen5) );
-//
-//  Fails the following unit test:
-//    ASSERT_EQ( d5.rank() , dr5.rank() );
-//
-//  Explanation: In construction of the Kokkos::LayoutStride below, since the 
-//   remaining dimensions are not specified, they will default to values of 0 
-//   rather thanKOKKOS_INVALID_INDEX. 
-//  When passed to the DynRankView constructor the default dimensions (of 0) 
-//   will be counted toward the dynamic rank and returning an incorrect value 
-//   (i.e. rank 7 rather than 5).
-
-// Check LayoutRight dr5 and LayoutStride d5 dimensions agree (as they should) 
-    ASSERT_EQ( d5.extent(0) , dr5.extent(0) );
-    ASSERT_EQ( d5.extent(1) , dr5.extent(1) );
-    ASSERT_EQ( d5.extent(2) , dr5.extent(2) );
-    ASSERT_EQ( d5.extent(3) , dr5.extent(3) );
-    ASSERT_EQ( d5.extent(4) , dr5.extent(4) );
-    ASSERT_EQ( d5.extent(5) , dr5.extent(5) );
-    ASSERT_EQ( d5.rank() , dr5.rank() );
-
-// Rank 5 subview of rank 5 dynamic rank view, layout stride input
-    sdView ds5 = Kokkos::subdynrankview( d5 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::pair<unsigned,unsigned>(0,1) );
-    ASSERT_EQ( ds5.rank() , 5 );
-
-// Pass in extra ALL arguments beyond the rank of the DynRank View.
-// This behavior is allowed - ignore the extra ALL arguments when
-//  the src.rank() < number of arguments, but be careful!
-    sdView ds5plus = Kokkos::subdynrankview( d5 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::pair<unsigned,unsigned>(0,1) , Kokkos::ALL() );
-
-    ASSERT_EQ( ds5.rank() , ds5plus.rank() );
-    ASSERT_EQ( ds5.extent(0) , ds5plus.extent(0) );
-    ASSERT_EQ( ds5.extent(4) , ds5plus.extent(4) );
-    ASSERT_EQ( ds5.extent(5) , ds5plus.extent(5) );
-
-#if ! defined( KOKKOS_ENABLE_CUDA ) || defined ( KOKKOS_ENABLE_CUDA_UVM )
-    ASSERT_EQ( & ds5(1,1,1,1,0) - & ds5plus(1,1,1,1,0) , 0 );
-    ASSERT_EQ( & ds5(1,1,1,1,0,0) - & ds5plus(1,1,1,1,0,0) , 0 );  // passing argument to rank beyond the view's rank is allowed iff it is a 0. 
+    ASSERT_EQ(d5.rank(), 5);
+
+    //  LayoutStride arranged as LayoutRight - commented out as example that
+    //  fails unit test
+    //    unsigned order5[] = { 4,3,2,1,0 }, dimen5[] = { N0, N1, N2, 2, 2 };
+    //    sdView d5( "d5" , Kokkos::LayoutStride::order_dimensions(5, order5,
+    //    dimen5) );
+    //
+    //  Fails the following unit test:
+    //    ASSERT_EQ( d5.rank() , dr5.rank() );
+    //
+    //  Explanation: In construction of the Kokkos::LayoutStride below, since
+    //  the
+    //   remaining dimensions are not specified, they will default to values of
+    //   0 rather thanKOKKOS_INVALID_INDEX.
+    //  When passed to the DynRankView constructor the default dimensions (of 0)
+    //   will be counted toward the dynamic rank and returning an incorrect
+    //   value (i.e. rank 7 rather than 5).
+
+    // Check LayoutRight dr5 and LayoutStride d5 dimensions agree (as they
+    // should)
+    ASSERT_EQ(d5.extent(0), dr5.extent(0));
+    ASSERT_EQ(d5.extent(1), dr5.extent(1));
+    ASSERT_EQ(d5.extent(2), dr5.extent(2));
+    ASSERT_EQ(d5.extent(3), dr5.extent(3));
+    ASSERT_EQ(d5.extent(4), dr5.extent(4));
+    ASSERT_EQ(d5.extent(5), dr5.extent(5));
+    ASSERT_EQ(d5.rank(), dr5.rank());
+
+    // Rank 5 subview of rank 5 dynamic rank view, layout stride input
+    sdView ds5 = Kokkos::subdynrankview(d5, Kokkos::ALL(), Kokkos::ALL(),
+                                        Kokkos::ALL(), Kokkos::ALL(),
+                                        Kokkos::pair<unsigned, unsigned>(0, 1));
+    ASSERT_EQ(ds5.rank(), 5);
+
+    // Pass in extra ALL arguments beyond the rank of the DynRank View.
+    // This behavior is allowed - ignore the extra ALL arguments when
+    //  the src.rank() < number of arguments, but be careful!
+    sdView ds5plus = Kokkos::subdynrankview(
+        d5, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+        Kokkos::pair<unsigned, unsigned>(0, 1), Kokkos::ALL());
+
+    ASSERT_EQ(ds5.rank(), ds5plus.rank());
+    ASSERT_EQ(ds5.extent(0), ds5plus.extent(0));
+    ASSERT_EQ(ds5.extent(4), ds5plus.extent(4));
+    ASSERT_EQ(ds5.extent(5), ds5plus.extent(5));
+
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_CUDA_UVM)
+    ASSERT_EQ(&ds5(1, 1, 1, 1, 0) - &ds5plus(1, 1, 1, 1, 0), 0);
+    ASSERT_EQ(&ds5(1, 1, 1, 1, 0, 0) - &ds5plus(1, 1, 1, 1, 0, 0),
+              0);  // passing argument to rank beyond the view's rank is allowed
+                   // iff it is a 0.
 #endif
 
-// Similar test to rank 5 above, but create rank 4 subview
-// Check that the rank contracts (ds4 and ds4plus) and that subdynrankview can accept extra args (ds4plus)
-    sdView ds4 = Kokkos::subdynrankview( d5 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , 0 );
-    sdView ds4plus = Kokkos::subdynrankview( d5 , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , Kokkos::ALL() , 0 , Kokkos::ALL() );
-
-    ASSERT_EQ( ds4.rank() , ds4plus.rank() );
-    ASSERT_EQ( ds4.rank() , 4 );
-    ASSERT_EQ( ds4.extent(0) , ds4plus.extent(0) );
-    ASSERT_EQ( ds4.extent(4) , ds4plus.extent(4) );
-    ASSERT_EQ( ds4.extent(5) , ds4plus.extent(5) );
+    // Similar test to rank 5 above, but create rank 4 subview
+    // Check that the rank contracts (ds4 and ds4plus) and that subdynrankview
+    // can accept extra args (ds4plus)
+    sdView ds4 = Kokkos::subdynrankview(d5, Kokkos::ALL(), Kokkos::ALL(),
+                                        Kokkos::ALL(), Kokkos::ALL(), 0);
+    sdView ds4plus =
+        Kokkos::subdynrankview(d5, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                               Kokkos::ALL(), 0, Kokkos::ALL());
+
+    ASSERT_EQ(ds4.rank(), ds4plus.rank());
+    ASSERT_EQ(ds4.rank(), 4);
+    ASSERT_EQ(ds4.extent(0), ds4plus.extent(0));
+    ASSERT_EQ(ds4.extent(4), ds4plus.extent(4));
+    ASSERT_EQ(ds4.extent(5), ds4plus.extent(5));
   }
 
-  static void run_test_subview_strided()
-  {
-    typedef Kokkos::DynRankView < int , Kokkos::LayoutLeft , host_drv_space > drview_left ;
-    typedef Kokkos::DynRankView < int , Kokkos::LayoutRight , host_drv_space > drview_right ;
-    typedef Kokkos::DynRankView < int , Kokkos::LayoutStride , host_drv_space > drview_stride ;
-
-    drview_left  xl2( "xl2", 100 , 200 );
-    drview_right xr2( "xr2", 100 , 200 );
-    drview_stride yl1 = Kokkos::subdynrankview( xl2 , 0 , Kokkos::ALL() );
-    drview_stride yl2 = Kokkos::subdynrankview( xl2 , 1 , Kokkos::ALL() );
-    drview_stride ys1 = Kokkos::subdynrankview( xr2 , 0 , Kokkos::ALL() );
-    drview_stride ys2 = Kokkos::subdynrankview( xr2 , 1 , Kokkos::ALL() );
-    drview_stride yr1 = Kokkos::subdynrankview( xr2 , 0 , Kokkos::ALL() );
-    drview_stride yr2 = Kokkos::subdynrankview( xr2 , 1 , Kokkos::ALL() );
-
-    ASSERT_EQ( yl1.extent(0) , xl2.extent(1) );
-    ASSERT_EQ( yl2.extent(0) , xl2.extent(1) );
-
-    ASSERT_EQ( yr1.extent(0) , xr2.extent(1) );
-    ASSERT_EQ( yr2.extent(0) , xr2.extent(1) );
-
-    ASSERT_EQ( & yl1(0) - & xl2(0,0) , 0 );
-    ASSERT_EQ( & yl2(0) - & xl2(1,0) , 0 );
-    ASSERT_EQ( & yr1(0) - & xr2(0,0) , 0 );
-    ASSERT_EQ( & yr2(0) - & xr2(1,0) , 0 );
-
-
-    drview_left  xl4( "xl4", 10 , 20 , 30 , 40 );
-    drview_right xr4( "xr4", 10 , 20 , 30 , 40 );
-
-    //Replace subdynrankview with subview - test
-    drview_stride yl4 = Kokkos::subview( xl4 , 1 , Kokkos::ALL() , 2 , Kokkos::ALL() );
-    drview_stride yr4 = Kokkos::subview( xr4 , 1 , Kokkos::ALL() , 2 , Kokkos::ALL() );
-
-    ASSERT_EQ( yl4.extent(0) , xl4.extent(1) );
-    ASSERT_EQ( yl4.extent(1) , xl4.extent(3) );
-    ASSERT_EQ( yr4.extent(0) , xr4.extent(1) );
-    ASSERT_EQ( yr4.extent(1) , xr4.extent(3) );
-    ASSERT_EQ( yl4.rank() , 2);
-    ASSERT_EQ( yr4.rank() , 2);
-
-    ASSERT_EQ( & yl4(4,4) - & xl4(1,4,2,4) , 0 );
-    ASSERT_EQ( & yr4(4,4) - & xr4(1,4,2,4) , 0 );
+  static void run_test_subview_strided() {
+    typedef Kokkos::DynRankView<int, Kokkos::LayoutLeft, host_drv_space>
+        drview_left;
+    typedef Kokkos::DynRankView<int, Kokkos::LayoutRight, host_drv_space>
+        drview_right;
+    typedef Kokkos::DynRankView<int, Kokkos::LayoutStride, host_drv_space>
+        drview_stride;
+
+    drview_left xl2("xl2", 100, 200);
+    drview_right xr2("xr2", 100, 200);
+    drview_stride yl1 = Kokkos::subdynrankview(xl2, 0, Kokkos::ALL());
+    drview_stride yl2 = Kokkos::subdynrankview(xl2, 1, Kokkos::ALL());
+    drview_stride ys1 = Kokkos::subdynrankview(xr2, 0, Kokkos::ALL());
+    drview_stride ys2 = Kokkos::subdynrankview(xr2, 1, Kokkos::ALL());
+    drview_stride yr1 = Kokkos::subdynrankview(xr2, 0, Kokkos::ALL());
+    drview_stride yr2 = Kokkos::subdynrankview(xr2, 1, Kokkos::ALL());
+
+    ASSERT_EQ(yl1.extent(0), xl2.extent(1));
+    ASSERT_EQ(yl2.extent(0), xl2.extent(1));
+
+    ASSERT_EQ(yr1.extent(0), xr2.extent(1));
+    ASSERT_EQ(yr2.extent(0), xr2.extent(1));
+
+    ASSERT_EQ(&yl1(0) - &xl2(0, 0), 0);
+    ASSERT_EQ(&yl2(0) - &xl2(1, 0), 0);
+    ASSERT_EQ(&yr1(0) - &xr2(0, 0), 0);
+    ASSERT_EQ(&yr2(0) - &xr2(1, 0), 0);
+
+    drview_left xl4("xl4", 10, 20, 30, 40);
+    drview_right xr4("xr4", 10, 20, 30, 40);
+
+    // Replace subdynrankview with subview - test
+    drview_stride yl4 =
+        Kokkos::subview(xl4, 1, Kokkos::ALL(), 2, Kokkos::ALL());
+    drview_stride yr4 =
+        Kokkos::subview(xr4, 1, Kokkos::ALL(), 2, Kokkos::ALL());
+
+    ASSERT_EQ(yl4.extent(0), xl4.extent(1));
+    ASSERT_EQ(yl4.extent(1), xl4.extent(3));
+    ASSERT_EQ(yr4.extent(0), xr4.extent(1));
+    ASSERT_EQ(yr4.extent(1), xr4.extent(3));
+    ASSERT_EQ(yl4.rank(), 2);
+    ASSERT_EQ(yr4.rank(), 2);
+
+    ASSERT_EQ(&yl4(4, 4) - &xl4(1, 4, 2, 4), 0);
+    ASSERT_EQ(&yr4(4, 4) - &xr4(1, 4, 2, 4), 0);
   }
 
-  static void run_test_vector()
-  {
-    static const unsigned Length = 1000 , Count = 8 ;
-
-    typedef typename Kokkos::DynRankView< T , Kokkos::LayoutLeft , host_drv_space > multivector_type ; 
-
-    typedef typename Kokkos::DynRankView< T , Kokkos::LayoutRight , host_drv_space > multivector_right_type ;
-
-    multivector_type mv = multivector_type( "mv" , Length , Count );
-    multivector_right_type mv_right = multivector_right_type( "mv" , Length , Count );
-
-    typedef typename Kokkos::DynRankView< T , Kokkos::LayoutStride , host_drv_space > svector_type ;
-    typedef typename Kokkos::DynRankView< T , Kokkos::LayoutStride , host_drv_space > smultivector_type ;
-    typedef typename Kokkos::DynRankView< const T , Kokkos::LayoutStride , host_drv_space > const_svector_right_type ; 
-    typedef typename Kokkos::DynRankView< const T , Kokkos::LayoutStride , host_drv_space > const_svector_type ;
-    typedef typename Kokkos::DynRankView< const T , Kokkos::LayoutStride , host_drv_space > const_smultivector_type ;
-
-    svector_type v1 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 0 );
-    svector_type v2 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 1 );
-    svector_type v3 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 2 );
-
-    svector_type rv1 = Kokkos::subdynrankview( mv_right , 0 , Kokkos::ALL() );
-    svector_type rv2 = Kokkos::subdynrankview( mv_right , 1 , Kokkos::ALL() );
-    svector_type rv3 = Kokkos::subdynrankview( mv_right , 2 , Kokkos::ALL() );
-
-    smultivector_type mv1 = Kokkos::subdynrankview( mv , std::make_pair( 1 , 998 ) ,
-                                                 std::make_pair( 2 , 5 ) );
-
-    smultivector_type mvr1 =
-      Kokkos::subdynrankview( mv_right ,
-                       std::make_pair( 1 , 998 ) ,
-                       std::make_pair( 2 , 5 ) );
-
-    const_svector_type cv1 = Kokkos::subdynrankview( mv , Kokkos::ALL(), 0 );
-    const_svector_type cv2 = Kokkos::subdynrankview( mv , Kokkos::ALL(), 1 );
-    const_svector_type cv3 = Kokkos::subdynrankview( mv , Kokkos::ALL(), 2 );
-
-    svector_type vr1 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 0 );
-    svector_type vr2 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 1 );
-    svector_type vr3 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 2 );
-
-    const_svector_right_type cvr1 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 0 );
-    const_svector_right_type cvr2 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 1 );
-    const_svector_right_type cvr3 = Kokkos::subdynrankview( mv , Kokkos::ALL() , 2 );
-
-
-    ASSERT_TRUE( & v1[0] == & v1(0) );
-    ASSERT_TRUE( & v1[0] == & mv(0,0) );
-    ASSERT_TRUE( & v2[0] == & mv(0,1) );
-    ASSERT_TRUE( & v3[0] == & mv(0,2) );
-
-    ASSERT_TRUE( & cv1[0] == & mv(0,0) );
-    ASSERT_TRUE( & cv2[0] == & mv(0,1) );
-    ASSERT_TRUE( & cv3[0] == & mv(0,2) );
-
-    ASSERT_TRUE( & vr1[0] == & mv(0,0) );
-    ASSERT_TRUE( & vr2[0] == & mv(0,1) );
-    ASSERT_TRUE( & vr3[0] == & mv(0,2) );
-
-    ASSERT_TRUE( & cvr1[0] == & mv(0,0) );
-    ASSERT_TRUE( & cvr2[0] == & mv(0,1) );
-    ASSERT_TRUE( & cvr3[0] == & mv(0,2) );
-
-
-    ASSERT_TRUE( & mv1(0,0) == & mv( 1 , 2 ) );
-    ASSERT_TRUE( & mv1(1,1) == & mv( 2 , 3 ) );
-    ASSERT_TRUE( & mv1(3,2) == & mv( 4 , 4 ) );
-    ASSERT_TRUE( & mvr1(0,0) == & mv_right( 1 , 2 ) );
-    ASSERT_TRUE( & mvr1(1,1) == & mv_right( 2 , 3 ) );
-    ASSERT_TRUE( & mvr1(3,2) == & mv_right( 4 , 4 ) );
-
-    const_svector_type c_cv1( v1 );
-    typename svector_type::const_type c_cv2( v2 );
-    typename const_svector_type::const_type c_ccv2( v2 );
-
-
-    const_smultivector_type cmv( mv );
-    typename smultivector_type::const_type cmvX( cmv );
-    typename const_smultivector_type::const_type ccmvX( cmv );
+  static void run_test_vector() {
+    static const unsigned Length = 1000, Count = 8;
+
+    typedef typename Kokkos::DynRankView<T, Kokkos::LayoutLeft, host_drv_space>
+        multivector_type;
+
+    typedef typename Kokkos::DynRankView<T, Kokkos::LayoutRight, host_drv_space>
+        multivector_right_type;
+
+    multivector_type mv = multivector_type("mv", Length, Count);
+    multivector_right_type mv_right =
+        multivector_right_type("mv", Length, Count);
+
+    typedef
+        typename Kokkos::DynRankView<T, Kokkos::LayoutStride, host_drv_space>
+            svector_type;
+    typedef
+        typename Kokkos::DynRankView<T, Kokkos::LayoutStride, host_drv_space>
+            smultivector_type;
+    typedef typename Kokkos::DynRankView<const T, Kokkos::LayoutStride,
+                                         host_drv_space>
+        const_svector_right_type;
+    typedef typename Kokkos::DynRankView<const T, Kokkos::LayoutStride,
+                                         host_drv_space>
+        const_svector_type;
+    typedef typename Kokkos::DynRankView<const T, Kokkos::LayoutStride,
+                                         host_drv_space>
+        const_smultivector_type;
+
+    svector_type v1 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 0);
+    svector_type v2 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 1);
+    svector_type v3 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 2);
+
+    svector_type rv1 = Kokkos::subdynrankview(mv_right, 0, Kokkos::ALL());
+    svector_type rv2 = Kokkos::subdynrankview(mv_right, 1, Kokkos::ALL());
+    svector_type rv3 = Kokkos::subdynrankview(mv_right, 2, Kokkos::ALL());
+
+    smultivector_type mv1 = Kokkos::subdynrankview(mv, std::make_pair(1, 998),
+                                                   std::make_pair(2, 5));
+
+    smultivector_type mvr1 = Kokkos::subdynrankview(
+        mv_right, std::make_pair(1, 998), std::make_pair(2, 5));
+
+    const_svector_type cv1 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 0);
+    const_svector_type cv2 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 1);
+    const_svector_type cv3 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 2);
+
+    svector_type vr1 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 0);
+    svector_type vr2 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 1);
+    svector_type vr3 = Kokkos::subdynrankview(mv, Kokkos::ALL(), 2);
+
+    const_svector_right_type cvr1 =
+        Kokkos::subdynrankview(mv, Kokkos::ALL(), 0);
+    const_svector_right_type cvr2 =
+        Kokkos::subdynrankview(mv, Kokkos::ALL(), 1);
+    const_svector_right_type cvr3 =
+        Kokkos::subdynrankview(mv, Kokkos::ALL(), 2);
+
+    ASSERT_TRUE(&v1[0] == &v1(0));
+    ASSERT_TRUE(&v1[0] == &mv(0, 0));
+    ASSERT_TRUE(&v2[0] == &mv(0, 1));
+    ASSERT_TRUE(&v3[0] == &mv(0, 2));
+
+    ASSERT_TRUE(&cv1[0] == &mv(0, 0));
+    ASSERT_TRUE(&cv2[0] == &mv(0, 1));
+    ASSERT_TRUE(&cv3[0] == &mv(0, 2));
+
+    ASSERT_TRUE(&vr1[0] == &mv(0, 0));
+    ASSERT_TRUE(&vr2[0] == &mv(0, 1));
+    ASSERT_TRUE(&vr3[0] == &mv(0, 2));
+
+    ASSERT_TRUE(&cvr1[0] == &mv(0, 0));
+    ASSERT_TRUE(&cvr2[0] == &mv(0, 1));
+    ASSERT_TRUE(&cvr3[0] == &mv(0, 2));
+
+    ASSERT_TRUE(&mv1(0, 0) == &mv(1, 2));
+    ASSERT_TRUE(&mv1(1, 1) == &mv(2, 3));
+    ASSERT_TRUE(&mv1(3, 2) == &mv(4, 4));
+    ASSERT_TRUE(&mvr1(0, 0) == &mv_right(1, 2));
+    ASSERT_TRUE(&mvr1(1, 1) == &mv_right(2, 3));
+    ASSERT_TRUE(&mvr1(3, 2) == &mv_right(4, 4));
+
+    const_svector_type c_cv1(v1);
+    typename svector_type::const_type c_cv2(v2);
+    typename const_svector_type::const_type c_ccv2(v2);
+
+    const_smultivector_type cmv(mv);
+    typename smultivector_type::const_type cmvX(cmv);
+    typename const_smultivector_type::const_type ccmvX(cmv);
   }
 };
 
-} // namespace Test
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
-
diff --git a/lib/kokkos/containers/unit_tests/TestDynViewAPI_generic.hpp b/lib/kokkos/containers/unit_tests/TestDynViewAPI_generic.hpp
index 2909e8cc76e419e006041f361938d38cabea8051..90ca5df194d5c33f53446125470ab7f464085095 100644
--- a/lib/kokkos/containers/unit_tests/TestDynViewAPI_generic.hpp
+++ b/lib/kokkos/containers/unit_tests/TestDynViewAPI_generic.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,9 @@
 //@HEADER
 */
 
-#include<TestDynViewAPI.hpp>
+#include <TestDynViewAPI.hpp>
 namespace Test {
-TEST_F( TEST_CATEGORY , dyn_rank_view_api_generic) {
-  TestDynViewAPI< double , TEST_EXECSPACE >::run_tests();
+TEST(TEST_CATEGORY, dyn_rank_view_api_generic) {
+  TestDynViewAPI<double, TEST_EXECSPACE>::run_tests();
 }
-}
-
+}  // namespace Test
diff --git a/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank12345.hpp b/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank12345.hpp
index 5b2c22440d0f748c596cffe7e3eed2ebd3b8d271..050ebbe35cab5e85b726b7ad5f9a10f3170607bb 100644
--- a/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank12345.hpp
+++ b/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank12345.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,11 +42,10 @@
 //@HEADER
 */
 
-#include<TestDynViewAPI.hpp>
+#include <TestDynViewAPI.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , dyn_rank_view_api_operator_rank12345) {
-  TestDynViewAPI< double , TEST_EXECSPACE >::run_operator_test_rank12345();
+TEST(TEST_CATEGORY, dyn_rank_view_api_operator_rank12345) {
+  TestDynViewAPI<double, TEST_EXECSPACE>::run_operator_test_rank12345();
 }
-}
-
+}  // namespace Test
diff --git a/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank67.hpp b/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank67.hpp
index 45a49fb8198422843c30181654c26c67358c251e..eb8df60a89d204fee4e454956304e48026a7c120 100644
--- a/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank67.hpp
+++ b/lib/kokkos/containers/unit_tests/TestDynViewAPI_rank67.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,9 @@
 //@HEADER
 */
 
-#include<TestDynViewAPI.hpp>
+#include <TestDynViewAPI.hpp>
 namespace Test {
-TEST_F( TEST_CATEGORY , dyn_rank_view_api_operator_rank67) {
-  TestDynViewAPI< double , TEST_EXECSPACE >::run_operator_test_rank67();
+TEST(TEST_CATEGORY, dyn_rank_view_api_operator_rank67) {
+  TestDynViewAPI<double, TEST_EXECSPACE>::run_operator_test_rank67();
 }
-}
-
+}  // namespace Test
diff --git a/lib/kokkos/containers/unit_tests/TestDynamicView.hpp b/lib/kokkos/containers/unit_tests/TestDynamicView.hpp
index 9e87fdf5ccaa4afc58eca7fbaca29a3c39e3c2ed..235464ef07e0648088153fb94b0613d4fdab376a 100644
--- a/lib/kokkos/containers/unit_tests/TestDynamicView.hpp
+++ b/lib/kokkos/containers/unit_tests/TestDynamicView.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -55,45 +56,43 @@
 
 namespace Test {
 
-template< typename Scalar , class Space >
-struct TestDynamicView
-{
-  typedef typename Space::execution_space  execution_space ;
-  typedef typename Space::memory_space     memory_space ;
+template <typename Scalar, class Space>
+struct TestDynamicView {
+  typedef typename Space::execution_space execution_space;
+  typedef typename Space::memory_space memory_space;
 
-  typedef Kokkos::Experimental::DynamicView<Scalar*,Space> view_type;
+  typedef Kokkos::Experimental::DynamicView<Scalar*, Space> view_type;
 
   typedef double value_type;
 
-  static void run( unsigned arg_total_size )
-  {
-    // Test: Create DynamicView, initialize size (via resize), run through parallel_for to set values, check values (via parallel_reduce); resize values and repeat
+  static void run(unsigned arg_total_size) {
+    // Test: Create DynamicView, initialize size (via resize), run through
+    // parallel_for to set values, check values (via parallel_reduce); resize
+    // values and repeat
     //   Case 1: min_chunk_size is a power of 2
     {
-      view_type da("da", 1024, arg_total_size );
-      ASSERT_EQ( da.size(), 0 );
+      view_type da("da", 1024, arg_total_size);
+      ASSERT_EQ(da.size(), 0);
       // Init
       unsigned da_size = arg_total_size / 8;
       da.resize_serial(da_size);
-      ASSERT_EQ( da.size(), da_size );
+      ASSERT_EQ(da.size(), da_size);
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-      Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i )
-          {
-          da(i) = Scalar(i);
-          }
-          );
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<execution_space>(0, da_size),
+          KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
 
       value_type result_sum = 0.0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
-          {
-          partial_sum += (value_type)da(i);
-          }
-          , result_sum
-          );
-
-      ASSERT_EQ(result_sum, (value_type)( da_size * (da_size - 1) / 2 ) );
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<execution_space>(0, da_size),
+          KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
+            partial_sum += (value_type)da(i);
+          },
+          result_sum);
+
+      ASSERT_EQ(result_sum, (value_type)(da_size * (da_size - 1) / 2));
 #endif
 #endif
 
@@ -101,56 +100,55 @@ struct TestDynamicView
       // the first 1/4 should remain the same
       unsigned da_resize = arg_total_size / 2;
       da.resize_serial(da_resize);
-      ASSERT_EQ( da.size(), da_resize );
+      ASSERT_EQ(da.size(), da_resize);
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-      Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i )
-          {
-          da(i) = Scalar(i);
-          }
-          );
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<execution_space>(da_size, da_resize),
+          KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
 
       value_type new_result_sum = 0.0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
-          {
-          partial_sum += (value_type)da(i);
-          }
-          , new_result_sum
-          );
-
-      ASSERT_EQ(new_result_sum+result_sum, (value_type)( da_resize * (da_resize - 1) / 2 ) );
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<execution_space>(da_size, da_resize),
+          KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
+            partial_sum += (value_type)da(i);
+          },
+          new_result_sum);
+
+      ASSERT_EQ(new_result_sum + result_sum,
+                (value_type)(da_resize * (da_resize - 1) / 2));
 #endif
 #endif
-    } // end scope
+    }  // end scope
 
-    // Test: Create DynamicView, initialize size (via resize), run through parallel_for to set values, check values (via parallel_reduce); resize values and repeat
+    // Test: Create DynamicView, initialize size (via resize), run through
+    // parallel_for to set values, check values (via parallel_reduce); resize
+    // values and repeat
     //   Case 2: min_chunk_size is NOT a power of 2
     {
-      view_type da("da", 1023, arg_total_size );
-      ASSERT_EQ( da.size(), 0 );
+      view_type da("da", 1023, arg_total_size);
+      ASSERT_EQ(da.size(), 0);
       // Init
       unsigned da_size = arg_total_size / 8;
       da.resize_serial(da_size);
-      ASSERT_EQ( da.size(), da_size );
+      ASSERT_EQ(da.size(), da_size);
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-      Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i )
-          {
-          da(i) = Scalar(i);
-          }
-          );
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<execution_space>(0, da_size),
+          KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
 
       value_type result_sum = 0.0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
-          {
-          partial_sum += (value_type)da(i);
-          }
-          , result_sum
-          );
-
-      ASSERT_EQ(result_sum, (value_type)( da_size * (da_size - 1) / 2 ) );
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<execution_space>(0, da_size),
+          KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
+            partial_sum += (value_type)da(i);
+          },
+          result_sum);
+
+      ASSERT_EQ(result_sum, (value_type)(da_size * (da_size - 1) / 2));
 #endif
 #endif
 
@@ -158,99 +156,92 @@ struct TestDynamicView
       // the first 1/4 should remain the same
       unsigned da_resize = arg_total_size / 2;
       da.resize_serial(da_resize);
-      ASSERT_EQ( da.size(), da_resize );
+      ASSERT_EQ(da.size(), da_resize);
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-      Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i )
-          {
-          da(i) = Scalar(i);
-          }
-          );
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<execution_space>(da_size, da_resize),
+          KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
 
       value_type new_result_sum = 0.0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(da_size, da_resize), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
-          {
-          partial_sum += (value_type)da(i);
-          }
-          , new_result_sum
-          );
-
-      ASSERT_EQ(new_result_sum+result_sum, (value_type)( da_resize * (da_resize - 1) / 2 ) );
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<execution_space>(da_size, da_resize),
+          KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
+            partial_sum += (value_type)da(i);
+          },
+          new_result_sum);
+
+      ASSERT_EQ(new_result_sum + result_sum,
+                (value_type)(da_resize * (da_resize - 1) / 2));
 #endif
 #endif
-    } // end scope
+    }  // end scope
 
-    // Test: Create DynamicView, initialize size (via resize), run through parallel_for to set values, check values (via parallel_reduce); resize values and repeat
+    // Test: Create DynamicView, initialize size (via resize), run through
+    // parallel_for to set values, check values (via parallel_reduce); resize
+    // values and repeat
     //   Case 3: resize reduces the size
     {
-      view_type da("da", 1023, arg_total_size );
-      ASSERT_EQ( da.size(), 0 );
+      view_type da("da", 1023, arg_total_size);
+      ASSERT_EQ(da.size(), 0);
       // Init
       unsigned da_size = arg_total_size / 2;
       da.resize_serial(da_size);
-      ASSERT_EQ( da.size(), da_size );
+      ASSERT_EQ(da.size(), da_size);
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-      Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i )
-          {
-          da(i) = Scalar(i);
-          }
-          );
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<execution_space>(0, da_size),
+          KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
 
       value_type result_sum = 0.0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_size), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
-          {
-          partial_sum += (value_type)da(i);
-          }
-          , result_sum
-          );
-
-      ASSERT_EQ(result_sum, (value_type)( da_size * (da_size - 1) / 2 ) );
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<execution_space>(0, da_size),
+          KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
+            partial_sum += (value_type)da(i);
+          },
+          result_sum);
+
+      ASSERT_EQ(result_sum, (value_type)(da_size * (da_size - 1) / 2));
 #endif
 #endif
 
       // remove the final 3/4 entries i.e. first 1/4 remain
       unsigned da_resize = arg_total_size / 8;
       da.resize_serial(da_resize);
-      ASSERT_EQ( da.size(), da_resize );
+      ASSERT_EQ(da.size(), da_resize);
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-      Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>(0, da_resize), KOKKOS_LAMBDA ( const int i )
-          {
-          da(i) = Scalar(i);
-          }
-          );
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<execution_space>(0, da_resize),
+          KOKKOS_LAMBDA(const int i) { da(i) = Scalar(i); });
 
       value_type new_result_sum = 0.0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space>(0, da_resize), KOKKOS_LAMBDA ( const int i, value_type& partial_sum )
-          {
-          partial_sum += (value_type)da(i);
-          }
-          , new_result_sum
-          );
-
-      ASSERT_EQ(new_result_sum, (value_type)( da_resize * (da_resize - 1) / 2 ) );
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<execution_space>(0, da_resize),
+          KOKKOS_LAMBDA(const int i, value_type& partial_sum) {
+            partial_sum += (value_type)da(i);
+          },
+          new_result_sum);
+
+      ASSERT_EQ(new_result_sum, (value_type)(da_resize * (da_resize - 1) / 2));
 #endif
 #endif
-    } // end scope
-
+    }  // end scope
   }
 };
 
-TEST_F( TEST_CATEGORY , dynamic_view )
-{
-  typedef TestDynamicView< double , TEST_EXECSPACE >
-    TestDynView ;
+TEST(TEST_CATEGORY, dynamic_view) {
+  typedef TestDynamicView<double, TEST_EXECSPACE> TestDynView;
 
-  for ( int i = 0 ; i < 10 ; ++i ) {
-    TestDynView::run( 100000 + 100 * i );
+  for (int i = 0; i < 10; ++i) {
+    TestDynView::run(100000 + 100 * i);
   }
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif /* #ifndef KOKKOS_TEST_DYNAMICVIEW_HPP */
-
diff --git a/lib/kokkos/containers/unit_tests/TestErrorReporter.hpp b/lib/kokkos/containers/unit_tests/TestErrorReporter.hpp
index 7e48089b432f5133ab8961ac2a2ed9b7ddc38317..49b71cdea7a3449b56cffcb1b2cbfc3bc2f2f6e9 100644
--- a/lib/kokkos/containers/unit_tests/TestErrorReporter.hpp
+++ b/lib/kokkos/containers/unit_tests/TestErrorReporter.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,47 +52,47 @@
 
 namespace Test {
 
-// Just save the data in the report.  Informative text goies in the operator<<(..).
+// Just save the data in the report.  Informative text goies in the
+// operator<<(..).
 template <typename DataType1, typename DataType2, typename DataType3>
-struct ThreeValReport
-{
+struct ThreeValReport {
   DataType1 m_data1;
   DataType2 m_data2;
   DataType3 m_data3;
-
 };
 
 template <typename DataType1, typename DataType2, typename DataType3>
-std::ostream &operator<<(std::ostream & os, const ThreeValReport<DataType1, DataType2, DataType3> &val)
-{
-  return os << "{" << val.m_data1 << " " << val.m_data2 << " " << val.m_data3 << "}";
+std::ostream &operator<<(
+    std::ostream &os,
+    const ThreeValReport<DataType1, DataType2, DataType3> &val) {
+  return os << "{" << val.m_data1 << " " << val.m_data2 << " " << val.m_data3
+            << "}";
 }
 
-template<typename ReportType>
+template <typename ReportType>
 void checkReportersAndReportsAgree(const std::vector<int> &reporters,
-                                   const std::vector<ReportType> &reports)
-{
+                                   const std::vector<ReportType> &reports) {
   for (size_t i = 0; i < reports.size(); ++i) {
     EXPECT_EQ(1, reporters[i] % 2);
     EXPECT_EQ(reporters[i], reports[i].m_data1);
   }
 }
 
-
 template <typename DeviceType>
 struct ErrorReporterDriverBase {
-
-  typedef ThreeValReport<int, int, double>                                      report_type;
-  typedef Kokkos::Experimental::ErrorReporter<report_type, DeviceType>  error_reporter_type;
+  typedef ThreeValReport<int, int, double> report_type;
+  typedef Kokkos::Experimental::ErrorReporter<report_type, DeviceType>
+      error_reporter_type;
   error_reporter_type m_errorReporter;
 
   ErrorReporterDriverBase(int reporter_capacity, int test_size)
-    : m_errorReporter(reporter_capacity)  {  }
+      : m_errorReporter(reporter_capacity) {}
 
-  KOKKOS_INLINE_FUNCTION bool error_condition(const int work_idx) const { return (work_idx % 2 != 0); }
+  KOKKOS_INLINE_FUNCTION bool error_condition(const int work_idx) const {
+    return (work_idx % 2 != 0);
+  }
 
-  void check_expectations(int reporter_capacity, int test_size)
-  {
+  void check_expectations(int reporter_capacity, int test_size) {
     int num_reported = m_errorReporter.getNumReports();
     int num_attempts = m_errorReporter.getNumReportAttempts();
 
@@ -99,15 +100,14 @@ struct ErrorReporterDriverBase {
     EXPECT_EQ(expected_num_reports, num_reported);
     EXPECT_EQ(test_size / 2, num_attempts);
 
-    bool expect_full = (reporter_capacity <= (test_size / 2));
+    bool expect_full   = (reporter_capacity <= (test_size / 2));
     bool reported_full = m_errorReporter.full();
     EXPECT_EQ(expect_full, reported_full);
   }
 };
 
 template <typename ErrorReporterDriverType>
-void TestErrorReporter()
-{
+void TestErrorReporter() {
   typedef ErrorReporterDriverType tester_type;
   std::vector<int> reporters;
   std::vector<typename tester_type::report_type> reports;
@@ -120,9 +120,12 @@ void TestErrorReporter()
   test2.m_errorReporter.getReports(reporters, reports);
   checkReportersAndReportsAgree(reporters, reports);
 
-  typename Kokkos::View<int*, typename ErrorReporterDriverType::execution_space >::HostMirror view_reporters;
-  typename Kokkos::View<typename tester_type::report_type*, typename ErrorReporterDriverType::execution_space >::HostMirror
-     view_reports;
+  typename Kokkos::View<
+      int *, typename ErrorReporterDriverType::execution_space>::HostMirror
+      view_reporters;
+  typename Kokkos::View<typename tester_type::report_type *,
+                        typename ErrorReporterDriverType::execution_space>::
+      HostMirror view_reports;
   test2.m_errorReporter.getReports(view_reporters, view_reports);
 
   int num_reports = view_reporters.extent(0);
@@ -136,19 +139,16 @@ void TestErrorReporter()
     reports.push_back(view_reports(i));
   }
   checkReportersAndReportsAgree(reporters, reports);
-
 }
 
-
 template <typename DeviceType>
-struct ErrorReporterDriver : public ErrorReporterDriverBase<DeviceType>
-{
-  typedef ErrorReporterDriverBase<DeviceType>                             driver_base;
-  typedef typename driver_base::error_reporter_type::execution_space  execution_space;
+struct ErrorReporterDriver : public ErrorReporterDriverBase<DeviceType> {
+  typedef ErrorReporterDriverBase<DeviceType> driver_base;
+  typedef typename driver_base::error_reporter_type::execution_space
+      execution_space;
 
   ErrorReporterDriver(int reporter_capacity, int test_size)
-    : driver_base(reporter_capacity, test_size)
-  {
+      : driver_base(reporter_capacity, test_size) {
     execute(reporter_capacity, test_size);
 
     // Test that clear() and resize() work across memory spaces.
@@ -159,19 +159,18 @@ struct ErrorReporterDriver : public ErrorReporterDriverBase<DeviceType>
     }
   }
 
-  void execute(int reporter_capacity, int test_size)
-  {
-    Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0,test_size), *this);
+  void execute(int reporter_capacity, int test_size) {
+    Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, test_size),
+                         *this);
     Kokkos::fence();
     driver_base::check_expectations(reporter_capacity, test_size);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(const int work_idx) const
-  {
+  void operator()(const int work_idx) const {
     if (driver_base::error_condition(work_idx)) {
       double val = M_PI * static_cast<double>(work_idx);
-      typename driver_base::report_type report = {work_idx, -2*work_idx, val};
+      typename driver_base::report_type report = {work_idx, -2 * work_idx, val};
       driver_base::m_errorReporter.add_report(work_idx, report);
     }
   }
@@ -179,45 +178,45 @@ struct ErrorReporterDriver : public ErrorReporterDriverBase<DeviceType>
 
 #if defined(KOKKOS_CLASS_LAMBDA)
 template <typename DeviceType>
-struct ErrorReporterDriverUseLambda : public ErrorReporterDriverBase<DeviceType>
-{
-
-  typedef ErrorReporterDriverBase<DeviceType>                             driver_base;
-  typedef typename driver_base::error_reporter_type::execution_space  execution_space;
+struct ErrorReporterDriverUseLambda
+    : public ErrorReporterDriverBase<DeviceType> {
+  typedef ErrorReporterDriverBase<DeviceType> driver_base;
+  typedef typename driver_base::error_reporter_type::execution_space
+      execution_space;
 
   ErrorReporterDriverUseLambda(int reporter_capacity, int test_size)
-    : driver_base(reporter_capacity, test_size)
-  {
-    Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0,test_size), KOKKOS_CLASS_LAMBDA (const int work_idx) {
-      if (driver_base::error_condition(work_idx)) {
-        double val = M_PI * static_cast<double>(work_idx);
-        typename driver_base::report_type report = {work_idx, -2*work_idx, val};
-        driver_base::m_errorReporter.add_report(work_idx, report);
-      }
-    });
+      : driver_base(reporter_capacity, test_size) {
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<execution_space>(0, test_size),
+        KOKKOS_CLASS_LAMBDA(const int work_idx) {
+          if (driver_base::error_condition(work_idx)) {
+            double val = M_PI * static_cast<double>(work_idx);
+            typename driver_base::report_type report = {work_idx, -2 * work_idx,
+                                                        val};
+            driver_base::m_errorReporter.add_report(work_idx, report);
+          }
+        });
     Kokkos::fence();
     driver_base::check_expectations(reporter_capacity, test_size);
   }
-
 };
 #endif
 
-
 #ifdef KOKKOS_ENABLE_OPENMP
-struct ErrorReporterDriverNativeOpenMP : public ErrorReporterDriverBase<Kokkos::OpenMP>
-{
-  typedef ErrorReporterDriverBase<Kokkos::OpenMP>  driver_base;
-  typedef typename driver_base::error_reporter_type::execution_space  execution_space;
+struct ErrorReporterDriverNativeOpenMP
+    : public ErrorReporterDriverBase<Kokkos::OpenMP> {
+  typedef ErrorReporterDriverBase<Kokkos::OpenMP> driver_base;
+  typedef typename driver_base::error_reporter_type::execution_space
+      execution_space;
 
   ErrorReporterDriverNativeOpenMP(int reporter_capacity, int test_size)
-    : driver_base(reporter_capacity, test_size)
-  {
+      : driver_base(reporter_capacity, test_size) {
 #pragma omp parallel for
-    for(int work_idx = 0; work_idx < test_size; ++work_idx)
-    {
+    for (int work_idx = 0; work_idx < test_size; ++work_idx) {
       if (driver_base::error_condition(work_idx)) {
         double val = M_PI * static_cast<double>(work_idx);
-        typename driver_base::report_type report = {work_idx, -2*work_idx, val};
+        typename driver_base::report_type report = {work_idx, -2 * work_idx,
+                                                    val};
         driver_base::m_errorReporter.add_report(work_idx, report);
       }
     };
@@ -227,17 +226,14 @@ struct ErrorReporterDriverNativeOpenMP : public ErrorReporterDriverBase<Kokkos::
 #endif
 
 #if defined(KOKKOS_CLASS_LAMBDA)
-TEST_F(TEST_CATEGORY, ErrorReporterViaLambda)
-{
+TEST(TEST_CATEGORY, ErrorReporterViaLambda) {
   TestErrorReporter<ErrorReporterDriverUseLambda<TEST_EXECSPACE>>();
 }
 #endif
 
-TEST_F(TEST_CATEGORY, ErrorReporter)
-{
+TEST(TEST_CATEGORY, ErrorReporter) {
   TestErrorReporter<ErrorReporterDriver<TEST_EXECSPACE>>();
 }
 
-} // namespace Test
-#endif // #ifndef KOKKOS_TEST_ERROR_REPORTING_HPP
-
+}  // namespace Test
+#endif  // #ifndef KOKKOS_TEST_ERROR_REPORTING_HPP
diff --git a/lib/kokkos/containers/unit_tests/TestOffsetView.hpp b/lib/kokkos/containers/unit_tests/TestOffsetView.hpp
index 6965199d4550aeb31d958a081243631de9893d22..12bcda9524ee7c179b697b41be9450b5018740df 100644
--- a/lib/kokkos/containers/unit_tests/TestOffsetView.hpp
+++ b/lib/kokkos/containers/unit_tests/TestOffsetView.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,8 +46,6 @@
 #ifndef CONTAINERS_UNIT_TESTS_TESTOFFSETVIEW_HPP_
 #define CONTAINERS_UNIT_TESTS_TESTOFFSETVIEW_HPP_
 
-
-
 #include <gtest/gtest.h>
 #include <iostream>
 #include <cstdlib>
@@ -55,372 +54,652 @@
 #include <Kokkos_OffsetView.hpp>
 #include <KokkosExp_MDRangePolicy.hpp>
 
-using std::endl;
 using std::cout;
+using std::endl;
 
-namespace Test{
-
-   template <typename Scalar, typename Device>
-   void test_offsetview_construction(unsigned int size)
-   {
-
-      typedef Kokkos::Experimental::OffsetView<Scalar**, Device> offset_view_type;
-      typedef Kokkos::View<Scalar**, Device> view_type;
+namespace Test {
 
-      Kokkos::Experimental::index_list_type range0 = {-1, 3};
-      Kokkos::Experimental::index_list_type range1 = {-2, 2};
+template <typename Scalar, typename Device>
+void test_offsetview_construction(unsigned int size) {
+  typedef Kokkos::Experimental::OffsetView<Scalar**, Device> offset_view_type;
+  typedef Kokkos::View<Scalar**, Device> view_type;
 
-      offset_view_type ov("firstOV", range0, range1);
+  Kokkos::Experimental::index_list_type range0 = {-1, 3};
+  Kokkos::Experimental::index_list_type range1 = {-2, 2};
 
-      ASSERT_EQ("firstOV", ov.label());
-      ASSERT_EQ(2, ov.Rank);
+  offset_view_type ov("firstOV", range0, range1);
 
-      ASSERT_EQ(ov.begin(0), -1);
-      ASSERT_EQ(ov.end(0), 4);
+  ASSERT_EQ("firstOV", ov.label());
+  ASSERT_EQ(2, ov.Rank);
 
-      ASSERT_EQ(ov.begin(1), -2);
-      ASSERT_EQ(ov.end(1), 3);
+  ASSERT_EQ(ov.begin(0), -1);
+  ASSERT_EQ(ov.end(0), 4);
 
-      ASSERT_EQ(ov.extent(0), 5);
-      ASSERT_EQ(ov.extent(1), 5);
+  ASSERT_EQ(ov.begin(1), -2);
+  ASSERT_EQ(ov.end(1), 3);
 
-      const int ovmin0 = ov.begin(0);
-      const int ovend0 = ov.end(0);
-      const int ovmin1 = ov.begin(1);
-      const int ovend1 = ov.end(1);
+  ASSERT_EQ(ov.extent(0), 5);
+  ASSERT_EQ(ov.extent(1), 5);
 
 #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-      {
-         Kokkos::Experimental::OffsetView<Scalar*, Device> offsetV1("OneDOffsetView", range0);
-
-         Kokkos::RangePolicy<Device, int> rangePolicy1(offsetV1.begin(0), offsetV1.end(0));
-         Kokkos::parallel_for(rangePolicy1, KOKKOS_LAMBDA (const int i){
-            offsetV1(i) = 1;
-         }
-         );
-	 Kokkos::fence();
-
-         int OVResult = 0;
-         Kokkos::parallel_reduce(rangePolicy1, KOKKOS_LAMBDA(const int i, int & updateMe){
-            updateMe += offsetV1(i);
-         }, OVResult);
-	 
-	 Kokkos::fence();
-         ASSERT_EQ(OVResult, offsetV1.end(0) - offsetV1.begin(0)) << "found wrong number of elements in OffsetView that was summed.";
-
-      }
-      {  //test deep copy of scalar const value into mirro
-         const int constVal = 6;
-         typename offset_view_type::HostMirror hostOffsetView =
-               Kokkos::Experimental::create_mirror_view(ov);
-
-         Kokkos::Experimental::deep_copy(hostOffsetView, constVal);
-
-         for(int i = hostOffsetView.begin(0); i < hostOffsetView.end(0); ++i) {
-            for(int j = hostOffsetView.begin(1); j < hostOffsetView.end(1); ++j) {
-               ASSERT_EQ(hostOffsetView(i,j),  constVal) << "Bad data found in OffsetView";
-            }
-         }
-      }
-
-      typedef Kokkos::MDRangePolicy<Device, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
-      typedef typename range_type::point_type point_type;
-
-      range_type rangePolicy2D(point_type{ {ovmin0, ovmin1 } },
-            point_type{ { ovend0, ovend1 } });
-
-      const int constValue = 9;
-      Kokkos::parallel_for(rangePolicy2D, KOKKOS_LAMBDA (const int i, const int j) {
-         ov(i,j) =  constValue;
-      }
-      );
-      
-      //test offsetview to offsetviewmirror deep copy
-      typename offset_view_type::HostMirror hostOffsetView =
-            Kokkos::Experimental::create_mirror_view(ov);
-
-      Kokkos::Experimental::deep_copy(hostOffsetView, ov);
-
-      for(int i = hostOffsetView.begin(0); i < hostOffsetView.end(0); ++i) {
-         for(int j = hostOffsetView.begin(1); j < hostOffsetView.end(1); ++j) {
-            ASSERT_EQ(hostOffsetView(i,j),  constValue) << "Bad data found in OffsetView";
-         }
-      }
-      
-     int OVResult = 0;
-      Kokkos::parallel_reduce(rangePolicy2D, KOKKOS_LAMBDA(const int i, const int j, int & updateMe){
-         updateMe += ov(i, j);
-      }, OVResult);
-
-      int answer = 0;
-      for(int i = ov.begin(0); i < ov.end(0); ++i) {
-         for(int j = ov.begin(1); j < ov.end(1); ++j) {
-            answer += constValue;
-         }
+  const int ovmin0 = ov.begin(0);
+  const int ovend0 = ov.end(0);
+  const int ovmin1 = ov.begin(1);
+  const int ovend1 = ov.end(1);
+  {
+    Kokkos::Experimental::OffsetView<Scalar*, Device> offsetV1("OneDOffsetView",
+                                                               range0);
+
+    Kokkos::RangePolicy<Device, int> rangePolicy1(offsetV1.begin(0),
+                                                  offsetV1.end(0));
+    Kokkos::parallel_for(
+        rangePolicy1, KOKKOS_LAMBDA(const int i) { offsetV1(i) = 1; });
+    Kokkos::fence();
+
+    int OVResult = 0;
+    Kokkos::parallel_reduce(
+        rangePolicy1,
+        KOKKOS_LAMBDA(const int i, int& updateMe) { updateMe += offsetV1(i); },
+        OVResult);
+
+    Kokkos::fence();
+    ASSERT_EQ(OVResult, offsetV1.end(0) - offsetV1.begin(0))
+        << "found wrong number of elements in OffsetView that was summed.";
+  }
+  {  // test deep copy of scalar const value into mirro
+    const int constVal = 6;
+    typename offset_view_type::HostMirror hostOffsetView =
+        Kokkos::Experimental::create_mirror_view(ov);
+
+    Kokkos::Experimental::deep_copy(hostOffsetView, constVal);
+
+    for (int i = hostOffsetView.begin(0); i < hostOffsetView.end(0); ++i) {
+      for (int j = hostOffsetView.begin(1); j < hostOffsetView.end(1); ++j) {
+        ASSERT_EQ(hostOffsetView(i, j), constVal)
+            << "Bad data found in OffsetView";
       }
-      
-      ASSERT_EQ(OVResult, answer) << "Bad data found in OffsetView";
+    }
+  }
+
+  typedef Kokkos::MDRangePolicy<Device, Kokkos::Rank<2>,
+                                Kokkos::IndexType<int> >
+      range_type;
+  typedef typename range_type::point_type point_type;
+
+  range_type rangePolicy2D(point_type{{ovmin0, ovmin1}},
+                           point_type{{ovend0, ovend1}});
+
+  const int constValue = 9;
+  Kokkos::parallel_for(
+      rangePolicy2D,
+      KOKKOS_LAMBDA(const int i, const int j) { ov(i, j) = constValue; });
+
+  // test offsetview to offsetviewmirror deep copy
+  typename offset_view_type::HostMirror hostOffsetView =
+      Kokkos::Experimental::create_mirror_view(ov);
+
+  Kokkos::Experimental::deep_copy(hostOffsetView, ov);
+
+  for (int i = hostOffsetView.begin(0); i < hostOffsetView.end(0); ++i) {
+    for (int j = hostOffsetView.begin(1); j < hostOffsetView.end(1); ++j) {
+      ASSERT_EQ(hostOffsetView(i, j), constValue)
+          << "Bad data found in OffsetView";
+    }
+  }
+
+  int OVResult = 0;
+  Kokkos::parallel_reduce(
+      rangePolicy2D,
+      KOKKOS_LAMBDA(const int i, const int j, int& updateMe) {
+        updateMe += ov(i, j);
+      },
+      OVResult);
+
+  int answer = 0;
+  for (int i = ov.begin(0); i < ov.end(0); ++i) {
+    for (int j = ov.begin(1); j < ov.end(1); ++j) {
+      answer += constValue;
+    }
+  }
+
+  ASSERT_EQ(OVResult, answer) << "Bad data found in OffsetView";
 #endif
 
-      {
-         offset_view_type ovCopy(ov);
-         ASSERT_EQ(ovCopy==ov, true) <<
-               "Copy constructor or equivalence operator broken";
-      }
-      
-      {
-         offset_view_type ovAssigned = ov;
-         ASSERT_EQ(ovAssigned==ov, true) <<
-               "Assignment operator or equivalence operator broken";
-      }
-      
-      {  //construct OffsetView from a View plus begins array
-         const int extent0 = 100;
-         const int extent1 = 200;
-         const int extent2 = 300;
-         Kokkos::View<Scalar***, Device> view3D("view3D", extent0, extent1, extent2);
-
-         Kokkos::deep_copy(view3D, 1);
+  {
+    offset_view_type ovCopy(ov);
+    ASSERT_EQ(ovCopy == ov, true)
+        << "Copy constructor or equivalence operator broken";
+  }
 
-         Kokkos::Array<int64_t,3> begins = {{-10, -20, -30}};
-         Kokkos::Experimental::OffsetView<Scalar***, Device> offsetView3D(view3D, begins);
+  {
+    offset_view_type ovAssigned = ov;
+    ASSERT_EQ(ovAssigned == ov, true)
+        << "Assignment operator or equivalence operator broken";
+  }
 
-         typedef Kokkos::MDRangePolicy<Device, Kokkos::Rank<3>, Kokkos::IndexType<int64_t> > range3_type;
-         typedef typename range3_type::point_type point3_type;
+  {  // construct OffsetView from a View plus begins array
+    const int extent0 = 100;
+    const int extent1 = 200;
+    const int extent2 = 300;
+    Kokkos::View<Scalar***, Device> view3D("view3D", extent0, extent1, extent2);
 
-         range3_type rangePolicy3DZero(point3_type{ {0, 0, 0 } },
-               point3_type{ { extent0, extent1, extent2 } });
+    Kokkos::deep_copy(view3D, 1);
 
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-        int view3DSum = 0;
-         Kokkos::parallel_reduce(rangePolicy3DZero, KOKKOS_LAMBDA(const int i, const int j, int k, int & updateMe){
-            updateMe += view3D(i, j, k);
-         }, view3DSum);
+    Kokkos::Array<int64_t, 3> begins = {{-10, -20, -30}};
+    Kokkos::Experimental::OffsetView<Scalar***, Device> offsetView3D(view3D,
+                                                                     begins);
 
-         range3_type rangePolicy3D(point3_type{ {begins[0], begins[1], begins[2] } },
-               point3_type{ { begins[0] + extent0, begins[1] + extent1, begins[2] + extent2 } });
-         int offsetView3DSum = 0;
+    typedef Kokkos::MDRangePolicy<Device, Kokkos::Rank<3>,
+                                  Kokkos::IndexType<int64_t> >
+        range3_type;
+    typedef typename range3_type::point_type point3_type;
 
-         Kokkos::parallel_reduce(rangePolicy3D, KOKKOS_LAMBDA(const int i, const int j, int k, int & updateMe){
-            updateMe += offsetView3D(i, j, k);
-         }, offsetView3DSum);
+    range3_type rangePolicy3DZero(point3_type{{0, 0, 0}},
+                                  point3_type{{extent0, extent1, extent2}});
 
-         ASSERT_EQ(view3DSum, offsetView3DSum) << "construction of OffsetView from View and begins array broken.";
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+    int view3DSum = 0;
+    Kokkos::parallel_reduce(
+        rangePolicy3DZero,
+        KOKKOS_LAMBDA(const int i, const int j, int k, int& updateMe) {
+          updateMe += view3D(i, j, k);
+        },
+        view3DSum);
+
+    range3_type rangePolicy3D(
+        point3_type{{begins[0], begins[1], begins[2]}},
+        point3_type{
+            {begins[0] + extent0, begins[1] + extent1, begins[2] + extent2}});
+    int offsetView3DSum = 0;
+
+    Kokkos::parallel_reduce(
+        rangePolicy3D,
+        KOKKOS_LAMBDA(const int i, const int j, int k, int& updateMe) {
+          updateMe += offsetView3D(i, j, k);
+        },
+        offsetView3DSum);
+
+    ASSERT_EQ(view3DSum, offsetView3DSum)
+        << "construction of OffsetView from View and begins array broken.";
 #endif
-      }
-      view_type viewFromOV = ov.view();
-
-      ASSERT_EQ(viewFromOV == ov, true) <<
-            "OffsetView::view() or equivalence operator View == OffsetView broken";
-
-      {
-         offset_view_type ovFromV(viewFromOV, {-1, -2});
-
-         ASSERT_EQ(ovFromV == viewFromOV , true) <<
-               "Construction of OffsetView from View or equivalence operator OffsetView == View broken";
-      }
-      {
-         offset_view_type ovFromV = viewFromOV;
-         ASSERT_EQ(ovFromV == viewFromOV , true) <<
-               "Construction of OffsetView from View by assignment (implicit conversion) or equivalence operator OffsetView == View broken";
-      }
-
-      {// test offsetview to view deep copy
-         view_type aView("aView", ov.extent(0), ov.extent(1));
-         Kokkos::Experimental::deep_copy(aView, ov);
+  }
+  view_type viewFromOV = ov.view();
+
+  ASSERT_EQ(viewFromOV == ov, true)
+      << "OffsetView::view() or equivalence operator View == OffsetView broken";
+
+  {
+    offset_view_type ovFromV(viewFromOV, {-1, -2});
+
+    ASSERT_EQ(ovFromV == viewFromOV, true)
+        << "Construction of OffsetView from View or equivalence operator "
+           "OffsetView == View broken";
+  }
+  {
+    offset_view_type ovFromV = viewFromOV;
+    ASSERT_EQ(ovFromV == viewFromOV, true)
+        << "Construction of OffsetView from View by assignment (implicit "
+           "conversion) or equivalence operator OffsetView == View broken";
+  }
+
+  {  // test offsetview to view deep copy
+    view_type aView("aView", ov.extent(0), ov.extent(1));
+    Kokkos::Experimental::deep_copy(aView, ov);
 
 #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-         int sum = 0;
-         Kokkos::parallel_reduce(rangePolicy2D, KOKKOS_LAMBDA(const int i, const int j, int & updateMe){
-            updateMe += ov(i, j) - aView(i- ov.begin(0), j-ov.begin(1));
-         }, sum);
-
-         ASSERT_EQ(sum, 0) << "deep_copy(view, offsetView) broken.";
+    int sum = 0;
+    Kokkos::parallel_reduce(
+        rangePolicy2D,
+        KOKKOS_LAMBDA(const int i, const int j, int& updateMe) {
+          updateMe += ov(i, j) - aView(i - ov.begin(0), j - ov.begin(1));
+        },
+        sum);
+
+    ASSERT_EQ(sum, 0) << "deep_copy(view, offsetView) broken.";
 #endif
-      }
+  }
 
-      {// test view to  offsetview deep copy
-         view_type aView("aView", ov.extent(0), ov.extent(1));
+  {  // test view to  offsetview deep copy
+    view_type aView("aView", ov.extent(0), ov.extent(1));
 
-         Kokkos::deep_copy(aView, 99);
-         Kokkos::Experimental::deep_copy(ov, aView);
-	 
+    Kokkos::deep_copy(aView, 99);
+    Kokkos::Experimental::deep_copy(ov, aView);
 
 #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-         int sum = 0;
-         Kokkos::parallel_reduce(rangePolicy2D, KOKKOS_LAMBDA(const int i, const int j, int & updateMe){
-            updateMe += ov(i, j) - aView(i- ov.begin(0), j-ov.begin(1));
-         }, sum);
-
-         ASSERT_EQ(sum, 0) << "deep_copy(offsetView, view) broken.";
+    int sum = 0;
+    Kokkos::parallel_reduce(
+        rangePolicy2D,
+        KOKKOS_LAMBDA(const int i, const int j, int& updateMe) {
+          updateMe += ov(i, j) - aView(i - ov.begin(0), j - ov.begin(1));
+        },
+        sum);
+
+    ASSERT_EQ(sum, 0) << "deep_copy(offsetView, view) broken.";
 #endif
-      }
-   }
-   template <typename Scalar, typename Device>
-   void test_offsetview_subview(unsigned int size)
-   {
-      {//test subview 1
-          Kokkos::Experimental::OffsetView<Scalar*, Device> sliceMe("offsetToSlice", {-10, 20});
-          {
-             auto offsetSubviewa = Kokkos::Experimental::subview(sliceMe, 0);
-             ASSERT_EQ(offsetSubviewa.Rank, 0) << "subview of offset is broken.";
-          }
-
-       }
-      {//test subview 2
-         Kokkos::Experimental::OffsetView<Scalar**, Device> sliceMe("offsetToSlice", {-10,20}, {-20,30});
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(),-2);
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, 0, Kokkos::ALL());
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-      }
+  }
+}
+
+template <typename Scalar, typename Device>
+void test_offsetview_unmanaged_construction() {
+  // Preallocated memory (Only need a valid address for this test)
+  Scalar s;
+
+  {
+    // Constructing an OffsetView directly around our preallocated memory
+    Kokkos::Array<int64_t, 1> begins1{{2}};
+    Kokkos::Array<int64_t, 1> ends1{{3}};
+    Kokkos::Experimental::OffsetView<Scalar*, Device> ov1(&s, begins1, ends1);
+
+    // Constructing an OffsetView around an unmanaged View of our preallocated
+    // memory
+    Kokkos::View<Scalar*, Device> v1(&s, ends1[0] - begins1[0]);
+    Kokkos::Experimental::OffsetView<Scalar*, Device> ovv1(v1, begins1);
+
+    // They should match
+    ASSERT_EQ(ovv1, ov1)
+        << "OffsetView unmanaged construction fails for rank 1";
+  }
+
+  {
+    Kokkos::Array<int64_t, 2> begins2{{-2, -7}};
+    Kokkos::Array<int64_t, 2> ends2{{5, -3}};
+    Kokkos::Experimental::OffsetView<Scalar**, Device> ov2(&s, begins2, ends2);
+
+    Kokkos::View<Scalar**, Device> v2(&s, ends2[0] - begins2[0],
+                                      ends2[1] - begins2[1]);
+    Kokkos::Experimental::OffsetView<Scalar**, Device> ovv2(v2, begins2);
+
+    ASSERT_EQ(ovv2, ov2)
+        << "OffsetView unmanaged construction fails for rank 2";
+  }
+
+  {
+    Kokkos::Array<int64_t, 3> begins3{{2, 3, 5}};
+    Kokkos::Array<int64_t, 3> ends3{{7, 11, 13}};
+    Kokkos::Experimental::OffsetView<Scalar***, Device> ovv3(&s, begins3,
+                                                             ends3);
+
+    Kokkos::View<Scalar***, Device> v3(&s, ends3[0] - begins3[0],
+                                       ends3[1] - begins3[1],
+                                       ends3[2] - begins3[2]);
+    Kokkos::Experimental::OffsetView<Scalar***, Device> ov3(v3, begins3);
+
+    ASSERT_EQ(ovv3, ov3)
+        << "OffsetView unmanaged construction fails for rank 3";
+  }
+
+  {
+    // Test all four public constructor overloads (begins_type x
+    // index_list_type)
+    Kokkos::Array<int64_t, 1> begins{{-3}};
+    Kokkos::Array<int64_t, 1> ends{{2}};
+
+    Kokkos::Experimental::OffsetView<Scalar*, Device> bb(&s, begins, ends);
+    Kokkos::Experimental::OffsetView<Scalar*, Device> bi(&s, begins, {2});
+    Kokkos::Experimental::OffsetView<Scalar*, Device> ib(&s, {-3}, ends);
+    Kokkos::Experimental::OffsetView<Scalar*, Device> ii(&s, {-3}, {2});
+
+    ASSERT_EQ(bb, bi);
+    ASSERT_EQ(bb, ib);
+    ASSERT_EQ(bb, ii);
+  }
+
+#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+  {
+    using offset_view_type = Kokkos::Experimental::OffsetView<Scalar*, Device>;
+
+    // Range calculations must be positive
+    ASSERT_NO_THROW(offset_view_type(&s, {0}, {1}));
+    ASSERT_NO_THROW(offset_view_type(&s, {0}, {0}));
+    ASSERT_THROW(offset_view_type(&s, {0}, {-1}), std::runtime_error);
+  }
+
+  {
+    using offset_view_type = Kokkos::Experimental::OffsetView<Scalar*, Device>;
+
+    // Range calculations must not overflow
+    ASSERT_NO_THROW(offset_view_type(&s, {0}, {0x7fffffffffffffffl}));
+    ASSERT_THROW(offset_view_type(&s, {-1}, {0x7fffffffffffffffl}),
+                 std::runtime_error);
+    ASSERT_THROW(
+        offset_view_type(&s, {-0x7fffffffffffffffl - 1}, {0x7fffffffffffffffl}),
+        std::runtime_error);
+    ASSERT_THROW(offset_view_type(&s, {-0x7fffffffffffffffl - 1}, {0}),
+                 std::runtime_error);
+  }
+
+  {
+    using offset_view_type = Kokkos::Experimental::OffsetView<Scalar**, Device>;
+
+    // Should throw when the rank of begins and/or ends doesn't match that of
+    // OffsetView
+    ASSERT_THROW(offset_view_type(&s, {0}, {1}), std::runtime_error);
+    ASSERT_THROW(offset_view_type(&s, {0}, {1, 1}), std::runtime_error);
+    ASSERT_THROW(offset_view_type(&s, {0}, {1, 1, 1}), std::runtime_error);
+    ASSERT_THROW(offset_view_type(&s, {0, 0}, {1}), std::runtime_error);
+    ASSERT_NO_THROW(offset_view_type(&s, {0, 0}, {1, 1}));
+    ASSERT_THROW(offset_view_type(&s, {0, 0}, {1, 1, 1}), std::runtime_error);
+    ASSERT_THROW(offset_view_type(&s, {0, 0, 0}, {1}), std::runtime_error);
+    ASSERT_THROW(offset_view_type(&s, {0, 0, 0}, {1, 1}), std::runtime_error);
+    ASSERT_THROW(offset_view_type(&s, {0, 0, 0}, {1, 1, 1}),
+                 std::runtime_error);
+  }
+#endif  // KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+}
+
+template <typename Scalar, typename Device>
+void test_offsetview_subview(unsigned int size) {
+  {  // test subview 1
+    Kokkos::Experimental::OffsetView<Scalar*, Device> sliceMe("offsetToSlice",
+                                                              {-10, 20});
+    {
+      auto offsetSubviewa = Kokkos::Experimental::subview(sliceMe, 0);
+      ASSERT_EQ(offsetSubviewa.Rank, 0) << "subview of offset is broken.";
+    }
+  }
+  {  // test subview 2
+    Kokkos::Experimental::OffsetView<Scalar**, Device> sliceMe(
+        "offsetToSlice", {-10, 20}, {-20, 30});
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), -2);
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, 0, Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+  }
+
+  {  // test subview rank 3
+
+    Kokkos::Experimental::OffsetView<Scalar***, Device> sliceMe(
+        "offsetToSlice", {-10, 20}, {-20, 30}, {-30, 40});
+
+    // slice 1
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(),
+                                                         Kokkos::ALL(), 0);
+      ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(),
+                                                         0, Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
+    }
+
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(
+          sliceMe, 0, Kokkos::ALL(), Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(
+          sliceMe, 0, Kokkos::ALL(), Kokkos::make_pair(-30, -21));
+      ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
+
+      ASSERT_EQ(offsetSubview.begin(0), -20);
+      ASSERT_EQ(offsetSubview.end(0), 31);
+      ASSERT_EQ(offsetSubview.begin(1), 0);
+      ASSERT_EQ(offsetSubview.end(1), 9);
 
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+      typedef Kokkos::MDRangePolicy<Device, Kokkos::Rank<2>,
+                                    Kokkos::IndexType<int> >
+          range_type;
+      typedef typename range_type::point_type point_type;
 
-      {//test subview rank 3
+      const int b0 = offsetSubview.begin(0);
+      const int b1 = offsetSubview.begin(1);
 
-         Kokkos::Experimental::OffsetView<Scalar***, Device> sliceMe("offsetToSlice", {-10,20}, {-20,30}, {-30,40});
+      const int e0 = offsetSubview.end(0);
+      const int e1 = offsetSubview.end(1);
 
-         //slice 1
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe,Kokkos::ALL(),Kokkos::ALL(), 0);
-            ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe,Kokkos::ALL(), 0,Kokkos::ALL());
-            ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
-         }
+      range_type rangeP2D(point_type{{b0, b1}}, point_type{{e0, e1}});
 
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe,0, Kokkos::ALL(),Kokkos::ALL());
-            ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
+      Kokkos::parallel_for(
+          rangeP2D,
+          KOKKOS_LAMBDA(const int i, const int j) { offsetSubview(i, j) = 6; });
 
-         }
-         {
-	   auto offsetSubview = Kokkos::Experimental::subview(sliceMe,0, Kokkos::ALL(), Kokkos::make_pair(-30, -21));
-            ASSERT_EQ(offsetSubview.Rank, 2) << "subview of offset is broken.";
+      int sum = 0;
+      Kokkos::parallel_reduce(
+          rangeP2D,
+          KOKKOS_LAMBDA(const int i, const int j, int& updateMe) {
+            updateMe += offsetSubview(i, j);
+          },
+          sum);
 
-            ASSERT_EQ(offsetSubview.begin(0) , -20);
-            ASSERT_EQ(offsetSubview.end(0) , 31);
-            ASSERT_EQ(offsetSubview.begin(1) , 0);
-            ASSERT_EQ(offsetSubview.end(1) , 9);
+      ASSERT_EQ(sum, 6 * (e0 - b0) * (e1 - b1));
+#endif
+    }
+
+    // slice 2
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), 0, 0);
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, 0, 0, Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, 0, Kokkos::ALL(), 0);
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+  }
+
+  {  // test subview rank 4
+
+    Kokkos::Experimental::OffsetView<Scalar****, Device> sliceMe(
+        "offsetToSlice", {-10, 20}, {-20, 30}, {-30, 40}, {-40, 50});
+
+    // slice 1
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(
+          sliceMe, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), 0);
+      ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(
+          sliceMe, Kokkos::ALL(), Kokkos::ALL(), 0, Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(
+          sliceMe, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview = Kokkos::Experimental::subview(
+          sliceMe, 0, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
+    }
+
+    // slice 2
+    auto offsetSubview2a = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(),
+                                                         Kokkos::ALL(), 0, 0);
+    ASSERT_EQ(offsetSubview2a.Rank, 2) << "subview of offset is broken.";
+    {
+      auto offsetSubview2b = Kokkos::Experimental::subview(
+          sliceMe, Kokkos::ALL(), 0, Kokkos::ALL(), 0);
+      ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview2b = Kokkos::Experimental::subview(
+          sliceMe, Kokkos::ALL(), 0, 0, Kokkos::ALL());
+      ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview2b = Kokkos::Experimental::subview(
+          sliceMe, 0, Kokkos::ALL(), 0, Kokkos::ALL());
+      ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview2b = Kokkos::Experimental::subview(
+          sliceMe, 0, 0, Kokkos::ALL(), Kokkos::ALL());
+      ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
+    }
+    // slice 3
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), 0, 0, 0);
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, 0, Kokkos::ALL(), 0, 0);
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, 0, 0, Kokkos::ALL(), 0);
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+    {
+      auto offsetSubview =
+          Kokkos::Experimental::subview(sliceMe, 0, 0, 0, Kokkos::ALL());
+      ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
+    }
+  }
+}
 
 #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-            typedef Kokkos::MDRangePolicy<Device, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
-            typedef typename range_type::point_type point_type;
-
-            const int b0 = offsetSubview.begin(0);
-            const int b1 = offsetSubview.begin(1);
-
-            const int e0 = offsetSubview.end(0);
-            const int e1 = offsetSubview.end(1);
-
-            range_type rangeP2D(point_type{ {b0, b1 } }, point_type{ { e0, e1} });
+template <class InputIt, class T, class BinaryOperation>
+KOKKOS_INLINE_FUNCTION T std_accumulate(InputIt first, InputIt last, T init,
+                                        BinaryOperation op) {
+  for (; first != last; ++first) {
+    init = op(std::move(init), *first);
+  }
+  return init;
+}
+
+KOKKOS_INLINE_FUNCTION int element(std::initializer_list<int> il) {
+  return std_accumulate(il.begin(), il.end(), 0,
+                        [](int l, int r) { return l * 10 + r; });
+}
+
+template <typename DEVICE>
+void test_offsetview_offsets_rank1() {
+  using data_type        = int*;
+  using view_type        = Kokkos::View<data_type, DEVICE>;
+  using index_type       = Kokkos::IndexType<int>;
+  using execution_policy = Kokkos::RangePolicy<DEVICE, index_type>;
+  using offset_view_type = Kokkos::Experimental::OffsetView<data_type, DEVICE>;
+
+  view_type v("View1", 10);
+  Kokkos::parallel_for(
+      "For1", execution_policy(0, v.extent_int(0)),
+      KOKKOS_LAMBDA(const int i) { v(i) = element({i}); });
+
+  int errors;
+  Kokkos::parallel_reduce(
+      "Reduce1", execution_policy(-3, 4),
+      KOKKOS_LAMBDA(const int ii, int& lerrors) {
+        offset_view_type ov(v, {ii});
+        lerrors += (ov(3) != element({3 - ii}));
+      },
+      errors);
+
+  ASSERT_EQ(0, errors);
+}
+
+template <typename DEVICE>
+void test_offsetview_offsets_rank2() {
+  using data_type        = int**;
+  using view_type        = Kokkos::View<data_type, DEVICE>;
+  using index_type       = Kokkos::IndexType<int>;
+  using execution_policy = Kokkos::RangePolicy<DEVICE, index_type>;
+  using offset_view_type = Kokkos::Experimental::OffsetView<data_type, DEVICE>;
+
+  view_type v("View2", 10, 10);
+  Kokkos::parallel_for(
+      "For2", execution_policy(0, v.extent_int(0)), KOKKOS_LAMBDA(const int i) {
+        for (int j = 0; j != v.extent_int(1); ++j) {
+          v(i, j) = element({i, j});
+        }
+      });
+
+  int errors;
+  Kokkos::parallel_reduce(
+      "Reduce2", execution_policy(-3, 4),
+      KOKKOS_LAMBDA(const int ii, int& lerrors) {
+        for (int jj = -3; jj <= 3; ++jj) {
+          offset_view_type ov(v, {ii, jj});
+          lerrors += (ov(3, 3) != element({3 - ii, 3 - jj}));
+        }
+      },
+      errors);
+
+  ASSERT_EQ(0, errors);
+}
+
+template <typename DEVICE>
+void test_offsetview_offsets_rank3() {
+  using data_type        = int***;
+  using view_type        = Kokkos::View<data_type, DEVICE>;
+  using index_type       = Kokkos::IndexType<int>;
+  using execution_policy = Kokkos::RangePolicy<DEVICE, index_type>;
+  using offset_view_type = Kokkos::Experimental::OffsetView<data_type, DEVICE>;
+
+  view_type v("View3", 10, 10, 10);
+  Kokkos::parallel_for(
+      "For3", execution_policy(0, v.extent_int(0)), KOKKOS_LAMBDA(const int i) {
+        for (int j = 0; j != v.extent_int(1); ++j) {
+          for (int k = 0; k != v.extent_int(2); ++k) {
+            v(i, j, k) = element({i, j, k});
+          }
+        }
+      });
+
+  int errors;
+  Kokkos::parallel_reduce(
+      "Reduce3", execution_policy(-3, 4),
+      KOKKOS_LAMBDA(const int ii, int& lerrors) {
+        for (int jj = -3; jj <= 3; ++jj) {
+          for (int kk = -3; kk <= 3; ++kk) {
+            offset_view_type ov(v, {ii, jj, kk});
+            lerrors += (ov(3, 3, 3) != element({3 - ii, 3 - jj, 3 - kk}));
+          }
+        }
+      },
+      errors);
 
-            Kokkos::parallel_for(rangeP2D, KOKKOS_LAMBDA(const int i, const int j) {
-               offsetSubview(i,j) =  6;
-            }
-            );
+  ASSERT_EQ(0, errors);
+}
+#endif
 
-            int sum = 0;
-             Kokkos::parallel_reduce(rangeP2D, KOKKOS_LAMBDA(const int i, const int j, int & updateMe){
-                updateMe += offsetSubview(i, j);
-             }, sum);
+TEST(TEST_CATEGORY, offsetview_construction) {
+  test_offsetview_construction<int, TEST_EXECSPACE>(10);
+}
 
-            ASSERT_EQ(sum, 6*(e0-b0)*(e1-b1));
-#endif
-         }
-
-         // slice 2
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), 0, 0);
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, 0, 0, Kokkos::ALL());
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, 0, Kokkos::ALL(), 0);
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-      }
+TEST(TEST_CATEGORY, offsetview_unmanaged_construction) {
+  test_offsetview_unmanaged_construction<int, TEST_EXECSPACE>();
+}
 
-      {//test subview rank 4
-
-         Kokkos::Experimental::OffsetView<Scalar****, Device> sliceMe("offsetToSlice", {-10,20}, {-20,30}, {-30,40}, {-40, 50});
-
-         //slice 1
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(),Kokkos::ALL(), Kokkos::ALL(), 0);
-            ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), Kokkos::ALL(), 0, Kokkos::ALL());
-            ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe ,Kokkos::ALL(), 0, Kokkos::ALL(),Kokkos::ALL());
-            ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe , 0, Kokkos::ALL(), Kokkos::ALL(),  Kokkos::ALL() );
-            ASSERT_EQ(offsetSubview.Rank, 3) << "subview of offset is broken.";
-         }
-
-         // slice 2
-         auto offsetSubview2a = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), Kokkos::ALL(), 0, 0);
-         ASSERT_EQ(offsetSubview2a.Rank, 2) << "subview of offset is broken.";
-         {
-            auto offsetSubview2b = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), 0, Kokkos::ALL(), 0);
-            ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview2b = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), 0, 0, Kokkos::ALL());
-            ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview2b = Kokkos::Experimental::subview(sliceMe,  0, Kokkos::ALL(), 0, Kokkos::ALL());
-            ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview2b = Kokkos::Experimental::subview(sliceMe,  0, 0, Kokkos::ALL(), Kokkos::ALL());
-            ASSERT_EQ(offsetSubview2b.Rank, 2) << "subview of offset is broken.";
-         }
-         // slice 3
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, Kokkos::ALL(), 0, 0, 0);
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe, 0, Kokkos::ALL(), 0, 0);
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe,  0, 0, Kokkos::ALL(), 0);
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
-         {
-            auto offsetSubview = Kokkos::Experimental::subview(sliceMe,  0, 0, 0, Kokkos::ALL());
-            ASSERT_EQ(offsetSubview.Rank, 1) << "subview of offset is broken.";
-         }
+TEST(TEST_CATEGORY, offsetview_subview) {
+  test_offsetview_subview<int, TEST_EXECSPACE>(10);
+}
 
-      }
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+TEST(TEST_CATEGORY, offsetview_offsets_rank1) {
+  test_offsetview_offsets_rank1<TEST_EXECSPACE>();
+}
 
-   }
+TEST(TEST_CATEGORY, offsetview_offsets_rank2) {
+  test_offsetview_offsets_rank2<TEST_EXECSPACE>();
+}
 
-   TEST_F( TEST_CATEGORY, offsetview_construction) {
-      test_offsetview_construction<int,TEST_EXECSPACE>(10);
-   }
-   TEST_F( TEST_CATEGORY, offsetview_subview) {
-      test_offsetview_subview<int,TEST_EXECSPACE>(10);
-   }
+TEST(TEST_CATEGORY, offsetview_offsets_rank3) {
+  test_offsetview_offsets_rank3<TEST_EXECSPACE>();
+}
+#endif
 
-} // namespace Test
+}  // namespace Test
 
 #endif /* CONTAINERS_UNIT_TESTS_TESTOFFSETVIEW_HPP_ */
diff --git a/lib/kokkos/containers/unit_tests/TestScatterView.hpp b/lib/kokkos/containers/unit_tests/TestScatterView.hpp
index a9d97b32f39f1e150dea8fa2d1784de9b1660e2f..93b69cc769c28dd9c165983e8ba3b5cce81c6ccf 100644
--- a/lib/kokkos/containers/unit_tests/TestScatterView.hpp
+++ b/lib/kokkos/containers/unit_tests/TestScatterView.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,381 +46,378 @@
 #define KOKKOS_TEST_SCATTER_VIEW_HPP
 
 #include <Kokkos_ScatterView.hpp>
+#include <gtest/gtest.h>
 
 namespace Test {
 
-template <typename ExecSpace, typename Layout, int duplication, int contribution, int op>
+template <typename ExecSpace, typename Layout, int duplication,
+          int contribution, int op>
 struct test_scatter_view_impl_cls;
 
-template <typename ExecSpace, typename Layout, int duplication, int contribution>
-struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution, Kokkos::Experimental::ScatterSum>   
-{
-public:   
+template <typename ExecSpace, typename Layout, int duplication,
+          int contribution>
+struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution,
+                                  Kokkos::Experimental::ScatterSum> {
+ public:
+  typedef Kokkos::Experimental::ScatterView<double * [3], Layout, ExecSpace,
+                                            Kokkos::Experimental::ScatterSum,
+                                            duplication, contribution>
+      scatter_view_type;
 
-   typedef Kokkos::Experimental::ScatterView
-       < double*[3]
-       , Layout
-       , ExecSpace
-       , Kokkos::Experimental::ScatterSum
-       , duplication
-       , contribution
-        > scatter_view_type;
+  typedef Kokkos::View<double * [3], Layout, ExecSpace> orig_view_type;
 
-   typedef Kokkos::View<double *[3], Layout, ExecSpace> orig_view_type; 
+  scatter_view_type scatter_view;
+  int scatterSize;
 
+  test_scatter_view_impl_cls(const scatter_view_type& view) {
+    scatter_view = view;
+    scatterSize  = 0;
+  }
 
-   scatter_view_type scatter_view;
-   int scatterSize;
+  void initialize(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      host_view(i, 0) = 0.0;
+      host_view(i, 1) = 0.0;
+      host_view(i, 2) = 0.0;
+    }
+    Kokkos::fence();
+    Kokkos::deep_copy(orig, host_view);
+  }
 
-   test_scatter_view_impl_cls(const scatter_view_type& view){
-      scatter_view = view;
-      scatterSize = 0;
-   }
+  void run_parallel(int n) {
+    scatterSize = n;
+    auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
+    Kokkos::parallel_for(policy, *this, "scatter_view_test: Sum");
+  }
 
-   void initialize(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        host_view(i, 0) = 0.0;
-        host_view(i, 1) = 0.0;
-        host_view(i, 2) = 0.0;
-      }
-      Kokkos::fence();
-      Kokkos::deep_copy(orig, host_view);
-   }
-
-   void run_parallel(int n) {
-        scatterSize = n;
-        auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
-        Kokkos::parallel_for(policy, *this, "scatter_view_test: Sum");
-   }
-
-   KOKKOS_INLINE_FUNCTION
-   void operator()(int i) const {
-      auto scatter_access = scatter_view.access();
-      auto scatter_access_atomic = scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
-      for (int j = 0; j < 10; ++j) {
-        auto k = (i + j) % scatterSize;
-        scatter_access(k, 0) += 4.2;
-        scatter_access_atomic(k, 1) += 2.0;
-        scatter_access(k, 2) += 1.0;
-      }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i) const {
+    auto scatter_access = scatter_view.access();
+    auto scatter_access_atomic =
+        scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
+    for (int j = 0; j < 10; ++j) {
+      auto k = (i + j) % scatterSize;
+      scatter_access(k, 0) += 4.2;
+      scatter_access_atomic(k, 1) += 2.0;
+      scatter_access(k, 2) += 1.0;
     }
+  }
 
-    void validateResults(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        auto val0 = host_view(i, 0);
-        auto val1 = host_view(i, 1);
-        auto val2 = host_view(i, 2);
-        EXPECT_TRUE(std::fabs((val0 - 84.0) / 84.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val1 - 40.0) / 40.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val2 - 20.0) / 20.0) < 1e-14);
-      }
+  void validateResults(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      auto val0 = host_view(i, 0);
+      auto val1 = host_view(i, 1);
+      auto val2 = host_view(i, 2);
+      EXPECT_TRUE(std::fabs((val0 - 84.0) / 84.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val1 - 40.0) / 40.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val2 - 20.0) / 20.0) < 1e-14);
     }
+  }
 };
 
+template <typename ExecSpace, typename Layout, int duplication,
+          int contribution>
+struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution,
+                                  Kokkos::Experimental::ScatterProd> {
+ public:
+  typedef Kokkos::Experimental::ScatterView<double * [3], Layout, ExecSpace,
+                                            Kokkos::Experimental::ScatterProd,
+                                            duplication, contribution>
+      scatter_view_type;
 
-template <typename ExecSpace, typename Layout, int duplication, int contribution>
-struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution, Kokkos::Experimental::ScatterProd>   
-{
-public:   
-
-   typedef Kokkos::Experimental::ScatterView
-       < double*[3]
-       , Layout
-       , ExecSpace
-       , Kokkos::Experimental::ScatterProd
-       , duplication
-       , contribution
-        > scatter_view_type;
+  typedef Kokkos::View<double * [3], Layout, ExecSpace> orig_view_type;
 
-   typedef Kokkos::View<double *[3], Layout, ExecSpace> orig_view_type; 
+  scatter_view_type scatter_view;
+  int scatterSize;
 
+  test_scatter_view_impl_cls(const scatter_view_type& view) {
+    scatter_view = view;
+    scatterSize  = 0;
+  }
 
-   scatter_view_type scatter_view;
-   int scatterSize;
+  void initialize(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      host_view(i, 0) = 1.0;
+      host_view(i, 1) = 1.0;
+      host_view(i, 2) = 1.0;
+    }
+    Kokkos::fence();
+    Kokkos::deep_copy(orig, host_view);
+  }
 
-   test_scatter_view_impl_cls(const scatter_view_type& view){
-      scatter_view = view;
-      scatterSize = 0;
-   }
+  void run_parallel(int n) {
+    scatterSize = n;
+    auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
+    Kokkos::parallel_for(policy, *this, "scatter_view_test: Prod");
+  }
 
-   void initialize(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        host_view(i, 0) = 1.0;
-        host_view(i, 1) = 1.0;
-        host_view(i, 2) = 1.0;
-      }
-      Kokkos::fence();
-      Kokkos::deep_copy(orig, host_view);
-   }
-
-   void run_parallel(int n) {
-        scatterSize = n;
-        auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
-        Kokkos::parallel_for(policy, *this, "scatter_view_test: Prod");
-   }
-
-   KOKKOS_INLINE_FUNCTION
-   void operator()(int i) const {
-      auto scatter_access = scatter_view.access();
-      auto scatter_access_atomic = scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
-      for (int j = 0; j < 4; ++j) {
-        auto k = (i + j) % scatterSize;
-        scatter_access(k, 0) *= 4.0;
-        scatter_access_atomic(k, 1) *= 2.0;
-        scatter_access(k, 2) *= 1.0;
-      }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i) const {
+    auto scatter_access = scatter_view.access();
+    auto scatter_access_atomic =
+        scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
+    for (int j = 0; j < 4; ++j) {
+      auto k = (i + j) % scatterSize;
+      scatter_access(k, 0) *= 4.0;
+      scatter_access_atomic(k, 1) *= 2.0;
+      scatter_access(k, 2) *= 1.0;
     }
+  }
 
-    void validateResults(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        auto val0 = host_view(i, 0);
-        auto val1 = host_view(i, 1);
-        auto val2 = host_view(i, 2);
-        EXPECT_TRUE(std::fabs((val0 - 65536.0) / 65536.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val1 - 256.0) / 256.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val2 - 1.0) / 1.0) < 1e-14);
-      }
+  void validateResults(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      auto val0 = host_view(i, 0);
+      auto val1 = host_view(i, 1);
+      auto val2 = host_view(i, 2);
+      EXPECT_TRUE(std::fabs((val0 - 65536.0) / 65536.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val1 - 256.0) / 256.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val2 - 1.0) / 1.0) < 1e-14);
     }
+  }
 };
 
+template <typename ExecSpace, typename Layout, int duplication,
+          int contribution>
+struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution,
+                                  Kokkos::Experimental::ScatterMin> {
+ public:
+  typedef Kokkos::Experimental::ScatterView<double * [3], Layout, ExecSpace,
+                                            Kokkos::Experimental::ScatterMin,
+                                            duplication, contribution>
+      scatter_view_type;
 
-template <typename ExecSpace, typename Layout, int duplication, int contribution>
-struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution, Kokkos::Experimental::ScatterMin>   
-{
-public:   
-
-   typedef Kokkos::Experimental::ScatterView
-       < double*[3]
-       , Layout
-       , ExecSpace
-       , Kokkos::Experimental::ScatterMin
-       , duplication
-       , contribution
-        > scatter_view_type;
+  typedef Kokkos::View<double * [3], Layout, ExecSpace> orig_view_type;
 
-   typedef Kokkos::View<double *[3], Layout, ExecSpace> orig_view_type; 
+  scatter_view_type scatter_view;
+  int scatterSize;
 
+  test_scatter_view_impl_cls(const scatter_view_type& view) {
+    scatter_view = view;
+    scatterSize  = 0;
+  }
 
-   scatter_view_type scatter_view;
-   int scatterSize;
+  void initialize(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      host_view(i, 0) = 999999.0;
+      host_view(i, 1) = 999999.0;
+      host_view(i, 2) = 999999.0;
+    }
+    Kokkos::fence();
+    Kokkos::deep_copy(orig, host_view);
+  }
 
-   test_scatter_view_impl_cls(const scatter_view_type& view){
-      scatter_view = view;
-      scatterSize = 0;
-   }
+  void run_parallel(int n) {
+    scatterSize = n;
+    auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
+    Kokkos::parallel_for(policy, *this, "scatter_view_test: Prod");
+  }
 
-   void initialize(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        host_view(i, 0) = 999999.0;
-        host_view(i, 1) = 999999.0;
-        host_view(i, 2) = 999999.0;
-      }
-      Kokkos::fence();
-      Kokkos::deep_copy(orig, host_view);
-   }
-
-   void run_parallel(int n) {
-        scatterSize = n;
-        auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
-        Kokkos::parallel_for(policy, *this, "scatter_view_test: Prod");
-   }
-
-   KOKKOS_INLINE_FUNCTION
-   void operator()(int i) const {
-      auto scatter_access = scatter_view.access();
-      auto scatter_access_atomic = scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
-      for (int j = 0; j < 4; ++j) {
-        auto k = (i + j) % scatterSize;
-        scatter_access(k, 0).update((double)(j+1)*4);
-        scatter_access_atomic(k, 1).update((double)(j+1)*2.0);
-        scatter_access(k, 2).update((double)(j+1)*1.0);
-      }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i) const {
+    auto scatter_access = scatter_view.access();
+    auto scatter_access_atomic =
+        scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
+    for (int j = 0; j < 4; ++j) {
+      auto k = (i + j) % scatterSize;
+      scatter_access(k, 0).update((double)(j + 1) * 4);
+      scatter_access_atomic(k, 1).update((double)(j + 1) * 2.0);
+      scatter_access(k, 2).update((double)(j + 1) * 1.0);
     }
+  }
 
-    void validateResults(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        auto val0 = host_view(i, 0);
-        auto val1 = host_view(i, 1);
-        auto val2 = host_view(i, 2);
-        EXPECT_TRUE(std::fabs((val0 - 4.0) / 4.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val1 - 2.0) / 2.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val2 - 1.0) / 1.0) < 1e-14);
-      }
+  void validateResults(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      auto val0 = host_view(i, 0);
+      auto val1 = host_view(i, 1);
+      auto val2 = host_view(i, 2);
+      EXPECT_TRUE(std::fabs((val0 - 4.0) / 4.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val1 - 2.0) / 2.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val2 - 1.0) / 1.0) < 1e-14);
     }
+  }
 };
 
+template <typename ExecSpace, typename Layout, int duplication,
+          int contribution>
+struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution,
+                                  Kokkos::Experimental::ScatterMax> {
+ public:
+  typedef Kokkos::Experimental::ScatterView<double * [3], Layout, ExecSpace,
+                                            Kokkos::Experimental::ScatterMax,
+                                            duplication, contribution>
+      scatter_view_type;
 
-template <typename ExecSpace, typename Layout, int duplication, int contribution>
-struct test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution, Kokkos::Experimental::ScatterMax>   
-{
-public:   
-
-   typedef Kokkos::Experimental::ScatterView
-       < double*[3]
-       , Layout
-       , ExecSpace
-       , Kokkos::Experimental::ScatterMax
-       , duplication
-       , contribution
-        > scatter_view_type;
+  typedef Kokkos::View<double * [3], Layout, ExecSpace> orig_view_type;
 
-   typedef Kokkos::View<double *[3], Layout, ExecSpace> orig_view_type; 
+  scatter_view_type scatter_view;
+  int scatterSize;
 
+  test_scatter_view_impl_cls(const scatter_view_type& view) {
+    scatter_view = view;
+    scatterSize  = 0;
+  }
 
-   scatter_view_type scatter_view;
-   int scatterSize;
+  void initialize(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      host_view(i, 0) = 0.0;
+      host_view(i, 1) = 0.0;
+      host_view(i, 2) = 0.0;
+    }
+    Kokkos::fence();
+    Kokkos::deep_copy(orig, host_view);
+  }
 
-   test_scatter_view_impl_cls(const scatter_view_type& view){
-      scatter_view = view;
-      scatterSize = 0;
-   }
+  void run_parallel(int n) {
+    scatterSize = n;
+    auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
+    Kokkos::parallel_for(policy, *this, "scatter_view_test: Prod");
+  }
 
-   void initialize(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        host_view(i, 0) = 0.0;
-        host_view(i, 1) = 0.0;
-        host_view(i, 2) = 0.0;
-      }
-      Kokkos::fence();
-      Kokkos::deep_copy(orig, host_view);
-   }
-
-   void run_parallel(int n) {
-        scatterSize = n;
-        auto policy = Kokkos::RangePolicy<ExecSpace, int>(0, n);
-        Kokkos::parallel_for(policy, *this, "scatter_view_test: Prod");
-   }
-
-   KOKKOS_INLINE_FUNCTION
-   void operator()(int i) const {
-      auto scatter_access = scatter_view.access();
-      auto scatter_access_atomic = scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
-      for (int j = 0; j < 4; ++j) {
-        auto k = (i + j) % scatterSize;
-        scatter_access(k, 0).update((double)(j+1)*4);
-        scatter_access_atomic(k, 1).update((double)(j+1)*2.0);
-        scatter_access(k, 2).update((double)(j+1)*1.0);
-      }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i) const {
+    auto scatter_access = scatter_view.access();
+    auto scatter_access_atomic =
+        scatter_view.template access<Kokkos::Experimental::ScatterAtomic>();
+    for (int j = 0; j < 4; ++j) {
+      auto k = (i + j) % scatterSize;
+      scatter_access(k, 0).update((double)(j + 1) * 4);
+      scatter_access_atomic(k, 1).update((double)(j + 1) * 2.0);
+      scatter_access(k, 2).update((double)(j + 1) * 1.0);
     }
+  }
 
-    void validateResults(orig_view_type orig) {
-      auto host_view = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
-      Kokkos::fence();
-      for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0); ++i) {
-        auto val0 = host_view(i, 0);
-        auto val1 = host_view(i, 1);
-        auto val2 = host_view(i, 2);
-        EXPECT_TRUE(std::fabs((val0 - 16.0) / 16.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val1 - 8.0) / 8.0) < 1e-14);
-        EXPECT_TRUE(std::fabs((val2 - 4.0) / 4.0) < 1e-14);
-      }
+  void validateResults(orig_view_type orig) {
+    auto host_view =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), orig);
+    Kokkos::fence();
+    for (typename decltype(host_view)::size_type i = 0; i < host_view.extent(0);
+         ++i) {
+      auto val0 = host_view(i, 0);
+      auto val1 = host_view(i, 1);
+      auto val2 = host_view(i, 2);
+      EXPECT_TRUE(std::fabs((val0 - 16.0) / 16.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val1 - 8.0) / 8.0) < 1e-14);
+      EXPECT_TRUE(std::fabs((val2 - 4.0) / 4.0) < 1e-14);
     }
+  }
 };
 
-
-
-template <typename ExecSpace, typename Layout, int duplication, int contribution, int op>
-struct test_scatter_view_config
-{
+template <typename ExecSpace, typename Layout, int duplication,
+          int contribution, int op>
+struct test_scatter_view_config {
  public:
-   typedef typename test_scatter_view_impl_cls<ExecSpace, Layout, 
-         duplication, contribution, op>::scatter_view_type scatter_view_def;
-   typedef typename test_scatter_view_impl_cls<ExecSpace, Layout, 
-         duplication, contribution, op>::orig_view_type orig_view_def;
-
-   test_scatter_view_config() {
-   }
-
-   void run_test(int n)
-   {
-     //Test creation via create_scatter_view
-     {
-     orig_view_def original_view("original_view", n);
-     scatter_view_def scatter_view = Kokkos::Experimental::create_scatter_view
-       < op
-       , duplication
-       , contribution
-       > (original_view);
-
-     test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution, op> scatter_view_test_impl(scatter_view);
-     scatter_view_test_impl.initialize(original_view);
-     scatter_view_test_impl.run_parallel(n);
-
-     Kokkos::Experimental::contribute(original_view, scatter_view);
-     scatter_view.reset_except(original_view);
-
-     scatter_view_test_impl.run_parallel(n);
-
-     Kokkos::Experimental::contribute(original_view, scatter_view);
-     Kokkos::fence();
+  typedef
+      typename test_scatter_view_impl_cls<ExecSpace, Layout, duplication,
+                                          contribution, op>::scatter_view_type
+          scatter_view_def;
+  typedef typename test_scatter_view_impl_cls<ExecSpace, Layout, duplication,
+                                              contribution, op>::orig_view_type
+      orig_view_def;
+
+  test_scatter_view_config() {}
+
+  void run_test(int n) {
+    // Test creation via create_scatter_view
+    {
+      orig_view_def original_view("original_view", n);
+      scatter_view_def scatter_view = Kokkos::Experimental::create_scatter_view<
+          op, duplication, contribution>(original_view);
+
+      test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution,
+                                 op>
+          scatter_view_test_impl(scatter_view);
+      scatter_view_test_impl.initialize(original_view);
+      scatter_view_test_impl.run_parallel(n);
+
+      Kokkos::Experimental::contribute(original_view, scatter_view);
+      scatter_view.reset_except(original_view);
+
+      scatter_view_test_impl.run_parallel(n);
+
+      Kokkos::Experimental::contribute(original_view, scatter_view);
+      Kokkos::fence();
 
-     scatter_view_test_impl.validateResults(original_view);
+      scatter_view_test_impl.validateResults(original_view);
 
-     {
+      {
         scatter_view_def persistent_view("persistent", n);
         auto result_view = persistent_view.subview();
         contribute(result_view, persistent_view);
         Kokkos::fence();
-     }
-     }
-     //Test creation via constructor
-     {
-     orig_view_def original_view("original_view", n);
-     scatter_view_def scatter_view(original_view);
+      }
+    }
+    // Test creation via constructor
+    {
+      orig_view_def original_view("original_view", n);
+      scatter_view_def scatter_view(original_view);
 
-     test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution, op> scatter_view_test_impl(scatter_view);
-     scatter_view_test_impl.initialize(original_view);
-     scatter_view_test_impl.run_parallel(n);
+      test_scatter_view_impl_cls<ExecSpace, Layout, duplication, contribution,
+                                 op>
+          scatter_view_test_impl(scatter_view);
+      scatter_view_test_impl.initialize(original_view);
+      scatter_view_test_impl.run_parallel(n);
 
-     Kokkos::Experimental::contribute(original_view, scatter_view);
-     scatter_view.reset_except(original_view);
+      Kokkos::Experimental::contribute(original_view, scatter_view);
+      scatter_view.reset_except(original_view);
 
-     scatter_view_test_impl.run_parallel(n);
+      scatter_view_test_impl.run_parallel(n);
 
-     Kokkos::Experimental::contribute(original_view, scatter_view);
-     Kokkos::fence();
+      Kokkos::Experimental::contribute(original_view, scatter_view);
+      Kokkos::fence();
 
-     scatter_view_test_impl.validateResults(original_view);
+      scatter_view_test_impl.validateResults(original_view);
 
-     {
+      {
         scatter_view_def persistent_view("persistent", n);
         auto result_view = persistent_view.subview();
         contribute(result_view, persistent_view);
         Kokkos::fence();
-     }
-     }
-   }
-
+      }
+    }
+  }
 };
 
-
 template <typename ExecSpace, int ScatterType>
 struct TestDuplicatedScatterView {
   TestDuplicatedScatterView(int n) {
     // ScatterSum test
-    test_scatter_view_config<ExecSpace, Kokkos::LayoutRight,
-      Kokkos::Experimental::ScatterDuplicated,
-      Kokkos::Experimental::ScatterNonAtomic,
-      ScatterType> test_sv_right_config;
+    test_scatter_view_config<
+        ExecSpace, Kokkos::LayoutRight, Kokkos::Experimental::ScatterDuplicated,
+        Kokkos::Experimental::ScatterNonAtomic, ScatterType>
+        test_sv_right_config;
     test_sv_right_config.run_test(n);
-    test_scatter_view_config<ExecSpace, Kokkos::LayoutLeft,
-      Kokkos::Experimental::ScatterDuplicated,
-      Kokkos::Experimental::ScatterNonAtomic,
-      ScatterType> test_sv_left_config;
+    test_scatter_view_config<
+        ExecSpace, Kokkos::LayoutLeft, Kokkos::Experimental::ScatterDuplicated,
+        Kokkos::Experimental::ScatterNonAtomic, ScatterType>
+        test_sv_left_config;
     test_sv_left_config.run_test(n);
   }
 };
@@ -429,8 +427,7 @@ struct TestDuplicatedScatterView {
 // UniqueToken can support it
 template <int ScatterType>
 struct TestDuplicatedScatterView<Kokkos::Cuda, ScatterType> {
-  TestDuplicatedScatterView(int) {
-  }
+  TestDuplicatedScatterView(int) {}
 };
 #endif
 
@@ -439,14 +436,12 @@ struct TestDuplicatedScatterView<Kokkos::Cuda, ScatterType> {
 // UniqueToken can support it
 template <int ScatterType>
 struct TestDuplicatedScatterView<Kokkos::Experimental::ROCm, ScatterType> {
-  TestDuplicatedScatterView(int) {
-  }
+  TestDuplicatedScatterView(int) {}
 };
 #endif
 
 template <typename ExecSpace, int ScatterType>
-void test_scatter_view(int n)
-{
+void test_scatter_view(int n) {
   // all of these configurations should compile okay, but only some of them are
   // correct and/or sensible in terms of memory use
   Kokkos::Experimental::UniqueToken<ExecSpace> unique_token{ExecSpace()};
@@ -456,33 +451,37 @@ void test_scatter_view(int n)
   // we also test OpenMP with one thread: LAMMPS cares about that)
   if (unique_token.size() == 1) {
     test_scatter_view_config<ExecSpace, Kokkos::LayoutRight,
-      Kokkos::Experimental::ScatterNonDuplicated,
-      Kokkos::Experimental::ScatterNonAtomic,
-      ScatterType> test_sv_config;
+                             Kokkos::Experimental::ScatterNonDuplicated,
+                             Kokkos::Experimental::ScatterNonAtomic,
+                             ScatterType>
+        test_sv_config;
     test_sv_config.run_test(n);
   }
 #ifdef KOKKOS_ENABLE_SERIAL
   if (!std::is_same<ExecSpace, Kokkos::Serial>::value) {
 #endif
-  test_scatter_view_config<ExecSpace, Kokkos::LayoutRight,
-    Kokkos::Experimental::ScatterNonDuplicated,
-    Kokkos::Experimental::ScatterAtomic,
-    ScatterType> test_sv_config;
-  test_sv_config.run_test(n);
+    test_scatter_view_config<ExecSpace, Kokkos::LayoutRight,
+                             Kokkos::Experimental::ScatterNonDuplicated,
+                             Kokkos::Experimental::ScatterAtomic, ScatterType>
+        test_sv_config;
+    test_sv_config.run_test(n);
 #ifdef KOKKOS_ENABLE_SERIAL
   }
 #endif
   // with hundreds of threads we were running out of memory.
   // limit (n) so that duplication doesn't exceed 8GB
-  constexpr std::size_t maximum_allowed_total_bytes = 8ull * 1024ull * 1024ull * 1024ull;
-  std::size_t const maximum_allowed_copy_bytes = maximum_allowed_total_bytes / std::size_t(unique_token.size());
+  constexpr std::size_t maximum_allowed_total_bytes =
+      8ull * 1024ull * 1024ull * 1024ull;
+  std::size_t const maximum_allowed_copy_bytes =
+      maximum_allowed_total_bytes / std::size_t(unique_token.size());
   constexpr std::size_t bytes_per_value = sizeof(double) * 3;
-  std::size_t const maximum_allowed_copy_values = maximum_allowed_copy_bytes / bytes_per_value;
+  std::size_t const maximum_allowed_copy_values =
+      maximum_allowed_copy_bytes / bytes_per_value;
   n = std::min(n, int(maximum_allowed_copy_values));
   TestDuplicatedScatterView<ExecSpace, ScatterType> duptest(n);
 }
 
-TEST_F( TEST_CATEGORY, scatterview) {
+TEST(TEST_CATEGORY, scatterview) {
 #ifndef KOKKOS_ENABLE_ROCM
   test_scatter_view<TEST_EXECSPACE, Kokkos::Experimental::ScatterSum>(10);
   test_scatter_view<TEST_EXECSPACE, Kokkos::Experimental::ScatterProd>(10);
@@ -492,17 +491,22 @@ TEST_F( TEST_CATEGORY, scatterview) {
 #ifdef KOKKOS_ENABLE_DEBUG
   int big_n = 100 * 1000;
 #else
-  int big_n = 10 * 1000 * 1000;
+
+#ifdef KOKKOS_ENABLE_SERIAL
+  bool is_serial = std::is_same<TEST_EXECSPACE, Kokkos::Serial>::value;
+  int big_n      = is_serial ? 100 * 1000 : 10000 * 1000;
+#else
+  int big_n = 10000 * 1000;
+#endif
+
 #endif
-  test_scatter_view<TEST_EXECSPACE,Kokkos::Experimental::ScatterSum>(big_n);
-  test_scatter_view<TEST_EXECSPACE,Kokkos::Experimental::ScatterProd>(big_n);
-  test_scatter_view<TEST_EXECSPACE,Kokkos::Experimental::ScatterMin>(big_n);
-  test_scatter_view<TEST_EXECSPACE,Kokkos::Experimental::ScatterMax>(big_n);
+  test_scatter_view<TEST_EXECSPACE, Kokkos::Experimental::ScatterSum>(big_n);
+  test_scatter_view<TEST_EXECSPACE, Kokkos::Experimental::ScatterProd>(big_n);
+  test_scatter_view<TEST_EXECSPACE, Kokkos::Experimental::ScatterMin>(big_n);
+  test_scatter_view<TEST_EXECSPACE, Kokkos::Experimental::ScatterMax>(big_n);
 #endif
 }
 
-} // namespace Test
-
-#endif //KOKKOS_TEST_UNORDERED_MAP_HPP
-
+}  // namespace Test
 
+#endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
diff --git a/lib/kokkos/containers/unit_tests/TestStaticCrsGraph.hpp b/lib/kokkos/containers/unit_tests/TestStaticCrsGraph.hpp
index 7ba307079f62b5f5ff9037e828923a1ad596cb77..15c190242c768577251f8e49b9ebd2f734b578c9 100644
--- a/lib/kokkos/containers/unit_tests/TestStaticCrsGraph.hpp
+++ b/lib/kokkos/containers/unit_tests/TestStaticCrsGraph.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,233 +53,244 @@
 namespace Test {
 namespace TestStaticCrsGraph {
 
-template< class Space >
-void run_test_graph()
-{
-  typedef Kokkos::StaticCrsGraph< unsigned , Space > dView ;
-  typedef typename dView::HostMirror hView ;
+template <class Space>
+void run_test_graph() {
+  typedef Kokkos::StaticCrsGraph<unsigned, Space> dView;
+  typedef typename dView::HostMirror hView;
 
-  const unsigned LENGTH = 1000 ;
-  dView dx ;
-  hView hx ;
+  const unsigned LENGTH = 1000;
+  dView dx;
+  hView hx;
 
-  std::vector< std::vector< int > > graph( LENGTH );
+  std::vector<std::vector<int> > graph(LENGTH);
 
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
+  for (size_t i = 0; i < LENGTH; ++i) {
     graph[i].reserve(8);
-    for ( size_t j = 0 ; j < 8 ; ++j ) {
-      graph[i].push_back( i + j * 3 );
+    for (size_t j = 0; j < 8; ++j) {
+      graph[i].push_back(i + j * 3);
     }
   }
 
-  dx = Kokkos::create_staticcrsgraph<dView>( "dx" , graph );
-  hx = Kokkos::create_mirror( dx );
+  dx = Kokkos::create_staticcrsgraph<dView>("dx", graph);
+  hx = Kokkos::create_mirror(dx);
 
-  ASSERT_EQ( hx.row_map.extent(0) - 1 , LENGTH );
+  ASSERT_EQ(hx.row_map.extent(0) - 1, LENGTH);
 
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
+  for (size_t i = 0; i < LENGTH; ++i) {
     const size_t begin = hx.row_map[i];
-    const size_t n = hx.row_map[i+1] - begin ;
-    ASSERT_EQ( n , graph[i].size() );
-    for ( size_t j = 0 ; j < n ; ++j ) {
-      ASSERT_EQ( (int) hx.entries( j + begin ) , graph[i][j] );
+    const size_t n     = hx.row_map[i + 1] - begin;
+    ASSERT_EQ(n, graph[i].size());
+    for (size_t j = 0; j < n; ++j) {
+      ASSERT_EQ((int)hx.entries(j + begin), graph[i][j]);
     }
   }
 
   // Test row view access
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
+  for (size_t i = 0; i < LENGTH; ++i) {
     auto rowView = hx.rowConst(i);
-    ASSERT_EQ( rowView.length, graph[i].size() );
-    for ( size_t j = 0 ; j < rowView.length ; ++j ) {
-      ASSERT_EQ( rowView.colidx( j ) , graph[i][j] );
-      ASSERT_EQ( rowView( j )        , graph[i][j] );
+    ASSERT_EQ(rowView.length, graph[i].size());
+    for (size_t j = 0; j < rowView.length; ++j) {
+      ASSERT_EQ(rowView.colidx(j), graph[i][j]);
+      ASSERT_EQ(rowView(j), graph[i][j]);
     }
   }
 }
 
-template< class Space >
-void run_test_graph2()
-{
-  typedef Kokkos::StaticCrsGraph< unsigned[3] , Space > dView ;
-  typedef typename dView::HostMirror hView ;
+template <class Space>
+void run_test_graph2() {
+  typedef Kokkos::StaticCrsGraph<unsigned[3], Space> dView;
+  typedef typename dView::HostMirror hView;
 
-  const unsigned LENGTH = 10 ;
+  const unsigned LENGTH = 10;
 
-  std::vector< size_t > sizes( LENGTH );
+  std::vector<size_t> sizes(LENGTH);
 
-  size_t total_length = 0 ;
+  size_t total_length = 0;
 
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
-    total_length += ( sizes[i] = 6 + i % 4 );
+  for (size_t i = 0; i < LENGTH; ++i) {
+    total_length += (sizes[i] = 6 + i % 4);
   }
 
-  dView dx = Kokkos::create_staticcrsgraph<dView>( "test" , sizes );
-  hView hx = Kokkos::create_mirror( dx );
-  hView mx = Kokkos::create_mirror( dx );
+  dView dx = Kokkos::create_staticcrsgraph<dView>("test", sizes);
+  hView hx = Kokkos::create_mirror(dx);
+  hView mx = Kokkos::create_mirror(dx);
 
-  ASSERT_EQ( (size_t) dx.row_map.extent(0) , (size_t) LENGTH + 1 );
-  ASSERT_EQ( (size_t) hx.row_map.extent(0) , (size_t) LENGTH + 1 );
-  ASSERT_EQ( (size_t) mx.row_map.extent(0) , (size_t) LENGTH + 1 );
+  ASSERT_EQ((size_t)dx.row_map.extent(0), (size_t)LENGTH + 1);
+  ASSERT_EQ((size_t)hx.row_map.extent(0), (size_t)LENGTH + 1);
+  ASSERT_EQ((size_t)mx.row_map.extent(0), (size_t)LENGTH + 1);
 
-  ASSERT_EQ( (size_t) dx.entries.extent(0) , (size_t) total_length );
-  ASSERT_EQ( (size_t) hx.entries.extent(0) , (size_t) total_length );
-  ASSERT_EQ( (size_t) mx.entries.extent(0) , (size_t) total_length );
+  ASSERT_EQ((size_t)dx.entries.extent(0), (size_t)total_length);
+  ASSERT_EQ((size_t)hx.entries.extent(0), (size_t)total_length);
+  ASSERT_EQ((size_t)mx.entries.extent(0), (size_t)total_length);
 
-  ASSERT_EQ( (size_t) dx.entries.extent(1) , (size_t) 3 );
-  ASSERT_EQ( (size_t) hx.entries.extent(1) , (size_t) 3 );
-  ASSERT_EQ( (size_t) mx.entries.extent(1) , (size_t) 3 );
+  ASSERT_EQ((size_t)dx.entries.extent(1), (size_t)3);
+  ASSERT_EQ((size_t)hx.entries.extent(1), (size_t)3);
+  ASSERT_EQ((size_t)mx.entries.extent(1), (size_t)3);
 
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
+  for (size_t i = 0; i < LENGTH; ++i) {
     const size_t entry_begin = hx.row_map[i];
-    const size_t entry_end   = hx.row_map[i+1];
-    for ( size_t j = entry_begin ; j < entry_end ; ++j ) {
-      hx.entries(j,0) = j + 1 ;
-      hx.entries(j,1) = j + 2 ;
-      hx.entries(j,2) = j + 3 ;
+    const size_t entry_end   = hx.row_map[i + 1];
+    for (size_t j = entry_begin; j < entry_end; ++j) {
+      hx.entries(j, 0) = j + 1;
+      hx.entries(j, 1) = j + 2;
+      hx.entries(j, 2) = j + 3;
     }
   }
 
-  Kokkos::deep_copy( dx.entries , hx.entries );
-  Kokkos::deep_copy( mx.entries , dx.entries );
+  Kokkos::deep_copy(dx.entries, hx.entries);
+  Kokkos::deep_copy(mx.entries, dx.entries);
 
-  ASSERT_EQ( mx.row_map.extent(0) , (size_t) LENGTH + 1 );
+  ASSERT_EQ(mx.row_map.extent(0), (size_t)LENGTH + 1);
 
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
+  for (size_t i = 0; i < LENGTH; ++i) {
     const size_t entry_begin = mx.row_map[i];
-    const size_t entry_end   = mx.row_map[i+1];
-    ASSERT_EQ( ( entry_end - entry_begin ) , sizes[i] );
-    for ( size_t j = entry_begin ; j < entry_end ; ++j ) {
-      ASSERT_EQ( (size_t) mx.entries( j , 0 ) , ( j + 1 ) );
-      ASSERT_EQ( (size_t) mx.entries( j , 1 ) , ( j + 2 ) );
-      ASSERT_EQ( (size_t) mx.entries( j , 2 ) , ( j + 3 ) );
+    const size_t entry_end   = mx.row_map[i + 1];
+    ASSERT_EQ((entry_end - entry_begin), sizes[i]);
+    for (size_t j = entry_begin; j < entry_end; ++j) {
+      ASSERT_EQ((size_t)mx.entries(j, 0), (j + 1));
+      ASSERT_EQ((size_t)mx.entries(j, 1), (j + 2));
+      ASSERT_EQ((size_t)mx.entries(j, 2), (j + 3));
     }
   }
 }
 
-template< class Space >
-void run_test_graph3(size_t B, size_t N)
-{
+template <class Space>
+void run_test_graph3(size_t B, size_t N) {
   srand(10310);
 
-  typedef Kokkos::StaticCrsGraph< int , Space > dView ;
-  typedef typename dView::HostMirror hView ;
+  typedef Kokkos::StaticCrsGraph<int, Space> dView;
+  typedef typename dView::HostMirror hView;
 
-  const unsigned LENGTH = 2000 ;
+  const unsigned LENGTH = 2000;
 
-  std::vector< size_t > sizes( LENGTH );
+  std::vector<size_t> sizes(LENGTH);
 
-  size_t total_length = 0 ;
+  size_t total_length = 0;
 
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
-    sizes[i] = rand()%1000;
+  for (size_t i = 0; i < LENGTH; ++i) {
+    sizes[i] = rand() % 1000;
   }
 
-  sizes[1] = N;
+  sizes[1]    = N;
   sizes[1998] = N;
 
-  for ( size_t i = 0 ; i < LENGTH ; ++i ) {
+  for (size_t i = 0; i < LENGTH; ++i) {
     total_length += sizes[i];
   }
 
-  int C = 0;
-  dView dx = Kokkos::create_staticcrsgraph<dView>( "test" , sizes );
-  dx.create_block_partitioning(B,C);
-  hView hx = Kokkos::create_mirror( dx );
+  int C    = 0;
+  dView dx = Kokkos::create_staticcrsgraph<dView>("test", sizes);
+  dx.create_block_partitioning(B, C);
+  hView hx = Kokkos::create_mirror(dx);
 
-  for( size_t i = 0; i<B; i++) {
+  for (size_t i = 0; i < B; i++) {
     size_t ne = 0;
-    for(size_t j = hx.row_block_offsets(i); j<hx.row_block_offsets(i+1); j++)
-      ne += hx.row_map(j+1)-hx.row_map(j)+C;
+    for (size_t j = hx.row_block_offsets(i); j < hx.row_block_offsets(i + 1);
+         j++)
+      ne += hx.row_map(j + 1) - hx.row_map(j) + C;
 
-    ASSERT_FALSE((ne>2*((hx.row_map(hx.numRows())+C*hx.numRows())/B))&&(hx.row_block_offsets(i+1)>hx.row_block_offsets(i)+1));
+    ASSERT_FALSE(
+        (ne > 2 * ((hx.row_map(hx.numRows()) + C * hx.numRows()) / B)) &&
+        (hx.row_block_offsets(i + 1) > hx.row_block_offsets(i) + 1));
   }
 }
 
-template< class Space >
-void run_test_graph4()
-{
+template <class Space>
+void run_test_graph4() {
   typedef unsigned ordinal_type;
   typedef Kokkos::LayoutRight layout_type;
   typedef Space space_type;
   typedef Kokkos::MemoryUnmanaged memory_traits_type;
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  typedef Kokkos::StaticCrsGraph< ordinal_type , layout_type , space_type , ordinal_type , memory_traits_type > dView ;
+  typedef Kokkos::StaticCrsGraph<ordinal_type, layout_type, space_type,
+                                 ordinal_type, memory_traits_type>
+      dView;
 #else
-  typedef Kokkos::StaticCrsGraph< ordinal_type , layout_type , space_type , memory_traits_type > dView ;
+  typedef Kokkos::StaticCrsGraph<ordinal_type, layout_type, space_type,
+                                 memory_traits_type>
+      dView;
 #endif
-  typedef typename dView::HostMirror hView ;
+  typedef typename dView::HostMirror hView;
 
-  dView dx ;
+  dView dx;
 
-  // StaticCrsGraph with Unmanaged trait will contain row_map and entries members
-  // with the Unmanaged memory trait.
-  // Use of such a StaticCrsGraph requires an allocaton of memory for the unmanaged views
-  // to wrap.
+  // StaticCrsGraph with Unmanaged trait will contain row_map and entries
+  // members with the Unmanaged memory trait. Use of such a StaticCrsGraph
+  // requires an allocaton of memory for the unmanaged views to wrap.
   //
   // In this test, a graph (via raw arrays) resides on the host.
-  // The pointers are wrapped by unmanaged Views. 
-  // To make use of this on the device, managed device Views are created (allocation required),
-  // and data from the unmanaged host views is deep copied to the device Views
-  // Unmanaged views of the appropriate type wrap the device data and are assigned to
-  // their corresponding unmanaged view members of the unmanaged StaticCrsGraph
+  // The pointers are wrapped by unmanaged Views.
+  // To make use of this on the device, managed device Views are created
+  // (allocation required), and data from the unmanaged host views is deep
+  // copied to the device Views Unmanaged views of the appropriate type wrap the
+  // device data and are assigned to their corresponding unmanaged view members
+  // of the unmanaged StaticCrsGraph
 
   // Data types for raw pointers storing StaticCrsGraph info
   typedef typename dView::size_type ptr_row_map_type;
   typedef typename dView::data_type ptr_entries_type;
 
   const ordinal_type numRows = 8;
-  const ordinal_type nnz = 24;
-  ptr_row_map_type ptrRaw[] = {0, 4, 8, 10, 12, 14, 16, 20, 24};
-  ptr_entries_type indRaw[] = {0, 1, 4, 5, 0, 1, 4, 5, 2, 3, 2, 3, 4, 5, 4, 5, 2, 3, 6, 7, 2, 3, 6, 7};
+  const ordinal_type nnz     = 24;
+  ptr_row_map_type ptrRaw[]  = {0, 4, 8, 10, 12, 14, 16, 20, 24};
+  ptr_entries_type indRaw[]  = {0, 1, 4, 5, 0, 1, 4, 5, 2, 3, 2, 3,
+                               4, 5, 4, 5, 2, 3, 6, 7, 2, 3, 6, 7};
 
   // Wrap pointers in unmanaged host views
-  typedef typename hView::row_map_type local_row_map_type ;
-  typedef typename hView::entries_type local_entries_type ;
-  local_row_map_type unman_row_map( &(ptrRaw[0]) , numRows+1 );
-  local_entries_type unman_entries( &(indRaw[0]) , nnz );
+  typedef typename hView::row_map_type local_row_map_type;
+  typedef typename hView::entries_type local_entries_type;
+  local_row_map_type unman_row_map(&(ptrRaw[0]), numRows + 1);
+  local_entries_type unman_entries(&(indRaw[0]), nnz);
 
-  hView hx ;
-  hx = hView( unman_entries, unman_row_map );
+  hView hx;
+  hx = hView(unman_entries, unman_row_map);
 
   // Create the device Views for copying the host arrays into
-  // An allocation is needed on the device for the unmanaged StaticCrsGraph to wrap the pointer
-  typedef typename Kokkos::View< ptr_row_map_type*, layout_type, space_type > d_row_map_view_type;
-  typedef typename Kokkos::View< ptr_entries_type*, layout_type, space_type > d_entries_view_type;
-
-  d_row_map_view_type tmp_row_map( "tmp_row_map", numRows+1 );
-  d_entries_view_type tmp_entries( "tmp_entries", nnz );
-
-  Kokkos::deep_copy (tmp_row_map, unman_row_map);
-  Kokkos::deep_copy (tmp_entries, unman_entries);
-
-  // Wrap the pointer in unmanaged View and assign to the corresponding StaticCrsGraph member
-  dx.row_map = typename dView::row_map_type(tmp_row_map.data(), numRows+1);
+  // An allocation is needed on the device for the unmanaged StaticCrsGraph to
+  // wrap the pointer
+  typedef typename Kokkos::View<ptr_row_map_type*, layout_type, space_type>
+      d_row_map_view_type;
+  typedef typename Kokkos::View<ptr_entries_type*, layout_type, space_type>
+      d_entries_view_type;
+
+  d_row_map_view_type tmp_row_map("tmp_row_map", numRows + 1);
+  d_entries_view_type tmp_entries("tmp_entries", nnz);
+
+  Kokkos::deep_copy(tmp_row_map, unman_row_map);
+  Kokkos::deep_copy(tmp_entries, unman_entries);
+
+  // Wrap the pointer in unmanaged View and assign to the corresponding
+  // StaticCrsGraph member
+  dx.row_map = typename dView::row_map_type(tmp_row_map.data(), numRows + 1);
   dx.entries = typename dView::entries_type(tmp_entries.data(), nnz);
 
-  ASSERT_TRUE((std::is_same< typename dView::row_map_type::memory_traits , Kokkos::MemoryUnmanaged >::value));
-  ASSERT_TRUE((std::is_same< typename dView::entries_type::memory_traits , Kokkos::MemoryUnmanaged >::value));
-  ASSERT_TRUE((std::is_same< typename hView::row_map_type::memory_traits , Kokkos::MemoryUnmanaged >::value));
-  ASSERT_TRUE((std::is_same< typename hView::entries_type::memory_traits , Kokkos::MemoryUnmanaged >::value));
+  ASSERT_TRUE((std::is_same<typename dView::row_map_type::memory_traits,
+                            Kokkos::MemoryUnmanaged>::value));
+  ASSERT_TRUE((std::is_same<typename dView::entries_type::memory_traits,
+                            Kokkos::MemoryUnmanaged>::value));
+  ASSERT_TRUE((std::is_same<typename hView::row_map_type::memory_traits,
+                            Kokkos::MemoryUnmanaged>::value));
+  ASSERT_TRUE((std::is_same<typename hView::entries_type::memory_traits,
+                            Kokkos::MemoryUnmanaged>::value));
 }
 
 } /* namespace TestStaticCrsGraph */
 
-TEST_F( TEST_CATEGORY , staticcrsgraph )
-{
-  TestStaticCrsGraph::run_test_graph< TEST_EXECSPACE >();
-  TestStaticCrsGraph::run_test_graph2< TEST_EXECSPACE >();
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(1, 0);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(1, 1000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(1, 10000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(1, 100000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(3, 0);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(3, 1000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(3, 10000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(3, 100000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(75, 0);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(75, 1000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(75, 10000);
-  TestStaticCrsGraph::run_test_graph3< TEST_EXECSPACE >(75, 100000);
-  TestStaticCrsGraph::run_test_graph4< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, staticcrsgraph) {
+  TestStaticCrsGraph::run_test_graph<TEST_EXECSPACE>();
+  TestStaticCrsGraph::run_test_graph2<TEST_EXECSPACE>();
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(1, 0);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(1, 1000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(1, 10000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(1, 100000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(3, 0);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(3, 1000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(3, 10000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(3, 100000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(75, 0);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(75, 1000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(75, 10000);
+  TestStaticCrsGraph::run_test_graph3<TEST_EXECSPACE>(75, 100000);
+  TestStaticCrsGraph::run_test_graph4<TEST_EXECSPACE>();
 }
+}  // namespace Test
diff --git a/lib/kokkos/containers/unit_tests/TestUnorderedMap.hpp b/lib/kokkos/containers/unit_tests/TestUnorderedMap.hpp
index 2d34267df308947f304e930f70e695370940a01b..82782d3bf43b27cf3e63ea56435c305bf6a4ebd9 100644
--- a/lib/kokkos/containers/unit_tests/TestUnorderedMap.hpp
+++ b/lib/kokkos/containers/unit_tests/TestUnorderedMap.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,8 +52,7 @@ namespace Test {
 namespace Impl {
 
 template <typename MapType, bool Near = false>
-struct TestInsert
-{
+struct TestInsert {
   typedef MapType map_type;
   typedef typename map_type::execution_space execution_space;
   typedef uint32_t value_type;
@@ -61,14 +61,10 @@ struct TestInsert
   uint32_t inserts;
   uint32_t collisions;
 
-  TestInsert( map_type arg_map, uint32_t arg_inserts, uint32_t arg_collisions)
-    : map(arg_map)
-    , inserts(arg_inserts)
-    , collisions(arg_collisions)
-  {}
+  TestInsert(map_type arg_map, uint32_t arg_inserts, uint32_t arg_collisions)
+      : map(arg_map), inserts(arg_inserts), collisions(arg_collisions) {}
 
-  void testit( bool rehash_on_fail = true )
-  {
+  void testit(bool rehash_on_fail = true) {
     execution_space().fence();
 
     uint32_t failed_count = 0;
@@ -77,138 +73,127 @@ struct TestInsert
       Kokkos::parallel_reduce(inserts, *this, failed_count);
 
       if (rehash_on_fail && failed_count > 0u) {
-        const uint32_t new_capacity = map.capacity() + ((map.capacity()*3ull)/20u) + failed_count/collisions ;
-        map.rehash( new_capacity );
+        const uint32_t new_capacity = map.capacity() +
+                                      ((map.capacity() * 3ull) / 20u) +
+                                      failed_count / collisions;
+        map.rehash(new_capacity);
       }
     } while (rehash_on_fail && failed_count > 0u);
 
     execution_space().fence();
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & failed_count ) const { failed_count = 0; }
+  void init(value_type &failed_count) const { failed_count = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & failed_count, const volatile value_type & count ) const
-  { failed_count += count; }
+  void join(volatile value_type &failed_count,
+            const volatile value_type &count) const {
+    failed_count += count;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(uint32_t i, value_type & failed_count) const
-  {
-    const uint32_t key = Near ? i/collisions : i%(inserts/collisions);
-    if (map.insert(key,i).failed()) ++failed_count;
+  void operator()(uint32_t i, value_type &failed_count) const {
+    const uint32_t key = Near ? i / collisions : i % (inserts / collisions);
+    if (map.insert(key, i).failed()) ++failed_count;
   }
-
 };
 
-  template <typename MapType, bool Near>
-  struct TestErase
-  {
-    typedef TestErase<MapType, Near> self_type;
+template <typename MapType, bool Near>
+struct TestErase {
+  typedef TestErase<MapType, Near> self_type;
 
-    typedef MapType map_type;
-    typedef typename MapType::execution_space execution_space;
+  typedef MapType map_type;
+  typedef typename MapType::execution_space execution_space;
 
-    map_type m_map;
-    uint32_t m_num_erase;
-    uint32_t m_num_duplicates;
+  map_type m_map;
+  uint32_t m_num_erase;
+  uint32_t m_num_duplicates;
 
-    TestErase(map_type map, uint32_t num_erases, uint32_t num_duplicates)
-      : m_map(map)
-      , m_num_erase(num_erases)
-      , m_num_duplicates(num_duplicates)
-    {}
+  TestErase(map_type map, uint32_t num_erases, uint32_t num_duplicates)
+      : m_map(map), m_num_erase(num_erases), m_num_duplicates(num_duplicates) {}
 
-    void testit()
-    {
-      execution_space().fence();
-      Kokkos::parallel_for(m_num_erase, *this);
-      execution_space().fence();
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(typename execution_space::size_type i) const
-    {
-      if (Near) {
-        m_map.erase(i/m_num_duplicates);
-      }
-      else {
-        m_map.erase(i%(m_num_erase/m_num_duplicates));
-      }
+  void testit() {
+    execution_space().fence();
+    Kokkos::parallel_for(m_num_erase, *this);
+    execution_space().fence();
+  }
 
+  KOKKOS_INLINE_FUNCTION
+  void operator()(typename execution_space::size_type i) const {
+    if (Near) {
+      m_map.erase(i / m_num_duplicates);
+    } else {
+      m_map.erase(i % (m_num_erase / m_num_duplicates));
     }
-  };
+  }
+};
 
-  template <typename MapType>
-  struct TestFind
-  {
-    typedef MapType map_type;
-    typedef typename MapType::execution_space::execution_space execution_space;
-    typedef uint32_t value_type;
-
-    map_type m_map;
-    uint32_t m_num_insert;
-    uint32_t m_num_duplicates;
-    uint32_t m_max_key;
-
-    TestFind(map_type map, uint32_t num_inserts, uint32_t num_duplicates)
-      : m_map(map)
-      , m_num_insert(num_inserts)
-      , m_num_duplicates(num_duplicates)
-      , m_max_key( ((num_inserts + num_duplicates) - 1)/num_duplicates )
-    {}
-
-    void testit(value_type &errors)
-    {
-      execution_space().fence();
-      Kokkos::parallel_reduce(m_map.capacity(), *this, errors);
-      execution_space().fence();
-    }
+template <typename MapType>
+struct TestFind {
+  typedef MapType map_type;
+  typedef typename MapType::execution_space::execution_space execution_space;
+  typedef uint32_t value_type;
 
-    KOKKOS_INLINE_FUNCTION
-    static void init( value_type & dst)
-    {
-      dst = 0;
-    }
+  map_type m_map;
+  uint32_t m_num_insert;
+  uint32_t m_num_duplicates;
+  uint32_t m_max_key;
 
-    KOKKOS_INLINE_FUNCTION
-    static void join( volatile value_type & dst, const volatile value_type & src)
-    { dst += src; }
+  TestFind(map_type map, uint32_t num_inserts, uint32_t num_duplicates)
+      : m_map(map),
+        m_num_insert(num_inserts),
+        m_num_duplicates(num_duplicates),
+        m_max_key(((num_inserts + num_duplicates) - 1) / num_duplicates) {}
 
-    KOKKOS_INLINE_FUNCTION
-    void operator()(typename execution_space::size_type i, value_type & errors) const
-    {
-      const bool expect_to_find_i = (i < m_max_key);
+  void testit(value_type &errors) {
+    execution_space().fence();
+    Kokkos::parallel_reduce(m_map.capacity(), *this, errors);
+    execution_space().fence();
+  }
 
-      const bool exists = m_map.exists(i);
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type &dst) { dst = 0; }
 
-      if (expect_to_find_i && !exists)  ++errors;
-      if (!expect_to_find_i && exists)  ++errors;
-    }
-  };
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type &dst, const volatile value_type &src) {
+    dst += src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(typename execution_space::size_type i,
+                  value_type &errors) const {
+    const bool expect_to_find_i = (i < m_max_key);
 
-} // namespace Impl
+    const bool exists = m_map.exists(i);
 
+    if (expect_to_find_i && !exists) ++errors;
+    if (!expect_to_find_i && exists) ++errors;
+  }
+};
 
+}  // namespace Impl
 
 template <typename Device>
-void test_insert( uint32_t num_nodes , uint32_t num_inserts , uint32_t num_duplicates , bool near )
-{
-  typedef Kokkos::UnorderedMap<uint32_t,uint32_t, Device> map_type;
-  typedef Kokkos::UnorderedMap<const uint32_t,const uint32_t, Device> const_map_type;
+void test_insert(uint32_t num_nodes, uint32_t num_inserts,
+                 uint32_t num_duplicates, bool near) {
+  typedef Kokkos::UnorderedMap<uint32_t, uint32_t, Device> map_type;
+  typedef Kokkos::UnorderedMap<const uint32_t, const uint32_t, Device>
+      const_map_type;
 
-  const uint32_t expected_inserts = (num_inserts + num_duplicates -1u) / num_duplicates;
+  const uint32_t expected_inserts =
+      (num_inserts + num_duplicates - 1u) / num_duplicates;
 
   map_type map;
-  map.rehash(num_nodes,false);
+  map.rehash(num_nodes, false);
 
   if (near) {
-    Impl::TestInsert<map_type,true> test_insert(map, num_inserts, num_duplicates);
+    Impl::TestInsert<map_type, true> test_insert(map, num_inserts,
+                                                 num_duplicates);
     test_insert.testit();
-  } else
-  {
-    Impl::TestInsert<map_type,false> test_insert(map, num_inserts, num_duplicates);
+  } else {
+    Impl::TestInsert<map_type, false> test_insert(map, num_inserts,
+                                                  num_duplicates);
     test_insert.testit();
   }
 
@@ -220,19 +205,21 @@ void test_insert( uint32_t num_nodes , uint32_t num_inserts , uint32_t num_dupli
 
   const uint32_t map_size = map.size();
 
-  ASSERT_FALSE( map.failed_insert());
+  ASSERT_FALSE(map.failed_insert());
   {
     EXPECT_EQ(expected_inserts, map_size);
 
     {
       uint32_t find_errors = 0;
-      Impl::TestFind<const_map_type> test_find(map, num_inserts, num_duplicates);
+      Impl::TestFind<const_map_type> test_find(map, num_inserts,
+                                               num_duplicates);
       test_find.testit(find_errors);
-      EXPECT_EQ( 0u, find_errors);
+      EXPECT_EQ(0u, find_errors);
     }
 
     map.begin_erase();
-    Impl::TestErase<map_type,false> test_erase(map, num_inserts, num_duplicates);
+    Impl::TestErase<map_type, false> test_erase(map, num_inserts,
+                                                num_duplicates);
     test_erase.testit();
     map.end_erase();
     EXPECT_EQ(0u, map.size());
@@ -240,56 +227,53 @@ void test_insert( uint32_t num_nodes , uint32_t num_inserts , uint32_t num_dupli
 }
 
 template <typename Device>
-void test_failed_insert( uint32_t num_nodes)
-{
-  typedef Kokkos::UnorderedMap<uint32_t,uint32_t, Device> map_type;
+void test_failed_insert(uint32_t num_nodes) {
+  typedef Kokkos::UnorderedMap<uint32_t, uint32_t, Device> map_type;
 
   map_type map(num_nodes);
-  Impl::TestInsert<map_type> test_insert(map, 2u*num_nodes, 1u);
+  Impl::TestInsert<map_type> test_insert(map, 2u * num_nodes, 1u);
   test_insert.testit(false /*don't rehash on fail*/);
   typename Device::execution_space().fence();
 
-  EXPECT_TRUE( map.failed_insert() );
+  EXPECT_TRUE(map.failed_insert());
 }
 
-
-
 template <typename Device>
-void test_deep_copy( uint32_t num_nodes )
-{
-  typedef Kokkos::UnorderedMap<uint32_t,uint32_t, Device> map_type;
-  typedef Kokkos::UnorderedMap<const uint32_t, const uint32_t, Device> const_map_type;
+void test_deep_copy(uint32_t num_nodes) {
+  typedef Kokkos::UnorderedMap<uint32_t, uint32_t, Device> map_type;
+  typedef Kokkos::UnorderedMap<const uint32_t, const uint32_t, Device>
+      const_map_type;
 
-  typedef typename map_type::HostMirror host_map_type ;
-  // typedef Kokkos::UnorderedMap<uint32_t, uint32_t, typename Device::host_mirror_execution_space > host_map_type;
+  typedef typename map_type::HostMirror host_map_type;
+  // typedef Kokkos::UnorderedMap<uint32_t, uint32_t, typename
+  // Device::host_mirror_execution_space > host_map_type;
 
   map_type map;
-  map.rehash(num_nodes,false);
+  map.rehash(num_nodes, false);
 
   {
     Impl::TestInsert<map_type> test_insert(map, num_nodes, 1);
     test_insert.testit();
-    ASSERT_EQ( map.size(), num_nodes);
-    ASSERT_FALSE( map.failed_insert() );
+    ASSERT_EQ(map.size(), num_nodes);
+    ASSERT_FALSE(map.failed_insert());
     {
       uint32_t find_errors = 0;
       Impl::TestFind<map_type> test_find(map, num_nodes, 1);
       test_find.testit(find_errors);
-      EXPECT_EQ( find_errors, 0u);
+      EXPECT_EQ(find_errors, 0u);
     }
-
   }
 
   host_map_type hmap;
   Kokkos::deep_copy(hmap, map);
 
-  ASSERT_EQ( map.size(), hmap.size());
-  ASSERT_EQ( map.capacity(), hmap.capacity());
+  ASSERT_EQ(map.size(), hmap.size());
+  ASSERT_EQ(map.capacity(), hmap.capacity());
   {
     uint32_t find_errors = 0;
     Impl::TestFind<host_map_type> test_find(hmap, num_nodes, 1);
     test_find.testit(find_errors);
-    EXPECT_EQ( find_errors, 0u);
+    EXPECT_EQ(find_errors, 0u);
   }
 
   map_type mmap;
@@ -297,35 +281,31 @@ void test_deep_copy( uint32_t num_nodes )
 
   const_map_type cmap = mmap;
 
-  EXPECT_EQ( cmap.size(), num_nodes);
+  EXPECT_EQ(cmap.size(), num_nodes);
 
   {
     uint32_t find_errors = 0;
     Impl::TestFind<const_map_type> test_find(cmap, num_nodes, 1);
     test_find.testit(find_errors);
-    EXPECT_EQ( find_errors, 0u);
+    EXPECT_EQ(find_errors, 0u);
   }
-
 }
 
-TEST_F( TEST_CATEGORY, UnorderedMap_insert) {
-  for (int i=0; i<500; ++i) {
+TEST(TEST_CATEGORY, UnorderedMap_insert) {
+  for (int i = 0; i < 500; ++i) {
     test_insert<TEST_EXECSPACE>(100000, 90000, 100, true);
     test_insert<TEST_EXECSPACE>(100000, 90000, 100, false);
   }
 }
 
-TEST_F( TEST_CATEGORY, UnorderedMap_failed_insert) {
-  for (int i=0; i<1000; ++i)
-    test_failed_insert<TEST_EXECSPACE>(10000);
+TEST(TEST_CATEGORY, UnorderedMap_failed_insert) {
+  for (int i = 0; i < 1000; ++i) test_failed_insert<TEST_EXECSPACE>(10000);
 }
 
-TEST_F( TEST_CATEGORY, UnorderedMap_deep_copy) {
-  for (int i=0; i<2; ++i)
-    test_deep_copy<TEST_EXECSPACE>(10000);
+TEST(TEST_CATEGORY, UnorderedMap_deep_copy) {
+  for (int i = 0; i < 2; ++i) test_deep_copy<TEST_EXECSPACE>(10000);
 }
 
-} // namespace Test
-
-#endif //KOKKOS_TEST_UNORDERED_MAP_HPP
+}  // namespace Test
 
+#endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
diff --git a/lib/kokkos/containers/unit_tests/TestVector.hpp b/lib/kokkos/containers/unit_tests/TestVector.hpp
index b766ae87182e8e24083abc3f4e6141aff1d8ddda..4174a477c4d7e5d7ad525ed7b7248426e8de5761 100644
--- a/lib/kokkos/containers/unit_tests/TestVector.hpp
+++ b/lib/kokkos/containers/unit_tests/TestVector.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,85 +53,193 @@ namespace Test {
 
 namespace Impl {
 
-  template <typename Scalar, class Device>
-  struct test_vector_combinations
-  {
-    typedef test_vector_combinations<Scalar,Device> self_type;
-
-    typedef Scalar scalar_type;
-    typedef Device execution_space;
-
-    Scalar reference;
-    Scalar result;
-
-    template <typename Vector>
-    Scalar run_me(unsigned int n){
-      Vector a(n,1);
-
-
-      a.push_back(2);
-      a.resize(n+4);
-      a[n+1] = 3;
-      a[n+2] = 4;
-      a[n+3] = 5;
-
+template <typename Scalar, class Device>
+struct test_vector_insert {
+  typedef Scalar scalar_type;
+  typedef Device execution_space;
+
+  template <typename Vector>
+  void run_test(Vector& a) {
+    int n = a.size();
+
+    auto it = a.begin();
+    it += 15;
+    ASSERT_EQ(*it, scalar_type(1));
+
+    auto it_return = a.insert(it, scalar_type(3));
+    ASSERT_EQ(a.size(), n + 1);
+    ASSERT_EQ(std::distance(it_return, a.begin() + 15), 0);
+
+    it = a.begin();
+    it += 17;
+// Looks like some std::vector implementations do not have the restriction
+// right on the overload taking three iterators, and thus the following call
+// will hit that overload and then fail to compile.
+#if defined(KOKKOS_COMPILER_INTEL) && (1700 > KOKKOS_COMPILER_INTEL)
+// And at least GCC 4.8.4 doesn't implement vector insert correct for C++11
+// Return type is void ...
+#if (__GNUC__ < 5)
+    a.insert(it, typename Vector::size_type(n + 5), scalar_type(5));
+    it_return = a.begin() + 17;
+#else
+    it_return = a.insert(it, typename Vector::size_type(n + 5), scalar_type(5));
+#endif
+#else
+#if (__GNUC__ < 5)
+    a.insert(it, n + 5, scalar_type(5));
+    it_return = a.begin() + 17;
+#else
+    it_return = a.insert(it, n + 5, scalar_type(5));
+#endif
+#endif
+
+    ASSERT_EQ(a.size(), n + 1 + n + 5);
+    ASSERT_EQ(std::distance(it_return, a.begin() + 17), 0);
+
+    Vector b;
+
+// Looks like some std::vector implementations do not have the restriction
+// right on the overload taking three iterators, and thus the following call
+// will hit that overload and then fail to compile.
+#if defined(KOKKOS_COMPILER_INTEL) && (1700 > KOKKOS_COMPILER_INTEL)
+    b.insert(b.begin(), typename Vector::size_type(7), 9);
+#else
+    b.insert(b.begin(), 7, 9);
+#endif
+    ASSERT_EQ(b.size(), 7);
+    ASSERT_EQ(b[0], scalar_type(9));
+
+    it = a.begin();
+    it += 27 + n;
+#if (__GNUC__ < 5)
+    a.insert(it, b.begin(), b.end());
+    it_return = a.begin() + (27 + n);
+#else
+    it_return = a.insert(it, b.begin(), b.end());
+#endif
+    ASSERT_EQ(a.size(), n + 1 + n + 5 + 7);
+    ASSERT_EQ(std::distance(it_return, a.begin() + 27 + n), 0);
+
+    // Testing insert at end via all three function interfaces
+    a.insert(a.end(), 11);
+#if defined(KOKKOS_COMPILER_INTEL) && (1700 > KOKKOS_COMPILER_INTEL)
+    a.insert(a.end(), typename Vector::size_type(2), 12);
+#else
+    a.insert(a.end(), 2, 12);
+#endif
+    a.insert(a.end(), b.begin(), b.end());
+  }
+
+  template <typename Vector>
+  void check_test(Vector& a, int n) {
+    for (int i = 0; i < (int)a.size(); i++) {
+      if (i == 15)
+        ASSERT_EQ(a[i], scalar_type(3));
+      else if (i > 16 && i < 16 + 6 + n)
+        ASSERT_EQ(a[i], scalar_type(5));
+      else if (i > 26 + n && i < 34 + n)
+        ASSERT_EQ(a[i], scalar_type(9));
+      else if (i == (int)a.size() - 10)
+        ASSERT_EQ(a[i], scalar_type(11));
+      else if ((i == (int)a.size() - 9) || (i == (int)a.size() - 8))
+        ASSERT_EQ(a[i], scalar_type(12));
+      else if (i > (int)a.size() - 8)
+        ASSERT_EQ(a[i], scalar_type(9));
+      else
+        ASSERT_EQ(a[i], scalar_type(1));
+    }
+  }
 
-      Scalar temp1 = a[2];
-      Scalar temp2 = a[n];
-      Scalar temp3 = a[n+1];
+  test_vector_insert(unsigned int size) {
+    {
+      std::vector<Scalar> a(size, scalar_type(1));
+      run_test(a);
+      check_test(a, size);
+    }
+    {
+      Kokkos::vector<Scalar, Device> a(size, scalar_type(1));
+      a.sync_device();
+      run_test(a);
+      a.sync_host();
+      check_test(a, size);
+    }
+    {
+      Kokkos::vector<Scalar, Device> a(size, scalar_type(1));
+      a.sync_host();
+      run_test(a);
+      check_test(a, size);
+    }
+  }
+};
 
-      a.assign(n+2,-1);
+template <typename Scalar, class Device>
+struct test_vector_combinations {
+  typedef test_vector_combinations<Scalar, Device> self_type;
 
-      a[2] = temp1;
-      a[n] = temp2;
-      a[n+1] = temp3;
+  typedef Scalar scalar_type;
+  typedef Device execution_space;
 
-      Scalar test1 = 0;
-      for(unsigned int i=0; i<a.size(); i++)
-        test1+=a[i];
+  Scalar reference;
+  Scalar result;
 
-      a.assign(n+1,-2);
-      Scalar test2 = 0;
-      for(unsigned int i=0; i<a.size(); i++)
-        test2+=a[i];
+  template <typename Vector>
+  Scalar run_me(unsigned int n) {
+    Vector a(n, 1);
 
-      a.reserve(n+10);
+    a.push_back(2);
+    a.resize(n + 4);
+    a[n + 1] = 3;
+    a[n + 2] = 4;
+    a[n + 3] = 5;
 
-      Scalar test3 = 0;
-      for(unsigned int i=0; i<a.size(); i++)
-        test3+=a[i];
+    Scalar temp1 = a[2];
+    Scalar temp2 = a[n];
+    Scalar temp3 = a[n + 1];
 
+    a.assign(n + 2, -1);
 
-      return (test1*test2+test3)*test2+test1*test3;
-    }
+    a[2]     = temp1;
+    a[n]     = temp2;
+    a[n + 1] = temp3;
 
+    Scalar test1 = 0;
+    for (unsigned int i = 0; i < a.size(); i++) test1 += a[i];
 
-    test_vector_combinations(unsigned int size)
-    {
-      reference = run_me<std::vector<Scalar> >(size);
-      result = run_me<Kokkos::vector<Scalar,Device> >(size);
-    }
+    a.assign(n + 1, -2);
+    Scalar test2 = 0;
+    for (unsigned int i = 0; i < a.size(); i++) test2 += a[i];
 
-   };
+    a.reserve(n + 10);
 
-} // namespace Impl
+    Scalar test3 = 0;
+    for (unsigned int i = 0; i < a.size(); i++) test3 += a[i];
 
+    return (test1 * test2 + test3) * test2 + test1 * test3;
+  }
 
+  test_vector_combinations(unsigned int size) {
+    reference = run_me<std::vector<Scalar> >(size);
+    result    = run_me<Kokkos::vector<Scalar, Device> >(size);
+  }
+};
 
+}  // namespace Impl
 
 template <typename Scalar, typename Device>
-void test_vector_combinations(unsigned int size)
-{
-  Impl::test_vector_combinations<Scalar,Device> test(size);
-  ASSERT_EQ( test.reference, test.result);
+void test_vector_combinations(unsigned int size) {
+  Impl::test_vector_combinations<Scalar, Device> test(size);
+  ASSERT_EQ(test.reference, test.result);
 }
 
-TEST_F( TEST_CATEGORY, vector_combination) {
-  test_vector_combinations<int,TEST_EXECSPACE>(10);
-  test_vector_combinations<int,TEST_EXECSPACE>(3057);
+TEST(TEST_CATEGORY, vector_combination) {
+  test_vector_combinations<int, TEST_EXECSPACE>(10);
+  test_vector_combinations<int, TEST_EXECSPACE>(3057);
 }
 
-} // namespace Test
+TEST(TEST_CATEGORY, vector_insert) {
+  Impl::test_vector_insert<int, TEST_EXECSPACE>(3057);
+}
 
-#endif //KOKKOS_TEST_UNORDERED_MAP_HPP
+}  // namespace Test
 
+#endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
diff --git a/lib/kokkos/containers/unit_tests/TestViewCtorPropEmbeddedDim.hpp b/lib/kokkos/containers/unit_tests/TestViewCtorPropEmbeddedDim.hpp
index 2dd5c56cd991a61cb76d8ebe177e0bcb4024d55b..3f7d4101f7e6bf2ddd3b1197b6f1326553dbe334 100644
--- a/lib/kokkos/containers/unit_tests/TestViewCtorPropEmbeddedDim.hpp
+++ b/lib/kokkos/containers/unit_tests/TestViewCtorPropEmbeddedDim.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -55,63 +56,58 @@ namespace Test {
 
 namespace {
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestViewCtorProp_EmbeddedDim {
+  using ViewIntType    = typename Kokkos::View<int**, ExecSpace>;
+  using ViewDoubleType = typename Kokkos::View<double*, ExecSpace>;
 
-  using ViewIntType     = typename Kokkos::View< int**, ExecSpace >;
-  using ViewDoubleType     = typename Kokkos::View< double*, ExecSpace >;
+  using DynRankViewIntType    = typename Kokkos::DynRankView<int, ExecSpace>;
+  using DynRankViewDoubleType = typename Kokkos::DynRankView<double, ExecSpace>;
 
-  using DynRankViewIntType     = typename Kokkos::DynRankView< int, ExecSpace >;
-  using DynRankViewDoubleType     = typename Kokkos::DynRankView< double, ExecSpace >;
-
-  // Cuda 7.0 has issues with using a lambda in parallel_for to initialize the view - replace with this functor
-  template < class ViewType >
+  // Cuda 7.0 has issues with using a lambda in parallel_for to initialize the
+  // view - replace with this functor
+  template <class ViewType>
   struct Functor {
-
     ViewType v;
 
-    Functor( const ViewType & v_ ) : v(v_) {}
+    Functor(const ViewType& v_) : v(v_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int i ) const {
-      v(i) = i;
-    }
-
+    void operator()(const int i) const { v(i) = i; }
   };
 
-
-  static void test_vcpt( const int N0, const int N1 )
-  {
-
+  static void test_vcpt(const int N0, const int N1) {
     // Create two views to test
     {
-      using VIT = typename TestViewCtorProp_EmbeddedDim::ViewIntType ;
-      using VDT = typename TestViewCtorProp_EmbeddedDim::ViewDoubleType ;
+      using VIT = typename TestViewCtorProp_EmbeddedDim::ViewIntType;
+      using VDT = typename TestViewCtorProp_EmbeddedDim::ViewDoubleType;
 
       VIT vi1("vi1", N0, N1);
       VDT vd1("vd1", N0);
 
-      // TEST: Test for common type between two views, one with type double, other with type int
-      // Deduce common value_type and construct a view with that type
+      // TEST: Test for common type between two views, one with type double,
+      // other with type int Deduce common value_type and construct a view with
+      // that type
       {
         // Two views
         auto view_alloc_arg = Kokkos::common_view_alloc_prop(vi1, vd1);
-        typedef typename decltype( view_alloc_arg )::value_type                    CommonViewValueType;
-        typedef typename Kokkos::View< CommonViewValueType*, ExecSpace >  CVT;
-        typedef typename CVT::HostMirror                                           HostCVT;
+        typedef
+            typename decltype(view_alloc_arg)::value_type CommonViewValueType;
+        typedef typename Kokkos::View<CommonViewValueType*, ExecSpace> CVT;
+        typedef typename CVT::HostMirror HostCVT;
 
-        // Construct View using the common type; for case of specialization, an 'embedded_dim' would be stored by view_alloc_arg
-        CVT cv1( Kokkos::view_alloc( "cv1", view_alloc_arg ), N0*N1 );
+        // Construct View using the common type; for case of specialization, an
+        // 'embedded_dim' would be stored by view_alloc_arg
+        CVT cv1(Kokkos::view_alloc("cv1", view_alloc_arg), N0 * N1);
 
-        Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace >(0, N0*N1), 
-          Functor<CVT>(cv1)
-        );
+        Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, N0 * N1),
+                             Functor<CVT>(cv1));
 
-        HostCVT hcv1 = Kokkos::create_mirror_view( cv1 );
-        Kokkos::deep_copy( hcv1, cv1 );
+        HostCVT hcv1 = Kokkos::create_mirror_view(cv1);
+        Kokkos::deep_copy(hcv1, cv1);
 
-        ASSERT_EQ( (std::is_same< CommonViewValueType, double >::value) , true ) ;
-      #if 0
+        ASSERT_EQ((std::is_same<CommonViewValueType, double>::value), true);
+#if 0
       // debug output
       for ( int i = 0; i < N0*N1; ++i ) {
         printf(" Output check: hcv1(%d) = %lf\n ", i, hcv1(i) );
@@ -126,91 +122,92 @@ struct TestViewCtorProp_EmbeddedDim {
         printf("WRONG common value_type\n");
       }
       // end debug output
-      #endif
+#endif
       }
 
       {
         // Single view
         auto view_alloc_arg = Kokkos::common_view_alloc_prop(vi1);
-        typedef typename decltype( view_alloc_arg )::value_type                    CommonViewValueType;
-        typedef typename Kokkos::View< CommonViewValueType*, ExecSpace >  CVT;
-        typedef typename CVT::HostMirror                                           HostCVT;
+        typedef
+            typename decltype(view_alloc_arg)::value_type CommonViewValueType;
+        typedef typename Kokkos::View<CommonViewValueType*, ExecSpace> CVT;
+        typedef typename CVT::HostMirror HostCVT;
 
-        // Construct View using the common type; for case of specialization, an 'embedded_dim' would be stored by view_alloc_arg
-        CVT cv1( Kokkos::view_alloc( "cv1", view_alloc_arg ), N0*N1 );
+        // Construct View using the common type; for case of specialization, an
+        // 'embedded_dim' would be stored by view_alloc_arg
+        CVT cv1(Kokkos::view_alloc("cv1", view_alloc_arg), N0 * N1);
 
-        Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace >(0, N0*N1), 
-          Functor<CVT>(cv1)
-        );
+        Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, N0 * N1),
+                             Functor<CVT>(cv1));
 
-        HostCVT hcv1 = Kokkos::create_mirror_view( cv1 );
-        Kokkos::deep_copy( hcv1, cv1 );
+        HostCVT hcv1 = Kokkos::create_mirror_view(cv1);
+        Kokkos::deep_copy(hcv1, cv1);
 
-        ASSERT_EQ( (std::is_same< CommonViewValueType, int>::value) , true ) ;
+        ASSERT_EQ((std::is_same<CommonViewValueType, int>::value), true);
       }
-
     }
 
     // Create two dynamic rank views to test
     {
-      using VIT = typename TestViewCtorProp_EmbeddedDim::DynRankViewIntType ;
-      using VDT = typename TestViewCtorProp_EmbeddedDim::DynRankViewDoubleType ;
+      using VIT = typename TestViewCtorProp_EmbeddedDim::DynRankViewIntType;
+      using VDT = typename TestViewCtorProp_EmbeddedDim::DynRankViewDoubleType;
 
       VIT vi1("vi1", N0, N1);
       VDT vd1("vd1", N0);
 
-      // TEST: Test for common type between two views, one with type double, other with type int
-      // Deduce common value_type and construct a view with that type
+      // TEST: Test for common type between two views, one with type double,
+      // other with type int Deduce common value_type and construct a view with
+      // that type
       {
         // Two views
-        auto view_alloc_arg = Kokkos::common_view_alloc_prop( vi1, vd1 );
-        typedef typename decltype( view_alloc_arg )::value_type                    CommonViewValueType;
-        typedef typename Kokkos::View< CommonViewValueType*, ExecSpace >  CVT;
-        typedef typename CVT::HostMirror                                           HostCVT;
-
-        // Construct View using the common type; for case of specialization, an 'embedded_dim' would be stored by view_alloc_arg
-        CVT cv1( Kokkos::view_alloc( "cv1", view_alloc_arg ), N0*N1 );
+        auto view_alloc_arg = Kokkos::common_view_alloc_prop(vi1, vd1);
+        typedef
+            typename decltype(view_alloc_arg)::value_type CommonViewValueType;
+        typedef typename Kokkos::View<CommonViewValueType*, ExecSpace> CVT;
+        typedef typename CVT::HostMirror HostCVT;
 
+        // Construct View using the common type; for case of specialization, an
+        // 'embedded_dim' would be stored by view_alloc_arg
+        CVT cv1(Kokkos::view_alloc("cv1", view_alloc_arg), N0 * N1);
 
-        Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace >(0, N0*N1), 
-          Functor<CVT>(cv1)
-        );
+        Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, N0 * N1),
+                             Functor<CVT>(cv1));
 
-        HostCVT hcv1 = Kokkos::create_mirror_view( cv1 );
-        Kokkos::deep_copy( hcv1, cv1 );
+        HostCVT hcv1 = Kokkos::create_mirror_view(cv1);
+        Kokkos::deep_copy(hcv1, cv1);
 
-        ASSERT_EQ( (std::is_same< CommonViewValueType, double >::value) , true ) ;
+        ASSERT_EQ((std::is_same<CommonViewValueType, double>::value), true);
       }
 
       {
         // Single views
-        auto view_alloc_arg = Kokkos::common_view_alloc_prop( vi1 );
-        typedef typename decltype( view_alloc_arg )::value_type                    CommonViewValueType;
-        typedef typename Kokkos::View< CommonViewValueType*, ExecSpace >  CVT;
-        typedef typename CVT::HostMirror                                           HostCVT;
+        auto view_alloc_arg = Kokkos::common_view_alloc_prop(vi1);
+        typedef
+            typename decltype(view_alloc_arg)::value_type CommonViewValueType;
+        typedef typename Kokkos::View<CommonViewValueType*, ExecSpace> CVT;
+        typedef typename CVT::HostMirror HostCVT;
 
-        // Construct View using the common type; for case of specialization, an 'embedded_dim' would be stored by view_alloc_arg
-        CVT cv1( Kokkos::view_alloc( "cv1", view_alloc_arg ), N0*N1 );
+        // Construct View using the common type; for case of specialization, an
+        // 'embedded_dim' would be stored by view_alloc_arg
+        CVT cv1(Kokkos::view_alloc("cv1", view_alloc_arg), N0 * N1);
 
-        Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace >(0, N0*N1), 
-          Functor<CVT>(cv1)
-        );
+        Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, N0 * N1),
+                             Functor<CVT>(cv1));
 
-        HostCVT hcv1 = Kokkos::create_mirror_view( cv1 );
-        Kokkos::deep_copy( hcv1, cv1 );
+        HostCVT hcv1 = Kokkos::create_mirror_view(cv1);
+        Kokkos::deep_copy(hcv1, cv1);
 
-        ASSERT_EQ( (std::is_same< CommonViewValueType, int>::value) , true ) ;
+        ASSERT_EQ((std::is_same<CommonViewValueType, int>::value), true);
       }
     }
 
+  }  // end test_vcpt
 
-  } // end test_vcpt
-
-}; // end struct
+};  // end struct
 
-} // namespace
+}  // namespace
 
-TEST_F( TEST_CATEGORY, viewctorprop_embedded_dim ) {
-  TestViewCtorProp_EmbeddedDim< TEST_EXECSPACE >::test_vcpt( 2, 3 );
+TEST(TEST_CATEGORY, viewctorprop_embedded_dim) {
+  TestViewCtorProp_EmbeddedDim<TEST_EXECSPACE>::test_vcpt(2, 3);
 }
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/containers/unit_tests/UnitTestMain.cpp b/lib/kokkos/containers/unit_tests/UnitTestMain.cpp
index 508b43efd809e7041cd773b5cdaa25dc92e71450..e245aad35fc33a595a16f711dbd4a63a0c7f8948 100644
--- a/lib/kokkos/containers/unit_tests/UnitTestMain.cpp
+++ b/lib/kokkos/containers/unit_tests/UnitTestMain.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,14 +43,12 @@
 */
 
 #include <gtest/gtest.h>
-#include <cstdlib>
 #include <Kokkos_Core.hpp>
 
 int main(int argc, char *argv[]) {
-  Kokkos::initialize(argc,argv);
-  ::testing::InitGoogleTest(&argc,argv);
+  Kokkos::initialize(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
   int result = RUN_ALL_TESTS();
   Kokkos::finalize();
   return result;
 }
-
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_BitSet.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_BitSet.cpp
index 5f7bc684e67fe0395ab8a17d0f7ae5bc29df4e2c..5306ab3883753875bf9b3a2ee3ce6b9058eddfe6 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_BitSet.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_BitSet.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestBitset.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestBitset.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_Category.hpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_Category.hpp
index 3e0d1424802f243ef9ec0098970e9d2d1be8fbb8..50935d7a34d1d2fe69311f33c71aaefb19f45080 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_Category.hpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,21 +45,6 @@
 #ifndef KOKKOS_TEST_CUDA_HPP
 #define KOKKOS_TEST_CUDA_HPP
 
-#include <gtest/gtest.h>
-
-namespace Test {
-
-class cuda : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY cuda
 #define TEST_EXECSPACE Kokkos::Cuda
 
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DualView.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DualView.cpp
index 1930293c3a34ca373a430b32700add5ff9ec2746..5641966db432f2764eab8b1c0f3b6488306172ca 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DualView.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DualView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestDualView.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestDualView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_generic.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_generic.cpp
index 3d381b3fb623507f8cc16d93a9a9e9e0b8988de6..609c8b41a535213a1a9dac6053ae74e24fa5aa1b 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_generic.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_generic.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestDynViewAPI_generic.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestDynViewAPI_generic.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank12345.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank12345.cpp
index 08d5b3957aadbeeaa28dac7386cd1932338a27c7..66d2d17e8b499daf78fd7d114a3c66c4bbb027fe 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank12345.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank12345.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestDynViewAPI_rank12345.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestDynViewAPI_rank12345.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank67.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank67.cpp
index a655491e81d8cff829ad470fe54f9c1dbb343ea2..19e248dd9330486a2c3faf440cc7d4adb4f73757 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank67.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynRankViewAPI_rank67.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestDynViewAPI_rank67.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestDynViewAPI_rank67.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynamicView.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynamicView.cpp
index 1986fd7e9217d740f08891d97ae082ab4dae078d..9eccb05a25d55165da409e45100c375ff3a3e0ae 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynamicView.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_DynamicView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestDynamicView.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestDynamicView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_ErrorReporter.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_ErrorReporter.cpp
index 22d8d15e03259c3e38892c7f951c5a89adfb508b..806a3c6eccb10cf0d02c0ad0a709513572f86a6d 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_ErrorReporter.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_ErrorReporter.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestErrorReporter.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestErrorReporter.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_OffsetView.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_OffsetView.cpp
index 546f6d603a482a2b84f7e5ff33f03d71db3cb5b6..b2e851d0999ad1267bc0906bed123220c58bf5b8 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_OffsetView.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_OffsetView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestOffsetView.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestOffsetView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_ScatterView.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_ScatterView.cpp
index 9bd1bbab2cd0e8506b0d4ba253b7515b340dbc35..10b63d037d7e20575d4987ccfcc87c36ec591a8f 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_ScatterView.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_ScatterView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestScatterView.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestScatterView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_StaticCrsGraph.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_StaticCrsGraph.cpp
index b15abcf5250e5036e15097f345ca2323fba5a5d2..9c93da9c503ea73c7c29332f0e33da12c7562c83 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_StaticCrsGraph.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_StaticCrsGraph.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestStaticCrsGraph.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestStaticCrsGraph.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_UnorderedMap.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_UnorderedMap.cpp
index 881b20b575e2198443b766d80fe473a301f834cb..b204e68977f1c84a79eff2a8fa44d5d9722081a8 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_UnorderedMap.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_UnorderedMap.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestUnorderedMap.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestUnorderedMap.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_Vector.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_Vector.cpp
index cf0f2012dc29f20544dbd317533c93539a807ab9..408d0c76fc2860b753a0a82ee5699ea420268ff3 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_Vector.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_Vector.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestVector.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestVector.hpp>
diff --git a/lib/kokkos/containers/unit_tests/cuda/TestCuda_ViewCtorPropEmbeddedDim.cpp b/lib/kokkos/containers/unit_tests/cuda/TestCuda_ViewCtorPropEmbeddedDim.cpp
index 7130195839a64660169897fa1b22970c08772a45..c865deb0b252018fb3ae9aa5d444999124fe4551 100644
--- a/lib/kokkos/containers/unit_tests/cuda/TestCuda_ViewCtorPropEmbeddedDim.cpp
+++ b/lib/kokkos/containers/unit_tests/cuda/TestCuda_ViewCtorPropEmbeddedDim.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestViewCtorPropEmbeddedDim.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_BitSet.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_BitSet.cpp
index cec24e00c7d9d4d6c30a40c6ea19c87734930a05..179cfcc7b486e09bf7c0d266a5d6fd2d18cc67e0 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_BitSet.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_BitSet.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestBitset.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestBitset.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_Category.hpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_Category.hpp
index 358b42d1aaaef441d40c957c06f4e92e2abbaffb..64fc7c0757baca29e2c0e02099a4234330378eb7 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_Category.hpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,21 +45,6 @@
 #ifndef KOKKOS_TEST_HPX_HPP
 #define KOKKOS_TEST_HPX_HPP
 
-#include <gtest/gtest.h>
-
-namespace Test {
-
-class hpx : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY hpx
 #define TEST_EXECSPACE Kokkos::Experimental::HPX
 
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DualView.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DualView.cpp
index 80af9dc33ad88b5b20321908cb2728a1d40344be..368cdde95c68b8ba48f5377e7dfd1fbd4cee18f0 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DualView.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DualView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestDualView.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestDualView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_generic.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_generic.cpp
index 95d49c8acf5d59c0290f63713df0eb402e61a2fb..778bd891d68befa2f3cc8a1ff39cc64d073da05f 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_generic.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_generic.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestDynViewAPI_generic.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestDynViewAPI_generic.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank12345.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank12345.cpp
index 72e0bc661635425b31a9efa088a5d357b5360cdc..0bb77a266d5b1feb85c02c65576eeaf76651b11f 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank12345.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank12345.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestDynViewAPI_rank12345.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestDynViewAPI_rank12345.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank67.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank67.cpp
index 5a104f0de260a09212b7fbafd265d83558c848ea..6594cb3213f49b005e27f7a455ebc6e1cf639e0e 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank67.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynRankViewAPI_rank67.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestDynViewAPI_rank67.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestDynViewAPI_rank67.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynamicView.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynamicView.cpp
index 718b322684c880cd5cc973752808f2a459fe3167..c1efc778a69455dd17d764330bd9420628c58dfd 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynamicView.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_DynamicView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestDynamicView.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestDynamicView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_ErrorReporter.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_ErrorReporter.cpp
index ea819ae3438ba18c9ca94c03b0e5b69d17499759..3f68c6d07f3bb0375f981f167497d21aa78c40be 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_ErrorReporter.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_ErrorReporter.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestErrorReporter.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestErrorReporter.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_OffsetView.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_OffsetView.cpp
index 4d3684923f2559a3bfa71b12fa506c3a94b21fb2..171930022820eb0a8d707612c4df6b3380283bac 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_OffsetView.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_OffsetView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestOffsetView.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestOffsetView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_ScatterView.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_ScatterView.cpp
index 6a871cc12131275a22db9e11dc4e02346a3911de..8f9eb059189b266af3359f5c9de97bf07b8e1ef8 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_ScatterView.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_ScatterView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestScatterView.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestScatterView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_StaticCrsGraph.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_StaticCrsGraph.cpp
index fbb70a762b2d80a5edce941b417e30abbf20709f..4f513efb0f0e981d88f91af075cc13ff2d73e524 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_StaticCrsGraph.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_StaticCrsGraph.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestStaticCrsGraph.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestStaticCrsGraph.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_UnorderedMap.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_UnorderedMap.cpp
index 7e7aad309fe38b0d57beb60d9ab53147361fd4d9..517135290a8ad7cf16b9ed20c4495e725e788148 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_UnorderedMap.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_UnorderedMap.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestUnorderedMap.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestUnorderedMap.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_Vector.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_Vector.cpp
index 5fb3664197f139928f8e102388493a87dcb72467..d42cef4b28809b6c220b78201a22028f59d83771 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_Vector.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_Vector.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestVector.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestVector.hpp>
diff --git a/lib/kokkos/containers/unit_tests/hpx/TestHPX_ViewCtorPropEmbeddedDim.cpp b/lib/kokkos/containers/unit_tests/hpx/TestHPX_ViewCtorPropEmbeddedDim.cpp
index fb9c263c8300c771061cb00de5341ffcec211a65..de2e96be7301cc8bae137162463a6b8fbd6fa5a4 100644
--- a/lib/kokkos/containers/unit_tests/hpx/TestHPX_ViewCtorPropEmbeddedDim.cpp
+++ b/lib/kokkos/containers/unit_tests/hpx/TestHPX_ViewCtorPropEmbeddedDim.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestViewCtorPropEmbeddedDim.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_BitSet.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_BitSet.cpp
index 2f3a52787dcdc3cf237505b3fff487a426acea43..db110171594657a9ca659827bb065ab9137fea05 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_BitSet.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_BitSet.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestBitset.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestBitset.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Category.hpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Category.hpp
index 150173e4bffec4d8a803c8ffcd255bfa082a2a36..a0169d170294ad9e7b32d847de09875b37bce8e0 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Category.hpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,21 +45,6 @@
 #ifndef KOKKOS_TEST_OPENMP_HPP
 #define KOKKOS_TEST_OPENMP_HPP
 
-#include <gtest/gtest.h>
-
-namespace Test {
-
-class openmp : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY openmp
 #define TEST_EXECSPACE Kokkos::OpenMP
 
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DualView.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DualView.cpp
index fd6b9ae7078c570d8321bfc7c647b66ebc37dabc..ed4eb23a8bd3a6eb0d43af28f3c2b742bdd0d5ed 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DualView.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DualView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestDualView.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestDualView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_generic.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_generic.cpp
index 066d8f919420e48c44caadd05bb64e8e882045d6..637be64dfa07202ef3c6a4950bb5f9cf2ab8e8e9 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_generic.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_generic.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestDynViewAPI_generic.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestDynViewAPI_generic.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank12345.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank12345.cpp
index f44e320ebaf34bcbab1e8df50e5197b5611b2858..01b57a1690a70df1161b99004ea0af901ee8515a 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank12345.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank12345.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestDynViewAPI_rank12345.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestDynViewAPI_rank12345.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank67.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank67.cpp
index 154243aec95ba3fdd237d59f7a86c2cae3d0e482..7d742eaeed19353ef61eee454e8982169002c8f7 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank67.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynRankViewAPI_rank67.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestDynViewAPI_rank67.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestDynViewAPI_rank67.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynamicView.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynamicView.cpp
index 7d9ead910fe1db63f237bf71351f034509a53e03..75b616f168c0a6ad58c989b1f99d972e72d39c2a 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynamicView.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_DynamicView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestDynamicView.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestDynamicView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ErrorReporter.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ErrorReporter.cpp
index d05bf163bfde0b2c450f330a884d9b3c8fa5497b..1f00f1853282b5dac360225ca35ecf31d12e476d 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ErrorReporter.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ErrorReporter.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestErrorReporter.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestErrorReporter.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_OffsetView.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_OffsetView.cpp
index 169dae3212847ce8d485f8e46ae97406aaa98bd9..98531ff212e0b821a848a805b49443f855cb699d 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_OffsetView.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_OffsetView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestOffsetView.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestOffsetView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ScatterView.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ScatterView.cpp
index 3adfcd840992ca772eabb1aa50707cec2f1596c6..c49577f75ddb63c0b0238c634ffadf14169373ef 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ScatterView.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ScatterView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestScatterView.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestScatterView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_StaticCrsGraph.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_StaticCrsGraph.cpp
index 486a51a0b97874606212192b9ab16c3072794418..d8ab7b6b211ab8e17a39e279a7c55e306265f518 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_StaticCrsGraph.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_StaticCrsGraph.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestStaticCrsGraph.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestStaticCrsGraph.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_UnorderedMap.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_UnorderedMap.cpp
index 32dc22ec937b6570d194d09c2f47c7902dd0b292..c3db0c0d888c8c0e439dd16998a44245f388091e 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_UnorderedMap.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_UnorderedMap.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestUnorderedMap.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestUnorderedMap.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Vector.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Vector.cpp
index 006caba816bf6033af04a13156b6dc278ba7a975..7ac49f24fb3000b6852289311ae8b9e1189f9dce 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Vector.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_Vector.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestVector.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestVector.hpp>
diff --git a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ViewCtorPropEmbeddedDim.cpp b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ViewCtorPropEmbeddedDim.cpp
index dbbf14cb5b8b754df48f1fccebf1ee4090b2cae5..b9ae5d80ed93666e8d7be610d4763adfebac9290 100644
--- a/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ViewCtorPropEmbeddedDim.cpp
+++ b/lib/kokkos/containers/unit_tests/openmp/TestOpenMP_ViewCtorPropEmbeddedDim.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestViewCtorPropEmbeddedDim.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_BitSet.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_BitSet.cpp
index 2c8657e4649c21f073fba4c1eb6d86adcce2033e..c72077eb4c7a1bd519eed3b2f0322d99409a7ebf 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_BitSet.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_BitSet.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestBitset.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestBitset.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_Category.hpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_Category.hpp
index d520bbc5a7c827f78c3ac33e46bbfaf7e1c757e9..d37cd05db68163a0e24bf61204e3054860537a5d 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_Category.hpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,21 +45,6 @@
 #ifndef KOKKOS_TEST_ROCM_HPP
 #define KOKKOS_TEST_ROCM_HPP
 
-#include <gtest/gtest.h>
-
-namespace Test {
-
-class rocm : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY rocm
 #define TEST_EXECSPACE Kokkos::Experimental::ROCm
 
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DualView.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DualView.cpp
index f60c6ade449e35cc0dfbcf19c52c8553797f4969..e9820395ba5bdba199e2948ac39956b3ae5c3b33 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DualView.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DualView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestDualView.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestDualView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_generic.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_generic.cpp
index 80bfe06153d807461b150def212179486c245769..7a3dd65f0efc1eb4ba5b5d7fa0912b6f0d09aee0 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_generic.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_generic.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestDynViewAPI_generic.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestDynViewAPI_generic.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank12345.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank12345.cpp
index b42ce07e8f1f2adce1d74d8c01570809217a6c87..3963dd9c9cf8fbffc4a3763f472ca1073e7b9dbc 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank12345.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank12345.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestDynViewAPI_rank12345.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestDynViewAPI_rank12345.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank67.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank67.cpp
index 0f47b800c61ea2e0faf862ff9672f214c9795074..b9a4582622807bb1f52aaf3e6c9302cf372fbb2f 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank67.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynRankViewAPI_rank67.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestDynViewAPI_rank67.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestDynViewAPI_rank67.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynamicView.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynamicView.cpp
index 5540eb2d20e3dd1121506f970832b26280f1fed8..285ed916c432d499d4b230d9c63600a7f41e803f 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynamicView.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_DynamicView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestDynamicView.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestDynamicView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_ErrorReporter.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_ErrorReporter.cpp
index 2c7a26c7fed5a38a19e2a266bd3e6ac64bdf4699..2af2f79a16806659b4650313950d00aaa4d684bd 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_ErrorReporter.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_ErrorReporter.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestErrorReporter.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestErrorReporter.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_ScatterView.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_ScatterView.cpp
index cc4a07ddbdfdc031b766e9c2183ca56aeb07467b..f7000bc99e206e852081488405d21fc24c1d9f04 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_ScatterView.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_ScatterView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestScatterView.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestScatterView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_StaticCrsGraph.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_StaticCrsGraph.cpp
index be83d4ef50fd9f1ad0009c00ad52954bac270751..bb1e04c53647f2457f852f23230d9178ab2b1211 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_StaticCrsGraph.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_StaticCrsGraph.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestStaticCrsGraph.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestStaticCrsGraph.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_UnorderedMap.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_UnorderedMap.cpp
index f6b2f9ef40c7f8c1149cb0b1ee0e0d4bc724d06e..7b8172fabdcdd04d81a0d9441abe5690ecb256bb 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_UnorderedMap.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_UnorderedMap.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestUnorderedMap.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestUnorderedMap.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_Vector.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_Vector.cpp
index e9073b6bb5178609278cd98a3f5cffa3b8c7b961..1759797487c45f0c4ccb8b48e9140b4034bb4fdc 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_Vector.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_Vector.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestVector.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestVector.hpp>
diff --git a/lib/kokkos/containers/unit_tests/rocm/TestROCm_ViewCtorPropEmbeddedDim.cpp b/lib/kokkos/containers/unit_tests/rocm/TestROCm_ViewCtorPropEmbeddedDim.cpp
index dd472270e78846e33fe235ac0faeee13276cb1aa..e95680445b5d75864367c1cf0c4268ac50907c15 100644
--- a/lib/kokkos/containers/unit_tests/rocm/TestROCm_ViewCtorPropEmbeddedDim.cpp
+++ b/lib/kokkos/containers/unit_tests/rocm/TestROCm_ViewCtorPropEmbeddedDim.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestViewCtorPropEmbeddedDim.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_BitSet.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_BitSet.cpp
index 03edd30c34d75b65fe90943c30d9b03987e79d84..322e88a6af9d700854a46be8c18d6984e97c30a1 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_BitSet.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_BitSet.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestBitset.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestBitset.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_Category.hpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_Category.hpp
index 858b6692863c966cf40a6ffdcf2cc98a0e1f28db..2aa09a315ae01e70a4267e6214fe478bbd0a9592 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_Category.hpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,21 +45,6 @@
 #ifndef KOKKOS_TEST_SERIAL_HPP
 #define KOKKOS_TEST_SERIAL_HPP
 
-#include <gtest/gtest.h>
-
-namespace Test {
-
-class serial : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY serial
 #define TEST_EXECSPACE Kokkos::Serial
 
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_DualView.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_DualView.cpp
index 0dac8eba879b25c7e04217a73a3a864ae3e59761..c1646ed13ba6c215017aec202acf091cacf02353 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_DualView.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_DualView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestDualView.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestDualView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_generic.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_generic.cpp
index 1a5874e7fa50e43a54429f27b4398cf639131ea0..e8f577c6ac3d5445027298a208b823b66ca81576 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_generic.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_generic.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestDynViewAPI_generic.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestDynViewAPI_generic.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank12345.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank12345.cpp
index df802bfe68d2cb6ed5a452c791d9ee191bdeb418..7db8983c1b1332840d76aa4cfc748d9379a4e469 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank12345.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank12345.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestDynViewAPI_rank12345.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestDynViewAPI_rank12345.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank67.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank67.cpp
index 84e5b452c478145bee07d3c01f5f6103c2720983..a3a745efb5d1faa9fcd7e31c0014115290368249 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank67.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynRankViewAPI_rank67.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestDynViewAPI_rank67.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestDynViewAPI_rank67.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynamicView.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynamicView.cpp
index 34f4002db247ef3a4511efc511102a845243c206..6624e3aa07f1fe0d790b9f517db8b3bd85fbcb40 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_DynamicView.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_DynamicView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestDynamicView.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestDynamicView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_ErrorReporter.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_ErrorReporter.cpp
index 326853f33a6acf4a3427c5f9d944da19169848ed..280302275fe1bd6278ee7cbb9e7403af5642bbda 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_ErrorReporter.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_ErrorReporter.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestErrorReporter.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestErrorReporter.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_OffsetView.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_OffsetView.cpp
index fadd748efbdb4b6c73906348c65269d4199fb041..5f8caf7c3f09af0022e041c7255ba970ca261634 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_OffsetView.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_OffsetView.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestOffsetView.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestOffsetView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_ScatterView.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_ScatterView.cpp
index ee04d3558444994ff4bed199a229933024d625b6..3f102e5cbc9d301664f9ca102b1db824c3540a7a 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_ScatterView.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_ScatterView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestScatterView.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestScatterView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_StaticCrsGraph.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_StaticCrsGraph.cpp
index 2d10ee70d2db4b0ff8e869022038609591e6137f..64f09e76e5899dc60541a1ea7ddc47a55c1c7bf4 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_StaticCrsGraph.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_StaticCrsGraph.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestStaticCrsGraph.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestStaticCrsGraph.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_UnorderedMap.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_UnorderedMap.cpp
index e78667e8aab51d5db70dd575a065c3ea1ddcc47b..a72be8e2fc25febb9afa102ed1cf2c5cf72d711e 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_UnorderedMap.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_UnorderedMap.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestUnorderedMap.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestUnorderedMap.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_Vector.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_Vector.cpp
index bf980556229f7b55a5371ab749ccf1539f878fa6..3826dab1d7053a12b821e5034fe52d8d52280d37 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_Vector.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_Vector.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestVector.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestVector.hpp>
diff --git a/lib/kokkos/containers/unit_tests/serial/TestSerial_ViewCtorPropEmbeddedDim.cpp b/lib/kokkos/containers/unit_tests/serial/TestSerial_ViewCtorPropEmbeddedDim.cpp
index 143b1f1c2d87104bd85628a0c3c175b1cbfe86bb..1251808bed7e610aa7eddb4e36b6973edf657712 100644
--- a/lib/kokkos/containers/unit_tests/serial/TestSerial_ViewCtorPropEmbeddedDim.cpp
+++ b/lib/kokkos/containers/unit_tests/serial/TestSerial_ViewCtorPropEmbeddedDim.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestViewCtorPropEmbeddedDim.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_BitSet.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_BitSet.cpp
index 0dfe69fee2b60cc6ae3a51a1ca55a8f59e5f4acc..ec93bb121cf94bb5256258e42305267f436a904c 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_BitSet.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_BitSet.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestBitset.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestBitset.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_Category.hpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_Category.hpp
index c4d0ed6da2958ed239e96ed4d5c64369d85e4fab..74a2b0da362e3226230c0f11e3a7fc987eb9a615 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_Category.hpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,21 +45,6 @@
 #ifndef KOKKOS_TEST_THREADS_HPP
 #define KOKKOS_TEST_THREADS_HPP
 
-#include <gtest/gtest.h>
-
-namespace Test {
-
-class threads : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY threads
 #define TEST_EXECSPACE Kokkos::Threads
 
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_DualView.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_DualView.cpp
index 0ddafcd6fdde630fe98c7d2f1301f8e041a41e39..f6967bf0d4e1d2e4f8a12b628ec1f66e15e518e1 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_DualView.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_DualView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestDualView.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestDualView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_generic.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_generic.cpp
index 0030673785acc08f905dc7f5ddfca7633917d7fd..b015683bb9d9ac0f97c87a153b4260d9d86b351a 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_generic.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_generic.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestDynViewAPI_generic.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestDynViewAPI_generic.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank12345.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank12345.cpp
index db39db38b3db96c1f91a7985990766c35fa626f8..dea56c408bd093d75895f8e32d76fa0e5a0ca672 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank12345.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank12345.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestDynViewAPI_rank12345.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestDynViewAPI_rank12345.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank67.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank67.cpp
index 1d1f94d6cfe847e0f3709b23f3c51a2747acd44c..17a289b506538dcf2249f0f85a96104b40f1b824 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank67.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynRankViewAPI_rank67.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestDynViewAPI_rank67.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestDynViewAPI_rank67.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynamicView.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynamicView.cpp
index 61616a5132c190d8a6deda762c79d2928cf32fe2..499321dbbea92f52e12a0a21321425ef5f5d423e 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_DynamicView.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_DynamicView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestDynamicView.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestDynamicView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_ErrorReporter.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_ErrorReporter.cpp
index a64c3f4082139f810ed5872d1a0a630a83d25797..513fdc4af62d92d83e8f21b74e5e300d33d2d1a8 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_ErrorReporter.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_ErrorReporter.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestErrorReporter.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestErrorReporter.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_OffsetView.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_OffsetView.cpp
index d1eaa265e3e47fa92097a7a3e598b95a374b77bf..717967b2ef3d8bdafe6c92efdc3b556811a96a47 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_OffsetView.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_OffsetView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestOffsetView.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestOffsetView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_ScatterView.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_ScatterView.cpp
index 6c7138058d3c9e3c0ca7ebab8db912045d14fe08..fbb37606ea01e358b62accc2349a7e7268179b99 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_ScatterView.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_ScatterView.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestScatterView.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestScatterView.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_StaticCrsGraph.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_StaticCrsGraph.cpp
index f6a1204dd3ac214c6801494fcc55fe059a84fd94..29117c4ef6546190a130947094fe6918bbfc3f7c 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_StaticCrsGraph.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_StaticCrsGraph.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestStaticCrsGraph.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestStaticCrsGraph.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_UnorderedMap.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_UnorderedMap.cpp
index 2f3aeedae00d8a36497adcb7687fe2d7b1972336..9a06288de46c989f992cf07eda485a29fd4f6d8a 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_UnorderedMap.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_UnorderedMap.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestUnorderedMap.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestUnorderedMap.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_Vector.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_Vector.cpp
index a497d43772802595087462ad3418b8179f6c9982..33e8b26c8ef375c61bc26ef2d961cb3494aeaa2b 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_Vector.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_Vector.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestVector.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestVector.hpp>
diff --git a/lib/kokkos/containers/unit_tests/threads/TestThreads_ViewCtorPropEmbeddedDim.cpp b/lib/kokkos/containers/unit_tests/threads/TestThreads_ViewCtorPropEmbeddedDim.cpp
index 89f85dca560d3a1fce84a7c2c6e6ead751b23e3f..567b2241953b5cbb956a6d04ad8b7acea93ff8cf 100644
--- a/lib/kokkos/containers/unit_tests/threads/TestThreads_ViewCtorPropEmbeddedDim.cpp
+++ b/lib/kokkos/containers/unit_tests/threads/TestThreads_ViewCtorPropEmbeddedDim.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestViewCtorPropEmbeddedDim.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
diff --git a/lib/kokkos/core/CMakeLists.txt b/lib/kokkos/core/CMakeLists.txt
index 93db0d2ecf916f6ca1451f0794d31049d5477498..8df72dfc90e53def1ee00c4207a968086e484a0c 100644
--- a/lib/kokkos/core/CMakeLists.txt
+++ b/lib/kokkos/core/CMakeLists.txt
@@ -1,13 +1,12 @@
-
-
-TRIBITS_SUBPACKAGE(Core)
-
-IF(KOKKOS_HAS_TRILINOS)
-  ADD_SUBDIRECTORY(src)
-ENDIF()
-
-TRIBITS_ADD_TEST_DIRECTORIES(unit_test)
-TRIBITS_ADD_TEST_DIRECTORIES(perf_test)
-
-TRIBITS_SUBPACKAGE_POSTPROCESS()
-
+
+
+KOKKOS_SUBPACKAGE(Core)
+
+ADD_SUBDIRECTORY(src)
+
+KOKKOS_ADD_TEST_DIRECTORIES(unit_test)
+KOKKOS_ADD_TEST_DIRECTORIES(perf_test)
+
+KOKKOS_SUBPACKAGE_POSTPROCESS()
+
+
diff --git a/lib/kokkos/core/cmake/KokkosCore_config.h.in b/lib/kokkos/core/cmake/KokkosCore_config.h.in
index b2c80207d4505f28788d751c741141713bade397..f430c2b5f6512ee2e389ec61c322fefaffbfc7fc 100644
--- a/lib/kokkos/core/cmake/KokkosCore_config.h.in
+++ b/lib/kokkos/core/cmake/KokkosCore_config.h.in
@@ -13,8 +13,7 @@
 
 #cmakedefine KOKKOS_ENABLE_CUDA
 #cmakedefine KOKKOS_ENABLE_OPENMP
-#cmakedefine KOKKOS_ENABLE_PTHREAD
-#cmakedefine KOKKOS_ENABLE_QTHREADS
+#cmakedefine KOKKOS_ENABLE_THREADS
 #cmakedefine KOKKOS_ENABLE_SERIAL
 #cmakedefine KOKKOS_ENABLE_Winthread
 
diff --git a/lib/kokkos/core/perf_test/CMakeLists.txt b/lib/kokkos/core/perf_test/CMakeLists.txt
index d92462a357cba28dc3a0ba5cb4f8e193e5b5348b..79567835ee0446347acbd35b7f182cae58f03cb5 100644
--- a/lib/kokkos/core/perf_test/CMakeLists.txt
+++ b/lib/kokkos/core/perf_test/CMakeLists.txt
@@ -1,59 +1,71 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
+#INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+#INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
 
-IF(NOT KOKKOS_HAS_TRILINOS)
-  IF(KOKKOS_SEPARATE_LIBS)
-    set(TEST_LINK_TARGETS kokkoscore)
-  ELSE()
-    set(TEST_LINK_TARGETS kokkos)
-  ENDIF()
-ENDIF()
 
 # warning: PerfTest_CustomReduction.cpp uses
 # ../../algorithms/src/Kokkos_Random.hpp
 # we'll just allow it to be included, but note
 # that in TriBITS KokkosAlgorithms can be disabled...
-INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/../../algorithms/src")
+#INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/../../algorithms/src")
 
 SET(SOURCES
   PerfTestMain.cpp
   PerfTestGramSchmidt.cpp
   PerfTestHexGrad.cpp
   PerfTest_CustomReduction.cpp
+  PerfTest_ExecSpacePartitioning.cpp
+  PerfTest_ViewCopy_a123.cpp
+  PerfTest_ViewCopy_b123.cpp
+  PerfTest_ViewCopy_c123.cpp
+  PerfTest_ViewCopy_d123.cpp
+  PerfTest_ViewCopy_a45.cpp
+  PerfTest_ViewCopy_b45.cpp
+  PerfTest_ViewCopy_c45.cpp
+  PerfTest_ViewCopy_d45.cpp
+  PerfTest_ViewCopy_a6.cpp
+  PerfTest_ViewCopy_b6.cpp
+  PerfTest_ViewCopy_c6.cpp
+  PerfTest_ViewCopy_d6.cpp
+  PerfTest_ViewCopy_a7.cpp
+  PerfTest_ViewCopy_b7.cpp
+  PerfTest_ViewCopy_c7.cpp
+  PerfTest_ViewCopy_d7.cpp
+  PerfTest_ViewCopy_a8.cpp
+  PerfTest_ViewCopy_b8.cpp
+  PerfTest_ViewCopy_c8.cpp
+  PerfTest_ViewCopy_d8.cpp
+  PerfTest_ViewAllocate.cpp
+  PerfTest_ViewFill_123.cpp
+  PerfTest_ViewFill_45.cpp
+  PerfTest_ViewFill_6.cpp
+  PerfTest_ViewFill_7.cpp
+  PerfTest_ViewFill_8.cpp
+  PerfTest_ViewResize_123.cpp
+  PerfTest_ViewResize_45.cpp
+  PerfTest_ViewResize_6.cpp
+  PerfTest_ViewResize_7.cpp
+  PerfTest_ViewResize_8.cpp
   )
 
 # Per #374, we always want to build this test, but we only want to run
 # it as a PERFORMANCE test.  That's why we separate building the test
 # from running the test.
 
-TRIBITS_ADD_EXECUTABLE(
+#leave these as basic includes for now
+#I don't need anything transitive
+KOKKOS_INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/../../algorithms/src")
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
+
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
   PerfTestExec
   SOURCES ${SOURCES}
-  COMM serial mpi
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-
-TRIBITS_ADD_TEST(
-  PerfTest
-  NAME PerfTestExec
-  COMM serial mpi
-  NUM_MPI_PROCS 1
   CATEGORIES PERFORMANCE
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-  )
+)
 
-TRIBITS_ADD_EXECUTABLE(
-  PerformanceTest_TaskDAG
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
+  PerformanceTest_TaskDag
   SOURCES test_taskdag.cpp
-  COMM serial mpi
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-  )
-
-TRIBITS_ADD_TEST(
-  PerformanceTest_TaskDAG
-  NAME PerformanceTest_TaskDAG
-  COMM serial mpi
-  NUM_MPI_PROCS 1
   CATEGORIES PERFORMANCE
-  )
+)
diff --git a/lib/kokkos/core/perf_test/PerfTestBlasKernels.hpp b/lib/kokkos/core/perf_test/PerfTestBlasKernels.hpp
index ff9bf5a91b852326917829a1dc672af0b825b9d6..a5a376565d812b69d48b217bd528c4fe769d448f 100644
--- a/lib/kokkos/core/perf_test/PerfTestBlasKernels.hpp
+++ b/lib/kokkos/core/perf_test/PerfTestBlasKernels.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -48,217 +49,186 @@
 
 namespace Kokkos {
 
-template< class ConstVectorType ,
-          class Device = typename ConstVectorType::execution_space >
-struct Dot ;
+template <class ConstVectorType,
+          class Device = typename ConstVectorType::execution_space>
+struct Dot;
 
-template< class ConstVectorType ,
-          class Device = typename ConstVectorType::execution_space >
-struct DotSingle ;
+template <class ConstVectorType,
+          class Device = typename ConstVectorType::execution_space>
+struct DotSingle;
 
-template< class ConstScalarType ,
-          class VectorType ,
-          class Device = typename VectorType::execution_space >
-struct Scale ;
+template <class ConstScalarType, class VectorType,
+          class Device = typename VectorType::execution_space>
+struct Scale;
 
-template< class ConstScalarType ,
-          class ConstVectorType ,
-          class VectorType ,
-          class Device = typename VectorType::execution_space >
-struct AXPBY ;
+template <class ConstScalarType, class ConstVectorType, class VectorType,
+          class Device = typename VectorType::execution_space>
+struct AXPBY;
 
 /** \brief  Y = alpha * X + beta * Y */
-template< class ConstScalarType ,
-          class ConstVectorType ,
-          class      VectorType >
-void axpby( const ConstScalarType & alpha ,
-            const ConstVectorType & X ,
-            const ConstScalarType & beta ,
-            const      VectorType & Y )
-{
-  typedef AXPBY< ConstScalarType , ConstVectorType , VectorType > functor ;
-
-  parallel_for( Y.extent(0) , functor( alpha , X , beta , Y ) );
+template <class ConstScalarType, class ConstVectorType, class VectorType>
+void axpby(const ConstScalarType& alpha, const ConstVectorType& X,
+           const ConstScalarType& beta, const VectorType& Y) {
+  typedef AXPBY<ConstScalarType, ConstVectorType, VectorType> functor;
+
+  parallel_for(Y.extent(0), functor(alpha, X, beta, Y));
 }
 
 /** \brief  Y *= alpha */
-template< class ConstScalarType ,
-          class      VectorType >
-void scale( const ConstScalarType & alpha , const VectorType & Y )
-{
-  typedef Scale< ConstScalarType , VectorType > functor ;
+template <class ConstScalarType, class VectorType>
+void scale(const ConstScalarType& alpha, const VectorType& Y) {
+  typedef Scale<ConstScalarType, VectorType> functor;
 
-  parallel_for( Y.extent(0) , functor( alpha , Y ) );
+  parallel_for(Y.extent(0), functor(alpha, Y));
 }
 
-template< class ConstVectorType ,
-          class Finalize >
-void dot( const ConstVectorType & X ,
-          const ConstVectorType & Y ,
-          const Finalize & finalize )
-{
-  typedef Dot< ConstVectorType >  functor ;
+template <class ConstVectorType, class Finalize>
+void dot(const ConstVectorType& X, const ConstVectorType& Y,
+         const Finalize& finalize) {
+  typedef Dot<ConstVectorType> functor;
 
-  parallel_reduce( X.extent(0) , functor( X , Y ) , finalize );
+  parallel_reduce(X.extent(0), functor(X, Y), finalize);
 }
 
-template< class ConstVectorType ,
-          class Finalize >
-void dot( const ConstVectorType & X ,
-          const Finalize & finalize )
-{
-  typedef DotSingle< ConstVectorType >  functor ;
+template <class ConstVectorType, class Finalize>
+void dot(const ConstVectorType& X, const Finalize& finalize) {
+  typedef DotSingle<ConstVectorType> functor;
 
-  parallel_reduce( X.extent(0) , functor( X ) , finalize );
+  parallel_reduce(X.extent(0), functor(X), finalize);
 }
 
 } /* namespace Kokkos */
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-template< class Type , class Device >
-struct Dot
-{
-  typedef typename Device::execution_space execution_space ;
-
-  static_assert( static_cast<unsigned>(Type::Rank) == static_cast<unsigned>(1),
-    "Dot static_assert Fail: Rank != 1");
+template <class Type, class Device>
+struct Dot {
+  typedef typename Device::execution_space execution_space;
 
+  static_assert(static_cast<unsigned>(Type::Rank) == static_cast<unsigned>(1),
+                "Dot static_assert Fail: Rank != 1");
 
-  typedef double value_type ;
+  typedef double value_type;
 
 #if 1
-  typename Type::const_type X ;
-  typename Type::const_type Y ;
+  typename Type::const_type X;
+  typename Type::const_type Y;
 #else
-  Type X ;
-  Type Y ;
+  Type X;
+  Type Y;
 #endif
 
-  Dot( const Type & arg_x , const Type & arg_y )
-    : X(arg_x) , Y(arg_y) { }
+  Dot(const Type& arg_x, const Type& arg_y) : X(arg_x), Y(arg_y) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i , value_type & update ) const
-    { update += X[i] * Y[i]; }
+  void operator()(int i, value_type& update) const { update += X[i] * Y[i]; }
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & source )
-    { update += source; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& source) {
+    update += source;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
+  static void init(value_type& update) { update = 0; }
 };
 
-template< class Type , class Device >
-struct DotSingle
-{
-  typedef typename Device::execution_space execution_space ;
+template <class Type, class Device>
+struct DotSingle {
+  typedef typename Device::execution_space execution_space;
 
-  static_assert( static_cast<unsigned>(Type::Rank) == static_cast<unsigned>(1),
-    "DotSingle static_assert Fail: Rank != 1");
+  static_assert(static_cast<unsigned>(Type::Rank) == static_cast<unsigned>(1),
+                "DotSingle static_assert Fail: Rank != 1");
 
-  typedef double value_type ;
+  typedef double value_type;
 
 #if 1
-  typename Type::const_type X ;
+  typename Type::const_type X;
 #else
-  Type X ;
+  Type X;
 #endif
 
-  DotSingle( const Type & arg_x ) : X(arg_x) {}
+  DotSingle(const Type& arg_x) : X(arg_x) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i , value_type & update ) const
-    {
-      const typename Type::value_type & x = X[i]; update += x * x ;
-    }
+  void operator()(int i, value_type& update) const {
+    const typename Type::value_type& x = X[i];
+    update += x * x;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & source )
-    { update += source; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& source) {
+    update += source;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0 ; }
+  static void init(value_type& update) { update = 0; }
 };
 
+template <class ScalarType, class VectorType, class Device>
+struct Scale {
+  typedef typename Device::execution_space execution_space;
 
-template< class ScalarType , class VectorType , class Device>
-struct Scale
-{
-  typedef typename Device::execution_space execution_space ;
+  static_assert(static_cast<unsigned>(ScalarType::Rank) ==
+                    static_cast<unsigned>(0),
+                "Scale static_assert Fail: ScalarType::Rank != 0");
 
-  static_assert( static_cast<unsigned>(ScalarType::Rank) == static_cast<unsigned>(0),
-    "Scale static_assert Fail: ScalarType::Rank != 0");
-
-  static_assert( static_cast<unsigned>(VectorType::Rank) == static_cast<unsigned>(1),
-    "Scale static_assert Fail: VectorType::Rank != 1");
+  static_assert(static_cast<unsigned>(VectorType::Rank) ==
+                    static_cast<unsigned>(1),
+                "Scale static_assert Fail: VectorType::Rank != 1");
 
 #if 1
-  typename ScalarType::const_type alpha ;
+  typename ScalarType::const_type alpha;
 #else
-  ScalarType alpha ;
+  ScalarType alpha;
 #endif
 
-  VectorType Y ;
+  VectorType Y;
 
-  Scale( const ScalarType & arg_alpha , const VectorType & arg_Y )
-    : alpha( arg_alpha ), Y( arg_Y ) {}
+  Scale(const ScalarType& arg_alpha, const VectorType& arg_Y)
+      : alpha(arg_alpha), Y(arg_Y) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i ) const
-    {
-      Y[i] *= alpha() ;
-    }
+  void operator()(int i) const { Y[i] *= alpha(); }
 };
 
-
-template< class ScalarType ,
-          class ConstVectorType ,
-          class VectorType,
+template <class ScalarType, class ConstVectorType, class VectorType,
           class Device>
-struct AXPBY
-{
-  typedef typename Device::execution_space execution_space ;
+struct AXPBY {
+  typedef typename Device::execution_space execution_space;
 
-  static_assert( static_cast<unsigned>(ScalarType::Rank) == static_cast<unsigned>(0),
-    "AXPBY static_assert Fail: ScalarType::Rank != 0");
+  static_assert(static_cast<unsigned>(ScalarType::Rank) ==
+                    static_cast<unsigned>(0),
+                "AXPBY static_assert Fail: ScalarType::Rank != 0");
 
-  static_assert( static_cast<unsigned>(ConstVectorType::Rank) == static_cast<unsigned>(1),
-    "AXPBY static_assert Fail: ConstVectorType::Rank != 1");
+  static_assert(static_cast<unsigned>(ConstVectorType::Rank) ==
+                    static_cast<unsigned>(1),
+                "AXPBY static_assert Fail: ConstVectorType::Rank != 1");
 
-  static_assert( static_cast<unsigned>(VectorType::Rank) == static_cast<unsigned>(1),
-    "AXPBY static_assert Fail: VectorType::Rank != 1");
+  static_assert(static_cast<unsigned>(VectorType::Rank) ==
+                    static_cast<unsigned>(1),
+                "AXPBY static_assert Fail: VectorType::Rank != 1");
 
 #if 1
-  typename ScalarType::const_type alpha , beta ;
-  typename ConstVectorType::const_type X ;
+  typename ScalarType::const_type alpha, beta;
+  typename ConstVectorType::const_type X;
 #else
-  ScalarType alpha , beta ;
-  ConstVectorType X ;
+  ScalarType alpha, beta;
+  ConstVectorType X;
 #endif
 
-  VectorType Y ;
+  VectorType Y;
 
-  AXPBY( const ScalarType      & arg_alpha ,
-         const ConstVectorType & arg_X ,
-         const ScalarType      & arg_beta ,
-         const VectorType      & arg_Y )
-    : alpha( arg_alpha ), beta( arg_beta ), X( arg_X ), Y( arg_Y ) {}
+  AXPBY(const ScalarType& arg_alpha, const ConstVectorType& arg_X,
+        const ScalarType& arg_beta, const VectorType& arg_Y)
+      : alpha(arg_alpha), beta(arg_beta), X(arg_X), Y(arg_Y) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i ) const
-    {
-      Y[i] = alpha() * X[i] + beta() * Y[i] ;
-    }
+  void operator()(int i) const { Y[i] = alpha() * X[i] + beta() * Y[i]; }
 };
 
 } /* namespace Kokkos */
diff --git a/lib/kokkos/core/perf_test/PerfTestDriver.hpp b/lib/kokkos/core/perf_test/PerfTestDriver.hpp
index 5367f2542ed82a11113a4f10d995d04b7a32b5a5..95d5128abf312086edd055b5cce158178d5e3cac 100644
--- a/lib/kokkos/core/perf_test/PerfTestDriver.hpp
+++ b/lib/kokkos/core/perf_test/PerfTestDriver.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -60,244 +61,262 @@ namespace Test {
 
 enum { NUMBER_OF_TRIALS = 5 };
 
-template< class DeviceType , class LayoutType >
-void run_test_mdrange( int exp_beg , int exp_end, const char deviceTypeName[], int range_offset = 0,  int tile_offset = 0 )
+template <class DeviceType, class LayoutType>
+void run_test_mdrange(int exp_beg, int exp_end, const char deviceTypeName[],
+                      int range_offset = 0, int tile_offset = 0)
 // exp_beg = 6 => 2^6 = 64 is starting range length
 {
 #define MDRANGE_PERFORMANCE_OUTPUT_VERBOSE 0
 
-  std::string label_mdrange ;
-  label_mdrange.append( "\"MDRange< double , " );
-  label_mdrange.append( deviceTypeName );
-  label_mdrange.append( " >\"" );
-
-  std::string label_range_col2 ;
-  label_range_col2.append( "\"RangeColTwo< double , " );
-  label_range_col2.append( deviceTypeName );
-  label_range_col2.append( " >\"" );
-
-  std::string label_range_col_all ;
-  label_range_col_all.append( "\"RangeColAll< double , " );
-  label_range_col_all.append( deviceTypeName );
-  label_range_col_all.append( " >\"" );
-
-  if ( std::is_same<LayoutType, Kokkos::LayoutRight>::value) {
-    std::cout << "--------------------------------------------------------------\n"
-      << "Performance tests for MDRange Layout Right"
-      << "\n--------------------------------------------------------------" << std::endl;
+  std::string label_mdrange;
+  label_mdrange.append("\"MDRange< double , ");
+  label_mdrange.append(deviceTypeName);
+  label_mdrange.append(" >\"");
+
+  std::string label_range_col2;
+  label_range_col2.append("\"RangeColTwo< double , ");
+  label_range_col2.append(deviceTypeName);
+  label_range_col2.append(" >\"");
+
+  std::string label_range_col_all;
+  label_range_col_all.append("\"RangeColAll< double , ");
+  label_range_col_all.append(deviceTypeName);
+  label_range_col_all.append(" >\"");
+
+  if (std::is_same<LayoutType, Kokkos::LayoutRight>::value) {
+    std::cout
+        << "--------------------------------------------------------------\n"
+        << "Performance tests for MDRange Layout Right"
+        << "\n--------------------------------------------------------------"
+        << std::endl;
   } else {
-    std::cout << "--------------------------------------------------------------\n"
-      << "Performance tests for MDRange Layout Left"
-      << "\n--------------------------------------------------------------" << std::endl;
+    std::cout
+        << "--------------------------------------------------------------\n"
+        << "Performance tests for MDRange Layout Left"
+        << "\n--------------------------------------------------------------"
+        << std::endl;
   }
 
+  for (int i = exp_beg; i < exp_end; ++i) {
+    const int range_length = (1 << i) + range_offset;
 
-  for (int i = exp_beg ; i < exp_end ; ++i) {
-    const int range_length = (1<<i) + range_offset;
-
-    std::cout << "\n--------------------------------------------------------------\n"
-      << "--------------------------------------------------------------\n"
-      << "MDRange Test:  range bounds: " << range_length << " , " << range_length << " , " << range_length 
-      << "\n--------------------------------------------------------------\n"
-      << "--------------------------------------------------------------\n";
-//      << std::endl;
+    std::cout
+        << "\n--------------------------------------------------------------\n"
+        << "--------------------------------------------------------------\n"
+        << "MDRange Test:  range bounds: " << range_length << " , "
+        << range_length << " , " << range_length
+        << "\n--------------------------------------------------------------\n"
+        << "--------------------------------------------------------------\n";
+    //      << std::endl;
 
     int t0_min = 0, t1_min = 0, t2_min = 0;
     double seconds_min = 0.0;
 
     // Test 1: The MDRange in full
     {
-    int t0 = 1, t1 = 1, t2 = 1;
-    int counter = 1;
+      int t0 = 1, t1 = 1, t2 = 1;
+      int counter = 1;
 #if !defined(KOKKOS_ENABLE_CUDA)
-    int min_bnd = 8;
-    int tfast = range_length;
+      int min_bnd = 8;
+      int tfast   = range_length;
 #else
-    int min_bnd = 2;
-    int tfast = 32;
+      int min_bnd = 2;
+      int tfast   = 32;
 #endif
-    while ( tfast >= min_bnd ) {
-      int tmid = min_bnd;
-      while ( tmid < tfast ) { 
-        t0 = min_bnd;
-        t1 = tmid;
-        t2 = tfast;
-        int t2_rev = min_bnd;
-        int t1_rev = tmid;
-        int t0_rev = tfast;
+      while (tfast >= min_bnd) {
+        int tmid = min_bnd;
+        while (tmid < tfast) {
+          t0         = min_bnd;
+          t1         = tmid;
+          t2         = tfast;
+          int t2_rev = min_bnd;
+          int t1_rev = tmid;
+          int t0_rev = tfast;
 
 #if defined(KOKKOS_ENABLE_CUDA)
-        //Note: Product of tile sizes must be < 1024 for Cuda
-        if ( t0*t1*t2 >= 1024 ) {
-          printf("  Exceeded Cuda tile limits; onto next range set\n\n");
-          break;
-        }
+          // Note: Product of tile sizes must be < 1024 for Cuda
+          if (t0 * t1 * t2 >= 1024) {
+            printf("  Exceeded Cuda tile limits; onto next range set\n\n");
+            break;
+          }
 #endif
 
-        // Run 1 with tiles LayoutRight style
-        double seconds_1 = 0;
-        { seconds_1 = MultiDimRangePerf3D< DeviceType , double , LayoutType >::test_multi_index(range_length,range_length,range_length, t0, t1, t2) ; }
+          // Run 1 with tiles LayoutRight style
+          double seconds_1 = 0;
+          {
+            seconds_1 =
+                MultiDimRangePerf3D<DeviceType, double,
+                                    LayoutType>::test_multi_index(range_length,
+                                                                  range_length,
+                                                                  range_length,
+                                                                  t0, t1, t2);
+          }
 
 #if MDRANGE_PERFORMANCE_OUTPUT_VERBOSE
-        std::cout << label_mdrange
-          << " , " << t0 << " , " << t1 << " , " << t2
-          << " , " << seconds_1
-          << std::endl ;
+          std::cout << label_mdrange << " , " << t0 << " , " << t1 << " , "
+                    << t2 << " , " << seconds_1 << std::endl;
 #endif
 
-        if ( counter == 1 ) {
-          seconds_min = seconds_1;
-          t0_min = t0;
-          t1_min = t1;
-          t2_min = t2;
-        } 
-        else {
-          if ( seconds_1 < seconds_min ) 
-          { 
-            seconds_min = seconds_1; 
-            t0_min = t0;
-            t1_min = t1;
-            t2_min = t2;
+          if (counter == 1) {
+            seconds_min = seconds_1;
+            t0_min      = t0;
+            t1_min      = t1;
+            t2_min      = t2;
+          } else {
+            if (seconds_1 < seconds_min) {
+              seconds_min = seconds_1;
+              t0_min      = t0;
+              t1_min      = t1;
+              t2_min      = t2;
+            }
           }
-        }
 
-        // Run 2 with tiles LayoutLeft style - reverse order of tile dims
-        double seconds_1rev = 0;
-        { seconds_1rev = MultiDimRangePerf3D< DeviceType , double , LayoutType >::test_multi_index(range_length,range_length,range_length, t0_rev, t1_rev, t2_rev) ; }
+          // Run 2 with tiles LayoutLeft style - reverse order of tile dims
+          double seconds_1rev = 0;
+          {
+            seconds_1rev =
+                MultiDimRangePerf3D<DeviceType, double,
+                                    LayoutType>::test_multi_index(range_length,
+                                                                  range_length,
+                                                                  range_length,
+                                                                  t0_rev,
+                                                                  t1_rev,
+                                                                  t2_rev);
+          }
 
 #if MDRANGE_PERFORMANCE_OUTPUT_VERBOSE
-        std::cout << label_mdrange
-          << " , " << t0_rev << " , " << t1_rev << " , " << t2_rev
-          << " , " << seconds_1rev
-          << std::endl ;
+          std::cout << label_mdrange << " , " << t0_rev << " , " << t1_rev
+                    << " , " << t2_rev << " , " << seconds_1rev << std::endl;
 #endif
 
-        if ( seconds_1rev < seconds_min ) 
-        { 
-          seconds_min = seconds_1rev; 
-          t0_min = t0_rev;
-          t1_min = t1_rev;
-          t2_min = t2_rev;
-        }
+          if (seconds_1rev < seconds_min) {
+            seconds_min = seconds_1rev;
+            t0_min      = t0_rev;
+            t1_min      = t1_rev;
+            t2_min      = t2_rev;
+          }
 
-        ++counter;
-        tmid <<= 1;
-      } //end inner while
-      tfast >>=1;
-    } //end outer while
-
-    std::cout << "\n"
-      << "--------------------------------------------------------------\n"
-      << label_mdrange
-      << "\n Min values "
-      << "\n Range length per dim (3D): " << range_length
-      << "\n TileDims:  " << t0_min << " , " << t1_min << " , " << t2_min
-      << "\n Min time: " << seconds_min
-      << "\n---------------------------------------------------------------"
-      << std::endl ;
-    } //end scope
+          ++counter;
+          tmid <<= 1;
+        }  // end inner while
+        tfast >>= 1;
+      }  // end outer while
+
+      std::cout
+          << "\n"
+          << "--------------------------------------------------------------\n"
+          << label_mdrange << "\n Min values "
+          << "\n Range length per dim (3D): " << range_length
+          << "\n TileDims:  " << t0_min << " , " << t1_min << " , " << t2_min
+          << "\n Min time: " << seconds_min
+          << "\n---------------------------------------------------------------"
+          << std::endl;
+    }  // end scope
 
 #if !defined(KOKKOS_ENABLE_CUDA)
-  double seconds_min_c = 0.0;
-  int t0c_min = 0, t1c_min = 0, t2c_min = 0;
-  int counter = 1;
-  {
-    int min_bnd = 8;
-    // Test 1_c: MDRange with 0 for 'inner' tile dim; this case will utilize the full span in that direction, should be similar to Collapse<2>
-    if ( std::is_same<LayoutType, Kokkos::LayoutRight>::value ) {
-      for ( unsigned int T0 = min_bnd; T0 < static_cast<unsigned int>(range_length); T0<<=1 ) {
-        for ( unsigned int T1 = min_bnd; T1 < static_cast<unsigned int>(range_length); T1<<=1 ) {
-          double seconds_c = 0;
-          { seconds_c = MultiDimRangePerf3D< DeviceType , double , LayoutType >::test_multi_index(range_length,range_length,range_length, T0, T1, 0) ; }
+    double seconds_min_c = 0.0;
+    int t0c_min = 0, t1c_min = 0, t2c_min = 0;
+    int counter = 1;
+    {
+      int min_bnd = 8;
+      // Test 1_c: MDRange with 0 for 'inner' tile dim; this case will utilize
+      // the full span in that direction, should be similar to Collapse<2>
+      if (std::is_same<LayoutType, Kokkos::LayoutRight>::value) {
+        for (unsigned int T0 = min_bnd;
+             T0 < static_cast<unsigned int>(range_length); T0 <<= 1) {
+          for (unsigned int T1 = min_bnd;
+               T1 < static_cast<unsigned int>(range_length); T1 <<= 1) {
+            double seconds_c = 0;
+            {
+              seconds_c = MultiDimRangePerf3D<DeviceType, double, LayoutType>::
+                  test_multi_index(range_length, range_length, range_length, T0,
+                                   T1, 0);
+            }
 
 #if MDRANGE_PERFORMANCE_OUTPUT_VERBOSE
-          std::cout << " MDRange LR with '0' tile - collapse-like \n"
-          << label_mdrange
-          << " , " << T0 << " , " << T1 << " , " << range_length
-          << " , " << seconds_c
-          << std::endl ;
+            std::cout << " MDRange LR with '0' tile - collapse-like \n"
+                      << label_mdrange << " , " << T0 << " , " << T1 << " , "
+                      << range_length << " , " << seconds_c << std::endl;
 #endif
 
-          t2c_min = range_length;
-          if ( counter == 1 ) {
-            seconds_min_c = seconds_c;
-            t0c_min = T0;
-            t1c_min = T1;
-          } 
-          else {
-            if ( seconds_c < seconds_min_c ) 
-            { 
-              seconds_min_c = seconds_c; 
-              t0c_min = T0;
-              t1c_min = T1;
+            t2c_min = range_length;
+            if (counter == 1) {
+              seconds_min_c = seconds_c;
+              t0c_min       = T0;
+              t1c_min       = T1;
+            } else {
+              if (seconds_c < seconds_min_c) {
+                seconds_min_c = seconds_c;
+                t0c_min       = T0;
+                t1c_min       = T1;
+              }
             }
+            ++counter;
           }
-          ++counter;
         }
-      }
-    }
-    else {
-      for ( unsigned int T1 = min_bnd; T1 <= static_cast<unsigned int>(range_length); T1<<=1 ) {
-        for ( unsigned int T2 = min_bnd; T2 <= static_cast<unsigned int>(range_length); T2<<=1 ) {
-          double seconds_c = 0;
-          { seconds_c = MultiDimRangePerf3D< DeviceType , double , LayoutType >::test_multi_index(range_length,range_length,range_length, 0, T1, T2) ; }
+      } else {
+        for (unsigned int T1 = min_bnd;
+             T1 <= static_cast<unsigned int>(range_length); T1 <<= 1) {
+          for (unsigned int T2 = min_bnd;
+               T2 <= static_cast<unsigned int>(range_length); T2 <<= 1) {
+            double seconds_c = 0;
+            {
+              seconds_c = MultiDimRangePerf3D<DeviceType, double, LayoutType>::
+                  test_multi_index(range_length, range_length, range_length, 0,
+                                   T1, T2);
+            }
 
 #if MDRANGE_PERFORMANCE_OUTPUT_VERBOSE
-          std::cout << " MDRange LL with '0' tile - collapse-like \n"
-          << label_mdrange
-          << " , " <<range_length << " < " << T1 << " , " << T2
-          << " , " << seconds_c
-          << std::endl ;
+            std::cout << " MDRange LL with '0' tile - collapse-like \n"
+                      << label_mdrange << " , " << range_length << " < " << T1
+                      << " , " << T2 << " , " << seconds_c << std::endl;
 #endif
 
-
-          t0c_min = range_length;
-          if ( counter == 1 ) {
-            seconds_min_c = seconds_c;
-            t1c_min = T1;
-            t2c_min = T2;
-          } 
-          else {
-            if ( seconds_c < seconds_min_c ) 
-            { 
-              seconds_min_c = seconds_c; 
-              t1c_min = T1;
-              t2c_min = T2;
+            t0c_min = range_length;
+            if (counter == 1) {
+              seconds_min_c = seconds_c;
+              t1c_min       = T1;
+              t2c_min       = T2;
+            } else {
+              if (seconds_c < seconds_min_c) {
+                seconds_min_c = seconds_c;
+                t1c_min       = T1;
+                t2c_min       = T2;
+              }
             }
+            ++counter;
           }
-          ++counter;
         }
       }
-    }
 
-    std::cout 
-//      << "--------------------------------------------------------------\n"
-      << label_mdrange
-      << "  Collapse<2> style: "
-      << "\n Min values "
-      << "\n Range length per dim (3D): " << range_length
-      << "\n TileDims:  " << t0c_min << " , " << t1c_min << " , " << t2c_min
-      << "\n Min time: " << seconds_min_c
-      << "\n---------------------------------------------------------------"
-      << std::endl ;
-  } //end scope test 2
+      std::cout
+          //      <<
+          //      "--------------------------------------------------------------\n"
+          << label_mdrange << "  Collapse<2> style: "
+          << "\n Min values "
+          << "\n Range length per dim (3D): " << range_length
+          << "\n TileDims:  " << t0c_min << " , " << t1c_min << " , " << t2c_min
+          << "\n Min time: " << seconds_min_c
+          << "\n---------------------------------------------------------------"
+          << std::endl;
+    }  // end scope test 2
 #endif
 
-
     // Test 2: RangePolicy Collapse2 style
     double seconds_2 = 0;
-    { seconds_2 = RangePolicyCollapseTwo< DeviceType , double , LayoutType >::test_index_collapse_two(range_length,range_length,range_length) ; }
-    std::cout << label_range_col2
-      << " , " << range_length
-      << " , " << seconds_2
-      << std::endl ;
-
+    {
+      seconds_2 = RangePolicyCollapseTwo<DeviceType, double, LayoutType>::
+          test_index_collapse_two(range_length, range_length, range_length);
+    }
+    std::cout << label_range_col2 << " , " << range_length << " , " << seconds_2
+              << std::endl;
 
     // Test 3: RangePolicy Collapse all style - not necessary, always slow
     /*
     double seconds_3 = 0;
-    { seconds_3 = RangePolicyCollapseAll< DeviceType , double , LayoutType >::test_collapse_all(range_length,range_length,range_length) ; }
-    std::cout << label_range_col_all
+    { seconds_3 = RangePolicyCollapseAll< DeviceType , double , LayoutType
+    >::test_collapse_all(range_length,range_length,range_length) ; } std::cout
+    << label_range_col_all
       << " , " << range_length
       << " , " << seconds_3
       << "\n---------------------------------------------------------------"
@@ -306,97 +325,105 @@ void run_test_mdrange( int exp_beg , int exp_end, const char deviceTypeName[], i
 
     // Compare fastest times... will never be collapse all so ignore it
     // seconds_min = tiled MDRange
-    // seconds_min_c = collapse<2>-like MDRange (tiledim = span for fast dim) - only for non-Cuda, else tile too long
-    // seconds_2 = collapse<2>-style RangePolicy
-    // seconds_3 = collapse<3>-style RangePolicy
+    // seconds_min_c = collapse<2>-like MDRange (tiledim = span for fast dim) -
+    // only for non-Cuda, else tile too long seconds_2 = collapse<2>-style
+    // RangePolicy seconds_3 = collapse<3>-style RangePolicy
 
 #if !defined(KOKKOS_ENABLE_CUDA)
-    if ( seconds_min < seconds_min_c ) {
-      if ( seconds_min < seconds_2 ) {
-        std::cout << "--------------------------------------------------------------\n"
-          << " Fastest run: MDRange tiled\n"
-          << " Time: " << seconds_min
-          << " Difference: " << seconds_2 - seconds_min
-          << " Other times: \n"
-          << "   MDrange collapse-like (tiledim = span on fast dim) type: " << seconds_min_c << "\n"
-          << "   Collapse2 Range Policy: " << seconds_2 << "\n"
-          << "\n--------------------------------------------------------------"
-          << "\n--------------------------------------------------------------"
-          //<< "\n\n"
-          << std::endl;
-      }
-      else if ( seconds_min > seconds_2 ) {
-        std::cout << " Fastest run: Collapse2 RangePolicy\n"
-          << " Time: " << seconds_2
-          << " Difference: " << seconds_min - seconds_2
-          << " Other times: \n"
-          << "   MDrange Tiled: " << seconds_min << "\n"
-          << "   MDrange collapse-like (tiledim = span on fast dim) type: " << seconds_min_c << "\n"
-          << "\n--------------------------------------------------------------"
-          << "\n--------------------------------------------------------------"
-          //<< "\n\n"
-          << std::endl;
-      }
-    }
-    else if ( seconds_min > seconds_min_c ) {
-      if ( seconds_min_c < seconds_2 ) {
-        std::cout << "--------------------------------------------------------------\n"
-          << " Fastest run: MDRange collapse-like (tiledim = span on fast dim) type\n"
-          << " Time: " << seconds_min_c
-          << " Difference: " << seconds_2 - seconds_min_c
-          << " Other times: \n"
-          << "   MDrange Tiled: " << seconds_min << "\n"
-          << "   Collapse2 Range Policy: " << seconds_2 << "\n"
-          << "\n--------------------------------------------------------------"
-          << "\n--------------------------------------------------------------"
-          //<< "\n\n"
-          << std::endl;
+    if (seconds_min < seconds_min_c) {
+      if (seconds_min < seconds_2) {
+        std::cout
+            << "--------------------------------------------------------------"
+               "\n"
+            << " Fastest run: MDRange tiled\n"
+            << " Time: " << seconds_min
+            << " Difference: " << seconds_2 - seconds_min << " Other times: \n"
+            << "   MDrange collapse-like (tiledim = span on fast dim) type: "
+            << seconds_min_c << "\n"
+            << "   Collapse2 Range Policy: " << seconds_2 << "\n"
+            << "\n-------------------------------------------------------------"
+               "-"
+            << "\n-------------------------------------------------------------"
+               "-"
+            //<< "\n\n"
+            << std::endl;
+      } else if (seconds_min > seconds_2) {
+        std::cout
+            << " Fastest run: Collapse2 RangePolicy\n"
+            << " Time: " << seconds_2
+            << " Difference: " << seconds_min - seconds_2 << " Other times: \n"
+            << "   MDrange Tiled: " << seconds_min << "\n"
+            << "   MDrange collapse-like (tiledim = span on fast dim) type: "
+            << seconds_min_c << "\n"
+            << "\n-------------------------------------------------------------"
+               "-"
+            << "\n-------------------------------------------------------------"
+               "-"
+            //<< "\n\n"
+            << std::endl;
       }
-      else if ( seconds_min_c > seconds_2 ) {
-        std::cout << " Fastest run: Collapse2 RangePolicy\n"
-          << " Time: " << seconds_2
-          << " Difference: " << seconds_min_c - seconds_2
-          << " Other times: \n"
-          << "   MDrange Tiled: " << seconds_min << "\n"
-          << "   MDrange collapse-like (tiledim = span on fast dim) type: " << seconds_min_c << "\n"
-          << "\n--------------------------------------------------------------"
-          << "\n--------------------------------------------------------------"
-          //<< "\n\n"
-          << std::endl;
+    } else if (seconds_min > seconds_min_c) {
+      if (seconds_min_c < seconds_2) {
+        std::cout << "---------------------------------------------------------"
+                     "-----\n"
+                  << " Fastest run: MDRange collapse-like (tiledim = span on "
+                     "fast dim) type\n"
+                  << " Time: " << seconds_min_c
+                  << " Difference: " << seconds_2 - seconds_min_c
+                  << " Other times: \n"
+                  << "   MDrange Tiled: " << seconds_min << "\n"
+                  << "   Collapse2 Range Policy: " << seconds_2 << "\n"
+                  << "\n-------------------------------------------------------"
+                     "-------"
+                  << "\n-------------------------------------------------------"
+                     "-------"
+                  //<< "\n\n"
+                  << std::endl;
+      } else if (seconds_min_c > seconds_2) {
+        std::cout
+            << " Fastest run: Collapse2 RangePolicy\n"
+            << " Time: " << seconds_2
+            << " Difference: " << seconds_min_c - seconds_2
+            << " Other times: \n"
+            << "   MDrange Tiled: " << seconds_min << "\n"
+            << "   MDrange collapse-like (tiledim = span on fast dim) type: "
+            << seconds_min_c << "\n"
+            << "\n-------------------------------------------------------------"
+               "-"
+            << "\n-------------------------------------------------------------"
+               "-"
+            //<< "\n\n"
+            << std::endl;
       }
-    } // end else if
+    }  // end else if
 #else
-      if ( seconds_min < seconds_2 ) {
-        std::cout << "--------------------------------------------------------------\n"
+    if (seconds_min < seconds_2) {
+      std::cout
+          << "--------------------------------------------------------------\n"
           << " Fastest run: MDRange tiled\n"
           << " Time: " << seconds_min
-          << " Difference: " << seconds_2 - seconds_min
-          << " Other times: \n"
+          << " Difference: " << seconds_2 - seconds_min << " Other times: \n"
           << "   Collapse2 Range Policy: " << seconds_2 << "\n"
           << "\n--------------------------------------------------------------"
           << "\n--------------------------------------------------------------"
           //<< "\n\n"
           << std::endl;
-      }
-      else if ( seconds_min > seconds_2 ) {
-        std::cout << " Fastest run: Collapse2 RangePolicy\n"
+    } else if (seconds_min > seconds_2) {
+      std::cout
+          << " Fastest run: Collapse2 RangePolicy\n"
           << " Time: " << seconds_2
-          << " Difference: " << seconds_min - seconds_2
-          << " Other times: \n"
+          << " Difference: " << seconds_min - seconds_2 << " Other times: \n"
           << "   MDrange Tiled: " << seconds_min << "\n"
           << "\n--------------------------------------------------------------"
           << "\n--------------------------------------------------------------"
           //<< "\n\n"
           << std::endl;
-      }
+    }
 #endif
 
-  } //end for
+  }  // end for
 
 #undef MDRANGE_PERFORMANCE_OUTPUT_VERBOSE
-
-}
-
-
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTestGramSchmidt.cpp b/lib/kokkos/core/perf_test/PerfTestGramSchmidt.cpp
index d812b16d85eaec14430ce952616776e5483cfd10..5e85163acfce8a648dca4732a3194af821d4dfb5 100644
--- a/lib/kokkos/core/perf_test/PerfTestGramSchmidt.cpp
+++ b/lib/kokkos/core/perf_test/PerfTestGramSchmidt.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -55,131 +56,105 @@ namespace Test {
 
 // Reduction   : result = dot( Q(:,j) , Q(:,j) );
 // PostProcess : R(j,j) = result ; inv = 1 / result ;
-template< class VectorView , class ValueView  >
-struct InvNorm2 : public Kokkos::DotSingle< VectorView > {
+template <class VectorView, class ValueView>
+struct InvNorm2 : public Kokkos::DotSingle<VectorView> {
+  typedef typename Kokkos::DotSingle<VectorView>::value_type value_type;
 
-  typedef typename Kokkos::DotSingle< VectorView >::value_type value_type ;
+  ValueView Rjj;
+  ValueView inv;
 
-  ValueView  Rjj ;
-  ValueView  inv ;
-
-  InvNorm2( const VectorView & argX ,
-            const ValueView  & argR ,
-            const ValueView  & argInv )
-    : Kokkos::DotSingle< VectorView >( argX )
-    , Rjj( argR )
-    , inv( argInv )
-    {}
+  InvNorm2(const VectorView& argX, const ValueView& argR,
+           const ValueView& argInv)
+      : Kokkos::DotSingle<VectorView>(argX), Rjj(argR), inv(argInv) {}
 
   KOKKOS_INLINE_FUNCTION
-  void final( value_type & result ) const
-  {
-    result = std::sqrt( result );
-    Rjj() = result ;
-    inv() = ( 0 < result ) ? 1.0 / result : 0 ;
+  void final(value_type& result) const {
+    result = std::sqrt(result);
+    Rjj()  = result;
+    inv()  = (0 < result) ? 1.0 / result : 0;
   }
 };
 
-template< class VectorView , class ValueView >
-inline
-void invnorm2( const VectorView & x ,
-               const ValueView  & r ,
-               const ValueView  & r_inv )
-{
-  Kokkos::parallel_reduce( x.extent(0) , InvNorm2< VectorView , ValueView >( x , r , r_inv ) );
+template <class VectorView, class ValueView>
+inline void invnorm2(const VectorView& x, const ValueView& r,
+                     const ValueView& r_inv) {
+  Kokkos::parallel_reduce(x.extent(0),
+                          InvNorm2<VectorView, ValueView>(x, r, r_inv));
 }
 
 // PostProcess : tmp = - ( R(j,k) = result );
-template< class VectorView , class ValueView  >
-struct DotM : public Kokkos::Dot< VectorView > {
-
-  typedef typename Kokkos::Dot< VectorView >::value_type value_type ;
+template <class VectorView, class ValueView>
+struct DotM : public Kokkos::Dot<VectorView> {
+  typedef typename Kokkos::Dot<VectorView>::value_type value_type;
 
-  ValueView  Rjk ;
-  ValueView  tmp ;
+  ValueView Rjk;
+  ValueView tmp;
 
-  DotM( const VectorView & argX ,
-        const VectorView & argY ,
-        const ValueView & argR ,
-        const ValueView & argTmp )
-    : Kokkos::Dot< VectorView >( argX , argY )
-    , Rjk( argR )
-    , tmp( argTmp )
-    {}
+  DotM(const VectorView& argX, const VectorView& argY, const ValueView& argR,
+       const ValueView& argTmp)
+      : Kokkos::Dot<VectorView>(argX, argY), Rjk(argR), tmp(argTmp) {}
 
   KOKKOS_INLINE_FUNCTION
-  void final( value_type & result ) const
-  {
-     Rjk()  = result ;
-     tmp()  = - result ;
+  void final(value_type& result) const {
+    Rjk() = result;
+    tmp() = -result;
   }
 };
 
-template< class VectorView , class ValueView >
-inline
-void dot_neg( const VectorView & x ,
-              const VectorView & y ,
-              const ValueView  & r ,
-              const ValueView  & r_neg )
-{
-  Kokkos::parallel_reduce( x.extent(0) , DotM< VectorView , ValueView >( x , y , r , r_neg ) );
+template <class VectorView, class ValueView>
+inline void dot_neg(const VectorView& x, const VectorView& y,
+                    const ValueView& r, const ValueView& r_neg) {
+  Kokkos::parallel_reduce(x.extent(0),
+                          DotM<VectorView, ValueView>(x, y, r, r_neg));
 }
 
+template <typename Scalar, class DeviceType>
+struct ModifiedGramSchmidt {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::size_type size_type;
 
-template< typename Scalar , class DeviceType >
-struct ModifiedGramSchmidt
-{
-  typedef DeviceType  execution_space ;
-  typedef typename execution_space::size_type  size_type ;
-
-  typedef Kokkos::View< Scalar** ,
-                        Kokkos::LayoutLeft ,
-                        execution_space > multivector_type ;
-
-  typedef Kokkos::View< Scalar* ,
-                        Kokkos::LayoutLeft ,
-                        execution_space > vector_type ;
+  typedef Kokkos::View<Scalar**, Kokkos::LayoutLeft, execution_space>
+      multivector_type;
 
-  typedef Kokkos::View< Scalar ,
-                        Kokkos::LayoutLeft ,
-                        execution_space > value_view ;
+  typedef Kokkos::View<Scalar*, Kokkos::LayoutLeft, execution_space>
+      vector_type;
 
+  typedef Kokkos::View<Scalar, Kokkos::LayoutLeft, execution_space> value_view;
 
-  multivector_type Q ;
-  multivector_type R ;
+  multivector_type Q;
+  multivector_type R;
 
-  static double factorization( const multivector_type Q_ ,
-                               const multivector_type R_ )
-  {
-    const size_type count  = Q_.extent(1);
+  static double factorization(const multivector_type Q_,
+                              const multivector_type R_) {
+    const size_type count = Q_.extent(1);
     value_view tmp("tmp");
     value_view one("one");
 
-    Kokkos::deep_copy( one , (Scalar) 1 );
+    Kokkos::deep_copy(one, (Scalar)1);
 
-    Kokkos::Timer timer ;
+    Kokkos::Timer timer;
 
-    for ( size_type j = 0 ; j < count ; ++j ) {
+    for (size_type j = 0; j < count; ++j) {
       // Reduction   : tmp = dot( Q(:,j) , Q(:,j) );
       // PostProcess : tmp = std::sqrt( tmp ); R(j,j) = tmp ; tmp = 1 / tmp ;
-      const vector_type Qj  = Kokkos::subview( Q_ , Kokkos::ALL() , j );
-      const value_view  Rjj = Kokkos::subview( R_ , j , j );
+      const vector_type Qj = Kokkos::subview(Q_, Kokkos::ALL(), j);
+      const value_view Rjj = Kokkos::subview(R_, j, j);
 
-      invnorm2( Qj , Rjj , tmp );
+      invnorm2(Qj, Rjj, tmp);
 
       // Q(:,j) *= ( 1 / R(j,j) ); => Q(:,j) *= tmp ;
-      Kokkos::scale( tmp , Qj );
+      Kokkos::scale(tmp, Qj);
 
-      for ( size_t k = j + 1 ; k < count ; ++k ) {
-        const vector_type Qk = Kokkos::subview( Q_ , Kokkos::ALL() , k );
-        const value_view  Rjk = Kokkos::subview( R_ , j , k );
+      for (size_t k = j + 1; k < count; ++k) {
+        const vector_type Qk = Kokkos::subview(Q_, Kokkos::ALL(), k);
+        const value_view Rjk = Kokkos::subview(R_, j, k);
 
         // Reduction   : R(j,k) = dot( Q(:,j) , Q(:,k) );
         // PostProcess : tmp = - R(j,k);
-        dot_neg( Qj , Qk , Rjk , tmp );
+        dot_neg(Qj, Qk, Rjk, tmp);
 
         // Q(:,k) -= R(j,k) * Q(:,j); => Q(:,k) += tmp * Q(:,j)
-        Kokkos::axpby( tmp , Qj , one , Qk );
+        Kokkos::axpby(tmp, Qj, one, Qk);
       }
     }
 
@@ -190,94 +165,87 @@ struct ModifiedGramSchmidt
 
   //--------------------------------------------------------------------------
 
-  static double test( const size_t length ,
-                      const size_t count ,
-                      const size_t iter = 1 )
-  {
-    multivector_type Q_( "Q" , length , count );
-    multivector_type R_( "R" , count , count );
+  static double test(const size_t length, const size_t count,
+                     const size_t iter = 1) {
+    multivector_type Q_("Q", length, count);
+    multivector_type R_("R", count, count);
 
-    typename multivector_type::HostMirror A =
-      Kokkos::create_mirror( Q_ );
+    typename multivector_type::HostMirror A = Kokkos::create_mirror(Q_);
 
     // Create and fill A on the host
 
-    for ( size_type j = 0 ; j < count ; ++j ) {
-      for ( size_type i = 0 ; i < length ; ++i ) {
-        A(i,j) = ( i + 1 ) * ( j + 1 );
+    for (size_type j = 0; j < count; ++j) {
+      for (size_type i = 0; i < length; ++i) {
+        A(i, j) = (i + 1) * (j + 1);
       }
     }
 
-    double dt_min = 0 ;
+    double dt_min = 0;
 
-    for ( size_t i = 0 ; i < iter ; ++i ) {
-
-      Kokkos::deep_copy( Q_ , A );
+    for (size_t i = 0; i < iter; ++i) {
+      Kokkos::deep_copy(Q_, A);
 
       // A = Q * R
 
-      const double dt = factorization( Q_ , R_ );
+      const double dt = factorization(Q_, R_);
 
-      if ( 0 == i ) dt_min = dt ;
-      else dt_min = dt < dt_min ? dt : dt_min ;
+      if (0 == i)
+        dt_min = dt;
+      else
+        dt_min = dt < dt_min ? dt : dt_min;
     }
 
-    return dt_min ;
+    return dt_min;
   }
 };
 
-template< class DeviceType >
-void run_test_gramschmidt( int exp_beg , int exp_end, int num_trials, const char deviceTypeName[] )
-{
-  std::string label_gramschmidt ;
-  label_gramschmidt.append( "\"GramSchmidt< double , " );
-  label_gramschmidt.append( deviceTypeName );
-  label_gramschmidt.append( " >\"" );
-
-  for (int i = exp_beg ; i < exp_end ; ++i) {
-    double min_seconds = 0.0 ;
-    double max_seconds = 0.0 ;
-    double avg_seconds = 0.0 ;
-
-    const int parallel_work_length = 1<<i;
-
-    for ( int j = 0 ; j < num_trials ; ++j ) {
-      const double seconds = ModifiedGramSchmidt< double , DeviceType >::test(parallel_work_length, 32 ) ;
-
-      if ( 0 == j ) {
-        min_seconds = seconds ;
-        max_seconds = seconds ;
-      }
-      else {
-        if ( seconds < min_seconds ) min_seconds = seconds ;
-        if ( seconds > max_seconds ) max_seconds = seconds ;
+template <class DeviceType>
+void run_test_gramschmidt(int exp_beg, int exp_end, int num_trials,
+                          const char deviceTypeName[]) {
+  std::string label_gramschmidt;
+  label_gramschmidt.append("\"GramSchmidt< double , ");
+  label_gramschmidt.append(deviceTypeName);
+  label_gramschmidt.append(" >\"");
+
+  for (int i = exp_beg; i < exp_end; ++i) {
+    double min_seconds = 0.0;
+    double max_seconds = 0.0;
+    double avg_seconds = 0.0;
+
+    const int parallel_work_length = 1 << i;
+
+    for (int j = 0; j < num_trials; ++j) {
+      const double seconds = ModifiedGramSchmidt<double, DeviceType>::test(
+          parallel_work_length, 32);
+
+      if (0 == j) {
+        min_seconds = seconds;
+        max_seconds = seconds;
+      } else {
+        if (seconds < min_seconds) min_seconds = seconds;
+        if (seconds > max_seconds) max_seconds = seconds;
       }
-      avg_seconds += seconds ;
+      avg_seconds += seconds;
     }
-    avg_seconds /= num_trials ;
+    avg_seconds /= num_trials;
 
-    std::cout << label_gramschmidt
-      << " , " << parallel_work_length
-      << " , " << min_seconds
-      << " , " << ( min_seconds / parallel_work_length )
-      << std::endl ;
+    std::cout << label_gramschmidt << " , " << parallel_work_length << " , "
+              << min_seconds << " , " << (min_seconds / parallel_work_length)
+              << std::endl;
   }
 }
 
-TEST_F( default_exec, gramschmidt ) {
-  int exp_beg = 10;
-  int exp_end = 20;
+TEST(default_exec, gramschmidt) {
+  int exp_beg    = 10;
+  int exp_end    = 20;
   int num_trials = 5;
 
-  if(command_line_num_args()>1)
-    exp_beg = atoi(command_line_arg(1));
-  if(command_line_num_args()>2)
-    exp_end = atoi(command_line_arg(2));
-  if(command_line_num_args()>3)
-    num_trials = atoi(command_line_arg(3));
-
-  EXPECT_NO_THROW(run_test_gramschmidt< Kokkos::DefaultExecutionSpace>( exp_beg, exp_end, num_trials, Kokkos::DefaultExecutionSpace::name()  ));
-}
+  if (command_line_num_args() > 1) exp_beg = atoi(command_line_arg(1));
+  if (command_line_num_args() > 2) exp_end = atoi(command_line_arg(2));
+  if (command_line_num_args() > 3) num_trials = atoi(command_line_arg(3));
 
+  EXPECT_NO_THROW(run_test_gramschmidt<Kokkos::DefaultExecutionSpace>(
+      exp_beg, exp_end, num_trials, Kokkos::DefaultExecutionSpace::name()));
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTestHexGrad.cpp b/lib/kokkos/core/perf_test/PerfTestHexGrad.cpp
index 03285a375c40443c3a830c370a206f0f95d4ce20..d8792828677e9e0012a99e4daf87d307e7ad9aaa 100644
--- a/lib/kokkos/core/perf_test/PerfTestHexGrad.cpp
+++ b/lib/kokkos/core/perf_test/PerfTestHexGrad.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -47,279 +48,253 @@
 
 namespace Test {
 
-template< class DeviceType ,
-          typename CoordScalarType = double ,
-          typename GradScalarType  = float >
-struct HexGrad
-{
-  typedef DeviceType execution_space ;
-  typedef typename execution_space::size_type  size_type ;
+template <class DeviceType, typename CoordScalarType = double,
+          typename GradScalarType = float>
+struct HexGrad {
+  typedef DeviceType execution_space;
+  typedef typename execution_space::size_type size_type;
 
-  typedef HexGrad<DeviceType,CoordScalarType,GradScalarType> self_type;
+  typedef HexGrad<DeviceType, CoordScalarType, GradScalarType> self_type;
 
   // 3D array : ( ParallelWork , Space , Node )
 
-  enum { NSpace = 3 , NNode = 8 };
+  enum { NSpace = 3, NNode = 8 };
 
-  typedef Kokkos::View< CoordScalarType*[NSpace][NNode] , execution_space >
-    elem_coord_type ;
+  typedef Kokkos::View<CoordScalarType * [NSpace][NNode], execution_space>
+      elem_coord_type;
 
-  typedef Kokkos::View< GradScalarType*[NSpace][NNode] , execution_space >
-    elem_grad_type ;
+  typedef Kokkos::View<GradScalarType * [NSpace][NNode], execution_space>
+      elem_grad_type;
 
-  elem_coord_type  coords ;
-  elem_grad_type   grad_op ;
+  elem_coord_type coords;
+  elem_grad_type grad_op;
 
-  enum { FLOPS  = 318 }; // = 3 * ( 18 + 8 * 11 ) };
-  enum { READS  = 18 };
+  enum { FLOPS = 318 };  // = 3 * ( 18 + 8 * 11 ) };
+  enum { READS = 18 };
   enum { WRITES = 18 };
 
-  HexGrad( const elem_coord_type  & arg_coords ,
-           const elem_grad_type   & arg_grad_op )
-    : coords( arg_coords )
-    , grad_op( arg_grad_op )
-    {}
-
-  KOKKOS_INLINE_FUNCTION static
-  void grad( const CoordScalarType x[] ,
-             const CoordScalarType z[] ,
-                   GradScalarType grad_y[] )
-  {
-    const GradScalarType R42=(x[3] - x[1]);
-    const GradScalarType R52=(x[4] - x[1]);
-    const GradScalarType R54=(x[4] - x[3]);
-
-    const GradScalarType R63=(x[5] - x[2]);
-    const GradScalarType R83=(x[7] - x[2]);
-    const GradScalarType R86=(x[7] - x[5]);
-
-    const GradScalarType R31=(x[2] - x[0]);
-    const GradScalarType R61=(x[5] - x[0]);
-    const GradScalarType R74=(x[6] - x[3]);
-
-    const GradScalarType R72=(x[6] - x[1]);
-    const GradScalarType R75=(x[6] - x[4]);
-    const GradScalarType R81=(x[7] - x[0]);
-
-    const GradScalarType t1=(R63 + R54);
-    const GradScalarType t2=(R61 + R74);
-    const GradScalarType t3=(R72 + R81);
-
-    const GradScalarType t4 =(R86 + R42);
-    const GradScalarType t5 =(R83 + R52);
-    const GradScalarType t6 =(R75 + R31);
+  HexGrad(const elem_coord_type& arg_coords, const elem_grad_type& arg_grad_op)
+      : coords(arg_coords), grad_op(arg_grad_op) {}
+
+  KOKKOS_INLINE_FUNCTION static void grad(const CoordScalarType x[],
+                                          const CoordScalarType z[],
+                                          GradScalarType grad_y[]) {
+    const GradScalarType R42 = (x[3] - x[1]);
+    const GradScalarType R52 = (x[4] - x[1]);
+    const GradScalarType R54 = (x[4] - x[3]);
+
+    const GradScalarType R63 = (x[5] - x[2]);
+    const GradScalarType R83 = (x[7] - x[2]);
+    const GradScalarType R86 = (x[7] - x[5]);
+
+    const GradScalarType R31 = (x[2] - x[0]);
+    const GradScalarType R61 = (x[5] - x[0]);
+    const GradScalarType R74 = (x[6] - x[3]);
+
+    const GradScalarType R72 = (x[6] - x[1]);
+    const GradScalarType R75 = (x[6] - x[4]);
+    const GradScalarType R81 = (x[7] - x[0]);
+
+    const GradScalarType t1 = (R63 + R54);
+    const GradScalarType t2 = (R61 + R74);
+    const GradScalarType t3 = (R72 + R81);
+
+    const GradScalarType t4 = (R86 + R42);
+    const GradScalarType t5 = (R83 + R52);
+    const GradScalarType t6 = (R75 + R31);
 
     //  Calculate Y gradient from X and Z data
 
-    grad_y[0] = (z[1] *  t1) - (z[2] * R42) - (z[3] *  t5)  + (z[4] *  t4) + (z[5] * R52) - (z[7] * R54);
-    grad_y[1] = (z[2] *  t2) + (z[3] * R31) - (z[0] *  t1)  - (z[5] *  t6) + (z[6] * R63) - (z[4] * R61);
-    grad_y[2] = (z[3] *  t3) + (z[0] * R42) - (z[1] *  t2)  - (z[6] *  t4) + (z[7] * R74) - (z[5] * R72);
-    grad_y[3] = (z[0] *  t5) - (z[1] * R31) - (z[2] *  t3)  + (z[7] *  t6) + (z[4] * R81) - (z[6] * R83);
-    grad_y[4] = (z[5] *  t3) + (z[6] * R86) - (z[7] *  t2)  - (z[0] *  t4) - (z[3] * R81) + (z[1] * R61);
-    grad_y[5] = (z[6] *  t5) - (z[4] *  t3)  - (z[7] * R75) + (z[1] *  t6) - (z[0] * R52) + (z[2] * R72);
-    grad_y[6] = (z[7] *  t1) - (z[5] *  t5)  - (z[4] * R86) + (z[2] *  t4) - (z[1] * R63) + (z[3] * R83);
-    grad_y[7] = (z[4] *  t2) - (z[6] *  t1)  + (z[5] * R75) - (z[3] *  t6) - (z[2] * R74) + (z[0] * R54);
+    grad_y[0] = (z[1] * t1) - (z[2] * R42) - (z[3] * t5) + (z[4] * t4) +
+                (z[5] * R52) - (z[7] * R54);
+    grad_y[1] = (z[2] * t2) + (z[3] * R31) - (z[0] * t1) - (z[5] * t6) +
+                (z[6] * R63) - (z[4] * R61);
+    grad_y[2] = (z[3] * t3) + (z[0] * R42) - (z[1] * t2) - (z[6] * t4) +
+                (z[7] * R74) - (z[5] * R72);
+    grad_y[3] = (z[0] * t5) - (z[1] * R31) - (z[2] * t3) + (z[7] * t6) +
+                (z[4] * R81) - (z[6] * R83);
+    grad_y[4] = (z[5] * t3) + (z[6] * R86) - (z[7] * t2) - (z[0] * t4) -
+                (z[3] * R81) + (z[1] * R61);
+    grad_y[5] = (z[6] * t5) - (z[4] * t3) - (z[7] * R75) + (z[1] * t6) -
+                (z[0] * R52) + (z[2] * R72);
+    grad_y[6] = (z[7] * t1) - (z[5] * t5) - (z[4] * R86) + (z[2] * t4) -
+                (z[1] * R63) + (z[3] * R83);
+    grad_y[7] = (z[4] * t2) - (z[6] * t1) + (z[5] * R75) - (z[3] * t6) -
+                (z[2] * R74) + (z[0] * R54);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type ielem ) const
-  {
-    GradScalarType g[NNode] ;
-
-    const CoordScalarType x[NNode] = {
-      coords(ielem,0,0),
-      coords(ielem,0,1),
-      coords(ielem,0,2),
-      coords(ielem,0,3),
-      coords(ielem,0,4),
-      coords(ielem,0,5),
-      coords(ielem,0,6),
-      coords(ielem,0,7)
-    };
-
-    const CoordScalarType y[NNode] = {
-      coords(ielem,1,0),
-      coords(ielem,1,1),
-      coords(ielem,1,2),
-      coords(ielem,1,3),
-      coords(ielem,1,4),
-      coords(ielem,1,5),
-      coords(ielem,1,6),
-      coords(ielem,1,7)
-    };
-
-    const CoordScalarType z[NNode] = {
-      coords(ielem,2,0),
-      coords(ielem,2,1),
-      coords(ielem,2,2),
-      coords(ielem,2,3),
-      coords(ielem,2,4),
-      coords(ielem,2,5),
-      coords(ielem,2,6),
-      coords(ielem,2,7)
-    };
-
-    grad( z , y , g );
-
-    grad_op(ielem,0,0) = g[0];
-    grad_op(ielem,0,1) = g[1];
-    grad_op(ielem,0,2) = g[2];
-    grad_op(ielem,0,3) = g[3];
-    grad_op(ielem,0,4) = g[4];
-    grad_op(ielem,0,5) = g[5];
-    grad_op(ielem,0,6) = g[6];
-    grad_op(ielem,0,7) = g[7];
-
-    grad( x , z , g );
-
-    grad_op(ielem,1,0) = g[0];
-    grad_op(ielem,1,1) = g[1];
-    grad_op(ielem,1,2) = g[2];
-    grad_op(ielem,1,3) = g[3];
-    grad_op(ielem,1,4) = g[4];
-    grad_op(ielem,1,5) = g[5];
-    grad_op(ielem,1,6) = g[6];
-    grad_op(ielem,1,7) = g[7];
-
-    grad( y , x , g );
-
-    grad_op(ielem,2,0) = g[0];
-    grad_op(ielem,2,1) = g[1];
-    grad_op(ielem,2,2) = g[2];
-    grad_op(ielem,2,3) = g[3];
-    grad_op(ielem,2,4) = g[4];
-    grad_op(ielem,2,5) = g[5];
-    grad_op(ielem,2,6) = g[6];
-    grad_op(ielem,2,7) = g[7];
+  void operator()(size_type ielem) const {
+    GradScalarType g[NNode];
+
+    const CoordScalarType x[NNode] = {coords(ielem, 0, 0), coords(ielem, 0, 1),
+                                      coords(ielem, 0, 2), coords(ielem, 0, 3),
+                                      coords(ielem, 0, 4), coords(ielem, 0, 5),
+                                      coords(ielem, 0, 6), coords(ielem, 0, 7)};
+
+    const CoordScalarType y[NNode] = {coords(ielem, 1, 0), coords(ielem, 1, 1),
+                                      coords(ielem, 1, 2), coords(ielem, 1, 3),
+                                      coords(ielem, 1, 4), coords(ielem, 1, 5),
+                                      coords(ielem, 1, 6), coords(ielem, 1, 7)};
+
+    const CoordScalarType z[NNode] = {coords(ielem, 2, 0), coords(ielem, 2, 1),
+                                      coords(ielem, 2, 2), coords(ielem, 2, 3),
+                                      coords(ielem, 2, 4), coords(ielem, 2, 5),
+                                      coords(ielem, 2, 6), coords(ielem, 2, 7)};
+
+    grad(z, y, g);
+
+    grad_op(ielem, 0, 0) = g[0];
+    grad_op(ielem, 0, 1) = g[1];
+    grad_op(ielem, 0, 2) = g[2];
+    grad_op(ielem, 0, 3) = g[3];
+    grad_op(ielem, 0, 4) = g[4];
+    grad_op(ielem, 0, 5) = g[5];
+    grad_op(ielem, 0, 6) = g[6];
+    grad_op(ielem, 0, 7) = g[7];
+
+    grad(x, z, g);
+
+    grad_op(ielem, 1, 0) = g[0];
+    grad_op(ielem, 1, 1) = g[1];
+    grad_op(ielem, 1, 2) = g[2];
+    grad_op(ielem, 1, 3) = g[3];
+    grad_op(ielem, 1, 4) = g[4];
+    grad_op(ielem, 1, 5) = g[5];
+    grad_op(ielem, 1, 6) = g[6];
+    grad_op(ielem, 1, 7) = g[7];
+
+    grad(y, x, g);
+
+    grad_op(ielem, 2, 0) = g[0];
+    grad_op(ielem, 2, 1) = g[1];
+    grad_op(ielem, 2, 2) = g[2];
+    grad_op(ielem, 2, 3) = g[3];
+    grad_op(ielem, 2, 4) = g[4];
+    grad_op(ielem, 2, 5) = g[5];
+    grad_op(ielem, 2, 6) = g[6];
+    grad_op(ielem, 2, 7) = g[7];
   }
 
   //--------------------------------------------------------------------------
 
   struct Init {
-    typedef typename self_type::execution_space execution_space ;
+    typedef typename self_type::execution_space execution_space;
 
-    elem_coord_type coords ;
+    elem_coord_type coords;
 
-    Init( const elem_coord_type & arg_coords )
-      : coords( arg_coords ) {}
+    Init(const elem_coord_type& arg_coords) : coords(arg_coords) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( size_type ielem ) const
-    {
-      coords(ielem,0,0) = 0.;
-      coords(ielem,1,0) = 0.;
-      coords(ielem,2,0) = 0.;
-
-      coords(ielem,0,1) = 1.;
-      coords(ielem,1,1) = 0.;
-      coords(ielem,2,1) = 0.;
-
-      coords(ielem,0,2) = 1.;
-      coords(ielem,1,2) = 1.;
-      coords(ielem,2,2) = 0.;
-
-      coords(ielem,0,3) = 0.;
-      coords(ielem,1,3) = 1.;
-      coords(ielem,2,3) = 0.;
-
-
-      coords(ielem,0,4) = 0.;
-      coords(ielem,1,4) = 0.;
-      coords(ielem,2,4) = 1.;
-
-      coords(ielem,0,5) = 1.;
-      coords(ielem,1,5) = 0.;
-      coords(ielem,2,5) = 1.;
-
-      coords(ielem,0,6) = 1.;
-      coords(ielem,1,6) = 1.;
-      coords(ielem,2,6) = 1.;
-
-      coords(ielem,0,7) = 0.;
-      coords(ielem,1,7) = 1.;
-      coords(ielem,2,7) = 1.;
+    void operator()(size_type ielem) const {
+      coords(ielem, 0, 0) = 0.;
+      coords(ielem, 1, 0) = 0.;
+      coords(ielem, 2, 0) = 0.;
+
+      coords(ielem, 0, 1) = 1.;
+      coords(ielem, 1, 1) = 0.;
+      coords(ielem, 2, 1) = 0.;
+
+      coords(ielem, 0, 2) = 1.;
+      coords(ielem, 1, 2) = 1.;
+      coords(ielem, 2, 2) = 0.;
+
+      coords(ielem, 0, 3) = 0.;
+      coords(ielem, 1, 3) = 1.;
+      coords(ielem, 2, 3) = 0.;
+
+      coords(ielem, 0, 4) = 0.;
+      coords(ielem, 1, 4) = 0.;
+      coords(ielem, 2, 4) = 1.;
+
+      coords(ielem, 0, 5) = 1.;
+      coords(ielem, 1, 5) = 0.;
+      coords(ielem, 2, 5) = 1.;
+
+      coords(ielem, 0, 6) = 1.;
+      coords(ielem, 1, 6) = 1.;
+      coords(ielem, 2, 6) = 1.;
+
+      coords(ielem, 0, 7) = 0.;
+      coords(ielem, 1, 7) = 1.;
+      coords(ielem, 2, 7) = 1.;
     }
   };
 
   //--------------------------------------------------------------------------
 
-  static double test( const int count , const int iter = 1 )
-  {
-    elem_coord_type coord( "coord" , count );
-    elem_grad_type  grad ( "grad" , count );
+  static double test(const int count, const int iter = 1) {
+    elem_coord_type coord("coord", count);
+    elem_grad_type grad("grad", count);
 
     // Execute the parallel kernels on the arrays:
 
-    double dt_min = 0 ;
+    double dt_min = 0;
 
-    Kokkos::parallel_for( count , Init( coord ) );
+    Kokkos::parallel_for(count, Init(coord));
     execution_space().fence();
 
-    for ( int i = 0 ; i < iter ; ++i ) {
-      Kokkos::Timer timer ;
-      Kokkos::parallel_for( count , HexGrad<execution_space>( coord , grad ) );
+    for (int i = 0; i < iter; ++i) {
+      Kokkos::Timer timer;
+      Kokkos::parallel_for(count, HexGrad<execution_space>(coord, grad));
       execution_space().fence();
       const double dt = timer.seconds();
-      if ( 0 == i ) dt_min = dt ;
-      else dt_min = dt < dt_min ? dt : dt_min ;
+      if (0 == i)
+        dt_min = dt;
+      else
+        dt_min = dt < dt_min ? dt : dt_min;
     }
 
-    return dt_min ;
+    return dt_min;
   }
 };
 
-template< class DeviceType >
-void run_test_hexgrad( int exp_beg , int exp_end, int num_trials, const char deviceTypeName[] )
-{
-  std::string label_hexgrad ;
-  label_hexgrad.append( "\"HexGrad< double , " );
-  label_hexgrad.append( deviceTypeName );
-  label_hexgrad.append( " >\"" );
-
-  for (int i = exp_beg ; i < exp_end ; ++i) {
-    double min_seconds = 0.0 ;
-    double max_seconds = 0.0 ;
-    double avg_seconds = 0.0 ;
-
-    const int parallel_work_length = 1<<i;
-
-    for ( int j = 0 ; j < num_trials ; ++j ) {
-      const double seconds = HexGrad< DeviceType >::test(parallel_work_length) ;
-
-      if ( 0 == j ) {
-        min_seconds = seconds ;
-        max_seconds = seconds ;
+template <class DeviceType>
+void run_test_hexgrad(int exp_beg, int exp_end, int num_trials,
+                      const char deviceTypeName[]) {
+  std::string label_hexgrad;
+  label_hexgrad.append("\"HexGrad< double , ");
+  label_hexgrad.append(deviceTypeName);
+  label_hexgrad.append(" >\"");
+
+  for (int i = exp_beg; i < exp_end; ++i) {
+    double min_seconds = 0.0;
+    double max_seconds = 0.0;
+    double avg_seconds = 0.0;
+
+    const int parallel_work_length = 1 << i;
+
+    for (int j = 0; j < num_trials; ++j) {
+      const double seconds = HexGrad<DeviceType>::test(parallel_work_length);
+
+      if (0 == j) {
+        min_seconds = seconds;
+        max_seconds = seconds;
+      } else {
+        if (seconds < min_seconds) min_seconds = seconds;
+        if (seconds > max_seconds) max_seconds = seconds;
       }
-      else {
-        if ( seconds < min_seconds ) min_seconds = seconds ;
-        if ( seconds > max_seconds ) max_seconds = seconds ;
-      }
-      avg_seconds += seconds ;
+      avg_seconds += seconds;
     }
-    avg_seconds /= num_trials ;
+    avg_seconds /= num_trials;
 
-    std::cout << label_hexgrad
-      << " , " << parallel_work_length
-      << " , " << min_seconds
-      << " , " << ( min_seconds / parallel_work_length )
-      << std::endl ;
+    std::cout << label_hexgrad << " , " << parallel_work_length << " , "
+              << min_seconds << " , " << (min_seconds / parallel_work_length)
+              << std::endl;
   }
 }
 
-TEST_F( default_exec, hexgrad ) {
-  int exp_beg = 10;
-  int exp_end = 20;
+TEST(default_exec, hexgrad) {
+  int exp_beg    = 10;
+  int exp_end    = 20;
   int num_trials = 5;
 
-  if(command_line_num_args()>1)
-    exp_beg = atoi(command_line_arg(1));
-  if(command_line_num_args()>2)
-    exp_end = atoi(command_line_arg(2));
-  if(command_line_num_args()>3)
-    num_trials = atoi(command_line_arg(3));
-
-  EXPECT_NO_THROW(run_test_hexgrad< Kokkos::DefaultExecutionSpace >( exp_beg, exp_end, num_trials, Kokkos::DefaultExecutionSpace::name() ));
-}
+  if (command_line_num_args() > 1) exp_beg = atoi(command_line_arg(1));
+  if (command_line_num_args() > 2) exp_end = atoi(command_line_arg(2));
+  if (command_line_num_args() > 3) num_trials = atoi(command_line_arg(3));
 
+  EXPECT_NO_THROW(run_test_hexgrad<Kokkos::DefaultExecutionSpace>(
+      exp_beg, exp_end, num_trials, Kokkos::DefaultExecutionSpace::name()));
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTestMDRange.hpp b/lib/kokkos/core/perf_test/PerfTestMDRange.hpp
index f433451f789265f8a41d91def0c51f42145921de..3afff96ff3d9cab6ca43ec66f172646c6719d775 100644
--- a/lib/kokkos/core/perf_test/PerfTestMDRange.hpp
+++ b/lib/kokkos/core/perf_test/PerfTestMDRange.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,24 +37,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
 namespace Test {
-template< class DeviceType 
-        , typename ScalarType = double  
-        , typename TestLayout = Kokkos::LayoutRight  
-        >
-struct MultiDimRangePerf3D
-{
+template <class DeviceType, typename ScalarType = double,
+          typename TestLayout = Kokkos::LayoutRight>
+struct MultiDimRangePerf3D {
   typedef DeviceType execution_space;
-  typedef typename execution_space::size_type  size_type;
+  typedef typename execution_space::size_type size_type;
 
   using iterate_type = Kokkos::Iterate;
 
-  typedef Kokkos::View<ScalarType***, TestLayout, DeviceType> view_type;
+  typedef Kokkos::View<ScalarType ***, TestLayout, DeviceType> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   view_type A;
@@ -62,39 +60,36 @@ struct MultiDimRangePerf3D
   const long jrange;
   const long krange;
 
-  MultiDimRangePerf3D(const view_type & A_, const view_type & B_, const long &irange_,  const long &jrange_, const long &krange_)
-  : A(A_), B(B_), irange(irange_), jrange(jrange_), krange(krange_)
-  {}
+  MultiDimRangePerf3D(const view_type &A_, const view_type &B_,
+                      const long &irange_, const long &jrange_,
+                      const long &krange_)
+      : A(A_), B(B_), irange(irange_), jrange(jrange_), krange(krange_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(const long i, const long j, const long k) const
-  {
-    A(i,j,k) = 0.25*(ScalarType)( B(i+2,j,k) + B(i+1,j,k)
-                             + B(i,j+2,k) + B(i,j+1,k)
-                             + B(i,j,k+2) + B(i,j,k+1)
-                             + B(i,j,k) );
+  void operator()(const long i, const long j, const long k) const {
+    A(i, j, k) =
+        0.25 * (ScalarType)(B(i + 2, j, k) + B(i + 1, j, k) + B(i, j + 2, k) +
+                            B(i, j + 1, k) + B(i, j, k + 2) + B(i, j, k + 1) +
+                            B(i, j, k));
   }
 
-
   struct InitZeroTag {};
-//  struct InitViewTag {};
-
-  struct Init
-  {
+  //  struct InitViewTag {};
 
-    Init(const view_type & input_, const long &irange_,  const long &jrange_, const long &krange_)
-    : input(input_), irange(irange_), jrange(jrange_), krange(krange_) {}
+  struct Init {
+    Init(const view_type &input_, const long &irange_, const long &jrange_,
+         const long &krange_)
+        : input(input_), irange(irange_), jrange(jrange_), krange(krange_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator()(const long i, const long j, const long k) const
-    {
-      input(i,j,k) = 1.0;
+    void operator()(const long i, const long j, const long k) const {
+      input(i, j, k) = 1.0;
     }
 
     KOKKOS_INLINE_FUNCTION
-    void operator()(const InitZeroTag&, const long i, const long j, const long k) const
-    {
-      input(i,j,k) = 0;
+    void operator()(const InitZeroTag &, const long i, const long j,
+                    const long k) const {
+      input(i, j, k) = 0;
     }
 
     view_type input;
@@ -103,166 +98,221 @@ struct MultiDimRangePerf3D
     const long krange;
   };
 
-
-  static double test_multi_index(const unsigned int icount, const unsigned int jcount, const unsigned int kcount, const unsigned int Ti = 1, const unsigned int Tj = 1, const unsigned int Tk = 1, const long iter = 1)
-  {
-    //This test performs multidim range over all dims
+  static double test_multi_index(const unsigned int icount,
+                                 const unsigned int jcount,
+                                 const unsigned int kcount,
+                                 const unsigned int Ti = 1,
+                                 const unsigned int Tj = 1,
+                                 const unsigned int Tk = 1,
+                                 const long iter       = 1) {
+    // This test performs multidim range over all dims
     view_type Atest("Atest", icount, jcount, kcount);
-    view_type Btest("Btest", icount+2, jcount+2, kcount+2);
-    typedef MultiDimRangePerf3D<execution_space,ScalarType,TestLayout> FunctorType;
+    view_type Btest("Btest", icount + 2, jcount + 2, kcount + 2);
+    typedef MultiDimRangePerf3D<execution_space, ScalarType, TestLayout>
+        FunctorType;
 
     double dt_min = 0;
 
     // LayoutRight
-    if ( std::is_same<TestLayout, Kokkos::LayoutRight>::value ) {
-      Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>, execution_space > policy_initA({{0,0,0}},{{icount,jcount,kcount}},{{Ti,Tj,Tk}}); 
-      Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>, execution_space > policy_initB({{0,0,0}},{{icount+2,jcount+2,kcount+2}},{{Ti,Tj,Tk}}); 
-
-      typedef typename Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>, execution_space > MDRangeType;
-      using tile_type = typename MDRangeType::tile_type;
+    if (std::is_same<TestLayout, Kokkos::LayoutRight>::value) {
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>,
+          execution_space>
+          policy_initA({{0, 0, 0}}, {{icount, jcount, kcount}}, {{Ti, Tj, Tk}});
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>,
+          execution_space>
+          policy_initB({{0, 0, 0}}, {{icount + 2, jcount + 2, kcount + 2}},
+                       {{Ti, Tj, Tk}});
+
+      typedef typename Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>,
+          execution_space>
+          MDRangeType;
+      using tile_type  = typename MDRangeType::tile_type;
       using point_type = typename MDRangeType::point_type;
 
-      Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>, execution_space > policy(point_type{{0,0,0}},point_type{{icount,jcount,kcount}},tile_type{{Ti,Tj,Tk}} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, iterate_type::Right, iterate_type::Right>,
+          execution_space>
+          policy(point_type{{0, 0, 0}}, point_type{{icount, jcount, kcount}},
+                 tile_type{{Ti, Tj, Tk}});
 
-      Kokkos::parallel_for( policy_initA, Init(Atest, icount, jcount, kcount) );
+      Kokkos::parallel_for(policy_initA, Init(Atest, icount, jcount, kcount));
       execution_space().fence();
-      Kokkos::parallel_for( policy_initB, Init(Btest, icount+2, jcount+2, kcount+2) );
+      Kokkos::parallel_for(policy_initB,
+                           Init(Btest, icount + 2, jcount + 2, kcount + 2));
       execution_space().fence();
 
-    for (int i = 0; i < iter; ++i)
-    {
-      Kokkos::Timer timer;
-      Kokkos::parallel_for( policy, FunctorType(Atest, Btest, icount, jcount, kcount) );
-      execution_space().fence();
-      const double dt = timer.seconds();
-      if ( 0 == i ) dt_min = dt ;
-      else dt_min = dt < dt_min ? dt : dt_min ;
-
-      //Correctness check - only the first run
-      if ( 0 == i )
-      {
-        long numErrors = 0;
-        host_view_type Ahost("Ahost", icount, jcount, kcount);
-        Kokkos::deep_copy(Ahost, Atest);
-        host_view_type Bhost("Bhost", icount+2, jcount+2, kcount+2);
-        Kokkos::deep_copy(Bhost, Btest);
-
-        // On KNL, this may vectorize - add print statement to prevent
-        // Also, compare against epsilon, as vectorization can change bitwise answer
-        for ( long l = 0; l < static_cast<long>(icount); ++l ) {
-        for ( long j = 0; j < static_cast<long>(jcount); ++j ) {
-        for ( long k = 0; k < static_cast<long>(kcount); ++k ) {
-          ScalarType check  = 0.25*(ScalarType)( Bhost(l+2,j,k) + Bhost(l+1,j,k)
-                                        + Bhost(l,j+2,k) + Bhost(l,j+1,k)
-                                        + Bhost(l,j,k+2) + Bhost(l,j,k+1)
-                                        + Bhost(l,j,k) );
-          if ( Ahost(l,j,k) - check != 0 ) {
-            ++numErrors;
-            std::cout << "  Correctness error at index: " << l << ","<<j<<","<<k<<"\n"
-                      << "  multi Ahost = " << Ahost(l,j,k) << "  expected = " << check  
-                      << "  multi Bhost(ijk) = " << Bhost(l,j,k) 
-                      << "  multi Bhost(l+1jk) = " << Bhost(l+1,j,k) 
-                      << "  multi Bhost(l+2jk) = " << Bhost(l+2,j,k) 
-                      << "  multi Bhost(ij+1k) = " << Bhost(l,j+1,k) 
-                      << "  multi Bhost(ij+2k) = " << Bhost(l,j+2,k) 
-                      << "  multi Bhost(ijk+1) = " << Bhost(l,j,k+1) 
-                      << "  multi Bhost(ijk+2) = " << Bhost(l,j,k+2) 
-                      << std::endl;
-            //exit(-1);
+      for (int i = 0; i < iter; ++i) {
+        Kokkos::Timer timer;
+        Kokkos::parallel_for(policy,
+                             FunctorType(Atest, Btest, icount, jcount, kcount));
+        execution_space().fence();
+        const double dt = timer.seconds();
+        if (0 == i)
+          dt_min = dt;
+        else
+          dt_min = dt < dt_min ? dt : dt_min;
+
+        // Correctness check - only the first run
+        if (0 == i) {
+          long numErrors = 0;
+          host_view_type Ahost("Ahost", icount, jcount, kcount);
+          Kokkos::deep_copy(Ahost, Atest);
+          host_view_type Bhost("Bhost", icount + 2, jcount + 2, kcount + 2);
+          Kokkos::deep_copy(Bhost, Btest);
+
+          // On KNL, this may vectorize - add print statement to prevent
+          // Also, compare against epsilon, as vectorization can change bitwise
+          // answer
+          for (long l = 0; l < static_cast<long>(icount); ++l) {
+            for (long j = 0; j < static_cast<long>(jcount); ++j) {
+              for (long k = 0; k < static_cast<long>(kcount); ++k) {
+                ScalarType check =
+                    0.25 *
+                    (ScalarType)(Bhost(l + 2, j, k) + Bhost(l + 1, j, k) +
+                                 Bhost(l, j + 2, k) + Bhost(l, j + 1, k) +
+                                 Bhost(l, j, k + 2) + Bhost(l, j, k + 1) +
+                                 Bhost(l, j, k));
+                if (Ahost(l, j, k) - check != 0) {
+                  ++numErrors;
+                  std::cout << "  Correctness error at index: " << l << "," << j
+                            << "," << k << "\n"
+                            << "  multi Ahost = " << Ahost(l, j, k)
+                            << "  expected = " << check
+                            << "  multi Bhost(ijk) = " << Bhost(l, j, k)
+                            << "  multi Bhost(l+1jk) = " << Bhost(l + 1, j, k)
+                            << "  multi Bhost(l+2jk) = " << Bhost(l + 2, j, k)
+                            << "  multi Bhost(ij+1k) = " << Bhost(l, j + 1, k)
+                            << "  multi Bhost(ij+2k) = " << Bhost(l, j + 2, k)
+                            << "  multi Bhost(ijk+1) = " << Bhost(l, j, k + 1)
+                            << "  multi Bhost(ijk+2) = " << Bhost(l, j, k + 2)
+                            << std::endl;
+                  // exit(-1);
+                }
+              }
+            }
           }
-        } } }
-        if ( numErrors != 0 ) { std::cout << "LR multi: errors " << numErrors << "  range product " << icount*jcount*kcount << "  LL " << jcount*kcount << "  LR " << icount*jcount << std::endl; }
-        //else { std::cout << " multi: No errors!" <<  std::endl; }
-      }
-    } //end for
+          if (numErrors != 0) {
+            std::cout << "LR multi: errors " << numErrors << "  range product "
+                      << icount * jcount * kcount << "  LL " << jcount * kcount
+                      << "  LR " << icount * jcount << std::endl;
+          }
+          // else { std::cout << " multi: No errors!" <<  std::endl; }
+        }
+      }  // end for
 
-    } 
+    }
     // LayoutLeft
     else {
-      Kokkos::MDRangePolicy<Kokkos::Rank<3,iterate_type::Left,iterate_type::Left>, execution_space > policy_initA({{0,0,0}},{{icount,jcount,kcount}},{{Ti,Tj,Tk}}); 
-      Kokkos::MDRangePolicy<Kokkos::Rank<3,iterate_type::Left,iterate_type::Left>, execution_space > policy_initB({{0,0,0}},{{icount+2,jcount+2,kcount+2}},{{Ti,Tj,Tk}}); 
-
-      //typedef typename Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Left, iterate_type::Left>, execution_space > MDRangeType;
-      //using tile_type = typename MDRangeType::tile_type;
-      //using point_type = typename MDRangeType::point_type;
-      //Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Left, iterate_type::Left>, execution_space > policy(point_type{{0,0,0}},point_type{{icount,jcount,kcount}},tile_type{{Ti,Tj,Tk}} );
-      Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Left, iterate_type::Left>, execution_space > policy({{0,0,0}},{{icount,jcount,kcount}},{{Ti,Tj,Tk}} ); 
-
-      Kokkos::parallel_for( policy_initA, Init(Atest, icount, jcount, kcount) );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, iterate_type::Left, iterate_type::Left>,
+          execution_space>
+          policy_initA({{0, 0, 0}}, {{icount, jcount, kcount}}, {{Ti, Tj, Tk}});
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, iterate_type::Left, iterate_type::Left>,
+          execution_space>
+          policy_initB({{0, 0, 0}}, {{icount + 2, jcount + 2, kcount + 2}},
+                       {{Ti, Tj, Tk}});
+
+      // typedef typename Kokkos::MDRangePolicy<Kokkos::Rank<3,
+      // iterate_type::Left, iterate_type::Left>, execution_space > MDRangeType;
+      // using tile_type = typename MDRangeType::tile_type;
+      // using point_type = typename MDRangeType::point_type;
+      // Kokkos::MDRangePolicy<Kokkos::Rank<3, iterate_type::Left,
+      // iterate_type::Left>, execution_space >
+      // policy(point_type{{0,0,0}},point_type{{icount,jcount,kcount}},tile_type{{Ti,Tj,Tk}}
+      // );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, iterate_type::Left, iterate_type::Left>,
+          execution_space>
+          policy({{0, 0, 0}}, {{icount, jcount, kcount}}, {{Ti, Tj, Tk}});
+
+      Kokkos::parallel_for(policy_initA, Init(Atest, icount, jcount, kcount));
       execution_space().fence();
-      Kokkos::parallel_for( policy_initB, Init(Btest, icount+2, jcount+2, kcount+2) );
+      Kokkos::parallel_for(policy_initB,
+                           Init(Btest, icount + 2, jcount + 2, kcount + 2));
       execution_space().fence();
 
-    for (int i = 0; i < iter; ++i)
-    {
-      Kokkos::Timer timer;
-      Kokkos::parallel_for( policy, FunctorType(Atest, Btest, icount, jcount, kcount) );
-      execution_space().fence();
-      const double dt = timer.seconds();
-      if ( 0 == i ) dt_min = dt ;
-      else dt_min = dt < dt_min ? dt : dt_min ;
-
-      //Correctness check - only the first run
-      if ( 0 == i )
-      {
-        long numErrors = 0;
-        host_view_type Ahost("Ahost", icount, jcount, kcount);
-        Kokkos::deep_copy(Ahost, Atest);
-        host_view_type Bhost("Bhost", icount+2, jcount+2, kcount+2);
-        Kokkos::deep_copy(Bhost, Btest);
-
-        // On KNL, this may vectorize - add print statement to prevent
-        // Also, compare against epsilon, as vectorization can change bitwise answer
-        for ( long l = 0; l < static_cast<long>(icount); ++l ) {
-        for ( long j = 0; j < static_cast<long>(jcount); ++j ) {
-        for ( long k = 0; k < static_cast<long>(kcount); ++k ) {
-          ScalarType check  = 0.25*(ScalarType)( Bhost(l+2,j,k) + Bhost(l+1,j,k)
-                                        + Bhost(l,j+2,k) + Bhost(l,j+1,k)
-                                        + Bhost(l,j,k+2) + Bhost(l,j,k+1)
-                                        + Bhost(l,j,k) );
-          if ( Ahost(l,j,k) - check != 0 ) {
-            ++numErrors;
-            std::cout << "  Correctness error at index: " << l << ","<<j<<","<<k<<"\n"
-                      << "  multi Ahost = " << Ahost(l,j,k) << "  expected = " << check  
-                      << "  multi Bhost(ijk) = " << Bhost(l,j,k) 
-                      << "  multi Bhost(l+1jk) = " << Bhost(l+1,j,k) 
-                      << "  multi Bhost(l+2jk) = " << Bhost(l+2,j,k) 
-                      << "  multi Bhost(ij+1k) = " << Bhost(l,j+1,k) 
-                      << "  multi Bhost(ij+2k) = " << Bhost(l,j+2,k) 
-                      << "  multi Bhost(ijk+1) = " << Bhost(l,j,k+1) 
-                      << "  multi Bhost(ijk+2) = " << Bhost(l,j,k+2) 
-                      << std::endl;
-            //exit(-1);
+      for (int i = 0; i < iter; ++i) {
+        Kokkos::Timer timer;
+        Kokkos::parallel_for(policy,
+                             FunctorType(Atest, Btest, icount, jcount, kcount));
+        execution_space().fence();
+        const double dt = timer.seconds();
+        if (0 == i)
+          dt_min = dt;
+        else
+          dt_min = dt < dt_min ? dt : dt_min;
+
+        // Correctness check - only the first run
+        if (0 == i) {
+          long numErrors = 0;
+          host_view_type Ahost("Ahost", icount, jcount, kcount);
+          Kokkos::deep_copy(Ahost, Atest);
+          host_view_type Bhost("Bhost", icount + 2, jcount + 2, kcount + 2);
+          Kokkos::deep_copy(Bhost, Btest);
+
+          // On KNL, this may vectorize - add print statement to prevent
+          // Also, compare against epsilon, as vectorization can change bitwise
+          // answer
+          for (long l = 0; l < static_cast<long>(icount); ++l) {
+            for (long j = 0; j < static_cast<long>(jcount); ++j) {
+              for (long k = 0; k < static_cast<long>(kcount); ++k) {
+                ScalarType check =
+                    0.25 *
+                    (ScalarType)(Bhost(l + 2, j, k) + Bhost(l + 1, j, k) +
+                                 Bhost(l, j + 2, k) + Bhost(l, j + 1, k) +
+                                 Bhost(l, j, k + 2) + Bhost(l, j, k + 1) +
+                                 Bhost(l, j, k));
+                if (Ahost(l, j, k) - check != 0) {
+                  ++numErrors;
+                  std::cout << "  Correctness error at index: " << l << "," << j
+                            << "," << k << "\n"
+                            << "  multi Ahost = " << Ahost(l, j, k)
+                            << "  expected = " << check
+                            << "  multi Bhost(ijk) = " << Bhost(l, j, k)
+                            << "  multi Bhost(l+1jk) = " << Bhost(l + 1, j, k)
+                            << "  multi Bhost(l+2jk) = " << Bhost(l + 2, j, k)
+                            << "  multi Bhost(ij+1k) = " << Bhost(l, j + 1, k)
+                            << "  multi Bhost(ij+2k) = " << Bhost(l, j + 2, k)
+                            << "  multi Bhost(ijk+1) = " << Bhost(l, j, k + 1)
+                            << "  multi Bhost(ijk+2) = " << Bhost(l, j, k + 2)
+                            << std::endl;
+                  // exit(-1);
+                }
+              }
+            }
           }
-        } } }
-        if ( numErrors != 0 ) { std::cout << " LL multi run: errors " << numErrors << "  range product " << icount*jcount*kcount << "  LL " << jcount*kcount << "  LR " << icount*jcount << std::endl; }
-        //else { std::cout << " multi: No errors!" <<  std::endl; }
-
-      }
-    } //end for
+          if (numErrors != 0) {
+            std::cout << " LL multi run: errors " << numErrors
+                      << "  range product " << icount * jcount * kcount
+                      << "  LL " << jcount * kcount << "  LR "
+                      << icount * jcount << std::endl;
+          }
+          // else { std::cout << " multi: No errors!" <<  std::endl; }
+        }
+      }  // end for
     }
 
     return dt_min;
-  } 
-
+  }
 };
 
-
-template< class DeviceType 
-        , typename ScalarType = double  
-        , typename TestLayout = Kokkos::LayoutRight  
-        >
-struct RangePolicyCollapseTwo
-{
-  // RangePolicy for 3D range, but will collapse only 2 dims => like Rank<2> for multi-dim; unroll 2 dims in one-dim
+template <class DeviceType, typename ScalarType = double,
+          typename TestLayout = Kokkos::LayoutRight>
+struct RangePolicyCollapseTwo {
+  // RangePolicy for 3D range, but will collapse only 2 dims => like Rank<2> for
+  // multi-dim; unroll 2 dims in one-dim
 
   typedef DeviceType execution_space;
-  typedef typename execution_space::size_type  size_type;
+  typedef typename execution_space::size_type size_type;
   typedef TestLayout layout;
 
   using iterate_type = Kokkos::Iterate;
 
-  typedef Kokkos::View<ScalarType***, TestLayout, DeviceType> view_type;
+  typedef Kokkos::View<ScalarType ***, TestLayout, DeviceType> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   view_type A;
@@ -271,165 +321,170 @@ struct RangePolicyCollapseTwo
   const long jrange;
   const long krange;
 
-  RangePolicyCollapseTwo(view_type & A_, const view_type & B_, const long &irange_,  const long &jrange_, const long &krange_)
-  : A(A_), B(B_) , irange(irange_), jrange(jrange_), krange(krange_)
-  {}
+  RangePolicyCollapseTwo(view_type &A_, const view_type &B_,
+                         const long &irange_, const long &jrange_,
+                         const long &krange_)
+      : A(A_), B(B_), irange(irange_), jrange(jrange_), krange(krange_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(const long r) const
-  {
-    if ( std::is_same<TestLayout, Kokkos::LayoutRight>::value )
-    {
-//id(i,j,k) = k + j*Nk + i*Nk*Nj = k + Nk*(j + i*Nj) = k + Nk*r
-//r = j + i*Nj
-      long i = int(r / jrange); 
-      long j = int( r - i*jrange);
+  void operator()(const long r) const {
+    if (std::is_same<TestLayout, Kokkos::LayoutRight>::value) {
+      // id(i,j,k) = k + j*Nk + i*Nk*Nj = k + Nk*(j + i*Nj) = k + Nk*r
+      // r = j + i*Nj
+      long i = int(r / jrange);
+      long j = int(r - i * jrange);
       for (int k = 0; k < krange; ++k) {
-        A(i,j,k) = 0.25*(ScalarType)( B(i+2,j,k) + B(i+1,j,k)
-                                 + B(i,j+2,k) + B(i,j+1,k)
-                                 + B(i,j,k+2) + B(i,j,k+1)
-                                 + B(i,j,k) );
+        A(i, j, k) =
+            0.25 * (ScalarType)(B(i + 2, j, k) + B(i + 1, j, k) +
+                                B(i, j + 2, k) + B(i, j + 1, k) +
+                                B(i, j, k + 2) + B(i, j, k + 1) + B(i, j, k));
       }
-    }
-    else if ( std::is_same<TestLayout, Kokkos::LayoutLeft>::value )
-    {
-//id(i,j,k) = i + j*Ni + k*Ni*Nj = i + Ni*(j + k*Nj) = i + Ni*r
-//r = j + k*Nj
-      long k = int(r / jrange); 
-      long j = int( r - k*jrange);
+    } else if (std::is_same<TestLayout, Kokkos::LayoutLeft>::value) {
+      // id(i,j,k) = i + j*Ni + k*Ni*Nj = i + Ni*(j + k*Nj) = i + Ni*r
+      // r = j + k*Nj
+      long k = int(r / jrange);
+      long j = int(r - k * jrange);
       for (int i = 0; i < irange; ++i) {
-        A(i,j,k) = 0.25*(ScalarType)( B(i+2,j,k) + B(i+1,j,k)
-                                 + B(i,j+2,k) + B(i,j+1,k)
-                                 + B(i,j,k+2) + B(i,j,k+1)
-                                 + B(i,j,k) );
+        A(i, j, k) =
+            0.25 * (ScalarType)(B(i + 2, j, k) + B(i + 1, j, k) +
+                                B(i, j + 2, k) + B(i, j + 1, k) +
+                                B(i, j, k + 2) + B(i, j, k + 1) + B(i, j, k));
       }
     }
   }
 
-
-  struct Init
-  {
+  struct Init {
     view_type input;
     const long irange;
     const long jrange;
     const long krange;
 
-    Init(const view_type & input_, const long &irange_,  const long &jrange_, const long &krange_)
-    : input(input_), irange(irange_), jrange(jrange_), krange(krange_) {}
+    Init(const view_type &input_, const long &irange_, const long &jrange_,
+         const long &krange_)
+        : input(input_), irange(irange_), jrange(jrange_), krange(krange_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator()(const long r) const
-    {
-      if ( std::is_same<TestLayout, Kokkos::LayoutRight>::value )
-      {
-        long i = int(r / jrange); 
-        long j = int( r - i*jrange);
+    void operator()(const long r) const {
+      if (std::is_same<TestLayout, Kokkos::LayoutRight>::value) {
+        long i = int(r / jrange);
+        long j = int(r - i * jrange);
         for (int k = 0; k < krange; ++k) {
-          input(i,j,k) = 1;
+          input(i, j, k) = 1;
         }
-      }
-      else if ( std::is_same<TestLayout, Kokkos::LayoutLeft>::value )
-      {
-        long k = int(r / jrange); 
-        long j = int( r - k*jrange);
+      } else if (std::is_same<TestLayout, Kokkos::LayoutLeft>::value) {
+        long k = int(r / jrange);
+        long j = int(r - k * jrange);
         for (int i = 0; i < irange; ++i) {
-          input(i,j,k) = 1;
+          input(i, j, k) = 1;
         }
       }
     }
   };
 
-
-  static double test_index_collapse_two(const unsigned int icount, const unsigned int jcount, const unsigned int kcount, const long iter = 1)
-  {
+  static double test_index_collapse_two(const unsigned int icount,
+                                        const unsigned int jcount,
+                                        const unsigned int kcount,
+                                        const long iter = 1) {
     // This test refers to collapsing two dims while using the RangePolicy
     view_type Atest("Atest", icount, jcount, kcount);
-    view_type Btest("Btest", icount+2, jcount+2, kcount+2);
-    typedef RangePolicyCollapseTwo<execution_space,ScalarType,TestLayout> FunctorType;
+    view_type Btest("Btest", icount + 2, jcount + 2, kcount + 2);
+    typedef RangePolicyCollapseTwo<execution_space, ScalarType, TestLayout>
+        FunctorType;
 
     long collapse_index_rangeA = 0;
     long collapse_index_rangeB = 0;
-    if ( std::is_same<TestLayout, Kokkos::LayoutRight>::value ) {
-      collapse_index_rangeA = icount*jcount;
-      collapse_index_rangeB = (icount+2)*(jcount+2);
-//      std::cout << "   LayoutRight " << std::endl;
-    } else if ( std::is_same<TestLayout, Kokkos::LayoutLeft>::value ) {
-      collapse_index_rangeA = kcount*jcount;
-      collapse_index_rangeB = (kcount+2)*(jcount+2);
-//      std::cout << "   LayoutLeft " << std::endl;
+    if (std::is_same<TestLayout, Kokkos::LayoutRight>::value) {
+      collapse_index_rangeA = icount * jcount;
+      collapse_index_rangeB = (icount + 2) * (jcount + 2);
+      //      std::cout << "   LayoutRight " << std::endl;
+    } else if (std::is_same<TestLayout, Kokkos::LayoutLeft>::value) {
+      collapse_index_rangeA = kcount * jcount;
+      collapse_index_rangeB = (kcount + 2) * (jcount + 2);
+      //      std::cout << "   LayoutLeft " << std::endl;
     } else {
-      std::cout << "  LayoutRight or LayoutLeft required - will pass 0 as range instead " << std::endl;
+      std::cout << "  LayoutRight or LayoutLeft required - will pass 0 as "
+                   "range instead "
+                << std::endl;
       exit(-1);
     }
 
-    Kokkos::RangePolicy<execution_space> policy(0, (collapse_index_rangeA) );
-    Kokkos::RangePolicy<execution_space> policy_initB(0, (collapse_index_rangeB) );
+    Kokkos::RangePolicy<execution_space> policy(0, (collapse_index_rangeA));
+    Kokkos::RangePolicy<execution_space> policy_initB(0,
+                                                      (collapse_index_rangeB));
 
     double dt_min = 0;
 
-    Kokkos::parallel_for( policy, Init(Atest,icount,jcount,kcount) );
+    Kokkos::parallel_for(policy, Init(Atest, icount, jcount, kcount));
     execution_space().fence();
-    Kokkos::parallel_for( policy_initB, Init(Btest,icount+2,jcount+2,kcount+2) );
+    Kokkos::parallel_for(policy_initB,
+                         Init(Btest, icount + 2, jcount + 2, kcount + 2));
     execution_space().fence();
 
-    for (int i = 0; i < iter; ++i)
-    {
+    for (int i = 0; i < iter; ++i) {
       Kokkos::Timer timer;
-      Kokkos::parallel_for(policy, FunctorType(Atest, Btest, icount, jcount, kcount));
+      Kokkos::parallel_for(policy,
+                           FunctorType(Atest, Btest, icount, jcount, kcount));
       execution_space().fence();
       const double dt = timer.seconds();
-      if ( 0 == i ) dt_min = dt ;
-      else dt_min = dt < dt_min ? dt : dt_min ;
+      if (0 == i)
+        dt_min = dt;
+      else
+        dt_min = dt < dt_min ? dt : dt_min;
 
-      //Correctness check - first iteration only
-      if ( 0 == i )
-      {
+      // Correctness check - first iteration only
+      if (0 == i) {
         long numErrors = 0;
         host_view_type Ahost("Ahost", icount, jcount, kcount);
         Kokkos::deep_copy(Ahost, Atest);
-        host_view_type Bhost("Bhost", icount+2, jcount+2, kcount+2);
+        host_view_type Bhost("Bhost", icount + 2, jcount + 2, kcount + 2);
         Kokkos::deep_copy(Bhost, Btest);
 
         // On KNL, this may vectorize - add print statement to prevent
-        // Also, compare against epsilon, as vectorization can change bitwise answer
-        for ( long l = 0; l < static_cast<long>(icount); ++l ) {
-        for ( long j = 0; j < static_cast<long>(jcount); ++j ) {
-        for ( long k = 0; k < static_cast<long>(kcount); ++k ) {
-          ScalarType check  = 0.25*(ScalarType)( Bhost(l+2,j,k) + Bhost(l+1,j,k)
-                                        + Bhost(l,j+2,k) + Bhost(l,j+1,k)
-                                        + Bhost(l,j,k+2) + Bhost(l,j,k+1)
-                                        + Bhost(l,j,k) );
-          if ( Ahost(l,j,k) - check != 0 ) {
-            ++numErrors;
-            std::cout << "  Correctness error at index: " << l << ","<<j<<","<<k<<"\n"
-                      << "  flat Ahost = " << Ahost(l,j,k) << "  expected = " << check  << std::endl;
-            //exit(-1);
+        // Also, compare against epsilon, as vectorization can change bitwise
+        // answer
+        for (long l = 0; l < static_cast<long>(icount); ++l) {
+          for (long j = 0; j < static_cast<long>(jcount); ++j) {
+            for (long k = 0; k < static_cast<long>(kcount); ++k) {
+              ScalarType check =
+                  0.25 * (ScalarType)(Bhost(l + 2, j, k) + Bhost(l + 1, j, k) +
+                                      Bhost(l, j + 2, k) + Bhost(l, j + 1, k) +
+                                      Bhost(l, j, k + 2) + Bhost(l, j, k + 1) +
+                                      Bhost(l, j, k));
+              if (Ahost(l, j, k) - check != 0) {
+                ++numErrors;
+                std::cout << "  Correctness error at index: " << l << "," << j
+                          << "," << k << "\n"
+                          << "  flat Ahost = " << Ahost(l, j, k)
+                          << "  expected = " << check << std::endl;
+                // exit(-1);
+              }
+            }
           }
-        } } }
-        if ( numErrors != 0 ) { std::cout << " RP collapse2: errors " << numErrors << "  range product " << icount*jcount*kcount << "  LL " << jcount*kcount << "  LR " << icount*jcount << std::endl; }
-        //else { std::cout << " RP collapse2: Pass! " << std::endl; }
+        }
+        if (numErrors != 0) {
+          std::cout << " RP collapse2: errors " << numErrors
+                    << "  range product " << icount * jcount * kcount << "  LL "
+                    << jcount * kcount << "  LR " << icount * jcount
+                    << std::endl;
+        }
+        // else { std::cout << " RP collapse2: Pass! " << std::endl; }
       }
     }
 
     return dt_min;
-  } 
-
+  }
 };
 
-
-template< class DeviceType 
-        , typename ScalarType = double  
-        , typename TestLayout = Kokkos::LayoutRight  
-        >
-struct RangePolicyCollapseAll
-{
+template <class DeviceType, typename ScalarType = double,
+          typename TestLayout = Kokkos::LayoutRight>
+struct RangePolicyCollapseAll {
   // RangePolicy for 3D range, but will collapse all dims
 
   typedef DeviceType execution_space;
-  typedef typename execution_space::size_type  size_type;
+  typedef typename execution_space::size_type size_type;
   typedef TestLayout layout;
 
-  typedef Kokkos::View<ScalarType***, TestLayout, DeviceType> view_type;
+  typedef Kokkos::View<ScalarType ***, TestLayout, DeviceType> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   view_type A;
@@ -438,127 +493,134 @@ struct RangePolicyCollapseAll
   const long jrange;
   const long krange;
 
-  RangePolicyCollapseAll(view_type & A_, const view_type & B_, const long &irange_,  const long &jrange_, const long &krange_)
-  : A(A_), B(B_), irange(irange_), jrange(jrange_), krange(krange_)
-  {}
+  RangePolicyCollapseAll(view_type &A_, const view_type &B_,
+                         const long &irange_, const long &jrange_,
+                         const long &krange_)
+      : A(A_), B(B_), irange(irange_), jrange(jrange_), krange(krange_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(const long r) const
-  {
-    if ( std::is_same<TestLayout, Kokkos::LayoutRight>::value )
-    {
-      long i = int(r / (jrange*krange)); 
-      long j = int(( r - i*jrange*krange)/krange);
-      long k = int(r - i*jrange*krange - j*krange);
-        A(i,j,k) = 0.25*(ScalarType)( B(i+2,j,k) + B(i+1,j,k)
-            + B(i,j+2,k) + B(i,j+1,k)
-            + B(i,j,k+2) + B(i,j,k+1)
-            + B(i,j,k) );
-    }
-    else if ( std::is_same<TestLayout, Kokkos::LayoutLeft>::value )
-    {
-      long k = int(r / (irange*jrange)); 
-      long j = int(( r - k*irange*jrange)/irange);
-      long i = int(r - k*irange*jrange - j*irange);
-        A(i,j,k) = 0.25*(ScalarType)( B(i+2,j,k) + B(i+1,j,k)
-            + B(i,j+2,k) + B(i,j+1,k)
-            + B(i,j,k+2) + B(i,j,k+1)
-            + B(i,j,k) );
+  void operator()(const long r) const {
+    if (std::is_same<TestLayout, Kokkos::LayoutRight>::value) {
+      long i = int(r / (jrange * krange));
+      long j = int((r - i * jrange * krange) / krange);
+      long k = int(r - i * jrange * krange - j * krange);
+      A(i, j, k) =
+          0.25 * (ScalarType)(B(i + 2, j, k) + B(i + 1, j, k) + B(i, j + 2, k) +
+                              B(i, j + 1, k) + B(i, j, k + 2) + B(i, j, k + 1) +
+                              B(i, j, k));
+    } else if (std::is_same<TestLayout, Kokkos::LayoutLeft>::value) {
+      long k = int(r / (irange * jrange));
+      long j = int((r - k * irange * jrange) / irange);
+      long i = int(r - k * irange * jrange - j * irange);
+      A(i, j, k) =
+          0.25 * (ScalarType)(B(i + 2, j, k) + B(i + 1, j, k) + B(i, j + 2, k) +
+                              B(i, j + 1, k) + B(i, j, k + 2) + B(i, j, k + 1) +
+                              B(i, j, k));
     }
   }
 
-
-  struct Init
-  {
+  struct Init {
     view_type input;
     const long irange;
     const long jrange;
     const long krange;
 
-    Init(const view_type & input_, const long &irange_,  const long &jrange_, const long &krange_)
-    : input(input_), irange(irange_), jrange(jrange_), krange(krange_) {}
+    Init(const view_type &input_, const long &irange_, const long &jrange_,
+         const long &krange_)
+        : input(input_), irange(irange_), jrange(jrange_), krange(krange_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator()(const long r) const
-    {
-      if ( std::is_same<TestLayout, Kokkos::LayoutRight>::value )
-      {
-        long i = int(r / (jrange*krange)); 
-        long j = int(( r - i*jrange*krange)/krange);
-        long k = int(r - i*jrange*krange - j*krange);
-        input(i,j,k) = 1;
-      }
-      else if ( std::is_same<TestLayout, Kokkos::LayoutLeft>::value )
-      {
-        long k = int(r / (irange*jrange));
-        long j = int(( r - k*irange*jrange)/irange);
-        long i = int(r - k*irange*jrange - j*irange);
-        input(i,j,k) = 1;
+    void operator()(const long r) const {
+      if (std::is_same<TestLayout, Kokkos::LayoutRight>::value) {
+        long i         = int(r / (jrange * krange));
+        long j         = int((r - i * jrange * krange) / krange);
+        long k         = int(r - i * jrange * krange - j * krange);
+        input(i, j, k) = 1;
+      } else if (std::is_same<TestLayout, Kokkos::LayoutLeft>::value) {
+        long k         = int(r / (irange * jrange));
+        long j         = int((r - k * irange * jrange) / irange);
+        long i         = int(r - k * irange * jrange - j * irange);
+        input(i, j, k) = 1;
       }
     }
   };
 
-
-  static double test_collapse_all(const unsigned int icount, const unsigned int jcount, const unsigned int kcount, const long iter = 1)
-  {
-    //This test refers to collapsing all dims using the RangePolicy
+  static double test_collapse_all(const unsigned int icount,
+                                  const unsigned int jcount,
+                                  const unsigned int kcount,
+                                  const long iter = 1) {
+    // This test refers to collapsing all dims using the RangePolicy
     view_type Atest("Atest", icount, jcount, kcount);
-    view_type Btest("Btest", icount+2, jcount+2, kcount+2);
-    typedef RangePolicyCollapseAll<execution_space,ScalarType,TestLayout> FunctorType;
+    view_type Btest("Btest", icount + 2, jcount + 2, kcount + 2);
+    typedef RangePolicyCollapseAll<execution_space, ScalarType, TestLayout>
+        FunctorType;
 
-    const long flat_index_range = icount*jcount*kcount;
-    Kokkos::RangePolicy<execution_space> policy(0, flat_index_range );
-    Kokkos::RangePolicy<execution_space> policy_initB(0, (icount+2)*(jcount+2)*(kcount+2) );
+    const long flat_index_range = icount * jcount * kcount;
+    Kokkos::RangePolicy<execution_space> policy(0, flat_index_range);
+    Kokkos::RangePolicy<execution_space> policy_initB(
+        0, (icount + 2) * (jcount + 2) * (kcount + 2));
 
     double dt_min = 0;
 
-    Kokkos::parallel_for( policy, Init(Atest,icount,jcount,kcount) );
+    Kokkos::parallel_for(policy, Init(Atest, icount, jcount, kcount));
     execution_space().fence();
-    Kokkos::parallel_for( policy_initB, Init(Btest,icount+2,jcount+2,kcount+2) );
+    Kokkos::parallel_for(policy_initB,
+                         Init(Btest, icount + 2, jcount + 2, kcount + 2));
     execution_space().fence();
 
-    for (int i = 0; i < iter; ++i)
-    {
+    for (int i = 0; i < iter; ++i) {
       Kokkos::Timer timer;
-      Kokkos::parallel_for(policy, FunctorType(Atest, Btest, icount, jcount, kcount));
+      Kokkos::parallel_for(policy,
+                           FunctorType(Atest, Btest, icount, jcount, kcount));
       execution_space().fence();
       const double dt = timer.seconds();
-      if ( 0 == i ) dt_min = dt ;
-      else dt_min = dt < dt_min ? dt : dt_min ;
+      if (0 == i)
+        dt_min = dt;
+      else
+        dt_min = dt < dt_min ? dt : dt_min;
 
-      //Correctness check - first iteration only
-      if ( 0 == i )
-      {
+      // Correctness check - first iteration only
+      if (0 == i) {
         long numErrors = 0;
         host_view_type Ahost("Ahost", icount, jcount, kcount);
         Kokkos::deep_copy(Ahost, Atest);
-        host_view_type Bhost("Bhost", icount+2, jcount+2, kcount+2);
+        host_view_type Bhost("Bhost", icount + 2, jcount + 2, kcount + 2);
         Kokkos::deep_copy(Bhost, Btest);
 
         // On KNL, this may vectorize - add print statement to prevent
-        // Also, compare against epsilon, as vectorization can change bitwise answer
-        for ( long l = 0; l < static_cast<long>(icount); ++l ) {
-        for ( long j = 0; j < static_cast<long>(jcount); ++j ) {
-        for ( long k = 0; k < static_cast<long>(kcount); ++k ) {
-          ScalarType check  = 0.25*(ScalarType)( Bhost(l+2,j,k) + Bhost(l+1,j,k)
-                                        + Bhost(l,j+2,k) + Bhost(l,j+1,k)
-                                        + Bhost(l,j,k+2) + Bhost(l,j,k+1)
-                                        + Bhost(l,j,k) );
-          if ( Ahost(l,j,k) - check != 0 ) {
-            ++numErrors;
-            std::cout << "  Callapse ALL Correctness error at index: " << l << ","<<j<<","<<k<<"\n"
-                      << "  flat Ahost = " << Ahost(l,j,k) << "  expected = " << check  << std::endl;
-            //exit(-1);
+        // Also, compare against epsilon, as vectorization can change bitwise
+        // answer
+        for (long l = 0; l < static_cast<long>(icount); ++l) {
+          for (long j = 0; j < static_cast<long>(jcount); ++j) {
+            for (long k = 0; k < static_cast<long>(kcount); ++k) {
+              ScalarType check =
+                  0.25 * (ScalarType)(Bhost(l + 2, j, k) + Bhost(l + 1, j, k) +
+                                      Bhost(l, j + 2, k) + Bhost(l, j + 1, k) +
+                                      Bhost(l, j, k + 2) + Bhost(l, j, k + 1) +
+                                      Bhost(l, j, k));
+              if (Ahost(l, j, k) - check != 0) {
+                ++numErrors;
+                std::cout << "  Callapse ALL Correctness error at index: " << l
+                          << "," << j << "," << k << "\n"
+                          << "  flat Ahost = " << Ahost(l, j, k)
+                          << "  expected = " << check << std::endl;
+                // exit(-1);
+              }
+            }
           }
-        } } }
-        if ( numErrors != 0 ) { std::cout << " RP collapse all: errors " << numErrors << "  range product " << icount*jcount*kcount << "  LL " << jcount*kcount << "  LR " << icount*jcount << std::endl; }
-        //else { std::cout << " RP collapse all: Pass! " << std::endl; }
+        }
+        if (numErrors != 0) {
+          std::cout << " RP collapse all: errors " << numErrors
+                    << "  range product " << icount * jcount * kcount << "  LL "
+                    << jcount * kcount << "  LR " << icount * jcount
+                    << std::endl;
+        }
+        // else { std::cout << " RP collapse all: Pass! " << std::endl; }
       }
     }
 
     return dt_min;
-  } 
-
+  }
 };
 
-} //end namespace Test
+}  // end namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTestMain.cpp b/lib/kokkos/core/perf_test/PerfTestMain.cpp
index f1f8a50f1b35fd1f3935e4097d679aa7b653a14b..8cd015fbe85ccddbddbc1f3f9afc162424071ea8 100644
--- a/lib/kokkos/core/perf_test/PerfTestMain.cpp
+++ b/lib/kokkos/core/perf_test/PerfTestMain.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,29 +50,27 @@
 namespace Test {
 int command_line_num_args(int n = 0) {
   static int n_args = 0;
-  if(n>0)
-    n_args = n;
+  if (n > 0) n_args = n;
   return n_args;
 }
 
 const char* command_line_arg(int k, char** input_args = NULL) {
   static char** args;
-  if(input_args != NULL)
-    args = input_args;
-  if(command_line_num_args() > k)
+  if (input_args != NULL) args = input_args;
+  if (command_line_num_args() > k)
     return args[k];
   else
     return NULL;
 }
 
-}
+}  // namespace Test
 
-int main(int argc, char *argv[]) {
-  ::testing::InitGoogleTest(&argc,argv);
-  Kokkos::initialize(argc,argv);
+int main(int argc, char* argv[]) {
+  ::testing::InitGoogleTest(&argc, argv);
+  Kokkos::initialize(argc, argv);
 
-  (void) Test::command_line_num_args(argc);
-  (void) Test::command_line_arg(0,argv);
+  (void)Test::command_line_num_args(argc);
+  (void)Test::command_line_arg(0, argv);
 
   int result = RUN_ALL_TESTS();
 
diff --git a/lib/kokkos/core/perf_test/PerfTest_Category.hpp b/lib/kokkos/core/perf_test/PerfTest_Category.hpp
index 18e309ab129c839abbdeef7d34b720140351654e..c2cff22502096a670e863c2c1402c5e2fe20a1c8 100644
--- a/lib/kokkos/core/perf_test/PerfTest_Category.hpp
+++ b/lib/kokkos/core/perf_test/PerfTest_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,16 +52,7 @@ namespace Test {
 extern int command_line_num_args(int n = 0);
 extern const char* command_line_arg(int k, char** input_args = NULL);
 
-class default_exec : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
+}  // namespace Test
 
 #define TEST_CATEGORY default_exec
 #define TEST_EXECSPACE Kokkos::DefaultExecutionSpace
diff --git a/lib/kokkos/core/perf_test/PerfTest_CustomReduction.cpp b/lib/kokkos/core/perf_test/PerfTest_CustomReduction.cpp
index 5c67084c6e807f1d71983292fccf25a720f1eede..d06851ec9b3cc553bb703d637782dbd68a1723da 100644
--- a/lib/kokkos/core/perf_test/PerfTest_CustomReduction.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_CustomReduction.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,71 +49,90 @@
 
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
 namespace Test {
-template<class Scalar>
+template <class Scalar>
 void custom_reduction_test(int N, int R, int num_trials) {
   Kokkos::Random_XorShift64_Pool<> rand_pool(183291);
-  Kokkos::View<Scalar*> a("A",N);
-  Kokkos::fill_random(a,rand_pool,1.0);
+  Kokkos::View<Scalar*> a("A", N);
+  Kokkos::fill_random(a, rand_pool, 1.0);
 
   Scalar max;
 
   int team_size = 32;
-  if ( team_size > Kokkos::DefaultExecutionSpace::concurrency() )
+  if (team_size > Kokkos::DefaultExecutionSpace::concurrency())
     team_size = Kokkos::DefaultExecutionSpace::concurrency();
   // Warm up
-  Kokkos::parallel_reduce(Kokkos::TeamPolicy<>(N/1024,team_size), KOKKOS_LAMBDA( const Kokkos::TeamPolicy<>::member_type& team, Scalar& lmax) {
-    Scalar team_max = Scalar(0);
-    for(int rr = 0; rr<R; rr++) {
-    int i = team.league_rank();
-    Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,32), [&] (const int& j, Scalar& thread_max) {
-      Scalar t_max = Scalar(0);
-      Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(team,32), [&] (const int& k, Scalar& max_) {
-        const Scalar val =  a((i*32 + j)*32 + k);
-        if(val>lmax) lmax = val;
-        if((k == 11) && (j==17) && (i==2)) lmax = 11.5;
-      },Kokkos::Max<Scalar>(t_max));
-      if(t_max>thread_max) thread_max = t_max;
-    },Kokkos::Max<Scalar>(team_max));
-    }
-    if(team_max>lmax) lmax = team_max;
-  },Kokkos::Max<Scalar>(max));
+  Kokkos::parallel_reduce(
+      Kokkos::TeamPolicy<>(N / 1024, team_size),
+      KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team,
+                    Scalar& lmax) {
+        Scalar team_max = Scalar(0);
+        for (int rr = 0; rr < R; rr++) {
+          int i = team.league_rank();
+          Kokkos::parallel_reduce(
+              Kokkos::TeamThreadRange(team, 32),
+              [&](const int& j, Scalar& thread_max) {
+                Scalar t_max = Scalar(0);
+                Kokkos::parallel_reduce(
+                    Kokkos::ThreadVectorRange(team, 32),
+                    [&](const int& k, Scalar& max_) {
+                      const Scalar val = a((i * 32 + j) * 32 + k);
+                      if (val > lmax) lmax = val;
+                      if ((k == 11) && (j == 17) && (i == 2)) lmax = 11.5;
+                    },
+                    Kokkos::Max<Scalar>(t_max));
+                if (t_max > thread_max) thread_max = t_max;
+              },
+              Kokkos::Max<Scalar>(team_max));
+        }
+        if (team_max > lmax) lmax = team_max;
+      },
+      Kokkos::Max<Scalar>(max));
 
   // Timing
   Kokkos::Timer timer;
-  for(int r = 0; r<num_trials; r++) {
-    Kokkos::parallel_reduce(Kokkos::TeamPolicy<>(N/1024,team_size), KOKKOS_LAMBDA( const Kokkos::TeamPolicy<>::member_type& team, Scalar& lmax) {
-      Scalar team_max = Scalar(0);
-      for(int rr = 0; rr<R; rr++) {
-      int i = team.league_rank();
-      Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,32), [&] (const int& j, Scalar& thread_max) {
-        Scalar t_max = Scalar(0);
-        Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(team,32), [&] (const int& k, Scalar& max_) {
-          const Scalar val =  a((i*32 + j)*32 + k);
-          if(val>lmax) lmax = val;
-          if((k == 11) && (j==17) && (i==2)) lmax = 11.5;
-        },Kokkos::Max<Scalar>(t_max));
-        if(t_max>thread_max) thread_max = t_max;
-      },Kokkos::Max<Scalar>(team_max));
-      }
-      if(team_max>lmax) lmax = team_max;
-    },Kokkos::Max<Scalar>(max));
+  for (int r = 0; r < num_trials; r++) {
+    Kokkos::parallel_reduce(
+        Kokkos::TeamPolicy<>(N / 1024, team_size),
+        KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team,
+                      Scalar& lmax) {
+          Scalar team_max = Scalar(0);
+          for (int rr = 0; rr < R; rr++) {
+            int i = team.league_rank();
+            Kokkos::parallel_reduce(
+                Kokkos::TeamThreadRange(team, 32),
+                [&](const int& j, Scalar& thread_max) {
+                  Scalar t_max = Scalar(0);
+                  Kokkos::parallel_reduce(
+                      Kokkos::ThreadVectorRange(team, 32),
+                      [&](const int& k, Scalar& max_) {
+                        const Scalar val = a((i * 32 + j) * 32 + k);
+                        if (val > lmax) lmax = val;
+                        if ((k == 11) && (j == 17) && (i == 2)) lmax = 11.5;
+                      },
+                      Kokkos::Max<Scalar>(t_max));
+                  if (t_max > thread_max) thread_max = t_max;
+                },
+                Kokkos::Max<Scalar>(team_max));
+          }
+          if (team_max > lmax) lmax = team_max;
+        },
+        Kokkos::Max<Scalar>(max));
   }
   double time = timer.seconds();
-  printf("%e %e %e\n",time,1.0*N*R*num_trials*sizeof(Scalar)/time/1024/1024/1024,max);
+  printf("%e %e %e\n", time,
+         1.0 * N * R * num_trials * sizeof(Scalar) / time / 1024 / 1024 / 1024,
+         max);
 }
 
-TEST_F( default_exec, custom_reduction ) {
-  int N = 100000;
-  int R = 1000;
+TEST(default_exec, custom_reduction) {
+  int N          = 100000;
+  int R          = 1000;
   int num_trials = 1;
 
-  if(command_line_num_args()>1)
-    N = atoi(command_line_arg(1));
-  if(command_line_num_args()>2)
-    R = atoi(command_line_arg(2));
-  if(command_line_num_args()>3)
-    num_trials = atoi(command_line_arg(3));
-  custom_reduction_test<double>(N,R,num_trials);
-}
+  if (command_line_num_args() > 1) N = atoi(command_line_arg(1));
+  if (command_line_num_args() > 2) R = atoi(command_line_arg(2));
+  if (command_line_num_args() > 3) num_trials = atoi(command_line_arg(3));
+  custom_reduction_test<double>(N, R, num_trials);
 }
+}  // namespace Test
 #endif
diff --git a/lib/kokkos/core/perf_test/PerfTest_ExecSpacePartitioning.cpp b/lib/kokkos/core/perf_test/PerfTest_ExecSpacePartitioning.cpp
index 2fc889beedee31030e213dc5da3359c43cbe6b1f..c6d5b2b8d647d2c997ef5fef4b19b544c14c3f0b 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ExecSpacePartitioning.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ExecSpacePartitioning.cpp
@@ -2,563 +2,631 @@
 #include <gtest/gtest.h>
 #include <PerfTest_Category.hpp>
 
-
 namespace Test {
 
 namespace {
-  template<class ExecSpace>
-  struct SpaceInstance {
-    static ExecSpace create() {
-      return ExecSpace();
-    }
-    static void destroy(ExecSpace&) {
-    }
-    static bool overlap() {
-      return false;
-    }
-  };
-
-  #ifndef KOKKOS_ENABLE_DEBUG
-  #ifdef KOKKOS_ENABLE_CUDA
-  template<>
-  struct SpaceInstance<Kokkos::Cuda> {
-    static Kokkos::Cuda create() {
-      cudaStream_t stream;
-      cudaStreamCreate(&stream);
-      return Kokkos::Cuda(stream);
-    }
-    static void destroy(Kokkos::Cuda& space) {
-      cudaStream_t stream = space.cuda_stream();
-      cudaStreamDestroy(stream);
-    }
-    static bool overlap() {
-      bool value = true;
-      auto local_rank_str = std::getenv("CUDA_LAUNCH_BLOCKING");
-      if(local_rank_str) {
-        value = (std::atoi(local_rank_str)==0);
-      }
-      return value;
+template <class ExecSpace>
+struct SpaceInstance {
+  static ExecSpace create() { return ExecSpace(); }
+  static void destroy(ExecSpace&) {}
+  static bool overlap() { return false; }
+};
+
+#ifndef KOKKOS_ENABLE_DEBUG
+#ifdef KOKKOS_ENABLE_CUDA
+template <>
+struct SpaceInstance<Kokkos::Cuda> {
+  static Kokkos::Cuda create() {
+    cudaStream_t stream;
+    cudaStreamCreate(&stream);
+    return Kokkos::Cuda(stream);
+  }
+  static void destroy(Kokkos::Cuda& space) {
+    cudaStream_t stream = space.cuda_stream();
+    cudaStreamDestroy(stream);
+  }
+  static bool overlap() {
+    bool value          = true;
+    auto local_rank_str = std::getenv("CUDA_LAUNCH_BLOCKING");
+    if (local_rank_str) {
+      value = (std::atoi(local_rank_str) == 0);
     }
-  };
-  #endif
-  #endif
-}
+    return value;
+  }
+};
+#endif
+#endif
+}  // namespace
 
 struct FunctorRange {
-  int M,R;
-  Kokkos::View<double**,TEST_EXECSPACE> a;
-  FunctorRange(int M_, int R_, Kokkos::View<double**,TEST_EXECSPACE> a_):M(M_),R(R_),a(a_){}
+  int M, R;
+  Kokkos::View<double**, TEST_EXECSPACE> a;
+  FunctorRange(int M_, int R_, Kokkos::View<double**, TEST_EXECSPACE> a_)
+      : M(M_), R(R_), a(a_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i) const {
-    for(int r=0;r<R;r++)
-    for(int j=0;j<M;j++) {
-      a(i,j)+=1.0;
-    }
+  void operator()(const int i) const {
+    for (int r = 0; r < R; r++)
+      for (int j = 0; j < M; j++) {
+        a(i, j) += 1.0;
+      }
   }
 };
 
 struct FunctorMDRange {
-  int M,R;
-  Kokkos::View<double**,TEST_EXECSPACE> a;
-  FunctorMDRange(int M_, int R_, Kokkos::View<double**,TEST_EXECSPACE> a_):M(M_),R(R_),a(a_){}
+  int M, R;
+  Kokkos::View<double**, TEST_EXECSPACE> a;
+  FunctorMDRange(int M_, int R_, Kokkos::View<double**, TEST_EXECSPACE> a_)
+      : M(M_), R(R_), a(a_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i, const int) const {
-    for(int j=0;j<M;j++)
-      a(i,j)+=1.0;
+  void operator()(const int i, const int) const {
+    for (int j = 0; j < M; j++) a(i, j) += 1.0;
   }
 };
 
 struct FunctorTeam {
-  int M,R;
-  Kokkos::View<double**,Kokkos::LayoutRight,TEST_EXECSPACE> a;
-  FunctorTeam(int M_, int R_, Kokkos::View<double**,Kokkos::LayoutRight,TEST_EXECSPACE> a_):M(M_),R(R_),a(a_){}
+  int M, R;
+  Kokkos::View<double**, Kokkos::LayoutRight, TEST_EXECSPACE> a;
+  FunctorTeam(int M_, int R_,
+              Kokkos::View<double**, Kokkos::LayoutRight, TEST_EXECSPACE> a_)
+      : M(M_), R(R_), a(a_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type& team) const {
+  void operator()(
+      const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type& team) const {
     int i = team.league_rank();
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(Kokkos::TeamThreadRange(team,M), [&] (const int j) {
-        a(i,j)+=1.0;
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(Kokkos::TeamThreadRange(team, M),
+                           [&](const int j) { a(i, j) += 1.0; });
     }
   }
 };
 
 struct FunctorRangeReduce {
-  int M,R;
-  Kokkos::View<double**,TEST_EXECSPACE> a;
-  FunctorRangeReduce(int M_, int R_, Kokkos::View<double**,TEST_EXECSPACE> a_):M(M_),R(R_),a(a_){}
+  int M, R;
+  Kokkos::View<double**, TEST_EXECSPACE> a;
+  FunctorRangeReduce(int M_, int R_, Kokkos::View<double**, TEST_EXECSPACE> a_)
+      : M(M_), R(R_), a(a_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i, double& tmp) const {
-    for(int r=0;r<R;r++)
-    for(int j=0;j<M;j++) {
-      tmp += a(i,j);
-    }
+  void operator()(const int i, double& tmp) const {
+    for (int r = 0; r < R; r++)
+      for (int j = 0; j < M; j++) {
+        tmp += a(i, j);
+      }
   }
 };
 
 struct FunctorMDRangeReduce {
-  int M,R;
-  Kokkos::View<double**,TEST_EXECSPACE> a;
-  FunctorMDRangeReduce(int M_, int R_, Kokkos::View<double**,TEST_EXECSPACE> a_):M(M_),R(R_),a(a_){}
+  int M, R;
+  Kokkos::View<double**, TEST_EXECSPACE> a;
+  FunctorMDRangeReduce(int M_, int R_,
+                       Kokkos::View<double**, TEST_EXECSPACE> a_)
+      : M(M_), R(R_), a(a_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i, const int, double& tmp) const {
-    for(int j=0;j<M;j++)
-      tmp += a(i,j);
+  void operator()(const int i, const int, double& tmp) const {
+    for (int j = 0; j < M; j++) tmp += a(i, j);
   }
 };
 
 struct FunctorTeamReduce {
-  int M,R;
-  Kokkos::View<double**,Kokkos::LayoutRight,TEST_EXECSPACE> a;
-  FunctorTeamReduce(int M_, int R_, Kokkos::View<double**,Kokkos::LayoutRight,TEST_EXECSPACE> a_):M(M_),R(R_),a(a_){}
+  int M, R;
+  Kokkos::View<double**, Kokkos::LayoutRight, TEST_EXECSPACE> a;
+  FunctorTeamReduce(
+      int M_, int R_,
+      Kokkos::View<double**, Kokkos::LayoutRight, TEST_EXECSPACE> a_)
+      : M(M_), R(R_), a(a_) {}
   KOKKOS_INLINE_FUNCTION
-  void operator() (const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type& team, double& tmp) const {
+  void operator()(const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type& team,
+                  double& tmp) const {
     int i = team.league_rank();
-    for(int r=0;r<R;r++) {
+    for (int r = 0; r < R; r++) {
       double val;
-      Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,M), [&] (const int j, double& tmp2) {
-        tmp2 += a(i,j);
-      },val);
-      tmp+=val;
+      Kokkos::parallel_reduce(
+          Kokkos::TeamThreadRange(team, M),
+          [&](const int j, double& tmp2) { tmp2 += a(i, j); }, val);
+      tmp += val;
     }
   }
 };
 
-TEST_F( default_exec, overlap_range_policy ) {
+TEST(default_exec, overlap_range_policy) {
   int N = 2000;
-   int M = 10000;
-   int R =  10;
-
-   TEST_EXECSPACE space;
-   TEST_EXECSPACE space1 = SpaceInstance<TEST_EXECSPACE>::create();
-   TEST_EXECSPACE space2 = SpaceInstance<TEST_EXECSPACE>::create();
-
-   Kokkos::View<double**,TEST_EXECSPACE> a("A",N,M);
-   FunctorRange f(M,R,a);
-   FunctorRangeReduce fr(M,R,a);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel0",
-       Kokkos::RangePolicy<TEST_EXECSPACE>(0,N), FunctorRange(M,R,a));
-
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel1",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space1,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel2",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space2,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-
-   Kokkos::Timer timer;
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel3",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel4",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-
-   timer.reset();
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel5",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space1,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorRange(M,R,a));
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel6",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space2,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorRange(M,R,a));
-   Kokkos::fence();
-   double time_overlap = timer.seconds();
-
-   timer.reset();
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel7",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel8",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-   double time_end = timer.seconds();
-
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE( (time_end > 1.5*time_overlap) );
-   }
-   printf("Time RangePolicy: NonOverlap: %lf Time Overlap: %lf\n",time_end,time_overlap);
-
-   Kokkos::View<double,TEST_EXECSPACE> result("result");
-   Kokkos::View<double,TEST_EXECSPACE> result1("result1");
-   Kokkos::View<double,TEST_EXECSPACE> result2("result2");
-   Kokkos::View<double,Kokkos::HostSpace> h_result("h_result");
-   Kokkos::View<double,Kokkos::HostSpace> h_result1("h_result1");
-   Kokkos::View<double,Kokkos::HostSpace> h_result2("h_result2");
-
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_range_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
-   Kokkos::fence();
-   double time_fenced = timer.seconds();
-   Kokkos::deep_copy(h_result,result);
-   
-   timer.reset();  
-   Kokkos::parallel_reduce("default_exec::overlap_range_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);   
-   double time_not_fenced = timer.seconds();
-   Kokkos::fence();
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE(time_fenced>2.0*time_not_fenced);
-   }
-
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_range_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
-   Kokkos::parallel_reduce("default_exec::overlap_range_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
+  int M = 10000;
+  int R = 10;
+
+  TEST_EXECSPACE space;
+  TEST_EXECSPACE space1 = SpaceInstance<TEST_EXECSPACE>::create();
+  TEST_EXECSPACE space2 = SpaceInstance<TEST_EXECSPACE>::create();
+
+  Kokkos::View<double**, TEST_EXECSPACE> a("A", N, M);
+  FunctorRange f(M, R, a);
+  FunctorRangeReduce fr(M, R, a);
+  Kokkos::parallel_for("default_exec::overlap_range_policy::kernel0",
+                       Kokkos::RangePolicy<TEST_EXECSPACE>(0, N),
+                       FunctorRange(M, R, a));
+
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel1",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel2",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+
+  Kokkos::Timer timer;
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel3",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel4",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+
+  timer.reset();
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel5",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorRange(M, R, a));
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel6",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorRange(M, R, a));
+  Kokkos::fence();
+  double time_overlap = timer.seconds();
+
+  timer.reset();
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel7",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel8",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+  double time_end = timer.seconds();
+
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE((time_end > 1.5 * time_overlap));
+  }
+  printf("Time RangePolicy: NonOverlap: %lf Time Overlap: %lf\n", time_end,
+         time_overlap);
+
+  Kokkos::View<double, TEST_EXECSPACE> result("result");
+  Kokkos::View<double, TEST_EXECSPACE> result1("result1");
+  Kokkos::View<double, TEST_EXECSPACE> result2("result2");
+  Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
+  Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
+  Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_range_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  Kokkos::fence();
+  double time_fenced = timer.seconds();
+  Kokkos::deep_copy(h_result, result);
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_range_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  double time_not_fenced = timer.seconds();
+  Kokkos::fence();
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE(time_fenced > 2.0 * time_not_fenced);
+  }
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_range_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_range_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
   Kokkos::fence();
   double time_no_overlapped_reduce = timer.seconds();
 
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_range_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space1,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result1);
-   Kokkos::parallel_reduce("default_exec::overlap_range_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::RangePolicy<TEST_EXECSPACE>(space2,0,N),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result2);
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_range_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result1);
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_range_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result2);
   Kokkos::fence();
   double time_overlapped_reduce = timer.seconds();
 
-  Kokkos::deep_copy(h_result2,result2);
-  Kokkos::deep_copy(h_result1,result1);
+  Kokkos::deep_copy(h_result2, result2);
+  Kokkos::deep_copy(h_result1, result1);
 
-  ASSERT_EQ(h_result1(),h_result()); 
-  ASSERT_EQ(h_result2(),h_result()); 
+  ASSERT_EQ(h_result1(), h_result());
+  ASSERT_EQ(h_result2(), h_result());
 
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE(time_overlapped_reduce < 1.5*time_no_overlapped_reduce);
-   }
-   printf("Time RangePolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",time_no_overlapped_reduce,time_overlapped_reduce);
-   SpaceInstance<TEST_EXECSPACE>::destroy(space1);
-   SpaceInstance<TEST_EXECSPACE>::destroy(space2);
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE(time_overlapped_reduce < 1.5 * time_no_overlapped_reduce);
+  }
+  printf("Time RangePolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",
+         time_no_overlapped_reduce, time_overlapped_reduce);
+  SpaceInstance<TEST_EXECSPACE>::destroy(space1);
+  SpaceInstance<TEST_EXECSPACE>::destroy(space2);
 }
 
-TEST_F( default_exec, overlap_mdrange_policy ) {
-   int N = 200;
-   int M = 10000;
-   int R =  10;
-
-   TEST_EXECSPACE space;
-   TEST_EXECSPACE space1 = SpaceInstance<TEST_EXECSPACE>::create();
-   TEST_EXECSPACE space2 = SpaceInstance<TEST_EXECSPACE>::create();
-
-   Kokkos::View<double**,TEST_EXECSPACE> a("A",N,M);
-   FunctorMDRange f(M,R,a);
-   FunctorMDRangeReduce fr(M,R,a);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel0",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>({0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorMDRange(M,R,a));
-
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel1",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space1,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel2",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space2,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-
-   Kokkos::Timer timer;
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel3",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel4",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-
-   timer.reset();
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel5",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space1,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorMDRange(M,R,a));
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel6",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space2,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorMDRange(M,R,a));
-   Kokkos::fence();
-   double time_overlap = timer.seconds();
-
-   timer.reset();
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel7",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel8",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-   double time_end = timer.seconds();
-
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE( (time_end > 1.5*time_overlap) );
-   }
-   printf("Time MDRangePolicy: NonOverlap: %lf Time Overlap: %lf\n",time_end,time_overlap);
-
-   Kokkos::View<double,TEST_EXECSPACE> result("result");
-   Kokkos::View<double,TEST_EXECSPACE> result1("result1");
-   Kokkos::View<double,TEST_EXECSPACE> result2("result2");
-   Kokkos::View<double,Kokkos::HostSpace> h_result("h_result");
-   Kokkos::View<double,Kokkos::HostSpace> h_result1("h_result1");
-   Kokkos::View<double,Kokkos::HostSpace> h_result2("h_result2");
-
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_mdrange_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
-   Kokkos::fence();
-   double time_fenced = timer.seconds();
-   Kokkos::deep_copy(h_result,result);
-   
-   timer.reset();  
-   Kokkos::parallel_reduce("default_exec::overlap_mdrange_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);   
-   double time_not_fenced = timer.seconds();
-   Kokkos::fence();
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE(time_fenced>2.0*time_not_fenced);
-   }
-
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_mdrange_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
-   Kokkos::parallel_reduce("default_exec::overlap_mdrange_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
+TEST(default_exec, overlap_mdrange_policy) {
+  int N = 200;
+  int M = 10000;
+  int R = 10;
+
+  TEST_EXECSPACE space;
+  TEST_EXECSPACE space1 = SpaceInstance<TEST_EXECSPACE>::create();
+  TEST_EXECSPACE space2 = SpaceInstance<TEST_EXECSPACE>::create();
+
+  Kokkos::View<double**, TEST_EXECSPACE> a("A", N, M);
+  FunctorMDRange f(M, R, a);
+  FunctorMDRangeReduce fr(M, R, a);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel0",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>({0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorMDRange(M, R, a));
+
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel1",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space1, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel2",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space2, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+
+  Kokkos::Timer timer;
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel3",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel4",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+
+  timer.reset();
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel5",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space1, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorMDRange(M, R, a));
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel6",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space2, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorMDRange(M, R, a));
+  Kokkos::fence();
+  double time_overlap = timer.seconds();
+
+  timer.reset();
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel7",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel8",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+  double time_end = timer.seconds();
+
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE((time_end > 1.5 * time_overlap));
+  }
+  printf("Time MDRangePolicy: NonOverlap: %lf Time Overlap: %lf\n", time_end,
+         time_overlap);
+
+  Kokkos::View<double, TEST_EXECSPACE> result("result");
+  Kokkos::View<double, TEST_EXECSPACE> result1("result1");
+  Kokkos::View<double, TEST_EXECSPACE> result2("result2");
+  Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
+  Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
+  Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_mdrange_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  Kokkos::fence();
+  double time_fenced = timer.seconds();
+  Kokkos::deep_copy(h_result, result);
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_mdrange_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  double time_not_fenced = timer.seconds();
+  Kokkos::fence();
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE(time_fenced > 2.0 * time_not_fenced);
+  }
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_mdrange_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_mdrange_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
   Kokkos::fence();
   double time_no_overlapped_reduce = timer.seconds();
 
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_mdrange_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space1,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result1);
-   Kokkos::parallel_reduce("default_exec::overlap_mdrange_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<2>>(space2,{0,0},{N,R}),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result2);
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_mdrange_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space1, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result1);
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_mdrange_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space2, {0, 0},
+                                                                 {N, R}),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result2);
   Kokkos::fence();
   double time_overlapped_reduce = timer.seconds();
 
-  Kokkos::deep_copy(h_result2,result2);
-  Kokkos::deep_copy(h_result1,result1);
-
-  ASSERT_EQ(h_result1(),h_result()); 
-  ASSERT_EQ(h_result2(),h_result()); 
+  Kokkos::deep_copy(h_result2, result2);
+  Kokkos::deep_copy(h_result1, result1);
 
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE(time_overlapped_reduce < 1.5*time_no_overlapped_reduce);
-   }
-   printf("Time MDRangePolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",time_no_overlapped_reduce,time_overlapped_reduce);
-   SpaceInstance<TEST_EXECSPACE>::destroy(space2);
-   SpaceInstance<TEST_EXECSPACE>::destroy(space1);
+  ASSERT_EQ(h_result1(), h_result());
+  ASSERT_EQ(h_result2(), h_result());
 
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE(time_overlapped_reduce < 1.5 * time_no_overlapped_reduce);
+  }
+  printf("Time MDRangePolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",
+         time_no_overlapped_reduce, time_overlapped_reduce);
+  SpaceInstance<TEST_EXECSPACE>::destroy(space2);
+  SpaceInstance<TEST_EXECSPACE>::destroy(space1);
 }
 
-TEST_F( default_exec, overlap_team_policy ) {
+TEST(default_exec, overlap_team_policy) {
   int N = 20;
-   int M = 1000000;
-   int R =  10;
-
-   TEST_EXECSPACE space;
-   TEST_EXECSPACE space1 = SpaceInstance<TEST_EXECSPACE>::create();
-   TEST_EXECSPACE space2 = SpaceInstance<TEST_EXECSPACE>::create();
-
-   Kokkos::View<double**,Kokkos::LayoutRight,TEST_EXECSPACE> a("A",N,M);
-   FunctorTeam f(M,R,a);
-   FunctorTeamReduce fr(M,R,a);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel0",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorTeam(M,R,a));
-
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel1",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space1,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel2",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space2,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-
-   Kokkos::Timer timer;
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel3",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel4",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-
-   timer.reset();
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel5",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space1,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorTeam(M,R,a));
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel6",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space2,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , FunctorTeam(M,R,a));
-   Kokkos::fence();
-   double time_overlap = timer.seconds();
-
-   timer.reset();
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel7",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::parallel_for("default_exec::overlap_range_policy::kernel8",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , f);
-   Kokkos::fence();
-   double time_end = timer.seconds();
-
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE( (time_end > 1.5*time_overlap) );
-   }
-   printf("Time TeamPolicy: NonOverlap: %lf Time Overlap: %lf\n",time_end,time_overlap);
-
-   Kokkos::View<double,TEST_EXECSPACE> result("result");
-   Kokkos::View<double,TEST_EXECSPACE> result1("result1");
-   Kokkos::View<double,TEST_EXECSPACE> result2("result2");
-   Kokkos::View<double,Kokkos::HostSpace> h_result("h_result");
-   Kokkos::View<double,Kokkos::HostSpace> h_result1("h_result1");
-   Kokkos::View<double,Kokkos::HostSpace> h_result2("h_result2");
-
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_team_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
-   Kokkos::fence();
-   double time_fenced = timer.seconds();
-   Kokkos::deep_copy(h_result,result);
-   
-   timer.reset();  
-   Kokkos::parallel_reduce("default_exec::overlap_team_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);   
-   double time_not_fenced = timer.seconds();
-   Kokkos::fence();
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE(time_fenced>2.0*time_not_fenced);
-   }
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_team_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
-   Kokkos::parallel_reduce("default_exec::overlap_team_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result);
+  int M = 1000000;
+  int R = 10;
+
+  TEST_EXECSPACE space;
+  TEST_EXECSPACE space1 = SpaceInstance<TEST_EXECSPACE>::create();
+  TEST_EXECSPACE space2 = SpaceInstance<TEST_EXECSPACE>::create();
+
+  Kokkos::View<double**, Kokkos::LayoutRight, TEST_EXECSPACE> a("A", N, M);
+  FunctorTeam f(M, R, a);
+  FunctorTeamReduce fr(M, R, a);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel0",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorTeam(M, R, a));
+
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel1",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel2",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+
+  Kokkos::Timer timer;
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel3",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel4",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+
+  timer.reset();
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel5",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorTeam(M, R, a));
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel6",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      FunctorTeam(M, R, a));
+  Kokkos::fence();
+  double time_overlap = timer.seconds();
+
+  timer.reset();
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel7",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::parallel_for(
+      "default_exec::overlap_range_policy::kernel8",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      f);
+  Kokkos::fence();
+  double time_end = timer.seconds();
+
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE((time_end > 1.5 * time_overlap));
+  }
+  printf("Time TeamPolicy: NonOverlap: %lf Time Overlap: %lf\n", time_end,
+         time_overlap);
+
+  Kokkos::View<double, TEST_EXECSPACE> result("result");
+  Kokkos::View<double, TEST_EXECSPACE> result1("result1");
+  Kokkos::View<double, TEST_EXECSPACE> result2("result2");
+  Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
+  Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
+  Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_team_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  Kokkos::fence();
+  double time_fenced = timer.seconds();
+  Kokkos::deep_copy(h_result, result);
+
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_team_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  double time_not_fenced = timer.seconds();
+  Kokkos::fence();
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE(time_fenced > 2.0 * time_not_fenced);
+  }
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_team_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_team_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result);
   Kokkos::fence();
   double time_no_overlapped_reduce = timer.seconds();
 
-   timer.reset();
-   Kokkos::parallel_reduce("default_exec::overlap_team_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space1,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result1);
-   Kokkos::parallel_reduce("default_exec::overlap_team_policy::kernel_reduce",
-       Kokkos::Experimental::require(
-           Kokkos::TeamPolicy<TEST_EXECSPACE>(space2,N,Kokkos::AUTO),
-           Kokkos::Experimental::WorkItemProperty::HintLightWeight)
-       , fr, result2);
+  timer.reset();
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_team_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result1);
+  Kokkos::parallel_reduce(
+      "default_exec::overlap_team_policy::kernel_reduce",
+      Kokkos::Experimental::require(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+      fr, result2);
   Kokkos::fence();
   double time_overlapped_reduce = timer.seconds();
 
-  Kokkos::deep_copy(h_result2,result2);
-  Kokkos::deep_copy(h_result1,result1);
+  Kokkos::deep_copy(h_result2, result2);
+  Kokkos::deep_copy(h_result1, result1);
 
-  ASSERT_EQ(h_result1(),h_result()); 
-  ASSERT_EQ(h_result2(),h_result()); 
+  ASSERT_EQ(h_result1(), h_result());
+  ASSERT_EQ(h_result2(), h_result());
 
-   if(SpaceInstance<TEST_EXECSPACE>::overlap()) {
-     ASSERT_TRUE(time_overlapped_reduce < 1.5*time_no_overlapped_reduce);
-   }
-   printf("Time TeamPolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",time_no_overlapped_reduce,time_overlapped_reduce);
-   SpaceInstance<TEST_EXECSPACE>::destroy(space1);
-   SpaceInstance<TEST_EXECSPACE>::destroy(space2);
-}
+  if (SpaceInstance<TEST_EXECSPACE>::overlap()) {
+    ASSERT_TRUE(time_overlapped_reduce < 1.5 * time_no_overlapped_reduce);
+  }
+  printf("Time TeamPolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",
+         time_no_overlapped_reduce, time_overlapped_reduce);
+  SpaceInstance<TEST_EXECSPACE>::destroy(space1);
+  SpaceInstance<TEST_EXECSPACE>::destroy(space2);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewAllocate.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewAllocate.cpp
index 685194c15018a4ef4b3126a3645873ca968a8a44..550316bec997121a58a8b44f6df8efdced16a623 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewAllocate.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewAllocate.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,102 +49,112 @@
 
 namespace Test {
 
-template<class Layout>
+template <class Layout>
 void run_allocateview_tests(int N, int R) {
   const int N1 = N;
-  const int N2 = N*N;
-  const int N3 = N2*N;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N * N;
+  const int N3 = N2 * N;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time1,time2,time3,time4,time5,time6,time7,time8,time_raw = 100000.0;
+  double time1, time2, time3, time4, time5, time6, time7, time8,
+      time_raw = 100000.0;
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double*,Layout> a("A1",N8);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a("A1", N8);
     }
-    time1 = timer.seconds()/R;
+    time1 = timer.seconds() / R;
   }
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double**,Layout> a("A2",N4,N4);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double**, Layout> a("A2", N4, N4);
     }
-    time2 = timer.seconds()/R;
+    time2 = timer.seconds() / R;
   }
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double***,Layout> a("A3",N3,N3,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
     }
-    time3 = timer.seconds()/R;
+    time3 = timer.seconds() / R;
   }
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double****,Layout> a("A4",N2,N2,N2,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
     }
-    time4 = timer.seconds()/R;
+    time4 = timer.seconds() / R;
   }
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double*****,Layout> a("A5",N2,N2,N1,N1,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
     }
-    time5 = timer.seconds()/R;
+    time5 = timer.seconds() / R;
   }
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double******,Layout> a("A6",N2,N1,N1,N1,N1,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
     }
-    time6 = timer.seconds()/R;
+    time6 = timer.seconds() / R;
   }
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double*******,Layout> a("A7",N2,N1,N1,N1,N1,N1,N1);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
     }
-    time7 = timer.seconds()/R;
+    time7 = timer.seconds() / R;
   }
   {
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double********,Layout> a("A8",N1,N1,N1,N1,N1,N1,N1,N1);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
+                                             N1);
     }
-    time8 = timer.seconds()/R;
+    time8 = timer.seconds() / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      double* a_ptr = (double*) Kokkos::kokkos_malloc("A", sizeof(double)*N8);
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = 0.0;
-      });
+    for (int r = 0; r < R; r++) {
+      double* a_ptr = (double*)Kokkos::kokkos_malloc("A", sizeof(double) * N8);
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 0.0; });
       Kokkos::fence();
       Kokkos::kokkos_free(a_ptr);
     }
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,size/1024/time_raw);
-  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n",time1,size,size/1024/time1);
-  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n",time2,size,size/1024/time2);
-  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n",time3,size,size/1024/time3);
-  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n",time4,size,size/1024/time4);
-  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n",time5,size,size/1024/time5);
-  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n",time6,size,size/1024/time6);
-  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n",time7,size,size/1024/time7);
-  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n",time8,size,size/1024/time8);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         size / 1024 / time_raw);
+  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n", time1, size,
+         size / 1024 / time1);
+  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n", time2, size,
+         size / 1024 / time2);
+  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n", time3, size,
+         size / 1024 / time3);
+  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n", time4, size,
+         size / 1024 / time4);
+  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n", time5, size,
+         size / 1024 / time5);
+  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n", time6, size,
+         size / 1024 / time6);
+  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n", time7, size,
+         size / 1024 / time7);
+  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n", time8, size,
+         size / 1024 / time8);
 }
 
-TEST_F( default_exec, ViewCreate ) {
+TEST(default_exec, ViewCreate) {
   printf("Create View Performance for LayoutLeft:\n");
-  run_allocateview_tests<Kokkos::LayoutLeft>(10,1);
+  run_allocateview_tests<Kokkos::LayoutLeft>(10, 1);
   printf("Create View Performance for LayoutRight:\n");
-  run_allocateview_tests<Kokkos::LayoutRight>(10,1);
+  run_allocateview_tests<Kokkos::LayoutRight>(10, 1);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy.hpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy.hpp
index eff31c69bb68c1539dc5a9d8d8c06e20bc8cd1fb..8e7bf25e809cf7649574c332af9bc35dfb0e1d94 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy.hpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,204 +49,213 @@
 
 namespace Test {
 
-template<class ViewTypeA, class ViewTypeB>
-double deepcopy_view (ViewTypeA& a, ViewTypeB& b, int repeat){
+template <class ViewTypeA, class ViewTypeB>
+double deepcopy_view(ViewTypeA& a, ViewTypeB& b, int repeat) {
   Kokkos::Timer timer;
-  for(int i=0; i<repeat; i++) {
-    Kokkos::deep_copy(a,b);
+  for (int i = 0; i < repeat; i++) {
+    Kokkos::deep_copy(a, b);
   }
   Kokkos::fence();
   return timer.seconds();
 }
 
-
-template<class LayoutA, class LayoutB>
+template <class LayoutA, class LayoutB>
 void run_deepcopyview_tests123(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N3 = N2*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N3 = N2 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time1,time2,time3,time_raw = 100000.0;
+  double time1, time2, time3, time_raw = 100000.0;
   {
-    Kokkos::View<double*,LayoutA> a("A1",N8);
-    Kokkos::View<double*,LayoutB> b("B1",N8);
-    time1 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double*, LayoutA> a("A1", N8);
+    Kokkos::View<double*, LayoutB> b("B1", N8);
+    time1 = deepcopy_view(a, b, R) / R;
   }
   {
-    Kokkos::View<double**,LayoutA> a("A2",N4,N4);
-    Kokkos::View<double**,LayoutB> b("B2",N4,N4);
-    time2 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double**, LayoutA> a("A2", N4, N4);
+    Kokkos::View<double**, LayoutB> b("B2", N4, N4);
+    time2 = deepcopy_view(a, b, R) / R;
   }
   {
-    Kokkos::View<double***,LayoutA> a("A3",N3,N3,N2);
-    Kokkos::View<double***,LayoutB> b("B3",N3,N3,N2);
-    time3 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double***, LayoutA> a("A3", N3, N3, N2);
+    Kokkos::View<double***, LayoutB> b("B3", N3, N3, N2);
+    time3 = deepcopy_view(a, b, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,LayoutA> a("A1",N8);
-    Kokkos::View<double*,LayoutB> b("B1",N8);
-    double* const a_ptr = a.data();
+    Kokkos::View<double*, LayoutA> a("A1", N8);
+    Kokkos::View<double*, LayoutB> b("B1", N8);
+    double* const a_ptr       = a.data();
     const double* const b_ptr = b.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = b_ptr[i];
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = b_ptr[i]; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n",time1,size,2.0*size/1024/time1);
-  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n",time2,size,2.0*size/1024/time2);
-  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n",time3,size,2.0*size/1024/time3);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n", time1, size,
+         2.0 * size / 1024 / time1);
+  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n", time2, size,
+         2.0 * size / 1024 / time2);
+  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n", time3, size,
+         2.0 * size / 1024 / time3);
 }
 
-template<class LayoutA, class LayoutB>
+template <class LayoutA, class LayoutB>
 void run_deepcopyview_tests45(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time4,time5,time_raw = 100000.0;
+  double time4, time5, time_raw = 100000.0;
   {
-    Kokkos::View<double****,LayoutA> a("A4",N2,N2,N2,N2);
-    Kokkos::View<double****,LayoutB> b("B4",N2,N2,N2,N2);
-    time4 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double****, LayoutA> a("A4", N2, N2, N2, N2);
+    Kokkos::View<double****, LayoutB> b("B4", N2, N2, N2, N2);
+    time4 = deepcopy_view(a, b, R) / R;
   }
   {
-    Kokkos::View<double*****,LayoutA> a("A5",N2,N2,N1,N1,N2);
-    Kokkos::View<double*****,LayoutB> b("B5",N2,N2,N1,N1,N2);
-    time5 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double*****, LayoutA> a("A5", N2, N2, N1, N1, N2);
+    Kokkos::View<double*****, LayoutB> b("B5", N2, N2, N1, N1, N2);
+    time5 = deepcopy_view(a, b, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,LayoutA> a("A1",N8);
-    Kokkos::View<double*,LayoutB> b("B1",N8);
-    double* const a_ptr = a.data();
+    Kokkos::View<double*, LayoutA> a("A1", N8);
+    Kokkos::View<double*, LayoutB> b("B1", N8);
+    double* const a_ptr       = a.data();
     const double* const b_ptr = b.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = b_ptr[i];
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = b_ptr[i]; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n",time4,size,2.0*size/1024/time4);
-  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n",time5,size,2.0*size/1024/time5);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n", time4, size,
+         2.0 * size / 1024 / time4);
+  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n", time5, size,
+         2.0 * size / 1024 / time5);
 }
 
-template<class LayoutA, class LayoutB>
+template <class LayoutA, class LayoutB>
 void run_deepcopyview_tests6(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time6,time_raw = 100000.0;
+  double time6, time_raw = 100000.0;
   {
-    Kokkos::View<double******,LayoutA> a("A6",N2,N1,N1,N1,N1,N2);
-    Kokkos::View<double******,LayoutB> b("B6",N2,N1,N1,N1,N1,N2);
-    time6 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double******, LayoutA> a("A6", N2, N1, N1, N1, N1, N2);
+    Kokkos::View<double******, LayoutB> b("B6", N2, N1, N1, N1, N1, N2);
+    time6 = deepcopy_view(a, b, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,LayoutA> a("A1",N8);
-    Kokkos::View<double*,LayoutB> b("B1",N8);
-    double* const a_ptr = a.data();
+    Kokkos::View<double*, LayoutA> a("A1", N8);
+    Kokkos::View<double*, LayoutB> b("B1", N8);
+    double* const a_ptr       = a.data();
     const double* const b_ptr = b.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = b_ptr[i];
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = b_ptr[i]; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n",time6,size,2.0*size/1024/time6);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n", time6, size,
+         2.0 * size / 1024 / time6);
 }
 
-template<class LayoutA, class LayoutB>
+template <class LayoutA, class LayoutB>
 void run_deepcopyview_tests7(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time7,time_raw = 100000.0;
+  double time7, time_raw = 100000.0;
   {
-    Kokkos::View<double*******,LayoutA> a("A7",N2,N1,N1,N1,N1,N1,N1);
-    Kokkos::View<double*******,LayoutB> b("B7",N2,N1,N1,N1,N1,N1,N1);
-    time7 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double*******, LayoutA> a("A7", N2, N1, N1, N1, N1, N1, N1);
+    Kokkos::View<double*******, LayoutB> b("B7", N2, N1, N1, N1, N1, N1, N1);
+    time7 = deepcopy_view(a, b, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,LayoutA> a("A1",N8);
-    Kokkos::View<double*,LayoutB> b("B1",N8);
-    double* const a_ptr = a.data();
+    Kokkos::View<double*, LayoutA> a("A1", N8);
+    Kokkos::View<double*, LayoutB> b("B1", N8);
+    double* const a_ptr       = a.data();
     const double* const b_ptr = b.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = b_ptr[i];
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = b_ptr[i]; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n",time7,size,2.0*size/1024/time7);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n", time7, size,
+         2.0 * size / 1024 / time7);
 }
 
-template<class LayoutA, class LayoutB>
+template <class LayoutA, class LayoutB>
 void run_deepcopyview_tests8(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time8,time_raw = 100000.0;
+  double time8, time_raw = 100000.0;
   {
-    Kokkos::View<double********,LayoutA> a("A8",N1,N1,N1,N1,N1,N1,N1,N1);
-    Kokkos::View<double********,LayoutB> b("B8",N1,N1,N1,N1,N1,N1,N1,N1);
-    time8 = deepcopy_view(a,b,R)/R;
+    Kokkos::View<double********, LayoutA> a("A8", N1, N1, N1, N1, N1, N1, N1,
+                                            N1);
+    Kokkos::View<double********, LayoutB> b("B8", N1, N1, N1, N1, N1, N1, N1,
+                                            N1);
+    time8 = deepcopy_view(a, b, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,LayoutA> a("A1",N8);
-    Kokkos::View<double*,LayoutB> b("B1",N8);
-    double* const a_ptr = a.data();
+    Kokkos::View<double*, LayoutA> a("A1", N8);
+    Kokkos::View<double*, LayoutB> b("B1", N8);
+    double* const a_ptr       = a.data();
     const double* const b_ptr = b.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = b_ptr[i];
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = b_ptr[i]; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n",time8,size,2.0*size/1024/time8);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n", time8, size,
+         2.0 * size / 1024 / time8);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a123.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a123.cpp
index 3dd2477ebb4941ca1f70cec7a8166042623ca9d8..dceef801aa8bc295403505c16e8d664d61541bf7 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a123.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a123.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftLeft_Rank123 ) {
+TEST(default_exec, ViewDeepCopy_LeftLeft_Rank123) {
   printf("DeepCopy Performance for LayoutLeft to LayoutLeft:\n");
-  run_deepcopyview_tests123<Kokkos::LayoutLeft,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests123<Kokkos::LayoutLeft, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a45.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a45.cpp
index b7fa71b06ffc53243889c1e49bd2e29b9d093364..3f9b694461211933cf4fffc7424b6fa38c47af02 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a45.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a45.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftLeft_Rank45 ) {
+TEST(default_exec, ViewDeepCopy_LeftLeft_Rank45) {
   printf("DeepCopy Performance for LayoutLeft to LayoutLeft:\n");
-  run_deepcopyview_tests45<Kokkos::LayoutLeft,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests45<Kokkos::LayoutLeft, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a6.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a6.cpp
index ee86af41b0b06ee16053c80fc7072701ad44b67a..ac364c31cbc53a002334811817220558cbc225be 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a6.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a6.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftLeft_Rank6 ) {
+TEST(default_exec, ViewDeepCopy_LeftLeft_Rank6) {
   printf("DeepCopy Performance for LayoutLeft to LayoutLeft:\n");
-  run_deepcopyview_tests6<Kokkos::LayoutLeft,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests6<Kokkos::LayoutLeft, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a7.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a7.cpp
index 5a7a78a1965c65747136a94e8d352413c7aa0bfe..94f30bac9fb529de334344a48dd20539751a4a6e 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a7.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a7.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftLeft_Rank7 ) {
+TEST(default_exec, ViewDeepCopy_LeftLeft_Rank7) {
   printf("DeepCopy Performance for LayoutLeft to LayoutLeft:\n");
-  run_deepcopyview_tests7<Kokkos::LayoutLeft,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests7<Kokkos::LayoutLeft, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a8.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a8.cpp
index cc0d7a6c2a921e7d9f64280eab6c04d81d56fd06..b916169f1b732843d2070232885cfeb87b2e64e1 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a8.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_a8.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftLeft_Rank8 ) {
+TEST(default_exec, ViewDeepCopy_LeftLeft_Rank8) {
   printf("DeepCopy Performance for LayoutLeft to LayoutLeft:\n");
-  run_deepcopyview_tests8<Kokkos::LayoutLeft,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests8<Kokkos::LayoutLeft, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b123.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b123.cpp
index eb9921d09072d2961a659821f40bb81609c4a93a..f314cb0ff43c4d1e68e81574e273b7411c25118a 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b123.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b123.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightRight_Rank123 ) {
+TEST(default_exec, ViewDeepCopy_RightRight_Rank123) {
   printf("DeepCopy Performance for LayoutRight to LayoutRight:\n");
-  run_deepcopyview_tests123<Kokkos::LayoutRight,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests123<Kokkos::LayoutRight, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b45.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b45.cpp
index b805c4c7fc624a2439c0e9b51108e97e58a05f0b..5d06f060afa91d7be89c140613f1ef93f9e1d46a 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b45.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b45.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightRight_Rank45 ) {
+TEST(default_exec, ViewDeepCopy_RightRight_Rank45) {
   printf("DeepCopy Performance for LayoutRight to LayoutRight:\n");
-  run_deepcopyview_tests45<Kokkos::LayoutRight,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests45<Kokkos::LayoutRight, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b6.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b6.cpp
index 8f350f4895c07b5fed22fc3e884a757f21874aaa..0e28fee631eb29ec1d70a38b834fc0744d45bb04 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b6.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b6.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightRight_Rank6 ) {
+TEST(default_exec, ViewDeepCopy_RightRight_Rank6) {
   printf("DeepCopy Performance for LayoutRight to LayoutRight:\n");
-  run_deepcopyview_tests6<Kokkos::LayoutRight,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests6<Kokkos::LayoutRight, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b7.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b7.cpp
index 6f82e178f9bbe9e35ec54c75202c8c452dfdcae4..37e1325fc4c0b1928dcc160e8c0a12cd364830ec 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b7.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b7.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightRight_Rank7 ) {
+TEST(default_exec, ViewDeepCopy_RightRight_Rank7) {
   printf("DeepCopy Performance for LayoutRight to LayoutRight:\n");
-  run_deepcopyview_tests7<Kokkos::LayoutRight,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests7<Kokkos::LayoutRight, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b8.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b8.cpp
index ef165c9a354cc174c3f05acffe6b853adac56704..986c39aaf447d4f6fc04e54b06e5222007e4ace9 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b8.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_b8.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightRight_Rank8 ) {
+TEST(default_exec, ViewDeepCopy_RightRight_Rank8) {
   printf("DeepCopy Performance for LayoutRight to LayoutRight:\n");
-  run_deepcopyview_tests8<Kokkos::LayoutRight,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests8<Kokkos::LayoutRight, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c123.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c123.cpp
index ebc924d9f0b33aa0b24d09987cd6247c56ece40c..b98563ee429564d1944a45426f3fd5afbc7e2e3d 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c123.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c123.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftRight_Rank123 ) {
+TEST(default_exec, ViewDeepCopy_LeftRight_Rank123) {
   printf("DeepCopy Performance for LayoutLeft to LayoutRight:\n");
-  run_deepcopyview_tests123<Kokkos::LayoutLeft,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests123<Kokkos::LayoutLeft, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c45.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c45.cpp
index a8a79356407a82af78cfe8d3a345804e74c5dd5e..a0ef11e09b8736009afcebb6fe5e3070fadcbbe0 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c45.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c45.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftRight_Rank45 ) {
+TEST(default_exec, ViewDeepCopy_LeftRight_Rank45) {
   printf("DeepCopy Performance for LayoutLeft to LayoutRight:\n");
-  run_deepcopyview_tests45<Kokkos::LayoutLeft,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests45<Kokkos::LayoutLeft, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c6.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c6.cpp
index c65c17c55b80d2623902feca71a2d93acd99a157..fea5dde73adf69ec45bd8d6549882102dd4cbddc 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c6.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c6.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftRight_Rank6 ) {
+TEST(default_exec, ViewDeepCopy_LeftRight_Rank6) {
   printf("DeepCopy Performance for LayoutLeft to LayoutRight:\n");
-  run_deepcopyview_tests6<Kokkos::LayoutLeft,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests6<Kokkos::LayoutLeft, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c7.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c7.cpp
index 48fcf053e6aa730883548259f006faf977f63f6c..a8c8d866f927a40f7d6b29a759a6fadeda7c96e4 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c7.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c7.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftRight_Rank7 ) {
+TEST(default_exec, ViewDeepCopy_LeftRight_Rank7) {
   printf("DeepCopy Performance for LayoutLeft to LayoutRight:\n");
-  run_deepcopyview_tests7<Kokkos::LayoutLeft,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests7<Kokkos::LayoutLeft, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c8.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c8.cpp
index 46e5798c8f5b84e244ae39b48c0f44bae5b5327e..e5abdaa5d81f9e147a9180b54a0a897b40ee08a0 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c8.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_c8.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_LeftRight_Rank8 ) {
+TEST(default_exec, ViewDeepCopy_LeftRight_Rank8) {
   printf("DeepCopy Performance for LayoutLeft to LayoutRight:\n");
-  run_deepcopyview_tests8<Kokkos::LayoutLeft,Kokkos::LayoutRight>(10,1);
-}
+  run_deepcopyview_tests8<Kokkos::LayoutLeft, Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d123.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d123.cpp
index ad0f455cfcb5fb21a601a5a24585f5caefd07411..2b58f8dd1f6b2554f2aeaa89052e0d52403da118 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d123.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d123.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightLeft_Rank123 ) {
+TEST(default_exec, ViewDeepCopy_RightLeft_Rank123) {
   printf("DeepCopy Performance for LayoutRight to LayoutLeft:\n");
-  run_deepcopyview_tests123<Kokkos::LayoutRight,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests123<Kokkos::LayoutRight, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d45.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d45.cpp
index 4853e343dd677f67d714906fb4e36ed427eac8c5..fe34e4fd1a84a1960a37893bc0e8dfd26ed0a42f 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d45.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d45.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightLeft_Rank45 ) {
+TEST(default_exec, ViewDeepCopy_RightLeft_Rank45) {
   printf("DeepCopy Performance for LayoutRight to LayoutLeft:\n");
-  run_deepcopyview_tests45<Kokkos::LayoutRight,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests45<Kokkos::LayoutRight, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d6.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d6.cpp
index 1ce10414585a66f132b7b5c05cc9fee205c3e815..115b223e68b88b297d96cfe9fe6db7fdd9c5591c 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d6.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d6.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightLeft_Rank6 ) {
+TEST(default_exec, ViewDeepCopy_RightLeft_Rank6) {
   printf("DeepCopy Performance for LayoutRight to LayoutLeft:\n");
-  run_deepcopyview_tests6<Kokkos::LayoutRight,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests6<Kokkos::LayoutRight, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d7.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d7.cpp
index af73733e64dce559ba97c2b4918149a1e7cf5a17..51e88795e73a9b802c6410a99e63190c1cdb91eb 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d7.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d7.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightLeft_Rank7 ) {
+TEST(default_exec, ViewDeepCopy_RightLeft_Rank7) {
   printf("DeepCopy Performance for LayoutRight to LayoutLeft:\n");
-  run_deepcopyview_tests7<Kokkos::LayoutRight,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests7<Kokkos::LayoutRight, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d8.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d8.cpp
index 3c9b9934cb85b3e95c11fe7afab5d515164ba0a6..2a53cdef213079833e3c1c4b48b760e643dc7f23 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d8.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewCopy_d8.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,10 +42,10 @@
 //@HEADER
 */
 
-#include<PerfTest_ViewCopy.hpp>
+#include <PerfTest_ViewCopy.hpp>
 namespace Test {
-TEST_F( default_exec, ViewDeepCopy_RightLeft_Rank8 ) {
+TEST(default_exec, ViewDeepCopy_RightLeft_Rank8) {
   printf("DeepCopy Performance for LayoutRight to LayoutLeft:\n");
-  run_deepcopyview_tests8<Kokkos::LayoutRight,Kokkos::LayoutLeft>(10,1);
-}
+  run_deepcopyview_tests8<Kokkos::LayoutRight, Kokkos::LayoutLeft>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewFill.hpp b/lib/kokkos/core/perf_test/PerfTest_ViewFill.hpp
index b17356f0c85969dc8fb202183cb2dfb1a823e030..38be4bb212c8527ccb246712dc5c2d8b32d53a56 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewFill.hpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewFill.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,186 +49,195 @@
 
 namespace Test {
 
-template<class ViewType>
-double fill_view (ViewType& a, typename ViewType::const_value_type& val, int repeat){
+template <class ViewType>
+double fill_view(ViewType& a, typename ViewType::const_value_type& val,
+                 int repeat) {
   Kokkos::Timer timer;
-  for(int i=0; i<repeat; i++) {
-    Kokkos::deep_copy(a,val);
+  for (int i = 0; i < repeat; i++) {
+    Kokkos::deep_copy(a, val);
   }
   Kokkos::fence();
   return timer.seconds();
 }
 
-
-template<class Layout>
+template <class Layout>
 void run_fillview_tests123(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N3 = N2*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N3 = N2 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time1,time2,time3,time_raw = 100000.0;
+  double time1, time2, time3, time_raw = 100000.0;
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
-    time1 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double*, Layout> a("A1", N8);
+    time1 = fill_view(a, 1.1, R) / R;
   }
   {
-    Kokkos::View<double**,Layout> a("A2",N4,N4);
-    time2 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double**, Layout> a("A2", N4, N4);
+    time2 = fill_view(a, 1.1, R) / R;
   }
   {
-    Kokkos::View<double***,Layout> a("A3",N3,N3,N2);
-    time3 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
+    time3 = fill_view(a, 1.1, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = 1.1;
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,size/1024/time_raw);
-  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n",time1,size,size/1024/time1);
-  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n",time2,size,size/1024/time2);
-  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n",time3,size,size/1024/time3);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         size / 1024 / time_raw);
+  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n", time1, size,
+         size / 1024 / time1);
+  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n", time2, size,
+         size / 1024 / time2);
+  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n", time3, size,
+         size / 1024 / time3);
 }
 
-template<class Layout>
+template <class Layout>
 void run_fillview_tests45(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time4,time5,time_raw = 100000.0;
+  double time4, time5, time_raw = 100000.0;
   {
-    Kokkos::View<double****,Layout> a("A4",N2,N2,N2,N2);
-    time4 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+    time4 = fill_view(a, 1.1, R) / R;
   }
   {
-    Kokkos::View<double*****,Layout> a("A5",N2,N2,N1,N1,N2);
-    time5 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+    time5 = fill_view(a, 1.1, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = 1.1;
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,size/1024/time_raw);
-  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n",time4,size,size/1024/time4);
-  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n",time5,size,size/1024/time5);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         size / 1024 / time_raw);
+  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n", time4, size,
+         size / 1024 / time4);
+  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n", time5, size,
+         size / 1024 / time5);
 }
 
-template<class Layout>
+template <class Layout>
 void run_fillview_tests6(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time6,time_raw = 100000.0;
+  double time6, time_raw = 100000.0;
   {
-    Kokkos::View<double******,Layout> a("A6",N2,N1,N1,N1,N1,N2);
-    time6 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+    time6 = fill_view(a, 1.1, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = 1.1;
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,size/1024/time_raw);
-  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n",time6,size,size/1024/time6);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         size / 1024 / time_raw);
+  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n", time6, size,
+         size / 1024 / time6);
 }
 
-template<class Layout>
+template <class Layout>
 void run_fillview_tests7(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time7,time_raw = 100000.0;
+  double time7, time_raw = 100000.0;
   {
-    Kokkos::View<double*******,Layout> a("A7",N2,N1,N1,N1,N1,N1,N1);
-    time7 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
+    time7 = fill_view(a, 1.1, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = 1.1;
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,size/1024/time_raw);
-  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n",time7,size,size/1024/time7);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         size / 1024 / time_raw);
+  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n", time7, size,
+         size / 1024 / time7);
 }
 
-template<class Layout>
+template <class Layout>
 void run_fillview_tests8(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time8,time_raw = 100000.0;
+  double time8, time_raw = 100000.0;
   {
-    Kokkos::View<double********,Layout> a("A8",N1,N1,N1,N1,N1,N1,N1,N1);
-    time8 = fill_view(a,1.1,R)/R;
+    Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
+                                           N1);
+    time8 = fill_view(a, 1.1, R) / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a_ptr[i] = 1.1;
-      });
+    for (int r = 0; r < R; r++) {
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,size/1024/time_raw);
-  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n",time8,size,size/1024/time8);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         size / 1024 / time_raw);
+  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n", time8, size,
+         size / 1024 / time8);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewFill_123.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewFill_123.cpp
index 6b1a4a6bd68dfdf230aa70c68a30334da3441f13..0bf8a28329e8993282e407955fe96b5caaabb5e3 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewFill_123.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewFill_123.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,10 +45,10 @@
 #include <PerfTest_ViewFill.hpp>
 
 namespace Test {
-TEST_F( default_exec, ViewFill_Rank123 ) {
+TEST(default_exec, ViewFill_Rank123) {
   printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests123<Kokkos::LayoutLeft>(10,1);
+  run_fillview_tests123<Kokkos::LayoutLeft>(10, 1);
   printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests123<Kokkos::LayoutRight>(10,1);
-}
+  run_fillview_tests123<Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewFill_45.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewFill_45.cpp
index e1d1b6900d3f30c4b014f1abc51e8e604a491f7d..53ac509da804c3fa6766f956fe9e2eabdbc27e01 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewFill_45.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewFill_45.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,10 +45,10 @@
 #include <PerfTest_ViewFill.hpp>
 
 namespace Test {
-TEST_F( default_exec, ViewFill_Rank45 ) {
+TEST(default_exec, ViewFill_Rank45) {
   printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests45<Kokkos::LayoutLeft>(10,1);
+  run_fillview_tests45<Kokkos::LayoutLeft>(10, 1);
   printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests45<Kokkos::LayoutRight>(10,1);
-}
+  run_fillview_tests45<Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewFill_6.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewFill_6.cpp
index 571867937e19613d0f54ff51eef8e4c19408ceb7..f0a2e248f238542084917497dec7c203a254a6fc 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewFill_6.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewFill_6.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,10 +45,10 @@
 #include <PerfTest_ViewFill.hpp>
 
 namespace Test {
-TEST_F( default_exec, ViewFill_Rank6 ) {
+TEST(default_exec, ViewFill_Rank6) {
   printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests6<Kokkos::LayoutLeft>(10,1);
+  run_fillview_tests6<Kokkos::LayoutLeft>(10, 1);
   printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests6<Kokkos::LayoutRight>(10,1);
-}
+  run_fillview_tests6<Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewFill_7.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewFill_7.cpp
index 9b89c8fc7b248026485b54c490f90e3aed3616d2..675d9e636f27577b1deaa9202de5f21770163f8d 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewFill_7.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewFill_7.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,10 +45,10 @@
 #include <PerfTest_ViewFill.hpp>
 
 namespace Test {
-TEST_F( default_exec, ViewFill_Rank7 ) {
+TEST(default_exec, ViewFill_Rank7) {
   printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests7<Kokkos::LayoutLeft>(10,1);
+  run_fillview_tests7<Kokkos::LayoutLeft>(10, 1);
   printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests7<Kokkos::LayoutRight>(10,1);
-}
+  run_fillview_tests7<Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewFill_8.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewFill_8.cpp
index 4d3df5035422ff1343ad238ffc742f138fc8be1f..35e1e81c43dbc6e36f6760694529d3b175b8d7d1 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewFill_8.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewFill_8.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,10 +45,10 @@
 #include <PerfTest_ViewFill.hpp>
 
 namespace Test {
-TEST_F( default_exec, ViewFill_Rank8 ) {
+TEST(default_exec, ViewFill_Rank8) {
   printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests8<Kokkos::LayoutLeft>(10,1);
+  run_fillview_tests8<Kokkos::LayoutLeft>(10, 1);
   printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests8<Kokkos::LayoutRight>(10,1);
-}
+  run_fillview_tests8<Kokkos::LayoutRight>(10, 1);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewResize.hpp b/lib/kokkos/core/perf_test/PerfTest_ViewResize.hpp
index b5019b467a3d3c62309bfb871ad2cf43b4658e5e..2ea81b5046278430309557419000fa750a079e78 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewResize.hpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewResize.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,230 +49,340 @@
 
 namespace Test {
 
-template<class Layout>
+template <class Layout>
 void run_resizeview_tests123(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N3 = N2*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N3 = N2 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time1,time2,time3,time_raw = 100000.0;
+  double time1, time2, time3, time_raw = 100000.0;
+  double time1_noinit, time2_noinit, time3_noinit;
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double*,Layout> a_(a);
-      Kokkos::resize(a_,int(N8*1.1));
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a_(a);
+      Kokkos::resize(a_, int(N8 * 1.1));
     }
-    time1 = timer.seconds()/R;
+    time1 = timer.seconds() / R;
   }
   {
-    Kokkos::View<double**,Layout> a("A2",N4,N4);
+    Kokkos::View<double**, Layout> a("A2", N4, N4);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double**,Layout> a_(a);
-      Kokkos::resize(a_,int(N4*1.1),N4);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double**, Layout> a_(a);
+      Kokkos::resize(a_, int(N4 * 1.1), N4);
     }
-    time2 = timer.seconds()/R;
+    time2 = timer.seconds() / R;
   }
   {
-    Kokkos::View<double***,Layout> a("A3",N3,N3,N2);
+    Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double***,Layout> a_(a);
-      Kokkos::resize(a_,int(N3*1.1),N3,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double***, Layout> a_(a);
+      Kokkos::resize(a_, int(N3 * 1.1), N3, N2);
     }
-    time3 = timer.seconds()/R;
+    time3 = timer.seconds() / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N8 * 1.1));
+    }
+    time1_noinit = timer.seconds() / R;
+  }
+  {
+    Kokkos::View<double**, Layout> a("A2", N4, N4);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double**, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N4 * 1.1), N4);
+    }
+    time2_noinit = timer.seconds() / R;
+  }
+  {
+    Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double***, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N3 * 1.1), N3, N2);
+    }
+    time3_noinit = timer.seconds() / R;
+  }
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+  {
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::View<double*,Layout> a1(Kokkos::ViewAllocateWithoutInitializing("A1"),int(N8*1.1));
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a1(
+          Kokkos::ViewAllocateWithoutInitializing("A1"), int(N8 * 1.1));
       double* a1_ptr = a1.data();
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a1_ptr[i] = a_ptr[i];
-      });
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
       Kokkos::fence();
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n",time1,size,2.0*size/1024/time1);
-  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n",time2,size,2.0*size/1024/time2);
-  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n",time3,size,2.0*size/1024/time3);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n", time1, size,
+         2.0 * size / 1024 / time1);
+  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n", time2, size,
+         2.0 * size / 1024 / time2);
+  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n", time3, size,
+         2.0 * size / 1024 / time3);
+  printf("   Rank1 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time1_noinit, size, 2.0 * size / 1024 / time1_noinit);
+  printf("   Rank2 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time2_noinit, size, 2.0 * size / 1024 / time2_noinit);
+  printf("   Rank3 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time3_noinit, size, 2.0 * size / 1024 / time3_noinit);
 }
 
-template<class Layout>
+template <class Layout>
 void run_resizeview_tests45(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time4,time5,time_raw = 100000.0;
+  double time4, time5, time_raw = 100000.0;
+  double time4_noinit, time5_noinit;
+  {
+    Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double****, Layout> a_(a);
+      Kokkos::resize(a_, int(N2 * 1.1), N2, N2, N2);
+    }
+    time4 = timer.seconds() / R;
+  }
   {
-    Kokkos::View<double****,Layout> a("A4",N2,N2,N2,N2);
+    Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double****,Layout> a_(a);
-      Kokkos::resize(a_,int(N2*1.1),N2,N2,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*****, Layout> a_(a);
+      Kokkos::resize(a_, int(N2 * 1.1), N2, N1, N1, N2);
     }
-    time4 = timer.seconds()/R;
+    time5 = timer.seconds() / R;
   }
   {
-    Kokkos::View<double*****,Layout> a("A5",N2,N2,N1,N1,N2);
+    Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double*****,Layout> a_(a);
-      Kokkos::resize(a_,int(N2*1.1),N2,N1,N1,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double****, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N2, N2,
+                     N2);
     }
-    time5 = timer.seconds()/R;
+    time4_noinit = timer.seconds() / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*****, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N2, N1, N1,
+                     N2);
+    }
+    time5_noinit = timer.seconds() / R;
+  }
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+  {
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::View<double*,Layout> a1(Kokkos::ViewAllocateWithoutInitializing("A1"),int(N8*1.1));
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a1(
+          Kokkos::ViewAllocateWithoutInitializing("A1"), int(N8 * 1.1));
       double* a1_ptr = a1.data();
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a1_ptr[i] = a_ptr[i];
-      });
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
       Kokkos::fence();
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n",time4,size,2.0*size/1024/time4);
-  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n",time5,size,2.0*size/1024/time5);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n", time4, size,
+         2.0 * size / 1024 / time4);
+  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n", time5, size,
+         2.0 * size / 1024 / time5);
+  printf("   Rank4 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time4_noinit, size, 2.0 * size / 1024 / time4_noinit);
+  printf("   Rank5 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time5_noinit, size, 2.0 * size / 1024 / time5_noinit);
 }
 
-template<class Layout>
+template <class Layout>
 void run_resizeview_tests6(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time6,time_raw = 100000.0;
+  double time6, time6_noinit, time_raw = 100000.0;
+  {
+    Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double******, Layout> a_(a);
+      Kokkos::resize(a_, int(N2 * 1.1), N1, N1, N1, N1, N2);
+    }
+    time6 = timer.seconds() / R;
+  }
   {
-    Kokkos::View<double******,Layout> a("A6",N2,N1,N1,N1,N1,N2);
+    Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double******,Layout> a_(a);
-      Kokkos::resize(a_,int(N2*1.1),N1,N1,N1,N1,N2);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double******, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N1, N1, N1,
+                     N1, N2);
     }
-    time6 = timer.seconds()/R;
+    time6_noinit = timer.seconds() / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::View<double*,Layout> a1(Kokkos::ViewAllocateWithoutInitializing("A1"),int(N8*1.1));
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a1(
+          Kokkos::ViewAllocateWithoutInitializing("A1"), int(N8 * 1.1));
       double* a1_ptr = a1.data();
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a1_ptr[i] = a_ptr[i];
-      });
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
       Kokkos::fence();
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n",time6,size,2.0*size/1024/time6);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n", time6, size,
+         2.0 * size / 1024 / time6);
+  printf("   Rank6 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time6_noinit, size, 2.0 * size / 1024 / time6_noinit);
 }
 
-template<class Layout>
+template <class Layout>
 void run_resizeview_tests7(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time7,time_raw = 100000.0;
+  double time7, time7_noinit, time_raw = 100000.0;
+  {
+    Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*******, Layout> a_(a);
+      Kokkos::resize(a_, int(N2 * 1.1), N1, N1, N1, N1, N1, N1);
+    }
+    time7 = timer.seconds() / R;
+  }
   {
-    Kokkos::View<double*******,Layout> a("A7",N2,N1,N1,N1,N1,N1,N1);
+    Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double*******,Layout> a_(a);
-      Kokkos::resize(a_,int(N2*1.1),N1,N1,N1,N1,N1,N1);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*******, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N1, N1, N1,
+                     N1, N1, N1);
     }
-    time7 = timer.seconds()/R;
+    time7_noinit = timer.seconds() / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::View<double*,Layout> a1(Kokkos::ViewAllocateWithoutInitializing("A1"),int(N8*1.1));
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a1(
+          Kokkos::ViewAllocateWithoutInitializing("A1"), int(N8 * 1.1));
       double* a1_ptr = a1.data();
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a1_ptr[i] = a_ptr[i];
-      });
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
       Kokkos::fence();
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n",time7,size,2.0*size/1024/time7);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n", time7, size,
+         2.0 * size / 1024 / time7);
+  printf("   Rank7 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time7_noinit, size, 2.0 * size / 1024 / time7_noinit);
 }
 
-template<class Layout>
+template <class Layout>
 void run_resizeview_tests8(int N, int R) {
   const int N1 = N;
-  const int N2 = N1*N1;
-  const int N4 = N2*N2;
-  const int N8 = N4*N4;
+  const int N2 = N1 * N1;
+  const int N4 = N2 * N2;
+  const int N8 = N4 * N4;
 
-  double time8,time_raw = 100000.0;
+  double time8, time8_noinit, time_raw = 100000.0;
+  {
+    Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
+                                           N1);
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double********, Layout> a_(a);
+      Kokkos::resize(a_, int(N1 * 1.1), N1, N1, N1, N1, N1, N1, N1);
+    }
+    time8 = timer.seconds() / R;
+  }
   {
-    Kokkos::View<double********,Layout> a("A8",N1,N1,N1,N1,N1,N1,N1,N1);
+    Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
+                                           N1);
     Kokkos::Timer timer;
-    for(int r=0; r<R; r++) {
-      Kokkos::View<double********,Layout> a_(a);
-      Kokkos::resize(a_,int(N1*1.1),N1,N1,N1,N1,N1,N1,N1);
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double********, Layout> a_(a);
+      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N1 * 1.1), N1, N1, N1,
+                     N1, N1, N1, N1);
     }
-    time8 = timer.seconds()/R;
+    time8_noinit = timer.seconds() / R;
   }
-  #if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
   {
-    Kokkos::View<double*,Layout> a("A1",N8);
+    Kokkos::View<double*, Layout> a("A1", N8);
     double* a_ptr = a.data();
     Kokkos::Timer timer;
-    for(int r=0;r<R;r++) {
-      Kokkos::View<double*,Layout> a1(Kokkos::ViewAllocateWithoutInitializing("A1"),int(N8*1.1));
+    for (int r = 0; r < R; r++) {
+      Kokkos::View<double*, Layout> a1(
+          Kokkos::ViewAllocateWithoutInitializing("A1"), int(N8 * 1.1));
       double* a1_ptr = a1.data();
-      Kokkos::parallel_for(N8, KOKKOS_LAMBDA (const int& i) {
-        a1_ptr[i] = a_ptr[i];
-      });
+      Kokkos::parallel_for(
+          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
       Kokkos::fence();
     }
     Kokkos::fence();
-    time_raw = timer.seconds()/R;
+    time_raw = timer.seconds() / R;
   }
-  #endif
-  double size = 1.0*N8*8/1024/1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n",time_raw,size,2.0*size/1024/time_raw);
-  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n",time8,size,2.0*size/1024/time8);
+#endif
+  double size = 1.0 * N8 * 8 / 1024 / 1024;
+  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
+         2.0 * size / 1024 / time_raw);
+  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n", time8, size,
+         2.0 * size / 1024 / time8);
+  printf("   Rank8 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
+         time8_noinit, size, 2.0 * size / 1024 / time8_noinit);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewResize_123.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewResize_123.cpp
index 61b7edf3734f9570022baa616112ca8677ae2bd4..1dc4f285f56479b4987a0e3adf39664d8590ddc0 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewResize_123.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewResize_123.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,11 @@
 
 namespace Test {
 
-TEST_F( default_exec, ViewResize_Rank123 ) {
+TEST(default_exec, ViewResize_Rank123) {
   printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests123<Kokkos::LayoutLeft>(10,1);
+  run_resizeview_tests123<Kokkos::LayoutLeft>(10, 1);
   printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests123<Kokkos::LayoutRight>(10,1);
+  run_resizeview_tests123<Kokkos::LayoutRight>(10, 1);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewResize_45.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewResize_45.cpp
index 172f9474d9dd07df692404b59bb679726bc43db9..3754a5bb147b8d5a057d3c385179aa7645d63e11 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewResize_45.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewResize_45.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,11 @@
 
 namespace Test {
 
-TEST_F( default_exec, ViewResize_Rank_45 ) {
+TEST(default_exec, ViewResize_Rank_45) {
   printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests45<Kokkos::LayoutLeft>(10,1);
+  run_resizeview_tests45<Kokkos::LayoutLeft>(10, 1);
   printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests45<Kokkos::LayoutRight>(10,1);
+  run_resizeview_tests45<Kokkos::LayoutRight>(10, 1);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewResize_6.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewResize_6.cpp
index d4f8fb2af0ea290f61e6f06c94d957095c4ba799..1b8d6fbc8a04528f6ea30d6c52bd17e55ff2a683 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewResize_6.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewResize_6.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,11 @@
 
 namespace Test {
 
-TEST_F( default_exec, ViewResize_Rank6 ) {
+TEST(default_exec, ViewResize_Rank6) {
   printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests6<Kokkos::LayoutLeft>(10,1);
+  run_resizeview_tests6<Kokkos::LayoutLeft>(10, 1);
   printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests6<Kokkos::LayoutRight>(10,1);
+  run_resizeview_tests6<Kokkos::LayoutRight>(10, 1);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewResize_7.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewResize_7.cpp
index f7b9b5b54532baa3fe9fb23355d6297a51a86de5..f8efa195fc8e90eb9cbbde39a002b142192800a6 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewResize_7.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewResize_7.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,11 @@
 
 namespace Test {
 
-TEST_F( default_exec, ViewResize_Rank7 ) {
+TEST(default_exec, ViewResize_Rank7) {
   printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests7<Kokkos::LayoutLeft>(10,1);
+  run_resizeview_tests7<Kokkos::LayoutLeft>(10, 1);
   printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests7<Kokkos::LayoutRight>(10,1);
+  run_resizeview_tests7<Kokkos::LayoutRight>(10, 1);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/PerfTest_ViewResize_8.cpp b/lib/kokkos/core/perf_test/PerfTest_ViewResize_8.cpp
index 877fcef933079abfc7b36868015011cd24644650..afeeb643569ecd1a981132bed08944288ec3ca72 100644
--- a/lib/kokkos/core/perf_test/PerfTest_ViewResize_8.cpp
+++ b/lib/kokkos/core/perf_test/PerfTest_ViewResize_8.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,11 @@
 
 namespace Test {
 
-TEST_F( default_exec, ViewResize_Rank8 ) {
+TEST(default_exec, ViewResize_Rank8) {
   printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests8<Kokkos::LayoutLeft>(10,1);
+  run_resizeview_tests8<Kokkos::LayoutLeft>(10, 1);
   printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests8<Kokkos::LayoutRight>(10,1);
+  run_resizeview_tests8<Kokkos::LayoutRight>(10, 1);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/perf_test/test_atomic.cpp b/lib/kokkos/core/perf_test/test_atomic.cpp
index 24e4f015d3e65c58b07412ac0860be589de0a85c..7699d7b91cac1dca2fd4f02bbfb048bf61727901 100644
--- a/lib/kokkos/core/perf_test/test_atomic.cpp
+++ b/lib/kokkos/core/perf_test/test_atomic.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,335 +51,323 @@
 
 typedef Kokkos::DefaultExecutionSpace exec_space;
 
-#define RESET		0
-#define BRIGHT 		1
-#define DIM		2
-#define UNDERLINE 	3
-#define BLINK		4
-#define REVERSE		7
-#define HIDDEN		8
-
-#define BLACK 		0
-#define RED		1
-#define GREEN		2
-#define YELLOW		3
-#define BLUE		4
-#define MAGENTA		5
-#define CYAN		6
-#define GREY		7
-#define	WHITE		8
-
-void textcolor(int attr, int fg, int bg)
-{	char command[40];
-
-	/* Command is the control command to the terminal */
-	sprintf(command, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
-	printf("%s", command);
+#define RESET 0
+#define BRIGHT 1
+#define DIM 2
+#define UNDERLINE 3
+#define BLINK 4
+#define REVERSE 7
+#define HIDDEN 8
+
+#define BLACK 0
+#define RED 1
+#define GREEN 2
+#define YELLOW 3
+#define BLUE 4
+#define MAGENTA 5
+#define CYAN 6
+#define GREY 7
+#define WHITE 8
+
+void textcolor(int attr, int fg, int bg) {
+  char command[40];
+
+  /* Command is the control command to the terminal */
+  sprintf(command, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
+  printf("%s", command);
 }
-void textcolor_standard() {textcolor(RESET, BLACK, WHITE);}
+void textcolor_standard() { textcolor(RESET, BLACK, WHITE); }
 
-
-template<class T,class DEVICE_TYPE>
-struct ZeroFunctor{
+template <class T, class DEVICE_TYPE>
+struct ZeroFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef typename Kokkos::View<T,execution_space> type;
-  typedef typename Kokkos::View<T,execution_space>::HostMirror h_type;
+  typedef typename Kokkos::View<T, execution_space> type;
+  typedef typename Kokkos::View<T, execution_space>::HostMirror h_type;
   type data;
   KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    data() = 0;
-  }
+  void operator()(int) const { data() = 0; }
 };
 
 //---------------------------------------------------
 //--------------atomic_fetch_add---------------------
 //---------------------------------------------------
 
-template<class T,class DEVICE_TYPE>
-struct AddFunctor{
+template <class T, class DEVICE_TYPE>
+struct AddFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View<T,execution_space> type;
+  typedef Kokkos::View<T, execution_space> type;
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    Kokkos::atomic_fetch_add(&data(),(T)1);
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_add(&data(), (T)1); }
 };
 
-template<class T>
+template <class T>
 T AddLoop(int loop) {
-  struct ZeroFunctor<T,exec_space> f_zero;
-  typename ZeroFunctor<T,exec_space>::type data("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data("HData");
+  struct ZeroFunctor<T, exec_space> f_zero;
+  typename ZeroFunctor<T, exec_space>::type data("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data("HData");
   f_zero.data = data;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  struct AddFunctor<T,exec_space> f_add;
+  struct AddFunctor<T, exec_space> f_add;
   f_add.data = data;
-  Kokkos::parallel_for(loop,f_add);
+  Kokkos::parallel_for(loop, f_add);
   exec_space().fence();
 
-  Kokkos::deep_copy(h_data,data);
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
   return val;
 }
 
-template<class T,class DEVICE_TYPE>
-struct AddNonAtomicFunctor{
+template <class T, class DEVICE_TYPE>
+struct AddNonAtomicFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View<T,execution_space> type;
+  typedef Kokkos::View<T, execution_space> type;
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    data()+=(T)1;
-  }
+  void operator()(int) const { data() += (T)1; }
 };
 
-template<class T>
+template <class T>
 T AddLoopNonAtomic(int loop) {
-  struct ZeroFunctor<T,exec_space> f_zero;
-  typename ZeroFunctor<T,exec_space>::type data("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data("HData");
+  struct ZeroFunctor<T, exec_space> f_zero;
+  typename ZeroFunctor<T, exec_space>::type data("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data("HData");
 
   f_zero.data = data;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  struct AddNonAtomicFunctor<T,exec_space> f_add;
+  struct AddNonAtomicFunctor<T, exec_space> f_add;
   f_add.data = data;
-  Kokkos::parallel_for(loop,f_add);
+  Kokkos::parallel_for(loop, f_add);
   exec_space().fence();
 
-  Kokkos::deep_copy(h_data,data);
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template<class T>
+template <class T>
 T AddLoopSerial(int loop) {
   T* data = new T[1];
   data[0] = 0;
 
-  for(int i=0;i<loop;i++)
-  *data+=(T)1;
+  for (int i = 0; i < loop; i++) *data += (T)1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
   return val;
 }
 
-template<class T,class DEVICE_TYPE>
-struct CASFunctor{
+template <class T, class DEVICE_TYPE>
+struct CASFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View<T,execution_space> type;
+  typedef Kokkos::View<T, execution_space> type;
   type data;
 
   KOKKOS_INLINE_FUNCTION
   void operator()(int) const {
-	  T old = data();
-	  T newval, assumed;
-	  do {
-	    assumed = old;
-	    newval = assumed + (T)1;
-	    old = Kokkos::atomic_compare_exchange(&data(), assumed, newval);
-	  }
-	  while( old != assumed );
+    T old = data();
+    T newval, assumed;
+    do {
+      assumed = old;
+      newval  = assumed + (T)1;
+      old     = Kokkos::atomic_compare_exchange(&data(), assumed, newval);
+    } while (old != assumed);
   }
 };
 
-template<class T>
+template <class T>
 T CASLoop(int loop) {
-  struct ZeroFunctor<T,exec_space> f_zero;
-  typename ZeroFunctor<T,exec_space>::type data("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data("HData");
+  struct ZeroFunctor<T, exec_space> f_zero;
+  typename ZeroFunctor<T, exec_space>::type data("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data("HData");
   f_zero.data = data;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  struct CASFunctor<T,exec_space> f_cas;
+  struct CASFunctor<T, exec_space> f_cas;
   f_cas.data = data;
-  Kokkos::parallel_for(loop,f_cas);
+  Kokkos::parallel_for(loop, f_cas);
   exec_space().fence();
 
-  Kokkos::deep_copy(h_data,data);
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template<class T,class DEVICE_TYPE>
-struct CASNonAtomicFunctor{
+template <class T, class DEVICE_TYPE>
+struct CASNonAtomicFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View<T,execution_space> type;
+  typedef Kokkos::View<T, execution_space> type;
   type data;
 
   KOKKOS_INLINE_FUNCTION
   void operator()(int) const {
-	  volatile T assumed;
-	  volatile T newval;
-	  bool fail=1;
-	  do {
-	    assumed = data();
-	    newval = assumed + (T)1;
-	    if(data()==assumed) {
-	    	data() = newval;
-	    	fail = 0;
-	    }
-	  }
-	  while(fail);
+    volatile T assumed;
+    volatile T newval;
+    bool fail = 1;
+    do {
+      assumed = data();
+      newval  = assumed + (T)1;
+      if (data() == assumed) {
+        data() = newval;
+        fail   = 0;
+      }
+    } while (fail);
   }
 };
 
-template<class T>
+template <class T>
 T CASLoopNonAtomic(int loop) {
-  struct ZeroFunctor<T,exec_space> f_zero;
-  typename ZeroFunctor<T,exec_space>::type data("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data("HData");
+  struct ZeroFunctor<T, exec_space> f_zero;
+  typename ZeroFunctor<T, exec_space>::type data("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data("HData");
   f_zero.data = data;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  struct CASNonAtomicFunctor<T,exec_space> f_cas;
+  struct CASNonAtomicFunctor<T, exec_space> f_cas;
   f_cas.data = data;
-  Kokkos::parallel_for(loop,f_cas);
+  Kokkos::parallel_for(loop, f_cas);
   exec_space().fence();
 
-  Kokkos::deep_copy(h_data,data);
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template<class T>
+template <class T>
 T CASLoopSerial(int loop) {
   T* data = new T[1];
   data[0] = 0;
 
-  for(int i=0;i<loop;i++) {
-	  T assumed;
-	  T newval;
-	  T old;
-	  do {
-	    assumed = *data;
-	    newval = assumed + (T)1;
-	    old = *data;
-	    *data = newval;
-	  }
-	  while(!(assumed==old));
+  for (int i = 0; i < loop; i++) {
+    T assumed;
+    T newval;
+    T old;
+    do {
+      assumed = *data;
+      newval  = assumed + (T)1;
+      old     = *data;
+      *data   = newval;
+    } while (!(assumed == old));
   }
 
   T val = *data;
-  delete [] data;
+  delete[] data;
   return val;
 }
 
-template<class T,class DEVICE_TYPE>
-struct ExchFunctor{
+template <class T, class DEVICE_TYPE>
+struct ExchFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View<T,execution_space> type;
+  typedef Kokkos::View<T, execution_space> type;
   type data, data2;
 
   KOKKOS_INLINE_FUNCTION
   void operator()(int i) const {
-	T old = Kokkos::atomic_exchange(&data(),(T)i);
-    Kokkos::atomic_fetch_add(&data2(),old);
+    T old = Kokkos::atomic_exchange(&data(), (T)i);
+    Kokkos::atomic_fetch_add(&data2(), old);
   }
 };
 
-template<class T>
+template <class T>
 T ExchLoop(int loop) {
-  struct ZeroFunctor<T,exec_space> f_zero;
-  typename ZeroFunctor<T,exec_space>::type data("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data("HData");
+  struct ZeroFunctor<T, exec_space> f_zero;
+  typename ZeroFunctor<T, exec_space>::type data("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data("HData");
   f_zero.data = data;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  typename ZeroFunctor<T,exec_space>::type data2("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data2("HData");
+  typename ZeroFunctor<T, exec_space>::type data2("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data2("HData");
   f_zero.data = data2;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  struct ExchFunctor<T,exec_space> f_exch;
-  f_exch.data = data;
+  struct ExchFunctor<T, exec_space> f_exch;
+  f_exch.data  = data;
   f_exch.data2 = data2;
-  Kokkos::parallel_for(loop,f_exch);
+  Kokkos::parallel_for(loop, f_exch);
   exec_space().fence();
 
-  Kokkos::deep_copy(h_data,data);
-  Kokkos::deep_copy(h_data2,data2);
+  Kokkos::deep_copy(h_data, data);
+  Kokkos::deep_copy(h_data2, data2);
   T val = h_data() + h_data2();
 
   return val;
 }
 
-template<class T,class DEVICE_TYPE>
-struct ExchNonAtomicFunctor{
+template <class T, class DEVICE_TYPE>
+struct ExchNonAtomicFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View<T,execution_space> type;
+  typedef Kokkos::View<T, execution_space> type;
   type data, data2;
 
   KOKKOS_INLINE_FUNCTION
   void operator()(int i) const {
-		T old = data();
-		data()=(T) i;
-		data2()+=old;
+    T old  = data();
+    data() = (T)i;
+    data2() += old;
   }
 };
 
-
-template<class T>
+template <class T>
 T ExchLoopNonAtomic(int loop) {
-  struct ZeroFunctor<T,exec_space> f_zero;
-  typename ZeroFunctor<T,exec_space>::type data("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data("HData");
+  struct ZeroFunctor<T, exec_space> f_zero;
+  typename ZeroFunctor<T, exec_space>::type data("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data("HData");
   f_zero.data = data;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  typename ZeroFunctor<T,exec_space>::type data2("Data");
-  typename ZeroFunctor<T,exec_space>::h_type h_data2("HData");
+  typename ZeroFunctor<T, exec_space>::type data2("Data");
+  typename ZeroFunctor<T, exec_space>::h_type h_data2("HData");
   f_zero.data = data2;
-  Kokkos::parallel_for(1,f_zero);
+  Kokkos::parallel_for(1, f_zero);
   exec_space().fence();
 
-  struct ExchNonAtomicFunctor<T,exec_space> f_exch;
-  f_exch.data = data;
+  struct ExchNonAtomicFunctor<T, exec_space> f_exch;
+  f_exch.data  = data;
   f_exch.data2 = data2;
-  Kokkos::parallel_for(loop,f_exch);
+  Kokkos::parallel_for(loop, f_exch);
   exec_space().fence();
 
-  Kokkos::deep_copy(h_data,data);
-  Kokkos::deep_copy(h_data2,data2);
+  Kokkos::deep_copy(h_data, data);
+  Kokkos::deep_copy(h_data2, data2);
   T val = h_data() + h_data2();
 
   return val;
 }
 
-template<class T>
+template <class T>
 T ExchLoopSerial(int loop) {
-  T* data = new T[1];
+  T* data  = new T[1];
   T* data2 = new T[1];
-  data[0] = 0;
+  data[0]  = 0;
   data2[0] = 0;
-  for(int i=0;i<loop;i++) {
-	T old = *data;
-	*data=(T) i;
-	*data2+=old;
+  for (int i = 0; i < loop; i++) {
+    T old = *data;
+    *data = (T)i;
+    *data2 += old;
   }
 
   T val = *data2 + *data;
-  delete [] data;
-  delete [] data2;
+  delete[] data;
+  delete[] data2;
   return val;
 }
 
-template<class T>
+template <class T>
 T LoopVariant(int loop, int test) {
   switch (test) {
     case 1: return AddLoop<T>(loop);
@@ -388,7 +377,7 @@ T LoopVariant(int loop, int test) {
   return 0;
 }
 
-template<class T>
+template <class T>
 T LoopVariantSerial(int loop, int test) {
   switch (test) {
     case 1: return AddLoopSerial<T>(loop);
@@ -398,7 +387,7 @@ T LoopVariantSerial(int loop, int test) {
   return 0;
 }
 
-template<class T>
+template <class T>
 T LoopVariantNonAtomic(int loop, int test) {
   switch (test) {
     case 1: return AddLoopNonAtomic<T>(loop);
@@ -408,100 +397,105 @@ T LoopVariantNonAtomic(int loop, int test) {
   return 0;
 }
 
-template<class T>
+template <class T>
 void Loop(int loop, int test, const char* type_name) {
-  LoopVariant<T>(loop,test);
+  LoopVariant<T>(loop, test);
 
   Kokkos::Impl::Timer timer;
-  T res = LoopVariant<T>(loop,test);
+  T res       = LoopVariant<T>(loop, test);
   double time = timer.seconds();
 
   timer.reset();
-  T resNonAtomic = LoopVariantNonAtomic<T>(loop,test);
+  T resNonAtomic       = LoopVariantNonAtomic<T>(loop, test);
   double timeNonAtomic = timer.seconds();
 
   timer.reset();
-  T resSerial = LoopVariantSerial<T>(loop,test);
+  T resSerial       = LoopVariantSerial<T>(loop, test);
   double timeSerial = timer.seconds();
 
-  time         *=1e6/loop;
-  timeNonAtomic*=1e6/loop;
-  timeSerial   *=1e6/loop;
-  //textcolor_standard();
+  time *= 1e6 / loop;
+  timeNonAtomic *= 1e6 / loop;
+  timeSerial *= 1e6 / loop;
+  // textcolor_standard();
   bool passed = true;
-  if(resSerial!=res) passed = false;
-  //if(!passed) textcolor(RESET,BLACK,YELLOW);
-  printf("%s Test %i %s  --- Loop: %i Value (S,A,NA): %e %e %e Time: %7.4e %7.4e %7.4e Size of Type %i)",
-         type_name,test,passed?"PASSED":"FAILED",loop,
-         1.0*resSerial,1.0*res,1.0*resNonAtomic,
-         timeSerial,time,timeNonAtomic,(int)sizeof(T));
-  //if(!passed) textcolor_standard();
+  if (resSerial != res) passed = false;
+  // if(!passed) textcolor(RESET,BLACK,YELLOW);
+  printf(
+      "%s Test %i %s  --- Loop: %i Value (S,A,NA): %e %e %e Time: %7.4e %7.4e "
+      "%7.4e Size of Type %i)",
+      type_name, test, passed ? "PASSED" : "FAILED", loop, 1.0 * resSerial,
+      1.0 * res, 1.0 * resNonAtomic, timeSerial, time, timeNonAtomic,
+      (int)sizeof(T));
+  // if(!passed) textcolor_standard();
   printf("\n");
 }
 
-
-template<class T>
+template <class T>
 void Test(int loop, int test, const char* type_name) {
-  if(test==-1) {
-    Loop<T>(loop,1,type_name);
-    Loop<T>(loop,2,type_name);
-    Loop<T>(loop,3,type_name);
+  if (test == -1) {
+    Loop<T>(loop, 1, type_name);
+    Loop<T>(loop, 2, type_name);
+    Loop<T>(loop, 3, type_name);
 
-  }
-  else
-    Loop<T>(loop,test,type_name);
+  } else
+    Loop<T>(loop, test, type_name);
 }
 
-int main(int argc, char* argv[])
-{
+int main(int argc, char* argv[]) {
   int type = -1;
   int loop = 100000;
   int test = -1;
 
-  for(int i=0;i<argc;i++)
-  {
-     if((strcmp(argv[i],"--test")==0)) {test=atoi(argv[++i]); continue;}
-     if((strcmp(argv[i],"--type")==0)) {type=atoi(argv[++i]); continue;}
-     if((strcmp(argv[i],"-l")==0)||(strcmp(argv[i],"--loop")==0)) {loop=atoi(argv[++i]); continue;}
+  for (int i = 0; i < argc; i++) {
+    if ((strcmp(argv[i], "--test") == 0)) {
+      test = atoi(argv[++i]);
+      continue;
+    }
+    if ((strcmp(argv[i], "--type") == 0)) {
+      type = atoi(argv[++i]);
+      continue;
+    }
+    if ((strcmp(argv[i], "-l") == 0) || (strcmp(argv[i], "--loop") == 0)) {
+      loop = atoi(argv[++i]);
+      continue;
+    }
   }
 
+  Kokkos::initialize(argc, argv);
 
-  Kokkos::initialize(argc,argv);
-
-
-  printf("Using %s\n",Kokkos::atomic_query_version());
+  printf("Using %s\n", Kokkos::atomic_query_version());
   bool all_tests = false;
-  if(type==-1) all_tests = true;
-  while(type<100) {
-    if(type==1) {
-     Test<int>(loop,test,"int                    ");
+  if (type == -1) all_tests = true;
+  while (type < 100) {
+    if (type == 1) {
+      Test<int>(loop, test, "int                    ");
     }
-    if(type==2) {
-     Test<long int>(loop,test,"long int               ");
+    if (type == 2) {
+      Test<long int>(loop, test, "long int               ");
     }
-    if(type==3) {
-     Test<long long int>(loop,test,"long long int          ");
+    if (type == 3) {
+      Test<long long int>(loop, test, "long long int          ");
     }
-    if(type==4) {
-     Test<unsigned int>(loop,test,"unsigned int           ");
+    if (type == 4) {
+      Test<unsigned int>(loop, test, "unsigned int           ");
     }
-    if(type==5) {
-     Test<unsigned long int>(loop,test,"unsigned long int      ");
+    if (type == 5) {
+      Test<unsigned long int>(loop, test, "unsigned long int      ");
     }
-    if(type==6) {
-     Test<unsigned long long int>(loop,test,"unsigned long long int ");
+    if (type == 6) {
+      Test<unsigned long long int>(loop, test, "unsigned long long int ");
     }
-    if(type==10) {
-     //Test<float>(loop,test,"float                  ");
+    if (type == 10) {
+      // Test<float>(loop,test,"float                  ");
     }
-    if(type==11) {
-     Test<double>(loop,test,"double                 ");
+    if (type == 11) {
+      Test<double>(loop, test, "double                 ");
     }
-    if(!all_tests) type=100;
-    else type++;
+    if (!all_tests)
+      type = 100;
+    else
+      type++;
   }
 
   Kokkos::finalize();
-
 }
-
diff --git a/lib/kokkos/core/perf_test/test_mempool.cpp b/lib/kokkos/core/perf_test/test_mempool.cpp
index c47730ec69746143cb4dc7c6b8f510984c306217..ad8622e7a656fcfd5468857d6deef10359bf17a1 100644
--- a/lib/kokkos/core/perf_test/test_mempool.cpp
+++ b/lib/kokkos/core/perf_test/test_mempool.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,310 +50,271 @@
 #include <Kokkos_Core.hpp>
 #include <impl/Kokkos_Timer.hpp>
 
-using ExecSpace   = Kokkos::DefaultExecutionSpace ;
-using MemorySpace = Kokkos::DefaultExecutionSpace::memory_space ;
+using ExecSpace   = Kokkos::DefaultExecutionSpace;
+using MemorySpace = Kokkos::DefaultExecutionSpace::memory_space;
 
-using MemoryPool = Kokkos::MemoryPool< ExecSpace > ;
+using MemoryPool = Kokkos::MemoryPool<ExecSpace>;
 
 struct TestFunctor {
-
-  typedef Kokkos::View< uintptr_t * , ExecSpace >  ptrs_type ;
+  typedef Kokkos::View<uintptr_t*, ExecSpace> ptrs_type;
 
   enum : unsigned { chunk = 32 };
 
-  MemoryPool  pool ;
-  ptrs_type   ptrs ;
-  unsigned    chunk_span ;
-  unsigned    fill_stride ;
-  unsigned    range_iter ;
-  unsigned    repeat_inner ;
-
-  TestFunctor( size_t    total_alloc_size
-             , unsigned  min_superblock_size
-             , unsigned  number_alloc
-             , unsigned  arg_stride_alloc
-             , unsigned  arg_chunk_span
-             , unsigned  arg_repeat )
-    : pool()
-    , ptrs()
-    , chunk_span(0)
-    , fill_stride(0)
-    , repeat_inner(0)
-    {
-      MemorySpace m ;
-
-      const unsigned min_block_size = chunk ;
-      const unsigned max_block_size = chunk * arg_chunk_span ;
-      pool = MemoryPool( m , total_alloc_size
-                           , min_block_size
-                           , max_block_size
-                           , min_superblock_size );
-
-      ptrs = ptrs_type( Kokkos::view_alloc( m , "ptrs") , number_alloc );
-      fill_stride = arg_stride_alloc ;
-      chunk_span = arg_chunk_span ;
-      range_iter   = fill_stride * number_alloc ;
-      repeat_inner       = arg_repeat ;
-    }
+  MemoryPool pool;
+  ptrs_type ptrs;
+  unsigned chunk_span;
+  unsigned fill_stride;
+  unsigned range_iter;
+  unsigned repeat_inner;
+
+  TestFunctor(size_t total_alloc_size, unsigned min_superblock_size,
+              unsigned number_alloc, unsigned arg_stride_alloc,
+              unsigned arg_chunk_span, unsigned arg_repeat)
+      : pool(), ptrs(), chunk_span(0), fill_stride(0), repeat_inner(0) {
+    MemorySpace m;
+
+    const unsigned min_block_size = chunk;
+    const unsigned max_block_size = chunk * arg_chunk_span;
+    pool = MemoryPool(m, total_alloc_size, min_block_size, max_block_size,
+                      min_superblock_size);
+
+    ptrs         = ptrs_type(Kokkos::view_alloc(m, "ptrs"), number_alloc);
+    fill_stride  = arg_stride_alloc;
+    chunk_span   = arg_chunk_span;
+    range_iter   = fill_stride * number_alloc;
+    repeat_inner = arg_repeat;
+  }
 
   //----------------------------------------
 
-  typedef long value_type ;
+  typedef long value_type;
 
   //----------------------------------------
 
   struct TagFill {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagFill , int i , value_type & update ) const noexcept
-    {
-      if ( 0 == i % fill_stride ) {
+  void operator()(TagFill, int i, value_type& update) const noexcept {
+    if (0 == i % fill_stride) {
+      const int j = i / fill_stride;
 
-        const int j = i / fill_stride ;
+      const unsigned size_alloc = chunk * (1 + (j % chunk_span));
 
-        const unsigned size_alloc = chunk * ( 1 + ( j % chunk_span ) );
+      ptrs(j) = (uintptr_t)pool.allocate(size_alloc);
 
-        ptrs(j) = (uintptr_t) pool.allocate(size_alloc);
-
-        if ( ptrs(j) ) ++update ;
-      }
+      if (ptrs(j)) ++update;
     }
+  }
 
-  bool test_fill()
-    {
-      typedef Kokkos::RangePolicy< ExecSpace , TagFill > policy ;
+  bool test_fill() {
+    typedef Kokkos::RangePolicy<ExecSpace, TagFill> policy;
 
-      long result = 0 ;
+    long result = 0;
 
-      Kokkos::parallel_reduce( policy(0,range_iter), *this , result );
+    Kokkos::parallel_reduce(policy(0, range_iter), *this, result);
 
-      if ( result == long(ptrs.extent(0)) ) return true;
-      pool.print_state( std::cerr );
-      return false;
-    }
+    if (result == long(ptrs.extent(0))) return true;
+    pool.print_state(std::cerr);
+    return false;
+  }
 
   //----------------------------------------
 
   struct TagDel {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagDel , int i ) const noexcept
-    {
-      if ( 0 == i % fill_stride ) {
-
-        const int j = i / fill_stride ;
+  void operator()(TagDel, int i) const noexcept {
+    if (0 == i % fill_stride) {
+      const int j = i / fill_stride;
 
-        const unsigned size_alloc = chunk * ( 1 + ( j % chunk_span ) );
+      const unsigned size_alloc = chunk * (1 + (j % chunk_span));
 
-        pool.deallocate( (void*) ptrs(j) , size_alloc );
-      }
+      pool.deallocate((void*)ptrs(j), size_alloc);
     }
+  }
 
-  void test_del()
-    {
-      typedef Kokkos::RangePolicy< ExecSpace , TagDel > policy ;
+  void test_del() {
+    typedef Kokkos::RangePolicy<ExecSpace, TagDel> policy;
 
-      Kokkos::parallel_for( policy(0,range_iter), *this );
-      Kokkos::fence();
-    }
+    Kokkos::parallel_for(policy(0, range_iter), *this);
+    Kokkos::fence();
+  }
 
   //----------------------------------------
 
   struct TagAllocDealloc {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagAllocDealloc , int i , long & update ) const noexcept
-    {
-      if ( 0 == i % fill_stride ) {
-
-        const int j = i / fill_stride ;
-
-        if ( 0 == j % 3 ) {
+  void operator()(TagAllocDealloc, int i, long& update) const noexcept {
+    if (0 == i % fill_stride) {
+      const int j = i / fill_stride;
 
-          for ( unsigned k = 0 ; k < repeat_inner ; ++k ) {
+      if (0 == j % 3) {
+        for (unsigned k = 0; k < repeat_inner; ++k) {
+          const unsigned size_alloc = chunk * (1 + (j % chunk_span));
 
-            const unsigned size_alloc = chunk * ( 1 + ( j % chunk_span ) );
+          pool.deallocate((void*)ptrs(j), size_alloc);
 
-            pool.deallocate( (void*) ptrs(j) , size_alloc );
+          ptrs(j) = (uintptr_t)pool.allocate(size_alloc);
 
-            ptrs(j) = (uintptr_t) pool.allocate(size_alloc);
-
-            if ( 0 == ptrs(j) ) update++ ;
-          }
+          if (0 == ptrs(j)) update++;
         }
       }
     }
+  }
 
-  bool test_alloc_dealloc()
-    {
-      typedef Kokkos::RangePolicy< ExecSpace , TagAllocDealloc > policy ;
+  bool test_alloc_dealloc() {
+    typedef Kokkos::RangePolicy<ExecSpace, TagAllocDealloc> policy;
 
-      long error_count = 0 ;
+    long error_count = 0;
 
-      Kokkos::parallel_reduce( policy(0,range_iter), *this , error_count );
+    Kokkos::parallel_reduce(policy(0, range_iter), *this, error_count);
 
-      return 0 == error_count ;
-    }
+    return 0 == error_count;
+  }
 };
 
+int main(int argc, char* argv[]) {
+  static const char help_flag[]         = "--help";
+  static const char alloc_size_flag[]   = "--alloc_size=";
+  static const char super_size_flag[]   = "--super_size=";
+  static const char chunk_span_flag[]   = "--chunk_span=";
+  static const char fill_stride_flag[]  = "--fill_stride=";
+  static const char fill_level_flag[]   = "--fill_level=";
+  static const char repeat_outer_flag[] = "--repeat_outer=";
+  static const char repeat_inner_flag[] = "--repeat_inner=";
 
+  long total_alloc_size   = 1000000;
+  int min_superblock_size = 10000;
+  int chunk_span          = 5;
+  int fill_stride         = 1;
+  int fill_level          = 70;
+  int repeat_outer        = 1;
+  int repeat_inner        = 1;
 
-int main( int argc , char* argv[] )
-{
-  static const char help_flag[] = "--help" ;
-  static const char alloc_size_flag[]   = "--alloc_size=" ;
-  static const char super_size_flag[]   = "--super_size=" ;
-  static const char chunk_span_flag[]   = "--chunk_span=" ;
-  static const char fill_stride_flag[]  = "--fill_stride=" ;
-  static const char fill_level_flag[]   = "--fill_level=" ;
-  static const char repeat_outer_flag[] = "--repeat_outer=" ;
-  static const char repeat_inner_flag[] = "--repeat_inner=" ;
-
-  long total_alloc_size    = 1000000 ;
-  int  min_superblock_size =   10000 ;
-  int  chunk_span          =       5 ;
-  int  fill_stride        =       1 ;
-  int  fill_level         =      70 ;
-  int  repeat_outer   =       1 ;
-  int  repeat_inner   =       1 ;
-
-  int  ask_help = 0 ;
+  int ask_help = 0;
 
-  for(int i=1;i<argc;i++)
-  {
-     const char * const a = argv[i];
+  for (int i = 1; i < argc; i++) {
+    const char* const a = argv[i];
 
-     if ( ! strncmp(a,help_flag,strlen(help_flag) ) ) ask_help = 1 ;
+    if (!strncmp(a, help_flag, strlen(help_flag))) ask_help = 1;
 
-     if ( ! strncmp(a,alloc_size_flag,strlen(alloc_size_flag) ) )
-       total_alloc_size = atol( a + strlen(alloc_size_flag) );
+    if (!strncmp(a, alloc_size_flag, strlen(alloc_size_flag)))
+      total_alloc_size = atol(a + strlen(alloc_size_flag));
 
-     if ( ! strncmp(a,super_size_flag,strlen(super_size_flag) ) )
-       min_superblock_size = atoi( a + strlen(super_size_flag) );
+    if (!strncmp(a, super_size_flag, strlen(super_size_flag)))
+      min_superblock_size = atoi(a + strlen(super_size_flag));
 
-     if ( ! strncmp(a,fill_stride_flag,strlen(fill_stride_flag) ) )
-       fill_stride = atoi( a + strlen(fill_stride_flag) );
+    if (!strncmp(a, fill_stride_flag, strlen(fill_stride_flag)))
+      fill_stride = atoi(a + strlen(fill_stride_flag));
 
-     if ( ! strncmp(a,fill_level_flag,strlen(fill_level_flag) ) )
-       fill_level = atoi( a + strlen(fill_level_flag) );
+    if (!strncmp(a, fill_level_flag, strlen(fill_level_flag)))
+      fill_level = atoi(a + strlen(fill_level_flag));
 
-     if ( ! strncmp(a,chunk_span_flag,strlen(chunk_span_flag) ) )
-       chunk_span = atoi( a + strlen(chunk_span_flag) );
+    if (!strncmp(a, chunk_span_flag, strlen(chunk_span_flag)))
+      chunk_span = atoi(a + strlen(chunk_span_flag));
 
-     if ( ! strncmp(a,repeat_outer_flag,strlen(repeat_outer_flag) ) )
-       repeat_outer = atoi( a + strlen(repeat_outer_flag) );
+    if (!strncmp(a, repeat_outer_flag, strlen(repeat_outer_flag)))
+      repeat_outer = atoi(a + strlen(repeat_outer_flag));
 
-     if ( ! strncmp(a,repeat_inner_flag,strlen(repeat_inner_flag) ) )
-       repeat_inner = atoi( a + strlen(repeat_inner_flag) );
+    if (!strncmp(a, repeat_inner_flag, strlen(repeat_inner_flag)))
+      repeat_inner = atoi(a + strlen(repeat_inner_flag));
   }
 
   int chunk_span_bytes = 0;
   for (int i = 0; i < chunk_span; ++i) {
-    auto chunk_bytes = TestFunctor::chunk * ( 1 + i );
+    auto chunk_bytes = TestFunctor::chunk * (1 + i);
     if (chunk_bytes < 64) chunk_bytes = 64;
-    auto block_bytes_lg2 = Kokkos::Impl::integral_power_of_two_that_contains( chunk_bytes );
+    auto block_bytes_lg2 =
+        Kokkos::Impl::integral_power_of_two_that_contains(chunk_bytes);
     auto block_bytes = (1 << block_bytes_lg2);
     chunk_span_bytes += block_bytes;
   }
-  auto actual_superblock_bytes_lg2 = Kokkos::Impl::integral_power_of_two_that_contains( min_superblock_size );
+  auto actual_superblock_bytes_lg2 =
+      Kokkos::Impl::integral_power_of_two_that_contains(min_superblock_size);
   auto actual_superblock_bytes = (1 << actual_superblock_bytes_lg2);
-  auto superblock_mask = actual_superblock_bytes - 1;
-  auto nsuperblocks = (total_alloc_size + superblock_mask) >> actual_superblock_bytes_lg2;
+  auto superblock_mask         = actual_superblock_bytes - 1;
+  auto nsuperblocks =
+      (total_alloc_size + superblock_mask) >> actual_superblock_bytes_lg2;
   auto actual_total_bytes = nsuperblocks * actual_superblock_bytes;
-  auto bytes_wanted = (actual_total_bytes * fill_level) / 100;
-  auto chunk_spans = bytes_wanted / chunk_span_bytes;
-  auto number_alloc = int( chunk_spans * chunk_span );
+  auto bytes_wanted       = (actual_total_bytes * fill_level) / 100;
+  auto chunk_spans        = bytes_wanted / chunk_span_bytes;
+  auto number_alloc       = int(chunk_spans * chunk_span);
 
-  if ( ask_help ) {
+  if (ask_help) {
     std::cout << "command line options:"
-              << " " << help_flag
-              << " " << alloc_size_flag << "##"
+              << " " << help_flag << " " << alloc_size_flag << "##"
               << " " << super_size_flag << "##"
               << " " << fill_stride_flag << "##"
               << " " << fill_level_flag << "##"
               << " " << chunk_span_flag << "##"
               << " " << repeat_outer_flag << "##"
-              << " " << repeat_inner_flag << "##"
-              << std::endl ;
+              << " " << repeat_inner_flag << "##" << std::endl;
     return 0;
   }
 
-  Kokkos::initialize(argc,argv);
+  Kokkos::initialize(argc, argv);
 
-  double sum_fill_time = 0;
+  double sum_fill_time  = 0;
   double sum_cycle_time = 0;
-  double sum_both_time = 0;
-  double min_fill_time = std::numeric_limits<double>::max();
+  double sum_both_time  = 0;
+  double min_fill_time  = std::numeric_limits<double>::max();
   double min_cycle_time = std::numeric_limits<double>::max();
-  double min_both_time = std::numeric_limits<double>::max();
-  //one alloc in fill, alloc/dealloc pair in repeat_inner
-  for ( int i = 0 ; i < repeat_outer ; ++i ) {
+  double min_both_time  = std::numeric_limits<double>::max();
+  // one alloc in fill, alloc/dealloc pair in repeat_inner
+  for (int i = 0; i < repeat_outer; ++i) {
+    TestFunctor functor(total_alloc_size, min_superblock_size, number_alloc,
+                        fill_stride, chunk_span, repeat_inner);
 
-    TestFunctor functor( total_alloc_size
-                       , min_superblock_size
-                       , number_alloc
-                       , fill_stride
-                       , chunk_span
-                       , repeat_inner );
+    Kokkos::Impl::Timer timer;
 
-    Kokkos::Impl::Timer timer ;
-
-    if ( ! functor.test_fill() ) {
+    if (!functor.test_fill()) {
       Kokkos::abort("fill ");
     }
 
     auto t0 = timer.seconds();
 
-    if ( ! functor.test_alloc_dealloc() ) {
+    if (!functor.test_alloc_dealloc()) {
       Kokkos::abort("alloc/dealloc ");
     }
 
-    auto t1 = timer.seconds();
-    auto this_fill_time = t0;
+    auto t1              = timer.seconds();
+    auto this_fill_time  = t0;
     auto this_cycle_time = t1 - t0;
-    auto this_both_time = t1;
+    auto this_both_time  = t1;
     sum_fill_time += this_fill_time;
     sum_cycle_time += this_cycle_time;
     sum_both_time += this_both_time;
-    min_fill_time = std::min(min_fill_time, this_fill_time);
+    min_fill_time  = std::min(min_fill_time, this_fill_time);
     min_cycle_time = std::min(min_cycle_time, this_cycle_time);
-    min_both_time = std::min(min_both_time, this_both_time);
+    min_both_time  = std::min(min_both_time, this_both_time);
   }
 
   Kokkos::finalize();
 
-  printf( "\"mempool: alloc super stride level span inner outer number\" %ld %d %d %d %d %d %d %d\n"
-        , total_alloc_size
-        , min_superblock_size
-        , fill_stride
-        , fill_level
-        , chunk_span
-        , repeat_inner
-        , repeat_outer
-        , number_alloc );
-
-  auto avg_fill_time = sum_fill_time / repeat_outer;
+  printf(
+      "\"mempool: alloc super stride level span inner outer number\" %ld %d %d "
+      "%d %d %d %d %d\n",
+      total_alloc_size, min_superblock_size, fill_stride, fill_level,
+      chunk_span, repeat_inner, repeat_outer, number_alloc);
+
+  auto avg_fill_time  = sum_fill_time / repeat_outer;
   auto avg_cycle_time = sum_cycle_time / repeat_outer;
-  auto avg_both_time = sum_both_time / repeat_outer;
+  auto avg_both_time  = sum_both_time / repeat_outer;
 
-  printf( "\"mempool: fill time (min, avg)\" %.8f %.8f\n"
-        , min_fill_time
-        , avg_fill_time );
+  printf("\"mempool: fill time (min, avg)\" %.8f %.8f\n", min_fill_time,
+         avg_fill_time);
 
-  printf( "\"mempool: cycle time (min, avg)\" %.8f %.8f\n"
-        , min_cycle_time
-        , avg_cycle_time );
+  printf("\"mempool: cycle time (min, avg)\" %.8f %.8f\n", min_cycle_time,
+         avg_cycle_time);
 
-  printf( "\"mempool: test time (min, avg)\" %.8f %.8f\n"
-        , min_both_time
-        , avg_both_time );
+  printf("\"mempool: test time (min, avg)\" %.8f %.8f\n", min_both_time,
+         avg_both_time);
 
-  printf( "\"mempool: fill ops per second (max, avg)\" %g %g\n"
-        , number_alloc / min_fill_time
-        , number_alloc / avg_fill_time );
+  printf("\"mempool: fill ops per second (max, avg)\" %g %g\n",
+         number_alloc / min_fill_time, number_alloc / avg_fill_time);
 
-  printf( "\"mempool: cycle ops per second (max, avg)\" %g %g\n"
-        , (2 * number_alloc * repeat_inner) / min_cycle_time
-        , (2 * number_alloc * repeat_inner) / avg_cycle_time );
+  printf("\"mempool: cycle ops per second (max, avg)\" %g %g\n",
+         (2 * number_alloc * repeat_inner) / min_cycle_time,
+         (2 * number_alloc * repeat_inner) / avg_cycle_time);
 }
-
diff --git a/lib/kokkos/core/perf_test/test_taskdag.cpp b/lib/kokkos/core/perf_test/test_taskdag.cpp
index 41198edfe156274eb3a89be9fe0b3dd132b37a04..a97edc59e8312cc74e51dd8cd6dfb2fdb1057d4f 100644
--- a/lib/kokkos/core/perf_test/test_taskdag.cpp
+++ b/lib/kokkos/core/perf_test/test_taskdag.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,13 +44,10 @@
 
 #include <Kokkos_Core.hpp>
 
-#if ! defined( KOKKOS_ENABLE_TASKDAG ) || \
-    defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS )
+#if !defined(KOKKOS_ENABLE_TASKDAG) || \
+    defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
 
-int main()
-{
-  return 0 ;
-}
+int main() { return 0; }
 
 #else
 
@@ -60,187 +58,160 @@ int main()
 
 #include <impl/Kokkos_Timer.hpp>
 
-using ExecSpace = Kokkos::DefaultExecutionSpace ;
+using ExecSpace = Kokkos::DefaultExecutionSpace;
 
-inline
-long eval_fib( long n )
-{
+inline long eval_fib(long n) {
   constexpr long mask = 0x03;
 
-  long fib[4] = { 0, 1, 0, 0 };
+  long fib[4] = {0, 1, 0, 0};
 
-  for ( long i = 2; i <= n; ++i ) {
-    fib[ i & mask ] = fib[ ( i - 1 ) & mask ] + fib[ ( i - 2 ) & mask ];
+  for (long i = 2; i <= n; ++i) {
+    fib[i & mask] = fib[(i - 1) & mask] + fib[(i - 2) & mask];
   }
 
-  return fib[ n & mask ];
+  return fib[n & mask];
 }
 
-inline
-long fib_alloc_count( long n )
-{
+inline long fib_alloc_count(long n) {
   constexpr long mask = 0x03;
 
-  long count[4] = { 1, 1, 0, 0 };
+  long count[4] = {1, 1, 0, 0};
 
-  for ( long i = 2; i <= n; ++i ) {
-    count[ i & mask ] = 2 // this task plus the 'when_all' task
-                      + count[ ( i - 1 ) & mask ]
-                      + count[ ( i - 2 ) & mask ];
+  for (long i = 2; i <= n; ++i) {
+    count[i & mask] = 2  // this task plus the 'when_all' task
+                      + count[(i - 1) & mask] + count[(i - 2) & mask];
   }
 
-  return count[ n & mask ];
+  return count[n & mask];
 }
 
-template< class Scheduler >
+template <class Scheduler>
 struct TestFib {
+  using MemorySpace = typename Scheduler::memory_space;
+  using MemberType  = typename Scheduler::member_type;
+  using FutureType  = Kokkos::BasicFuture<long, Scheduler>;
 
-  using MemorySpace = typename Scheduler::memory_space ;
-  using MemberType  = typename Scheduler::member_type ;
-  using FutureType  = Kokkos::BasicFuture< long , Scheduler > ;
-
-  typedef long value_type ;
+  typedef long value_type;
 
-  FutureType dep[2] ;
-  const value_type n ;
+  FutureType dep[2];
+  const value_type n;
 
   KOKKOS_INLINE_FUNCTION
-  TestFib( const value_type arg_n )
-    : dep{} , n( arg_n ) {}
+  TestFib(const value_type arg_n) : dep{}, n(arg_n) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( MemberType & member, value_type & result ) noexcept
-    {
-      auto& sched = member.scheduler();
-      if ( n < 2 ) {
-        result = n ;
-      }
-      else if ( ! dep[0].is_null() && ! dep[1].is_null() ) {
-        result = dep[0].get() + dep[1].get();
-      }
-      else {
-        // Spawn new children and respawn myself to sum their results.
-        // Spawn lower value at higher priority as it has a shorter
-        // path to completion.
-
-        dep[1] = Kokkos::task_spawn
-          ( Kokkos::TaskSingle( sched, Kokkos::TaskPriority::High )
-          , TestFib( n - 2 ) );
-
-        dep[0] = Kokkos::task_spawn
-          ( Kokkos::TaskSingle( sched )
-          , TestFib( n - 1 ) );
-
-        auto fib_all = sched.when_all( dep, 2 );
-
-        if ( ! dep[0].is_null() && ! dep[1].is_null() && ! fib_all.is_null() ) {
-          // High priority to retire this branch.
-          Kokkos::respawn( this, fib_all, Kokkos::TaskPriority::High );
-        }
-        else {
-          Kokkos::abort("Failed nested task spawn (allocation)");
-        }
+  void operator()(MemberType& member, value_type& result) noexcept {
+    auto& sched = member.scheduler();
+    if (n < 2) {
+      result = n;
+    } else if (!dep[0].is_null() && !dep[1].is_null()) {
+      result = dep[0].get() + dep[1].get();
+    } else {
+      // Spawn new children and respawn myself to sum their results.
+      // Spawn lower value at higher priority as it has a shorter
+      // path to completion.
+
+      dep[1] = Kokkos::task_spawn(
+          Kokkos::TaskSingle(sched, Kokkos::TaskPriority::High),
+          TestFib(n - 2));
+
+      dep[0] = Kokkos::task_spawn(Kokkos::TaskSingle(sched), TestFib(n - 1));
+
+      auto fib_all = sched.when_all(dep, 2);
+
+      if (!dep[0].is_null() && !dep[1].is_null() && !fib_all.is_null()) {
+        // High priority to retire this branch.
+        Kokkos::respawn(this, fib_all, Kokkos::TaskPriority::High);
+      } else {
+        Kokkos::abort("Failed nested task spawn (allocation)");
       }
     }
+  }
 };
 
+int main(int argc, char* argv[]) {
+  static const char help[]         = "--help";
+  static const char alloc_size[]   = "--alloc_size=";
+  static const char super_size[]   = "--super_size=";
+  static const char repeat_outer[] = "--repeat_outer=";
+  static const char input_value[]  = "--input=";
 
+  long total_alloc_size   = 1000000;
+  int min_superblock_size = 10000;
+  int test_repeat_outer   = 1;
+  int fib_input           = 4;
 
-int main( int argc , char* argv[] )
-{
-  static const char help[] = "--help" ;
-  static const char alloc_size[]   = "--alloc_size=" ;
-  static const char super_size[]   = "--super_size=" ;
-  static const char repeat_outer[] = "--repeat_outer=" ;
-  static const char input_value[]  = "--input=" ;
+  int ask_help = 0;
 
-  long total_alloc_size    = 1000000 ;
-  int  min_superblock_size =   10000 ;
-  int  test_repeat_outer   =       1 ;
-  int  fib_input           =       4 ;
+  for (int i = 1; i < argc; i++) {
+    const char* const a = argv[i];
 
-  int  ask_help = 0 ;
+    if (!strncmp(a, help, strlen(help))) ask_help = 1;
 
-  for(int i=1;i<argc;i++)
-  {
-     const char * const a = argv[i];
+    if (!strncmp(a, alloc_size, strlen(alloc_size)))
+      total_alloc_size = atol(a + strlen(alloc_size));
 
-     if ( ! strncmp(a,help,strlen(help) ) ) ask_help = 1 ;
+    if (!strncmp(a, super_size, strlen(super_size)))
+      min_superblock_size = atoi(a + strlen(super_size));
 
-     if ( ! strncmp(a,alloc_size,strlen(alloc_size) ) )
-       total_alloc_size = atol( a + strlen(alloc_size) );
+    if (!strncmp(a, repeat_outer, strlen(repeat_outer)))
+      test_repeat_outer = atoi(a + strlen(repeat_outer));
 
-     if ( ! strncmp(a,super_size,strlen(super_size) ) )
-       min_superblock_size = atoi( a + strlen(super_size) );
-
-     if ( ! strncmp(a,repeat_outer,strlen(repeat_outer) ) )
-       test_repeat_outer = atoi( a + strlen(repeat_outer) );
-
-     if ( ! strncmp(a,input_value,strlen(input_value) ) )
-       fib_input = atoi( a + strlen(input_value) );
+    if (!strncmp(a, input_value, strlen(input_value)))
+      fib_input = atoi(a + strlen(input_value));
   }
 
-  const long fib_output   = eval_fib( fib_input );
-  const long number_alloc = fib_alloc_count( fib_input );
+  const long fib_output   = eval_fib(fib_input);
+  const long number_alloc = fib_alloc_count(fib_input);
 
-  const unsigned min_block_size =  32 ;
-  const unsigned max_block_size = 128 ;
+  const unsigned min_block_size = 32;
+  const unsigned max_block_size = 128;
 
-  long task_count_max = 0 ;
-  long task_count_accum = 0 ;
-  long test_result = 0 ;
+  long task_count_max   = 0;
+  long task_count_accum = 0;
+  long test_result      = 0;
 
-  if ( ask_help ) {
+  if (ask_help) {
     std::cout << "command line options:"
-              << " " << help
-              << " " << alloc_size << "##"
+              << " " << help << " " << alloc_size << "##"
               << " " << super_size << "##"
               << " " << input_value << "##"
-              << " " << repeat_outer << "##"
-              << std::endl ;
+              << " " << repeat_outer << "##" << std::endl;
     return -1;
   }
 
   using Scheduler = Kokkos::TaskSchedulerMultiple<ExecSpace>;
 
-  typedef TestFib< Scheduler >  Functor ;
+  typedef TestFib<Scheduler> Functor;
 
-  Kokkos::initialize(argc,argv);
+  Kokkos::initialize(argc, argv);
 
   {
-
-    Scheduler sched( Functor::MemorySpace()
-                            , total_alloc_size
-                            , min_block_size
-                            , max_block_size
-                            , min_superblock_size
-                            );
+    Scheduler sched(Functor::MemorySpace(), total_alloc_size, min_block_size,
+                    max_block_size, min_superblock_size);
 
     Functor::FutureType f =
-      Kokkos::host_spawn( Kokkos::TaskSingle( sched )
-                        , Functor( fib_input )
-                        );
+        Kokkos::host_spawn(Kokkos::TaskSingle(sched), Functor(fib_input));
 
-    Kokkos::wait( sched );
+    Kokkos::wait(sched);
 
     test_result = f.get();
 
-    //task_count_max   = sched.allocated_task_count_max();
-    //task_count_accum = sched.allocated_task_count_accum();
+    // task_count_max   = sched.allocated_task_count_max();
+    // task_count_accum = sched.allocated_task_count_accum();
 
-    //if ( number_alloc != task_count_accum ) {
+    // if ( number_alloc != task_count_accum ) {
     //  std::cout << " number_alloc( " << number_alloc << " )"
     //            << " != task_count_accum( " << task_count_accum << " )"
     //            << std::endl ;
     //}
 
-    if ( fib_output != test_result ) {
+    if (fib_output != test_result) {
       std::cout << " answer( " << fib_output << " )"
-                << " != result( " << test_result << " )"
-                << std::endl ;
+                << " != result( " << test_result << " )" << std::endl;
     }
 
-    if ( fib_output != test_result) { // || number_alloc != task_count_accum ) {
+    if (fib_output != test_result) {  // || number_alloc != task_count_accum ) {
       printf("  TEST FAILED\n");
       return -1;
     }
@@ -248,41 +219,34 @@ int main( int argc , char* argv[] )
     double min_time = std::numeric_limits<double>::max();
     double time_sum = 0;
 
-    for ( int i = 0 ; i < test_repeat_outer ; ++i ) {
-      Kokkos::Impl::Timer timer ;
+    for (int i = 0; i < test_repeat_outer; ++i) {
+      Kokkos::Impl::Timer timer;
 
       Functor::FutureType ftmp =
-        Kokkos::host_spawn( Kokkos::TaskSingle( sched )
-                          , Functor( fib_input )
-                          );
+          Kokkos::host_spawn(Kokkos::TaskSingle(sched), Functor(fib_input));
 
-      Kokkos::wait( sched );
+      Kokkos::wait(sched);
       auto this_time = timer.seconds();
-      min_time = std::min(min_time, this_time);
+      min_time       = std::min(min_time, this_time);
       time_sum += this_time;
     }
 
     auto avg_time = time_sum / test_repeat_outer;
 
-    printf( "\"taskdag: alloc super repeat input output task-accum task-max\" %ld %d %d %d %ld %ld %ld\n"
-          , total_alloc_size
-          , min_superblock_size
-          , test_repeat_outer
-          , fib_input
-          , fib_output
-          , task_count_accum
-          , task_count_max );
-
-    printf( "\"taskdag: time (min, avg)\" %g %g\n", min_time, avg_time);
-    printf( "\"taskdag: tasks per second (max, avg)\" %g %g\n"
-          , number_alloc / min_time
-          , number_alloc / avg_time );
-  } // end scope to destroy scheduler prior to finalize
+    printf(
+        "\"taskdag: alloc super repeat input output task-accum task-max\" %ld "
+        "%d %d %d %ld %ld %ld\n",
+        total_alloc_size, min_superblock_size, test_repeat_outer, fib_input,
+        fib_output, task_count_accum, task_count_max);
+
+    printf("\"taskdag: time (min, avg)\" %g %g\n", min_time, avg_time);
+    printf("\"taskdag: tasks per second (max, avg)\" %g %g\n",
+           number_alloc / min_time, number_alloc / avg_time);
+  }  // end scope to destroy scheduler prior to finalize
 
   Kokkos::finalize();
 
-  return 0 ;
+  return 0;
 }
 
 #endif
-
diff --git a/lib/kokkos/core/src/CMakeLists.txt b/lib/kokkos/core/src/CMakeLists.txt
index a941c5da0c390754a1e47cd4d38c0d142861ca86..eb058a982e199c3244e5640b61a95df5f61dd6c3 100644
--- a/lib/kokkos/core/src/CMakeLists.txt
+++ b/lib/kokkos/core/src/CMakeLists.txt
@@ -1,124 +1,81 @@
-
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-#-----------------------------------------------------------------------------
-
-SET(TRILINOS_INCDIR ${CMAKE_INSTALL_PREFIX}/${${PROJECT_NAME}_INSTALL_INCLUDE_DIR})
-
-#-----------------------------------------------------------------------------
-
-IF(KOKKOS_LEGACY_TRIBITS)
-
-  MESSAGE("LEGACY STUFF GETTING CALLED")
-
-  IF(KOKKOS_ENABLE_EXPLICIT_INSTANTIATION)
-    MESSAGE("GOING INTO ETI DIR")
-    ADD_SUBDIRECTORY(eti)
-    INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/eti")
-  ENDIF()
-
-  ASSERT_DEFINED(${PROJECT_NAME}_ENABLE_CXX11)
-  ASSERT_DEFINED(${PACKAGE_NAME}_ENABLE_CUDA)
-
-  SET(HEADERS_PUBLIC "")
-  SET(HEADERS_PRIVATE "")
-  SET(SOURCES "")
-
-  FILE(GLOB HEADERS_PUBLIC Kokkos*.hpp)
-  LIST( APPEND HEADERS_PUBLIC ${CMAKE_BINARY_DIR}/${PACKAGE_NAME}_config.h )
-
-  #-----------------------------------------------------------------------------
-
-  FILE(GLOB HEADERS_IMPL impl/*.hpp)
-  FILE(GLOB SOURCES_IMPL impl/*.cpp)
-
-  LIST(APPEND HEADERS_PRIVATE ${HEADERS_IMPL} )
-  LIST(APPEND SOURCES         ${SOURCES_IMPL} )
-
-  INSTALL(FILES ${HEADERS_IMPL} DESTINATION ${TRILINOS_INCDIR}/impl/)
-
-  #-----------------------------------------------------------------------------
-
-  FILE(GLOB HEADERS_THREADS Threads/*.hpp)
-  FILE(GLOB SOURCES_THREADS Threads/*.cpp)
-
-  LIST(APPEND HEADERS_PRIVATE ${HEADERS_THREADS} )
-  LIST(APPEND SOURCES         ${SOURCES_THREADS} )
-
-  INSTALL(FILES ${HEADERS_THREADS} DESTINATION ${TRILINOS_INCDIR}/Threads/)
-
-  #-----------------------------------------------------------------------------
-
-  FILE(GLOB HEADERS_OPENMP OpenMP/*.hpp)
-  FILE(GLOB SOURCES_OPENMP OpenMP/*.cpp)
-
-  LIST(APPEND HEADERS_PRIVATE ${HEADERS_OPENMP} )
-  LIST(APPEND SOURCES         ${SOURCES_OPENMP} )
-
-  INSTALL(FILES ${HEADERS_OPENMP} DESTINATION ${TRILINOS_INCDIR}/OpenMP/)
-
-  #-----------------------------------------------------------------------------
-
-  FILE(GLOB HEADERS_HPX HPX/*.hpp)
-  FILE(GLOB SOURCES_HPX HPX/*.cpp)
-
-  LIST(APPEND HEADERS_PRIVATE ${HEADERS_HPX} )
-  LIST(APPEND SOURCES         ${SOURCES_HPX} )
-
-  INSTALL(FILES ${HEADERS_HPX} DESTINATION ${TRILINOS_INCDIR}/HPX/)
-
-  #-----------------------------------------------------------------------------
-
-  FILE(GLOB HEADERS_CUDA Cuda/*.hpp)
-  FILE(GLOB SOURCES_CUDA Cuda/*.cpp)
-
-  LIST(APPEND HEADERS_PRIVATE ${HEADERS_CUDA} )
-  LIST(APPEND SOURCES         ${SOURCES_CUDA} )
-
-  INSTALL(FILES ${HEADERS_CUDA} DESTINATION ${TRILINOS_INCDIR}/Cuda/)
-
-  #-----------------------------------------------------------------------------
-  FILE(GLOB HEADERS_QTHREADS Qthreads/*.hpp)
-  FILE(GLOB SOURCES_QTHREADS Qthreads/*.cpp)
-
-  LIST(APPEND HEADERS_PRIVATE ${HEADERS_QTHREADS} )
-  LIST(APPEND SOURCES         ${SOURCES_QTHREADS} )
-
-  IF(KOKKOS_ENABLE_EXPLICIT_INSTANTIATION)
-    LIST(APPEND SOURCES       ${ETI_SOURCES} )
-  ENDIF()
-
-  INSTALL(FILES ${HEADERS_QTHREADS} DESTINATION ${TRILINOS_INCDIR}/Qthreads/)
-
-  TRIBITS_ADD_LIBRARY(
-      kokkoscore
-      HEADERS ${HEADERS_PUBLIC}
-      NOINSTALLHEADERS ${HEADERS_PRIVATE}
-      SOURCES ${SOURCES}
-      DEPLIBS
-      )
-
-#-----------------------------------------------------------------------------
-#  In the new build system, sources are calculated by Makefile.kokkos
-else()
-
-  INSTALL (DIRECTORY
-           "${CMAKE_CURRENT_SOURCE_DIR}/"
-           DESTINATION ${TRILINOS_INCDIR}
-           FILES_MATCHING PATTERN "*.hpp"
-  )
-
-  TRIBITS_ADD_LIBRARY(
-      kokkoscore
-      SOURCES ${KOKKOS_CORE_SRCS}
-      DEPLIBS
-      )
-
-endif()
-#-----------------------------------------------------------------------------
-
-# build and install pkgconfig file
-CONFIGURE_FILE(kokkos.pc.in kokkos.pc @ONLY)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/kokkos.pc DESTINATION lib/pkgconfig)
+#I have to leave these here for tribits
+KOKKOS_INCLUDE_DIRECTORIES(
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${KOKKOS_TOP_BUILD_DIR}
+)
+
+INSTALL (DIRECTORY
+  "${CMAKE_CURRENT_SOURCE_DIR}/"
+  DESTINATION ${KOKKOS_HEADER_DIR}
+  FILES_MATCHING PATTERN "*.hpp"
+)
+
+SET(KOKKOS_CORE_SRCS)
+APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/impl/*.cpp)
+
+IF (KOKKOS_ENABLE_ROCM)
+  APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/ROCm/*.cpp)
+  IF (KOKKOS_ENABLE_ETI)
+    APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/eti/ROCm/*.cpp)
+  ENDIF()
+ENDIF()
+
+IF (KOKKOS_ENABLE_CUDA)
+  APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/Cuda/*.cpp)
+  IF (KOKKOS_ENABLE_ETI)
+    APPEND_GLOB(KOKKOS_CORE_SRC ${CMAKE_CURRENT_SOURCE_DIR/eti/Cuda/*.cpp)
+  ENDIF()
+ENDIF()
+
+IF (KOKKOS_ENABLE_OPENMP)
+  APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/OpenMP/*.cpp)
+  IF (KOKKOS_ENABLE_ETI)
+    APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/eti/OpenMP/*.cpp)
+  ENDIF()
+ENDIF()
+
+IF (KOKKOS_ENABLE_PTHREAD)
+  APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/Threads/*.cpp)
+  IF (KOKKOS_ENABLE_ETI)
+    APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/eti/Threads/*.cpp)
+  ENDIF()
+ENDIF()
+
+IF (KOKKOS_ENABLE_HPX)
+  APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/HPX/*.cpp)
+ENDIF()
+
+IF (NOT KOKKOS_ENABLE_MEMKIND)
+  LIST(REMOVE_ITEM KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/impl/Kokkos_HBWSpace.cpp)
+ENDIF()
+
+IF (KOKKOS_ENABLE_SERIAL)
+  IF (KOKKOS_ENABLE_ETI)
+    APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/eti/Serial/*.cpp)
+  ENDIF()
+ELSE()
+  LIST(REMOVE_ITEM KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/impl/Kokkos_Serial.cpp)
+  LIST(REMOVE_ITEM KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/impl/Kokkos_Serial_task.cpp)
+ENDIF()
+
+KOKKOS_ADD_LIBRARY(
+  kokkoscore
+  SOURCES ${KOKKOS_CORE_SRCS}
+)
+
+SET_TARGET_PROPERTIES(kokkoscore PROPERTIES VERSION ${Kokkos_VERSION})
+
+KOKKOS_LIB_INCLUDE_DIRECTORIES(kokkoscore
+  ${KOKKOS_TOP_BUILD_DIR}
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+KOKKOS_LINK_TPL(kokkoscore PUBLIC HWLOC)
+KOKKOS_LINK_TPL(kokkoscore PUBLIC MEMKIND)
+KOKKOS_LINK_TPL(kokkoscore PUBLIC CUDA)
+KOKKOS_LINK_TPL(kokkoscore PUBLIC HPX)
+KOKKOS_LINK_TPL(kokkoscore PUBLIC LIBDL)
+KOKKOS_LINK_TPL(kokkoscore PUBLIC LIBRT)
+KOKKOS_LINK_TPL(kokkoscore PUBLIC PTHREAD)
diff --git a/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile.hpp b/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile.hpp
index 8a83dfff4a47ef340d758fd8a420cf4683b595f9..37062639217693623a02d93fc1eb469540011cbe 100644
--- a/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile.hpp
+++ b/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_CUDA_EXP_ITERATE_TILE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
 
 #include <iostream>
 #include <algorithm>
@@ -55,181 +56,182 @@
 
 //#include<Cuda/Kokkos_CudaExec.hpp>
 // Including the file above, leads to following type of errors:
-// /home/ndellin/kokkos/core/src/Cuda/Kokkos_CudaExec.hpp(84): error: incomplete type is not allowed
-// As a result, recreate cuda_parallel_launch and associated code
+// /home/ndellin/kokkos/core/src/Cuda/Kokkos_CudaExec.hpp(84): error: incomplete
+// type is not allowed As a result, recreate cuda_parallel_launch and associated
+// code
 
 #if defined(KOKKOS_ENABLE_PROFILING)
 #include <impl/Kokkos_Profiling_Interface.hpp>
 #include <typeinfo>
 #endif
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 // ------------------------------------------------------------------ //
 
-template< class DriverType >
-__global__
-static void cuda_parallel_launch( const DriverType driver )
-{
+template <class DriverType>
+__global__ static void cuda_parallel_launch(const DriverType driver) {
   driver();
 }
 
-template< class DriverType >
-struct CudaLaunch
-{
-  inline
-  CudaLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-            )
-  {
-    cuda_parallel_launch< DriverType ><<< grid , block >>>(driver);
+template <class DriverType>
+struct CudaLaunch {
+  inline CudaLaunch(const DriverType& driver, const dim3& grid,
+                    const dim3& block) {
+    cuda_parallel_launch<DriverType><<<grid, block>>>(driver);
   }
-
 };
 
 // ------------------------------------------------------------------ //
-template< int N , typename RP , typename Functor , typename Tag >
+template <int N, typename RP, typename Functor, typename Tag>
 struct apply_impl;
 
-//Rank 2
+// Rank 2
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct apply_impl<2,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct apply_impl<2, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-// LL
-  if (RP::inner_direction == RP::Left) {
-    for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-      const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-      if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-
-        for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-          const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-          if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-            m_func(offset_0 , offset_1);
+  __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
+
+  inline __device__ void exec_range() const {
+    // LL
+    if (RP::inner_direction == RP::Left) {
+      for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+           tile_id1 += gridDim.y) {
+        const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                    (index_type)threadIdx.y +
+                                    (index_type)m_rp.m_lower[1];
+        if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+          for (index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0];
+               tile_id0 += gridDim.x) {
+            const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                        (index_type)threadIdx.x +
+                                        (index_type)m_rp.m_lower[0];
+            if (offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0]) {
+              m_func(offset_0, offset_1);
+            }
           }
         }
       }
     }
-  }
-// LR
-  else {
-    for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-      const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-      if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-
-        for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-          const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-          if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-            m_func(offset_0 , offset_1);
+    // LR
+    else {
+      for (index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0];
+           tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+               tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+              m_func(offset_0, offset_1);
+            }
           }
         }
       }
     }
-  }
-
-  } //end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+  }  // end exec_range
 
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct apply_impl<2,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct apply_impl<2, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-  if (RP::inner_direction == RP::Left) {
-    // Loop over size maxnumblocks until full range covered
-    for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-      const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-      if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-
-        for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-          const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-          if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-            m_func(Tag(), offset_0 , offset_1);
+  inline __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
+
+  inline __device__ void exec_range() const {
+    if (RP::inner_direction == RP::Left) {
+      // Loop over size maxnumblocks until full range covered
+      for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+           tile_id1 += gridDim.y) {
+        const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                    (index_type)threadIdx.y +
+                                    (index_type)m_rp.m_lower[1];
+        if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+          for (index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0];
+               tile_id0 += gridDim.x) {
+            const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                        (index_type)threadIdx.x +
+                                        (index_type)m_rp.m_lower[0];
+            if (offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0]) {
+              m_func(Tag(), offset_0, offset_1);
+            }
           }
         }
       }
-    }
-  }
-  else {
-    for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-      const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-      if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-
-        for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-          const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-          if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-            m_func(Tag(), offset_0 , offset_1);
+    } else {
+      for (index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0];
+           tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+               tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+              m_func(Tag(), offset_0, offset_1);
+            }
           }
         }
       }
     }
-  }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 3
+// Rank 3
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct apply_impl<3,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct apply_impl<3, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
-  inline __device__
-  void exec_range() const
-  {
-// LL
+  inline __device__ void exec_range() const {
+    // LL
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id2 = blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-        const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-        if ( offset_2 < m_rp.m_upper[2] && threadIdx.z < m_rp.m_tile[2] ) {
-
-          for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-                const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-                if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-                  m_func(offset_0 , offset_1 , offset_2);
+      for (index_type tile_id2 = blockIdx.z; tile_id2 < m_rp.m_tile_end[2];
+           tile_id2 += gridDim.z) {
+        const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[2];
+        if (offset_2 < m_rp.m_upper[2] && threadIdx.z < m_rp.m_tile[2]) {
+          for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+               tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id0 = blockIdx.x;
+                   tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+                const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                            (index_type)threadIdx.x +
+                                            (index_type)m_rp.m_lower[0];
+                if (offset_0 < m_rp.m_upper[0] &&
+                    threadIdx.x < m_rp.m_tile[0]) {
+                  m_func(offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -237,83 +239,100 @@ struct apply_impl<3,RP,Functor,void >
         }
       }
     }
-// LR
-  else {
-    for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-      const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-      if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-
-        for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-          const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-          if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-
-            for ( index_type tile_id2 = blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-              const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-              if ( offset_2 < m_rp.m_upper[2] && threadIdx.z < m_rp.m_tile[2] ) {
-                m_func(offset_0 , offset_1 , offset_2);
+    // LR
+    else {
+      for (index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0];
+           tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+               tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = blockIdx.z;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.z +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    threadIdx.z < m_rp.m_tile[2]) {
+                  m_func(offset_0, offset_1, offset_2);
+                }
               }
             }
           }
         }
       }
     }
-  }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag >
-struct apply_impl<3,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct apply_impl<3, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  inline __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
-  inline __device__
-  void exec_range() const
-  {
+  inline __device__ void exec_range() const {
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id2 = blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-        const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-        if ( offset_2 < m_rp.m_upper[2] && threadIdx.z < m_rp.m_tile[2] ) {
-
-          for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-                const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-                if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-                  m_func(Tag(), offset_0 , offset_1 , offset_2);
+      for (index_type tile_id2 = blockIdx.z; tile_id2 < m_rp.m_tile_end[2];
+           tile_id2 += gridDim.z) {
+        const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[2];
+        if (offset_2 < m_rp.m_upper[2] && threadIdx.z < m_rp.m_tile[2]) {
+          for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+               tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id0 = blockIdx.x;
+                   tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+                const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                            (index_type)threadIdx.x +
+                                            (index_type)m_rp.m_lower[0];
+                if (offset_0 < m_rp.m_upper[0] &&
+                    threadIdx.x < m_rp.m_tile[0]) {
+                  m_func(Tag(), offset_0, offset_1, offset_2);
                 }
               }
             }
           }
         }
       }
-    }
-    else {
-      for ( index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && threadIdx.z < m_rp.m_tile[2] ) {
-                  m_func(Tag(), offset_0 , offset_1 , offset_2);
+    } else {
+      for (index_type tile_id0 = blockIdx.x; tile_id0 < m_rp.m_tile_end[0];
+           tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = blockIdx.y; tile_id1 < m_rp.m_tile_end[1];
+               tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = blockIdx.z;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.z +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    threadIdx.z < m_rp.m_tile[2]) {
+                  m_func(Tag(), offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -322,61 +341,64 @@ struct apply_impl<3,RP,Functor,Tag>
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 4
+// Rank 4
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct apply_impl<4,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct apply_impl<4, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
 
-  inline __device__
-  void exec_range() const
-  {
-// LL
+  inline __device__ void exec_range() const {
+    // LL
     if (RP::inner_direction == RP::Left) {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x % numbl0;
       const index_type tile_id1 = blockIdx.x / numbl0;
-      const index_type thr_id0 = threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = threadIdx.x / m_rp.m_tile[0];
-
-      for ( index_type tile_id3 = blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-        const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-        if ( offset_3 < m_rp.m_upper[3] && threadIdx.z < m_rp.m_tile[3] ) {
-
-          for ( index_type tile_id2 = blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-            const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-            if ( offset_2 < m_rp.m_upper[2] && threadIdx.y < m_rp.m_tile[2] ) {
-
-              for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                  for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                    const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                    if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                      m_func(offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = threadIdx.x / m_rp.m_tile[0];
+
+      for (index_type tile_id3 = blockIdx.z; tile_id3 < m_rp.m_tile_end[3];
+           tile_id3 += gridDim.z) {
+        const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[3];
+        if (offset_3 < m_rp.m_upper[3] && threadIdx.z < m_rp.m_tile[3]) {
+          for (index_type tile_id2 = blockIdx.y; tile_id2 < m_rp.m_tile_end[2];
+               tile_id2 += gridDim.y) {
+            const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[2];
+            if (offset_2 < m_rp.m_upper[2] && threadIdx.y < m_rp.m_tile[2]) {
+              for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                   j += numbl1) {
+                const index_type offset_1 =
+                    j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+                if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+                  for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                       i += numbl0) {
+                    const index_type offset_0 = i * m_rp.m_tile[0] + thr_id0 +
+                                                (index_type)m_rp.m_lower[0];
+                    if (offset_0 < m_rp.m_upper[0] &&
+                        thr_id0 < m_rp.m_tile[0]) {
+                      m_func(offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -386,35 +408,44 @@ struct apply_impl<4,RP,Functor,void >
         }
       }
     }
-// LR
+    // LR
     else {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-      ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x / numbl1;
       const index_type tile_id1 = blockIdx.x % numbl1;
-      const index_type thr_id0 = threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = threadIdx.x % m_rp.m_tile[1];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && threadIdx.y < m_rp.m_tile[2] ) {
-
-                  for ( index_type tile_id3 = blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-                    const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && threadIdx.z < m_rp.m_tile[3] ) {
-                      m_func(offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = threadIdx.x % m_rp.m_tile[1];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = blockIdx.y;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.y +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    threadIdx.y < m_rp.m_tile[2]) {
+                  for (index_type tile_id3 = blockIdx.z;
+                       tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z) {
+                    const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                                (index_type)threadIdx.z +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        threadIdx.z < m_rp.m_tile[3]) {
+                      m_func(offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -425,58 +456,62 @@ struct apply_impl<4,RP,Functor,void >
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag >
-struct apply_impl<4,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct apply_impl<4, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  inline __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
 
-  inline __device__
-  void exec_range() const
-  {
+  inline __device__ void exec_range() const {
     if (RP::inner_direction == RP::Left) {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x % numbl0;
       const index_type tile_id1 = blockIdx.x / numbl0;
-      const index_type thr_id0 = threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = threadIdx.x / m_rp.m_tile[0];
-
-      for ( index_type tile_id3 = blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-        const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-        if ( offset_3 < m_rp.m_upper[3] && threadIdx.z < m_rp.m_tile[3] ) {
-
-          for ( index_type tile_id2 = blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-            const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-            if ( offset_2 < m_rp.m_upper[2] && threadIdx.y < m_rp.m_tile[2] ) {
-
-              for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                  for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                    const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                    if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                      m_func(Tag(), offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = threadIdx.x / m_rp.m_tile[0];
+
+      for (index_type tile_id3 = blockIdx.z; tile_id3 < m_rp.m_tile_end[3];
+           tile_id3 += gridDim.z) {
+        const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[3];
+        if (offset_3 < m_rp.m_upper[3] && threadIdx.z < m_rp.m_tile[3]) {
+          for (index_type tile_id2 = blockIdx.y; tile_id2 < m_rp.m_tile_end[2];
+               tile_id2 += gridDim.y) {
+            const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[2];
+            if (offset_2 < m_rp.m_upper[2] && threadIdx.y < m_rp.m_tile[2]) {
+              for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                   j += numbl1) {
+                const index_type offset_1 =
+                    j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+                if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+                  for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                       i += numbl0) {
+                    const index_type offset_0 = i * m_rp.m_tile[0] + thr_id0 +
+                                                (index_type)m_rp.m_lower[0];
+                    if (offset_0 < m_rp.m_upper[0] &&
+                        thr_id0 < m_rp.m_tile[0]) {
+                      m_func(Tag(), offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -485,35 +520,43 @@ struct apply_impl<4,RP,Functor,Tag>
           }
         }
       }
-    }
-    else {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-      ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+    } else {
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x / numbl1;
       const index_type tile_id1 = blockIdx.x % numbl1;
-      const index_type thr_id0 = threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = threadIdx.x % m_rp.m_tile[1];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && threadIdx.y < m_rp.m_tile[2] ) {
-
-                  for ( index_type tile_id3 = blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-                    const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && threadIdx.z < m_rp.m_tile[3] ) {
-                      m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = threadIdx.x % m_rp.m_tile[1];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] + thr_id1 +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = blockIdx.y;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.y +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    threadIdx.y < m_rp.m_tile[2]) {
+                  for (index_type tile_id3 = blockIdx.z;
+                       tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z) {
+                    const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                                (index_type)threadIdx.z +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        threadIdx.z < m_rp.m_tile[3]) {
+                      m_func(Tag(), offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -524,77 +567,83 @@ struct apply_impl<4,RP,Functor,Tag>
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 5
+// Rank 5
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct apply_impl<5,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct apply_impl<5, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
 
-  inline __device__
-  void exec_range() const
-  {
-// LL
+  inline __device__ void exec_range() const {
+    // LL
     if (RP::inner_direction == RP::Left) {
-
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x % numbl0;
       const index_type tile_id1 = blockIdx.x / numbl0;
-      const index_type thr_id0 = threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y % numbl2;
       const index_type tile_id3 = blockIdx.y / numbl2;
-      const index_type thr_id2 = threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = threadIdx.y / m_rp.m_tile[2];
-
-      for ( index_type tile_id4 = blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-        if ( offset_4 < m_rp.m_upper[4] && threadIdx.z < m_rp.m_tile[4] ) {
-
-          for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-            const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-            if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                    const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                    if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                      for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                          m_func(offset_0 , offset_1 , offset_2 , offset_3, offset_4);
+      const index_type thr_id2  = threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = threadIdx.y / m_rp.m_tile[2];
+
+      for (index_type tile_id4 = blockIdx.z; tile_id4 < m_rp.m_tile_end[4];
+           tile_id4 += gridDim.z) {
+        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[4];
+        if (offset_4 < m_rp.m_upper[4] && threadIdx.z < m_rp.m_tile[4]) {
+          for (index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3) {
+            const index_type offset_3 =
+                l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+            if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                       j += numbl1) {
+                    const index_type offset_1 = j * m_rp.m_tile[1] + thr_id1 +
+                                                (index_type)m_rp.m_lower[1];
+                    if (offset_1 < m_rp.m_upper[1] &&
+                        thr_id1 < m_rp.m_tile[1]) {
+                      for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                           i += numbl0) {
+                        const index_type offset_0 = i * m_rp.m_tile[0] +
+                                                    thr_id0 +
+                                                    (index_type)m_rp.m_lower[0];
+                        if (offset_0 < m_rp.m_upper[0] &&
+                            thr_id0 < m_rp.m_tile[0]) {
+                          m_func(offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -606,50 +655,63 @@ struct apply_impl<5,RP,Functor,void >
         }
       }
     }
-// LR
+    // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-      ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x / numbl1;
       const index_type tile_id1 = blockIdx.x % numbl1;
-      const index_type thr_id0 = threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-      (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y / numbl3;
       const index_type tile_id3 = blockIdx.y % numbl3;
-      const index_type thr_id2 = threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = threadIdx.y % m_rp.m_tile[3];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type tile_id4 = blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-                        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && threadIdx.z < m_rp.m_tile[4] ) {
-                          m_func(offset_0 , offset_1 , offset_2 , offset_3 , offset_4);
+      const index_type thr_id2  = threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = threadIdx.y % m_rp.m_tile[3];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type tile_id4 = blockIdx.z;
+                           tile_id4 < m_rp.m_tile_end[4];
+                           tile_id4 += gridDim.z) {
+                        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                                    (index_type)threadIdx.z +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            threadIdx.z < m_rp.m_tile[4]) {
+                          m_func(offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -662,74 +724,82 @@ struct apply_impl<5,RP,Functor,void >
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct apply_impl<5,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct apply_impl<5, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
 
-  inline __device__
-  void exec_range() const
-  {
-// LL
+  inline __device__ void exec_range() const {
+    // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x % numbl0;
       const index_type tile_id1 = blockIdx.x / numbl0;
-      const index_type thr_id0 = threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y % numbl2;
       const index_type tile_id3 = blockIdx.y / numbl2;
-      const index_type thr_id2 = threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = threadIdx.y / m_rp.m_tile[2];
-
-      for ( index_type tile_id4 = blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-        if ( offset_4 < m_rp.m_upper[4] && threadIdx.z < m_rp.m_tile[4] ) {
-
-          for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-            const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-            if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                    const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                    if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                      for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                          m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3, offset_4);
+      const index_type thr_id2  = threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = threadIdx.y / m_rp.m_tile[2];
+
+      for (index_type tile_id4 = blockIdx.z; tile_id4 < m_rp.m_tile_end[4];
+           tile_id4 += gridDim.z) {
+        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[4];
+        if (offset_4 < m_rp.m_upper[4] && threadIdx.z < m_rp.m_tile[4]) {
+          for (index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3) {
+            const index_type offset_3 =
+                l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+            if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                       j += numbl1) {
+                    const index_type offset_1 = j * m_rp.m_tile[1] + thr_id1 +
+                                                (index_type)m_rp.m_lower[1];
+                    if (offset_1 < m_rp.m_upper[1] &&
+                        thr_id1 < m_rp.m_tile[1]) {
+                      for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                           i += numbl0) {
+                        const index_type offset_0 = i * m_rp.m_tile[0] +
+                                                    thr_id0 +
+                                                    (index_type)m_rp.m_lower[0];
+                        if (offset_0 < m_rp.m_upper[0] &&
+                            thr_id0 < m_rp.m_tile[0]) {
+                          m_func(Tag(), offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -741,50 +811,63 @@ struct apply_impl<5,RP,Functor,Tag>
         }
       }
     }
-// LR
+    // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-      ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x / numbl1;
       const index_type tile_id1 = blockIdx.x % numbl1;
-      const index_type thr_id0 = threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-      (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y / numbl3;
       const index_type tile_id3 = blockIdx.y % numbl3;
-      const index_type thr_id2 = threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = threadIdx.y % m_rp.m_tile[3];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type tile_id4 = blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-                        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && threadIdx.z < m_rp.m_tile[4] ) {
-                          m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3 , offset_4);
+      const index_type thr_id2  = threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = threadIdx.y % m_rp.m_tile[3];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type tile_id4 = blockIdx.z;
+                           tile_id4 < m_rp.m_tile_end[4];
+                           tile_id4 += gridDim.z) {
+                        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                                    (index_type)threadIdx.z +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            threadIdx.z < m_rp.m_tile[4]) {
+                          m_func(Tag(), offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -797,91 +880,101 @@ struct apply_impl<5,RP,Functor,Tag>
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 6
+// Rank 6
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct apply_impl<6,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct apply_impl<6, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
 
-  inline __device__
-  void exec_range() const
-  {
-// LL
+  inline __device__ void exec_range() const {
+    // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x % numbl0;
       const index_type tile_id1 = blockIdx.x / numbl0;
-      const index_type thr_id0 = threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y % numbl2;
       const index_type tile_id3 = blockIdx.y / numbl2;
-      const index_type thr_id2 = threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = threadIdx.y / m_rp.m_tile[2];
+      const index_type thr_id2  = threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = threadIdx.y / m_rp.m_tile[2];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl4 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl5 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl4 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl4 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl5 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl4)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id4 = blockIdx.z % numbl4;
       const index_type tile_id5 = blockIdx.z / numbl4;
-      const index_type thr_id4 = threadIdx.z % m_rp.m_tile[4];
-      const index_type thr_id5 = threadIdx.z / m_rp.m_tile[4];
-
-      for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-        const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-        if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-
-          for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-            const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-            if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-              for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                  for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                    const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                    if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                      for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                        const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                        if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                          for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                            const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                            if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                              m_func(offset_0 , offset_1 , offset_2 , offset_3, offset_4, offset_5);
+      const index_type thr_id4  = threadIdx.z % m_rp.m_tile[4];
+      const index_type thr_id5  = threadIdx.z / m_rp.m_tile[4];
+
+      for (index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5) {
+        const index_type offset_5 =
+            n * m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
+        if (offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5]) {
+          for (index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4) {
+            const index_type offset_4 =
+                m * m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
+            if (offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4]) {
+              for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                   l += numbl3) {
+                const index_type offset_3 =
+                    l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+                if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+                  for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                       k += numbl2) {
+                    const index_type offset_2 = k * m_rp.m_tile[2] + thr_id2 +
+                                                (index_type)m_rp.m_lower[2];
+                    if (offset_2 < m_rp.m_upper[2] &&
+                        thr_id2 < m_rp.m_tile[2]) {
+                      for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                           j += numbl1) {
+                        const index_type offset_1 = j * m_rp.m_tile[1] +
+                                                    thr_id1 +
+                                                    (index_type)m_rp.m_lower[1];
+                        if (offset_1 < m_rp.m_upper[1] &&
+                            thr_id1 < m_rp.m_tile[1]) {
+                          for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                               i += numbl0) {
+                            const index_type offset_0 =
+                                i * m_rp.m_tile[0] + thr_id0 +
+                                (index_type)m_rp.m_lower[0];
+                            if (offset_0 < m_rp.m_upper[0] &&
+                                thr_id0 < m_rp.m_tile[0]) {
+                              m_func(offset_0, offset_1, offset_2, offset_3,
+                                     offset_4, offset_5);
                             }
                           }
                         }
@@ -895,65 +988,82 @@ struct apply_impl<6,RP,Functor,void >
         }
       }
     }
-// LR
+    // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-      ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x / numbl1;
       const index_type tile_id1 = blockIdx.x % numbl1;
-      const index_type thr_id0 = threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-      (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y / numbl3;
       const index_type tile_id3 = blockIdx.y % numbl3;
-      const index_type thr_id2 = threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = threadIdx.y % m_rp.m_tile[3];
+      const index_type thr_id2  = threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = threadIdx.y % m_rp.m_tile[3];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl5 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl4 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl5 ) :
-      (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl5 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl4 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl5)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id4 = blockIdx.z / numbl5;
       const index_type tile_id5 = blockIdx.z % numbl5;
-      const index_type thr_id4 = threadIdx.z / m_rp.m_tile[5];
-      const index_type thr_id5 = threadIdx.z % m_rp.m_tile[5];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-                        const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-                          for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-                            const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-                            if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-                              m_func(offset_0 , offset_1 , offset_2 , offset_3 , offset_4 , offset_5);
+      const index_type thr_id4  = threadIdx.z / m_rp.m_tile[5];
+      const index_type thr_id5  = threadIdx.z % m_rp.m_tile[5];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type m = tile_id4; m < m_rp.m_tile_end[4];
+                           m += numbl4) {
+                        const index_type offset_4 = m * m_rp.m_tile[4] +
+                                                    thr_id4 +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            thr_id4 < m_rp.m_tile[4]) {
+                          for (index_type n = tile_id5; n < m_rp.m_tile_end[5];
+                               n += numbl5) {
+                            const index_type offset_5 =
+                                n * m_rp.m_tile[5] + thr_id5 +
+                                (index_type)m_rp.m_lower[5];
+                            if (offset_5 < m_rp.m_upper[5] &&
+                                thr_id5 < m_rp.m_tile[5]) {
+                              m_func(offset_0, offset_1, offset_2, offset_3,
+                                     offset_4, offset_5);
                             }
                           }
                         }
@@ -968,89 +1078,100 @@ struct apply_impl<6,RP,Functor,void >
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct apply_impl<6,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct apply_impl<6, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  __device__
-  apply_impl( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ apply_impl(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
 
-  inline __device__
-  void exec_range() const
-  {
-// LL
+  inline __device__ void exec_range() const {
+    // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x % numbl0;
       const index_type tile_id1 = blockIdx.x / numbl0;
-      const index_type thr_id0 = threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y % numbl2;
       const index_type tile_id3 = blockIdx.y / numbl2;
-      const index_type thr_id2 = threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = threadIdx.y / m_rp.m_tile[2];
+      const index_type thr_id2  = threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = threadIdx.y / m_rp.m_tile[2];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl4 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl5 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl4 ) :
-      (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl4 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl5 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl4)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id4 = blockIdx.z % numbl4;
       const index_type tile_id5 = blockIdx.z / numbl4;
-      const index_type thr_id4 = threadIdx.z % m_rp.m_tile[4];
-      const index_type thr_id5 = threadIdx.z / m_rp.m_tile[4];
-
-      for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-        const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-        if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-
-          for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-            const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-            if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-              for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                  for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                    const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                    if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                      for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                        const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                        if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                          for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                            const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                            if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                              m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3, offset_4, offset_5);
+      const index_type thr_id4  = threadIdx.z % m_rp.m_tile[4];
+      const index_type thr_id5  = threadIdx.z / m_rp.m_tile[4];
+
+      for (index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5) {
+        const index_type offset_5 =
+            n * m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
+        if (offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5]) {
+          for (index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4) {
+            const index_type offset_4 =
+                m * m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
+            if (offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4]) {
+              for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                   l += numbl3) {
+                const index_type offset_3 =
+                    l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+                if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+                  for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                       k += numbl2) {
+                    const index_type offset_2 = k * m_rp.m_tile[2] + thr_id2 +
+                                                (index_type)m_rp.m_lower[2];
+                    if (offset_2 < m_rp.m_upper[2] &&
+                        thr_id2 < m_rp.m_tile[2]) {
+                      for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                           j += numbl1) {
+                        const index_type offset_1 = j * m_rp.m_tile[1] +
+                                                    thr_id1 +
+                                                    (index_type)m_rp.m_lower[1];
+                        if (offset_1 < m_rp.m_upper[1] &&
+                            thr_id1 < m_rp.m_tile[1]) {
+                          for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                               i += numbl0) {
+                            const index_type offset_0 =
+                                i * m_rp.m_tile[0] + thr_id0 +
+                                (index_type)m_rp.m_lower[0];
+                            if (offset_0 < m_rp.m_upper[0] &&
+                                thr_id0 < m_rp.m_tile[0]) {
+                              m_func(Tag(), offset_0, offset_1, offset_2,
+                                     offset_3, offset_4, offset_5);
                             }
                           }
                         }
@@ -1064,65 +1185,82 @@ struct apply_impl<6,RP,Functor,Tag>
         }
       }
     }
-// LR
+    // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-      ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = blockIdx.x / numbl1;
       const index_type tile_id1 = blockIdx.x % numbl1;
-      const index_type thr_id0 = threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-      (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = blockIdx.y / numbl3;
       const index_type tile_id3 = blockIdx.y % numbl3;
-      const index_type thr_id2 = threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = threadIdx.y % m_rp.m_tile[3];
+      const index_type thr_id2  = threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = threadIdx.y % m_rp.m_tile[3];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl5 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl4 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl5 ) :
-      (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl5 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl4 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl5)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id4 = blockIdx.z / numbl5;
       const index_type tile_id5 = blockIdx.z % numbl5;
-      const index_type thr_id4 = threadIdx.z / m_rp.m_tile[5];
-      const index_type thr_id5 = threadIdx.z % m_rp.m_tile[5];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-                        const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-                          for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-                            const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-                            if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-                              m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3 , offset_4 , offset_5);
+      const index_type thr_id4  = threadIdx.z / m_rp.m_tile[5];
+      const index_type thr_id5  = threadIdx.z % m_rp.m_tile[5];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type m = tile_id4; m < m_rp.m_tile_end[4];
+                           m += numbl4) {
+                        const index_type offset_4 = m * m_rp.m_tile[4] +
+                                                    thr_id4 +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            thr_id4 < m_rp.m_tile[4]) {
+                          for (index_type n = tile_id5; n < m_rp.m_tile_end[5];
+                               n += numbl5) {
+                            const index_type offset_5 =
+                                n * m_rp.m_tile[5] + thr_id5 +
+                                (index_type)m_rp.m_lower[5];
+                            if (offset_5 < m_rp.m_upper[5] &&
+                                thr_id5 < m_rp.m_tile[5]) {
+                              m_func(Tag(), offset_0, offset_1, offset_2,
+                                     offset_3, offset_4, offset_5);
                             }
                           }
                         }
@@ -1137,127 +1275,118 @@ struct apply_impl<6,RP,Functor,Tag>
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // ----------------------------------------------------------------------------------
 
-template < typename RP
-         , typename Functor
-         , typename Tag
-         >
-struct DeviceIterateTile
-{
-  using index_type = typename RP::index_type;
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile {
+  using index_type       = typename RP::index_type;
   using array_index_type = typename RP::array_index_type;
-  using point_type = typename RP::point_type;
+  using point_type       = typename RP::point_type;
 
   struct VoidDummy {};
-  typedef typename std::conditional< std::is_same<Tag, void>::value, VoidDummy, Tag>::type usable_tag;
-
-  DeviceIterateTile( const RP & rp, const Functor & func )
-    : m_rp{rp}
-    , m_func{func}
-  {}
-
-private:
-  inline __device__
-  void apply() const
-  {
-    apply_impl<RP::rank,RP,Functor,Tag>(m_rp,m_func).exec_range();
-  } //end apply
-
-public:
-
-  inline
-  __device__
-  void operator()(void) const
-  {
-    this-> apply();
-  }
+  typedef typename std::conditional<std::is_same<Tag, void>::value, VoidDummy,
+                                    Tag>::type usable_tag;
+
+  DeviceIterateTile(const RP& rp, const Functor& func)
+      : m_rp{rp}, m_func{func} {}
+
+ private:
+  inline __device__ void apply() const {
+    apply_impl<RP::rank, RP, Functor, Tag>(m_rp, m_func).exec_range();
+  }  // end apply
+
+ public:
+  inline __device__ void operator()(void) const { this->apply(); }
 
-  inline
-  void execute() const
-  {
-    const array_index_type maxblocks = 65535; //not true for blockIdx.x for newer archs
-    if ( RP::rank == 2 )
-    {
-      const dim3 block( m_rp.m_tile[0] , m_rp.m_tile[1] , 1);
+  inline void execute() const {
+    const array_index_type maxblocks =
+        65535;  // not true for blockIdx.x for newer archs
+    if (RP::rank == 2) {
+      const dim3 block(m_rp.m_tile[0], m_rp.m_tile[1], 1);
       const dim3 grid(
-            std::min( ( m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1 ) / block.x , maxblocks )
-          , std::min( ( m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1 ) / block.y , maxblocks )
-          , 1
-          );
-      CudaLaunch< DeviceIterateTile >( *this , grid , block );
-    }
-    else if ( RP::rank == 3 )
-    {
-      const dim3 block( m_rp.m_tile[0] , m_rp.m_tile[1] , m_rp.m_tile[2] );
+          std::min((m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1) / block.x,
+                   maxblocks),
+          std::min((m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1) / block.y,
+                   maxblocks),
+          1);
+      CudaLaunch<DeviceIterateTile>(*this, grid, block);
+    } else if (RP::rank == 3) {
+      const dim3 block(m_rp.m_tile[0], m_rp.m_tile[1], m_rp.m_tile[2]);
       const dim3 grid(
-          std::min( ( m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1 ) / block.x , maxblocks )
-        , std::min( ( m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1 ) / block.y , maxblocks )
-        , std::min( ( m_rp.m_upper[2] - m_rp.m_lower[2] + block.z - 1 ) / block.z , maxblocks )
-        );
-      CudaLaunch< DeviceIterateTile >( *this , grid , block );
-    }
-    else if ( RP::rank == 4 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2] , m_rp.m_tile[3] );
+          std::min((m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1) / block.x,
+                   maxblocks),
+          std::min((m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1) / block.y,
+                   maxblocks),
+          std::min((m_rp.m_upper[2] - m_rp.m_lower[2] + block.z - 1) / block.z,
+                   maxblocks));
+      CudaLaunch<DeviceIterateTile>(*this, grid, block);
+    } else if (RP::rank == 4) {
+      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1], m_rp.m_tile[2],
+                       m_rp.m_tile[3]);
       const dim3 grid(
-          std::min( static_cast<index_type>( m_rp.m_tile_end[0] * m_rp.m_tile_end[1] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( ( m_rp.m_upper[2] - m_rp.m_lower[2] + block.y - 1 ) / block.y , maxblocks )
-        , std::min( ( m_rp.m_upper[3] - m_rp.m_lower[3] + block.z - 1 ) / block.z , maxblocks )
-        );
-      CudaLaunch< DeviceIterateTile >( *this , grid , block );
-    }
-    else if ( RP::rank == 5 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2]*m_rp.m_tile[3] , m_rp.m_tile[4] );
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[0] * m_rp.m_tile_end[1]),
+              static_cast<index_type>(maxblocks)),
+          std::min((m_rp.m_upper[2] - m_rp.m_lower[2] + block.y - 1) / block.y,
+                   maxblocks),
+          std::min((m_rp.m_upper[3] - m_rp.m_lower[3] + block.z - 1) / block.z,
+                   maxblocks));
+      CudaLaunch<DeviceIterateTile>(*this, grid, block);
+    } else if (RP::rank == 5) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1],
+                       m_rp.m_tile[2] * m_rp.m_tile[3], m_rp.m_tile[4]);
       const dim3 grid(
-          std::min( static_cast<index_type>( m_rp.m_tile_end[0] * m_rp.m_tile_end[1] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( static_cast<index_type>( m_rp.m_tile_end[2] * m_rp.m_tile_end[3] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( ( m_rp.m_upper[4] - m_rp.m_lower[4] + block.z - 1 ) / block.z , maxblocks )
-        );
-      CudaLaunch< DeviceIterateTile >( *this , grid , block );
-    }
-    else if ( RP::rank == 6 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4,id5 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2]*m_rp.m_tile[3] , m_rp.m_tile[4]*m_rp.m_tile[5] );
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[0] * m_rp.m_tile_end[1]),
+              static_cast<index_type>(maxblocks)),
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[2] * m_rp.m_tile_end[3]),
+              static_cast<index_type>(maxblocks)),
+          std::min((m_rp.m_upper[4] - m_rp.m_lower[4] + block.z - 1) / block.z,
+                   maxblocks));
+      CudaLaunch<DeviceIterateTile>(*this, grid, block);
+    } else if (RP::rank == 6) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4,id5 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1],
+                       m_rp.m_tile[2] * m_rp.m_tile[3],
+                       m_rp.m_tile[4] * m_rp.m_tile[5]);
       const dim3 grid(
-          std::min( static_cast<index_type>( m_rp.m_tile_end[0] * m_rp.m_tile_end[1] )
-                  , static_cast<index_type>(maxblocks) )
-        ,  std::min( static_cast<index_type>( m_rp.m_tile_end[2] * m_rp.m_tile_end[3] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( static_cast<index_type>( m_rp.m_tile_end[4] * m_rp.m_tile_end[5] )
-                  , static_cast<index_type>(maxblocks) )
-        );
-      CudaLaunch< DeviceIterateTile >( *this , grid , block );
-    }
-    else
-    {
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[0] * m_rp.m_tile_end[1]),
+              static_cast<index_type>(maxblocks)),
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[2] * m_rp.m_tile_end[3]),
+              static_cast<index_type>(maxblocks)),
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[4] * m_rp.m_tile_end[5]),
+              static_cast<index_type>(maxblocks)));
+      CudaLaunch<DeviceIterateTile>(*this, grid, block);
+    } else {
       printf("Kokkos::MDRange Error: Exceeded rank bounds with Cuda\n");
       Kokkos::abort("Aborting");
     }
 
-  } //end execute
+  }  // end execute
 
-protected:
-  const RP         m_rp;
-  const Functor    m_func;
+ protected:
+  const RP m_rp;
+  const Functor m_func;
 };
 
-} } //end namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
 #endif
-
diff --git a/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile_Refactor.hpp b/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile_Refactor.hpp
index 636e05c8acf29ed5cc23e52c2217a0573c610d26..cb7f5971ae0f3c4bb4abe5a72241ce5effa715f4 100644
--- a/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile_Refactor.hpp
+++ b/lib/kokkos/core/src/Cuda/KokkosExp_Cuda_IterateTile_Refactor.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_CUDA_EXP_ITERATE_TILE_REFACTOR_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
 
 #include <iostream>
 #include <algorithm>
@@ -55,49 +56,52 @@
 
 // #include<Cuda/Kokkos_CudaExec.hpp>
 // Including the file above leads to following type of errors:
-// /home/ndellin/kokkos/core/src/Cuda/Kokkos_CudaExec.hpp(84): error: incomplete type is not allowed
-// use existing Kokkos functionality, e.g. max blocks, once resolved
+// /home/ndellin/kokkos/core/src/Cuda/Kokkos_CudaExec.hpp(84): error: incomplete
+// type is not allowed use existing Kokkos functionality, e.g. max blocks, once
+// resolved
 
 #if defined(KOKKOS_ENABLE_PROFILING)
 #include <impl/Kokkos_Profiling_Interface.hpp>
 #include <typeinfo>
 #endif
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 namespace Refactor {
 
 // ------------------------------------------------------------------ //
 // ParallelFor iteration pattern
-template< int N , typename RP , typename Functor , typename Tag >
+template <int N, typename RP, typename Functor, typename Tag>
 struct DeviceIterateTile;
 
-//Rank 2
+// Rank 2
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<2,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<2, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
-  inline __device__
-  void exec_range() const
-  {
+  inline __device__ void exec_range() const {
     // LL
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-        const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-        if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-
-          for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-            const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-            if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-              m_func(offset_0 , offset_1);
+      for (index_type tile_id1 = (index_type)blockIdx.y;
+           tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+        const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                    (index_type)threadIdx.y +
+                                    (index_type)m_rp.m_lower[1];
+        if (offset_1 < m_rp.m_upper[1] &&
+            (index_type)threadIdx.y < m_rp.m_tile[1]) {
+          for (index_type tile_id0 = (index_type)blockIdx.x;
+               tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+            const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                        (index_type)threadIdx.x +
+                                        (index_type)m_rp.m_lower[0];
+            if (offset_0 < m_rp.m_upper[0] &&
+                (index_type)threadIdx.x < m_rp.m_tile[0]) {
+              m_func(offset_0, offset_1);
             }
           }
         }
@@ -105,108 +109,125 @@ struct DeviceIterateTile<2,RP,Functor,void >
     }
     // LR
     else {
-      for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-              m_func(offset_0 , offset_1);
+      for (index_type tile_id0 = (index_type)blockIdx.x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx.y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx.y < m_rp.m_tile[1]) {
+              m_func(offset_0, offset_1);
             }
           }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<2,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<2, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
-  inline __device__
-  void exec_range() const
-  {
+  inline __device__ void exec_range() const {
     if (RP::inner_direction == RP::Left) {
       // Loop over size maxnumblocks until full range covered
-      for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-        const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-        if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-
-          for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-            const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-            if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-              m_func(Tag(), offset_0 , offset_1);
+      for (index_type tile_id1 = (index_type)blockIdx.y;
+           tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+        const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                    (index_type)threadIdx.y +
+                                    (index_type)m_rp.m_lower[1];
+        if (offset_1 < m_rp.m_upper[1] &&
+            (index_type)threadIdx.y < m_rp.m_tile[1]) {
+          for (index_type tile_id0 = (index_type)blockIdx.x;
+               tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+            const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                        (index_type)threadIdx.x +
+                                        (index_type)m_rp.m_lower[0];
+            if (offset_0 < m_rp.m_upper[0] &&
+                (index_type)threadIdx.x < m_rp.m_tile[0]) {
+              m_func(Tag(), offset_0, offset_1);
             }
           }
         }
       }
-    }
-    else {
-      for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-              m_func(Tag(), offset_0 , offset_1);
+    } else {
+      for (index_type tile_id0 = (index_type)blockIdx.x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx.y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx.y < m_rp.m_tile[1]) {
+              m_func(Tag(), offset_0, offset_1);
             }
           }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 3
+// Rank 3
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<3,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<3, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
-  inline __device__
-  void exec_range() const
-  {
+  inline __device__ void exec_range() const {
     // LL
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id2 = (index_type)blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-        const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-        if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.z < m_rp.m_tile[2] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-                const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-                if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-                  m_func(offset_0 , offset_1 , offset_2);
+      for (index_type tile_id2 = (index_type)blockIdx.z;
+           tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z) {
+        const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[2];
+        if (offset_2 < m_rp.m_upper[2] &&
+            (index_type)threadIdx.z < m_rp.m_tile[2]) {
+          for (index_type tile_id1 = (index_type)blockIdx.y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id0 = (index_type)blockIdx.x;
+                   tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+                const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                            (index_type)threadIdx.x +
+                                            (index_type)m_rp.m_lower[0];
+                if (offset_0 < m_rp.m_upper[0] &&
+                    (index_type)threadIdx.x < m_rp.m_tile[0]) {
+                  m_func(offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -216,18 +237,28 @@ struct DeviceIterateTile<3,RP,Functor,void >
     }
     // LR
     else {
-      for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.z < m_rp.m_tile[2] ) {
-                  m_func(offset_0 , offset_1 , offset_2);
+      for (index_type tile_id0 = (index_type)blockIdx.x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx.y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx.z;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.z +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx.z < m_rp.m_tile[2]) {
+                  m_func(offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -235,61 +266,74 @@ struct DeviceIterateTile<3,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<3,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<3, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
-  inline __device__
-  void exec_range() const
-  {
+  inline __device__ void exec_range() const {
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id2 = (index_type)blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-        const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-        if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.z < m_rp.m_tile[2] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-                const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-                if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-                  m_func(Tag(), offset_0 , offset_1 , offset_2);
+      for (index_type tile_id2 = (index_type)blockIdx.z;
+           tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z) {
+        const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[2];
+        if (offset_2 < m_rp.m_upper[2] &&
+            (index_type)threadIdx.z < m_rp.m_tile[2]) {
+          for (index_type tile_id1 = (index_type)blockIdx.y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id0 = (index_type)blockIdx.x;
+                   tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+                const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                            (index_type)threadIdx.x +
+                                            (index_type)m_rp.m_lower[0];
+                if (offset_0 < m_rp.m_upper[0] &&
+                    (index_type)threadIdx.x < m_rp.m_tile[0]) {
+                  m_func(Tag(), offset_0, offset_1, offset_2);
                 }
               }
             }
           }
         }
       }
-    }
-    else {
-      for ( index_type tile_id0 = (index_type)blockIdx.x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx.x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx.x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx.y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx.y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx.z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.z < m_rp.m_tile[2] ) {
-                  m_func(Tag(), offset_0 , offset_1 , offset_2);
+    } else {
+      for (index_type tile_id0 = (index_type)blockIdx.x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim.x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx.x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx.x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx.y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim.y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx.y < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx.z;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.z) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.z +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx.z < m_rp.m_tile[2]) {
+                  m_func(Tag(), offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -297,64 +341,72 @@ struct DeviceIterateTile<3,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 4
+// Rank 4
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<4,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<4, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx.x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx.x / m_rp.m_tile[0];
-
-      for ( index_type tile_id3 = (index_type)blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-        const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-        if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx.z < m_rp.m_tile[3] ) {
-
-          for ( index_type tile_id2 = (index_type)blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-            const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-            if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.y < m_rp.m_tile[2] ) {
-
-              for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                  for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                    const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                    if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                      m_func(offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx.x / m_rp.m_tile[0];
+
+      for (index_type tile_id3 = (index_type)blockIdx.z;
+           tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z) {
+        const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[3];
+        if (offset_3 < m_rp.m_upper[3] &&
+            (index_type)threadIdx.z < m_rp.m_tile[3]) {
+          for (index_type tile_id2 = (index_type)blockIdx.y;
+               tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y) {
+            const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[2];
+            if (offset_2 < m_rp.m_upper[2] &&
+                (index_type)threadIdx.y < m_rp.m_tile[2]) {
+              for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                   j += numbl1) {
+                const index_type offset_1 =
+                    j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+                if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+                  for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                       i += numbl0) {
+                    const index_type offset_0 = i * m_rp.m_tile[0] + thr_id0 +
+                                                (index_type)m_rp.m_lower[0];
+                    if (offset_0 < m_rp.m_upper[0] &&
+                        thr_id0 < m_rp.m_tile[0]) {
+                      m_func(offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -366,33 +418,42 @@ struct DeviceIterateTile<4,RP,Functor,void >
     }
     // LR
     else {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx.x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx.x % m_rp.m_tile[1];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.y < m_rp.m_tile[2] ) {
-
-                  for ( index_type tile_id3 = (index_type)blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-                    const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx.z < m_rp.m_tile[3] ) {
-                      m_func(offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx.x % m_rp.m_tile[1];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx.y;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.y +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx.y < m_rp.m_tile[2]) {
+                  for (index_type tile_id3 = (index_type)blockIdx.z;
+                       tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z) {
+                    const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                                (index_type)threadIdx.z +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        (index_type)threadIdx.z < m_rp.m_tile[3]) {
+                      m_func(offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -402,61 +463,70 @@ struct DeviceIterateTile<4,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<4,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<4, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
     if (RP::inner_direction == RP::Left) {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx.x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx.x / m_rp.m_tile[0];
-
-      for ( index_type tile_id3 = (index_type)blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-        const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-        if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx.z < m_rp.m_tile[3] ) {
-
-          for ( index_type tile_id2 = (index_type)blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-            const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-            if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.y < m_rp.m_tile[2] ) {
-
-              for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                  for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                    const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                    if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                      m_func(Tag(), offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx.x / m_rp.m_tile[0];
+
+      for (index_type tile_id3 = (index_type)blockIdx.z;
+           tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z) {
+        const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[3];
+        if (offset_3 < m_rp.m_upper[3] &&
+            (index_type)threadIdx.z < m_rp.m_tile[3]) {
+          for (index_type tile_id2 = (index_type)blockIdx.y;
+               tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y) {
+            const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                        (index_type)threadIdx.y +
+                                        (index_type)m_rp.m_lower[2];
+            if (offset_2 < m_rp.m_upper[2] &&
+                (index_type)threadIdx.y < m_rp.m_tile[2]) {
+              for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                   j += numbl1) {
+                const index_type offset_1 =
+                    j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+                if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+                  for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                       i += numbl0) {
+                    const index_type offset_0 = i * m_rp.m_tile[0] + thr_id0 +
+                                                (index_type)m_rp.m_lower[0];
+                    if (offset_0 < m_rp.m_upper[0] &&
+                        thr_id0 < m_rp.m_tile[0]) {
+                      m_func(Tag(), offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -465,35 +535,43 @@ struct DeviceIterateTile<4,RP,Functor,Tag>
           }
         }
       }
-    }
-    else {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+    } else {
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx.x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx.x % m_rp.m_tile[1];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx.y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx.y + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx.y < m_rp.m_tile[2] ) {
-
-                  for ( index_type tile_id3 = (index_type)blockIdx.z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z ) {
-                    const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx.z < m_rp.m_tile[3] ) {
-                      m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx.x % m_rp.m_tile[1];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] + thr_id1 +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx.y;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim.y) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx.y +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx.y < m_rp.m_tile[2]) {
+                  for (index_type tile_id3 = (index_type)blockIdx.z;
+                       tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim.z) {
+                    const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                                (index_type)threadIdx.z +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        (index_type)threadIdx.z < m_rp.m_tile[3]) {
+                      m_func(Tag(), offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -503,80 +581,90 @@ struct DeviceIterateTile<4,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 5
+// Rank 5
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<5,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<5, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx.x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx.y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx.y / m_rp.m_tile[2];
-
-      for ( index_type tile_id4 = (index_type)blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx.z < m_rp.m_tile[4] ) {
-
-          for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-            const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-            if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                    const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                    if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                      for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                          m_func(offset_0 , offset_1 , offset_2 , offset_3, offset_4);
+      const index_type thr_id2  = (index_type)threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx.y / m_rp.m_tile[2];
+
+      for (index_type tile_id4 = (index_type)blockIdx.z;
+           tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z) {
+        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[4];
+        if (offset_4 < m_rp.m_upper[4] &&
+            (index_type)threadIdx.z < m_rp.m_tile[4]) {
+          for (index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3) {
+            const index_type offset_3 =
+                l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+            if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                       j += numbl1) {
+                    const index_type offset_1 = j * m_rp.m_tile[1] + thr_id1 +
+                                                (index_type)m_rp.m_lower[1];
+                    if (offset_1 < m_rp.m_upper[1] &&
+                        thr_id1 < m_rp.m_tile[1]) {
+                      for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                           i += numbl0) {
+                        const index_type offset_0 = i * m_rp.m_tile[0] +
+                                                    thr_id0 +
+                                                    (index_type)m_rp.m_lower[0];
+                        if (offset_0 < m_rp.m_upper[0] &&
+                            thr_id0 < m_rp.m_tile[0]) {
+                          m_func(offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -590,48 +678,61 @@ struct DeviceIterateTile<5,RP,Functor,void >
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx.x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx.y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx.y % m_rp.m_tile[3];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type tile_id4 = (index_type)blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-                        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx.z < m_rp.m_tile[4] ) {
-                          m_func(offset_0 , offset_1 , offset_2 , offset_3 , offset_4);
+      const index_type thr_id2  = (index_type)threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx.y % m_rp.m_tile[3];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type tile_id4 = (index_type)blockIdx.z;
+                           tile_id4 < m_rp.m_tile_end[4];
+                           tile_id4 += gridDim.z) {
+                        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                                    (index_type)threadIdx.z +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            (index_type)threadIdx.z < m_rp.m_tile[4]) {
+                          m_func(offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -643,77 +744,89 @@ struct DeviceIterateTile<5,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<5,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<5, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx.x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx.y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx.y / m_rp.m_tile[2];
-
-      for ( index_type tile_id4 = (index_type)blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx.z < m_rp.m_tile[4] ) {
-
-          for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-            const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-            if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                    const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                    if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                      for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                          m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3, offset_4);
+      const index_type thr_id2  = (index_type)threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx.y / m_rp.m_tile[2];
+
+      for (index_type tile_id4 = (index_type)blockIdx.z;
+           tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z) {
+        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                    (index_type)threadIdx.z +
+                                    (index_type)m_rp.m_lower[4];
+        if (offset_4 < m_rp.m_upper[4] &&
+            (index_type)threadIdx.z < m_rp.m_tile[4]) {
+          for (index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3) {
+            const index_type offset_3 =
+                l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+            if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                       j += numbl1) {
+                    const index_type offset_1 = j * m_rp.m_tile[1] + thr_id1 +
+                                                (index_type)m_rp.m_lower[1];
+                    if (offset_1 < m_rp.m_upper[1] &&
+                        thr_id1 < m_rp.m_tile[1]) {
+                      for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                           i += numbl0) {
+                        const index_type offset_0 = i * m_rp.m_tile[0] +
+                                                    thr_id0 +
+                                                    (index_type)m_rp.m_lower[0];
+                        if (offset_0 < m_rp.m_upper[0] &&
+                            thr_id0 < m_rp.m_tile[0]) {
+                          m_func(Tag(), offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -727,48 +840,61 @@ struct DeviceIterateTile<5,RP,Functor,Tag>
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx.x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx.y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx.y % m_rp.m_tile[3];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type tile_id4 = (index_type)blockIdx.z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim.z ) {
-                        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx.z + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx.z < m_rp.m_tile[4] ) {
-                          m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3 , offset_4);
+      const index_type thr_id2  = (index_type)threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx.y % m_rp.m_tile[3];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type tile_id4 = (index_type)blockIdx.z;
+                           tile_id4 < m_rp.m_tile_end[4];
+                           tile_id4 += gridDim.z) {
+                        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                                    (index_type)threadIdx.z +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            (index_type)threadIdx.z < m_rp.m_tile[4]) {
+                          m_func(Tag(), offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -780,94 +906,107 @@ struct DeviceIterateTile<5,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 6
+// Rank 6
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<6,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<6, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx.x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx.y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx.y / m_rp.m_tile[2];
+      const index_type thr_id2  = (index_type)threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx.y / m_rp.m_tile[2];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl4 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl5 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl4 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl4 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl5 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl4)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx.z % numbl4;
       const index_type tile_id5 = (index_type)blockIdx.z / numbl4;
-      const index_type thr_id4 = (index_type)threadIdx.z % m_rp.m_tile[4];
-      const index_type thr_id5 = (index_type)threadIdx.z / m_rp.m_tile[4];
-
-      for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-        const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-        if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-
-          for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-            const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-            if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-              for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                  for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                    const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                    if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                      for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                        const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                        if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                          for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                            const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                            if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                              m_func(offset_0 , offset_1 , offset_2 , offset_3, offset_4, offset_5);
+      const index_type thr_id4  = (index_type)threadIdx.z % m_rp.m_tile[4];
+      const index_type thr_id5  = (index_type)threadIdx.z / m_rp.m_tile[4];
+
+      for (index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5) {
+        const index_type offset_5 =
+            n * m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
+        if (offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5]) {
+          for (index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4) {
+            const index_type offset_4 =
+                m * m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
+            if (offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4]) {
+              for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                   l += numbl3) {
+                const index_type offset_3 =
+                    l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+                if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+                  for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                       k += numbl2) {
+                    const index_type offset_2 = k * m_rp.m_tile[2] + thr_id2 +
+                                                (index_type)m_rp.m_lower[2];
+                    if (offset_2 < m_rp.m_upper[2] &&
+                        thr_id2 < m_rp.m_tile[2]) {
+                      for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                           j += numbl1) {
+                        const index_type offset_1 = j * m_rp.m_tile[1] +
+                                                    thr_id1 +
+                                                    (index_type)m_rp.m_lower[1];
+                        if (offset_1 < m_rp.m_upper[1] &&
+                            thr_id1 < m_rp.m_tile[1]) {
+                          for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                               i += numbl0) {
+                            const index_type offset_0 =
+                                i * m_rp.m_tile[0] + thr_id0 +
+                                (index_type)m_rp.m_lower[0];
+                            if (offset_0 < m_rp.m_upper[0] &&
+                                thr_id0 < m_rp.m_tile[0]) {
+                              m_func(offset_0, offset_1, offset_2, offset_3,
+                                     offset_4, offset_5);
                             }
                           }
                         }
@@ -883,63 +1022,80 @@ struct DeviceIterateTile<6,RP,Functor,void >
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx.x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx.y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx.y % m_rp.m_tile[3];
+      const index_type thr_id2  = (index_type)threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx.y % m_rp.m_tile[3];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl5 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl4 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl5 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl5 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl4 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl5)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx.z / numbl5;
       const index_type tile_id5 = (index_type)blockIdx.z % numbl5;
-      const index_type thr_id4 = (index_type)threadIdx.z / m_rp.m_tile[5];
-      const index_type thr_id5 = (index_type)threadIdx.z % m_rp.m_tile[5];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-                        const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-                          for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-                            const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-                            if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-                              m_func(offset_0 , offset_1 , offset_2 , offset_3 , offset_4 , offset_5);
+      const index_type thr_id4  = (index_type)threadIdx.z / m_rp.m_tile[5];
+      const index_type thr_id5  = (index_type)threadIdx.z % m_rp.m_tile[5];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type m = tile_id4; m < m_rp.m_tile_end[4];
+                           m += numbl4) {
+                        const index_type offset_4 = m * m_rp.m_tile[4] +
+                                                    thr_id4 +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            thr_id4 < m_rp.m_tile[4]) {
+                          for (index_type n = tile_id5; n < m_rp.m_tile_end[5];
+                               n += numbl5) {
+                            const index_type offset_5 =
+                                n * m_rp.m_tile[5] + thr_id5 +
+                                (index_type)m_rp.m_lower[5];
+                            if (offset_5 < m_rp.m_upper[5] &&
+                                thr_id5 < m_rp.m_tile[5]) {
+                              m_func(offset_0, offset_1, offset_2, offset_3,
+                                     offset_4, offset_5);
                             }
                           }
                         }
@@ -953,92 +1109,106 @@ struct DeviceIterateTile<6,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<6,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<6, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx.x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx.x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx.x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx.x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx.x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx.y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx.y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx.y / m_rp.m_tile[2];
+      const index_type thr_id2  = (index_type)threadIdx.y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx.y / m_rp.m_tile[2];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl4 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl5 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl4 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl4 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl5 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl4)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx.z % numbl4;
       const index_type tile_id5 = (index_type)blockIdx.z / numbl4;
-      const index_type thr_id4 = (index_type)threadIdx.z % m_rp.m_tile[4];
-      const index_type thr_id5 = (index_type)threadIdx.z / m_rp.m_tile[4];
-
-      for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-        const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-        if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-
-          for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-            const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-            if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-              for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                  for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                    const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                    if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                      for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                        const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                        if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                          for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                            const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                            if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                              m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3, offset_4, offset_5);
+      const index_type thr_id4  = (index_type)threadIdx.z % m_rp.m_tile[4];
+      const index_type thr_id5  = (index_type)threadIdx.z / m_rp.m_tile[4];
+
+      for (index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5) {
+        const index_type offset_5 =
+            n * m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
+        if (offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5]) {
+          for (index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4) {
+            const index_type offset_4 =
+                m * m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
+            if (offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4]) {
+              for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                   l += numbl3) {
+                const index_type offset_3 =
+                    l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+                if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+                  for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                       k += numbl2) {
+                    const index_type offset_2 = k * m_rp.m_tile[2] + thr_id2 +
+                                                (index_type)m_rp.m_lower[2];
+                    if (offset_2 < m_rp.m_upper[2] &&
+                        thr_id2 < m_rp.m_tile[2]) {
+                      for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                           j += numbl1) {
+                        const index_type offset_1 = j * m_rp.m_tile[1] +
+                                                    thr_id1 +
+                                                    (index_type)m_rp.m_lower[1];
+                        if (offset_1 < m_rp.m_upper[1] &&
+                            thr_id1 < m_rp.m_tile[1]) {
+                          for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                               i += numbl0) {
+                            const index_type offset_0 =
+                                i * m_rp.m_tile[0] + thr_id0 +
+                                (index_type)m_rp.m_lower[0];
+                            if (offset_0 < m_rp.m_upper[0] &&
+                                thr_id0 < m_rp.m_tile[0]) {
+                              m_func(Tag(), offset_0, offset_1, offset_2,
+                                     offset_3, offset_4, offset_5);
                             }
                           }
                         }
@@ -1054,63 +1224,80 @@ struct DeviceIterateTile<6,RP,Functor,Tag>
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx.x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx.x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx.x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx.x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx.x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx.x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx.y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx.y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx.y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx.y % m_rp.m_tile[3];
+      const index_type thr_id2  = (index_type)threadIdx.y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx.y % m_rp.m_tile[3];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl5 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl4 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl5 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl5 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl4 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl5)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx.z / numbl5;
       const index_type tile_id5 = (index_type)blockIdx.z % numbl5;
-      const index_type thr_id4 = (index_type)threadIdx.z / m_rp.m_tile[5];
-      const index_type thr_id5 = (index_type)threadIdx.z % m_rp.m_tile[5];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-                        const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-                          for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-                            const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-                            if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-                              m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3 , offset_4 , offset_5);
+      const index_type thr_id4  = (index_type)threadIdx.z / m_rp.m_tile[5];
+      const index_type thr_id5  = (index_type)threadIdx.z % m_rp.m_tile[5];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type m = tile_id4; m < m_rp.m_tile_end[4];
+                           m += numbl4) {
+                        const index_type offset_4 = m * m_rp.m_tile[4] +
+                                                    thr_id4 +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            thr_id4 < m_rp.m_tile[4]) {
+                          for (index_type n = tile_id5; n < m_rp.m_tile_end[5];
+                               n += numbl5) {
+                            const index_type offset_5 =
+                                n * m_rp.m_tile[5] + thr_id5 +
+                                (index_type)m_rp.m_lower[5];
+                            if (offset_5 < m_rp.m_upper[5] &&
+                                thr_id5 < m_rp.m_tile[5]) {
+                              m_func(Tag(), offset_0, offset_1, offset_2,
+                                     offset_3, offset_4, offset_5);
                             }
                           }
                         }
@@ -1124,168 +1311,175 @@ struct DeviceIterateTile<6,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-} // Refactor
+}  // namespace Refactor
 
 // ----------------------------------------------------------------------------------
 
 namespace Reduce {
 
-template < typename T >
-using is_void = std::is_same< T, void >;
+template <typename T>
+using is_void = std::is_same<T, void>;
 
-template < typename T >
-struct is_array_type : std::false_type
-{
+template <typename T>
+struct is_array_type : std::false_type {
   using value_type = T;
 };
 
-template < typename T >
-struct is_array_type< T* > : std::true_type
-{
+template <typename T>
+struct is_array_type<T*> : std::true_type {
   using value_type = T;
 };
 
-template < typename T >
-struct is_array_type< T[] > : std::true_type
-{
+template <typename T>
+struct is_array_type<T[]> : std::true_type {
   using value_type = T;
 };
 
 // ------------------------------------------------------------------ //
-template< int N , typename RP , typename Functor , typename Tag , typename ValueType , typename Enable = void >
+template <int N, typename RP, typename Functor, typename Tag,
+          typename ValueType, typename Enable = void>
 struct DeviceIterateTile;
 
 // ParallelReduce iteration pattern
 // Scalar reductions
 
-// num_blocks = min( num_tiles, max_num_blocks ); //i.e. determined by number of tiles and reduction algorithm constraints
-// extract n-dim tile offsets (i.e. tile's global starting mulit-index) from the tileid = blockid using tile dimensions
-// local indices within a tile extracted from (index_type)threadIdx.x using tile dims, constrained by blocksize
-// combine tile and local id info for multi-dim global ids
+// num_blocks = min( num_tiles, max_num_blocks ); //i.e. determined by number of
+// tiles and reduction algorithm constraints extract n-dim tile offsets (i.e.
+// tile's global starting mulit-index) from the tileid = blockid using tile
+// dimensions local indices within a tile extracted from (index_type)threadIdx.x
+// using tile dims, constrained by blocksize combine tile and local id info for
+// multi-dim global ids
 
 // Pattern:
-// Each block+thread is responsible for a tile+local_id combo (additional when striding by num_blocks)
+// Each block+thread is responsible for a tile+local_id combo (additional when
+// striding by num_blocks)
 // 1. create offset arrays
-// 2. loop over number of tiles, striding by griddim (equal to num tiles, or max num blocks)
+// 2. loop over number of tiles, striding by griddim (equal to num tiles, or max
+// num blocks)
 // 3. temps set for tile_idx and thrd_idx, which will be modified
 // 4. if LL vs LR:
 //      determine tile starting point offsets (multidim)
 //      determine local index offsets (multidim)
 //      concatentate tile offset + local offset for global multi-dim index
-//    if offset withinin range bounds AND local offset within tile bounds, call functor
+//    if offset withinin range bounds AND local offset within tile bounds, call
+//    functor
 
 // ValueType = T
-//Rank 2
+// Rank 2
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,void,ValueType, typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
+          for (int i = 0; i < RP::rank; ++i) {
             // Deduce this blocks tile_id
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]);
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          {
-            m_func( m_offset[0], m_offset[1], m_v );
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
           }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]);
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
+          }
         }
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_,
+                                      ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1293,72 +1487,78 @@ struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< !
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 3
+// Rank 3
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1366,71 +1566,79 @@ struct DeviceIterateTile<3,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_,
+                                      ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1438,77 +1646,86 @@ struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< !
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 4
+// Rank 4
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1516,17 +1733,20 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1534,58 +1754,64 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_,
+                                      ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1593,17 +1819,21 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1611,59 +1841,64 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 5
+// Rank 5
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1671,17 +1906,21 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1689,58 +1928,64 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1748,17 +1993,21 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1766,59 +2015,64 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 6
+// Rank 6
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1826,17 +2080,21 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1844,58 +2102,64 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1903,17 +2167,21 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -1921,130 +2189,138 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // ValueType = T[], T*
-//Rank 2
+// Rank 2
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,void,ValueType, typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
-
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  using value_type = typename is_array_type<ValueType>::value_type;
+
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]);
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          {
-            m_func( m_offset[0], m_offset[1], m_v );
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
           }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
-
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  using value_type = typename is_array_type<ValueType>::value_type;
+
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_,
+                                      value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2052,17 +2328,20 @@ struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2070,128 +2349,139 @@ struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
-      } //end for loop over num_tiles - product of tiles in each direction
+      }  // end for loop over num_tiles - product of tiles in each direction
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 3
+// Rank 3
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
-
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  using value_type = typename is_array_type<ValueType>::value_type;
+
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
-
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
-
-  inline __device__
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  using value_type = typename is_array_type<ValueType>::value_type;
+
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_,
+                                      value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
+
+  inline __device__ void exec_range() const {
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2199,17 +2489,20 @@ struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2217,60 +2510,64 @@ struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 4
+// Rank 4
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2278,17 +2575,20 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2296,59 +2596,65 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
-  inline __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  inline __device__ DeviceIterateTile(const RP& rp_, const Functor& f_,
+                                      value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2356,17 +2662,21 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2374,60 +2684,65 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 5
+// Rank 5
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2435,17 +2750,21 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2453,59 +2772,65 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2513,17 +2838,21 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2531,60 +2860,65 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 6
+// Rank 6
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2592,17 +2926,21 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2610,59 +2948,65 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
-  __device__
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  __device__ DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
-
-  inline __device__
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::cuda_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx.x < m_rp.m_num_tiles && (index_type)threadIdx.y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx.x; tileidx < m_rp.m_num_tiles; tileidx += gridDim.x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount);
+
+  inline __device__ void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::CudaTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::cuda_internal_maximum_grid_count() );
+    if ((index_type)blockIdx.x < m_rp.m_num_tiles &&
+        (index_type)threadIdx.y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx.x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim.x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx.y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2670,17 +3014,21 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx.y
@@ -2688,28 +3036,32 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-} // Reduce
+}  // namespace Reduce
 
 // ----------------------------------------------------------------------------------
 
-} } //end namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
 #endif
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_CudaSpace.cpp b/lib/kokkos/core/src/Cuda/Kokkos_CudaSpace.cpp
index 4c9ed47085cc5a30b683d7c43fea75fc259cc89a..24be022d24c7f494c30e2f1f3a002f725e74314e 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_CudaSpace.cpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_CudaSpace.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,12 +58,12 @@
 
 //#include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
 #include <impl/Kokkos_Error.hpp>
+#include <impl/Kokkos_MemorySpace.hpp>
 
 #if defined(KOKKOS_ENABLE_PROFILING)
 #include <impl/Kokkos_Profiling_Interface.hpp>
 #endif
 
-
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
@@ -71,68 +72,82 @@ namespace Impl {
 
 namespace {
 
-  static std::atomic<int> num_uvm_allocations(0) ;
+static std::atomic<int> num_uvm_allocations(0);
 
-   cudaStream_t get_deep_copy_stream() {
-     static cudaStream_t s = 0;
-     if( s == 0) {
-       cudaStreamCreate ( &s );
-     }
-     return s;
-   }
+cudaStream_t get_deep_copy_stream() {
+  static cudaStream_t s = 0;
+  if (s == 0) {
+    cudaStreamCreate(&s);
+  }
+  return s;
 }
+}  // namespace
 
-DeepCopy<CudaSpace,CudaSpace,Cuda>::DeepCopy( void * dst , const void * src , size_t n )
-{ CUDA_SAFE_CALL( cudaMemcpy( dst , src , n , cudaMemcpyDefault ) ); }
+DeepCopy<CudaSpace, CudaSpace, Cuda>::DeepCopy(void *dst, const void *src,
+                                               size_t n) {
+  CUDA_SAFE_CALL(cudaMemcpy(dst, src, n, cudaMemcpyDefault));
+}
 
-DeepCopy<HostSpace,CudaSpace,Cuda>::DeepCopy( void * dst , const void * src , size_t n )
-{ CUDA_SAFE_CALL( cudaMemcpy( dst , src , n , cudaMemcpyDefault ) ); }
+DeepCopy<HostSpace, CudaSpace, Cuda>::DeepCopy(void *dst, const void *src,
+                                               size_t n) {
+  CUDA_SAFE_CALL(cudaMemcpy(dst, src, n, cudaMemcpyDefault));
+}
 
-DeepCopy<CudaSpace,HostSpace,Cuda>::DeepCopy( void * dst , const void * src , size_t n )
-{ CUDA_SAFE_CALL( cudaMemcpy( dst , src , n , cudaMemcpyDefault ) ); }
+DeepCopy<CudaSpace, HostSpace, Cuda>::DeepCopy(void *dst, const void *src,
+                                               size_t n) {
+  CUDA_SAFE_CALL(cudaMemcpy(dst, src, n, cudaMemcpyDefault));
+}
 
-DeepCopy<CudaSpace,CudaSpace,Cuda>::DeepCopy( const Cuda & instance , void * dst , const void * src , size_t n )
-{ CUDA_SAFE_CALL( cudaMemcpyAsync( dst , src , n , cudaMemcpyDefault , instance.cuda_stream() ) ); }
+DeepCopy<CudaSpace, CudaSpace, Cuda>::DeepCopy(const Cuda &instance, void *dst,
+                                               const void *src, size_t n) {
+  CUDA_SAFE_CALL(
+      cudaMemcpyAsync(dst, src, n, cudaMemcpyDefault, instance.cuda_stream()));
+}
 
-DeepCopy<HostSpace,CudaSpace,Cuda>::DeepCopy( const Cuda & instance , void * dst , const void * src , size_t n )
-{ CUDA_SAFE_CALL( cudaMemcpyAsync( dst , src , n , cudaMemcpyDefault , instance.cuda_stream() ) ); }
+DeepCopy<HostSpace, CudaSpace, Cuda>::DeepCopy(const Cuda &instance, void *dst,
+                                               const void *src, size_t n) {
+  CUDA_SAFE_CALL(
+      cudaMemcpyAsync(dst, src, n, cudaMemcpyDefault, instance.cuda_stream()));
+}
 
-DeepCopy<CudaSpace,HostSpace,Cuda>::DeepCopy( const Cuda & instance , void * dst , const void * src , size_t n )
-{ CUDA_SAFE_CALL( cudaMemcpyAsync( dst , src , n , cudaMemcpyDefault , instance.cuda_stream() ) ); }
+DeepCopy<CudaSpace, HostSpace, Cuda>::DeepCopy(const Cuda &instance, void *dst,
+                                               const void *src, size_t n) {
+  CUDA_SAFE_CALL(
+      cudaMemcpyAsync(dst, src, n, cudaMemcpyDefault, instance.cuda_stream()));
+}
 
-void DeepCopyAsyncCuda( void * dst , const void * src , size_t n) {
+void DeepCopyAsyncCuda(void *dst, const void *src, size_t n) {
   cudaStream_t s = get_deep_copy_stream();
-  CUDA_SAFE_CALL( cudaMemcpyAsync( dst , src , n , cudaMemcpyDefault , s ) );
+  CUDA_SAFE_CALL(cudaMemcpyAsync(dst, src, n, cudaMemcpyDefault, s));
   cudaStreamSynchronize(s);
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
-
 namespace Kokkos {
 
-void CudaSpace::access_error()
-{
-  const std::string msg("Kokkos::CudaSpace::access_error attempt to execute Cuda function from non-Cuda space" );
-  Kokkos::Impl::throw_runtime_exception( msg );
+void CudaSpace::access_error() {
+  const std::string msg(
+      "Kokkos::CudaSpace::access_error attempt to execute Cuda function from "
+      "non-Cuda space");
+  Kokkos::Impl::throw_runtime_exception(msg);
 }
 
-void CudaSpace::access_error( const void * const )
-{
-  const std::string msg("Kokkos::CudaSpace::access_error attempt to execute Cuda function from non-Cuda space" );
-  Kokkos::Impl::throw_runtime_exception( msg );
+void CudaSpace::access_error(const void *const) {
+  const std::string msg(
+      "Kokkos::CudaSpace::access_error attempt to execute Cuda function from "
+      "non-Cuda space");
+  Kokkos::Impl::throw_runtime_exception(msg);
 }
 
-
 /*--------------------------------------------------------------------------*/
 
-bool CudaUVMSpace::available()
-{
-#if defined( CUDA_VERSION ) && ( 6000 <= CUDA_VERSION ) && !defined(__APPLE__)
+bool CudaUVMSpace::available() {
+#if defined(CUDA_VERSION) && (6000 <= CUDA_VERSION) && !defined(__APPLE__)
   enum { UVM_available = true };
 #else
   enum { UVM_available = false };
@@ -142,99 +157,155 @@ bool CudaUVMSpace::available()
 
 /*--------------------------------------------------------------------------*/
 
-int CudaUVMSpace::number_of_allocations()
-{
+int CudaUVMSpace::number_of_allocations() {
   return Kokkos::Impl::num_uvm_allocations.load();
 }
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+// The purpose of the following variable is to allow a state-based choice
+// for pinning UVM allocations to the CPU. For now this is considered
+// an experimental debugging capability - with the potential to work around
+// some CUDA issues.
+bool CudaUVMSpace::kokkos_impl_cuda_pin_uvm_to_host_v = false;
 
-} // namespace Kokkos
+bool CudaUVMSpace::cuda_pin_uvm_to_host() {
+  return CudaUVMSpace::kokkos_impl_cuda_pin_uvm_to_host_v;
+}
+void CudaUVMSpace::cuda_set_pin_uvm_to_host(bool val) {
+  CudaUVMSpace::kokkos_impl_cuda_pin_uvm_to_host_v = val;
+}
+#endif
+}  // namespace Kokkos
+
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+bool kokkos_impl_cuda_pin_uvm_to_host() {
+  return Kokkos::CudaUVMSpace::cuda_pin_uvm_to_host();
+}
+
+void kokkos_impl_cuda_set_pin_uvm_to_host(bool val) {
+  Kokkos::CudaUVMSpace::cuda_set_pin_uvm_to_host(val);
+}
+#endif
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
 namespace Kokkos {
 
-CudaSpace::CudaSpace()
-  : m_device( Kokkos::Cuda().cuda_device() )
-{
-}
+CudaSpace::CudaSpace() : m_device(Kokkos::Cuda().cuda_device()) {}
 
-CudaUVMSpace::CudaUVMSpace()
-  : m_device( Kokkos::Cuda().cuda_device() )
-{
-}
+CudaUVMSpace::CudaUVMSpace() : m_device(Kokkos::Cuda().cuda_device()) {}
 
-CudaHostPinnedSpace::CudaHostPinnedSpace()
-{
-}
+CudaHostPinnedSpace::CudaHostPinnedSpace() {}
 
-void * CudaSpace::allocate( const size_t arg_alloc_size ) const
-{
-  void * ptr = NULL;
+//==============================================================================
+// <editor-fold desc="allocate()"> {{{1
 
-  CUDA_SAFE_CALL( cudaMalloc( &ptr, arg_alloc_size ) );
+void *CudaSpace::allocate(const size_t arg_alloc_size) const {
+  void *ptr = nullptr;
 
-  return ptr ;
+  auto error_code = cudaMalloc(&ptr, arg_alloc_size);
+  if (error_code != cudaSuccess) {  // TODO tag as unlikely branch
+    cudaGetLastError();  // This is the only way to clear the last error, which
+                         // we should do here since we're turning it into an
+                         // exception here
+    throw Experimental::CudaRawMemoryAllocationFailure(
+        arg_alloc_size, error_code,
+        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
+            CudaMalloc);
+  }
+  return ptr;
 }
 
-void * CudaUVMSpace::allocate( const size_t arg_alloc_size ) const
-{
-  void * ptr = NULL;
+void *CudaUVMSpace::allocate(const size_t arg_alloc_size) const {
+  void *ptr = nullptr;
 
   enum { max_uvm_allocations = 65536 };
 
   Cuda::impl_static_fence();
-  if ( arg_alloc_size > 0 )
-  {
+  if (arg_alloc_size > 0) {
     Kokkos::Impl::num_uvm_allocations++;
 
-    if ( Kokkos::Impl::num_uvm_allocations.load() > max_uvm_allocations ) {
-      Kokkos::Impl::throw_runtime_exception( "CudaUVM error: The maximum limit of UVM allocations exceeded (currently 65536)." ) ;
+    if (Kokkos::Impl::num_uvm_allocations.load() > max_uvm_allocations) {
+      throw Experimental::CudaRawMemoryAllocationFailure(
+          arg_alloc_size, 1,
+          Experimental::RawMemoryAllocationFailure::FailureMode::
+              MaximumCudaUVMAllocationsExceeded);
     }
 
-    CUDA_SAFE_CALL( cudaMallocManaged( &ptr, arg_alloc_size , cudaMemAttachGlobal ) );
+    auto error_code =
+        cudaMallocManaged(&ptr, arg_alloc_size, cudaMemAttachGlobal);
+
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+    if (Kokkos::CudaUVMSpace::cuda_pin_uvm_to_host())
+      cudaMemAdvise(ptr, arg_alloc_size, cudaMemAdviseSetPreferredLocation,
+                    cudaCpuDeviceId);
+#endif
+
+    if (error_code != cudaSuccess) {  // TODO tag as unlikely branch
+      cudaGetLastError();  // This is the only way to clear the last error,
+                           // which we should do here since we're turning it
+                           // into an exception here
+      throw Experimental::CudaRawMemoryAllocationFailure(
+          arg_alloc_size, error_code,
+          Experimental::RawMemoryAllocationFailure::AllocationMechanism::
+              CudaMallocManaged);
+    }
   }
   Cuda::impl_static_fence();
 
-  return ptr ;
+  return ptr;
 }
 
-void * CudaHostPinnedSpace::allocate( const size_t arg_alloc_size ) const
-{
-  void * ptr = NULL;
+void *CudaHostPinnedSpace::allocate(const size_t arg_alloc_size) const {
+  void *ptr = nullptr;
 
-  CUDA_SAFE_CALL( cudaHostAlloc( &ptr, arg_alloc_size , cudaHostAllocDefault ) );
+  auto error_code = cudaHostAlloc(&ptr, arg_alloc_size, cudaHostAllocDefault);
+  if (error_code != cudaSuccess) {  // TODO tag as unlikely branch
+    cudaGetLastError();  // This is the only way to clear the last error, which
+                         // we should do here since we're turning it into an
+                         // exception here
+    throw Experimental::CudaRawMemoryAllocationFailure(
+        arg_alloc_size, error_code,
+        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
+            CudaHostAlloc);
+  }
 
-  return ptr ;
+  return ptr;
 }
 
-void CudaSpace::deallocate( void * const arg_alloc_ptr , const size_t /* arg_alloc_size */ ) const
-{
+// </editor-fold> end allocate() }}}1
+//==============================================================================
+
+void CudaSpace::deallocate(void *const arg_alloc_ptr,
+                           const size_t /* arg_alloc_size */) const {
   try {
-    CUDA_SAFE_CALL( cudaFree( arg_alloc_ptr ) );
-  } catch(...) {}
+    CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
+  } catch (...) {
+  }
 }
 
-void CudaUVMSpace::deallocate( void * const arg_alloc_ptr , const size_t /* arg_alloc_size */ ) const
-{
+void CudaUVMSpace::deallocate(void *const arg_alloc_ptr,
+                              const size_t /* arg_alloc_size */) const {
   Cuda::impl_static_fence();
   try {
-    if ( arg_alloc_ptr != nullptr ) {
+    if (arg_alloc_ptr != nullptr) {
       Kokkos::Impl::num_uvm_allocations--;
-      CUDA_SAFE_CALL( cudaFree( arg_alloc_ptr ) );
+      CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
     }
-  } catch(...) {}
+  } catch (...) {
+  }
   Cuda::impl_static_fence();
 }
 
-void CudaHostPinnedSpace::deallocate( void * const arg_alloc_ptr , const size_t /* arg_alloc_size */ ) const
-{
+void CudaHostPinnedSpace::deallocate(void *const arg_alloc_ptr,
+                                     const size_t /* arg_alloc_size */) const {
   try {
-    CUDA_SAFE_CALL( cudaFreeHost( arg_alloc_ptr ) );
-  } catch(...) {}
+    CUDA_SAFE_CALL(cudaFreeHost(arg_alloc_ptr));
+  } catch (...) {
+  }
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -243,606 +314,611 @@ namespace Kokkos {
 namespace Impl {
 
 #ifdef KOKKOS_DEBUG
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::CudaSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void>
+    SharedAllocationRecord<Kokkos::CudaSpace, void>::s_root_record;
 
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void>
+    SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::s_root_record;
 
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void>
+    SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::s_root_record;
 #endif
 
 ::cudaTextureObject_t
-SharedAllocationRecord< Kokkos::CudaSpace , void >::
-attach_texture_object( const unsigned sizeof_alias
-                     , void *   const alloc_ptr
-                     , size_t   const alloc_size )
-{
+SharedAllocationRecord<Kokkos::CudaSpace, void>::attach_texture_object(
+    const unsigned sizeof_alias, void *const alloc_ptr,
+    size_t const alloc_size) {
   enum { TEXTURE_BOUND_1D = 1u << 27 };
 
-  if ( ( alloc_ptr == 0 ) || ( sizeof_alias * TEXTURE_BOUND_1D <= alloc_size ) ) {
-    std::ostringstream msg ;
+  if ((alloc_ptr == 0) || (sizeof_alias * TEXTURE_BOUND_1D <= alloc_size)) {
+    std::ostringstream msg;
     msg << "Kokkos::CudaSpace ERROR: Cannot attach texture object to"
         << " alloc_ptr(" << alloc_ptr << ")"
         << " alloc_size(" << alloc_size << ")"
-        << " max_size(" << ( sizeof_alias * TEXTURE_BOUND_1D ) << ")" ;
-    std::cerr << msg.str() << std::endl ;
+        << " max_size(" << (sizeof_alias * TEXTURE_BOUND_1D) << ")";
+    std::cerr << msg.str() << std::endl;
     std::cerr.flush();
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
-  ::cudaTextureObject_t tex_obj ;
+  ::cudaTextureObject_t tex_obj;
 
-  struct cudaResourceDesc resDesc ;
-  struct cudaTextureDesc  texDesc ;
+  struct cudaResourceDesc resDesc;
+  struct cudaTextureDesc texDesc;
 
-  memset( & resDesc , 0 , sizeof(resDesc) );
-  memset( & texDesc , 0 , sizeof(texDesc) );
+  memset(&resDesc, 0, sizeof(resDesc));
+  memset(&texDesc, 0, sizeof(texDesc));
 
-  resDesc.resType                = cudaResourceTypeLinear ;
-  resDesc.res.linear.desc        = ( sizeof_alias ==  4 ?  cudaCreateChannelDesc< int >() :
-                                   ( sizeof_alias ==  8 ?  cudaCreateChannelDesc< ::int2 >() :
-                                  /* sizeof_alias == 16 */ cudaCreateChannelDesc< ::int4 >() ) );
-  resDesc.res.linear.sizeInBytes = alloc_size ;
-  resDesc.res.linear.devPtr      = alloc_ptr ;
+  resDesc.resType = cudaResourceTypeLinear;
+  resDesc.res.linear.desc =
+      (sizeof_alias == 4
+           ? cudaCreateChannelDesc<int>()
+           : (sizeof_alias == 8
+                  ? cudaCreateChannelDesc< ::int2>()
+                  :
+                  /* sizeof_alias == 16 */ cudaCreateChannelDesc< ::int4>()));
+  resDesc.res.linear.sizeInBytes = alloc_size;
+  resDesc.res.linear.devPtr      = alloc_ptr;
 
-  CUDA_SAFE_CALL( cudaCreateTextureObject( & tex_obj , & resDesc, & texDesc, NULL ) );
+  CUDA_SAFE_CALL(cudaCreateTextureObject(&tex_obj, &resDesc, &texDesc, NULL));
 
-  return tex_obj ;
+  return tex_obj;
 }
 
-std::string
-SharedAllocationRecord< Kokkos::CudaSpace , void >::get_label() const
-{
-  SharedAllocationHeader header ;
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecord::get_label()"> {{{1
 
-  Kokkos::Impl::DeepCopy< Kokkos::HostSpace , Kokkos::CudaSpace >( & header , RecordBase::head() , sizeof(SharedAllocationHeader) );
+std::string SharedAllocationRecord<Kokkos::CudaSpace, void>::get_label() const {
+  SharedAllocationHeader header;
 
-  return std::string( header.m_label );
+  Kokkos::Impl::DeepCopy<Kokkos::HostSpace, Kokkos::CudaSpace>(
+      &header, RecordBase::head(), sizeof(SharedAllocationHeader));
+
+  return std::string(header.m_label);
 }
 
-std::string
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::get_label() const
-{
-  return std::string( RecordBase::head()->m_label );
+std::string SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::get_label()
+    const {
+  return std::string(RecordBase::head()->m_label);
 }
 
 std::string
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::get_label() const
-{
-  return std::string( RecordBase::head()->m_label );
+SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::get_label() const {
+  return std::string(RecordBase::head()->m_label);
 }
 
-SharedAllocationRecord< Kokkos::CudaSpace , void > *
-SharedAllocationRecord< Kokkos::CudaSpace , void >::
-allocate( const Kokkos::CudaSpace &  arg_space
-        , const std::string       &  arg_label
-        , const size_t               arg_alloc_size
-        )
-{
-  return new SharedAllocationRecord( arg_space , arg_label , arg_alloc_size );
+// </editor-fold> end SharedAllocationRecord::get_label() }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecord allocate()"> {{{1
+
+SharedAllocationRecord<Kokkos::CudaSpace, void>
+    *SharedAllocationRecord<Kokkos::CudaSpace, void>::allocate(
+        const Kokkos::CudaSpace &arg_space, const std::string &arg_label,
+        const size_t arg_alloc_size) {
+  return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void > *
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-allocate( const Kokkos::CudaUVMSpace &  arg_space
-        , const std::string          &  arg_label
-        , const size_t                  arg_alloc_size
-        )
-{
-  return new SharedAllocationRecord( arg_space , arg_label , arg_alloc_size );
+SharedAllocationRecord<Kokkos::CudaUVMSpace, void>
+    *SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::allocate(
+        const Kokkos::CudaUVMSpace &arg_space, const std::string &arg_label,
+        const size_t arg_alloc_size) {
+  return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void > *
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-allocate( const Kokkos::CudaHostPinnedSpace &  arg_space
-        , const std::string                 &  arg_label
-        , const size_t                         arg_alloc_size
-        )
-{
-  return new SharedAllocationRecord( arg_space , arg_label , arg_alloc_size );
+SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>
+    *SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::allocate(
+        const Kokkos::CudaHostPinnedSpace &arg_space,
+        const std::string &arg_label, const size_t arg_alloc_size) {
+  return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
 }
 
-void
-SharedAllocationRecord< Kokkos::CudaSpace , void >::
-deallocate( SharedAllocationRecord< void , void > * arg_rec )
-{
-  delete static_cast<SharedAllocationRecord*>(arg_rec);
+// </editor-fold> end SharedAllocationRecord allocate() }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecord deallocate"> {{{1
+
+void SharedAllocationRecord<Kokkos::CudaSpace, void>::deallocate(
+    SharedAllocationRecord<void, void> *arg_rec) {
+  delete static_cast<SharedAllocationRecord *>(arg_rec);
 }
 
-void
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-deallocate( SharedAllocationRecord< void , void > * arg_rec )
-{
-  delete static_cast<SharedAllocationRecord*>(arg_rec);
+void SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::deallocate(
+    SharedAllocationRecord<void, void> *arg_rec) {
+  delete static_cast<SharedAllocationRecord *>(arg_rec);
 }
 
-void
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-deallocate( SharedAllocationRecord< void , void > * arg_rec )
-{
-  delete static_cast<SharedAllocationRecord*>(arg_rec);
+void SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::deallocate(
+    SharedAllocationRecord<void, void> *arg_rec) {
+  delete static_cast<SharedAllocationRecord *>(arg_rec);
 }
 
-SharedAllocationRecord< Kokkos::CudaSpace , void >::
-~SharedAllocationRecord()
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+// </editor-fold> end SharedAllocationRecord deallocate }}}1
+//==============================================================================
 
-    SharedAllocationHeader header ;
-    Kokkos::Impl::DeepCopy<CudaSpace,HostSpace>( & header , RecordBase::m_alloc_ptr , sizeof(SharedAllocationHeader) );
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecord destructors"> {{{1
+
+SharedAllocationRecord<Kokkos::CudaSpace, void>::~SharedAllocationRecord() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    SharedAllocationHeader header;
+    Kokkos::Impl::DeepCopy<CudaSpace, HostSpace>(
+        &header, RecordBase::m_alloc_ptr, sizeof(SharedAllocationHeader));
 
     Kokkos::Profiling::deallocateData(
-      Kokkos::Profiling::SpaceHandle(Kokkos::CudaSpace::name()),header.m_label,
-      data(),size());
+        Kokkos::Profiling::SpaceHandle(Kokkos::CudaSpace::name()),
+        header.m_label, data(), size());
   }
-  #endif
+#endif
 
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-~SharedAllocationRecord()
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Cuda::impl_static_fence(); //Make sure I can access the label ...
+SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::~SharedAllocationRecord() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Cuda::impl_static_fence();  // Make sure I can access the label ...
     Kokkos::Profiling::deallocateData(
-      Kokkos::Profiling::SpaceHandle(Kokkos::CudaUVMSpace::name()),RecordBase::m_alloc_ptr->m_label,
-      data(),size());
+        Kokkos::Profiling::SpaceHandle(Kokkos::CudaUVMSpace::name()),
+        RecordBase::m_alloc_ptr->m_label, data(), size());
   }
-  #endif
+#endif
 
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-~SharedAllocationRecord()
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+SharedAllocationRecord<Kokkos::CudaHostPinnedSpace,
+                       void>::~SharedAllocationRecord() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::deallocateData(
-      Kokkos::Profiling::SpaceHandle(Kokkos::CudaHostPinnedSpace::name()),RecordBase::m_alloc_ptr->m_label,
-      data(),size());
+        Kokkos::Profiling::SpaceHandle(Kokkos::CudaHostPinnedSpace::name()),
+        RecordBase::m_alloc_ptr->m_label, data(), size());
   }
-  #endif
-
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
-}
-
-SharedAllocationRecord< Kokkos::CudaSpace , void >::
-SharedAllocationRecord( const Kokkos::CudaSpace & arg_space
-                      , const std::string       & arg_label
-                      , const size_t              arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+#endif
+
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
+}
+
+// </editor-fold> end SharedAllocationRecord destructors }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecord constructors"> {{{1
+
+SharedAllocationRecord<Kokkos::CudaSpace, void>::SharedAllocationRecord(
+    const Kokkos::CudaSpace &arg_space, const std::string &arg_label,
+    const size_t arg_alloc_size,
+    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-        & SharedAllocationRecord< Kokkos::CudaSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::CudaSpace, void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_tex_obj( 0 )
-  , m_space( arg_space )
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Profiling::allocateData(Kokkos::Profiling::SpaceHandle(arg_space.name()),arg_label,data(),arg_alloc_size);
+          Impl::checked_allocation_with_header(arg_space, arg_label,
+                                               arg_alloc_size),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_tex_obj(0),
+      m_space(arg_space) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::allocateData(
+        Kokkos::Profiling::SpaceHandle(arg_space.name()), arg_label, data(),
+        arg_alloc_size);
   }
-  #endif
+#endif
 
-  SharedAllocationHeader header ;
+  SharedAllocationHeader header;
 
   // Fill in the Header information
-  header.m_record = static_cast< SharedAllocationRecord< void , void > * >( this );
+  header.m_record = static_cast<SharedAllocationRecord<void, void> *>(this);
 
-  strncpy( header.m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(header.m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
   // Set last element zero, in case c_str is too long
-  header.m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0;
+  header.m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
 
   // Copy to device memory
-  Kokkos::Impl::DeepCopy<CudaSpace,HostSpace>( RecordBase::m_alloc_ptr , & header , sizeof(SharedAllocationHeader) );
-}
-
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-SharedAllocationRecord( const Kokkos::CudaUVMSpace & arg_space
-                      , const std::string          & arg_label
-                      , const size_t                 arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+  Kokkos::Impl::DeepCopy<CudaSpace, HostSpace>(RecordBase::m_alloc_ptr, &header,
+                                               sizeof(SharedAllocationHeader));
+}
+
+SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::SharedAllocationRecord(
+    const Kokkos::CudaUVMSpace &arg_space, const std::string &arg_label,
+    const size_t arg_alloc_size,
+    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-        & SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_tex_obj( 0 )
-  , m_space( arg_space )
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Profiling::allocateData(Kokkos::Profiling::SpaceHandle(arg_space.name()),arg_label,data(),arg_alloc_size);
+          Impl::checked_allocation_with_header(arg_space, arg_label,
+                                               arg_alloc_size),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_tex_obj(0),
+      m_space(arg_space) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::allocateData(
+        Kokkos::Profiling::SpaceHandle(arg_space.name()), arg_label, data(),
+        arg_alloc_size);
   }
-  #endif
- // Fill in the Header information, directly accessible via UVM
+#endif
+  // Fill in the Header information, directly accessible via UVM
 
-  RecordBase::m_alloc_ptr->m_record = this ;
+  RecordBase::m_alloc_ptr->m_record = this;
 
-  strncpy( RecordBase::m_alloc_ptr->m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(RecordBase::m_alloc_ptr->m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
 
   // Set last element zero, in case c_str is too long
-  RecordBase::m_alloc_ptr->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0;
-}
-
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-SharedAllocationRecord( const Kokkos::CudaHostPinnedSpace & arg_space
-                      , const std::string                 & arg_label
-                      , const size_t                        arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+  RecordBase::m_alloc_ptr
+      ->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
+}
+
+SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::
+    SharedAllocationRecord(
+        const Kokkos::CudaHostPinnedSpace &arg_space,
+        const std::string &arg_label, const size_t arg_alloc_size,
+        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-        & SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::CudaHostPinnedSpace,
+                                  void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_space( arg_space )
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Profiling::allocateData(Kokkos::Profiling::SpaceHandle(arg_space.name()),arg_label,data(),arg_alloc_size);
+          Impl::checked_allocation_with_header(arg_space, arg_label,
+                                               arg_alloc_size),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_space(arg_space) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::allocateData(
+        Kokkos::Profiling::SpaceHandle(arg_space.name()), arg_label, data(),
+        arg_alloc_size);
   }
-  #endif
-  // Fill in the Header information, directly accessible via UVM
+#endif
+  // Fill in the Header information, directly accessible on the host
 
-  RecordBase::m_alloc_ptr->m_record = this ;
+  RecordBase::m_alloc_ptr->m_record = this;
 
-  strncpy( RecordBase::m_alloc_ptr->m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(RecordBase::m_alloc_ptr->m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
   // Set last element zero, in case c_str is too long
-  RecordBase::m_alloc_ptr->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0;
+  RecordBase::m_alloc_ptr
+      ->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
 }
 
-//----------------------------------------------------------------------------
+// </editor-fold> end SharedAllocationRecord constructors }}}1
+//==============================================================================
 
-void * SharedAllocationRecord< Kokkos::CudaSpace , void >::
-allocate_tracked( const Kokkos::CudaSpace & arg_space
-                , const std::string & arg_alloc_label
-                , const size_t arg_alloc_size )
-{
-  if ( ! arg_alloc_size ) return (void *) 0 ;
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecored::(re|de|)allocate_tracked"> {{{1
 
-  SharedAllocationRecord * const r =
-    allocate( arg_space , arg_alloc_label , arg_alloc_size );
+void *SharedAllocationRecord<Kokkos::CudaSpace, void>::allocate_tracked(
+    const Kokkos::CudaSpace &arg_space, const std::string &arg_alloc_label,
+    const size_t arg_alloc_size) {
+  if (!arg_alloc_size) return (void *)0;
 
-  RecordBase::increment( r );
+  SharedAllocationRecord *const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
+
+  RecordBase::increment(r);
 
   return r->data();
 }
 
-void SharedAllocationRecord< Kokkos::CudaSpace , void >::
-deallocate_tracked( void * const arg_alloc_ptr )
-{
-  if ( arg_alloc_ptr != 0 ) {
-    SharedAllocationRecord * const r = get_record( arg_alloc_ptr );
+void SharedAllocationRecord<Kokkos::CudaSpace, void>::deallocate_tracked(
+    void *const arg_alloc_ptr) {
+  if (arg_alloc_ptr != 0) {
+    SharedAllocationRecord *const r = get_record(arg_alloc_ptr);
 
-    RecordBase::decrement( r );
+    RecordBase::decrement(r);
   }
 }
 
-void * SharedAllocationRecord< Kokkos::CudaSpace , void >::
-reallocate_tracked( void * const arg_alloc_ptr
-                  , const size_t arg_alloc_size )
-{
-  SharedAllocationRecord * const r_old = get_record( arg_alloc_ptr );
-  SharedAllocationRecord * const r_new = allocate( r_old->m_space , r_old->get_label() , arg_alloc_size );
+void *SharedAllocationRecord<Kokkos::CudaSpace, void>::reallocate_tracked(
+    void *const arg_alloc_ptr, const size_t arg_alloc_size) {
+  SharedAllocationRecord *const r_old = get_record(arg_alloc_ptr);
+  SharedAllocationRecord *const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
 
-  Kokkos::Impl::DeepCopy<CudaSpace,CudaSpace>( r_new->data() , r_old->data()
-                                             , std::min( r_old->size() , r_new->size() ) );
+  Kokkos::Impl::DeepCopy<CudaSpace, CudaSpace>(
+      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
 
-  RecordBase::increment( r_new );
-  RecordBase::decrement( r_old );
+  RecordBase::increment(r_new);
+  RecordBase::decrement(r_old);
 
   return r_new->data();
 }
 
-void * SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-allocate_tracked( const Kokkos::CudaUVMSpace & arg_space
-                , const std::string & arg_alloc_label
-                , const size_t arg_alloc_size )
-{
-  if ( ! arg_alloc_size ) return (void *) 0 ;
+void *SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::allocate_tracked(
+    const Kokkos::CudaUVMSpace &arg_space, const std::string &arg_alloc_label,
+    const size_t arg_alloc_size) {
+  if (!arg_alloc_size) return (void *)0;
 
-  SharedAllocationRecord * const r =
-    allocate( arg_space , arg_alloc_label , arg_alloc_size );
+  SharedAllocationRecord *const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
 
-  RecordBase::increment( r );
+  RecordBase::increment(r);
 
   return r->data();
 }
 
-void SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-deallocate_tracked( void * const arg_alloc_ptr )
-{
-  if ( arg_alloc_ptr != 0 ) {
-
-    SharedAllocationRecord * const r = get_record( arg_alloc_ptr );
+void SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::deallocate_tracked(
+    void *const arg_alloc_ptr) {
+  if (arg_alloc_ptr != 0) {
+    SharedAllocationRecord *const r = get_record(arg_alloc_ptr);
 
-    RecordBase::decrement( r );
+    RecordBase::decrement(r);
   }
 }
 
-void * SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-reallocate_tracked( void * const arg_alloc_ptr
-                  , const size_t arg_alloc_size )
-{
-  SharedAllocationRecord * const r_old = get_record( arg_alloc_ptr );
-  SharedAllocationRecord * const r_new = allocate( r_old->m_space , r_old->get_label() , arg_alloc_size );
+void *SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::reallocate_tracked(
+    void *const arg_alloc_ptr, const size_t arg_alloc_size) {
+  SharedAllocationRecord *const r_old = get_record(arg_alloc_ptr);
+  SharedAllocationRecord *const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
 
-  Kokkos::Impl::DeepCopy<CudaUVMSpace,CudaUVMSpace>( r_new->data() , r_old->data()
-                                             , std::min( r_old->size() , r_new->size() ) );
+  Kokkos::Impl::DeepCopy<CudaUVMSpace, CudaUVMSpace>(
+      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
 
-  RecordBase::increment( r_new );
-  RecordBase::decrement( r_old );
+  RecordBase::increment(r_new);
+  RecordBase::decrement(r_old);
 
   return r_new->data();
 }
 
-void * SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-allocate_tracked( const Kokkos::CudaHostPinnedSpace & arg_space
-                , const std::string & arg_alloc_label
-                , const size_t arg_alloc_size )
-{
-  if ( ! arg_alloc_size ) return (void *) 0 ;
+void *
+SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::allocate_tracked(
+    const Kokkos::CudaHostPinnedSpace &arg_space,
+    const std::string &arg_alloc_label, const size_t arg_alloc_size) {
+  if (!arg_alloc_size) return (void *)0;
 
-  SharedAllocationRecord * const r =
-    allocate( arg_space , arg_alloc_label , arg_alloc_size );
+  SharedAllocationRecord *const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
 
-  RecordBase::increment( r );
+  RecordBase::increment(r);
 
   return r->data();
 }
 
-void SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-deallocate_tracked( void * const arg_alloc_ptr )
-{
-  if ( arg_alloc_ptr != 0 ) {
-    SharedAllocationRecord * const r = get_record( arg_alloc_ptr );
+void SharedAllocationRecord<Kokkos::CudaHostPinnedSpace,
+                            void>::deallocate_tracked(void *const
+                                                          arg_alloc_ptr) {
+  if (arg_alloc_ptr != 0) {
+    SharedAllocationRecord *const r = get_record(arg_alloc_ptr);
 
-    RecordBase::decrement( r );
+    RecordBase::decrement(r);
   }
 }
 
-void * SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-reallocate_tracked( void * const arg_alloc_ptr
-                  , const size_t arg_alloc_size )
-{
-  SharedAllocationRecord * const r_old = get_record( arg_alloc_ptr );
-  SharedAllocationRecord * const r_new = allocate( r_old->m_space , r_old->get_label() , arg_alloc_size );
+void *
+SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::reallocate_tracked(
+    void *const arg_alloc_ptr, const size_t arg_alloc_size) {
+  SharedAllocationRecord *const r_old = get_record(arg_alloc_ptr);
+  SharedAllocationRecord *const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
 
-  Kokkos::Impl::DeepCopy<CudaHostPinnedSpace,CudaHostPinnedSpace>( r_new->data() , r_old->data()
-                                             , std::min( r_old->size() , r_new->size() ) );
+  Kokkos::Impl::DeepCopy<CudaHostPinnedSpace, CudaHostPinnedSpace>(
+      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
 
-  RecordBase::increment( r_new );
-  RecordBase::decrement( r_old );
+  RecordBase::increment(r_new);
+  RecordBase::decrement(r_old);
 
   return r_new->data();
 }
 
-//----------------------------------------------------------------------------
+// </editor-fold> end SharedAllocationRecored::(re|de|)allocate_tracked }}}1
+//==============================================================================
 
-SharedAllocationRecord< Kokkos::CudaSpace , void > *
-SharedAllocationRecord< Kokkos::CudaSpace , void >::get_record( void * alloc_ptr )
-{
-  using RecordCuda = SharedAllocationRecord< Kokkos::CudaSpace , void > ;
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecord::get_record()"> {{{1
 
-  using Header     = SharedAllocationHeader ;
+SharedAllocationRecord<Kokkos::CudaSpace, void> *
+SharedAllocationRecord<Kokkos::CudaSpace, void>::get_record(void *alloc_ptr) {
+  using RecordCuda = SharedAllocationRecord<Kokkos::CudaSpace, void>;
+
+  using Header = SharedAllocationHeader;
 
   // Copy the header from the allocation
-  Header head ;
+  Header head;
 
-  Header const * const head_cuda = alloc_ptr ? Header::get_header( alloc_ptr ) : (Header*) 0 ;
+  Header const *const head_cuda =
+      alloc_ptr ? Header::get_header(alloc_ptr) : (Header *)0;
 
-  if ( alloc_ptr ) {
-    Kokkos::Impl::DeepCopy<HostSpace,CudaSpace>( & head , head_cuda , sizeof(SharedAllocationHeader) );
+  if (alloc_ptr) {
+    Kokkos::Impl::DeepCopy<HostSpace, CudaSpace>(
+        &head, head_cuda, sizeof(SharedAllocationHeader));
   }
 
-  RecordCuda * const record = alloc_ptr ? static_cast< RecordCuda * >( head.m_record ) : (RecordCuda *) 0 ;
+  RecordCuda *const record =
+      alloc_ptr ? static_cast<RecordCuda *>(head.m_record) : (RecordCuda *)0;
 
-  if ( ! alloc_ptr || record->m_alloc_ptr != head_cuda ) {
-    Kokkos::Impl::throw_runtime_exception( std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaSpace , void >::get_record ERROR" ) );
+  if (!alloc_ptr || record->m_alloc_ptr != head_cuda) {
+    Kokkos::Impl::throw_runtime_exception(
+        std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaSpace , "
+                    "void >::get_record ERROR"));
   }
 
-  return record ;
+  return record;
 }
 
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void > *
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::get_record( void * alloc_ptr )
-{
-  using Header     = SharedAllocationHeader ;
-  using RecordCuda = SharedAllocationRecord< Kokkos::CudaUVMSpace , void > ;
+SharedAllocationRecord<Kokkos::CudaUVMSpace, void> *SharedAllocationRecord<
+    Kokkos::CudaUVMSpace, void>::get_record(void *alloc_ptr) {
+  using Header     = SharedAllocationHeader;
+  using RecordCuda = SharedAllocationRecord<Kokkos::CudaUVMSpace, void>;
 
-  Header * const h = alloc_ptr ? reinterpret_cast< Header * >( alloc_ptr ) - 1 : (Header *) 0 ;
+  Header *const h =
+      alloc_ptr ? reinterpret_cast<Header *>(alloc_ptr) - 1 : (Header *)0;
 
-  if ( ! alloc_ptr || h->m_record->m_alloc_ptr != h ) {
-    Kokkos::Impl::throw_runtime_exception( std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::get_record ERROR" ) );
+  if (!alloc_ptr || h->m_record->m_alloc_ptr != h) {
+    Kokkos::Impl::throw_runtime_exception(
+        std::string("Kokkos::Impl::SharedAllocationRecord< "
+                    "Kokkos::CudaUVMSpace , void >::get_record ERROR"));
   }
 
-  return static_cast< RecordCuda * >( h->m_record );
+  return static_cast<RecordCuda *>(h->m_record);
 }
 
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void > *
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::get_record( void * alloc_ptr )
-{
-  using Header     = SharedAllocationHeader ;
-  using RecordCuda = SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void > ;
+SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>
+    *SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::get_record(
+        void *alloc_ptr) {
+  using Header     = SharedAllocationHeader;
+  using RecordCuda = SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>;
 
-  Header * const h = alloc_ptr ? reinterpret_cast< Header * >( alloc_ptr ) - 1 : (Header *) 0 ;
+  Header *const h =
+      alloc_ptr ? reinterpret_cast<Header *>(alloc_ptr) - 1 : (Header *)0;
 
-  if ( ! alloc_ptr || h->m_record->m_alloc_ptr != h ) {
-    Kokkos::Impl::throw_runtime_exception( std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::get_record ERROR" ) );
+  if (!alloc_ptr || h->m_record->m_alloc_ptr != h) {
+    Kokkos::Impl::throw_runtime_exception(
+        std::string("Kokkos::Impl::SharedAllocationRecord< "
+                    "Kokkos::CudaHostPinnedSpace , void >::get_record ERROR"));
   }
 
-  return static_cast< RecordCuda * >( h->m_record );
+  return static_cast<RecordCuda *>(h->m_record);
 }
 
+// </editor-fold> end SharedAllocationRecord::get_record() }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="SharedAllocationRecord::print_records()"> {{{1
+
 // Iterate records to print orphaned memory ...
-void
-SharedAllocationRecord< Kokkos::CudaSpace , void >::
-print_records( std::ostream & s , const Kokkos::CudaSpace & , bool detail )
-{
+void SharedAllocationRecord<Kokkos::CudaSpace, void>::print_records(
+    std::ostream &s, const Kokkos::CudaSpace &, bool detail) {
 #ifdef KOKKOS_DEBUG
-  SharedAllocationRecord< void , void > * r = & s_root_record ;
+  SharedAllocationRecord<void, void> *r = &s_root_record;
 
-  char buffer[256] ;
+  char buffer[256];
 
-  SharedAllocationHeader head ;
+  SharedAllocationHeader head;
 
-  if ( detail ) {
+  if (detail) {
     do {
-      if ( r->m_alloc_ptr ) {
-        Kokkos::Impl::DeepCopy<HostSpace,CudaSpace>( & head , r->m_alloc_ptr , sizeof(SharedAllocationHeader) );
-      }
-      else {
-        head.m_label[0] = 0 ;
+      if (r->m_alloc_ptr) {
+        Kokkos::Impl::DeepCopy<HostSpace, CudaSpace>(
+            &head, r->m_alloc_ptr, sizeof(SharedAllocationHeader));
+      } else {
+        head.m_label[0] = 0;
       }
 
-      //Formatting dependent on sizeof(uintptr_t)
-      const char * format_string;
+      // Formatting dependent on sizeof(uintptr_t)
+      const char *format_string;
 
       if (sizeof(uintptr_t) == sizeof(unsigned long)) {
-        format_string = "Cuda addr( 0x%.12lx ) list( 0x%.12lx 0x%.12lx ) extent[ 0x%.12lx + %.8ld ] count(%d) dealloc(0x%.12lx) %s\n";
-      }
-      else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
-        format_string = "Cuda addr( 0x%.12llx ) list( 0x%.12llx 0x%.12llx ) extent[ 0x%.12llx + %.8ld ] count(%d) dealloc(0x%.12llx) %s\n";
+        format_string =
+            "Cuda addr( 0x%.12lx ) list( 0x%.12lx 0x%.12lx ) extent[ 0x%.12lx "
+            "+ %.8ld ] count(%d) dealloc(0x%.12lx) %s\n";
+      } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
+        format_string =
+            "Cuda addr( 0x%.12llx ) list( 0x%.12llx 0x%.12llx ) extent[ "
+            "0x%.12llx + %.8ld ] count(%d) dealloc(0x%.12llx) %s\n";
       }
 
-      snprintf( buffer , 256
-              , format_string
-              , reinterpret_cast<uintptr_t>( r )
-              , reinterpret_cast<uintptr_t>( r->m_prev )
-              , reinterpret_cast<uintptr_t>( r->m_next )
-              , reinterpret_cast<uintptr_t>( r->m_alloc_ptr )
-              , r->m_alloc_size
-              , r->m_count
-              , reinterpret_cast<uintptr_t>( r->m_dealloc )
-              , head.m_label
-              );
-      s << buffer ;
-      r = r->m_next ;
-    } while ( r != & s_root_record );
-  }
-  else {
+      snprintf(buffer, 256, format_string, reinterpret_cast<uintptr_t>(r),
+               reinterpret_cast<uintptr_t>(r->m_prev),
+               reinterpret_cast<uintptr_t>(r->m_next),
+               reinterpret_cast<uintptr_t>(r->m_alloc_ptr), r->m_alloc_size,
+               r->m_count, reinterpret_cast<uintptr_t>(r->m_dealloc),
+               head.m_label);
+      s << buffer;
+      r = r->m_next;
+    } while (r != &s_root_record);
+  } else {
     do {
-      if ( r->m_alloc_ptr ) {
-
-        Kokkos::Impl::DeepCopy<HostSpace,CudaSpace>( & head , r->m_alloc_ptr , sizeof(SharedAllocationHeader) );
+      if (r->m_alloc_ptr) {
+        Kokkos::Impl::DeepCopy<HostSpace, CudaSpace>(
+            &head, r->m_alloc_ptr, sizeof(SharedAllocationHeader));
 
-        //Formatting dependent on sizeof(uintptr_t)
-        const char * format_string;
+        // Formatting dependent on sizeof(uintptr_t)
+        const char *format_string;
 
         if (sizeof(uintptr_t) == sizeof(unsigned long)) {
           format_string = "Cuda [ 0x%.12lx + %ld ] %s\n";
-        }
-        else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
+        } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
           format_string = "Cuda [ 0x%.12llx + %ld ] %s\n";
         }
 
-        snprintf( buffer , 256
-                , format_string
-                , reinterpret_cast< uintptr_t >( r->data() )
-                , r->size()
-                , head.m_label
-                );
-      }
-      else {
-        snprintf( buffer , 256 , "Cuda [ 0 + 0 ]\n" );
+        snprintf(buffer, 256, format_string,
+                 reinterpret_cast<uintptr_t>(r->data()), r->size(),
+                 head.m_label);
+      } else {
+        snprintf(buffer, 256, "Cuda [ 0 + 0 ]\n");
       }
-      s << buffer ;
-      r = r->m_next ;
-    } while ( r != & s_root_record );
+      s << buffer;
+      r = r->m_next;
+    } while (r != &s_root_record);
   }
 #else
-  Kokkos::Impl::throw_runtime_exception("SharedAllocationHeader<CudaSpace>::print_records only works with KOKKOS_DEBUG enabled");
+  Kokkos::Impl::throw_runtime_exception(
+      "SharedAllocationHeader<CudaSpace>::print_records only works with "
+      "KOKKOS_DEBUG enabled");
 #endif
 }
 
-void
-SharedAllocationRecord< Kokkos::CudaUVMSpace , void >::
-print_records( std::ostream & s , const Kokkos::CudaUVMSpace & , bool detail )
-{
+void SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::print_records(
+    std::ostream &s, const Kokkos::CudaUVMSpace &, bool detail) {
 #ifdef KOKKOS_DEBUG
-  SharedAllocationRecord< void , void >::print_host_accessible_records( s , "CudaUVM" , & s_root_record , detail );
+  SharedAllocationRecord<void, void>::print_host_accessible_records(
+      s, "CudaUVM", &s_root_record, detail);
 #else
-  Kokkos::Impl::throw_runtime_exception("SharedAllocationHeader<CudaSpace>::print_records only works with KOKKOS_DEBUG enabled");
+  Kokkos::Impl::throw_runtime_exception(
+      "SharedAllocationHeader<CudaSpace>::print_records only works with "
+      "KOKKOS_DEBUG enabled");
 #endif
 }
 
-void
-SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >::
-print_records( std::ostream & s , const Kokkos::CudaHostPinnedSpace & , bool detail )
-{
+void SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::print_records(
+    std::ostream &s, const Kokkos::CudaHostPinnedSpace &, bool detail) {
 #ifdef KOKKOS_DEBUG
-  SharedAllocationRecord< void , void >::print_host_accessible_records( s , "CudaHostPinned" , & s_root_record , detail );
+  SharedAllocationRecord<void, void>::print_host_accessible_records(
+      s, "CudaHostPinned", &s_root_record, detail);
 #else
-  Kokkos::Impl::throw_runtime_exception("SharedAllocationHeader<CudaSpace>::print_records only works with KOKKOS_DEBUG enabled");
+  Kokkos::Impl::throw_runtime_exception(
+      "SharedAllocationHeader<CudaSpace>::print_records only works with "
+      "KOKKOS_DEBUG enabled");
 #endif
 }
 
-void* cuda_resize_scratch_space(std::int64_t bytes, bool force_shrink) {
-  static void* ptr = NULL;
+// </editor-fold> end SharedAllocationRecord::print_records() }}}1
+//==============================================================================
+
+void *cuda_resize_scratch_space(std::int64_t bytes, bool force_shrink) {
+  static void *ptr                 = NULL;
   static std::int64_t current_size = 0;
-  if(current_size == 0) {
+  if (current_size == 0) {
     current_size = bytes;
-    ptr = Kokkos::kokkos_malloc<Kokkos::CudaSpace>("CudaSpace::ScratchMemory",current_size);
+    ptr = Kokkos::kokkos_malloc<Kokkos::CudaSpace>("CudaSpace::ScratchMemory",
+                                                   current_size);
   }
-  if(bytes > current_size) {
+  if (bytes > current_size) {
     current_size = bytes;
     Kokkos::kokkos_free<Kokkos::CudaSpace>(ptr);
-    ptr = Kokkos::kokkos_malloc<Kokkos::CudaSpace>("CudaSpace::ScratchMemory",current_size);
+    ptr = Kokkos::kokkos_malloc<Kokkos::CudaSpace>("CudaSpace::ScratchMemory",
+                                                   current_size);
   }
-  if((bytes < current_size) && (force_shrink)) {
+  if ((bytes < current_size) && (force_shrink)) {
     current_size = bytes;
     Kokkos::kokkos_free<Kokkos::CudaSpace>(ptr);
-    ptr = Kokkos::kokkos_malloc<Kokkos::CudaSpace>("CudaSpace::ScratchMemory",current_size);
+    ptr = Kokkos::kokkos_malloc<Kokkos::CudaSpace>("CudaSpace::ScratchMemory",
+                                                   current_size);
   }
   return ptr;
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 #else
 void KOKKOS_CORE_SRC_CUDA_CUDASPACE_PREVENT_LINK_ERROR() {}
-#endif // KOKKOS_ENABLE_CUDA
-
+#endif  // KOKKOS_ENABLE_CUDA
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Alloc.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Alloc.hpp
index 5726e02180d084fa91914ae736b9d0f9a6b44d2d..e76133fae8702484874cc6afe5b7aa92934cba02 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Alloc.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Alloc.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,13 +53,12 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class DestructFunctor >
-SharedAllocationRecord *
-shared_allocation_record( Kokkos::CudaSpace const & arg_space
-                        , void *            const   arg_alloc_ptr
-                        , DestructFunctor   const & arg_destruct )
-{
-  SharedAllocationRecord * const record = SharedAllocationRecord::get_record( arg_alloc_ptr );
+template <class DestructFunctor>
+SharedAllocationRecord* shared_allocation_record(
+    Kokkos::CudaSpace const& arg_space, void* const arg_alloc_ptr,
+    DestructFunctor const& arg_destruct) {
+  SharedAllocationRecord* const record =
+      SharedAllocationRecord::get_record(arg_alloc_ptr);
 
   // assert: record != 0
 
@@ -66,115 +66,88 @@ shared_allocation_record( Kokkos::CudaSpace const & arg_space
 
   // assert: record->m_destruct_function == 0
 
-  DestructFunctor * const functor =
-    reinterpret_cast< DestructFunctor * >(
-    reinterpret_cast< uintptr_t >( record ) + sizeof(SharedAllocationRecord) );
+  DestructFunctor* const functor = reinterpret_cast<DestructFunctor*>(
+      reinterpret_cast<uintptr_t>(record) + sizeof(SharedAllocationRecord));
 
-  new( functor ) DestructFunctor( arg_destruct );
+  new (functor) DestructFunctor(arg_destruct);
 
-  record->m_destruct_functor = & shared_allocation_destroy< DestructFunctor > ;
+  record->m_destruct_functor = &shared_allocation_destroy<DestructFunctor>;
 
-  return record ;
+  return record;
 }
 
-
 /// class CudaUnmanagedAllocator
 /// does nothing when deallocate(ptr,size) is called
-struct CudaUnmanagedAllocator
-{
-  static const char * name()
-  {
-    return "Cuda Unmanaged Allocator";
-  }
+struct CudaUnmanagedAllocator {
+  static const char* name() { return "Cuda Unmanaged Allocator"; }
 
-  static void deallocate(void * /*ptr*/, size_t /*size*/) {}
+  static void deallocate(void* /*ptr*/, size_t /*size*/) {}
 
   static bool support_texture_binding() { return true; }
 };
 
 /// class CudaUnmanagedAllocator
 /// does nothing when deallocate(ptr,size) is called
-struct CudaUnmanagedUVMAllocator
-{
-  static const char * name()
-  {
-    return "Cuda Unmanaged UVM Allocator";
-  }
+struct CudaUnmanagedUVMAllocator {
+  static const char* name() { return "Cuda Unmanaged UVM Allocator"; }
 
-  static void deallocate(void * /*ptr*/, size_t /*size*/) {}
+  static void deallocate(void* /*ptr*/, size_t /*size*/) {}
 
   static bool support_texture_binding() { return true; }
 };
 
 /// class CudaUnmanagedHostAllocator
 /// does nothing when deallocate(ptr,size) is called
-class CudaUnmanagedHostAllocator
-{
-public:
-  static const char * name()
-  {
-    return "Cuda Unmanaged Host Allocator";
-  }
+class CudaUnmanagedHostAllocator {
+ public:
+  static const char* name() { return "Cuda Unmanaged Host Allocator"; }
   // Unmanaged deallocate does nothing
-  static void deallocate(void * /*ptr*/, size_t /*size*/) {}
+  static void deallocate(void* /*ptr*/, size_t /*size*/) {}
 };
 
 /// class CudaMallocAllocator
-class CudaMallocAllocator
-{
-public:
-  static const char * name()
-  {
-    return "Cuda Malloc Allocator";
-  }
+class CudaMallocAllocator {
+ public:
+  static const char* name() { return "Cuda Malloc Allocator"; }
 
   static void* allocate(size_t size);
 
-  static void deallocate(void * ptr, size_t);
+  static void deallocate(void* ptr, size_t);
 
-  static void * reallocate(void * old_ptr, size_t old_size, size_t new_size);
+  static void* reallocate(void* old_ptr, size_t old_size, size_t new_size);
 
   static bool support_texture_binding() { return true; }
 };
 
 /// class CudaUVMAllocator
-class CudaUVMAllocator
-{
-public:
-  static const char * name()
-  {
-    return "Cuda UVM Allocator";
-  }
+class CudaUVMAllocator {
+ public:
+  static const char* name() { return "Cuda UVM Allocator"; }
 
   static void* allocate(size_t size);
 
-  static void deallocate(void * ptr, size_t);
+  static void deallocate(void* ptr, size_t);
 
-  static void * reallocate(void * old_ptr, size_t old_size, size_t new_size);
+  static void* reallocate(void* old_ptr, size_t old_size, size_t new_size);
 
   static bool support_texture_binding() { return true; }
 };
 
 /// class CudaHostAllocator
-class CudaHostAllocator
-{
-public:
-  static const char * name()
-  {
-    return "Cuda Host Allocator";
-  }
+class CudaHostAllocator {
+ public:
+  static const char* name() { return "Cuda Host Allocator"; }
 
   static void* allocate(size_t size);
 
-  static void deallocate(void * ptr, size_t);
+  static void deallocate(void* ptr, size_t);
 
-  static void * reallocate(void * old_ptr, size_t old_size, size_t new_size);
+  static void* reallocate(void* old_ptr, size_t old_size, size_t new_size);
 };
 
+}  // namespace Impl
+}  // namespace Kokkos
 
-}} // namespace Kokkos::Impl
-
-#endif //KOKKOS_ENABLE_CUDA
-
-#endif // #ifndef KOKKOS_CUDA_ALLOCATION_TRACKING_HPP
+#endif  // KOKKOS_ENABLE_CUDA
 
+#endif  // #ifndef KOKKOS_CUDA_ALLOCATION_TRACKING_HPP
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp
index 9d4bcbc8cf196f9e198c801f6d6df41d77d44c51..8a6c0433c8d848633457c98845b7758e63fae52d 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp
@@ -32,10 +32,10 @@ LICENSE ASSOCIATED WITH SUBSEQUENT MODIFICATIONS
 
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
+//                        Kokkos v. 3.0
 //              Copyright (2019) Sandia Corporation
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -53,10 +53,10 @@ LICENSE ASSOCIATED WITH SUBSEQUENT MODIFICATIONS
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -82,85 +82,334 @@ LICENSE ASSOCIATED WITH SUBSEQUENT MODIFICATIONS
 namespace Kokkos {
 namespace Impl {
 
-
 #ifndef __simt_scope
 // Modification: Kokkos GPU atomics should default to `gpu` scope
 #define __simt_scope "gpu"
 #endif
 
-#define __simt_fence_signal_() asm volatile("":::"memory")
-#define __simt_fence_sc_() asm volatile("fence.sc." __simt_scope ";":::"memory")
-#define __simt_fence_() asm volatile("fence." __simt_scope ";":::"memory")
-
-#define __simt_load_acquire_8_as_32(ptr,ret) asm volatile("ld.acquire." __simt_scope ".b8 %0, [%1];" : "=r"(ret) : "l"(ptr) : "memory")
-#define __simt_load_relaxed_8_as_32(ptr,ret) asm volatile("ld.relaxed." __simt_scope ".b8 %0, [%1];" : "=r"(ret) : "l"(ptr) : "memory")
-#define __simt_store_release_8_as_32(ptr,desired) asm volatile("st.release." __simt_scope ".b8 [%0], %1;" :: "l"(ptr), "r"(desired) : "memory")
-#define __simt_store_relaxed_8_as_32(ptr,desired) asm volatile("st.relaxed." __simt_scope ".b8 [%0], %1;" :: "l"(ptr), "r"(desired) : "memory")
-
-#define __simt_load_acquire_16(ptr,ret) asm volatile("ld.acquire." __simt_scope ".b16 %0, [%1];" : "=h"(ret) : "l"(ptr) : "memory")
-#define __simt_load_relaxed_16(ptr,ret) asm volatile("ld.relaxed." __simt_scope ".b16 %0, [%1];" : "=h"(ret) : "l"(ptr) : "memory")
-#define __simt_store_release_16(ptr,desired) asm volatile("st.release." __simt_scope ".b16 [%0], %1;" :: "l"(ptr), "h"(desired) : "memory")
-#define __simt_store_relaxed_16(ptr,desired) asm volatile("st.relaxed." __simt_scope ".b16 [%0], %1;" :: "l"(ptr), "h"(desired) : "memory")
-
-#define __simt_load_acquire_32(ptr,ret) asm volatile("ld.acquire." __simt_scope ".b32 %0, [%1];" : "=r"(ret) : "l"(ptr) : "memory")
-#define __simt_load_relaxed_32(ptr,ret) asm volatile("ld.relaxed." __simt_scope ".b32 %0, [%1];" : "=r"(ret) : "l"(ptr) : "memory")
-#define __simt_store_release_32(ptr,desired) asm volatile("st.release." __simt_scope ".b32 [%0], %1;" :: "l"(ptr), "r"(desired) : "memory")
-#define __simt_store_relaxed_32(ptr,desired) asm volatile("st.relaxed." __simt_scope ".b32 [%0], %1;" :: "l"(ptr), "r"(desired) : "memory")
-#define __simt_exch_release_32(ptr,old,desired) asm volatile("atom.exch.release." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(desired) : "memory")
-#define __simt_exch_acquire_32(ptr,old,desired) asm volatile("atom.exch.acquire." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(desired) : "memory")
-#define __simt_exch_acq_rel_32(ptr,old,desired) asm volatile("atom.exch.acq_rel." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(desired) : "memory")
-#define __simt_exch_relaxed_32(ptr,old,desired) asm volatile("atom.exch.relaxed." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(desired) : "memory")
-#define __simt_cas_release_32(ptr,old,expected,desired) asm volatile("atom.cas.release." __simt_scope ".b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#define __simt_cas_acquire_32(ptr,old,expected,desired) asm volatile("atom.cas.acquire." __simt_scope ".b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#define __simt_cas_acq_rel_32(ptr,old,expected,desired) asm volatile("atom.cas.acq_rel." __simt_scope ".b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#define __simt_cas_relaxed_32(ptr,old,expected,desired) asm volatile("atom.cas.relaxed." __simt_scope ".b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#define __simt_add_release_32(ptr,old,addend) asm volatile("atom.add.release." __simt_scope ".u32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(addend) : "memory")
-#define __simt_add_acquire_32(ptr,old,addend) asm volatile("atom.add.acquire." __simt_scope ".u32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(addend) : "memory")
-#define __simt_add_acq_rel_32(ptr,old,addend) asm volatile("atom.add.acq_rel." __simt_scope ".u32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(addend) : "memory")
-#define __simt_add_relaxed_32(ptr,old,addend) asm volatile("atom.add.relaxed." __simt_scope ".u32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(addend) : "memory")
-#define __simt_and_release_32(ptr,old,andend) asm volatile("atom.and.release." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(andend) : "memory")
-#define __simt_and_acquire_32(ptr,old,andend) asm volatile("atom.and.acquire." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(andend) : "memory")
-#define __simt_and_acq_rel_32(ptr,old,andend) asm volatile("atom.and.acq_rel." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(andend) : "memory")
-#define __simt_and_relaxed_32(ptr,old,andend) asm volatile("atom.and.relaxed." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(andend) : "memory")
-#define __simt_or_release_32(ptr,old,orend) asm volatile("atom.or.release." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(orend) : "memory")
-#define __simt_or_acquire_32(ptr,old,orend) asm volatile("atom.or.acquire." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(orend) : "memory")
-#define __simt_or_acq_rel_32(ptr,old,orend) asm volatile("atom.or.acq_rel." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(orend) : "memory")
-#define __simt_or_relaxed_32(ptr,old,orend) asm volatile("atom.or.relaxed." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(orend) : "memory")
-#define __simt_xor_release_32(ptr,old,xorend) asm volatile("atom.xor.release." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(xorend) : "memory")
-#define __simt_xor_acquire_32(ptr,old,xorend) asm volatile("atom.xor.acquire." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(xorend) : "memory")
-#define __simt_xor_acq_rel_32(ptr,old,xorend) asm volatile("atom.xor.acq_rel." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(xorend) : "memory")
-#define __simt_xor_relaxed_32(ptr,old,xorend) asm volatile("atom.xor.relaxed." __simt_scope ".b32 %0, [%1], %2;" : "=r"(old) : "l"(ptr), "r"(xorend) : "memory")
-
-#define __simt_load_acquire_64(ptr,ret) asm volatile("ld.acquire." __simt_scope ".b64 %0, [%1];" : "=l"(ret) : "l"(ptr) : "memory")
-#define __simt_load_relaxed_64(ptr,ret) asm volatile("ld.relaxed." __simt_scope ".b64 %0, [%1];" : "=l"(ret) : "l"(ptr) : "memory")
-#define __simt_store_release_64(ptr,desired) asm volatile("st.release." __simt_scope ".b64 [%0], %1;" :: "l"(ptr), "l"(desired) : "memory")
-#define __simt_store_relaxed_64(ptr,desired) asm volatile("st.relaxed." __simt_scope ".b64 [%0], %1;" :: "l"(ptr), "l"(desired) : "memory")
-#define __simt_exch_release_64(ptr,old,desired) asm volatile("atom.exch.release." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(desired) : "memory")
-#define __simt_exch_acquire_64(ptr,old,desired) asm volatile("atom.exch.acquire." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(desired) : "memory")
-#define __simt_exch_acq_rel_64(ptr,old,desired) asm volatile("atom.exch.acq_rel." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(desired) : "memory")
-#define __simt_exch_relaxed_64(ptr,old,desired) asm volatile("atom.exch.relaxed." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(desired) : "memory")
-#define __simt_cas_release_64(ptr,old,expected,desired) asm volatile("atom.cas.release." __simt_scope ".b64 %0, [%1], %2, %3;" : "=l"(old) : "l"(ptr), "l"(expected), "l"(desired) : "memory")
-#define __simt_cas_acquire_64(ptr,old,expected,desired) asm volatile("atom.cas.acquire." __simt_scope ".b64 %0, [%1], %2, %3;" : "=l"(old) : "l"(ptr), "l"(expected), "l"(desired) : "memory")
-#define __simt_cas_acq_rel_64(ptr,old,expected,desired) asm volatile("atom.cas.acq_rel." __simt_scope ".b64 %0, [%1], %2, %3;" : "=l"(old) : "l"(ptr), "l"(expected), "l"(desired) : "memory")
-#define __simt_cas_relaxed_64(ptr,old,expected,desired) asm volatile("atom.cas.relaxed." __simt_scope ".b64 %0, [%1], %2, %3;" : "=l"(old) : "l"(ptr), "l"(expected), "l"(desired) : "memory")
-#define __simt_add_release_64(ptr,old,addend) asm volatile("atom.add.release." __simt_scope ".u64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(addend) : "memory")
-#define __simt_add_acquire_64(ptr,old,addend) asm volatile("atom.add.acquire." __simt_scope ".u64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(addend) : "memory")
-#define __simt_add_acq_rel_64(ptr,old,addend) asm volatile("atom.add.acq_rel." __simt_scope ".u64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(addend) : "memory")
-#define __simt_add_relaxed_64(ptr,old,addend) asm volatile("atom.add.relaxed." __simt_scope ".u64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(addend) : "memory")
-#define __simt_and_release_64(ptr,old,andend) asm volatile("atom.and.release." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(andend) : "memory")
-#define __simt_and_acquire_64(ptr,old,andend) asm volatile("atom.and.acquire." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(andend) : "memory")
-#define __simt_and_acq_rel_64(ptr,old,andend) asm volatile("atom.and.acq_rel." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(andend) : "memory")
-#define __simt_and_relaxed_64(ptr,old,andend) asm volatile("atom.and.relaxed." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(andend) : "memory")
-#define __simt_or_release_64(ptr,old,orend) asm volatile("atom.or.release." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(orend) : "memory")
-#define __simt_or_acquire_64(ptr,old,orend) asm volatile("atom.or.acquire." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(orend) : "memory")
-#define __simt_or_acq_rel_64(ptr,old,orend) asm volatile("atom.or.acq_rel." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(orend) : "memory")
-#define __simt_or_relaxed_64(ptr,old,orend) asm volatile("atom.or.relaxed." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(orend) : "memory")
-#define __simt_xor_release_64(ptr,old,xorend) asm volatile("atom.xor.release." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(xorend) : "memory")
-#define __simt_xor_acquire_64(ptr,old,xorend) asm volatile("atom.xor.acquire." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(xorend) : "memory")
-#define __simt_xor_acq_rel_64(ptr,old,xorend) asm volatile("atom.xor.acq_rel." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(xorend) : "memory")
-#define __simt_xor_relaxed_64(ptr,old,xorend) asm volatile("atom.xor.relaxed." __simt_scope ".b64 %0, [%1], %2;" : "=l"(old) : "l"(ptr), "l"(xorend) : "memory")
-
-#define __simt_nanosleep(timeout) asm volatile("nanosleep.u32 %0;" :: "r"(unsigned(timeout)) : )
+#define __simt_fence_signal_() asm volatile("" ::: "memory")
+#define __simt_fence_sc_() \
+  asm volatile("fence.sc." __simt_scope ";" ::: "memory")
+#define __simt_fence_() asm volatile("fence." __simt_scope ";" ::: "memory")
+
+#define __simt_load_acquire_8_as_32(ptr, ret)             \
+  asm volatile("ld.acquire." __simt_scope ".b8 %0, [%1];" \
+               : "=r"(ret)                                \
+               : "l"(ptr)                                 \
+               : "memory")
+#define __simt_load_relaxed_8_as_32(ptr, ret)             \
+  asm volatile("ld.relaxed." __simt_scope ".b8 %0, [%1];" \
+               : "=r"(ret)                                \
+               : "l"(ptr)                                 \
+               : "memory")
+#define __simt_store_release_8_as_32(ptr, desired)                    \
+  asm volatile("st.release." __simt_scope ".b8 [%0], %1;" ::"l"(ptr), \
+               "r"(desired)                                           \
+               : "memory")
+#define __simt_store_relaxed_8_as_32(ptr, desired)                    \
+  asm volatile("st.relaxed." __simt_scope ".b8 [%0], %1;" ::"l"(ptr), \
+               "r"(desired)                                           \
+               : "memory")
+
+#define __simt_load_acquire_16(ptr, ret)                   \
+  asm volatile("ld.acquire." __simt_scope ".b16 %0, [%1];" \
+               : "=h"(ret)                                 \
+               : "l"(ptr)                                  \
+               : "memory")
+#define __simt_load_relaxed_16(ptr, ret)                   \
+  asm volatile("ld.relaxed." __simt_scope ".b16 %0, [%1];" \
+               : "=h"(ret)                                 \
+               : "l"(ptr)                                  \
+               : "memory")
+#define __simt_store_release_16(ptr, desired)                          \
+  asm volatile("st.release." __simt_scope ".b16 [%0], %1;" ::"l"(ptr), \
+               "h"(desired)                                            \
+               : "memory")
+#define __simt_store_relaxed_16(ptr, desired)                          \
+  asm volatile("st.relaxed." __simt_scope ".b16 [%0], %1;" ::"l"(ptr), \
+               "h"(desired)                                            \
+               : "memory")
+
+#define __simt_load_acquire_32(ptr, ret)                   \
+  asm volatile("ld.acquire." __simt_scope ".b32 %0, [%1];" \
+               : "=r"(ret)                                 \
+               : "l"(ptr)                                  \
+               : "memory")
+#define __simt_load_relaxed_32(ptr, ret)                   \
+  asm volatile("ld.relaxed." __simt_scope ".b32 %0, [%1];" \
+               : "=r"(ret)                                 \
+               : "l"(ptr)                                  \
+               : "memory")
+#define __simt_store_release_32(ptr, desired)                          \
+  asm volatile("st.release." __simt_scope ".b32 [%0], %1;" ::"l"(ptr), \
+               "r"(desired)                                            \
+               : "memory")
+#define __simt_store_relaxed_32(ptr, desired)                          \
+  asm volatile("st.relaxed." __simt_scope ".b32 [%0], %1;" ::"l"(ptr), \
+               "r"(desired)                                            \
+               : "memory")
+#define __simt_exch_release_32(ptr, old, desired)                     \
+  asm volatile("atom.exch.release." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                            \
+               : "l"(ptr), "r"(desired)                               \
+               : "memory")
+#define __simt_exch_acquire_32(ptr, old, desired)                     \
+  asm volatile("atom.exch.acquire." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                            \
+               : "l"(ptr), "r"(desired)                               \
+               : "memory")
+#define __simt_exch_acq_rel_32(ptr, old, desired)                     \
+  asm volatile("atom.exch.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                            \
+               : "l"(ptr), "r"(desired)                               \
+               : "memory")
+#define __simt_exch_relaxed_32(ptr, old, desired)                     \
+  asm volatile("atom.exch.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                            \
+               : "l"(ptr), "r"(desired)                               \
+               : "memory")
+#define __simt_cas_release_32(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.release." __simt_scope ".b32 %0, [%1], %2, %3;" \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define __simt_cas_acquire_32(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.acquire." __simt_scope ".b32 %0, [%1], %2, %3;" \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define __simt_cas_acq_rel_32(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.acq_rel." __simt_scope ".b32 %0, [%1], %2, %3;" \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define __simt_cas_relaxed_32(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.relaxed." __simt_scope ".b32 %0, [%1], %2, %3;" \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define __simt_add_release_32(ptr, old, addend)                      \
+  asm volatile("atom.add.release." __simt_scope ".u32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(addend)                               \
+               : "memory")
+#define __simt_add_acquire_32(ptr, old, addend)                      \
+  asm volatile("atom.add.acquire." __simt_scope ".u32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(addend)                               \
+               : "memory")
+#define __simt_add_acq_rel_32(ptr, old, addend)                      \
+  asm volatile("atom.add.acq_rel." __simt_scope ".u32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(addend)                               \
+               : "memory")
+#define __simt_add_relaxed_32(ptr, old, addend)                      \
+  asm volatile("atom.add.relaxed." __simt_scope ".u32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(addend)                               \
+               : "memory")
+#define __simt_and_release_32(ptr, old, andend)                      \
+  asm volatile("atom.and.release." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(andend)                               \
+               : "memory")
+#define __simt_and_acquire_32(ptr, old, andend)                      \
+  asm volatile("atom.and.acquire." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(andend)                               \
+               : "memory")
+#define __simt_and_acq_rel_32(ptr, old, andend)                      \
+  asm volatile("atom.and.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(andend)                               \
+               : "memory")
+#define __simt_and_relaxed_32(ptr, old, andend)                      \
+  asm volatile("atom.and.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(andend)                               \
+               : "memory")
+#define __simt_or_release_32(ptr, old, orend)                       \
+  asm volatile("atom.or.release." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                          \
+               : "l"(ptr), "r"(orend)                               \
+               : "memory")
+#define __simt_or_acquire_32(ptr, old, orend)                       \
+  asm volatile("atom.or.acquire." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                          \
+               : "l"(ptr), "r"(orend)                               \
+               : "memory")
+#define __simt_or_acq_rel_32(ptr, old, orend)                       \
+  asm volatile("atom.or.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                          \
+               : "l"(ptr), "r"(orend)                               \
+               : "memory")
+#define __simt_or_relaxed_32(ptr, old, orend)                       \
+  asm volatile("atom.or.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                          \
+               : "l"(ptr), "r"(orend)                               \
+               : "memory")
+#define __simt_xor_release_32(ptr, old, xorend)                      \
+  asm volatile("atom.xor.release." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(xorend)                               \
+               : "memory")
+#define __simt_xor_acquire_32(ptr, old, xorend)                      \
+  asm volatile("atom.xor.acquire." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(xorend)                               \
+               : "memory")
+#define __simt_xor_acq_rel_32(ptr, old, xorend)                      \
+  asm volatile("atom.xor.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(xorend)                               \
+               : "memory")
+#define __simt_xor_relaxed_32(ptr, old, xorend)                      \
+  asm volatile("atom.xor.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
+               : "=r"(old)                                           \
+               : "l"(ptr), "r"(xorend)                               \
+               : "memory")
+
+#define __simt_load_acquire_64(ptr, ret)                   \
+  asm volatile("ld.acquire." __simt_scope ".b64 %0, [%1];" \
+               : "=l"(ret)                                 \
+               : "l"(ptr)                                  \
+               : "memory")
+#define __simt_load_relaxed_64(ptr, ret)                   \
+  asm volatile("ld.relaxed." __simt_scope ".b64 %0, [%1];" \
+               : "=l"(ret)                                 \
+               : "l"(ptr)                                  \
+               : "memory")
+#define __simt_store_release_64(ptr, desired)                          \
+  asm volatile("st.release." __simt_scope ".b64 [%0], %1;" ::"l"(ptr), \
+               "l"(desired)                                            \
+               : "memory")
+#define __simt_store_relaxed_64(ptr, desired)                          \
+  asm volatile("st.relaxed." __simt_scope ".b64 [%0], %1;" ::"l"(ptr), \
+               "l"(desired)                                            \
+               : "memory")
+#define __simt_exch_release_64(ptr, old, desired)                     \
+  asm volatile("atom.exch.release." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                            \
+               : "l"(ptr), "l"(desired)                               \
+               : "memory")
+#define __simt_exch_acquire_64(ptr, old, desired)                     \
+  asm volatile("atom.exch.acquire." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                            \
+               : "l"(ptr), "l"(desired)                               \
+               : "memory")
+#define __simt_exch_acq_rel_64(ptr, old, desired)                     \
+  asm volatile("atom.exch.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                            \
+               : "l"(ptr), "l"(desired)                               \
+               : "memory")
+#define __simt_exch_relaxed_64(ptr, old, desired)                     \
+  asm volatile("atom.exch.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                            \
+               : "l"(ptr), "l"(desired)                               \
+               : "memory")
+#define __simt_cas_release_64(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.release." __simt_scope ".b64 %0, [%1], %2, %3;" \
+               : "=l"(old)                                               \
+               : "l"(ptr), "l"(expected), "l"(desired)                   \
+               : "memory")
+#define __simt_cas_acquire_64(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.acquire." __simt_scope ".b64 %0, [%1], %2, %3;" \
+               : "=l"(old)                                               \
+               : "l"(ptr), "l"(expected), "l"(desired)                   \
+               : "memory")
+#define __simt_cas_acq_rel_64(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.acq_rel." __simt_scope ".b64 %0, [%1], %2, %3;" \
+               : "=l"(old)                                               \
+               : "l"(ptr), "l"(expected), "l"(desired)                   \
+               : "memory")
+#define __simt_cas_relaxed_64(ptr, old, expected, desired)               \
+  asm volatile("atom.cas.relaxed." __simt_scope ".b64 %0, [%1], %2, %3;" \
+               : "=l"(old)                                               \
+               : "l"(ptr), "l"(expected), "l"(desired)                   \
+               : "memory")
+#define __simt_add_release_64(ptr, old, addend)                      \
+  asm volatile("atom.add.release." __simt_scope ".u64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(addend)                               \
+               : "memory")
+#define __simt_add_acquire_64(ptr, old, addend)                      \
+  asm volatile("atom.add.acquire." __simt_scope ".u64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(addend)                               \
+               : "memory")
+#define __simt_add_acq_rel_64(ptr, old, addend)                      \
+  asm volatile("atom.add.acq_rel." __simt_scope ".u64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(addend)                               \
+               : "memory")
+#define __simt_add_relaxed_64(ptr, old, addend)                      \
+  asm volatile("atom.add.relaxed." __simt_scope ".u64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(addend)                               \
+               : "memory")
+#define __simt_and_release_64(ptr, old, andend)                      \
+  asm volatile("atom.and.release." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(andend)                               \
+               : "memory")
+#define __simt_and_acquire_64(ptr, old, andend)                      \
+  asm volatile("atom.and.acquire." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(andend)                               \
+               : "memory")
+#define __simt_and_acq_rel_64(ptr, old, andend)                      \
+  asm volatile("atom.and.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(andend)                               \
+               : "memory")
+#define __simt_and_relaxed_64(ptr, old, andend)                      \
+  asm volatile("atom.and.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(andend)                               \
+               : "memory")
+#define __simt_or_release_64(ptr, old, orend)                       \
+  asm volatile("atom.or.release." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                          \
+               : "l"(ptr), "l"(orend)                               \
+               : "memory")
+#define __simt_or_acquire_64(ptr, old, orend)                       \
+  asm volatile("atom.or.acquire." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                          \
+               : "l"(ptr), "l"(orend)                               \
+               : "memory")
+#define __simt_or_acq_rel_64(ptr, old, orend)                       \
+  asm volatile("atom.or.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                          \
+               : "l"(ptr), "l"(orend)                               \
+               : "memory")
+#define __simt_or_relaxed_64(ptr, old, orend)                       \
+  asm volatile("atom.or.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                          \
+               : "l"(ptr), "l"(orend)                               \
+               : "memory")
+#define __simt_xor_release_64(ptr, old, xorend)                      \
+  asm volatile("atom.xor.release." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(xorend)                               \
+               : "memory")
+#define __simt_xor_acquire_64(ptr, old, xorend)                      \
+  asm volatile("atom.xor.acquire." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(xorend)                               \
+               : "memory")
+#define __simt_xor_acq_rel_64(ptr, old, xorend)                      \
+  asm volatile("atom.xor.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(xorend)                               \
+               : "memory")
+#define __simt_xor_relaxed_64(ptr, old, xorend)                      \
+  asm volatile("atom.xor.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
+               : "=l"(old)                                           \
+               : "l"(ptr), "l"(xorend)                               \
+               : "memory")
+
+#define __simt_nanosleep(timeout) \
+  asm volatile("nanosleep.u32 %0;" ::"r"(unsigned(timeout)) :)
 
 /*
     definitions
@@ -189,309 +438,355 @@ namespace Impl {
 #endif
 
 inline __device__ int __stronger_order_simt_(int a, int b) {
-    if (b == __ATOMIC_SEQ_CST) return __ATOMIC_SEQ_CST;
-    if (b == __ATOMIC_RELAXED) return a;
-    switch (a) {
+  if (b == __ATOMIC_SEQ_CST) return __ATOMIC_SEQ_CST;
+  if (b == __ATOMIC_RELAXED) return a;
+  switch (a) {
     case __ATOMIC_SEQ_CST:
     case __ATOMIC_ACQ_REL: return a;
     case __ATOMIC_CONSUME:
-    case __ATOMIC_ACQUIRE: if (b != __ATOMIC_ACQUIRE) return __ATOMIC_ACQ_REL; else return __ATOMIC_ACQUIRE;
-    case __ATOMIC_RELEASE: if (b != __ATOMIC_RELEASE) return __ATOMIC_ACQ_REL; else return __ATOMIC_RELEASE;
+    case __ATOMIC_ACQUIRE:
+      if (b != __ATOMIC_ACQUIRE)
+        return __ATOMIC_ACQ_REL;
+      else
+        return __ATOMIC_ACQUIRE;
+    case __ATOMIC_RELEASE:
+      if (b != __ATOMIC_RELEASE)
+        return __ATOMIC_ACQ_REL;
+      else
+        return __ATOMIC_RELEASE;
     case __ATOMIC_RELAXED: return b;
     default: assert(0);
-    }
-    return __ATOMIC_SEQ_CST;
+  }
+  return __ATOMIC_SEQ_CST;
 }
 
 /*
     base
 */
 
-#define DO__atomic_load_simt_(bytes, bits) \
-template<class type, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-void __device__ __atomic_load_simt_ (const type *ptr, type *ret, int memorder) { \
-    int##bits##_t tmp = 0; \
-    switch (memorder) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_load_acquire_##bits(ptr, tmp); break; \
-    case __ATOMIC_RELAXED: __simt_load_relaxed_##bits(ptr, tmp); break; \
-    default: assert(0); \
-    } \
-    memcpy(ret, &tmp, bytes); \
-}
-DO__atomic_load_simt_(1,32)
-DO__atomic_load_simt_(2,16)
-DO__atomic_load_simt_(4,32)
-DO__atomic_load_simt_(8,64)
-
-template<class type>
-type __device__ __atomic_load_n_simt_(const type *ptr, int memorder) {
-    type ret;
-    __atomic_load_simt_(ptr, &ret, memorder);
-    return ret;
-}
-
-#define DO__atomic_store_simt_(bytes, bits) \
-template<class type, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-void __device__ __atomic_store_simt_ (type *ptr, type *val, int memorder) { \
-    int##bits##_t tmp = 0; \
-    memcpy(&tmp, val, bytes); \
-    switch (memorder) { \
-    case __ATOMIC_RELEASE: __simt_store_release_##bits(ptr, tmp); break; \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_RELAXED: __simt_store_relaxed_##bits(ptr, tmp); break; \
-    default: assert(0); \
-    } \
-}
-DO__atomic_store_simt_(1,32)
-DO__atomic_store_simt_(2,16)
-DO__atomic_store_simt_(4,32)
-DO__atomic_store_simt_(8,64)
-
-template<class type>
-void __device__ __atomic_store_n_simt_(type *ptr, type val, int memorder) {
-    __atomic_store_simt_(ptr, &val, memorder);
-}
-
-#define DO__atomic_compare_exchange_simt_(bytes, bits) \
-template<class type, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-bool __device__ __atomic_compare_exchange_simt_ (type *ptr, type *expected, const type *desired, bool, int success_memorder, int failure_memorder) { \
-    int##bits##_t tmp = 0, old = 0, old_tmp; \
-    memcpy(&tmp, desired, bytes); \
-    memcpy(&old, expected, bytes); \
-    old_tmp = old; \
-    switch (__stronger_order_simt_(success_memorder, failure_memorder)) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_cas_acquire_##bits(ptr, old, old_tmp, tmp); break; \
-    case __ATOMIC_ACQ_REL: __simt_cas_acq_rel_##bits(ptr, old, old_tmp, tmp); break; \
-    case __ATOMIC_RELEASE: __simt_cas_release_##bits(ptr, old, old_tmp, tmp); break; \
-    case __ATOMIC_RELAXED: __simt_cas_relaxed_##bits(ptr, old, old_tmp, tmp); break; \
-    default: assert(0); \
-    } \
-    bool const ret = old == old_tmp; \
-    memcpy(expected, &old, bytes); \
-    return ret; \
-}
+#define DO__atomic_load_simt_(bytes, bits)                                 \
+  template <class type,                                                    \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0> \
+  void __device__ __atomic_load_simt_(const type *ptr, type *ret,          \
+                                      int memorder) {                      \
+    int##bits##_t tmp = 0;                                                 \
+    switch (memorder) {                                                    \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                           \
+      case __ATOMIC_CONSUME:                                               \
+      case __ATOMIC_ACQUIRE: __simt_load_acquire_##bits(ptr, tmp); break;  \
+      case __ATOMIC_RELAXED: __simt_load_relaxed_##bits(ptr, tmp); break;  \
+      default: assert(0);                                                  \
+    }                                                                      \
+    memcpy(ret, &tmp, bytes);                                              \
+  }
+DO__atomic_load_simt_(1, 32) DO__atomic_load_simt_(2, 16)
+    DO__atomic_load_simt_(4, 32) DO__atomic_load_simt_(8, 64)
+
+        template <class type>
+        type __device__ __atomic_load_n_simt_(const type *ptr, int memorder) {
+  type ret;
+  __atomic_load_simt_(ptr, &ret, memorder);
+  return ret;
+}
+
+#define DO__atomic_store_simt_(bytes, bits)                                  \
+  template <class type,                                                      \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0>   \
+  void __device__ __atomic_store_simt_(type *ptr, type *val, int memorder) { \
+    int##bits##_t tmp = 0;                                                   \
+    memcpy(&tmp, val, bytes);                                                \
+    switch (memorder) {                                                      \
+      case __ATOMIC_RELEASE: __simt_store_release_##bits(ptr, tmp); break;   \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                             \
+      case __ATOMIC_RELAXED: __simt_store_relaxed_##bits(ptr, tmp); break;   \
+      default: assert(0);                                                    \
+    }                                                                        \
+  }
+DO__atomic_store_simt_(1, 32) DO__atomic_store_simt_(2, 16)
+    DO__atomic_store_simt_(4, 32) DO__atomic_store_simt_(8, 64)
+
+        template <class type>
+        void __device__
+    __atomic_store_n_simt_(type *ptr, type val, int memorder) {
+  __atomic_store_simt_(ptr, &val, memorder);
+}
+
+#define DO__atomic_compare_exchange_simt_(bytes, bits)                     \
+  template <class type,                                                    \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0> \
+  bool __device__ __atomic_compare_exchange_simt_(                         \
+      type *ptr, type *expected, const type *desired, bool,                \
+      int success_memorder, int failure_memorder) {                        \
+    int##bits##_t tmp = 0, old = 0, old_tmp;                               \
+    memcpy(&tmp, desired, bytes);                                          \
+    memcpy(&old, expected, bytes);                                         \
+    old_tmp = old;                                                         \
+    switch (__stronger_order_simt_(success_memorder, failure_memorder)) {  \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                           \
+      case __ATOMIC_CONSUME:                                               \
+      case __ATOMIC_ACQUIRE:                                               \
+        __simt_cas_acquire_##bits(ptr, old, old_tmp, tmp);                 \
+        break;                                                             \
+      case __ATOMIC_ACQ_REL:                                               \
+        __simt_cas_acq_rel_##bits(ptr, old, old_tmp, tmp);                 \
+        break;                                                             \
+      case __ATOMIC_RELEASE:                                               \
+        __simt_cas_release_##bits(ptr, old, old_tmp, tmp);                 \
+        break;                                                             \
+      case __ATOMIC_RELAXED:                                               \
+        __simt_cas_relaxed_##bits(ptr, old, old_tmp, tmp);                 \
+        break;                                                             \
+      default: assert(0);                                                  \
+    }                                                                      \
+    bool const ret = old == old_tmp;                                       \
+    memcpy(expected, &old, bytes);                                         \
+    return ret;                                                            \
+  }
 DO__atomic_compare_exchange_simt_(4, 32)
-DO__atomic_compare_exchange_simt_(8, 64)
-
-template<class type, typename std::enable_if<sizeof(type) <= 2, int>::type = 0> \
-bool __device__ __atomic_compare_exchange_simt_(type *ptr, type *expected, const type *desired, bool, int success_memorder, int failure_memorder) {
-
-    using R = typename std::conditional<std::is_volatile<type>::value, volatile uint32_t, uint32_t>::type;
-    auto const aligned = (R*)((intptr_t)ptr & ~(sizeof(uint32_t) - 1));
-    auto const offset = uint32_t((intptr_t)ptr & (sizeof(uint32_t) - 1)) * 8;
-    auto const mask = ((1 << sizeof(type)*8) - 1) << offset;
-
-    uint32_t old = *expected << offset, old_value;
-    while (1) {
-        old_value = (old & mask) >> offset;
-        if (old_value != *expected)
-            break;
-        uint32_t const attempt = (old & ~mask) | (*desired << offset);
-        if (__atomic_compare_exchange_simt_ (aligned, &old, &attempt, true, success_memorder, failure_memorder))
-            return true;
-    }
-    *expected = old_value;
-    return false;
-}
-
-template<class type>
-bool __device__ __atomic_compare_exchange_n_simt_(type *ptr, type *expected, type desired, bool weak, int success_memorder, int failure_memorder) {
-    return __atomic_compare_exchange_simt_(ptr, expected, &desired, weak, success_memorder, failure_memorder);
-}
-
-#define DO__atomic_exchange_simt_(bytes, bits) \
-template<class type, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-void __device__ __atomic_exchange_simt_ (type *ptr, type *val, type *ret, int memorder) { \
-    int##bits##_t tmp = 0; \
-    memcpy(&tmp, val, bytes); \
-    switch (memorder) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_exch_acquire_##bits(ptr, tmp, tmp); break; \
-    case __ATOMIC_ACQ_REL: __simt_exch_acq_rel_##bits(ptr, tmp, tmp); break; \
-    case __ATOMIC_RELEASE: __simt_exch_release_##bits(ptr, tmp, tmp); break; \
-    case __ATOMIC_RELAXED: __simt_exch_relaxed_##bits(ptr, tmp, tmp); break; \
-    default: assert(0); \
-    } \
-    memcpy(ret, &tmp, bytes); \
-}
-DO__atomic_exchange_simt_(4,32)
-DO__atomic_exchange_simt_(8,64)
-
-template<class type, typename std::enable_if<sizeof(type)<=2, int>::type = 0>
-void __device__ __atomic_exchange_simt_ (type *ptr, type *val, type *ret, int memorder) {
-
-    type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-    while(!__atomic_compare_exchange_simt_(ptr, &expected, val, true, memorder, memorder))
-        ;
-    *ret = expected;
-}
-
-template<class type>
+    DO__atomic_compare_exchange_simt_(8, 64)
+
+        template <class type,
+                  typename std::enable_if<sizeof(type) <= 2, int>::type = 0>
+        bool __device__
+    __atomic_compare_exchange_simt_(type *ptr, type *expected,
+                                    const type *desired, bool,
+                                    int success_memorder,
+                                    int failure_memorder) {
+  using R            = typename std::conditional<std::is_volatile<type>::value,
+                                      volatile uint32_t, uint32_t>::type;
+  auto const aligned = (R *)((intptr_t)ptr & ~(sizeof(uint32_t) - 1));
+  auto const offset  = uint32_t((intptr_t)ptr & (sizeof(uint32_t) - 1)) * 8;
+  auto const mask    = ((1 << sizeof(type) * 8) - 1) << offset;
+
+  uint32_t old = *expected << offset, old_value;
+  while (1) {
+    old_value = (old & mask) >> offset;
+    if (old_value != *expected) break;
+    uint32_t const attempt = (old & ~mask) | (*desired << offset);
+    if (__atomic_compare_exchange_simt_(aligned, &old, &attempt, true,
+                                        success_memorder, failure_memorder))
+      return true;
+  }
+  *expected = old_value;
+  return false;
+}
+
+template <class type>
+bool __device__ __atomic_compare_exchange_n_simt_(type *ptr, type *expected,
+                                                  type desired, bool weak,
+                                                  int success_memorder,
+                                                  int failure_memorder) {
+  return __atomic_compare_exchange_simt_(ptr, expected, &desired, weak,
+                                         success_memorder, failure_memorder);
+}
+
+#define DO__atomic_exchange_simt_(bytes, bits)                                 \
+  template <class type,                                                        \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0>     \
+  void __device__ __atomic_exchange_simt_(type *ptr, type *val, type *ret,     \
+                                          int memorder) {                      \
+    int##bits##_t tmp = 0;                                                     \
+    memcpy(&tmp, val, bytes);                                                  \
+    switch (memorder) {                                                        \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                               \
+      case __ATOMIC_CONSUME:                                                   \
+      case __ATOMIC_ACQUIRE: __simt_exch_acquire_##bits(ptr, tmp, tmp); break; \
+      case __ATOMIC_ACQ_REL: __simt_exch_acq_rel_##bits(ptr, tmp, tmp); break; \
+      case __ATOMIC_RELEASE: __simt_exch_release_##bits(ptr, tmp, tmp); break; \
+      case __ATOMIC_RELAXED: __simt_exch_relaxed_##bits(ptr, tmp, tmp); break; \
+      default: assert(0);                                                      \
+    }                                                                          \
+    memcpy(ret, &tmp, bytes);                                                  \
+  }
+DO__atomic_exchange_simt_(4, 32) DO__atomic_exchange_simt_(8, 64)
+
+    template <class type,
+              typename std::enable_if<sizeof(type) <= 2, int>::type = 0>
+    void __device__
+    __atomic_exchange_simt_(type *ptr, type *val, type *ret, int memorder) {
+  type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
+  while (!__atomic_compare_exchange_simt_(ptr, &expected, val, true, memorder,
+                                          memorder))
+    ;
+  *ret = expected;
+}
+
+template <class type>
 type __device__ __atomic_exchange_n_simt_(type *ptr, type val, int memorder) {
-    type ret;
-    __atomic_exchange_simt_(ptr, &val, &ret, memorder);
-    return ret;
-}
-
-#define DO__atomic_fetch_add_simt_(bytes, bits) \
-template<class type, class delta, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-type __device__ __atomic_fetch_add_simt_ (type *ptr, delta val, int memorder) { \
-    type ret; \
-    switch (memorder) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_add_acquire_##bits(ptr, ret, val); break; \
-    case __ATOMIC_ACQ_REL: __simt_add_acq_rel_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELEASE: __simt_add_release_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELAXED: __simt_add_relaxed_##bits(ptr, ret, val); break; \
-    default: assert(0); \
-    } \
-    return ret; \
-}
-DO__atomic_fetch_add_simt_(4, 32)
-DO__atomic_fetch_add_simt_(8, 64)
-
-template<class type, class delta, typename std::enable_if<sizeof(type)<=2, int>::type = 0>
-type __device__ __atomic_fetch_add_simt_ (type *ptr, delta val, int memorder) {
-
-    type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-    type const desired = expected + val;
-    while(!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true, memorder, memorder))
-        ;
-    return expected;
-}
-
-#define DO__atomic_fetch_sub_simt_(bytes, bits) \
-template<class type, class delta, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-type __device__ __atomic_fetch_sub_simt_ (type *ptr, delta val, int memorder) { \
-    type ret; \
-    switch (memorder) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_add_acquire_##bits(ptr, ret, -val); break; \
-    case __ATOMIC_ACQ_REL: __simt_add_acq_rel_##bits(ptr, ret, -val); break; \
-    case __ATOMIC_RELEASE: __simt_add_release_##bits(ptr, ret, -val); break; \
-    case __ATOMIC_RELAXED: __simt_add_relaxed_##bits(ptr, ret, -val); break; \
-    default: assert(0); \
-    } \
-    return ret; \
-}
-DO__atomic_fetch_sub_simt_(4,32)
-DO__atomic_fetch_sub_simt_(8,64)
-
-template<class type, class delta, typename std::enable_if<sizeof(type)<=2, int>::type = 0>
-type __device__ __atomic_fetch_sub_simt_ (type *ptr, delta val, int memorder) {
-
-    type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-    type const desired = expected - val;
-    while(!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true, memorder, memorder))
-        ;
-    return expected;
-}
-
-#define DO__atomic_fetch_and_simt_(bytes, bits) \
-template<class type, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-type __device__ __atomic_fetch_and_simt_ (type *ptr, type val, int memorder) { \
-    type ret; \
-    switch (memorder) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_and_acquire_##bits(ptr, ret, val); break; \
-    case __ATOMIC_ACQ_REL: __simt_and_acq_rel_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELEASE: __simt_and_release_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELAXED: __simt_and_relaxed_##bits(ptr, ret, val); break; \
-    default: assert(0); \
-    } \
-    return ret; \
-}
-DO__atomic_fetch_and_simt_(4,32)
-DO__atomic_fetch_and_simt_(8,64)
-
-template<class type, class delta, typename std::enable_if<sizeof(type)<=2, int>::type = 0>
-type __device__ __atomic_fetch_and_simt_ (type *ptr, delta val, int memorder) {
-
-    type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-    type const desired = expected & val;
-    while(!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true, memorder, memorder))
-        ;
-    return expected;
-}
-
-#define DO__atomic_fetch_xor_simt_(bytes, bits) \
-template<class type, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-type __device__ __atomic_fetch_xor_simt_ (type *ptr, type val, int memorder) { \
-    type ret; \
-    switch (memorder) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_xor_acquire_##bits(ptr, ret, val); break; \
-    case __ATOMIC_ACQ_REL: __simt_xor_acq_rel_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELEASE: __simt_xor_release_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELAXED: __simt_xor_relaxed_##bits(ptr, ret, val); break; \
-    default: assert(0); \
-    } \
-    return ret; \
-}
-DO__atomic_fetch_xor_simt_(4,32)
-DO__atomic_fetch_xor_simt_(8,64)
-
-template<class type, class delta, typename std::enable_if<sizeof(type)<=2, int>::type = 0>
-type __device__ __atomic_fetch_xor_simt_ (type *ptr, delta val, int memorder) {
-
-    type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-    type const desired = expected ^ val;
-    while(!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true, memorder, memorder))
-        ;
-    return expected;
-}
-
-#define DO__atomic_fetch_or_simt_(bytes, bits) \
-template<class type, typename std::enable_if<sizeof(type)==bytes, int>::type = 0> \
-type __device__ __atomic_fetch_or_simt_ (type *ptr, type val, int memorder) { \
-    type ret; \
-    switch (memorder) { \
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); \
-    case __ATOMIC_CONSUME: \
-    case __ATOMIC_ACQUIRE: __simt_or_acquire_##bits(ptr, ret, val); break; \
-    case __ATOMIC_ACQ_REL: __simt_or_acq_rel_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELEASE: __simt_or_release_##bits(ptr, ret, val); break; \
-    case __ATOMIC_RELAXED: __simt_or_relaxed_##bits(ptr, ret, val); break; \
-    default: assert(0); \
-    } \
-    return ret; \
-}
-DO__atomic_fetch_or_simt_(4,32)
-DO__atomic_fetch_or_simt_(8,64)
-
-template<class type, class delta, typename std::enable_if<sizeof(type)<=2, int>::type = 0>
-type __device__ __atomic_fetch_or_simt_ (type *ptr, delta val, int memorder) {
-
-    type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-    type const desired = expected | val;
-    while(!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true, memorder, memorder))
-        ;
-    return expected;
-}
-
-template<class type>
+  type ret;
+  __atomic_exchange_simt_(ptr, &val, &ret, memorder);
+  return ret;
+}
+
+#define DO__atomic_fetch_add_simt_(bytes, bits)                               \
+  template <class type, class delta,                                          \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0>    \
+  type __device__ __atomic_fetch_add_simt_(type *ptr, delta val,              \
+                                           int memorder) {                    \
+    type ret;                                                                 \
+    switch (memorder) {                                                       \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                              \
+      case __ATOMIC_CONSUME:                                                  \
+      case __ATOMIC_ACQUIRE: __simt_add_acquire_##bits(ptr, ret, val); break; \
+      case __ATOMIC_ACQ_REL: __simt_add_acq_rel_##bits(ptr, ret, val); break; \
+      case __ATOMIC_RELEASE: __simt_add_release_##bits(ptr, ret, val); break; \
+      case __ATOMIC_RELAXED: __simt_add_relaxed_##bits(ptr, ret, val); break; \
+      default: assert(0);                                                     \
+    }                                                                         \
+    return ret;                                                               \
+  }
+DO__atomic_fetch_add_simt_(4, 32) DO__atomic_fetch_add_simt_(8, 64)
+
+    template <class type, class delta,
+              typename std::enable_if<sizeof(type) <= 2, int>::type = 0>
+    type __device__
+    __atomic_fetch_add_simt_(type *ptr, delta val, int memorder) {
+  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
+  type const desired = expected + val;
+  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
+                                          memorder, memorder))
+    ;
+  return expected;
+}
+
+#define DO__atomic_fetch_sub_simt_(bytes, bits)                                \
+  template <class type, class delta,                                           \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0>     \
+  type __device__ __atomic_fetch_sub_simt_(type *ptr, delta val,               \
+                                           int memorder) {                     \
+    type ret;                                                                  \
+    switch (memorder) {                                                        \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                               \
+      case __ATOMIC_CONSUME:                                                   \
+      case __ATOMIC_ACQUIRE: __simt_add_acquire_##bits(ptr, ret, -val); break; \
+      case __ATOMIC_ACQ_REL: __simt_add_acq_rel_##bits(ptr, ret, -val); break; \
+      case __ATOMIC_RELEASE: __simt_add_release_##bits(ptr, ret, -val); break; \
+      case __ATOMIC_RELAXED: __simt_add_relaxed_##bits(ptr, ret, -val); break; \
+      default: assert(0);                                                      \
+    }                                                                          \
+    return ret;                                                                \
+  }
+DO__atomic_fetch_sub_simt_(4, 32) DO__atomic_fetch_sub_simt_(8, 64)
+
+    template <class type, class delta,
+              typename std::enable_if<sizeof(type) <= 2, int>::type = 0>
+    type __device__
+    __atomic_fetch_sub_simt_(type *ptr, delta val, int memorder) {
+  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
+  type const desired = expected - val;
+  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
+                                          memorder, memorder))
+    ;
+  return expected;
+}
+
+#define DO__atomic_fetch_and_simt_(bytes, bits)                               \
+  template <class type,                                                       \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0>    \
+  type __device__ __atomic_fetch_and_simt_(type *ptr, type val,               \
+                                           int memorder) {                    \
+    type ret;                                                                 \
+    switch (memorder) {                                                       \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                              \
+      case __ATOMIC_CONSUME:                                                  \
+      case __ATOMIC_ACQUIRE: __simt_and_acquire_##bits(ptr, ret, val); break; \
+      case __ATOMIC_ACQ_REL: __simt_and_acq_rel_##bits(ptr, ret, val); break; \
+      case __ATOMIC_RELEASE: __simt_and_release_##bits(ptr, ret, val); break; \
+      case __ATOMIC_RELAXED: __simt_and_relaxed_##bits(ptr, ret, val); break; \
+      default: assert(0);                                                     \
+    }                                                                         \
+    return ret;                                                               \
+  }
+DO__atomic_fetch_and_simt_(4, 32) DO__atomic_fetch_and_simt_(8, 64)
+
+    template <class type, class delta,
+              typename std::enable_if<sizeof(type) <= 2, int>::type = 0>
+    type __device__
+    __atomic_fetch_and_simt_(type *ptr, delta val, int memorder) {
+  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
+  type const desired = expected & val;
+  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
+                                          memorder, memorder))
+    ;
+  return expected;
+}
+
+#define DO__atomic_fetch_xor_simt_(bytes, bits)                               \
+  template <class type,                                                       \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0>    \
+  type __device__ __atomic_fetch_xor_simt_(type *ptr, type val,               \
+                                           int memorder) {                    \
+    type ret;                                                                 \
+    switch (memorder) {                                                       \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                              \
+      case __ATOMIC_CONSUME:                                                  \
+      case __ATOMIC_ACQUIRE: __simt_xor_acquire_##bits(ptr, ret, val); break; \
+      case __ATOMIC_ACQ_REL: __simt_xor_acq_rel_##bits(ptr, ret, val); break; \
+      case __ATOMIC_RELEASE: __simt_xor_release_##bits(ptr, ret, val); break; \
+      case __ATOMIC_RELAXED: __simt_xor_relaxed_##bits(ptr, ret, val); break; \
+      default: assert(0);                                                     \
+    }                                                                         \
+    return ret;                                                               \
+  }
+DO__atomic_fetch_xor_simt_(4, 32) DO__atomic_fetch_xor_simt_(8, 64)
+
+    template <class type, class delta,
+              typename std::enable_if<sizeof(type) <= 2, int>::type = 0>
+    type __device__
+    __atomic_fetch_xor_simt_(type *ptr, delta val, int memorder) {
+  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
+  type const desired = expected ^ val;
+  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
+                                          memorder, memorder))
+    ;
+  return expected;
+}
+
+#define DO__atomic_fetch_or_simt_(bytes, bits)                                 \
+  template <class type,                                                        \
+            typename std::enable_if<sizeof(type) == bytes, int>::type = 0>     \
+  type __device__ __atomic_fetch_or_simt_(type *ptr, type val, int memorder) { \
+    type ret;                                                                  \
+    switch (memorder) {                                                        \
+      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                               \
+      case __ATOMIC_CONSUME:                                                   \
+      case __ATOMIC_ACQUIRE: __simt_or_acquire_##bits(ptr, ret, val); break;   \
+      case __ATOMIC_ACQ_REL: __simt_or_acq_rel_##bits(ptr, ret, val); break;   \
+      case __ATOMIC_RELEASE: __simt_or_release_##bits(ptr, ret, val); break;   \
+      case __ATOMIC_RELAXED: __simt_or_relaxed_##bits(ptr, ret, val); break;   \
+      default: assert(0);                                                      \
+    }                                                                          \
+    return ret;                                                                \
+  }
+DO__atomic_fetch_or_simt_(4, 32) DO__atomic_fetch_or_simt_(8, 64)
+
+    template <class type, class delta,
+              typename std::enable_if<sizeof(type) <= 2, int>::type = 0>
+    type __device__
+    __atomic_fetch_or_simt_(type *ptr, delta val, int memorder) {
+  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
+  type const desired = expected | val;
+  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
+                                          memorder, memorder))
+    ;
+  return expected;
+}
+
+template <class type>
 inline bool __device__ __atomic_test_and_set_simt_(type *ptr, int memorder) {
-    return __atomic_exchange_n_simt_((char*)ptr, (char)1, memorder) == 1;
+  return __atomic_exchange_n_simt_((char *)ptr, (char)1, memorder) == 1;
 }
-template<class type>
+template <class type>
 inline void __device__ __atomic_clear_simt_(type *ptr, int memorder) {
-    return __atomic_store_n_simt_((char*)ptr, (char)0, memorder);
+  return __atomic_store_n_simt_((char *)ptr, (char)0, memorder);
 }
 
-inline constexpr __device__ bool __atomic_always_lock_free_simt_ (size_t size, void *) {
-    return size <= 8;
+inline constexpr __device__ bool __atomic_always_lock_free_simt_(size_t size,
+                                                                 void *) {
+  return size <= 8;
 }
-inline __device__ bool __atomic_is_lock_free_simt_(size_t size, void * ptr) {
-    return __atomic_always_lock_free_simt_(size, ptr);
+inline __device__ bool __atomic_is_lock_free_simt_(size_t size, void *ptr) {
+  return __atomic_always_lock_free_simt_(size, ptr);
 }
 
 /*
@@ -499,7 +794,7 @@ inline __device__ bool __atomic_is_lock_free_simt_(size_t size, void * ptr) {
 */
 
 inline void __device__ __atomic_thread_fence_simt(int memorder) {
-    switch (memorder) {
+  switch (memorder) {
     case __ATOMIC_SEQ_CST: __simt_fence_sc_(); break;
     case __ATOMIC_CONSUME:
     case __ATOMIC_ACQUIRE:
@@ -507,124 +802,184 @@ inline void __device__ __atomic_thread_fence_simt(int memorder) {
     case __ATOMIC_RELEASE: __simt_fence_(); break;
     case __ATOMIC_RELAXED: break;
     default: assert(0);
-    }
+  }
 }
-inline void __device__ __atomic_signal_fence_simt(int memorder) { 
-    __atomic_thread_fence_simt(memorder);
+inline void __device__ __atomic_signal_fence_simt(int memorder) {
+  __atomic_thread_fence_simt(memorder);
 }
 
 /*
     non-volatile
 */
 
-template<class type> type __device__ __atomic_load_n_simt(const type *ptr, int memorder) {
-    return __atomic_load_n_simt_(const_cast<const type*>(ptr), memorder);
-}
-template<class type> void __device__ __atomic_load_simt(const type *ptr, type *ret, int memorder) {
-    __atomic_load_simt_(const_cast<const type*>(ptr), ret, memorder);
-}
-template<class type> void __device__ __atomic_store_n_simt(type *ptr, type val, int memorder) {
-    __atomic_store_n_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> void __device__ __atomic_store_simt(type *ptr, type *val, int memorder) {
-    __atomic_store_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_exchange_n_simt(type *ptr, type val, int memorder) {
-    return __atomic_exchange_n_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> void __device__ __atomic_exchange_simt(type *ptr, type *val, type *ret, int memorder) {
-    __atomic_exchange_simt_(const_cast<type*>(ptr), val, ret, memorder);
-}
-template<class type> bool __device__ __atomic_compare_exchange_n_simt(type *ptr, type *expected, type desired, bool weak, int success_memorder, int failure_memorder) {
-    return __atomic_compare_exchange_n_simt_(const_cast<type*>(ptr), expected, desired, weak, success_memorder, failure_memorder);
-}
-template<class type> bool __device__ __atomic_compare_exchange_simt(type *ptr, type *expected, type *desired, bool weak, int success_memorder, int failure_memorder) {
-    return __atomic_compare_exchange_simt_(const_cast<type*>(ptr), expected, desired, weak, success_memorder, failure_memorder);
-}
-template<class type, class delta> type __device__ __atomic_fetch_add_simt(type *ptr, delta val, int memorder) {
-    return __atomic_fetch_add_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type, class delta> type __device__ __atomic_fetch_sub_simt(type *ptr, delta val, int memorder) {
-    return __atomic_fetch_sub_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_fetch_and_simt(type *ptr, type val, int memorder) {
-    return __atomic_fetch_and_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_fetch_xor_simt(type *ptr, type val, int memorder) {
-    return __atomic_fetch_xor_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_fetch_or_simt(type *ptr, type val, int memorder) {
-    return __atomic_fetch_or_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> bool __device__ __atomic_test_and_set_simt(void *ptr, int memorder) {
-    return __atomic_test_and_set_simt_(const_cast<void*>(ptr), memorder);
-}
-template<class type> void __device__ __atomic_clear_simt(void *ptr, int memorder) {
-    return __atomic_clear_simt_(const_cast<void*>(ptr), memorder);
+template <class type>
+type __device__ __atomic_load_n_simt(const type *ptr, int memorder) {
+  return __atomic_load_n_simt_(const_cast<const type *>(ptr), memorder);
+}
+template <class type>
+void __device__ __atomic_load_simt(const type *ptr, type *ret, int memorder) {
+  __atomic_load_simt_(const_cast<const type *>(ptr), ret, memorder);
+}
+template <class type>
+void __device__ __atomic_store_n_simt(type *ptr, type val, int memorder) {
+  __atomic_store_n_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+void __device__ __atomic_store_simt(type *ptr, type *val, int memorder) {
+  __atomic_store_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_exchange_n_simt(type *ptr, type val, int memorder) {
+  return __atomic_exchange_n_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+void __device__ __atomic_exchange_simt(type *ptr, type *val, type *ret,
+                                       int memorder) {
+  __atomic_exchange_simt_(const_cast<type *>(ptr), val, ret, memorder);
+}
+template <class type>
+bool __device__ __atomic_compare_exchange_n_simt(type *ptr, type *expected,
+                                                 type desired, bool weak,
+                                                 int success_memorder,
+                                                 int failure_memorder) {
+  return __atomic_compare_exchange_n_simt_(const_cast<type *>(ptr), expected,
+                                           desired, weak, success_memorder,
+                                           failure_memorder);
+}
+template <class type>
+bool __device__ __atomic_compare_exchange_simt(type *ptr, type *expected,
+                                               type *desired, bool weak,
+                                               int success_memorder,
+                                               int failure_memorder) {
+  return __atomic_compare_exchange_simt_(const_cast<type *>(ptr), expected,
+                                         desired, weak, success_memorder,
+                                         failure_memorder);
+}
+template <class type, class delta>
+type __device__ __atomic_fetch_add_simt(type *ptr, delta val, int memorder) {
+  return __atomic_fetch_add_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type, class delta>
+type __device__ __atomic_fetch_sub_simt(type *ptr, delta val, int memorder) {
+  return __atomic_fetch_sub_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_fetch_and_simt(type *ptr, type val, int memorder) {
+  return __atomic_fetch_and_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_fetch_xor_simt(type *ptr, type val, int memorder) {
+  return __atomic_fetch_xor_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_fetch_or_simt(type *ptr, type val, int memorder) {
+  return __atomic_fetch_or_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+bool __device__ __atomic_test_and_set_simt(void *ptr, int memorder) {
+  return __atomic_test_and_set_simt_(const_cast<void *>(ptr), memorder);
+}
+template <class type>
+void __device__ __atomic_clear_simt(void *ptr, int memorder) {
+  return __atomic_clear_simt_(const_cast<void *>(ptr), memorder);
 }
 inline bool __device__ __atomic_always_lock_free_simt(size_t size, void *ptr) {
-    return __atomic_always_lock_free_simt_(size, const_cast<void*>(ptr));
+  return __atomic_always_lock_free_simt_(size, const_cast<void *>(ptr));
 }
 inline bool __device__ __atomic_is_lock_free_simt(size_t size, void *ptr) {
-    return __atomic_is_lock_free_simt_(size, const_cast<void*>(ptr));
+  return __atomic_is_lock_free_simt_(size, const_cast<void *>(ptr));
 }
 
 /*
-    volatile 
+    volatile
 */
 
-template<class type> type __device__ __atomic_load_n_simt(const volatile type *ptr, int memorder) {
-    return __atomic_load_n_simt_(const_cast<const type*>(ptr), memorder);
-}
-template<class type> void __device__ __atomic_load_simt(const volatile type *ptr, type *ret, int memorder) {
-    __atomic_load_simt_(const_cast<const type*>(ptr), ret, memorder);
-}
-template<class type> void __device__ __atomic_store_n_simt(volatile type *ptr, type val, int memorder) {
-    __atomic_store_n_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> void __device__ __atomic_store_simt(volatile type *ptr, type *val, int memorder) {
-    __atomic_store_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_exchange_n_simt(volatile type *ptr, type val, int memorder) {
-    return __atomic_exchange_n_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> void __device__ __atomic_exchange_simt(volatile type *ptr, type *val, type *ret, int memorder) {
-    __atomic_exchange_simt_(const_cast<type*>(ptr), val, ret, memorder);
-}
-template<class type> bool __device__ __atomic_compare_exchange_n_simt(volatile type *ptr, type *expected, type desired, bool weak, int success_memorder, int failure_memorder) {
-    return __atomic_compare_exchange_n_simt_(const_cast<type*>(ptr), expected, desired, weak, success_memorder, failure_memorder);
-}
-template<class type> bool __device__ __atomic_compare_exchange_simt(volatile type *ptr, type *expected, type *desired, bool weak, int success_memorder, int failure_memorder) {
-    return __atomic_compare_exchange_simt_(const_cast<type*>(ptr), expected, desired, weak, success_memorder, failure_memorder);
-}
-template<class type, class delta> type __device__ __atomic_fetch_add_simt(volatile type *ptr, delta val, int memorder) {
-    return __atomic_fetch_add_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type, class delta> type __device__ __atomic_fetch_sub_simt(volatile type *ptr, delta val, int memorder) {
-    return __atomic_fetch_sub_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_fetch_and_simt(volatile type *ptr, type val, int memorder) {
-    return __atomic_fetch_and_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_fetch_xor_simt(volatile type *ptr, type val, int memorder) {
-    return __atomic_fetch_xor_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> type __device__ __atomic_fetch_or_simt(volatile type *ptr, type val, int memorder) {
-    return __atomic_fetch_or_simt_(const_cast<type*>(ptr), val, memorder);
-}
-template<class type> bool __device__ __atomic_test_and_set_simt(volatile void *ptr, int memorder) {
-    return __atomic_test_and_set_simt_(const_cast<void*>(ptr), memorder);
-}
-template<class type> void __device__ __atomic_clear_simt(volatile void *ptr, int memorder) {
-    return __atomic_clear_simt_(const_cast<void*>(ptr), memorder);
-}
-
-
-
-} // end namespace Impl
-} // end namespace Kokkos
-
-#endif //_SIMT_DETAILS_CONFIG
+template <class type>
+type __device__ __atomic_load_n_simt(const volatile type *ptr, int memorder) {
+  return __atomic_load_n_simt_(const_cast<const type *>(ptr), memorder);
+}
+template <class type>
+void __device__ __atomic_load_simt(const volatile type *ptr, type *ret,
+                                   int memorder) {
+  __atomic_load_simt_(const_cast<const type *>(ptr), ret, memorder);
+}
+template <class type>
+void __device__ __atomic_store_n_simt(volatile type *ptr, type val,
+                                      int memorder) {
+  __atomic_store_n_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+void __device__ __atomic_store_simt(volatile type *ptr, type *val,
+                                    int memorder) {
+  __atomic_store_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_exchange_n_simt(volatile type *ptr, type val,
+                                         int memorder) {
+  return __atomic_exchange_n_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+void __device__ __atomic_exchange_simt(volatile type *ptr, type *val, type *ret,
+                                       int memorder) {
+  __atomic_exchange_simt_(const_cast<type *>(ptr), val, ret, memorder);
+}
+template <class type>
+bool __device__ __atomic_compare_exchange_n_simt(volatile type *ptr,
+                                                 type *expected, type desired,
+                                                 bool weak,
+                                                 int success_memorder,
+                                                 int failure_memorder) {
+  return __atomic_compare_exchange_n_simt_(const_cast<type *>(ptr), expected,
+                                           desired, weak, success_memorder,
+                                           failure_memorder);
+}
+template <class type>
+bool __device__ __atomic_compare_exchange_simt(volatile type *ptr,
+                                               type *expected, type *desired,
+                                               bool weak, int success_memorder,
+                                               int failure_memorder) {
+  return __atomic_compare_exchange_simt_(const_cast<type *>(ptr), expected,
+                                         desired, weak, success_memorder,
+                                         failure_memorder);
+}
+template <class type, class delta>
+type __device__ __atomic_fetch_add_simt(volatile type *ptr, delta val,
+                                        int memorder) {
+  return __atomic_fetch_add_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type, class delta>
+type __device__ __atomic_fetch_sub_simt(volatile type *ptr, delta val,
+                                        int memorder) {
+  return __atomic_fetch_sub_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_fetch_and_simt(volatile type *ptr, type val,
+                                        int memorder) {
+  return __atomic_fetch_and_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_fetch_xor_simt(volatile type *ptr, type val,
+                                        int memorder) {
+  return __atomic_fetch_xor_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+type __device__ __atomic_fetch_or_simt(volatile type *ptr, type val,
+                                       int memorder) {
+  return __atomic_fetch_or_simt_(const_cast<type *>(ptr), val, memorder);
+}
+template <class type>
+bool __device__ __atomic_test_and_set_simt(volatile void *ptr, int memorder) {
+  return __atomic_test_and_set_simt_(const_cast<void *>(ptr), memorder);
+}
+template <class type>
+void __device__ __atomic_clear_simt(volatile void *ptr, int memorder) {
+  return __atomic_clear_simt_(const_cast<void *>(ptr), memorder);
+}
+
+}  // end namespace Impl
+}  // end namespace Kokkos
+
+#endif  //_SIMT_DETAILS_CONFIG
 
 #ifndef KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
 /*
@@ -653,5 +1008,5 @@ template<class type> void __device__ __atomic_clear_simt(volatile void *ptr, int
 
 #define KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
 
-#endif //__CUDA_ARCH__ && KOKKOS_ENABLE_CUDA_ASM_ATOMICS
-#endif // KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
+#endif  //__CUDA_ARCH__ && KOKKOS_ENABLE_CUDA_ASM_ATOMICS
+#endif  // KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp
index bedb1472275cd640b475b393b4f1c52eadf49d05..d7cd1bab1303a76e08723c07d6ff32cb613c0245 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp
@@ -2,10 +2,10 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
+//                        Kokkos v. 3.0
 //              Copyright (2019) Sandia Corporation
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -65,4 +65,4 @@
 
 #undef KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
 
-#endif // KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
+#endif  // KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp
index 932bde2b37e8835acab7805c79e4ba2e13ee1337..34b681be15cd5ebc15f19c3793b866839875b84b 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,377 +48,447 @@
 #include <Kokkos_Macros.hpp>
 #ifdef KOKKOS_ENABLE_CUDA
 
-#include<iostream>
+#include <iostream>
 #include <Cuda/Kokkos_Cuda_Error.hpp>
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
-template<class DriverType, class LaunchBounds, bool Large>
+template <class DriverType, class LaunchBounds, bool Large>
 struct CudaGetMaxBlockSize;
 
-template<class DriverType, class LaunchBounds>
-int cuda_get_max_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
-  return CudaGetMaxBlockSize<DriverType,LaunchBounds
-          , true
-      >::get_block_size(f,vector_length, shmem_extra_block,shmem_extra_thread);
+template <class DriverType, class LaunchBounds>
+int cuda_get_max_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
+  return CudaGetMaxBlockSize<DriverType, LaunchBounds, true>::get_block_size(
+      f, vector_length, shmem_extra_block, shmem_extra_thread);
 }
 
-template<class FunctorType, class LaunchBounds>
-int cuda_get_max_block_size(const CudaInternal* cuda_instance, const cudaFuncAttributes& attr, const FunctorType& f, const size_t vector_length,
-    const size_t shmem_block, const size_t shmem_thread) {
-
-  const int min_blocks_per_sm = LaunchBounds::minBperSM == 0 ?
-                                     1 : LaunchBounds::minBperSM ;
-  const int max_threads_per_block = LaunchBounds::maxTperB == 0 ?
-                                     cuda_instance->m_maxThreadsPerBlock : LaunchBounds::maxTperB ;
-
-  const int regs_per_thread = attr.numRegs;
-  const int regs_per_sm = cuda_instance->m_regsPerSM;
-  const int shmem_per_sm = cuda_instance->m_shmemPerSM;
+template <class FunctorType, class LaunchBounds>
+int cuda_get_max_block_size(const CudaInternal* cuda_instance,
+                            const cudaFuncAttributes& attr,
+                            const FunctorType& f, const size_t vector_length,
+                            const size_t shmem_block,
+                            const size_t shmem_thread) {
+  const int min_blocks_per_sm =
+      LaunchBounds::minBperSM == 0 ? 1 : LaunchBounds::minBperSM;
+  const int max_threads_per_block = LaunchBounds::maxTperB == 0
+                                        ? cuda_instance->m_maxThreadsPerBlock
+                                        : LaunchBounds::maxTperB;
+
+  const int regs_per_thread     = attr.numRegs;
+  const int regs_per_sm         = cuda_instance->m_regsPerSM;
+  const int shmem_per_sm        = cuda_instance->m_shmemPerSM;
   const int max_shmem_per_block = cuda_instance->m_maxShmemPerBlock;
-  const int max_blocks_per_sm = cuda_instance->m_maxBlocksPerSM;
-  const int max_threads_per_sm = cuda_instance->m_maxThreadsPerSM;
-
-  int block_size = std::min(attr.maxThreadsPerBlock,max_threads_per_block);
-
-  int functor_shmem = FunctorTeamShmemSize< FunctorType  >::value( f , block_size/vector_length );
-  int total_shmem = shmem_block + shmem_thread*(block_size/vector_length) + functor_shmem + attr.sharedSizeBytes;
-  int max_blocks_regs = regs_per_sm/(regs_per_thread*block_size);
-  int max_blocks_shmem = (total_shmem<max_shmem_per_block)?(total_shmem>0?shmem_per_sm/total_shmem:max_blocks_regs):0;
-  int blocks_per_sm = std::min(max_blocks_regs,max_blocks_shmem);
+  const int max_blocks_per_sm   = cuda_instance->m_maxBlocksPerSM;
+  const int max_threads_per_sm  = cuda_instance->m_maxThreadsPerSM;
+
+  int block_size = std::min(attr.maxThreadsPerBlock, max_threads_per_block);
+
+  int functor_shmem =
+      FunctorTeamShmemSize<FunctorType>::value(f, block_size / vector_length);
+  int total_shmem = shmem_block + shmem_thread * (block_size / vector_length) +
+                    functor_shmem + attr.sharedSizeBytes;
+  int max_blocks_regs = regs_per_sm / (regs_per_thread * block_size);
+  int max_blocks_shmem =
+      (total_shmem < max_shmem_per_block)
+          ? (total_shmem > 0 ? shmem_per_sm / total_shmem : max_blocks_regs)
+          : 0;
+  int blocks_per_sm  = std::min(max_blocks_regs, max_blocks_shmem);
   int threads_per_sm = blocks_per_sm * block_size;
-  if(threads_per_sm > max_threads_per_sm) {
-    blocks_per_sm = max_threads_per_sm/block_size;
+  if (threads_per_sm > max_threads_per_sm) {
+    blocks_per_sm  = max_threads_per_sm / block_size;
     threads_per_sm = blocks_per_sm * block_size;
   }
-  int opt_block_size = (blocks_per_sm>=min_blocks_per_sm) ? block_size : 0;
+  int opt_block_size = (blocks_per_sm >= min_blocks_per_sm) ? block_size : 0;
   int opt_threads_per_sm = threads_per_sm;
-  //printf("BlockSizeMax: %i Shmem: %i %i %i %i Regs: %i %i Blocks: %i %i Achieved: %i %i Opt: %i %i\n",block_size,
+  // printf("BlockSizeMax: %i Shmem: %i %i %i %i Regs: %i %i Blocks: %i %i
+  // Achieved: %i %i Opt: %i %i\n",block_size,
   //   shmem_per_sm,max_shmem_per_block,functor_shmem,total_shmem,
   //   regs_per_sm,regs_per_thread,max_blocks_shmem,max_blocks_regs,blocks_per_sm,threads_per_sm,opt_block_size,opt_threads_per_sm);
-  block_size-=32;
-  while ((blocks_per_sm==0) && (block_size>=32)) {
-    functor_shmem = FunctorTeamShmemSize< FunctorType  >::value( f , block_size/vector_length );
-    total_shmem = shmem_block + shmem_thread*(block_size/vector_length) + functor_shmem + attr.sharedSizeBytes;
-    max_blocks_regs = regs_per_sm/(regs_per_thread*block_size);
-    max_blocks_shmem = (total_shmem<max_shmem_per_block)?(total_shmem>0?shmem_per_sm/total_shmem:max_blocks_regs):0;
-    blocks_per_sm = std::min(max_blocks_regs,max_blocks_shmem);
+  block_size -= 32;
+  while ((blocks_per_sm == 0) && (block_size >= 32)) {
+    functor_shmem =
+        FunctorTeamShmemSize<FunctorType>::value(f, block_size / vector_length);
+    total_shmem = shmem_block + shmem_thread * (block_size / vector_length) +
+                  functor_shmem + attr.sharedSizeBytes;
+    max_blocks_regs = regs_per_sm / (regs_per_thread * block_size);
+    max_blocks_shmem =
+        (total_shmem < max_shmem_per_block)
+            ? (total_shmem > 0 ? shmem_per_sm / total_shmem : max_blocks_regs)
+            : 0;
+    blocks_per_sm  = std::min(max_blocks_regs, max_blocks_shmem);
     threads_per_sm = blocks_per_sm * block_size;
-    if(threads_per_sm > max_threads_per_sm) {
-      blocks_per_sm = max_threads_per_sm/block_size;
+    if (threads_per_sm > max_threads_per_sm) {
+      blocks_per_sm  = max_threads_per_sm / block_size;
       threads_per_sm = blocks_per_sm * block_size;
     }
-    if((blocks_per_sm >= min_blocks_per_sm) && (blocks_per_sm <= max_blocks_per_sm)) {
-      if(threads_per_sm>=opt_threads_per_sm) {
-        opt_block_size = block_size;
+    if ((blocks_per_sm >= min_blocks_per_sm) &&
+        (blocks_per_sm <= max_blocks_per_sm)) {
+      if (threads_per_sm >= opt_threads_per_sm) {
+        opt_block_size     = block_size;
         opt_threads_per_sm = threads_per_sm;
       }
     }
-  //printf("BlockSizeMax: %i Shmem: %i %i %i %i Regs: %i %i Blocks: %i %i Achieved: %i %i Opt: %i %i\n",block_size,
-  //   shmem_per_sm,max_shmem_per_block,functor_shmem,total_shmem,
-  //   regs_per_sm,regs_per_thread,max_blocks_shmem,max_blocks_regs,blocks_per_sm,threads_per_sm,opt_block_size,opt_threads_per_sm);
-    block_size-=32;
+    // printf("BlockSizeMax: %i Shmem: %i %i %i %i Regs: %i %i Blocks: %i %i
+    // Achieved: %i %i Opt: %i %i\n",block_size,
+    //   shmem_per_sm,max_shmem_per_block,functor_shmem,total_shmem,
+    //   regs_per_sm,regs_per_thread,max_blocks_shmem,max_blocks_regs,blocks_per_sm,threads_per_sm,opt_block_size,opt_threads_per_sm);
+    block_size -= 32;
   }
   return opt_block_size;
 }
 
-
-template<class DriverType>
-struct CudaGetMaxBlockSize<DriverType,Kokkos::LaunchBounds<>,true> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
+template <class DriverType>
+struct CudaGetMaxBlockSize<DriverType, Kokkos::LaunchBounds<>, true> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
     int numBlocks;
-    int blockSize=1024;
-    int sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                    FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    int blockSize = 1024;
+    int sharedmem =
+        shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+        FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+            f, blockSize / vector_length);
     cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-        &numBlocks,
-        cuda_parallel_launch_constant_memory<DriverType>,
-        blockSize,
+        &numBlocks, cuda_parallel_launch_constant_memory<DriverType>, blockSize,
         sharedmem);
 
-    if(numBlocks>0) return blockSize;
-    while (blockSize>32 && numBlocks==0) {
-      blockSize/=2;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    if (numBlocks > 0) return blockSize;
+    while (blockSize > 32 && numBlocks == 0) {
+      blockSize /= 2;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-          &numBlocks,
-          cuda_parallel_launch_constant_memory<DriverType>,
-          blockSize,
-          sharedmem);
+          &numBlocks, cuda_parallel_launch_constant_memory<DriverType>,
+          blockSize, sharedmem);
     }
-    int blockSizeUpperBound = blockSize*2;
-    while (blockSize<blockSizeUpperBound && numBlocks>0) {
-      blockSize+=32;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    int blockSizeUpperBound = blockSize * 2;
+    while (blockSize < blockSizeUpperBound && numBlocks > 0) {
+      blockSize += 32;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-            &numBlocks,
-            cuda_parallel_launch_constant_memory<DriverType>,
-            blockSize,
-            sharedmem);
+          &numBlocks, cuda_parallel_launch_constant_memory<DriverType>,
+          blockSize, sharedmem);
     }
     return blockSize - 32;
   }
 };
 
-template<class DriverType>
-struct CudaGetMaxBlockSize<DriverType,Kokkos::LaunchBounds<>,false> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
+template <class DriverType>
+struct CudaGetMaxBlockSize<DriverType, Kokkos::LaunchBounds<>, false> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
     int numBlocks;
 
-    unsigned int blockSize=1024;
-    unsigned int sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                    FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    unsigned int blockSize = 1024;
+    unsigned int sharedmem =
+        shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+        FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+            f, blockSize / vector_length);
     cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-        &numBlocks,
-        cuda_parallel_launch_local_memory<DriverType>,
-        blockSize,
+        &numBlocks, cuda_parallel_launch_local_memory<DriverType>, blockSize,
         sharedmem);
 
-    if(numBlocks>0) return blockSize;
-    while (blockSize>32 && numBlocks==0) {
-      blockSize/=2;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    if (numBlocks > 0) return blockSize;
+    while (blockSize > 32 && numBlocks == 0) {
+      blockSize /= 2;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-          &numBlocks,
-          cuda_parallel_launch_local_memory<DriverType>,
-          blockSize,
+          &numBlocks, cuda_parallel_launch_local_memory<DriverType>, blockSize,
           sharedmem);
     }
-    unsigned int blockSizeUpperBound = blockSize*2;
-    while (blockSize<blockSizeUpperBound && numBlocks>0) {
-      blockSize+=32;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    unsigned int blockSizeUpperBound = blockSize * 2;
+    while (blockSize < blockSizeUpperBound && numBlocks > 0) {
+      blockSize += 32;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-            &numBlocks,
-            cuda_parallel_launch_local_memory<DriverType>,
-            blockSize,
-            sharedmem);
+          &numBlocks, cuda_parallel_launch_local_memory<DriverType>, blockSize,
+          sharedmem);
     }
     return blockSize - 32;
   }
 };
 
-template<class DriverType, unsigned int MaxThreadsPerBlock, unsigned int MinBlocksPerSM>
-struct CudaGetMaxBlockSize<DriverType,Kokkos::LaunchBounds<MaxThreadsPerBlock,MinBlocksPerSM>,true> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct CudaGetMaxBlockSize<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>,
+    true> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
     int numBlocks = 0, oldNumBlocks = 0;
-    unsigned int blockSize=MaxThreadsPerBlock;
-    unsigned int sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                    FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    unsigned int blockSize = MaxThreadsPerBlock;
+    unsigned int sharedmem =
+        shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+        FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+            f, blockSize / vector_length);
     cudaOccupancyMaxActiveBlocksPerMultiprocessor(
         &numBlocks,
-        cuda_parallel_launch_constant_memory<DriverType,MaxThreadsPerBlock,MinBlocksPerSM>,
-        blockSize,
-        sharedmem);
+        cuda_parallel_launch_constant_memory<DriverType, MaxThreadsPerBlock,
+                                             MinBlocksPerSM>,
+        blockSize, sharedmem);
 
-    if(static_cast<unsigned int>(numBlocks)>=MinBlocksPerSM) return blockSize;
+    if (static_cast<unsigned int>(numBlocks) >= MinBlocksPerSM)
+      return blockSize;
 
-    while (blockSize>32 && static_cast<unsigned int>(numBlocks)<MinBlocksPerSM) {
-      blockSize/=2;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    while (blockSize > 32 &&
+           static_cast<unsigned int>(numBlocks) < MinBlocksPerSM) {
+      blockSize /= 2;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-          &numBlocks,
-          cuda_parallel_launch_constant_memory<DriverType>,
-          blockSize,
-          sharedmem);
+          &numBlocks, cuda_parallel_launch_constant_memory<DriverType>,
+          blockSize, sharedmem);
     }
-    unsigned int blockSizeUpperBound = (blockSize*2<MaxThreadsPerBlock?blockSize*2:MaxThreadsPerBlock);
-    while (blockSize<blockSizeUpperBound && static_cast<unsigned int>(numBlocks)>MinBlocksPerSM) {
-      blockSize+=32;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    unsigned int blockSizeUpperBound =
+        (blockSize * 2 < MaxThreadsPerBlock ? blockSize * 2
+                                            : MaxThreadsPerBlock);
+    while (blockSize<blockSizeUpperBound&& static_cast<unsigned int>(numBlocks)>
+               MinBlocksPerSM) {
+      blockSize += 32;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
       oldNumBlocks = numBlocks;
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-            &numBlocks,
-            cuda_parallel_launch_constant_memory<DriverType>,
-            blockSize,
-            sharedmem);
+          &numBlocks, cuda_parallel_launch_constant_memory<DriverType>,
+          blockSize, sharedmem);
     }
-    if(static_cast<unsigned int>(oldNumBlocks)>=MinBlocksPerSM) return blockSize - 32;
+    if (static_cast<unsigned int>(oldNumBlocks) >= MinBlocksPerSM)
+      return blockSize - 32;
     return -1;
   }
 };
 
-template<class DriverType, unsigned int MaxThreadsPerBlock, unsigned int MinBlocksPerSM>
-struct CudaGetMaxBlockSize<DriverType,Kokkos::LaunchBounds<MaxThreadsPerBlock,MinBlocksPerSM>,false> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct CudaGetMaxBlockSize<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>,
+    false> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
     int numBlocks = 0, oldNumBlocks = 0;
-    unsigned int blockSize=MaxThreadsPerBlock;
-    int sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                    FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    unsigned int blockSize = MaxThreadsPerBlock;
+    int sharedmem =
+        shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+        FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+            f, blockSize / vector_length);
     cudaOccupancyMaxActiveBlocksPerMultiprocessor(
         &numBlocks,
-        cuda_parallel_launch_local_memory<DriverType,MaxThreadsPerBlock,MinBlocksPerSM>,
-        blockSize,
-        sharedmem);
-    if(static_cast<unsigned int>(numBlocks)>=MinBlocksPerSM) return blockSize;
-
-    while (blockSize>32 && static_cast<unsigned int>(numBlocks)<MinBlocksPerSM) {
-      blockSize/=2;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+        cuda_parallel_launch_local_memory<DriverType, MaxThreadsPerBlock,
+                                          MinBlocksPerSM>,
+        blockSize, sharedmem);
+    if (static_cast<unsigned int>(numBlocks) >= MinBlocksPerSM)
+      return blockSize;
+
+    while (blockSize > 32 &&
+           static_cast<unsigned int>(numBlocks) < MinBlocksPerSM) {
+      blockSize /= 2;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-          &numBlocks,
-          cuda_parallel_launch_local_memory<DriverType>,
-          blockSize,
+          &numBlocks, cuda_parallel_launch_local_memory<DriverType>, blockSize,
           sharedmem);
     }
-    unsigned int blockSizeUpperBound = (blockSize*2<MaxThreadsPerBlock?blockSize*2:MaxThreadsPerBlock);
-    while (blockSize<blockSizeUpperBound && static_cast<unsigned int>(numBlocks)>=MinBlocksPerSM) {
-      blockSize+=32;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    unsigned int blockSizeUpperBound =
+        (blockSize * 2 < MaxThreadsPerBlock ? blockSize * 2
+                                            : MaxThreadsPerBlock);
+    while (blockSize < blockSizeUpperBound &&
+           static_cast<unsigned int>(numBlocks) >= MinBlocksPerSM) {
+      blockSize += 32;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
       oldNumBlocks = numBlocks;
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-            &numBlocks,
-            cuda_parallel_launch_local_memory<DriverType>,
-            blockSize,
-            sharedmem);
+          &numBlocks, cuda_parallel_launch_local_memory<DriverType>, blockSize,
+          sharedmem);
     }
-    if(static_cast<unsigned int>(oldNumBlocks)>=MinBlocksPerSM) return blockSize - 32;
+    if (static_cast<unsigned int>(oldNumBlocks) >= MinBlocksPerSM)
+      return blockSize - 32;
     return -1;
   }
 };
 
-
-template<class DriverType, class LaunchBounds, bool Large>
+template <class DriverType, class LaunchBounds, bool Large>
 struct CudaGetOptBlockSize;
 
-template<class DriverType, class LaunchBounds>
-int cuda_get_opt_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
-  return CudaGetOptBlockSize<DriverType,LaunchBounds,
-      //LaunchBounds::launch_mechanism == Kokkos::Experimental::LaunchDefault ?
-      //            (( CudaTraits::ConstantMemoryUseThreshold < sizeof(DriverType) )?
+template <class DriverType, class LaunchBounds>
+int cuda_get_opt_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
+  return CudaGetOptBlockSize<
+      DriverType, LaunchBounds,
+      // LaunchBounds::launch_mechanism == Kokkos::Experimental::LaunchDefault ?
+      //            (( CudaTraits::ConstantMemoryUseThreshold <
+      //            sizeof(DriverType) )?
       //                   Kokkos::Experimental::CudaLaunchConstantMemory:Kokkos::Experimental::CudaLaunchLocalMemory):
       //             LaunchBounds::launch_mechanism
-      (CudaTraits::ConstantMemoryUseThreshold < sizeof(DriverType))
-      >::get_block_size(f,vector_length,shmem_extra_block,shmem_extra_thread);
+      (CudaTraits::ConstantMemoryUseThreshold <
+       sizeof(DriverType))>::get_block_size(f, vector_length, shmem_extra_block,
+                                            shmem_extra_thread);
 }
 
-template<class FunctorType, class LaunchBounds>
-int cuda_get_opt_block_size(const CudaInternal* cuda_instance, const cudaFuncAttributes& attr, const FunctorType& f, const size_t vector_length,
-    const size_t shmem_block, const size_t shmem_thread) {
-
-  const int min_blocks_per_sm = LaunchBounds::minBperSM == 0 ?
-                                     1 : LaunchBounds::minBperSM ;
-  const int max_threads_per_block = LaunchBounds::maxTperB == 0 ?
-                                     cuda_instance->m_maxThreadsPerBlock : LaunchBounds::maxTperB ;
-
-  const int regs_per_thread = attr.numRegs;
-  const int regs_per_sm = cuda_instance->m_regsPerSM;
-  const int shmem_per_sm = cuda_instance->m_shmemPerSM;
+template <class FunctorType, class LaunchBounds>
+int cuda_get_opt_block_size(const CudaInternal* cuda_instance,
+                            const cudaFuncAttributes& attr,
+                            const FunctorType& f, const size_t vector_length,
+                            const size_t shmem_block,
+                            const size_t shmem_thread) {
+  const int min_blocks_per_sm =
+      LaunchBounds::minBperSM == 0 ? 1 : LaunchBounds::minBperSM;
+  const int max_threads_per_block = LaunchBounds::maxTperB == 0
+                                        ? cuda_instance->m_maxThreadsPerBlock
+                                        : LaunchBounds::maxTperB;
+
+  const int regs_per_thread     = attr.numRegs;
+  const int regs_per_sm         = cuda_instance->m_regsPerSM;
+  const int shmem_per_sm        = cuda_instance->m_shmemPerSM;
   const int max_shmem_per_block = cuda_instance->m_maxShmemPerBlock;
-  const int max_blocks_per_sm = cuda_instance->m_maxBlocksPerSM;
-  const int max_threads_per_sm = cuda_instance->m_maxThreadsPerSM;
-
-  int block_size = std::min(attr.maxThreadsPerBlock,max_threads_per_block);
-
-  int functor_shmem = FunctorTeamShmemSize< FunctorType  >::value( f , block_size/vector_length );
-  int total_shmem = shmem_block + shmem_thread*(block_size/vector_length) + functor_shmem + attr.sharedSizeBytes;
-  int max_blocks_regs = regs_per_sm/(regs_per_thread*block_size);
-  int max_blocks_shmem = (total_shmem<max_shmem_per_block)?(total_shmem>0?shmem_per_sm/total_shmem:max_blocks_regs):0;
-  int blocks_per_sm = std::min(max_blocks_regs,max_blocks_shmem);
+  const int max_blocks_per_sm   = cuda_instance->m_maxBlocksPerSM;
+  const int max_threads_per_sm  = cuda_instance->m_maxThreadsPerSM;
+
+  int block_size = std::min(attr.maxThreadsPerBlock, max_threads_per_block);
+
+  int functor_shmem =
+      FunctorTeamShmemSize<FunctorType>::value(f, block_size / vector_length);
+  int total_shmem = shmem_block + shmem_thread * (block_size / vector_length) +
+                    functor_shmem + attr.sharedSizeBytes;
+  int max_blocks_regs = regs_per_sm / (regs_per_thread * block_size);
+  int max_blocks_shmem =
+      (total_shmem < max_shmem_per_block)
+          ? (total_shmem > 0 ? shmem_per_sm / total_shmem : max_blocks_regs)
+          : 0;
+  int blocks_per_sm  = std::min(max_blocks_regs, max_blocks_shmem);
   int threads_per_sm = blocks_per_sm * block_size;
-  if(threads_per_sm > max_threads_per_sm) {
-    blocks_per_sm = max_threads_per_sm/block_size;
+  if (threads_per_sm > max_threads_per_sm) {
+    blocks_per_sm  = max_threads_per_sm / block_size;
     threads_per_sm = blocks_per_sm * block_size;
   }
-  int opt_block_size = (blocks_per_sm>=min_blocks_per_sm) ? block_size : 0;
+  int opt_block_size = (blocks_per_sm >= min_blocks_per_sm) ? block_size : 0;
   int opt_threads_per_sm = threads_per_sm;
 
-  block_size-=32;
-  while ((block_size>=32)) {
-    functor_shmem = FunctorTeamShmemSize< FunctorType  >::value( f , block_size/vector_length );
-    total_shmem = shmem_block + shmem_thread*(block_size/vector_length) + functor_shmem + attr.sharedSizeBytes;
-    max_blocks_regs = regs_per_sm/(regs_per_thread*block_size);
-    max_blocks_shmem = (total_shmem<max_shmem_per_block)?(total_shmem>0?shmem_per_sm/total_shmem:max_blocks_regs):0;
-    blocks_per_sm = std::min(max_blocks_regs,max_blocks_shmem);
+  block_size -= 32;
+  while ((block_size >= 32)) {
+    functor_shmem =
+        FunctorTeamShmemSize<FunctorType>::value(f, block_size / vector_length);
+    total_shmem = shmem_block + shmem_thread * (block_size / vector_length) +
+                  functor_shmem + attr.sharedSizeBytes;
+    max_blocks_regs = regs_per_sm / (regs_per_thread * block_size);
+    max_blocks_shmem =
+        (total_shmem < max_shmem_per_block)
+            ? (total_shmem > 0 ? shmem_per_sm / total_shmem : max_blocks_regs)
+            : 0;
+    blocks_per_sm  = std::min(max_blocks_regs, max_blocks_shmem);
     threads_per_sm = blocks_per_sm * block_size;
-    if(threads_per_sm > max_threads_per_sm) {
-      blocks_per_sm = max_threads_per_sm/block_size;
+    if (threads_per_sm > max_threads_per_sm) {
+      blocks_per_sm  = max_threads_per_sm / block_size;
       threads_per_sm = blocks_per_sm * block_size;
     }
-    if((blocks_per_sm >= min_blocks_per_sm) && (blocks_per_sm <= max_blocks_per_sm)) {
-      if(threads_per_sm>=opt_threads_per_sm) {
-        opt_block_size = block_size;
+    if ((blocks_per_sm >= min_blocks_per_sm) &&
+        (blocks_per_sm <= max_blocks_per_sm)) {
+      if (threads_per_sm >= opt_threads_per_sm) {
+        opt_block_size     = block_size;
         opt_threads_per_sm = threads_per_sm;
       }
     }
-    block_size-=32;
+    block_size -= 32;
   }
   return opt_block_size;
 }
 
-template<class DriverType>
-struct CudaGetOptBlockSize<DriverType,Kokkos::LaunchBounds<0,0>,true> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
-    int blockSize=16;
+template <class DriverType>
+struct CudaGetOptBlockSize<DriverType, Kokkos::LaunchBounds<0, 0>, true> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
+    int blockSize = 16;
     int numBlocks;
     int sharedmem;
-    int maxOccupancy=0;
-    int bestBlockSize=0;
-
-    while(blockSize<1024) {
-      blockSize*=2;
-
-      //calculate the occupancy with that optBlockSize and check whether its larger than the largest one found so far
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    int maxOccupancy  = 0;
+    int bestBlockSize = 0;
+
+    while (blockSize < 1024) {
+      blockSize *= 2;
+
+      // calculate the occupancy with that optBlockSize and check whether its
+      // larger than the largest one found so far
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-              &numBlocks,
-              cuda_parallel_launch_constant_memory<DriverType>,
-              blockSize,
-              sharedmem);
-      if(maxOccupancy < numBlocks*blockSize) {
-         maxOccupancy = numBlocks*blockSize;
-         bestBlockSize = blockSize;
+          &numBlocks, cuda_parallel_launch_constant_memory<DriverType>,
+          blockSize, sharedmem);
+      if (maxOccupancy < numBlocks * blockSize) {
+        maxOccupancy  = numBlocks * blockSize;
+        bestBlockSize = blockSize;
       }
     }
     return bestBlockSize;
   }
 };
 
-template<class DriverType>
-struct CudaGetOptBlockSize<DriverType,Kokkos::LaunchBounds<0,0>,false> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
-    int blockSize=16;
+template <class DriverType>
+struct CudaGetOptBlockSize<DriverType, Kokkos::LaunchBounds<0, 0>, false> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
+    int blockSize = 16;
     int numBlocks;
     int sharedmem;
-    int maxOccupancy=0;
-    int bestBlockSize=0;
+    int maxOccupancy  = 0;
+    int bestBlockSize = 0;
 
-    while(blockSize<1024) {
-      blockSize*=2;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    while (blockSize < 1024) {
+      blockSize *= 2;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-              &numBlocks,
-              cuda_parallel_launch_local_memory<DriverType>,
-              blockSize,
-              sharedmem);
+          &numBlocks, cuda_parallel_launch_local_memory<DriverType>, blockSize,
+          sharedmem);
 
-      if(maxOccupancy < numBlocks*blockSize) {
-        maxOccupancy = numBlocks*blockSize;
+      if (maxOccupancy < numBlocks * blockSize) {
+        maxOccupancy  = numBlocks * blockSize;
         bestBlockSize = blockSize;
       }
     }
@@ -425,77 +496,96 @@ struct CudaGetOptBlockSize<DriverType,Kokkos::LaunchBounds<0,0>,false> {
   }
 };
 
-template<class DriverType, unsigned int MaxThreadsPerBlock, unsigned int MinBlocksPerSM>
-struct CudaGetOptBlockSize<DriverType,Kokkos::LaunchBounds< MaxThreadsPerBlock, MinBlocksPerSM>,true> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
-    int blockSize=16;
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct CudaGetOptBlockSize<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>,
+    true> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
+    int blockSize = 16;
     int numBlocks;
     int sharedmem;
-    int maxOccupancy=0;
-    int bestBlockSize=0;
-    int max_threads_per_block = std::min(MaxThreadsPerBlock,cuda_internal_maximum_warp_count()*CudaTraits::WarpSize);
-
-    while(blockSize < max_threads_per_block ) {
-      blockSize*=2;
-
-      //calculate the occupancy with that optBlockSize and check whether its larger than the largest one found so far
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    int maxOccupancy  = 0;
+    int bestBlockSize = 0;
+    int max_threads_per_block =
+        std::min(MaxThreadsPerBlock,
+                 cuda_internal_maximum_warp_count() * CudaTraits::WarpSize);
+
+    while (blockSize < max_threads_per_block) {
+      blockSize *= 2;
+
+      // calculate the occupancy with that optBlockSize and check whether its
+      // larger than the largest one found so far
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-              &numBlocks,
-              cuda_parallel_launch_constant_memory<DriverType,MaxThreadsPerBlock,MinBlocksPerSM>,
-              blockSize,
-              sharedmem);
-      if(numBlocks >= int(MinBlocksPerSM) && blockSize<=int(MaxThreadsPerBlock)) {
-        if(maxOccupancy < numBlocks*blockSize) {
-           maxOccupancy = numBlocks*blockSize;
-           bestBlockSize = blockSize;
+          &numBlocks,
+          cuda_parallel_launch_constant_memory<DriverType, MaxThreadsPerBlock,
+                                               MinBlocksPerSM>,
+          blockSize, sharedmem);
+      if (numBlocks >= int(MinBlocksPerSM) &&
+          blockSize <= int(MaxThreadsPerBlock)) {
+        if (maxOccupancy < numBlocks * blockSize) {
+          maxOccupancy  = numBlocks * blockSize;
+          bestBlockSize = blockSize;
         }
       }
     }
-    if(maxOccupancy > 0)
-      return bestBlockSize;
+    if (maxOccupancy > 0) return bestBlockSize;
     return -1;
   }
 };
 
-template<class DriverType, unsigned int MaxThreadsPerBlock, unsigned int MinBlocksPerSM>
-struct CudaGetOptBlockSize<DriverType,Kokkos::LaunchBounds< MaxThreadsPerBlock, MinBlocksPerSM >,false> {
-  static int get_block_size(const typename DriverType::functor_type & f, const size_t vector_length,
-                            const size_t shmem_extra_block, const size_t shmem_extra_thread) {
-    int blockSize=16;
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct CudaGetOptBlockSize<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>,
+    false> {
+  static int get_block_size(const typename DriverType::functor_type& f,
+                            const size_t vector_length,
+                            const size_t shmem_extra_block,
+                            const size_t shmem_extra_thread) {
+    int blockSize = 16;
     int numBlocks;
     int sharedmem;
-    int maxOccupancy=0;
-    int bestBlockSize=0;
-    int max_threads_per_block = std::min(MaxThreadsPerBlock,cuda_internal_maximum_warp_count()*CudaTraits::WarpSize);
-
-    while(blockSize < max_threads_per_block ) {
-      blockSize*=2;
-      sharedmem = shmem_extra_block + shmem_extra_thread*(blockSize/vector_length) +
-                  FunctorTeamShmemSize< typename DriverType::functor_type  >::value( f , blockSize/vector_length );
+    int maxOccupancy  = 0;
+    int bestBlockSize = 0;
+    int max_threads_per_block =
+        std::min(MaxThreadsPerBlock,
+                 cuda_internal_maximum_warp_count() * CudaTraits::WarpSize);
+
+    while (blockSize < max_threads_per_block) {
+      blockSize *= 2;
+      sharedmem =
+          shmem_extra_block + shmem_extra_thread * (blockSize / vector_length) +
+          FunctorTeamShmemSize<typename DriverType::functor_type>::value(
+              f, blockSize / vector_length);
 
       cudaOccupancyMaxActiveBlocksPerMultiprocessor(
-              &numBlocks,
-              cuda_parallel_launch_local_memory<DriverType,MaxThreadsPerBlock,MinBlocksPerSM>,
-              blockSize,
-              sharedmem);
-      if(numBlocks >= int(MinBlocksPerSM) && blockSize<=int(MaxThreadsPerBlock)) {
-        if(maxOccupancy < numBlocks*blockSize) {
-          maxOccupancy = numBlocks*blockSize;
+          &numBlocks,
+          cuda_parallel_launch_local_memory<DriverType, MaxThreadsPerBlock,
+                                            MinBlocksPerSM>,
+          blockSize, sharedmem);
+      if (numBlocks >= int(MinBlocksPerSM) &&
+          blockSize <= int(MaxThreadsPerBlock)) {
+        if (maxOccupancy < numBlocks * blockSize) {
+          maxOccupancy  = numBlocks * blockSize;
           bestBlockSize = blockSize;
         }
       }
     }
-    if(maxOccupancy > 0)
-      return bestBlockSize;
+    if (maxOccupancy > 0) return bestBlockSize;
     return -1;
   }
 };
 
-}} // namespace Kokkos::Impl
-
-#endif // KOKKOS_ENABLE_CUDA
-#endif /* #ifndef KOKKOS_CUDA_INTERNAL_HPP */
+}  // namespace Impl
+}  // namespace Kokkos
 
+#endif  // KOKKOS_ENABLE_CUDA
+#endif  /* #ifndef KOKKOS_CUDA_INTERNAL_HPP */
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Error.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Error.hpp
index 55c7c782fe3b66f94d446e2bed6c10881f1cf5b5..3b674bbb30d13f1a2e68b6ed4749a73edcf80d40 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Error.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Error.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,22 +48,82 @@
 #include <Kokkos_Macros.hpp>
 #ifdef KOKKOS_ENABLE_CUDA
 
-namespace Kokkos { namespace Impl {
+#include <impl/Kokkos_Error.hpp>
+
+#include <iostream>
+
+namespace Kokkos {
+namespace Impl {
 
 void cuda_device_synchronize();
 
-void cuda_internal_error_throw( cudaError e , const char * name, const char * file = NULL, const int line = 0 );
+void cuda_internal_error_throw(cudaError e, const char* name,
+                               const char* file = NULL, const int line = 0);
 
-inline void cuda_internal_safe_call( cudaError e , const char * name, const char * file = NULL, const int line = 0)
-{
-  if ( cudaSuccess != e ) { cuda_internal_error_throw( e , name, file, line ); }
+inline void cuda_internal_safe_call(cudaError e, const char* name,
+                                    const char* file = NULL,
+                                    const int line   = 0) {
+  if (cudaSuccess != e) {
+    cuda_internal_error_throw(e, name, file, line);
+  }
 }
 
-#define CUDA_SAFE_CALL( call )  \
-	Kokkos::Impl::cuda_internal_safe_call( call , #call, __FILE__, __LINE__ )
+#define CUDA_SAFE_CALL(call) \
+  Kokkos::Impl::cuda_internal_safe_call(call, #call, __FILE__, __LINE__)
+
+}  // namespace Impl
+
+namespace Experimental {
+
+class CudaRawMemoryAllocationFailure : public RawMemoryAllocationFailure {
+ private:
+  using base_t = RawMemoryAllocationFailure;
+
+  cudaError_t m_error_code = cudaSuccess;
+
+  static FailureMode get_failure_mode(cudaError_t error_code) {
+    switch (error_code) {
+      case cudaErrorMemoryAllocation: return FailureMode::OutOfMemoryError;
+      case cudaErrorInvalidValue: return FailureMode::InvalidAllocationSize;
+      // TODO handle cudaErrorNotSupported for cudaMallocManaged
+      default: return FailureMode::Unknown;
+    }
+  }
+
+ public:
+  // using base_t::base_t;
+  // would trigger
+  //
+  // error: cannot determine the exception specification of the default
+  // constructor due to a circular dependency
+  //
+  // using NVCC 9.1 and gcc 7.4
+  CudaRawMemoryAllocationFailure(
+      size_t arg_attempted_size, size_t arg_attempted_alignment,
+      FailureMode arg_failure_mode = FailureMode::OutOfMemoryError,
+      AllocationMechanism arg_mechanism =
+          AllocationMechanism::StdMalloc) noexcept
+      : base_t(arg_attempted_size, arg_attempted_alignment, arg_failure_mode,
+               arg_mechanism) {}
+
+  CudaRawMemoryAllocationFailure(size_t arg_attempted_size,
+                                 cudaError_t arg_error_code,
+                                 AllocationMechanism arg_mechanism) noexcept
+      : base_t(arg_attempted_size, /* CudaSpace doesn't handle alignment? */ 1,
+               get_failure_mode(arg_error_code), arg_mechanism),
+        m_error_code(arg_error_code) {}
+
+  void append_additional_error_information(std::ostream& o) const override {
+    if (m_error_code != cudaSuccess) {
+      o << "  The Cuda allocation returned the error code \"\""
+        << cudaGetErrorName(m_error_code) << "\".";
+    }
+  }
+};
 
-}} // namespace Kokkos::Impl
+}  // end namespace Experimental
 
-#endif //KOKKOS_ENABLE_CUDA
-#endif //KOKKOS_CUDA_ERROR_HPP
+}  // namespace Kokkos
 
+#endif  // KOKKOS_ENABLE_CUDA
+#endif  // KOKKOS_CUDA_ERROR_HPP
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.cpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.cpp
index 0ca9e3c16050ed300f5240406502d3b93f716308..b3c7edf67cdb1662399285893cd1e01e188f7556 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.cpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -66,10 +67,34 @@
 #include <sstream>
 #include <string>
 
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+namespace Kokkos {
+namespace Impl {
+
+bool CudaInternal::kokkos_impl_cuda_use_serial_execution_v = false;
+
+void CudaInternal::cuda_set_serial_execution(bool val) {
+  CudaInternal::kokkos_impl_cuda_use_serial_execution_v = val;
+}
+bool CudaInternal::cuda_use_serial_execution() {
+  return CudaInternal::kokkos_impl_cuda_use_serial_execution_v;
+}
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+void kokkos_impl_cuda_set_serial_execution(bool val) {
+  Kokkos::Impl::CudaInternal::cuda_set_serial_execution(val);
+}
+bool kokkos_impl_cuda_use_serial_execution() {
+  return Kokkos::Impl::CudaInternal::cuda_use_serial_execution();
+}
+#endif
+
 #ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
 
-__device__ __constant__
-unsigned long kokkos_impl_cuda_constant_memory_buffer[ Kokkos::Impl::CudaTraits::ConstantMemoryUsage / sizeof(unsigned long) ] ;
+__device__ __constant__ unsigned long kokkos_impl_cuda_constant_memory_buffer
+    [Kokkos::Impl::CudaTraits::ConstantMemoryUsage / sizeof(unsigned long)];
 
 #endif
 
@@ -80,32 +105,28 @@ namespace Impl {
 
 namespace {
 
-__global__
-void query_cuda_kernel_arch( int * d_arch )
-{
-#if defined( __CUDA_ARCH__ )
-  *d_arch = __CUDA_ARCH__ ;
+__global__ void query_cuda_kernel_arch(int *d_arch) {
+#if defined(__CUDA_ARCH__)
+  *d_arch = __CUDA_ARCH__;
 #else
-  *d_arch = 0 ;
+  *d_arch = 0;
 #endif
 }
 
 /** Query what compute capability is actually launched to the device: */
-int cuda_kernel_arch()
-{
-  int * d_arch = 0 ;
-  cudaMalloc( (void **) & d_arch , sizeof(int) );
-  query_cuda_kernel_arch<<<1,1>>>( d_arch );
-  int arch = 0 ;
-  cudaMemcpy( & arch , d_arch , sizeof(int) , cudaMemcpyDefault );
-  cudaFree( d_arch );
-  return arch ;
+int cuda_kernel_arch() {
+  int *d_arch = 0;
+  cudaMalloc((void **)&d_arch, sizeof(int));
+  query_cuda_kernel_arch<<<1, 1>>>(d_arch);
+  int arch = 0;
+  cudaMemcpy(&arch, d_arch, sizeof(int), cudaMemcpyDefault);
+  cudaFree(d_arch);
+  return arch;
 }
 
 #ifdef KOKKOS_ENABLE_CUDA_UVM
-bool cuda_launch_blocking()
-{
-  const char * env = getenv("CUDA_LAUNCH_BLOCKING");
+bool cuda_launch_blocking() {
+  const char *env = getenv("CUDA_LAUNCH_BLOCKING");
 
   if (env == 0) return false;
 
@@ -113,21 +134,19 @@ bool cuda_launch_blocking()
 }
 #endif
 
-}
+}  // namespace
 
-void cuda_device_synchronize()
-{
-  CUDA_SAFE_CALL( cudaDeviceSynchronize() );
-}
+void cuda_device_synchronize() { CUDA_SAFE_CALL(cudaDeviceSynchronize()); }
 
-void cuda_internal_error_throw( cudaError e , const char * name, const char * file, const int line )
-{
-  std::ostringstream out ;
-  out << name << " error( " << cudaGetErrorName(e) << "): " << cudaGetErrorString(e);
+void cuda_internal_error_throw(cudaError e, const char *name, const char *file,
+                               const int line) {
+  std::ostringstream out;
+  out << name << " error( " << cudaGetErrorName(e)
+      << "): " << cudaGetErrorString(e);
   if (file) {
     out << " " << file << ":" << line;
   }
-  throw_runtime_exception( out.str() );
+  throw_runtime_exception(out.str());
 }
 
 //----------------------------------------------------------------------------
@@ -180,231 +199,220 @@ void cuda_internal_error_throw( cudaError e , const char * name, const char * fi
 //   int maxThreadsPerMultiProcessor;
 // };
 
-
 namespace {
 
-
-
 class CudaInternalDevices {
-public:
+ public:
   enum { MAXIMUM_DEVICE_COUNT = 64 };
-  struct cudaDeviceProp  m_cudaProp[ MAXIMUM_DEVICE_COUNT ] ;
-  int                    m_cudaDevCount ;
+  struct cudaDeviceProp m_cudaProp[MAXIMUM_DEVICE_COUNT];
+  int m_cudaDevCount;
 
   CudaInternalDevices();
 
-  static const CudaInternalDevices & singleton();
+  static const CudaInternalDevices &singleton();
 };
 
-CudaInternalDevices::CudaInternalDevices()
-{
+CudaInternalDevices::CudaInternalDevices() {
   // See 'cudaSetDeviceFlags' for host-device thread interaction
   // Section 4.4.2.6 of the CUDA Toolkit Reference Manual
 
-  CUDA_SAFE_CALL (cudaGetDeviceCount( & m_cudaDevCount ) );
+  CUDA_SAFE_CALL(cudaGetDeviceCount(&m_cudaDevCount));
 
-  if(m_cudaDevCount > MAXIMUM_DEVICE_COUNT) {
-    Kokkos::abort("Sorry, you have more GPUs per node than we thought anybody would ever have. Please report this to github.com/kokkos/kokkos.");
+  if (m_cudaDevCount > MAXIMUM_DEVICE_COUNT) {
+    Kokkos::abort(
+        "Sorry, you have more GPUs per node than we thought anybody would ever "
+        "have. Please report this to github.com/kokkos/kokkos.");
   }
-  for ( int i = 0 ; i < m_cudaDevCount ; ++i ) {
-    CUDA_SAFE_CALL( cudaGetDeviceProperties( m_cudaProp + i , i ) );
+  for (int i = 0; i < m_cudaDevCount; ++i) {
+    CUDA_SAFE_CALL(cudaGetDeviceProperties(m_cudaProp + i, i));
   }
 }
 
-const CudaInternalDevices & CudaInternalDevices::singleton()
-{
-  static CudaInternalDevices self ; return self ;
-}
-
+const CudaInternalDevices &CudaInternalDevices::singleton() {
+  static CudaInternalDevices self;
+  return self;
 }
 
+}  // namespace
 
 int CudaInternal::was_initialized = 0;
-int CudaInternal::was_finalized = 0;
+int CudaInternal::was_finalized   = 0;
 //----------------------------------------------------------------------------
 
+void CudaInternal::print_configuration(std::ostream &s) const {
+  const CudaInternalDevices &dev_info = CudaInternalDevices::singleton();
 
-void CudaInternal::print_configuration( std::ostream & s ) const
-{
-  const CudaInternalDevices & dev_info = CudaInternalDevices::singleton();
-
-#if defined( KOKKOS_ENABLE_CUDA )
-    s << "macro  KOKKOS_ENABLE_CUDA      : defined" << std::endl ;
+#if defined(KOKKOS_ENABLE_CUDA)
+  s << "macro  KOKKOS_ENABLE_CUDA      : defined" << std::endl;
 #endif
-#if defined( CUDA_VERSION )
-    s << "macro  CUDA_VERSION          = " << CUDA_VERSION
-      << " = version " << CUDA_VERSION / 1000
-      << "." << ( CUDA_VERSION % 1000 ) / 10
-      << std::endl ;
+#if defined(CUDA_VERSION)
+  s << "macro  CUDA_VERSION          = " << CUDA_VERSION << " = version "
+    << CUDA_VERSION / 1000 << "." << (CUDA_VERSION % 1000) / 10 << std::endl;
 #endif
 
-  for ( int i = 0 ; i < dev_info.m_cudaDevCount ; ++i ) {
-    s << "Kokkos::Cuda[ " << i << " ] "
-      << dev_info.m_cudaProp[i].name
-      << " capability " << dev_info.m_cudaProp[i].major << "." << dev_info.m_cudaProp[i].minor
-      << ", Total Global Memory: " << human_memory_size(dev_info.m_cudaProp[i].totalGlobalMem)
-      << ", Shared Memory per Block: " << human_memory_size(dev_info.m_cudaProp[i].sharedMemPerBlock);
-    if ( m_cudaDev == i ) s << " : Selected" ;
-    s << std::endl ;
+  for (int i = 0; i < dev_info.m_cudaDevCount; ++i) {
+    s << "Kokkos::Cuda[ " << i << " ] " << dev_info.m_cudaProp[i].name
+      << " capability " << dev_info.m_cudaProp[i].major << "."
+      << dev_info.m_cudaProp[i].minor << ", Total Global Memory: "
+      << human_memory_size(dev_info.m_cudaProp[i].totalGlobalMem)
+      << ", Shared Memory per Block: "
+      << human_memory_size(dev_info.m_cudaProp[i].sharedMemPerBlock);
+    if (m_cudaDev == i) s << " : Selected";
+    s << std::endl;
   }
 }
 
 //----------------------------------------------------------------------------
 
-CudaInternal::~CudaInternal()
-{
-  if ( m_stream ||
-       m_scratchSpace ||
-       m_scratchFlags ||
-       m_scratchUnified ||
-       m_scratchConcurrentBitset ) {
+CudaInternal::~CudaInternal() {
+  if (m_stream || m_scratchSpace || m_scratchFlags || m_scratchUnified ||
+      m_scratchConcurrentBitset) {
     std::cerr << "Kokkos::Cuda ERROR: Failed to call Kokkos::Cuda::finalize()"
-              << std::endl ;
+              << std::endl;
     std::cerr.flush();
   }
 
-  m_cudaDev                 = -1 ;
-  m_cudaArch                = -1 ;
-  m_multiProcCount          = 0 ;
-  m_maxWarpCount            = 0 ;
-  m_maxBlock                = 0 ;
-  m_maxSharedWords          = 0 ;
-  m_maxConcurrency          = 0 ;
-  m_scratchSpaceCount       = 0 ;
-  m_scratchFlagsCount       = 0 ;
-  m_scratchUnifiedCount     = 0 ;
-  m_scratchUnifiedSupported = 0 ;
-  m_streamCount             = 0 ;
-  m_scratchSpace            = 0 ;
-  m_scratchFlags            = 0 ;
-  m_scratchUnified          = 0 ;
-  m_scratchConcurrentBitset = 0 ;
-  m_stream                  = 0 ;
-}
-
-int CudaInternal::verify_is_initialized( const char * const label ) const
-{
-  if ( m_cudaDev < 0 ) {
-    std::cerr << "Kokkos::Cuda::" << label << " : ERROR device not initialized" << std::endl ;
-  }
-  return 0 <= m_cudaDev ;
+  m_cudaDev                 = -1;
+  m_cudaArch                = -1;
+  m_multiProcCount          = 0;
+  m_maxWarpCount            = 0;
+  m_maxBlock                = 0;
+  m_maxSharedWords          = 0;
+  m_maxConcurrency          = 0;
+  m_scratchSpaceCount       = 0;
+  m_scratchFlagsCount       = 0;
+  m_scratchUnifiedCount     = 0;
+  m_scratchUnifiedSupported = 0;
+  m_streamCount             = 0;
+  m_scratchSpace            = 0;
+  m_scratchFlags            = 0;
+  m_scratchUnified          = 0;
+  m_scratchConcurrentBitset = 0;
+  m_stream                  = 0;
 }
 
-CudaInternal & CudaInternal::singleton()
-{
-  static CudaInternal self ;
-  return self ;
+int CudaInternal::verify_is_initialized(const char *const label) const {
+  if (m_cudaDev < 0) {
+    std::cerr << "Kokkos::Cuda::" << label << " : ERROR device not initialized"
+              << std::endl;
+  }
+  return 0 <= m_cudaDev;
 }
-void CudaInternal::fence() const {
-  cudaStreamSynchronize(m_stream);
+
+CudaInternal &CudaInternal::singleton() {
+  static CudaInternal self;
+  return self;
 }
+void CudaInternal::fence() const { cudaStreamSynchronize(m_stream); }
 
-void CudaInternal::initialize( int cuda_device_id , cudaStream_t stream )
-{
-  if ( was_finalized ) Kokkos::abort("Calling Cuda::initialize after Cuda::finalize is illegal\n");
+void CudaInternal::initialize(int cuda_device_id, cudaStream_t stream) {
+  if (was_finalized)
+    Kokkos::abort("Calling Cuda::initialize after Cuda::finalize is illegal\n");
   was_initialized = 1;
-  if ( is_initialized() ) return;
+  if (is_initialized()) return;
 
   enum { WordSize = sizeof(size_type) };
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  if ( ! HostSpace::execution_space::is_initialized() ) {
+  if (!HostSpace::execution_space::is_initialized()) {
 #else
-  if ( ! HostSpace::execution_space::impl_is_initialized() ) {
+  if (!HostSpace::execution_space::impl_is_initialized()) {
 #endif
-    const std::string msg("Cuda::initialize ERROR : HostSpace::execution_space is not initialized");
-    throw_runtime_exception( msg );
+    const std::string msg(
+        "Cuda::initialize ERROR : HostSpace::execution_space is not "
+        "initialized");
+    throw_runtime_exception(msg);
   }
 
-  const CudaInternalDevices & dev_info = CudaInternalDevices::singleton();
+  const CudaInternalDevices &dev_info = CudaInternalDevices::singleton();
 
-  const bool ok_init = 0 == m_scratchSpace || 0 == m_scratchFlags ;
+  const bool ok_init = 0 == m_scratchSpace || 0 == m_scratchFlags;
 
-  const bool ok_id   = 0 <= cuda_device_id &&
-                            cuda_device_id < dev_info.m_cudaDevCount ;
+  const bool ok_id =
+      0 <= cuda_device_id && cuda_device_id < dev_info.m_cudaDevCount;
 
   // Need device capability 3.0 or better
 
-  const bool ok_dev = ok_id &&
-    ( 3 <= dev_info.m_cudaProp[ cuda_device_id ].major &&
-      0 <= dev_info.m_cudaProp[ cuda_device_id ].minor );
-
-  if ( ok_init && ok_dev ) {
+  const bool ok_dev =
+      ok_id && (3 <= dev_info.m_cudaProp[cuda_device_id].major &&
+                0 <= dev_info.m_cudaProp[cuda_device_id].minor);
 
-    const struct cudaDeviceProp & cudaProp =
-      dev_info.m_cudaProp[ cuda_device_id ];
+  if (ok_init && ok_dev) {
+    const struct cudaDeviceProp &cudaProp = dev_info.m_cudaProp[cuda_device_id];
 
-    m_cudaDev = cuda_device_id ;
+    m_cudaDev = cuda_device_id;
 
-    CUDA_SAFE_CALL( cudaSetDevice( m_cudaDev ) );
+    CUDA_SAFE_CALL(cudaSetDevice(m_cudaDev));
     Kokkos::Impl::cuda_device_synchronize();
 
     // Query what compute capability architecture a kernel executes:
     m_cudaArch = cuda_kernel_arch();
 
     int compiled_major = m_cudaArch / 100;
-    int compiled_minor = ( m_cudaArch % 100 ) / 10;
+    int compiled_minor = (m_cudaArch % 100) / 10;
 
-    if ( compiled_major < 5 && cudaProp.major >= 5 ) {
+    if (compiled_major < 5 && cudaProp.major >= 5) {
       std::stringstream ss;
-      ss << "Kokkos::Cuda::initialize ERROR: running kernels compiled for compute capability "
+      ss << "Kokkos::Cuda::initialize ERROR: running kernels compiled for "
+            "compute capability "
          << compiled_major << "." << compiled_minor
-         << " (< 5.0) on device with compute capability "
-         << cudaProp.major << "." << cudaProp.minor
-         << " (>=5.0), this would give incorrect results!"
-         << std::endl ;
+         << " (< 5.0) on device with compute capability " << cudaProp.major
+         << "." << cudaProp.minor
+         << " (>=5.0), this would give incorrect results!" << std::endl;
       std::string msg = ss.str();
-      Kokkos::abort( msg.c_str() );
+      Kokkos::abort(msg.c_str());
     }
-    if ( Kokkos::show_warnings() && (compiled_major != cudaProp.major || compiled_minor != cudaProp.minor) ) {
-      std::cerr << "Kokkos::Cuda::initialize WARNING: running kernels compiled for compute capability "
+    if (Kokkos::show_warnings() && (compiled_major != cudaProp.major ||
+                                    compiled_minor != cudaProp.minor)) {
+      std::cerr << "Kokkos::Cuda::initialize WARNING: running kernels compiled "
+                   "for compute capability "
                 << compiled_major << "." << compiled_minor
-                << " on device with compute capability "
-                << cudaProp.major << "." << cudaProp.minor
+                << " on device with compute capability " << cudaProp.major
+                << "." << cudaProp.minor
                 << " , this will likely reduce potential performance."
-                << std::endl ;
+                << std::endl;
     }
 
     // number of multiprocessors
 
-    m_multiProcCount = cudaProp.multiProcessorCount ;
+    m_multiProcCount = cudaProp.multiProcessorCount;
 
     //----------------------------------
     // Maximum number of warps,
     // at most one warp per thread in a warp for reduction.
 
-    m_maxWarpCount = cudaProp.maxThreadsPerBlock / Impl::CudaTraits::WarpSize ;
+    m_maxWarpCount = cudaProp.maxThreadsPerBlock / Impl::CudaTraits::WarpSize;
 
-    if ( Impl::CudaTraits::WarpSize < m_maxWarpCount ) {
-      m_maxWarpCount = Impl::CudaTraits::WarpSize ;
+    if (Impl::CudaTraits::WarpSize < m_maxWarpCount) {
+      m_maxWarpCount = Impl::CudaTraits::WarpSize;
     }
 
-    m_maxSharedWords = cudaProp.sharedMemPerBlock / WordSize ;
+    m_maxSharedWords = cudaProp.sharedMemPerBlock / WordSize;
 
     //----------------------------------
     // Maximum number of blocks:
 
-    m_maxBlock = cudaProp.maxGridSize[0] ;
+    m_maxBlock = cudaProp.maxGridSize[0];
 
-    m_shmemPerSM = cudaProp.sharedMemPerMultiprocessor ;
-    m_maxShmemPerBlock = cudaProp.sharedMemPerBlock ;
-    m_regsPerSM = cudaProp.regsPerMultiprocessor ;
-    m_maxBlocksPerSM = m_cudaArch < 500 ? 16 : (
-                       m_cudaArch < 750 ? 32 : (
-                       m_cudaArch == 750 ? 16 : 32));
-    m_maxThreadsPerSM = cudaProp.maxThreadsPerMultiProcessor ;
-    m_maxThreadsPerBlock = cudaProp.maxThreadsPerBlock ;
+    m_shmemPerSM       = cudaProp.sharedMemPerMultiprocessor;
+    m_maxShmemPerBlock = cudaProp.sharedMemPerBlock;
+    m_regsPerSM        = cudaProp.regsPerMultiprocessor;
+    m_maxBlocksPerSM =
+        m_cudaArch < 500
+            ? 16
+            : (m_cudaArch < 750 ? 32 : (m_cudaArch == 750 ? 16 : 32));
+    m_maxThreadsPerSM    = cudaProp.maxThreadsPerMultiProcessor;
+    m_maxThreadsPerBlock = cudaProp.maxThreadsPerBlock;
 
     //----------------------------------
 
-    m_scratchUnifiedSupported = cudaProp.unifiedAddressing ;
+    m_scratchUnifiedSupported = cudaProp.unifiedAddressing;
 
-    if ( Kokkos::show_warnings() && ! m_scratchUnifiedSupported ) {
-      std::cerr << "Kokkos::Cuda device "
-                << cudaProp.name << " capability "
+    if (Kokkos::show_warnings() && !m_scratchUnifiedSupported) {
+      std::cerr << "Kokkos::Cuda device " << cudaProp.name << " capability "
                 << cudaProp.major << "." << cudaProp.minor
                 << " does not support unified virtual address space"
-                << std::endl ;
+                << std::endl;
     }
 
     //----------------------------------
@@ -413,345 +421,362 @@ void CudaInternal::initialize( int cuda_device_id , cudaStream_t stream )
     // Allocate some initial space.  This will grow as needed.
 
     {
-      const unsigned reduce_block_count = m_maxWarpCount * Impl::CudaTraits::WarpSize ;
+      const unsigned reduce_block_count =
+          m_maxWarpCount * Impl::CudaTraits::WarpSize;
 
-      (void) scratch_unified( 16 * sizeof(size_type) );
-      (void) scratch_flags( reduce_block_count * 2  * sizeof(size_type) );
-      (void) scratch_space( reduce_block_count * 16 * sizeof(size_type) );
+      (void)scratch_unified(16 * sizeof(size_type));
+      (void)scratch_flags(reduce_block_count * 2 * sizeof(size_type));
+      (void)scratch_space(reduce_block_count * 16 * sizeof(size_type));
     }
     //----------------------------------
     // Concurrent bitset for obtaining unique tokens from within
     // an executing kernel.
     {
-
-      m_maxConcurrency =
-        m_maxThreadsPerSM * cudaProp.multiProcessorCount ;
+      m_maxConcurrency = m_maxThreadsPerSM * cudaProp.multiProcessorCount;
 
       const int32_t buffer_bound =
-         Kokkos::Impl::concurrent_bitset::buffer_bound( m_maxConcurrency );
+          Kokkos::Impl::concurrent_bitset::buffer_bound(m_maxConcurrency);
 
       // Allocate and initialize uint32_t[ buffer_bound ]
 
-      typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaSpace , void > Record ;
-
-      Record * const r = Record::allocate( Kokkos::CudaSpace()
-                                         , "InternalScratchBitset"
-                                         , sizeof(uint32_t) * buffer_bound );
+      typedef Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>
+          Record;
 
-      Record::increment( r );
+      Record *const r =
+          Record::allocate(Kokkos::CudaSpace(), "InternalScratchBitset",
+                           sizeof(uint32_t) * buffer_bound);
 
-      m_scratchConcurrentBitset = reinterpret_cast<uint32_t *>( r->data() );
+      Record::increment(r);
 
-      CUDA_SAFE_CALL( cudaMemset( m_scratchConcurrentBitset , 0 , sizeof(uint32_t) * buffer_bound ) );
+      m_scratchConcurrentBitset = reinterpret_cast<uint32_t *>(r->data());
 
+      CUDA_SAFE_CALL(cudaMemset(m_scratchConcurrentBitset, 0,
+                                sizeof(uint32_t) * buffer_bound));
     }
     //----------------------------------
 
-  }
-  else {
+  } else {
+    std::ostringstream msg;
+    msg << "Kokkos::Cuda::initialize(" << cuda_device_id << ") FAILED";
 
-    std::ostringstream msg ;
-    msg << "Kokkos::Cuda::initialize(" << cuda_device_id << ") FAILED" ;
-
-    if ( ! ok_init ) {
-      msg << " : Already initialized" ;
+    if (!ok_init) {
+      msg << " : Already initialized";
     }
-    if ( ! ok_id ) {
+    if (!ok_id) {
       msg << " : Device identifier out of range "
-          << "[0.." << dev_info.m_cudaDevCount << "]" ;
-    }
-    else if ( ! ok_dev ) {
-      msg << " : Device " ;
-      msg << dev_info.m_cudaProp[ cuda_device_id ].major ;
-      msg << "." ;
-      msg << dev_info.m_cudaProp[ cuda_device_id ].minor ;
-      msg << " has insufficient capability, required 3.0 or better" ;
+          << "[0.." << dev_info.m_cudaDevCount << "]";
+    } else if (!ok_dev) {
+      msg << " : Device ";
+      msg << dev_info.m_cudaProp[cuda_device_id].major;
+      msg << ".";
+      msg << dev_info.m_cudaProp[cuda_device_id].minor;
+      msg << " has insufficient capability, required 3.0 or better";
     }
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
-  #ifdef KOKKOS_ENABLE_CUDA_UVM
-    if( Kokkos::show_warnings() && !cuda_launch_blocking() ) {
-      std::cerr << "Kokkos::Cuda::initialize WARNING: Cuda is allocating into UVMSpace by default" << std::endl;
-      std::cerr << "                                  without setting CUDA_LAUNCH_BLOCKING=1." << std::endl;
-      std::cerr << "                                  The code must call Cuda().fence() after each kernel" << std::endl;
-      std::cerr << "                                  or will likely crash when accessing data on the host." << std::endl;
-    }
+#ifdef KOKKOS_ENABLE_CUDA_UVM
+  if (Kokkos::show_warnings() && !cuda_launch_blocking()) {
+    std::cerr << "Kokkos::Cuda::initialize WARNING: Cuda is allocating into "
+                 "UVMSpace by default"
+              << std::endl;
+    std::cerr << "                                  without setting "
+                 "CUDA_LAUNCH_BLOCKING=1."
+              << std::endl;
+    std::cerr << "                                  The code must call "
+                 "Cuda().fence() after each kernel"
+              << std::endl;
+    std::cerr << "                                  or will likely crash when "
+                 "accessing data on the host."
+              << std::endl;
+  }
 
-    const char * env_force_device_alloc = getenv("CUDA_MANAGED_FORCE_DEVICE_ALLOC");
-    bool force_device_alloc;
-    if (env_force_device_alloc == 0) force_device_alloc=false;
-    else force_device_alloc=atoi(env_force_device_alloc)!=0;
-
-    const char * env_visible_devices = getenv("CUDA_VISIBLE_DEVICES");
-    bool visible_devices_one=true;
-    if (env_visible_devices == 0) visible_devices_one=false;
-
-    if( Kokkos::show_warnings() && (!visible_devices_one && !force_device_alloc) ) {
-      std::cerr << "Kokkos::Cuda::initialize WARNING: Cuda is allocating into UVMSpace by default" << std::endl;
-      std::cerr << "                                  without setting CUDA_MANAGED_FORCE_DEVICE_ALLOC=1 or " << std::endl;
-      std::cerr << "                                  setting CUDA_VISIBLE_DEVICES." << std::endl;
-      std::cerr << "                                  This could on multi GPU systems lead to severe performance" << std::endl;
-      std::cerr << "                                  penalties." << std::endl;
-    }
-  #endif
+  const char *env_force_device_alloc =
+      getenv("CUDA_MANAGED_FORCE_DEVICE_ALLOC");
+  bool force_device_alloc;
+  if (env_force_device_alloc == 0)
+    force_device_alloc = false;
+  else
+    force_device_alloc = atoi(env_force_device_alloc) != 0;
+
+  const char *env_visible_devices = getenv("CUDA_VISIBLE_DEVICES");
+  bool visible_devices_one        = true;
+  if (env_visible_devices == 0) visible_devices_one = false;
+
+  if (Kokkos::show_warnings() &&
+      (!visible_devices_one && !force_device_alloc)) {
+    std::cerr << "Kokkos::Cuda::initialize WARNING: Cuda is allocating into "
+                 "UVMSpace by default"
+              << std::endl;
+    std::cerr << "                                  without setting "
+                 "CUDA_MANAGED_FORCE_DEVICE_ALLOC=1 or "
+              << std::endl;
+    std::cerr
+        << "                                  setting CUDA_VISIBLE_DEVICES."
+        << std::endl;
+    std::cerr << "                                  This could on multi GPU "
+                 "systems lead to severe performance"
+              << std::endl;
+    std::cerr << "                                  penalties." << std::endl;
+  }
+#endif
 
-  #ifdef KOKKOS_ENABLE_PRE_CUDA_10_DEPRECATION_API
+#ifdef KOKKOS_ENABLE_PRE_CUDA_10_DEPRECATION_API
   cudaThreadSetCacheConfig(cudaFuncCachePreferShared);
-  #else
+#else
   cudaDeviceSetCacheConfig(cudaFuncCachePreferShared);
-  #endif
+#endif
 
   // Init the array for used for arbitrarily sized atomics
-  if(stream == 0)
-    Impl::initialize_host_cuda_lock_arrays();
+  if (stream == 0) Impl::initialize_host_cuda_lock_arrays();
 
   m_stream = stream;
 }
 
 //----------------------------------------------------------------------------
 
-typedef Cuda::size_type ScratchGrain[ Impl::CudaTraits::WarpSize ] ;
+typedef Cuda::size_type ScratchGrain[Impl::CudaTraits::WarpSize];
 enum { sizeScratchGrain = sizeof(ScratchGrain) };
 
+Cuda::size_type *CudaInternal::scratch_flags(const Cuda::size_type size) const {
+  if (verify_is_initialized("scratch_flags") &&
+      m_scratchFlagsCount * sizeScratchGrain < size) {
+    m_scratchFlagsCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
 
-Cuda::size_type *
-CudaInternal::scratch_flags( const Cuda::size_type size ) const 
-{
-  if ( verify_is_initialized("scratch_flags") && m_scratchFlagsCount * sizeScratchGrain < size ) {
-
-
-    m_scratchFlagsCount = ( size + sizeScratchGrain - 1 ) / sizeScratchGrain ;
-
-    typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaSpace , void > Record ;
+    typedef Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>
+        Record;
 
-    if( m_scratchFlags )
-      Record::decrement( Record::get_record( m_scratchFlags ) );
+    if (m_scratchFlags) Record::decrement(Record::get_record(m_scratchFlags));
 
-    Record * const r = Record::allocate( Kokkos::CudaSpace()
-                                       , "InternalScratchFlags"
-                                       , ( sizeof( ScratchGrain ) * m_scratchFlagsCount ) );
+    Record *const r =
+        Record::allocate(Kokkos::CudaSpace(), "InternalScratchFlags",
+                         (sizeof(ScratchGrain) * m_scratchFlagsCount));
 
-    Record::increment( r );
+    Record::increment(r);
 
-    m_scratchFlags = reinterpret_cast<size_type *>( r->data() );
+    m_scratchFlags = reinterpret_cast<size_type *>(r->data());
 
-    CUDA_SAFE_CALL( cudaMemset( m_scratchFlags , 0 , m_scratchFlagsCount * sizeScratchGrain ) );
+    CUDA_SAFE_CALL(
+        cudaMemset(m_scratchFlags, 0, m_scratchFlagsCount * sizeScratchGrain));
   }
 
-  return m_scratchFlags ;
+  return m_scratchFlags;
 }
 
-Cuda::size_type *
-CudaInternal::scratch_space( const Cuda::size_type size ) const 
-{
-  if ( verify_is_initialized("scratch_space") && m_scratchSpaceCount * sizeScratchGrain < size ) {
-
-    m_scratchSpaceCount = ( size + sizeScratchGrain - 1 ) / sizeScratchGrain ;
+Cuda::size_type *CudaInternal::scratch_space(const Cuda::size_type size) const {
+  if (verify_is_initialized("scratch_space") &&
+      m_scratchSpaceCount * sizeScratchGrain < size) {
+    m_scratchSpaceCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
 
-     typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaSpace , void > Record ;
+    typedef Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>
+        Record;
 
-     if( m_scratchSpace )
-       Record::decrement( Record::get_record( m_scratchSpace ) );
+    if (m_scratchSpace) Record::decrement(Record::get_record(m_scratchSpace));
 
-     Record * const r = Record::allocate( Kokkos::CudaSpace()
-                                        , "InternalScratchSpace"
-                                        , ( sizeof( ScratchGrain ) * m_scratchSpaceCount ) );
+    Record *const r =
+        Record::allocate(Kokkos::CudaSpace(), "InternalScratchSpace",
+                         (sizeof(ScratchGrain) * m_scratchSpaceCount));
 
-     Record::increment( r );
+    Record::increment(r);
 
-     m_scratchSpace = reinterpret_cast<size_type *>( r->data() );
+    m_scratchSpace = reinterpret_cast<size_type *>(r->data());
   }
 
-  return m_scratchSpace ;
+  return m_scratchSpace;
 }
 
-Cuda::size_type *
-CudaInternal::scratch_unified( const Cuda::size_type size ) const
-{
-  if ( verify_is_initialized("scratch_unified") &&
-       m_scratchUnifiedSupported && m_scratchUnifiedCount * sizeScratchGrain < size ) {
+Cuda::size_type *CudaInternal::scratch_unified(
+    const Cuda::size_type size) const {
+  if (verify_is_initialized("scratch_unified") && m_scratchUnifiedSupported &&
+      m_scratchUnifiedCount * sizeScratchGrain < size) {
+    m_scratchUnifiedCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
 
-    m_scratchUnifiedCount = ( size + sizeScratchGrain - 1 ) / sizeScratchGrain ;
+    typedef Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaHostPinnedSpace,
+                                                 void>
+        Record;
 
-    typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void > Record ;
+    if (m_scratchUnified)
+      Record::decrement(Record::get_record(m_scratchUnified));
 
-    if( m_scratchUnified )
-      Record::decrement( Record::get_record( m_scratchUnified ) );
+    Record *const r = Record::allocate(
+        Kokkos::CudaHostPinnedSpace(), "InternalScratchUnified",
+        (sizeof(ScratchGrain) * m_scratchUnifiedCount));
 
-    Record * const r = Record::allocate( Kokkos::CudaHostPinnedSpace()
-                                       , "InternalScratchUnified"
-                                       , ( sizeof( ScratchGrain ) * m_scratchUnifiedCount ) );
+    Record::increment(r);
 
-    Record::increment( r );
-
-    m_scratchUnified = reinterpret_cast<size_type *>( r->data() );
+    m_scratchUnified = reinterpret_cast<size_type *>(r->data());
   }
 
-  return m_scratchUnified ;
+  return m_scratchUnified;
 }
 
-Cuda::size_type *
-CudaInternal::scratch_functor( const Cuda::size_type size ) const
-{
-  if ( verify_is_initialized("scratch_functor") &&
-       m_scratchFunctorSize < size ) {
-
-    m_scratchFunctorSize = size ;
+Cuda::size_type *CudaInternal::scratch_functor(
+    const Cuda::size_type size) const {
+  if (verify_is_initialized("scratch_functor") && m_scratchFunctorSize < size) {
+    m_scratchFunctorSize = size;
 
-    typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaSpace , void > Record ;
+    typedef Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>
+        Record;
 
-    if( m_scratchFunctor )
-      Record::decrement( Record::get_record( m_scratchFunctor ) );
+    if (m_scratchFunctor)
+      Record::decrement(Record::get_record(m_scratchFunctor));
 
-    Record * const r = Record::allocate( Kokkos::CudaSpace()
-                                       , "InternalScratchFunctor"
-                                       , m_scratchFunctorSize );
+    Record *const r = Record::allocate(
+        Kokkos::CudaSpace(), "InternalScratchFunctor", m_scratchFunctorSize);
 
-    Record::increment( r );
+    Record::increment(r);
 
-    m_scratchFunctor = reinterpret_cast<size_type *>( r->data() );
+    m_scratchFunctor = reinterpret_cast<size_type *>(r->data());
   }
 
-  return m_scratchFunctor ;
+  return m_scratchFunctor;
 }
 
 //----------------------------------------------------------------------------
 
-void CudaInternal::finalize()
-{
+void CudaInternal::finalize() {
   was_finalized = 1;
-  if ( 0 != m_scratchSpace || 0 != m_scratchFlags ) {
-
+  if (0 != m_scratchSpace || 0 != m_scratchFlags) {
     Impl::finalize_host_cuda_lock_arrays();
 
-    if(m_stream!=0) cudaStreamDestroy(m_stream);
-
-    typedef Kokkos::Impl::SharedAllocationRecord< CudaSpace > RecordCuda ;
-    typedef Kokkos::Impl::SharedAllocationRecord< CudaHostPinnedSpace > RecordHost ;
-
-    RecordCuda::decrement( RecordCuda::get_record( m_scratchFlags ) );
-    RecordCuda::decrement( RecordCuda::get_record( m_scratchSpace ) );
-    RecordHost::decrement( RecordHost::get_record( m_scratchUnified ) );
-    RecordCuda::decrement( RecordCuda::get_record( m_scratchConcurrentBitset ) );
-    if(m_scratchFunctorSize>0)
-    RecordCuda::decrement( RecordCuda::get_record( m_scratchFunctor ) );
-
-    m_cudaDev             = -1 ;
-    m_multiProcCount      = 0 ;
-    m_maxWarpCount        = 0 ;
-    m_maxBlock            = 0 ;
-    m_maxSharedWords      = 0 ;
-    m_scratchSpaceCount   = 0 ;
-    m_scratchFlagsCount   = 0 ;
-    m_scratchUnifiedCount = 0 ;
-    m_streamCount         = 0 ;
-    m_scratchSpace        = 0 ;
-    m_scratchFlags        = 0 ;
-    m_scratchUnified      = 0 ;
-    m_scratchConcurrentBitset = 0 ;
-    m_stream              = 0 ;
+    if (m_stream != 0) cudaStreamDestroy(m_stream);
+
+    typedef Kokkos::Impl::SharedAllocationRecord<CudaSpace> RecordCuda;
+    typedef Kokkos::Impl::SharedAllocationRecord<CudaHostPinnedSpace>
+        RecordHost;
+
+    RecordCuda::decrement(RecordCuda::get_record(m_scratchFlags));
+    RecordCuda::decrement(RecordCuda::get_record(m_scratchSpace));
+    RecordHost::decrement(RecordHost::get_record(m_scratchUnified));
+    RecordCuda::decrement(RecordCuda::get_record(m_scratchConcurrentBitset));
+    if (m_scratchFunctorSize > 0)
+      RecordCuda::decrement(RecordCuda::get_record(m_scratchFunctor));
+
+    m_cudaDev                 = -1;
+    m_multiProcCount          = 0;
+    m_maxWarpCount            = 0;
+    m_maxBlock                = 0;
+    m_maxSharedWords          = 0;
+    m_scratchSpaceCount       = 0;
+    m_scratchFlagsCount       = 0;
+    m_scratchUnifiedCount     = 0;
+    m_streamCount             = 0;
+    m_scratchSpace            = 0;
+    m_scratchFlags            = 0;
+    m_scratchUnified          = 0;
+    m_scratchConcurrentBitset = 0;
+    m_stream                  = 0;
   }
 }
 
 //----------------------------------------------------------------------------
 
-Cuda::size_type cuda_internal_multiprocessor_count()
-{ return CudaInternal::singleton().m_multiProcCount ; }
+Cuda::size_type cuda_internal_multiprocessor_count() {
+  return CudaInternal::singleton().m_multiProcCount;
+}
 
-CudaSpace::size_type cuda_internal_maximum_concurrent_block_count()
-{
-  #if defined(KOKKOS_ARCH_KEPLER)
+CudaSpace::size_type cuda_internal_maximum_concurrent_block_count() {
+#if defined(KOKKOS_ARCH_KEPLER)
   // Compute capability 3.0 through 3.7
   enum : int { max_resident_blocks_per_multiprocessor = 16 };
-  #else
+#else
   // Compute capability 5.0 through 6.2
   enum : int { max_resident_blocks_per_multiprocessor = 32 };
-  #endif
-   return CudaInternal::singleton().m_multiProcCount
-          * max_resident_blocks_per_multiprocessor ;
+#endif
+  return CudaInternal::singleton().m_multiProcCount *
+         max_resident_blocks_per_multiprocessor;
 };
 
-Cuda::size_type cuda_internal_maximum_warp_count()
-{ return CudaInternal::singleton().m_maxWarpCount ; }
-
-Cuda::size_type cuda_internal_maximum_grid_count()
-{ return CudaInternal::singleton().m_maxBlock ; }
+Cuda::size_type cuda_internal_maximum_warp_count() {
+  return CudaInternal::singleton().m_maxWarpCount;
+}
 
-Cuda::size_type cuda_internal_maximum_shared_words()
-{ return CudaInternal::singleton().m_maxSharedWords ; }
+Cuda::size_type cuda_internal_maximum_grid_count() {
+  return CudaInternal::singleton().m_maxBlock;
+}
 
-Cuda::size_type * cuda_internal_scratch_space( const Cuda& instance, const Cuda::size_type size )
-{ return instance.impl_internal_space_instance()->scratch_space( size ); }
+Cuda::size_type cuda_internal_maximum_shared_words() {
+  return CudaInternal::singleton().m_maxSharedWords;
+}
 
-Cuda::size_type * cuda_internal_scratch_flags( const Cuda& instance, const Cuda::size_type size )
-{ return instance.impl_internal_space_instance()->scratch_flags( size ); }
+Cuda::size_type *cuda_internal_scratch_space(const Cuda &instance,
+                                             const Cuda::size_type size) {
+  return instance.impl_internal_space_instance()->scratch_space(size);
+}
 
-Cuda::size_type * cuda_internal_scratch_unified( const Cuda& instance, const Cuda::size_type size )
-{ return instance.impl_internal_space_instance()->scratch_unified( size ); }
+Cuda::size_type *cuda_internal_scratch_flags(const Cuda &instance,
+                                             const Cuda::size_type size) {
+  return instance.impl_internal_space_instance()->scratch_flags(size);
+}
 
+Cuda::size_type *cuda_internal_scratch_unified(const Cuda &instance,
+                                               const Cuda::size_type size) {
+  return instance.impl_internal_space_instance()->scratch_unified(size);
+}
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-Cuda::size_type Cuda::detect_device_count()
-{ return Impl::CudaInternalDevices::singleton().m_cudaDevCount ; }
+Cuda::size_type Cuda::detect_device_count() {
+  return Impl::CudaInternalDevices::singleton().m_cudaDevCount;
+}
 
-int Cuda::concurrency()
-{ return Impl::CudaInternal::singleton().m_maxConcurrency ; }
+int Cuda::concurrency() {
+  return Impl::CudaInternal::singleton().m_maxConcurrency;
+}
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
 int Cuda::is_initialized()
 #else
 int Cuda::impl_is_initialized()
 #endif
-{ return Impl::CudaInternal::singleton().is_initialized(); }
+{
+  return Impl::CudaInternal::singleton().is_initialized();
+}
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-void Cuda::initialize( const Cuda::SelectDevice config , size_t num_instances )
+void Cuda::initialize(const Cuda::SelectDevice config, size_t num_instances)
 #else
-void Cuda::impl_initialize( const Cuda::SelectDevice config , size_t num_instances )
+void Cuda::impl_initialize(const Cuda::SelectDevice config,
+                           size_t num_instances)
 #endif
 {
-  Impl::CudaInternal::singleton().initialize( config.cuda_device_id , 0 );
+  Impl::CudaInternal::singleton().initialize(config.cuda_device_id, 0);
 
-  #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::initialize();
-  #endif
+#if defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::initialize();
+#endif
 }
 
-std::vector<unsigned>
-Cuda::detect_device_arch()
-{
-  const Impl::CudaInternalDevices & s = Impl::CudaInternalDevices::singleton();
+std::vector<unsigned> Cuda::detect_device_arch() {
+  const Impl::CudaInternalDevices &s = Impl::CudaInternalDevices::singleton();
 
-  std::vector<unsigned> output( s.m_cudaDevCount );
+  std::vector<unsigned> output(s.m_cudaDevCount);
 
-  for ( int i = 0 ; i < s.m_cudaDevCount ; ++i ) {
-    output[i] = s.m_cudaProp[i].major * 100 + s.m_cudaProp[i].minor ;
+  for (int i = 0; i < s.m_cudaDevCount; ++i) {
+    output[i] = s.m_cudaProp[i].major * 100 + s.m_cudaProp[i].minor;
   }
 
-  return output ;
+  return output;
 }
 
-Cuda::size_type Cuda::device_arch()
-{
-  const int dev_id = Impl::CudaInternal::singleton().m_cudaDev ;
+Cuda::size_type Cuda::device_arch() {
+  const int dev_id = Impl::CudaInternal::singleton().m_cudaDev;
 
-  int dev_arch = 0 ;
+  int dev_arch = 0;
 
-  if ( 0 <= dev_id ) {
-    const struct cudaDeviceProp & cudaProp =
-      Impl::CudaInternalDevices::singleton().m_cudaProp[ dev_id ] ;
+  if (0 <= dev_id) {
+    const struct cudaDeviceProp &cudaProp =
+        Impl::CudaInternalDevices::singleton().m_cudaProp[dev_id];
 
-    dev_arch = cudaProp.major * 100 + cudaProp.minor ;
+    dev_arch = cudaProp.major * 100 + cudaProp.minor;
   }
 
-  return dev_arch ;
+  return dev_arch;
 }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
@@ -762,71 +787,62 @@ void Cuda::impl_finalize()
 {
   Impl::CudaInternal::singleton().finalize();
 
-  #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::finalize();
-  #endif
+#if defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::finalize();
+#endif
 }
 
-Cuda::Cuda()
-  : m_space_instance( &Impl::CudaInternal::singleton() )
-{
-  Impl::CudaInternal::singleton().verify_is_initialized( "Cuda instance constructor" );
+Cuda::Cuda() : m_space_instance(&Impl::CudaInternal::singleton()) {
+  Impl::CudaInternal::singleton().verify_is_initialized(
+      "Cuda instance constructor");
 }
 
-Cuda::Cuda(cudaStream_t stream)
-  :   m_space_instance(new Impl::CudaInternal)
-{
-  Impl::CudaInternal::singleton().verify_is_initialized( "Cuda instance constructor" );
-  m_space_instance->initialize(Impl::CudaInternal::singleton().m_cudaDev,stream);
+Cuda::Cuda(cudaStream_t stream) : m_space_instance(new Impl::CudaInternal) {
+  Impl::CudaInternal::singleton().verify_is_initialized(
+      "Cuda instance constructor");
+  m_space_instance->initialize(Impl::CudaInternal::singleton().m_cudaDev,
+                               stream);
 }
 
-void Cuda::print_configuration( std::ostream & s , const bool )
-{ Impl::CudaInternal::singleton().print_configuration( s ); }
+void Cuda::print_configuration(std::ostream &s, const bool) {
+  Impl::CudaInternal::singleton().print_configuration(s);
+}
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-bool Cuda::sleep() { return false ; }
+bool Cuda::sleep() { return false; }
 
-bool Cuda::wake() { return true ; }
+bool Cuda::wake() { return true; }
 #endif
 
-void Cuda::impl_static_fence()
-{
-  Kokkos::Impl::cuda_device_synchronize();
-}
+void Cuda::impl_static_fence() { Kokkos::Impl::cuda_device_synchronize(); }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-void Cuda::fence() {
-  impl_static_fence();
-}
+void Cuda::fence() { impl_static_fence(); }
 #else
-void Cuda::fence() const {
-  m_space_instance->fence();
-}
+void Cuda::fence() const { m_space_instance->fence(); }
 #endif
 
-const char* Cuda::name() { return "Cuda"; }
+const char *Cuda::name() { return "Cuda"; }
 
-cudaStream_t Cuda::cuda_stream() const { return m_space_instance->m_stream ; }
-int          Cuda::cuda_device() const { return m_space_instance->m_cudaDev ; }
+cudaStream_t Cuda::cuda_stream() const { return m_space_instance->m_stream; }
+int Cuda::cuda_device() const { return m_space_instance->m_cudaDev; }
 
-
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Experimental {
 
-UniqueToken< Kokkos::Cuda , Kokkos::Experimental::UniqueTokenScope::Global >::
-UniqueToken( Kokkos::Cuda const & )
-  : m_buffer( Kokkos::Impl::CudaInternal::singleton().m_scratchConcurrentBitset )
-  , m_count(  Kokkos::Impl::CudaInternal::singleton().m_maxConcurrency )
-  {}
+UniqueToken<Kokkos::Cuda, Kokkos::Experimental::UniqueTokenScope::Global>::
+    UniqueToken(Kokkos::Cuda const &)
+    : m_buffer(
+          Kokkos::Impl::CudaInternal::singleton().m_scratchConcurrentBitset),
+      m_count(Kokkos::Impl::CudaInternal::singleton().m_maxConcurrency) {}
 
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 #else
 
 void KOKKOS_CORE_SRC_CUDA_IMPL_PREVENT_LINK_ERROR() {}
 
-#endif // KOKKOS_ENABLE_CUDA
-
+#endif  // KOKKOS_ENABLE_CUDA
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.hpp
index f9e333fcf0b954e7f0ceb39ee68f8b74e60574c6..9d2c939af85305cfb09a3b2fc53f85edfa2e86bc 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Instance.hpp
@@ -3,39 +3,48 @@
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
+// These functions fulfill the purpose of allowing to work around
+// a suspected system software issue, or to check for race conditions.
+// They are not currently a fully officially supported capability.
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+extern "C" void kokkos_impl_cuda_set_serial_execution(bool);
+extern "C" bool kokkos_impl_cuda_use_serial_execution();
+#endif
 
 namespace Kokkos {
 namespace Impl {
 
 struct CudaTraits {
-  enum { WarpSize       = 32      /* 0x0020 */ };
-  enum { WarpIndexMask  = 0x001f  /* Mask for warpindex */ };
-  enum { WarpIndexShift = 5       /* WarpSize == 1 << WarpShift */ };
+  enum { WarpSize = 32 /* 0x0020 */ };
+  enum { WarpIndexMask = 0x001f /* Mask for warpindex */ };
+  enum { WarpIndexShift = 5 /* WarpSize == 1 << WarpShift */ };
 
-  enum { ConstantMemoryUsage    = 0x008000 /* 32k bytes */ };
-  enum { ConstantMemoryCache    = 0x002000 /*  8k bytes */ };
-  enum { KernelArgumentLimit    = 0x001000 /*  4k bytes */ };
+  enum { ConstantMemoryUsage = 0x008000 /* 32k bytes */ };
+  enum { ConstantMemoryCache = 0x002000 /*  8k bytes */ };
+  enum { KernelArgumentLimit = 0x001000 /*  4k bytes */ };
 
   typedef unsigned long
-    ConstantGlobalBufferType[ ConstantMemoryUsage / sizeof(unsigned long) ];
+      ConstantGlobalBufferType[ConstantMemoryUsage / sizeof(unsigned long)];
 
-#if defined(KOKKOS_ARCH_VOLTA) || \
-    defined(KOKKOS_ARCH_PASCAL)
-  enum { ConstantMemoryUseThreshold = 0x000200 /* 0 bytes -> always use constant (or global)*/ };
+#if defined(KOKKOS_ARCH_VOLTA) || defined(KOKKOS_ARCH_PASCAL)
+  enum {
+    ConstantMemoryUseThreshold =
+        0x000200 /* 0 bytes -> always use constant (or global)*/
+  };
 #else
   enum { ConstantMemoryUseThreshold = 0x000200 /* 512 bytes */ };
 #endif
 
-  KOKKOS_INLINE_FUNCTION static
-  CudaSpace::size_type warp_count( CudaSpace::size_type i )
-    { return ( i + WarpIndexMask ) >> WarpIndexShift ; }
+  KOKKOS_INLINE_FUNCTION static CudaSpace::size_type warp_count(
+      CudaSpace::size_type i) {
+    return (i + WarpIndexMask) >> WarpIndexShift;
+  }
 
-  KOKKOS_INLINE_FUNCTION static
-  CudaSpace::size_type warp_align( CudaSpace::size_type i )
-    {
-      enum { Mask = ~CudaSpace::size_type( WarpIndexMask ) };
-      return ( i + WarpIndexMask ) & Mask ;
-    }
+  KOKKOS_INLINE_FUNCTION static CudaSpace::size_type warp_align(
+      CudaSpace::size_type i) {
+    enum { Mask = ~CudaSpace::size_type(WarpIndexMask) };
+    return (i + WarpIndexMask) & Mask;
+  }
 };
 
 //----------------------------------------------------------------------------
@@ -47,110 +56,118 @@ CudaSpace::size_type cuda_internal_maximum_shared_words();
 
 CudaSpace::size_type cuda_internal_maximum_concurrent_block_count();
 
-CudaSpace::size_type * cuda_internal_scratch_flags( const Cuda&, const CudaSpace::size_type size );
-CudaSpace::size_type * cuda_internal_scratch_space( const Cuda&, const CudaSpace::size_type size );
-CudaSpace::size_type * cuda_internal_scratch_unified( const Cuda&, const CudaSpace::size_type size );
+CudaSpace::size_type* cuda_internal_scratch_flags(
+    const Cuda&, const CudaSpace::size_type size);
+CudaSpace::size_type* cuda_internal_scratch_space(
+    const Cuda&, const CudaSpace::size_type size);
+CudaSpace::size_type* cuda_internal_scratch_unified(
+    const Cuda&, const CudaSpace::size_type size);
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 namespace Kokkos {
 namespace Impl {
 
 class CudaInternal {
-private:
-
-  CudaInternal( const CudaInternal & );
-  CudaInternal & operator = ( const CudaInternal & );
-
-
-public:
+ private:
+  CudaInternal(const CudaInternal&);
+  CudaInternal& operator=(const CudaInternal&);
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+  static bool kokkos_impl_cuda_use_serial_execution_v;
+#endif
 
-  typedef Cuda::size_type size_type ;
+ public:
+  typedef Cuda::size_type size_type;
 
-  int         m_cudaDev ;
+  int m_cudaDev;
 
   // Device Properties
-  int         m_cudaArch ;
-  unsigned    m_multiProcCount ;
-  unsigned    m_maxWarpCount ;
-  unsigned    m_maxBlock ;
-  unsigned    m_maxSharedWords ;
-  uint32_t    m_maxConcurrency ;
-  int         m_shmemPerSM ;
-  int         m_maxShmemPerBlock ;
-  int         m_regsPerSM ;
-  int         m_maxBlocksPerSM ;
-  int         m_maxThreadsPerSM ;
-  int         m_maxThreadsPerBlock ;
-
-  mutable size_type   m_scratchSpaceCount ;
-  mutable size_type   m_scratchFlagsCount ;
-  mutable size_type   m_scratchUnifiedCount ;
-  mutable size_type   m_scratchFunctorSize ;
-  size_type   m_scratchUnifiedSupported ;
-  size_type   m_streamCount ;
-  mutable size_type * m_scratchSpace ;
-  mutable size_type * m_scratchFlags ;
-  mutable size_type * m_scratchUnified ;
-  mutable size_type * m_scratchFunctor ;
-  uint32_t  * m_scratchConcurrentBitset ;
-  cudaStream_t m_stream ;
+  int m_cudaArch;
+  unsigned m_multiProcCount;
+  unsigned m_maxWarpCount;
+  unsigned m_maxBlock;
+  unsigned m_maxSharedWords;
+  uint32_t m_maxConcurrency;
+  int m_shmemPerSM;
+  int m_maxShmemPerBlock;
+  int m_regsPerSM;
+  int m_maxBlocksPerSM;
+  int m_maxThreadsPerSM;
+  int m_maxThreadsPerBlock;
+
+  mutable size_type m_scratchSpaceCount;
+  mutable size_type m_scratchFlagsCount;
+  mutable size_type m_scratchUnifiedCount;
+  mutable size_type m_scratchFunctorSize;
+  size_type m_scratchUnifiedSupported;
+  size_type m_streamCount;
+  mutable size_type* m_scratchSpace;
+  mutable size_type* m_scratchFlags;
+  mutable size_type* m_scratchUnified;
+  mutable size_type* m_scratchFunctor;
+  uint32_t* m_scratchConcurrentBitset;
+  cudaStream_t m_stream;
 
   static int was_initialized;
   static int was_finalized;
 
-  static CudaInternal & singleton();
+  static CudaInternal& singleton();
 
-  int verify_is_initialized( const char * const label ) const ;
+  int verify_is_initialized(const char* const label) const;
 
-  int is_initialized() const
-    { return 0 != m_scratchSpace && 0 != m_scratchFlags ; }
+  int is_initialized() const {
+    return 0 != m_scratchSpace && 0 != m_scratchFlags;
+  }
 
-  void initialize( int cuda_device_id , cudaStream_t stream = 0 );
+  void initialize(int cuda_device_id, cudaStream_t stream = 0);
   void finalize();
 
-  void print_configuration( std::ostream & ) const ;
+  void print_configuration(std::ostream&) const;
+
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+  static bool cuda_use_serial_execution();
+  static void cuda_set_serial_execution(bool);
+#endif
 
-  void fence() const ;
+  void fence() const;
 
   ~CudaInternal();
 
   CudaInternal()
-    : m_cudaDev( -1 )
-    , m_cudaArch( -1 )
-    , m_multiProcCount( 0 )
-    , m_maxWarpCount( 0 )
-    , m_maxBlock( 0 )
-    , m_maxSharedWords( 0 )
-    , m_maxConcurrency( 0 )
-    , m_shmemPerSM( 0 )
-    , m_maxShmemPerBlock( 0 )
-    , m_regsPerSM( 0 )
-    , m_maxBlocksPerSM( 0 )
-    , m_maxThreadsPerSM( 0 )
-    , m_maxThreadsPerBlock( 0 )
-    , m_scratchSpaceCount( 0 )
-    , m_scratchFlagsCount( 0 )
-    , m_scratchUnifiedCount( 0 )
-    , m_scratchFunctorSize( 0 )
-    , m_scratchUnifiedSupported( 0 )
-    , m_streamCount( 0 )
-    , m_scratchSpace( 0 )
-    , m_scratchFlags( 0 )
-    , m_scratchUnified( 0 )
-    , m_scratchFunctor( 0 )
-    , m_scratchConcurrentBitset( 0 )
-    , m_stream( 0 )
-    {}
-
-  size_type * scratch_space( const size_type size ) const ;
-  size_type * scratch_flags( const size_type size ) const ;
-  size_type * scratch_unified( const size_type size ) const ;
-  size_type * scratch_functor( const size_type size ) const ;
+      : m_cudaDev(-1),
+        m_cudaArch(-1),
+        m_multiProcCount(0),
+        m_maxWarpCount(0),
+        m_maxBlock(0),
+        m_maxSharedWords(0),
+        m_maxConcurrency(0),
+        m_shmemPerSM(0),
+        m_maxShmemPerBlock(0),
+        m_regsPerSM(0),
+        m_maxBlocksPerSM(0),
+        m_maxThreadsPerSM(0),
+        m_maxThreadsPerBlock(0),
+        m_scratchSpaceCount(0),
+        m_scratchFlagsCount(0),
+        m_scratchUnifiedCount(0),
+        m_scratchFunctorSize(0),
+        m_scratchUnifiedSupported(0),
+        m_streamCount(0),
+        m_scratchSpace(0),
+        m_scratchFlags(0),
+        m_scratchUnified(0),
+        m_scratchFunctor(0),
+        m_scratchConcurrentBitset(0),
+        m_stream(0) {}
+
+  size_type* scratch_space(const size_type size) const;
+  size_type* scratch_flags(const size_type size) const;
+  size_type* scratch_unified(const size_type size) const;
+  size_type* scratch_functor(const size_type size) const;
 };
 
-} // Namespace Impl
-} // Namespace Kokkos
+}  // Namespace Impl
+}  // Namespace Kokkos
 #endif
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
index 2ec868c1f173d451444341362bfe665aae3a0929..590fa7a7847733c65189a815b37857a2d94ee57c 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -59,32 +60,32 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-#if defined( __CUDACC__ )
+#if defined(__CUDACC__)
 
 /** \brief  Access to constant memory on the device */
 #ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
 
-__device__ __constant__
-extern unsigned long kokkos_impl_cuda_constant_memory_buffer[] ;
+__device__ __constant__ extern unsigned long
+    kokkos_impl_cuda_constant_memory_buffer[];
 
 #else
 
-__device__ __constant__
-unsigned long kokkos_impl_cuda_constant_memory_buffer[ Kokkos::Impl::CudaTraits::ConstantMemoryUsage / sizeof(unsigned long) ] ;
+__device__ __constant__ unsigned long kokkos_impl_cuda_constant_memory_buffer
+    [Kokkos::Impl::CudaTraits::ConstantMemoryUsage / sizeof(unsigned long)];
 
 #endif
 
 namespace Kokkos {
 namespace Impl {
-  void* cuda_resize_scratch_space(std::int64_t bytes, bool force_shrink = false);
-}
+void* cuda_resize_scratch_space(std::int64_t bytes, bool force_shrink = false);
 }
+}  // namespace Kokkos
 
-template< typename T >
-inline
-__device__
-T * kokkos_impl_cuda_shared_memory()
-{ extern __shared__ Kokkos::CudaSpace::size_type sh[]; return (T*) sh ; }
+template <typename T>
+inline __device__ T* kokkos_impl_cuda_shared_memory() {
+  extern __shared__ Kokkos::CudaSpace::size_type sh[];
+  return (T*)sh;
+}
 
 namespace Kokkos {
 namespace Impl {
@@ -100,105 +101,111 @@ namespace Impl {
 // For 2.0 capability: 48 KB L1 and 16 KB shared
 //----------------------------------------------------------------------------
 
-template< class DriverType>
-__global__
-static void cuda_parallel_launch_constant_memory()
-{
-  const DriverType & driver =
-    *((const DriverType *) kokkos_impl_cuda_constant_memory_buffer );
+template <class DriverType>
+__global__ static void cuda_parallel_launch_constant_memory() {
+  const DriverType& driver =
+      *((const DriverType*)kokkos_impl_cuda_constant_memory_buffer);
 
   driver();
 }
 
-template< class DriverType, unsigned int maxTperB, unsigned int minBperSM >
-__global__
-__launch_bounds__(maxTperB, minBperSM)
-static void cuda_parallel_launch_constant_memory()
-{
-  const DriverType & driver =
-    *((const DriverType *) kokkos_impl_cuda_constant_memory_buffer );
+template <class DriverType, unsigned int maxTperB, unsigned int minBperSM>
+__global__ __launch_bounds__(
+    maxTperB, minBperSM) static void cuda_parallel_launch_constant_memory() {
+  const DriverType& driver =
+      *((const DriverType*)kokkos_impl_cuda_constant_memory_buffer);
 
   driver();
 }
 
-template< class DriverType>
-__global__
-static void cuda_parallel_launch_local_memory( const DriverType driver )
-{
+template <class DriverType>
+__global__ static void cuda_parallel_launch_local_memory(
+    const DriverType driver) {
   driver();
 }
 
-template< class DriverType, unsigned int maxTperB, unsigned int minBperSM >
-__global__
-__launch_bounds__(maxTperB, minBperSM)
-static void cuda_parallel_launch_local_memory( const DriverType driver )
-{
+template <class DriverType, unsigned int maxTperB, unsigned int minBperSM>
+__global__ __launch_bounds__(
+    maxTperB,
+    minBperSM) static void cuda_parallel_launch_local_memory(const DriverType
+                                                                 driver) {
   driver();
 }
 
-template< class DriverType>
-__global__
-static void cuda_parallel_launch_global_memory( const DriverType* driver )
-{
+template <class DriverType>
+__global__ static void cuda_parallel_launch_global_memory(
+    const DriverType* driver) {
   driver->operator()();
 }
 
-template< class DriverType, unsigned int maxTperB, unsigned int minBperSM >
-__global__
-__launch_bounds__(maxTperB, minBperSM)
-static void cuda_parallel_launch_global_memory( const DriverType* driver )
-{
+template <class DriverType, unsigned int maxTperB, unsigned int minBperSM>
+__global__ __launch_bounds__(
+    maxTperB,
+    minBperSM) static void cuda_parallel_launch_global_memory(const DriverType*
+                                                                  driver) {
   driver->operator()();
 }
 
-template< class DriverType>
-__global__
-static void cuda_parallel_launch_constant_or_global_memory( const DriverType* driver_ptr )
-{
-  const DriverType & driver = driver_ptr!=NULL ? *driver_ptr :
-    *((const DriverType *) kokkos_impl_cuda_constant_memory_buffer );
+template <class DriverType>
+__global__ static void cuda_parallel_launch_constant_or_global_memory(
+    const DriverType* driver_ptr) {
+  const DriverType& driver =
+      driver_ptr != NULL
+          ? *driver_ptr
+          : *((const DriverType*)kokkos_impl_cuda_constant_memory_buffer);
 
   driver();
 }
 
-template< class DriverType, unsigned int maxTperB, unsigned int minBperSM >
+template <class DriverType, unsigned int maxTperB, unsigned int minBperSM>
 __global__
-__launch_bounds__(maxTperB, minBperSM)
-static void cuda_parallel_launch_constant_or_global_memory( const DriverType* driver_ptr )
-{
-  const DriverType & driver = driver_ptr!=NULL ? *driver_ptr :
-    *((const DriverType *) kokkos_impl_cuda_constant_memory_buffer );
+__launch_bounds__(maxTperB, minBperSM) static void cuda_parallel_launch_constant_or_global_memory(
+    const DriverType* driver_ptr) {
+  const DriverType& driver =
+      driver_ptr != NULL
+          ? *driver_ptr
+          : *((const DriverType*)kokkos_impl_cuda_constant_memory_buffer);
 
   driver();
 }
 
-template< class DriverType >
+template <class DriverType>
 struct DeduceCudaLaunchMechanism {
-  constexpr static const Kokkos::Experimental::WorkItemProperty::HintLightWeight_t light_weight = Kokkos::Experimental::WorkItemProperty::HintLightWeight;
-  constexpr static const Kokkos::Experimental::WorkItemProperty::HintHeavyWeight_t heavy_weight = Kokkos::Experimental::WorkItemProperty::HintHeavyWeight ;
-  constexpr static const typename DriverType::Policy::work_item_property property = typename DriverType::Policy::work_item_property();
-
-  static constexpr const Experimental::CudaLaunchMechanism valid_launch_mechanism =
-      // BuildValidMask
-      (sizeof(DriverType)<CudaTraits::KernelArgumentLimit?
-          Experimental::CudaLaunchMechanism::LocalMemory:Experimental::CudaLaunchMechanism::Default)|
-      (sizeof(DriverType)<CudaTraits::ConstantMemoryUsage?
-          Experimental::CudaLaunchMechanism::ConstantMemory:Experimental::CudaLaunchMechanism::Default)|
+  constexpr static const Kokkos::Experimental::WorkItemProperty::
+      HintLightWeight_t light_weight =
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight;
+  constexpr static const Kokkos::Experimental::WorkItemProperty::
+      HintHeavyWeight_t heavy_weight =
+          Kokkos::Experimental::WorkItemProperty::HintHeavyWeight;
+  constexpr static const typename DriverType::Policy::work_item_property
+      property = typename DriverType::Policy::work_item_property();
+
+  static constexpr const Experimental::CudaLaunchMechanism
+      valid_launch_mechanism =
+          // BuildValidMask
+      (sizeof(DriverType) < CudaTraits::KernelArgumentLimit
+           ? Experimental::CudaLaunchMechanism::LocalMemory
+           : Experimental::CudaLaunchMechanism::Default) |
+      (sizeof(DriverType) < CudaTraits::ConstantMemoryUsage
+           ? Experimental::CudaLaunchMechanism::ConstantMemory
+           : Experimental::CudaLaunchMechanism::Default) |
       Experimental::CudaLaunchMechanism::GlobalMemory;
 
-  static constexpr const Experimental::CudaLaunchMechanism requested_launch_mechanism =
-      (((property&light_weight)==light_weight)?
-           Experimental::CudaLaunchMechanism::LocalMemory :
-           Experimental::CudaLaunchMechanism::ConstantMemory)
-    | Experimental::CudaLaunchMechanism::GlobalMemory;
-
-  static constexpr const Experimental::CudaLaunchMechanism default_launch_mechanism =
-      // BuildValidMask
-      (sizeof(DriverType)<CudaTraits::ConstantMemoryUseThreshold)?
-          Experimental::CudaLaunchMechanism::LocalMemory:(
-      (sizeof(DriverType)<CudaTraits::ConstantMemoryUsage)?
-          Experimental::CudaLaunchMechanism::ConstantMemory:
-          Experimental::CudaLaunchMechanism::GlobalMemory);
+  static constexpr const Experimental::CudaLaunchMechanism
+      requested_launch_mechanism =
+          (((property & light_weight) == light_weight)
+               ? Experimental::CudaLaunchMechanism::LocalMemory
+               : Experimental::CudaLaunchMechanism::ConstantMemory) |
+          Experimental::CudaLaunchMechanism::GlobalMemory;
+
+  static constexpr const Experimental::CudaLaunchMechanism
+      default_launch_mechanism =
+          // BuildValidMask
+      (sizeof(DriverType) < CudaTraits::ConstantMemoryUseThreshold)
+          ? Experimental::CudaLaunchMechanism::LocalMemory
+          : ((sizeof(DriverType) < CudaTraits::ConstantMemoryUsage)
+                 ? Experimental::CudaLaunchMechanism::ConstantMemory
+                 : Experimental::CudaLaunchMechanism::GlobalMemory);
 
   //              None                LightWeight    HeavyWeight
   // F<UseT       LCG LCG L  L        LCG  LG L  L    LCG  CG L  C
@@ -206,76 +213,69 @@ struct DeduceCudaLaunchMechanism {
   // Kal<F<CMU     CG LCG C  C         CG  LG C  G     CG  CG C  C
   // CMU<F          G LCG G  G          G  LG G  G      G  CG G  G
   static constexpr const Experimental::CudaLaunchMechanism launch_mechanism =
-      ((property&light_weight)==light_weight)?
-          (sizeof(DriverType)<CudaTraits::KernelArgumentLimit?
-              Experimental::CudaLaunchMechanism::LocalMemory:
-              Experimental::CudaLaunchMechanism::GlobalMemory):(
-        ((property&heavy_weight)==heavy_weight)?
-          (sizeof(DriverType)<CudaTraits::ConstantMemoryUsage?
-              Experimental::CudaLaunchMechanism::ConstantMemory:
-              Experimental::CudaLaunchMechanism::GlobalMemory):
-          (default_launch_mechanism)
-      );
+      ((property & light_weight) == light_weight)
+          ? (sizeof(DriverType) < CudaTraits::KernelArgumentLimit
+                 ? Experimental::CudaLaunchMechanism::LocalMemory
+                 : Experimental::CudaLaunchMechanism::GlobalMemory)
+          : (((property & heavy_weight) == heavy_weight)
+                 ? (sizeof(DriverType) < CudaTraits::ConstantMemoryUsage
+                        ? Experimental::CudaLaunchMechanism::ConstantMemory
+                        : Experimental::CudaLaunchMechanism::GlobalMemory)
+                 : (default_launch_mechanism));
 };
 // Use local memory up to ConstantMemoryUseThreshold
 // Use global memory above ConstantMemoryUsage
 // In between use ConstantMemory
-template < class DriverType
-         , class LaunchBounds = Kokkos::LaunchBounds<>
-         , Experimental::CudaLaunchMechanism LaunchMechanism =
-             DeduceCudaLaunchMechanism<DriverType>::launch_mechanism >
-struct CudaParallelLaunch ;
-
-template < class DriverType
-         , unsigned int MaxThreadsPerBlock
-         , unsigned int MinBlocksPerSM>
-struct CudaParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds< MaxThreadsPerBlock 
-                                               , MinBlocksPerSM >
-                          , Experimental::CudaLaunchMechanism::ConstantMemory>
-{
-  static_assert(sizeof(DriverType)<CudaTraits::ConstantMemoryUsage,"Kokkos Error: Requested CudaLaunchConstantMemory with a Functor larger than 32kB.");
-  inline
-  CudaParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int          shmem
-                    , const CudaInternal* cuda_instance
-                    , const bool prefer_shmem )
-  {
-    if ( (grid.x != 0) && ( ( block.x * block.y * block.z ) != 0 ) ) {
-
+template <class DriverType, class LaunchBounds = Kokkos::LaunchBounds<>,
+          Experimental::CudaLaunchMechanism LaunchMechanism =
+              DeduceCudaLaunchMechanism<DriverType>::launch_mechanism>
+struct CudaParallelLaunch;
+
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct CudaParallelLaunch<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>,
+    Experimental::CudaLaunchMechanism::ConstantMemory> {
+  static_assert(sizeof(DriverType) < CudaTraits::ConstantMemoryUsage,
+                "Kokkos Error: Requested CudaLaunchConstantMemory with a "
+                "Functor larger than 32kB.");
+  inline CudaParallelLaunch(const DriverType& driver, const dim3& grid,
+                            const dim3& block, const int shmem,
+                            const CudaInternal* cuda_instance,
+                            const bool prefer_shmem) {
+    if ((grid.x != 0) && ((block.x * block.y * block.z) != 0)) {
       // Fence before changing settings and copying closure
       Kokkos::Cuda().fence();
 
-      if ( cuda_instance->m_maxShmemPerBlock < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("CudaParallelLaunch FAILED: shared memory request is too large") );
+      if (cuda_instance->m_maxShmemPerBlock < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "CudaParallelLaunch FAILED: shared memory request is too large"));
       }
-      #ifndef KOKKOS_ARCH_KEPLER
+#ifndef KOKKOS_ARCH_KEPLER
       // On Kepler the L1 has no benefit since it doesn't cache reads
       else {
-        CUDA_SAFE_CALL(
-          cudaFuncSetCacheConfig
-            ( cuda_parallel_launch_constant_memory
-                < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >
-            , ( prefer_shmem ? cudaFuncCachePreferShared : cudaFuncCachePreferL1 )
-            ) );
+        CUDA_SAFE_CALL(cudaFuncSetCacheConfig(
+            cuda_parallel_launch_constant_memory<DriverType, MaxThreadsPerBlock,
+                                                 MinBlocksPerSM>,
+            (prefer_shmem ? cudaFuncCachePreferShared
+                          : cudaFuncCachePreferL1)));
       }
-      #endif
+#endif
 
       // Copy functor to constant memory on the device
-      cudaMemcpyToSymbolAsync(
-        kokkos_impl_cuda_constant_memory_buffer, &driver, sizeof(DriverType), 0, cudaMemcpyHostToDevice, cudaStream_t(cuda_instance->m_stream));
+      cudaMemcpyToSymbolAsync(kokkos_impl_cuda_constant_memory_buffer, &driver,
+                              sizeof(DriverType), 0, cudaMemcpyHostToDevice,
+                              cudaStream_t(cuda_instance->m_stream));
 
       KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE();
 
       // Invoke the driver function on the device
-      cuda_parallel_launch_constant_memory
-        < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >
-          <<< grid , block , shmem , cuda_instance->m_stream >>>();
+      cuda_parallel_launch_constant_memory<DriverType, MaxThreadsPerBlock,
+                                           MinBlocksPerSM>
+          <<<grid, block, shmem, cuda_instance->m_stream>>>();
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-      CUDA_SAFE_CALL( cudaGetLastError() );
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+      CUDA_SAFE_CALL(cudaGetLastError());
       Kokkos::Cuda().fence();
 #endif
     }
@@ -283,57 +283,55 @@ struct CudaParallelLaunch< DriverType
 
   static cudaFuncAttributes get_cuda_func_attributes() {
     cudaFuncAttributes attr;
-    cudaFuncGetAttributes(&attr,cuda_parallel_launch_constant_memory
-            < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >);
+    CUDA_SAFE_CALL(cudaFuncGetAttributes(
+        &attr,
+        cuda_parallel_launch_constant_memory<DriverType, MaxThreadsPerBlock,
+                                             MinBlocksPerSM>));
     return attr;
   }
 };
 
-template < class DriverType>
-struct CudaParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds<0,0>
-                         , Experimental::CudaLaunchMechanism::ConstantMemory >
-{
-  static_assert(sizeof(DriverType)<CudaTraits::ConstantMemoryUsage,"Kokkos Error: Requested CudaLaunchConstantMemory with a Functor larger than 32kB.");
-  inline
-  CudaParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int          shmem
-                    , const CudaInternal* cuda_instance
-                    , const bool prefer_shmem )
-  {
-    if ( (grid.x != 0) && ( ( block.x * block.y * block.z ) != 0 ) ) {
-
+template <class DriverType>
+struct CudaParallelLaunch<DriverType, Kokkos::LaunchBounds<0, 0>,
+                          Experimental::CudaLaunchMechanism::ConstantMemory> {
+  static_assert(sizeof(DriverType) < CudaTraits::ConstantMemoryUsage,
+                "Kokkos Error: Requested CudaLaunchConstantMemory with a "
+                "Functor larger than 32kB.");
+  inline CudaParallelLaunch(const DriverType& driver, const dim3& grid,
+                            const dim3& block, const int shmem,
+                            const CudaInternal* cuda_instance,
+                            const bool prefer_shmem) {
+    if ((grid.x != 0) && ((block.x * block.y * block.z) != 0)) {
       // Fence before changing settings and copying closure
       Kokkos::Cuda().fence();
 
-      if ( cuda_instance->m_maxShmemPerBlock < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("CudaParallelLaunch FAILED: shared memory request is too large") );
+      if (cuda_instance->m_maxShmemPerBlock < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "CudaParallelLaunch FAILED: shared memory request is too large"));
       }
-      #ifndef KOKKOS_ARCH_KEPLER
+#ifndef KOKKOS_ARCH_KEPLER
       // On Kepler the L1 has no benefit since it doesn't cache reads
       else {
-        CUDA_SAFE_CALL(
-          cudaFuncSetCacheConfig
-            ( cuda_parallel_launch_constant_memory< DriverType >
-            , ( prefer_shmem ? cudaFuncCachePreferShared : cudaFuncCachePreferL1 )
-            ) );
+        CUDA_SAFE_CALL(cudaFuncSetCacheConfig(
+            cuda_parallel_launch_constant_memory<DriverType>,
+            (prefer_shmem ? cudaFuncCachePreferShared
+                          : cudaFuncCachePreferL1)));
       }
-      #endif
+#endif
 
       // Copy functor to constant memory on the device
-      cudaMemcpyToSymbolAsync(
-        kokkos_impl_cuda_constant_memory_buffer, &driver, sizeof(DriverType), 0, cudaMemcpyHostToDevice, cudaStream_t(cuda_instance->m_stream));
+      cudaMemcpyToSymbolAsync(kokkos_impl_cuda_constant_memory_buffer, &driver,
+                              sizeof(DriverType), 0, cudaMemcpyHostToDevice,
+                              cudaStream_t(cuda_instance->m_stream));
 
       KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE();
 
       // Invoke the driver function on the device
-      cuda_parallel_launch_constant_memory< DriverType >
-          <<< grid , block , shmem , cuda_instance->m_stream >>>();
+      cuda_parallel_launch_constant_memory<DriverType>
+          <<<grid, block, shmem, cuda_instance->m_stream>>>();
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-      CUDA_SAFE_CALL( cudaGetLastError() );
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+      CUDA_SAFE_CALL(cudaGetLastError());
       Kokkos::Cuda().fence();
 #endif
     }
@@ -341,55 +339,49 @@ struct CudaParallelLaunch< DriverType
 
   static cudaFuncAttributes get_cuda_func_attributes() {
     cudaFuncAttributes attr;
-    cudaFuncGetAttributes(&attr,cuda_parallel_launch_constant_memory
-            < DriverType >);
+    CUDA_SAFE_CALL(cudaFuncGetAttributes(
+        &attr, cuda_parallel_launch_constant_memory<DriverType>));
     return attr;
   }
 };
 
-template < class DriverType
-         , unsigned int MaxThreadsPerBlock
-         , unsigned int MinBlocksPerSM >
-struct CudaParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds< MaxThreadsPerBlock 
-                                               , MinBlocksPerSM >
-                         , Experimental::CudaLaunchMechanism::LocalMemory >
-{
-  static_assert(sizeof(DriverType)<CudaTraits::KernelArgumentLimit,"Kokkos Error: Requested CudaLaunchLocalMemory with a Functor larger than 4096 bytes.");
-  inline
-  CudaParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int          shmem
-                    , const CudaInternal* cuda_instance
-                    , const bool prefer_shmem )
-  {
-    if ( (grid.x != 0) && ( ( block.x * block.y * block.z ) != 0 ) ) {
-
-      if ( cuda_instance->m_maxShmemPerBlock < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("CudaParallelLaunch FAILED: shared memory request is too large") );
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct CudaParallelLaunch<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>,
+    Experimental::CudaLaunchMechanism::LocalMemory> {
+  static_assert(sizeof(DriverType) < CudaTraits::KernelArgumentLimit,
+                "Kokkos Error: Requested CudaLaunchLocalMemory with a Functor "
+                "larger than 4096 bytes.");
+  inline CudaParallelLaunch(const DriverType& driver, const dim3& grid,
+                            const dim3& block, const int shmem,
+                            const CudaInternal* cuda_instance,
+                            const bool prefer_shmem) {
+    if ((grid.x != 0) && ((block.x * block.y * block.z) != 0)) {
+      if (cuda_instance->m_maxShmemPerBlock < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "CudaParallelLaunch FAILED: shared memory request is too large"));
       }
-      #ifndef KOKKOS_ARCH_KEPLER
+#ifndef KOKKOS_ARCH_KEPLER
       // On Kepler the L1 has no benefit since it doesn't cache reads
       else {
-        CUDA_SAFE_CALL(
-          cudaFuncSetCacheConfig
-            ( cuda_parallel_launch_local_memory
-                < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >
-            , ( prefer_shmem ? cudaFuncCachePreferShared : cudaFuncCachePreferL1 )
-            ) );
+        CUDA_SAFE_CALL(cudaFuncSetCacheConfig(
+            cuda_parallel_launch_local_memory<DriverType, MaxThreadsPerBlock,
+                                              MinBlocksPerSM>,
+            (prefer_shmem ? cudaFuncCachePreferShared
+                          : cudaFuncCachePreferL1)));
       }
-      #endif
+#endif
 
       KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE();
 
       // Invoke the driver function on the device
-      cuda_parallel_launch_local_memory
-        < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >
-          <<< grid , block , shmem , cuda_instance->m_stream >>>( driver );
+      cuda_parallel_launch_local_memory<DriverType, MaxThreadsPerBlock,
+                                        MinBlocksPerSM>
+          <<<grid, block, shmem, cuda_instance->m_stream>>>(driver);
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-      CUDA_SAFE_CALL( cudaGetLastError() );
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+      CUDA_SAFE_CALL(cudaGetLastError());
       Kokkos::Cuda().fence();
 #endif
     }
@@ -397,50 +389,46 @@ struct CudaParallelLaunch< DriverType
 
   static cudaFuncAttributes get_cuda_func_attributes() {
     cudaFuncAttributes attr;
-    cudaFuncGetAttributes(&attr,cuda_parallel_launch_local_memory
-            < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >);
+    CUDA_SAFE_CALL(cudaFuncGetAttributes(
+        &attr, cuda_parallel_launch_local_memory<DriverType, MaxThreadsPerBlock,
+                                                 MinBlocksPerSM>));
     return attr;
   }
 };
 
-template < class DriverType>
-struct CudaParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds<0,0>
-                         , Experimental::CudaLaunchMechanism::LocalMemory >
-{
-  static_assert(sizeof(DriverType)<CudaTraits::KernelArgumentLimit,"Kokkos Error: Requested CudaLaunchLocalMemory with a Functor larger than 4096 bytes.");
-  inline
-  CudaParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int          shmem
-                    , const CudaInternal* cuda_instance
-                    , const bool prefer_shmem)
-  {
-    if ( (grid.x != 0) && ( ( block.x * block.y * block.z ) != 0 ) ) {
-
-      if ( cuda_instance->m_maxShmemPerBlock < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("CudaParallelLaunch FAILED: shared memory request is too large") );
+template <class DriverType>
+struct CudaParallelLaunch<DriverType, Kokkos::LaunchBounds<0, 0>,
+                          Experimental::CudaLaunchMechanism::LocalMemory> {
+  static_assert(sizeof(DriverType) < CudaTraits::KernelArgumentLimit,
+                "Kokkos Error: Requested CudaLaunchLocalMemory with a Functor "
+                "larger than 4096 bytes.");
+  inline CudaParallelLaunch(const DriverType& driver, const dim3& grid,
+                            const dim3& block, const int shmem,
+                            const CudaInternal* cuda_instance,
+                            const bool prefer_shmem) {
+    if ((grid.x != 0) && ((block.x * block.y * block.z) != 0)) {
+      if (cuda_instance->m_maxShmemPerBlock < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "CudaParallelLaunch FAILED: shared memory request is too large"));
       }
-      #ifndef KOKKOS_ARCH_KEPLER
+#ifndef KOKKOS_ARCH_KEPLER
       // On Kepler the L1 has no benefit since it doesn't cache reads
       else {
-        CUDA_SAFE_CALL(
-          cudaFuncSetCacheConfig
-            ( cuda_parallel_launch_local_memory< DriverType >
-            , ( prefer_shmem ? cudaFuncCachePreferShared : cudaFuncCachePreferL1 )
-            ) );
+        CUDA_SAFE_CALL(cudaFuncSetCacheConfig(
+            cuda_parallel_launch_local_memory<DriverType>,
+            (prefer_shmem ? cudaFuncCachePreferShared
+                          : cudaFuncCachePreferL1)));
       }
-      #endif
+#endif
 
       KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE();
 
       // Invoke the driver function on the device
-      cuda_parallel_launch_local_memory< DriverType >
-          <<< grid , block , shmem , cuda_instance->m_stream >>>( driver );
+      cuda_parallel_launch_local_memory<DriverType>
+          <<<grid, block, shmem, cuda_instance->m_stream>>>(driver);
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-      CUDA_SAFE_CALL( cudaGetLastError() );
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+      CUDA_SAFE_CALL(cudaGetLastError());
       Kokkos::Cuda().fence();
 #endif
     }
@@ -448,111 +436,101 @@ struct CudaParallelLaunch< DriverType
 
   static cudaFuncAttributes get_cuda_func_attributes() {
     cudaFuncAttributes attr;
-    cudaFuncGetAttributes(&attr,cuda_parallel_launch_local_memory
-            < DriverType >);
+    CUDA_SAFE_CALL(cudaFuncGetAttributes(
+        &attr, cuda_parallel_launch_local_memory<DriverType>));
     return attr;
   }
 };
 
-template < class DriverType
-         , unsigned int MaxThreadsPerBlock
-         , unsigned int MinBlocksPerSM>
-struct CudaParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds< MaxThreadsPerBlock
-                                               , MinBlocksPerSM>
-                         , Experimental::CudaLaunchMechanism::GlobalMemory >
-{
-  inline
-  CudaParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int          shmem
-                    , CudaInternal* cuda_instance
-                    , const bool prefer_shmem )
-  {
-    if ( (grid.x != 0) && ( ( block.x * block.y * block.z ) != 0 ) ) {
-
-      if ( cuda_instance->m_maxShmemPerBlock < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("CudaParallelLaunch FAILED: shared memory request is too large") );
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct CudaParallelLaunch<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>,
+    Experimental::CudaLaunchMechanism::GlobalMemory> {
+  inline CudaParallelLaunch(const DriverType& driver, const dim3& grid,
+                            const dim3& block, const int shmem,
+                            CudaInternal* cuda_instance,
+                            const bool prefer_shmem) {
+    if ((grid.x != 0) && ((block.x * block.y * block.z) != 0)) {
+      if (cuda_instance->m_maxShmemPerBlock < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "CudaParallelLaunch FAILED: shared memory request is too large"));
       }
-      #ifndef KOKKOS_ARCH_KEPLER
+#ifndef KOKKOS_ARCH_KEPLER
       // On Kepler the L1 has no benefit since it doesn't cache reads
       else {
-        CUDA_SAFE_CALL(
-          cudaFuncSetCacheConfig
-            ( cuda_parallel_launch_global_memory
-                < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >
-            , ( prefer_shmem ? cudaFuncCachePreferShared : cudaFuncCachePreferL1 )
-            ) );
+        CUDA_SAFE_CALL(cudaFuncSetCacheConfig(
+            cuda_parallel_launch_global_memory<DriverType, MaxThreadsPerBlock,
+                                               MinBlocksPerSM>,
+            (prefer_shmem ? cudaFuncCachePreferShared
+                          : cudaFuncCachePreferL1)));
       }
-      #endif
+#endif
 
       KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE();
 
       DriverType* driver_ptr = NULL;
-      driver_ptr = reinterpret_cast<DriverType*>(cuda_instance->scratch_functor(sizeof(DriverType)));
-      cudaMemcpyAsync(driver_ptr,&driver, sizeof(DriverType), cudaMemcpyDefault, cuda_instance->m_stream);
+      driver_ptr             = reinterpret_cast<DriverType*>(
+          cuda_instance->scratch_functor(sizeof(DriverType)));
+      cudaMemcpyAsync(driver_ptr, &driver, sizeof(DriverType),
+                      cudaMemcpyDefault, cuda_instance->m_stream);
 
       // Invoke the driver function on the device
-      cuda_parallel_launch_global_memory
-        < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >
-          <<< grid , block , shmem , cuda_instance->m_stream >>>( driver_ptr );
+      cuda_parallel_launch_global_memory<DriverType, MaxThreadsPerBlock,
+                                         MinBlocksPerSM>
+          <<<grid, block, shmem, cuda_instance->m_stream>>>(driver_ptr);
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-      CUDA_SAFE_CALL( cudaGetLastError() );
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+      CUDA_SAFE_CALL(cudaGetLastError());
       Kokkos::Cuda().fence();
 #endif
     }
   }
   static cudaFuncAttributes get_cuda_func_attributes() {
     cudaFuncAttributes attr;
-    cudaFuncGetAttributes(&attr,cuda_parallel_launch_global_memory
-            < DriverType, MaxThreadsPerBlock, MinBlocksPerSM >);
+    CUDA_SAFE_CALL(cudaFuncGetAttributes(
+        &attr,
+        cuda_parallel_launch_global_memory<DriverType, MaxThreadsPerBlock,
+                                           MinBlocksPerSM>));
     return attr;
   }
-
 };
 
-template < class DriverType>
-struct CudaParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds<0,0>
-                         , Experimental::CudaLaunchMechanism::GlobalMemory >
-{
-  inline
-  CudaParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int          shmem
-                    , CudaInternal* cuda_instance
-                    , const bool prefer_shmem)
-  {
-    if ( (grid.x != 0) && ( ( block.x * block.y * block.z ) != 0 ) ) {
-
-      if ( cuda_instance->m_maxShmemPerBlock < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("CudaParallelLaunch FAILED: shared memory request is too large") );
+template <class DriverType>
+struct CudaParallelLaunch<DriverType, Kokkos::LaunchBounds<0, 0>,
+                          Experimental::CudaLaunchMechanism::GlobalMemory> {
+  inline CudaParallelLaunch(const DriverType& driver, const dim3& grid,
+                            const dim3& block, const int shmem,
+                            CudaInternal* cuda_instance,
+                            const bool prefer_shmem) {
+    if ((grid.x != 0) && ((block.x * block.y * block.z) != 0)) {
+      if (cuda_instance->m_maxShmemPerBlock < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "CudaParallelLaunch FAILED: shared memory request is too large"));
       }
-      #ifndef KOKKOS_ARCH_KEPLER
+#ifndef KOKKOS_ARCH_KEPLER
       // On Kepler the L1 has no benefit since it doesn't cache reads
       else {
-        CUDA_SAFE_CALL(
-          cudaFuncSetCacheConfig
-            ( cuda_parallel_launch_global_memory< DriverType >
-            , ( prefer_shmem ? cudaFuncCachePreferShared : cudaFuncCachePreferL1 )
-            ) );
+        CUDA_SAFE_CALL(cudaFuncSetCacheConfig(
+            cuda_parallel_launch_global_memory<DriverType>,
+            (prefer_shmem ? cudaFuncCachePreferShared
+                          : cudaFuncCachePreferL1)));
       }
-      #endif
+#endif
 
       KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE();
 
       DriverType* driver_ptr = NULL;
-      driver_ptr = reinterpret_cast<DriverType*>(cuda_instance->scratch_functor(sizeof(DriverType)));
-      cudaMemcpyAsync(driver_ptr,&driver, sizeof(DriverType), cudaMemcpyDefault, cuda_instance->m_stream);
+      driver_ptr             = reinterpret_cast<DriverType*>(
+          cuda_instance->scratch_functor(sizeof(DriverType)));
+      cudaMemcpyAsync(driver_ptr, &driver, sizeof(DriverType),
+                      cudaMemcpyDefault, cuda_instance->m_stream);
 
-      cuda_parallel_launch_global_memory< DriverType >
-          <<< grid , block , shmem , cuda_instance->m_stream >>>( driver_ptr );
+      cuda_parallel_launch_global_memory<DriverType>
+          <<<grid, block, shmem, cuda_instance->m_stream>>>(driver_ptr);
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-      CUDA_SAFE_CALL( cudaGetLastError() );
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+      CUDA_SAFE_CALL(cudaGetLastError());
       Kokkos::Cuda().fence();
 #endif
     }
@@ -560,15 +538,15 @@ struct CudaParallelLaunch< DriverType
 
   static cudaFuncAttributes get_cuda_func_attributes() {
     cudaFuncAttributes attr;
-    cudaFuncGetAttributes(&attr,cuda_parallel_launch_global_memory
-            < DriverType >);
+    CUDA_SAFE_CALL(cudaFuncGetAttributes(
+        &attr, cuda_parallel_launch_global_memory<DriverType>));
     return attr;
   }
 };
 //----------------------------------------------------------------------------
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -576,4 +554,3 @@ struct CudaParallelLaunch< DriverType
 #endif /* defined( __CUDACC__ ) */
 #endif /* defined( KOKKOS_ENABLE_CUDA ) */
 #endif /* #ifndef KOKKOS_CUDAEXEC_HPP */
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.cpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.cpp
index f1828ea2de75926a912ed2dea8a8aaa8ea515543..07dadb3c16eeea14ea379e21fd873199d3b9bebc 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.cpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,10 +53,10 @@
 #ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
 namespace Kokkos {
 namespace Impl {
-__device__ __constant__
-CudaLockArrays g_device_cuda_lock_arrays = { nullptr, nullptr, 0 };
-}
+__device__ __constant__ CudaLockArrays g_device_cuda_lock_arrays = {nullptr,
+                                                                    nullptr, 0};
 }
+}  // namespace Kokkos
 #endif
 
 namespace Kokkos {
@@ -63,36 +64,38 @@ namespace Kokkos {
 namespace {
 
 __global__ void init_lock_array_kernel_atomic() {
-  unsigned i = blockIdx.x*blockDim.x + threadIdx.x;
-  if(i<CUDA_SPACE_ATOMIC_MASK+1) {
+  unsigned i = blockIdx.x * blockDim.x + threadIdx.x;
+  if (i < CUDA_SPACE_ATOMIC_MASK + 1) {
     Kokkos::Impl::g_device_cuda_lock_arrays.atomic[i] = 0;
   }
 }
 
 __global__ void init_lock_array_kernel_threadid(int N) {
-  unsigned i = blockIdx.x*blockDim.x + threadIdx.x;
-  if(i<(unsigned)N) {
+  unsigned i = blockIdx.x * blockDim.x + threadIdx.x;
+  if (i < (unsigned)N) {
     Kokkos::Impl::g_device_cuda_lock_arrays.scratch[i] = 0;
   }
 }
 
-} // namespace
+}  // namespace
 
 namespace Impl {
 
-CudaLockArrays g_host_cuda_lock_arrays = { nullptr, nullptr, 0 };
+CudaLockArrays g_host_cuda_lock_arrays = {nullptr, nullptr, 0};
 
 void initialize_host_cuda_lock_arrays() {
   if (g_host_cuda_lock_arrays.atomic != nullptr) return;
   CUDA_SAFE_CALL(cudaMalloc(&g_host_cuda_lock_arrays.atomic,
-                 sizeof(int)*(CUDA_SPACE_ATOMIC_MASK+1)));
+                            sizeof(int) * (CUDA_SPACE_ATOMIC_MASK + 1)));
   CUDA_SAFE_CALL(cudaMalloc(&g_host_cuda_lock_arrays.scratch,
-                 sizeof(int)*(Cuda::concurrency())));
+                            sizeof(int) * (Cuda::concurrency())));
   CUDA_SAFE_CALL(cudaDeviceSynchronize());
   g_host_cuda_lock_arrays.n = Cuda::concurrency();
   KOKKOS_COPY_CUDA_LOCK_ARRAYS_TO_DEVICE();
-  init_lock_array_kernel_atomic<<<(CUDA_SPACE_ATOMIC_MASK+1+255)/256,256>>>();
-  init_lock_array_kernel_threadid<<<(Kokkos::Cuda::concurrency()+255)/256,256>>>(Kokkos::Cuda::concurrency());
+  init_lock_array_kernel_atomic<<<(CUDA_SPACE_ATOMIC_MASK + 1 + 255) / 256,
+                                  256>>>();
+  init_lock_array_kernel_threadid<<<(Kokkos::Cuda::concurrency() + 255) / 256,
+                                    256>>>(Kokkos::Cuda::concurrency());
   CUDA_SAFE_CALL(cudaDeviceSynchronize());
 }
 
@@ -102,15 +105,15 @@ void finalize_host_cuda_lock_arrays() {
   g_host_cuda_lock_arrays.atomic = nullptr;
   cudaFree(g_host_cuda_lock_arrays.scratch);
   g_host_cuda_lock_arrays.scratch = nullptr;
-  g_host_cuda_lock_arrays.n = 0;
+  g_host_cuda_lock_arrays.n       = 0;
 #ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
   KOKKOS_COPY_CUDA_LOCK_ARRAYS_TO_DEVICE();
 #endif
 }
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #else
 
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.hpp
index cfc46f0461cfeccdeba93de557c6bc0830733c4a..a4b5d08ccf6f1cf56e97270df2699daa3d4ef3f5 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Locks.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -63,7 +64,7 @@ struct CudaLockArrays {
 
 /// \brief This global variable in Host space is the central definition
 ///        of these arrays.
-extern Kokkos::Impl::CudaLockArrays g_host_cuda_lock_arrays ;
+extern Kokkos::Impl::CudaLockArrays g_host_cuda_lock_arrays;
 
 /// \brief After this call, the g_host_cuda_lock_arrays variable has
 ///        valid, initialized arrays.
@@ -77,10 +78,10 @@ void initialize_host_cuda_lock_arrays();
 /// This call is idempotent.
 void finalize_host_cuda_lock_arrays();
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
-#if defined( __CUDACC__ )
+#if defined(__CUDACC__)
 
 namespace Kokkos {
 namespace Impl {
@@ -106,10 +107,9 @@ namespace Impl {
 /// That is the purpose of the KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE macro.
 __device__
 #ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-__constant__
-extern
+    __constant__ extern
 #endif
-Kokkos::Impl::CudaLockArrays g_device_cuda_lock_arrays ;
+    Kokkos::Impl::CudaLockArrays g_device_cuda_lock_arrays;
 
 #define CUDA_SPACE_ATOMIC_MASK 0x1FFFF
 
@@ -118,12 +118,13 @@ Kokkos::Impl::CudaLockArrays g_device_cuda_lock_arrays ;
 /// This function tries to acquire the lock for the hash value derived
 /// from the provided ptr. If the lock is successfully acquired the
 /// function returns true. Otherwise it returns false.
-__device__ inline
-bool lock_address_cuda_space(void* ptr) {
+__device__ inline bool lock_address_cuda_space(void* ptr) {
   size_t offset = size_t(ptr);
-  offset = offset >> 2;
-  offset = offset & CUDA_SPACE_ATOMIC_MASK;
-  return (0 == atomicCAS(&Kokkos::Impl::g_device_cuda_lock_arrays.atomic[offset],0,1));
+  offset        = offset >> 2;
+  offset        = offset & CUDA_SPACE_ATOMIC_MASK;
+  return (
+      0 ==
+      atomicCAS(&Kokkos::Impl::g_device_cuda_lock_arrays.atomic[offset], 0, 1));
 }
 
 /// \brief Release lock for the address
@@ -132,47 +133,44 @@ bool lock_address_cuda_space(void* ptr) {
 /// from the provided ptr. This function should only be called
 /// after previously successfully acquiring a lock with
 /// lock_address.
-__device__ inline
-void unlock_address_cuda_space(void* ptr) {
+__device__ inline void unlock_address_cuda_space(void* ptr) {
   size_t offset = size_t(ptr);
-  offset = offset >> 2;
-  offset = offset & CUDA_SPACE_ATOMIC_MASK;
-  atomicExch( &Kokkos::Impl::g_device_cuda_lock_arrays.atomic[ offset ], 0);
+  offset        = offset >> 2;
+  offset        = offset & CUDA_SPACE_ATOMIC_MASK;
+  atomicExch(&Kokkos::Impl::g_device_cuda_lock_arrays.atomic[offset], 0);
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 // Make lock_array_copied an explicit translation unit scope thingy
 namespace Kokkos {
 namespace Impl {
 namespace {
-  static int lock_array_copied = 0;
-  inline int eliminate_warning_for_lock_array() {
-    return lock_array_copied;
-  }
-}
-}
-}
+static int lock_array_copied = 0;
+inline int eliminate_warning_for_lock_array() { return lock_array_copied; }
+}  // namespace
+}  // namespace Impl
+}  // namespace Kokkos
 /* Dan Ibanez: it is critical that this code be a macro, so that it will
    capture the right address for Kokkos::Impl::g_device_cuda_lock_arrays!
    putting this in an inline function will NOT do the right thing! */
-#define KOKKOS_COPY_CUDA_LOCK_ARRAYS_TO_DEVICE() \
-{ \
-  if(::Kokkos::Impl::lock_array_copied == 0) { \
-    CUDA_SAFE_CALL(cudaMemcpyToSymbol( \
-        Kokkos::Impl::g_device_cuda_lock_arrays , \
-        & Kokkos::Impl::g_host_cuda_lock_arrays , \
-        sizeof(Kokkos::Impl::CudaLockArrays) ) ); \
-  } \
-  lock_array_copied = 1; \
-  \
-}
+#define KOKKOS_COPY_CUDA_LOCK_ARRAYS_TO_DEVICE()                      \
+  {                                                                   \
+    if (::Kokkos::Impl::lock_array_copied == 0) {                     \
+      CUDA_SAFE_CALL(                                                 \
+          cudaMemcpyToSymbol(Kokkos::Impl::g_device_cuda_lock_arrays, \
+                             &Kokkos::Impl::g_host_cuda_lock_arrays,  \
+                             sizeof(Kokkos::Impl::CudaLockArrays)));  \
+    }                                                                 \
+    lock_array_copied = 1;                                            \
+  }
 
 #ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
 #define KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE()
 #else
-#define KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE() KOKKOS_COPY_CUDA_LOCK_ARRAYS_TO_DEVICE()
+#define KOKKOS_ENSURE_CUDA_LOCK_ARRAYS_ON_DEVICE() \
+  KOKKOS_COPY_CUDA_LOCK_ARRAYS_TO_DEVICE()
 #endif
 
 #endif /* defined( __CUDACC__ ) */
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Parallel.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Parallel.hpp
index 860d94d6c778e7cc44218bfbdf9213778f0271cf..78db807478642fbfb4aa4450643d2e344d80f159 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Parallel.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Parallel.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_CUDA_PARALLEL_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
 
 #include <iostream>
 #include <algorithm>
@@ -78,202 +79,223 @@ extern bool show_warnings() noexcept;
 
 namespace Impl {
 
-template< class ... Properties >
-class TeamPolicyInternal< Kokkos::Cuda , Properties ... >: public PolicyTraits<Properties ... >
-{
-public:
-
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Cuda, Properties...>
+    : public PolicyTraits<Properties...> {
+ public:
   //! Tag this class as a kokkos execution policy
-  typedef TeamPolicyInternal      execution_policy ;
+  typedef TeamPolicyInternal execution_policy;
 
-  typedef PolicyTraits<Properties ... > traits;
+  typedef PolicyTraits<Properties...> traits;
 
-  template< class ExecSpace, class ... OtherProperties >
+  template <class ExecSpace, class... OtherProperties>
   friend class TeamPolicyInternal;
 
-private:
-
+ private:
   enum { MAX_WARP = 8 };
 
   typename traits::execution_space m_space;
-  int m_league_size ;
-  int m_team_size ;
-  int m_vector_length ;
-  int m_team_scratch_size[2] ;
-  int m_thread_scratch_size[2] ;
+  int m_league_size;
+  int m_team_size;
+  int m_vector_length;
+  int m_team_scratch_size[2];
+  int m_thread_scratch_size[2];
   int m_chunk_size;
 
-public:
-
+ public:
   //! Execution space of this execution policy
-  typedef Kokkos::Cuda  execution_space ;
-
-  template<class ... OtherProperties>
-  TeamPolicyInternal( const TeamPolicyInternal<OtherProperties...>& p ) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_vector_length = p.m_vector_length;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+  typedef Kokkos::Cuda execution_space;
+
+  template <class... OtherProperties>
+  TeamPolicyInternal(const TeamPolicyInternal<OtherProperties...>& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_vector_length          = p.m_vector_length;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
-    m_space = p.m_space;
+    m_chunk_size             = p.m_chunk_size;
+    m_space                  = p.m_space;
   }
 
-  TeamPolicyInternal& operator = (const TeamPolicyInternal& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_vector_length = p.m_vector_length;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+  TeamPolicyInternal& operator=(const TeamPolicyInternal& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_vector_length          = p.m_vector_length;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
-    m_space = p.m_space;
+    m_chunk_size             = p.m_chunk_size;
+    m_space                  = p.m_space;
     return *this;
   }
 
   //----------------------------------------
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  template< class FunctorType >
-  static inline
-  int team_size_max( const FunctorType & functor )
-    {
-      int n = MAX_WARP * Impl::CudaTraits::WarpSize ;
-
-      for ( ; n ; n >>= 1 ) {
-        const int shmem_size =
-          /* for global reduce */ Impl::cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,typename traits::work_tag>( functor , n )
-          /* for team   reduce */ + ( n + 2 ) * sizeof(double)
-          /* for team   shared */ + Impl::FunctorTeamShmemSize< FunctorType >::value( functor , n );
-
-        if ( shmem_size < typename traits::execution_space().impl_internal_space_instance()->m_maxShmemPerBlock ) break ;
-      }
-
-      return n ;
-    }
+  template <class FunctorType>
+  static inline int team_size_max(const FunctorType& functor) {
+    int n = MAX_WARP * Impl::CudaTraits::WarpSize;
+
+    for (; n; n >>= 1) {
+      const int shmem_size =
+          /* for global reduce */ Impl::
+              cuda_single_inter_block_reduce_scan_shmem<
+                  false, FunctorType, typename traits::work_tag>(functor, n)
+          /* for team   reduce */
+          + (n + 2) * sizeof(double)
+          /* for team   shared */
+          + Impl::FunctorTeamShmemSize<FunctorType>::value(functor, n);
+
+      if (shmem_size < typename traits::execution_space()
+                           .impl_internal_space_instance()
+                           ->m_maxShmemPerBlock)
+        break;
+    }
+
+    return n;
+  }
 #endif
 
-  template<class FunctorType>
-  int team_size_max( const FunctorType& f, const ParallelForTag& ) const {
-    typedef Impl::ParallelFor< FunctorType , TeamPolicy<Properties...> > closure_type;
-    cudaFuncAttributes attr = CudaParallelLaunch< closure_type, typename traits::launch_bounds >::
-        get_cuda_func_attributes();
-    int block_size = Kokkos::Impl::cuda_get_max_block_size< FunctorType, typename traits::launch_bounds >( 
-        space().impl_internal_space_instance(),attr,f ,(size_t) vector_length(),
-        (size_t) team_scratch_size(0) + 2*sizeof(double), (size_t) thread_scratch_size(0) + sizeof(double) );
-    return block_size/vector_length();
-  }
-
-  template<class FunctorType>
-  int team_size_max( const FunctorType& f, const ParallelReduceTag& ) const {
-    typedef Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,TeamPolicyInternal,FunctorType> functor_analysis_type;
-    typedef typename Impl::ParallelReduceReturnValue<void,typename functor_analysis_type::value_type,FunctorType>::reducer_type reducer_type;
-    typedef Impl::ParallelReduce< FunctorType , TeamPolicy<Properties...>, reducer_type > closure_type;
-    typedef Impl::FunctorValueTraits< FunctorType , typename traits::work_tag > functor_value_traits;
-
-    cudaFuncAttributes attr = CudaParallelLaunch< closure_type, typename traits::launch_bounds >::
-        get_cuda_func_attributes();
-    int block_size = Kokkos::Impl::cuda_get_max_block_size< FunctorType, typename traits::launch_bounds >( 
-        space().impl_internal_space_instance(),attr,f ,(size_t) vector_length(),
-        (size_t) team_scratch_size(0) + 2*sizeof(double), (size_t) thread_scratch_size(0) + sizeof(double) +
-                                                          ((functor_value_traits::StaticValueSize!=0)?0:functor_value_traits::value_size( f )));
+  template <class FunctorType>
+  int team_size_max(const FunctorType& f, const ParallelForTag&) const {
+    typedef Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>
+        closure_type;
+    cudaFuncAttributes attr =
+        CudaParallelLaunch<closure_type, typename traits::launch_bounds>::
+            get_cuda_func_attributes();
+    int block_size =
+        Kokkos::Impl::cuda_get_max_block_size<FunctorType,
+                                              typename traits::launch_bounds>(
+            space().impl_internal_space_instance(), attr, f,
+            (size_t)vector_length(),
+            (size_t)team_scratch_size(0) + 2 * sizeof(double),
+            (size_t)thread_scratch_size(0) + sizeof(double));
+    return block_size / vector_length();
+  }
 
-    // Currently we require Power-of-2 team size for reductions.
-    int p2 = 1;
-    while(p2<=block_size) p2*=2;
-    p2/=2;
-    return p2/vector_length();
+  template <class FunctorType>
+  inline int team_size_max(const FunctorType& f,
+                           const ParallelReduceTag&) const {
+    typedef Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                                  TeamPolicyInternal, FunctorType>
+        functor_analysis_type;
+    typedef typename Impl::ParallelReduceReturnValue<
+        void, typename functor_analysis_type::value_type,
+        FunctorType>::reducer_type reducer_type;
+    typedef Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
+                                 reducer_type>
+        closure_type;
+    return internal_team_size_max<closure_type>(f);
+  }
+
+  template <class FunctorType, class ReducerType>
+  inline int team_size_max(const FunctorType& f, const ReducerType& r,
+                           const ParallelReduceTag&) const {
+    using closure_type =
+        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
+                             ReducerType>;
+    return internal_team_size_max<closure_type>(f);
   }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  template< class FunctorType >
-  static int team_size_recommended( const FunctorType & functor )
-    { return team_size_max( functor ); }
+  template <class FunctorType>
+  static int team_size_recommended(const FunctorType& functor) {
+    return team_size_max(functor);
+  }
 
-  template< class FunctorType >
-  static int team_size_recommended( const FunctorType & functor , const int vector_length)
-    {
-      int max = team_size_max( functor )/vector_length;
-      if(max<1) max = 1;
-      return max;
-    }
+  template <class FunctorType>
+  static int team_size_recommended(const FunctorType& functor,
+                                   const int vector_length) {
+    int max = team_size_max(functor) / vector_length;
+    if (max < 1) max = 1;
+    return max;
+  }
 #endif
 
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType& f, const ParallelForTag& ) const {
-    typedef Impl::ParallelFor< FunctorType , TeamPolicy<Properties...> > closure_type;
-    cudaFuncAttributes attr = CudaParallelLaunch< closure_type, typename traits::launch_bounds >::
-        get_cuda_func_attributes();
-    const int block_size = Kokkos::Impl::cuda_get_opt_block_size< FunctorType, typename traits::launch_bounds>(
-        space().impl_internal_space_instance(),
-        attr, f , (size_t) vector_length(),
-        (size_t) team_scratch_size(0) + 2*sizeof(double), (size_t) thread_scratch_size(0) + sizeof(double));
-    return block_size/vector_length();
-  }
-
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType& f, const ParallelReduceTag& ) const {
-    typedef Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,TeamPolicyInternal,FunctorType> functor_analysis_type;
-    typedef typename Impl::ParallelReduceReturnValue<void,typename functor_analysis_type::value_type,FunctorType>::reducer_type reducer_type;
-    typedef Impl::ParallelReduce< FunctorType , TeamPolicy<Properties...>, reducer_type > closure_type;
-    typedef Impl::FunctorValueTraits< FunctorType , typename traits::work_tag > functor_value_traits;
-
-    cudaFuncAttributes attr = CudaParallelLaunch< closure_type, typename traits::launch_bounds >::
-        get_cuda_func_attributes();
-    const int block_size = Kokkos::Impl::cuda_get_opt_block_size< FunctorType, typename traits::launch_bounds>(
-        space().impl_internal_space_instance(),
-        attr, f , (size_t) vector_length(),
-        (size_t) team_scratch_size(0) + 2*sizeof(double), (size_t) thread_scratch_size(0) + sizeof(double) +
-                                                          ((functor_value_traits::StaticValueSize!=0)?0:functor_value_traits::value_size( f )));
-    // Currently we require Power-of-2 team size for reductions.
-    int p2 = 1;
-    while(p2<=block_size) p2*=2;
-    p2/=2;
-    return p2/vector_length();
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType& f, const ParallelForTag&) const {
+    typedef Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>
+        closure_type;
+    cudaFuncAttributes attr =
+        CudaParallelLaunch<closure_type, typename traits::launch_bounds>::
+            get_cuda_func_attributes();
+    const int block_size =
+        Kokkos::Impl::cuda_get_opt_block_size<FunctorType,
+                                              typename traits::launch_bounds>(
+            space().impl_internal_space_instance(), attr, f,
+            (size_t)vector_length(),
+            (size_t)team_scratch_size(0) + 2 * sizeof(double),
+            (size_t)thread_scratch_size(0) + sizeof(double));
+    return block_size / vector_length();
   }
 
+  template <class FunctorType>
+  inline int team_size_recommended(const FunctorType& f,
+                                   const ParallelReduceTag&) const {
+    typedef Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                                  TeamPolicyInternal, FunctorType>
+        functor_analysis_type;
+    typedef typename Impl::ParallelReduceReturnValue<
+        void, typename functor_analysis_type::value_type,
+        FunctorType>::reducer_type reducer_type;
+    typedef Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
+                                 reducer_type>
+        closure_type;
+    return internal_team_size_recommended<closure_type>(f);
+  }
 
-  inline static
-  int vector_length_max()
-    { return Impl::CudaTraits::WarpSize; }
+  template <class FunctorType, class ReducerType>
+  int team_size_recommended(const FunctorType& f, const ReducerType&,
+                            const ParallelReduceTag&) const {
+    typedef Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
+                                 ReducerType>
+        closure_type;
+    return internal_team_size_recommended<closure_type>(f);
+  }
 
-  inline static
-  int verify_requested_vector_length( int requested_vector_length ) {
-      int test_vector_length = std::min( requested_vector_length, vector_length_max() );
+  inline static int vector_length_max() { return Impl::CudaTraits::WarpSize; }
 
-      // Allow only power-of-two vector_length
-      if ( !(is_integral_power_of_two( test_vector_length ) ) ) {
-         int test_pow2 = 1;
-         for (int i = 0; i < 5; i++) {
-            test_pow2 = test_pow2 << 1;
-            if (test_pow2 > test_vector_length) {
-               break;
-            }
-         }
-         test_vector_length = test_pow2 >> 1;
+  inline static int verify_requested_vector_length(
+      int requested_vector_length) {
+    int test_vector_length =
+        std::min(requested_vector_length, vector_length_max());
+
+    // Allow only power-of-two vector_length
+    if (!(is_integral_power_of_two(test_vector_length))) {
+      int test_pow2 = 1;
+      for (int i = 0; i < 5; i++) {
+        test_pow2 = test_pow2 << 1;
+        if (test_pow2 > test_vector_length) {
+          break;
+        }
       }
+      test_vector_length = test_pow2 >> 1;
+    }
 
-      return test_vector_length;
+    return test_vector_length;
   }
 
-  inline static
-  int scratch_size_max(int level)
-    { return (level==0?
-        1024*40:             // 48kB is the max for CUDA, but we need some for team_member.reduce etc.
-        20*1024*1024);   // arbitrarily setting this to 20MB, for a Volta V100 that would give us about 3.2GB for 2 teams per SM
-    }
+  inline static int scratch_size_max(int level) {
+    return (
+        level == 0 ? 1024 * 40 :  // 48kB is the max for CUDA, but we need some
+                                  // for team_member.reduce etc.
+            20 * 1024 *
+                1024);  // arbitrarily setting this to 20MB, for a Volta V100
+                        // that would give us about 3.2GB for 2 teams per SM
+  }
 
   //----------------------------------------
 
-  inline int vector_length()   const { return m_vector_length ; }
-  inline int team_size()   const { return m_team_size ; }
-  inline int league_size() const { return m_league_size ; }
+  inline int vector_length() const { return m_vector_length; }
+  inline int team_size() const { return m_team_size; }
+  inline int league_size() const { return m_league_size; }
   inline int scratch_size(int level, int team_size_ = -1) const {
-    if(team_size_<0) team_size_ = m_team_size;
-    return m_team_scratch_size[level] + team_size_*m_thread_scratch_size[level];
+    if (team_size_ < 0) team_size_ = m_team_size;
+    return m_team_scratch_size[level] +
+           team_size_ * m_thread_scratch_size[level];
   }
   inline int team_scratch_size(int level) const {
     return m_team_scratch_size[level];
@@ -282,189 +304,259 @@ public:
     return m_thread_scratch_size[level];
   }
 
-  inline typename traits::execution_space space() const {
-    return m_space;
-  }
+  inline typename traits::execution_space space() const { return m_space; }
 
   TeamPolicyInternal()
-    : m_space(typename traits::execution_space())
-    , m_league_size( 0 )
-    , m_team_size( -1 )
-    , m_vector_length( 0 )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 32 )
-   {}
+      : m_space(typename traits::execution_space()),
+        m_league_size(0),
+        m_team_size(-1),
+        m_vector_length(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(32) {}
 
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal( const execution_space space_
-            , int league_size_
-            , int team_size_request
-            , int vector_length_request = 1 )
-    : m_space( space_ )
-    , m_league_size( league_size_ )
-    , m_team_size( team_size_request )
-    , m_vector_length( verify_requested_vector_length(vector_length_request) )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 32 )
-    {
-      // Make sure league size is permissible
-      if(league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
-        Impl::throw_runtime_exception( "Requested too large league_size for TeamPolicy on Cuda execution space.");
-
-      // Make sure total block size is permissible
-      if ( m_team_size * m_vector_length > 1024 ) {
-        Impl::throw_runtime_exception(std::string("Kokkos::TeamPolicy< Cuda > the team size is too large. Team size x vector length must be smaller than 1024."));
-      }
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     int team_size_request, int vector_length_request = 1)
+      : m_space(space_),
+        m_league_size(league_size_),
+        m_team_size(team_size_request),
+        m_vector_length(verify_requested_vector_length(vector_length_request)),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(32) {
+    // Make sure league size is permissible
+    if (league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
+      Impl::throw_runtime_exception(
+          "Requested too large league_size for TeamPolicy on Cuda execution "
+          "space.");
+
+    // Make sure total block size is permissible
+    if (m_team_size * m_vector_length > 1024) {
+      Impl::throw_runtime_exception(
+          std::string("Kokkos::TeamPolicy< Cuda > the team size is too large. "
+                      "Team size x vector length must be smaller than 1024."));
     }
+  }
 
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal( const execution_space space_
-            , int league_size_
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int vector_length_request = 1 )
-    : m_space( space_ )
-    , m_league_size( league_size_ )
-    , m_team_size( -1 )
-    , m_vector_length( verify_requested_vector_length(vector_length_request) )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 32 )
-    {
-      // Make sure league size is permissible
-      if(league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
-        Impl::throw_runtime_exception( "Requested too large league_size for TeamPolicy on Cuda execution space.");
-    }
-
-  TeamPolicyInternal( int league_size_
-            , int team_size_request
-            , int vector_length_request = 1 )
-    : m_space( typename traits::execution_space() )
-    , m_league_size( league_size_ )
-    , m_team_size( team_size_request )
-    , m_vector_length ( verify_requested_vector_length(vector_length_request) )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 32 )
-    {
-      // Make sure league size is permissible
-      if(league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
-        Impl::throw_runtime_exception( "Requested too large league_size for TeamPolicy on Cuda execution space.");
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int vector_length_request = 1)
+      : m_space(space_),
+        m_league_size(league_size_),
+        m_team_size(-1),
+        m_vector_length(verify_requested_vector_length(vector_length_request)),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(32) {
+    // Make sure league size is permissible
+    if (league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
+      Impl::throw_runtime_exception(
+          "Requested too large league_size for TeamPolicy on Cuda execution "
+          "space.");
+  }
 
-      // Make sure total block size is permissible
-      if ( m_team_size * m_vector_length > 1024 ) {
-        Impl::throw_runtime_exception(std::string("Kokkos::TeamPolicy< Cuda > the team size is too large. Team size x vector length must be smaller than 1024."));
-      }
+  TeamPolicyInternal(int league_size_, int team_size_request,
+                     int vector_length_request = 1)
+      : m_space(typename traits::execution_space()),
+        m_league_size(league_size_),
+        m_team_size(team_size_request),
+        m_vector_length(verify_requested_vector_length(vector_length_request)),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(32) {
+    // Make sure league size is permissible
+    if (league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
+      Impl::throw_runtime_exception(
+          "Requested too large league_size for TeamPolicy on Cuda execution "
+          "space.");
+
+    // Make sure total block size is permissible
+    if (m_team_size * m_vector_length > 1024) {
+      Impl::throw_runtime_exception(
+          std::string("Kokkos::TeamPolicy< Cuda > the team size is too large. "
+                      "Team size x vector length must be smaller than 1024."));
     }
+  }
 
-  TeamPolicyInternal( int league_size_
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int vector_length_request = 1 )
-    : m_space( typename traits::execution_space() )
-    , m_league_size( league_size_ )
-    , m_team_size( -1 )
-    , m_vector_length ( verify_requested_vector_length(vector_length_request) )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 32 )
-    {
-      // Make sure league size is permissible
-      if(league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
-        Impl::throw_runtime_exception( "Requested too large league_size for TeamPolicy on Cuda execution space.");
-    }
+  TeamPolicyInternal(int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int vector_length_request = 1)
+      : m_space(typename traits::execution_space()),
+        m_league_size(league_size_),
+        m_team_size(-1),
+        m_vector_length(verify_requested_vector_length(vector_length_request)),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(32) {
+    // Make sure league size is permissible
+    if (league_size_ >= int(Impl::cuda_internal_maximum_grid_count()))
+      Impl::throw_runtime_exception(
+          "Requested too large league_size for TeamPolicy on Cuda execution "
+          "space.");
+  }
 
-  inline int chunk_size() const { return m_chunk_size ; }
+  inline int chunk_size() const { return m_chunk_size; }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal set_chunk_size(typename traits::index_type chunk_size_) const {
+  inline TeamPolicyInternal set_chunk_size(
+      typename traits::index_type chunk_size_) const {
     TeamPolicyInternal p = *this;
-    p.m_chunk_size = chunk_size_;
+    p.m_chunk_size       = chunk_size_;
     return p;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team) const {
+    TeamPolicyInternal p         = *this;
     p.m_team_scratch_size[level] = per_team.value;
     return p;
   };
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   };
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
-    p.m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
+    p.m_team_scratch_size[level]   = per_team.value;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   };
 #else
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal& set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal& set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(const int& level,
+                                              const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-  typedef Kokkos::Impl::CudaTeamMember member_type ;
+  typedef Kokkos::Impl::CudaTeamMember member_type;
 
-protected:
+ protected:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal internal_set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal internal_set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
+
+  template <class ClosureType, class FunctorType, class BlockSizeCallable>
+  int internal_team_size_common(const FunctorType& f,
+                                BlockSizeCallable&& block_size_callable) const {
+    using closure_type = ClosureType;
+    using functor_value_traits =
+        Impl::FunctorValueTraits<FunctorType, typename traits::work_tag>;
+
+    cudaFuncAttributes attr =
+        CudaParallelLaunch<closure_type, typename traits::launch_bounds>::
+            get_cuda_func_attributes();
+    const int block_size = std::forward<BlockSizeCallable>(block_size_callable)(
+        space().impl_internal_space_instance(), attr, f,
+        (size_t)vector_length(),
+        (size_t)team_scratch_size(0) + 2 * sizeof(double),
+        (size_t)thread_scratch_size(0) + sizeof(double) +
+            ((functor_value_traits::StaticValueSize != 0)
+                 ? 0
+                 : functor_value_traits::value_size(f)));
+    KOKKOS_ASSERT(block_size > 0);
+
+    // Currently we require Power-of-2 team size for reductions.
+    int p2 = 1;
+    while (p2 <= block_size) p2 *= 2;
+    p2 /= 2;
+    return p2 / vector_length();
+  }
+
+  template <class ClosureType, class FunctorType>
+  int internal_team_size_max(const FunctorType& f) const {
+    return internal_team_size_common<ClosureType>(
+        f,
+        Kokkos::Impl::cuda_get_max_block_size<FunctorType,
+                                              typename traits::launch_bounds>);
+  }
+
+  template <class ClosureType, class FunctorType>
+  int internal_team_size_recommended(const FunctorType& f) const {
+    return internal_team_size_common<ClosureType>(
+        f,
+        Kokkos::Impl::cuda_get_opt_block_size<FunctorType,
+                                              typename traits::launch_bounds>);
+  }
 };
 
-} // namspace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -472,262 +564,268 @@ protected:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::RangePolicy< Traits ... >
-                 , Kokkos::Cuda
-                 >
-{
-public:
-  typedef Kokkos::RangePolicy< Traits ... > Policy;
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
+ public:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::launch_bounds LaunchBounds ;
+ private:
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::launch_bounds LaunchBounds;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  ParallelFor() = delete ;
-  ParallelFor & operator = ( const ParallelFor & ) = delete ;
+  ParallelFor()        = delete;
+  ParallelFor& operator=(const ParallelFor&) = delete;
 
-  template< class TagType >
+  template <class TagType>
   inline __device__
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const Member i ) const
-    { m_functor( i ); }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const Member i) const {
+    m_functor(i);
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline __device__
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const Member i ) const
-    { m_functor( TagType() , i ); }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const Member i) const {
+    m_functor(TagType(), i);
+  }
 
-public:
+ public:
+  typedef FunctorType functor_type;
 
-  typedef FunctorType functor_type ;
+  inline __device__ void operator()(void) const {
+    const Member work_stride = blockDim.y * gridDim.x;
+    const Member work_end    = m_policy.end();
 
-  inline
-  __device__
-  void operator()(void) const
-    {
-      const Member work_stride = blockDim.y * gridDim.x ;
-      const Member work_end    = m_policy.end();
-
-      for ( Member
-              iwork =  m_policy.begin() + threadIdx.y + blockDim.y * blockIdx.x ;
-              iwork <  work_end ;
-              iwork = iwork < work_end - work_stride ? iwork + work_stride : work_end) {
-        this-> template exec_range< WorkTag >( iwork );
-      }
+    for (Member iwork =
+             m_policy.begin() + threadIdx.y + blockDim.y * blockIdx.x;
+         iwork < work_end;
+         iwork = iwork < work_end - work_stride ? iwork + work_stride
+                                                : work_end) {
+      this->template exec_range<WorkTag>(iwork);
     }
+  }
 
-  inline
-  void execute() const
-    {
-      const typename Policy::index_type nwork = m_policy.end() - m_policy.begin();
-
-      cudaFuncAttributes attr = CudaParallelLaunch< ParallelFor, LaunchBounds >::
-          get_cuda_func_attributes();
-      const int block_size = Kokkos::Impl::cuda_get_opt_block_size< FunctorType, LaunchBounds>(
-          m_policy.space().impl_internal_space_instance(),
-          attr, m_functor , 1, 0 , 0 );
-      const dim3 block(  1 , block_size , 1);
-      const dim3 grid( std::min( typename Policy::index_type(( nwork + block.y - 1 ) / block.y) ,
-                       typename Policy::index_type(cuda_internal_maximum_grid_count()) ) , 1 , 1);
-
-      CudaParallelLaunch< ParallelFor, LaunchBounds >( *this , grid , block , 0 , m_policy.space().impl_internal_space_instance() , false );
+  inline void execute() const {
+    const typename Policy::index_type nwork = m_policy.end() - m_policy.begin();
+
+    cudaFuncAttributes attr =
+        CudaParallelLaunch<ParallelFor,
+                           LaunchBounds>::get_cuda_func_attributes();
+    const int block_size =
+        Kokkos::Impl::cuda_get_opt_block_size<FunctorType, LaunchBounds>(
+            m_policy.space().impl_internal_space_instance(), attr, m_functor, 1,
+            0, 0);
+    dim3 block(1, block_size, 1);
+    dim3 grid(
+        std::min(
+            typename Policy::index_type((nwork + block.y - 1) / block.y),
+            typename Policy::index_type(cuda_internal_maximum_grid_count())),
+        1, 1);
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    if (Kokkos::Impl::CudaInternal::cuda_use_serial_execution()) {
+      block = dim3(1, 1, 1);
+      grid  = dim3(1, 1, 1);
     }
+#endif
 
-  ParallelFor( const FunctorType  & arg_functor ,
-               const Policy       & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    { }
+    CudaParallelLaunch<ParallelFor, LaunchBounds>(
+        *this, grid, block, 0, m_policy.space().impl_internal_space_instance(),
+        false);
+  }
 
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
-
 // MDRangePolicy impl
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::MDRangePolicy< Traits ... >
-                 , Kokkos::Cuda
-                 >
-{
-public:
-  typedef Kokkos::MDRangePolicy< Traits ...  > Policy ;
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, Kokkos::Cuda> {
+ public:
+  typedef Kokkos::MDRangePolicy<Traits...> Policy;
+
+ private:
   using RP = Policy;
   typedef typename Policy::array_index_type array_index_type;
   typedef typename Policy::index_type index_type;
   typedef typename Policy::launch_bounds LaunchBounds;
 
+  const FunctorType m_functor;
+  const Policy m_rp;
 
-  const FunctorType m_functor ;
-  const Policy      m_rp ;
-
-public:
-
-  inline
-  __device__
-  void operator()(void) const
-    {
-      Kokkos::Impl::Refactor::DeviceIterateTile<Policy::rank,Policy,FunctorType,typename Policy::work_tag>(m_rp,m_functor).exec_range();
-    }
-
+ public:
+  inline __device__ void operator()(void) const {
+    Kokkos::Impl::Refactor::DeviceIterateTile<Policy::rank, Policy, FunctorType,
+                                              typename Policy::work_tag>(
+        m_rp, m_functor)
+        .exec_range();
+  }
 
-  inline
-  void execute() const
-  {
-    if(m_rp.m_num_tiles==0) return;
-    const array_index_type maxblocks = static_cast<array_index_type>(m_rp.space().impl_internal_space_instance()->m_maxBlock);
-    if ( RP::rank == 2 )
-    {
-      const dim3 block( m_rp.m_tile[0] , m_rp.m_tile[1] , 1);
+  inline void execute() const {
+    if (m_rp.m_num_tiles == 0) return;
+    const array_index_type maxblocks = static_cast<array_index_type>(
+        m_rp.space().impl_internal_space_instance()->m_maxBlock);
+    if (RP::rank == 2) {
+      const dim3 block(m_rp.m_tile[0], m_rp.m_tile[1], 1);
       const dim3 grid(
-            std::min( ( m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1 ) / block.x , maxblocks )
-          , std::min( ( m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1 ) / block.y , maxblocks )
-          , 1
-          );
-      CudaParallelLaunch< ParallelFor, LaunchBounds >( *this , grid , block , 0 , m_rp.space().impl_internal_space_instance() , false );
-    }
-    else if ( RP::rank == 3 )
-    {
-      const dim3 block( m_rp.m_tile[0] , m_rp.m_tile[1] , m_rp.m_tile[2] );
+          std::min((m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1) / block.x,
+                   maxblocks),
+          std::min((m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1) / block.y,
+                   maxblocks),
+          1);
+      CudaParallelLaunch<ParallelFor, LaunchBounds>(
+          *this, grid, block, 0, m_rp.space().impl_internal_space_instance(),
+          false);
+    } else if (RP::rank == 3) {
+      const dim3 block(m_rp.m_tile[0], m_rp.m_tile[1], m_rp.m_tile[2]);
       const dim3 grid(
-          std::min( ( m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1 ) / block.x , maxblocks )
-        , std::min( ( m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1 ) / block.y , maxblocks )
-        , std::min( ( m_rp.m_upper[2] - m_rp.m_lower[2] + block.z - 1 ) / block.z , maxblocks )
-        );
-      CudaParallelLaunch< ParallelFor, LaunchBounds >( *this , grid , block , 0 , m_rp.space().impl_internal_space_instance() , false );
-    }
-    else if ( RP::rank == 4 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2] , m_rp.m_tile[3] );
+          std::min((m_rp.m_upper[0] - m_rp.m_lower[0] + block.x - 1) / block.x,
+                   maxblocks),
+          std::min((m_rp.m_upper[1] - m_rp.m_lower[1] + block.y - 1) / block.y,
+                   maxblocks),
+          std::min((m_rp.m_upper[2] - m_rp.m_lower[2] + block.z - 1) / block.z,
+                   maxblocks));
+      CudaParallelLaunch<ParallelFor, LaunchBounds>(
+          *this, grid, block, 0, m_rp.space().impl_internal_space_instance(),
+          false);
+    } else if (RP::rank == 4) {
+      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1], m_rp.m_tile[2],
+                       m_rp.m_tile[3]);
       const dim3 grid(
-          std::min( static_cast<index_type>( m_rp.m_tile_end[0] * m_rp.m_tile_end[1] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( ( m_rp.m_upper[2] - m_rp.m_lower[2] + block.y - 1 ) / block.y , maxblocks )
-        , std::min( ( m_rp.m_upper[3] - m_rp.m_lower[3] + block.z - 1 ) / block.z , maxblocks )
-        );
-      CudaParallelLaunch< ParallelFor, LaunchBounds >( *this , grid , block , 0 , m_rp.space().impl_internal_space_instance() , false );
-    }
-    else if ( RP::rank == 5 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2]*m_rp.m_tile[3] , m_rp.m_tile[4] );
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[0] * m_rp.m_tile_end[1]),
+              static_cast<index_type>(maxblocks)),
+          std::min((m_rp.m_upper[2] - m_rp.m_lower[2] + block.y - 1) / block.y,
+                   maxblocks),
+          std::min((m_rp.m_upper[3] - m_rp.m_lower[3] + block.z - 1) / block.z,
+                   maxblocks));
+      CudaParallelLaunch<ParallelFor, LaunchBounds>(
+          *this, grid, block, 0, m_rp.space().impl_internal_space_instance(),
+          false);
+    } else if (RP::rank == 5) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1],
+                       m_rp.m_tile[2] * m_rp.m_tile[3], m_rp.m_tile[4]);
       const dim3 grid(
-          std::min( static_cast<index_type>( m_rp.m_tile_end[0] * m_rp.m_tile_end[1] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( static_cast<index_type>( m_rp.m_tile_end[2] * m_rp.m_tile_end[3] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( ( m_rp.m_upper[4] - m_rp.m_lower[4] + block.z - 1 ) / block.z , maxblocks )
-        );
-      CudaParallelLaunch< ParallelFor, LaunchBounds >( *this , grid , block , 0 , m_rp.space().impl_internal_space_instance() , false );
-    }
-    else if ( RP::rank == 6 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4,id5 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2]*m_rp.m_tile[3] , m_rp.m_tile[4]*m_rp.m_tile[5] );
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[0] * m_rp.m_tile_end[1]),
+              static_cast<index_type>(maxblocks)),
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[2] * m_rp.m_tile_end[3]),
+              static_cast<index_type>(maxblocks)),
+          std::min((m_rp.m_upper[4] - m_rp.m_lower[4] + block.z - 1) / block.z,
+                   maxblocks));
+      CudaParallelLaunch<ParallelFor, LaunchBounds>(
+          *this, grid, block, 0, m_rp.space().impl_internal_space_instance(),
+          false);
+    } else if (RP::rank == 6) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4,id5 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1],
+                       m_rp.m_tile[2] * m_rp.m_tile[3],
+                       m_rp.m_tile[4] * m_rp.m_tile[5]);
       const dim3 grid(
-          std::min( static_cast<index_type>( m_rp.m_tile_end[0] * m_rp.m_tile_end[1] )
-                  , static_cast<index_type>(maxblocks) )
-        ,  std::min( static_cast<index_type>( m_rp.m_tile_end[2] * m_rp.m_tile_end[3] )
-                  , static_cast<index_type>(maxblocks) )
-        , std::min( static_cast<index_type>( m_rp.m_tile_end[4] * m_rp.m_tile_end[5] )
-                  , static_cast<index_type>(maxblocks) )
-        );
-      CudaParallelLaunch< ParallelFor, LaunchBounds >( *this , grid , block , 0 , m_rp.space().impl_internal_space_instance() , false );
-    }
-    else
-    {
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[0] * m_rp.m_tile_end[1]),
+              static_cast<index_type>(maxblocks)),
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[2] * m_rp.m_tile_end[3]),
+              static_cast<index_type>(maxblocks)),
+          std::min(
+              static_cast<index_type>(m_rp.m_tile_end[4] * m_rp.m_tile_end[5]),
+              static_cast<index_type>(maxblocks)));
+      CudaParallelLaunch<ParallelFor, LaunchBounds>(
+          *this, grid, block, 0, m_rp.space().impl_internal_space_instance(),
+          false);
+    } else {
       printf("Kokkos::MDRange Error: Exceeded rank bounds with Cuda\n");
       Kokkos::abort("Aborting");
     }
 
-  } //end execute
+  }  // end execute
 
-//  inline
-  ParallelFor( const FunctorType & arg_functor
-             , Policy arg_policy )
-    : m_functor( arg_functor )
-    , m_rp(  arg_policy )
-    {}
+  //  inline
+  ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
+      : m_functor(arg_functor), m_rp(arg_policy) {}
 };
 
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::Cuda> {
+ public:
+  typedef TeamPolicyInternal<Kokkos::Cuda, Properties...> Policy;
 
-template< class FunctorType , class ... Properties >
-class ParallelFor< FunctorType
-                 , Kokkos::TeamPolicy< Properties ... >
-                 , Kokkos::Cuda
-                 >
-{
-public:
-  typedef TeamPolicyInternal< Kokkos::Cuda , Properties ... >   Policy ;
-private:
-
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::launch_bounds  LaunchBounds ;
-
-public:
-
-  typedef FunctorType      functor_type ;
-  typedef Cuda::size_type  size_type ;
+ private:
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::launch_bounds LaunchBounds;
 
-private:
+ public:
+  typedef FunctorType functor_type;
+  typedef Cuda::size_type size_type;
 
-  // Algorithmic constraints: blockDim.y is a power of two AND blockDim.y == blockDim.z == 1
-  // shared memory utilization:
+ private:
+  // Algorithmic constraints: blockDim.y is a power of two AND blockDim.y ==
+  // blockDim.z == 1 shared memory utilization:
   //
   //  [ team   reduce space ]
   //  [ team   shared space ]
   //
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  const size_type    m_league_size ;
-  int    m_team_size ;
-  const size_type    m_vector_size ;
-  int m_shmem_begin ;
-  int m_shmem_size ;
-  void*              m_scratch_ptr[2] ;
-  int m_scratch_size[2] ;
-
-  template< class TagType >
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const size_type m_league_size;
+  int m_team_size;
+  const size_type m_vector_size;
+  int m_shmem_begin;
+  int m_shmem_size;
+  void* m_scratch_ptr[2];
+  int m_scratch_size[2];
+
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_team( const Member & member ) const
-    { m_functor( member ); }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_team(const Member& member) const {
+    m_functor(member);
+  }
 
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_team( const Member & member ) const
-    { m_functor( TagType() , member ); }
-
-public:
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_team(const Member& member) const {
+    m_functor(TagType(), member);
+  }
 
-  __device__ inline
-  void operator()(void) const
-  {
+ public:
+  __device__ inline void operator()(void) const {
     // Iterate this block through the league
     int64_t threadid = 0;
-    if ( m_scratch_size[1]>0 ) {
+    if (m_scratch_size[1] > 0) {
       __shared__ int64_t base_thread_id;
-      if (threadIdx.x==0 && threadIdx.y==0 ) {
-        threadid = (blockIdx.x*blockDim.z + threadIdx.z) %
-          (Kokkos::Impl::g_device_cuda_lock_arrays.n / (blockDim.x * blockDim.y));
+      if (threadIdx.x == 0 && threadIdx.y == 0) {
+        threadid = (blockIdx.x * blockDim.z + threadIdx.z) %
+                   (Kokkos::Impl::g_device_cuda_lock_arrays.n /
+                    (blockDim.x * blockDim.y));
         threadid *= blockDim.x * blockDim.y;
         int done = 0;
         while (!done) {
-          done = (0 == atomicCAS(&Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid],0,1));
-          if(!done) {
+          done =
+              (0 ==
+               atomicCAS(
+                   &Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid],
+                   0, 1));
+          if (!done) {
             threadid += blockDim.x * blockDim.y;
-            if(int64_t(threadid+blockDim.x * blockDim.y) >= int64_t(Kokkos::Impl::g_device_cuda_lock_arrays.n)) threadid = 0;
+            if (int64_t(threadid + blockDim.x * blockDim.y) >=
+                int64_t(Kokkos::Impl::g_device_cuda_lock_arrays.n))
+              threadid = 0;
           }
         }
         base_thread_id = threadid;
@@ -736,79 +834,102 @@ public:
       threadid = base_thread_id;
     }
 
-
     const int int_league_size = (int)m_league_size;
-    for ( int league_rank = blockIdx.x ; league_rank < int_league_size ; league_rank += gridDim.x ) {
-
-      this-> template exec_team< WorkTag >(
-        typename Policy::member_type( kokkos_impl_cuda_shared_memory<void>()
-                                    , m_shmem_begin
-                                    , m_shmem_size
-                                    , (void*) ( ((char*)m_scratch_ptr[1]) + ptrdiff_t(threadid/(blockDim.x*blockDim.y)) * m_scratch_size[1])
-                                    , m_scratch_size[1]
-                                    , league_rank
-                                    , m_league_size ) );
-    }
-    if ( m_scratch_size[1]>0 ) {
+    for (int league_rank = blockIdx.x; league_rank < int_league_size;
+         league_rank += gridDim.x) {
+      this->template exec_team<WorkTag>(typename Policy::member_type(
+          kokkos_impl_cuda_shared_memory<void>(), m_shmem_begin, m_shmem_size,
+          (void*)(((char*)m_scratch_ptr[1]) +
+                  ptrdiff_t(threadid / (blockDim.x * blockDim.y)) *
+                      m_scratch_size[1]),
+          m_scratch_size[1], league_rank, m_league_size));
+    }
+    if (m_scratch_size[1] > 0) {
       __syncthreads();
-      if (threadIdx.x==0 && threadIdx.y==0 )
-        Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid]=0;
+      if (threadIdx.x == 0 && threadIdx.y == 0)
+        Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid] = 0;
     }
   }
 
-  inline
-  void execute() const
-    {
-      const int64_t shmem_size_total = m_shmem_begin + m_shmem_size ;
-      const dim3 grid( int(m_league_size) , 1 , 1 );
-      const dim3 block( int(m_vector_size) , int(m_team_size) , 1 );
-
-      CudaParallelLaunch< ParallelFor, LaunchBounds >( *this, grid, block, shmem_size_total, m_policy.space().impl_internal_space_instance() , true ); // copy to device and execute
+  inline void execute() const {
+    const int64_t shmem_size_total = m_shmem_begin + m_shmem_size;
+    dim3 grid(int(m_league_size), 1, 1);
+    const dim3 block(int(m_vector_size), int(m_team_size), 1);
 
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    if (Kokkos::Impl::CudaInternal::cuda_use_serial_execution()) {
+      grid = dim3(1, 1, 1);
     }
+#endif
 
-  ParallelFor( const FunctorType  & arg_functor
-             , const Policy       & arg_policy
-             )
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    , m_league_size( arg_policy.league_size() )
-    , m_team_size( arg_policy.team_size() )
-    , m_vector_size( arg_policy.vector_length() )
-    {
-      cudaFuncAttributes attr = CudaParallelLaunch< ParallelFor, LaunchBounds >::
-          get_cuda_func_attributes();
-      m_team_size = m_team_size>=0?m_team_size:Kokkos::Impl::cuda_get_opt_block_size< FunctorType, LaunchBounds>(
+    CudaParallelLaunch<ParallelFor, LaunchBounds>(
+        *this, grid, block, shmem_size_total,
         m_policy.space().impl_internal_space_instance(),
-        attr, m_functor , m_vector_size,
-        m_policy.team_scratch_size(0), m_policy.thread_scratch_size(0) )/m_vector_size;
-
-      m_shmem_begin = ( sizeof(double) * ( m_team_size + 2 ) );
-      m_shmem_size = ( m_policy.scratch_size(0,m_team_size) + FunctorTeamShmemSize< FunctorType >::value( m_functor , m_team_size ) );
-      m_scratch_size[0] = m_policy.scratch_size(0,m_team_size);
-      m_scratch_size[1] = m_policy.scratch_size(1,m_team_size);
-
-      // Functor's reduce memory, team scan memory, and team shared memory depend upon team size.
-      m_scratch_ptr[0] = NULL;
-      m_scratch_ptr[1] = m_team_size<=0?NULL:cuda_resize_scratch_space(static_cast<ptrdiff_t>(m_scratch_size[1])*static_cast<ptrdiff_t>(Cuda::concurrency()/(m_team_size*m_vector_size)));
-
-      const int shmem_size_total = m_shmem_begin + m_shmem_size ;
-      if ( m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock < shmem_size_total ) {
-        printf("%i %i\n",m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock,shmem_size_total);
-        Kokkos::Impl::throw_runtime_exception(std::string("Kokkos::Impl::ParallelFor< Cuda > insufficient shared memory"));
-      }
+        true);  // copy to device and execute
+  }
 
-      if ( int(m_team_size) >
-           int(Kokkos::Impl::cuda_get_max_block_size< FunctorType, LaunchBounds >
-                 ( m_policy.space().impl_internal_space_instance(),
-        attr, arg_functor , arg_policy.vector_length(), arg_policy.team_scratch_size(0),arg_policy.thread_scratch_size(0) ) / arg_policy.vector_length())) {
-        Kokkos::Impl::throw_runtime_exception(std::string("Kokkos::Impl::ParallelFor< Cuda > requested too large team size."));
-      }
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_league_size(arg_policy.league_size()),
+        m_team_size(arg_policy.team_size()),
+        m_vector_size(arg_policy.vector_length()) {
+    cudaFuncAttributes attr =
+        CudaParallelLaunch<ParallelFor,
+                           LaunchBounds>::get_cuda_func_attributes();
+    m_team_size =
+        m_team_size >= 0
+            ? m_team_size
+            : Kokkos::Impl::cuda_get_opt_block_size<FunctorType, LaunchBounds>(
+                  m_policy.space().impl_internal_space_instance(), attr,
+                  m_functor, m_vector_size, m_policy.team_scratch_size(0),
+                  m_policy.thread_scratch_size(0)) /
+                  m_vector_size;
+
+    m_shmem_begin = (sizeof(double) * (m_team_size + 2));
+    m_shmem_size =
+        (m_policy.scratch_size(0, m_team_size) +
+         FunctorTeamShmemSize<FunctorType>::value(m_functor, m_team_size));
+    m_scratch_size[0] = m_policy.scratch_size(0, m_team_size);
+    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
+
+    // Functor's reduce memory, team scan memory, and team shared memory depend
+    // upon team size.
+    m_scratch_ptr[0] = NULL;
+    m_scratch_ptr[1] =
+        m_team_size <= 0
+            ? NULL
+            : cuda_resize_scratch_space(
+                  static_cast<ptrdiff_t>(m_scratch_size[1]) *
+                  static_cast<ptrdiff_t>(Cuda::concurrency() /
+                                         (m_team_size * m_vector_size)));
+
+    const int shmem_size_total = m_shmem_begin + m_shmem_size;
+    if (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock <
+        shmem_size_total) {
+      printf(
+          "%i %i\n",
+          m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock,
+          shmem_size_total);
+      Kokkos::Impl::throw_runtime_exception(std::string(
+          "Kokkos::Impl::ParallelFor< Cuda > insufficient shared memory"));
+    }
+
+    if (int(m_team_size) >
+        int(Kokkos::Impl::cuda_get_max_block_size<FunctorType, LaunchBounds>(
+                m_policy.space().impl_internal_space_instance(), attr,
+                arg_functor, arg_policy.vector_length(),
+                arg_policy.team_scratch_size(0),
+                arg_policy.thread_scratch_size(0)) /
+            arg_policy.vector_length())) {
+      Kokkos::Impl::throw_runtime_exception(std::string(
+          "Kokkos::Impl::ParallelFor< Cuda > requested too large team size."));
     }
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -816,576 +937,696 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ReducerType, class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::RangePolicy< Traits ... >
-                    , ReducerType
-                    , Kokkos::Cuda
-                    >
-{
-public:
-  typedef Kokkos::RangePolicy< Traits ... >         Policy ;
-private:
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+                     Kokkos::Cuda> {
+ public:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
+ private:
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::launch_bounds LaunchBounds;
 
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::launch_bounds LaunchBounds ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
-
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd, WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd, WorkTagFwd > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd, WorkTagFwd > ValueJoin ;
-
-public:
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::value_type      value_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef FunctorType                           functor_type ;
-  typedef Kokkos::Cuda::size_type                  size_type ;
-  typedef typename Policy::index_type             index_type ;
-
-  // Algorithmic constraints: blockSize is a power of two AND blockDim.y == blockDim.z == 1
-
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
-  const bool          m_result_ptr_device_accessible ;
-  size_type *         m_scratch_space ;
-  size_type *         m_scratch_flags ;
-  size_type *         m_unified_space ;
-
-  // Shall we use the shfl based reduction or not (only use it for static sized types of more than 128bit)
-  enum { UseShflReduction = false };//((sizeof(value_type)>2*sizeof(double)) && ValueTraits::StaticValueSize) };
-  // Some crutch to do function overloading
-private:
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
+
+ public:
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::value_type value_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef FunctorType functor_type;
+  typedef Kokkos::Cuda::size_type size_type;
+  typedef typename Policy::index_type index_type;
+
+  // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
+  // blockDim.z == 1
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+  size_type* m_scratch_space;
+  size_type* m_scratch_flags;
+  size_type* m_unified_space;
+
+  // Shall we use the shfl based reduction or not (only use it for static sized
+  // types of more than 128bit)
+  enum {
+    UseShflReduction = false
+  };  //((sizeof(value_type)>2*sizeof(double)) && ValueTraits::StaticValueSize)
+      //};
+      // Some crutch to do function overloading
+ private:
   typedef double DummyShflReductionType;
   typedef int DummySHMEMReductionType;
 
-public:
+ public:
   // Make the exec_range calls call to Reduce::DeviceIterateTile
-  template< class TagType >
-  __device__ inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const Member & i , reference_type update ) const
-    { m_functor( i , update ); }
-
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const Member & i , reference_type update ) const
-    { m_functor( TagType() , i , update ); }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const Member& i, reference_type update) const {
+    m_functor(i, update);
+  }
 
+  template <class TagType>
   __device__ inline
-  void operator() () const {
-/*    run(Kokkos::Impl::if_c<UseShflReduction, DummyShflReductionType, DummySHMEMReductionType>::select(1,1.0) );
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const Member& i, reference_type update) const {
+    m_functor(TagType(), i, update);
   }
 
-  __device__ inline
-  void run(const DummySHMEMReductionType& ) const
-  {*/
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-      word_count( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) / sizeof(size_type) );
+  __device__ inline void operator()() const {
+    /*    run(Kokkos::Impl::if_c<UseShflReduction, DummyShflReductionType,
+      DummySHMEMReductionType>::select(1,1.0) );
+      }
+
+      __device__ inline
+      void run(const DummySHMEMReductionType& ) const
+      {*/
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(size_type)>
+        word_count(ValueTraits::value_size(
+                       ReducerConditional::select(m_functor, m_reducer)) /
+                   sizeof(size_type));
 
     {
       reference_type value =
-        ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , kokkos_impl_cuda_shared_memory<size_type>() + threadIdx.y * word_count.value );
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          kokkos_impl_cuda_shared_memory<size_type>() +
+                              threadIdx.y * word_count.value);
 
-      // Number of blocks is bounded so that the reduction can be limited to two passes.
-      // Each thread block is given an approximately equal amount of work to perform.
-      // Accumulate the values for this block.
-      // The accumulation ordering does not match the final pass, but is arithmatically equivalent.
+      // Number of blocks is bounded so that the reduction can be limited to two
+      // passes. Each thread block is given an approximately equal amount of
+      // work to perform. Accumulate the values for this block. The accumulation
+      // ordering does not match the final pass, but is arithmatically
+      // equivalent.
 
-      const WorkRange range( m_policy , blockIdx.x , gridDim.x );
+      const WorkRange range(m_policy, blockIdx.x, gridDim.x);
 
-      for ( Member iwork = range.begin() + threadIdx.y , iwork_end = range.end() ;
-            iwork < iwork_end ; iwork += blockDim.y ) {
-        this-> template exec_range< WorkTag >( iwork , value );
+      for (Member iwork = range.begin() + threadIdx.y, iwork_end = range.end();
+           iwork < iwork_end; iwork += blockDim.y) {
+        this->template exec_range<WorkTag>(iwork, value);
       }
     }
 
     // Reduce with final value at blockDim.y - 1 location.
-    if ( cuda_single_inter_block_reduce_scan<false,ReducerTypeFwd,WorkTagFwd>(
-           ReducerConditional::select(m_functor , m_reducer) , blockIdx.x , gridDim.x ,
-           kokkos_impl_cuda_shared_memory<size_type>() , m_scratch_space , m_scratch_flags ) ) {
-
-      // This is the final block with the final result at the final threads' location
-
-      size_type * const shared = kokkos_impl_cuda_shared_memory<size_type>() + ( blockDim.y - 1 ) * word_count.value ;
-      size_type * const global = m_result_ptr_device_accessible? reinterpret_cast<size_type*>(m_result_ptr) : 
-                                 ( m_unified_space ? m_unified_space : m_scratch_space );
-
-      if ( threadIdx.y == 0 ) {
-        Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , shared );
+    if (cuda_single_inter_block_reduce_scan<false, ReducerTypeFwd, WorkTagFwd>(
+            ReducerConditional::select(m_functor, m_reducer), blockIdx.x,
+            gridDim.x, kokkos_impl_cuda_shared_memory<size_type>(),
+            m_scratch_space, m_scratch_flags)) {
+      // This is the final block with the final result at the final threads'
+      // location
+
+      size_type* const shared = kokkos_impl_cuda_shared_memory<size_type>() +
+                                (blockDim.y - 1) * word_count.value;
+      size_type* const global =
+          m_result_ptr_device_accessible
+              ? reinterpret_cast<size_type*>(m_result_ptr)
+              : (m_unified_space ? m_unified_space : m_scratch_space);
+
+      if (threadIdx.y == 0) {
+        Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+            ReducerConditional::select(m_functor, m_reducer), shared);
       }
 
-      if ( CudaTraits::WarpSize < word_count.value ) { __syncthreads(); }
+      if (CudaTraits::WarpSize < word_count.value) {
+        __syncthreads();
+      }
 
-      for ( unsigned i = threadIdx.y ; i < word_count.value ; i += blockDim.y ) { global[i] = shared[i]; }
+      for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
+        global[i] = shared[i];
+      }
     }
   }
 
-/*  __device__ inline
-   void run(const DummyShflReductionType&) const
-   {
-     value_type value;
-     ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , &value);
-     // Number of blocks is bounded so that the reduction can be limited to two passes.
-     // Each thread block is given an approximately equal amount of work to perform.
-     // Accumulate the values for this block.
-     // The accumulation ordering does not match the final pass, but is arithmatically equivalent.
-
-     const WorkRange range( m_policy , blockIdx.x , gridDim.x );
-
-     for ( Member iwork = range.begin() + threadIdx.y , iwork_end = range.end() ;
-           iwork < iwork_end ; iwork += blockDim.y ) {
-       this-> template exec_range< WorkTag >( iwork , value );
-     }
-
-     pointer_type const result = (pointer_type) (m_unified_space ? m_unified_space : m_scratch_space) ;
-
-     int max_active_thread = range.end()-range.begin() < blockDim.y ? range.end() - range.begin():blockDim.y;
-
-     max_active_thread = (max_active_thread == 0)?blockDim.y:max_active_thread;
+  /*  __device__ inline
+     void run(const DummyShflReductionType&) const
+     {
+       value_type value;
+       ValueInit::init( ReducerConditional::select(m_functor , m_reducer) ,
+     &value);
+       // Number of blocks is bounded so that the reduction can be limited to
+     two passes.
+       // Each thread block is given an approximately equal amount of work to
+     perform.
+       // Accumulate the values for this block.
+       // The accumulation ordering does not match the final pass, but is
+     arithmatically equivalent.
+
+       const WorkRange range( m_policy , blockIdx.x , gridDim.x );
+
+       for ( Member iwork = range.begin() + threadIdx.y , iwork_end =
+     range.end() ; iwork < iwork_end ; iwork += blockDim.y ) { this-> template
+     exec_range< WorkTag >( iwork , value );
+       }
 
-    value_type init;
-    ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , &init);
-     if(Impl::cuda_inter_block_reduction<ReducerTypeFwd,ValueJoin,WorkTagFwd>
-            (value,init,ValueJoin(ReducerConditional::select(m_functor , m_reducer)),m_scratch_space,result,m_scratch_flags,max_active_thread)) {
-       const unsigned id = threadIdx.y*blockDim.x + threadIdx.x;
-       if(id==0) {
-         Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , (void*) &value );
-         *result = value;
+       pointer_type const result = (pointer_type) (m_unified_space ?
+     m_unified_space : m_scratch_space) ;
+
+       int max_active_thread = range.end()-range.begin() < blockDim.y ?
+     range.end() - range.begin():blockDim.y;
+
+       max_active_thread = (max_active_thread ==
+     0)?blockDim.y:max_active_thread;
+
+      value_type init;
+      ValueInit::init( ReducerConditional::select(m_functor , m_reducer) ,
+     &init);
+       if(Impl::cuda_inter_block_reduction<ReducerTypeFwd,ValueJoin,WorkTagFwd>
+              (value,init,ValueJoin(ReducerConditional::select(m_functor ,
+     m_reducer)),m_scratch_space,result,m_scratch_flags,max_active_thread)) {
+         const unsigned id = threadIdx.y*blockDim.x + threadIdx.x;
+         if(id==0) {
+           Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final(
+     ReducerConditional::select(m_functor , m_reducer) , (void*) &value );
+           *result = value;
+         }
        }
-     }
-   }*/
+     }*/
 
   // Determine block size constrained by shared memory:
-  inline
-  unsigned local_block_size( const FunctorType & f )
-    {
-      unsigned n = CudaTraits::WarpSize * 8 ;
-      int shmem_size = cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( f , n );
-      while ( (n && (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock < shmem_size)) ||
-          (n > static_cast<unsigned>(Kokkos::Impl::cuda_get_max_block_size< ParallelReduce, LaunchBounds>( f , 1, shmem_size , 0 )))) {
-        n >>= 1 ;
-        shmem_size = cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( f , n );
-      }
-      return n ;
-    }
-
-  inline
-  void execute()
-    {
-      const index_type nwork = m_policy.end() - m_policy.begin();
-      if ( nwork ) {
-        const int block_size = local_block_size( m_functor );
-
-        m_scratch_space = cuda_internal_scratch_space( m_policy.space(), ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) * block_size /* block_size == max block_count */ );
-        m_scratch_flags = cuda_internal_scratch_flags( m_policy.space(), sizeof(size_type) );
-        m_unified_space = cuda_internal_scratch_unified( m_policy.space(), ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) );
-
-        // REQUIRED ( 1 , N , 1 )
-        const dim3 block( 1 , block_size , 1 );
-        // Required grid.x <= block.y
-        const dim3 grid( std::min( int(block.y) , int( ( nwork + block.y - 1 ) / block.y ) ) , 1 , 1 );
+  inline unsigned local_block_size(const FunctorType& f) {
+    unsigned n = CudaTraits::WarpSize * 8;
+    int shmem_size =
+        cuda_single_inter_block_reduce_scan_shmem<false, FunctorType, WorkTag>(
+            f, n);
+    while (
+        (n &&
+         (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock <
+          shmem_size)) ||
+        (n > static_cast<unsigned>(
+                 Kokkos::Impl::cuda_get_max_block_size<
+                     ParallelReduce, LaunchBounds>(f, 1, shmem_size, 0)))) {
+      n >>= 1;
+      shmem_size = cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                             WorkTag>(f, n);
+    }
+    return n;
+  }
 
-      const int shmem = UseShflReduction?0:cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( m_functor , block.y );
+  inline void execute() {
+    const index_type nwork = m_policy.end() - m_policy.begin();
+    if (nwork) {
+      const int block_size = local_block_size(m_functor);
+
+      m_scratch_space = cuda_internal_scratch_space(
+          m_policy.space(), ValueTraits::value_size(ReducerConditional::select(
+                                m_functor, m_reducer)) *
+                                block_size /* block_size == max block_count */);
+      m_scratch_flags =
+          cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type));
+      m_unified_space = cuda_internal_scratch_unified(
+          m_policy.space(), ValueTraits::value_size(ReducerConditional::select(
+                                m_functor, m_reducer)));
+
+      // REQUIRED ( 1 , N , 1 )
+      dim3 block(1, block_size, 1);
+      // Required grid.x <= block.y
+      dim3 grid(std::min(int(block.y), int((nwork + block.y - 1) / block.y)), 1,
+                1);
+
+      const int shmem =
+          UseShflReduction
+              ? 0
+              : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                          WorkTag>(m_functor,
+                                                                   block.y);
+
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+      if (Kokkos::Impl::CudaInternal::cuda_use_serial_execution()) {
+        block = dim3(1, 1, 1);
+        grid  = dim3(1, 1, 1);
+      }
+#endif
 
-      CudaParallelLaunch< ParallelReduce, LaunchBounds >( *this, grid, block, shmem , m_policy.space().impl_internal_space_instance() , false ); // copy to device and execute
+      CudaParallelLaunch<ParallelReduce, LaunchBounds>(
+          *this, grid, block, shmem,
+          m_policy.space().impl_internal_space_instance(),
+          false);  // copy to device and execute
 
-      if(!m_result_ptr_device_accessible) {
+      if (!m_result_ptr_device_accessible) {
         Cuda().fence();
 
-        if ( m_result_ptr ) {
-          if ( m_unified_space ) {
-            const int count = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer)  );
-            for ( int i = 0 ; i < count ; ++i ) { m_result_ptr[i] = pointer_type(m_unified_space)[i] ; }
-          }
-          else {
-            const int size = ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer)  );
-            DeepCopy<HostSpace,CudaSpace>( m_result_ptr , m_scratch_space , size );
+        if (m_result_ptr) {
+          if (m_unified_space) {
+            const int count = ValueTraits::value_count(
+                ReducerConditional::select(m_functor, m_reducer));
+            for (int i = 0; i < count; ++i) {
+              m_result_ptr[i] = pointer_type(m_unified_space)[i];
+            }
+          } else {
+            const int size = ValueTraits::value_size(
+                ReducerConditional::select(m_functor, m_reducer));
+            DeepCopy<HostSpace, CudaSpace>(m_result_ptr, m_scratch_space, size);
           }
         }
       }
-    }
-    else {
+    } else {
       if (m_result_ptr) {
-        ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , m_result_ptr );
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                        m_result_ptr);
       }
     }
   }
 
-  template< class ViewType >
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ViewType & arg_result
-                , typename std::enable_if<
-                   Kokkos::is_view< ViewType >::value
-                ,void*>::type = NULL)
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( InvalidType() )
-  , m_result_ptr( arg_result.data() )
-  , m_result_ptr_device_accessible(MemorySpaceAccess< Kokkos::CudaSpace , typename ViewType::memory_space>::accessible )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_unified_space( 0 )
-  { }
-
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ReducerType & reducer)
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr( reducer.view().data() )
-  , m_result_ptr_device_accessible(MemorySpaceAccess< Kokkos::CudaSpace , typename ReducerType::result_view_type::memory_space>::accessible )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_unified_space( 0 )
-  { }
+  template <class ViewType>
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const ViewType& arg_result,
+                 typename std::enable_if<Kokkos::is_view<ViewType>::value,
+                                         void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<Kokkos::CudaSpace,
+                              typename ViewType::memory_space>::accessible),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_unified_space(0) {}
+
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<Kokkos::CudaSpace,
+                              typename ReducerType::result_view_type::
+                                  memory_space>::accessible),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_unified_space(0) {}
 };
 
-
 // MDRangePolicy impl
-template< class FunctorType , class ReducerType, class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::MDRangePolicy< Traits ... >
-                    , ReducerType
-                    , Kokkos::Cuda
-                    >
-{
-public:
-  typedef Kokkos::MDRangePolicy< Traits ... > Policy ;
-private:
-
-  typedef typename Policy::array_index_type                 array_index_type;
-  typedef typename Policy::index_type                       index_type;
-
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::launch_bounds LaunchBounds;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
-  typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
+                     Kokkos::Cuda> {
+ public:
+  typedef Kokkos::MDRangePolicy<Traits...> Policy;
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd, WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd, WorkTagFwd > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd, WorkTagFwd > ValueJoin ;
-
-public:
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::value_type      value_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef FunctorType                           functor_type ;
-  typedef Cuda::size_type                       size_type ;
-
-  // Algorithmic constraints: blockSize is a power of two AND blockDim.y == blockDim.z == 1
-
-  const FunctorType   m_functor ;
-  const Policy        m_policy ; // used for workrange and nwork
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
-  const bool          m_result_ptr_device_accessible ;
-  size_type *         m_scratch_space ;
-  size_type *         m_scratch_flags ;
-  size_type *         m_unified_space ;
+ private:
+  typedef typename Policy::array_index_type array_index_type;
+  typedef typename Policy::index_type index_type;
 
-  typedef typename Kokkos::Impl::Reduce::DeviceIterateTile<Policy::rank, Policy, FunctorType, typename Policy::work_tag, reference_type> DeviceIteratePattern;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::launch_bounds LaunchBounds;
 
-  // Shall we use the shfl based reduction or not (only use it for static sized types of more than 128bit
-  enum { UseShflReduction = ((sizeof(value_type)>2*sizeof(double)) && (ValueTraits::StaticValueSize!=0)) };
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
+  typedef typename ReducerConditional::type ReducerTypeFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
+
+ public:
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::value_type value_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef FunctorType functor_type;
+  typedef Cuda::size_type size_type;
+
+  // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
+  // blockDim.z == 1
+
+  const FunctorType m_functor;
+  const Policy m_policy;  // used for workrange and nwork
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+  size_type* m_scratch_space;
+  size_type* m_scratch_flags;
+  size_type* m_unified_space;
+
+  typedef typename Kokkos::Impl::Reduce::DeviceIterateTile<
+      Policy::rank, Policy, FunctorType, typename Policy::work_tag,
+      reference_type>
+      DeviceIteratePattern;
+
+  // Shall we use the shfl based reduction or not (only use it for static sized
+  // types of more than 128bit
+  enum {
+    UseShflReduction = ((sizeof(value_type) > 2 * sizeof(double)) &&
+                        (ValueTraits::StaticValueSize != 0))
+  };
   // Some crutch to do function overloading
-private:
+ private:
   typedef double DummyShflReductionType;
   typedef int DummySHMEMReductionType;
 
-public:
-  inline
-  __device__
-  void
-  exec_range( reference_type update ) const
-  {
-    Kokkos::Impl::Reduce::DeviceIterateTile<Policy::rank,Policy,FunctorType,typename Policy::work_tag, reference_type>(m_policy, m_functor, update).exec_range();
+ public:
+  inline __device__ void exec_range(reference_type update) const {
+    Kokkos::Impl::Reduce::DeviceIterateTile<Policy::rank, Policy, FunctorType,
+                                            typename Policy::work_tag,
+                                            reference_type>(m_policy, m_functor,
+                                                            update)
+        .exec_range();
   }
 
-  inline
-  __device__
-  void operator() (void) const {
-/*    run(Kokkos::Impl::if_c<UseShflReduction, DummyShflReductionType, DummySHMEMReductionType>::select(1,1.0) );
-  }
+  inline __device__ void operator()(void) const {
+    /*    run(Kokkos::Impl::if_c<UseShflReduction, DummyShflReductionType,
+      DummySHMEMReductionType>::select(1,1.0) );
+      }
 
-  __device__ inline
-  void run(const DummySHMEMReductionType& ) const
-  {*/
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-      word_count( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) / sizeof(size_type) );
+      __device__ inline
+      void run(const DummySHMEMReductionType& ) const
+      {*/
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(size_type)>
+        word_count(ValueTraits::value_size(
+                       ReducerConditional::select(m_functor, m_reducer)) /
+                   sizeof(size_type));
 
     {
       reference_type value =
-        ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , kokkos_impl_cuda_shared_memory<size_type>() + threadIdx.y * word_count.value );
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          kokkos_impl_cuda_shared_memory<size_type>() +
+                              threadIdx.y * word_count.value);
 
-      // Number of blocks is bounded so that the reduction can be limited to two passes.
-      // Each thread block is given an approximately equal amount of work to perform.
-      // Accumulate the values for this block.
-      // The accumulation ordering does not match the final pass, but is arithmatically equivalent.
+      // Number of blocks is bounded so that the reduction can be limited to two
+      // passes. Each thread block is given an approximately equal amount of
+      // work to perform. Accumulate the values for this block. The accumulation
+      // ordering does not match the final pass, but is arithmatically
+      // equivalent.
 
-      this-> exec_range( value );
+      this->exec_range(value);
     }
 
     // Reduce with final value at blockDim.y - 1 location.
     // Problem: non power-of-two blockDim
-    if ( cuda_single_inter_block_reduce_scan<false,ReducerTypeFwd,WorkTagFwd>(
-           ReducerConditional::select(m_functor , m_reducer) , blockIdx.x , gridDim.x ,
-           kokkos_impl_cuda_shared_memory<size_type>() , m_scratch_space , m_scratch_flags ) ) {
-
-      // This is the final block with the final result at the final threads' location
-      size_type * const shared = kokkos_impl_cuda_shared_memory<size_type>() + ( blockDim.y - 1 ) * word_count.value ;
-      size_type * const global = m_result_ptr_device_accessible? reinterpret_cast<size_type*>(m_result_ptr) :
-                                 ( m_unified_space ? m_unified_space : m_scratch_space );
-
-      if ( threadIdx.y == 0 ) {
-        Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , shared );
+    if (cuda_single_inter_block_reduce_scan<false, ReducerTypeFwd, WorkTagFwd>(
+            ReducerConditional::select(m_functor, m_reducer), blockIdx.x,
+            gridDim.x, kokkos_impl_cuda_shared_memory<size_type>(),
+            m_scratch_space, m_scratch_flags)) {
+      // This is the final block with the final result at the final threads'
+      // location
+      size_type* const shared = kokkos_impl_cuda_shared_memory<size_type>() +
+                                (blockDim.y - 1) * word_count.value;
+      size_type* const global =
+          m_result_ptr_device_accessible
+              ? reinterpret_cast<size_type*>(m_result_ptr)
+              : (m_unified_space ? m_unified_space : m_scratch_space);
+
+      if (threadIdx.y == 0) {
+        Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+            ReducerConditional::select(m_functor, m_reducer), shared);
       }
 
-      if ( CudaTraits::WarpSize < word_count.value ) { __syncthreads(); }
+      if (CudaTraits::WarpSize < word_count.value) {
+        __syncthreads();
+      }
 
-      for ( unsigned i = threadIdx.y ; i < word_count.value ; i += blockDim.y ) { global[i] = shared[i]; }
+      for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
+        global[i] = shared[i];
+      }
     }
   }
 
-/*  __device__ inline
-   void run(const DummyShflReductionType&) const
-   {
-
-     value_type value;
-     ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , &value);
-     // Number of blocks is bounded so that the reduction can be limited to two passes.
-     // Each thread block is given an approximately equal amount of work to perform.
-     // Accumulate the values for this block.
-     // The accumulation ordering does not match the final pass, but is arithmatically equivalent.
-
-     const Member work_part =
-       ( ( m_policy.m_num_tiles + ( gridDim.x - 1 ) ) / gridDim.x ); //portion of tiles handled by each block
-
-     this-> exec_range( value );
-
-     pointer_type const result = (pointer_type) (m_unified_space ? m_unified_space : m_scratch_space) ;
-
-     int max_active_thread = work_part < blockDim.y ? work_part:blockDim.y;
-     max_active_thread = (max_active_thread == 0)?blockDim.y:max_active_thread;
-
-     value_type init;
-     ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , &init);
-     if(Impl::cuda_inter_block_reduction<ReducerTypeFwd,ValueJoin,WorkTagFwd>
-         (value,init,ValueJoin(ReducerConditional::select(m_functor , m_reducer)),m_scratch_space,result,m_scratch_flags,max_active_thread)) {
-       const unsigned id = threadIdx.y*blockDim.x + threadIdx.x;
-       if(id==0) {
-         Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , (void*) &value );
-         *result = value;
+  /*  __device__ inline
+     void run(const DummyShflReductionType&) const
+     {
+
+       value_type value;
+       ValueInit::init( ReducerConditional::select(m_functor , m_reducer) ,
+     &value);
+       // Number of blocks is bounded so that the reduction can be limited to
+     two passes.
+       // Each thread block is given an approximately equal amount of work to
+     perform.
+       // Accumulate the values for this block.
+       // The accumulation ordering does not match the final pass, but is
+     arithmatically equivalent.
+
+       const Member work_part =
+         ( ( m_policy.m_num_tiles + ( gridDim.x - 1 ) ) / gridDim.x ); //portion
+     of tiles handled by each block
+
+       this-> exec_range( value );
+
+       pointer_type const result = (pointer_type) (m_unified_space ?
+     m_unified_space : m_scratch_space) ;
+
+       int max_active_thread = work_part < blockDim.y ? work_part:blockDim.y;
+       max_active_thread = (max_active_thread ==
+     0)?blockDim.y:max_active_thread;
+
+       value_type init;
+       ValueInit::init( ReducerConditional::select(m_functor , m_reducer) ,
+     &init);
+       if(Impl::cuda_inter_block_reduction<ReducerTypeFwd,ValueJoin,WorkTagFwd>
+           (value,init,ValueJoin(ReducerConditional::select(m_functor ,
+     m_reducer)),m_scratch_space,result,m_scratch_flags,max_active_thread)) {
+         const unsigned id = threadIdx.y*blockDim.x + threadIdx.x;
+         if(id==0) {
+           Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final(
+     ReducerConditional::select(m_functor , m_reducer) , (void*) &value );
+           *result = value;
+         }
        }
      }
-   }
-*/
+  */
   // Determine block size constrained by shared memory:
-  inline
-  unsigned local_block_size( const FunctorType & f )
-    {
-      unsigned n = CudaTraits::WarpSize * 8 ;
-      int shmem_size = cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( f , n );
-      while ( (n && (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock < shmem_size)) ||
-          (n > static_cast<unsigned>(Kokkos::Impl::cuda_get_max_block_size< ParallelReduce, LaunchBounds>( f , 1, shmem_size , 0 )))) {
-        n >>= 1 ;
-        shmem_size = cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( f , n );
-      }
-      return n ;
-    }
-
-  inline
-  void execute()
-    {
-      const int nwork = m_policy.m_num_tiles;
-      if ( nwork ) {
-        int block_size = m_policy.m_prod_tile_dims;
-        // CONSTRAINT: Algorithm requires block_size >= product of tile dimensions
-        // Nearest power of two
-        int exponent_pow_two = std::ceil( std::log2(block_size) );
-        block_size = std::pow(2, exponent_pow_two);
-        int suggested_blocksize = local_block_size( m_functor );
-
-        block_size = (block_size > suggested_blocksize) ? block_size : suggested_blocksize ; //Note: block_size must be less than or equal to 512
-
-
-        m_scratch_space = cuda_internal_scratch_space( m_policy.space(), ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) * block_size /* block_size == max block_count */ );
-        m_scratch_flags = cuda_internal_scratch_flags( m_policy.space(), sizeof(size_type) );
-        m_unified_space = cuda_internal_scratch_unified( m_policy.space(), ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) );
-
-        // REQUIRED ( 1 , N , 1 )
-        const dim3 block( 1 , block_size , 1 );
-        // Required grid.x <= block.y
-        const dim3 grid( std::min( int(block.y) , int( nwork ) ) , 1 , 1 );
-
-      const int shmem = UseShflReduction?0:cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( m_functor , block.y );
+  inline unsigned local_block_size(const FunctorType& f) {
+    unsigned n = CudaTraits::WarpSize * 8;
+    int shmem_size =
+        cuda_single_inter_block_reduce_scan_shmem<false, FunctorType, WorkTag>(
+            f, n);
+    while (
+        (n &&
+         (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock <
+          shmem_size)) ||
+        (n > static_cast<unsigned>(
+                 Kokkos::Impl::cuda_get_max_block_size<
+                     ParallelReduce, LaunchBounds>(f, 1, shmem_size, 0)))) {
+      n >>= 1;
+      shmem_size = cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                             WorkTag>(f, n);
+    }
+    return n;
+  }
 
-      CudaParallelLaunch< ParallelReduce, LaunchBounds >( *this, grid, block, shmem , m_policy.space().impl_internal_space_instance() , false ); // copy to device and execute
+  inline void execute() {
+    const int nwork = m_policy.m_num_tiles;
+    if (nwork) {
+      int block_size = m_policy.m_prod_tile_dims;
+      // CONSTRAINT: Algorithm requires block_size >= product of tile dimensions
+      // Nearest power of two
+      int exponent_pow_two    = std::ceil(std::log2(block_size));
+      block_size              = std::pow(2, exponent_pow_two);
+      int suggested_blocksize = local_block_size(m_functor);
+
+      block_size = (block_size > suggested_blocksize)
+                       ? block_size
+                       : suggested_blocksize;  // Note: block_size must be less
+                                               // than or equal to 512
+
+      m_scratch_space = cuda_internal_scratch_space(
+          m_policy.space(), ValueTraits::value_size(ReducerConditional::select(
+                                m_functor, m_reducer)) *
+                                block_size /* block_size == max block_count */);
+      m_scratch_flags =
+          cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type));
+      m_unified_space = cuda_internal_scratch_unified(
+          m_policy.space(), ValueTraits::value_size(ReducerConditional::select(
+                                m_functor, m_reducer)));
+
+      // REQUIRED ( 1 , N , 1 )
+      const dim3 block(1, block_size, 1);
+      // Required grid.x <= block.y
+      const dim3 grid(std::min(int(block.y), int(nwork)), 1, 1);
+
+      const int shmem =
+          UseShflReduction
+              ? 0
+              : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                          WorkTag>(m_functor,
+                                                                   block.y);
+
+      CudaParallelLaunch<ParallelReduce, LaunchBounds>(
+          *this, grid, block, shmem,
+          m_policy.space().impl_internal_space_instance(),
+          false);  // copy to device and execute
 
-      if(!m_result_ptr_device_accessible) {
+      if (!m_result_ptr_device_accessible) {
         Cuda().fence();
 
-        if ( m_result_ptr ) {
-          if ( m_unified_space ) {
-            const int count = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer)  );
-            for ( int i = 0 ; i < count ; ++i ) { m_result_ptr[i] = pointer_type(m_unified_space)[i] ; }
-          }
-          else {
-            const int size = ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer)  );
-            DeepCopy<HostSpace,CudaSpace>( m_result_ptr , m_scratch_space , size );
+        if (m_result_ptr) {
+          if (m_unified_space) {
+            const int count = ValueTraits::value_count(
+                ReducerConditional::select(m_functor, m_reducer));
+            for (int i = 0; i < count; ++i) {
+              m_result_ptr[i] = pointer_type(m_unified_space)[i];
+            }
+          } else {
+            const int size = ValueTraits::value_size(
+                ReducerConditional::select(m_functor, m_reducer));
+            DeepCopy<HostSpace, CudaSpace>(m_result_ptr, m_scratch_space, size);
           }
         }
       }
-    }
-    else {
+    } else {
       if (m_result_ptr) {
-        ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , m_result_ptr );
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                        m_result_ptr);
       }
     }
   }
 
-  template< class ViewType >
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ViewType & arg_result
-                , typename std::enable_if<
-                   Kokkos::is_view< ViewType >::value
-                ,void*>::type = NULL)
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( InvalidType() )
-  , m_result_ptr( arg_result.data() )
-  , m_result_ptr_device_accessible(MemorySpaceAccess< Kokkos::CudaSpace , typename ViewType::memory_space>::accessible )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_unified_space( 0 )
-  {}
-
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ReducerType & reducer)
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr( reducer.view().data() )
-  , m_result_ptr_device_accessible(MemorySpaceAccess< Kokkos::CudaSpace , typename ReducerType::result_view_type::memory_space>::accessible )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_unified_space( 0 )
-  {}
+  template <class ViewType>
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const ViewType& arg_result,
+                 typename std::enable_if<Kokkos::is_view<ViewType>::value,
+                                         void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<Kokkos::CudaSpace,
+                              typename ViewType::memory_space>::accessible),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_unified_space(0) {}
+
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<Kokkos::CudaSpace,
+                              typename ReducerType::result_view_type::
+                                  memory_space>::accessible),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_unified_space(0) {}
 };
 
-
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ReducerType, class ... Properties >
-class ParallelReduce< FunctorType
-                    , Kokkos::TeamPolicy< Properties ... >
-                    , ReducerType
-                    , Kokkos::Cuda
-                    >
-{
-public:
-  typedef TeamPolicyInternal< Kokkos::Cuda, Properties ... >  Policy ;
-private:
-
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::launch_bounds     LaunchBounds ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
-  typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+template <class FunctorType, class ReducerType, class... Properties>
+class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                     ReducerType, Kokkos::Cuda> {
+ public:
+  typedef TeamPolicyInternal<Kokkos::Cuda, Properties...> Policy;
+
+ private:
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::launch_bounds LaunchBounds;
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd, WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd, WorkTagFwd > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd, WorkTagFwd > ValueJoin ;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
+  typedef typename ReducerConditional::type ReducerTypeFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef typename ValueTraits::value_type      value_type ;
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
 
-public:
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef typename ValueTraits::value_type value_type;
 
-  typedef FunctorType      functor_type ;
-  typedef Cuda::size_type  size_type ;
+ public:
+  typedef FunctorType functor_type;
+  typedef Cuda::size_type size_type;
 
-  enum { UseShflReduction = (true && (ValueTraits::StaticValueSize!=0)) };
+  enum { UseShflReduction = (true && (ValueTraits::StaticValueSize != 0)) };
 
-private:
+ private:
   typedef double DummyShflReductionType;
   typedef int DummySHMEMReductionType;
 
-  // Algorithmic constraints: blockDim.y is a power of two AND blockDim.y == blockDim.z == 1
-  // shared memory utilization:
+  // Algorithmic constraints: blockDim.y is a power of two AND blockDim.y ==
+  // blockDim.z == 1 shared memory utilization:
   //
   //  [ global reduce space ]
   //  [ team   reduce space ]
   //  [ team   shared space ]
   //
 
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
-  const bool          m_result_ptr_device_accessible ;
-  size_type *         m_scratch_space ;
-  size_type *         m_scratch_flags ;
-  size_type *         m_unified_space ;
-  size_type           m_team_begin ;
-  size_type           m_shmem_begin ;
-  size_type           m_shmem_size ;
-  void*               m_scratch_ptr[2] ;
-  int                 m_scratch_size[2] ;
-  const size_type     m_league_size ;
-  int                 m_team_size ;
-  const size_type     m_vector_size ;
-
-  template< class TagType >
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+  size_type* m_scratch_space;
+  size_type* m_scratch_flags;
+  size_type* m_unified_space;
+  size_type m_team_begin;
+  size_type m_shmem_begin;
+  size_type m_shmem_size;
+  void* m_scratch_ptr[2];
+  int m_scratch_size[2];
+  const size_type m_league_size;
+  int m_team_size;
+  const size_type m_vector_size;
+
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_team( const Member & member , reference_type update ) const
-    { m_functor( member , update ); }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_team(const Member& member, reference_type update) const {
+    m_functor(member, update);
+  }
 
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_team( const Member & member , reference_type update ) const
-    { m_functor( TagType() , member , update ); }
-
-public:
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_team(const Member& member, reference_type update) const {
+    m_functor(TagType(), member, update);
+  }
 
-  __device__ inline
-  void operator() () const {
+ public:
+  __device__ inline void operator()() const {
     int64_t threadid = 0;
-    if ( m_scratch_size[1]>0 ) {
+    if (m_scratch_size[1] > 0) {
       __shared__ int64_t base_thread_id;
-      if (threadIdx.x==0 && threadIdx.y==0 ) {
-        threadid = (blockIdx.x*blockDim.z + threadIdx.z) %
-          (Kokkos::Impl::g_device_cuda_lock_arrays.n / (blockDim.x * blockDim.y));
+      if (threadIdx.x == 0 && threadIdx.y == 0) {
+        threadid = (blockIdx.x * blockDim.z + threadIdx.z) %
+                   (Kokkos::Impl::g_device_cuda_lock_arrays.n /
+                    (blockDim.x * blockDim.y));
         threadid *= blockDim.x * blockDim.y;
         int done = 0;
         while (!done) {
-          done = (0 == atomicCAS(&Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid],0,1));
-          if(!done) {
+          done =
+              (0 ==
+               atomicCAS(
+                   &Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid],
+                   0, 1));
+          if (!done) {
             threadid += blockDim.x * blockDim.y;
-            if(int64_t(threadid + blockDim.x * blockDim.y) >= int64_t(Kokkos::Impl::g_device_cuda_lock_arrays.n)) threadid = 0;
+            if (int64_t(threadid + blockDim.x * blockDim.y) >=
+                int64_t(Kokkos::Impl::g_device_cuda_lock_arrays.n))
+              threadid = 0;
           }
         }
         base_thread_id = threadid;
@@ -1394,272 +1635,374 @@ public:
       threadid = base_thread_id;
     }
 
-    run(Kokkos::Impl::if_c<UseShflReduction, DummyShflReductionType, DummySHMEMReductionType>::select(1,1.0), threadid );
-    if ( m_scratch_size[1]>0 ) {
+    run(Kokkos::Impl::if_c<UseShflReduction, DummyShflReductionType,
+                           DummySHMEMReductionType>::select(1, 1.0),
+        threadid);
+    if (m_scratch_size[1] > 0) {
       __syncthreads();
-      if (threadIdx.x==0 && threadIdx.y==0 )
-        Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid]=0;
+      if (threadIdx.x == 0 && threadIdx.y == 0)
+        Kokkos::Impl::g_device_cuda_lock_arrays.scratch[threadid] = 0;
     }
   }
 
-  __device__ inline
-  void run(const DummySHMEMReductionType&, const int& threadid) const
-  {
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-      word_count( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) / sizeof(size_type) );
+  __device__ inline void run(const DummySHMEMReductionType&,
+                             const int& threadid) const {
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(size_type)>
+        word_count(ValueTraits::value_size(
+                       ReducerConditional::select(m_functor, m_reducer)) /
+                   sizeof(size_type));
 
     reference_type value =
-      ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , kokkos_impl_cuda_shared_memory<size_type>() + threadIdx.y * word_count.value );
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                        kokkos_impl_cuda_shared_memory<size_type>() +
+                            threadIdx.y * word_count.value);
 
     // Iterate this block through the league
     const int int_league_size = (int)m_league_size;
-    for ( int league_rank = blockIdx.x ; league_rank < int_league_size ; league_rank += gridDim.x ) {
-      this-> template exec_team< WorkTag >
-        ( Member( kokkos_impl_cuda_shared_memory<char>() + m_team_begin
-                                        , m_shmem_begin
-                                        , m_shmem_size
-                                        , (void*) ( ((char*)m_scratch_ptr[1]) + ptrdiff_t(threadid/(blockDim.x*blockDim.y)) * m_scratch_size[1])
-                                        , m_scratch_size[1]
-                                        , league_rank
-                                        , m_league_size )
-        , value );
+    for (int league_rank = blockIdx.x; league_rank < int_league_size;
+         league_rank += gridDim.x) {
+      this->template exec_team<WorkTag>(
+          Member(kokkos_impl_cuda_shared_memory<char>() + m_team_begin,
+                 m_shmem_begin, m_shmem_size,
+                 (void*)(((char*)m_scratch_ptr[1]) +
+                         ptrdiff_t(threadid / (blockDim.x * blockDim.y)) *
+                             m_scratch_size[1]),
+                 m_scratch_size[1], league_rank, m_league_size),
+          value);
     }
 
     // Reduce with final value at blockDim.y - 1 location.
-    if ( cuda_single_inter_block_reduce_scan<false,FunctorType,WorkTag>(
-           ReducerConditional::select(m_functor , m_reducer) , blockIdx.x , gridDim.x ,
-           kokkos_impl_cuda_shared_memory<size_type>() , m_scratch_space , m_scratch_flags ) ) {
-
-      // This is the final block with the final result at the final threads' location
-
-      size_type * const shared = kokkos_impl_cuda_shared_memory<size_type>() + ( blockDim.y - 1 ) * word_count.value ;
-      size_type * const global = m_result_ptr_device_accessible? reinterpret_cast<size_type*>(m_result_ptr) :
-                                 ( m_unified_space ? m_unified_space : m_scratch_space );
-
-      if ( threadIdx.y == 0 ) {
-        Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , shared );
+    if (cuda_single_inter_block_reduce_scan<false, FunctorType, WorkTag>(
+            ReducerConditional::select(m_functor, m_reducer), blockIdx.x,
+            gridDim.x, kokkos_impl_cuda_shared_memory<size_type>(),
+            m_scratch_space, m_scratch_flags)) {
+      // This is the final block with the final result at the final threads'
+      // location
+
+      size_type* const shared = kokkos_impl_cuda_shared_memory<size_type>() +
+                                (blockDim.y - 1) * word_count.value;
+      size_type* const global =
+          m_result_ptr_device_accessible
+              ? reinterpret_cast<size_type*>(m_result_ptr)
+              : (m_unified_space ? m_unified_space : m_scratch_space);
+
+      if (threadIdx.y == 0) {
+        Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+            ReducerConditional::select(m_functor, m_reducer), shared);
       }
 
-      if ( CudaTraits::WarpSize < word_count.value ) { __syncthreads(); }
+      if (CudaTraits::WarpSize < word_count.value) {
+        __syncthreads();
+      }
 
-      for ( unsigned i = threadIdx.y ; i < word_count.value ; i += blockDim.y ) { global[i] = shared[i]; }
+      for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
+        global[i] = shared[i];
+      }
     }
-
   }
 
-  __device__ inline
-  void run(const DummyShflReductionType&, const int& threadid) const
-  {
+  __device__ inline void run(const DummyShflReductionType&,
+                             const int& threadid) const {
     value_type value;
-    ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , &value);
+    ValueInit::init(ReducerConditional::select(m_functor, m_reducer), &value);
 
     // Iterate this block through the league
     const int int_league_size = (int)m_league_size;
-    for ( int league_rank = blockIdx.x ; league_rank < int_league_size ; league_rank += gridDim.x ) {
-      this-> template exec_team< WorkTag >
-        ( Member( kokkos_impl_cuda_shared_memory<char>() + m_team_begin
-                                        , m_shmem_begin
-                                        , m_shmem_size
-                                        , (void*) ( ((char*)m_scratch_ptr[1]) + ptrdiff_t(threadid/(blockDim.x*blockDim.y)) * m_scratch_size[1])
-                                        , m_scratch_size[1]
-                                        , league_rank
-                                        , m_league_size )
-        , value );
-    }
-
-    pointer_type const result = m_result_ptr_device_accessible? m_result_ptr :
-                                (pointer_type) ( m_unified_space ? m_unified_space : m_scratch_space );
+    for (int league_rank = blockIdx.x; league_rank < int_league_size;
+         league_rank += gridDim.x) {
+      this->template exec_team<WorkTag>(
+          Member(kokkos_impl_cuda_shared_memory<char>() + m_team_begin,
+                 m_shmem_begin, m_shmem_size,
+                 (void*)(((char*)m_scratch_ptr[1]) +
+                         ptrdiff_t(threadid / (blockDim.x * blockDim.y)) *
+                             m_scratch_size[1]),
+                 m_scratch_size[1], league_rank, m_league_size),
+          value);
+    }
+
+    pointer_type const result =
+        m_result_ptr_device_accessible
+            ? m_result_ptr
+            : (pointer_type)(m_unified_space ? m_unified_space
+                                             : m_scratch_space);
 
     value_type init;
-    ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , &init);
-    if(
-        Impl::cuda_inter_block_reduction<FunctorType,ValueJoin,WorkTag>
-           (value,init,ValueJoin(ReducerConditional::select(m_functor , m_reducer)),m_scratch_space,result,m_scratch_flags,blockDim.y)
-        //This breaks a test
-        //   Kokkos::Impl::CudaReductionsFunctor<FunctorType,WorkTag,false,true>::scalar_inter_block_reduction(ReducerConditional::select(m_functor , m_reducer) , blockIdx.x , gridDim.x ,
-        //              kokkos_impl_cuda_shared_memory<size_type>() , m_scratch_space , m_scratch_flags)
+    ValueInit::init(ReducerConditional::select(m_functor, m_reducer), &init);
+    if (Impl::cuda_inter_block_reduction<FunctorType, ValueJoin, WorkTag>(
+            value, init,
+            ValueJoin(ReducerConditional::select(m_functor, m_reducer)),
+            m_scratch_space, result, m_scratch_flags, blockDim.y)
+        // This breaks a test
+        //   Kokkos::Impl::CudaReductionsFunctor<FunctorType,WorkTag,false,true>::scalar_inter_block_reduction(ReducerConditional::select(m_functor
+        //   , m_reducer) , blockIdx.x , gridDim.x ,
+        //              kokkos_impl_cuda_shared_memory<size_type>() ,
+        //              m_scratch_space , m_scratch_flags)
     ) {
-      const unsigned id = threadIdx.y*blockDim.x + threadIdx.x;
-      if(id==0) {
-        Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , (void*) &value );
+      const unsigned id = threadIdx.y * blockDim.x + threadIdx.x;
+      if (id == 0) {
+        Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+            ReducerConditional::select(m_functor, m_reducer), (void*)&value);
         *result = value;
       }
     }
   }
 
-  inline
-  void execute()
-    {
-      const int nwork = m_league_size * m_team_size ;
-      if ( nwork ) {
-        const int block_count = UseShflReduction? std::min( m_league_size , size_type(1024*32) )
-          :std::min( int(m_league_size) , m_team_size );
-
-        m_scratch_space = cuda_internal_scratch_space(m_policy.space(), ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) * block_count );
-        m_scratch_flags = cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type) );
-        m_unified_space = cuda_internal_scratch_unified( m_policy.space(),ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) );
-
-        const dim3 block( m_vector_size , m_team_size , 1 );
-        const dim3 grid( block_count , 1 , 1 );
-        const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size ;
+  inline void execute() {
+    const int nwork = m_league_size * m_team_size;
+    if (nwork) {
+      const int block_count =
+          UseShflReduction ? std::min(m_league_size, size_type(1024 * 32))
+                           : std::min(int(m_league_size), m_team_size);
+
+      m_scratch_space = cuda_internal_scratch_space(
+          m_policy.space(), ValueTraits::value_size(ReducerConditional::select(
+                                m_functor, m_reducer)) *
+                                block_count);
+      m_scratch_flags =
+          cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type));
+      m_unified_space = cuda_internal_scratch_unified(
+          m_policy.space(), ValueTraits::value_size(ReducerConditional::select(
+                                m_functor, m_reducer)));
+
+      dim3 block(m_vector_size, m_team_size, 1);
+      dim3 grid(block_count, 1, 1);
+      const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
+
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+      if (Kokkos::Impl::CudaInternal::cuda_use_serial_execution()) {
+        block = dim3(1, 1, 1);
+        grid  = dim3(1, 1, 1);
+      }
+#endif
 
-        CudaParallelLaunch< ParallelReduce, LaunchBounds >( *this, grid, block, shmem_size_total , m_policy.space().impl_internal_space_instance() , true ); // copy to device and execute
+      CudaParallelLaunch<ParallelReduce, LaunchBounds>(
+          *this, grid, block, shmem_size_total,
+          m_policy.space().impl_internal_space_instance(),
+          true);  // copy to device and execute
 
-        if(!m_result_ptr_device_accessible) {
-          Cuda().fence();
+      if (!m_result_ptr_device_accessible) {
+        Cuda().fence();
 
-          if ( m_result_ptr ) {
-            if ( m_unified_space ) {
-              const int count = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer) );
-              for ( int i = 0 ; i < count ; ++i ) { m_result_ptr[i] = pointer_type(m_unified_space)[i] ; }
-            }
-            else {
-              const int size = ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) );
-              DeepCopy<HostSpace,CudaSpace>( m_result_ptr, m_scratch_space, size );
+        if (m_result_ptr) {
+          if (m_unified_space) {
+            const int count = ValueTraits::value_count(
+                ReducerConditional::select(m_functor, m_reducer));
+            for (int i = 0; i < count; ++i) {
+              m_result_ptr[i] = pointer_type(m_unified_space)[i];
             }
+          } else {
+            const int size = ValueTraits::value_size(
+                ReducerConditional::select(m_functor, m_reducer));
+            DeepCopy<HostSpace, CudaSpace>(m_result_ptr, m_scratch_space, size);
           }
         }
       }
-      else {
-        if (m_result_ptr) {
-          ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , m_result_ptr );
-        }
+    } else {
+      if (m_result_ptr) {
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                        m_result_ptr);
       }
     }
+  }
 
-  template< class ViewType >
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ViewType & arg_result
-                , typename std::enable_if<
-                                   Kokkos::is_view< ViewType >::value
-                                ,void*>::type = NULL)
-  : m_functor( arg_functor )
-  , m_policy ( arg_policy )
-  , m_reducer( InvalidType() )
-  , m_result_ptr( arg_result.data() )
-  , m_result_ptr_device_accessible(MemorySpaceAccess< Kokkos::CudaSpace , typename ViewType::memory_space>::accessible )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_unified_space( 0 )
-  , m_team_begin( 0 )
-  , m_shmem_begin( 0 )
-  , m_shmem_size( 0 )
-  , m_scratch_ptr{NULL,NULL}
-  , m_league_size( arg_policy.league_size() )
-  , m_team_size( arg_policy.team_size() )
-  , m_vector_size( arg_policy.vector_length() )
-  {
-    cudaFuncAttributes attr = CudaParallelLaunch< ParallelReduce, LaunchBounds >::
-        get_cuda_func_attributes();
-    m_team_size = m_team_size>=0?m_team_size:
-        Kokkos::Impl::cuda_get_opt_block_size< FunctorType, LaunchBounds>(
-      m_policy.space().impl_internal_space_instance(),
-      attr, m_functor , m_vector_size,
-      m_policy.team_scratch_size(0), m_policy.thread_scratch_size(0) )/m_vector_size;
+  template <class ViewType>
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const ViewType& arg_result,
+                 typename std::enable_if<Kokkos::is_view<ViewType>::value,
+                                         void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<Kokkos::CudaSpace,
+                              typename ViewType::memory_space>::accessible),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_unified_space(0),
+        m_team_begin(0),
+        m_shmem_begin(0),
+        m_shmem_size(0),
+        m_scratch_ptr{NULL, NULL},
+        m_league_size(arg_policy.league_size()),
+        m_team_size(arg_policy.team_size()),
+        m_vector_size(arg_policy.vector_length()) {
+    cudaFuncAttributes attr =
+        CudaParallelLaunch<ParallelReduce,
+                           LaunchBounds>::get_cuda_func_attributes();
+    m_team_size =
+        m_team_size >= 0
+            ? m_team_size
+            : Kokkos::Impl::cuda_get_opt_block_size<FunctorType, LaunchBounds>(
+                  m_policy.space().impl_internal_space_instance(), attr,
+                  m_functor, m_vector_size, m_policy.team_scratch_size(0),
+                  m_policy.thread_scratch_size(0)) /
+                  m_vector_size;
 
     // Return Init value if the number of worksets is zero
-    if( m_league_size*m_team_size == 0) {
-      ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , arg_result.data() );
-      return ;
-    }
-
-    m_team_begin = UseShflReduction?0:cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( arg_functor , m_team_size );
-    m_shmem_begin = sizeof(double) * ( m_team_size + 2 );
-    m_shmem_size = m_policy.scratch_size(0,m_team_size) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , m_team_size );
+    if (m_league_size * m_team_size == 0) {
+      ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                      arg_result.data());
+      return;
+    }
+
+    m_team_begin =
+        UseShflReduction
+            ? 0
+            : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                        WorkTag>(arg_functor,
+                                                                 m_team_size);
+    m_shmem_begin = sizeof(double) * (m_team_size + 2);
+    m_shmem_size =
+        m_policy.scratch_size(0, m_team_size) +
+        FunctorTeamShmemSize<FunctorType>::value(arg_functor, m_team_size);
     m_scratch_size[0] = m_shmem_size;
-    m_scratch_size[1] = m_policy.scratch_size(1,m_team_size);
-    m_scratch_ptr[1] = m_team_size<=0?NULL:cuda_resize_scratch_space(static_cast<std::int64_t>(m_scratch_size[1])*(static_cast<std::int64_t>(Cuda::concurrency()/(m_team_size*m_vector_size))));
-
-    // The global parallel_reduce does not support vector_length other than 1 at the moment
-    if( (arg_policy.vector_length() > 1) && !UseShflReduction )
-      Impl::throw_runtime_exception( "Kokkos::parallel_reduce with a TeamPolicy using a vector length of greater than 1 is not currently supported for CUDA for dynamic sized reduction types.");
-
-    if( (m_team_size < 32) && !UseShflReduction )
-      Impl::throw_runtime_exception( "Kokkos::parallel_reduce with a TeamPolicy using a team_size smaller than 32 is not currently supported with CUDA for dynamic sized reduction types.");
-
-    // Functor's reduce memory, team scan memory, and team shared memory depend upon team size.
-
-    const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size ;
-
-    if (! Kokkos::Impl::is_integral_power_of_two( m_team_size )  && !UseShflReduction ) {
-      Kokkos::Impl::throw_runtime_exception(std::string("Kokkos::Impl::ParallelReduce< Cuda > bad team size"));
-    }
-
-    if ( m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock < shmem_size_total ) {
-      Kokkos::Impl::throw_runtime_exception(std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too much L0 scratch memory"));
-    }
-
-    if ( int(m_team_size) > arg_policy.team_size_max(m_functor,ParallelReduceTag()) ) {
-      Kokkos::Impl::throw_runtime_exception(std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too large team size."));
+    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
+    m_scratch_ptr[1] =
+        m_team_size <= 0
+            ? NULL
+            : cuda_resize_scratch_space(
+                  static_cast<std::int64_t>(m_scratch_size[1]) *
+                  (static_cast<std::int64_t>(Cuda::concurrency() /
+                                             (m_team_size * m_vector_size))));
+
+    // The global parallel_reduce does not support vector_length other than 1 at
+    // the moment
+    if ((arg_policy.vector_length() > 1) && !UseShflReduction)
+      Impl::throw_runtime_exception(
+          "Kokkos::parallel_reduce with a TeamPolicy using a vector length of "
+          "greater than 1 is not currently supported for CUDA for dynamic "
+          "sized reduction types.");
+
+    if ((m_team_size < 32) && !UseShflReduction)
+      Impl::throw_runtime_exception(
+          "Kokkos::parallel_reduce with a TeamPolicy using a team_size smaller "
+          "than 32 is not currently supported with CUDA for dynamic sized "
+          "reduction types.");
+
+    // Functor's reduce memory, team scan memory, and team shared memory depend
+    // upon team size.
+
+    const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
+
+    if (!Kokkos::Impl::is_integral_power_of_two(m_team_size) &&
+        !UseShflReduction) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelReduce< Cuda > bad team size"));
+    }
+
+    if (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock <
+        shmem_size_total) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too much "
+                      "L0 scratch memory"));
+    }
+
+    if (int(m_team_size) >
+        arg_policy.team_size_max(m_functor, m_reducer, ParallelReduceTag())) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too "
+                      "large team size."));
     }
-
   }
 
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ReducerType & reducer)
-  : m_functor( arg_functor )
-  , m_policy( arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr( reducer.view().data() )
-  , m_result_ptr_device_accessible(MemorySpaceAccess< Kokkos::CudaSpace , typename ReducerType::result_view_type::memory_space>::accessible )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_unified_space( 0 )
-  , m_team_begin( 0 )
-  , m_shmem_begin( 0 )
-  , m_shmem_size( 0 )
-  , m_scratch_ptr{NULL,NULL}
-  , m_league_size( arg_policy.league_size() )
-  , m_team_size( arg_policy.team_size() )
-  , m_vector_size( arg_policy.vector_length() )
-  {
-    cudaFuncAttributes attr = CudaParallelLaunch< ParallelReduce, LaunchBounds >::
-        get_cuda_func_attributes();
-    m_team_size = m_team_size>=0?m_team_size:
-        Kokkos::Impl::cuda_get_opt_block_size< FunctorType, LaunchBounds>(
-      m_policy.space().impl_internal_space_instance(),
-      attr, m_functor , m_vector_size,
-      m_policy.team_scratch_size(0), m_policy.thread_scratch_size(0) )/m_vector_size;
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<Kokkos::CudaSpace,
+                              typename ReducerType::result_view_type::
+                                  memory_space>::accessible),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_unified_space(0),
+        m_team_begin(0),
+        m_shmem_begin(0),
+        m_shmem_size(0),
+        m_scratch_ptr{NULL, NULL},
+        m_league_size(arg_policy.league_size()),
+        m_team_size(arg_policy.team_size()),
+        m_vector_size(arg_policy.vector_length()) {
+    cudaFuncAttributes attr =
+        CudaParallelLaunch<ParallelReduce,
+                           LaunchBounds>::get_cuda_func_attributes();
+    m_team_size =
+        m_team_size >= 0
+            ? m_team_size
+            : Kokkos::Impl::cuda_get_opt_block_size<FunctorType, LaunchBounds>(
+                  m_policy.space().impl_internal_space_instance(), attr,
+                  m_functor, m_vector_size, m_policy.team_scratch_size(0),
+                  m_policy.thread_scratch_size(0)) /
+                  m_vector_size;
 
     // Return Init value if the number of worksets is zero
-    if( arg_policy.league_size() == 0) {
-      ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , m_result_ptr );
-      return ;
-    }
-
-    m_team_begin = UseShflReduction?0:cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( arg_functor , m_team_size );
-    m_shmem_begin = sizeof(double) * ( m_team_size + 2 );
-    m_shmem_size = m_policy.scratch_size(0,m_team_size) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , m_team_size );
+    if (arg_policy.league_size() == 0) {
+      ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                      m_result_ptr);
+      return;
+    }
+
+    m_team_begin =
+        UseShflReduction
+            ? 0
+            : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                        WorkTag>(arg_functor,
+                                                                 m_team_size);
+    m_shmem_begin = sizeof(double) * (m_team_size + 2);
+    m_shmem_size =
+        m_policy.scratch_size(0, m_team_size) +
+        FunctorTeamShmemSize<FunctorType>::value(arg_functor, m_team_size);
     m_scratch_size[0] = m_shmem_size;
-    m_scratch_size[1] = m_policy.scratch_size(1,m_team_size);
-    m_scratch_ptr[1] = m_team_size<=0?NULL:cuda_resize_scratch_space(static_cast<ptrdiff_t>(m_scratch_size[1])*static_cast<ptrdiff_t>(Cuda::concurrency()/(m_team_size*m_vector_size)));
-
-    // The global parallel_reduce does not support vector_length other than 1 at the moment
-    if( (arg_policy.vector_length() > 1) && !UseShflReduction )
-      Impl::throw_runtime_exception( "Kokkos::parallel_reduce with a TeamPolicy using a vector length of greater than 1 is not currently supported for CUDA for dynamic sized reduction types.");
-
-    if( (m_team_size < 32) && !UseShflReduction )
-      Impl::throw_runtime_exception( "Kokkos::parallel_reduce with a TeamPolicy using a team_size smaller than 32 is not currently supported with CUDA for dynamic sized reduction types.");
-
-    // Functor's reduce memory, team scan memory, and team shared memory depend upon team size.
-
-    const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size ;
-
-    if ( (! Kokkos::Impl::is_integral_power_of_two( m_team_size )  && !UseShflReduction ) ||
-         m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock < shmem_size_total ) {
-      Kokkos::Impl::throw_runtime_exception(std::string("Kokkos::Impl::ParallelReduce< Cuda > bad team size"));
+    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
+    m_scratch_ptr[1] =
+        m_team_size <= 0
+            ? NULL
+            : cuda_resize_scratch_space(
+                  static_cast<ptrdiff_t>(m_scratch_size[1]) *
+                  static_cast<ptrdiff_t>(Cuda::concurrency() /
+                                         (m_team_size * m_vector_size)));
+
+    // The global parallel_reduce does not support vector_length other than 1 at
+    // the moment
+    if ((arg_policy.vector_length() > 1) && !UseShflReduction)
+      Impl::throw_runtime_exception(
+          "Kokkos::parallel_reduce with a TeamPolicy using a vector length of "
+          "greater than 1 is not currently supported for CUDA for dynamic "
+          "sized reduction types.");
+
+    if ((m_team_size < 32) && !UseShflReduction)
+      Impl::throw_runtime_exception(
+          "Kokkos::parallel_reduce with a TeamPolicy using a team_size smaller "
+          "than 32 is not currently supported with CUDA for dynamic sized "
+          "reduction types.");
+
+    // Functor's reduce memory, team scan memory, and team shared memory depend
+    // upon team size.
+
+    const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
+
+    if ((!Kokkos::Impl::is_integral_power_of_two(m_team_size) &&
+         !UseShflReduction) ||
+        m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock <
+            shmem_size_total) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelReduce< Cuda > bad team size"));
+    }
+    if (int(m_team_size) >
+        arg_policy.team_size_max(m_functor, m_reducer, ParallelReduceTag())) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too "
+                      "large team size."));
     }
-    if ( int(m_team_size) > arg_policy.team_size_max(m_functor,ParallelReduceTag()) ) {
-      Kokkos::Impl::throw_runtime_exception(std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too large team size."));
-    }
-
   }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1667,463 +2010,595 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelScan< FunctorType
-                  , Kokkos::RangePolicy< Traits ... >
-                  , Kokkos::Cuda
-                  >
-{
-public:
-  typedef Kokkos::RangePolicy< Traits ... >  Policy ;
-private:
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::launch_bounds  LaunchBounds ;
-
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, WorkTag > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueOps<    FunctorType, WorkTag > ValueOps ;
-
-public:
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef FunctorType                           functor_type ;
-  typedef Cuda::size_type                       size_type ;
-
-private:
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
+ public:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+
+ private:
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::launch_bounds LaunchBounds;
+
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, WorkTag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
+  typedef Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag> ValueOps;
+
+ public:
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef FunctorType functor_type;
+  typedef Cuda::size_type size_type;
 
+ private:
   // Algorithmic constraints:
   //  (a) blockDim.y is a power of two
   //  (b) blockDim.y == blockDim.z == 1
   //  (c) gridDim.x  <= blockDim.y * blockDim.y
   //  (d) gridDim.y  == gridDim.z == 1
 
-  const FunctorType m_functor ;
-  const Policy      m_policy ;
-  size_type *       m_scratch_space ;
-  size_type *       m_scratch_flags ;
-  size_type         m_final ;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  size_type* m_scratch_space;
+  size_type* m_scratch_flags;
+  size_type m_final;
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+  bool m_run_serial;
+#endif
 
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const Member & i , reference_type update , const bool final_result ) const
-    { m_functor( i , update , final_result ); }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const Member& i, reference_type update,
+                 const bool final_result) const {
+    m_functor(i, update, final_result);
+  }
 
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const Member & i , reference_type update , const bool final_result ) const
-    { m_functor( TagType() , i , update , final_result ); }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const Member& i, reference_type update,
+                 const bool final_result) const {
+    m_functor(TagType(), i, update, final_result);
+  }
 
   //----------------------------------------
 
-  __device__ inline
-  void initial(void) const
-  {
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-      word_count( ValueTraits::value_size( m_functor ) / sizeof(size_type) );
+  __device__ inline void initial(void) const {
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(size_type)>
+        word_count(ValueTraits::value_size(m_functor) / sizeof(size_type));
 
-    size_type * const shared_value = kokkos_impl_cuda_shared_memory<size_type>() + word_count.value * threadIdx.y ;
+    size_type* const shared_value =
+        kokkos_impl_cuda_shared_memory<size_type>() +
+        word_count.value * threadIdx.y;
 
-    ValueInit::init( m_functor , shared_value );
+    ValueInit::init(m_functor, shared_value);
 
-    // Number of blocks is bounded so that the reduction can be limited to two passes.
-    // Each thread block is given an approximately equal amount of work to perform.
-    // Accumulate the values for this block.
-    // The accumulation ordering does not match the final pass, but is arithmatically equivalent.
+    // Number of blocks is bounded so that the reduction can be limited to two
+    // passes. Each thread block is given an approximately equal amount of work
+    // to perform. Accumulate the values for this block. The accumulation
+    // ordering does not match the final pass, but is arithmatically equivalent.
 
-    const WorkRange range( m_policy , blockIdx.x , gridDim.x );
+    const WorkRange range(m_policy, blockIdx.x, gridDim.x);
 
-    for ( Member iwork = range.begin() + threadIdx.y , iwork_end = range.end() ;
-          iwork < iwork_end ; iwork += blockDim.y ) {
-      this-> template exec_range< WorkTag >( iwork , ValueOps::reference( shared_value ) , false );
+    for (Member iwork = range.begin() + threadIdx.y, iwork_end = range.end();
+         iwork < iwork_end; iwork += blockDim.y) {
+      this->template exec_range<WorkTag>(
+          iwork, ValueOps::reference(shared_value), false);
     }
 
-    // Reduce and scan, writing out scan of blocks' totals and block-groups' totals.
-    // Blocks' scan values are written to 'blockIdx.x' location.
-    // Block-groups' scan values are at: i = ( j * blockDim.y - 1 ) for i < gridDim.x
-    cuda_single_inter_block_reduce_scan<true,FunctorType,WorkTag>( m_functor , blockIdx.x , gridDim.x , kokkos_impl_cuda_shared_memory<size_type>() , m_scratch_space , m_scratch_flags );
+    // Reduce and scan, writing out scan of blocks' totals and block-groups'
+    // totals. Blocks' scan values are written to 'blockIdx.x' location.
+    // Block-groups' scan values are at: i = ( j * blockDim.y - 1 ) for i <
+    // gridDim.x
+    cuda_single_inter_block_reduce_scan<true, FunctorType, WorkTag>(
+        m_functor, blockIdx.x, gridDim.x,
+        kokkos_impl_cuda_shared_memory<size_type>(), m_scratch_space,
+        m_scratch_flags);
   }
 
   //----------------------------------------
 
-  __device__ inline
-  void final(void) const
-  {
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-      word_count( ValueTraits::value_size( m_functor ) / sizeof(size_type) );
+  __device__ inline void final(void) const {
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(size_type)>
+        word_count(ValueTraits::value_size(m_functor) / sizeof(size_type));
 
-    // Use shared memory as an exclusive scan: { 0 , value[0] , value[1] , value[2] , ... }
-    size_type * const shared_data   = kokkos_impl_cuda_shared_memory<size_type>();
-    size_type * const shared_prefix = shared_data + word_count.value * threadIdx.y ;
-    size_type * const shared_accum  = shared_data + word_count.value * ( blockDim.y + 1 );
+    // Use shared memory as an exclusive scan: { 0 , value[0] , value[1] ,
+    // value[2] , ... }
+    size_type* const shared_data = kokkos_impl_cuda_shared_memory<size_type>();
+    size_type* const shared_prefix =
+        shared_data + word_count.value * threadIdx.y;
+    size_type* const shared_accum =
+        shared_data + word_count.value * (blockDim.y + 1);
 
     // Starting value for this thread block is the previous block's total.
-    if ( blockIdx.x ) {
-      size_type * const block_total = m_scratch_space + word_count.value * ( blockIdx.x - 1 );
-      for ( unsigned i = threadIdx.y ; i < word_count.value ; ++i ) { shared_accum[i] = block_total[i] ; }
-    }
-    else if ( 0 == threadIdx.y ) {
-      ValueInit::init( m_functor , shared_accum );
+    if (blockIdx.x) {
+      size_type* const block_total =
+          m_scratch_space + word_count.value * (blockIdx.x - 1);
+      for (unsigned i = threadIdx.y; i < word_count.value; ++i) {
+        shared_accum[i] = block_total[i];
+      }
+    } else if (0 == threadIdx.y) {
+      ValueInit::init(m_functor, shared_accum);
     }
 
-    const WorkRange range( m_policy , blockIdx.x , gridDim.x );
+    const WorkRange range(m_policy, blockIdx.x, gridDim.x);
 
-    for ( typename Policy::member_type iwork_base = range.begin(); iwork_base < range.end() ; iwork_base += blockDim.y ) {
-      #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      unsigned MASK=KOKKOS_IMPL_CUDA_ACTIVEMASK;
-      #endif
-      const typename Policy::member_type iwork = iwork_base + threadIdx.y ;
+    for (typename Policy::member_type iwork_base = range.begin();
+         iwork_base < range.end(); iwork_base += blockDim.y) {
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+      unsigned MASK = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+#endif
+      const typename Policy::member_type iwork = iwork_base + threadIdx.y;
 
-      __syncthreads(); // Don't overwrite previous iteration values until they are used
+      __syncthreads();  // Don't overwrite previous iteration values until they
+                        // are used
 
-      ValueInit::init( m_functor , shared_prefix + word_count.value );
+      ValueInit::init(m_functor, shared_prefix + word_count.value);
 
-      // Copy previous block's accumulation total into thread[0] prefix and inclusive scan value of this block
-      for ( unsigned i = threadIdx.y ; i < word_count.value ; ++i ) {
-        shared_data[i + word_count.value] = shared_data[i] = shared_accum[i] ;
+      // Copy previous block's accumulation total into thread[0] prefix and
+      // inclusive scan value of this block
+      for (unsigned i = threadIdx.y; i < word_count.value; ++i) {
+        shared_data[i + word_count.value] = shared_data[i] = shared_accum[i];
       }
-      #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
       KOKKOS_IMPL_CUDA_SYNCWARP_MASK(MASK);
-      #else
+#else
       KOKKOS_IMPL_CUDA_SYNCWARP;
-      #endif
-      if ( CudaTraits::WarpSize < word_count.value ) { __syncthreads(); } // Protect against large scan values.
+#endif
+      if (CudaTraits::WarpSize < word_count.value) {
+        __syncthreads();
+      }  // Protect against large scan values.
 
       // Call functor to accumulate inclusive scan value for this work item
-      if ( iwork < range.end() ) {
-        this-> template exec_range< WorkTag >( iwork , ValueOps::reference( shared_prefix + word_count.value ) , false );
+      if (iwork < range.end()) {
+        this->template exec_range<WorkTag>(
+            iwork, ValueOps::reference(shared_prefix + word_count.value),
+            false);
       }
 
       // Scan block values into locations shared_data[1..blockDim.y]
-      cuda_intra_block_reduce_scan<true,FunctorType,WorkTag>( m_functor , typename ValueTraits::pointer_type(shared_data+word_count.value) );
+      cuda_intra_block_reduce_scan<true, FunctorType, WorkTag>(
+          m_functor,
+          typename ValueTraits::pointer_type(shared_data + word_count.value));
 
       {
-        size_type * const block_total = shared_data + word_count.value * blockDim.y ;
-        for ( unsigned i = threadIdx.y ; i < word_count.value ; ++i ) { shared_accum[i] = block_total[i]; }
+        size_type* const block_total =
+            shared_data + word_count.value * blockDim.y;
+        for (unsigned i = threadIdx.y; i < word_count.value; ++i) {
+          shared_accum[i] = block_total[i];
+        }
       }
 
       // Call functor with exclusive scan value
-      if ( iwork < range.end() ) {
-        this-> template exec_range< WorkTag >( iwork , ValueOps::reference( shared_prefix ) , true );
+      if (iwork < range.end()) {
+        this->template exec_range<WorkTag>(
+            iwork, ValueOps::reference(shared_prefix), true);
       }
     }
   }
 
-public:
-
+ public:
   //----------------------------------------
 
-  __device__ inline
-  void operator()(void) const
-  {
-    if ( ! m_final ) {
-      initial();
-    }
-    else {
-      final();
+  __device__ inline void operator()(void) const {
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    if (m_run_serial) {
+      typename ValueTraits::value_type value;
+      ValueInit::init(m_functor, (void*)&value);
+      const WorkRange range(m_policy, blockIdx.x, gridDim.x);
+
+      for (typename Policy::member_type iwork_base = range.begin();
+           iwork_base < range.end(); iwork_base++) {
+        this->template exec_range<WorkTag>(iwork_base, value, true);
+      }
+    } else {
+#endif
+      if (!m_final) {
+        initial();
+      } else {
+        final();
+      }
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
     }
+#endif
   }
 
   // Determine block size constrained by shared memory:
-  inline
-  unsigned local_block_size( const FunctorType & f )
-    {
-      // blockDim.y must be power of two = 128 (4 warps) or 256 (8 warps) or 512 (16 warps)
-      // gridDim.x <= blockDim.y * blockDim.y
-      //
-      // 4 warps was 10% faster than 8 warps and 20% faster than 16 warps in unit testing
-
-      unsigned n = CudaTraits::WarpSize * 4 ;
-      while ( n && unsigned(m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock) < cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( f , n ) ) { n >>= 1 ; }
-      return n ;
-    }
-
-  inline
-  void execute()
-    {
-      const int nwork    = m_policy.end() - m_policy.begin();
-      if ( nwork ) {
-        enum { GridMaxComputeCapability_2x = 0x0ffff };
+  inline unsigned local_block_size(const FunctorType& f) {
+    // blockDim.y must be power of two = 128 (4 warps) or 256 (8 warps) or 512
+    // (16 warps) gridDim.x <= blockDim.y * blockDim.y
+    //
+    // 4 warps was 10% faster than 8 warps and 20% faster than 16 warps in unit
+    // testing
+
+    unsigned n = CudaTraits::WarpSize * 4;
+    while (n &&
+           unsigned(m_policy.space()
+                        .impl_internal_space_instance()
+                        ->m_maxShmemPerBlock) <
+               cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                         WorkTag>(f, n)) {
+      n >>= 1;
+    }
+    return n;
+  }
 
-        const int block_size = local_block_size( m_functor );
+  inline void execute() {
+    const int nwork = m_policy.end() - m_policy.begin();
+    if (nwork) {
+      enum { GridMaxComputeCapability_2x = 0x0ffff };
 
-        const int grid_max =
-          ( block_size * block_size ) < GridMaxComputeCapability_2x ?
-          ( block_size * block_size ) : GridMaxComputeCapability_2x ;
+      const int block_size = local_block_size(m_functor);
 
-        // At most 'max_grid' blocks:
-        const int max_grid = std::min( int(grid_max) , int(( nwork + block_size - 1 ) / block_size ));
+      const int grid_max =
+          (block_size * block_size) < GridMaxComputeCapability_2x
+              ? (block_size * block_size)
+              : GridMaxComputeCapability_2x;
 
-        // How much work per block:
-        const int work_per_block = ( nwork + max_grid - 1 ) / max_grid ;
+      // At most 'max_grid' blocks:
+      const int max_grid =
+          std::min(int(grid_max), int((nwork + block_size - 1) / block_size));
 
-        // How many block are really needed for this much work:
-        const int grid_x = ( nwork + work_per_block - 1 ) / work_per_block ;
+      // How much work per block:
+      const int work_per_block = (nwork + max_grid - 1) / max_grid;
 
-        m_scratch_space = cuda_internal_scratch_space( m_policy.space(), ValueTraits::value_size( m_functor ) * grid_x );
-        m_scratch_flags = cuda_internal_scratch_flags( m_policy.space(), sizeof(size_type) * 1 );
+      // How many block are really needed for this much work:
+      const int grid_x = (nwork + work_per_block - 1) / work_per_block;
 
-        const dim3 grid( grid_x , 1 , 1 );
-        const dim3 block( 1 , block_size , 1 ); // REQUIRED DIMENSIONS ( 1 , N , 1 )
-        const int shmem = ValueTraits::value_size( m_functor ) * ( block_size + 2 );
+      m_scratch_space = cuda_internal_scratch_space(
+          m_policy.space(), ValueTraits::value_size(m_functor) * grid_x);
+      m_scratch_flags =
+          cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type) * 1);
 
-        m_final = false ;
-        CudaParallelLaunch< ParallelScan, LaunchBounds >( *this, grid, block, shmem , m_policy.space().impl_internal_space_instance() , false ); // copy to device and execute
+      dim3 grid(grid_x, 1, 1);
+      dim3 block(1, block_size, 1);  // REQUIRED DIMENSIONS ( 1 , N , 1 )
+      const int shmem = ValueTraits::value_size(m_functor) * (block_size + 2);
 
-        m_final = true ;
-        CudaParallelLaunch< ParallelScan, LaunchBounds >( *this, grid, block, shmem , m_policy.space().impl_internal_space_instance() , false ); // copy to device and execute
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+      if (m_run_serial) {
+        block = dim3(1, 1, 1);
+        grid  = dim3(1, 1, 1);
+      } else {
+#endif
+        m_final = false;
+        CudaParallelLaunch<ParallelScan, LaunchBounds>(
+            *this, grid, block, shmem,
+            m_policy.space().impl_internal_space_instance(),
+            false);  // copy to device and execute
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
       }
+#endif
+      m_final = true;
+      CudaParallelLaunch<ParallelScan, LaunchBounds>(
+          *this, grid, block, shmem,
+          m_policy.space().impl_internal_space_instance(),
+          false);  // copy to device and execute
     }
+  }
 
-  ParallelScan( const FunctorType  & arg_functor ,
-                const Policy       & arg_policy )
-  : m_functor( arg_functor )
-  , m_policy( arg_policy )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_final( false )
-  { }
+  ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_final(false)
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+        ,
+        m_run_serial(Kokkos::Impl::CudaInternal::cuda_use_serial_execution())
+#endif
+  {
+  }
 };
 
 //----------------------------------------------------------------------------
-template< class FunctorType, class ReturnType, class ... Traits >
-class ParallelScanWithTotal< FunctorType
-                           , Kokkos::RangePolicy< Traits ... >
-                           , ReturnType
-                           , Kokkos::Cuda
-                           >
-{
-public:
-  typedef Kokkos::RangePolicy< Traits ... >  Policy ;
-
-private:
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::launch_bounds  LaunchBounds ;
-
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, WorkTag > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueOps<    FunctorType, WorkTag > ValueOps ;
-
-public:
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef FunctorType                           functor_type ;
-  typedef Cuda::size_type                       size_type ;
-
-private:
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::Cuda> {
+ public:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+
+ private:
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::launch_bounds LaunchBounds;
+
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, WorkTag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
+  typedef Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag> ValueOps;
 
+ public:
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef FunctorType functor_type;
+  typedef Cuda::size_type size_type;
+
+ private:
   // Algorithmic constraints:
   //  (a) blockDim.y is a power of two
   //  (b) blockDim.y == blockDim.z == 1
   //  (c) gridDim.x  <= blockDim.y * blockDim.y
   //  (d) gridDim.y  == gridDim.z == 1
 
-  const FunctorType m_functor ;
-  const Policy      m_policy ;
-  size_type *       m_scratch_space ;
-  size_type *       m_scratch_flags ;
-  size_type         m_final ;
-  ReturnType      & m_returnvalue;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  size_type* m_scratch_space;
+  size_type* m_scratch_flags;
+  size_type m_final;
+  ReturnType& m_returnvalue;
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+  bool m_run_serial;
+#endif
 
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const Member & i , reference_type update , const bool final_result ) const
-    { m_functor( i , update , final_result ); }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const Member& i, reference_type update,
+                 const bool final_result) const {
+    m_functor(i, update, final_result);
+  }
 
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const Member & i , reference_type update , const bool final_result ) const
-    { m_functor( TagType() , i , update , final_result ); }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const Member& i, reference_type update,
+                 const bool final_result) const {
+    m_functor(TagType(), i, update, final_result);
+  }
 
   //----------------------------------------
 
-  __device__ inline
-  void initial(void) const
-  {
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-      word_count( ValueTraits::value_size( m_functor ) / sizeof(size_type) );
+  __device__ inline void initial(void) const {
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(size_type)>
+        word_count(ValueTraits::value_size(m_functor) / sizeof(size_type));
 
-    size_type * const shared_value = kokkos_impl_cuda_shared_memory<size_type>() + word_count.value * threadIdx.y ;
+    size_type* const shared_value =
+        kokkos_impl_cuda_shared_memory<size_type>() +
+        word_count.value * threadIdx.y;
 
-    ValueInit::init( m_functor , shared_value );
+    ValueInit::init(m_functor, shared_value);
 
-    // Number of blocks is bounded so that the reduction can be limited to two passes.
-    // Each thread block is given an approximately equal amount of work to perform.
-    // Accumulate the values for this block.
-    // The accumulation ordering does not match the final pass, but is arithmatically equivalent.
+    // Number of blocks is bounded so that the reduction can be limited to two
+    // passes. Each thread block is given an approximately equal amount of work
+    // to perform. Accumulate the values for this block. The accumulation
+    // ordering does not match the final pass, but is arithmatically equivalent.
 
-    const WorkRange range( m_policy , blockIdx.x , gridDim.x );
+    const WorkRange range(m_policy, blockIdx.x, gridDim.x);
 
-    for ( Member iwork = range.begin() + threadIdx.y , iwork_end = range.end() ;
-          iwork < iwork_end ; iwork += blockDim.y ) {
-      this-> template exec_range< WorkTag >( iwork , ValueOps::reference( shared_value ) , false );
+    for (Member iwork = range.begin() + threadIdx.y, iwork_end = range.end();
+         iwork < iwork_end; iwork += blockDim.y) {
+      this->template exec_range<WorkTag>(
+          iwork, ValueOps::reference(shared_value), false);
     }
 
-    // Reduce and scan, writing out scan of blocks' totals and block-groups' totals.
-    // Blocks' scan values are written to 'blockIdx.x' location.
-    // Block-groups' scan values are at: i = ( j * blockDim.y - 1 ) for i < gridDim.x
-    cuda_single_inter_block_reduce_scan<true,FunctorType,WorkTag>( m_functor , blockIdx.x , gridDim.x , kokkos_impl_cuda_shared_memory<size_type>() , m_scratch_space , m_scratch_flags );
+    // Reduce and scan, writing out scan of blocks' totals and block-groups'
+    // totals. Blocks' scan values are written to 'blockIdx.x' location.
+    // Block-groups' scan values are at: i = ( j * blockDim.y - 1 ) for i <
+    // gridDim.x
+    cuda_single_inter_block_reduce_scan<true, FunctorType, WorkTag>(
+        m_functor, blockIdx.x, gridDim.x,
+        kokkos_impl_cuda_shared_memory<size_type>(), m_scratch_space,
+        m_scratch_flags);
   }
 
   //----------------------------------------
 
-  __device__ inline
-  void final(void) const
-  {
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-      word_count( ValueTraits::value_size( m_functor ) / sizeof(size_type) );
+  __device__ inline void final(void) const {
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(size_type)>
+        word_count(ValueTraits::value_size(m_functor) / sizeof(size_type));
 
-    // Use shared memory as an exclusive scan: { 0 , value[0] , value[1] , value[2] , ... }
-    size_type * const shared_data   = kokkos_impl_cuda_shared_memory<size_type>();
-    size_type * const shared_prefix = shared_data + word_count.value * threadIdx.y ;
-    size_type * const shared_accum  = shared_data + word_count.value * ( blockDim.y + 1 );
+    // Use shared memory as an exclusive scan: { 0 , value[0] , value[1] ,
+    // value[2] , ... }
+    size_type* const shared_data = kokkos_impl_cuda_shared_memory<size_type>();
+    size_type* const shared_prefix =
+        shared_data + word_count.value * threadIdx.y;
+    size_type* const shared_accum =
+        shared_data + word_count.value * (blockDim.y + 1);
 
     // Starting value for this thread block is the previous block's total.
-    if ( blockIdx.x ) {
-      size_type * const block_total = m_scratch_space + word_count.value * ( blockIdx.x - 1 );
-      for ( unsigned i = threadIdx.y ; i < word_count.value ; ++i ) { shared_accum[i] = block_total[i] ; }
-    }
-    else if ( 0 == threadIdx.y ) {
-      ValueInit::init( m_functor , shared_accum );
+    if (blockIdx.x) {
+      size_type* const block_total =
+          m_scratch_space + word_count.value * (blockIdx.x - 1);
+      for (unsigned i = threadIdx.y; i < word_count.value; ++i) {
+        shared_accum[i] = block_total[i];
+      }
+    } else if (0 == threadIdx.y) {
+      ValueInit::init(m_functor, shared_accum);
     }
 
-    const WorkRange range( m_policy , blockIdx.x , gridDim.x );
+    const WorkRange range(m_policy, blockIdx.x, gridDim.x);
 
-    for ( typename Policy::member_type iwork_base = range.begin(); iwork_base < range.end() ; iwork_base += blockDim.y ) {
-      #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      unsigned MASK=KOKKOS_IMPL_CUDA_ACTIVEMASK;
-      #endif
+    for (typename Policy::member_type iwork_base = range.begin();
+         iwork_base < range.end(); iwork_base += blockDim.y) {
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+      unsigned MASK = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+#endif
 
-      const typename Policy::member_type iwork = iwork_base + threadIdx.y ;
+      const typename Policy::member_type iwork = iwork_base + threadIdx.y;
 
-      __syncthreads(); // Don't overwrite previous iteration values until they are used
+      __syncthreads();  // Don't overwrite previous iteration values until they
+                        // are used
 
-      ValueInit::init( m_functor , shared_prefix + word_count.value );
+      ValueInit::init(m_functor, shared_prefix + word_count.value);
 
-      // Copy previous block's accumulation total into thread[0] prefix and inclusive scan value of this block
-      for ( unsigned i = threadIdx.y ; i < word_count.value ; ++i ) {
-        shared_data[i + word_count.value] = shared_data[i] = shared_accum[i] ;
+      // Copy previous block's accumulation total into thread[0] prefix and
+      // inclusive scan value of this block
+      for (unsigned i = threadIdx.y; i < word_count.value; ++i) {
+        shared_data[i + word_count.value] = shared_data[i] = shared_accum[i];
       }
 
-      #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
       KOKKOS_IMPL_CUDA_SYNCWARP_MASK(MASK);
-      #else
+#else
       KOKKOS_IMPL_CUDA_SYNCWARP;
-      #endif
-      if ( CudaTraits::WarpSize < word_count.value ) { __syncthreads(); } // Protect against large scan values.
+#endif
+      if (CudaTraits::WarpSize < word_count.value) {
+        __syncthreads();
+      }  // Protect against large scan values.
 
       // Call functor to accumulate inclusive scan value for this work item
-      if ( iwork < range.end() ) {
-        this-> template exec_range< WorkTag >( iwork , ValueOps::reference( shared_prefix + word_count.value ) , false );
+      if (iwork < range.end()) {
+        this->template exec_range<WorkTag>(
+            iwork, ValueOps::reference(shared_prefix + word_count.value),
+            false);
       }
 
       // Scan block values into locations shared_data[1..blockDim.y]
-      cuda_intra_block_reduce_scan<true,FunctorType,WorkTag>( m_functor , typename ValueTraits::pointer_type(shared_data+word_count.value) );
+      cuda_intra_block_reduce_scan<true, FunctorType, WorkTag>(
+          m_functor,
+          typename ValueTraits::pointer_type(shared_data + word_count.value));
 
       {
-        size_type * const block_total = shared_data + word_count.value * blockDim.y ;
-        for ( unsigned i = threadIdx.y ; i < word_count.value ; ++i ) { shared_accum[i] = block_total[i]; }
+        size_type* const block_total =
+            shared_data + word_count.value * blockDim.y;
+        for (unsigned i = threadIdx.y; i < word_count.value; ++i) {
+          shared_accum[i] = block_total[i];
+        }
       }
 
       // Call functor with exclusive scan value
-      if ( iwork < range.end() ) {
-        this-> template exec_range< WorkTag >( iwork , ValueOps::reference( shared_prefix ) , true );
+      if (iwork < range.end()) {
+        this->template exec_range<WorkTag>(
+            iwork, ValueOps::reference(shared_prefix), true);
       }
     }
   }
 
-public:
-
+ public:
   //----------------------------------------
 
-  __device__ inline
-  void operator()(void) const
-  {
-    if ( ! m_final ) {
-      initial();
-    }
-    else {
-      final();
+  __device__ inline void operator()(void) const {
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    if (m_run_serial) {
+      typename ValueTraits::value_type value;
+      ValueInit::init(m_functor, (void*)&value);
+      const WorkRange range(m_policy, blockIdx.x, gridDim.x);
+
+      for (typename Policy::member_type iwork_base = range.begin();
+           iwork_base < range.end(); iwork_base++) {
+        this->template exec_range<WorkTag>(iwork_base, value, true);
+      }
+      *((typename ValueTraits::value_type*)m_scratch_space) = value;
+    } else {
+#endif
+      if (!m_final) {
+        initial();
+      } else {
+        final();
+      }
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
     }
+#endif
   }
 
   // Determine block size constrained by shared memory:
-  inline
-  unsigned local_block_size( const FunctorType & f )
-    {
-      // blockDim.y must be power of two = 128 (4 warps) or 256 (8 warps) or 512 (16 warps)
-      // gridDim.x <= blockDim.y * blockDim.y
-      //
-      // 4 warps was 10% faster than 8 warps and 20% faster than 16 warps in unit testing
-
-      unsigned n = CudaTraits::WarpSize * 4 ;
-      while ( n && unsigned(m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock) < cuda_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( f , n ) ) { n >>= 1 ; }
-      return n ;
-    }
-
-  inline
-  void execute()
-    {
-      const int nwork    = m_policy.end() - m_policy.begin();
-      if ( nwork ) {
-        enum { GridMaxComputeCapability_2x = 0x0ffff };
+  inline unsigned local_block_size(const FunctorType& f) {
+    // blockDim.y must be power of two = 128 (4 warps) or 256 (8 warps) or 512
+    // (16 warps) gridDim.x <= blockDim.y * blockDim.y
+    //
+    // 4 warps was 10% faster than 8 warps and 20% faster than 16 warps in unit
+    // testing
+
+    unsigned n = CudaTraits::WarpSize * 4;
+    while (n &&
+           unsigned(m_policy.space()
+                        .impl_internal_space_instance()
+                        ->m_maxShmemPerBlock) <
+               cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                         WorkTag>(f, n)) {
+      n >>= 1;
+    }
+    return n;
+  }
 
-        const int block_size = local_block_size( m_functor );
+  inline void execute() {
+    const int nwork = m_policy.end() - m_policy.begin();
+    if (nwork) {
+      enum { GridMaxComputeCapability_2x = 0x0ffff };
 
-        const int grid_max =
-          ( block_size * block_size ) < GridMaxComputeCapability_2x ?
-          ( block_size * block_size ) : GridMaxComputeCapability_2x ;
+      const int block_size = local_block_size(m_functor);
 
-        // At most 'max_grid' blocks:
-        const int max_grid = std::min( int(grid_max) , int(( nwork + block_size - 1 ) / block_size ));
+      const int grid_max =
+          (block_size * block_size) < GridMaxComputeCapability_2x
+              ? (block_size * block_size)
+              : GridMaxComputeCapability_2x;
 
-        // How much work per block:
-        const int work_per_block = ( nwork + max_grid - 1 ) / max_grid ;
+      // At most 'max_grid' blocks:
+      const int max_grid =
+          std::min(int(grid_max), int((nwork + block_size - 1) / block_size));
 
-        // How many block are really needed for this much work:
-        const int grid_x = ( nwork + work_per_block - 1 ) / work_per_block ;
+      // How much work per block:
+      const int work_per_block = (nwork + max_grid - 1) / max_grid;
 
-        m_scratch_space = cuda_internal_scratch_space( m_policy.space(), ValueTraits::value_size( m_functor ) * grid_x );
-        m_scratch_flags = cuda_internal_scratch_flags( m_policy.space(), sizeof(size_type) * 1 );
+      // How many block are really needed for this much work:
+      const int grid_x = (nwork + work_per_block - 1) / work_per_block;
 
-        const dim3 grid( grid_x , 1 , 1 );
-        const dim3 block( 1 , block_size , 1 ); // REQUIRED DIMENSIONS ( 1 , N , 1 )
-        const int shmem = ValueTraits::value_size( m_functor ) * ( block_size + 2 );
+      m_scratch_space = cuda_internal_scratch_space(
+          m_policy.space(), ValueTraits::value_size(m_functor) * grid_x);
+      m_scratch_flags =
+          cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type) * 1);
 
-        m_final = false ;
-        CudaParallelLaunch< ParallelScanWithTotal, LaunchBounds >( *this, grid, block, shmem , m_policy.space().impl_internal_space_instance() , false ); // copy to device and execute
+      dim3 grid(grid_x, 1, 1);
+      dim3 block(1, block_size, 1);  // REQUIRED DIMENSIONS ( 1 , N , 1 )
+      const int shmem = ValueTraits::value_size(m_functor) * (block_size + 2);
 
-        m_final = true ;
-        CudaParallelLaunch< ParallelScanWithTotal, LaunchBounds >( *this, grid, block, shmem , m_policy.space().impl_internal_space_instance() , false ); // copy to device and execute
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+      if (m_run_serial) {
+        block = dim3(1, 1, 1);
+        grid  = dim3(1, 1, 1);
+      } else {
+#endif
 
-        const int size = ValueTraits::value_size( m_functor );
-        DeepCopy<HostSpace,CudaSpace>( &m_returnvalue, m_scratch_space + (grid_x - 1)*size/sizeof(int), size );
+        m_final = false;
+        CudaParallelLaunch<ParallelScanWithTotal, LaunchBounds>(
+            *this, grid, block, shmem,
+            m_policy.space().impl_internal_space_instance(),
+            false);  // copy to device and execute
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
       }
+#endif
+      m_final = true;
+      CudaParallelLaunch<ParallelScanWithTotal, LaunchBounds>(
+          *this, grid, block, shmem,
+          m_policy.space().impl_internal_space_instance(),
+          false);  // copy to device and execute
+
+      const int size = ValueTraits::value_size(m_functor);
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+      if (m_run_serial)
+        DeepCopy<HostSpace, CudaSpace>(&m_returnvalue, m_scratch_space, size);
+      else
+#endif
+        DeepCopy<HostSpace, CudaSpace>(
+            &m_returnvalue, m_scratch_space + (grid_x - 1) * size / sizeof(int),
+            size);
     }
+  }
 
-  ParallelScanWithTotal( const FunctorType  & arg_functor ,
-                         const Policy       & arg_policy ,   
-                         ReturnType         & arg_returnvalue )
-  : m_functor( arg_functor )
-  , m_policy( arg_policy )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  , m_final( false )
-  , m_returnvalue( arg_returnvalue )
-  { }
+  ParallelScanWithTotal(const FunctorType& arg_functor,
+                        const Policy& arg_policy, ReturnType& arg_returnvalue)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_scratch_space(0),
+        m_scratch_flags(0),
+        m_final(false),
+        m_returnvalue(arg_returnvalue)
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+        ,
+        m_run_serial(Kokkos::Impl::CudaInternal::cuda_use_serial_execution())
+#endif
+  {
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -2131,155 +2606,228 @@ public:
 namespace Kokkos {
 
 namespace Impl {
-  template< class FunctorType, class ExecPolicy, class ValueType , class Tag = typename ExecPolicy::work_tag>
-  struct CudaFunctorAdapter {
-    const FunctorType f;
-    typedef ValueType value_type;
-    CudaFunctorAdapter(const FunctorType& f_):f(f_) {}
-
-    __device__ inline
-    void operator() (typename ExecPolicy::work_tag, const typename ExecPolicy::member_type& i, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals third argument type of FunctorType::operator()
-      f(typename ExecPolicy::work_tag(), i, val);
-    }
-
-    __device__ inline
-    void operator() (typename ExecPolicy::work_tag, const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals third argument type of FunctorType::operator()
-      f(typename ExecPolicy::work_tag(), i, j, val);
-    }
-
-    __device__ inline
-    void operator() (typename ExecPolicy::work_tag, const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals third argument type of FunctorType::operator()
-      f(typename ExecPolicy::work_tag(), i, j, k, val);
-    }
-
-    __device__ inline
-    void operator() (typename ExecPolicy::work_tag, const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, const typename ExecPolicy::member_type& l, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals third argument type of FunctorType::operator()
-      f(typename ExecPolicy::work_tag(), i, j, k, l, val);
-    }
-
-    __device__ inline
-    void operator() (typename ExecPolicy::work_tag, const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, const typename ExecPolicy::member_type& l, const typename ExecPolicy::member_type& m, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals third argument type of FunctorType::operator()
-      f(typename ExecPolicy::work_tag(), i, j, k, l, m, val);
-    }
-
-    __device__ inline
-    void operator() (typename ExecPolicy::work_tag, const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, const typename ExecPolicy::member_type& l, const typename ExecPolicy::member_type& m, const typename ExecPolicy::member_type& n, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals third argument type of FunctorType::operator()
-      f(typename ExecPolicy::work_tag(), i, j, k, l, m, n, val);
-    }
+template <class FunctorType, class ExecPolicy, class ValueType,
+          class Tag = typename ExecPolicy::work_tag>
+struct CudaFunctorAdapter {
+  const FunctorType f;
+  typedef ValueType value_type;
+  CudaFunctorAdapter(const FunctorType& f_) : f(f_) {}
+
+  __device__ inline void operator()(typename ExecPolicy::work_tag,
+                                    const typename ExecPolicy::member_type& i,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals third argument
+    // type of FunctorType::operator()
+    f(typename ExecPolicy::work_tag(), i, val);
+  }
 
-  };
+  __device__ inline void operator()(typename ExecPolicy::work_tag,
+                                    const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals third argument
+    // type of FunctorType::operator()
+    f(typename ExecPolicy::work_tag(), i, j, val);
+  }
 
-  template< class FunctorType, class ExecPolicy, class ValueType >
-  struct CudaFunctorAdapter<FunctorType,ExecPolicy,ValueType,void> {
-    const FunctorType f;
-    typedef ValueType value_type;
-    CudaFunctorAdapter(const FunctorType& f_):f(f_) {}
+  __device__ inline void operator()(typename ExecPolicy::work_tag,
+                                    const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals third argument
+    // type of FunctorType::operator()
+    f(typename ExecPolicy::work_tag(), i, j, k, val);
+  }
 
-    __device__ inline
-    void operator() (const typename ExecPolicy::member_type& i, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,val);
-    }
+  __device__ inline void operator()(typename ExecPolicy::work_tag,
+                                    const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    const typename ExecPolicy::member_type& l,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals third argument
+    // type of FunctorType::operator()
+    f(typename ExecPolicy::work_tag(), i, j, k, l, val);
+  }
 
-    __device__ inline
-    void operator() (const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,val);
-    }
+  __device__ inline void operator()(typename ExecPolicy::work_tag,
+                                    const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    const typename ExecPolicy::member_type& l,
+                                    const typename ExecPolicy::member_type& m,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals third argument
+    // type of FunctorType::operator()
+    f(typename ExecPolicy::work_tag(), i, j, k, l, m, val);
+  }
 
-    __device__ inline
-    void operator() (const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,val);
-    }
+  __device__ inline void operator()(typename ExecPolicy::work_tag,
+                                    const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    const typename ExecPolicy::member_type& l,
+                                    const typename ExecPolicy::member_type& m,
+                                    const typename ExecPolicy::member_type& n,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals third argument
+    // type of FunctorType::operator()
+    f(typename ExecPolicy::work_tag(), i, j, k, l, m, n, val);
+  }
+};
 
-    __device__ inline
-    void operator() (const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, const typename ExecPolicy::member_type& l, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,l,val);
-    }
+template <class FunctorType, class ExecPolicy, class ValueType>
+struct CudaFunctorAdapter<FunctorType, ExecPolicy, ValueType, void> {
+  const FunctorType f;
+  typedef ValueType value_type;
+  CudaFunctorAdapter(const FunctorType& f_) : f(f_) {}
+
+  __device__ inline void operator()(const typename ExecPolicy::member_type& i,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, val);
+  }
 
-    __device__ inline
-    void operator() (const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, const typename ExecPolicy::member_type& l, const typename ExecPolicy::member_type& m, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,l,m,val);
-    }
+  __device__ inline void operator()(const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, val);
+  }
 
-    __device__ inline
-    void operator() (const typename ExecPolicy::member_type& i, const typename ExecPolicy::member_type& j, const typename ExecPolicy::member_type& k, const typename ExecPolicy::member_type& l, const typename ExecPolicy::member_type& m, const typename ExecPolicy::member_type& n, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,l,m,n,val);
-    }
+  __device__ inline void operator()(const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, val);
+  }
 
+  __device__ inline void operator()(const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    const typename ExecPolicy::member_type& l,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, l, val);
+  }
 
-    __device__ inline
-    void operator() (typename ExecPolicy::member_type& i, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,val);
-    }
+  __device__ inline void operator()(const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    const typename ExecPolicy::member_type& l,
+                                    const typename ExecPolicy::member_type& m,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, l, m, val);
+  }
 
-    __device__ inline
-    void operator() (typename ExecPolicy::member_type& i, typename ExecPolicy::member_type& j, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,val);
-    }
+  __device__ inline void operator()(const typename ExecPolicy::member_type& i,
+                                    const typename ExecPolicy::member_type& j,
+                                    const typename ExecPolicy::member_type& k,
+                                    const typename ExecPolicy::member_type& l,
+                                    const typename ExecPolicy::member_type& m,
+                                    const typename ExecPolicy::member_type& n,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, l, m, n, val);
+  }
 
-    __device__ inline
-    void operator() (typename ExecPolicy::member_type& i, typename ExecPolicy::member_type& j, typename ExecPolicy::member_type& k, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,val);
-    }
+  __device__ inline void operator()(typename ExecPolicy::member_type& i,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, val);
+  }
 
-    __device__ inline
-    void operator() (typename ExecPolicy::member_type& i, typename ExecPolicy::member_type& j, typename ExecPolicy::member_type& k, typename ExecPolicy::member_type& l, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,l,val);
-    }
+  __device__ inline void operator()(typename ExecPolicy::member_type& i,
+                                    typename ExecPolicy::member_type& j,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, val);
+  }
 
-    __device__ inline
-    void operator() (typename ExecPolicy::member_type& i, typename ExecPolicy::member_type& j, typename ExecPolicy::member_type& k, typename ExecPolicy::member_type& l, typename ExecPolicy::member_type& m, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,l,m,val);
-    }
+  __device__ inline void operator()(typename ExecPolicy::member_type& i,
+                                    typename ExecPolicy::member_type& j,
+                                    typename ExecPolicy::member_type& k,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, val);
+  }
 
-    __device__ inline
-    void operator() (typename ExecPolicy::member_type& i, typename ExecPolicy::member_type& j, typename ExecPolicy::member_type& k, typename ExecPolicy::member_type& l, typename ExecPolicy::member_type& m, typename ExecPolicy::member_type& n, ValueType& val) const {
-      //Insert Static Assert with decltype on ValueType equals second argument type of FunctorType::operator()
-      f(i,j,k,l,m,n,val);
-    }
+  __device__ inline void operator()(typename ExecPolicy::member_type& i,
+                                    typename ExecPolicy::member_type& j,
+                                    typename ExecPolicy::member_type& k,
+                                    typename ExecPolicy::member_type& l,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, l, val);
+  }
 
-  };
+  __device__ inline void operator()(typename ExecPolicy::member_type& i,
+                                    typename ExecPolicy::member_type& j,
+                                    typename ExecPolicy::member_type& k,
+                                    typename ExecPolicy::member_type& l,
+                                    typename ExecPolicy::member_type& m,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, l, m, val);
+  }
 
-  template<class FunctorType, class ResultType, class Tag, bool Enable = IsNonTrivialReduceFunctor<FunctorType>::value >
-  struct FunctorReferenceType {
-    typedef ResultType& reference_type;
-  };
+  __device__ inline void operator()(typename ExecPolicy::member_type& i,
+                                    typename ExecPolicy::member_type& j,
+                                    typename ExecPolicy::member_type& k,
+                                    typename ExecPolicy::member_type& l,
+                                    typename ExecPolicy::member_type& m,
+                                    typename ExecPolicy::member_type& n,
+                                    ValueType& val) const {
+    // Insert Static Assert with decltype on ValueType equals second argument
+    // type of FunctorType::operator()
+    f(i, j, k, l, m, n, val);
+  }
+};
 
-  template<class FunctorType, class ResultType, class Tag>
-  struct FunctorReferenceType<FunctorType, ResultType, Tag, true> {
-    typedef typename Kokkos::Impl::FunctorValueTraits< FunctorType ,Tag >::reference_type reference_type;
-  };
+template <class FunctorType, class ResultType, class Tag,
+          bool Enable = IsNonTrivialReduceFunctor<FunctorType>::value>
+struct FunctorReferenceType {
+  typedef ResultType& reference_type;
+};
 
-  template< class FunctorTypeIn, class ExecPolicy, class ValueType>
-  struct ParallelReduceFunctorType<FunctorTypeIn,ExecPolicy,ValueType,Cuda> {
+template <class FunctorType, class ResultType, class Tag>
+struct FunctorReferenceType<FunctorType, ResultType, Tag, true> {
+  typedef typename Kokkos::Impl::FunctorValueTraits<
+      FunctorType, Tag>::reference_type reference_type;
+};
 
-    enum {FunctorHasValueType = IsNonTrivialReduceFunctor<FunctorTypeIn>::value };
-    typedef typename Kokkos::Impl::if_c<FunctorHasValueType, FunctorTypeIn, Impl::CudaFunctorAdapter<FunctorTypeIn,ExecPolicy,ValueType> >::type functor_type;
-    static functor_type functor(const FunctorTypeIn& functor_in) {
-      return Impl::if_c<FunctorHasValueType,FunctorTypeIn,functor_type>::select(functor_in,functor_type(functor_in));
-    }
+template <class FunctorTypeIn, class ExecPolicy, class ValueType>
+struct ParallelReduceFunctorType<FunctorTypeIn, ExecPolicy, ValueType, Cuda> {
+  enum {
+    FunctorHasValueType = IsNonTrivialReduceFunctor<FunctorTypeIn>::value
   };
+  typedef typename Kokkos::Impl::if_c<
+      FunctorHasValueType, FunctorTypeIn,
+      Impl::CudaFunctorAdapter<FunctorTypeIn, ExecPolicy, ValueType>>::type
+      functor_type;
+  static functor_type functor(const FunctorTypeIn& functor_in) {
+    return Impl::if_c<FunctorHasValueType, FunctorTypeIn, functor_type>::select(
+        functor_in, functor_type(functor_in));
+  }
+};
 
-}
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif /* defined( __CUDACC__ ) */
 #endif /* #ifndef KOKKOS_CUDA_PARALLEL_HPP */
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
index c39dddb19822519be550b8ef2b9592578415cbd6..41431bfb8da350341deac44f7e764c17b43c73dc 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_CUDA_REDUCESCAN_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
 
 #include <utility>
 
@@ -60,131 +61,6 @@
 namespace Kokkos {
 namespace Impl {
 
-//----------------------------------------------------------------------------
-// Shuffle operations require input to be a register (stack) variable
-
-// TODO: reconcile these implementations with those in Kokkos_Cuda_Vectorization.hpp
-
-template< typename T >
-__device__ inline
-void cuda_shfl( T & out , T const & in , int lane ,
-  typename std::enable_if< sizeof(int) == sizeof(T) , int >::type width
-  , unsigned mask = 0xffffffff )
-{
-  *reinterpret_cast<int*>(&out) =
-    KOKKOS_IMPL_CUDA_SHFL_MASK( mask , *reinterpret_cast<int const *>(&in) , lane , width );
-}
-
-// TODO: figure out why 64-bit shfl fails in Clang
-#if ( CUDA_VERSION >= 9000 ) && (!defined(KOKKOS_COMPILER_CLANG))
-
-template< typename T >
-__device__ inline
-void cuda_shfl( T & out , T const & in , int lane ,
-  typename std::enable_if< sizeof(long long) == sizeof(T) , int >::type width
-  , unsigned mask = 0xffffffff )
-{
-  *reinterpret_cast<long long*>(&out) =
-    KOKKOS_IMPL_CUDA_SHFL_MASK( mask , *reinterpret_cast<long long const *>(&in) , lane , width );
-}
-
-#endif
-
-template< typename T >
-__device__ inline
-void cuda_shfl( T & out , T const & in , int lane ,
-  typename std::enable_if
-    < ( KOKKOS_IMPL_CUDA_MAX_SHFL_SIZEOF < sizeof(T) ) && ( 0 == ( sizeof(T) % sizeof(int) ) )
-    , int >::type width, unsigned mask = 0xffffffff )
-{
-  enum : int { N = sizeof(T) / sizeof(int) };
-
-  for ( int i = 0 ; i < N ; ++i ) {
-    reinterpret_cast<int*>(&out)[i] =
-      KOKKOS_IMPL_CUDA_SHFL_MASK( mask , reinterpret_cast<int const *>(&in)[i] , lane , width );
-  }
-}
-
-//----------------------------------------------------------------------------
-
-template< typename T >
-__device__ inline
-void cuda_shfl_down( T & out , T const & in , int delta ,
-  typename std::enable_if< sizeof(int) == sizeof(T) , int >::type width , unsigned mask = 0xffffffff )
-{
-  *reinterpret_cast<int*>(&out) =
-    KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK( mask , *reinterpret_cast<int const *>(&in) , delta , width );
-}
-
-// TODO: figure out why 64-bit shfl fails in Clang
-#if ( CUDA_VERSION >= 9000 ) && (!defined(KOKKOS_COMPILER_CLANG))
-
-template< typename T >
-__device__ inline
-void cuda_shfl_down( T & out , T const & in , int delta ,
-  typename std::enable_if< sizeof(long long) == sizeof(T) , int >::type width , unsigned mask = 0xffffffff )
-{
-  *reinterpret_cast<long long*>(&out) =
-    KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK( mask , *reinterpret_cast<long long const *>(&in) , delta , width );
-}
-
-#endif
-
-template< typename T >
-__device__ inline
-void cuda_shfl_down( T & out , T const & in , int delta ,
-  typename std::enable_if
-    < ( KOKKOS_IMPL_CUDA_MAX_SHFL_SIZEOF < sizeof(T) ) && ( 0 == ( sizeof(T) % sizeof(int) ) )
-    , int >::type width , unsigned mask = 0xffffffff )
-{
-  enum : int { N = sizeof(T) / sizeof(int) };
-
-  for ( int i = 0 ; i < N ; ++i ) {
-    reinterpret_cast<int*>(&out)[i] =
-      KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK( mask , reinterpret_cast<int const *>(&in)[i] , delta , width );
-  }
-}
-
-//----------------------------------------------------------------------------
-
-template< typename T >
-__device__ inline
-void cuda_shfl_up( T & out , T const & in , int delta ,
-  typename std::enable_if< sizeof(int) == sizeof(T) , int >::type width , unsigned mask = 0xffffffff )
-{
-  *reinterpret_cast<int*>(&out) =
-    KOKKOS_IMPL_CUDA_SHFL_UP_MASK( mask , *reinterpret_cast<int const *>(&in) , delta , width );
-}
-
-// TODO: figure out why 64-bit shfl fails in Clang
-#if ( CUDA_VERSION >= 9000 ) && (!defined(KOKKOS_COMPILER_CLANG))
-
-template< typename T >
-__device__ inline
-void cuda_shfl_up( T & out , T const & in , int delta ,
-  typename std::enable_if< sizeof(long long) == sizeof(T) , int >::type width , unsigned mask = 0xffffffff )
-{
-  *reinterpret_cast<long long*>(&out) =
-    KOKKOS_IMPL_CUDA_SHFL_UP_MASK( mask , *reinterpret_cast<long long const *>(&in) , delta , width );
-}
-
-#endif
-
-template< typename T >
-__device__ inline
-void cuda_shfl_up( T & out , T const & in , int delta ,
-  typename std::enable_if
-    < ( KOKKOS_IMPL_CUDA_MAX_SHFL_SIZEOF < sizeof(T) ) && ( 0 == ( sizeof(T) % sizeof(int) ) )
-    , int >::type width , unsigned mask = 0xffffffff )
-{
-  enum : int { N = sizeof(T) / sizeof(int) };
-
-  for ( int i = 0 ; i < N ; ++i ) {
-    reinterpret_cast<int*>(&out)[i] =
-      KOKKOS_IMPL_CUDA_SHFL_UP_MASK( mask , reinterpret_cast<int const *>(&in)[i] , delta , width );
-  }
-}
-
 //----------------------------------------------------------------------------
 /*
  *  Algorithmic constraints:
@@ -193,511 +69,502 @@ void cuda_shfl_up( T & out , T const & in , int delta ,
  *   (c) blockDim.z == 1
  */
 
-template< class ValueType , class JoinOp>
+template <class ValueType, class JoinOp>
 __device__ inline
-typename std::enable_if< !Kokkos::is_reducer<ValueType>::value >::type
-cuda_intra_warp_reduction( ValueType& result,
-                                       const JoinOp& join,
-                                       const uint32_t max_active_thread = blockDim.y) {
-
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    cuda_intra_warp_reduction(ValueType& result, const JoinOp& join,
+                              const uint32_t max_active_thread = blockDim.y) {
   unsigned int shift = 1;
 
-  //Reduce over values from threads with different threadIdx.y
-  while(blockDim.x * shift < 32 ) {
-    const ValueType tmp = shfl_down(result, blockDim.x*shift,32u);
-    //Only join if upper thread is active (this allows non power of two for blockDim.y
-    if(threadIdx.y + shift < max_active_thread)
-      join(result , tmp);
-    shift*=2;
+  // Reduce over values from threads with different threadIdx.y
+  while (blockDim.x * shift < 32) {
+    const ValueType tmp = shfl_down(result, blockDim.x * shift, 32u);
+    // Only join if upper thread is active (this allows non power of two for
+    // blockDim.y
+    if (threadIdx.y + shift < max_active_thread) join(result, tmp);
+    shift *= 2;
   }
 
-  result = shfl(result,0,32);
+  result = shfl(result, 0, 32);
 }
 
-template< class ValueType , class JoinOp>
+template <class ValueType, class JoinOp>
 __device__ inline
-typename std::enable_if< !Kokkos::is_reducer<ValueType>::value >::type
-cuda_inter_warp_reduction( ValueType& value,
-                                       const JoinOp& join,
-                                       const int max_active_thread = blockDim.y) {
-
-  #define STEP_WIDTH 4
-  // Depending on the ValueType _shared__ memory must be aligned up to 8byte boundaries
-  // The reason not to use ValueType directly is that for types with constructors it
-  // could lead to race conditions
-  __shared__ double sh_result[(sizeof(ValueType)+7)/8*STEP_WIDTH];
-  ValueType* result = (ValueType*) & sh_result;
-  const int step = 32 / blockDim.x;
-  int shift = STEP_WIDTH;
-  const int id = threadIdx.y%step==0?threadIdx.y/step:65000;
-  if(id < STEP_WIDTH ) {
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    cuda_inter_warp_reduction(ValueType& value, const JoinOp& join,
+                              const int max_active_thread = blockDim.y) {
+#define STEP_WIDTH 4
+  // Depending on the ValueType _shared__ memory must be aligned up to 8byte
+  // boundaries The reason not to use ValueType directly is that for types with
+  // constructors it could lead to race conditions
+  __shared__ double sh_result[(sizeof(ValueType) + 7) / 8 * STEP_WIDTH];
+  ValueType* result = (ValueType*)&sh_result;
+  const int step    = 32 / blockDim.x;
+  int shift         = STEP_WIDTH;
+  const int id      = threadIdx.y % step == 0 ? threadIdx.y / step : 65000;
+  if (id < STEP_WIDTH) {
     result[id] = value;
   }
   __syncthreads();
-  while (shift<=max_active_thread/step) {
-    if(shift<=id && shift+STEP_WIDTH>id && threadIdx.x==0) {
-      join(result[id%STEP_WIDTH],value);
+  while (shift <= max_active_thread / step) {
+    if (shift <= id && shift + STEP_WIDTH > id && threadIdx.x == 0) {
+      join(result[id % STEP_WIDTH], value);
     }
     __syncthreads();
-    shift+=STEP_WIDTH;
+    shift += STEP_WIDTH;
   }
 
-
   value = result[0];
-  for(int i = 1; (i*step<max_active_thread) && i<STEP_WIDTH; i++)
-    join(value,result[i]);
+  for (int i = 1; (i * step < max_active_thread) && i < STEP_WIDTH; i++)
+    join(value, result[i]);
 }
 
-template< class ValueType , class JoinOp>
+template <class ValueType, class JoinOp>
 __device__ inline
-typename std::enable_if< !Kokkos::is_reducer<ValueType>::value >::type
-cuda_intra_block_reduction( ValueType& value,
-                                        const JoinOp& join,
-                                        const int max_active_thread = blockDim.y) {
-  cuda_intra_warp_reduction(value,join,max_active_thread);
-  cuda_inter_warp_reduction(value,join,max_active_thread);
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    cuda_intra_block_reduction(ValueType& value, const JoinOp& join,
+                               const int max_active_thread = blockDim.y) {
+  cuda_intra_warp_reduction(value, join, max_active_thread);
+  cuda_inter_warp_reduction(value, join, max_active_thread);
 }
 
-template< class FunctorType , class JoinOp , class ArgTag = void >
-__device__
-bool cuda_inter_block_reduction( typename FunctorValueTraits< FunctorType , ArgTag >::reference_type  value,
-                                 typename FunctorValueTraits< FunctorType , ArgTag >::reference_type  neutral,
-                                 const JoinOp& join,
-                                 Cuda::size_type * const m_scratch_space,
-                                 typename FunctorValueTraits< FunctorType , ArgTag >::pointer_type const result,
-                                 Cuda::size_type * const m_scratch_flags,
-                                 const int max_active_thread = blockDim.y) {
+template <class FunctorType, class JoinOp, class ArgTag = void>
+__device__ bool cuda_inter_block_reduction(
+    typename FunctorValueTraits<FunctorType, ArgTag>::reference_type value,
+    typename FunctorValueTraits<FunctorType, ArgTag>::reference_type neutral,
+    const JoinOp& join, Cuda::size_type* const m_scratch_space,
+    typename FunctorValueTraits<FunctorType, ArgTag>::pointer_type const result,
+    Cuda::size_type* const m_scratch_flags,
+    const int max_active_thread = blockDim.y) {
 #ifdef __CUDA_ARCH__
-  typedef typename FunctorValueTraits< FunctorType , ArgTag >::pointer_type pointer_type;
-  typedef typename FunctorValueTraits< FunctorType , ArgTag >::value_type value_type;
+  typedef typename FunctorValueTraits<FunctorType, ArgTag>::pointer_type
+      pointer_type;
+  typedef
+      typename FunctorValueTraits<FunctorType, ArgTag>::value_type value_type;
 
-  //Do the intra-block reduction with shfl operations and static shared memory
-  cuda_intra_block_reduction(value,join,max_active_thread);
+  // Do the intra-block reduction with shfl operations and static shared memory
+  cuda_intra_block_reduction(value, join, max_active_thread);
 
-  const int id = threadIdx.y*blockDim.x + threadIdx.x;
+  const int id = threadIdx.y * blockDim.x + threadIdx.x;
 
-  //One thread in the block writes block result to global scratch_memory
-  if(id == 0 ) {
-    pointer_type global = ((pointer_type) m_scratch_space) + blockIdx.x;
-    *global = value;
+  // One thread in the block writes block result to global scratch_memory
+  if (id == 0) {
+    pointer_type global = ((pointer_type)m_scratch_space) + blockIdx.x;
+    *global             = value;
   }
 
-  //One warp of last block performs inter block reduction through loading the block values from global scratch_memory
+  // One warp of last block performs inter block reduction through loading the
+  // block values from global scratch_memory
   bool last_block = false;
-
+  __threadfence();
   __syncthreads();
-  if ( id < 32 ) {
+  if (id < 32) {
     Cuda::size_type count;
 
-    //Figure out whether this is the last block
-    if(id == 0)
-      count = Kokkos::atomic_fetch_add(m_scratch_flags,1);
-    count = Kokkos::shfl(count,0,32);
+    // Figure out whether this is the last block
+    if (id == 0) count = Kokkos::atomic_fetch_add(m_scratch_flags, 1);
+    count = Kokkos::shfl(count, 0, 32);
 
-    //Last block does the inter block reduction
-    if( count == gridDim.x - 1) {
-      //set flag back to zero
-      if(id == 0)
-        *m_scratch_flags = 0;
+    // Last block does the inter block reduction
+    if (count == gridDim.x - 1) {
+      // set flag back to zero
+      if (id == 0) *m_scratch_flags = 0;
       last_block = true;
-      value = neutral;
+      value      = neutral;
 
-      pointer_type const volatile global = (pointer_type) m_scratch_space ;
+      pointer_type const volatile global = (pointer_type)m_scratch_space;
 
-      //Reduce all global values with splitting work over threads in one warp
-      const int step_size = blockDim.x*blockDim.y < 32 ? blockDim.x*blockDim.y : 32;
-      for(int i=id; i<(int)gridDim.x; i+=step_size) {
+      // Reduce all global values with splitting work over threads in one warp
+      const int step_size =
+          blockDim.x * blockDim.y < 32 ? blockDim.x * blockDim.y : 32;
+      for (int i = id; i < (int)gridDim.x; i += step_size) {
         value_type tmp = global[i];
         join(value, tmp);
       }
 
-      //Perform shfl reductions within the warp only join if contribution is valid (allows gridDim.x non power of two and <32)
-      if (int(blockDim.x*blockDim.y) > 1) {
-        value_type tmp = Kokkos::shfl_down(value, 1,32);
-        if( id + 1 < int(gridDim.x) )
-          join(value, tmp);
+      // Perform shfl reductions within the warp only join if contribution is
+      // valid (allows gridDim.x non power of two and <32)
+      if (int(blockDim.x * blockDim.y) > 1) {
+        value_type tmp = Kokkos::shfl_down(value, 1, 32);
+        if (id + 1 < int(gridDim.x)) join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
       unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-      int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      int active        = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 2) {
-        value_type tmp = Kokkos::shfl_down(value, 2,32);
-        if( id + 2 < int(gridDim.x) )
-          join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 2) {
+        value_type tmp = Kokkos::shfl_down(value, 2, 32);
+        if (id + 2 < int(gridDim.x)) join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 4) {
-        value_type tmp = Kokkos::shfl_down(value, 4,32);
-        if( id + 4 < int(gridDim.x) )
-          join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 4) {
+        value_type tmp = Kokkos::shfl_down(value, 4, 32);
+        if (id + 4 < int(gridDim.x)) join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 8) {
-        value_type tmp = Kokkos::shfl_down(value, 8,32);
-        if( id + 8 < int(gridDim.x) )
-          join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 8) {
+        value_type tmp = Kokkos::shfl_down(value, 8, 32);
+        if (id + 8 < int(gridDim.x)) join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 16) {
-        value_type tmp = Kokkos::shfl_down(value, 16,32);
-        if( id + 16 < int(gridDim.x) )
-          join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 16) {
+        value_type tmp = Kokkos::shfl_down(value, 16, 32);
+        if (id + 16 < int(gridDim.x)) join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
     }
   }
-  //The last block has in its thread=0 the global reduction value through "value"
+  // The last block has in its thread=0 the global reduction value through
+  // "value"
   return last_block;
 #else
   return true;
 #endif
 }
 
-template< class ReducerType >
+template <class ReducerType>
 __device__ inline
-typename std::enable_if< Kokkos::is_reducer<ReducerType>::value >::type
-cuda_intra_warp_reduction( const ReducerType& reducer,
-                           typename ReducerType::value_type& result,
-                           const uint32_t max_active_thread = blockDim.y) {
-
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    cuda_intra_warp_reduction(const ReducerType& reducer,
+                              typename ReducerType::value_type& result,
+                              const uint32_t max_active_thread = blockDim.y) {
   typedef typename ReducerType::value_type ValueType;
 
   unsigned int shift = 1;
 
-  //Reduce over values from threads with different threadIdx.y
-  while(blockDim.x * shift < 32 ) {
-    const ValueType tmp = shfl_down(result, blockDim.x*shift,32u);
-    //Only join if upper thread is active (this allows non power of two for blockDim.y
-    if(threadIdx.y + shift < max_active_thread)
-      reducer.join(result , tmp);
-    shift*=2;
+  // Reduce over values from threads with different threadIdx.y
+  while (blockDim.x * shift < 32) {
+    const ValueType tmp = shfl_down(result, blockDim.x * shift, 32u);
+    // Only join if upper thread is active (this allows non power of two for
+    // blockDim.y
+    if (threadIdx.y + shift < max_active_thread) reducer.join(result, tmp);
+    shift *= 2;
   }
 
-  result = shfl(result,0,32);
+  result              = shfl(result, 0, 32);
   reducer.reference() = result;
 }
 
-template< class ReducerType >
+template <class ReducerType>
 __device__ inline
-typename std::enable_if< Kokkos::is_reducer<ReducerType>::value >::type
-cuda_inter_warp_reduction( const ReducerType& reducer,
-                           typename ReducerType::value_type value,
-                           const int max_active_thread = blockDim.y) {
-
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    cuda_inter_warp_reduction(const ReducerType& reducer,
+                              typename ReducerType::value_type value,
+                              const int max_active_thread = blockDim.y) {
   typedef typename ReducerType::value_type ValueType;
 
-  #define STEP_WIDTH 4
-  // Depending on the ValueType _shared__ memory must be aligned up to 8byte boundaries
-  // The reason not to use ValueType directly is that for types with constructors it
-  // could lead to race conditions
-  __shared__ double sh_result[(sizeof(ValueType)+7)/8*STEP_WIDTH];
-  ValueType* result = (ValueType*) & sh_result;
-  const int step = 32 / blockDim.x;
-  int shift = STEP_WIDTH;
-  const int id = threadIdx.y%step==0?threadIdx.y/step:65000;
-  if(id < STEP_WIDTH ) {
+#define STEP_WIDTH 4
+  // Depending on the ValueType _shared__ memory must be aligned up to 8byte
+  // boundaries The reason not to use ValueType directly is that for types with
+  // constructors it could lead to race conditions
+  __shared__ double sh_result[(sizeof(ValueType) + 7) / 8 * STEP_WIDTH];
+  ValueType* result = (ValueType*)&sh_result;
+  const int step    = 32 / blockDim.x;
+  int shift         = STEP_WIDTH;
+  const int id      = threadIdx.y % step == 0 ? threadIdx.y / step : 65000;
+  if (id < STEP_WIDTH) {
     result[id] = value;
   }
   __syncthreads();
-  while (shift<=max_active_thread/step) {
-    if(shift<=id && shift+STEP_WIDTH>id && threadIdx.x==0) {
-      reducer.join(result[id%STEP_WIDTH],value);
+  while (shift <= max_active_thread / step) {
+    if (shift <= id && shift + STEP_WIDTH > id && threadIdx.x == 0) {
+      reducer.join(result[id % STEP_WIDTH], value);
     }
     __syncthreads();
-    shift+=STEP_WIDTH;
+    shift += STEP_WIDTH;
   }
 
-
   value = result[0];
-  for(int i = 1; (i*step<max_active_thread) && i<STEP_WIDTH; i++)
-    reducer.join(value,result[i]);
+  for (int i = 1; (i * step < max_active_thread) && i < STEP_WIDTH; i++)
+    reducer.join(value, result[i]);
 
   reducer.reference() = value;
 }
 
-template< class ReducerType >
+template <class ReducerType>
 __device__ inline
-typename std::enable_if< Kokkos::is_reducer<ReducerType>::value >::type
-cuda_intra_block_reduction( const ReducerType& reducer,
-                            typename ReducerType::value_type value,
-                            const int max_active_thread = blockDim.y) {
-  cuda_intra_warp_reduction(reducer,value,max_active_thread);
-  cuda_inter_warp_reduction(reducer,value,max_active_thread);
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    cuda_intra_block_reduction(const ReducerType& reducer,
+                               typename ReducerType::value_type value,
+                               const int max_active_thread = blockDim.y) {
+  cuda_intra_warp_reduction(reducer, value, max_active_thread);
+  cuda_inter_warp_reduction(reducer, value, max_active_thread);
 }
 
-template< class ReducerType >
+template <class ReducerType>
 __device__ inline
-typename std::enable_if< Kokkos::is_reducer<ReducerType>::value >::type
-cuda_intra_block_reduction( const ReducerType& reducer,
-                            const int max_active_thread = blockDim.y) {
-  cuda_intra_block_reduction(reducer,reducer.reference(),max_active_thread);
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    cuda_intra_block_reduction(const ReducerType& reducer,
+                               const int max_active_thread = blockDim.y) {
+  cuda_intra_block_reduction(reducer, reducer.reference(), max_active_thread);
 }
 
-template< class ReducerType>
+template <class ReducerType>
 __device__ inline
-typename std::enable_if< Kokkos::is_reducer<ReducerType>::value , bool >::type
-cuda_inter_block_reduction( const ReducerType& reducer,
-                            Cuda::size_type * const m_scratch_space,
-                            Cuda::size_type * const m_scratch_flags,
-                            const int max_active_thread = blockDim.y) {
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value, bool>::type
+    cuda_inter_block_reduction(const ReducerType& reducer,
+                               Cuda::size_type* const m_scratch_space,
+                               Cuda::size_type* const m_scratch_flags,
+                               const int max_active_thread = blockDim.y) {
 #ifdef __CUDA_ARCH__
   typedef typename ReducerType::value_type* pointer_type;
   typedef typename ReducerType::value_type value_type;
 
-  //Do the intra-block reduction with shfl operations and static shared memory
-  cuda_intra_block_reduction(reducer,max_active_thread);
+  // Do the intra-block reduction with shfl operations and static shared memory
+  cuda_intra_block_reduction(reducer, max_active_thread);
 
   value_type value = reducer.reference();
 
-  const int id = threadIdx.y*blockDim.x + threadIdx.x;
+  const int id = threadIdx.y * blockDim.x + threadIdx.x;
 
-  //One thread in the block writes block result to global scratch_memory
-  if(id == 0 ) {
-    pointer_type global = ((pointer_type) m_scratch_space) + blockIdx.x;
-    *global = value;
+  // One thread in the block writes block result to global scratch_memory
+  if (id == 0) {
+    pointer_type global = ((pointer_type)m_scratch_space) + blockIdx.x;
+    *global             = value;
   }
 
-  //One warp of last block performs inter block reduction through loading the block values from global scratch_memory
+  // One warp of last block performs inter block reduction through loading the
+  // block values from global scratch_memory
   bool last_block = false;
 
+  __threadfence();
   __syncthreads();
-  if ( id < 32 ) {
+  if (id < 32) {
     Cuda::size_type count;
 
-    //Figure out whether this is the last block
-    if(id == 0)
-      count = Kokkos::atomic_fetch_add(m_scratch_flags,1);
-    count = Kokkos::shfl(count,0,32);
+    // Figure out whether this is the last block
+    if (id == 0) count = Kokkos::atomic_fetch_add(m_scratch_flags, 1);
+    count = Kokkos::shfl(count, 0, 32);
 
-    //Last block does the inter block reduction
-    if( count == gridDim.x - 1) {
-      //set flag back to zero
-      if(id == 0)
-        *m_scratch_flags = 0;
+    // Last block does the inter block reduction
+    if (count == gridDim.x - 1) {
+      // set flag back to zero
+      if (id == 0) *m_scratch_flags = 0;
       last_block = true;
       reducer.init(value);
 
-      pointer_type const volatile global = (pointer_type) m_scratch_space ;
+      pointer_type const volatile global = (pointer_type)m_scratch_space;
 
-      //Reduce all global values with splitting work over threads in one warp
-      const int step_size = blockDim.x*blockDim.y < 32 ? blockDim.x*blockDim.y : 32;
-      for(int i=id; i<(int)gridDim.x; i+=step_size) {
+      // Reduce all global values with splitting work over threads in one warp
+      const int step_size =
+          blockDim.x * blockDim.y < 32 ? blockDim.x * blockDim.y : 32;
+      for (int i = id; i < (int)gridDim.x; i += step_size) {
         value_type tmp = global[i];
         reducer.join(value, tmp);
       }
 
-      //Perform shfl reductions within the warp only join if contribution is valid (allows gridDim.x non power of two and <32)
-      if (int(blockDim.x*blockDim.y) > 1) {
-        value_type tmp = Kokkos::shfl_down(value, 1,32);
-        if( id + 1 < int(gridDim.x) )
-          reducer.join(value, tmp);
+      // Perform shfl reductions within the warp only join if contribution is
+      // valid (allows gridDim.x non power of two and <32)
+      if (int(blockDim.x * blockDim.y) > 1) {
+        value_type tmp = Kokkos::shfl_down(value, 1, 32);
+        if (id + 1 < int(gridDim.x)) reducer.join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
       unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-      int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      int active        = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 2) {
-        value_type tmp = Kokkos::shfl_down(value, 2,32);
-        if( id + 2 < int(gridDim.x) )
-          reducer.join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 2) {
+        value_type tmp = Kokkos::shfl_down(value, 2, 32);
+        if (id + 2 < int(gridDim.x)) reducer.join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 4) {
-        value_type tmp = Kokkos::shfl_down(value, 4,32);
-        if( id + 4 < int(gridDim.x) )
-          reducer.join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 4) {
+        value_type tmp = Kokkos::shfl_down(value, 4, 32);
+        if (id + 4 < int(gridDim.x)) reducer.join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 8) {
-        value_type tmp = Kokkos::shfl_down(value, 8,32);
-        if( id + 8 < int(gridDim.x) )
-          reducer.join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 8) {
+        value_type tmp = Kokkos::shfl_down(value, 8, 32);
+        if (id + 8 < int(gridDim.x)) reducer.join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
-      if (int(blockDim.x*blockDim.y) > 16) {
-        value_type tmp = Kokkos::shfl_down(value, 16,32);
-        if( id + 16 < int(gridDim.x) )
-          reducer.join(value, tmp);
+      if (int(blockDim.x * blockDim.y) > 16) {
+        value_type tmp = Kokkos::shfl_down(value, 16, 32);
+        if (id + 16 < int(gridDim.x)) reducer.join(value, tmp);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+      active += KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
       active += KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
     }
   }
 
-  //The last block has in its thread=0 the global reduction value through "value"
+  // The last block has in its thread=0 the global reduction value through
+  // "value"
   return last_block;
 #else
   return true;
 #endif
 }
 
-template<class FunctorType, class ArgTag, bool DoScan, bool UseShfl>
+template <class FunctorType, class ArgTag, bool DoScan, bool UseShfl>
 struct CudaReductionsFunctor;
 
-template<class FunctorType, class ArgTag>
+template <class FunctorType, class ArgTag>
 struct CudaReductionsFunctor<FunctorType, ArgTag, false, true> {
-  typedef FunctorValueTraits< FunctorType , ArgTag >  ValueTraits ;
-  typedef FunctorValueJoin<   FunctorType , ArgTag >  ValueJoin ;
-  typedef FunctorValueInit<   FunctorType , ArgTag >  ValueInit ;
-  typedef FunctorValueOps<    FunctorType , ArgTag >  ValueOps ;
-  typedef typename ValueTraits::pointer_type  pointer_type ;
+  typedef FunctorValueTraits<FunctorType, ArgTag> ValueTraits;
+  typedef FunctorValueJoin<FunctorType, ArgTag> ValueJoin;
+  typedef FunctorValueInit<FunctorType, ArgTag> ValueInit;
+  typedef FunctorValueOps<FunctorType, ArgTag> ValueOps;
+  typedef typename ValueTraits::pointer_type pointer_type;
   typedef typename ValueTraits::value_type Scalar;
 
-  __device__
-  static inline void scalar_intra_warp_reduction(
+  __device__ static inline void scalar_intra_warp_reduction(
       const FunctorType& functor,
-      Scalar value,                            // Contribution
-      const bool skip_vector,                  // Skip threads if Kokkos vector lanes are not part of the reduction
-      const int width,                         // How much of the warp participates
-      Scalar& result)
-  {
-    unsigned mask = width==32?0xffffffff:((1<<width)-1)<<((threadIdx.y*blockDim.x+threadIdx.x)/width)*width;
-    for(int delta=skip_vector?blockDim.x:1; delta<width; delta*=2) {
-      Scalar tmp;
-      cuda_shfl_down(tmp,value,delta,width,mask);
-      ValueJoin::join( functor , &value, &tmp);
+      Scalar value,            // Contribution
+      const bool skip_vector,  // Skip threads if Kokkos vector lanes are not
+                               // part of the reduction
+      const int width,         // How much of the warp participates
+      Scalar& result) {
+    unsigned mask =
+        width == 32
+            ? 0xffffffff
+            : ((1 << width) - 1)
+                  << ((threadIdx.y * blockDim.x + threadIdx.x) / width) * width;
+    for (int delta = skip_vector ? blockDim.x : 1; delta < width; delta *= 2) {
+      Scalar tmp = Kokkos::shfl_down(value, delta, width, mask);
+      ValueJoin::join(functor, &value, &tmp);
     }
 
-    cuda_shfl(result,value,0,width,mask);
+    Impl::in_place_shfl(result, value, 0, width, mask);
   }
 
-
-  __device__
-  static inline void scalar_intra_block_reduction(
-      const FunctorType& functor,
-      Scalar value,
-      const bool skip,
-      Scalar* my_global_team_buffer_element,
-      const int shared_elements,
+  __device__ static inline void scalar_intra_block_reduction(
+      const FunctorType& functor, Scalar value, const bool skip,
+      Scalar* my_global_team_buffer_element, const int shared_elements,
       Scalar* shared_team_buffer_element) {
-
-    const int warp_id = (threadIdx.y*blockDim.x)/32;
+    const int warp_id = (threadIdx.y * blockDim.x) / 32;
     Scalar* const my_shared_team_buffer_element =
-        shared_team_buffer_element + warp_id%shared_elements;
+        shared_team_buffer_element + warp_id % shared_elements;
 
     // Warp Level Reduction, ignoring Kokkos vector entries
-    scalar_intra_warp_reduction(functor,value,skip,32,value);
+    scalar_intra_warp_reduction(functor, value, skip, 32, value);
 
-    if(warp_id<shared_elements) {
-        *my_shared_team_buffer_element=value;
+    if (warp_id < shared_elements) {
+      *my_shared_team_buffer_element = value;
     }
-    // Wait for every warp to be done before using one warp to do final cross warp reduction
+    // Wait for every warp to be done before using one warp to do final cross
+    // warp reduction
     __syncthreads();
 
-    const int num_warps = blockDim.x*blockDim.y/32;
-    for(int w = shared_elements; w<num_warps; w+=shared_elements) {
-      if(warp_id>=w && warp_id<w+shared_elements) {
-        if((threadIdx.y*blockDim.x + threadIdx.x)%32==0)
-          ValueJoin::join( functor , my_shared_team_buffer_element, &value);
+    const int num_warps = blockDim.x * blockDim.y / 32;
+    for (int w = shared_elements; w < num_warps; w += shared_elements) {
+      if (warp_id >= w && warp_id < w + shared_elements) {
+        if ((threadIdx.y * blockDim.x + threadIdx.x) % 32 == 0)
+          ValueJoin::join(functor, my_shared_team_buffer_element, &value);
       }
       __syncthreads();
     }
 
-
-    if( warp_id == 0) {
-      ValueInit::init( functor , &value );
-      for(unsigned int i=threadIdx.y*blockDim.x+threadIdx.x; i<blockDim.y*blockDim.x/32; i+=32)
-        ValueJoin::join( functor , &value,&shared_team_buffer_element[i]);
-      scalar_intra_warp_reduction(functor,value,false,32,*my_global_team_buffer_element);
+    if (warp_id == 0) {
+      ValueInit::init(functor, &value);
+      for (unsigned int i = threadIdx.y * blockDim.x + threadIdx.x;
+           i < blockDim.y * blockDim.x / 32; i += 32)
+        ValueJoin::join(functor, &value, &shared_team_buffer_element[i]);
+      scalar_intra_warp_reduction(functor, value, false, 32,
+                                  *my_global_team_buffer_element);
     }
   }
 
-  __device__
-  static inline bool scalar_inter_block_reduction(
-      const FunctorType     & functor ,
-      const Cuda::size_type   block_id ,
-      const Cuda::size_type   block_count ,
-      Cuda::size_type * const shared_data ,
-      Cuda::size_type * const global_data ,
-      Cuda::size_type * const global_flags )  {
-    Scalar* const global_team_buffer_element = ((Scalar*) global_data);
-    Scalar* const my_global_team_buffer_element = global_team_buffer_element + blockIdx.x;
-    Scalar* shared_team_buffer_elements = ((Scalar*) shared_data);
-    Scalar value = shared_team_buffer_elements[threadIdx.y];
-    int shared_elements=blockDim.x*blockDim.y/32;
-    int global_elements=block_count;
+  __device__ static inline bool scalar_inter_block_reduction(
+      const FunctorType& functor, const Cuda::size_type block_id,
+      const Cuda::size_type block_count, Cuda::size_type* const shared_data,
+      Cuda::size_type* const global_data, Cuda::size_type* const global_flags) {
+    Scalar* const global_team_buffer_element = ((Scalar*)global_data);
+    Scalar* const my_global_team_buffer_element =
+        global_team_buffer_element + blockIdx.x;
+    Scalar* shared_team_buffer_elements = ((Scalar*)shared_data);
+    Scalar value        = shared_team_buffer_elements[threadIdx.y];
+    int shared_elements = blockDim.x * blockDim.y / 32;
+    int global_elements = block_count;
     __syncthreads();
 
-    scalar_intra_block_reduction(functor,value,true,my_global_team_buffer_element,shared_elements,shared_team_buffer_elements);
+    scalar_intra_block_reduction(functor, value, true,
+                                 my_global_team_buffer_element, shared_elements,
+                                 shared_team_buffer_elements);
+    __threadfence();
     __syncthreads();
     unsigned int num_teams_done = 0;
-    if(threadIdx.x + threadIdx.y == 0) {
-      __threadfence();
-      num_teams_done = Kokkos::atomic_fetch_add(global_flags,1)+1;
+    if (threadIdx.x + threadIdx.y == 0) {
+      num_teams_done = Kokkos::atomic_fetch_add(global_flags, 1) + 1;
     }
     bool is_last_block = false;
-    if(__syncthreads_or(num_teams_done == gridDim.x)) {
-      is_last_block=true;
+    if (__syncthreads_or(num_teams_done == gridDim.x)) {
+      is_last_block = true;
       *global_flags = 0;
-      ValueInit::init( functor, &value);
-      for(int i=threadIdx.y*blockDim.x+threadIdx.x; i<global_elements; i+=blockDim.x*blockDim.y) {
-        ValueJoin::join( functor , &value,&global_team_buffer_element[i]);
+      ValueInit::init(functor, &value);
+      for (int i = threadIdx.y * blockDim.x + threadIdx.x; i < global_elements;
+           i += blockDim.x * blockDim.y) {
+        ValueJoin::join(functor, &value, &global_team_buffer_element[i]);
       }
-      scalar_intra_block_reduction(functor,value,false,shared_team_buffer_elements+(blockDim.y-1),shared_elements,shared_team_buffer_elements);
+      scalar_intra_block_reduction(
+          functor, value, false, shared_team_buffer_elements + (blockDim.y - 1),
+          shared_elements, shared_team_buffer_elements);
     }
     return is_last_block;
   }
 };
 
-template<class FunctorType, class ArgTag>
+template <class FunctorType, class ArgTag>
 struct CudaReductionsFunctor<FunctorType, ArgTag, false, false> {
-  typedef FunctorValueTraits< FunctorType , ArgTag >  ValueTraits ;
-  typedef FunctorValueJoin<   FunctorType , ArgTag >  ValueJoin ;
-  typedef FunctorValueInit<   FunctorType , ArgTag >  ValueInit ;
-  typedef FunctorValueOps<    FunctorType , ArgTag >  ValueOps ;
-  typedef typename ValueTraits::pointer_type  pointer_type ;
+  typedef FunctorValueTraits<FunctorType, ArgTag> ValueTraits;
+  typedef FunctorValueJoin<FunctorType, ArgTag> ValueJoin;
+  typedef FunctorValueInit<FunctorType, ArgTag> ValueInit;
+  typedef FunctorValueOps<FunctorType, ArgTag> ValueOps;
+  typedef typename ValueTraits::pointer_type pointer_type;
   typedef typename ValueTraits::value_type Scalar;
 
-  __device__
-  static inline void scalar_intra_warp_reduction(
+  __device__ static inline void scalar_intra_warp_reduction(
       const FunctorType& functor,
-      Scalar* value,                           // Contribution
-      const bool skip_vector,                  // Skip threads if Kokkos vector lanes are not part of the reduction
-      const int width)                         // How much of the warp participates
+      Scalar* value,           // Contribution
+      const bool skip_vector,  // Skip threads if Kokkos vector lanes are not
+                               // part of the reduction
+      const int width)         // How much of the warp participates
   {
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    unsigned mask = width==32?0xffffffff:((1<<width)-1)<<((threadIdx.y*blockDim.x+threadIdx.x)/width)*width;
+    unsigned mask =
+        width == 32
+            ? 0xffffffff
+            : ((1 << width) - 1)
+                  << ((threadIdx.y * blockDim.x + threadIdx.x) / width) * width;
 #endif
-    const int lane_id = (threadIdx.y*blockDim.x+threadIdx.x)%32;
-    for(int delta=skip_vector?blockDim.x:1; delta<width; delta*=2) {
-      if(lane_id + delta<32) {
-        ValueJoin::join( functor , value, value+delta);
+    const int lane_id = (threadIdx.y * blockDim.x + threadIdx.x) % 32;
+    for (int delta = skip_vector ? blockDim.x : 1; delta < width; delta *= 2) {
+      if (lane_id + delta < 32) {
+        ValueJoin::join(functor, value, value + delta);
       }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
       KOKKOS_IMPL_CUDA_SYNCWARP_MASK(mask);
@@ -705,71 +572,69 @@ struct CudaReductionsFunctor<FunctorType, ArgTag, false, false> {
       KOKKOS_IMPL_CUDA_SYNCWARP;
 #endif
     }
-    *value=*(value-lane_id);
+    *value = *(value - lane_id);
   }
 
-
-  __device__
-  static inline void scalar_intra_block_reduction(
-      const FunctorType& functor,
-      Scalar value,
-      const bool skip,
-      Scalar* result,
-      const int shared_elements,
-      Scalar* shared_team_buffer_element) {
-
-    const int warp_id = (threadIdx.y*blockDim.x)/32;
+  __device__ static inline void scalar_intra_block_reduction(
+      const FunctorType& functor, Scalar value, const bool skip, Scalar* result,
+      const int shared_elements, Scalar* shared_team_buffer_element) {
+    const int warp_id = (threadIdx.y * blockDim.x) / 32;
     Scalar* const my_shared_team_buffer_element =
-        shared_team_buffer_element + threadIdx.y*blockDim.x+threadIdx.x;
+        shared_team_buffer_element + threadIdx.y * blockDim.x + threadIdx.x;
     *my_shared_team_buffer_element = value;
     // Warp Level Reduction, ignoring Kokkos vector entries
-    scalar_intra_warp_reduction(functor,my_shared_team_buffer_element,skip,32);
-    // Wait for every warp to be done before using one warp to do final cross warp reduction
+    scalar_intra_warp_reduction(functor, my_shared_team_buffer_element, skip,
+                                32);
+    // Wait for every warp to be done before using one warp to do final cross
+    // warp reduction
     __syncthreads();
 
-    if( warp_id == 0) {
-      const unsigned int delta = (threadIdx.y*blockDim.x+threadIdx.x)*32;
-      if(delta<blockDim.x*blockDim.y)
+    if (warp_id == 0) {
+      const unsigned int delta = (threadIdx.y * blockDim.x + threadIdx.x) * 32;
+      if (delta < blockDim.x * blockDim.y)
         *my_shared_team_buffer_element = shared_team_buffer_element[delta];
-      KOKKOS_IMPL_CUDA_SYNCWARP;   
-      scalar_intra_warp_reduction(functor,my_shared_team_buffer_element,false,blockDim.x*blockDim.y/32);
-      if(threadIdx.x + threadIdx.y == 0) *result = *shared_team_buffer_element;
+      KOKKOS_IMPL_CUDA_SYNCWARP;
+      scalar_intra_warp_reduction(functor, my_shared_team_buffer_element, false,
+                                  blockDim.x * blockDim.y / 32);
+      if (threadIdx.x + threadIdx.y == 0) *result = *shared_team_buffer_element;
     }
   }
 
-  __device__
-  static inline bool scalar_inter_block_reduction(
-      const FunctorType     & functor ,
-      const Cuda::size_type   block_id ,
-      const Cuda::size_type   block_count ,
-      Cuda::size_type * const shared_data ,
-      Cuda::size_type * const global_data ,
-      Cuda::size_type * const global_flags )  {
-    Scalar* const global_team_buffer_element = ((Scalar*) global_data);
-    Scalar* const my_global_team_buffer_element = global_team_buffer_element + blockIdx.x;
-    Scalar* shared_team_buffer_elements = ((Scalar*) shared_data);
-    Scalar value = shared_team_buffer_elements[threadIdx.y];
-    int shared_elements=blockDim.x*blockDim.y/32;
-    int global_elements=block_count;
+  __device__ static inline bool scalar_inter_block_reduction(
+      const FunctorType& functor, const Cuda::size_type block_id,
+      const Cuda::size_type block_count, Cuda::size_type* const shared_data,
+      Cuda::size_type* const global_data, Cuda::size_type* const global_flags) {
+    Scalar* const global_team_buffer_element = ((Scalar*)global_data);
+    Scalar* const my_global_team_buffer_element =
+        global_team_buffer_element + blockIdx.x;
+    Scalar* shared_team_buffer_elements = ((Scalar*)shared_data);
+    Scalar value        = shared_team_buffer_elements[threadIdx.y];
+    int shared_elements = blockDim.x * blockDim.y / 32;
+    int global_elements = block_count;
     __syncthreads();
 
-    scalar_intra_block_reduction(functor,value,true,my_global_team_buffer_element,shared_elements,shared_team_buffer_elements);
+    scalar_intra_block_reduction(functor, value, true,
+                                 my_global_team_buffer_element, shared_elements,
+                                 shared_team_buffer_elements);
+    __threadfence();
     __syncthreads();
 
     unsigned int num_teams_done = 0;
-    if(threadIdx.x + threadIdx.y == 0) {
-      __threadfence();
-      num_teams_done = Kokkos::atomic_fetch_add(global_flags,1)+1;
+    if (threadIdx.x + threadIdx.y == 0) {
+      num_teams_done = Kokkos::atomic_fetch_add(global_flags, 1) + 1;
     }
     bool is_last_block = false;
-    if(__syncthreads_or(num_teams_done == gridDim.x)) {
-      is_last_block=true;
+    if (__syncthreads_or(num_teams_done == gridDim.x)) {
+      is_last_block = true;
       *global_flags = 0;
-      ValueInit::init( functor, &value);
-      for(int i=threadIdx.y*blockDim.x+threadIdx.x; i<global_elements; i+=blockDim.x*blockDim.y) {
-        ValueJoin::join( functor , &value,&global_team_buffer_element[i]);
+      ValueInit::init(functor, &value);
+      for (int i = threadIdx.y * blockDim.x + threadIdx.x; i < global_elements;
+           i += blockDim.x * blockDim.y) {
+        ValueJoin::join(functor, &value, &global_team_buffer_element[i]);
       }
-      scalar_intra_block_reduction(functor,value,false,shared_team_buffer_elements+(blockDim.y-1),shared_elements,shared_team_buffer_elements);
+      scalar_intra_block_reduction(
+          functor, value, false, shared_team_buffer_elements + (blockDim.y - 1),
+          shared_elements, shared_team_buffer_elements);
     }
     return is_last_block;
   }
@@ -792,116 +657,168 @@ struct CudaReductionsFunctor<FunctorType, ArgTag, false, false> {
  *   (c) blockDim.x == blockDim.z == 1
  */
 
-template< bool DoScan , class FunctorType , class ArgTag >
-__device__
-void cuda_intra_block_reduce_scan( const FunctorType & functor ,
-                                   const typename FunctorValueTraits< FunctorType , ArgTag >::pointer_type base_data )
-{
-  typedef FunctorValueTraits< FunctorType , ArgTag >  ValueTraits ;
-  typedef FunctorValueJoin<   FunctorType , ArgTag >  ValueJoin ;
+template <bool DoScan, class FunctorType, class ArgTag>
+__device__ void cuda_intra_block_reduce_scan(
+    const FunctorType& functor,
+    const typename FunctorValueTraits<FunctorType, ArgTag>::pointer_type
+        base_data) {
+  typedef FunctorValueTraits<FunctorType, ArgTag> ValueTraits;
+  typedef FunctorValueJoin<FunctorType, ArgTag> ValueJoin;
 
-  typedef typename ValueTraits::pointer_type  pointer_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
 
-  const unsigned value_count   = ValueTraits::value_count( functor );
-  const unsigned BlockSizeMask = blockDim.y - 1 ;
+  const unsigned value_count   = ValueTraits::value_count(functor);
+  const unsigned BlockSizeMask = blockDim.y - 1;
 
   // Must have power of two thread count
 
-  if ( BlockSizeMask & blockDim.y ) { Kokkos::abort("Cuda::cuda_intra_block_scan requires power-of-two blockDim"); }
+  if (BlockSizeMask & blockDim.y) {
+    Kokkos::abort("Cuda::cuda_intra_block_scan requires power-of-two blockDim");
+  }
 
-#define BLOCK_REDUCE_STEP( R , TD , S )  \
-  if ( ! ( R & ((1<<(S+1))-1) ) ) { ValueJoin::join( functor , TD , (TD - (value_count<<S)) ); }
+#define BLOCK_REDUCE_STEP(R, TD, S)                          \
+  if (!(R & ((1 << (S + 1)) - 1))) {                         \
+    ValueJoin::join(functor, TD, (TD - (value_count << S))); \
+  }
 
-#define BLOCK_SCAN_STEP( TD , N , S )  \
-  if ( N == (1<<S) ) { ValueJoin::join( functor , TD , (TD - (value_count<<S))); }
+#define BLOCK_SCAN_STEP(TD, N, S)                            \
+  if (N == (1 << S)) {                                       \
+    ValueJoin::join(functor, TD, (TD - (value_count << S))); \
+  }
 
-  const unsigned     rtid_intra = threadIdx.y ^ BlockSizeMask ;
-  const pointer_type tdata_intra = base_data + value_count * threadIdx.y ;
+  const unsigned rtid_intra      = threadIdx.y ^ BlockSizeMask;
+  const pointer_type tdata_intra = base_data + value_count * threadIdx.y;
 
-  { // Intra-warp reduction:
+  {  // Intra-warp reduction:
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,0)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 0)
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,1)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 1)
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,2)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 2)
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,3)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 3)
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,4)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 4)
     KOKKOS_IMPL_CUDA_SYNCWARP;
- }
-
-  __syncthreads(); // Wait for all warps to reduce
-
-  { // Inter-warp reduce-scan by a single warp to avoid extra synchronizations
-    const unsigned rtid_inter = ( threadIdx.y ^ BlockSizeMask ) << CudaTraits::WarpIndexShift ;
-
-    #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    unsigned inner_mask = KOKKOS_IMPL_CUDA_BALLOT_MASK(0xffffffff,(rtid_inter<blockDim.y));
-    #endif
-    if ( rtid_inter < blockDim.y ) {
-
-      const pointer_type tdata_inter = base_data + value_count * ( rtid_inter ^ BlockSizeMask );
-
-      #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-      if ( (1<<5) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,5) }
-      if ( (1<<6) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,6) }
-      if ( (1<<7) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,7) }
-      if ( (1<<8) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,8) }
-      if ( (1<<9) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,9) }
-      #else
-      if ( (1<<5) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,5) }
-      if ( (1<<6) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,6) }
-      if ( (1<<7) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,7) }
-      if ( (1<<8) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,8) }
-      if ( (1<<9) < BlockSizeMask ) { KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_REDUCE_STEP(rtid_inter,tdata_inter,9) }
-      #endif
-
-      if ( DoScan ) {
-
-        int n = ( rtid_inter &  32 ) ?  32 : (
-                ( rtid_inter &  64 ) ?  64 : (
-                ( rtid_inter & 128 ) ? 128 : (
-                ( rtid_inter & 256 ) ? 256 : 0 )));
-
-        if ( ! ( rtid_inter + n < blockDim.y ) ) n = 0 ;
-
-        #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_SCAN_STEP(tdata_inter,n,8)
-        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_SCAN_STEP(tdata_inter,n,7)
-        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_SCAN_STEP(tdata_inter,n,6)
-        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask); BLOCK_SCAN_STEP(tdata_inter,n,5)
-        #else
-        KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_SCAN_STEP(tdata_inter,n,8)
-        KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_SCAN_STEP(tdata_inter,n,7)
-        KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_SCAN_STEP(tdata_inter,n,6)
-        KOKKOS_IMPL_CUDA_SYNCWARP; BLOCK_SCAN_STEP(tdata_inter,n,5)
-        #endif
+  }
+
+  __syncthreads();  // Wait for all warps to reduce
+
+  {  // Inter-warp reduce-scan by a single warp to avoid extra synchronizations
+    const unsigned rtid_inter = (threadIdx.y ^ BlockSizeMask)
+                                << CudaTraits::WarpIndexShift;
+
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+    unsigned inner_mask =
+        KOKKOS_IMPL_CUDA_BALLOT_MASK(0xffffffff, (rtid_inter < blockDim.y));
+#endif
+    if (rtid_inter < blockDim.y) {
+      const pointer_type tdata_inter =
+          base_data + value_count * (rtid_inter ^ BlockSizeMask);
+
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+      if ((1 << 5) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 5)
+      }
+      if ((1 << 6) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 6)
+      }
+      if ((1 << 7) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 7)
+      }
+      if ((1 << 8) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 8)
+      }
+      if ((1 << 9) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 9)
+      }
+#else
+      if ((1 << 5) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 5)
+      }
+      if ((1 << 6) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 6)
+      }
+      if ((1 << 7) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 7)
+      }
+      if ((1 << 8) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 8)
+      }
+      if ((1 << 9) < BlockSizeMask) {
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_REDUCE_STEP(rtid_inter, tdata_inter, 9)
+      }
+#endif
+
+      if (DoScan) {
+        int n =
+            (rtid_inter & 32)
+                ? 32
+                : ((rtid_inter & 64)
+                       ? 64
+                       : ((rtid_inter & 128) ? 128
+                                             : ((rtid_inter & 256) ? 256 : 0)));
+
+        if (!(rtid_inter + n < blockDim.y)) n = 0;
+
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_SCAN_STEP(tdata_inter, n, 8)
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_SCAN_STEP(tdata_inter, n, 7)
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_SCAN_STEP(tdata_inter, n, 6)
+        KOKKOS_IMPL_CUDA_SYNCWARP_MASK(inner_mask);
+        BLOCK_SCAN_STEP(tdata_inter, n, 5)
+#else
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_SCAN_STEP(tdata_inter, n, 8)
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_SCAN_STEP(tdata_inter, n, 7)
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_SCAN_STEP(tdata_inter, n, 6)
+        KOKKOS_IMPL_CUDA_SYNCWARP;
+        BLOCK_SCAN_STEP(tdata_inter, n, 5)
+#endif
       }
     }
   }
 
-  __syncthreads(); // Wait for inter-warp reduce-scan to complete
+  __syncthreads();  // Wait for inter-warp reduce-scan to complete
 
-  if ( DoScan ) {
-    int n = ( rtid_intra &  1 ) ?  1 : (
-            ( rtid_intra &  2 ) ?  2 : (
-            ( rtid_intra &  4 ) ?  4 : (
-            ( rtid_intra &  8 ) ?  8 : (
-            ( rtid_intra & 16 ) ? 16 : 0 ))));
+  if (DoScan) {
+    int n =
+        (rtid_intra & 1)
+            ? 1
+            : ((rtid_intra & 2)
+                   ? 2
+                   : ((rtid_intra & 4)
+                          ? 4
+                          : ((rtid_intra & 8) ? 8
+                                              : ((rtid_intra & 16) ? 16 : 0))));
 
-    if ( ! ( rtid_intra + n < blockDim.y ) ) n = 0 ;
+    if (!(rtid_intra + n < blockDim.y)) n = 0;
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_SCAN_STEP(tdata_intra,n,4) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 4) __threadfence_block();
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_SCAN_STEP(tdata_intra,n,3) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 3) __threadfence_block();
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_SCAN_STEP(tdata_intra,n,2) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 2) __threadfence_block();
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_SCAN_STEP(tdata_intra,n,1) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 1) __threadfence_block();
     KOKKOS_IMPL_CUDA_SYNCWARP;
-    BLOCK_SCAN_STEP(tdata_intra,n,0) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 0) __threadfence_block();
     KOKKOS_IMPL_CUDA_SYNCWARP;
   }
 
@@ -918,116 +835,130 @@ void cuda_intra_block_reduce_scan( const FunctorType & functor ,
  *  Global reduce result is in the last threads' 'shared_data' location.
  */
 
-template< bool DoScan , class FunctorType , class ArgTag >
-__device__
-bool cuda_single_inter_block_reduce_scan2( const FunctorType     & functor ,
-                                    const Cuda::size_type   block_id ,
-                                    const Cuda::size_type   block_count ,
-                                    Cuda::size_type * const shared_data ,
-                                    Cuda::size_type * const global_data ,
-                                    Cuda::size_type * const global_flags )
-{
-  typedef Cuda::size_type                  size_type ;
-  typedef FunctorValueTraits< FunctorType , ArgTag >  ValueTraits ;
-  typedef FunctorValueJoin<   FunctorType , ArgTag >  ValueJoin ;
-  typedef FunctorValueInit<   FunctorType , ArgTag >  ValueInit ;
-  typedef FunctorValueOps<    FunctorType , ArgTag >  ValueOps ;
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
+template <bool DoScan, class FunctorType, class ArgTag>
+__device__ bool cuda_single_inter_block_reduce_scan2(
+    const FunctorType& functor, const Cuda::size_type block_id,
+    const Cuda::size_type block_count, Cuda::size_type* const shared_data,
+    Cuda::size_type* const global_data, Cuda::size_type* const global_flags) {
+  typedef Cuda::size_type size_type;
+  typedef FunctorValueTraits<FunctorType, ArgTag> ValueTraits;
+  typedef FunctorValueJoin<FunctorType, ArgTag> ValueJoin;
+  typedef FunctorValueInit<FunctorType, ArgTag> ValueInit;
+  typedef FunctorValueOps<FunctorType, ArgTag> ValueOps;
+
+  typedef typename ValueTraits::pointer_type pointer_type;
 
   // '__ffs' = position of the least significant bit set to 1.
   // 'blockDim.y' is guaranteed to be a power of two so this
   // is the integral shift value that can replace an integral divide.
-  const unsigned BlockSizeShift = __ffs( blockDim.y ) - 1 ;
-  const unsigned BlockSizeMask  = blockDim.y - 1 ;
+  const unsigned BlockSizeShift = __ffs(blockDim.y) - 1;
+  const unsigned BlockSizeMask  = blockDim.y - 1;
 
   // Must have power of two thread count
-  if ( BlockSizeMask & blockDim.y ) { Kokkos::abort("Cuda::cuda_single_inter_block_reduce_scan requires power-of-two blockDim"); }
+  if (BlockSizeMask & blockDim.y) {
+    Kokkos::abort(
+        "Cuda::cuda_single_inter_block_reduce_scan requires power-of-two "
+        "blockDim");
+  }
 
-  const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(size_type) >
-    word_count( ValueTraits::value_size( functor ) / sizeof(size_type) );
+  const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                 sizeof(size_type)>
+      word_count(ValueTraits::value_size(functor) / sizeof(size_type));
 
   // Reduce the accumulation for the entire block.
-  cuda_intra_block_reduce_scan<false,FunctorType,ArgTag>( functor , pointer_type(shared_data) );
+  cuda_intra_block_reduce_scan<false, FunctorType, ArgTag>(
+      functor, pointer_type(shared_data));
 
   {
     // Write accumulation total to global scratch space.
     // Accumulation total is the last thread's data.
-    size_type * const shared = shared_data + word_count.value * BlockSizeMask ;
-    size_type * const global = global_data + word_count.value * block_id ;
+    size_type* const shared = shared_data + word_count.value * BlockSizeMask;
+    size_type* const global = global_data + word_count.value * block_id;
 
-    for ( int i = int(threadIdx.y) ; i < int(word_count.value) ; i += int(blockDim.y) ) { global[i] = shared[i] ; }
+    for (int i = int(threadIdx.y); i < int(word_count.value);
+         i += int(blockDim.y)) {
+      global[i] = shared[i];
+    }
   }
-
-  // Contributing blocks note that their contribution has been completed via an atomic-increment flag
-  // If this block is not the last block to contribute to this group then the block is done.
-  const bool is_last_block =
-    ! __syncthreads_or( threadIdx.y ? 0 : ( 1 + atomicInc( global_flags , block_count - 1 ) < block_count ) );
-
-  if ( is_last_block ) {
-
-    const size_type b = ( long(block_count) * long(threadIdx.y) ) >> BlockSizeShift ;
-    const size_type e = ( long(block_count) * long( threadIdx.y + 1 ) ) >> BlockSizeShift ;
+  __threadfence();
+
+  // Contributing blocks note that their contribution has been completed via an
+  // atomic-increment flag If this block is not the last block to contribute to
+  // this group then the block is done.
+  const bool is_last_block = !__syncthreads_or(
+      threadIdx.y
+          ? 0
+          : (1 + atomicInc(global_flags, block_count - 1) < block_count));
+
+  if (is_last_block) {
+    const size_type b =
+        (long(block_count) * long(threadIdx.y)) >> BlockSizeShift;
+    const size_type e =
+        (long(block_count) * long(threadIdx.y + 1)) >> BlockSizeShift;
 
     {
-      void * const shared_ptr = shared_data + word_count.value * threadIdx.y ;
-      /* reference_type shared_value = */ ValueInit::init( functor , shared_ptr );
+      void* const shared_ptr = shared_data + word_count.value * threadIdx.y;
+      /* reference_type shared_value = */ ValueInit::init(functor, shared_ptr);
 
-      for ( size_type i = b ; i < e ; ++i ) {
-        ValueJoin::join( functor , shared_ptr , global_data + word_count.value * i );
+      for (size_type i = b; i < e; ++i) {
+        ValueJoin::join(functor, shared_ptr,
+                        global_data + word_count.value * i);
       }
     }
 
-    cuda_intra_block_reduce_scan<DoScan,FunctorType,ArgTag>( functor , pointer_type(shared_data) );
+    cuda_intra_block_reduce_scan<DoScan, FunctorType, ArgTag>(
+        functor, pointer_type(shared_data));
 
-    if ( DoScan ) {
+    if (DoScan) {
+      size_type* const shared_value =
+          shared_data +
+          word_count.value * (threadIdx.y ? threadIdx.y - 1 : blockDim.y);
 
-      size_type * const shared_value = shared_data + word_count.value * ( threadIdx.y ? threadIdx.y - 1 : blockDim.y );
-
-      if ( ! threadIdx.y ) { ValueInit::init( functor , shared_value ); }
+      if (!threadIdx.y) {
+        ValueInit::init(functor, shared_value);
+      }
 
       // Join previous inclusive scan value to each member
-      for ( size_type i = b ; i < e ; ++i ) {
-        size_type * const global_value = global_data + word_count.value * i ;
-        ValueJoin::join( functor , shared_value , global_value );
-        ValueOps ::copy( functor , global_value , shared_value );
+      for (size_type i = b; i < e; ++i) {
+        size_type* const global_value = global_data + word_count.value * i;
+        ValueJoin::join(functor, shared_value, global_value);
+        ValueOps ::copy(functor, global_value, shared_value);
       }
     }
   }
 
-  return is_last_block ;
+  return is_last_block;
 }
 
-template< bool DoScan , class FunctorType , class ArgTag >
-__device__
-bool cuda_single_inter_block_reduce_scan( const FunctorType     & functor ,
-                                          const Cuda::size_type   block_id ,
-                                          const Cuda::size_type   block_count ,
-                                          Cuda::size_type * const shared_data ,
-                                          Cuda::size_type * const global_data ,
-                                          Cuda::size_type * const global_flags )
-{
-  typedef FunctorValueTraits< FunctorType , ArgTag >  ValueTraits ;
-  if(!DoScan && ValueTraits::StaticValueSize)
-    return Kokkos::Impl::CudaReductionsFunctor<FunctorType,ArgTag,false,(ValueTraits::StaticValueSize>16)>::scalar_inter_block_reduction(functor,block_id,block_count,shared_data,global_data,global_flags);
+template <bool DoScan, class FunctorType, class ArgTag>
+__device__ bool cuda_single_inter_block_reduce_scan(
+    const FunctorType& functor, const Cuda::size_type block_id,
+    const Cuda::size_type block_count, Cuda::size_type* const shared_data,
+    Cuda::size_type* const global_data, Cuda::size_type* const global_flags) {
+  typedef FunctorValueTraits<FunctorType, ArgTag> ValueTraits;
+  if (!DoScan && ValueTraits::StaticValueSize)
+    return Kokkos::Impl::CudaReductionsFunctor<
+        FunctorType, ArgTag, false, (ValueTraits::StaticValueSize > 16)>::
+        scalar_inter_block_reduction(functor, block_id, block_count,
+                                     shared_data, global_data, global_flags);
   else
-    return cuda_single_inter_block_reduce_scan2<DoScan, FunctorType, ArgTag>(functor, block_id, block_count, shared_data, global_data, global_flags);
+    return cuda_single_inter_block_reduce_scan2<DoScan, FunctorType, ArgTag>(
+        functor, block_id, block_count, shared_data, global_data, global_flags);
 }
 
 // Size in bytes required for inter block reduce or scan
-template< bool DoScan , class FunctorType , class ArgTag >
-inline
-unsigned cuda_single_inter_block_reduce_scan_shmem( const FunctorType & functor , const unsigned BlockSize )
-{
-  return ( BlockSize + 2 ) * Impl::FunctorValueTraits< FunctorType , ArgTag >::value_size( functor );
+template <bool DoScan, class FunctorType, class ArgTag>
+inline unsigned cuda_single_inter_block_reduce_scan_shmem(
+    const FunctorType& functor, const unsigned BlockSize) {
+  return (BlockSize + 2) *
+         Impl::FunctorValueTraits<FunctorType, ArgTag>::value_size(functor);
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( __CUDACC__ ) */
 #endif /* KOKKOS_CUDA_REDUCESCAN_HPP */
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.cpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.cpp
index ac36cfd67e3e74cd99db374e2c3ef50463b44bde..777f57ced45b246af52cea73e796fbeae01cb57c 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.cpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_CUDA ) && defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core.hpp>
 
@@ -54,13 +55,18 @@
 namespace Kokkos {
 namespace Impl {
 
-template class TaskQueue< Kokkos::Cuda, Impl::default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda> > ;
-template class TaskQueueMultiple< Kokkos::Cuda, Impl::default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda> > ;
+template class TaskQueue<
+    Kokkos::Cuda,
+    Impl::default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda> >;
+template class TaskQueueMultiple<
+    Kokkos::Cuda,
+    Impl::default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda> >;
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 #else
 void KOKKOS_CORE_SRC_CUDA_KOKKOS_CUDA_TASK_PREVENT_LINK_ERROR() {}
-#endif /* #if defined( KOKKOS_ENABLE_CUDA ) && defined( KOKKOS_ENABLE_TASKDAG ) */
-
+#endif /* #if defined( KOKKOS_ENABLE_CUDA ) && defined( KOKKOS_ENABLE_TASKDAG \
+          ) */
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.hpp
index c35987e49ed6ec209652617dcffb63650b21cde6..237d2430d6cd6820aab0bb8773d6baf44a61e681 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Task.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_IMPL_CUDA_TASK_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -53,7 +54,7 @@
 #include <Kokkos_Core_fwd.hpp>
 
 #include <impl/Kokkos_TaskBase.hpp>
-#include <Cuda/Kokkos_Cuda_Error.hpp> // CUDA_SAFE_CALL
+#include <Cuda/Kokkos_Cuda_Error.hpp>  // CUDA_SAFE_CALL
 #include <impl/Kokkos_TaskTeamMember.hpp>
 
 //----------------------------------------------------------------------------
@@ -62,65 +63,57 @@ namespace Kokkos {
 namespace Impl {
 namespace {
 
-template< typename TaskType >
-__global__
-void set_cuda_task_base_apply_function_pointer
-  ( typename TaskType::function_type * ptr, typename TaskType::destroy_type* dtor )
-{ 
-  *ptr = TaskType::apply;
+template <typename TaskType>
+__global__ void set_cuda_task_base_apply_function_pointer(
+    typename TaskType::function_type* ptr,
+    typename TaskType::destroy_type* dtor) {
+  *ptr  = TaskType::apply;
   *dtor = TaskType::destroy;
 }
 
-template< typename Scheduler >
-__global__
-void cuda_task_queue_execute( Scheduler scheduler, int32_t shmem_size ) {
-  TaskQueueSpecialization< Scheduler >::driver( std::move(scheduler) , shmem_size );
+template <typename Scheduler>
+__global__ void cuda_task_queue_execute(Scheduler scheduler,
+                                        int32_t shmem_size) {
+  TaskQueueSpecialization<Scheduler>::driver(std::move(scheduler), shmem_size);
 }
 
-}
-
-template <class, class> class TaskExec ;
+}  // namespace
 
-template<class QueueType>
-class TaskQueueSpecialization<
-  SimpleTaskScheduler<Kokkos::Cuda, QueueType>
->
-{
-public:
+template <class, class>
+class TaskExec;
 
-  using scheduler_type = SimpleTaskScheduler<Kokkos::Cuda, QueueType>;
+template <class QueueType>
+class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::Cuda, QueueType>> {
+ public:
+  using scheduler_type  = SimpleTaskScheduler<Kokkos::Cuda, QueueType>;
   using execution_space = Kokkos::Cuda;
-  using memory_space = Kokkos::CudaUVMSpace;
-  using member_type = TaskExec<Kokkos::Cuda, scheduler_type> ;
+  using memory_space    = Kokkos::CudaUVMSpace;
+  using member_type     = TaskExec<Kokkos::Cuda, scheduler_type>;
 
   enum : long { max_league_size = 16 };
   enum : int { warps_per_block = 4 };
 
   KOKKOS_INLINE_FUNCTION
-  static
-  void iff_single_thread_recursive_execute( scheduler_type const& ) {}
+  static void iff_single_thread_recursive_execute(scheduler_type const&) {}
 
-  static int get_max_team_count(
-    execution_space const&
-  ) {
+  static int get_max_team_count(execution_space const&) {
     return Kokkos::Impl::cuda_internal_multiprocessor_count() * warps_per_block;
   }
 
-  __device__
-  static void driver(scheduler_type scheduler, int32_t shmem_per_warp)
-  {
-    using queue_type = typename scheduler_type::task_queue_type;
+  __device__ static void driver(scheduler_type scheduler,
+                                int32_t shmem_per_warp) {
+    using queue_type     = typename scheduler_type::task_queue_type;
     using task_base_type = typename scheduler_type::task_base_type;
-    using runnable_task_base_type = typename scheduler_type::runnable_task_base_type;
-    using scheduling_info_storage_type =
-      SchedulingInfoStorage<
+    using runnable_task_base_type =
+        typename scheduler_type::runnable_task_base_type;
+    using scheduling_info_storage_type = SchedulingInfoStorage<
         runnable_task_base_type,
-        typename scheduler_type::task_scheduling_info_type
-      >;
+        typename scheduler_type::task_scheduling_info_type>;
 
     extern __shared__ int32_t shmem_all[];
 
-    int32_t* const warp_shmem = shmem_all + (threadIdx.z * shmem_per_warp) / sizeof(int32_t);
+    int32_t* const warp_shmem =
+        shmem_all + (threadIdx.z * shmem_per_warp) / sizeof(int32_t);
 
     task_base_type* const shared_memory_task_copy = (task_base_type*)warp_shmem;
 
@@ -129,44 +122,47 @@ public:
     member_type single_exec(scheduler, warp_shmem, 1);
     member_type team_exec(scheduler, warp_shmem, blockDim.y);
 
-    auto& queue = scheduler.queue();
+    auto& queue          = scheduler.queue();
     auto& team_scheduler = team_exec.scheduler();
 
     auto current_task = OptionalRef<task_base_type>();
 
     // Loop until all queues are empty and no tasks in flight
-    while(not queue.is_done()) {
-
-      if(warp_lane == 0) {  // should be (?) same as team_exec.team_rank() == 0
+    while (not queue.is_done()) {
+      if (warp_lane == 0) {  // should be (?) same as team_exec.team_rank() == 0
         // pop off a task
-        current_task = queue.pop_ready_task(team_scheduler.team_scheduler_info());
+        current_task =
+            queue.pop_ready_task(team_scheduler.team_scheduler_info());
       }
 
       // Broadcast task pointer:
 
       // Sync before the broadcast
       KOKKOS_IMPL_CUDA_SYNCWARP;
-      
-      // pretend it's an int* for shuffle purposes
-      ((int*) &current_task)[0] = KOKKOS_IMPL_CUDA_SHFL(((int*) &current_task)[0], 0, 32);
-      ((int*) &current_task)[1] = KOKKOS_IMPL_CUDA_SHFL(((int*) &current_task)[1], 0, 32);
 
-      if(current_task) {
+      // pretend it's an int* for shuffle purposes
+      ((int*)&current_task)[0] =
+          KOKKOS_IMPL_CUDA_SHFL(((int*)&current_task)[0], 0, 32);
+      ((int*)&current_task)[1] =
+          KOKKOS_IMPL_CUDA_SHFL(((int*)&current_task)[1], 0, 32);
 
+      if (current_task) {
         KOKKOS_ASSERT(!current_task->as_runnable_task().get_respawn_flag());
 
         int32_t b = sizeof(scheduling_info_storage_type) / sizeof(int32_t);
         static_assert(
-          sizeof(scheduling_info_storage_type) % sizeof(int32_t) == 0,
-          "bad task size"
-        );
+            sizeof(scheduling_info_storage_type) % sizeof(int32_t) == 0,
+            "bad task size");
         int32_t const e = current_task->get_allocation_size() / sizeof(int32_t);
-        KOKKOS_ASSERT(current_task->get_allocation_size() % sizeof(int32_t) == 0);
+        KOKKOS_ASSERT(current_task->get_allocation_size() % sizeof(int32_t) ==
+                      0);
 
-        int32_t volatile* const task_mem = (int32_t volatile*)current_task.get();
+        int32_t volatile* const task_mem =
+            (int32_t volatile*)current_task.get();
 
-        // do a coordinated copy of the task closure from global to shared memory:
-        for(int32_t i = warp_lane; i < e; i += CudaTraits::WarpSize) {
+        // do a coordinated copy of the task closure from global to shared
+        // memory:
+        for (int32_t i = warp_lane; i < e; i += CudaTraits::WarpSize) {
           warp_shmem[i] = task_mem[i];
         }
 
@@ -174,13 +170,12 @@ public:
         // writes are visible to all threads in the warp.
         KOKKOS_IMPL_CUDA_SYNCWARP;
 
-        if(shared_memory_task_copy->is_team_runnable()) {
+        if (shared_memory_task_copy->is_team_runnable()) {
           // Thread Team Task
           shared_memory_task_copy->as_runnable_task().run(team_exec);
-        }
-        else if(threadIdx.y == 0) {
-          // TODO @tasking @optimization DSH Change this to warp_lane == 0 when we allow blockDim.x to be more than 1
-          // Single Thread Task
+        } else if (threadIdx.y == 0) {
+          // TODO @tasking @optimization DSH Change this to warp_lane == 0 when
+          // we allow blockDim.x to be more than 1 Single Thread Task
           shared_memory_task_copy->as_runnable_task().run(single_exec);
         }
 
@@ -189,8 +184,8 @@ public:
 
         KOKKOS_IMPL_CUDA_SYNCWARP;
 
-        //if(warp_lane < b % CudaTraits::WarpSize) b += CudaTraits::WarpSize;
-        //b -= b % CudaTraits::WarpSize;
+        // if(warp_lane < b % CudaTraits::WarpSize) b += CudaTraits::WarpSize;
+        // b -= b % CudaTraits::WarpSize;
 
         // copy task closure from shared to global memory:
         for (int32_t i = b + warp_lane; i < e; i += CudaTraits::WarpSize) {
@@ -203,17 +198,15 @@ public:
 
         KOKKOS_IMPL_CUDA_SYNCWARP;
 
-
         if (warp_lane == 0) {
           // If respawn requested copy respawn data back to main memory
-          if(shared_memory_task_copy->as_runnable_task().get_respawn_flag()) {
-            if(shared_memory_task_copy->as_runnable_task().has_predecessor()) {
+          if (shared_memory_task_copy->as_runnable_task().get_respawn_flag()) {
+            if (shared_memory_task_copy->as_runnable_task().has_predecessor()) {
               // It's not necessary to make this a volatile write because
               // the next read of the predecessor is on this thread in complete,
               // and the predecessor is cleared there (using a volatile write)
               current_task->as_runnable_task().acquire_predecessor_from(
-                shared_memory_task_copy->as_runnable_task()
-              );
+                  shared_memory_task_copy->as_runnable_task());
             }
 
             // It may not necessary to make this a volatile write, since the
@@ -224,39 +217,35 @@ public:
             // where else the priority would be read after it is scheduled
             // by this thread; for now, we leave it volatile, but we should
             // benchmark the cost of this.)
-            current_task.as_volatile()->set_priority(shared_memory_task_copy->get_priority());
+            current_task.as_volatile()->set_priority(
+                shared_memory_task_copy->get_priority());
 
             // It's not necessary to make this a volatile write, since the
             // next read of it (if true) will be by this thread in `complete()`,
             // which will unset the flag (using volatile) once it has handled
             // the respawn
             current_task->as_runnable_task().set_respawn_flag();
-
           }
 
-          queue.complete(
-            (*std::move(current_task)).as_runnable_task(),
-            team_scheduler.team_scheduler_info()
-          );
+          queue.complete((*std::move(current_task)).as_runnable_task(),
+                         team_scheduler.team_scheduler_info());
         }
-
       }
     }
   }
 
-  static
-  void execute(scheduler_type const& scheduler)
-  {
-    const int shared_per_warp = 2048 ;
+  static void execute(scheduler_type const& scheduler) {
+    const int shared_per_warp = 2048;
     const dim3 grid(Kokkos::Impl::cuda_internal_multiprocessor_count(), 1, 1);
     const dim3 block(1, Kokkos::Impl::CudaTraits::WarpSize, warps_per_block);
-    const int shared_total = shared_per_warp * warps_per_block;
+    const int shared_total    = shared_per_warp * warps_per_block;
     const cudaStream_t stream = nullptr;
 
     KOKKOS_ASSERT(
-      static_cast<long>(grid.x * grid.y * grid.z * block.x * block.y * block.z)
-        == static_cast<long>(get_max_team_count(scheduler.get_execution_space()) * Kokkos::Impl::CudaTraits::WarpSize)
-    );
+        static_cast<long>(grid.x * grid.y * grid.z * block.x * block.y *
+                          block.z) ==
+        static_cast<long>(get_max_team_count(scheduler.get_execution_space()) *
+                          Kokkos::Impl::CudaTraits::WarpSize));
 
     auto& queue = scheduler.queue();
 
@@ -265,7 +254,8 @@ public:
     // Query the stack size, in bytes:
 
     size_t previous_stack_size = 0;
-    CUDA_SAFE_CALL(cudaDeviceGetLimit(&previous_stack_size, cudaLimitStackSize));
+    CUDA_SAFE_CALL(
+        cudaDeviceGetLimit(&previous_stack_size, cudaLimitStackSize));
 
     // If not large enough then set the stack size, in bytes:
 
@@ -275,45 +265,45 @@ public:
       CUDA_SAFE_CALL(cudaDeviceSetLimit(cudaLimitStackSize, larger_stack_size));
     }
 
-    cuda_task_queue_execute<<<grid, block, shared_total, stream>>>(scheduler, shared_per_warp);
+    cuda_task_queue_execute<<<grid, block, shared_total, stream>>>(
+        scheduler, shared_per_warp);
 
     CUDA_SAFE_CALL(cudaGetLastError());
 
     CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
     if (previous_stack_size < larger_stack_size) {
-      CUDA_SAFE_CALL(cudaDeviceSetLimit(cudaLimitStackSize, previous_stack_size));
+      CUDA_SAFE_CALL(
+          cudaDeviceSetLimit(cudaLimitStackSize, previous_stack_size));
     }
   }
 
   template <typename TaskType>
   static
-  // TODO @tasking @optimiazation DSH specialize this for trivially destructible types
-  void
-  get_function_pointer(
-    typename TaskType::function_type& ptr,
-    typename TaskType::destroy_type& dtor
-  )
-  {
+      // TODO @tasking @optimiazation DSH specialize this for trivially
+      // destructible types
+      void
+      get_function_pointer(typename TaskType::function_type& ptr,
+                           typename TaskType::destroy_type& dtor) {
     using function_type = typename TaskType::function_type;
-    using destroy_type = typename TaskType::destroy_type;
+    using destroy_type  = typename TaskType::destroy_type;
 
     // TODO @tasking @minor DSH make sure there aren't any alignment concerns?
-    void* storage = cuda_internal_scratch_unified( 
-      Kokkos::Cuda(),
-      sizeof(function_type) + sizeof(destroy_type)
-    );
+    void* storage = cuda_internal_scratch_unified(
+        Kokkos::Cuda(), sizeof(function_type) + sizeof(destroy_type));
     function_type* ptr_ptr = (function_type*)storage;
-    destroy_type* dtor_ptr = (destroy_type*)((char*)storage + sizeof(function_type));
+    destroy_type* dtor_ptr =
+        (destroy_type*)((char*)storage + sizeof(function_type));
 
-    CUDA_SAFE_CALL( cudaDeviceSynchronize() );
+    CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
-    set_cuda_task_base_apply_function_pointer<TaskType><<<1,1>>>(ptr_ptr, dtor_ptr);
+    set_cuda_task_base_apply_function_pointer<TaskType>
+        <<<1, 1>>>(ptr_ptr, dtor_ptr);
 
-    CUDA_SAFE_CALL( cudaGetLastError() );
-    CUDA_SAFE_CALL( cudaDeviceSynchronize() );
+    CUDA_SAFE_CALL(cudaGetLastError());
+    CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
-    ptr = *ptr_ptr;
+    ptr  = *ptr_ptr;
     dtor = *dtor_ptr;
   }
 };
@@ -321,144 +311,133 @@ public:
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template<class Scheduler>
+template <class Scheduler>
 class TaskQueueSpecializationConstrained<
-  Scheduler,
-  typename std::enable_if<
-    std::is_same<typename Scheduler::execution_space, Kokkos::Cuda>::value
-  >::type
->
-{
-public:
-
-  using scheduler_type = Scheduler;
+    Scheduler,
+    typename std::enable_if<std::is_same<typename Scheduler::execution_space,
+                                         Kokkos::Cuda>::value>::type> {
+ public:
+  using scheduler_type  = Scheduler;
   using execution_space = Kokkos::Cuda;
-  using memory_space = Kokkos::CudaUVMSpace;
-  using member_type = TaskExec<Kokkos::Cuda, Scheduler> ;
+  using memory_space    = Kokkos::CudaUVMSpace;
+  using member_type     = TaskExec<Kokkos::Cuda, Scheduler>;
 
   enum : long { max_league_size = 16 };
 
   KOKKOS_INLINE_FUNCTION
-  static
-  void iff_single_thread_recursive_execute( scheduler_type const& ) {}
+  static void iff_single_thread_recursive_execute(scheduler_type const&) {}
 
-  __device__
-  static void driver(scheduler_type scheduler, int32_t shmem_per_warp)
-  {
-    using queue_type = typename scheduler_type::queue_type;
+  __device__ static void driver(scheduler_type scheduler,
+                                int32_t shmem_per_warp) {
+    using queue_type     = typename scheduler_type::queue_type;
     using task_root_type = TaskBase;
 
     extern __shared__ int32_t shmem_all[];
 
-    task_root_type* const end = (task_root_type *) task_root_type::EndTag ;
+    task_root_type* const end = (task_root_type*)task_root_type::EndTag;
     task_root_type* const no_more_tasks_sentinel = nullptr;
 
-    int32_t * const warp_shmem =
-      shmem_all + ( threadIdx.z * shmem_per_warp ) / sizeof(int32_t);
+    int32_t* const warp_shmem =
+        shmem_all + (threadIdx.z * shmem_per_warp) / sizeof(int32_t);
 
-    task_root_type * const task_shmem = (task_root_type *) warp_shmem ;
+    task_root_type* const task_shmem = (task_root_type*)warp_shmem;
 
-    const int warp_lane = threadIdx.x + threadIdx.y * blockDim.x ;
+    const int warp_lane = threadIdx.x + threadIdx.y * blockDim.x;
 
     member_type single_exec(scheduler, warp_shmem, 1);
     member_type team_exec(scheduler, warp_shmem, blockDim.y);
 
     auto& team_queue = team_exec.scheduler().queue();
 
-    task_root_type * task_ptr = no_more_tasks_sentinel;
+    task_root_type* task_ptr = no_more_tasks_sentinel;
 
     // Loop until all queues are empty and no tasks in flight
 
     do {
-
       // Each team lead attempts to acquire either a thread team task
       // or collection of single thread tasks for the team.
 
-      if ( 0 == warp_lane ) {
-
-        if( *((volatile int *) & team_queue.m_ready_count) > 0 ) {
+      if (0 == warp_lane) {
+        if (*((volatile int*)&team_queue.m_ready_count) > 0) {
           task_ptr = end;
           // Attempt to acquire a task
           // Loop by priority and then type
-          for ( int i = 0 ; i < queue_type::NumQueue && end == task_ptr ; ++i ) {
-            for ( int j = 0 ; j < 2 && end == task_ptr ; ++j ) {
-              task_ptr = queue_type::pop_ready_task( & team_queue.m_ready[i][j] );
+          for (int i = 0; i < queue_type::NumQueue && end == task_ptr; ++i) {
+            for (int j = 0; j < 2 && end == task_ptr; ++j) {
+              task_ptr = queue_type::pop_ready_task(&team_queue.m_ready[i][j]);
             }
           }
-        }
-        else {
+        } else {
           // returns nullptr if and only if all other queues have a ready
           // count of 0 also. Otherwise, returns a task from another queue
           // or `end` if one couldn't be popped
           task_ptr = team_queue.attempt_to_steal_task();
-          #if 0
+#if 0
           if(task != no_more_tasks_sentinel && task != end) {
             std::printf("task stolen on rank %d\n", team_exec.league_rank());
           }
-          #endif
+#endif
         }
-
       }
 
       // Synchronize warp with memory fence before broadcasting task pointer:
 
       // KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( "A" );
-      KOKKOS_IMPL_CUDA_SYNCWARP ;
+      KOKKOS_IMPL_CUDA_SYNCWARP;
 
       // Broadcast task pointer:
 
-      ((int*) & task_ptr )[0] = KOKKOS_IMPL_CUDA_SHFL( ((int*) & task_ptr )[0] , 0 , 32 );
-      ((int*) & task_ptr )[1] = KOKKOS_IMPL_CUDA_SHFL( ((int*) & task_ptr )[1] , 0 , 32 );
-
-      #if defined( KOKKOS_DEBUG )
-      KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( "TaskQueue CUDA task_ptr" );
-      #endif
+      ((int*)&task_ptr)[0] = KOKKOS_IMPL_CUDA_SHFL(((int*)&task_ptr)[0], 0, 32);
+      ((int*)&task_ptr)[1] = KOKKOS_IMPL_CUDA_SHFL(((int*)&task_ptr)[1], 0, 32);
 
-      if ( 0 == task_ptr ) break ; // 0 == queue->m_ready_count
+#if defined(KOKKOS_DEBUG)
+      KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN("TaskQueue CUDA task_ptr");
+#endif
 
-      if ( end != task_ptr ) {
+      if (0 == task_ptr) break;  // 0 == queue->m_ready_count
 
+      if (end != task_ptr) {
         // Whole warp copy task's closure to/from shared memory.
         // Use all threads of warp for coalesced read/write.
 
         int32_t const b = sizeof(task_root_type) / sizeof(int32_t);
-        int32_t const e = *((int32_t volatile *)( & task_ptr->m_alloc_size )) / sizeof(int32_t);
+        int32_t const e =
+            *((int32_t volatile*)(&task_ptr->m_alloc_size)) / sizeof(int32_t);
 
-        int32_t volatile * const task_mem = (int32_t volatile *) task_ptr ;
+        int32_t volatile* const task_mem = (int32_t volatile*)task_ptr;
 
         KOKKOS_ASSERT(e * sizeof(int32_t) < shmem_per_warp);
 
         // copy task closure from global to shared memory:
 
-        for ( int32_t i = warp_lane ; i < e ; i += CudaTraits::WarpSize ) {
-          warp_shmem[i] = task_mem[i] ;
+        for (int32_t i = warp_lane; i < e; i += CudaTraits::WarpSize) {
+          warp_shmem[i] = task_mem[i];
         }
 
         // Synchronize threads of the warp and insure memory
         // writes are visible to all threads in the warp.
 
         // KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( "B" );
-        KOKKOS_IMPL_CUDA_SYNCWARP ;
+        KOKKOS_IMPL_CUDA_SYNCWARP;
 
-        if ( task_root_type::TaskTeam == task_shmem->m_task_type ) {
+        if (task_root_type::TaskTeam == task_shmem->m_task_type) {
           // Thread Team Task
-          (*task_shmem->m_apply)( task_shmem , & team_exec );
-        }
-        else if ( 0 == threadIdx.y ) {
+          (*task_shmem->m_apply)(task_shmem, &team_exec);
+        } else if (0 == threadIdx.y) {
           // Single Thread Task
-          (*task_shmem->m_apply)( task_shmem , & single_exec );
+          (*task_shmem->m_apply)(task_shmem, &single_exec);
         }
 
         // Synchronize threads of the warp and insure memory
         // writes are visible to all threads in the warp.
 
         // KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( "C" );
-        KOKKOS_IMPL_CUDA_SYNCWARP ;
+        KOKKOS_IMPL_CUDA_SYNCWARP;
 
         // copy task closure from shared to global memory:
 
-        for ( int32_t i = b + warp_lane ; i < e ; i += CudaTraits::WarpSize ) {
-          task_mem[i] = warp_shmem[i] ;
+        for (int32_t i = b + warp_lane; i < e; i += CudaTraits::WarpSize) {
+          task_mem[i] = warp_shmem[i];
         }
 
         // Synchronize threads of the warp and insure memory
@@ -466,99 +445,96 @@ public:
         // respawn or completion.
 
         // KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( "D" );
-        KOKKOS_IMPL_CUDA_SYNCWARP ;
+        KOKKOS_IMPL_CUDA_SYNCWARP;
 
         // If respawn requested copy respawn data back to main memory
 
-        if ( 0 == warp_lane ) {
-
-          if ( ((task_root_type *) task_root_type::LockTag) != task_shmem->m_next ) {
-            ( (volatile task_root_type *) task_ptr )->m_next = task_shmem->m_next ;
-            ( (volatile task_root_type *) task_ptr )->m_priority = task_shmem->m_priority ;
+        if (0 == warp_lane) {
+          if (((task_root_type*)task_root_type::LockTag) !=
+              task_shmem->m_next) {
+            ((volatile task_root_type*)task_ptr)->m_next = task_shmem->m_next;
+            ((volatile task_root_type*)task_ptr)->m_priority =
+                task_shmem->m_priority;
           }
 
-          team_queue.complete( task_ptr );
+          team_queue.complete(task_ptr);
         }
-
       }
-    } while(1);
+    } while (1);
   }
 
-  static
-  void execute(scheduler_type const& scheduler)
-  {
-    const int shared_per_warp = 2048 ;
-    const int warps_per_block = 4 ;
-    const dim3 grid( Kokkos::Impl::cuda_internal_multiprocessor_count() , 1 , 1 );
-    //const dim3 grid( 1 , 1 , 1 );
-    const dim3 block( 1 , Kokkos::Impl::CudaTraits::WarpSize , warps_per_block );
-    const int shared_total = shared_per_warp * warps_per_block ;
-    const cudaStream_t stream = 0 ;
+  static void execute(scheduler_type const& scheduler) {
+    const int shared_per_warp = 2048;
+    const int warps_per_block = 4;
+    const dim3 grid(Kokkos::Impl::cuda_internal_multiprocessor_count(), 1, 1);
+    // const dim3 grid( 1 , 1 , 1 );
+    const dim3 block(1, Kokkos::Impl::CudaTraits::WarpSize, warps_per_block);
+    const int shared_total    = shared_per_warp * warps_per_block;
+    const cudaStream_t stream = 0;
 
     auto& queue = scheduler.queue();
     queue.initialize_team_queues(warps_per_block * grid.x);
 
-    CUDA_SAFE_CALL( cudaDeviceSynchronize() );
+    CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
     // Query the stack size, in bytes:
 
-    size_t previous_stack_size = 0 ;
-    CUDA_SAFE_CALL( cudaDeviceGetLimit( & previous_stack_size , cudaLimitStackSize ) );
+    size_t previous_stack_size = 0;
+    CUDA_SAFE_CALL(
+        cudaDeviceGetLimit(&previous_stack_size, cudaLimitStackSize));
 
     // If not large enough then set the stack size, in bytes:
 
-    const size_t larger_stack_size = 2048 ;
+    const size_t larger_stack_size = 2048;
 
-    if ( previous_stack_size < larger_stack_size ) {
-      CUDA_SAFE_CALL( cudaDeviceSetLimit( cudaLimitStackSize , larger_stack_size ) );
+    if (previous_stack_size < larger_stack_size) {
+      CUDA_SAFE_CALL(cudaDeviceSetLimit(cudaLimitStackSize, larger_stack_size));
     }
 
-    cuda_task_queue_execute<<< grid , block , shared_total , stream >>>( scheduler , shared_per_warp );
+    cuda_task_queue_execute<<<grid, block, shared_total, stream>>>(
+        scheduler, shared_per_warp);
 
-    CUDA_SAFE_CALL( cudaGetLastError() );
+    CUDA_SAFE_CALL(cudaGetLastError());
 
-    CUDA_SAFE_CALL( cudaDeviceSynchronize() );
+    CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
-    if ( previous_stack_size < larger_stack_size ) {
-      CUDA_SAFE_CALL( cudaDeviceSetLimit( cudaLimitStackSize , previous_stack_size ) );
+    if (previous_stack_size < larger_stack_size) {
+      CUDA_SAFE_CALL(
+          cudaDeviceSetLimit(cudaLimitStackSize, previous_stack_size));
     }
-
   }
 
-  template< typename TaskType >
-  static
-  void
-  get_function_pointer(
-    typename TaskType::function_type& ptr,
-    typename TaskType::destroy_type& dtor
-  )
-    {
-      using function_type = typename TaskType::function_type;
-      using destroy_type = typename TaskType::destroy_type;
-
-      void* storage = cuda_internal_scratch_unified(
-        Kokkos::Cuda(),
-        sizeof(function_type) + sizeof(destroy_type)
-      );
-      function_type* ptr_ptr = (function_type*)storage;
-      destroy_type* dtor_ptr = (destroy_type*)((char*)storage + sizeof(function_type));
+  template <typename TaskType>
+  static void get_function_pointer(typename TaskType::function_type& ptr,
+                                   typename TaskType::destroy_type& dtor) {
+    using function_type = typename TaskType::function_type;
+    using destroy_type  = typename TaskType::destroy_type;
 
-      CUDA_SAFE_CALL( cudaDeviceSynchronize() );
+    void* storage = cuda_internal_scratch_unified(
+        Kokkos::Cuda(), sizeof(function_type) + sizeof(destroy_type));
+    function_type* ptr_ptr = (function_type*)storage;
+    destroy_type* dtor_ptr =
+        (destroy_type*)((char*)storage + sizeof(function_type));
 
-      set_cuda_task_base_apply_function_pointer<TaskType><<<1,1>>>(ptr_ptr, dtor_ptr);
+    CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
-      CUDA_SAFE_CALL( cudaGetLastError() );
-      CUDA_SAFE_CALL( cudaDeviceSynchronize() );
+    set_cuda_task_base_apply_function_pointer<TaskType>
+        <<<1, 1>>>(ptr_ptr, dtor_ptr);
 
-      ptr = *ptr_ptr;
-      dtor = *dtor_ptr;
+    CUDA_SAFE_CALL(cudaGetLastError());
+    CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
-    }
+    ptr  = *ptr_ptr;
+    dtor = *dtor_ptr;
+  }
 };
 
-extern template class TaskQueue< Kokkos::Cuda, default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda> > ;
+extern template class TaskQueue<
+    Kokkos::Cuda,
+    default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda>>;
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -589,85 +565,82 @@ namespace Impl {
  *  warp synchronizing functions must not be called.
  */
 template <class Scheduler>
-class TaskExec<Kokkos::Cuda, Scheduler>
-{
-private:
-
+class TaskExec<Kokkos::Cuda, Scheduler> {
+ private:
   enum : int { WarpSize = Kokkos::Impl::CudaTraits::WarpSize };
 
-  TaskExec( TaskExec && ) = delete ;
-  TaskExec( TaskExec const & ) = delete ;
-  TaskExec & operator = ( TaskExec && ) = delete ;
-  TaskExec & operator = ( TaskExec const & ) = delete ;
+  TaskExec(TaskExec&&)      = delete;
+  TaskExec(TaskExec const&) = delete;
+  TaskExec& operator=(TaskExec&&) = delete;
+  TaskExec& operator=(TaskExec const&) = delete;
 
-  friend class Kokkos::Impl::TaskQueue< Kokkos::Cuda, default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda> > ;
+  friend class Kokkos::Impl::TaskQueue<
+      Kokkos::Cuda,
+      default_tasking_memory_space_for_execution_space_t<Kokkos::Cuda>>;
   template <class, class>
   friend class Kokkos::Impl::TaskQueueSpecializationConstrained;
   template <class>
   friend class Kokkos::Impl::TaskQueueSpecialization;
 
-  int32_t * m_team_shmem ;
-  const int m_team_size ;
+  int32_t* m_team_shmem;
+  const int m_team_size;
   Scheduler m_scheduler;
 
   // If constructed with arg_team_size == 1 the object
   // can only be used by 0 == threadIdx.y.
   KOKKOS_INLINE_FUNCTION
-  TaskExec(
-    Scheduler const& parent_scheduler,
-    int32_t* arg_team_shmem,
-    int arg_team_size = blockDim.y
-  )
-    : m_team_shmem(arg_team_shmem),
-      m_team_size(arg_team_size),
-      m_scheduler(parent_scheduler.get_team_scheduler(league_rank()))
-  { }
-
-public:
+  TaskExec(Scheduler const& parent_scheduler, int32_t* arg_team_shmem,
+           int arg_team_size = blockDim.y)
+      : m_team_shmem(arg_team_shmem),
+        m_team_size(arg_team_size),
+        m_scheduler(parent_scheduler.get_team_scheduler(league_rank())) {}
 
+ public:
   using thread_team_member = TaskExec;
 
-#if defined( __CUDA_ARCH__ )
-  __device__ int team_rank() const { return threadIdx.y ; }
-  __device__ int team_size() const { return m_team_size ; }
+#if defined(__CUDA_ARCH__)
+  __device__ int team_rank() const { return threadIdx.y; }
+  __device__ int team_size() const { return m_team_size; }
   //__device__ int league_rank() const { return threadIdx.z; }
-  __device__ int league_rank() const { return blockIdx.x * blockDim.z + threadIdx.z; }
+  __device__ int league_rank() const {
+    return blockIdx.x * blockDim.z + threadIdx.z;
+  }
   __device__ int league_size() const { return blockDim.z * gridDim.x; }
 
-  __device__ void team_barrier() const
-    {
-      if ( 1 < m_team_size ) {
-        KOKKOS_IMPL_CUDA_SYNCWARP ;
-      }
+  __device__ void team_barrier() const {
+    if (1 < m_team_size) {
+      KOKKOS_IMPL_CUDA_SYNCWARP;
     }
+  }
 
-  template< class ValueType >
-  __device__ void team_broadcast( ValueType & val , const int thread_id ) const
-    {
-      if ( 1 < m_team_size ) {
-        // WarpSize = blockDim.X * blockDim.y
-        // thread_id < blockDim.y
-        ValueType tmp( val ); // input might not be register variable
-        cuda_shfl( val, tmp, blockDim.x * thread_id, WarpSize );
-      }
+  template <class ValueType>
+  __device__ void team_broadcast(ValueType& val, const int thread_id) const {
+    if (1 < m_team_size) {
+      // WarpSize = blockDim.X * blockDim.y
+      // thread_id < blockDim.y
+      ValueType tmp(val);  // input might not be register variable
+      Impl::in_place_shfl(val, tmp, blockDim.x * thread_id, WarpSize);
     }
+  }
 
 #else
-  __host__ int team_rank() const { return 0 ; }
-  __host__ int team_size() const { return 0 ; }
+  __host__ int team_rank() const { return 0; }
+  __host__ int team_size() const { return 0; }
   __host__ int league_rank() const { return 0; }
   __host__ int league_size() const { return 0; }
   __host__ void team_barrier() const {}
-  template< class ValueType >
-  __host__ void team_broadcast( ValueType & , const int ) const {}
+  template <class ValueType>
+  __host__ void team_broadcast(ValueType&, const int) const {}
 #endif
 
-  KOKKOS_INLINE_FUNCTION Scheduler const& scheduler() const noexcept { return m_scheduler; }
+  KOKKOS_INLINE_FUNCTION Scheduler const& scheduler() const noexcept {
+    return m_scheduler;
+  }
   KOKKOS_INLINE_FUNCTION Scheduler& scheduler() noexcept { return m_scheduler; }
-
 };
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -675,144 +648,137 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template<typename iType, typename Scheduler>
-struct TeamThreadRangeBoundariesStruct<iType, TaskExec<Kokkos::Cuda, Scheduler>>
-{
-  using index_type = iType;
+template <typename iType, typename Scheduler>
+struct TeamThreadRangeBoundariesStruct<iType,
+                                       TaskExec<Kokkos::Cuda, Scheduler>> {
+  using index_type  = iType;
   using member_type = TaskExec<Kokkos::Cuda, Scheduler>;
 
-  const iType start ;
-  const iType end ;
-  const iType increment ;
+  const iType start;
+  const iType end;
+  const iType increment;
   member_type const& thread;
 
-#if defined( __CUDA_ARCH__ )
-
-  __device__ inline
-  TeamThreadRangeBoundariesStruct
-    ( member_type const& arg_thread, const iType& arg_count)
-    : start( threadIdx.y )
-    , end(arg_count)
-    , increment( blockDim.y )
-    , thread(arg_thread)
-    {}
-
-  __device__ inline
-  TeamThreadRangeBoundariesStruct
-    ( member_type const& arg_thread
-    , const iType & arg_start
-    , const iType & arg_end
-    )
-    : start( arg_start + threadIdx.y )
-    , end(   arg_end)
-    , increment( blockDim.y )
-    , thread( arg_thread )
-    {}
+#if defined(__CUDA_ARCH__)
+
+  __device__ inline TeamThreadRangeBoundariesStruct(
+      member_type const& arg_thread, const iType& arg_count)
+      : start(threadIdx.y),
+        end(arg_count),
+        increment(blockDim.y),
+        thread(arg_thread) {}
+
+  __device__ inline TeamThreadRangeBoundariesStruct(
+      member_type const& arg_thread, const iType& arg_start,
+      const iType& arg_end)
+      : start(arg_start + threadIdx.y),
+        end(arg_end),
+        increment(blockDim.y),
+        thread(arg_thread) {}
 
 #else
 
-  TeamThreadRangeBoundariesStruct
-    ( member_type const& arg_thread, const iType& arg_count);
+  TeamThreadRangeBoundariesStruct(member_type const& arg_thread,
+                                  const iType& arg_count);
 
-  TeamThreadRangeBoundariesStruct
-    ( member_type const& arg_thread
-    , const iType & arg_start
-    , const iType & arg_end
-    );
+  TeamThreadRangeBoundariesStruct(member_type const& arg_thread,
+                                  const iType& arg_start, const iType& arg_end);
 
 #endif
-
 };
 
 //----------------------------------------------------------------------------
 
-template<typename iType, typename Scheduler>
-struct ThreadVectorRangeBoundariesStruct<iType, TaskExec< Kokkos::Cuda, Scheduler > >
-{
-  using index_type = iType;
+template <typename iType, typename Scheduler>
+struct ThreadVectorRangeBoundariesStruct<iType,
+                                         TaskExec<Kokkos::Cuda, Scheduler>> {
+  using index_type  = iType;
   using member_type = TaskExec<Kokkos::Cuda, Scheduler>;
 
-  const index_type start ;
-  const index_type end ;
-  const index_type increment ;
+  const index_type start;
+  const index_type end;
+  const index_type increment;
   const member_type& thread;
 
-#if defined( __CUDA_ARCH__ )
-
-  __device__ inline
-  ThreadVectorRangeBoundariesStruct
-    ( member_type const& arg_thread, const index_type& arg_count )
-    : start( threadIdx.x )
-    , end(arg_count)
-    , increment( blockDim.x )
-    , thread(arg_thread)
-    {}
-
-  __device__ inline
-  ThreadVectorRangeBoundariesStruct
-    ( member_type const& arg_thread, const index_type& arg_begin, const index_type& arg_end )
-    : start( arg_begin + threadIdx.x )
-    , end(arg_end)
-    , increment( blockDim.x )
-    , thread(arg_thread)
-    {}
+#if defined(__CUDA_ARCH__)
+
+  __device__ inline ThreadVectorRangeBoundariesStruct(
+      member_type const& arg_thread, const index_type& arg_count)
+      : start(threadIdx.x),
+        end(arg_count),
+        increment(blockDim.x),
+        thread(arg_thread) {}
+
+  __device__ inline ThreadVectorRangeBoundariesStruct(
+      member_type const& arg_thread, const index_type& arg_begin,
+      const index_type& arg_end)
+      : start(arg_begin + threadIdx.x),
+        end(arg_end),
+        increment(blockDim.x),
+        thread(arg_thread) {}
 
 #else
 
-  ThreadVectorRangeBoundariesStruct
-    ( member_type const& arg_thread, const index_type& arg_count );
+  ThreadVectorRangeBoundariesStruct(member_type const& arg_thread,
+                                    const index_type& arg_count);
 
-  ThreadVectorRangeBoundariesStruct
-    ( member_type const& arg_thread, const index_type& arg_begin, const index_type& arg_end);
+  ThreadVectorRangeBoundariesStruct(member_type const& arg_thread,
+                                    const index_type& arg_begin,
+                                    const index_type& arg_end);
 
 #endif
-
 };
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-//template<typename iType>
-//KOKKOS_INLINE_FUNCTION
-//Impl::TeamThreadRangeBoundariesStruct< iType, Impl::TaskExec< Kokkos::Cuda > >
-//TeamThreadRange( const Impl::TaskExec< Kokkos::Cuda > & thread, const iType & count )
+// template<typename iType>
+// KOKKOS_INLINE_FUNCTION
+// Impl::TeamThreadRangeBoundariesStruct< iType, Impl::TaskExec< Kokkos::Cuda >
+// > TeamThreadRange( const Impl::TaskExec< Kokkos::Cuda > & thread, const iType
+// & count )
 //{
-//  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::TaskExec< Kokkos::Cuda > >( thread, count );
+//  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::TaskExec<
+//  Kokkos::Cuda > >( thread, count );
 //}
 //
-//template<typename iType1, typename iType2>
-//KOKKOS_INLINE_FUNCTION
-//Impl::TeamThreadRangeBoundariesStruct
+// template<typename iType1, typename iType2>
+// KOKKOS_INLINE_FUNCTION
+// Impl::TeamThreadRangeBoundariesStruct
 //  < typename std::common_type<iType1,iType2>::type
 //  , Impl::TaskExec< Kokkos::Cuda > >
-//TeamThreadRange( const Impl::TaskExec< Kokkos::Cuda > & thread
+// TeamThreadRange( const Impl::TaskExec< Kokkos::Cuda > & thread
 //               , const iType1 & begin, const iType2 & end )
 //{
 //  typedef typename std::common_type< iType1, iType2 >::type iType;
-//  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::TaskExec< Kokkos::Cuda > >(
+//  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::TaskExec<
+//  Kokkos::Cuda > >(
 //           thread, iType(begin), iType(end) );
 //}
 //
-//template<typename iType>
-//KOKKOS_INLINE_FUNCTION
-//Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda > >
-//ThreadVectorRange( const Impl::TaskExec< Kokkos::Cuda > & thread
+// template<typename iType>
+// KOKKOS_INLINE_FUNCTION
+// Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda >
+// > ThreadVectorRange( const Impl::TaskExec< Kokkos::Cuda > & thread
 //                 , const iType & count )
 //{
-//  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda > >(thread,count);
+//  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec<
+//  Kokkos::Cuda > >(thread,count);
 //}
 //
-//template<typename iType>
-//KOKKOS_INLINE_FUNCTION
-//Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda > >
-//ThreadVectorRange( const Impl::TaskExec< Kokkos::Cuda > & thread
+// template<typename iType>
+// KOKKOS_INLINE_FUNCTION
+// Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda >
+// > ThreadVectorRange( const Impl::TaskExec< Kokkos::Cuda > & thread
 //                 , const iType & arg_begin
 //                 , const iType & arg_end )
 //{
-//  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda > >(thread,arg_begin,arg_end);
+//  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec<
+//  Kokkos::Cuda > >(thread,arg_begin,arg_end);
 //}
 
 // KOKKOS_INLINE_FUNCTION
@@ -829,78 +795,70 @@ namespace Kokkos {
 //   return Impl::VectorSingleStruct<Impl::TaskExec< Kokkos::Cuda > >(thread);
 // }
 
-/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all threads of the the calling thread team.
  * This functionality requires C++11 support.
-*/
-template<typename iType, class Lambda, class Scheduler>
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl:: TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries
-  , const Lambda& lambda
-  )
-{
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+ */
+template <typename iType, class Lambda, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i);
   }
 }
 
-template< typename iType, class Lambda, class Scheduler >
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries,
-   const Lambda & lambda) {
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+template <typename iType, class Lambda, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i);
   }
 }
 
 // reduce across corresponding lanes between team members within warp
 // assume stride*team_size == warp_size
-template< typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void strided_shfl_warp_reduction
-  (const JoinType& join,
-   ValueType& val,
-   int team_size,
-   int stride)
-{
-  for (int lane_delta=(team_size*stride)>>1; lane_delta>=stride; lane_delta>>=1) {
-    join(val, Kokkos::shfl_down(val, lane_delta, team_size*stride));
+template <typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void strided_shfl_warp_reduction(const JoinType& join,
+                                                        ValueType& val,
+                                                        int team_size,
+                                                        int stride) {
+  for (int lane_delta = (team_size * stride) >> 1; lane_delta >= stride;
+       lane_delta >>= 1) {
+    join(val, Kokkos::shfl_down(val, lane_delta, team_size * stride));
   }
 }
 
 // multiple within-warp non-strided reductions
-template< typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void multi_shfl_warp_reduction
-  (const JoinType& join,
-   ValueType& val,
-   int vec_length)
-{
-  for (int lane_delta=vec_length>>1; lane_delta; lane_delta>>=1) {
+template <typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void multi_shfl_warp_reduction(const JoinType& join,
+                                                      ValueType& val,
+                                                      int vec_length) {
+  for (int lane_delta = vec_length >> 1; lane_delta; lane_delta >>= 1) {
     join(val, Kokkos::shfl_down(val, lane_delta, vec_length));
   }
 }
 
 // broadcast within warp
-template< class ValueType >
-KOKKOS_INLINE_FUNCTION
-ValueType shfl_warp_broadcast
-  (ValueType& val,
-   int src_lane,
-   int width)
-{
-  if ( 1 < width ) {
+template <class ValueType>
+KOKKOS_INLINE_FUNCTION ValueType shfl_warp_broadcast(ValueType& val,
+                                                     int src_lane, int width) {
+  if (1 < width) {
     return Kokkos::shfl(val, src_lane, width);
-  }
-  else {
-    return val ;
+  } else {
+    return val;
   }
 }
 
-/*// all-reduce across corresponding vector lanes between team members within warp
+/*// all-reduce across corresponding vector lanes between team members within
+warp
 // assume vec_length*team_size == warp_size
 // blockDim.x == vec_length == stride
 // blockDim.y == team_size
@@ -909,14 +867,13 @@ ValueType shfl_warp_broadcast
 template< typename iType, class Lambda, typename ValueType, class JoinType >
 KOKKOS_INLINE_FUNCTION
 void parallel_reduce
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda > >& loop_boundaries,
-   const Lambda & lambda,
-   const JoinType& join,
+  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec<
+Kokkos::Cuda > >& loop_boundaries, const Lambda & lambda, const JoinType& join,
    ValueType& initialized_result) {
 
   ValueType result = initialized_result;
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for( iType i = loop_boundaries.start; i < loop_boundaries.end;
+i+=loop_boundaries.increment) { lambda(i,result);
   }
   initialized_result = result;
 
@@ -925,7 +882,8 @@ void parallel_reduce
                           initialized_result,
                           loop_boundaries.thread.team_size(),
                           blockDim.x);
-  initialized_result = shfl_warp_broadcast<ValueType>( initialized_result, threadIdx.x, Impl::CudaTraits::WarpSize );
+  initialized_result = shfl_warp_broadcast<ValueType>( initialized_result,
+threadIdx.x, Impl::CudaTraits::WarpSize );
 }*/
 
 // all-reduce across corresponding vector lanes between team members within warp
@@ -935,63 +893,55 @@ void parallel_reduce
 // blockDim.y == team_size
 // threadIdx.x == position in vec
 // threadIdx.y == member number
-template< typename iType, class Lambda, typename ValueType, class Scheduler >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries,
-   const Lambda & lambda,
-   ValueType& initialized_result) {
-
-  //TODO @internal_documentation what is the point of creating this temporary?
+template <typename iType, class Lambda, typename ValueType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Lambda& lambda, ValueType& initialized_result) {
+  // TODO @internal_documentation what is the point of creating this temporary?
   ValueType result = initialized_result;
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
   initialized_result = result;
 
-  if ( 1 < loop_boundaries.thread.team_size() ) {
-
+  if (1 < loop_boundaries.thread.team_size()) {
     strided_shfl_warp_reduction(
-      [&] (ValueType& val1, const ValueType& val2) { val1 += val2; },
-      initialized_result,
-      loop_boundaries.thread.team_size(),
-      blockDim.x);
+        [&](ValueType& val1, const ValueType& val2) { val1 += val2; },
+        initialized_result, loop_boundaries.thread.team_size(), blockDim.x);
 
-    initialized_result =
-      shfl_warp_broadcast<ValueType>(
-        initialized_result, threadIdx.x, Impl::CudaTraits::WarpSize );
+    initialized_result = shfl_warp_broadcast<ValueType>(
+        initialized_result, threadIdx.x, Impl::CudaTraits::WarpSize);
   }
 }
 
-template< typename iType, class Lambda, typename ReducerType, class Scheduler >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries,
-   const Lambda & lambda,
-   const ReducerType& reducer) {
-
+template <typename iType, class Lambda, typename ReducerType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Lambda& lambda, const ReducerType& reducer) {
   typedef typename ReducerType::value_type ValueType;
-  //TODO @internal_documentation what is the point of creating this temporary?
+  // TODO @internal_documentation what is the point of creating this temporary?
   ValueType result = ValueType();
   reducer.init(result);
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
 
-  if ( 1 < loop_boundaries.thread.team_size() ) {
+  if (1 < loop_boundaries.thread.team_size()) {
     strided_shfl_warp_reduction(
-      [&] (ValueType& val1, const ValueType& val2) { reducer.join(val1,val2); },
-      result,
-      loop_boundaries.thread.team_size(),
-      blockDim.x);
-
-    reducer.reference() =
-      shfl_warp_broadcast<ValueType>(
-        result, threadIdx.x, Impl::CudaTraits::WarpSize );
-  }
-  else {
-    reducer.reference() = result ;
+        [&](ValueType& val1, const ValueType& val2) {
+          reducer.join(val1, val2);
+        },
+        result, loop_boundaries.thread.team_size(), blockDim.x);
+
+    reducer.reference() = shfl_warp_broadcast<ValueType>(
+        result, threadIdx.x, Impl::CudaTraits::WarpSize);
+  } else {
+    reducer.reference() = result;
   }
 }
 // all-reduce within team members within warp
@@ -1003,19 +953,19 @@ void parallel_reduce
 /*template< typename iType, class Lambda, typename ValueType, class JoinType >
 KOKKOS_INLINE_FUNCTION
 void parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda > >& loop_boundaries,
-   const Lambda & lambda,
-   const JoinType& join,
+  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec<
+Kokkos::Cuda > >& loop_boundaries, const Lambda & lambda, const JoinType& join,
    ValueType& initialized_result) {
 
   ValueType result = initialized_result;
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for( iType i = loop_boundaries.start; i < loop_boundaries.end;
+i+=loop_boundaries.increment) { lambda(i,result);
   }
   initialized_result = result;
 
-  multi_shfl_warp_reduction<ValueType, JoinType>(join, initialized_result, blockDim.x);
-  initialized_result = shfl_warp_broadcast<ValueType>( initialized_result, 0, blockDim.x );
+  multi_shfl_warp_reduction<ValueType, JoinType>(join, initialized_result,
+blockDim.x); initialized_result = shfl_warp_broadcast<ValueType>(
+initialized_result, 0, blockDim.x );
 }*/
 
 // all-reduce within team members within warp
@@ -1025,60 +975,56 @@ void parallel_reduce
 // blockDim.y == team_size
 // threadIdx.x == position in vec
 // threadIdx.y == member number
-template< typename iType, class Lambda, typename ValueType, class Scheduler >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries,
-   const Lambda & lambda,
-   ValueType& initialized_result) {
-
+template <typename iType, class Lambda, typename ValueType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Lambda& lambda, ValueType& initialized_result) {
   ValueType result = initialized_result;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
 
   initialized_result = result;
 
-  if ( 1 < loop_boundaries.thread.team_size() ) {
-    //initialized_result = multi_shfl_warp_reduction(
+  if (1 < loop_boundaries.thread.team_size()) {
+    // initialized_result = multi_shfl_warp_reduction(
     multi_shfl_warp_reduction(
-      [&] (ValueType& val1, const ValueType& val2) { val1 += val2; },
-      initialized_result,
-      blockDim.x);
+        [&](ValueType& val1, const ValueType& val2) { val1 += val2; },
+        initialized_result, blockDim.x);
 
     initialized_result =
-      shfl_warp_broadcast<ValueType>( initialized_result, 0, blockDim.x );
+        shfl_warp_broadcast<ValueType>(initialized_result, 0, blockDim.x);
   }
 }
 
-template< typename iType, class Lambda, typename ReducerType, class Scheduler >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries,
-   const Lambda & lambda,
-   const ReducerType& reducer) {
-
+template <typename iType, class Lambda, typename ReducerType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Lambda& lambda, const ReducerType& reducer) {
   typedef typename ReducerType::value_type ValueType;
 
   ValueType result = ValueType();
   reducer.init(result);
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
 
-  if ( 1 < loop_boundaries.thread.team_size() ) {
+  if (1 < loop_boundaries.thread.team_size()) {
     multi_shfl_warp_reduction(
-      [&] (ValueType& val1, const ValueType& val2) { reducer.join(val1,val2); },
-      result,
-      blockDim.x);
-
-    reducer.reference() =
-      shfl_warp_broadcast<ValueType>( result, 0, blockDim.x );
-  }
-  else {
-    reducer.reference() = result ;
+        [&](ValueType& val1, const ValueType& val2) {
+          reducer.join(val1, val2);
+        },
+        result, blockDim.x);
+
+    reducer.reference() = shfl_warp_broadcast<ValueType>(result, 0, blockDim.x);
+  } else {
+    reducer.reference() = result;
   }
 }
 // scan across corresponding vector lanes between team members within warp
@@ -1087,61 +1033,61 @@ void parallel_reduce
 // blockDim.y == team_size
 // threadIdx.x == position in vec
 // threadIdx.y == member number
-template< typename iType, class Closure, class Scheduler >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries,
-   const Closure & closure )
-{
+template <typename iType, class Closure, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Closure& closure) {
   // Extract value_type from closure
 
-  using value_type =
-    typename Kokkos::Impl::FunctorAnalysis
-      < Kokkos::Impl::FunctorPatternInterface::SCAN
-      , void
-      , Closure >::value_type ;
-
-  if ( 1 < loop_boundaries.thread.team_size() ) {
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
 
+  if (1 < loop_boundaries.thread.team_size()) {
     // make sure all threads perform all loop iterations
-    const iType bound = loop_boundaries.end + loop_boundaries.start ;
-    const int lane = threadIdx.y * blockDim.x ;
+    const iType bound = loop_boundaries.end + loop_boundaries.start;
+    const int lane    = threadIdx.y * blockDim.x;
 
-    value_type accum = 0 ;
+    value_type accum = 0;
     value_type val, y, local_total;
 
-    for( iType i = loop_boundaries.start; i < bound; i+=loop_boundaries.increment) {
+    for (iType i = loop_boundaries.start; i < bound;
+         i += loop_boundaries.increment) {
       val = 0;
-      if ( i < loop_boundaries.end ) closure(i,val,false);
+      if (i < loop_boundaries.end) closure(i, val, false);
 
       // intra-blockDim.y exclusive scan on 'val'
       // accum = accumulated, sum in total for this iteration
 
       // INCLUSIVE scan
-      for( int offset = blockDim.x ; offset < Impl::CudaTraits::WarpSize ; offset <<= 1 ) {
+      for (int offset = blockDim.x; offset < Impl::CudaTraits::WarpSize;
+           offset <<= 1) {
         y = Kokkos::shfl_up(val, offset, Impl::CudaTraits::WarpSize);
-        if(lane >= offset) { val += y; }
+        if (lane >= offset) {
+          val += y;
+        }
       }
 
       // pass accum to all threads
       local_total = shfl_warp_broadcast<value_type>(
-         val,
-         threadIdx.x+Impl::CudaTraits::WarpSize-blockDim.x,
-         Impl::CudaTraits::WarpSize);
+          val, threadIdx.x + Impl::CudaTraits::WarpSize - blockDim.x,
+          Impl::CudaTraits::WarpSize);
 
       // make EXCLUSIVE scan by shifting values over one
       val = Kokkos::shfl_up(val, blockDim.x, Impl::CudaTraits::WarpSize);
-      if ( threadIdx.y == 0 ) { val = 0 ; }
+      if (threadIdx.y == 0) {
+        val = 0;
+      }
 
       val += accum;
-      if ( i < loop_boundaries.end ) closure(i,val,true);
+      if (i < loop_boundaries.end) closure(i, val, true);
       accum += local_total;
     }
-  }
-  else {
-    value_type accum = 0 ;
-    for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-      closure(i,accum,true);
+  } else {
+    value_type accum = 0;
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+         i += loop_boundaries.increment) {
+      closure(i, accum, true);
     }
   }
 }
@@ -1152,57 +1098,58 @@ void parallel_scan
 // blockDim.y == team_size
 // threadIdx.x == position in vec
 // threadIdx.y == member number
-template< typename iType, class Closure, class Scheduler >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Cuda, Scheduler > >& loop_boundaries,
-   const Closure & closure )
-{
+template <typename iType, class Closure, class Scheduler>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Cuda, Scheduler>>& loop_boundaries,
+    const Closure& closure) {
   // Extract value_type from closure
 
-  using value_type =
-    typename Kokkos::Impl::FunctorAnalysis
-      < Kokkos::Impl::FunctorPatternInterface::SCAN
-      , void
-      , Closure >::value_type ;
-
-  if ( 1 < loop_boundaries.thread.team_size() ) {
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
 
+  if (1 < loop_boundaries.thread.team_size()) {
     // make sure all threads perform all loop iterations
-    const iType bound = loop_boundaries.end + loop_boundaries.start ;
+    const iType bound = loop_boundaries.end + loop_boundaries.start;
 
-    value_type accum = 0 ;
+    value_type accum = 0;
     value_type val, y, local_total;
 
-    for( iType i = loop_boundaries.start; i < bound; i+=loop_boundaries.increment) {
+    for (iType i = loop_boundaries.start; i < bound;
+         i += loop_boundaries.increment) {
       val = 0;
-      if ( i < loop_boundaries.end ) closure(i,val,false);
+      if (i < loop_boundaries.end) closure(i, val, false);
 
       // intra-blockDim.x exclusive scan on 'val'
       // accum = accumulated, sum in total for this iteration
 
       // INCLUSIVE scan
-      for( int offset = 1 ; offset < blockDim.x ; offset <<= 1 ) {
+      for (int offset = 1; offset < blockDim.x; offset <<= 1) {
         y = Kokkos::shfl_up(val, offset, blockDim.x);
-        if(threadIdx.x >= offset) { val += y; }
+        if (threadIdx.x >= offset) {
+          val += y;
+        }
       }
 
       // pass accum to all threads
-      local_total = shfl_warp_broadcast<value_type>(val, blockDim.x-1, blockDim.x);
+      local_total =
+          shfl_warp_broadcast<value_type>(val, blockDim.x - 1, blockDim.x);
 
       // make EXCLUSIVE scan by shifting values over one
       val = Kokkos::shfl_up(val, 1, blockDim.x);
-      if ( threadIdx.x == 0 ) { val = 0 ; }
+      if (threadIdx.x == 0) {
+        val = 0;
+      }
 
       val += accum;
-      if ( i < loop_boundaries.end ) closure(i,val,true);
+      if (i < loop_boundaries.end) closure(i, val, true);
       accum += local_total;
     }
-  }
-  else {
-    value_type accum = 0 ;
-    for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-      closure(i,accum,true);
+  } else {
+    value_type accum = 0;
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+         i += loop_boundaries.increment) {
+      closure(i, accum, true);
     }
   }
 }
@@ -1211,49 +1158,53 @@ void parallel_scan
 
 namespace Kokkos {
 
-  template<class FunctorType, class Scheduler>
-  KOKKOS_INLINE_FUNCTION
-  void single(const Impl::VectorSingleStruct<Impl::TaskExec< Kokkos::Cuda, Scheduler > >& , const FunctorType& lambda) {
+template <class FunctorType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::TaskExec<Kokkos::Cuda, Scheduler>>&,
+    const FunctorType& lambda) {
 #ifdef __CUDA_ARCH__
-    if(threadIdx.x == 0) lambda();
+  if (threadIdx.x == 0) lambda();
 #endif
-  }
-  
-  template<class FunctorType, class Scheduler>
-  KOKKOS_INLINE_FUNCTION
-  void single(const Impl::ThreadSingleStruct<Impl::TaskExec< Kokkos::Cuda, Scheduler > >& , const FunctorType& lambda) {
+}
+
+template <class FunctorType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::TaskExec<Kokkos::Cuda, Scheduler>>&,
+    const FunctorType& lambda) {
 #ifdef __CUDA_ARCH__
-    if(threadIdx.x == 0 && threadIdx.y == 0) lambda();
+  if (threadIdx.x == 0 && threadIdx.y == 0) lambda();
 #endif
-  }
-  
-  template<class FunctorType, class ValueType, class Scheduler>
-  KOKKOS_INLINE_FUNCTION
-  void single(const Impl::VectorSingleStruct<Impl::TaskExec< Kokkos::Cuda, Scheduler > >& s , const FunctorType& lambda, ValueType& val) {
+}
+
+template <class FunctorType, class ValueType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::TaskExec<Kokkos::Cuda, Scheduler>>& s,
+    const FunctorType& lambda, ValueType& val) {
 #ifdef __CUDA_ARCH__
-    if(threadIdx.x == 0) lambda(val);
-    if ( 1 < s.team_member.team_size() ) {
-      val = shfl(val,0,blockDim.x);
-    }
-#endif
+  if (threadIdx.x == 0) lambda(val);
+  if (1 < s.team_member.team_size()) {
+    val = shfl(val, 0, blockDim.x);
   }
-  
-  template<class FunctorType, class ValueType, class Scheduler>
-  KOKKOS_INLINE_FUNCTION
-  void single(const Impl::ThreadSingleStruct<Impl::TaskExec< Kokkos::Cuda, Scheduler > >& single_struct, const FunctorType& lambda, ValueType& val) {
-#ifdef __CUDA_ARCH__
-    if(threadIdx.x == 0 && threadIdx.y == 0) {
-      lambda(val);
-    }
-    single_struct.team_member.team_broadcast(val,0);
 #endif
+}
+
+template <class FunctorType, class ValueType, class Scheduler>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::TaskExec<Kokkos::Cuda, Scheduler>>&
+        single_struct,
+    const FunctorType& lambda, ValueType& val) {
+#ifdef __CUDA_ARCH__
+  if (threadIdx.x == 0 && threadIdx.y == 0) {
+    lambda(val);
   }
+  single_struct.team_member.team_broadcast(val, 0);
+#endif
+}
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_CUDA_TASK_HPP */
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Team.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Team.hpp
index 587ad6001dfa78d57fe0c0e22246f2b7cfa811e5..ac9ab9660cbdd092fc8ccdeafc6f3bb68faf8649 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Team.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Team.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,7 +52,7 @@
 #include <Kokkos_Macros.hpp>
 
 /* only compile this file if CUDA is enabled for Kokkos */
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
 
 #include <utility>
 #include <Kokkos_Parallel.hpp>
@@ -72,14 +73,15 @@
 namespace Kokkos {
 namespace Impl {
 
-template< typename Type >
+template <typename Type>
 struct CudaJoinFunctor {
-  typedef Type value_type ;
+  typedef Type value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    volatile const value_type & input )
-    { update += input ; }
+  static void join(volatile value_type& update,
+                   volatile const value_type& input) {
+    update += input;
+  }
 };
 
 /**\brief  Team member_type passed to TeamPolicy or TeamTask closures.
@@ -101,108 +103,105 @@ struct CudaJoinFunctor {
  *  total available shared memory must be partitioned among teams.
  */
 class CudaTeamMember {
-
-public:
-  typedef Kokkos::Cuda                           execution_space ;
-  typedef execution_space::scratch_memory_space  scratch_memory_space ;
-
-private:
-
-  mutable void        * m_team_reduce ;
-  scratch_memory_space  m_team_shared ;
-  int                   m_team_reduce_size ;
-  int                   m_league_rank ;
-  int                   m_league_size ;
-
-public:
-
+ public:
+  typedef Kokkos::Cuda execution_space;
+  typedef execution_space::scratch_memory_space scratch_memory_space;
+
+ private:
+  mutable void* m_team_reduce;
+  scratch_memory_space m_team_shared;
+  int m_team_reduce_size;
+  int m_league_rank;
+  int m_league_size;
+
+ public:
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space & team_shmem() const
-    { return m_team_shared.set_team_thread_mode(0,1,0) ; }
+  const execution_space::scratch_memory_space& team_shmem() const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space &
-    team_scratch(const int& level) const
-      { return m_team_shared.set_team_thread_mode(level,1,0) ; }
+  const execution_space::scratch_memory_space& team_scratch(
+      const int& level) const {
+    return m_team_shared.set_team_thread_mode(level, 1, 0);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space &
-    thread_scratch(const int& level) const
-      { return m_team_shared.set_team_thread_mode(level,team_size(),team_rank()) ; }
-
-  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank ; }
-  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size ; }
-  KOKKOS_INLINE_FUNCTION int team_rank() const
-    {
-      #ifdef __CUDA_ARCH__
-      return threadIdx.y ;
-      #else
-      return 0;
-      #endif
-    }
+  const execution_space::scratch_memory_space& thread_scratch(
+      const int& level) const {
+    return m_team_shared.set_team_thread_mode(level, team_size(), team_rank());
+  }
 
-  KOKKOS_INLINE_FUNCTION int team_size() const
-    {
-      #ifdef __CUDA_ARCH__
-      return blockDim.y ;
-      #else
-      return 1;
-      #endif
-    }
+  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank; }
+  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
+  KOKKOS_INLINE_FUNCTION int team_rank() const {
+#ifdef __CUDA_ARCH__
+    return threadIdx.y;
+#else
+    return 0;
+#endif
+  }
 
-  KOKKOS_INLINE_FUNCTION void team_barrier() const
-    {
-      #ifdef __CUDA_ARCH__
-      if ( 1 == blockDim.z ) __syncthreads();       // team == block
-      else                   __threadfence_block(); // team <= warp
-      #endif
-    }
+  KOKKOS_INLINE_FUNCTION int team_size() const {
+#ifdef __CUDA_ARCH__
+    return blockDim.y;
+#else
+    return 1;
+#endif
+  }
+
+  KOKKOS_INLINE_FUNCTION void team_barrier() const {
+#ifdef __CUDA_ARCH__
+    if (1 == blockDim.z)
+      __syncthreads();  // team == block
+    else
+      __threadfence_block();  // team <= warp
+#endif
+  }
 
   //--------------------------------------------------------------------------
 
-  template<class ValueType>
-  KOKKOS_INLINE_FUNCTION
-  void team_broadcast( ValueType & val, const int& thread_id ) const
-    {
-      #ifdef __CUDA_ARCH__
-      if ( 1 == blockDim.z ) { // team == block
-        __syncthreads();
-        // Wait for shared data write until all threads arrive here
-        if ( threadIdx.x == 0u && threadIdx.y == (uint32_t)thread_id ) {
-          *((ValueType*) m_team_reduce) = val ;
-        }
-        __syncthreads(); // Wait for shared data read until root thread writes
-        val = *((ValueType*) m_team_reduce);
-      }
-      else { // team <= warp
-        ValueType tmp( val ); // input might not be a register variable
-        cuda_shfl( val, tmp, blockDim.x * thread_id, blockDim.x * blockDim.y );
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(ValueType& val,
+                                             const int& thread_id) const {
+#ifdef __CUDA_ARCH__
+    if (1 == blockDim.z) {  // team == block
+      __syncthreads();
+      // Wait for shared data write until all threads arrive here
+      if (threadIdx.x == 0u && threadIdx.y == (uint32_t)thread_id) {
+        *((ValueType*)m_team_reduce) = val;
       }
-      #endif
+      __syncthreads();  // Wait for shared data read until root thread writes
+      val = *((ValueType*)m_team_reduce);
+    } else {               // team <= warp
+      ValueType tmp(val);  // input might not be a register variable
+      Impl::in_place_shfl(val, tmp, blockDim.x * thread_id,
+                          blockDim.x * blockDim.y);
     }
-	
-  template<class Closure, class ValueType>
-  KOKKOS_INLINE_FUNCTION
-  void team_broadcast( Closure const & f, ValueType & val, const int& thread_id ) const
-    {
-      #ifdef __CUDA_ARCH__
-      f( val );
-
-      if ( 1 == blockDim.z ) { // team == block
-        __syncthreads();
-        // Wait for shared data write until all threads arrive here
-        if ( threadIdx.x == 0u && threadIdx.y == (uint32_t)thread_id ) {
-          *((ValueType*) m_team_reduce) = val ;
-        }
-        __syncthreads(); // Wait for shared data read until root thread writes
-        val = *((ValueType*) m_team_reduce);
-      }
-      else { // team <= warp
-        ValueType tmp( val ); // input might not be a register variable
-        cuda_shfl( val, tmp, blockDim.x * thread_id, blockDim.x * blockDim.y );
+#endif
+  }
+
+  template <class Closure, class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(Closure const& f, ValueType& val,
+                                             const int& thread_id) const {
+#ifdef __CUDA_ARCH__
+    f(val);
+
+    if (1 == blockDim.z) {  // team == block
+      __syncthreads();
+      // Wait for shared data write until all threads arrive here
+      if (threadIdx.x == 0u && threadIdx.y == (uint32_t)thread_id) {
+        *((ValueType*)m_team_reduce) = val;
       }
-      #endif
+      __syncthreads();  // Wait for shared data read until root thread writes
+      val = *((ValueType*)m_team_reduce);
+    } else {               // team <= warp
+      ValueType tmp(val);  // input might not be a register variable
+      Impl::in_place_shfl(val, tmp, blockDim.x * thread_id,
+                          blockDim.x * blockDim.y);
     }
+#endif
+  }
 
   //--------------------------------------------------------------------------
   /**\brief  Reduction across a team
@@ -219,24 +218,22 @@ public:
    *      OR
    *    ( 1 == blockDim.z )
    */
-  template< typename ReducerType >
+  template <typename ReducerType>
   KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< is_reducer< ReducerType >::value >::type
-  team_reduce( ReducerType const & reducer ) const noexcept
-    {
-      team_reduce(reducer,reducer.reference());
-    }
-  
-  template< typename ReducerType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< is_reducer< ReducerType >::value >::type
-  team_reduce( ReducerType const & reducer, typename ReducerType::value_type& value ) const noexcept
-    {
-      #ifdef __CUDA_ARCH__
-      cuda_intra_block_reduction(reducer,value,blockDim.y);
-      #endif /* #ifdef __CUDA_ARCH__ */
-    }
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      team_reduce(ReducerType const& reducer) const noexcept {
+    team_reduce(reducer, reducer.reference());
+  }
 
+  template <typename ReducerType>
+  KOKKOS_INLINE_FUNCTION
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      team_reduce(ReducerType const& reducer,
+                  typename ReducerType::value_type& value) const noexcept {
+#ifdef __CUDA_ARCH__
+    cuda_intra_block_reduction(reducer, value, blockDim.y);
+#endif /* #ifdef __CUDA_ARCH__ */
+  }
 
   //--------------------------------------------------------------------------
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
@@ -248,307 +245,299 @@ public:
    *  As such the base value for each team's scan operation is similarly
    *  non-deterministic.
    */
-  template< typename Type >
-  KOKKOS_INLINE_FUNCTION
-  Type team_scan( const Type & value , Type * const global_accum ) const
-    {
-      #ifdef __CUDA_ARCH__
-      Type * const base_data = (Type *) m_team_reduce ;
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_scan(const Type& value,
+                                        Type* const global_accum) const {
+#ifdef __CUDA_ARCH__
+    Type* const base_data = (Type*)m_team_reduce;
 
-      __syncthreads(); // Don't write in to shared data until all threads have entered this function
+    __syncthreads();  // Don't write in to shared data until all threads have
+                      // entered this function
 
-      if ( 0 == threadIdx.y ) { base_data[0] = 0 ; }
+    if (0 == threadIdx.y) {
+      base_data[0] = 0;
+    }
 
-      base_data[ threadIdx.y + 1 ] = value ;
+    base_data[threadIdx.y + 1] = value;
 
-      Impl::cuda_intra_block_reduce_scan<true,Impl::CudaJoinFunctor<Type>,void>( Impl::CudaJoinFunctor<Type>() , base_data + 1 );
+    Impl::cuda_intra_block_reduce_scan<true, Impl::CudaJoinFunctor<Type>, void>(
+        Impl::CudaJoinFunctor<Type>(), base_data + 1);
 
-      if ( global_accum ) {
-        if ( blockDim.y == threadIdx.y + 1 ) {
-          base_data[ blockDim.y ] = atomic_fetch_add( global_accum , base_data[ blockDim.y ] );
-        }
-        __syncthreads(); // Wait for atomic
-        base_data[ threadIdx.y ] += base_data[ blockDim.y ] ;
+    if (global_accum) {
+      if (blockDim.y == threadIdx.y + 1) {
+        base_data[blockDim.y] =
+            atomic_fetch_add(global_accum, base_data[blockDim.y]);
       }
-
-      return base_data[ threadIdx.y ];
-      #else
-      return Type();
-      #endif
+      __syncthreads();  // Wait for atomic
+      base_data[threadIdx.y] += base_data[blockDim.y];
     }
 
+    return base_data[threadIdx.y];
+#else
+    return Type();
+#endif
+  }
+
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering.
    *
    *  The highest rank thread can compute the reduction total as
    *    reduction_total = dev.team_scan( value ) + value ;
    */
-  template< typename Type >
-  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value ) const {
-    return this->template team_scan<Type>( value , 0 );
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_scan(const Type& value) const {
+    return this->template team_scan<Type>(value, 0);
   }
 
   //----------------------------------------
 
-  template< typename ReducerType >
+  template <typename ReducerType>
   KOKKOS_INLINE_FUNCTION static
-  typename std::enable_if< is_reducer< ReducerType >::value >::type
-  vector_reduce( ReducerType const & reducer ) {
-    vector_reduce(reducer,reducer.reference());
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      vector_reduce(ReducerType const& reducer) {
+    vector_reduce(reducer, reducer.reference());
   }
 
-  template< typename ReducerType >
+  template <typename ReducerType>
   KOKKOS_INLINE_FUNCTION static
-  typename std::enable_if< is_reducer< ReducerType >::value >::type
-  vector_reduce( ReducerType const & reducer, typename ReducerType::value_type& value )
-    {
-
-      #ifdef __CUDA_ARCH__
-      if(blockDim.x == 1) return;
-
-      // Intra vector lane shuffle reduction:
-      typename ReducerType::value_type tmp ( value );
-      typename ReducerType::value_type tmp2 = tmp;
-
-      unsigned mask = blockDim.x==32?0xffffffff:((1<<blockDim.x)-1)<<((threadIdx.y%(32/blockDim.x))*blockDim.x);
-
-      for ( int i = blockDim.x ; ( i >>= 1 ) ; ) {
-        cuda_shfl_down( tmp2 , tmp , i , blockDim.x , mask );
-        if ( (int)threadIdx.x < i ) { reducer.join( tmp , tmp2 ); }
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      vector_reduce(ReducerType const& reducer,
+                    typename ReducerType::value_type& value) {
+#ifdef __CUDA_ARCH__
+    if (blockDim.x == 1) return;
+
+    // Intra vector lane shuffle reduction:
+    typename ReducerType::value_type tmp(value);
+    typename ReducerType::value_type tmp2 = tmp;
+
+    unsigned mask =
+        blockDim.x == 32
+            ? 0xffffffff
+            : ((1 << blockDim.x) - 1)
+                  << ((threadIdx.y % (32 / blockDim.x)) * blockDim.x);
+
+    for (int i = blockDim.x; (i >>= 1);) {
+      Impl::in_place_shfl_down(tmp2, tmp, i, blockDim.x, mask);
+      if ((int)threadIdx.x < i) {
+        reducer.join(tmp, tmp2);
       }
+    }
 
-      // Broadcast from root lane to all other lanes.
-      // Cannot use "butterfly" algorithm to avoid the broadcast
-      // because floating point summation is not associative
-      // and thus different threads could have different results.
+    // Broadcast from root lane to all other lanes.
+    // Cannot use "butterfly" algorithm to avoid the broadcast
+    // because floating point summation is not associative
+    // and thus different threads could have different results.
 
-      cuda_shfl( tmp2 , tmp , 0 , blockDim.x , mask );
-      value = tmp2;
-      reducer.reference() = tmp2;
-      #endif
-    }
+    Impl::in_place_shfl(tmp2, tmp, 0, blockDim.x, mask);
+    value               = tmp2;
+    reducer.reference() = tmp2;
+#endif
+  }
 
   //--------------------------------------------------------------------------
   /**\brief  Global reduction across all blocks
    *
    *  Return !0 if reducer contains the final value
    */
-  template< typename ReducerType >
+  template <typename ReducerType>
   KOKKOS_INLINE_FUNCTION static
-  typename std::enable_if< is_reducer< ReducerType >::value , int >::type
-  global_reduce( ReducerType const & reducer
-               , int  * const global_scratch_flags
-               , void * const global_scratch_space
-               , void * const shmem
-               , int    const shmem_size
-               )
-    {
-    #ifdef __CUDA_ARCH__
-
-      typedef typename ReducerType::value_type value_type ;
-      typedef value_type volatile * pointer_type ;
+      typename std::enable_if<is_reducer<ReducerType>::value, int>::type
+      global_reduce(ReducerType const& reducer, int* const global_scratch_flags,
+                    void* const global_scratch_space, void* const shmem,
+                    int const shmem_size) {
+#ifdef __CUDA_ARCH__
 
-      // Number of shared memory entries for the reduction:
-      const int nsh = shmem_size / sizeof(value_type);
+    typedef typename ReducerType::value_type value_type;
+    typedef value_type volatile* pointer_type;
 
-      // Number of CUDA threads in the block, rank within the block
-      const int nid = blockDim.x * blockDim.y * blockDim.z ;
-      const int tid = threadIdx.x + blockDim.x * (
-                      threadIdx.y + blockDim.y * threadIdx.z );
+    // Number of shared memory entries for the reduction:
+    const int nsh = shmem_size / sizeof(value_type);
 
-      // Reduces within block using all available shared memory
-      // Contributes if it is the root "vector lane"
+    // Number of CUDA threads in the block, rank within the block
+    const int nid = blockDim.x * blockDim.y * blockDim.z;
+    const int tid =
+        threadIdx.x + blockDim.x * (threadIdx.y + blockDim.y * threadIdx.z);
 
-      // wn == number of warps in the block
-      // wx == which lane within the warp
-      // wy == which warp within the block
+    // Reduces within block using all available shared memory
+    // Contributes if it is the root "vector lane"
 
-      const int wn = ( nid + CudaTraits::WarpIndexMask ) >> CudaTraits::WarpIndexShift ;
-      const int wx = tid &  CudaTraits::WarpIndexMask ;
-      const int wy = tid >> CudaTraits::WarpIndexShift ;
+    // wn == number of warps in the block
+    // wx == which lane within the warp
+    // wy == which warp within the block
 
-      //------------------------
-      { // Intra warp shuffle reduction from contributing CUDA threads
+    const int wn =
+        (nid + CudaTraits::WarpIndexMask) >> CudaTraits::WarpIndexShift;
+    const int wx = tid & CudaTraits::WarpIndexMask;
+    const int wy = tid >> CudaTraits::WarpIndexShift;
 
-        value_type tmp( reducer.reference() );
+    //------------------------
+    {  // Intra warp shuffle reduction from contributing CUDA threads
 
-        for ( int i = CudaTraits::WarpSize ; (int)blockDim.x <= ( i >>= 1 ) ; ) {
+      value_type tmp(reducer.reference());
 
-          cuda_shfl_down( reducer.reference(), tmp, i, CudaTraits::WarpSize );
+      for (int i = CudaTraits::WarpSize; (int)blockDim.x <= (i >>= 1);) {
+        Impl::in_place_shfl_down(reducer.reference(), tmp, i,
+                                 CudaTraits::WarpSize);
 
-          // Root of each vector lane reduces "thread" contribution
-          if ( 0 == threadIdx.x && wx < i ) {
-            reducer.join( & tmp , reducer.data() );
-          }
+        // Root of each vector lane reduces "thread" contribution
+        if (0 == threadIdx.x && wx < i) {
+          reducer.join(&tmp, reducer.data());
         }
+      }
 
-        // Reduce across warps using shared memory.
-        // Number of warps may not be power of two.
+      // Reduce across warps using shared memory.
+      // Number of warps may not be power of two.
 
-        __syncthreads(); // Wait before shared data write
+      __syncthreads();  // Wait before shared data write
 
-        // Number of shared memory entries for the reduction
-        // is at most one per warp
-        const int nentry = wn < nsh ? wn : nsh ;
+      // Number of shared memory entries for the reduction
+      // is at most one per warp
+      const int nentry = wn < nsh ? wn : nsh;
 
-        if ( 0 == wx && wy < nentry ) {
-          // Root thread of warp 'wy' has warp's value to contribute
-          ((value_type*) shmem)[wy] = tmp ;
-        }
-
-        __syncthreads(); // Wait for write to be visible to block
-
-        // When more warps than shared entries
-        // then warps must take turns joining their contribution
-        // to the designated shared memory entry.
-        for ( int i = nentry ; i < wn ; i += nentry ) {
+      if (0 == wx && wy < nentry) {
+        // Root thread of warp 'wy' has warp's value to contribute
+        ((value_type*)shmem)[wy] = tmp;
+      }
 
-          const int k = wy - i ;
+      __syncthreads();  // Wait for write to be visible to block
 
-          if ( 0 == wx && i <= wy && k < nentry ) {
-            // Root thread of warp 'wy' has warp's value to contribute
-            reducer.join( ((value_type*) shmem) + k , & tmp );
-          }
+      // When more warps than shared entries
+      // then warps must take turns joining their contribution
+      // to the designated shared memory entry.
+      for (int i = nentry; i < wn; i += nentry) {
+        const int k = wy - i;
 
-          __syncthreads(); // Wait for write to be visible to block
+        if (0 == wx && i <= wy && k < nentry) {
+          // Root thread of warp 'wy' has warp's value to contribute
+          reducer.join(((value_type*)shmem) + k, &tmp);
         }
 
-        // One warp performs the inter-warp reduction:
+        __syncthreads();  // Wait for write to be visible to block
+      }
 
-        if ( 0 == wy ) {
+      // One warp performs the inter-warp reduction:
 
-          // Start fan-in at power of two covering nentry
+      if (0 == wy) {
+        // Start fan-in at power of two covering nentry
 
-          for ( int i = ( 1 << ( 32 - __clz(nentry-1) ) ) ; ( i >>= 1 ) ; ) {
-            const int k = wx + i ;
-            if ( wx < i && k < nentry ) {
-              reducer.join( ((pointer_type)shmem) + wx
-                          , ((pointer_type)shmem) + k );
-              __threadfence_block(); // Wait for write to be visible to warp
-            }
+        for (int i = (1 << (32 - __clz(nentry - 1))); (i >>= 1);) {
+          const int k = wx + i;
+          if (wx < i && k < nentry) {
+            reducer.join(((pointer_type)shmem) + wx, ((pointer_type)shmem) + k);
+            __threadfence_block();  // Wait for write to be visible to warp
           }
         }
       }
-      //------------------------
-      { // Write block's value to global_scratch_memory
-
-        int last_block = 0 ;
-
-        if ( 0 == wx ) {
-          reducer.copy( ((pointer_type)global_scratch_space)
-                        + blockIdx.x * reducer.length()
-                      , reducer.data() );
+    }
+    //------------------------
+    {  // Write block's value to global_scratch_memory
 
-          __threadfence(); // Wait until global write is visible.
+      int last_block = 0;
 
-          last_block = (int)gridDim.x ==
-                       1 + Kokkos::atomic_fetch_add(global_scratch_flags,1);
+      if (0 == wx) {
+        reducer.copy(((pointer_type)global_scratch_space) +
+                         blockIdx.x * reducer.length(),
+                     reducer.data());
 
-          // If last block then reset count
-          if ( last_block ) *global_scratch_flags = 0 ;
-        }
+        __threadfence();  // Wait until global write is visible.
 
-        last_block = __syncthreads_or( last_block );
-
-        if ( ! last_block ) return 0 ;
+        last_block = (int)gridDim.x ==
+                     1 + Kokkos::atomic_fetch_add(global_scratch_flags, 1);
 
+        // If last block then reset count
+        if (last_block) *global_scratch_flags = 0;
       }
-      //------------------------
-      // Last block reads global_scratch_memory into shared memory.
 
-      const int nentry = nid < gridDim.x ?
-                       ( nid       < nsh ? nid       : nsh ) :
-                       ( gridDim.x < nsh ? gridDim.x : nsh ) ;
+      last_block = __syncthreads_or(last_block);
 
-      // nentry = min( nid , nsh , gridDim.x )
+      if (!last_block) return 0;
+    }
+    //------------------------
+    // Last block reads global_scratch_memory into shared memory.
 
-      // whole block reads global memory into shared memory:
+    const int nentry = nid < gridDim.x ? (nid < nsh ? nid : nsh)
+                                       : (gridDim.x < nsh ? gridDim.x : nsh);
 
-      if ( tid < nentry ) {
+    // nentry = min( nid , nsh , gridDim.x )
 
-        const int offset = tid * reducer.length();
+    // whole block reads global memory into shared memory:
 
-        reducer.copy( ((pointer_type)shmem) + offset
-                    , ((pointer_type)global_scratch_space) + offset );
+    if (tid < nentry) {
+      const int offset = tid * reducer.length();
 
-        for ( int i = nentry + tid ; i < (int)gridDim.x ; i += nentry ) {
-          reducer.join( ((pointer_type)shmem) + offset
-                      , ((pointer_type)global_scratch_space)
-                        + i * reducer.length() );
-        }
-      }
+      reducer.copy(((pointer_type)shmem) + offset,
+                   ((pointer_type)global_scratch_space) + offset);
 
-      __syncthreads(); // Wait for writes to be visible to block
+      for (int i = nentry + tid; i < (int)gridDim.x; i += nentry) {
+        reducer.join(
+            ((pointer_type)shmem) + offset,
+            ((pointer_type)global_scratch_space) + i * reducer.length());
+      }
+    }
 
-      if ( 0 == wy ) {
+    __syncthreads();  // Wait for writes to be visible to block
 
-        // Iterate to reduce shared memory to single warp fan-in size
+    if (0 == wy) {
+      // Iterate to reduce shared memory to single warp fan-in size
 
-        const int nreduce = CudaTraits::WarpSize < nentry
-                          ? CudaTraits::WarpSize : nentry ;
+      const int nreduce =
+          CudaTraits::WarpSize < nentry ? CudaTraits::WarpSize : nentry;
 
-        // nreduce = min( CudaTraits::WarpSize , nsh , gridDim.x )
+      // nreduce = min( CudaTraits::WarpSize , nsh , gridDim.x )
 
-        if ( wx < nreduce && nreduce < nentry ) {
-          for ( int i = nreduce + wx ; i < nentry ; i += nreduce ) {
-            reducer.join( ((pointer_type)shmem) + wx
-                        , ((pointer_type)shmem) + i );
-          }
-          __threadfence_block(); // Wait for writes to be visible to warp
+      if (wx < nreduce && nreduce < nentry) {
+        for (int i = nreduce + wx; i < nentry; i += nreduce) {
+          reducer.join(((pointer_type)shmem) + wx, ((pointer_type)shmem) + i);
         }
+        __threadfence_block();  // Wait for writes to be visible to warp
+      }
 
-        // Start fan-in at power of two covering nentry
-
-        for ( int i = ( 1 << ( 32 - __clz(nreduce-1) ) ) ; ( i >>= 1 ) ; ) {
-          const int k = wx + i ;
-          if ( wx < i && k < nreduce ) {
-            reducer.join( ((pointer_type)shmem) + wx
-                        , ((pointer_type)shmem) + k );
-            __threadfence_block(); // Wait for writes to be visible to warp
-          }
-        }
+      // Start fan-in at power of two covering nentry
 
-        if ( 0 == wx ) {
-          reducer.copy( reducer.data() , (pointer_type)shmem );
-          return 1 ;
+      for (int i = (1 << (32 - __clz(nreduce - 1))); (i >>= 1);) {
+        const int k = wx + i;
+        if (wx < i && k < nreduce) {
+          reducer.join(((pointer_type)shmem) + wx, ((pointer_type)shmem) + k);
+          __threadfence_block();  // Wait for writes to be visible to warp
         }
       }
-      return 0 ;
 
-    #else
-      return 0 ;
-    #endif
+      if (0 == wx) {
+        reducer.copy(reducer.data(), (pointer_type)shmem);
+        return 1;
+      }
     }
+    return 0;
+
+#else
+    return 0;
+#endif
+  }
 
   //----------------------------------------
   // Private for the driver
 
   KOKKOS_INLINE_FUNCTION
-  CudaTeamMember( void * shared
-                , const int shared_begin
-                , const int shared_size
-                , void*     scratch_level_1_ptr
-                , const int scratch_level_1_size
-                , const int arg_league_rank
-                , const int arg_league_size )
-    : m_team_reduce( shared )
-    , m_team_shared( ((char *)shared) + shared_begin , shared_size,  scratch_level_1_ptr, scratch_level_1_size)
-    , m_team_reduce_size( shared_begin )
-    , m_league_rank( arg_league_rank )
-    , m_league_size( arg_league_size )
-    {}
-
-public:
+  CudaTeamMember(void* shared, const int shared_begin, const int shared_size,
+                 void* scratch_level_1_ptr, const int scratch_level_1_size,
+                 const int arg_league_rank, const int arg_league_size)
+      : m_team_reduce(shared),
+        m_team_shared(((char*)shared) + shared_begin, shared_size,
+                      scratch_level_1_ptr, scratch_level_1_size),
+        m_team_reduce_size(shared_begin),
+        m_league_rank(arg_league_rank),
+        m_league_size(arg_league_size) {}
+
+ public:
   // Declare to avoid unused private member warnings which are trigger
   // when SFINAE excludes the member function which uses these variables
   // Making another class a friend also surpresses these warnings
-  bool impl_avoid_sfinae_warning() const noexcept
-  {
+  bool impl_avoid_sfinae_warning() const noexcept {
     return m_team_reduce_size > 0 && m_team_reduce != nullptr;
   }
 };
 
-} // namspace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -556,124 +545,128 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template<typename iType>
-struct TeamThreadRangeBoundariesStruct<iType,CudaTeamMember> {
+template <typename iType>
+struct TeamThreadRangeBoundariesStruct<iType, CudaTeamMember> {
   typedef iType index_type;
   const CudaTeamMember& member;
   const iType start;
   const iType end;
 
   KOKKOS_INLINE_FUNCTION
-  TeamThreadRangeBoundariesStruct (const CudaTeamMember& thread_, iType count)
-    : member(thread_)
-    , start( 0 )
-    , end( count ) {}
+  TeamThreadRangeBoundariesStruct(const CudaTeamMember& thread_, iType count)
+      : member(thread_), start(0), end(count) {}
 
   KOKKOS_INLINE_FUNCTION
-  TeamThreadRangeBoundariesStruct (const CudaTeamMember& thread_, iType begin_, iType end_)
-    : member(thread_)
-    , start( begin_ )
-    , end( end_ ) {}
+  TeamThreadRangeBoundariesStruct(const CudaTeamMember& thread_, iType begin_,
+                                  iType end_)
+      : member(thread_), start(begin_), end(end_) {}
 };
 
-template<typename iType>
-struct TeamVectorRangeBoundariesStruct<iType,CudaTeamMember> {
+template <typename iType>
+struct TeamVectorRangeBoundariesStruct<iType, CudaTeamMember> {
   typedef iType index_type;
   const CudaTeamMember& member;
   const iType start;
   const iType end;
 
   KOKKOS_INLINE_FUNCTION
-  TeamVectorRangeBoundariesStruct (const CudaTeamMember& thread_, const iType& count)
-    : member(thread_)
-    , start( 0 )
-    , end( count ) {}
+  TeamVectorRangeBoundariesStruct(const CudaTeamMember& thread_,
+                                  const iType& count)
+      : member(thread_), start(0), end(count) {}
 
   KOKKOS_INLINE_FUNCTION
-  TeamVectorRangeBoundariesStruct (const CudaTeamMember& thread_,  const iType& begin_, const iType& end_)
-    : member(thread_)
-    , start( begin_ )
-    , end( end_ ) {}
+  TeamVectorRangeBoundariesStruct(const CudaTeamMember& thread_,
+                                  const iType& begin_, const iType& end_)
+      : member(thread_), start(begin_), end(end_) {}
 };
 
-template<typename iType>
-struct ThreadVectorRangeBoundariesStruct<iType,CudaTeamMember> {
+template <typename iType>
+struct ThreadVectorRangeBoundariesStruct<iType, CudaTeamMember> {
   typedef iType index_type;
   const index_type start;
   const index_type end;
 
   KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct (const CudaTeamMember, index_type count)
-    : start( static_cast<index_type>(0) ), end( count ) {}
+  ThreadVectorRangeBoundariesStruct(const CudaTeamMember, index_type count)
+      : start(static_cast<index_type>(0)), end(count) {}
 
   KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct (index_type count)
-    : start( static_cast<index_type>(0) ), end( count ) {}
+  ThreadVectorRangeBoundariesStruct(index_type count)
+      : start(static_cast<index_type>(0)), end(count) {}
 
   KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct (const CudaTeamMember, index_type arg_begin, index_type arg_end)
-    : start( arg_begin ), end( arg_end ) {}
+  ThreadVectorRangeBoundariesStruct(const CudaTeamMember, index_type arg_begin,
+                                    index_type arg_end)
+      : start(arg_begin), end(arg_end) {}
 
   KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct (index_type arg_begin, index_type arg_end)
-    : start( arg_begin ), end( arg_end ) {}
+  ThreadVectorRangeBoundariesStruct(index_type arg_begin, index_type arg_end)
+      : start(arg_begin), end(arg_end) {}
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< iType, Impl::CudaTeamMember >
-TeamThreadRange( const Impl::CudaTeamMember & thread, iType count ) {
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::CudaTeamMember >( thread, count );
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::CudaTeamMember>
+    TeamThreadRange(const Impl::CudaTeamMember& thread, iType count) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::CudaTeamMember>(
+      thread, count);
 }
 
-template< typename iType1, typename iType2 >
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< typename std::common_type< iType1, iType2 >::type,
-                                       Impl::CudaTeamMember >
-TeamThreadRange( const Impl::CudaTeamMember & thread, iType1 begin, iType2 end ) {
-  typedef typename std::common_type< iType1, iType2 >::type iType;
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::CudaTeamMember >( thread, iType(begin), iType(end) );
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type, Impl::CudaTeamMember>
+TeamThreadRange(const Impl::CudaTeamMember& thread, iType1 begin, iType2 end) {
+  typedef typename std::common_type<iType1, iType2>::type iType;
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::CudaTeamMember>(
+      thread, iType(begin), iType(end));
 }
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::TeamVectorRangeBoundariesStruct< iType, Impl::CudaTeamMember >
-TeamVectorRange( const Impl::CudaTeamMember & thread, const iType & count ) {
-  return Impl::TeamVectorRangeBoundariesStruct< iType, Impl::CudaTeamMember >( thread, count );
+    Impl::TeamVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>
+    TeamVectorRange(const Impl::CudaTeamMember& thread, const iType& count) {
+  return Impl::TeamVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>(
+      thread, count);
 }
 
-template< typename iType1, typename iType2 >
-KOKKOS_INLINE_FUNCTION
-Impl::TeamVectorRangeBoundariesStruct< typename std::common_type< iType1, iType2 >::type,
-                                       Impl::CudaTeamMember >
-TeamVectorRange( const Impl::CudaTeamMember & thread, const iType1 & begin, const iType2 & end ) {
-  typedef typename std::common_type< iType1, iType2 >::type iType;
-  return Impl::TeamVectorRangeBoundariesStruct< iType, Impl::CudaTeamMember >( thread, iType(begin), iType(end) );
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamVectorRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type, Impl::CudaTeamMember>
+TeamVectorRange(const Impl::CudaTeamMember& thread, const iType1& begin,
+                const iType2& end) {
+  typedef typename std::common_type<iType1, iType2>::type iType;
+  return Impl::TeamVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>(
+      thread, iType(begin), iType(end));
 }
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember >
-ThreadVectorRange(const Impl::CudaTeamMember& thread, iType count) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember >(thread,count);
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>
+    ThreadVectorRange(const Impl::CudaTeamMember& thread, iType count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>(
+      thread, count);
 }
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember >
-ThreadVectorRange(const Impl::CudaTeamMember& thread, iType arg_begin, iType arg_end) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember >(thread,arg_begin,arg_end);
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>
+    ThreadVectorRange(const Impl::CudaTeamMember& thread, iType arg_begin,
+                      iType arg_end) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>(
+      thread, arg_begin, arg_end);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::CudaTeamMember> PerTeam(const Impl::CudaTeamMember& thread) {
+Impl::ThreadSingleStruct<Impl::CudaTeamMember> PerTeam(
+    const Impl::CudaTeamMember& thread) {
   return Impl::ThreadSingleStruct<Impl::CudaTeamMember>(thread);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::CudaTeamMember> PerThread(const Impl::CudaTeamMember& thread) {
+Impl::VectorSingleStruct<Impl::CudaTeamMember> PerThread(
+    const Impl::CudaTeamMember& thread) {
   return Impl::VectorSingleStruct<Impl::CudaTeamMember>(thread);
 }
 
@@ -685,20 +678,16 @@ Impl::VectorSingleStruct<Impl::CudaTeamMember> PerThread(const Impl::CudaTeamMem
  *
  * The range [0..N) is mapped to all threads of the the calling thread team.
  */
-template<typename iType, class Closure >
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::CudaTeamMember>&
-      loop_boundaries
-  , const Closure & closure
-  )
-{
-  #ifdef __CUDA_ARCH__
-  for( iType i = loop_boundaries.start + threadIdx.y
-     ; i < loop_boundaries.end
-     ; i += blockDim.y )
+template <typename iType, class Closure>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::CudaTeamMember>&
+        loop_boundaries,
+    const Closure& closure) {
+#ifdef __CUDA_ARCH__
+  for (iType i = loop_boundaries.start + threadIdx.y; i < loop_boundaries.end;
+       i += blockDim.y)
     closure(i);
-  #endif
+#endif
 }
 
 //----------------------------------------------------------------------------
@@ -711,32 +700,26 @@ void parallel_for
  *  calling thread team and a summation of val is
  *  performed and put into result.
  */
-template< typename iType, class Closure, class ReducerType >
+template <typename iType, class Closure, class ReducerType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< Kokkos::is_reducer< ReducerType >::value >::type
-parallel_reduce
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::CudaTeamMember> &
-      loop_boundaries
-  , const Closure & closure
-  , const ReducerType & reducer
-  )
-{
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                        iType, Impl::CudaTeamMember>& loop_boundaries,
+                    const Closure& closure, const ReducerType& reducer) {
 #ifdef __CUDA_ARCH__
   typename ReducerType::value_type value;
-  reducer.init( value );
+  reducer.init(value);
 
-  for( iType i = loop_boundaries.start + threadIdx.y
-     ; i < loop_boundaries.end
-     ; i += blockDim.y ) {
-    closure(i,value);
+  for (iType i = loop_boundaries.start + threadIdx.y; i < loop_boundaries.end;
+       i += blockDim.y) {
+    closure(i, value);
   }
 
-  loop_boundaries.member.team_reduce( reducer, value );
+  loop_boundaries.member.team_reduce(reducer, value);
 
 #endif
 }
 
-
 /** \brief  Inter-thread parallel_reduce assuming summation.
  *
  *  Executes closure(iType i, ValueType & val) for each i=[0..N)
@@ -745,98 +728,79 @@ parallel_reduce
  *  calling thread team and a summation of val is
  *  performed and put into result.
  */
-template< typename iType, class Closure, typename ValueType >
+template <typename iType, class Closure, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< ! Kokkos::is_reducer< ValueType >::value >::type
-parallel_reduce
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::CudaTeamMember> &
-      loop_boundaries
-  , const Closure & closure
-  , ValueType & result
-  )
-{
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                        iType, Impl::CudaTeamMember>& loop_boundaries,
+                    const Closure& closure, ValueType& result) {
 #ifdef __CUDA_ARCH__
   ValueType val;
   Kokkos::Sum<ValueType> reducer(val);
 
-  reducer.init( reducer.reference() );
+  reducer.init(reducer.reference());
 
-  for( iType i = loop_boundaries.start + threadIdx.y
-     ; i < loop_boundaries.end
-     ; i += blockDim.y ) {
-    closure(i,val);
+  for (iType i = loop_boundaries.start + threadIdx.y; i < loop_boundaries.end;
+       i += blockDim.y) {
+    closure(i, val);
   }
 
-  loop_boundaries.member.team_reduce( reducer , val);
+  loop_boundaries.member.team_reduce(reducer, val);
   result = reducer.reference();
 #endif
 }
 
-template<typename iType, class Closure >
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( const Impl::TeamVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember>&
-      loop_boundaries
-  , const Closure & closure
-  )
-{
-  #ifdef __CUDA_ARCH__
-  for( iType i = loop_boundaries.start + threadIdx.y * blockDim.x + threadIdx.x
-     ; i < loop_boundaries.end
-     ; i += blockDim.y*blockDim.x )
+template <typename iType, class Closure>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>&
+        loop_boundaries,
+    const Closure& closure) {
+#ifdef __CUDA_ARCH__
+  for (iType i = loop_boundaries.start + threadIdx.y * blockDim.x + threadIdx.x;
+       i < loop_boundaries.end; i += blockDim.y * blockDim.x)
     closure(i);
-  #endif
+#endif
 }
 
-template< typename iType, class Closure, class ReducerType >
+template <typename iType, class Closure, class ReducerType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< Kokkos::is_reducer< ReducerType >::value >::type
-parallel_reduce
-  ( const Impl::TeamVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember> &
-      loop_boundaries
-  , const Closure & closure
-  , const ReducerType & reducer
-  )
-{
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
+                        iType, Impl::CudaTeamMember>& loop_boundaries,
+                    const Closure& closure, const ReducerType& reducer) {
 #ifdef __CUDA_ARCH__
   typename ReducerType::value_type value;
-  reducer.init( value );
+  reducer.init(value);
 
-  for( iType i = loop_boundaries.start + threadIdx.y * blockDim.x + threadIdx.x
-     ; i < loop_boundaries.end
-     ; i += blockDim.y * blockDim.x ) {
-    closure(i,value);
+  for (iType i = loop_boundaries.start + threadIdx.y * blockDim.x + threadIdx.x;
+       i < loop_boundaries.end; i += blockDim.y * blockDim.x) {
+    closure(i, value);
   }
 
-  loop_boundaries.member.vector_reduce( reducer, value );
-  loop_boundaries.member.team_reduce( reducer, value );
+  loop_boundaries.member.vector_reduce(reducer, value);
+  loop_boundaries.member.team_reduce(reducer, value);
 #endif
 }
 
-template< typename iType, class Closure, typename ValueType >
+template <typename iType, class Closure, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< ! Kokkos::is_reducer< ValueType >::value >::type
-parallel_reduce
-  ( const Impl::TeamVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember> &
-      loop_boundaries
-  , const Closure & closure
-  , ValueType & result
-  )
-{
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
+                        iType, Impl::CudaTeamMember>& loop_boundaries,
+                    const Closure& closure, ValueType& result) {
 #ifdef __CUDA_ARCH__
   ValueType val;
   Kokkos::Sum<ValueType> reducer(val);
 
-  reducer.init( reducer.reference() );
+  reducer.init(reducer.reference());
 
-  for( iType i = loop_boundaries.start + threadIdx.y * blockDim.x + threadIdx.x
-     ; i < loop_boundaries.end
-     ; i += blockDim.y * blockDim.x ) {
-    closure(i,val);
+  for (iType i = loop_boundaries.start + threadIdx.y * blockDim.x + threadIdx.x;
+       i < loop_boundaries.end; i += blockDim.y * blockDim.x) {
+    closure(i, val);
   }
 
-  loop_boundaries.member.vector_reduce( reducer );
-  loop_boundaries.member.team_reduce( reducer );
+  loop_boundaries.member.vector_reduce(reducer);
+  loop_boundaries.member.team_reduce(reducer);
   result = reducer.reference();
 #endif
 }
@@ -849,25 +813,24 @@ parallel_reduce
  *
  * The range [0..N) is mapped to all vector lanes of the the calling thread.
  */
-template<typename iType, class Closure >
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember>&
-    loop_boundaries
-  , const Closure & closure
-  )
-{
+template <typename iType, class Closure>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>&
+        loop_boundaries,
+    const Closure& closure) {
 #ifdef __CUDA_ARCH__
-  for ( iType i = loop_boundaries.start + threadIdx.x
-      ; i < loop_boundaries.end
-      ; i += blockDim.x ) {
+  for (iType i = loop_boundaries.start + threadIdx.x; i < loop_boundaries.end;
+       i += blockDim.x) {
     closure(i);
   }
-  #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  KOKKOS_IMPL_CUDA_SYNCWARP_MASK(blockDim.x==32?0xffffffff:((1<<blockDim.x)-1)<<(threadIdx.y%(32/blockDim.x))*blockDim.x);
-  #else
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+  KOKKOS_IMPL_CUDA_SYNCWARP_MASK(
+      blockDim.x == 32 ? 0xffffffff
+                       : ((1 << blockDim.x) - 1)
+                             << (threadIdx.y % (32 / blockDim.x)) * blockDim.x);
+#else
   KOKKOS_IMPL_CUDA_SYNCWARP;
-  #endif
+#endif
 #endif
 }
 
@@ -884,26 +847,22 @@ void parallel_for
  *  The identity value for the += operator is assumed to be the default
  *  constructed value.
  */
-template< typename iType, class Closure, class ReducerType >
+template <typename iType, class Closure, class ReducerType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< is_reducer< ReducerType >::value >::type
-parallel_reduce
-  ( Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember>
-      const & loop_boundaries
-  , Closure const & closure
-  , ReducerType const & reducer )
-{
+    typename std::enable_if<is_reducer<ReducerType>::value>::type
+    parallel_reduce(Impl::ThreadVectorRangeBoundariesStruct<
+                        iType, Impl::CudaTeamMember> const& loop_boundaries,
+                    Closure const& closure, ReducerType const& reducer) {
 #ifdef __CUDA_ARCH__
 
-  reducer.init( reducer.reference() );
+  reducer.init(reducer.reference());
 
-  for ( iType i = loop_boundaries.start + threadIdx.x
-      ; i < loop_boundaries.end
-      ; i += blockDim.x ) {
-    closure(i,reducer.reference());
+  for (iType i = loop_boundaries.start + threadIdx.x; i < loop_boundaries.end;
+       i += blockDim.x) {
+    closure(i, reducer.reference());
   }
 
-  Impl::CudaTeamMember::vector_reduce( reducer );
+  Impl::CudaTeamMember::vector_reduce(reducer);
 
 #endif
 }
@@ -919,26 +878,21 @@ parallel_reduce
  *  The identity value for the += operator is assumed to be the default
  *  constructed value.
  */
-template< typename iType, class Closure, typename ValueType >
+template <typename iType, class Closure, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< ! is_reducer< ValueType >::value >::type
-parallel_reduce
-  ( Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember>
-      const & loop_boundaries
-  , Closure const & closure
-  , ValueType & result )
-{
+    typename std::enable_if<!is_reducer<ValueType>::value>::type
+    parallel_reduce(Impl::ThreadVectorRangeBoundariesStruct<
+                        iType, Impl::CudaTeamMember> const& loop_boundaries,
+                    Closure const& closure, ValueType& result) {
 #ifdef __CUDA_ARCH__
   result = ValueType();
 
-  for ( iType i = loop_boundaries.start + threadIdx.x
-      ; i < loop_boundaries.end
-      ; i += blockDim.x ) {
-    closure(i,result);
+  for (iType i = loop_boundaries.start + threadIdx.x; i < loop_boundaries.end;
+       i += blockDim.x) {
+    closure(i, result);
   }
 
-  Impl::CudaTeamMember::vector_reduce(
-    Kokkos::Sum<ValueType>(result ) );
+  Impl::CudaTeamMember::vector_reduce(Kokkos::Sum<ValueType>(result));
 
 #endif
 }
@@ -953,29 +907,22 @@ parallel_reduce
  *  thread and a scan operation is performed.
  *  The last call to closure has final == true.
  */
-template< typename iType, class Closure >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan
-  ( const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::CudaTeamMember >&
-      loop_boundaries
-  , const Closure & closure
-  )
-{
-
+template <typename iType, class Closure>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>&
+        loop_boundaries,
+    const Closure& closure) {
 #ifdef __CUDA_ARCH__
 
   // Extract value_type from closure
 
-  using value_type =
-    typename Kokkos::Impl::FunctorAnalysis
-      < Kokkos::Impl::FunctorPatternInterface::SCAN
-      , void
-      , Closure >::value_type ;
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
 
   // Loop through boundaries by vector-length chunks
   // must scan at each iteration
 
-  value_type accum = 0 ;
+  value_type accum = 0;
 
   // All thread "lanes" must loop the same number of times.
   // Determine an loop end for all thread "lanes."
@@ -984,19 +931,21 @@ void parallel_scan
   //     ( end % blockDim.x ) == ( end & ( blockDim.x - 1 ) )
   //   1 <= blockDim.x <= CudaTraits::WarpSize
 
-  const int mask = blockDim.x - 1 ;
-  const unsigned active_mask = blockDim.x==32?0xffffffff:((1<<blockDim.x)-1)<<(threadIdx.y%(32/blockDim.x))*blockDim.x;
-  const int rem  = loop_boundaries.end & mask ; // == end % blockDim.x
-  const int end  = loop_boundaries.end + ( rem ? blockDim.x - rem : 0 );
+  const int mask = blockDim.x - 1;
+  const unsigned active_mask =
+      blockDim.x == 32 ? 0xffffffff
+                       : ((1 << blockDim.x) - 1)
+                             << (threadIdx.y % (32 / blockDim.x)) * blockDim.x;
+  const int rem = loop_boundaries.end & mask;  // == end % blockDim.x
+  const int end = loop_boundaries.end + (rem ? blockDim.x - rem : 0);
 
-  for ( int i = threadIdx.x ; i < end ; i += blockDim.x ) {
-
-    value_type val = 0 ;
+  for (int i = threadIdx.x; i < end; i += blockDim.x) {
+    value_type val = 0;
 
     // First acquire per-lane contributions:
-    if ( i < loop_boundaries.end ) closure( i , val , false );
+    if (i < loop_boundaries.end) closure(i, val, false);
 
-    value_type sval = val ;
+    value_type sval = val;
 
     // Bottom up inclusive scan in triangular pattern
     // where each CUDA thread is the root of a reduction tree
@@ -1006,81 +955,95 @@ void parallel_scan
     //  [t] += [t-4] if t >= 4
     //  ...
 
-    for ( int j = 1 ; j < (int)blockDim.x ; j <<= 1 ) {
-      value_type tmp = 0 ;
-      Impl::cuda_shfl_up(tmp, sval , j , blockDim.x, active_mask );
-      if ( j <= (int)threadIdx.x ) { sval += tmp ; }
+    for (int j = 1; j < (int)blockDim.x; j <<= 1) {
+      value_type tmp = 0;
+      Impl::in_place_shfl_up(tmp, sval, j, blockDim.x, active_mask);
+      if (j <= (int)threadIdx.x) {
+        sval += tmp;
+      }
     }
 
     // Include accumulation and remove value for exclusive scan:
-    val = accum + sval - val ;
+    val = accum + sval - val;
 
     // Provide exclusive scan value:
-    if ( i < loop_boundaries.end ) closure( i , val , true );
+    if (i < loop_boundaries.end) closure(i, val, true);
 
     // Accumulate the last value in the inclusive scan:
-    Impl::cuda_shfl( sval , sval , mask , blockDim.x, active_mask );
+    Impl::in_place_shfl(sval, sval, mask, blockDim.x, active_mask);
 
-    accum += sval ;
+    accum += sval;
   }
 
 #endif
 }
 
-}
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::CudaTeamMember>& , const FunctorType& lambda) {
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::CudaTeamMember>&,
+    const FunctorType& lambda) {
 #ifdef __CUDA_ARCH__
-  if(threadIdx.x == 0) lambda();
-  #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  KOKKOS_IMPL_CUDA_SYNCWARP_MASK(blockDim.x==32?0xffffffff:((1<<blockDim.x)-1)<<(threadIdx.y%(32/blockDim.x))*blockDim.x);
-  #else
+  if (threadIdx.x == 0) lambda();
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+  KOKKOS_IMPL_CUDA_SYNCWARP_MASK(
+      blockDim.x == 32 ? 0xffffffff
+                       : ((1 << blockDim.x) - 1)
+                             << (threadIdx.y % (32 / blockDim.x)) * blockDim.x);
+#else
   KOKKOS_IMPL_CUDA_SYNCWARP;
-  #endif
+#endif
 #endif
 }
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::CudaTeamMember>& , const FunctorType& lambda) {
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::CudaTeamMember>&,
+    const FunctorType& lambda) {
 #ifdef __CUDA_ARCH__
-  if(threadIdx.x == 0 && threadIdx.y == 0) lambda();
-  #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  KOKKOS_IMPL_CUDA_SYNCWARP_MASK(blockDim.x==32?0xffffffff:((1<<blockDim.x)-1)<<(threadIdx.y%(32/blockDim.x))*blockDim.x);
-  #else
+  if (threadIdx.x == 0 && threadIdx.y == 0) lambda();
+#ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+  KOKKOS_IMPL_CUDA_SYNCWARP_MASK(
+      blockDim.x == 32 ? 0xffffffff
+                       : ((1 << blockDim.x) - 1)
+                             << (threadIdx.y % (32 / blockDim.x)) * blockDim.x);
+#else
   KOKKOS_IMPL_CUDA_SYNCWARP;
-  #endif
+#endif
 #endif
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::CudaTeamMember>& , const FunctorType& lambda, ValueType& val) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::CudaTeamMember>&,
+    const FunctorType& lambda, ValueType& val) {
 #ifdef __CUDA_ARCH__
-  if(threadIdx.x == 0) lambda(val);
-  unsigned mask = blockDim.x==32?0xffffffff:((1<<blockDim.x)-1)<<((threadIdx.y%(32/blockDim.x))*blockDim.x);
-  Impl::cuda_shfl(val,val,0,blockDim.x,mask);
+  if (threadIdx.x == 0) lambda(val);
+  unsigned mask = blockDim.x == 32
+                      ? 0xffffffff
+                      : ((1 << blockDim.x) - 1)
+                            << ((threadIdx.y % (32 / blockDim.x)) * blockDim.x);
+  Impl::in_place_shfl(val, val, 0, blockDim.x, mask);
 #endif
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::CudaTeamMember>& single_struct, const FunctorType& lambda, ValueType& val) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::CudaTeamMember>& single_struct,
+    const FunctorType& lambda, ValueType& val) {
 #ifdef __CUDA_ARCH__
-  if(threadIdx.x == 0 && threadIdx.y == 0) {
+  if (threadIdx.x == 0 && threadIdx.y == 0) {
     lambda(val);
   }
-  single_struct.team_member.team_broadcast(val,0);
+  single_struct.team_member.team_broadcast(val, 0);
 #endif
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif /* defined( __CUDACC__ ) */
 
 #endif /* #ifndef KOKKOS_CUDA_TEAM_HPP */
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
index c4140750da38281f3934846629b996a4e5879c50..a0de4eaa7f429f0cc28dce861fd1316c9063ee84 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,92 +53,79 @@
 #include <impl/Kokkos_SharedAlloc.hpp>
 #include <impl/Kokkos_ConcurrentBitset.hpp>
 
-namespace Kokkos { namespace Experimental {
+namespace Kokkos {
+namespace Experimental {
 
 // both global and instance Unique Tokens are implemented in the same way
-template<>
-class UniqueToken< Cuda, UniqueTokenScope::Global >
-{
-private:
-
-  uint32_t volatile * m_buffer ;
-  uint32_t            m_count ;
-
-public:
+template <>
+class UniqueToken<Cuda, UniqueTokenScope::Global> {
+ private:
+  uint32_t volatile* m_buffer;
+  uint32_t m_count;
 
+ public:
   using execution_space = Cuda;
-  using size_type = int32_t;
+  using size_type       = int32_t;
 
-#if defined( KOKKOS_ENABLE_DEPRECATED_CODE )
-  explicit
-  UniqueToken( execution_space const& );
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE)
+  explicit UniqueToken(execution_space const&);
 
   KOKKOS_INLINE_FUNCTION
   UniqueToken() : m_buffer(0), m_count(0) {}
 #else
-  explicit
-  UniqueToken( execution_space const& = execution_space() );
+  explicit UniqueToken(execution_space const& = execution_space());
 #endif
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
   KOKKOS_INLINE_FUNCTION
-  UniqueToken( const UniqueToken & rhs )
-  : m_buffer(rhs.m_buffer)
-  , m_count(rhs.m_count)
-  {
-  }
+  UniqueToken(const UniqueToken& rhs)
+      : m_buffer(rhs.m_buffer), m_count(rhs.m_count) {}
 
   KOKKOS_INLINE_FUNCTION
-  UniqueToken( UniqueToken && rhs )
-  : m_buffer(std::move(rhs.m_buffer))
-  , m_count(std::move(rhs.m_count))
-  {
-  }
+  UniqueToken(UniqueToken&& rhs)
+      : m_buffer(std::move(rhs.m_buffer)), m_count(std::move(rhs.m_count)) {}
 
   KOKKOS_INLINE_FUNCTION
-  UniqueToken & operator=( const UniqueToken & rhs ) {
+  UniqueToken& operator=(const UniqueToken& rhs) {
     m_buffer = rhs.m_buffer;
-    m_count = rhs.m_count;
+    m_count  = rhs.m_count;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  UniqueToken & operator=( UniqueToken && rhs ) {
+  UniqueToken& operator=(UniqueToken&& rhs) {
     m_buffer = std::move(rhs.m_buffer);
-    m_count = std::move(rhs.m_count);
+    m_count  = std::move(rhs.m_count);
     return *this;
   }
 #else
   KOKKOS_INLINE_FUNCTION
-  UniqueToken( const UniqueToken & ) = default;
+  UniqueToken(const UniqueToken&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  UniqueToken( UniqueToken && )      = default;
+  UniqueToken(UniqueToken&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  UniqueToken & operator=( const UniqueToken & ) = default ;
+  UniqueToken& operator=(const UniqueToken&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  UniqueToken & operator=( UniqueToken && ) = default ;
+  UniqueToken& operator=(UniqueToken&&) = default;
 #endif
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  size_type size() const noexcept { return m_count ; }
+  size_type size() const noexcept { return m_count; }
 
   /// \brief acquire value such that 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  size_type acquire() const
-  {
-    const Kokkos::pair<int,int> result =
-      Kokkos::Impl::concurrent_bitset::
-        acquire_bounded( m_buffer
-                       , m_count
-                       , Kokkos::Impl::clock_tic() % m_count
-                       );
-
-    if ( result.first < 0 ) {
-      Kokkos::abort("UniqueToken<Cuda> failure to release tokens, no tokens available" );
+  size_type acquire() const {
+    const Kokkos::pair<int, int> result =
+        Kokkos::Impl::concurrent_bitset::acquire_bounded(
+            m_buffer, m_count, Kokkos::Impl::clock_tic() % m_count);
+
+    if (result.first < 0) {
+      Kokkos::abort(
+          "UniqueToken<Cuda> failure to release tokens, no tokens available");
     }
 
     return result.first;
@@ -145,31 +133,26 @@ public:
 
   /// \brief release an acquired value
   KOKKOS_INLINE_FUNCTION
-  void release( size_type i ) const noexcept
-  {
-    Kokkos::Impl::concurrent_bitset::release( m_buffer, i );
+  void release(size_type i) const noexcept {
+    Kokkos::Impl::concurrent_bitset::release(m_buffer, i);
   }
 };
 
-template<>
-class UniqueToken< Cuda, UniqueTokenScope::Instance >
-  : public UniqueToken< Cuda, UniqueTokenScope::Global >
-{
-public:
-
+template <>
+class UniqueToken<Cuda, UniqueTokenScope::Instance>
+    : public UniqueToken<Cuda, UniqueTokenScope::Global> {
+ public:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  explicit
-  UniqueToken( execution_space const& arg )
-    : UniqueToken< Cuda, UniqueTokenScope::Global >( arg ) {}
+  explicit UniqueToken(execution_space const& arg)
+      : UniqueToken<Cuda, UniqueTokenScope::Global>(arg) {}
 #else
-  explicit
-  UniqueToken( execution_space const& arg = execution_space() )
-    : UniqueToken< Cuda, UniqueTokenScope::Global >( arg ) {}
+  explicit UniqueToken(execution_space const& arg = execution_space())
+      : UniqueToken<Cuda, UniqueTokenScope::Global>(arg) {}
 #endif
 };
 
-}} // namespace Kokkos::Experimental
-
-#endif // KOKKOS_ENABLE_CUDA
-#endif // KOKKOS_CUDA_UNIQUE_TOKEN_HPP
+}  // namespace Experimental
+}  // namespace Kokkos
 
+#endif  // KOKKOS_ENABLE_CUDA
+#endif  // KOKKOS_CUDA_UNIQUE_TOKEN_HPP
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Vectorization.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Vectorization.hpp
index fc369191bd73bea0892e2b4070fadd89bd3fdb3c..085262b8040660bd84ad7720da142354cce7148a 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Vectorization.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Vectorization.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,342 +49,163 @@
 
 #include <Kokkos_Cuda.hpp>
 #include <Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
-namespace Kokkos {
 
+namespace Kokkos {
 
-// Shuffle only makes sense on >= Kepler GPUs; it doesn't work on CPUs
-// or other GPUs.  We provide a generic definition (which is trivial
-// and doesn't do what it claims to do) because we don't actually use
-// this function unless we are on a suitable GPU, with a suitable
-// Scalar type.  (For example, in the mat-vec, the "ThreadsPerRow"
-// internal parameter depends both on the ExecutionSpace and the Scalar type,
-// and it controls whether shfl_down() gets called.)
 namespace Impl {
 
-  template< typename Scalar >
-  struct shfl_union {
-    enum {n = sizeof(Scalar)/4};
-    float fval[n];
-    KOKKOS_INLINE_FUNCTION
-    Scalar value() {
-      return *(Scalar*) fval;
-    }
-    KOKKOS_INLINE_FUNCTION
-    void operator= (Scalar& value_) {
-      float* const val_ptr = (float*) &value_;
-      for(int i=0; i<n ; i++) {
-        fval[i] = val_ptr[i];
-      }
-    }
-    KOKKOS_INLINE_FUNCTION
-    void operator= (const Scalar& value_) {
-      float* const val_ptr = (float*) &value_;
-      for(int i=0; i<n ; i++) {
-        fval[i] = val_ptr[i];
-      }
-    }
-
-  };
+// Include all lanes
+constexpr unsigned shfl_all_mask = 0xffffffff;
+
+//----------------------------------------------------------------------------
+// Shuffle operations require input to be a register (stack) variable
+
+// Derived implements do_shfl_op(unsigned mask, T& in, int lane, int width),
+// which turns in to one of KOKKOS_IMPL_CUDA_SHFL(_UP_|_DOWN_|_)MASK
+// Since the logic with respect to value sizes, etc., is the same everywhere,
+// put it all in one place.
+template <class Derived>
+struct in_place_shfl_op {
+  // CRTP boilerplate
+  __device__ KOKKOS_IMPL_FORCEINLINE const Derived& self() const noexcept {
+    return *static_cast<Derived const*>(this);
+  }
+
+  // sizeof(Scalar) == sizeof(int) case
+  template <class Scalar>
+  // requires _assignable_from_bits<Scalar>
+  __device__ inline typename std::enable_if<sizeof(Scalar) == sizeof(int)>::type
+  operator()(Scalar& out, Scalar const& in, int lane_or_delta, int width,
+             unsigned mask = shfl_all_mask) const noexcept {
+    //------------------------------------------------
+    reinterpret_cast<int&>(out) = self().do_shfl_op(
+        mask, reinterpret_cast<int const&>(in), lane_or_delta, width);
+    //------------------------------------------------
+  }
+
+// TODO: figure out why 64-bit shfl fails in Clang
+#if (CUDA_VERSION >= 9000) && (!defined(KOKKOS_COMPILER_CLANG))
+  // sizeof(Scalar) == sizeof(double) case
+  // requires _assignable_from_bits<Scalar>
+  template <class Scalar>
+  __device__ inline
+      typename std::enable_if<sizeof(Scalar) == sizeof(double)>::type
+      operator()(Scalar& out, Scalar const& in, int lane_or_delta, int width,
+                 unsigned mask = shfl_all_mask) const noexcept {
+    //------------------------------------------------
+    reinterpret_cast<double&>(out) = self().do_shfl_op(
+        mask, *reinterpret_cast<double const*>(&in), lane_or_delta, width);
+    //------------------------------------------------
+  }
+#else
+  // sizeof(Scalar) == sizeof(double) case
+  // requires _assignable_from_bits<Scalar>
+  template <typename Scalar>
+  __device__ inline
+      typename std::enable_if<sizeof(Scalar) == sizeof(double)>::type
+      operator()(Scalar& out, const Scalar& val, int lane_or_delta, int width,
+                 unsigned mask = shfl_all_mask) const noexcept {
+    //------------------------------------------------
+    int lo   = __double2loint(*reinterpret_cast<const double*>(&val));
+    int hi   = __double2hiint(*reinterpret_cast<const double*>(&val));
+    lo       = self().do_shfl_op(mask, lo, lane_or_delta, width);
+    hi       = self().do_shfl_op(mask, hi, lane_or_delta, width);
+    auto tmp = __hiloint2double(hi, lo);
+    out      = reinterpret_cast<Scalar&>(tmp);
+    //------------------------------------------------
+  }
+#endif
+
+  // sizeof(Scalar) > sizeof(double) case
+  template <typename Scalar>
+  __device__ inline
+      typename std::enable_if<(sizeof(Scalar) > sizeof(double))>::type
+      operator()(Scalar& out, const Scalar& val, int lane_or_delta, int width,
+                 unsigned mask = shfl_all_mask) const noexcept {
+    // TODO DSH shouldn't this be KOKKOS_IMPL_CUDA_MAX_SHFL_SIZEOF instead of
+    //      sizeof(int)? (Need benchmarks to decide which is faster)
+    using shuffle_as_t = int;
+    enum : int { N = sizeof(Scalar) / sizeof(shuffle_as_t) };
+
+    for (int i = 0; i < N; ++i) {
+      reinterpret_cast<shuffle_as_t*>(&out)[i] = self().do_shfl_op(
+          mask, reinterpret_cast<shuffle_as_t const*>(&val)[i], lane_or_delta,
+          width);
+    }
+  }
+};
+
+struct in_place_shfl_fn : in_place_shfl_op<in_place_shfl_fn> {
+  template <class T>
+  __device__ KOKKOS_IMPL_FORCEINLINE T do_shfl_op(unsigned mask, T& val,
+                                                  int lane, int width) const
+      noexcept {
+    return KOKKOS_IMPL_CUDA_SHFL_MASK(mask, val, lane, width);
+  }
+};
+template <class... Args>
+__device__ KOKKOS_IMPL_FORCEINLINE void in_place_shfl(Args&&... args) noexcept {
+  in_place_shfl_fn{}((Args &&) args...);
 }
 
-#ifdef __CUDA_ARCH__
-#if (__CUDA_ARCH__ >= 300)
-
-    KOKKOS_INLINE_FUNCTION
-    int shfl(const int &val, const int& srcLane, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL(val,srcLane,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    float shfl(const float &val, const int& srcLane, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL(val,srcLane,width);
-    }
-
-// TODO: figure out why 64-bit shfl fails with Clang
-#if ( CUDA_VERSION >= 9000 ) && (!defined(KOKKOS_COMPILER_CLANG))
-
-    KOKKOS_INLINE_FUNCTION
-    long shfl(const long &val, const int& srcLane, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL(val,srcLane,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    long long shfl(const long long &val, const int& srcLane, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL(val,srcLane,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    double shfl(const double &val, const int& srcLane, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL(val,srcLane,width);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const typename Impl::enable_if< (sizeof(Scalar) == 8) , int >::type& width
-        ) {
-      Scalar tmp1 = val;
-      double tmp = *reinterpret_cast<double*>(&tmp1);
-      tmp = KOKKOS_IMPL_CUDA_SHFL(tmp,srcLane,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
-
-#else // ( CUDA_VERSION < 9000 )
-
-    KOKKOS_INLINE_FUNCTION
-    double shfl(const double &val, const int& srcLane, const int& width) {
-      int lo = __double2loint(val);
-      int hi = __double2hiint(val);
-      lo = KOKKOS_IMPL_CUDA_SHFL(lo,srcLane,width);
-      hi = KOKKOS_IMPL_CUDA_SHFL(hi,srcLane,width);
-      return __hiloint2double(hi,lo);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const typename Impl::enable_if< (sizeof(Scalar) == 8) ,int>::type& width) {
-      int lo = __double2loint(*reinterpret_cast<const double*>(&val));
-      int hi = __double2hiint(*reinterpret_cast<const double*>(&val));
-      lo = KOKKOS_IMPL_CUDA_SHFL(lo,srcLane,width);
-      hi = KOKKOS_IMPL_CUDA_SHFL(hi,srcLane,width);
-      const double tmp = __hiloint2double(hi,lo);
-      return *(reinterpret_cast<const Scalar*>(&tmp));
-    }
-
-#endif // ( CUDA_VERSION < 9000 )
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const typename Impl::enable_if< (sizeof(Scalar) == 4) , int >::type& width
-        ) {
-      Scalar tmp1 = val;
-      float tmp = *reinterpret_cast<float*>(&tmp1);
-      tmp = KOKKOS_IMPL_CUDA_SHFL(tmp,srcLane,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const typename Impl::enable_if< (sizeof(Scalar) > 8) ,int>::type& width) {
-      Impl::shfl_union<Scalar> s_val;
-      Impl::shfl_union<Scalar> r_val;
-      s_val = val;
-
-      for(int i = 0; i<s_val.n; i++)
-        r_val.fval[i] = KOKKOS_IMPL_CUDA_SHFL(s_val.fval[i],srcLane,width);
-      return r_val.value();
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    int shfl_down(const int &val, const int& delta, const int& width) {
-      return KOKKOS_IMPL_CUDA_SHFL_DOWN(val,delta,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    float shfl_down(const float &val, const int& delta, const int& width) {
-      return KOKKOS_IMPL_CUDA_SHFL_DOWN(val,delta,width);
-    }
-
-// TODO: figure out why 64-bit shfl fails with Clang
-#if ( CUDA_VERSION >= 9000 ) && (!defined(KOKKOS_COMPILER_CLANG))
-
-    KOKKOS_INLINE_FUNCTION
-    long shfl_down(const long &val, const int& delta, const int& width) {
-      return KOKKOS_IMPL_CUDA_SHFL_DOWN(val,delta,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    long long shfl_down(const long long &val, const int& delta, const int& width) {
-      return KOKKOS_IMPL_CUDA_SHFL_DOWN(val,delta,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    double shfl_down(const double &val, const int& delta, const int& width) {
-      return KOKKOS_IMPL_CUDA_SHFL_DOWN(val,delta,width);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 8) , int >::type & width) {
-      Scalar tmp1 = val;
-      double tmp = *reinterpret_cast<double*>(&tmp1);
-      tmp = KOKKOS_IMPL_CUDA_SHFL_DOWN(tmp,delta,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
-
-#else // ( CUDA_VERSION < 9000 )
-
-    KOKKOS_INLINE_FUNCTION
-    double shfl_down(const double &val, const int& delta, const int& width) {
-      int lo = __double2loint(val);
-      int hi = __double2hiint(val);
-      lo = KOKKOS_IMPL_CUDA_SHFL_DOWN(lo,delta,width);
-      hi = KOKKOS_IMPL_CUDA_SHFL_DOWN(hi,delta,width);
-      return __hiloint2double(hi,lo);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 8) , int >::type & width) {
-      int lo = __double2loint(*reinterpret_cast<const double*>(&val));
-      int hi = __double2hiint(*reinterpret_cast<const double*>(&val));
-      lo = KOKKOS_IMPL_CUDA_SHFL_DOWN(lo,delta,width);
-      hi = KOKKOS_IMPL_CUDA_SHFL_DOWN(hi,delta,width);
-      const double tmp = __hiloint2double(hi,lo);
-      return *(reinterpret_cast<const Scalar*>(&tmp));
-    }
-
-#endif // ( CUDA_VERSION < 9000 )
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 4) , int >::type & width) {
-      Scalar tmp1 = val;
-      float tmp = *reinterpret_cast<float*>(&tmp1);
-      tmp = KOKKOS_IMPL_CUDA_SHFL_DOWN(tmp,delta,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) > 8) , int >::type & width) {
-      Impl::shfl_union<Scalar> s_val;
-      Impl::shfl_union<Scalar> r_val;
-      s_val = val;
-
-      for(int i = 0; i<s_val.n; i++)
-        r_val.fval[i] = KOKKOS_IMPL_CUDA_SHFL_DOWN(s_val.fval[i],delta,width);
-      return r_val.value();
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    int shfl_up(const int &val, const int& delta, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL_UP(val,delta,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    float shfl_up(const float &val, const int& delta, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL_UP(val,delta,width);
-    }
-
-// TODO: figure out why 64-bit shfl fails with Clang
-#if ( CUDA_VERSION >= 9000 ) && (!defined(KOKKOS_COMPILER_CLANG))
-
-    KOKKOS_INLINE_FUNCTION
-    long shfl_up(const long &val, const int& delta, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL_UP(val,delta,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    long long shfl_up(const long long &val, const int& delta, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL_UP(val,delta,width);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    double shfl_up(const double &val, const int& delta, const int& width ) {
-      return KOKKOS_IMPL_CUDA_SHFL_UP(val,delta,width);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 8) , int >::type & width) {
-      Scalar tmp1 = val;
-      double tmp = *reinterpret_cast<double*>(&tmp1);
-      tmp = KOKKOS_IMPL_CUDA_SHFL_UP(tmp,delta,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
-
-#else // ( CUDA_VERSION < 9000 )
-
-    KOKKOS_INLINE_FUNCTION
-    double shfl_up(const double &val, const int& delta, const int& width ) {
-      int lo = __double2loint(val);
-      int hi = __double2hiint(val);
-      lo = KOKKOS_IMPL_CUDA_SHFL_UP(lo,delta,width);
-      hi = KOKKOS_IMPL_CUDA_SHFL_UP(hi,delta,width);
-      return __hiloint2double(hi,lo);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 8) , int >::type & width) {
-      int lo = __double2loint(*reinterpret_cast<const double*>(&val));
-      int hi = __double2hiint(*reinterpret_cast<const double*>(&val));
-      lo = KOKKOS_IMPL_CUDA_SHFL_UP(lo,delta,width);
-      hi = KOKKOS_IMPL_CUDA_SHFL_UP(hi,delta,width);
-      const double tmp = __hiloint2double(hi,lo);
-      return *(reinterpret_cast<const Scalar*>(&tmp));
-    }
-
-#endif // ( CUDA_VERSION < 9000 )
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 4) , int >::type & width) {
-      Scalar tmp1 = val;
-      float tmp = *reinterpret_cast<float*>(&tmp1);
-      tmp = KOKKOS_IMPL_CUDA_SHFL_UP(tmp,delta,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
-
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) > 8) , int >::type & width) {
-      Impl::shfl_union<Scalar> s_val;
-      Impl::shfl_union<Scalar> r_val;
-      s_val = val;
-
-      for(int i = 0; i<s_val.n; i++)
-        r_val.fval[i] = KOKKOS_IMPL_CUDA_SHFL_UP(s_val.fval[i],delta,width);
-      return r_val.value();
-    }
-
-#else // (__CUDA_ARCH__ < 300)
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl from a device with CC<3.0.");
-      return val;
-    }
+struct in_place_shfl_up_fn : in_place_shfl_op<in_place_shfl_up_fn> {
+  template <class T>
+  __device__ KOKKOS_IMPL_FORCEINLINE T do_shfl_op(unsigned mask, T& val,
+                                                  int lane, int width) const
+      noexcept {
+    return KOKKOS_IMPL_CUDA_SHFL_UP_MASK(mask, val, lane, width);
+  }
+};
+template <class... Args>
+__device__ KOKKOS_IMPL_FORCEINLINE void in_place_shfl_up(
+    Args&&... args) noexcept {
+  in_place_shfl_up_fn{}((Args &&) args...);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl_down from a device with CC<3.0.");
-      return val;
-    }
+struct in_place_shfl_down_fn : in_place_shfl_op<in_place_shfl_down_fn> {
+  template <class T>
+  __device__ KOKKOS_IMPL_FORCEINLINE T do_shfl_op(unsigned mask, T& val,
+                                                  int lane, int width) const
+      noexcept {
+    return KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK(mask, val, lane, width);
+  }
+};
+template <class... Args>
+__device__ KOKKOS_IMPL_FORCEINLINE void in_place_shfl_down(
+    Args&&... args) noexcept {
+  in_place_shfl_down_fn{}((Args &&) args...);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl_down from a device with CC<3.0.");
-      return val;
-    }
-#endif // (__CUDA_ARCH__ < 300)
-#else // !defined( __CUDA_ARCH__ )
-    template<typename Scalar>
-    inline
-    Scalar shfl(const Scalar &val, const int& srcLane, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl outside __CUDA_ARCH__.");
-      return val;
-    }
+}  // namespace Impl
 
-    template<typename Scalar>
-    inline
-    Scalar shfl_down(const Scalar &val, const int& delta, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl_down outside __CUDA_ARCH__.");
-      return val;
-    }
+template <class T>
+// requires default_constructible<T> && _assignable_from_bits<T>
+__device__ inline T shfl(const T& val, const int& srcLane, const int& width,
+                         unsigned mask = Impl::shfl_all_mask) {
+  T rv = {};
+  Impl::in_place_shfl(rv, val, srcLane, width, mask);
+  return rv;
+}
 
-    template<typename Scalar>
-    inline
-    Scalar shfl_up(const Scalar &val, const int& delta, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl_down outside __CUDA_ARCH__.");
-      return val;
-    }
-#endif // !defined( __CUDA_ARCH__ )
+template <class T>
+// requires default_constructible<T> && _assignable_from_bits<T>
+__device__ inline T shfl_down(const T& val, int delta, int width,
+                              unsigned mask = Impl::shfl_all_mask) {
+  T rv = {};
+  Impl::in_place_shfl_down(rv, val, delta, width, mask);
+  return rv;
+}
 
-} // end namespace Kokkos
+template <class T>
+// requires default_constructible<T> && _assignable_from_bits<T>
+__device__ inline T shfl_up(const T& val, int delta, int width,
+                            unsigned mask = Impl::shfl_all_mask) {
+  T rv = {};
+  Impl::in_place_shfl_up(rv, val, delta, width, mask);
+  return rv;
+}
 
-#endif // defined( KOKKOS_ENABLE_CUDA )
-#endif // !defined( KOKKOS_CUDA_VECTORIZATION_HPP )
+}  // end namespace Kokkos
 
+#endif  // defined( KOKKOS_ENABLE_CUDA )
+#endif  // !defined( KOKKOS_CUDA_VECTORIZATION_HPP )
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp
index 8aa8b8f459f4281f296dd202e564346617a61da2..66231e55f9c0dd55956c34f77519ce8a5fddb501 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp
@@ -1,86 +1,77 @@
-#include<Kokkos_Macros.hpp>
+#include <Kokkos_Macros.hpp>
 
-#if defined( __CUDA_ARCH__ )
-#if ( CUDA_VERSION < 9000 )
+#if defined(__CUDA_ARCH__)
+#if (CUDA_VERSION < 9000)
 #define KOKKOS_IMPL_CUDA_ACTIVEMASK 0
 #define KOKKOS_IMPL_CUDA_SYNCWARP __threadfence_block()
-#define KOKKOS_IMPL_CUDA_SYNCWARP_MASK(m) if(m)__threadfence_block()
+#define KOKKOS_IMPL_CUDA_SYNCWARP_MASK(m) \
+  if (m) __threadfence_block()
 #define KOKKOS_IMPL_CUDA_BALLOT(x) __ballot(x)
-#define KOKKOS_IMPL_CUDA_BALLOT_MASK(m,x) __ballot(x)
-#define KOKKOS_IMPL_CUDA_SHFL(x,y,z) __shfl(x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_MASK(m,x,y,z) __shfl(x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_UP(x,y,z) __shfl_up(x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_UP_MASK(m,x,y,z) __shfl_up(x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_DOWN(x,y,z) __shfl_down(x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK(m,x,y,z) __shfl_down(x,y,z)
+#define KOKKOS_IMPL_CUDA_BALLOT_MASK(m, x) __ballot(x)
+#define KOKKOS_IMPL_CUDA_SHFL(x, y, z) __shfl(x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_MASK(m, x, y, z) __shfl(x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_UP(x, y, z) __shfl_up(x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_UP_MASK(m, x, y, z) __shfl_up(x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_DOWN(x, y, z) __shfl_down(x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK(m, x, y, z) __shfl_down(x, y, z)
 #else
 #define KOKKOS_IMPL_CUDA_ACTIVEMASK __activemask()
 #define KOKKOS_IMPL_CUDA_SYNCWARP __syncwarp(0xffffffff)
 #define KOKKOS_IMPL_CUDA_SYNCWARP_MASK(m) __syncwarp(m)
-#define KOKKOS_IMPL_CUDA_BALLOT(x) __ballot_sync(__activemask(),x)
-#define KOKKOS_IMPL_CUDA_BALLOT_MASK(m,x) __ballot_sync(m,x)
-#define KOKKOS_IMPL_CUDA_SHFL(x,y,z) __shfl_sync(0xffffffff,x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_MASK(m,x,y,z) __shfl_sync(m,x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_UP(x,y,z) __shfl_up_sync(0xffffffff,x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_UP_MASK(m,x,y,z) __shfl_up_sync(m,x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_DOWN(x,y,z) __shfl_down_sync(0xffffffff,x,y,z)
-#define KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK(m,x,y,z) __shfl_down_sync(m,x,y,z)
-#endif 
+#define KOKKOS_IMPL_CUDA_BALLOT(x) __ballot_sync(__activemask(), x)
+#define KOKKOS_IMPL_CUDA_BALLOT_MASK(m, x) __ballot_sync(m, x)
+#define KOKKOS_IMPL_CUDA_SHFL(x, y, z) __shfl_sync(0xffffffff, x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_MASK(m, x, y, z) __shfl_sync(m, x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_UP(x, y, z) __shfl_up_sync(0xffffffff, x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_UP_MASK(m, x, y, z) __shfl_up_sync(m, x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_DOWN(x, y, z) \
+  __shfl_down_sync(0xffffffff, x, y, z)
+#define KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK(m, x, y, z) __shfl_down_sync(m, x, y, z)
+#endif
 #else
 #define KOKKOS_IMPL_CUDA_ACTIVEMASK 0
-#define KOKKOS_IMPL_CUDA_SYNCWARP 
+#define KOKKOS_IMPL_CUDA_SYNCWARP
 #define KOKKOS_IMPL_CUDA_SYNCWARP_MASK(m) (void)m
 #define KOKKOS_IMPL_CUDA_BALLOT(x) 0
-#define KOKKOS_IMPL_CUDA_BALLOT_MASK(m,x) 0
-#define KOKKOS_IMPL_CUDA_SHFL(x,y,z) 0
-#define KOKKOS_IMPL_CUDA_SHFL_MASK(m,x,y,z) 0
-#define KOKKOS_IMPL_CUDA_SHFL_UP(x,y,z) 0
-#define KOKKOS_IMPL_CUDA_SHFL_DOWN(x,y,z) 0
-#define KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK(m,x,y,z) 0
-#endif 
+#define KOKKOS_IMPL_CUDA_BALLOT_MASK(m, x) 0
+#define KOKKOS_IMPL_CUDA_SHFL(x, y, z) 0
+#define KOKKOS_IMPL_CUDA_SHFL_MASK(m, x, y, z) 0
+#define KOKKOS_IMPL_CUDA_SHFL_UP(x, y, z) 0
+#define KOKKOS_IMPL_CUDA_SHFL_DOWN(x, y, z) 0
+#define KOKKOS_IMPL_CUDA_SHFL_DOWN_MASK(m, x, y, z) 0
+#endif
 
-#if ( CUDA_VERSION >= 9000 ) && (!defined(KOKKOS_COMPILER_CLANG))
+#if (CUDA_VERSION >= 9000) && (!defined(KOKKOS_COMPILER_CLANG))
 #define KOKKOS_IMPL_CUDA_MAX_SHFL_SIZEOF sizeof(long long)
 #else
 #define KOKKOS_IMPL_CUDA_MAX_SHFL_SIZEOF sizeof(int)
 #endif
 
-#if defined( __CUDA_ARCH__ )
-#if ( CUDA_VERSION < 9000 )
-#define KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( MSG ) { \
-  const unsigned b = __ballot(1); \
-  if ( b != 0xffffffff ) { \
-    printf(" SYNCWARP AT %s (%d,%d,%d) (%d,%d,%d) failed %x\n" \
-      , MSG \
-      , blockIdx.x \
-      , blockIdx.y \
-      , blockIdx.z \
-      , threadIdx.x \
-      , threadIdx.y \
-      , threadIdx.z \
-      , b ); \
-    return ; \
-  } \
-}
+#if defined(__CUDA_ARCH__)
+#if (CUDA_VERSION < 9000)
+#define KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN(MSG)                           \
+  {                                                                        \
+    const unsigned b = __ballot(1);                                        \
+    if (b != 0xffffffff) {                                                 \
+      printf(" SYNCWARP AT %s (%d,%d,%d) (%d,%d,%d) failed %x\n", MSG,     \
+             blockIdx.x, blockIdx.y, blockIdx.z, threadIdx.x, threadIdx.y, \
+             threadIdx.z, b);                                              \
+      return;                                                              \
+    }                                                                      \
+  }
 #else
-#define KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( MSG ) { \
-  __syncwarp(); \
-  const unsigned b = __activemask(); \
-  if ( b != 0xffffffff ) { \
-    printf(" SYNCWARP AT %s (%d,%d,%d) (%d,%d,%d) failed %x\n" \
-      , MSG \
-      , blockIdx.x \
-      , blockIdx.y \
-      , blockIdx.z \
-      , threadIdx.x \
-      , threadIdx.y \
-      , threadIdx.z \
-      , b ); \
-    return ; \
-  } \
-}
-#endif 
+#define KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN(MSG)                           \
+  {                                                                        \
+    __syncwarp();                                                          \
+    const unsigned b = __activemask();                                     \
+    if (b != 0xffffffff) {                                                 \
+      printf(" SYNCWARP AT %s (%d,%d,%d) (%d,%d,%d) failed %x\n", MSG,     \
+             blockIdx.x, blockIdx.y, blockIdx.z, threadIdx.x, threadIdx.y, \
+             threadIdx.z, b);                                              \
+      return;                                                              \
+    }                                                                      \
+  }
+#endif
 #else
-#define KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN( MSG ) 
-#endif 
-
+#define KOKKOS_IMPL_CUDA_SYNCWARP_OR_RETURN(MSG)
+#endif
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_View.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_View.hpp
index 2fe9d8ccf7543f160f935bb6797b7dceb4944de4..08fdbea38728e7bcf0d1d57ff7c594180d6cc90a 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_View.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_View.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_EXPERIMENTAL_CUDA_VIEW_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -53,117 +54,101 @@
 namespace Kokkos {
 namespace Impl {
 
-// Cuda Texture fetches can be performed for 4, 8 and 16 byte objects (int,int2,int4)
-// Via reinterpret_case this can be used to support all scalar types of those sizes.
-// Any other scalar type falls back to either normal reads out of global memory,
-// or using the __ldg intrinsic on Kepler GPUs or newer (Compute Capability >= 3.0)
+// Cuda Texture fetches can be performed for 4, 8 and 16 byte objects
+// (int,int2,int4) Via reinterpret_case this can be used to support all scalar
+// types of those sizes. Any other scalar type falls back to either normal reads
+// out of global memory, or using the __ldg intrinsic on Kepler GPUs or newer
+// (Compute Capability >= 3.0)
 
-template< typename ValueType , typename AliasType >
+template <typename ValueType, typename AliasType>
 struct CudaTextureFetch {
-
-  ::cudaTextureObject_t   m_obj ;
-  const ValueType       * m_ptr ;
-  int                     m_offset ;
+  ::cudaTextureObject_t m_obj;
+  const ValueType* m_ptr;
+  int m_offset;
 
   // Deference operator pulls through texture object and returns by value
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  ValueType operator[]( const iType & i ) const
-    {
-#if defined( __CUDA_ARCH__ ) && ( 300 <= __CUDA_ARCH__ )
-      AliasType v = tex1Dfetch<AliasType>( m_obj , i + m_offset );
-      return  *(reinterpret_cast<ValueType*> (&v));
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION ValueType operator[](const iType& i) const {
+#if defined(__CUDA_ARCH__) && (300 <= __CUDA_ARCH__)
+    AliasType v = tex1Dfetch<AliasType>(m_obj, i + m_offset);
+    return *(reinterpret_cast<ValueType*>(&v));
 #else
-      return m_ptr[ i ];
+    return m_ptr[i];
 #endif
-    }
+  }
 
   // Pointer to referenced memory
   KOKKOS_INLINE_FUNCTION
-  operator const ValueType * () const { return m_ptr ; }
-
+  operator const ValueType*() const { return m_ptr; }
 
   KOKKOS_INLINE_FUNCTION
-  CudaTextureFetch() : m_obj() , m_ptr() , m_offset() {}
+  CudaTextureFetch() : m_obj(), m_ptr(), m_offset() {}
 
   KOKKOS_INLINE_FUNCTION
   ~CudaTextureFetch() {}
 
   KOKKOS_INLINE_FUNCTION
-  CudaTextureFetch( const CudaTextureFetch & rhs )
-    : m_obj(     rhs.m_obj )
-    , m_ptr(     rhs.m_ptr )
-    , m_offset(  rhs.m_offset )
-    {}
+  CudaTextureFetch(const CudaTextureFetch& rhs)
+      : m_obj(rhs.m_obj), m_ptr(rhs.m_ptr), m_offset(rhs.m_offset) {}
 
   KOKKOS_INLINE_FUNCTION
-  CudaTextureFetch( CudaTextureFetch && rhs )
-    : m_obj(     rhs.m_obj )
-    , m_ptr(     rhs.m_ptr )
-    , m_offset(  rhs.m_offset )
-    {}
+  CudaTextureFetch(CudaTextureFetch&& rhs)
+      : m_obj(rhs.m_obj), m_ptr(rhs.m_ptr), m_offset(rhs.m_offset) {}
 
   KOKKOS_INLINE_FUNCTION
-  CudaTextureFetch & operator = ( const CudaTextureFetch & rhs )
-    {
-      m_obj     = rhs.m_obj ;
-      m_ptr     = rhs.m_ptr ;
-      m_offset  = rhs.m_offset ;
-      return *this ;
-    }
+  CudaTextureFetch& operator=(const CudaTextureFetch& rhs) {
+    m_obj    = rhs.m_obj;
+    m_ptr    = rhs.m_ptr;
+    m_offset = rhs.m_offset;
+    return *this;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  CudaTextureFetch & operator = ( CudaTextureFetch && rhs )
-    {
-      m_obj     = rhs.m_obj ;
-      m_ptr     = rhs.m_ptr ;
-      m_offset  = rhs.m_offset ;
-      return *this ;
-    }
+  CudaTextureFetch& operator=(CudaTextureFetch&& rhs) {
+    m_obj    = rhs.m_obj;
+    m_ptr    = rhs.m_ptr;
+    m_offset = rhs.m_offset;
+    return *this;
+  }
 
   // Texture object spans the entire allocation.
   // This handle may view a subset of the allocation, so an offset is required.
-  template< class CudaMemorySpace >
-  inline explicit
-  CudaTextureFetch( const ValueType * const arg_ptr
-                  , Kokkos::Impl::SharedAllocationRecord< CudaMemorySpace , void > * record
-                  )
-    : m_obj( record->template attach_texture_object< AliasType >() )
-    , m_ptr( arg_ptr )
-    , m_offset( record->attach_texture_object_offset( reinterpret_cast<const AliasType*>( arg_ptr ) ) )
-    {}
+  template <class CudaMemorySpace>
+  inline explicit CudaTextureFetch(
+      const ValueType* const arg_ptr,
+      Kokkos::Impl::SharedAllocationRecord<CudaMemorySpace, void>* record)
+      : m_obj(record->template attach_texture_object<AliasType>()),
+        m_ptr(arg_ptr),
+        m_offset(record->attach_texture_object_offset(
+            reinterpret_cast<const AliasType*>(arg_ptr))) {}
 
   // Texture object spans the entire allocation.
   // This handle may view a subset of the allocation, so an offset is required.
   KOKKOS_INLINE_FUNCTION
-  CudaTextureFetch( const CudaTextureFetch & rhs , size_t offset )
-    : m_obj(     rhs.m_obj )
-    , m_ptr(     rhs.m_ptr + offset)
-    , m_offset( offset + rhs.m_offset )
-    {}
+  CudaTextureFetch(const CudaTextureFetch& rhs, size_t offset)
+      : m_obj(rhs.m_obj),
+        m_ptr(rhs.m_ptr + offset),
+        m_offset(offset + rhs.m_offset) {}
 };
 
-#if defined( KOKKOS_ENABLE_CUDA_LDG_INTRINSIC )
+#if defined(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC)
 
-template< typename ValueType , typename AliasType >
+template <typename ValueType, typename AliasType>
 struct CudaLDGFetch {
+  const ValueType* m_ptr;
 
-  const ValueType * m_ptr ;
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  ValueType operator[]( const iType & i ) const
-    {
-      #ifdef __CUDA_ARCH__
-      AliasType v = __ldg(reinterpret_cast<const AliasType*>(&m_ptr[i]));
-      return  *(reinterpret_cast<ValueType*> (&v));
-      #else
-      return m_ptr[i];
-      #endif
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION ValueType operator[](const iType& i) const {
+#ifdef __CUDA_ARCH__
+    AliasType v = __ldg(reinterpret_cast<const AliasType*>(&m_ptr[i]));
+    return *(reinterpret_cast<ValueType*>(&v));
+#else
+    return m_ptr[i];
+#endif
+  }
 
   KOKKOS_INLINE_FUNCTION
-  operator const ValueType * () const { return m_ptr ; }
+  operator const ValueType*() const { return m_ptr; }
 
   KOKKOS_INLINE_FUNCTION
   CudaLDGFetch() : m_ptr() {}
@@ -172,48 +157,38 @@ struct CudaLDGFetch {
   ~CudaLDGFetch() {}
 
   KOKKOS_INLINE_FUNCTION
-  CudaLDGFetch( const CudaLDGFetch & rhs )
-    : m_ptr( rhs.m_ptr )
-    {}
+  CudaLDGFetch(const CudaLDGFetch& rhs) : m_ptr(rhs.m_ptr) {}
 
   KOKKOS_INLINE_FUNCTION
-  CudaLDGFetch( CudaLDGFetch && rhs )
-    : m_ptr( rhs.m_ptr )
-    {}
+  CudaLDGFetch(CudaLDGFetch&& rhs) : m_ptr(rhs.m_ptr) {}
 
   KOKKOS_INLINE_FUNCTION
-  CudaLDGFetch & operator = ( const CudaLDGFetch & rhs )
-    {
-      m_ptr = rhs.m_ptr ;
-      return *this ;
-    }
+  CudaLDGFetch& operator=(const CudaLDGFetch& rhs) {
+    m_ptr = rhs.m_ptr;
+    return *this;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  CudaLDGFetch & operator = ( CudaLDGFetch && rhs )
-    {
-      m_ptr = rhs.m_ptr ;
-      return *this ;
-    }
+  CudaLDGFetch& operator=(CudaLDGFetch&& rhs) {
+    m_ptr = rhs.m_ptr;
+    return *this;
+  }
 
-  template< class CudaMemorySpace >
-  inline explicit
-  CudaLDGFetch( const ValueType * const arg_ptr
-              , Kokkos::Impl::SharedAllocationRecord<CudaMemorySpace,void>*
-              )
-    : m_ptr( arg_ptr )
-    {}
+  template <class CudaMemorySpace>
+  inline explicit CudaLDGFetch(
+      const ValueType* const arg_ptr,
+      Kokkos::Impl::SharedAllocationRecord<CudaMemorySpace, void>*)
+      : m_ptr(arg_ptr) {}
 
   KOKKOS_INLINE_FUNCTION
-  CudaLDGFetch( CudaLDGFetch const rhs ,size_t offset)
-    : m_ptr( rhs.m_ptr + offset )
-    {}
-
+  CudaLDGFetch(CudaLDGFetch const rhs, size_t offset)
+      : m_ptr(rhs.m_ptr + offset) {}
 };
 
 #endif
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -221,98 +196,95 @@ struct CudaLDGFetch {
 namespace Kokkos {
 namespace Impl {
 
-/** \brief  Replace Default ViewDataHandle with Cuda texture fetch specialization
- *          if 'const' value type, CudaSpace and random access.
+/** \brief  Replace Default ViewDataHandle with Cuda texture fetch
+ * specialization if 'const' value type, CudaSpace and random access.
  */
-template< class Traits >
-class ViewDataHandle< Traits ,
-  typename std::enable_if<(
-    // Is Cuda memory space
-    ( std::is_same< typename Traits::memory_space,Kokkos::CudaSpace>::value ||
-      std::is_same< typename Traits::memory_space,Kokkos::CudaUVMSpace>::value )
-    &&
-    // Is a trivial const value of 4, 8, or 16 bytes
-    std::is_trivial<typename Traits::const_value_type>::value
-    &&
-    std::is_same<typename Traits::const_value_type,typename Traits::value_type>::value
-    &&
-    ( sizeof(typename Traits::const_value_type) ==  4 ||
-      sizeof(typename Traits::const_value_type) ==  8 ||
-      sizeof(typename Traits::const_value_type) == 16 )
-    &&
-    // Random access trait
-    ( Traits::memory_traits::is_random_access != 0 )
-  )>::type >
-{
-public:
-
-  using track_type  = Kokkos::Impl::SharedAllocationTracker ;
-
-  using value_type  = typename Traits::const_value_type ;
-  using return_type = typename Traits::const_value_type ; // NOT a reference
-
-  using alias_type = typename std::conditional< ( sizeof(value_type) ==  4 ) , int ,
-                     typename std::conditional< ( sizeof(value_type) ==  8 ) , ::int2 ,
-                     typename std::conditional< ( sizeof(value_type) == 16 ) , ::int4 , void
-                     >::type
-                     >::type
-                     >::type ;
-
-#if defined( KOKKOS_ENABLE_CUDA_LDG_INTRINSIC )
-  using handle_type = Kokkos::Impl::CudaLDGFetch< value_type , alias_type > ;
+template <class Traits>
+class ViewDataHandle<
+    Traits, typename std::enable_if<(
+                // Is Cuda memory space
+                (std::is_same<typename Traits::memory_space,
+                              Kokkos::CudaSpace>::value ||
+                 std::is_same<typename Traits::memory_space,
+                              Kokkos::CudaUVMSpace>::value) &&
+                // Is a trivial const value of 4, 8, or 16 bytes
+                std::is_trivial<typename Traits::const_value_type>::value &&
+                std::is_same<typename Traits::const_value_type,
+                             typename Traits::value_type>::value &&
+                (sizeof(typename Traits::const_value_type) == 4 ||
+                 sizeof(typename Traits::const_value_type) == 8 ||
+                 sizeof(typename Traits::const_value_type) == 16) &&
+                // Random access trait
+                (Traits::memory_traits::is_random_access != 0))>::type> {
+ public:
+  using track_type = Kokkos::Impl::SharedAllocationTracker;
+
+  using value_type  = typename Traits::const_value_type;
+  using return_type = typename Traits::const_value_type;  // NOT a reference
+
+  using alias_type = typename std::conditional<
+      (sizeof(value_type) == 4), int,
+      typename std::conditional<
+          (sizeof(value_type) == 8), ::int2,
+          typename std::conditional<(sizeof(value_type) == 16), ::int4,
+                                    void>::type>::type>::type;
+
+#if defined(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC)
+  using handle_type = Kokkos::Impl::CudaLDGFetch<value_type, alias_type>;
 #else
-  using handle_type = Kokkos::Impl::CudaTextureFetch< value_type , alias_type > ;
+  using handle_type = Kokkos::Impl::CudaTextureFetch<value_type, alias_type>;
 #endif
 
   KOKKOS_INLINE_FUNCTION
-  static handle_type const & assign( handle_type const & arg_handle , track_type const & /* arg_tracker */ )
-    {
-      return arg_handle ;
-    }
+  static handle_type const& assign(handle_type const& arg_handle,
+                                   track_type const& /* arg_tracker */) {
+    return arg_handle;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static handle_type const assign( handle_type const & arg_handle , size_t offset )
-    {
-      return handle_type(arg_handle,offset) ;
-    }
+  static handle_type const assign(handle_type const& arg_handle,
+                                  size_t offset) {
+    return handle_type(arg_handle, offset);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static handle_type assign( value_type * arg_data_ptr, track_type const & arg_tracker )
-    {
-      if(arg_data_ptr == NULL) return handle_type();
-
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      // Assignment of texture = non-texture requires creation of a texture object
-      // which can only occur on the host.  In addition, 'get_record' is only valid
-      // if called in a host execution space
+  static handle_type assign(value_type* arg_data_ptr,
+                            track_type const& arg_tracker) {
+    if (arg_data_ptr == NULL) return handle_type();
 
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    // Assignment of texture = non-texture requires creation of a texture object
+    // which can only occur on the host.  In addition, 'get_record' is only
+    // valid if called in a host execution space
 
-      typedef typename Traits::memory_space memory_space ;
-      typedef typename Impl::SharedAllocationRecord<memory_space,void> record ;
+    typedef typename Traits::memory_space memory_space;
+    typedef typename Impl::SharedAllocationRecord<memory_space, void> record;
 
-      record * const r = arg_tracker.template get_record< memory_space >();
+    record* const r = arg_tracker.template get_record<memory_space>();
 
-#if ! defined( KOKKOS_ENABLE_CUDA_LDG_INTRINSIC )
-      if ( 0 == r ) {
-        Kokkos::abort("Cuda const random access View using Cuda texture memory requires Kokkos to allocate the View's memory");
-      }
+#if !defined(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC)
+    if (0 == r) {
+      Kokkos::abort(
+          "Cuda const random access View using Cuda texture memory requires "
+          "Kokkos to allocate the View's memory");
+    }
 #endif
 
-      return handle_type( arg_data_ptr , r );
+    return handle_type(arg_data_ptr, r);
 
 #else
-      Kokkos::Impl::cuda_abort("Cannot create Cuda texture object from within a Cuda kernel");
-      return handle_type();
+    Kokkos::Impl::cuda_abort(
+        "Cannot create Cuda texture object from within a Cuda kernel");
+    return handle_type();
 #endif
-    }
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_CUDA ) */
 #endif /* #ifndef KOKKOS_CUDA_VIEW_HPP */
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIAvail.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIAvail.hpp
index 33615f3f9fd3891c1090c971abbfc9c69bb6cf2a..2fbfb6727784d1078026e4169e76f7687de14e5f 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIAvail.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIAvail.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Cuda
 
-#include<eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIDecl.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIDecl.hpp
index befff1a86572abd57dce7106939892d31a098a68..18e56aa32dfbe794937aef623e15d7e937394611 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIDecl.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_ViewCopyETIDecl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Cuda
 
-#include<eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
index 9c0ac470c84887c831009432bf9818629787e64c..0753e383a171beb679dd8745fcfd78e1287a242b 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,74 +48,64 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::WorkGraphPolicy< Traits ... >
-                 , Kokkos::Cuda
-                 >
-{
-public:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
+                  Kokkos::Cuda> {
+ public:
+  typedef Kokkos::WorkGraphPolicy<Traits...> Policy;
+  typedef ParallelFor<FunctorType, Policy, Kokkos::Cuda> Self;
 
-  typedef Kokkos::WorkGraphPolicy< Traits ... >   Policy ;
-  typedef ParallelFor<FunctorType, Policy, Kokkos::Cuda>        Self ;
+ private:
+  Policy m_policy;
+  FunctorType m_functor;
 
-private:
-
-  Policy       m_policy ;
-  FunctorType  m_functor ;
-
-  template< class TagType >
+  template <class TagType>
   __device__ inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { m_functor( w ); }
-
-  template< class TagType >
-  __device__ inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { const TagType t{} ; m_functor( t , w ); }
-
-public:
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_one(const std::int32_t w) const noexcept {
+    m_functor(w);
+  }
 
+  template <class TagType>
   __device__ inline
-  void operator()() const noexcept
-    {
-      if ( 0 == ( threadIdx.y % 16 ) ) {
-
-        // Spin until COMPLETED_TOKEN.
-        // END_TOKEN indicates no work is currently available.
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_one(const std::int32_t w) const noexcept {
+    const TagType t{};
+    m_functor(t, w);
+  }
 
-        for ( std::int32_t w = Policy::END_TOKEN ;
-              Policy::COMPLETED_TOKEN != ( w = m_policy.pop_work() ) ; ) {
-          if ( Policy::END_TOKEN != w ) {
-            exec_one< typename Policy::work_tag >( w );
-            m_policy.completed_work(w);
-          }
+ public:
+  __device__ inline void operator()() const noexcept {
+    if (0 == (threadIdx.y % 16)) {
+      // Spin until COMPLETED_TOKEN.
+      // END_TOKEN indicates no work is currently available.
+
+      for (std::int32_t w = Policy::END_TOKEN;
+           Policy::COMPLETED_TOKEN != (w = m_policy.pop_work());) {
+        if (Policy::END_TOKEN != w) {
+          exec_one<typename Policy::work_tag>(w);
+          m_policy.completed_work(w);
         }
       }
     }
+  }
 
-  inline
-  void execute()
-  {
-    const int warps_per_block = 4 ;
-    const dim3 grid( Kokkos::Impl::cuda_internal_multiprocessor_count() , 1 , 1 );
-    const dim3 block( 1 , Kokkos::Impl::CudaTraits::WarpSize , warps_per_block );
-    const int shared = 0 ;
+  inline void execute() {
+    const int warps_per_block = 4;
+    const dim3 grid(Kokkos::Impl::cuda_internal_multiprocessor_count(), 1, 1);
+    const dim3 block(1, Kokkos::Impl::CudaTraits::WarpSize, warps_per_block);
+    const int shared = 0;
 
-    Kokkos::Impl::CudaParallelLaunch<Self>(*this, grid, block, shared, Cuda().impl_internal_space_instance() , false );
+    Kokkos::Impl::CudaParallelLaunch<Self>(
+        *this, grid, block, shared, Cuda().impl_internal_space_instance(),
+        false);
   }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_policy( arg_policy )
-    , m_functor( arg_functor )
-  {}
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_policy(arg_policy), m_functor(arg_functor) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #define KOKKOS_CUDA_WORKGRAPHPOLICY_HPP */
diff --git a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_abort.hpp b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_abort.hpp
index 9f5415b5119d3091e960d13572495243a20c38ea..698695dbdb44bbf60d1773aff9c8f623dcd20f73 100644
--- a/lib/kokkos/core/src/Cuda/Kokkos_Cuda_abort.hpp
+++ b/lib/kokkos/core/src/Cuda/Kokkos_Cuda_abort.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 #include <Kokkos_Macros.hpp>
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
 
 #include <cuda.h>
 
@@ -55,35 +56,26 @@ extern "C" {
 /*  Cuda runtime function, declared in <crt/device_runtime.h>
  *  Requires capability 2.x or better.
  */
-extern __device__ void __assertfail(
-  const void  *message,
-  const void  *file,
-  unsigned int line,
-  const void  *function,
-  size_t       charsize);
+extern __device__ void __assertfail(const void *message, const void *file,
+                                    unsigned int line, const void *function,
+                                    size_t charsize);
 }
 
 namespace Kokkos {
 namespace Impl {
 
-__device__ inline
-void cuda_abort( const char * const message )
-{
+__device__ inline void cuda_abort(const char *const message) {
 #ifndef __APPLE__
-  const char empty[] = "" ;
+  const char empty[] = "";
 
-  __assertfail( (const void *) message ,
-                (const void *) empty ,
-                (unsigned int) 0 ,
-                (const void *) empty ,
-                sizeof(char) );
+  __assertfail((const void *)message, (const void *)empty, (unsigned int)0,
+               (const void *)empty, sizeof(char));
 #endif
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 #else
 void KOKKOS_CORE_SRC_CUDA_ABORT_PREVENT_LINK_ERROR() {}
 #endif /* #if defined(__CUDACC__) && defined( KOKKOS_ENABLE_CUDA ) */
 #endif /* #ifndef KOKKOS_CUDA_ABORT_HPP */
-
diff --git a/lib/kokkos/core/src/HPX/Kokkos_HPX.cpp b/lib/kokkos/core/src/HPX/Kokkos_HPX.cpp
index da9783467ce34899cc6e7ec2dd0be036ef216f30..0c4cca70f8ee0cdec9d2884a5ab30f78a0b95536 100644
--- a/lib/kokkos/core/src/HPX/Kokkos_HPX.cpp
+++ b/lib/kokkos/core/src/HPX/Kokkos_HPX.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,6 @@
 //@HEADER
 */
 
-
 #include <Kokkos_Macros.hpp>
 
 #ifdef KOKKOS_ENABLE_HPX
@@ -80,8 +80,8 @@ void HPX::impl_initialize(int thread_count) {
         "--hpx:attach-debugger=exception",
 #endif
     };
-    int argc_hpx = 1;
-    char name[] = "kokkos_hpx";
+    int argc_hpx     = 1;
+    char name[]      = "kokkos_hpx";
     char *argv_hpx[] = {name, nullptr};
     hpx::start(nullptr, argc_hpx, argv_hpx, config);
 
@@ -107,8 +107,8 @@ void HPX::impl_initialize() {
         "--hpx:attach-debugger=exception",
 #endif
     };
-    int argc_hpx = 1;
-    char name[] = "kokkos_hpx";
+    int argc_hpx     = 1;
+    char name[]      = "kokkos_hpx";
     char *argv_hpx[] = {name, nullptr};
     hpx::start(nullptr, argc_hpx, argv_hpx, config);
 
@@ -138,15 +138,16 @@ void HPX::impl_finalize() {
       hpx::apply([]() { hpx::finalize(); });
       hpx::stop();
     } else {
-      Kokkos::abort("Kokkos::Experimental::HPX::impl_finalize: Kokkos started "
-                    "HPX but something else already stopped HPX\n");
+      Kokkos::abort(
+          "Kokkos::Experimental::HPX::impl_finalize: Kokkos started "
+          "HPX but something else already stopped HPX\n");
     }
   }
 }
 
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 #else
 void KOKKOS_CORE_SRC_IMPL_HPX_PREVENT_LINK_ERROR() {}
-#endif //#ifdef KOKKOS_ENABLE_HPX
+#endif  //#ifdef KOKKOS_ENABLE_HPX
diff --git a/lib/kokkos/core/src/HPX/Kokkos_HPX_ChunkedRoundRobinExecutor.hpp b/lib/kokkos/core/src/HPX/Kokkos_HPX_ChunkedRoundRobinExecutor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b364b4a6eb2f93a424bd8b4904d743456174425f
--- /dev/null
+++ b/lib/kokkos/core/src/HPX/Kokkos_HPX_ChunkedRoundRobinExecutor.hpp
@@ -0,0 +1,208 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef KOKKOS_HPX_CHUNKEDROUNDROBINEXECUTOR_HPP
+#define KOKKOS_HPX_CHUNKEDROUNDROBINEXECUTOR_HPP
+
+#include <hpx/config.hpp>
+#include <hpx/async_launch_policy_dispatch.hpp>
+#include <hpx/lcos/local/latch.hpp>
+#include <hpx/parallel/executors/execution.hpp>
+#include <hpx/parallel/executors/post_policy_dispatch.hpp>
+#include <hpx/runtime/get_os_thread_count.hpp>
+#include <hpx/runtime/threads/thread_helpers.hpp>
+#include <hpx/traits/is_executor.hpp>
+#include <hpx/traits/is_launch_policy.hpp>
+#include <hpx/util/deferred_call.hpp>
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace Kokkos {
+namespace Impl {
+
+///////////////////////////////////////////////////////////////////////////
+/// A \a ChunkedRoundRobinExecutor creates groups of parallel execution
+/// agents which execute in threads implicitly created by the executor. This
+/// executor uses the scheduling hint to spawn threads with the first grouped on
+/// the first core, the second group getting the next consecutive threads, etc.
+/// For example, if 10 tasks are spawned (num_tasks is set to 10) and num_cores
+/// is set to 2 the executor will schedule the tasks in the following order:
+///
+/// worker thread | 1 | 2
+/// --------------+---+---
+/// tasks         | 1 | 6
+///               | 2 | 7
+///               | 3 | 8
+///               | 4 | 9
+///               | 5 | 10
+///
+/// rather than the typical round robin:
+///
+/// worker thread | 1 | 2
+/// --------------+---+---
+/// tasks         | 1 | 2
+///               | 3 | 4
+///               | 5 | 6
+///               | 7 | 8
+///               | 9 | 10
+struct ChunkedRoundRobinExecutor {
+  using execution_category = hpx::parallel::execution::parallel_execution_tag;
+
+  HPX_CONSTEXPR explicit ChunkedRoundRobinExecutor(
+      std::size_t num_tasks = std::size_t(-1), std::size_t core_offset = 0,
+      std::size_t num_cores = hpx::get_os_thread_count())
+      : num_tasks_(num_tasks),
+        core_offset_(core_offset),
+        num_cores_(num_cores),
+        num_tasks_per_core_(double(num_tasks_) / num_cores_),
+        num_tasks_spawned_(0) {}
+
+  bool operator==(ChunkedRoundRobinExecutor const &rhs) const noexcept {
+    return num_cores_ == rhs.num_cores_ && num_tasks_ == rhs.num_tasks_;
+  }
+
+  bool operator!=(ChunkedRoundRobinExecutor const &rhs) const noexcept {
+    return !(*this == rhs);
+  }
+
+  ChunkedRoundRobinExecutor const &context() const noexcept { return *this; }
+
+  template <typename F, typename... Ts>
+  hpx::future<
+      typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type>
+  async_execute(F &&f, Ts &&... ts) const {
+    return hpx::detail::async_launch_policy_dispatch<hpx::launch>::call(
+        hpx::launch::async_policy{}, std::forward<F>(f),
+        std::forward<Ts>(ts)...);
+  }
+
+  template <typename F, typename... Ts>
+  void post(F &&f, Ts &&... ts) const {
+    hpx::util::thread_description const desc(
+        f, "Kokkos::Impl::ChunkedRoundRobinExecutor::async_execute");
+    hpx::threads::thread_schedule_hint const hint(
+        hpx::threads::thread_schedule_hint_mode_thread,
+        core_offset_ + std::floor(double(num_tasks_spawned_ % num_tasks_) /
+                                  num_tasks_per_core_));
+
+    hpx::threads::register_thread_nullary(
+        hpx::util::deferred_call(std::forward<F>(f), std::forward<Ts>(ts)...),
+        desc, hpx::threads::pending, false,
+        hpx::threads::thread_priority_normal, hint,
+        hpx::threads::thread_stacksize_default);
+
+    ++num_tasks_spawned_;
+  }
+
+  template <typename F, typename Shape, typename... Ts>
+  std::vector<hpx::future<typename hpx::parallel::execution::detail::
+                              bulk_function_result<F, Shape, Ts...>::type>>
+  bulk_async_execute(F &&f, Shape const &shape, Ts &&... ts) {
+    hpx::util::thread_description desc(
+        f, "Kokkos::Impl::ChunkedRoundRobinExecutor::bulk_sync_execute");
+
+    hpx::lcos::local::latch l(hpx::util::size(shape));
+    // Keep a separate counter for bulk launch
+    std::size_t num_tasks_spawned = 0;
+
+    for (auto const &s : shape) {
+      hpx::threads::thread_schedule_hint const hint(
+          hpx::threads::thread_schedule_hint_mode_thread,
+          core_offset_ + std::floor(double(num_tasks_spawned % num_tasks_) /
+                                    num_tasks_per_core_));
+
+      hpx::threads::register_thread_nullary(
+          [&, s]() {
+            hpx::util::invoke(f, s, ts...);
+            l.count_down(1);
+          },
+          desc, hpx::threads::pending, false,
+          hpx::threads::thread_priority_normal, hint,
+          hpx::threads::thread_stacksize_default);
+
+      ++num_tasks_spawned;
+    }
+
+    // NOTE: We block here to avoid extra synchronization. Since this executor
+    // is only used in the HPX backend we get away with this.
+    l.wait();
+
+    return {};
+  }
+
+ private:
+  std::size_t num_tasks_;
+  std::size_t core_offset_;
+  std::size_t num_cores_;
+  double num_tasks_per_core_;
+  mutable std::size_t num_tasks_spawned_;
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+namespace hpx {
+namespace parallel {
+namespace execution {
+
+template <>
+struct is_one_way_executor<Kokkos::Impl::ChunkedRoundRobinExecutor>
+    : std::true_type {};
+
+template <>
+struct is_two_way_executor<Kokkos::Impl::ChunkedRoundRobinExecutor>
+    : std::true_type {};
+
+template <>
+struct is_bulk_two_way_executor<Kokkos::Impl::ChunkedRoundRobinExecutor>
+    : std::true_type {};
+
+}  // namespace execution
+}  // namespace parallel
+}  // namespace hpx
+
+#endif
diff --git a/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.cpp b/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.cpp
index df7c40368538194d5acfa77c0ca8dc42c9058735..8d42589bdf37b0b5557aed6631de851276a5f5c4 100644
--- a/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.cpp
+++ b/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,9 +58,9 @@ namespace Impl {
 template class TaskQueue<Kokkos::Experimental::HPX,
                          Kokkos::Experimental::HPX::memory_space>;
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #else
 void KOKKOS_CORE_SRC_IMPL_HPX_TASK_PREVENT_LINK_ERROR() {}
-#endif // #if defined( KOKKOS_ENABLE_HPX ) && defined( KOKKOS_ENABLE_TASKDAG )
+#endif  // #if defined( KOKKOS_ENABLE_HPX ) && defined( KOKKOS_ENABLE_TASKDAG )
diff --git a/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.hpp b/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.hpp
index c3a14efee6554ccbe0a8f13c53340f496b30468d..803d955914257caf39d4c570249c12779ee9b8e6 100644
--- a/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.hpp
+++ b/lib/kokkos/core/src/HPX/Kokkos_HPX_Task.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,10 +50,11 @@
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
+#include <HPX/Kokkos_HPX_ChunkedRoundRobinExecutor.hpp>
 #include <Kokkos_HPX.hpp>
 
 #include <hpx/apply.hpp>
-#include <hpx/lcos/local/counting_semaphore.hpp>
+#include <hpx/lcos/local/latch.hpp>
 
 #include <type_traits>
 
@@ -65,7 +67,7 @@ namespace Impl {
 template <class QueueType>
 class TaskQueueSpecialization<
     SimpleTaskScheduler<Kokkos::Experimental::HPX, QueueType>> {
-public:
+ public:
   using execution_space = Kokkos::Experimental::HPX;
   using scheduler_type =
       SimpleTaskScheduler<Kokkos::Experimental::HPX, QueueType>;
@@ -85,7 +87,7 @@ public:
   // Must provide task queue execution function
   void execute_task() const {
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
     using task_base_type = typename scheduler_type::task_base_type;
 
     const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
@@ -95,25 +97,28 @@ public:
 
     auto &queue = scheduler->queue();
 
-    counting_semaphore sem(0);
+    latch num_tasks_remaining(num_worker_threads);
+    ChunkedRoundRobinExecutor exec(num_worker_threads);
 
     for (int thread = 0; thread < num_worker_threads; ++thread) {
-      apply([this, &sem, &queue, &buffer, num_worker_threads, thread]() {
+      apply(exec, [this, &num_tasks_remaining, &queue, &buffer,
+                   num_worker_threads]() {
         // NOTE: This implementation has been simplified based on the
         // assumption that team_size = 1. The HPX backend currently only
         // supports a team size of 1.
         std::size_t t = Kokkos::Experimental::HPX::impl_hardware_thread_id();
 
         buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id());
-        HPXTeamMember member(TeamPolicyInternal<Kokkos::Experimental::HPX>(
-                                 Kokkos::Experimental::HPX(), num_worker_threads, 1),
-                             0, t, buffer.get(t), 512);
+        HPXTeamMember member(
+            TeamPolicyInternal<Kokkos::Experimental::HPX>(
+                Kokkos::Experimental::HPX(), num_worker_threads, 1),
+            0, t, buffer.get(t), 512);
 
         member_type single_exec(*scheduler, member);
         member_type &team_exec = single_exec;
 
         auto &team_scheduler = team_exec.scheduler();
-        auto current_task = OptionalRef<task_base_type>(nullptr);
+        auto current_task    = OptionalRef<task_base_type>(nullptr);
 
         while (!queue.is_done()) {
           current_task =
@@ -128,11 +133,11 @@ public:
           }
         }
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
     }
 
-    sem.wait(num_worker_threads);
+    num_tasks_remaining.wait();
   }
 
   static uint32_t get_max_team_count(execution_space const &espace) {
@@ -142,11 +147,11 @@ public:
   template <typename TaskType>
   static void get_function_pointer(typename TaskType::function_type &ptr,
                                    typename TaskType::destroy_type &dtor) {
-    ptr = TaskType::apply;
+    ptr  = TaskType::apply;
     dtor = TaskType::destroy;
   }
 
-private:
+ private:
   const scheduler_type *scheduler;
 };
 
@@ -155,21 +160,21 @@ class TaskQueueSpecializationConstrained<
     Scheduler, typename std::enable_if<
                    std::is_same<typename Scheduler::execution_space,
                                 Kokkos::Experimental::HPX>::value>::type> {
-public:
+ public:
   using execution_space = Kokkos::Experimental::HPX;
-  using scheduler_type = Scheduler;
+  using scheduler_type  = Scheduler;
   using member_type =
       TaskTeamMemberAdapter<Kokkos::Impl::HPXTeamMember, scheduler_type>;
   using memory_space = Kokkos::HostSpace;
 
-  static void
-  iff_single_thread_recursive_execute(scheduler_type const &scheduler) {
+  static void iff_single_thread_recursive_execute(
+      scheduler_type const &scheduler) {
     using task_base_type = typename scheduler_type::task_base;
-    using queue_type = typename scheduler_type::queue_type;
+    using queue_type     = typename scheduler_type::queue_type;
 
     if (1 == Kokkos::Experimental::HPX::concurrency()) {
       task_base_type *const end = (task_base_type *)task_base_type::EndTag;
-      task_base_type *task = end;
+      task_base_type *task      = end;
 
       HPXTeamMember member(TeamPolicyInternal<Kokkos::Experimental::HPX>(
                                Kokkos::Experimental::HPX(), 1, 1),
@@ -187,8 +192,7 @@ public:
           }
         }
 
-        if (end == task)
-          break;
+        if (end == task) break;
 
         (*task->m_apply)(task, &single_exec);
 
@@ -210,11 +214,11 @@ public:
   // Must provide task queue execution function
   void execute_task() const {
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
     using task_base_type = typename scheduler_type::task_base;
-    using queue_type = typename scheduler_type::queue_type;
+    using queue_type     = typename scheduler_type::queue_type;
 
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
+    const int num_worker_threads     = Kokkos::Experimental::HPX::concurrency();
     static task_base_type *const end = (task_base_type *)task_base_type::EndTag;
     constexpr task_base_type *no_more_tasks_sentinel = nullptr;
 
@@ -224,10 +228,11 @@ public:
     auto &queue = scheduler->queue();
     queue.initialize_team_queues(num_worker_threads);
 
-    counting_semaphore sem(0);
+    latch num_tasks_remaining(num_worker_threads);
+    ChunkedRoundRobinExecutor exec(num_worker_threads);
 
     for (int thread = 0; thread < num_worker_threads; ++thread) {
-      apply([this, &sem, &buffer, num_worker_threads, thread]() {
+      apply(exec, [this, &num_tasks_remaining, &buffer, num_worker_threads]() {
         // NOTE: This implementation has been simplified based on the assumption
         // that team_size = 1. The HPX backend currently only supports a team
         // size of 1.
@@ -242,7 +247,7 @@ public:
         member_type single_exec(*scheduler, member);
         member_type &team_exec = single_exec;
 
-        auto &team_queue = team_exec.scheduler().queue();
+        auto &team_queue     = team_exec.scheduler().queue();
         task_base_type *task = no_more_tasks_sentinel;
 
         do {
@@ -266,21 +271,21 @@ public:
           }
         } while (task != no_more_tasks_sentinel);
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
     }
 
-    sem.wait(num_worker_threads);
+    num_tasks_remaining.wait();
   }
 
   template <typename TaskType>
   static void get_function_pointer(typename TaskType::function_type &ptr,
                                    typename TaskType::destroy_type &dtor) {
-    ptr = TaskType::apply;
+    ptr  = TaskType::apply;
     dtor = TaskType::destroy;
   }
 
-private:
+ private:
   const scheduler_type *scheduler;
 };
 
@@ -288,8 +293,8 @@ extern template class TaskQueue<
     Kokkos::Experimental::HPX,
     typename Kokkos::Experimental::HPX::memory_space>;
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIAvail.hpp b/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIAvail.hpp
index bbc1b33bf97cd153a13537c558460c12cd9eed45..99020a3e0de7d6847042749cd70b50c005496704 100644
--- a/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIAvail.hpp
+++ b/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIAvail.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Experimental::HPX
 
-#include<eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIDecl.hpp b/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIDecl.hpp
index aa1c2f15185ab653a39b14e994f57a903227e809..fae486f4b028ac160a07cf0da62905633369539b 100644
--- a/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIDecl.hpp
+++ b/lib/kokkos/core/src/HPX/Kokkos_HPX_ViewCopyETIDecl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Experimental::HPX
 
-#include<eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp b/lib/kokkos/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
index 4dd28dd994ca6884515b8af7a16cee622a489b89..6705005c1b931e177273b82942648c67b7efa383 100644
--- a/lib/kokkos/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
+++ b/lib/kokkos/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,8 +45,10 @@
 #ifndef KOKKOS_HPX_WORKGRAPHPOLICY_HPP
 #define KOKKOS_HPX_WORKGRAPHPOLICY_HPP
 
+#include <HPX/Kokkos_HPX_ChunkedRoundRobinExecutor.hpp>
+
 #include <hpx/apply.hpp>
-#include <hpx/lcos/local/counting_semaphore.hpp>
+#include <hpx/lcos/local/latch.hpp>
 
 namespace Kokkos {
 namespace Impl {
@@ -53,8 +56,8 @@ namespace Impl {
 template <class FunctorType, class... Traits>
 class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
                   Kokkos::Experimental::HPX> {
-private:
-  using Policy = Kokkos::WorkGraphPolicy<Traits...>;
+ private:
+  using Policy  = Kokkos::WorkGraphPolicy<Traits...>;
   using WorkTag = typename Policy::work_tag;
 
   Policy m_policy;
@@ -73,7 +76,7 @@ private:
     m_functor(t, w);
   }
 
-public:
+ public:
   void execute() const {
     dispatch_execute_task(this);
     Kokkos::Experimental::HPX().fence();
@@ -83,12 +86,13 @@ public:
     const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
 
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
 
-    counting_semaphore sem(0);
+    latch num_tasks_remaining(num_worker_threads);
+    ChunkedRoundRobinExecutor exec(num_worker_threads);
 
     for (int thread = 0; thread < num_worker_threads; ++thread) {
-      apply([this, &sem]() {
+      apply(exec, [this, &num_tasks_remaining]() {
         std::int32_t w = m_policy.pop_work();
         while (w != Policy::COMPLETED_TOKEN) {
           if (w != Policy::END_TOKEN) {
@@ -99,18 +103,18 @@ public:
           w = m_policy.pop_work();
         }
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
     }
 
-    sem.wait(num_worker_threads);
+    num_tasks_remaining.wait();
   }
 
   inline ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
       : m_policy(arg_policy), m_functor(arg_functor) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #define KOKKOS_HPX_WORKGRAPHPOLICY_HPP */
diff --git a/lib/kokkos/core/src/KokkosExp_MDRangePolicy.hpp b/lib/kokkos/core/src/KokkosExp_MDRangePolicy.hpp
index 1972aa485bd3242857486fd2bc8fc2ab4fbd1d1a..7981c04b4f411a0ec98ea4031a7ad85c55509ca4 100644
--- a/lib/kokkos/core/src/KokkosExp_MDRangePolicy.hpp
+++ b/lib/kokkos/core/src/KokkosExp_MDRangePolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,16 +49,16 @@
 
 #include <Kokkos_Layout.hpp>
 
-#include<impl/KokkosExp_Host_IterateTile.hpp>
+#include <impl/KokkosExp_Host_IterateTile.hpp>
 #include <Kokkos_ExecPolicy.hpp>
 #include <Kokkos_Parallel.hpp>
 
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
-#include<Cuda/KokkosExp_Cuda_IterateTile.hpp>
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
+#include <Cuda/KokkosExp_Cuda_IterateTile.hpp>
 #include <Cuda/KokkosExp_Cuda_IterateTile_Refactor.hpp>
 #endif
 
-#if defined( __HCC__ ) && defined( KOKKOS_ENABLE_ROCM )
+#if defined(__HCC__) && defined(KOKKOS_ENABLE_ROCM)
 //#include<ROCm/KokkosExp_ROCm_IterateTile.hpp>
 #include <ROCm/KokkosExp_ROCm_IterateTile_Refactor.hpp>
 #endif
@@ -76,583 +77,613 @@ enum class Iterate
 */
 
 template <typename ExecSpace>
-struct default_outer_direction
-{
+struct default_outer_direction {
   using type = Iterate;
-  #if defined( KOKKOS_ENABLE_CUDA)||defined( KOKKOS_ENABLE_ROCM)
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_ROCM)
   static constexpr Iterate value = Iterate::Left;
-  #else
+#else
   static constexpr Iterate value = Iterate::Right;
-  #endif
+#endif
 };
 
 template <typename ExecSpace>
-struct default_inner_direction
-{
+struct default_inner_direction {
   using type = Iterate;
-  #if defined( KOKKOS_ENABLE_CUDA)||defined( KOKKOS_ENABLE_ROCM)
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_ROCM)
   static constexpr Iterate value = Iterate::Left;
-  #else
+#else
   static constexpr Iterate value = Iterate::Right;
-  #endif
+#endif
 };
 
-
 // Iteration Pattern
-template < unsigned N
-         , Iterate OuterDir = Iterate::Default
-         , Iterate InnerDir = Iterate::Default
-         >
-struct Rank
-{
-  static_assert( N != 0u, "Kokkos Error: rank 0 undefined");
-  static_assert( N != 1u, "Kokkos Error: rank 1 is not a multi-dimensional range");
-  static_assert( N < 7u, "Kokkos Error: Unsupported rank...");
+template <unsigned N, Iterate OuterDir = Iterate::Default,
+          Iterate InnerDir = Iterate::Default>
+struct Rank {
+  static_assert(N != 0u, "Kokkos Error: rank 0 undefined");
+  static_assert(N != 1u,
+                "Kokkos Error: rank 1 is not a multi-dimensional range");
+  static_assert(N < 7u, "Kokkos Error: Unsupported rank...");
 
   using iteration_pattern = Rank<N, OuterDir, InnerDir>;
 
-  static constexpr int rank = N;
+  static constexpr int rank                = N;
   static constexpr Iterate outer_direction = OuterDir;
   static constexpr Iterate inner_direction = InnerDir;
 };
 
-
 // multi-dimensional iteration pattern
 template <typename... Properties>
-struct MDRangePolicy
-  : public Kokkos::Impl::PolicyTraits<Properties ...>
-{
-  using traits = Kokkos::Impl::PolicyTraits<Properties ...>;
+struct MDRangePolicy : public Kokkos::Impl::PolicyTraits<Properties...> {
+  using traits       = Kokkos::Impl::PolicyTraits<Properties...>;
   using range_policy = RangePolicy<Properties...>;
 
   typename traits::execution_space m_space;
 
-  using impl_range_policy = RangePolicy< typename traits::execution_space
-                                       , typename traits::schedule_type
-                                       , typename traits::index_type
-                                       > ;
+  using impl_range_policy =
+      RangePolicy<typename traits::execution_space,
+                  typename traits::schedule_type, typename traits::index_type>;
 
-  typedef MDRangePolicy execution_policy; // needed for is_execution_space interrogation
+  typedef MDRangePolicy
+      execution_policy;  // needed for is_execution_space interrogation
 
-  template<class ... OtherProperties>
+  template <class... OtherProperties>
   friend struct MDRangePolicy;
 
-  static_assert( !std::is_same<typename traits::iteration_pattern,void>::value
-               , "Kokkos Error: MD iteration pattern not defined" );
+  static_assert(!std::is_same<typename traits::iteration_pattern, void>::value,
+                "Kokkos Error: MD iteration pattern not defined");
 
-  using iteration_pattern   = typename traits::iteration_pattern;
-  using work_tag            = typename traits::work_tag;
-  using launch_bounds       = typename traits::launch_bounds;
-  using member_type = typename range_policy::member_type;
+  using iteration_pattern = typename traits::iteration_pattern;
+  using work_tag          = typename traits::work_tag;
+  using launch_bounds     = typename traits::launch_bounds;
+  using member_type       = typename range_policy::member_type;
 
   enum { rank = static_cast<int>(iteration_pattern::rank) };
 
-  using index_type  = typename traits::index_type;
+  using index_type       = typename traits::index_type;
   using array_index_type = long;
-  using point_type  = Kokkos::Array<array_index_type,rank>; //was index_type
-  using tile_type   = Kokkos::Array<array_index_type,rank>;
-  // If point_type or tile_type is not templated on a signed integral type (if it is unsigned), 
-  // then if user passes in intializer_list of runtime-determined values of 
-  // signed integral type that are not const will receive a compiler error due 
-  // to an invalid case for implicit conversion - 
-  // "conversion from integer or unscoped enumeration type to integer type that cannot represent all values of the original, except where source is a constant expression whose value can be stored exactly in the target type"
+  using point_type = Kokkos::Array<array_index_type, rank>;  // was index_type
+  using tile_type  = Kokkos::Array<array_index_type, rank>;
+  // If point_type or tile_type is not templated on a signed integral type (if
+  // it is unsigned), then if user passes in intializer_list of
+  // runtime-determined values of signed integral type that are not const will
+  // receive a compiler error due to an invalid case for implicit conversion -
+  // "conversion from integer or unscoped enumeration type to integer type that
+  // cannot represent all values of the original, except where source is a
+  // constant expression whose value can be stored exactly in the target type"
   // This would require the user to either pass a matching index_type parameter
-  // as template parameter to the MDRangePolicy or static_cast the individual values
+  // as template parameter to the MDRangePolicy or static_cast the individual
+  // values
 
   point_type m_lower;
   point_type m_upper;
-  tile_type  m_tile;
+  tile_type m_tile;
   point_type m_tile_end;
   index_type m_num_tiles;
   index_type m_prod_tile_dims;
 
-/*
-  // NDE enum impl definition alternative - replace static constexpr int ? 
-  enum { outer_direction = static_cast<int> (
-      (iteration_pattern::outer_direction != Iterate::Default)
-    ? iteration_pattern::outer_direction
-    : default_outer_direction< typename traits::execution_space>::value ) };
+  /*
+    // NDE enum impl definition alternative - replace static constexpr int ?
+    enum { outer_direction = static_cast<int> (
+        (iteration_pattern::outer_direction != Iterate::Default)
+      ? iteration_pattern::outer_direction
+      : default_outer_direction< typename traits::execution_space>::value ) };
 
-  enum { inner_direction = static_cast<int> (
-      iteration_pattern::inner_direction != Iterate::Default
-    ? iteration_pattern::inner_direction
-    : default_inner_direction< typename traits::execution_space>::value ) };
+    enum { inner_direction = static_cast<int> (
+        iteration_pattern::inner_direction != Iterate::Default
+      ? iteration_pattern::inner_direction
+      : default_inner_direction< typename traits::execution_space>::value ) };
 
-  enum { Right = static_cast<int>( Iterate::Right ) };
-  enum { Left  = static_cast<int>( Iterate::Left ) };
-*/
-  //static constexpr int rank = iteration_pattern::rank;
+    enum { Right = static_cast<int>( Iterate::Right ) };
+    enum { Left  = static_cast<int>( Iterate::Left ) };
+  */
+  // static constexpr int rank = iteration_pattern::rank;
 
-  static constexpr int outer_direction = static_cast<int> (
+  static constexpr int outer_direction = static_cast<int>(
       (iteration_pattern::outer_direction != Iterate::Default)
-    ? iteration_pattern::outer_direction
-    : default_outer_direction< typename traits::execution_space>::value );
+          ? iteration_pattern::outer_direction
+          : default_outer_direction<typename traits::execution_space>::value);
 
-  static constexpr int inner_direction = static_cast<int> (
+  static constexpr int inner_direction = static_cast<int>(
       iteration_pattern::inner_direction != Iterate::Default
-    ? iteration_pattern::inner_direction
-    : default_inner_direction< typename traits::execution_space>::value ) ;
+          ? iteration_pattern::inner_direction
+          : default_inner_direction<typename traits::execution_space>::value);
 
   // Ugly ugly workaround intel 14 not handling scoped enum correctly
-  static constexpr int Right = static_cast<int>( Iterate::Right );
-  static constexpr int Left  = static_cast<int>( Iterate::Left );
+  static constexpr int Right = static_cast<int>(Iterate::Right);
+  static constexpr int Left  = static_cast<int>(Iterate::Left);
 
-  KOKKOS_INLINE_FUNCTION const typename traits::execution_space & space() const { return m_space ; }
-  template < typename LT , typename UT , typename TT = array_index_type >
-  MDRangePolicy(std::initializer_list<LT> const& lower, std::initializer_list<UT> const& upper, std::initializer_list<TT> const& tile = {} )
-    : m_space() {
+  KOKKOS_INLINE_FUNCTION const typename traits::execution_space& space() const {
+    return m_space;
+  }
+  template <typename LT, typename UT, typename TT = array_index_type>
+  MDRangePolicy(std::initializer_list<LT> const& lower,
+                std::initializer_list<UT> const& upper,
+                std::initializer_list<TT> const& tile = {})
+      : m_space() {
     init(lower, upper, tile);
   }
 
-  template < typename LT , typename UT , typename TT = array_index_type >
-  MDRangePolicy(const typename traits::execution_space & work_space,
-    std::initializer_list<LT> const& lower, std::initializer_list<UT> const& upper, std::initializer_list<TT> const& tile = {} )
-    : m_space( work_space ) {
+  template <typename LT, typename UT, typename TT = array_index_type>
+  MDRangePolicy(const typename traits::execution_space& work_space,
+                std::initializer_list<LT> const& lower,
+                std::initializer_list<UT> const& upper,
+                std::initializer_list<TT> const& tile = {})
+      : m_space(work_space) {
     init(lower, upper, tile);
   }
 
-  MDRangePolicy( point_type const& lower, point_type const& upper, tile_type const& tile = tile_type{} )
-    : m_space()
-    , m_lower(lower)
-    , m_upper(upper)
-    , m_tile(tile)
-    , m_num_tiles(1)
-    , m_prod_tile_dims(1) {
+  MDRangePolicy(point_type const& lower, point_type const& upper,
+                tile_type const& tile = tile_type{})
+      : m_space(),
+        m_lower(lower),
+        m_upper(upper),
+        m_tile(tile),
+        m_num_tiles(1),
+        m_prod_tile_dims(1) {
     init();
   }
 
-  MDRangePolicy( const typename traits::execution_space & work_space,
-    point_type const& lower, point_type const& upper, tile_type const& tile = tile_type{} )
-    : m_space( work_space )
-    , m_lower(lower)
-    , m_upper(upper)
-    , m_tile(tile)
-    , m_num_tiles(1)
-    , m_prod_tile_dims(1) {
+  MDRangePolicy(const typename traits::execution_space& work_space,
+                point_type const& lower, point_type const& upper,
+                tile_type const& tile = tile_type{})
+      : m_space(work_space),
+        m_lower(lower),
+        m_upper(upper),
+        m_tile(tile),
+        m_num_tiles(1),
+        m_prod_tile_dims(1) {
     init();
   }
 
-  template<class ... OtherProperties>
-  MDRangePolicy( const MDRangePolicy<OtherProperties...> p ):
-     m_space(p.m_space),
-     m_lower(p.m_lower),
-     m_upper(p.m_upper),
-     m_tile(p.m_tile),
-     m_tile_end(p.m_tile_end),
-     m_num_tiles(p.m_num_tiles),
-     m_prod_tile_dims(p.m_prod_tile_dims) {}
-
-private:
-
+  template <class... OtherProperties>
+  MDRangePolicy(const MDRangePolicy<OtherProperties...> p)
+      : m_space(p.m_space),
+        m_lower(p.m_lower),
+        m_upper(p.m_upper),
+        m_tile(p.m_tile),
+        m_tile_end(p.m_tile_end),
+        m_num_tiles(p.m_num_tiles),
+        m_prod_tile_dims(p.m_prod_tile_dims) {}
+
+ private:
   void init() {
     // Host
-    if ( true
-       #if defined(KOKKOS_ENABLE_CUDA)
-         && !std::is_same< typename traits::execution_space, Kokkos::Cuda >::value
-       #endif
-       #if defined(KOKKOS_ENABLE_ROCM)
-         && !std::is_same< typename traits::execution_space, Kokkos::Experimental::ROCm >::value
-       #endif
-       )
-    {
+    if (true
+#if defined(KOKKOS_ENABLE_CUDA)
+        && !std::is_same<typename traits::execution_space, Kokkos::Cuda>::value
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+        && !std::is_same<typename traits::execution_space,
+                         Kokkos::Experimental::ROCm>::value
+#endif
+    ) {
       index_type span;
-      for (int i=0; i<rank; ++i) {
+      for (int i = 0; i < rank; ++i) {
         span = m_upper[i] - m_lower[i];
-        if ( m_tile[i] <= 0 ) {
-          if (  ((int)inner_direction == (int)Right && (i < rank-1))
-              || ((int)inner_direction == (int)Left && (i > 0)) )
-          {
+        if (m_tile[i] <= 0) {
+          if (((int)inner_direction == (int)Right && (i < rank - 1)) ||
+              ((int)inner_direction == (int)Left && (i > 0))) {
             m_tile[i] = 2;
-          }
-          else {
+          } else {
             m_tile[i] = (span == 0 ? 1 : span);
           }
         }
-        m_tile_end[i] = static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
+        m_tile_end[i] =
+            static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
         m_num_tiles *= m_tile_end[i];
         m_prod_tile_dims *= m_tile[i];
       }
     }
-    #if defined(KOKKOS_ENABLE_CUDA)
-    else // Cuda
+#if defined(KOKKOS_ENABLE_CUDA)
+    else  // Cuda
     {
       index_type span;
-      int increment = 1;
+      int increment  = 1;
       int rank_start = 0;
-      int rank_end = rank;
-      if((int)inner_direction == (int)Right) {
-        increment = -1;
-        rank_start = rank-1;
-        rank_end = -1;
+      int rank_end   = rank;
+      if ((int)inner_direction == (int)Right) {
+        increment  = -1;
+        rank_start = rank - 1;
+        rank_end   = -1;
       }
-      for (int i=rank_start; i!=rank_end; i+=increment) {
+      for (int i = rank_start; i != rank_end; i += increment) {
         span = m_upper[i] - m_lower[i];
-        if ( m_tile[i] <= 0 ) {
+        if (m_tile[i] <= 0) {
           // TODO: determine what is a good default tile size for cuda
           // may be rank dependent
-          if (  ((int)inner_direction == (int)Right && (i < rank-1))
-              || ((int)inner_direction == (int)Left && (i > 0)) )
-          {
-            if ( m_prod_tile_dims < 256 ) {
+          if (((int)inner_direction == (int)Right && (i < rank - 1)) ||
+              ((int)inner_direction == (int)Left && (i > 0))) {
+            if (m_prod_tile_dims < 256) {
               m_tile[i] = 2;
             } else {
               m_tile[i] = 1;
             }
-          }
-          else {
+          } else {
             m_tile[i] = 16;
           }
         }
-        m_tile_end[i] = static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
+        m_tile_end[i] =
+            static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
         m_num_tiles *= m_tile_end[i];
         m_prod_tile_dims *= m_tile[i];
       }
-      if ( m_prod_tile_dims > 1024 ) { // Match Cuda restriction for ParallelReduce; 1024,1024,64 max per dim (Kepler), but product num_threads < 1024
+      if (m_prod_tile_dims >
+          1024) {  // Match Cuda restriction for ParallelReduce; 1024,1024,64
+                   // max per dim (Kepler), but product num_threads < 1024
         printf(" Tile dimensions exceed Cuda limits\n");
-        Kokkos::abort(" Cuda ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
-        //Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
+        Kokkos::abort(
+            " Cuda ExecSpace Error: MDRange tile dims exceed maximum number of "
+            "threads per block - choose smaller tile dims");
+        // Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error:
+        // MDRange tile dims exceed maximum number of threads per block - choose
+        // smaller tile dims");
       }
     }
-    #endif
-    #if defined(KOKKOS_ENABLE_ROCM)
-    else // ROCm
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+    else  // ROCm
     {
       index_type span;
-      int increment = 1;
+      int increment  = 1;
       int rank_start = 0;
-      int rank_end = rank;
-      if((int)inner_direction == (int)Right) {
-        increment = -1;
-        rank_start = rank-1;
-        rank_end = -1;
+      int rank_end   = rank;
+      if ((int)inner_direction == (int)Right) {
+        increment  = -1;
+        rank_start = rank - 1;
+        rank_end   = -1;
       }
-      for (int i=rank_start; i!=rank_end; i+=increment) {
+      for (int i = rank_start; i != rank_end; i += increment) {
         span = m_upper[i] - m_lower[i];
-        if ( m_tile[i] <= 0 ) {
+        if (m_tile[i] <= 0) {
           // TODO: determine what is a good default tile size for rocm
           // may be rank dependent
-          if (  ((int)inner_direction == (int)Right && (i < rank-1))
-              || ((int)inner_direction == (int)Left && (i > 0)) )
-          {
-            if ( m_prod_tile_dims < 256 ) {
+          if (((int)inner_direction == (int)Right && (i < rank - 1)) ||
+              ((int)inner_direction == (int)Left && (i > 0))) {
+            if (m_prod_tile_dims < 256) {
               m_tile[i] = 4;
             } else {
               m_tile[i] = 1;
             }
-          }
-          else {
+          } else {
             m_tile[i] = 16;
           }
         }
-        m_tile_end[i] = static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
+        m_tile_end[i] =
+            static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
         m_num_tiles *= m_tile_end[i];
         m_prod_tile_dims *= m_tile[i];
       }
-      if ( m_prod_tile_dims > 1024 ) { //but product num_threads < 1024
+      if (m_prod_tile_dims > 1024) {  // but product num_threads < 1024
         printf(" Tile dimensions exceed ROCm limits\n");
-        Kokkos::abort(" ROCm ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
-        //Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
+        Kokkos::abort(
+            " ROCm ExecSpace Error: MDRange tile dims exceed maximum number of "
+            "threads per block - choose smaller tile dims");
+        // Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error:
+        // MDRange tile dims exceed maximum number of threads per block - choose
+        // smaller tile dims");
       }
     }
-    #endif
+#endif
   }
 
-  template < typename LT , typename UT , typename TT = array_index_type >
-  void init( std::initializer_list<LT> const& lower, std::initializer_list<UT> const& upper, std::initializer_list<TT> const& tile = {} )
-  {
-    if(static_cast<int>(m_lower.size()) != rank || static_cast<int>(m_upper.size()) != rank)
-      Kokkos::abort("MDRangePolicy: Constructor initializer lists have wrong size");
+  template <typename LT, typename UT, typename TT = array_index_type>
+  void init(std::initializer_list<LT> const& lower,
+            std::initializer_list<UT> const& upper,
+            std::initializer_list<TT> const& tile = {}) {
+    if (static_cast<int>(m_lower.size()) != rank ||
+        static_cast<int>(m_upper.size()) != rank)
+      Kokkos::abort(
+          "MDRangePolicy: Constructor initializer lists have wrong size");
 
-    for ( auto i = 0; i < rank; ++i ) {
+    for (auto i = 0; i < rank; ++i) {
       m_lower[i] = static_cast<array_index_type>(lower.begin()[i]);
       m_upper[i] = static_cast<array_index_type>(upper.begin()[i]);
-      if(static_cast<int>(tile.size())==rank)
+      if (static_cast<int>(tile.size()) == rank)
         m_tile[i] = static_cast<array_index_type>(tile.begin()[i]);
       else
         m_tile[i] = 0;
     }
 
-    m_num_tiles = 1;
+    m_num_tiles      = 1;
     m_prod_tile_dims = 1;
 
     // Host
-    if ( true
-       #if defined(KOKKOS_ENABLE_CUDA)
-         && !std::is_same< typename traits::execution_space, Kokkos::Cuda >::value
-       #endif
-       #if defined(KOKKOS_ENABLE_ROCM)
-         && !std::is_same< typename traits::execution_space, Kokkos::Experimental::ROCm >::value
-       #endif
-       )
-    {
+    if (true
+#if defined(KOKKOS_ENABLE_CUDA)
+        && !std::is_same<typename traits::execution_space, Kokkos::Cuda>::value
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+        && !std::is_same<typename traits::execution_space,
+                         Kokkos::Experimental::ROCm>::value
+#endif
+    ) {
       index_type span;
-      for (int i=0; i<rank; ++i) {
+      for (int i = 0; i < rank; ++i) {
         span = m_upper[i] - m_lower[i];
-        if ( m_tile[i] <= 0 ) {
-          if (  ((int)inner_direction == (int)Right && (i < rank-1))
-              || ((int)inner_direction == (int)Left && (i > 0)) )
-          {
+        if (m_tile[i] <= 0) {
+          if (((int)inner_direction == (int)Right && (i < rank - 1)) ||
+              ((int)inner_direction == (int)Left && (i > 0))) {
             m_tile[i] = 2;
-          }
-          else {
+          } else {
             m_tile[i] = (span == 0 ? 1 : span);
           }
         }
-        m_tile_end[i] = static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
+        m_tile_end[i] =
+            static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
         m_num_tiles *= m_tile_end[i];
         m_prod_tile_dims *= m_tile[i];
       }
     }
-    #if defined(KOKKOS_ENABLE_CUDA)
-    else // Cuda
+#if defined(KOKKOS_ENABLE_CUDA)
+    else  // Cuda
     {
       index_type span;
-      int increment = 1;
+      int increment  = 1;
       int rank_start = 0;
-      int rank_end = rank;
-      if((int)inner_direction == (int)Right) {
-        increment = -1;
-        rank_start = rank-1;
-        rank_end = -1;
+      int rank_end   = rank;
+      if ((int)inner_direction == (int)Right) {
+        increment  = -1;
+        rank_start = rank - 1;
+        rank_end   = -1;
       }
-      for (int i=rank_start; i!=rank_end; i+=increment) {
+      for (int i = rank_start; i != rank_end; i += increment) {
         span = m_upper[i] - m_lower[i];
-        if ( m_tile[i] <= 0 ) {
+        if (m_tile[i] <= 0) {
           // TODO: determine what is a good default tile size for cuda
           // may be rank dependent
-          if (  ((int)inner_direction == (int)Right && (i < rank-1))
-              || ((int)inner_direction == (int)Left && (i > 0)) )
-          {
-            if ( m_prod_tile_dims < 256 ) {
+          if (((int)inner_direction == (int)Right && (i < rank - 1)) ||
+              ((int)inner_direction == (int)Left && (i > 0))) {
+            if (m_prod_tile_dims < 256) {
               m_tile[i] = 2;
             } else {
               m_tile[i] = 1;
             }
-          }
-          else {
+          } else {
             m_tile[i] = 16;
           }
         }
-        m_tile_end[i] = static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
+        m_tile_end[i] =
+            static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
         m_num_tiles *= m_tile_end[i];
         m_prod_tile_dims *= m_tile[i];
       }
-      if ( m_prod_tile_dims > 1024 ) { // Match Cuda restriction for ParallelReduce; 1024,1024,64 max per dim (Kepler), but product num_threads < 1024
+      if (m_prod_tile_dims >
+          1024) {  // Match Cuda restriction for ParallelReduce; 1024,1024,64
+                   // max per dim (Kepler), but product num_threads < 1024
         printf(" Tile dimensions exceed Cuda limits\n");
-        Kokkos::abort(" Cuda ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
-        //Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
+        Kokkos::abort(
+            " Cuda ExecSpace Error: MDRange tile dims exceed maximum number of "
+            "threads per block - choose smaller tile dims");
+        // Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error:
+        // MDRange tile dims exceed maximum number of threads per block - choose
+        // smaller tile dims");
       }
     }
-    #endif
-    #if defined(KOKKOS_ENABLE_ROCM)
-    else // ROCm
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+    else  // ROCm
     {
       index_type span;
-      int increment = 1;
+      int increment  = 1;
       int rank_start = 0;
-      int rank_end = rank;
-      if((int)inner_direction == (int)Right) {
-        increment = -1;
-        rank_start = rank-1;
-        rank_end = -1;
+      int rank_end   = rank;
+      if ((int)inner_direction == (int)Right) {
+        increment  = -1;
+        rank_start = rank - 1;
+        rank_end   = -1;
       }
-      for (int i=rank_start; i!=rank_end; i+=increment) {
+      for (int i = rank_start; i != rank_end; i += increment) {
         span = m_upper[i] - m_lower[i];
-        if ( m_tile[i] <= 0 ) {
+        if (m_tile[i] <= 0) {
           // TODO: determine what is a good default tile size for cuda
           // may be rank dependent
-          if (  ((int)inner_direction == (int)Right && (i < rank-1))
-              || ((int)inner_direction == (int)Left && (i > 0)) )
-          {
-            if ( m_prod_tile_dims < 256 ) {
+          if (((int)inner_direction == (int)Right && (i < rank - 1)) ||
+              ((int)inner_direction == (int)Left && (i > 0))) {
+            if (m_prod_tile_dims < 256) {
               m_tile[i] = 2;
             } else {
               m_tile[i] = 1;
             }
-          }
-          else {
+          } else {
             m_tile[i] = 16;
           }
         }
-        m_tile_end[i] = static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
+        m_tile_end[i] =
+            static_cast<index_type>((span + m_tile[i] - 1) / m_tile[i]);
         m_num_tiles *= m_tile_end[i];
         m_prod_tile_dims *= m_tile[i];
       }
-      if ( m_prod_tile_dims > 1024 ) { // Match ROCm restriction for ParallelReduce; 1024,1024,1024 max per dim , but product num_threads < 1024
+      if (m_prod_tile_dims >
+          1024) {  // Match ROCm restriction for ParallelReduce; 1024,1024,1024
+                   // max per dim , but product num_threads < 1024
         printf(" Tile dimensions exceed ROCm limits\n");
-        Kokkos::abort(" ROCm ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
-        //Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error: MDRange tile dims exceed maximum number of threads per block - choose smaller tile dims");
+        Kokkos::abort(
+            " ROCm ExecSpace Error: MDRange tile dims exceed maximum number of "
+            "threads per block - choose smaller tile dims");
+        // Kokkos::Impl::throw_runtime_exception( " Cuda ExecSpace Error:
+        // MDRange tile dims exceed maximum number of threads per block - choose
+        // smaller tile dims");
       }
     }
-    #endif
+#endif
   }
-
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 // For backward compatibility
-namespace Kokkos { namespace Experimental {
-  using Kokkos::MDRangePolicy;
-  using Kokkos::Rank;
-  using Kokkos::Iterate;
-} } // end Kokkos::Experimental
+namespace Kokkos {
+namespace Experimental {
+using Kokkos::Iterate;
+using Kokkos::MDRangePolicy;
+using Kokkos::Rank;
+}  // namespace Experimental
+}  // namespace Kokkos
 // ------------------------------------------------------------------ //
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
 // ------------------------------------------------------------------ //
-//md_parallel_for - deprecated use parallel_for
+// md_parallel_for - deprecated use parallel_for
 // ------------------------------------------------------------------ //
 
-namespace Kokkos { namespace Experimental {
+namespace Kokkos {
+namespace Experimental {
 
 template <typename MDRange, typename Functor, typename Enable = void>
-void md_parallel_for( MDRange const& range
-                    , Functor const& f
-                    , const std::string& str = ""
-                    , typename std::enable_if<( true
-                      #if defined( KOKKOS_ENABLE_CUDA)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Cuda>::value
-                      #endif
-                      #if defined( KOKKOS_ENABLE_ROCM)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Experimental::ROCm>::value
-                      #endif
-                      ) >::type* = 0
-                    )
-{
+void md_parallel_for(
+    MDRange const& range, Functor const& f, const std::string& str = "",
+    typename std::enable_if<
+        (true
+#if defined(KOKKOS_ENABLE_CUDA)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Cuda>::value
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Experimental::ROCm>::value
+#endif
+         )>::type* = 0) {
   Kokkos::Impl::Experimental::MDFunctor<MDRange, Functor, void> g(range, f);
 
   using range_policy = typename MDRange::impl_range_policy;
 
-  Kokkos::parallel_for( range_policy(0, range.m_num_tiles).set_chunk_size(1), g, str );
+  Kokkos::parallel_for(range_policy(0, range.m_num_tiles).set_chunk_size(1), g,
+                       str);
 }
 
 template <typename MDRange, typename Functor>
-void md_parallel_for( const std::string& str
-                    , MDRange const& range
-                    , Functor const& f
-                    , typename std::enable_if<( true
-                      #if defined( KOKKOS_ENABLE_CUDA)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Cuda>::value
-                      #endif
-                      #if defined( KOKKOS_ENABLE_ROCM)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Experimental::ROCm>::value
-                      #endif
-                      ) >::type* = 0
-                    )
-{
+void md_parallel_for(
+    const std::string& str, MDRange const& range, Functor const& f,
+    typename std::enable_if<
+        (true
+#if defined(KOKKOS_ENABLE_CUDA)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Cuda>::value
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Experimental::ROCm>::value
+#endif
+         )>::type* = 0) {
   Kokkos::Impl::Experimental::MDFunctor<MDRange, Functor, void> g(range, f);
 
   using range_policy = typename MDRange::impl_range_policy;
 
-  Kokkos::parallel_for( range_policy(0, range.m_num_tiles).set_chunk_size(1), g, str );
+  Kokkos::parallel_for(range_policy(0, range.m_num_tiles).set_chunk_size(1), g,
+                       str);
 }
 
 // Cuda specialization
-#if defined( __CUDACC__ ) && defined( KOKKOS_ENABLE_CUDA )
+#if defined(__CUDACC__) && defined(KOKKOS_ENABLE_CUDA)
 template <typename MDRange, typename Functor>
-void md_parallel_for( const std::string& str
-                    , MDRange const& range
-                    , Functor const& f
-                    , typename std::enable_if<( true
-                      #if defined( KOKKOS_ENABLE_CUDA)
-                      && std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Cuda>::value
-                      #endif
-                      ) >::type* = 0
-                    )
-{
-  Kokkos::Impl::DeviceIterateTile<MDRange, Functor, typename MDRange::work_tag> closure(range, f);
+void md_parallel_for(
+    const std::string& str, MDRange const& range, Functor const& f,
+    typename std::enable_if<
+        (true
+#if defined(KOKKOS_ENABLE_CUDA)
+         && std::is_same<typename MDRange::range_policy::execution_space,
+                         Kokkos::Cuda>::value
+#endif
+         )>::type* = 0) {
+  Kokkos::Impl::DeviceIterateTile<MDRange, Functor, typename MDRange::work_tag>
+      closure(range, f);
   closure.execute();
 }
 
 template <typename MDRange, typename Functor>
-void md_parallel_for( MDRange const& range
-                    , Functor const& f
-                    , const std::string& str = ""
-                    , typename std::enable_if<( true
-                      #if defined( KOKKOS_ENABLE_CUDA)
-                      && std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Cuda>::value
-                      #endif
-                      ) >::type* = 0
-                    )
-{
-  Kokkos::Impl::DeviceIterateTile<MDRange, Functor, typename MDRange::work_tag> closure(range, f);
+void md_parallel_for(
+    MDRange const& range, Functor const& f, const std::string& str = "",
+    typename std::enable_if<
+        (true
+#if defined(KOKKOS_ENABLE_CUDA)
+         && std::is_same<typename MDRange::range_policy::execution_space,
+                         Kokkos::Cuda>::value
+#endif
+         )>::type* = 0) {
+  Kokkos::Impl::DeviceIterateTile<MDRange, Functor, typename MDRange::work_tag>
+      closure(range, f);
   closure.execute();
 }
 #endif
 // ------------------------------------------------------------------ //
 
 // ------------------------------------------------------------------ //
-//md_parallel_reduce - deprecated use parallel_reduce
+// md_parallel_reduce - deprecated use parallel_reduce
 // ------------------------------------------------------------------ //
 template <typename MDRange, typename Functor, typename ValueType>
-void md_parallel_reduce( MDRange const& range
-                    , Functor const& f
-                    , ValueType & v
-                    , const std::string& str = ""
-                    , typename std::enable_if<( true
-                      #if defined( KOKKOS_ENABLE_CUDA)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Cuda>::value
-                      #endif
-                      #if defined( KOKKOS_ENABLE_ROCM)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Experimental::ROCm>::value
-                      #endif
-                      ) >::type* = 0
-                    )
-{
-  Kokkos::Impl::Experimental::MDFunctor<MDRange, Functor, ValueType> g(range, f);
+void md_parallel_reduce(
+    MDRange const& range, Functor const& f, ValueType& v,
+    const std::string& str = "",
+    typename std::enable_if<
+        (true
+#if defined(KOKKOS_ENABLE_CUDA)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Cuda>::value
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Experimental::ROCm>::value
+#endif
+         )>::type* = 0) {
+  Kokkos::Impl::Experimental::MDFunctor<MDRange, Functor, ValueType> g(range,
+                                                                       f);
 
   using range_policy = typename MDRange::impl_range_policy;
-  Kokkos::parallel_reduce( str, range_policy(0, range.m_num_tiles).set_chunk_size(1), g, v );
+  Kokkos::parallel_reduce(
+      str, range_policy(0, range.m_num_tiles).set_chunk_size(1), g, v);
 }
 
 template <typename MDRange, typename Functor, typename ValueType>
-void md_parallel_reduce( const std::string& str
-                    , MDRange const& range
-                    , Functor const& f
-                    , ValueType & v
-                    , typename std::enable_if<( true
-                      #if defined( KOKKOS_ENABLE_CUDA)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Cuda>::value
-                      #endif
-                      #if defined( KOKKOS_ENABLE_ROCM)
-                      && !std::is_same< typename MDRange::range_policy::execution_space, Kokkos::Experimental::ROCm>::value
-                      #endif
-                      ) >::type* = 0
-                    )
-{
-  Kokkos::Impl::Experimental::MDFunctor<MDRange, Functor, ValueType> g(range, f);
+void md_parallel_reduce(
+    const std::string& str, MDRange const& range, Functor const& f,
+    ValueType& v,
+    typename std::enable_if<
+        (true
+#if defined(KOKKOS_ENABLE_CUDA)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Cuda>::value
+#endif
+#if defined(KOKKOS_ENABLE_ROCM)
+         && !std::is_same<typename MDRange::range_policy::execution_space,
+                          Kokkos::Experimental::ROCm>::value
+#endif
+         )>::type* = 0) {
+  Kokkos::Impl::Experimental::MDFunctor<MDRange, Functor, ValueType> g(range,
+                                                                       f);
 
   using range_policy = typename MDRange::impl_range_policy;
 
-  Kokkos::parallel_reduce( str, range_policy(0, range.m_num_tiles).set_chunk_size(1), g, v );
+  Kokkos::parallel_reduce(
+      str, range_policy(0, range.m_num_tiles).set_chunk_size(1), g, v);
 }
 
 // Cuda - md_parallel_reduce not implemented - use parallel_reduce
 
-} } // namespace Kokkos::Experimental
+}  // namespace Experimental
+}  // namespace Kokkos
 #endif
 
 namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template<unsigned long P, class ... Properties>
-struct PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,MDRangePolicy<Properties...>> {
+template <unsigned long P, class... Properties>
+struct PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,
+                             MDRangePolicy<Properties...>> {
   typedef MDRangePolicy<Properties...> policy_in_t;
   typedef MDRangePolicy<typename policy_in_t::traits::execution_space,
-                      typename policy_in_t::traits::schedule_type,
-                      typename policy_in_t::traits::work_tag,
-                      typename policy_in_t::traits::index_type,
-                      typename policy_in_t::traits::iteration_pattern,
-                      typename policy_in_t::traits::launch_bounds,
-                      WorkItemProperty::ImplWorkItemProperty<P>> policy_out_t;
+                        typename policy_in_t::traits::schedule_type,
+                        typename policy_in_t::traits::work_tag,
+                        typename policy_in_t::traits::index_type,
+                        typename policy_in_t::traits::iteration_pattern,
+                        typename policy_in_t::traits::launch_bounds,
+                        WorkItemProperty::ImplWorkItemProperty<P>>
+      policy_out_t;
 };
 
-}
-}
-}
-
-
-#endif //KOKKOS_CORE_EXP_MD_RANGE_POLICY_HPP
+}  // namespace Impl
+}  // namespace Experimental
+}  // namespace Kokkos
 
+#endif  // KOKKOS_CORE_EXP_MD_RANGE_POLICY_HPP
diff --git a/lib/kokkos/core/src/Kokkos_AnonymousSpace.hpp b/lib/kokkos/core/src/Kokkos_AnonymousSpace.hpp
index c34515899663a3ff009b3ca23f4ece0ed4e03441..a4e887668f0f22c45a87ffdefc2d2c7b90c1fa87 100644
--- a/lib/kokkos/core/src/Kokkos_AnonymousSpace.hpp
+++ b/lib/kokkos/core/src/Kokkos_AnonymousSpace.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,28 +54,28 @@
 namespace Kokkos {
 
 class AnonymousSpace {
-public:
+ public:
   //! Tag this class as a kokkos memory space
-  typedef AnonymousSpace  memory_space;
+  typedef AnonymousSpace memory_space;
   typedef Kokkos::DefaultExecutionSpace execution_space;
-  typedef size_t     size_type;
+  typedef size_t size_type;
 
   //! This memory space preferred device_type
-  typedef Kokkos::Device< execution_space, memory_space > device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
   /**\brief  Default memory space instance */
-  AnonymousSpace() = default;
-  AnonymousSpace( AnonymousSpace && rhs ) = default;
-  AnonymousSpace( const AnonymousSpace & rhs ) = default;
-  AnonymousSpace & operator = ( AnonymousSpace && ) = default;
-  AnonymousSpace & operator = ( const AnonymousSpace & ) = default;
-  ~AnonymousSpace() = default;
+  AnonymousSpace()                          = default;
+  AnonymousSpace(AnonymousSpace &&rhs)      = default;
+  AnonymousSpace(const AnonymousSpace &rhs) = default;
+  AnonymousSpace &operator=(AnonymousSpace &&) = default;
+  AnonymousSpace &operator=(const AnonymousSpace &) = default;
+  ~AnonymousSpace()                                 = default;
 
   /**\brief Return Name of the MemorySpace */
-  static constexpr const char* name() { return "Anonymous"; }
+  static constexpr const char *name() { return "Anonymous"; }
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -82,46 +83,43 @@ namespace Kokkos {
 
 namespace Impl {
 
-template<typename OtherSpace>
-struct MemorySpaceAccess< Kokkos::AnonymousSpace , OtherSpace > {
+template <typename OtherSpace>
+struct MemorySpaceAccess<Kokkos::AnonymousSpace, OtherSpace> {
   enum { assignable = true };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<typename OtherSpace>
-struct MemorySpaceAccess<  OtherSpace, Kokkos::AnonymousSpace > {
+template <typename OtherSpace>
+struct MemorySpaceAccess<OtherSpace, Kokkos::AnonymousSpace> {
   enum { assignable = true };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess<  Kokkos::AnonymousSpace, Kokkos::AnonymousSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::AnonymousSpace, Kokkos::AnonymousSpace> {
   enum { assignable = true };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<typename OtherSpace>
-struct VerifyExecutionCanAccessMemorySpace<OtherSpace, Kokkos::AnonymousSpace>
-{
-  enum {value = 1};
+template <typename OtherSpace>
+struct VerifyExecutionCanAccessMemorySpace<OtherSpace, Kokkos::AnonymousSpace> {
+  enum { value = 1 };
   KOKKOS_INLINE_FUNCTION static void verify(void) {}
   KOKKOS_INLINE_FUNCTION static void verify(const void *) {}
 };
 
-template<typename OtherSpace>
-struct VerifyExecutionCanAccessMemorySpace<Kokkos::AnonymousSpace, OtherSpace>
-{
-  enum {value = 1};
+template <typename OtherSpace>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::AnonymousSpace, OtherSpace> {
+  enum { value = 1 };
   KOKKOS_INLINE_FUNCTION static void verify(void) {}
   KOKKOS_INLINE_FUNCTION static void verify(const void *) {}
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
-
-#endif // #define KOKKOS_ANONYMOUSSPACE_HPP
+}  // namespace Kokkos
 
+#endif  // #define KOKKOS_ANONYMOUSSPACE_HPP
diff --git a/lib/kokkos/core/src/Kokkos_Array.hpp b/lib/kokkos/core/src/Kokkos_Array.hpp
index 8e5862fe9cc37eb1406c6311543b9b1bbb3ca3b3..88e7883cb97cd6bd4d2d286446f2d3c9763dfa40 100644
--- a/lib/kokkos/core/src/Kokkos_Array.hpp
+++ b/lib/kokkos/core/src/Kokkos_Array.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -82,7 +83,7 @@ template <typename Integral>
 struct ArrayBoundsCheck<Integral, false> {
   KOKKOS_INLINE_FUNCTION
   ArrayBoundsCheck(Integral i, size_t N) {
-    if ( size_t(i) >= N) {
+    if (size_t(i) >= N) {
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
       std::string s = "Kokkos::Array: index ";
       s += std::to_string(i);
@@ -95,7 +96,7 @@ struct ArrayBoundsCheck<Integral, false> {
     }
   }
 };
-} // end namespace Impl
+}  // end namespace Impl
 
 #define KOKKOS_ARRAY_BOUNDS_CHECK(i, N) \
   Kokkos::Impl::ArrayBoundsCheck<decltype(i)>(i, N)
@@ -104,17 +105,14 @@ struct ArrayBoundsCheck<Integral, false> {
 
 #define KOKKOS_ARRAY_BOUNDS_CHECK(i, N) (void)0
 
-#endif // !defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
+#endif  // !defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
 
 /**\brief  Derived from the C++17 'std::array'.
  *         Dropping the iterator interface.
  */
-template< class T      = void
-        , size_t N     =KOKKOS_INVALID_INDEX
-        , class Proxy  = void
-        >
+template <class T = void, size_t N = KOKKOS_INVALID_INDEX, class Proxy = void>
 struct Array {
-public:
+ public:
   /**
    * The elements of this C array shall not be accessed directly. The data
    * member has to be declared public to enable aggregate initialization as for
@@ -122,115 +120,113 @@ public:
    * @private
    */
   T m_internal_implementation_private_member_data[N];
-public:
 
-  typedef T &                                 reference ;
-  typedef typename std::add_const<T>::type &  const_reference ;
-  typedef size_t                              size_type ;
-  typedef ptrdiff_t                           difference_type ;
-  typedef T                                   value_type ;
-  typedef T *                                 pointer ;
-  typedef typename std::add_const<T>::type *  const_pointer ;
-
-  KOKKOS_INLINE_FUNCTION static constexpr size_type size() { return N ; }
-  KOKKOS_INLINE_FUNCTION static constexpr bool      empty(){ return false ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return N ; }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  reference operator[]( const iType & i )
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integral argument" );
-      KOKKOS_ARRAY_BOUNDS_CHECK(i, N);
-      return m_internal_implementation_private_member_data[i];
-    }
+ public:
+  typedef T& reference;
+  typedef typename std::add_const<T>::type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef T value_type;
+  typedef T* pointer;
+  typedef typename std::add_const<T>::type* const_pointer;
+
+  KOKKOS_INLINE_FUNCTION static constexpr size_type size() { return N; }
+  KOKKOS_INLINE_FUNCTION static constexpr bool empty() { return false; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return N; }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION reference operator[](const iType& i) {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integral argument");
+    KOKKOS_ARRAY_BOUNDS_CHECK(i, N);
+    return m_internal_implementation_private_member_data[i];
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  const_reference operator[]( const iType & i ) const
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integral argument" );
-      KOKKOS_ARRAY_BOUNDS_CHECK(i, N);
-      return m_internal_implementation_private_member_data[i];
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION const_reference operator[](const iType& i) const {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integral argument");
+    KOKKOS_ARRAY_BOUNDS_CHECK(i, N);
+    return m_internal_implementation_private_member_data[i];
+  }
 
-  KOKKOS_INLINE_FUNCTION pointer       data()
-    {
-      return & m_internal_implementation_private_member_data[0];
-    }
-  KOKKOS_INLINE_FUNCTION const_pointer data() const
-    {
-      return & m_internal_implementation_private_member_data[0];
-    }
+  KOKKOS_INLINE_FUNCTION pointer data() {
+    return &m_internal_implementation_private_member_data[0];
+  }
+  KOKKOS_INLINE_FUNCTION const_pointer data() const {
+    return &m_internal_implementation_private_member_data[0];
+  }
 
-  #ifdef KOKKOS_IMPL_ROCM_CLANG_WORKAROUND
+#ifdef KOKKOS_IMPL_ROCM_CLANG_WORKAROUND
   // Do not default unless move and move-assignment are also defined
   KOKKOS_INLINE_FUNCTION
-  ~Array() = default ;
-  Array() = default ;
-  Array( const Array & ) = default ;
-  Array & operator = ( const Array & ) = default ;
+  ~Array()            = default;
+  Array()             = default;
+  Array(const Array&) = default;
+  Array& operator=(const Array&) = default;
 
   // Some supported compilers are not sufficiently C++11 compliant
   // for default move constructor and move assignment operator.
-  Array( Array && ) = default ;
-  Array & operator = ( Array && ) = default ;
- 
+  Array(Array&&) = default;
+  Array& operator=(Array&&) = default;
+
   KOKKOS_INLINE_FUNCTION
   Array(const std::initializer_list<T>& vals) {
-    for(int i=0; i<N; i++) {
+    for (int i = 0; i < N; i++) {
       m_internal_implementation_private_member_data[i] = vals.begin()[i];
     }
   }
-  #endif
+#endif
 };
 
+template <class T, class Proxy>
+struct Array<T, 0, Proxy> {
+ public:
+  typedef T& reference;
+  typedef typename std::add_const<T>::type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef T value_type;
+  typedef T* pointer;
+  typedef typename std::add_const<T>::type* const_pointer;
+
+  KOKKOS_INLINE_FUNCTION static constexpr size_type size() { return 0; }
+  KOKKOS_INLINE_FUNCTION static constexpr bool empty() { return true; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return 0; }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION reference operator[](const iType&) {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integer argument");
+    Kokkos::abort("Unreachable code");
+    return *reinterpret_cast<pointer>(-1);
+  }
 
-template< class T , class Proxy >
-struct Array<T,0,Proxy> {
-public:
-
-  typedef typename std::add_const<T>::type &  reference ;
-  typedef typename std::add_const<T>::type &  const_reference ;
-  typedef size_t                              size_type ;
-  typedef ptrdiff_t                           difference_type ;
-  typedef typename std::add_const<T>::type    value_type ;
-  typedef typename std::add_const<T>::type *  pointer ;
-  typedef typename std::add_const<T>::type *  const_pointer ;
-
-  KOKKOS_INLINE_FUNCTION static constexpr size_type size()  { return 0 ; }
-  KOKKOS_INLINE_FUNCTION static constexpr bool      empty() { return true ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return 0 ; }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  value_type operator[]( const iType & )
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integer argument" );
-      return value_type();
-    }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  value_type operator[]( const iType & ) const
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integer argument" );
-      return value_type();
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION const_reference operator[](const iType&) const {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integer argument");
+    Kokkos::abort("Unreachable code");
+    return *reinterpret_cast<const_pointer>(-1);
+  }
 
-  KOKKOS_INLINE_FUNCTION pointer       data()       { return pointer(0) ; }
+  KOKKOS_INLINE_FUNCTION pointer data() { return pointer(0); }
   KOKKOS_INLINE_FUNCTION const_pointer data() const { return const_pointer(0); }
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
   KOKKOS_INLINE_FUNCTION ~Array() {}
   KOKKOS_INLINE_FUNCTION Array() {}
-  KOKKOS_INLINE_FUNCTION Array( const Array & ) {}
-  KOKKOS_INLINE_FUNCTION Array & operator = ( const Array & ) {}
+  KOKKOS_INLINE_FUNCTION Array(const Array&) {}
+  KOKKOS_INLINE_FUNCTION Array& operator=(const Array&) {}
 #else
-  KOKKOS_INLINE_FUNCTION ~Array() = default;
-  KOKKOS_INLINE_FUNCTION Array() = default;
-  KOKKOS_INLINE_FUNCTION Array( const Array & ) = default;
-  KOKKOS_INLINE_FUNCTION Array & operator = ( const Array & ) = default;
+  KOKKOS_INLINE_FUNCTION ~Array()            = default;
+  KOKKOS_INLINE_FUNCTION Array()             = default;
+  KOKKOS_INLINE_FUNCTION Array(const Array&) = default;
+  KOKKOS_INLINE_FUNCTION Array& operator=(const Array&) = default;
 #endif
 
   // Some supported compilers are not sufficiently C++11 compliant
@@ -239,62 +235,59 @@ public:
   // Array & operator = ( Array && ) = default ;
 };
 
-
-template<>
-struct Array<void,KOKKOS_INVALID_INDEX,void>
-{
+template <>
+struct Array<void, KOKKOS_INVALID_INDEX, void> {
   struct contiguous {};
   struct strided {};
 };
 
-template< class T >
-struct Array< T ,KOKKOS_INVALID_INDEX , Array<>::contiguous >
-{
-private:
-  T *    m_elem ;
-  size_t m_size ;
-public:
-
-  typedef T &                                 reference ;
-  typedef typename std::add_const<T>::type &  const_reference ;
-  typedef size_t                              size_type ;
-  typedef ptrdiff_t                           difference_type ;
-  typedef T                                   value_type ;
-  typedef T *                                 pointer ;
-  typedef typename std::add_const<T>::type *  const_pointer ;
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type size()  const { return m_size ; }
-  KOKKOS_INLINE_FUNCTION constexpr bool      empty() const { return 0 != m_size ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return m_size ; }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  reference operator[]( const iType & i )
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integral argument" );
-      KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
-      return m_elem[i];
-    }
+template <class T>
+struct Array<T, KOKKOS_INVALID_INDEX, Array<>::contiguous> {
+ private:
+  T* m_elem;
+  size_t m_size;
+
+ public:
+  typedef T& reference;
+  typedef typename std::add_const<T>::type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef T value_type;
+  typedef T* pointer;
+  typedef typename std::add_const<T>::type* const_pointer;
+
+  KOKKOS_INLINE_FUNCTION constexpr size_type size() const { return m_size; }
+  KOKKOS_INLINE_FUNCTION constexpr bool empty() const { return 0 != m_size; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return m_size; }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION reference operator[](const iType& i) {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integral argument");
+    KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
+    return m_elem[i];
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  const_reference operator[]( const iType & i ) const
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integral argument" );
-      KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
-      return m_elem[i];
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION const_reference operator[](const iType& i) const {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integral argument");
+    KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
+    return m_elem[i];
+  }
 
-  KOKKOS_INLINE_FUNCTION pointer       data()       { return m_elem ; }
-  KOKKOS_INLINE_FUNCTION const_pointer data() const { return m_elem ; }
+  KOKKOS_INLINE_FUNCTION pointer data() { return m_elem; }
+  KOKKOS_INLINE_FUNCTION const_pointer data() const { return m_elem; }
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
   KOKKOS_INLINE_FUNCTION ~Array() {}
 #else
-  KOKKOS_INLINE_FUNCTION ~Array() = default;
+  KOKKOS_INLINE_FUNCTION ~Array()                       = default;
 #endif
-  Array() = delete ;
-  Array( const Array & rhs ) = delete ;
+  Array()                 = delete;
+  Array(const Array& rhs) = delete;
 
   // Some supported compilers are not sufficiently C++11 compliant
   // for default move constructor and move assignment operator.
@@ -302,76 +295,72 @@ public:
   // Array & operator = ( Array && rhs ) = delete ;
 
   KOKKOS_INLINE_FUNCTION
-  Array & operator = ( const Array & rhs )
-    {
-      const size_t n = std::min( m_size , rhs.size() );
-      for ( size_t i = 0 ; i < n ; ++i ) m_elem[i] = rhs[i] ;
-      return *this ;
-    }
+  Array& operator=(const Array& rhs) {
+    const size_t n = std::min(m_size, rhs.size());
+    for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
+    return *this;
+  }
 
-  template< size_t N , class P >
-  KOKKOS_INLINE_FUNCTION
-  Array & operator = ( const Array<T,N,P> & rhs )
-    {
-      const size_t n = std::min( m_size , rhs.size() );
-      for ( size_t i = 0 ; i < n ; ++i ) m_elem[i] = rhs[i] ;
-      return *this ;
-    }
+  template <size_t N, class P>
+  KOKKOS_INLINE_FUNCTION Array& operator=(const Array<T, N, P>& rhs) {
+    const size_t n = std::min(m_size, rhs.size());
+    for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
+    return *this;
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr Array( pointer arg_ptr , size_type arg_size , size_type = 0 )
-    : m_elem(arg_ptr), m_size(arg_size) {}
+  KOKKOS_INLINE_FUNCTION constexpr Array(pointer arg_ptr, size_type arg_size,
+                                         size_type = 0)
+      : m_elem(arg_ptr), m_size(arg_size) {}
 };
 
-template< class T >
-struct Array< T ,KOKKOS_INVALID_INDEX , Array<>::strided >
-{
-private:
-  T *    m_elem ;
-  size_t m_size ;
-  size_t m_stride ;
-public:
-
-  typedef T &                                 reference ;
-  typedef typename std::add_const<T>::type &  const_reference ;
-  typedef size_t                              size_type ;
-  typedef ptrdiff_t                           difference_type ;
-  typedef T                                   value_type ;
-  typedef T *                                 pointer ;
-  typedef typename std::add_const<T>::type *  const_pointer ;
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type size()  const { return m_size ; }
-  KOKKOS_INLINE_FUNCTION constexpr bool      empty() const { return 0 != m_size ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return m_size ; }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  reference operator[]( const iType & i )
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integral argument" );
-      KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
-      return m_elem[i*m_stride];
-    }
+template <class T>
+struct Array<T, KOKKOS_INVALID_INDEX, Array<>::strided> {
+ private:
+  T* m_elem;
+  size_t m_size;
+  size_t m_stride;
+
+ public:
+  typedef T& reference;
+  typedef typename std::add_const<T>::type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef T value_type;
+  typedef T* pointer;
+  typedef typename std::add_const<T>::type* const_pointer;
+
+  KOKKOS_INLINE_FUNCTION constexpr size_type size() const { return m_size; }
+  KOKKOS_INLINE_FUNCTION constexpr bool empty() const { return 0 != m_size; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return m_size; }
+
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION reference operator[](const iType& i) {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integral argument");
+    KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
+    return m_elem[i * m_stride];
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  const_reference operator[]( const iType & i ) const
-    {
-      static_assert( ( std::is_integral<iType>::value || std::is_enum<iType>::value ) , "Must be integral argument" );
-      KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
-      return m_elem[i*m_stride];
-    }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION const_reference operator[](const iType& i) const {
+    static_assert(
+        (std::is_integral<iType>::value || std::is_enum<iType>::value),
+        "Must be integral argument");
+    KOKKOS_ARRAY_BOUNDS_CHECK(i, m_size);
+    return m_elem[i * m_stride];
+  }
 
-  KOKKOS_INLINE_FUNCTION pointer       data()       { return m_elem ; }
-  KOKKOS_INLINE_FUNCTION const_pointer data() const { return m_elem ; }
+  KOKKOS_INLINE_FUNCTION pointer data() { return m_elem; }
+  KOKKOS_INLINE_FUNCTION const_pointer data() const { return m_elem; }
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
   KOKKOS_INLINE_FUNCTION ~Array() {}
 #else
-  KOKKOS_INLINE_FUNCTION ~Array() = default;
+  KOKKOS_INLINE_FUNCTION ~Array()                       = default;
 #endif
-  Array()  = delete ;
-  Array( const Array & ) = delete ;
-
+  Array()             = delete;
+  Array(const Array&) = delete;
 
   // Some supported compilers are not sufficiently C++11 compliant
   // for default move constructor and move assignment operator.
@@ -379,27 +368,24 @@ public:
   // Array & operator = ( Array && rhs ) = delete ;
 
   KOKKOS_INLINE_FUNCTION
-  Array & operator = ( const Array & rhs )
-    {
-      const size_t n = std::min( m_size , rhs.size() );
-      for ( size_t i = 0 ; i < n ; ++i ) m_elem[i] = rhs[i] ;
-      return *this ;
-    }
+  Array& operator=(const Array& rhs) {
+    const size_t n = std::min(m_size, rhs.size());
+    for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
+    return *this;
+  }
 
-  template< size_t N , class P >
-  KOKKOS_INLINE_FUNCTION
-  Array & operator = ( const Array<T,N,P> & rhs )
-    {
-      const size_t n = std::min( m_size , rhs.size() );
-      for ( size_t i = 0 ; i < n ; ++i ) m_elem[i] = rhs[i] ;
-      return *this ;
-    }
+  template <size_t N, class P>
+  KOKKOS_INLINE_FUNCTION Array& operator=(const Array<T, N, P>& rhs) {
+    const size_t n = std::min(m_size, rhs.size());
+    for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
+    return *this;
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr Array( pointer arg_ptr , size_type arg_size , size_type arg_stride )
-    : m_elem(arg_ptr), m_size(arg_size), m_stride(arg_stride) {}
+  KOKKOS_INLINE_FUNCTION constexpr Array(pointer arg_ptr, size_type arg_size,
+                                         size_type arg_stride)
+      : m_elem(arg_ptr), m_size(arg_size), m_stride(arg_stride) {}
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_ARRAY_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Atomic.hpp b/lib/kokkos/core/src/Kokkos_Atomic.hpp
index c2268bd35f71b48131492e118f34910a323bd9b3..c4f7fa3ec14dc58414904a62942938bd8b73493e 100644
--- a/lib/kokkos/core/src/Kokkos_Atomic.hpp
+++ b/lib/kokkos/core/src/Kokkos_Atomic.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -75,7 +76,7 @@
 #if defined(_WIN32)
 #define KOKKOS_ENABLE_WINDOWS_ATOMICS
 #else
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 
 // Compiling NVIDIA device code, must use Cuda atomics:
 
@@ -87,32 +88,30 @@
 
 #endif
 
-#if ! defined( KOKKOS_ENABLE_GNU_ATOMICS ) && \
-    ! defined( KOKKOS_ENABLE_INTEL_ATOMICS ) && \
-    ! defined( KOKKOS_ENABLE_OPENMP_ATOMICS ) && \
-    ! defined( KOKKOS_ENABLE_STD_ATOMICS ) && \
-    ! defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#if !defined(KOKKOS_ENABLE_GNU_ATOMICS) &&    \
+    !defined(KOKKOS_ENABLE_INTEL_ATOMICS) &&  \
+    !defined(KOKKOS_ENABLE_OPENMP_ATOMICS) && \
+    !defined(KOKKOS_ENABLE_STD_ATOMICS) &&    \
+    !defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
 // Compiling for non-Cuda atomic implementation has not been pre-selected.
 // Choose the best implementation for the detected compiler.
 // Preference: GCC, INTEL, OMP31
 
-#if defined( KOKKOS_INTERNAL_NOT_PARALLEL )
+#if defined(KOKKOS_INTERNAL_NOT_PARALLEL)
 
 #define KOKKOS_ENABLE_SERIAL_ATOMICS
 
-#elif defined( KOKKOS_COMPILER_GNU ) || \
-    defined( KOKKOS_COMPILER_CLANG ) || \
-    ( defined ( KOKKOS_COMPILER_NVCC ) )
+#elif defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) || \
+    (defined(KOKKOS_COMPILER_NVCC))
 
 #define KOKKOS_ENABLE_GNU_ATOMICS
 
-#elif defined( KOKKOS_COMPILER_INTEL ) || \
-      defined( KOKKOS_COMPILER_CRAYC )
+#elif defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_CRAYC)
 
 #define KOKKOS_ENABLE_INTEL_ATOMICS
 
-#elif defined( _OPENMP ) && ( 201107 <= _OPENMP )
+#elif defined(_OPENMP) && (201107 <= _OPENMP)
 
 #define KOKKOS_ENABLE_OPENMP_ATOMICS
 
@@ -131,43 +130,37 @@
 
 namespace Kokkos {
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_add(volatile T * const dest, const T src);
+KOKKOS_INLINE_FUNCTION void atomic_add(volatile T* const dest, const T src);
 
 // Atomic increment
-template<typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_increment(volatile T* a);
+template <typename T>
+KOKKOS_INLINE_FUNCTION void atomic_increment(volatile T* a);
 
-template<typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_decrement(volatile T* a);
-}
+template <typename T>
+KOKKOS_INLINE_FUNCTION void atomic_decrement(volatile T* a);
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-
-inline
-const char * atomic_query_version()
-{
-#if defined( KOKKOS_ENABLE_CUDA_ATOMICS )
-  return "KOKKOS_ENABLE_CUDA_ATOMICS" ;
-#elif defined( KOKKOS_ENABLE_GNU_ATOMICS )
-  return "KOKKOS_ENABLE_GNU_ATOMICS" ;
-#elif defined( KOKKOS_ENABLE_INTEL_ATOMICS )
-  return "KOKKOS_ENABLE_INTEL_ATOMICS" ;
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
-  return "KOKKOS_ENABLE_OPENMP_ATOMICS" ;
-#elif defined( KOKKOS_ENABLE_WINDOWS_ATOMICS )
+inline const char* atomic_query_version() {
+#if defined(KOKKOS_ENABLE_CUDA_ATOMICS)
+  return "KOKKOS_ENABLE_CUDA_ATOMICS";
+#elif defined(KOKKOS_ENABLE_GNU_ATOMICS)
+  return "KOKKOS_ENABLE_GNU_ATOMICS";
+#elif defined(KOKKOS_ENABLE_INTEL_ATOMICS)
+  return "KOKKOS_ENABLE_INTEL_ATOMICS";
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
+  return "KOKKOS_ENABLE_OPENMP_ATOMICS";
+#elif defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
   return "KOKKOS_ENABLE_WINDOWS_ATOMICS";
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   return "KOKKOS_ENABLE_SERIAL_ATOMICS";
 #else
 #error "No valid response for atomic_query_version!"
 #endif
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 // Atomic Memory Orders
@@ -175,16 +168,14 @@ const char * atomic_query_version()
 // Implements Strongly-typed analogs of C++ standard memory orders
 #include "impl/Kokkos_Atomic_Memory_Order.hpp"
 
-#if defined( KOKKOS_ENABLE_ROCM )
+#if defined(KOKKOS_ENABLE_ROCM)
 namespace Kokkos {
 namespace Impl {
-extern KOKKOS_INLINE_FUNCTION
-bool lock_address_rocm_space(void* ptr);
+extern KOKKOS_INLINE_FUNCTION bool lock_address_rocm_space(void* ptr);
 
-extern KOKKOS_INLINE_FUNCTION
-void unlock_address_rocm_space(void* ptr);
-}
-}
+extern KOKKOS_INLINE_FUNCTION void unlock_address_rocm_space(void* ptr);
+}  // namespace Impl
+}  // namespace Kokkos
 #include <ROCm/Kokkos_ROCm_Atomic.hpp>
 #endif
 
@@ -212,8 +203,9 @@ void unlock_address_rocm_space(void* ptr);
 // Atomic compare-and-exchange
 //
 // template<class T>
-// bool atomic_compare_exchange_strong(volatile T* const dest, const T compare, const T val)
-// { bool equal = compare == *dest ; if ( equal ) { *dest = val ; } return equal ; }
+// bool atomic_compare_exchange_strong(volatile T* const dest, const T compare,
+// const T val) { bool equal = compare == *dest ; if ( equal ) { *dest = val ; }
+// return equal ; }
 
 #include "impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp"
 
@@ -275,7 +267,8 @@ void unlock_address_rocm_space(void* ptr);
 //----------------------------------------------------------------------------
 // Memory fence
 //
-// All loads and stores from this thread will be globally consistent before continuing
+// All loads and stores from this thread will be globally consistent before
+// continuing
 //
 // void memory_fence() {...};
 #include "impl/Kokkos_Memory_Fence.hpp"
@@ -301,23 +294,22 @@ void unlock_address_rocm_space(void* ptr);
 #include "impl/Kokkos_Atomic_Load.hpp"
 #include "impl/Kokkos_Atomic_Store.hpp"
 
-
 //----------------------------------------------------------------------------
 // This atomic-style macro should be an inlined function, not a macro
 
-#if defined( KOKKOS_COMPILER_GNU ) && !defined(__PGIC__) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_COMPILER_GNU) && !defined(__PGIC__) && \
+    !defined(__CUDA_ARCH__)
 
-  #define KOKKOS_NONTEMPORAL_PREFETCH_LOAD(addr) __builtin_prefetch(addr,0,0)
-  #define KOKKOS_NONTEMPORAL_PREFETCH_STORE(addr) __builtin_prefetch(addr,1,0)
+#define KOKKOS_NONTEMPORAL_PREFETCH_LOAD(addr) __builtin_prefetch(addr, 0, 0)
+#define KOKKOS_NONTEMPORAL_PREFETCH_STORE(addr) __builtin_prefetch(addr, 1, 0)
 
 #else
 
-  #define KOKKOS_NONTEMPORAL_PREFETCH_LOAD(addr) ((void)0)
-  #define KOKKOS_NONTEMPORAL_PREFETCH_STORE(addr) ((void)0)
+#define KOKKOS_NONTEMPORAL_PREFETCH_LOAD(addr) ((void)0)
+#define KOKKOS_NONTEMPORAL_PREFETCH_STORE(addr) ((void)0)
 
 #endif
 
 //----------------------------------------------------------------------------
 
 #endif /* KOKKOS_ATOMIC_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Complex.hpp b/lib/kokkos/core/src/Kokkos_Complex.hpp
index a3ada5d55ea1a04a0d0512873379767ef567f408..a9af073b4193d9e643d6f3c31c7dbd0837f65b60 100644
--- a/lib/kokkos/core/src/Kokkos_Complex.hpp
+++ b/lib/kokkos/core/src/Kokkos_Complex.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,658 +58,683 @@ namespace Kokkos {
 ///   complex number.  As with std::complex, this is only defined for
 ///   \c float, \c double, and <tt>long double</tt>.  The latter is
 ///   currently forbidden in CUDA device kernels.
-template<class RealType>
-class complex {
-private:
-  RealType re_, im_;
+template <class RealType>
+class
+#ifdef KOKKOS_ENABLE_COMPLEX_ALIGN
+    alignas(2 * sizeof(RealType))
+#endif
+        complex {
+ private:
+  RealType re_{};
+  RealType im_{};
 
-public:
+ public:
   //! The type of the real or imaginary parts of this complex number.
-  typedef RealType value_type;
+  using value_type = RealType;
 
   //! Default constructor (initializes both real and imaginary parts to zero).
-  KOKKOS_INLINE_FUNCTION complex () :
-    re_ (0.0), im_ (0.0)
-  {}
+  KOKKOS_INLINE_FUNCTION
+  complex() noexcept = default;
 
   //! Copy constructor.
-  KOKKOS_INLINE_FUNCTION complex (const complex<RealType>& src) :
-    re_ (src.re_), im_ (src.im_)
-  {}
+  KOKKOS_INLINE_FUNCTION
+  complex(const complex&) noexcept = default;
 
-  //! Copy constructor from volatile.
-  KOKKOS_INLINE_FUNCTION complex (const volatile complex<RealType>& src) :
-    re_ (src.re_), im_ (src.im_)
-  {}
+  KOKKOS_INLINE_FUNCTION
+  complex& operator=(const complex&) noexcept = default;
+
+  /// \brief Conversion constructor from compatible RType
+  template <class RType,
+            typename std::enable_if<std::is_convertible<RType, RealType>::value,
+                                    int>::type = 0>
+  KOKKOS_INLINE_FUNCTION complex(const complex<RType>& other) noexcept
+      // Intentionally do the conversions implicitly here so that users don't
+      // get any warnings about narrowing, etc., that they would expect to get
+      // otherwise.
+      : re_(other.real()), im_(other.imag()) {}
 
   /// \brief Conversion constructor from std::complex.
   ///
   /// This constructor cannot be called in a CUDA device function,
   /// because std::complex's methods and nonmember functions are not
   /// marked as CUDA device functions.
-  template<class InputRealType>
-  complex (const std::complex<InputRealType>& src) :
-    re_ (std::real (src)), im_ (std::imag (src))
-  {}
+  KOKKOS_INLINE_FUNCTION
+  complex(const std::complex<RealType>& src) noexcept
+      // We can use this aspect of the standard to avoid calling
+      // non-device-marked functions `std::real` and `std::imag`: "For any
+      // object z of type complex<T>, reinterpret_cast<T(&)[2]>(z)[0] is the
+      // real part of z and reinterpret_cast<T(&)[2]>(z)[1] is the imaginary
+      // part of z." Now we don't have to provide a whole bunch of the overloads
+      // of things taking either Kokkos::complex or std::complex
+      : re_(reinterpret_cast<const RealType (&)[2]>(src)[0]),
+        im_(reinterpret_cast<const RealType (&)[2]>(src)[1]) {}
 
   /// \brief Conversion operator to std::complex.
   ///
   /// This operator cannot be called in a CUDA device function,
   /// because std::complex's methods and nonmember functions are not
   /// marked as CUDA device functions.
-  operator std::complex<RealType> () const {
-    return std::complex<RealType> (re_, im_);
+  // TODO: make explicit.  DJS 2019-08-28
+  operator std::complex<RealType>() const noexcept {
+    return std::complex<RealType>(re_, im_);
   }
 
   /// \brief Constructor that takes just the real part, and sets the
   ///   imaginary part to zero.
-  template<class InputRealType>
-  KOKKOS_INLINE_FUNCTION complex (const InputRealType& val) :
-    re_ (val), im_ (static_cast<InputRealType>(0.0))
-  {}
-
-  // BUG HCC WORKAROUND
-  KOKKOS_INLINE_FUNCTION complex( const RealType& re, const RealType& im):
-    re_ (re), im_ (im)
-  {}
- 
-  //! Constructor that takes the real and imaginary parts.
-  template<class RealType1, class RealType2>
-  KOKKOS_INLINE_FUNCTION complex (const RealType1& re, const RealType2& im) :
-    re_ (re), im_ (im)
-  {}
+  KOKKOS_INLINE_FUNCTION complex(const RealType& val) noexcept
+      : re_(val), im_(static_cast<RealType>(0)) {}
 
-  //! Assignment operator.
-  template<class InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>& operator= (const complex<InputRealType>& src) {
-    re_ = src.re_;
-    im_ = src.im_;
-    return *this;
-  }
-
-  /// \brief Assignment operator, for volatile <tt>*this</tt> and
-  ///   nonvolatile input.
-  ///
-  /// \param src [in] Input; right-hand side of the assignment.
-  ///
-  /// This operator returns \c void instead of <tt>volatile
-  /// complex<RealType>& </tt>.  See Kokkos Issue #177 for the
-  /// explanation.  In practice, this means that you should not chain
-  /// assignments with volatile lvalues.
-  template<class InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  void operator= (const complex<InputRealType>& src) volatile {
-    re_ = src.re_;
-    im_ = src.im_;
-    // We deliberately do not return anything here.  See explanation
-    // in public documentation above.
-  }
-
-  //! Assignment operator.
-  template<class InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  volatile complex<RealType>& operator= (const volatile complex<InputRealType>& src) volatile {
-    re_ = src.re_;
-    im_ = src.im_;
-    return *this;
-  }
-
-  //! Assignment operator.
-  template<class InputRealType>
+  //! Constructor that takes the real and imaginary parts.
   KOKKOS_INLINE_FUNCTION
-  complex<RealType>& operator= (const volatile complex<InputRealType>& src) {
-    re_ = src.re_;
-    im_ = src.im_;
-    return *this;
-  }
+  complex(const RealType& re, const RealType& im) noexcept : re_(re), im_(im) {}
 
   //! Assignment operator (from a real number).
-  template<class InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>& operator= (const InputRealType& val) {
+  KOKKOS_INLINE_FUNCTION complex& operator=(const RealType& val) noexcept {
     re_ = val;
-    im_ = static_cast<RealType> (0.0);
+    im_ = RealType(0);
     return *this;
   }
 
-  //! Assignment operator (from a real number).
-  template<class InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  void operator= (const InputRealType& val) volatile {
-    re_ = val;
-    im_ = static_cast<RealType> (0.0);
-  }
-
   /// \brief Assignment operator from std::complex.
   ///
   /// This constructor cannot be called in a CUDA device function,
   /// because std::complex's methods and nonmember functions are not
   /// marked as CUDA device functions.
-  template<class InputRealType>
-  complex<RealType>& operator= (const std::complex<InputRealType>& src) {
-    re_ = std::real (src);
-    im_ = std::imag (src);
+  complex& operator=(const std::complex<RealType>& src) noexcept {
+    *this = complex(src);
     return *this;
   }
 
   //! The imaginary part of this complex number.
-  KOKKOS_INLINE_FUNCTION RealType& imag () {
-    return im_;
-  }
+  KOKKOS_INLINE_FUNCTION
+  KOKKOS_CONSTEXPR_14 RealType& imag() noexcept { return im_; }
 
   //! The real part of this complex number.
-  KOKKOS_INLINE_FUNCTION RealType& real () {
-    return re_;
-  }
+  KOKKOS_INLINE_FUNCTION
+  KOKKOS_CONSTEXPR_14 RealType& real() noexcept { return re_; }
 
   //! The imaginary part of this complex number.
-  KOKKOS_INLINE_FUNCTION const RealType imag () const {
-    return im_;
-  }
+  KOKKOS_INLINE_FUNCTION
+  constexpr RealType imag() const noexcept { return im_; }
 
   //! The real part of this complex number.
-  KOKKOS_INLINE_FUNCTION const RealType real () const {
-    return re_;
-  }
-
-  //! The imaginary part of this complex number (volatile overload).
-  KOKKOS_INLINE_FUNCTION volatile RealType& imag () volatile {
-    return im_;
-  }
-
-  //! The real part of this complex number (volatile overload).
-  KOKKOS_INLINE_FUNCTION volatile RealType& real () volatile {
-    return re_;
-  }
-
-  //! The imaginary part of this complex number (volatile overload).
-  KOKKOS_INLINE_FUNCTION const RealType imag () const volatile {
-    return im_;
-  }
-
-  //! The real part of this complex number (volatile overload).
-  KOKKOS_INLINE_FUNCTION const RealType real () const volatile {
-    return re_;
-  }
+  KOKKOS_INLINE_FUNCTION
+  constexpr RealType real() const noexcept { return re_; }
 
   //! Set the imaginary part of this complex number.
-  KOKKOS_INLINE_FUNCTION void imag (RealType v) {
-    im_ = v;
-  }
+  KOKKOS_INLINE_FUNCTION
+  KOKKOS_CONSTEXPR_14
+  void imag(RealType v) noexcept { im_ = v; }
 
   //! Set the real part of this complex number.
-  KOKKOS_INLINE_FUNCTION void real (RealType v) {
-    re_ = v;
-  }
-
-  template<typename InputRealType>
   KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator += (const complex<InputRealType>& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
-    re_ += src.re_;
-    im_ += src.im_;
-    return *this;
-  }
+  KOKKOS_CONSTEXPR_14
+  void real(RealType v) noexcept { re_ = v; }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  void
-  operator += (const volatile complex<InputRealType>& src) volatile {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator+=(
+      const complex<RealType>& src) noexcept {
     re_ += src.re_;
     im_ += src.im_;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator += (const std::complex<RealType>& src) {
-    re_ += src.real();
-    im_ += src.imag();
     return *this;
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator += (const InputRealType& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator+=(
+      const RealType& src) noexcept {
     re_ += src;
     return *this;
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  void
-  operator += (const volatile InputRealType& src) volatile {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
-    re_ += src;
-  }
-  
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator -= (const complex<InputRealType>& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator-=(
+      const complex<RealType>& src) noexcept {
     re_ -= src.re_;
     im_ -= src.im_;
     return *this;
   }
 
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator -= (const std::complex<RealType>& src) {
-    re_ -= src.real();
-    im_ -= src.imag();
-    return *this;
-  }
-
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator -= (const InputRealType& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator-=(
+      const RealType& src) noexcept {
     re_ -= src;
     return *this;
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator *= (const complex<InputRealType>& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
-    const RealType realPart = re_ * src.re_ - im_ * src.im_;
-    const RealType imagPart = re_ * src.im_ + im_ * src.re_;
-    re_ = realPart;
-    im_ = imagPart;
-    return *this;
-  }
-
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  void
-  operator *= (const volatile complex<InputRealType>& src) volatile {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator*=(
+      const complex<RealType>& src) noexcept {
     const RealType realPart = re_ * src.re_ - im_ * src.im_;
     const RealType imagPart = re_ * src.im_ + im_ * src.re_;
-    re_ = realPart;
-    im_ = imagPart;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator *= (const std::complex<RealType>& src) {
-    const RealType realPart = re_ * src.real() - im_ * src.imag();
-    const RealType imagPart = re_ * src.imag() + im_ * src.real();
-    re_ = realPart;
-    im_ = imagPart;
+    re_                     = realPart;
+    im_                     = imagPart;
     return *this;
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator *= (const InputRealType& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator*=(
+      const RealType& src) noexcept {
     re_ *= src;
     im_ *= src;
     return *this;
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  void
-  operator *= (const volatile InputRealType& src) volatile {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
-    re_ *= src;
-    im_ *= src;
-  }
-
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator /= (const complex<InputRealType>& y) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
-
+  // Conditional noexcept, just in case RType throws on divide-by-zero
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator/=(
+      const complex<RealType>& y) noexcept(noexcept(RealType{} / RealType{})) {
     // Scale (by the "1-norm" of y) to avoid unwarranted overflow.
     // If the real part is +/-Inf and the imaginary part is -/+Inf,
     // this won't change the result.
-    const RealType s = std::fabs (y.real ()) + std::fabs (y.imag ());
+    const RealType s = std::fabs(y.real()) + std::fabs(y.imag());
 
     // If s is 0, then y is zero, so x/y == real(x)/0 + i*imag(x)/0.
     // In that case, the relation x/y == (x/s) / (y/s) doesn't hold,
     // because y/s is NaN.
-    if (s == 0.0) {
+    // TODO mark this branch unlikely
+    if (s == RealType(0)) {
       this->re_ /= s;
       this->im_ /= s;
-    }
-    else {
-      const complex<RealType> x_scaled (this->re_ / s, this->im_ / s);
-      const complex<RealType> y_conj_scaled (y.re_ / s, -(y.im_) / s);
-      const RealType y_scaled_abs = y_conj_scaled.re_ * y_conj_scaled.re_ +
-        y_conj_scaled.im_ * y_conj_scaled.im_; // abs(y) == abs(conj(y))
+    } else {
+      const complex x_scaled(this->re_ / s, this->im_ / s);
+      const complex y_conj_scaled(y.re_ / s, -(y.im_) / s);
+      const RealType y_scaled_abs =
+          y_conj_scaled.re_ * y_conj_scaled.re_ +
+          y_conj_scaled.im_ * y_conj_scaled.im_;  // abs(y) == abs(conj(y))
       *this = x_scaled * y_conj_scaled;
       *this /= y_scaled_abs;
     }
     return *this;
   }
-  
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator /= (const std::complex<RealType>& y) {
 
+  KOKKOS_CONSTEXPR_14
+  KOKKOS_INLINE_FUNCTION complex& operator/=(
+      const std::complex<RealType>& y) noexcept(noexcept(RealType{} /
+                                                         RealType{})) {
     // Scale (by the "1-norm" of y) to avoid unwarranted overflow.
     // If the real part is +/-Inf and the imaginary part is -/+Inf,
     // this won't change the result.
-    const RealType s = std::fabs (y.real ()) + std::fabs (y.imag ());
+    const RealType s = std::fabs(y.real()) + std::fabs(y.imag());
 
     // If s is 0, then y is zero, so x/y == real(x)/0 + i*imag(x)/0.
     // In that case, the relation x/y == (x/s) / (y/s) doesn't hold,
     // because y/s is NaN.
-    if (s == 0.0) {
+    if (s == RealType(0)) {
       this->re_ /= s;
       this->im_ /= s;
-    }
-    else {
-      const complex<RealType> x_scaled (this->re_ / s, this->im_ / s);
-      const complex<RealType> y_conj_scaled (y.re_ / s, -(y.im_) / s);
-      const RealType y_scaled_abs = y_conj_scaled.re_ * y_conj_scaled.re_ +
-        y_conj_scaled.im_ * y_conj_scaled.im_; // abs(y) == abs(conj(y))
+    } else {
+      const complex x_scaled(this->re_ / s, this->im_ / s);
+      const complex y_conj_scaled(y.re_ / s, -(y.im_) / s);
+      const RealType y_scaled_abs =
+          y_conj_scaled.re_ * y_conj_scaled.re_ +
+          y_conj_scaled.im_ * y_conj_scaled.im_;  // abs(y) == abs(conj(y))
       *this = x_scaled * y_conj_scaled;
       *this /= y_scaled_abs;
     }
     return *this;
   }
 
-
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  complex<RealType>&
-  operator /= (const InputRealType& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
-
+  KOKKOS_CONSTEXPR_14 KOKKOS_INLINE_FUNCTION complex& operator/=(
+      const RealType& src) noexcept(noexcept(RealType{} / RealType{})) {
     re_ /= src;
     im_ /= src;
     return *this;
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  bool
-  operator == (const complex<InputRealType>& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  //---------------------------------------------------------------------------
+  // TODO: refactor Kokkos reductions to remove dependency on
+  // volatile member overloads since they are being deprecated in c++20
+  //---------------------------------------------------------------------------
+
+  //! Copy constructor from volatile.
+  template <class RType,
+            typename std::enable_if<std::is_convertible<RType, RealType>::value,
+                                    int>::type = 0>
+  KOKKOS_INLINE_FUNCTION complex(const volatile complex<RType>& src) noexcept
+      // Intentionally do the conversions implicitly here so that users don't
+      // get any warnings about narrowing, etc., that they would expect to get
+      // otherwise.
+      : re_(src.re_), im_(src.im_) {}
 
-    return (re_ == static_cast<RealType>(src.re_)) && (im_ == static_cast<RealType>(src.im_));
+  /// \brief Assignment operator, for volatile <tt>*this</tt> and
+  ///   nonvolatile input.
+  ///
+  /// \param src [in] Input; right-hand side of the assignment.
+  ///
+  /// This operator returns \c void instead of <tt>volatile
+  /// complex& </tt>.  See Kokkos Issue #177 for the
+  /// explanation.  In practice, this means that you should not chain
+  /// assignments with volatile lvalues.
+  KOKKOS_INLINE_FUNCTION void operator=(
+      const complex<RealType>& src) volatile noexcept {
+    re_ = src.re_;
+    im_ = src.im_;
+    // We deliberately do not return anything here.  See explanation
+    // in public documentation above.
   }
 
-  KOKKOS_INLINE_FUNCTION
-  bool
-  operator == (const std::complex<RealType>& src) {
-    return (re_ == src.real()) && (im_ == src.imag());
+  //! Assignment operator, volatile LHS and volatile RHS
+  // TODO Should this return void like the other volatile assignment operators?
+  KOKKOS_INLINE_FUNCTION volatile complex& operator=(
+      const volatile complex<RealType>& src) volatile noexcept {
+    re_ = src.re_;
+    im_ = src.im_;
+    return *this;
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  bool
-  operator == (const InputRealType src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  //! Assignment operator, volatile RHS and non-volatile LHS
+  KOKKOS_INLINE_FUNCTION complex& operator=(
+      const volatile complex<RealType>& src) noexcept {
+    re_ = src.re_;
+    im_ = src.im_;
+    return *this;
+  }
+
+  // Mirroring the behavior of the assignment operators from complex RHS in the
+  // RealType RHS versions.
 
-    return (re_ == static_cast<RealType>(src)) && (im_ == RealType(0));
+  //! Assignment operator (from a volatile real number).
+  KOKKOS_INLINE_FUNCTION void operator=(const volatile RealType& val) noexcept {
+    re_ = val;
+    im_ = RealType(0);
+    // We deliberately do not return anything here.  See explanation
+    // in public documentation above.
   }
 
-  template<typename InputRealType>
-  KOKKOS_INLINE_FUNCTION
-  bool
-  operator != (const complex<InputRealType>& src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  //! Assignment operator volatile LHS and non-volatile RHS
+  KOKKOS_INLINE_FUNCTION complex& operator=(
+      const RealType& val) volatile noexcept {
+    re_ = val;
+    im_ = RealType(0);
+    return *this;
+  }
 
-    return (re_ != static_cast<RealType>(src.re_)) || (im_ != static_cast<RealType>(src.im_));
+  //! Assignment operator volatile LHS and volatile RHS
+  // TODO Should this return void like the other volatile assignment operators?
+  KOKKOS_INLINE_FUNCTION complex& operator=(
+      const volatile RealType& val) volatile noexcept {
+    re_ = val;
+    im_ = RealType(0);
+    return *this;
   }
 
+  //! The imaginary part of this complex number (volatile overload).
   KOKKOS_INLINE_FUNCTION
-  bool
-  operator != (const std::complex<RealType>& src) {
-    return (re_ != src.real()) || (im_ != src.imag());
-  }
+  volatile RealType& imag() volatile noexcept { return im_; }
+
+  //! The real part of this complex number (volatile overload).
+  KOKKOS_INLINE_FUNCTION
+  volatile RealType& real() volatile noexcept { return re_; }
+
+  //! The imaginary part of this complex number (volatile overload).
+  KOKKOS_INLINE_FUNCTION
+  RealType imag() const volatile noexcept { return im_; }
 
-  template<typename InputRealType>
+  //! The real part of this complex number (volatile overload).
   KOKKOS_INLINE_FUNCTION
-  bool
-  operator != (const InputRealType src) {
-    static_assert(std::is_convertible<InputRealType,RealType>::value, 
-                  "InputRealType must be convertible to RealType");
+  RealType real() const volatile noexcept { return re_; }
+
+  KOKKOS_INLINE_FUNCTION void operator+=(
+      const volatile complex<RealType>& src) volatile noexcept {
+    re_ += src.re_;
+    im_ += src.im_;
+  }
+
+  KOKKOS_INLINE_FUNCTION void operator+=(
+      const volatile RealType& src) volatile noexcept {
+    re_ += src;
+  }
+
+  KOKKOS_INLINE_FUNCTION void operator*=(
+      const volatile complex<RealType>& src) volatile noexcept {
+    const RealType realPart = re_ * src.re_ - im_ * src.im_;
+    const RealType imagPart = re_ * src.im_ + im_ * src.re_;
 
-    return (re_ != static_cast<RealType>(src)) || (im_ != RealType(0));
+    re_ = realPart;
+    im_ = imagPart;
   }
-  
+
+  KOKKOS_INLINE_FUNCTION void operator*=(
+      const volatile RealType& src) volatile noexcept {
+    re_ *= src;
+    im_ *= src;
+  }
+
+  // TODO DSH 2019-10-7 why are there no volatile /= and friends?
 };
 
+//==============================================================================
+// <editor-fold desc="Equality and inequality"> {{{1
+
+// Note that this is not the same behavior as std::complex, which doesn't allow
+// implicit conversions, but since this is the way we had it before, we have
+// to do it this way now.
+
+//! Binary == operator for complex complex.
+template <class RealType1, class RealType2>
+KOKKOS_INLINE_FUNCTION bool operator==(complex<RealType1> const& x,
+                                       complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) == common_type(y.real()) &&
+         common_type(x.imag()) == common_type(y.imag());
+}
+
+// TODO (here and elsewhere) decide if we should convert to a Kokkos::complex
+//      and do the comparison in a device-marked function
+//! Binary == operator for std::complex complex.
+template <class RealType1, class RealType2>
+inline bool operator==(std::complex<RealType1> const& x,
+                       complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) == common_type(y.real()) &&
+         common_type(x.imag()) == common_type(y.imag());
+}
+
+//! Binary == operator for complex std::complex.
+template <class RealType1, class RealType2>
+inline bool operator==(complex<RealType1> const& x,
+                       std::complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) == common_type(y.real()) &&
+         common_type(x.imag()) == common_type(y.imag());
+}
+
+//! Binary == operator for complex real.
+template <
+    class RealType1, class RealType2,
+    // Constraints to avoid participation in oparator==() for every possible RHS
+    typename std::enable_if<std::is_convertible<RealType2, RealType1>::value,
+                            int>::type = 0>
+KOKKOS_INLINE_FUNCTION bool operator==(complex<RealType1> const& x,
+                                       RealType2 const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) == common_type(y) &&
+         common_type(x.imag()) == common_type(0);
+}
+
+//! Binary == operator for real complex.
+template <
+    class RealType1, class RealType2,
+    // Constraints to avoid participation in oparator==() for every possible RHS
+    typename std::enable_if<std::is_convertible<RealType1, RealType2>::value,
+                            int>::type = 0>
+KOKKOS_INLINE_FUNCTION bool operator==(RealType1 const& x,
+                                       complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x) == common_type(y.real()) &&
+         common_type(0) == common_type(y.imag());
+}
+
+//! Binary != operator for complex complex.
+template <class RealType1, class RealType2>
+KOKKOS_INLINE_FUNCTION bool operator!=(complex<RealType1> const& x,
+                                       complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) != common_type(y.real()) ||
+         common_type(x.imag()) != common_type(y.imag());
+}
+
+//! Binary != operator for std::complex complex.
+template <class RealType1, class RealType2>
+inline bool operator!=(std::complex<RealType1> const& x,
+                       complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) != common_type(y.real()) ||
+         common_type(x.imag()) != common_type(y.imag());
+}
+
+//! Binary != operator for complex std::complex.
+template <class RealType1, class RealType2>
+inline bool operator!=(complex<RealType1> const& x,
+                       std::complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) != common_type(y.real()) ||
+         common_type(x.imag()) != common_type(y.imag());
+}
+
+//! Binary != operator for complex real.
+template <
+    class RealType1, class RealType2,
+    // Constraints to avoid participation in oparator==() for every possible RHS
+    typename std::enable_if<std::is_convertible<RealType2, RealType1>::value,
+                            int>::type = 0>
+KOKKOS_INLINE_FUNCTION bool operator!=(complex<RealType1> const& x,
+                                       RealType2 const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x.real()) != common_type(y) ||
+         common_type(x.imag()) != common_type(0);
+}
+
+//! Binary != operator for real complex.
+template <
+    class RealType1, class RealType2,
+    // Constraints to avoid participation in oparator==() for every possible RHS
+    typename std::enable_if<std::is_convertible<RealType1, RealType2>::value,
+                            int>::type = 0>
+KOKKOS_INLINE_FUNCTION bool operator!=(RealType1 const& x,
+                                       complex<RealType2> const& y) noexcept {
+  using common_type = typename std::common_type<RealType1, RealType2>::type;
+  return common_type(x) != common_type(y.real()) ||
+         common_type(0) != common_type(y.imag());
+}
+
+// </editor-fold> end Equality and inequality }}}1
+//==============================================================================
 
 //! Binary + operator for complex complex.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator + (const complex<RealType1>& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type > (x.real () + y.real (), x.imag () + y.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator+(const complex<RealType1>& x,
+              const complex<RealType2>& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x.real() + y.real(), x.imag() + y.imag());
 }
 
 //! Binary + operator for complex scalar.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator + (const complex<RealType1>& x, const RealType2& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x.real () + y , x.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator+(const complex<RealType1>& x, const RealType2& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x.real() + y, x.imag());
 }
 
 //! Binary + operator for scalar complex.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator + (const RealType1& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x + y.real (), y.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator+(const RealType1& x, const complex<RealType2>& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x + y.real(), y.imag());
 }
 
 //! Unary + operator for complex.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-complex<RealType>
-operator + (const complex<RealType>& x) {
-  return x;
+template <class RealType>
+KOKKOS_INLINE_FUNCTION complex<RealType> operator+(
+    const complex<RealType>& x) noexcept {
+  return complex<RealType>{+x.real(), +x.imag()};
 }
 
 //! Binary - operator for complex.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator - (const complex<RealType1>& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x.real () - y.real (), x.imag () - y.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator-(const complex<RealType1>& x,
+              const complex<RealType2>& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x.real() - y.real(), x.imag() - y.imag());
 }
 
 //! Binary - operator for complex scalar.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator - (const complex<RealType1>& x, const RealType2& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x.real () - y , x.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator-(const complex<RealType1>& x, const RealType2& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x.real() - y, x.imag());
 }
 
 //! Binary - operator for scalar complex.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator - (const RealType1& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x - y.real (), - y.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator-(const RealType1& x, const complex<RealType2>& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x - y.real(), -y.imag());
 }
 
 //! Unary - operator for complex.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-complex<RealType>
-operator - (const complex<RealType>& x) {
-  return complex<RealType> (-x.real (), -x.imag ());
+template <class RealType>
+KOKKOS_INLINE_FUNCTION complex<RealType> operator-(
+    const complex<RealType>& x) noexcept {
+  return complex<RealType>(-x.real(), -x.imag());
 }
 
 //! Binary * operator for complex.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator * (const complex<RealType1>& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x.real () * y.real () - x.imag () * y.imag (),
-                                                                        x.real () * y.imag () + x.imag () * y.real ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator*(const complex<RealType1>& x,
+              const complex<RealType2>& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x.real() * y.real() - x.imag() * y.imag(),
+      x.real() * y.imag() + x.imag() * y.real());
 }
 
 /// \brief Binary * operator for std::complex and complex.
 ///
-/// This function exists because GCC 4.7.2 (and perhaps other
-/// compilers) are not able to deduce that they can multiply
-/// std::complex by Kokkos::complex, by first converting std::complex
-/// to Kokkos::complex.
+/// This needs to exist because template parameters can't be deduced when
+/// conversions occur.  We could probably fix this using hidden friends patterns
 ///
 /// This function cannot be called in a CUDA device function, because
 /// std::complex's methods and nonmember functions are not marked as
 /// CUDA device functions.
-template<class RealType1, class RealType2>
-inline
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator * (const std::complex<RealType1>& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x.real () * y.real () - x.imag () * y.imag (),
-                                                                        x.real () * y.imag () + x.imag () * y.real ());
+template <class RealType1, class RealType2>
+inline complex<typename std::common_type<RealType1, RealType2>::type> operator*(
+    const std::complex<RealType1>& x, const complex<RealType2>& y) {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x.real() * y.real() - x.imag() * y.imag(),
+      x.real() * y.imag() + x.imag() * y.real());
 }
 
 /// \brief Binary * operator for RealType times complex.
 ///
 /// This function exists because the compiler doesn't know that
 /// RealType and complex<RealType> commute with respect to operator*.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator * (const RealType1& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x * y.real (), x * y.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator*(const RealType1& x, const complex<RealType2>& y) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x * y.real(), x * y.imag());
 }
 
 /// \brief Binary * operator for RealType times complex.
 ///
 /// This function exists because the compiler doesn't know that
 /// RealType and complex<RealType> commute with respect to operator*.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator * (const complex<RealType1>& y, const RealType2& x) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x * y.real (), x * y.imag ());
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator*(const complex<RealType1>& y, const RealType2& x) noexcept {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      x * y.real(), x * y.imag());
 }
 
 //! Imaginary part of a complex number.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-RealType imag (const complex<RealType>& x) {
-  return x.imag ();
+template <class RealType>
+KOKKOS_INLINE_FUNCTION RealType imag(const complex<RealType>& x) noexcept {
+  return x.imag();
 }
 
 //! Real part of a complex number.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-RealType real (const complex<RealType>& x) {
-  return x.real ();
+template <class RealType>
+KOKKOS_INLINE_FUNCTION RealType real(const complex<RealType>& x) noexcept {
+  return x.real();
 }
 
 //! Absolute value (magnitude) of a complex number.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-RealType abs (const complex<RealType>& x) {
+template <class RealType>
+KOKKOS_INLINE_FUNCTION RealType abs(const complex<RealType>& x) {
 #ifndef __CUDA_ARCH__
   using std::hypot;
 #endif
-  return hypot(x.real(),x.imag());
+  return hypot(x.real(), x.imag());
 }
 
 //! Power of a complex number
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-Kokkos::complex<RealType> pow (const complex<RealType>& x, const RealType& e) {
-  RealType r = abs(x);
-  RealType phi = std::atan(x.imag()/x.real());
-  return std::pow(r,e) * Kokkos::complex<RealType>(std::cos(phi*e),std::sin(phi*e)); 
+template <class RealType>
+KOKKOS_INLINE_FUNCTION Kokkos::complex<RealType> pow(const complex<RealType>& x,
+                                                     const RealType& e) {
+  RealType r   = abs(x);
+  RealType phi = std::atan(x.imag() / x.real());
+  return std::pow(r, e) *
+         Kokkos::complex<RealType>(std::cos(phi * e), std::sin(phi * e));
 }
 
 //! Square root of a complex number.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-Kokkos::complex<RealType> sqrt (const complex<RealType>& x) {
-  RealType r = abs(x);
-  RealType phi = std::atan(x.imag()/x.real());
-  return std::sqrt(r) * Kokkos::complex<RealType>(std::cos(phi*0.5),std::sin(phi*0.5));
+template <class RealType>
+KOKKOS_INLINE_FUNCTION Kokkos::complex<RealType> sqrt(
+    const complex<RealType>& x) {
+  RealType r   = abs(x);
+  RealType phi = std::atan(x.imag() / x.real());
+  return std::sqrt(r) *
+         Kokkos::complex<RealType>(std::cos(phi * 0.5), std::sin(phi * 0.5));
 }
 
 //! Conjugate of a complex number.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-complex<RealType> conj (const complex<RealType>& x) {
-  return complex<RealType> (real (x), -imag (x));
+template <class RealType>
+KOKKOS_INLINE_FUNCTION complex<RealType> conj(
+    const complex<RealType>& x) noexcept {
+  return complex<RealType>(real(x), -imag(x));
 }
 
 //! Exponential of a complex number.
-template<class RealType>
-KOKKOS_INLINE_FUNCTION
-complex<RealType> exp (const complex<RealType>& x) {
-  return std::exp(x.real()) * complex<RealType> (std::cos (x.imag()),  std::sin(x.imag()));
+template <class RealType>
+KOKKOS_INLINE_FUNCTION complex<RealType> exp(const complex<RealType>& x) {
+  return std::exp(x.real()) *
+         complex<RealType>(std::cos(x.imag()), std::sin(x.imag()));
 }
 
 /// This function cannot be called in a CUDA device function,
 /// because std::complex's methods and nonmember functions are not
 /// marked as CUDA device functions.
-template<class RealType>
-inline
-complex<RealType>
-exp (const std::complex<RealType>& c) {
-  return complex<RealType>( std::exp( c.real() )*std::cos( c.imag() ), std::exp( c.real() )*std::sin( c.imag() ) );
+template <class RealType>
+inline complex<RealType> exp(const std::complex<RealType>& c) {
+  return complex<RealType>(std::exp(c.real()) * std::cos(c.imag()),
+                           std::exp(c.real()) * std::sin(c.imag()));
 }
 
 //! Binary operator / for complex and real numbers
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator / (const complex<RealType1>& x, const RealType2& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (real (x) / y, imag (x) / y);
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator/(const complex<RealType1>& x,
+              const RealType2& y) noexcept(noexcept(RealType1{} /
+                                                    RealType2{})) {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(
+      real(x) / y, imag(x) / y);
 }
 
 //! Binary operator / for complex.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator / (const complex<RealType1>& x, const complex<RealType2>& y) {
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator/(const complex<RealType1>& x,
+              const complex<RealType2>& y) noexcept(noexcept(RealType1{} /
+                                                             RealType2{})) {
   // Scale (by the "1-norm" of y) to avoid unwarranted overflow.
   // If the real part is +/-Inf and the imaginary part is -/+Inf,
   // this won't change the result.
-  typedef typename std::common_type<RealType1,RealType2>::type common_real_type;
-  const common_real_type s = std::fabs (real (y)) + std::fabs (imag (y));
+  typedef
+      typename std::common_type<RealType1, RealType2>::type common_real_type;
+  const common_real_type s = std::fabs(real(y)) + std::fabs(imag(y));
 
   // If s is 0, then y is zero, so x/y == real(x)/0 + i*imag(x)/0.
   // In that case, the relation x/y == (x/s) / (y/s) doesn't hold,
   // because y/s is NaN.
   if (s == 0.0) {
-    return complex<common_real_type> (real (x) / s, imag (x) / s);
-  }
-  else {
-    const complex<common_real_type> x_scaled (real (x) / s, imag (x) / s);
-    const complex<common_real_type> y_conj_scaled (real (y) / s, -imag (y) / s);
-    const RealType1 y_scaled_abs = real (y_conj_scaled) * real (y_conj_scaled) +
-      imag (y_conj_scaled) * imag (y_conj_scaled); // abs(y) == abs(conj(y))
+    return complex<common_real_type>(real(x) / s, imag(x) / s);
+  } else {
+    const complex<common_real_type> x_scaled(real(x) / s, imag(x) / s);
+    const complex<common_real_type> y_conj_scaled(real(y) / s, -imag(y) / s);
+    const RealType1 y_scaled_abs =
+        real(y_conj_scaled) * real(y_conj_scaled) +
+        imag(y_conj_scaled) * imag(y_conj_scaled);  // abs(y) == abs(conj(y))
     complex<common_real_type> result = x_scaled * y_conj_scaled;
     result /= y_scaled_abs;
     return result;
@@ -716,119 +742,43 @@ operator / (const complex<RealType1>& x, const complex<RealType2>& y) {
 }
 
 //! Binary operator / for complex and real numbers
-template<class RealType1, class RealType2>
-KOKKOS_INLINE_FUNCTION
-complex<typename std::common_type<RealType1,RealType2>::type>
-operator / (const RealType1& x, const complex<RealType2>& y) {
-  return complex<typename std::common_type<RealType1,RealType2>::type> (x)/y;
-}
-
-//! Equality operator for two complex numbers.
-template<class RealType1, class RealType2>
-KOKKOS_INLINE_FUNCTION
-bool
-operator == (const complex<RealType1>& x, const complex<RealType2>& y) {
-  typedef typename std::common_type<RealType1,RealType2>::type common_real_type;
-  return ( static_cast<common_real_type>(real (x)) == static_cast<common_real_type>(real (y)) && 
-           static_cast<common_real_type>(imag (x)) == static_cast<common_real_type>(imag (y)) );
-}
-
-/// \brief Equality operator for std::complex and Kokkos::complex.
-///
-/// This cannot be a device function, since std::real is not.
-/// Otherwise, CUDA builds will give compiler warnings ("warning:
-/// calling a constexpr __host__ function("real") from a __host__
-/// __device__ function("operator==") is not allowed").
-template<class RealType1, class RealType2>
-inline
-bool
-operator == (const std::complex<RealType1>& x, const complex<RealType2>& y) {
-  typedef typename std::common_type<RealType1,RealType2>::type common_real_type;
-  return ( static_cast<common_real_type>(std::real (x)) == static_cast<common_real_type>(real (y)) && 
-           static_cast<common_real_type>(std::imag (x)) == static_cast<common_real_type>(imag (y)) );
-}
-  
-//! Equality operator for complex and real number.
-template<class RealType1, class RealType2>
-KOKKOS_INLINE_FUNCTION
-bool
-operator == (const complex<RealType1>& x, const RealType2& y) {
-  typedef typename std::common_type<RealType1,RealType2>::type common_real_type;
-  return ( static_cast<common_real_type>(real (x)) == static_cast<common_real_type>(y) && 
-           static_cast<common_real_type>(imag (x)) == static_cast<common_real_type>(0.0) );
-}
-
-//! Equality operator for real and complex number.
-template<class RealType1, class RealType2>
-KOKKOS_INLINE_FUNCTION
-bool
-operator == (const RealType1& x, const complex<RealType2>& y) {
-  return y == x;
-}
-
-//! Inequality operator for two complex numbers.
-template<class RealType1, class RealType2>
+template <class RealType1, class RealType2>
 KOKKOS_INLINE_FUNCTION
-bool
-operator != (const complex<RealType1>& x, const complex<RealType2>& y) {
-  typedef typename std::common_type<RealType1,RealType2>::type common_real_type;
-  return ( static_cast<common_real_type>(real (x)) != static_cast<common_real_type>(real (y)) || 
-           static_cast<common_real_type>(imag (x)) != static_cast<common_real_type>(imag (y)) );
-}
-
-//! Inequality operator for std::complex and Kokkos::complex.
-template<class RealType1, class RealType2>
-inline
-bool
-operator != (const std::complex<RealType1>& x, const complex<RealType2>& y) {
-  typedef typename std::common_type<RealType1,RealType2>::type common_real_type;
-  return ( static_cast<common_real_type>(std::real (x)) != static_cast<common_real_type>(real (y)) || 
-           static_cast<common_real_type>(std::imag (x)) != static_cast<common_real_type>(imag (y)) );
+    complex<typename std::common_type<RealType1, RealType2>::type>
+    operator/(const RealType1& x,
+              const complex<RealType2>& y) noexcept(noexcept(RealType1{} /
+                                                             RealType2{})) {
+  return complex<typename std::common_type<RealType1, RealType2>::type>(x) / y;
 }
 
-//! Inequality operator for complex and real number.
-template<class RealType1, class RealType2>
-KOKKOS_INLINE_FUNCTION
-bool
-operator != (const complex<RealType1>& x, const RealType2& y) {
-  typedef typename std::common_type<RealType1,RealType2>::type common_real_type;
-  return ( static_cast<common_real_type>(real (x)) != static_cast<common_real_type>(y) || 
-           static_cast<common_real_type>(imag (x)) != static_cast<common_real_type>(0.0) );
-}
-
-//! Inequality operator for real and complex number.
-template<class RealType1, class RealType2>
-KOKKOS_INLINE_FUNCTION
-bool
-operator != (const RealType1& x, const complex<RealType2>& y) {
-  return y != x;
-}
-
-template<class RealType>
-std::ostream& operator << (std::ostream& os, const complex<RealType>& x) {
-  const std::complex<RealType> x_std (Kokkos::real (x), Kokkos::imag (x));
+template <class RealType>
+std::ostream& operator<<(std::ostream& os, const complex<RealType>& x) {
+  const std::complex<RealType> x_std(Kokkos::real(x), Kokkos::imag(x));
   os << x_std;
   return os;
 }
 
-template<class RealType>
-std::ostream& operator >> (std::ostream& os, complex<RealType>& x) {
+template <class RealType>
+std::istream& operator>>(std::istream& is, complex<RealType>& x) {
   std::complex<RealType> x_std;
-  os >> x_std;
-  x = x_std; // only assigns on success of above
-  return os;
+  is >> x_std;
+  x = x_std;  // only assigns on success of above
+  return is;
 }
 
-
-template<class T>
+template <class T>
 struct reduction_identity<Kokkos::complex<T> > {
   typedef reduction_identity<T> t_red_ident;
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static Kokkos::complex<T> sum()
-      {return Kokkos::complex<T>(t_red_ident::sum(),t_red_ident::sum());}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static Kokkos::complex<T> prod()
-      {return Kokkos::complex<T>(t_red_ident::prod(),t_red_ident::sum());}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static Kokkos::complex<T>
+  sum() noexcept {
+    return Kokkos::complex<T>(t_red_ident::sum(), t_red_ident::sum());
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static Kokkos::complex<T>
+  prod() noexcept {
+    return Kokkos::complex<T>(t_red_ident::prod(), t_red_ident::sum());
+  }
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
-#endif // KOKKOS_COMPLEX_HPP
+#endif  // KOKKOS_COMPLEX_HPP
diff --git a/lib/kokkos/core/src/Kokkos_Concepts.hpp b/lib/kokkos/core/src/Kokkos_Concepts.hpp
index ca2e8b4eb62ae9650abc8fee92b02c71911880b0..99b7aa9aab185d8a4cfc25a224acfcf25f7e816c 100644
--- a/lib/kokkos/core/src/Kokkos_Concepts.hpp
+++ b/lib/kokkos/core/src/Kokkos_Concepts.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -54,245 +55,264 @@
 
 namespace Kokkos {
 
-//Schedules for Execution Policies
+// Schedules for Execution Policies
 struct Static {};
 struct Dynamic {};
 
-//Schedule Wrapper Type
-template<class T>
-struct Schedule
-{
-  static_assert(  std::is_same<T,Static>::value
-               || std::is_same<T,Dynamic>::value
-               , "Kokkos: Invalid Schedule<> type."
-               );
-  using schedule_type = Schedule ;
-  using type = T;
+// Schedule Wrapper Type
+template <class T>
+struct Schedule {
+  static_assert(std::is_same<T, Static>::value ||
+                    std::is_same<T, Dynamic>::value,
+                "Kokkos: Invalid Schedule<> type.");
+  using schedule_type = Schedule;
+  using type          = T;
 };
 
-//Specify Iteration Index Type
-template<typename T>
-struct IndexType
-{
-  static_assert(std::is_integral<T>::value,"Kokkos: Invalid IndexType<>.");
-  using index_type = IndexType ;
-  using type = T;
+// Specify Iteration Index Type
+template <typename T>
+struct IndexType {
+  static_assert(std::is_integral<T>::value, "Kokkos: Invalid IndexType<>.");
+  using index_type = IndexType;
+  using type       = T;
 };
 
 namespace Experimental {
-  struct WorkItemProperty {
-    template<unsigned long Property>
-    struct ImplWorkItemProperty {
-      static const unsigned value = Property;
-      using work_item_property = ImplWorkItemProperty<Property>;
-    };
-
-    constexpr static const ImplWorkItemProperty<0> None = ImplWorkItemProperty<0>();
-    constexpr static const ImplWorkItemProperty<1> HintLightWeight = ImplWorkItemProperty<1>();
-    constexpr static const ImplWorkItemProperty<2> HintHeavyWeight = ImplWorkItemProperty<2>();
-    constexpr static const ImplWorkItemProperty<4> HintRegular = ImplWorkItemProperty<4>();
-    constexpr static const ImplWorkItemProperty<8> HintIrregular = ImplWorkItemProperty<8>();
-    typedef ImplWorkItemProperty<0> None_t;
-    typedef ImplWorkItemProperty<1> HintLightWeight_t;
-    typedef ImplWorkItemProperty<2> HintHeavyWeight_t;
-    typedef ImplWorkItemProperty<4> HintRegular_t;
-    typedef ImplWorkItemProperty<8> HintIrregular_t;
+struct WorkItemProperty {
+  template <unsigned long Property>
+  struct ImplWorkItemProperty {
+    static const unsigned value = Property;
+    using work_item_property    = ImplWorkItemProperty<Property>;
   };
 
-template<unsigned long pv1, unsigned long pv2>
-inline constexpr WorkItemProperty::ImplWorkItemProperty<pv1|pv2> operator |
-  (WorkItemProperty::ImplWorkItemProperty<pv1>, WorkItemProperty::ImplWorkItemProperty<pv2>) {
-  return WorkItemProperty::ImplWorkItemProperty<pv1|pv2>();
-}
+  constexpr static const ImplWorkItemProperty<0> None =
+      ImplWorkItemProperty<0>();
+  constexpr static const ImplWorkItemProperty<1> HintLightWeight =
+      ImplWorkItemProperty<1>();
+  constexpr static const ImplWorkItemProperty<2> HintHeavyWeight =
+      ImplWorkItemProperty<2>();
+  constexpr static const ImplWorkItemProperty<4> HintRegular =
+      ImplWorkItemProperty<4>();
+  constexpr static const ImplWorkItemProperty<8> HintIrregular =
+      ImplWorkItemProperty<8>();
+  typedef ImplWorkItemProperty<0> None_t;
+  typedef ImplWorkItemProperty<1> HintLightWeight_t;
+  typedef ImplWorkItemProperty<2> HintHeavyWeight_t;
+  typedef ImplWorkItemProperty<4> HintRegular_t;
+  typedef ImplWorkItemProperty<8> HintIrregular_t;
+};
 
-template<unsigned long pv1, unsigned long pv2>
-inline constexpr WorkItemProperty::ImplWorkItemProperty<pv1&pv2> operator &
-  (WorkItemProperty::ImplWorkItemProperty<pv1>, WorkItemProperty::ImplWorkItemProperty<pv2>) {
-  return WorkItemProperty::ImplWorkItemProperty<pv1&pv2>();
+template <unsigned long pv1, unsigned long pv2>
+inline constexpr WorkItemProperty::ImplWorkItemProperty<pv1 | pv2> operator|(
+    WorkItemProperty::ImplWorkItemProperty<pv1>,
+    WorkItemProperty::ImplWorkItemProperty<pv2>) {
+  return WorkItemProperty::ImplWorkItemProperty<pv1 | pv2>();
 }
 
-template<unsigned long pv1, unsigned long pv2>
-inline constexpr bool operator == (WorkItemProperty::ImplWorkItemProperty<pv1>, WorkItemProperty::ImplWorkItemProperty<pv2>) {
-  return pv1 ==  pv2;
+template <unsigned long pv1, unsigned long pv2>
+inline constexpr WorkItemProperty::ImplWorkItemProperty<pv1 & pv2> operator&(
+    WorkItemProperty::ImplWorkItemProperty<pv1>,
+    WorkItemProperty::ImplWorkItemProperty<pv2>) {
+  return WorkItemProperty::ImplWorkItemProperty<pv1 & pv2>();
 }
 
+template <unsigned long pv1, unsigned long pv2>
+inline constexpr bool operator==(WorkItemProperty::ImplWorkItemProperty<pv1>,
+                                 WorkItemProperty::ImplWorkItemProperty<pv2>) {
+  return pv1 == pv2;
 }
 
+}  // namespace Experimental
+
 /**\brief Specify Launch Bounds for CUDA execution.
  *
  *  If no launch bounds specified then do not set launch bounds.
  */
-template< unsigned int maxT = 0 /* Max threads per block */
-        , unsigned int minB = 0 /* Min blocks per SM */
-        >
-struct LaunchBounds
-{
+template <unsigned int maxT = 0 /* Max threads per block */
+          ,
+          unsigned int minB = 0 /* Min blocks per SM */
+          >
+struct LaunchBounds {
   using launch_bounds = LaunchBounds;
-  using type = LaunchBounds<maxT,minB>;
-  static unsigned int constexpr maxTperB {maxT};
-  static unsigned int constexpr minBperSM {minB};
+  using type          = LaunchBounds<maxT, minB>;
+  static unsigned int constexpr maxTperB{maxT};
+  static unsigned int constexpr minBperSM{minB};
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-#define KOKKOS_IMPL_IS_CONCEPT( CONCEPT ) \
-  template< typename T > struct is_ ## CONCEPT { \
-  private: \
-    template< typename , typename = std::true_type > struct have : std::false_type {}; \
-    template< typename U > struct have<U,typename std::is_base_of< \
-     typename std::remove_cv<typename U:: CONCEPT>::type, \
-     typename std::remove_cv<U>::type \
-   >::type> : std::true_type {}; \
-    template< typename U > struct have<U,typename std::is_base_of< \
-     typename std::remove_cv<typename U:: CONCEPT ## _type>::type, \
-     typename std::remove_cv<U>::type \
-   >::type> : std::true_type {}; \
-  public: \
-    enum { value = is_ ## CONCEPT::template have<T>::value }; \
+#define KOKKOS_IMPL_IS_CONCEPT(CONCEPT)                                        \
+  template <typename T>                                                        \
+  struct is_##CONCEPT {                                                        \
+   private:                                                                    \
+    template <typename, typename = std::true_type>                             \
+    struct have : std::false_type {};                                          \
+    template <typename U>                                                      \
+    struct have<U, typename std::is_base_of<                                   \
+                       typename std::remove_cv<typename U::CONCEPT>::type,     \
+                       typename std::remove_cv<U>::type>::type>                \
+        : std::true_type {};                                                   \
+    template <typename U>                                                      \
+    struct have<U,                                                             \
+                typename std::is_base_of<                                      \
+                    typename std::remove_cv<typename U::CONCEPT##_type>::type, \
+                    typename std::remove_cv<U>::type>::type>                   \
+        : std::true_type {};                                                   \
+                                                                               \
+   public:                                                                     \
+    enum { value = is_##CONCEPT::template have<T>::value };                    \
   };
 
 // Public concept:
 
-KOKKOS_IMPL_IS_CONCEPT( memory_space )
-KOKKOS_IMPL_IS_CONCEPT( memory_traits )
-KOKKOS_IMPL_IS_CONCEPT( execution_space )
-KOKKOS_IMPL_IS_CONCEPT( execution_policy )
-KOKKOS_IMPL_IS_CONCEPT( array_layout )
-KOKKOS_IMPL_IS_CONCEPT( reducer )
+KOKKOS_IMPL_IS_CONCEPT(memory_space)
+KOKKOS_IMPL_IS_CONCEPT(memory_traits)
+KOKKOS_IMPL_IS_CONCEPT(execution_space)
+KOKKOS_IMPL_IS_CONCEPT(execution_policy)
+KOKKOS_IMPL_IS_CONCEPT(array_layout)
+KOKKOS_IMPL_IS_CONCEPT(reducer)
 namespace Experimental {
-KOKKOS_IMPL_IS_CONCEPT( work_item_property )
+KOKKOS_IMPL_IS_CONCEPT(work_item_property)
 }
 
 namespace Impl {
 
 // For backward compatibility:
 
-using Kokkos::is_memory_space ;
-using Kokkos::is_memory_traits ;
-using Kokkos::is_execution_space ;
-using Kokkos::is_execution_policy ;
-using Kokkos::is_array_layout ;
+using Kokkos::is_array_layout;
+using Kokkos::is_execution_policy;
+using Kokkos::is_execution_space;
+using Kokkos::is_memory_space;
+using Kokkos::is_memory_traits;
 
 // Implementation concept:
 
-KOKKOS_IMPL_IS_CONCEPT( iteration_pattern )
-KOKKOS_IMPL_IS_CONCEPT( schedule_type )
-KOKKOS_IMPL_IS_CONCEPT( index_type )
-KOKKOS_IMPL_IS_CONCEPT( launch_bounds )
-KOKKOS_IMPL_IS_CONCEPT( thread_team_member )
-KOKKOS_IMPL_IS_CONCEPT( host_thread_team_member )
+KOKKOS_IMPL_IS_CONCEPT(iteration_pattern)
+KOKKOS_IMPL_IS_CONCEPT(schedule_type)
+KOKKOS_IMPL_IS_CONCEPT(index_type)
+KOKKOS_IMPL_IS_CONCEPT(launch_bounds)
+KOKKOS_IMPL_IS_CONCEPT(thread_team_member)
+KOKKOS_IMPL_IS_CONCEPT(host_thread_team_member)
 
-}
+}  // namespace Impl
 
 #undef KOKKOS_IMPL_IS_CONCEPT
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-template< class ExecutionSpace , class MemorySpace >
+template <class ExecutionSpace, class MemorySpace>
 struct Device {
-  static_assert( Kokkos::is_execution_space<ExecutionSpace>::value
-               , "Execution space is not valid" );
-  static_assert( Kokkos::is_memory_space<MemorySpace>::value
-               , "Memory space is not valid" );
-  typedef ExecutionSpace                        execution_space;
-  typedef MemorySpace                           memory_space;
-  typedef Device<execution_space,memory_space>  device_type;
+  static_assert(Kokkos::is_execution_space<ExecutionSpace>::value,
+                "Execution space is not valid");
+  static_assert(Kokkos::is_memory_space<MemorySpace>::value,
+                "Memory space is not valid");
+  typedef ExecutionSpace execution_space;
+  typedef MemorySpace memory_space;
+  typedef Device<execution_space, memory_space> device_type;
 };
 
-
-template< typename T >
+template <typename T>
 struct is_space {
-private:
-
-  template< typename , typename = void >
-  struct exe : std::false_type { typedef void space ; };
-
-  template< typename , typename = void >
-  struct mem : std::false_type { typedef void space ; };
+ private:
+  template <typename, typename = void>
+  struct exe : std::false_type {
+    typedef void space;
+  };
 
-  template< typename , typename = void >
-  struct dev : std::false_type { typedef void space ; };
+  template <typename, typename = void>
+  struct mem : std::false_type {
+    typedef void space;
+  };
 
-  template< typename U >
-  struct exe<U,typename std::conditional<true,void,typename U::execution_space>::type>
-    : std::is_same<U,typename U::execution_space>::type
-    { typedef typename U::execution_space space ; };
+  template <typename, typename = void>
+  struct dev : std::false_type {
+    typedef void space;
+  };
 
-  template< typename U >
-  struct mem<U,typename std::conditional<true,void,typename U::memory_space>::type>
-    : std::is_same<U,typename U::memory_space>::type
-    { typedef typename U::memory_space space ; };
+  template <typename U>
+  struct exe<U, typename std::conditional<true, void,
+                                          typename U::execution_space>::type>
+      : std::is_same<U, typename U::execution_space>::type {
+    typedef typename U::execution_space space;
+  };
 
-  template< typename U >
-  struct dev<U,typename std::conditional<true,void,typename U::device_type>::type>
-    : std::is_same<U,typename U::device_type>::type
-    { typedef typename U::device_type space ; };
+  template <typename U>
+  struct mem<
+      U, typename std::conditional<true, void, typename U::memory_space>::type>
+      : std::is_same<U, typename U::memory_space>::type {
+    typedef typename U::memory_space space;
+  };
 
-  typedef typename is_space::template exe<T> is_exe ;
-  typedef typename is_space::template mem<T> is_mem ;
-  typedef typename is_space::template dev<T> is_dev ;
+  template <typename U>
+  struct dev<
+      U, typename std::conditional<true, void, typename U::device_type>::type>
+      : std::is_same<U, typename U::device_type>::type {
+    typedef typename U::device_type space;
+  };
 
-public:
+  typedef typename is_space::template exe<T> is_exe;
+  typedef typename is_space::template mem<T> is_mem;
+  typedef typename is_space::template dev<T> is_dev;
 
+ public:
   enum { value = is_exe::value || is_mem::value || is_dev::value };
 
-  typedef typename is_exe::space execution_space ;
-  typedef typename is_mem::space memory_space ;
+  typedef typename is_exe::space execution_space;
+  typedef typename is_mem::space memory_space;
 
   // For backward compatibility, deprecated in favor of
   // Kokkos::Impl::HostMirror<S>::host_mirror_space
 
-  typedef typename std::conditional
-    < std::is_same< memory_space , Kokkos::HostSpace >::value
-#if defined( KOKKOS_ENABLE_CUDA )
-      || std::is_same< memory_space , Kokkos::CudaUVMSpace >::value
-      || std::is_same< memory_space , Kokkos::CudaHostPinnedSpace >::value
+  typedef typename std::conditional<
+      std::is_same<memory_space, Kokkos::HostSpace>::value
+#if defined(KOKKOS_ENABLE_CUDA)
+          || std::is_same<memory_space, Kokkos::CudaUVMSpace>::value ||
+          std::is_same<memory_space, Kokkos::CudaHostPinnedSpace>::value
 #endif /* #if defined( KOKKOS_ENABLE_CUDA ) */
-    , memory_space
-    , Kokkos::HostSpace
-    >::type  host_memory_space ;
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  typedef typename std::conditional
-    < std::is_same< execution_space , Kokkos::Cuda >::value
-    , Kokkos::DefaultHostExecutionSpace , execution_space
-    >::type  host_execution_space ;
+      ,
+      memory_space, Kokkos::HostSpace>::type host_memory_space;
+
+#if defined(KOKKOS_ENABLE_CUDA)
+  typedef typename std::conditional<
+      std::is_same<execution_space, Kokkos::Cuda>::value,
+      Kokkos::DefaultHostExecutionSpace, execution_space>::type
+      host_execution_space;
+#else
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+  typedef typename std::conditional<
+      std::is_same<execution_space, Kokkos::Experimental::OpenMPTarget>::value,
+      Kokkos::DefaultHostExecutionSpace, execution_space>::type
+      host_execution_space;
 #else
-  #if defined( KOKKOS_ENABLE_OPENMPTARGET )
-    typedef typename std::conditional
-      < std::is_same< execution_space , Kokkos::Experimental::OpenMPTarget >::value
-      , Kokkos::DefaultHostExecutionSpace , execution_space
-      >::type  host_execution_space ;
-  #else
-    typedef execution_space  host_execution_space ;
-  #endif
+  typedef execution_space host_execution_space;
+#endif
 #endif
 
-  typedef typename std::conditional
-    < std::is_same< execution_space , host_execution_space >::value &&
-      std::is_same< memory_space ,    host_memory_space    >::value
-    , T , Kokkos::Device< host_execution_space , host_memory_space >
-    >::type  host_mirror_space ;
+  typedef typename std::conditional<
+      std::is_same<execution_space, host_execution_space>::value &&
+          std::is_same<memory_space, host_memory_space>::value,
+      T, Kokkos::Device<host_execution_space, host_memory_space> >::type
+      host_mirror_space;
 };
 
 // For backward compatibility
 
 namespace Impl {
 
-using Kokkos::is_space ;
+using Kokkos::is_space;
 
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -304,12 +324,11 @@ namespace Impl {
  *  The default case can assume accessibility for the same space.
  *  Specializations must be defined for different memory spaces.
  */
-template< typename DstMemorySpace , typename SrcMemorySpace >
+template <typename DstMemorySpace, typename SrcMemorySpace>
 struct MemorySpaceAccess {
-
-  static_assert( Kokkos::is_memory_space< DstMemorySpace >::value &&
-                 Kokkos::is_memory_space< SrcMemorySpace >::value
-               , "template arguments must be memory spaces" );
+  static_assert(Kokkos::is_memory_space<DstMemorySpace>::value &&
+                    Kokkos::is_memory_space<SrcMemorySpace>::value,
+                "template arguments must be memory spaces");
 
   /**\brief  Can a View (or pointer) to memory in SrcMemorySpace
    *         be assigned to a View (or pointer) to memory marked DstMemorySpace.
@@ -318,7 +337,7 @@ struct MemorySpaceAccess {
    *  2. All execution spaces that can access DstMemorySpace can also access
    *     SrcMemorySpace.
    */
-  enum { assignable = std::is_same<DstMemorySpace,SrcMemorySpace>::value };
+  enum { assignable = std::is_same<DstMemorySpace, SrcMemorySpace>::value };
 
   /**\brief  For all DstExecSpace::memory_space == DstMemorySpace
    *         DstExecSpace can access SrcMemorySpace.
@@ -331,7 +350,8 @@ struct MemorySpaceAccess {
   enum { deepcopy = assignable };
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 
@@ -354,34 +374,31 @@ namespace Kokkos {
  *   When AccessSpace::memory_space == Kokkos::HostSpace
  *   then space is the View host mirror space.
  */
-template< typename AccessSpace , typename MemorySpace >
+template <typename AccessSpace, typename MemorySpace>
 struct SpaceAccessibility {
-private:
+ private:
+  static_assert(Kokkos::is_space<AccessSpace>::value,
+                "template argument #1 must be a Kokkos space");
 
-  static_assert( Kokkos::is_space< AccessSpace >::value
-               , "template argument #1 must be a Kokkos space" );
-
-  static_assert( Kokkos::is_memory_space< MemorySpace >::value
-               , "template argument #2 must be a Kokkos memory space" );
+  static_assert(Kokkos::is_memory_space<MemorySpace>::value,
+                "template argument #2 must be a Kokkos memory space");
 
   // The input AccessSpace may be a Device<ExecSpace,MemSpace>
   // verify that it is a valid combination of spaces.
-  static_assert( Kokkos::Impl::MemorySpaceAccess
-                   < typename AccessSpace::execution_space::memory_space
-                   , typename AccessSpace::memory_space
-                   >::accessible
-               , "template argument #1 is an invalid space" );
-
-  typedef Kokkos::Impl::MemorySpaceAccess
-    < typename AccessSpace::execution_space::memory_space , MemorySpace >
-      exe_access ;
+  static_assert(Kokkos::Impl::MemorySpaceAccess<
+                    typename AccessSpace::execution_space::memory_space,
+                    typename AccessSpace::memory_space>::accessible,
+                "template argument #1 is an invalid space");
 
-  typedef Kokkos::Impl::MemorySpaceAccess
-    < typename AccessSpace::memory_space , MemorySpace >
-      mem_access ;
+  typedef Kokkos::Impl::MemorySpaceAccess<
+      typename AccessSpace::execution_space::memory_space, MemorySpace>
+      exe_access;
 
-public:
+  typedef Kokkos::Impl::MemorySpaceAccess<typename AccessSpace::memory_space,
+                                          MemorySpace>
+      mem_access;
 
+ public:
   /**\brief  Can AccessSpace::execution_space access MemorySpace ?
    *
    *  Default based upon memory space accessibility.
@@ -394,8 +411,9 @@ public:
    *  Default based upon memory space accessibility.
    *  Specialization required for other relationships.
    */
-  enum { assignable =
-    is_memory_space< AccessSpace >::value && mem_access::assignable };
+  enum {
+    assignable = is_memory_space<AccessSpace>::value && mem_access::assignable
+  };
 
   /**\brief  Can deep copy to AccessSpace::memory_Space from MemorySpace ?  */
   enum { deepcopy = mem_access::deepcopy };
@@ -404,24 +422,24 @@ public:
   // to be able to access MemorySpace?
   // If same memory space or not accessible use the AccessSpace
   // else construct a device with execution space and memory space.
-  typedef typename std::conditional
-    < std::is_same<typename AccessSpace::memory_space,MemorySpace>::value ||
-      ! exe_access::accessible
-    , AccessSpace
-    , Kokkos::Device< typename AccessSpace::execution_space , MemorySpace >
-    >::type  space ;
+  typedef typename std::conditional<
+      std::is_same<typename AccessSpace::memory_space, MemorySpace>::value ||
+          !exe_access::accessible,
+      AccessSpace,
+      Kokkos::Device<typename AccessSpace::execution_space, MemorySpace> >::type
+      space;
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 
-using Kokkos::SpaceAccessibility ; // For backward compatibility
+using Kokkos::SpaceAccessibility;  // For backward compatibility
 
-}} // namespace Kokkos::Impl
+}
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
-#endif // KOKKOS_CORE_CONCEPTS_HPP
-
+#endif  // KOKKOS_CORE_CONCEPTS_HPP
diff --git a/lib/kokkos/core/src/Kokkos_CopyViews.hpp b/lib/kokkos/core/src/Kokkos_CopyViews.hpp
index 9210f21ab74acfebd28e5720e0cdae11a378517e..9b3db1277d677cf0e7a86a74ec0b161d55a466bc 100644
--- a/lib/kokkos/core/src/Kokkos_CopyViews.hpp
+++ b/lib/kokkos/core/src/Kokkos_CopyViews.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -56,1479 +57,1781 @@ namespace Kokkos {
 
 namespace Impl {
 
-template<class Layout>
-struct ViewFillLayoutSelector {
-};
+template <class Layout>
+struct ViewFillLayoutSelector {};
 
-template<>
+template <>
 struct ViewFillLayoutSelector<Kokkos::LayoutLeft> {
   static const Kokkos::Iterate iterate = Kokkos::Iterate::Left;
 };
 
-template<>
+template <>
 struct ViewFillLayoutSelector<Kokkos::LayoutRight> {
   static const Kokkos::Iterate iterate = Kokkos::Iterate::Right;
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
-#include<impl/Kokkos_ViewFillCopyETIAvail.hpp>
+#include <impl/Kokkos_ViewFillCopyETIAvail.hpp>
 
 namespace Kokkos {
 namespace Impl {
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,0,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 0, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,1,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 1, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&) const;
+  void operator()(const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,2,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 2, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&, const iType&) const;
+  void operator()(const iType&, const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,3,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 3, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&, const iType&, const iType&) const;
+  void operator()(const iType&, const iType&, const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,4,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 4, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&, const iType&, const iType&, const iType&) const;
+  void operator()(const iType&, const iType&, const iType&, const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,5,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 5, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&, const iType&, const iType&, const iType&,
-                   const iType&) const;
+  void operator()(const iType&, const iType&, const iType&, const iType&,
+                  const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,6,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 6, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&, const iType&, const iType&, const iType&,
-                   const iType&, const iType&) const;
+  void operator()(const iType&, const iType&, const iType&, const iType&,
+                  const iType&, const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,7,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 7, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&, const iType&, const iType&, const iType&,
-                   const iType&, const iType&, const iType&) const;
+  void operator()(const iType&, const iType&, const iType&, const iType&,
+                  const iType&, const iType&, const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType,bool ETIAvail>
-struct ViewFill<ViewType,Layout,ExecSpace,8,iType,ETIAvail> {
+template <class ViewType, class Layout, class ExecSpace, typename iType,
+          bool ETIAvail>
+struct ViewFill<ViewType, Layout, ExecSpace, 8, iType, ETIAvail> {
   ViewType a;
   typename ViewType::const_value_type val;
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType&, const ST&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType&, const iType&, const iType&, const iType&,
-                   const iType&, const iType&, const iType&, const iType&) const;
+  void operator()(const iType&, const iType&, const iType&, const iType&,
+                  const iType&, const iType&, const iType&, const iType&) const;
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,0,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 0, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   typedef typename ViewType::non_const_value_type ST;
   ViewFill(const ViewType& a, const ST& val) {
-    Kokkos::Impl::DeepCopy< typename ViewType::memory_space, Kokkos::HostSpace >( a.data() , &val, sizeof(ST) );
+    Kokkos::Impl::DeepCopy<typename ViewType::memory_space, Kokkos::HostSpace>(
+        a.data(), &val, sizeof(ST));
   }
 };
 
-
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,1,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 1, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
-  typedef Kokkos::RangePolicy<ExecSpace,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<iType>> policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
-    Kokkos::parallel_for("Kokkos::ViewFill-1D",policy_type(0,a.extent(0)),*this);
+    Kokkos::parallel_for("Kokkos::ViewFill-1D", policy_type(0, a.extent(0)),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i) const {
-    a(i) = val;
-  };
+  void operator()(const iType& i) const { a(i) = val; };
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,2,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 2, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
 
-  typedef Kokkos::Rank<2,ViewFillLayoutSelector<Layout>::iterate,ViewFillLayoutSelector<Layout>::iterate> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::Rank<2, ViewFillLayoutSelector<Layout>::iterate,
+                       ViewFillLayoutSelector<Layout>::iterate>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewFill-2D",
-       policy_type({0,0},{a.extent(0),a.extent(1)}),*this);
+                         policy_type({0, 0}, {a.extent(0), a.extent(1)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1) const {
-    a(i0,i1) = val;
-  };
+  void operator()(const iType& i0, const iType& i1) const { a(i0, i1) = val; };
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,3,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 3, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
 
-  typedef Kokkos::Rank<3,ViewFillLayoutSelector<Layout>::iterate,ViewFillLayoutSelector<Layout>::iterate> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::Rank<3, ViewFillLayoutSelector<Layout>::iterate,
+                       ViewFillLayoutSelector<Layout>::iterate>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
-    Kokkos::parallel_for("Kokkos::ViewFill-3D",
-       policy_type({0,0,0},{a.extent(0),a.extent(1),a.extent(2)}),*this);
+    Kokkos::parallel_for(
+        "Kokkos::ViewFill-3D",
+        policy_type({0, 0, 0}, {a.extent(0), a.extent(1), a.extent(2)}), *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2) const {
-    a(i0,i1,i2) = val;
+  void operator()(const iType& i0, const iType& i1, const iType& i2) const {
+    a(i0, i1, i2) = val;
   };
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,4,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 4, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
 
-  typedef Kokkos::Rank<4,ViewFillLayoutSelector<Layout>::iterate,ViewFillLayoutSelector<Layout>::iterate> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::Rank<4, ViewFillLayoutSelector<Layout>::iterate,
+                       ViewFillLayoutSelector<Layout>::iterate>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewFill-4D",
-       policy_type({0,0,0,0},{a.extent(0),a.extent(1),a.extent(2),a.extent(3)}),*this);
+                         policy_type({0, 0, 0, 0}, {a.extent(0), a.extent(1),
+                                                    a.extent(2), a.extent(3)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2, const iType& i3) const {
-    a(i0,i1,i2,i3) = val;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3) const {
+    a(i0, i1, i2, i3) = val;
   };
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,5,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 5, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
 
-  typedef Kokkos::Rank<5,ViewFillLayoutSelector<Layout>::iterate,ViewFillLayoutSelector<Layout>::iterate> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::Rank<5, ViewFillLayoutSelector<Layout>::iterate,
+                       ViewFillLayoutSelector<Layout>::iterate>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
-    Kokkos::parallel_for("Kokkos::ViewFill-5D",
-       policy_type({0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(2),a.extent(3),a.extent(4)}),*this);
+    Kokkos::parallel_for(
+        "Kokkos::ViewFill-5D",
+        policy_type({0, 0, 0, 0, 0}, {a.extent(0), a.extent(1), a.extent(2),
+                                      a.extent(3), a.extent(4)}),
+        *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2, const iType& i3, const iType& i4) const {
-    a(i0,i1,i2,i3,i4) = val;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4) const {
+    a(i0, i1, i2, i3, i4) = val;
   };
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,6,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 6, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
 
-  typedef Kokkos::Rank<6,ViewFillLayoutSelector<Layout>::iterate,ViewFillLayoutSelector<Layout>::iterate> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::Rank<6, ViewFillLayoutSelector<Layout>::iterate,
+                       ViewFillLayoutSelector<Layout>::iterate>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewFill-6D",
-       policy_type({0,0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(2),a.extent(3),a.extent(4),a.extent(5)}),*this);
+                         policy_type({0, 0, 0, 0, 0, 0},
+                                     {a.extent(0), a.extent(1), a.extent(2),
+                                      a.extent(3), a.extent(4), a.extent(5)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2, const iType& i3, const iType& i4, const iType& i5) const {
-    a(i0,i1,i2,i3,i4,i5) = val;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4, const iType& i5) const {
+    a(i0, i1, i2, i3, i4, i5) = val;
   };
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,7,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 7, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
 
-  typedef Kokkos::Rank<6,ViewFillLayoutSelector<Layout>::iterate,ViewFillLayoutSelector<Layout>::iterate> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::Rank<6, ViewFillLayoutSelector<Layout>::iterate,
+                       ViewFillLayoutSelector<Layout>::iterate>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewFill-7D",
-       policy_type({0,0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(2),a.extent(3),
-                                  a.extent(5),a.extent(6)}),*this);
+                         policy_type({0, 0, 0, 0, 0, 0},
+                                     {a.extent(0), a.extent(1), a.extent(2),
+                                      a.extent(3), a.extent(5), a.extent(6)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i3,
-                   const iType& i4, const iType& i5, const iType& i6) const {
-    for(iType i2=0; i2<iType(a.extent(2));i2++)
-      a(i0,i1,i2,i3,i4,i5,i6) = val;
+  void operator()(const iType& i0, const iType& i1, const iType& i3,
+                  const iType& i4, const iType& i5, const iType& i6) const {
+    for (iType i2 = 0; i2 < iType(a.extent(2)); i2++)
+      a(i0, i1, i2, i3, i4, i5, i6) = val;
   };
 };
 
-template<class ViewType,class Layout, class ExecSpace,typename iType>
-struct ViewFill<ViewType,Layout,ExecSpace,8,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewType, class Layout, class ExecSpace, typename iType>
+struct ViewFill<ViewType, Layout, ExecSpace, 8, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewType a;
   typename ViewType::const_value_type val;
 
-  typedef Kokkos::Rank<6,ViewFillLayoutSelector<Layout>::iterate,ViewFillLayoutSelector<Layout>::iterate> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::Rank<6, ViewFillLayoutSelector<Layout>::iterate,
+                       ViewFillLayoutSelector<Layout>::iterate>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
 
-  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_):a(a_),val(val_) {
+  ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_)
+      : a(a_), val(val_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewFill-8D",
-       policy_type({0,0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(3),
-                                  a.extent(5),a.extent(6),a.extent(7)}),*this);
+                         policy_type({0, 0, 0, 0, 0, 0},
+                                     {a.extent(0), a.extent(1), a.extent(3),
+                                      a.extent(5), a.extent(6), a.extent(7)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i3,
-                   const iType& i5, const iType& i6, const iType& i7) const {
-    for(iType i2=0; i2<iType(a.extent(2));i2++)
-    for(iType i4=0; i4<iType(a.extent(4));i4++)
-      a(i0,i1,i2,i3,i4,i5,i6,i7) = val;
+  void operator()(const iType& i0, const iType& i1, const iType& i3,
+                  const iType& i5, const iType& i6, const iType& i7) const {
+    for (iType i2 = 0; i2 < iType(a.extent(2)); i2++)
+      for (iType i4 = 0; i4 < iType(a.extent(4)); i4++)
+        a(i0, i1, i2, i3, i4, i5, i6, i7) = val;
   };
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,1,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 1, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0) const;
+  void operator()(const iType& i0) const;
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,2,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 2, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0,const iType& i1) const;
+  void operator()(const iType& i0, const iType& i1) const;
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,3,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 3, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0,const iType& i1,const iType& i2) const;
+  void operator()(const iType& i0, const iType& i1, const iType& i2) const;
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,4,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 4, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0,const iType& i1,const iType& i2,const iType& i3) const;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3) const;
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,5,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 5, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0,const iType& i1,const iType& i2,const iType& i3,
-                   const iType& i4) const;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4) const;
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,6,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 6, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0,const iType& i1,const iType& i2,const iType& i3,
-                   const iType& i4,const iType& i5) const;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4, const iType& i5) const;
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,7,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 7, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0,const iType& i1,const iType& i2,const iType& i3,
-                   const iType& i4,const iType& i5,const iType& i6) const;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4, const iType& i5,
+                  const iType& i6) const;
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType, bool ETIAvail>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,8,iType,ETIAvail> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType, bool ETIAvail>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 8, iType, ETIAvail> {
   ViewTypeA a;
   ViewTypeB b;
   ViewCopy(const ViewTypeA&, const ViewTypeB&);
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0,const iType& i1,const iType& i2,const iType& i3,
-                   const iType& i4,const iType& i5,const iType& i6,const iType& i7) const;
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4, const iType& i5,
+                  const iType& i6, const iType& i7) const;
 };
 
-
-
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,1,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 1, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
 
-  typedef Kokkos::RangePolicy<ExecSpace,Kokkos::IndexType<iType>> policy_type;
+  typedef Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<iType>> policy_type;
 
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
-    Kokkos::parallel_for("Kokkos::ViewCopy-1D",
-       policy_type(0,a.extent(0)),*this);
+    Kokkos::parallel_for("Kokkos::ViewCopy-1D", policy_type(0, a.extent(0)),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0) const {
-      a(i0) = b(i0);
-  };
+  void operator()(const iType& i0) const { a(i0) = b(i0); };
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,2,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 2, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
-  typedef Kokkos::Rank<2,outer_iteration_pattern,inner_iteration_pattern> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
-
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+  typedef Kokkos::Rank<2, outer_iteration_pattern, inner_iteration_pattern>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
+
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewCopy-2D",
-       policy_type({0,0},{a.extent(0),a.extent(1)}),*this);
+                         policy_type({0, 0}, {a.extent(0), a.extent(1)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1) const {
-      a(i0,i1) = b(i0,i1);
+  void operator()(const iType& i0, const iType& i1) const {
+    a(i0, i1) = b(i0, i1);
   };
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,3,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 3, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
 
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
-  typedef Kokkos::Rank<3,outer_iteration_pattern,inner_iteration_pattern> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
-
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+  typedef Kokkos::Rank<3, outer_iteration_pattern, inner_iteration_pattern>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
+
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
-    Kokkos::parallel_for("Kokkos::ViewCopy-3D",
-       policy_type({0,0,0},{a.extent(0),a.extent(1),a.extent(2)}),*this);
+    Kokkos::parallel_for(
+        "Kokkos::ViewCopy-3D",
+        policy_type({0, 0, 0}, {a.extent(0), a.extent(1), a.extent(2)}), *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2) const {
-      a(i0,i1,i2) = b(i0,i1,i2);
+  void operator()(const iType& i0, const iType& i1, const iType& i2) const {
+    a(i0, i1, i2) = b(i0, i1, i2);
   };
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,4,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 4, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
 
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
-  typedef Kokkos::Rank<4,outer_iteration_pattern,inner_iteration_pattern> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
-
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+  typedef Kokkos::Rank<4, outer_iteration_pattern, inner_iteration_pattern>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
+
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewCopy-4D",
-       policy_type({0,0,0,0},{a.extent(0),a.extent(1),a.extent(2),
-                              a.extent(3)}),*this);
+                         policy_type({0, 0, 0, 0}, {a.extent(0), a.extent(1),
+                                                    a.extent(2), a.extent(3)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2,
-                   const iType& i3) const {
-      a(i0,i1,i2,i3) = b(i0,i1,i2,i3);
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3) const {
+    a(i0, i1, i2, i3) = b(i0, i1, i2, i3);
   };
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,5,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 5, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
 
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
-  typedef Kokkos::Rank<5,outer_iteration_pattern,inner_iteration_pattern> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
-
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+  typedef Kokkos::Rank<5, outer_iteration_pattern, inner_iteration_pattern>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
+
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
-    Kokkos::parallel_for("Kokkos::ViewCopy-5D",
-       policy_type({0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(2),
-                                a.extent(3),a.extent(4)}),*this);
+    Kokkos::parallel_for(
+        "Kokkos::ViewCopy-5D",
+        policy_type({0, 0, 0, 0, 0}, {a.extent(0), a.extent(1), a.extent(2),
+                                      a.extent(3), a.extent(4)}),
+        *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2,
-                   const iType& i3, const iType& i4) const {
-      a(i0,i1,i2,i3,i4) = b(i0,i1,i2,i3,i4);
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4) const {
+    a(i0, i1, i2, i3, i4) = b(i0, i1, i2, i3, i4);
   };
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,6,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 6, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
 
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
-  typedef Kokkos::Rank<6,outer_iteration_pattern,inner_iteration_pattern> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
-
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+  typedef Kokkos::Rank<6, outer_iteration_pattern, inner_iteration_pattern>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
+
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewCopy-6D",
-       policy_type({0,0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(2),
-                                  a.extent(3),a.extent(4),a.extent(5)}),*this);
+                         policy_type({0, 0, 0, 0, 0, 0},
+                                     {a.extent(0), a.extent(1), a.extent(2),
+                                      a.extent(3), a.extent(4), a.extent(5)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i2,
-                   const iType& i3, const iType& i4, const iType& i5) const {
-      a(i0,i1,i2,i3,i4,i5) = b(i0,i1,i2,i3,i4,i5);
+  void operator()(const iType& i0, const iType& i1, const iType& i2,
+                  const iType& i3, const iType& i4, const iType& i5) const {
+    a(i0, i1, i2, i3, i4, i5) = b(i0, i1, i2, i3, i4, i5);
   };
 };
 
-
-template<class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,7,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 7, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
 
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
-  typedef Kokkos::Rank<6,outer_iteration_pattern,inner_iteration_pattern> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
-
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+  typedef Kokkos::Rank<6, outer_iteration_pattern, inner_iteration_pattern>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
+
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewCopy-7D",
-       policy_type({0,0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(3),
-                                  a.extent(4),a.extent(5),a.extent(6)}),*this);
+                         policy_type({0, 0, 0, 0, 0, 0},
+                                     {a.extent(0), a.extent(1), a.extent(3),
+                                      a.extent(4), a.extent(5), a.extent(6)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i3,
-                   const iType& i4, const iType& i5, const iType& i6) const {
-    for(iType i2=0; i2<iType(a.extent(2));i2++)
-      a(i0,i1,i2,i3,i4,i5,i6) = b(i0,i1,i2,i3,i4,i5,i6);
+  void operator()(const iType& i0, const iType& i1, const iType& i3,
+                  const iType& i4, const iType& i5, const iType& i6) const {
+    for (iType i2 = 0; i2 < iType(a.extent(2)); i2++)
+      a(i0, i1, i2, i3, i4, i5, i6) = b(i0, i1, i2, i3, i4, i5, i6);
   };
 };
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace,typename iType>
-struct ViewCopy<ViewTypeA,ViewTypeB,Layout,ExecSpace,8,iType,KOKKOS_IMPL_COMPILING_LIBRARY> {
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          typename iType>
+struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 8, iType,
+                KOKKOS_IMPL_COMPILING_LIBRARY> {
   ViewTypeA a;
   ViewTypeB b;
 
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
-  typedef Kokkos::Rank<6,outer_iteration_pattern,inner_iteration_pattern> iterate_type;
-  typedef Kokkos::MDRangePolicy<ExecSpace,iterate_type,Kokkos::IndexType<iType>> policy_type;
-
-  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_):a(a_),b(b_) {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+  typedef Kokkos::Rank<6, outer_iteration_pattern, inner_iteration_pattern>
+      iterate_type;
+  typedef Kokkos::MDRangePolicy<ExecSpace, iterate_type,
+                                Kokkos::IndexType<iType>>
+      policy_type;
+
+  ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_) : a(a_), b(b_) {
     ExecSpace().fence();
     Kokkos::parallel_for("Kokkos::ViewCopy-8D",
-       policy_type({0,0,0,0,0,0},{a.extent(0),a.extent(1),a.extent(3),
-                                  a.extent(5),a.extent(6),a.extent(7)}),*this);
+                         policy_type({0, 0, 0, 0, 0, 0},
+                                     {a.extent(0), a.extent(1), a.extent(3),
+                                      a.extent(5), a.extent(6), a.extent(7)}),
+                         *this);
     ExecSpace().fence();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const iType& i0, const iType& i1, const iType& i3,
-                   const iType& i5, const iType& i6, const iType& i7) const {
-    for(iType i2=0; i2<iType(a.extent(2));i2++)
-    for(iType i4=0; i4<iType(a.extent(4));i4++)
-      a(i0,i1,i2,i3,i4,i5,i6,i7) = b(i0,i1,i2,i3,i4,i5,i6,i7);
+  void operator()(const iType& i0, const iType& i1, const iType& i3,
+                  const iType& i5, const iType& i6, const iType& i7) const {
+    for (iType i2 = 0; i2 < iType(a.extent(2)); i2++)
+      for (iType i4 = 0; i4 < iType(a.extent(4)); i4++)
+        a(i0, i1, i2, i3, i4, i5, i6, i7) = b(i0, i1, i2, i3, i4, i5, i6, i7);
   };
 };
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 
-#include<impl/Kokkos_ViewFillCopyETIDecl.hpp>
+#include <impl/Kokkos_ViewFillCopyETIDecl.hpp>
 
 namespace Kokkos {
 namespace Impl {
 
-template<class DstType, class SrcType>
+template <class DstType, class SrcType>
 void view_copy(const DstType& dst, const SrcType& src) {
   typedef typename DstType::execution_space dst_execution_space;
   typedef typename SrcType::execution_space src_execution_space;
   typedef typename DstType::memory_space dst_memory_space;
   typedef typename SrcType::memory_space src_memory_space;
 
-  enum { DstExecCanAccessSrc =
-   Kokkos::Impl::SpaceAccessibility< dst_execution_space , src_memory_space >::accessible };
+  enum {
+    DstExecCanAccessSrc =
+        Kokkos::Impl::SpaceAccessibility<dst_execution_space,
+                                         src_memory_space>::accessible
+  };
 
-  enum { SrcExecCanAccessDst =
-   Kokkos::Impl::SpaceAccessibility< src_execution_space , dst_memory_space >::accessible };
+  enum {
+    SrcExecCanAccessDst =
+        Kokkos::Impl::SpaceAccessibility<src_execution_space,
+                                         dst_memory_space>::accessible
+  };
 
-  if( ! DstExecCanAccessSrc && ! SrcExecCanAccessDst) {
-    std::string message("Error: Kokkos::deep_copy with no available copy mechanism: ");
-    message += src.label(); message += " to ";
+  if (!DstExecCanAccessSrc && !SrcExecCanAccessDst) {
+    std::string message(
+        "Error: Kokkos::deep_copy with no available copy mechanism: ");
+    message += src.label();
+    message += " to ";
     message += dst.label();
     Kokkos::Impl::throw_runtime_exception(message);
   }
 
   // Figure out iteration order in case we need it
-  int64_t strides[DstType::Rank+1];
+  int64_t strides[DstType::Rank + 1];
   dst.stride(strides);
   Kokkos::Iterate iterate;
-  if        ( Kokkos::is_layouttiled<typename DstType::array_layout>::value ) {
-    iterate = Kokkos::layout_iterate_type_selector<typename DstType::array_layout>::outer_iteration_pattern;
-  } else if        ( std::is_same<typename DstType::array_layout,Kokkos::LayoutRight>::value ) {
+  if (Kokkos::is_layouttiled<typename DstType::array_layout>::value) {
+    iterate = Kokkos::layout_iterate_type_selector<
+        typename DstType::array_layout>::outer_iteration_pattern;
+  } else if (std::is_same<typename DstType::array_layout,
+                          Kokkos::LayoutRight>::value) {
     iterate = Kokkos::Iterate::Right;
-  } else if ( std::is_same<typename DstType::array_layout,Kokkos::LayoutLeft>::value ) {
+  } else if (std::is_same<typename DstType::array_layout,
+                          Kokkos::LayoutLeft>::value) {
     iterate = Kokkos::Iterate::Left;
-  } else if ( std::is_same<typename DstType::array_layout,Kokkos::LayoutStride>::value ) {
-    if( strides[0] > strides[DstType::Rank-1] )
+  } else if (std::is_same<typename DstType::array_layout,
+                          Kokkos::LayoutStride>::value) {
+    if (strides[0] > strides[DstType::Rank - 1])
       iterate = Kokkos::Iterate::Right;
     else
       iterate = Kokkos::Iterate::Left;
   } else {
-    if( std::is_same<typename DstType::execution_space::array_layout, Kokkos::LayoutRight>::value )
+    if (std::is_same<typename DstType::execution_space::array_layout,
+                     Kokkos::LayoutRight>::value)
       iterate = Kokkos::Iterate::Right;
     else
       iterate = Kokkos::Iterate::Left;
   }
 
-  if( (dst.span() >= size_t(std::numeric_limits<int>::max())) ||
-      (src.span() >= size_t(std::numeric_limits<int>::max())) ){
-    if(DstExecCanAccessSrc) {
-      if(iterate == Kokkos::Iterate::Right)
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutRight, dst_execution_space,
-                                DstType::Rank, int64_t >( dst , src );
+  if ((dst.span() >= size_t(std::numeric_limits<int>::max())) ||
+      (src.span() >= size_t(std::numeric_limits<int>::max()))) {
+    if (DstExecCanAccessSrc) {
+      if (iterate == Kokkos::Iterate::Right)
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutRight, dst_execution_space, DstType::Rank, int64_t>(
+            dst, src);
       else
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutLeft, dst_execution_space,
-                                DstType::Rank, int64_t >( dst , src );
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutLeft, dst_execution_space, DstType::Rank, int64_t>(
+            dst, src);
     } else {
-      if(iterate == Kokkos::Iterate::Right)
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutRight, src_execution_space,
-                                DstType::Rank, int64_t >( dst , src );
+      if (iterate == Kokkos::Iterate::Right)
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutRight, src_execution_space, DstType::Rank, int64_t>(
+            dst, src);
       else
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutLeft, src_execution_space,
-                                DstType::Rank, int64_t >( dst , src );
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutLeft, src_execution_space, DstType::Rank, int64_t>(
+            dst, src);
     }
   } else {
-    if(DstExecCanAccessSrc) {
-      if(iterate == Kokkos::Iterate::Right)
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutRight, dst_execution_space,
-                                DstType::Rank, int >( dst , src );
+    if (DstExecCanAccessSrc) {
+      if (iterate == Kokkos::Iterate::Right)
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutRight, dst_execution_space, DstType::Rank, int>(dst,
+                                                                          src);
       else
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutLeft, dst_execution_space,
-                                DstType::Rank, int >( dst , src );
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutLeft, dst_execution_space, DstType::Rank, int>(dst,
+                                                                         src);
     } else {
-      if(iterate == Kokkos::Iterate::Right)
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutRight, src_execution_space,
-                                DstType::Rank, int >( dst , src );
+      if (iterate == Kokkos::Iterate::Right)
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutRight, src_execution_space, DstType::Rank, int>(dst,
+                                                                          src);
       else
-        Kokkos::Impl::ViewCopy< typename DstType::uniform_runtime_nomemspace_type, typename SrcType::uniform_runtime_const_nomemspace_type, Kokkos::LayoutLeft, src_execution_space,
-                                DstType::Rank, int >( dst , src );
+        Kokkos::Impl::ViewCopy<
+            typename DstType::uniform_runtime_nomemspace_type,
+            typename SrcType::uniform_runtime_const_nomemspace_type,
+            Kokkos::LayoutLeft, src_execution_space, DstType::Rank, int>(dst,
+                                                                         src);
     }
-
   }
 }
 
-template<class DstType, class SrcType, int Rank, class ... Args>
+template <class DstType, class SrcType, int Rank, class... Args>
 struct CommonSubview;
 
-template<class DstType, class SrcType, class Arg0, class ... Args>
-struct CommonSubview<DstType,SrcType,1,Arg0,Args...> {
-  typedef typename Kokkos::Subview<DstType,Arg0> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class... Args>
+struct CommonSubview<DstType, SrcType, 1, Arg0, Args...> {
+  typedef typename Kokkos::Subview<DstType, Arg0> dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0> src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, Args... ):
-    dst_sub(dst,arg0),src_sub(src,arg0) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                Args...)
+      : dst_sub(dst, arg0), src_sub(src, arg0) {}
 };
 
-template<class DstType, class SrcType, class Arg0, class Arg1, class ... Args>
-struct CommonSubview<DstType,SrcType,2,Arg0,Arg1,Args...> {
-  typedef typename Kokkos::Subview<DstType,Arg0,Arg1> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0,Arg1> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class Arg1, class... Args>
+struct CommonSubview<DstType, SrcType, 2, Arg0, Arg1, Args...> {
+  typedef typename Kokkos::Subview<DstType, Arg0, Arg1> dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0, Arg1> src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, const Arg1& arg1, Args... ):
-    dst_sub(dst,arg0,arg1),src_sub(src,arg0,arg1) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                const Arg1& arg1, Args...)
+      : dst_sub(dst, arg0, arg1), src_sub(src, arg0, arg1) {}
 };
 
-template<class DstType, class SrcType, class Arg0, class Arg1, class Arg2, class ... Args>
-struct CommonSubview<DstType,SrcType,3,Arg0,Arg1,Arg2,Args...> {
-  typedef typename Kokkos::Subview<DstType,Arg0,Arg1,Arg2> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0,Arg1,Arg2> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class Arg1, class Arg2,
+          class... Args>
+struct CommonSubview<DstType, SrcType, 3, Arg0, Arg1, Arg2, Args...> {
+  typedef typename Kokkos::Subview<DstType, Arg0, Arg1, Arg2> dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0, Arg1, Arg2> src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, const Arg1& arg1,
-                const Arg2& arg2, Args... ):
-    dst_sub(dst,arg0,arg1,arg2),src_sub(src,arg0,arg1,arg2) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                const Arg1& arg1, const Arg2& arg2, Args...)
+      : dst_sub(dst, arg0, arg1, arg2), src_sub(src, arg0, arg1, arg2) {}
 };
 
-template<class DstType, class SrcType, class Arg0, class Arg1, class Arg2, class Arg3,
-         class ... Args>
-struct CommonSubview<DstType,SrcType,4,Arg0,Arg1,Arg2,Arg3,Args...> {
-  typedef typename Kokkos::Subview<DstType,Arg0,Arg1,Arg2,Arg3> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0,Arg1,Arg2,Arg3> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class Arg1, class Arg2,
+          class Arg3, class... Args>
+struct CommonSubview<DstType, SrcType, 4, Arg0, Arg1, Arg2, Arg3, Args...> {
+  typedef typename Kokkos::Subview<DstType, Arg0, Arg1, Arg2, Arg3>
+      dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0, Arg1, Arg2, Arg3>
+      src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, const Arg1& arg1,
-                const Arg2& arg2, const Arg3& arg3,
-                const Args ...):
-    dst_sub(dst,arg0,arg1,arg2,arg3),src_sub(src,arg0,arg1,arg2,arg3) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+                const Args...)
+      : dst_sub(dst, arg0, arg1, arg2, arg3),
+        src_sub(src, arg0, arg1, arg2, arg3) {}
 };
 
-template<class DstType, class SrcType, class Arg0, class Arg1, class Arg2, class Arg3,
-         class Arg4, class ... Args>
-struct CommonSubview<DstType,SrcType,5,Arg0,Arg1,Arg2,Arg3,Arg4,Args...> {
-  typedef typename Kokkos::Subview<DstType,Arg0,Arg1,Arg2,Arg3,Arg4> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0,Arg1,Arg2,Arg3,Arg4> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class Arg1, class Arg2,
+          class Arg3, class Arg4, class... Args>
+struct CommonSubview<DstType, SrcType, 5, Arg0, Arg1, Arg2, Arg3, Arg4,
+                     Args...> {
+  typedef typename Kokkos::Subview<DstType, Arg0, Arg1, Arg2, Arg3, Arg4>
+      dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0, Arg1, Arg2, Arg3, Arg4>
+      src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, const Arg1& arg1,
-                const Arg2& arg2, const Arg3& arg3, const Arg4& arg4,
-                const Args ...):
-    dst_sub(dst,arg0,arg1,arg2,arg3,arg4),src_sub(src,arg0,arg1,arg2,arg3,arg4) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+                const Arg4& arg4, const Args...)
+      : dst_sub(dst, arg0, arg1, arg2, arg3, arg4),
+        src_sub(src, arg0, arg1, arg2, arg3, arg4) {}
 };
 
-template<class DstType, class SrcType, class Arg0, class Arg1, class Arg2, class Arg3,
-         class Arg4, class Arg5, class ... Args>
-struct CommonSubview<DstType,SrcType,6,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5,Args...> {
-  typedef typename Kokkos::Subview<DstType,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class Arg1, class Arg2,
+          class Arg3, class Arg4, class Arg5, class... Args>
+struct CommonSubview<DstType, SrcType, 6, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
+                     Args...> {
+  typedef typename Kokkos::Subview<DstType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5>
+      dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5>
+      src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, const Arg1& arg1,
-                const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5,
-                const Args ...):
-    dst_sub(dst,arg0,arg1,arg2,arg3,arg4,arg5),src_sub(src,arg0,arg1,arg2,arg3,arg4,arg5) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+                const Arg4& arg4, const Arg5& arg5, const Args...)
+      : dst_sub(dst, arg0, arg1, arg2, arg3, arg4, arg5),
+        src_sub(src, arg0, arg1, arg2, arg3, arg4, arg5) {}
 };
 
-template<class DstType, class SrcType, class Arg0, class Arg1, class Arg2, class Arg3,
-         class Arg4, class Arg5, class Arg6, class ...Args>
-struct CommonSubview<DstType,SrcType,7,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Args...> {
-  typedef typename Kokkos::Subview<DstType,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class Arg1, class Arg2,
+          class Arg3, class Arg4, class Arg5, class Arg6, class... Args>
+struct CommonSubview<DstType, SrcType, 7, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
+                     Arg6, Args...> {
+  typedef typename Kokkos::Subview<DstType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
+                                   Arg6>
+      dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
+                                   Arg6>
+      src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, const Arg1& arg1,
-                const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5,
-                const Arg6& arg6, Args...):
-    dst_sub(dst,arg0,arg1,arg2,arg3,arg4,arg5,arg6),src_sub(src,arg0,arg1,arg2,arg3,arg4,arg5,arg6) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+                const Arg4& arg4, const Arg5& arg5, const Arg6& arg6, Args...)
+      : dst_sub(dst, arg0, arg1, arg2, arg3, arg4, arg5, arg6),
+        src_sub(src, arg0, arg1, arg2, arg3, arg4, arg5, arg6) {}
 };
 
-template<class DstType, class SrcType, class Arg0, class Arg1, class Arg2, class Arg3,
-         class Arg4, class Arg5, class Arg6, class Arg7>
-struct CommonSubview<DstType,SrcType,8,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7> {
-  typedef typename Kokkos::Subview<DstType,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7> dst_subview_type;
-  typedef typename Kokkos::Subview<SrcType,Arg0,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7> src_subview_type;
+template <class DstType, class SrcType, class Arg0, class Arg1, class Arg2,
+          class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
+struct CommonSubview<DstType, SrcType, 8, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
+                     Arg6, Arg7> {
+  typedef typename Kokkos::Subview<DstType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
+                                   Arg6, Arg7>
+      dst_subview_type;
+  typedef typename Kokkos::Subview<SrcType, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
+                                   Arg6, Arg7>
+      src_subview_type;
   dst_subview_type dst_sub;
   src_subview_type src_sub;
-  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0, const Arg1& arg1,
-                const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5,
-                const Arg6& arg6, const Arg7& arg7):
-    dst_sub(dst,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7),src_sub(src,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7) {}
+  CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0,
+                const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+                const Arg4& arg4, const Arg5& arg5, const Arg6& arg6,
+                const Arg7& arg7)
+      : dst_sub(dst, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7),
+        src_sub(src, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {}
 };
 
-
-template<class DstType, class SrcType, class ExecSpace = typename DstType::execution_space, int Rank = DstType::Rank>
+template <class DstType, class SrcType,
+          class ExecSpace = typename DstType::execution_space,
+          int Rank        = DstType::Rank>
 struct ViewRemap;
 
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,1> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 1> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      view_copy(dst,src);
+    if (dst.extent(0) == src.extent(0)) {
+      view_copy(dst, src);
     } else {
-      p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-      typedef CommonSubview<DstType,SrcType,1,p_type> sv_adapter_type;
-      sv_adapter_type common_subview(dst,src,ext0);
-      view_copy(common_subview.dst_sub,common_subview.src_sub);
+      p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+      typedef CommonSubview<DstType, SrcType, 1, p_type> sv_adapter_type;
+      sv_adapter_type common_subview(dst, src, ext0);
+      view_copy(common_subview.dst_sub, common_subview.src_sub);
     }
   }
 };
 
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,2> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 2> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      if(dst.extent(1) == src.extent(1)) {
-        view_copy(dst,src);
+    if (dst.extent(0) == src.extent(0)) {
+      if (dst.extent(1) == src.extent(1)) {
+        view_copy(dst, src);
       } else {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        typedef CommonSubview<DstType,SrcType,2,Kokkos::Impl::ALL_t,p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,ext1);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        typedef CommonSubview<DstType, SrcType, 2, Kokkos::Impl::ALL_t, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     } else {
-      if(dst.extent(1) == src.extent(1)) {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        typedef CommonSubview<DstType,SrcType,2,p_type,Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+      if (dst.extent(1) == src.extent(1)) {
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        typedef CommonSubview<DstType, SrcType, 2, p_type, Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        typedef CommonSubview<DstType,SrcType,2,p_type,p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,ext1);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        typedef CommonSubview<DstType, SrcType, 2, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     }
   }
 };
 
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,3> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 3> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      if(dst.extent(2) == src.extent(2)) {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        typedef CommonSubview<DstType,SrcType,3,Kokkos::Impl::ALL_t,p_type,Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,ext1,Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+    if (dst.extent(0) == src.extent(0)) {
+      if (dst.extent(2) == src.extent(2)) {
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        typedef CommonSubview<DstType, SrcType, 3, Kokkos::Impl::ALL_t, p_type,
+                              Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1,
+                                       Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        typedef CommonSubview<DstType,SrcType,3,Kokkos::Impl::ALL_t,p_type,p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,ext1,ext2);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        typedef CommonSubview<DstType, SrcType, 3, Kokkos::Impl::ALL_t, p_type,
+                              p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     } else {
-      if(dst.extent(2) == src.extent(2)) {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        typedef CommonSubview<DstType,SrcType,3,p_type,p_type,Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,ext1,Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+      if (dst.extent(2) == src.extent(2)) {
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        typedef CommonSubview<DstType, SrcType, 3, p_type, p_type,
+                              Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        typedef CommonSubview<DstType,SrcType,3,p_type,p_type,p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,ext1,ext2);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        typedef CommonSubview<DstType, SrcType, 3, p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     }
   }
 };
 
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,4> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 4> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      if(dst.extent(3) == src.extent(3)) {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        typedef CommonSubview<DstType,SrcType,4,Kokkos::Impl::ALL_t,
-                              p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,
+    if (dst.extent(0) == src.extent(0)) {
+      if (dst.extent(3) == src.extent(3)) {
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        typedef CommonSubview<DstType, SrcType, 4, Kokkos::Impl::ALL_t, p_type,
+                              p_type, Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2,
                                        Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        typedef CommonSubview<DstType,SrcType,4,Kokkos::Impl::ALL_t,
-                              p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,
-                                       ext3);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        typedef CommonSubview<DstType, SrcType, 4, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     } else {
-      if(dst.extent(7) == src.extent(7)) {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        typedef CommonSubview<DstType,SrcType,4,p_type,
-                              p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,
-                                       Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+      if (dst.extent(7) == src.extent(7)) {
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        typedef CommonSubview<DstType, SrcType, 4, p_type, p_type, p_type,
+                              Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        typedef CommonSubview<DstType,SrcType,4,p_type,
-                              p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,
-                                       ext3);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        typedef CommonSubview<DstType, SrcType, 4, p_type, p_type, p_type,
+                              p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     }
   }
 };
 
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,5> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 5> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      if(dst.extent(4) == src.extent(4)) {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        typedef CommonSubview<DstType,SrcType,5,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,
+    if (dst.extent(0) == src.extent(0)) {
+      if (dst.extent(4) == src.extent(4)) {
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        typedef CommonSubview<DstType, SrcType, 5, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        typedef CommonSubview<DstType,SrcType,5,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        typedef CommonSubview<DstType, SrcType, 5, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     } else {
-      if(dst.extent(4) == src.extent(4)) {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        typedef CommonSubview<DstType,SrcType,5,p_type,
-                              p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,
+      if (dst.extent(4) == src.extent(4)) {
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        typedef CommonSubview<DstType, SrcType, 5, p_type, p_type, p_type,
+                              p_type, Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3,
                                        Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        typedef CommonSubview<DstType,SrcType,5,p_type,
-                              p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,
-                                       ext4);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        typedef CommonSubview<DstType, SrcType, 5, p_type, p_type, p_type,
+                              p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     }
   }
 };
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,6> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 6> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      if(dst.extent(5) == src.extent(5)) {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        typedef CommonSubview<DstType,SrcType,6,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,ext4,
-                                       Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+    if (dst.extent(0) == src.extent(0)) {
+      if (dst.extent(5) == src.extent(5)) {
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        typedef CommonSubview<DstType, SrcType, 6, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, p_type, Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
+                                       ext4, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        typedef CommonSubview<DstType,SrcType,6,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,ext4,
-                                       ext5);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        typedef CommonSubview<DstType, SrcType, 6, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
+                                       ext4, ext5);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     } else {
-      if(dst.extent(5) == src.extent(5)) {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-
-        typedef CommonSubview<DstType,SrcType,6,p_type,
-                              p_type,p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,ext4,
+      if (dst.extent(5) == src.extent(5)) {
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+
+        typedef CommonSubview<DstType, SrcType, 6, p_type, p_type, p_type,
+                              p_type, p_type, Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
                                        Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-
-        typedef CommonSubview<DstType,SrcType,6,p_type,
-                              p_type,p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,ext4,
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+
+        typedef CommonSubview<DstType, SrcType, 6, p_type, p_type, p_type,
+                              p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
                                        ext5);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     }
   }
 };
 
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,7> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 7> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      if(dst.extent(6) == src.extent(6)) {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        typedef CommonSubview<DstType,SrcType,7,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,ext4,ext5,
-                                       Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+    if (dst.extent(0) == src.extent(0)) {
+      if (dst.extent(6) == src.extent(6)) {
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        typedef CommonSubview<DstType, SrcType, 7, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, p_type, p_type,
+                              Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
+                                       ext4, ext5, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        p_type ext6(0,std::min(dst.extent(6),src.extent(6)));
-        typedef CommonSubview<DstType,SrcType,7,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,ext4,ext5,
-                                       ext6);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
+        typedef CommonSubview<DstType, SrcType, 7, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
+                                       ext4, ext5, ext6);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     } else {
-      if(dst.extent(6) == src.extent(6)) {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        typedef CommonSubview<DstType,SrcType,7,p_type,
-                              p_type,p_type,p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,ext4,ext5,
-                                       Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+      if (dst.extent(6) == src.extent(6)) {
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        typedef CommonSubview<DstType, SrcType, 7, p_type, p_type, p_type,
+                              p_type, p_type, p_type, Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
+                                       ext5, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        p_type ext6(0,std::min(dst.extent(6),src.extent(6)));
-        typedef CommonSubview<DstType,SrcType,7,p_type,
-                              p_type,p_type,p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,ext4,ext5,
-                                       ext6);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
+        typedef CommonSubview<DstType, SrcType, 7, p_type, p_type, p_type,
+                              p_type, p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
+                                       ext5, ext6);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     }
   }
 };
 
-template<class DstType, class SrcType, class ExecSpace>
-struct ViewRemap<DstType,SrcType,ExecSpace,8> {
-  typedef Kokkos::pair<int64_t,int64_t> p_type;
+template <class DstType, class SrcType, class ExecSpace>
+struct ViewRemap<DstType, SrcType, ExecSpace, 8> {
+  typedef Kokkos::pair<int64_t, int64_t> p_type;
 
   ViewRemap(const DstType& dst, const SrcType& src) {
-    if(dst.extent(0) == src.extent(0)) {
-      if(dst.extent(7) == src.extent(7)) {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        p_type ext6(0,std::min(dst.extent(6),src.extent(6)));
-        typedef CommonSubview<DstType,SrcType,8,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,ext4,ext5,ext6,
-                                       Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+    if (dst.extent(0) == src.extent(0)) {
+      if (dst.extent(7) == src.extent(7)) {
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
+        typedef CommonSubview<DstType, SrcType, 8, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, p_type, p_type, p_type,
+                              Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
+                                       ext4, ext5, ext6, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        p_type ext6(0,std::min(dst.extent(6),src.extent(6)));
-        p_type ext7(0,std::min(dst.extent(7),src.extent(7)));
-        typedef CommonSubview<DstType,SrcType,8,Kokkos::Impl::ALL_t,
-                              p_type,p_type,p_type,p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,Kokkos::ALL,
-                                       ext1,ext2,ext3,ext4,ext5,ext6,
-                                       ext7);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
+        p_type ext7(0, std::min(dst.extent(7), src.extent(7)));
+        typedef CommonSubview<DstType, SrcType, 8, Kokkos::Impl::ALL_t, p_type,
+                              p_type, p_type, p_type, p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
+                                       ext4, ext5, ext6, ext7);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     } else {
-      if(dst.extent(7) == src.extent(7)) {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        p_type ext6(0,std::min(dst.extent(6),src.extent(6)));
-        typedef CommonSubview<DstType,SrcType,8,p_type,
-                              p_type,p_type,p_type,p_type,p_type,p_type,
-                              Kokkos::Impl::ALL_t> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,ext4,ext5,ext6,
-                                       Kokkos::ALL);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+      if (dst.extent(7) == src.extent(7)) {
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
+        typedef CommonSubview<DstType, SrcType, 8, p_type, p_type, p_type,
+                              p_type, p_type, p_type, p_type,
+                              Kokkos::Impl::ALL_t>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
+                                       ext5, ext6, Kokkos::ALL);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       } else {
-        p_type ext0(0,std::min(dst.extent(0),src.extent(0)));
-        p_type ext1(0,std::min(dst.extent(1),src.extent(1)));
-        p_type ext2(0,std::min(dst.extent(2),src.extent(2)));
-        p_type ext3(0,std::min(dst.extent(3),src.extent(3)));
-        p_type ext4(0,std::min(dst.extent(4),src.extent(4)));
-        p_type ext5(0,std::min(dst.extent(5),src.extent(5)));
-        p_type ext6(0,std::min(dst.extent(6),src.extent(6)));
-        p_type ext7(0,std::min(dst.extent(7),src.extent(7)));
-        typedef CommonSubview<DstType,SrcType,8,p_type,
-                              p_type,p_type,p_type,p_type,p_type,p_type,
-                              p_type> sv_adapter_type;
-        sv_adapter_type common_subview(dst,src,ext0,
-                                       ext1,ext2,ext3,ext4,ext5,ext6,
-                                       ext7);
-        view_copy(common_subview.dst_sub,common_subview.src_sub);
+        p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
+        p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
+        p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
+        p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
+        p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
+        p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
+        p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
+        p_type ext7(0, std::min(dst.extent(7), src.extent(7)));
+        typedef CommonSubview<DstType, SrcType, 8, p_type, p_type, p_type,
+                              p_type, p_type, p_type, p_type, p_type>
+            sv_adapter_type;
+        sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
+                                       ext5, ext6, ext7);
+        view_copy(common_subview.dst_sub, common_subview.src_sub);
       }
     }
   }
 };
 
-}
+}  // namespace Impl
 
 /** \brief  Deep copy a value from Host memory into a view.  */
-template< class DT , class ... DP >
-inline
-void deep_copy
-  ( const View<DT,DP...> & dst
-  , typename ViewTraits<DT,DP...>::const_value_type & value
-  , typename std::enable_if<
-    std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value
-    >::type * = 0 )
-{
-  typedef View<DT,DP...> ViewType;
-  if(dst.data() == NULL ) {
+template <class DT, class... DP>
+inline void deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<DT, DP...>::specialize, void>::value>::type* = 0) {
+  typedef View<DT, DP...> ViewType;
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(
+            typename ViewType::memory_space().name()),
+        dst.label(), dst.data(),
+        Kokkos::Profiling::SpaceHandle(Kokkos::HostSpace().name()), "Scalar",
+        &value, dst.span() * sizeof(typename ViewType::value_type));
+  }
+#endif
+
+  if (dst.data() == NULL) {
     Kokkos::fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
   Kokkos::fence();
-  static_assert(
-    std::is_same< typename ViewType::non_const_value_type ,
-                  typename ViewType::value_type >::value
-    , "deep_copy requires non-const type" );
+  static_assert(std::is_same<typename ViewType::non_const_value_type,
+                             typename ViewType::value_type>::value,
+                "deep_copy requires non-const type");
 
   // If contiguous we can simply do a 1D flat loop
-  if(dst.span_is_contiguous()) {
-    typedef Kokkos::View<typename ViewType::value_type*,Kokkos::LayoutRight,
+  if (dst.span_is_contiguous()) {
+    typedef Kokkos::View<
+        typename ViewType::value_type*, Kokkos::LayoutRight,
         Kokkos::Device<typename ViewType::execution_space,
-                       typename std::conditional<ViewType::Rank==0,
-                                      typename ViewType::memory_space,Kokkos::AnonymousSpace
-                                >::type>,
-        Kokkos::MemoryTraits<0> >
-     ViewTypeFlat;
-
-    ViewTypeFlat dst_flat(dst.data(),dst.size());
-    if(dst.span() < std::numeric_limits<int>::max()) {
-      Kokkos::Impl::ViewFill< ViewTypeFlat , Kokkos::LayoutRight, typename ViewType::execution_space, ViewTypeFlat::Rank, int >( dst_flat , value );
+                       typename std::conditional<
+                           ViewType::Rank == 0, typename ViewType::memory_space,
+                           Kokkos::AnonymousSpace>::type>,
+        Kokkos::MemoryTraits<0>>
+        ViewTypeFlat;
+
+    ViewTypeFlat dst_flat(dst.data(), dst.size());
+    if (dst.span() < static_cast<size_t>(std::numeric_limits<int>::max())) {
+      Kokkos::Impl::ViewFill<ViewTypeFlat, Kokkos::LayoutRight,
+                             typename ViewType::execution_space,
+                             ViewTypeFlat::Rank, int>(dst_flat, value);
     } else
-      Kokkos::Impl::ViewFill< ViewTypeFlat , Kokkos::LayoutRight, typename ViewType::execution_space, ViewTypeFlat::Rank, int64_t >( dst_flat , value );
+      Kokkos::Impl::ViewFill<ViewTypeFlat, Kokkos::LayoutRight,
+                             typename ViewType::execution_space,
+                             ViewTypeFlat::Rank, int64_t>(dst_flat, value);
     Kokkos::fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
   // Figure out iteration order to do the ViewFill
-  int64_t strides[ViewType::Rank+1];
+  int64_t strides[ViewType::Rank + 1];
   dst.stride(strides);
   Kokkos::Iterate iterate;
-  if        ( std::is_same<typename ViewType::array_layout,Kokkos::LayoutRight>::value ) {
+  if (std::is_same<typename ViewType::array_layout,
+                   Kokkos::LayoutRight>::value) {
     iterate = Kokkos::Iterate::Right;
-  } else if ( std::is_same<typename ViewType::array_layout,Kokkos::LayoutLeft>::value ) {
+  } else if (std::is_same<typename ViewType::array_layout,
+                          Kokkos::LayoutLeft>::value) {
     iterate = Kokkos::Iterate::Left;
-  } else if ( std::is_same<typename ViewType::array_layout,Kokkos::LayoutStride>::value ) {
-    if( strides[0] > strides[ViewType::Rank>0?ViewType::Rank-1:0] )
+  } else if (std::is_same<typename ViewType::array_layout,
+                          Kokkos::LayoutStride>::value) {
+    if (strides[0] > strides[ViewType::Rank > 0 ? ViewType::Rank - 1 : 0])
       iterate = Kokkos::Iterate::Right;
     else
       iterate = Kokkos::Iterate::Left;
   } else {
-    if( std::is_same<typename ViewType::execution_space::array_layout, Kokkos::LayoutRight>::value )
+    if (std::is_same<typename ViewType::execution_space::array_layout,
+                     Kokkos::LayoutRight>::value)
       iterate = Kokkos::Iterate::Right;
     else
       iterate = Kokkos::Iterate::Left;
   }
 
-  // Lets call the right ViewFill functor based on integer space needed and iteration type
-  typedef typename std::conditional<ViewType::Rank==0,
-                      typename ViewType::uniform_runtime_type,
-                      typename ViewType::uniform_runtime_nomemspace_type>::type ViewTypeUniform;
-  if(dst.span() > std::numeric_limits<int>::max()) {
-    if(iterate == Kokkos::Iterate::Right)
-      Kokkos::Impl::ViewFill< ViewTypeUniform, Kokkos::LayoutRight, typename ViewType::execution_space, ViewType::Rank, int64_t >( dst , value );
+  // Lets call the right ViewFill functor based on integer space needed and
+  // iteration type
+  typedef typename std::conditional<
+      ViewType::Rank == 0, typename ViewType::uniform_runtime_type,
+      typename ViewType::uniform_runtime_nomemspace_type>::type ViewTypeUniform;
+  if (dst.span() > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    if (iterate == Kokkos::Iterate::Right)
+      Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutRight,
+                             typename ViewType::execution_space, ViewType::Rank,
+                             int64_t>(dst, value);
     else
-      Kokkos::Impl::ViewFill< ViewTypeUniform, Kokkos::LayoutLeft, typename ViewType::execution_space, ViewType::Rank, int64_t >( dst , value );
+      Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutLeft,
+                             typename ViewType::execution_space, ViewType::Rank,
+                             int64_t>(dst, value);
   } else {
-    if(iterate == Kokkos::Iterate::Right)
-      Kokkos::Impl::ViewFill< ViewTypeUniform, Kokkos::LayoutRight, typename ViewType::execution_space, ViewType::Rank, int >( dst , value );
+    if (iterate == Kokkos::Iterate::Right)
+      Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutRight,
+                             typename ViewType::execution_space, ViewType::Rank,
+                             int>(dst, value);
     else
-      Kokkos::Impl::ViewFill< ViewTypeUniform, Kokkos::LayoutLeft, typename ViewType::execution_space, ViewType::Rank, int >( dst , value );
+      Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutLeft,
+                             typename ViewType::execution_space, ViewType::Rank,
+                             int>(dst, value);
   }
   Kokkos::fence();
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 /** \brief  Deep copy into a value in Host memory from a view.  */
-template< class ST , class ... SP >
-inline
-void deep_copy
-  ( typename ViewTraits<ST,SP...>::non_const_value_type & dst
-  , const View<ST,SP...> & src
-  , typename std::enable_if<
-    std::is_same< typename ViewTraits<ST,SP...>::specialize , void >::value
-    >::type * = 0 )
-{
-  static_assert( ViewTraits<ST,SP...>::rank == 0
-               , "ERROR: Non-rank-zero view in deep_copy( value , View )" );
-
-  if(src.data() == NULL) {
+template <class ST, class... SP>
+inline void deep_copy(
+    typename ViewTraits<ST, SP...>::non_const_value_type& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<ST, SP...>::specialize, void>::value>::type* = 0) {
+  typedef ViewTraits<ST, SP...> src_traits;
+  typedef typename src_traits::memory_space src_memory_space;
+
+  static_assert(src_traits::rank == 0,
+                "ERROR: Non-rank-zero view in deep_copy( value , View )");
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(Kokkos::HostSpace().name()), "Scalar",
+        &dst, Kokkos::Profiling::SpaceHandle(src_memory_space().name()),
+        src.label(), src.data(),
+        src.span() * sizeof(typename src_traits::value_type));
+  }
+#endif
+
+  if (src.data() == NULL) {
     Kokkos::fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
-  typedef ViewTraits<ST,SP...>               src_traits ;
-  typedef typename src_traits::memory_space  src_memory_space ;
-  Kokkos::Impl::DeepCopy< HostSpace , src_memory_space >( & dst , src.data() , sizeof(ST) );
+  Kokkos::Impl::DeepCopy<HostSpace, src_memory_space>(&dst, src.data(),
+                                                      sizeof(ST));
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 //----------------------------------------------------------------------------
 /** \brief  A deep copy between views of compatible type, and rank zero.  */
-template< class DT , class ... DP , class ST , class ... SP >
-inline
-void deep_copy
-  ( const View<DT,DP...> & dst
-  , const View<ST,SP...> & src
-  , typename std::enable_if<(
-    std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value &&
-    std::is_same< typename ViewTraits<ST,SP...>::specialize , void >::value &&
-    ( unsigned(ViewTraits<DT,DP...>::rank) == unsigned(0) &&
-      unsigned(ViewTraits<ST,SP...>::rank) == unsigned(0) )
-  )>::type * = 0 )
-{
-  static_assert(
-    std::is_same< typename ViewTraits<DT,DP...>::value_type ,
-                  typename ViewTraits<ST,SP...>::non_const_value_type >::value
-    , "deep_copy requires matching non-const destination type" );
-
-  if(dst.data() == NULL && src.data() == NULL) {
+template <class DT, class... DP, class ST, class... SP>
+inline void deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(
+        std::is_same<typename ViewTraits<DT, DP...>::specialize, void>::value &&
+        std::is_same<typename ViewTraits<ST, SP...>::specialize, void>::value &&
+        (unsigned(ViewTraits<DT, DP...>::rank) == unsigned(0) &&
+         unsigned(ViewTraits<ST, SP...>::rank) == unsigned(0)))>::type* = 0) {
+  typedef View<DT, DP...> dst_type;
+  typedef View<ST, SP...> src_type;
+
+  typedef typename dst_type::value_type value_type;
+  typedef typename dst_type::memory_space dst_memory_space;
+  typedef typename src_type::memory_space src_memory_space;
+
+  static_assert(std::is_same<typename dst_type::value_type,
+                             typename src_type::non_const_value_type>::value,
+                "deep_copy requires matching non-const destination type");
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(dst_memory_space().name()), dst.label(),
+        dst.data(), Kokkos::Profiling::SpaceHandle(src_memory_space().name()),
+        src.label(), src.data(),
+        src.span() * sizeof(typename dst_type::value_type));
+  }
+#endif
+
+  if (dst.data() == NULL && src.data() == NULL) {
     Kokkos::fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
-  typedef View<DT,DP...>  dst_type ;
-  typedef View<ST,SP...>  src_type ;
-
-  typedef typename dst_type::value_type    value_type ;
-  typedef typename dst_type::memory_space  dst_memory_space ;
-  typedef typename src_type::memory_space  src_memory_space ;
-
   Kokkos::fence();
-  if ( dst.data() != src.data() ) {
-    Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >( dst.data() , src.data() , sizeof(value_type) );
+  if (dst.data() != src.data()) {
+    Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space>(
+        dst.data(), src.data(), sizeof(value_type));
     Kokkos::fence();
   }
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 //----------------------------------------------------------------------------
-/** \brief  A deep copy between views of the default specialization, compatible type,
- *          same non-zero rank, same contiguous layout.
+/** \brief  A deep copy between views of the default specialization, compatible
+ * type, same non-zero rank, same contiguous layout.
  */
-template< class DT , class ... DP , class ST , class ... SP >
-inline
-void deep_copy
-  ( const View<DT,DP...> & dst
-  , const View<ST,SP...> & src
-  , typename std::enable_if<(
-    std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value &&
-    std::is_same< typename ViewTraits<ST,SP...>::specialize , void >::value &&
-    ( unsigned(ViewTraits<DT,DP...>::rank) != 0 ||
-      unsigned(ViewTraits<ST,SP...>::rank) != 0 )
-  )>::type * = 0 )
-{
-  typedef View<DT,DP...>  dst_type ;
-  typedef View<ST,SP...>  src_type ;
-
-  static_assert(
-    std::is_same< typename dst_type::value_type ,
-                  typename dst_type::non_const_value_type >::value
-    , "deep_copy requires non-const destination type" );
-
-  static_assert(
-    ( unsigned(dst_type::rank) ==
-      unsigned(src_type::rank) )
-    , "deep_copy requires Views of equal rank" );
-
-
-  typedef typename dst_type::execution_space  dst_execution_space ;
-  typedef typename src_type::execution_space  src_execution_space ;
-  typedef typename dst_type::memory_space     dst_memory_space ;
-  typedef typename src_type::memory_space     src_memory_space ;
-  typedef typename dst_type::value_type       dst_value_type ;
-  typedef typename src_type::value_type       src_value_type ;
-  if(dst.data() == NULL || src.data() == NULL) {
+template <class DT, class... DP, class ST, class... SP>
+inline void deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(
+        std::is_same<typename ViewTraits<DT, DP...>::specialize, void>::value &&
+        std::is_same<typename ViewTraits<ST, SP...>::specialize, void>::value &&
+        (unsigned(ViewTraits<DT, DP...>::rank) != 0 ||
+         unsigned(ViewTraits<ST, SP...>::rank) != 0))>::type* = 0) {
+  typedef View<DT, DP...> dst_type;
+  typedef View<ST, SP...> src_type;
+  typedef typename dst_type::execution_space dst_execution_space;
+  typedef typename src_type::execution_space src_execution_space;
+  typedef typename dst_type::memory_space dst_memory_space;
+  typedef typename src_type::memory_space src_memory_space;
+  typedef typename dst_type::value_type dst_value_type;
+  typedef typename src_type::value_type src_value_type;
+
+  static_assert(std::is_same<typename dst_type::value_type,
+                             typename dst_type::non_const_value_type>::value,
+                "deep_copy requires non-const destination type");
+
+  static_assert((unsigned(dst_type::rank) == unsigned(src_type::rank)),
+                "deep_copy requires Views of equal rank");
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(dst_memory_space().name()), dst.label(),
+        dst.data(), Kokkos::Profiling::SpaceHandle(src_memory_space().name()),
+        src.label(), src.data(),
+        src.span() * sizeof(typename dst_type::value_type));
+  }
+#endif
+
+  if (dst.data() == NULL || src.data() == NULL) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     // do nothing
 #else
     // throw if dimension mismatch
-    if ( (src.extent(0) != dst.extent(0)) ||
-         (src.extent(1) != dst.extent(1)) ||
-         (src.extent(2) != dst.extent(2)) ||
-         (src.extent(3) != dst.extent(3)) ||
-         (src.extent(4) != dst.extent(4)) ||
-         (src.extent(5) != dst.extent(5)) ||
-         (src.extent(6) != dst.extent(6)) ||
-         (src.extent(7) != dst.extent(7))
-       ) {
-      std::string message("Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
-      message += dst.label(); message += "(";
-      for(int r = 0; r<dst_type::Rank-1; r++)
-        { message+= std::to_string(dst.extent(r)); message += ","; }
-      message+= std::to_string(dst.extent(dst_type::Rank-1)); message += ") ";
-      message += src.label(); message += "(";
-      for(int r = 0; r<src_type::Rank-1; r++)
-        { message+= std::to_string(src.extent(r)); message += ","; }
-      message+= std::to_string(src.extent(src_type::Rank-1)); message += ") ";
+    if ((src.extent(0) != dst.extent(0)) || (src.extent(1) != dst.extent(1)) ||
+        (src.extent(2) != dst.extent(2)) || (src.extent(3) != dst.extent(3)) ||
+        (src.extent(4) != dst.extent(4)) || (src.extent(5) != dst.extent(5)) ||
+        (src.extent(6) != dst.extent(6)) || (src.extent(7) != dst.extent(7))) {
+      std::string message(
+          "Deprecation Error: Kokkos::deep_copy extents of views don't "
+          "match: ");
+      message += dst.label();
+      message += "(";
+      for (int r = 0; r < dst_type::Rank - 1; r++) {
+        message += std::to_string(dst.extent(r));
+        message += ",";
+      }
+      message += std::to_string(dst.extent(dst_type::Rank - 1));
+      message += ") ";
+      message += src.label();
+      message += "(";
+      for (int r = 0; r < src_type::Rank - 1; r++) {
+        message += std::to_string(src.extent(r));
+        message += ",";
+      }
+      message += std::to_string(src.extent(src_type::Rank - 1));
+      message += ") ";
 
       Kokkos::Impl::throw_runtime_exception(message);
     }
 #endif
     Kokkos::fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
-  enum { DstExecCanAccessSrc =
-   Kokkos::Impl::SpaceAccessibility< dst_execution_space , src_memory_space >::accessible };
+  enum {
+    DstExecCanAccessSrc =
+        Kokkos::Impl::SpaceAccessibility<dst_execution_space,
+                                         src_memory_space>::accessible
+  };
 
-  enum { SrcExecCanAccessDst =
-   Kokkos::Impl::SpaceAccessibility< src_execution_space , dst_memory_space >::accessible };
+  enum {
+    SrcExecCanAccessDst =
+        Kokkos::Impl::SpaceAccessibility<src_execution_space,
+                                         dst_memory_space>::accessible
+  };
 
   // Checking for Overlapping Views.
   dst_value_type* dst_start = dst.data();
   dst_value_type* dst_end   = dst.data() + dst.span();
   src_value_type* src_start = src.data();
   src_value_type* src_end   = src.data() + src.span();
-  if( ((std::ptrdiff_t)dst_start == (std::ptrdiff_t)src_start) &&
-      ((std::ptrdiff_t)dst_end   == (std::ptrdiff_t)src_end)   &&
-       (dst.span_is_contiguous() && src.span_is_contiguous()) ) {
+  if (((std::ptrdiff_t)dst_start == (std::ptrdiff_t)src_start) &&
+      ((std::ptrdiff_t)dst_end == (std::ptrdiff_t)src_end) &&
+      (dst.span_is_contiguous() && src.span_is_contiguous())) {
     Kokkos::fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
-  if( ( ( (std::ptrdiff_t)dst_start < (std::ptrdiff_t)src_end ) && ( (std::ptrdiff_t)dst_end > (std::ptrdiff_t)src_start ) ) &&
-      ( ( dst.span_is_contiguous() && src.span_is_contiguous() ))) {
+  if ((((std::ptrdiff_t)dst_start < (std::ptrdiff_t)src_end) &&
+       ((std::ptrdiff_t)dst_end > (std::ptrdiff_t)src_start)) &&
+      ((dst.span_is_contiguous() && src.span_is_contiguous()))) {
     std::string message("Error: Kokkos::deep_copy of overlapping views: ");
-    message += dst.label(); message += "(";
-    message += std::to_string((std::ptrdiff_t)dst_start); message += ",";
-    message += std::to_string((std::ptrdiff_t)dst_end); message += ") ";
-    message += src.label(); message += "(";
-    message += std::to_string((std::ptrdiff_t)src_start); message += ",";
-    message += std::to_string((std::ptrdiff_t)src_end); message += ") ";
+    message += dst.label();
+    message += "(";
+    message += std::to_string((std::ptrdiff_t)dst_start);
+    message += ",";
+    message += std::to_string((std::ptrdiff_t)dst_end);
+    message += ") ";
+    message += src.label();
+    message += "(";
+    message += std::to_string((std::ptrdiff_t)src_start);
+    message += ",";
+    message += std::to_string((std::ptrdiff_t)src_end);
+    message += ") ";
     Kokkos::Impl::throw_runtime_exception(message);
   }
 
   // Check for same extents
-  if ( (src.extent(0) != dst.extent(0)) ||
-       (src.extent(1) != dst.extent(1)) ||
-       (src.extent(2) != dst.extent(2)) ||
-       (src.extent(3) != dst.extent(3)) ||
-       (src.extent(4) != dst.extent(4)) ||
-       (src.extent(5) != dst.extent(5)) ||
-       (src.extent(6) != dst.extent(6)) ||
-       (src.extent(7) != dst.extent(7))
-     ) {
+  if ((src.extent(0) != dst.extent(0)) || (src.extent(1) != dst.extent(1)) ||
+      (src.extent(2) != dst.extent(2)) || (src.extent(3) != dst.extent(3)) ||
+      (src.extent(4) != dst.extent(4)) || (src.extent(5) != dst.extent(5)) ||
+      (src.extent(6) != dst.extent(6)) || (src.extent(7) != dst.extent(7))) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     Kokkos::fence();
-    if ( DstExecCanAccessSrc ) {
-      // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-      Kokkos::Impl::ViewRemap< dst_type , src_type >( dst , src );
-    }
-    else if ( SrcExecCanAccessDst ) {
-      // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-      Kokkos::Impl::ViewRemap< dst_type , src_type , src_execution_space >( dst , src );
-    }
-    else {
-      Kokkos::Impl::throw_runtime_exception("deep_copy given views that would require a temporary allocation");
+    if (DstExecCanAccessSrc) {
+      // Copying data between views in accessible memory spaces and either
+      // non-contiguous or incompatible shape.
+      Kokkos::Impl::ViewRemap<dst_type, src_type>(dst, src);
+    } else if (SrcExecCanAccessDst) {
+      // Copying data between views in accessible memory spaces and either
+      // non-contiguous or incompatible shape.
+      Kokkos::Impl::ViewRemap<dst_type, src_type, src_execution_space>(dst,
+                                                                       src);
+    } else {
+      Kokkos::Impl::throw_runtime_exception(
+          "deep_copy given views that would require a temporary allocation");
     }
     Kokkos::fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
 #else
-    std::string message("Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
-    message += dst.label(); message += "(";
-    for(int r = 0; r<dst_type::Rank-1; r++)
-      { message+= std::to_string(dst.extent(r)); message += ","; }
-    message+= std::to_string(dst.extent(dst_type::Rank-1)); message += ") ";
-    message += src.label(); message += "(";
-    for(int r = 0; r<src_type::Rank-1; r++)
-      { message+= std::to_string(src.extent(r)); message += ","; }
-    message+= std::to_string(src.extent(src_type::Rank-1)); message += ") ";
+    std::string message(
+        "Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
+    message += dst.label();
+    message += "(";
+    for (int r = 0; r < dst_type::Rank - 1; r++) {
+      message += std::to_string(dst.extent(r));
+      message += ",";
+    }
+    message += std::to_string(dst.extent(dst_type::Rank - 1));
+    message += ") ";
+    message += src.label();
+    message += "(";
+    for (int r = 0; r < src_type::Rank - 1; r++) {
+      message += std::to_string(src.extent(r));
+      message += ",";
+    }
+    message += std::to_string(src.extent(src_type::Rank - 1));
+    message += ") ";
 
     Kokkos::Impl::throw_runtime_exception(message);
 #endif
   }
 
-  // If same type, equal layout, equal dimensions, equal span, and contiguous memory then can byte-wise copy
-
-  if ( std::is_same< typename dst_type::value_type ,
-                     typename src_type::non_const_value_type >::value &&
-       (
-         std::is_same< typename dst_type::array_layout ,
-                       typename src_type::array_layout >::value
-         ||
-         ( dst_type::rank == 1 &&
-           src_type::rank == 1 )
-       ) &&
-       dst.span_is_contiguous() &&
-       src.span_is_contiguous() &&
-       ((dst_type::rank < 1) || (dst.stride_0() == src.stride_0()))  &&
-       ((dst_type::rank < 2) || (dst.stride_1() == src.stride_1())) &&
-       ((dst_type::rank < 3) || (dst.stride_2() == src.stride_2())) &&
-       ((dst_type::rank < 4) || (dst.stride_3() == src.stride_3())) &&
-       ((dst_type::rank < 5) || (dst.stride_4() == src.stride_4())) &&
-       ((dst_type::rank < 6) || (dst.stride_5() == src.stride_5())) &&
-       ((dst_type::rank < 7) || (dst.stride_6() == src.stride_6())) &&
-       ((dst_type::rank < 8) || (dst.stride_7() == src.stride_7()))
-    ) {
+  // If same type, equal layout, equal dimensions, equal span, and contiguous
+  // memory then can byte-wise copy
+
+  if (std::is_same<typename dst_type::value_type,
+                   typename src_type::non_const_value_type>::value &&
+      (std::is_same<typename dst_type::array_layout,
+                    typename src_type::array_layout>::value ||
+       (dst_type::rank == 1 && src_type::rank == 1)) &&
+      dst.span_is_contiguous() && src.span_is_contiguous() &&
+      ((dst_type::rank < 1) || (dst.stride_0() == src.stride_0())) &&
+      ((dst_type::rank < 2) || (dst.stride_1() == src.stride_1())) &&
+      ((dst_type::rank < 3) || (dst.stride_2() == src.stride_2())) &&
+      ((dst_type::rank < 4) || (dst.stride_3() == src.stride_3())) &&
+      ((dst_type::rank < 5) || (dst.stride_4() == src.stride_4())) &&
+      ((dst_type::rank < 6) || (dst.stride_5() == src.stride_5())) &&
+      ((dst_type::rank < 7) || (dst.stride_6() == src.stride_6())) &&
+      ((dst_type::rank < 8) || (dst.stride_7() == src.stride_7()))) {
     const size_t nbytes = sizeof(typename dst_type::value_type) * dst.span();
     Kokkos::fence();
-    if((void*)dst.data()!=(void*)src.data()) {
-      Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >
-        ( dst.data() , src.data() , nbytes );
+    if ((void*)dst.data() != (void*)src.data()) {
+      Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space>(
+          dst.data(), src.data(), nbytes);
     }
     Kokkos::fence();
   } else {
@@ -1536,779 +1839,779 @@ void deep_copy
     Impl::view_copy(dst, src);
     Kokkos::fence();
   }
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 namespace Experimental {
-/** \brief  A local deep copy between views of the default specialization, compatible type,
- *          same non-zero rank.
+/** \brief  A local deep copy between views of the default specialization,
+ * compatible type, same non-zero rank.
  */
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy_contiguous(const TeamType& team, const View<DT,DP...> & dst, const View<ST,SP...> & src) {
-    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, src.span()), [&] (const int& i) {
-        dst.data()[i] = src.data()[i];
-    });
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION
+local_deep_copy_contiguous(const TeamType& team, const View<DT, DP...>& dst,
+                           const View<ST, SP...>& src) {
+  Kokkos::parallel_for(Kokkos::TeamThreadRange(team, src.span()),
+                       [&](const int& i) { dst.data()[i] = src.data()[i]; });
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy_contiguous(const View<DT,DP...> & dst, const View<ST,SP...> & src) {
-    
-    for(size_t i=0;i<src.span();++i) {
-        dst.data()[i] = src.data()[i];
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy_contiguous(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src) {
+  for (size_t i = 0; i < src.span(); ++i) {
+    dst.data()[i] = src.data()[i];
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   const View<ST,SP...> & src,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 1 && 
-                                                                                             unsigned(ViewTraits<ST,SP...>::rank) == 1
-                                                                                           )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 1 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 1)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0);
+  const size_t N = dst.extent(0);
 
-    team.team_barrier();
-    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-        dst(i) = src(i);
-    });
-    team.team_barrier();
+  team.team_barrier();
+  Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N),
+                       [&](const int& i) { dst(i) = src(i); });
+  team.team_barrier();
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   const View<ST,SP...> & src,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 2 && 
-                                                                                             unsigned(ViewTraits<ST,SP...>::rank) == 2
-                                                                                           )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 2 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 2)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1);
+  const size_t N = dst.extent(0) * dst.extent(1);
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,src);
-        team.team_barrier();
-    } else {
-        team.team_barrier();
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0 = i%dst.extent(0);
-            int i1 = i/dst.extent(0);
-            dst(i0,i1) = src(i0,i1);
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, src);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0      = i % dst.extent(0);
+      int i1      = i / dst.extent(0);
+      dst(i0, i1) = src(i0, i1);
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   const View<ST,SP...> & src,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 3 && 
-                                                                                             unsigned(ViewTraits<ST,SP...>::rank) == 3
-                                                                                           )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 3 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 3)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2);
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,src);
-        team.team_barrier();
-    } else {
-        team.team_barrier();
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-            int i2   = itmp/dst.extent(1);
-            dst(i0,i1,i2) = src(i0,i1,i2);
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, src);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0          = i % dst.extent(0);
+      int itmp        = i / dst.extent(0);
+      int i1          = itmp % dst.extent(1);
+      int i2          = itmp / dst.extent(1);
+      dst(i0, i1, i2) = src(i0, i1, i2);
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   const View<ST,SP...> & src,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 4 && 
-                                                                                             unsigned(ViewTraits<ST,SP...>::rank) == 4
-                                                                                           )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 4 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 4)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3);
+  const size_t N =
+      dst.extent(0) * dst.extent(1) * dst.extent(2) * dst.extent(3);
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,src);
-        team.team_barrier();
-    } else {
-        team.team_barrier();
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-            int i3   = itmp/dst.extent(2);
-            dst(i0,i1,i2,i3) = src(i0,i1,i2,i3);
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, src);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0              = i % dst.extent(0);
+      int itmp            = i / dst.extent(0);
+      int i1              = itmp % dst.extent(1);
+      itmp                = itmp / dst.extent(1);
+      int i2              = itmp % dst.extent(2);
+      int i3              = itmp / dst.extent(2);
+      dst(i0, i1, i2, i3) = src(i0, i1, i2, i3);
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   const View<ST,SP...> & src,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 5 && 
-                                                                                             unsigned(ViewTraits<ST,SP...>::rank) == 5
-                                                                                           )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 5 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 5)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3)*dst.extent(4);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2) *
+                   dst.extent(3) * dst.extent(4);
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,src);
-        team.team_barrier();
-    } else {
-        team.team_barrier();
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-                itmp = itmp/dst.extent(2);
-            int i3   = itmp%dst.extent(3);
-            int i4   = itmp/dst.extent(3);
-            dst(i0,i1,i2,i3,i4) = src(i0,i1,i2,i3,i4);
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, src);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0                  = i % dst.extent(0);
+      int itmp                = i / dst.extent(0);
+      int i1                  = itmp % dst.extent(1);
+      itmp                    = itmp / dst.extent(1);
+      int i2                  = itmp % dst.extent(2);
+      itmp                    = itmp / dst.extent(2);
+      int i3                  = itmp % dst.extent(3);
+      int i4                  = itmp / dst.extent(3);
+      dst(i0, i1, i2, i3, i4) = src(i0, i1, i2, i3, i4);
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   const View<ST,SP...> & src,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 6 && 
-                                                                                             unsigned(ViewTraits<ST,SP...>::rank) == 6
-                                                                                           )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 6 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 6)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3)*dst.extent(4)*dst.extent(5);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2) *
+                   dst.extent(3) * dst.extent(4) * dst.extent(5);
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,src);
-        team.team_barrier();
-    } else {
-        team.team_barrier();
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-                itmp = itmp/dst.extent(2);
-            int i3   = itmp%dst.extent(3);
-                itmp = itmp/dst.extent(3);
-            int i4   = itmp%dst.extent(4);
-            int i5   = itmp/dst.extent(4);
-            dst(i0,i1,i2,i3,i4,i5) = src(i0,i1,i2,i3,i4,i5);
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, src);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0                      = i % dst.extent(0);
+      int itmp                    = i / dst.extent(0);
+      int i1                      = itmp % dst.extent(1);
+      itmp                        = itmp / dst.extent(1);
+      int i2                      = itmp % dst.extent(2);
+      itmp                        = itmp / dst.extent(2);
+      int i3                      = itmp % dst.extent(3);
+      itmp                        = itmp / dst.extent(3);
+      int i4                      = itmp % dst.extent(4);
+      int i5                      = itmp / dst.extent(4);
+      dst(i0, i1, i2, i3, i4, i5) = src(i0, i1, i2, i3, i4, i5);
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   const View<ST,SP...> & src,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 7 && 
-                                                                                             unsigned(ViewTraits<ST,SP...>::rank) == 7
-                                                                                           )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 7 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 7)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3)*dst.extent(4)*dst.extent(5)*dst.extent(6);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2) *
+                   dst.extent(3) * dst.extent(4) * dst.extent(5) *
+                   dst.extent(6);
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,src);
-        team.team_barrier();
-    } else {
-        team.team_barrier();
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-                itmp = itmp/dst.extent(2);
-            int i3   = itmp%dst.extent(3);
-                itmp = itmp/dst.extent(3);
-            int i4   = itmp%dst.extent(4);
-                itmp = itmp/dst.extent(4);
-            int i5   = itmp%dst.extent(5);
-            int i6   = itmp/dst.extent(5);
-            dst(i0,i1,i2,i3,i4,i5,i6) = src(i0,i1,i2,i3,i4,i5,i6);
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, src);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0                          = i % dst.extent(0);
+      int itmp                        = i / dst.extent(0);
+      int i1                          = itmp % dst.extent(1);
+      itmp                            = itmp / dst.extent(1);
+      int i2                          = itmp % dst.extent(2);
+      itmp                            = itmp / dst.extent(2);
+      int i3                          = itmp % dst.extent(3);
+      itmp                            = itmp / dst.extent(3);
+      int i4                          = itmp % dst.extent(4);
+      itmp                            = itmp / dst.extent(4);
+      int i5                          = itmp % dst.extent(5);
+      int i6                          = itmp / dst.extent(5);
+      dst(i0, i1, i2, i3, i4, i5, i6) = src(i0, i1, i2, i3, i4, i5, i6);
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             const View<ST,SP...> & src,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 1 && 
-                                                                       unsigned(ViewTraits<ST,SP...>::rank) == 1
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 1 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 1)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0);
+  const size_t N = dst.extent(0);
 
-    
-    for(size_t i=0;i<N;++i){
-        dst(i) = src(i);
-    }
+  for (size_t i = 0; i < N; ++i) {
+    dst(i) = src(i);
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             const View<ST,SP...> & src,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 2 && 
-                                                                       unsigned(ViewTraits<ST,SP...>::rank) == 2
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 2 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 2)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,src);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                dst(i0,i1) = src(i0,i1);
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, src);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1) dst(i0, i1) = src(i0, i1);
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             const View<ST,SP...> & src,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 3 && 
-                                                                       unsigned(ViewTraits<ST,SP...>::rank) == 3
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 3 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 3)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,src);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    dst(i0,i1,i2) = src(i0,i1,i2);
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, src);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          dst(i0, i1, i2) = src(i0, i1, i2);
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             const View<ST,SP...> & src,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 4 && 
-                                                                       unsigned(ViewTraits<ST,SP...>::rank) == 4
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 4 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 4)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,src);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        dst(i0,i1,i2,i3) = src(i0,i1,i2,i3);
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, src);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            dst(i0, i1, i2, i3) = src(i0, i1, i2, i3);
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             const View<ST,SP...> & src,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 5 && 
-                                                                       unsigned(ViewTraits<ST,SP...>::rank) == 5
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 5 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 5)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,src);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        for(size_t i4=0;i4<dst.extent(4);++i4)
-                            dst(i0,i1,i2,i3,i4) = src(i0,i1,i2,i3,i4);
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, src);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            for (size_t i4 = 0; i4 < dst.extent(4); ++i4)
+              dst(i0, i1, i2, i3, i4) = src(i0, i1, i2, i3, i4);
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             const View<ST,SP...> & src,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 6 && 
-                                                                        unsigned(ViewTraits<ST,SP...>::rank) == 6
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 6 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 6)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,src);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        for(size_t i4=0;i4<dst.extent(4);++i4)
-                            for(size_t i5=0;i5<dst.extent(5);++i5)
-                                dst(i0,i1,i2,i3,i4,i5) = src(i0,i1,i2,i3,i4,i5);
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, src);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            for (size_t i4 = 0; i4 < dst.extent(4); ++i4)
+              for (size_t i5 = 0; i5 < dst.extent(5); ++i5)
+                dst(i0, i1, i2, i3, i4, i5) = src(i0, i1, i2, i3, i4, i5);
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP , class ST , class ... SP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             const View<ST,SP...> & src,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 7 && 
-                                                                       unsigned(ViewTraits<ST,SP...>::rank) == 7
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP, class ST, class... SP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst, const View<ST, SP...>& src,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) == 7 &&
+                             unsigned(ViewTraits<ST, SP...>::rank) ==
+                                 7)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() && src.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,src);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        for(size_t i4=0;i4<dst.extent(4);++i4)
-                            for(size_t i5=0;i5<dst.extent(5);++i5)
-                                for(size_t i6=0;i6<dst.extent(6);++i6)
-                                    dst(i0,i1,i2,i3,i4,i5,i6) = src(i0,i1,i2,i3,i4,i5,i6);
-    }
+  if (dst.span_is_contiguous() && src.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, src);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            for (size_t i4 = 0; i4 < dst.extent(4); ++i4)
+              for (size_t i5 = 0; i5 < dst.extent(5); ++i5)
+                for (size_t i6 = 0; i6 < dst.extent(6); ++i6)
+                  dst(i0, i1, i2, i3, i4, i5, i6) =
+                      src(i0, i1, i2, i3, i4, i5, i6);
+  }
 }
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 /** \brief  Deep copy a value into a view.  */
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy_contiguous(const TeamType& team, const View<DT,DP...> & dst, typename ViewTraits<DT,DP...>::const_value_type & value) {
-    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, dst.span()), [&] (const int& i) {
-        dst.data()[i] = value;
-    });
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy_contiguous(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value) {
+  Kokkos::parallel_for(Kokkos::TeamThreadRange(team, dst.span()),
+                       [&](const int& i) { dst.data()[i] = value; });
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy_contiguous(const View<DT,DP...> & dst, typename ViewTraits<DT,DP...>::const_value_type & value) {
-    
-    for(size_t i=0;i<dst.span();++i) {
-        dst.data()[i] = value;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy_contiguous(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value) {
+  for (size_t i = 0; i < dst.span(); ++i) {
+    dst.data()[i] = value;
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   typename ViewTraits<DT,DP...>::const_value_type & value,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 1 )>::type * = 0 )
-{
-     if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             1)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0);
+  const size_t N = dst.extent(0);
 
-    team.team_barrier();
-    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-        dst(i) =  value;
-    });
-    team.team_barrier();
+  team.team_barrier();
+  Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N),
+                       [&](const int& i) { dst(i) = value; });
+  team.team_barrier();
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   typename ViewTraits<DT,DP...>::const_value_type & value,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 2 )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             2)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1);
+  const size_t N = dst.extent(0) * dst.extent(1);
 
-    if ( dst.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,value);
-        team.team_barrier();
-    } else {
-        team.team_barrier();    
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0 = i%dst.extent(0);
-            int i1 = i/dst.extent(0);
-            dst(i0,i1) =  value;
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, value);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0      = i % dst.extent(0);
+      int i1      = i / dst.extent(0);
+      dst(i0, i1) = value;
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   typename ViewTraits<DT,DP...>::const_value_type & value,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 3 )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             3)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2);
 
-    if ( dst.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,value);
-        team.team_barrier();
-    } else {
-        team.team_barrier();    
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-            int i2   = itmp/dst.extent(1);
-            dst(i0,i1,i2) =  value;
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, value);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0          = i % dst.extent(0);
+      int itmp        = i / dst.extent(0);
+      int i1          = itmp % dst.extent(1);
+      int i2          = itmp / dst.extent(1);
+      dst(i0, i1, i2) = value;
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   typename ViewTraits<DT,DP...>::const_value_type & value,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 4 )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             4)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3);
+  const size_t N =
+      dst.extent(0) * dst.extent(1) * dst.extent(2) * dst.extent(3);
 
-    if ( dst.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,value);
-        team.team_barrier();
-    } else {
-        team.team_barrier();    
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-            int i3   = itmp/dst.extent(2);
-            dst(i0,i1,i2,i3) =  value;
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, value);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0              = i % dst.extent(0);
+      int itmp            = i / dst.extent(0);
+      int i1              = itmp % dst.extent(1);
+      itmp                = itmp / dst.extent(1);
+      int i2              = itmp % dst.extent(2);
+      int i3              = itmp / dst.extent(2);
+      dst(i0, i1, i2, i3) = value;
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   typename ViewTraits<DT,DP...>::const_value_type & value,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 5 )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             5)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3)*dst.extent(4);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2) *
+                   dst.extent(3) * dst.extent(4);
 
-    if ( dst.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,value);
-        team.team_barrier();
-    } else {
-        team.team_barrier();    
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-                itmp = itmp/dst.extent(2);
-            int i3   = itmp%dst.extent(3);
-            int i4   = itmp/dst.extent(3);
-            dst(i0,i1,i2,i3,i4) =  value;
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, value);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0                  = i % dst.extent(0);
+      int itmp                = i / dst.extent(0);
+      int i1                  = itmp % dst.extent(1);
+      itmp                    = itmp / dst.extent(1);
+      int i2                  = itmp % dst.extent(2);
+      itmp                    = itmp / dst.extent(2);
+      int i3                  = itmp % dst.extent(3);
+      int i4                  = itmp / dst.extent(3);
+      dst(i0, i1, i2, i3, i4) = value;
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   typename ViewTraits<DT,DP...>::const_value_type & value,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 6 )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             6)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3)*dst.extent(4)*dst.extent(5);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2) *
+                   dst.extent(3) * dst.extent(4) * dst.extent(5);
 
-    if ( dst.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,value);
-        team.team_barrier();
-    } else {
-        team.team_barrier();    
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-                itmp = itmp/dst.extent(2);
-            int i3   = itmp%dst.extent(3);
-                itmp = itmp/dst.extent(3);
-            int i4   = itmp%dst.extent(4);
-            int i5   = itmp/dst.extent(4);
-            dst(i0,i1,i2,i3,i4,i5) =  value;
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, value);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0                      = i % dst.extent(0);
+      int itmp                    = i / dst.extent(0);
+      int i1                      = itmp % dst.extent(1);
+      itmp                        = itmp / dst.extent(1);
+      int i2                      = itmp % dst.extent(2);
+      itmp                        = itmp / dst.extent(2);
+      int i3                      = itmp % dst.extent(3);
+      itmp                        = itmp / dst.extent(3);
+      int i4                      = itmp % dst.extent(4);
+      int i5                      = itmp / dst.extent(4);
+      dst(i0, i1, i2, i3, i4, i5) = value;
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class TeamType, class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const TeamType& team, const View<DT,DP...> & dst, 
-                                                                   typename ViewTraits<DT,DP...>::const_value_type & value,
-                                                                   typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 7 )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class TeamType, class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const TeamType& team, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             7)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0)*dst.extent(1)*dst.extent(2)*dst.extent(3)*dst.extent(4)*dst.extent(5)*dst.extent(6);
+  const size_t N = dst.extent(0) * dst.extent(1) * dst.extent(2) *
+                   dst.extent(3) * dst.extent(4) * dst.extent(5) *
+                   dst.extent(6);
 
-    if ( dst.span_is_contiguous() ) {
-        team.team_barrier();
-        local_deep_copy_contiguous(team,dst,value);
-        team.team_barrier();
-    } else {
-        team.team_barrier();    
-        Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&] (const int& i) {
-            int i0   = i%dst.extent(0);
-            int itmp = i/dst.extent(0);
-            int i1   = itmp%dst.extent(1);
-                itmp = itmp/dst.extent(1);
-            int i2   = itmp%dst.extent(2);
-                itmp = itmp/dst.extent(2);
-            int i3   = itmp%dst.extent(3);
-                itmp = itmp/dst.extent(3);
-            int i4   = itmp%dst.extent(4);
-                itmp = itmp/dst.extent(4);
-            int i5   = itmp%dst.extent(5);
-            int i6   = itmp/dst.extent(5);
-            dst(i0,i1,i2,i3,i4,i5,i6) =  value;
-        });
-        team.team_barrier();
-    }
+  if (dst.span_is_contiguous()) {
+    team.team_barrier();
+    local_deep_copy_contiguous(team, dst, value);
+    team.team_barrier();
+  } else {
+    team.team_barrier();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, N), [&](const int& i) {
+      int i0                          = i % dst.extent(0);
+      int itmp                        = i / dst.extent(0);
+      int i1                          = itmp % dst.extent(1);
+      itmp                            = itmp / dst.extent(1);
+      int i2                          = itmp % dst.extent(2);
+      itmp                            = itmp / dst.extent(2);
+      int i3                          = itmp % dst.extent(3);
+      itmp                            = itmp / dst.extent(3);
+      int i4                          = itmp % dst.extent(4);
+      itmp                            = itmp / dst.extent(4);
+      int i5                          = itmp % dst.extent(5);
+      int i6                          = itmp / dst.extent(5);
+      dst(i0, i1, i2, i3, i4, i5, i6) = value;
+    });
+    team.team_barrier();
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             typename ViewTraits<DT,DP...>::const_value_type & value,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 1
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             1)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    const size_t N = dst.extent(0);
+  const size_t N = dst.extent(0);
 
-    
-    for(size_t i=0;i<N;++i){
-        dst(i) = value;
-    }
+  for (size_t i = 0; i < N; ++i) {
+    dst(i) = value;
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             typename ViewTraits<DT,DP...>::const_value_type & value,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 2
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             2)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,value);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                dst(i0,i1) = value;
-    }
+  if (dst.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, value);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1) dst(i0, i1) = value;
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,  
-                                             typename ViewTraits<DT,DP...>::const_value_type & value,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 3
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             3)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,value);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    dst(i0,i1,i2) = value;
-    }
+  if (dst.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, value);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2) dst(i0, i1, i2) = value;
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,
-                                             typename ViewTraits<DT,DP...>::const_value_type & value,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 4
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             4)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,value);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        dst(i0,i1,i2,i3) = value;
-    }
+  if (dst.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, value);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            dst(i0, i1, i2, i3) = value;
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,
-                                             typename ViewTraits<DT,DP...>::const_value_type & value,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 5
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             5)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,value);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        for(size_t i4=0;i4<dst.extent(4);++i4)
-                            dst(i0,i1,i2,i3,i4) = value;
-    }
+  if (dst.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, value);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            for (size_t i4 = 0; i4 < dst.extent(4); ++i4)
+              dst(i0, i1, i2, i3, i4) = value;
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,
-                                             typename ViewTraits<DT,DP...>::const_value_type & value,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 6
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             6)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,value);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        for(size_t i4=0;i4<dst.extent(4);++i4)
-                            for(size_t i5=0;i5<dst.extent(5);++i5)
-                                dst(i0,i1,i2,i3,i4,i5) = value;
-    }
+  if (dst.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, value);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            for (size_t i4 = 0; i4 < dst.extent(4); ++i4)
+              for (size_t i5 = 0; i5 < dst.extent(5); ++i5)
+                dst(i0, i1, i2, i3, i4, i5) = value;
+  }
 }
 //----------------------------------------------------------------------------
-template< class DT , class ... DP >
-void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,
-                                             typename ViewTraits<DT,DP...>::const_value_type & value,
-                                             typename std::enable_if<( unsigned(ViewTraits<DT,DP...>::rank) == 7
-                                                                     )>::type * = 0 )
-{
-    if( dst.data() == nullptr ) {
-        return;
-    }
+template <class DT, class... DP>
+void KOKKOS_INLINE_FUNCTION local_deep_copy(
+    const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<(unsigned(ViewTraits<DT, DP...>::rank) ==
+                             7)>::type* = 0) {
+  if (dst.data() == nullptr) {
+    return;
+  }
 
-    if ( dst.span_is_contiguous() ) {
-        local_deep_copy_contiguous(dst,value);
-    } else {
-        
-        for(size_t i0=0;i0<dst.extent(0);++i0)
-            for(size_t i1=0;i1<dst.extent(1);++i1)
-                for(size_t i2=0;i2<dst.extent(2);++i2)
-                    for(size_t i3=0;i3<dst.extent(3);++i3)
-                        for(size_t i4=0;i4<dst.extent(4);++i4)
-                            for(size_t i5=0;i5<dst.extent(5);++i5)
-                                for(size_t i6=0;i6<dst.extent(6);++i6)
-                                    dst(i0,i1,i2,i3,i4,i5,i6) = value;
-    }
+  if (dst.span_is_contiguous()) {
+    local_deep_copy_contiguous(dst, value);
+  } else {
+    for (size_t i0 = 0; i0 < dst.extent(0); ++i0)
+      for (size_t i1 = 0; i1 < dst.extent(1); ++i1)
+        for (size_t i2 = 0; i2 < dst.extent(2); ++i2)
+          for (size_t i3 = 0; i3 < dst.extent(3); ++i3)
+            for (size_t i4 = 0; i4 < dst.extent(4); ++i4)
+              for (size_t i5 = 0; i5 < dst.extent(5); ++i5)
+                for (size_t i6 = 0; i6 < dst.extent(6); ++i6)
+                  dst(i0, i1, i2, i3, i4, i5, i6) = value;
+  }
 }
 } /* namespace Experimental */
 } /* namespace Kokkos */
@@ -2319,261 +2622,334 @@ void KOKKOS_INLINE_FUNCTION local_deep_copy (const View<DT,DP...> & dst,
 namespace Kokkos {
 
 /** \brief  Deep copy a value from Host memory into a view.  */
-template< class ExecSpace ,class DT , class ... DP >
-inline
-void deep_copy
-  ( const ExecSpace &
-  , const View<DT,DP...> & dst
-  , typename ViewTraits<DT,DP...>::const_value_type & value
-  , typename std::enable_if<
-    Kokkos::Impl::is_execution_space< ExecSpace >::value &&
-    std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value
-    >::type * = 0 )
-{
-  static_assert(
-    std::is_same< typename ViewTraits<DT,DP...>::non_const_value_type ,
-                  typename ViewTraits<DT,DP...>::value_type >::value
-    , "deep_copy requires non-const type" );
-
+template <class ExecSpace, class DT, class... DP>
+inline void deep_copy(
+    const ExecSpace&, const View<DT, DP...>& dst,
+    typename ViewTraits<DT, DP...>::const_value_type& value,
+    typename std::enable_if<
+        Kokkos::Impl::is_execution_space<ExecSpace>::value &&
+        std::is_same<typename ViewTraits<DT, DP...>::specialize,
+                     void>::value>::type* = 0) {
+  typedef ViewTraits<DT, DP...> dst_traits;
+  typedef typename dst_traits::memory_space dst_memory_space;
+  static_assert(std::is_same<typename dst_traits::non_const_value_type,
+                             typename dst_traits::value_type>::value,
+                "deep_copy requires non-const type");
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(dst_memory_space().name()), dst.label(),
+        dst.data(), Kokkos::Profiling::SpaceHandle(Kokkos::HostSpace().name()),
+        "(none)", &value, dst.span() * sizeof(typename dst_traits::value_type));
+  }
+#endif
   ExecSpace().fence();
-  typedef typename View<DT,DP...>::uniform_runtime_nomemspace_type ViewTypeUniform;
-  Kokkos::Impl::ViewFill< ViewTypeUniform >( dst , value );
+  typedef
+      typename View<DT, DP...>::uniform_runtime_nomemspace_type ViewTypeUniform;
+  Kokkos::Impl::ViewFill<ViewTypeUniform>(dst, value);
   ExecSpace().fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 /** \brief  Deep copy into a value in Host memory from a view.  */
-template< class ExecSpace , class ST , class ... SP >
-inline
-void deep_copy
-  ( const ExecSpace & exec_space
-  , typename ViewTraits<ST,SP...>::non_const_value_type & dst
-  , const View<ST,SP...> & src
-  , typename std::enable_if<
-    Kokkos::Impl::is_execution_space< ExecSpace >::value &&
-    std::is_same< typename ViewTraits<ST,SP...>::specialize , void >::value
-    >::type * = 0 )
-{
-  static_assert( ViewTraits<ST,SP...>::rank == 0
-               , "ERROR: Non-rank-zero view in deep_copy( value , View )" );
-
-  if(src.data() == NULL) {
+template <class ExecSpace, class ST, class... SP>
+inline void deep_copy(
+    const ExecSpace& exec_space,
+    typename ViewTraits<ST, SP...>::non_const_value_type& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<
+        Kokkos::Impl::is_execution_space<ExecSpace>::value &&
+        std::is_same<typename ViewTraits<ST, SP...>::specialize,
+                     void>::value>::type* = 0) {
+  typedef ViewTraits<ST, SP...> src_traits;
+  typedef typename src_traits::memory_space src_memory_space;
+  static_assert(src_traits::rank == 0,
+                "ERROR: Non-rank-zero view in deep_copy( value , View )");
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(Kokkos::HostSpace().name()), "(none)",
+        &dst, Kokkos::Profiling::SpaceHandle(src_memory_space().name()),
+        src.label(), src.data(), sizeof(ST));
+  }
+#endif
+
+  if (src.data() == NULL) {
     exec_space.fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
-  typedef ViewTraits<ST,SP...>               src_traits ;
-  typedef typename src_traits::memory_space  src_memory_space ;
-  Kokkos::Impl::DeepCopy< HostSpace , src_memory_space , ExecSpace >
-    ( exec_space , & dst , src.data() , sizeof(ST) );
+  Kokkos::Impl::DeepCopy<HostSpace, src_memory_space, ExecSpace>(
+      exec_space, &dst, src.data(), sizeof(ST));
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 //----------------------------------------------------------------------------
 /** \brief  A deep copy between views of compatible type, and rank zero.  */
-template< class ExecSpace , class DT , class ... DP , class ST , class ... SP >
-inline
-void deep_copy
-  ( const ExecSpace & exec_space
-  , const View<DT,DP...> & dst
-  , const View<ST,SP...> & src
-  , typename std::enable_if<(
-    Kokkos::Impl::is_execution_space< ExecSpace >::value &&
-    std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value &&
-    std::is_same< typename ViewTraits<ST,SP...>::specialize , void >::value &&
-    ( unsigned(ViewTraits<DT,DP...>::rank) == unsigned(0) &&
-      unsigned(ViewTraits<ST,SP...>::rank) == unsigned(0) )
-  )>::type * = 0 )
-{
-  static_assert(
-    std::is_same< typename ViewTraits<DT,DP...>::value_type ,
-                  typename ViewTraits<ST,SP...>::non_const_value_type >::value
-    , "deep_copy requires matching non-const destination type" );
-
-  typedef View<DT,DP...>  dst_type ;
-  typedef View<ST,SP...>  src_type ;
-
-  typedef typename dst_type::value_type    value_type ;
-  typedef typename dst_type::memory_space  dst_memory_space ;
-  typedef typename src_type::memory_space  src_memory_space ;
-  if(dst.data() == NULL && src.data() == NULL) {
+template <class ExecSpace, class DT, class... DP, class ST, class... SP>
+inline void deep_copy(
+    const ExecSpace& exec_space, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(
+        Kokkos::Impl::is_execution_space<ExecSpace>::value &&
+        std::is_same<typename ViewTraits<DT, DP...>::specialize, void>::value &&
+        std::is_same<typename ViewTraits<ST, SP...>::specialize, void>::value &&
+        (unsigned(ViewTraits<DT, DP...>::rank) == unsigned(0) &&
+         unsigned(ViewTraits<ST, SP...>::rank) == unsigned(0)))>::type* = 0) {
+  typedef ViewTraits<ST, SP...> src_traits;
+  typedef ViewTraits<DT, DP...> dst_traits;
+
+  typedef typename src_traits::memory_space src_memory_space;
+  typedef typename dst_traits::memory_space dst_memory_space;
+  static_assert(std::is_same<typename dst_traits::value_type,
+                             typename src_traits::non_const_value_type>::value,
+                "deep_copy requires matching non-const destination type");
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(dst_memory_space().name()), dst.label(),
+        dst.data(), Kokkos::Profiling::SpaceHandle(src_memory_space().name()),
+        src.label(), src.data(), sizeof(DT));
+  }
+#endif
+
+  if (dst.data() == NULL && src.data() == NULL) {
     exec_space.fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
   exec_space.fence();
-  if ( dst.data() != src.data() ) {
-    Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space , ExecSpace >
-      ( exec_space , dst.data() , src.data() , sizeof(value_type) );
+  if (dst.data() != src.data()) {
+    Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space, ExecSpace>(
+        exec_space, dst.data(), src.data(),
+        sizeof(typename dst_traits::value_type));
   }
   exec_space.fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 //----------------------------------------------------------------------------
-/** \brief  A deep copy between views of the default specialization, compatible type,
- *          same non-zero rank
+/** \brief  A deep copy between views of the default specialization, compatible
+ * type, same non-zero rank
  */
-template< class ExecSpace , class DT, class ... DP, class ST, class ... SP >
-inline
-void deep_copy
-  ( const ExecSpace & exec_space
-  , const View<DT,DP...> & dst
-  , const View<ST,SP...> & src
-  , typename std::enable_if<(
-    Kokkos::Impl::is_execution_space< ExecSpace >::value &&
-    std::is_same< typename ViewTraits<DT,DP...>::specialize , void >::value &&
-    std::is_same< typename ViewTraits<ST,SP...>::specialize , void >::value &&
-    ( unsigned(ViewTraits<DT,DP...>::rank) != 0 ||
-      unsigned(ViewTraits<ST,SP...>::rank) != 0 )
-  )>::type * = 0 )
-{
-  typedef View<DT,DP...>  dst_type ;
-  typedef View<ST,SP...>  src_type ;
-
-  static_assert(
-    std::is_same< typename dst_type::value_type ,
-                  typename dst_type::non_const_value_type >::value
-    , "deep_copy requires non-const destination type" );
-
-  static_assert(
-    ( unsigned(dst_type::rank) ==
-      unsigned(src_type::rank) )
-    , "deep_copy requires Views of equal rank" );
-
-  typedef typename dst_type::execution_space  dst_execution_space ;
-  typedef typename src_type::execution_space  src_execution_space ;
-  typedef typename dst_type::memory_space     dst_memory_space ;
-  typedef typename src_type::memory_space     src_memory_space ;
-  typedef typename dst_type::value_type       dst_value_type ;
-  typedef typename src_type::value_type       src_value_type ;
-
-  if(dst.data() == NULL || src.data() == NULL) {
+template <class ExecSpace, class DT, class... DP, class ST, class... SP>
+inline void deep_copy(
+    const ExecSpace& exec_space, const View<DT, DP...>& dst,
+    const View<ST, SP...>& src,
+    typename std::enable_if<(
+        Kokkos::Impl::is_execution_space<ExecSpace>::value &&
+        std::is_same<typename ViewTraits<DT, DP...>::specialize, void>::value &&
+        std::is_same<typename ViewTraits<ST, SP...>::specialize, void>::value &&
+        (unsigned(ViewTraits<DT, DP...>::rank) != 0 ||
+         unsigned(ViewTraits<ST, SP...>::rank) != 0))>::type* = 0) {
+  typedef View<DT, DP...> dst_type;
+  typedef View<ST, SP...> src_type;
+
+  static_assert(std::is_same<typename dst_type::value_type,
+                             typename dst_type::non_const_value_type>::value,
+                "deep_copy requires non-const destination type");
+
+  static_assert((unsigned(dst_type::rank) == unsigned(src_type::rank)),
+                "deep_copy requires Views of equal rank");
+
+  typedef typename dst_type::execution_space dst_execution_space;
+  typedef typename src_type::execution_space src_execution_space;
+  typedef typename dst_type::memory_space dst_memory_space;
+  typedef typename src_type::memory_space src_memory_space;
+  typedef typename dst_type::value_type dst_value_type;
+  typedef typename src_type::value_type src_value_type;
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::beginDeepCopy(
+        Kokkos::Profiling::SpaceHandle(dst_memory_space().name()), dst.label(),
+        dst.data(), Kokkos::Profiling::SpaceHandle(src_memory_space().name()),
+        src.label(), src.data(), dst.span() * sizeof(dst_value_type));
+  }
+#endif
+
+  if (dst.data() == NULL || src.data() == NULL) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     // do nothing
 #else
     // throw if dimension mismatch
-    if ( (src.extent(0) != dst.extent(0)) ||
-         (src.extent(1) != dst.extent(1)) ||
-         (src.extent(2) != dst.extent(2)) ||
-         (src.extent(3) != dst.extent(3)) ||
-         (src.extent(4) != dst.extent(4)) ||
-         (src.extent(5) != dst.extent(5)) ||
-         (src.extent(6) != dst.extent(6)) ||
-         (src.extent(7) != dst.extent(7))
-       ) {
-      std::string message("Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
-      message += dst.label(); message += "(";
-      for(int r = 0; r<dst_type::Rank-1; r++)
-        { message+= std::to_string(dst.extent(r)); message += ","; }
-      message+= std::to_string(dst.extent(dst_type::Rank-1)); message += ") ";
-      message += src.label(); message += "(";
-      for(int r = 0; r<src_type::Rank-1; r++)
-        { message+= std::to_string(src.extent(r)); message += ","; }
-      message+= std::to_string(src.extent(src_type::Rank-1)); message += ") ";
+    if ((src.extent(0) != dst.extent(0)) || (src.extent(1) != dst.extent(1)) ||
+        (src.extent(2) != dst.extent(2)) || (src.extent(3) != dst.extent(3)) ||
+        (src.extent(4) != dst.extent(4)) || (src.extent(5) != dst.extent(5)) ||
+        (src.extent(6) != dst.extent(6)) || (src.extent(7) != dst.extent(7))) {
+      std::string message(
+          "Deprecation Error: Kokkos::deep_copy extents of views don't "
+          "match: ");
+      message += dst.label();
+      message += "(";
+      for (int r = 0; r < dst_type::Rank - 1; r++) {
+        message += std::to_string(dst.extent(r));
+        message += ",";
+      }
+      message += std::to_string(dst.extent(dst_type::Rank - 1));
+      message += ") ";
+      message += src.label();
+      message += "(";
+      for (int r = 0; r < src_type::Rank - 1; r++) {
+        message += std::to_string(src.extent(r));
+        message += ",";
+      }
+      message += std::to_string(src.extent(src_type::Rank - 1));
+      message += ") ";
 
       Kokkos::Impl::throw_runtime_exception(message);
     }
 #endif
     exec_space.fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
   }
 
-  enum { ExecCanAccessSrcDst =
-      Kokkos::Impl::SpaceAccessibility< ExecSpace , dst_memory_space >::accessible &&
-      Kokkos::Impl::SpaceAccessibility< ExecSpace , src_memory_space >::accessible
+  enum {
+    ExecCanAccessSrcDst =
+        Kokkos::Impl::SpaceAccessibility<ExecSpace,
+                                         dst_memory_space>::accessible &&
+        Kokkos::Impl::SpaceAccessibility<ExecSpace,
+                                         src_memory_space>::accessible
+  };
+  enum {
+    DstExecCanAccessSrc =
+        Kokkos::Impl::SpaceAccessibility<dst_execution_space,
+                                         src_memory_space>::accessible
   };
-  enum { DstExecCanAccessSrc =
-   Kokkos::Impl::SpaceAccessibility< dst_execution_space , src_memory_space >::accessible };
 
-  enum { SrcExecCanAccessDst =
-   Kokkos::Impl::SpaceAccessibility< src_execution_space , dst_memory_space >::accessible };
+  enum {
+    SrcExecCanAccessDst =
+        Kokkos::Impl::SpaceAccessibility<src_execution_space,
+                                         dst_memory_space>::accessible
+  };
 
   // Checking for Overlapping Views.
   dst_value_type* dst_start = dst.data();
   dst_value_type* dst_end   = dst.data() + dst.span();
   src_value_type* src_start = src.data();
   src_value_type* src_end   = src.data() + src.span();
-  if( ( ( (std::ptrdiff_t)dst_start < (std::ptrdiff_t)src_end ) && ( (std::ptrdiff_t)dst_end > (std::ptrdiff_t)src_start ) ) &&
-      ( ( dst.span_is_contiguous() && src.span_is_contiguous() ))) {
+  if ((((std::ptrdiff_t)dst_start < (std::ptrdiff_t)src_end) &&
+       ((std::ptrdiff_t)dst_end > (std::ptrdiff_t)src_start)) &&
+      ((dst.span_is_contiguous() && src.span_is_contiguous()))) {
     std::string message("Error: Kokkos::deep_copy of overlapping views: ");
-    message += dst.label(); message += "(";
-    message += std::to_string((std::ptrdiff_t)dst_start); message += ",";
-    message += std::to_string((std::ptrdiff_t)dst_end); message += ") ";
-    message += src.label(); message += "(";
-    message += std::to_string((std::ptrdiff_t)src_start); message += ",";
-    message += std::to_string((std::ptrdiff_t)src_end); message += ") ";
+    message += dst.label();
+    message += "(";
+    message += std::to_string((std::ptrdiff_t)dst_start);
+    message += ",";
+    message += std::to_string((std::ptrdiff_t)dst_end);
+    message += ") ";
+    message += src.label();
+    message += "(";
+    message += std::to_string((std::ptrdiff_t)src_start);
+    message += ",";
+    message += std::to_string((std::ptrdiff_t)src_end);
+    message += ") ";
     Kokkos::Impl::throw_runtime_exception(message);
   }
 
   // Check for same extents
-  if ( (src.extent(0) != dst.extent(0)) ||
-       (src.extent(1) != dst.extent(1)) ||
-       (src.extent(2) != dst.extent(2)) ||
-       (src.extent(3) != dst.extent(3)) ||
-       (src.extent(4) != dst.extent(4)) ||
-       (src.extent(5) != dst.extent(5)) ||
-       (src.extent(6) != dst.extent(6)) ||
-       (src.extent(7) != dst.extent(7))
-     ) {
+  if ((src.extent(0) != dst.extent(0)) || (src.extent(1) != dst.extent(1)) ||
+      (src.extent(2) != dst.extent(2)) || (src.extent(3) != dst.extent(3)) ||
+      (src.extent(4) != dst.extent(4)) || (src.extent(5) != dst.extent(5)) ||
+      (src.extent(6) != dst.extent(6)) || (src.extent(7) != dst.extent(7))) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     exec_space.fence();
-    if ( ExecCanAccessSrcDst ) {
-      Kokkos::Impl::ViewRemap< dst_type , src_type , ExecSpace >( dst , src );
-    }
-    else if ( DstExecCanAccessSrc ) {
-      // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-      Kokkos::Impl::ViewRemap< dst_type , src_type >( dst , src );
-    }
-    else if ( SrcExecCanAccessDst ) {
-      // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
-      Kokkos::Impl::ViewRemap< dst_type , src_type , src_execution_space >( dst , src );
-    }
-    else {
-      Kokkos::Impl::throw_runtime_exception("deep_copy given views that would require a temporary allocation");
+    if (ExecCanAccessSrcDst) {
+      Kokkos::Impl::ViewRemap<dst_type, src_type, ExecSpace>(dst, src);
+    } else if (DstExecCanAccessSrc) {
+      // Copying data between views in accessible memory spaces and either
+      // non-contiguous or incompatible shape.
+      Kokkos::Impl::ViewRemap<dst_type, src_type>(dst, src);
+    } else if (SrcExecCanAccessDst) {
+      // Copying data between views in accessible memory spaces and either
+      // non-contiguous or incompatible shape.
+      Kokkos::Impl::ViewRemap<dst_type, src_type, src_execution_space>(dst,
+                                                                       src);
+    } else {
+      Kokkos::Impl::throw_runtime_exception(
+          "deep_copy given views that would require a temporary allocation");
     }
     exec_space.fence();
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endDeepCopy();
+    }
+#endif
     return;
 #else
-    std::string message("Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
-    message += dst.label(); message += "(";
-    for(int r = 0; r<dst_type::Rank-1; r++)
-      { message+= std::to_string(dst.extent(r)); message += ","; }
-    message+= std::to_string(dst.extent(dst_type::Rank-1)); message += ") ";
-    message += src.label(); message += "(";
-    for(int r = 0; r<src_type::Rank-1; r++)
-      { message+= std::to_string(src.extent(r)); message += ","; }
-    message+= std::to_string(src.extent(src_type::Rank-1)); message += ") ";
+    std::string message(
+        "Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
+    message += dst.label();
+    message += "(";
+    for (int r = 0; r < dst_type::Rank - 1; r++) {
+      message += std::to_string(dst.extent(r));
+      message += ",";
+    }
+    message += std::to_string(dst.extent(dst_type::Rank - 1));
+    message += ") ";
+    message += src.label();
+    message += "(";
+    for (int r = 0; r < src_type::Rank - 1; r++) {
+      message += std::to_string(src.extent(r));
+      message += ",";
+    }
+    message += std::to_string(src.extent(src_type::Rank - 1));
+    message += ") ";
 
     Kokkos::Impl::throw_runtime_exception(message);
 #endif
   }
 
-  // If same type, equal layout, equal dimensions, equal span, and contiguous memory then can byte-wise copy
-
-  if ( std::is_same< typename dst_type::value_type ,
-                     typename src_type::non_const_value_type >::value &&
-       (
-         std::is_same< typename dst_type::array_layout ,
-                       typename src_type::array_layout >::value
-         ||
-         ( dst_type::rank == 1 &&
-           src_type::rank == 1 )
-       ) &&
-       dst.span_is_contiguous() &&
-       src.span_is_contiguous() &&
-       ((dst_type::rank < 1) || (dst.stride_0() == src.stride_0()))  &&
-       ((dst_type::rank < 2) || (dst.stride_1() == src.stride_1())) &&
-       ((dst_type::rank < 3) || (dst.stride_2() == src.stride_2())) &&
-       ((dst_type::rank < 4) || (dst.stride_3() == src.stride_3())) &&
-       ((dst_type::rank < 5) || (dst.stride_4() == src.stride_4())) &&
-       ((dst_type::rank < 6) || (dst.stride_5() == src.stride_5())) &&
-       ((dst_type::rank < 7) || (dst.stride_6() == src.stride_6())) &&
-       ((dst_type::rank < 8) || (dst.stride_7() == src.stride_7()))
-    ) {
-
+  // If same type, equal layout, equal dimensions, equal span, and contiguous
+  // memory then can byte-wise copy
+
+  if (std::is_same<typename dst_type::value_type,
+                   typename src_type::non_const_value_type>::value &&
+      (std::is_same<typename dst_type::array_layout,
+                    typename src_type::array_layout>::value ||
+       (dst_type::rank == 1 && src_type::rank == 1)) &&
+      dst.span_is_contiguous() && src.span_is_contiguous() &&
+      ((dst_type::rank < 1) || (dst.stride_0() == src.stride_0())) &&
+      ((dst_type::rank < 2) || (dst.stride_1() == src.stride_1())) &&
+      ((dst_type::rank < 3) || (dst.stride_2() == src.stride_2())) &&
+      ((dst_type::rank < 4) || (dst.stride_3() == src.stride_3())) &&
+      ((dst_type::rank < 5) || (dst.stride_4() == src.stride_4())) &&
+      ((dst_type::rank < 6) || (dst.stride_5() == src.stride_5())) &&
+      ((dst_type::rank < 7) || (dst.stride_6() == src.stride_6())) &&
+      ((dst_type::rank < 8) || (dst.stride_7() == src.stride_7()))) {
     const size_t nbytes = sizeof(typename dst_type::value_type) * dst.span();
     exec_space.fence();
-    if((void*)dst.data() != (void*)src.data()) {
-      Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space , ExecSpace >
-        ( exec_space , dst.data() , src.data() , nbytes );
+    if ((void*)dst.data() != (void*)src.data()) {
+      Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space, ExecSpace>(
+          exec_space, dst.data(), src.data(), nbytes);
     }
     exec_space.fence();
   } else {
@@ -2581,6 +2957,11 @@ void deep_copy
     Impl::view_copy(dst, src);
     exec_space.fence();
   }
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endDeepCopy();
+  }
+#endif
 }
 
 } /* namespace Kokkos */
@@ -2590,90 +2971,179 @@ void deep_copy
 
 namespace Kokkos {
 
-/** \brief  Resize a view with copying old data to new data at the corresponding indices. */
-template< class T , class ... P >
-inline
-typename std::enable_if<
-  std::is_same<typename Kokkos::View<T,P...>::array_layout,Kokkos::LayoutLeft>::value ||
-  std::is_same<typename Kokkos::View<T,P...>::array_layout,Kokkos::LayoutRight>::value
->::type
-resize( Kokkos::View<T,P...> & v ,
-             const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-             const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-             const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-             const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-             const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-             const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-             const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-             const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG )
-{
-  typedef Kokkos::View<T,P...>  view_type ;
-
-  static_assert( Kokkos::ViewTraits<T,P...>::is_managed , "Can only resize managed views" );
+/** \brief  Resize a view with copying old data to new data at the corresponding
+ * indices. */
+template <class T, class... P>
+inline typename std::enable_if<
+    std::is_same<typename Kokkos::View<T, P...>::array_layout,
+                 Kokkos::LayoutLeft>::value ||
+    std::is_same<typename Kokkos::View<T, P...>::array_layout,
+                 Kokkos::LayoutRight>::value>::type
+resize(Kokkos::View<T, P...>& v, const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
+  typedef Kokkos::View<T, P...> view_type;
+
+  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
+                "Can only resize managed views");
+
+  // Fix #904 by checking dimensions before actually resizing.
+  //
+  // Rank is known at compile time, so hopefully the compiler will
+  // remove branches that are compile-time false.  The upcoming "if
+  // constexpr" language feature would make this certain.
+  if (view_type::Rank == 1 && n0 == static_cast<size_t>(v.extent(0))) {
+    return;
+  }
+  if (view_type::Rank == 2 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1))) {
+    return;
+  }
+  if (view_type::Rank == 3 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2))) {
+    return;
+  }
+  if (view_type::Rank == 4 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3))) {
+    return;
+  }
+  if (view_type::Rank == 5 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4))) {
+    return;
+  }
+  if (view_type::Rank == 6 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4)) &&
+      n5 == static_cast<size_t>(v.extent(5))) {
+    return;
+  }
+  if (view_type::Rank == 7 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4)) &&
+      n5 == static_cast<size_t>(v.extent(5)) &&
+      n6 == static_cast<size_t>(v.extent(6))) {
+    return;
+  }
+  if (view_type::Rank == 8 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4)) &&
+      n5 == static_cast<size_t>(v.extent(5)) &&
+      n6 == static_cast<size_t>(v.extent(6)) &&
+      n7 == static_cast<size_t>(v.extent(7))) {
+    return;
+  }
+  // If Kokkos ever supports Views of rank > 8, the above code won't
+  // be incorrect, because avoiding reallocation in resize() is just
+  // an optimization.
+
+  // TODO (mfh 27 Jun 2017) If the old View has enough space but just
+  // different dimensions (e.g., if the product of the dimensions,
+  // including extra space for alignment, will not change), then
+  // consider just reusing storage.  For now, Kokkos always
+  // reallocates if any of the dimensions change, even if the old View
+  // has enough space.
+
+  view_type v_resized(v.label(), n0, n1, n2, n3, n4, n5, n6, n7);
+
+  Kokkos::Impl::ViewRemap<view_type, view_type>(v_resized, v);
+
+  v = v_resized;
+}
+
+/** \brief  Resize a view with copying old data to new data at the corresponding
+ * indices. */
+template <class I, class T, class... P>
+inline typename std::enable_if<
+    std::is_same<typename Kokkos::View<T, P...>::array_layout,
+                 Kokkos::LayoutLeft>::value ||
+    std::is_same<typename Kokkos::View<T, P...>::array_layout,
+                 Kokkos::LayoutRight>::value>::type
+resize(const I& arg_prop, Kokkos::View<T, P...>& v,
+       const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+       const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
+  typedef Kokkos::View<T, P...> view_type;
+
+  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
+                "Can only resize managed views");
 
   // Fix #904 by checking dimensions before actually resizing.
   //
   // Rank is known at compile time, so hopefully the compiler will
   // remove branches that are compile-time false.  The upcoming "if
   // constexpr" language feature would make this certain.
-  if (view_type::Rank == 1 &&
-      n0 == static_cast<size_t> (v.extent(0))) {
+  if (view_type::Rank == 1 && n0 == static_cast<size_t>(v.extent(0))) {
     return;
   }
-  if (view_type::Rank == 2 &&
-      n0 == static_cast<size_t> (v.extent(0)) &&
-      n1 == static_cast<size_t> (v.extent(1))) {
+  if (view_type::Rank == 2 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1))) {
     return;
   }
-  if (view_type::Rank == 3 &&
-      n0 == static_cast<size_t> (v.extent(0)) &&
-      n1 == static_cast<size_t> (v.extent(1)) &&
-      n2 == static_cast<size_t> (v.extent(2))) {
+  if (view_type::Rank == 3 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2))) {
     return;
   }
-  if (view_type::Rank == 4 &&
-      n0 == static_cast<size_t> (v.extent(0)) &&
-      n1 == static_cast<size_t> (v.extent(1)) &&
-      n2 == static_cast<size_t> (v.extent(2)) &&
-      n3 == static_cast<size_t> (v.extent(3))) {
+  if (view_type::Rank == 4 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3))) {
     return;
   }
-  if (view_type::Rank == 5 &&
-      n0 == static_cast<size_t> (v.extent(0)) &&
-      n1 == static_cast<size_t> (v.extent(1)) &&
-      n2 == static_cast<size_t> (v.extent(2)) &&
-      n3 == static_cast<size_t> (v.extent(3)) &&
-      n4 == static_cast<size_t> (v.extent(4))) {
+  if (view_type::Rank == 5 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4))) {
     return;
   }
-  if (view_type::Rank == 6 &&
-      n0 == static_cast<size_t> (v.extent(0)) &&
-      n1 == static_cast<size_t> (v.extent(1)) &&
-      n2 == static_cast<size_t> (v.extent(2)) &&
-      n3 == static_cast<size_t> (v.extent(3)) &&
-      n4 == static_cast<size_t> (v.extent(4)) &&
-      n5 == static_cast<size_t> (v.extent(5))) {
+  if (view_type::Rank == 6 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4)) &&
+      n5 == static_cast<size_t>(v.extent(5))) {
     return;
   }
-  if (view_type::Rank == 7 &&
-      n0 == static_cast<size_t> (v.extent(0)) &&
-      n1 == static_cast<size_t> (v.extent(1)) &&
-      n2 == static_cast<size_t> (v.extent(2)) &&
-      n3 == static_cast<size_t> (v.extent(3)) &&
-      n4 == static_cast<size_t> (v.extent(4)) &&
-      n5 == static_cast<size_t> (v.extent(5)) &&
-      n6 == static_cast<size_t> (v.extent(6))) {
+  if (view_type::Rank == 7 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4)) &&
+      n5 == static_cast<size_t>(v.extent(5)) &&
+      n6 == static_cast<size_t>(v.extent(6))) {
     return;
   }
-  if (view_type::Rank == 8 &&
-      n0 == static_cast<size_t> (v.extent(0)) &&
-      n1 == static_cast<size_t> (v.extent(1)) &&
-      n2 == static_cast<size_t> (v.extent(2)) &&
-      n3 == static_cast<size_t> (v.extent(3)) &&
-      n4 == static_cast<size_t> (v.extent(4)) &&
-      n5 == static_cast<size_t> (v.extent(5)) &&
-      n6 == static_cast<size_t> (v.extent(6)) &&
-      n7 == static_cast<size_t> (v.extent(7))) {
+  if (view_type::Rank == 8 && n0 == static_cast<size_t>(v.extent(0)) &&
+      n1 == static_cast<size_t>(v.extent(1)) &&
+      n2 == static_cast<size_t>(v.extent(2)) &&
+      n3 == static_cast<size_t>(v.extent(3)) &&
+      n4 == static_cast<size_t>(v.extent(4)) &&
+      n5 == static_cast<size_t>(v.extent(5)) &&
+      n6 == static_cast<size_t>(v.extent(6)) &&
+      n7 == static_cast<size_t>(v.extent(7))) {
     return;
   }
   // If Kokkos ever supports Views of rank > 8, the above code won't
@@ -2687,71 +3157,72 @@ resize( Kokkos::View<T,P...> & v ,
   // reallocates if any of the dimensions change, even if the old View
   // has enough space.
 
-  view_type v_resized( v.label(), n0, n1, n2, n3, n4, n5, n6, n7 );
+  view_type v_resized(view_alloc(v.label(), std::forward<const I>(arg_prop)),
+                      n0, n1, n2, n3, n4, n5, n6, n7);
 
-  Kokkos::Impl::ViewRemap< view_type , view_type >( v_resized , v );
+  Kokkos::Impl::ViewRemap<view_type, view_type>(v_resized, v);
 
-  v = v_resized ;
+  v = v_resized;
 }
 
-/** \brief  Resize a view with copying old data to new data at the corresponding indices. */
-template< class T , class ... P >
-inline
-void resize(       Kokkos::View<T,P...> & v ,
-    const typename Kokkos::View<T,P...>::array_layout & layout)
-{
-  typedef Kokkos::View<T,P...>  view_type ;
+/** \brief  Resize a view with copying old data to new data at the corresponding
+ * indices. */
+template <class T, class... P>
+inline void resize(Kokkos::View<T, P...>& v,
+                   const typename Kokkos::View<T, P...>::array_layout& layout) {
+  typedef Kokkos::View<T, P...> view_type;
 
-  static_assert( Kokkos::ViewTraits<T,P...>::is_managed , "Can only resize managed views" );
+  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
+                "Can only resize managed views");
 
-  view_type v_resized( v.label(), layout );
+  view_type v_resized(v.label(), layout);
 
-  Kokkos::Impl::ViewRemap< view_type , view_type >( v_resized , v );
+  Kokkos::Impl::ViewRemap<view_type, view_type>(v_resized, v);
 
-  v = v_resized ;
+  v = v_resized;
 }
 
 /** \brief  Resize a view with discarding old data. */
-template< class T , class ... P >
-inline
-typename std::enable_if<
-  std::is_same<typename Kokkos::View<T,P...>::array_layout,Kokkos::LayoutLeft>::value ||
-  std::is_same<typename Kokkos::View<T,P...>::array_layout,Kokkos::LayoutRight>::value
->::type
-realloc( Kokkos::View<T,P...> & v ,
-              const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-              const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-              const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-              const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-              const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-              const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-              const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG ,
-              const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG )
-{
-  typedef Kokkos::View<T,P...>  view_type ;
-
-  static_assert( Kokkos::ViewTraits<T,P...>::is_managed , "Can only realloc managed views" );
+template <class T, class... P>
+inline typename std::enable_if<
+    std::is_same<typename Kokkos::View<T, P...>::array_layout,
+                 Kokkos::LayoutLeft>::value ||
+    std::is_same<typename Kokkos::View<T, P...>::array_layout,
+                 Kokkos::LayoutRight>::value>::type
+realloc(Kokkos::View<T, P...>& v,
+        const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
+  typedef Kokkos::View<T, P...> view_type;
+
+  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
+                "Can only realloc managed views");
 
   const std::string label = v.label();
 
-  v = view_type(); // Deallocate first, if the only view to allocation
-  v = view_type( label, n0, n1, n2, n3, n4, n5, n6, n7 );
+  v = view_type();  // Deallocate first, if the only view to allocation
+  v = view_type(label, n0, n1, n2, n3, n4, n5, n6, n7);
 }
 
 /** \brief  Resize a view with discarding old data. */
-template< class T , class ... P >
-inline
-void realloc(      Kokkos::View<T,P...> & v ,
-    const typename Kokkos::View<T,P...>::array_layout & layout)
-{
-  typedef Kokkos::View<T,P...>  view_type ;
+template <class T, class... P>
+inline void realloc(
+    Kokkos::View<T, P...>& v,
+    const typename Kokkos::View<T, P...>::array_layout& layout) {
+  typedef Kokkos::View<T, P...> view_type;
 
-  static_assert( Kokkos::ViewTraits<T,P...>::is_managed , "Can only realloc managed views" );
+  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
+                "Can only realloc managed views");
 
   const std::string label = v.label();
 
-  v = view_type(); // Deallocate first, if the only view to allocation
-  v = view_type( label, layout );
+  v = view_type();  // Deallocate first, if the only view to allocation
+  v = view_type(label, layout);
 }
 } /* namespace Kokkos */
 
@@ -2762,94 +3233,99 @@ namespace Kokkos {
 namespace Impl {
 
 // Deduce Mirror Types
-template<class Space, class T, class ... P>
+template <class Space, class T, class... P>
 struct MirrorViewType {
   // The incoming view_type
-  typedef typename Kokkos::View<T,P...> src_view_type;
+  typedef typename Kokkos::View<T, P...> src_view_type;
   // The memory space for the mirror view
   typedef typename Space::memory_space memory_space;
   // Check whether it is the same memory space
-  enum { is_same_memspace = std::is_same<memory_space,typename src_view_type::memory_space>::value };
+  enum {
+    is_same_memspace =
+        std::is_same<memory_space, typename src_view_type::memory_space>::value
+  };
   // The array_layout
   typedef typename src_view_type::array_layout array_layout;
-  // The data type (we probably want it non-const since otherwise we can't even deep_copy to it.
+  // The data type (we probably want it non-const since otherwise we can't even
+  // deep_copy to it.
   typedef typename src_view_type::non_const_data_type data_type;
   // The destination view type if it is not the same memory space
-  typedef Kokkos::View<data_type,array_layout,Space> dest_view_type;
+  typedef Kokkos::View<data_type, array_layout, Space> dest_view_type;
   // If it is the same memory_space return the existsing view_type
   // This will also keep the unmanaged trait if necessary
-  typedef typename std::conditional<is_same_memspace,src_view_type,dest_view_type>::type view_type;
+  typedef typename std::conditional<is_same_memspace, src_view_type,
+                                    dest_view_type>::type view_type;
 };
 
-template<class Space, class T, class ... P>
+template <class Space, class T, class... P>
 struct MirrorType {
   // The incoming view_type
-  typedef typename Kokkos::View<T,P...> src_view_type;
+  typedef typename Kokkos::View<T, P...> src_view_type;
   // The memory space for the mirror view
   typedef typename Space::memory_space memory_space;
   // Check whether it is the same memory space
-  enum { is_same_memspace = std::is_same<memory_space,typename src_view_type::memory_space>::value };
+  enum {
+    is_same_memspace =
+        std::is_same<memory_space, typename src_view_type::memory_space>::value
+  };
   // The array_layout
   typedef typename src_view_type::array_layout array_layout;
-  // The data type (we probably want it non-const since otherwise we can't even deep_copy to it.
+  // The data type (we probably want it non-const since otherwise we can't even
+  // deep_copy to it.
   typedef typename src_view_type::non_const_data_type data_type;
   // The destination view type if it is not the same memory space
-  typedef Kokkos::View<data_type,array_layout,Space> view_type;
+  typedef Kokkos::View<data_type, array_layout, Space> view_type;
 };
 
-}
+}  // namespace Impl
+
+template <class T, class... P>
+inline typename Kokkos::View<T, P...>::HostMirror create_mirror(
+    const Kokkos::View<T, P...>& src,
+    typename std::enable_if<
+        std::is_same<typename ViewTraits<T, P...>::specialize, void>::value &&
+        !std::is_same<typename Kokkos::ViewTraits<T, P...>::array_layout,
+                      Kokkos::LayoutStride>::value>::type* = 0) {
+  typedef View<T, P...> src_type;
+  typedef typename src_type::HostMirror dst_type;
 
-template< class T , class ... P >
-inline
-typename Kokkos::View<T,P...>::HostMirror
-create_mirror( const Kokkos::View<T,P...> & src
-             , typename std::enable_if<
-                 std::is_same< typename ViewTraits<T,P...>::specialize , void >::value &&
-                 ! std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
-                               , Kokkos::LayoutStride >::value
-               >::type * = 0
-             )
-{
-  typedef View<T,P...>                   src_type ;
-  typedef typename src_type::HostMirror  dst_type ;
-
-  return dst_type( std::string( src.label() ).append("_mirror")
+  return dst_type(std::string(src.label()).append("_mirror")
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-                   , src.extent(0)
-                   , src.extent(1)
-                   , src.extent(2)
-                   , src.extent(3)
-                   , src.extent(4)
-                   , src.extent(5)
-                   , src.extent(6)
-                   , src.extent(7) );
+                      ,
+                  src.extent(0), src.extent(1), src.extent(2), src.extent(3),
+                  src.extent(4), src.extent(5), src.extent(6), src.extent(7));
 #else
-                 , src.rank_dynamic > 0 ? src.extent(0): KOKKOS_IMPL_CTOR_DEFAULT_ARG
-                 , src.rank_dynamic > 1 ? src.extent(1): KOKKOS_IMPL_CTOR_DEFAULT_ARG
-                 , src.rank_dynamic > 2 ? src.extent(2): KOKKOS_IMPL_CTOR_DEFAULT_ARG
-                 , src.rank_dynamic > 3 ? src.extent(3): KOKKOS_IMPL_CTOR_DEFAULT_ARG
-                 , src.rank_dynamic > 4 ? src.extent(4): KOKKOS_IMPL_CTOR_DEFAULT_ARG
-                 , src.rank_dynamic > 5 ? src.extent(5): KOKKOS_IMPL_CTOR_DEFAULT_ARG
-                 , src.rank_dynamic > 6 ? src.extent(6): KOKKOS_IMPL_CTOR_DEFAULT_ARG
-                 , src.rank_dynamic > 7 ? src.extent(7): KOKKOS_IMPL_CTOR_DEFAULT_ARG );
+                      ,
+                  src.rank_dynamic > 0 ? src.extent(0)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                  src.rank_dynamic > 1 ? src.extent(1)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                  src.rank_dynamic > 2 ? src.extent(2)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                  src.rank_dynamic > 3 ? src.extent(3)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                  src.rank_dynamic > 4 ? src.extent(4)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                  src.rank_dynamic > 5 ? src.extent(5)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                  src.rank_dynamic > 6 ? src.extent(6)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                  src.rank_dynamic > 7 ? src.extent(7)
+                                       : KOKKOS_IMPL_CTOR_DEFAULT_ARG);
 #endif
 }
 
-template< class T , class ... P >
-inline
-typename Kokkos::View<T,P...>::HostMirror
-create_mirror( const Kokkos::View<T,P...> & src
-             , typename std::enable_if<
-                 std::is_same< typename ViewTraits<T,P...>::specialize , void >::value &&
-                 std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
-                             , Kokkos::LayoutStride >::value
-               >::type * = 0
-             )
-{
-  typedef View<T,P...>                   src_type ;
-  typedef typename src_type::HostMirror  dst_type ;
-
-  Kokkos::LayoutStride layout ;
+template <class T, class... P>
+inline typename Kokkos::View<T, P...>::HostMirror create_mirror(
+    const Kokkos::View<T, P...>& src,
+    typename std::enable_if<
+        std::is_same<typename ViewTraits<T, P...>::specialize, void>::value &&
+        std::is_same<typename Kokkos::ViewTraits<T, P...>::array_layout,
+                     Kokkos::LayoutStride>::value>::type* = 0) {
+  typedef View<T, P...> src_type;
+  typedef typename src_type::HostMirror dst_type;
+
+  Kokkos::LayoutStride layout;
 
   layout.dimension[0] = src.extent(0);
   layout.dimension[1] = src.extent(1);
@@ -2869,117 +3345,119 @@ create_mirror( const Kokkos::View<T,P...> & src
   layout.stride[6] = src.stride_6();
   layout.stride[7] = src.stride_7();
 
-  return dst_type( std::string( src.label() ).append("_mirror") , layout );
+  return dst_type(std::string(src.label()).append("_mirror"), layout);
 }
 
-
 // Create a mirror in a new space (specialization for different space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorType<Space,T,P ...>::view_type
-create_mirror(const Space& , const Kokkos::View<T,P...> & src
-             , typename std::enable_if<
-                 std::is_same< typename ViewTraits<T,P...>::specialize , void >::value
-               >::type * = 0) {
-  return typename Impl::MirrorType<Space,T,P ...>::view_type(src.label(),src.layout());
+template <class Space, class T, class... P>
+typename Impl::MirrorType<Space, T, P...>::view_type create_mirror(
+    const Space&, const Kokkos::View<T, P...>& src,
+    typename std::enable_if<std::is_same<
+        typename ViewTraits<T, P...>::specialize, void>::value>::type* = 0) {
+  return typename Impl::MirrorType<Space, T, P...>::view_type(src.label(),
+                                                              src.layout());
 }
 
-template< class T , class ... P >
-inline
-typename Kokkos::View<T,P...>::HostMirror
-create_mirror_view( const Kokkos::View<T,P...> & src
-                  , typename std::enable_if<(
-                      std::is_same< typename Kokkos::View<T,P...>::memory_space
-                                  , typename Kokkos::View<T,P...>::HostMirror::memory_space
-                                  >::value
-                      &&
-                      std::is_same< typename Kokkos::View<T,P...>::data_type
-                                  , typename Kokkos::View<T,P...>::HostMirror::data_type
-                                  >::value
-                    )>::type * = 0
-                  )
-{
-  return src ;
+template <class T, class... P>
+inline typename Kokkos::View<T, P...>::HostMirror create_mirror_view(
+    const Kokkos::View<T, P...>& src,
+    typename std::enable_if<
+        (std::is_same<
+             typename Kokkos::View<T, P...>::memory_space,
+             typename Kokkos::View<T, P...>::HostMirror::memory_space>::value &&
+         std::is_same<typename Kokkos::View<T, P...>::data_type,
+                      typename Kokkos::View<T, P...>::HostMirror::data_type>::
+             value)>::type* = 0) {
+  return src;
 }
 
-template< class T , class ... P >
-inline
-typename Kokkos::View<T,P...>::HostMirror
-create_mirror_view( const Kokkos::View<T,P...> & src
-                  , typename std::enable_if< ! (
-                      std::is_same< typename Kokkos::View<T,P...>::memory_space
-                                  , typename Kokkos::View<T,P...>::HostMirror::memory_space
-                                  >::value
-                      &&
-                      std::is_same< typename Kokkos::View<T,P...>::data_type
-                                  , typename Kokkos::View<T,P...>::HostMirror::data_type
-                                  >::value
-                    )>::type * = 0
-                  )
-{
-  return Kokkos::create_mirror( src );
+template <class T, class... P>
+inline typename Kokkos::View<T, P...>::HostMirror create_mirror_view(
+    const Kokkos::View<T, P...>& src,
+    typename std::enable_if<!(
+        std::is_same<
+            typename Kokkos::View<T, P...>::memory_space,
+            typename Kokkos::View<T, P...>::HostMirror::memory_space>::value &&
+        std::is_same<typename Kokkos::View<T, P...>::data_type,
+                     typename Kokkos::View<T, P...>::HostMirror::data_type>::
+            value)>::type* = 0) {
+  return Kokkos::create_mirror(src);
 }
 
 // Create a mirror view in a new space (specialization for same space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorViewType<Space,T,P ...>::view_type
-create_mirror_view(const Space& , const Kokkos::View<T,P...> & src
-  , typename std::enable_if<Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
+template <class Space, class T, class... P>
+typename Impl::MirrorViewType<Space, T, P...>::view_type create_mirror_view(
+    const Space&, const Kokkos::View<T, P...>& src,
+    typename std::enable_if<
+        Impl::MirrorViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
   return src;
 }
 
 // Create a mirror view in a new space (specialization for different space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorViewType<Space,T,P ...>::view_type
-create_mirror_view(const Space& , const Kokkos::View<T,P...> & src
-  , typename std::enable_if<!Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-  return typename Impl::MirrorViewType<Space,T,P ...>::view_type(src.label(),src.layout());
+template <class Space, class T, class... P>
+typename Impl::MirrorViewType<Space, T, P...>::view_type create_mirror_view(
+    const Space&, const Kokkos::View<T, P...>& src,
+    typename std::enable_if<
+        !Impl::MirrorViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
+  return typename Impl::MirrorViewType<Space, T, P...>::view_type(src.label(),
+                                                                  src.layout());
 }
 
-// Create a mirror view and deep_copy in a new space (specialization for same space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorViewType<Space,T,P ...>::view_type
-create_mirror_view_and_copy(const Space& , const Kokkos::View<T,P...> & src
-  , std::string const& name = ""
-  , typename std::enable_if<Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
+// Create a mirror view and deep_copy in a new space (specialization for same
+// space)
+template <class Space, class T, class... P>
+typename Impl::MirrorViewType<Space, T, P...>::view_type
+create_mirror_view_and_copy(
+    const Space&, const Kokkos::View<T, P...>& src,
+    std::string const& name = "",
+    typename std::enable_if<
+        Impl::MirrorViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
   (void)name;
   return src;
 }
 
-// Create a mirror view and deep_copy in a new space (specialization for different space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorViewType<Space,T,P ...>::view_type
-create_mirror_view_and_copy(const Space& , const Kokkos::View<T,P...> & src
-  , std::string const& name = ""
-  , typename std::enable_if<!Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-  using Mirror = typename Impl::MirrorViewType<Space,T,P ...>::view_type;
+// Create a mirror view and deep_copy in a new space (specialization for
+// different space)
+template <class Space, class T, class... P>
+typename Impl::MirrorViewType<Space, T, P...>::view_type
+create_mirror_view_and_copy(
+    const Space&, const Kokkos::View<T, P...>& src,
+    std::string const& name = "",
+    typename std::enable_if<
+        !Impl::MirrorViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
+  using Mirror      = typename Impl::MirrorViewType<Space, T, P...>::view_type;
   std::string label = name.empty() ? src.label() : name;
   auto mirror = Mirror(ViewAllocateWithoutInitializing(label), src.layout());
   deep_copy(mirror, src);
   return mirror;
 }
-    
-// Create a mirror view in a new space without initializing (specialization for same space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorViewType<Space,T,P ...>::view_type
-create_mirror_view(const Space& , const Kokkos::View<T,P...> & src
-  , Kokkos::Impl::WithoutInitializing_t
-  , typename std::enable_if<Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
+
+// Create a mirror view in a new space without initializing (specialization for
+// same space)
+template <class Space, class T, class... P>
+typename Impl::MirrorViewType<Space, T, P...>::view_type create_mirror_view(
+    const Space&, const Kokkos::View<T, P...>& src,
+    Kokkos::Impl::WithoutInitializing_t,
+    typename std::enable_if<
+        Impl::MirrorViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
   return src;
 }
-    
-// Create a mirror view in a new space without initializing (specialization for different space)
-template<class Space, class T, class ... P>
-typename Impl::MirrorViewType<Space,T,P ...>::view_type
-create_mirror_view(const Space& , const Kokkos::View<T,P...> & src
-  , Kokkos::Impl::WithoutInitializing_t
-  , typename std::enable_if<!Impl::MirrorViewType<Space,T,P ...>::is_same_memspace>::type* = 0 ) {
-  using Mirror = typename Impl::MirrorViewType<Space,T,P ...>::view_type;
-  return Mirror(Kokkos::ViewAllocateWithoutInitializing(src.label()), src.layout());
+
+// Create a mirror view in a new space without initializing (specialization for
+// different space)
+template <class Space, class T, class... P>
+typename Impl::MirrorViewType<Space, T, P...>::view_type create_mirror_view(
+    const Space&, const Kokkos::View<T, P...>& src,
+    Kokkos::Impl::WithoutInitializing_t,
+    typename std::enable_if<
+        !Impl::MirrorViewType<Space, T, P...>::is_same_memspace>::type* = 0) {
+  using Mirror = typename Impl::MirrorViewType<Space, T, P...>::view_type;
+  return Mirror(Kokkos::ViewAllocateWithoutInitializing(src.label()),
+                src.layout());
 }
 
 } /* namespace Kokkos */
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
diff --git a/lib/kokkos/core/src/Kokkos_Core.hpp b/lib/kokkos/core/src/Kokkos_Core.hpp
index 9fbba0abfa3afb6ea3ed31d51249ad2c8170396d..7661efeca7954ecefb441bdcb2fb5127f21b628b 100644
--- a/lib/kokkos/core/src/Kokkos_Core.hpp
+++ b/lib/kokkos/core/src/Kokkos_Core.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,11 +50,11 @@
 
 #include <Kokkos_Core_fwd.hpp>
 
-#if defined( KOKKOS_ENABLE_SERIAL )
+#if defined(KOKKOS_ENABLE_SERIAL)
 #include <Kokkos_Serial.hpp>
 #endif
 
-#if defined( KOKKOS_ENABLE_OPENMP )
+#if defined(KOKKOS_ENABLE_OPENMP)
 #include <Kokkos_OpenMP.hpp>
 #endif
 
@@ -62,23 +63,23 @@
 #include <Kokkos_OpenMPTargetSpace.hpp>
 //#endif
 
-#if defined( KOKKOS_ENABLE_QTHREADS )
+#if defined(KOKKOS_ENABLE_QTHREADS)
 #include <Kokkos_Qthreads.hpp>
 #endif
 
-#if defined( KOKKOS_ENABLE_HPX )
+#if defined(KOKKOS_ENABLE_HPX)
 #include <Kokkos_HPX.hpp>
 #endif
 
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 #include <Kokkos_Threads.hpp>
 #endif
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 #include <Kokkos_Cuda.hpp>
 #endif
 
-#if defined( KOKKOS_ENABLE_ROCM )
+#if defined(KOKKOS_ENABLE_ROCM)
 #include <Kokkos_ROCm.hpp>
 #endif
 
@@ -111,18 +112,13 @@ struct InitArguments {
   int skip_device;
   bool disable_warnings;
 
-  InitArguments( int nt = -1
-               , int nn = -1
-               , int dv = -1
-               , bool dw = false
-               )
-    : num_threads{ nt }
-    , num_numa{ nn }
-    , device_id{ dv }
-    , ndevices{ -1 }
-    , skip_device{ 9999 }
-    , disable_warnings{ dw }
-  {}
+  InitArguments(int nt = -1, int nn = -1, int dv = -1, bool dw = false)
+      : num_threads{nt},
+        num_numa{nn},
+        device_id{dv},
+        ndevices{-1},
+        skip_device{9999},
+        disable_warnings{dw} {}
 };
 
 void initialize(int& narg, char* arg[]);
@@ -164,9 +160,9 @@ void finalize_all();
 void fence();
 
 /** \brief Print "Bill of Materials" */
-void print_configuration( std::ostream & , const bool detail = false );
+void print_configuration(std::ostream&, const bool detail = false);
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -177,92 +173,80 @@ namespace Kokkos {
  * The allocation is tracked in Kokkos memory tracking system, so
  * leaked memory can be identified.
  */
-template< class Space = typename Kokkos::DefaultExecutionSpace::memory_space >
-inline
-void * kokkos_malloc( const std::string & arg_alloc_label
-                    , const size_t arg_alloc_size )
-{
-  typedef typename Space::memory_space MemorySpace ;
-  return Impl::SharedAllocationRecord< MemorySpace >::
-    allocate_tracked( MemorySpace() , arg_alloc_label , arg_alloc_size );
+template <class Space = typename Kokkos::DefaultExecutionSpace::memory_space>
+inline void* kokkos_malloc(const std::string& arg_alloc_label,
+                           const size_t arg_alloc_size) {
+  typedef typename Space::memory_space MemorySpace;
+  return Impl::SharedAllocationRecord<MemorySpace>::allocate_tracked(
+      MemorySpace(), arg_alloc_label, arg_alloc_size);
 }
 
-template< class Space = typename Kokkos::DefaultExecutionSpace::memory_space >
-inline
-void * kokkos_malloc( const size_t arg_alloc_size )
-{
-  typedef typename Space::memory_space MemorySpace ;
-  return Impl::SharedAllocationRecord< MemorySpace >::
-    allocate_tracked( MemorySpace() , "no-label" , arg_alloc_size );
+template <class Space = typename Kokkos::DefaultExecutionSpace::memory_space>
+inline void* kokkos_malloc(const size_t arg_alloc_size) {
+  typedef typename Space::memory_space MemorySpace;
+  return Impl::SharedAllocationRecord<MemorySpace>::allocate_tracked(
+      MemorySpace(), "no-label", arg_alloc_size);
 }
 
-template< class Space = typename Kokkos::DefaultExecutionSpace::memory_space >
-inline
-void kokkos_free( void * arg_alloc )
-{
-  typedef typename Space::memory_space MemorySpace ;
-  return Impl::SharedAllocationRecord< MemorySpace >::
-    deallocate_tracked( arg_alloc );
+template <class Space = typename Kokkos::DefaultExecutionSpace::memory_space>
+inline void kokkos_free(void* arg_alloc) {
+  typedef typename Space::memory_space MemorySpace;
+  return Impl::SharedAllocationRecord<MemorySpace>::deallocate_tracked(
+      arg_alloc);
 }
 
-template< class Space = typename Kokkos::DefaultExecutionSpace::memory_space >
-inline
-void * kokkos_realloc( void * arg_alloc , const size_t arg_alloc_size )
-{
-  typedef typename Space::memory_space MemorySpace ;
-  return Impl::SharedAllocationRecord< MemorySpace >::
-    reallocate_tracked( arg_alloc , arg_alloc_size );
+template <class Space = typename Kokkos::DefaultExecutionSpace::memory_space>
+inline void* kokkos_realloc(void* arg_alloc, const size_t arg_alloc_size) {
+  typedef typename Space::memory_space MemorySpace;
+  return Impl::SharedAllocationRecord<MemorySpace>::reallocate_tracked(
+      arg_alloc, arg_alloc_size);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
 /** \brief  ScopeGuard
- *  Some user scope issues have been identified with some Kokkos::finalize calls;
- *  ScopeGuard aims to correct these issues.
+ *  Some user scope issues have been identified with some Kokkos::finalize
+ * calls; ScopeGuard aims to correct these issues.
  *
- *  Two requirements for ScopeGuard: 
- *     if Kokkos::is_initialized() in the constructor, don't call Kokkos::initialize or Kokkos::finalize
- *     it is not copyable or assignable
+ *  Two requirements for ScopeGuard:
+ *     if Kokkos::is_initialized() in the constructor, don't call
+ * Kokkos::initialize or Kokkos::finalize it is not copyable or assignable
  */
 
 class ScopeGuard {
-public:
-  ScopeGuard ( int& narg, char* arg[] )
-  {
-    sg_init = false; 
-    if ( ! Kokkos::is_initialized() ) { 
-      initialize( narg, arg );
+ public:
+  ScopeGuard(int& narg, char* arg[]) {
+    sg_init = false;
+    if (!Kokkos::is_initialized()) {
+      initialize(narg, arg);
       sg_init = true;
     }
   }
 
-  ScopeGuard ( const InitArguments& args = InitArguments() )
-  {
-    sg_init = false; 
-    if ( ! Kokkos::is_initialized() ) { 
-      initialize( args );
+  ScopeGuard(const InitArguments& args = InitArguments()) {
+    sg_init = false;
+    if (!Kokkos::is_initialized()) {
+      initialize(args);
       sg_init = true;
     }
   }
 
-  ~ScopeGuard( )
-  {
-    if ( Kokkos::is_initialized() && sg_init) { 
-      finalize(); 
+  ~ScopeGuard() {
+    if (Kokkos::is_initialized() && sg_init) {
+      finalize();
     }
   }
 
-//private:
-  bool sg_init;    
-
-  ScopeGuard& operator=( const ScopeGuard& ) = delete;
-  ScopeGuard( const ScopeGuard& ) = delete;
+  // private:
+  bool sg_init;
 
+  ScopeGuard& operator=(const ScopeGuard&) = delete;
+  ScopeGuard(const ScopeGuard&)            = delete;
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #include <Kokkos_Crs.hpp>
 #include <Kokkos_WorkGraphPolicy.hpp>
@@ -271,4 +255,3 @@ public:
 //----------------------------------------------------------------------------
 
 #endif
-
diff --git a/lib/kokkos/core/src/Kokkos_Core_fwd.hpp b/lib/kokkos/core/src/Kokkos_Core_fwd.hpp
index 55c6a5494ab992bba028d0afc4c67516026cac15..5b89dc51ca47b81d149eafefc60c9dcf75369dfc 100644
--- a/lib/kokkos/core/src/Kokkos_Core_fwd.hpp
+++ b/lib/kokkos/core/src/Kokkos_Core_fwd.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,8 +58,8 @@
 //----------------------------------------------------------------------------
 // Have assumed a 64bit build (8byte pointers) throughout the code base.
 
-static_assert( sizeof(void*) == 8
-             , "Kokkos assumes 64-bit build; i.e., 8-byte pointers" );
+static_assert(sizeof(void *) == 8,
+              "Kokkos assumes 64-bit build; i.e., 8-byte pointers");
 
 //----------------------------------------------------------------------------
 
@@ -66,133 +67,137 @@ namespace Kokkos {
 
 struct AUTO_t {
   KOKKOS_INLINE_FUNCTION
-  constexpr const AUTO_t & operator()() const { return *this; }
+  constexpr const AUTO_t &operator()() const { return *this; }
 };
 
 namespace {
-/**\brief Token to indicate that a parameter's value is to be automatically selected */
+/**\brief Token to indicate that a parameter's value is to be automatically
+ * selected */
 constexpr AUTO_t AUTO = Kokkos::AUTO_t();
-}
+}  // namespace
 
 struct InvalidType {};
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 // Forward declarations for class inter-relationships
 
 namespace Kokkos {
 
-class HostSpace; ///< Memory space for main process and CPU execution spaces
+class HostSpace;  ///< Memory space for main process and CPU execution spaces
 class AnonymousSpace;
 
 #ifdef KOKKOS_ENABLE_HBWSPACE
 namespace Experimental {
-class HBWSpace; /// Memory space for hbw_malloc from memkind (e.g. for KNL processor)
+class HBWSpace;  /// Memory space for hbw_malloc from memkind (e.g. for KNL
+                 /// processor)
 }
 #endif
 
-#if defined( KOKKOS_ENABLE_SERIAL )
-class Serial;    ///< Execution space main process on CPU.
+#if defined(KOKKOS_ENABLE_SERIAL)
+class Serial;  ///< Execution space main process on CPU.
 #endif
 
-#if defined( KOKKOS_ENABLE_QTHREADS )
+#if defined(KOKKOS_ENABLE_QTHREADS)
 class Qthreads;  ///< Execution space with Qthreads back-end.
 #endif
 
-#if defined( KOKKOS_ENABLE_HPX )
+#if defined(KOKKOS_ENABLE_HPX)
 namespace Experimental {
 class HPX;  ///< Execution space with HPX back-end.
 }
 #endif
 
-#if defined( KOKKOS_ENABLE_THREADS )
-class Threads;   ///< Execution space with pthreads back-end.
+#if defined(KOKKOS_ENABLE_THREADS)
+class Threads;  ///< Execution space with pthreads back-end.
 #endif
 
-#if defined( KOKKOS_ENABLE_OPENMP )
-class OpenMP;    ///< OpenMP execution space.
+#if defined(KOKKOS_ENABLE_OPENMP)
+class OpenMP;  ///< OpenMP execution space.
 #endif
 
-#if defined( KOKKOS_ENABLE_OPENMPTARGET )
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
 namespace Experimental {
-class OpenMPTarget;    ///< OpenMPTarget execution space.
+class OpenMPTarget;  ///< OpenMPTarget execution space.
 class OpenMPTargetSpace;
-}
+}  // namespace Experimental
 #endif
 
-
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 class CudaSpace;            ///< Memory space on Cuda GPU
 class CudaUVMSpace;         ///< Memory space on Cuda GPU with UVM
 class CudaHostPinnedSpace;  ///< Memory space on Host accessible to Cuda GPU
 class Cuda;                 ///< Execution space for Cuda GPU
 #endif
 
-#if defined( KOKKOS_ENABLE_ROCM )
+#if defined(KOKKOS_ENABLE_ROCM)
 namespace Experimental {
-class ROCmSpace ;            ///< Memory space on ROCm GPU
-class ROCm ;                 ///< Execution space for ROCm GPU
-}
+class ROCmSpace;  ///< Memory space on ROCm GPU
+class ROCm;       ///< Execution space for ROCm GPU
+}  // namespace Experimental
 #endif
 
-template<class ExecutionSpace, class MemorySpace>
+template <class ExecutionSpace, class MemorySpace>
 struct Device;
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 // Set the default execution space.
 
 /// Define Kokkos::DefaultExecutionSpace as per configuration option
 /// or chosen from the enabled execution spaces in the following order:
-/// Kokkos::Cuda, Kokkos::Experimental::OpenMPTarget, Kokkos::OpenMP, Kokkos::Threads, Kokkos::Serial
+/// Kokkos::Cuda, Kokkos::Experimental::OpenMPTarget, Kokkos::OpenMP,
+/// Kokkos::Threads, Kokkos::Serial
 
 namespace Kokkos {
 
-#if   defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA )
-  typedef Cuda DefaultExecutionSpace;
-#elif defined ( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET )
-  typedef Experimental::OpenMPTarget DefaultExecutionSpace ;
-#elif defined ( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM )
-  typedef Experimental::ROCm DefaultExecutionSpace ;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP )
-  typedef OpenMP DefaultExecutionSpace;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS )
-  typedef Threads DefaultExecutionSpace;
+#if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA)
+typedef Cuda DefaultExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET)
+typedef Experimental::OpenMPTarget DefaultExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM)
+typedef Experimental::ROCm DefaultExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
+typedef OpenMP DefaultExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
+typedef Threads DefaultExecutionSpace;
 //#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS )
 //  typedef Qthreads DefaultExecutionSpace;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX )
-  typedef Kokkos::Experimental::HPX DefaultExecutionSpace;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL )
-  typedef Serial DefaultExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX)
+typedef Kokkos::Experimental::HPX DefaultExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL)
+typedef Serial DefaultExecutionSpace;
 #else
-#  error "At least one of the following execution spaces must be defined in order to use Kokkos: Kokkos::Cuda, Kokkos::Experimental::OpenMPTarget, Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qthreads, or Kokkos::Serial."
+#error \
+    "At least one of the following execution spaces must be defined in order to use Kokkos: Kokkos::Cuda, Kokkos::Experimental::OpenMPTarget, Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qthreads, or Kokkos::Serial."
 #endif
 
-#if defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP )
-  typedef OpenMP DefaultHostExecutionSpace;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS )
-  typedef Threads DefaultHostExecutionSpace;
+#if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
+typedef OpenMP DefaultHostExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
+typedef Threads DefaultHostExecutionSpace;
 //#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS )
 //  typedef Qthreads DefaultHostExecutionSpace;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL )
-  typedef Serial DefaultHostExecutionSpace;
-#elif defined( KOKKOS_ENABLE_OPENMP )
-  typedef OpenMP DefaultHostExecutionSpace;
-#elif defined( KOKKOS_ENABLE_THREADS )
-  typedef Threads DefaultHostExecutionSpace;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL)
+typedef Serial DefaultHostExecutionSpace;
+#elif defined(KOKKOS_ENABLE_OPENMP)
+typedef OpenMP DefaultHostExecutionSpace;
+#elif defined(KOKKOS_ENABLE_THREADS)
+typedef Threads DefaultHostExecutionSpace;
 //#elif defined( KOKKOS_ENABLE_QTHREADS )
 //  typedef Qthreads DefaultHostExecutionSpace;
-#elif defined( KOKKOS_ENABLE_HPX )
-  typedef Kokkos::Experimental::HPX DefaultHostExecutionSpace;
-#elif defined( KOKKOS_ENABLE_SERIAL )
-  typedef Serial DefaultHostExecutionSpace;
+#elif defined(KOKKOS_ENABLE_HPX)
+typedef Kokkos::Experimental::HPX DefaultHostExecutionSpace;
+#elif defined(KOKKOS_ENABLE_SERIAL)
+typedef Serial DefaultHostExecutionSpace;
 #else
-#  error "At least one of the following execution spaces must be defined in order to use Kokkos: Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qthreads, or Kokkos::Serial."
+#error \
+    "At least one of the following execution spaces must be defined in order to use Kokkos: Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qthreads, or Kokkos::Serial."
 #endif
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 // Detect the active execution space and define its memory space.
@@ -203,44 +208,44 @@ namespace Kokkos {
 
 namespace Impl {
 
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA ) && defined( KOKKOS_ENABLE_CUDA )
-typedef Kokkos::CudaSpace  ActiveExecutionMemorySpace;
-#elif defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_ROCM_GPU )
-typedef Kokkos::HostSpace  ActiveExecutionMemorySpace ;
-#elif defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-typedef Kokkos::HostSpace  ActiveExecutionMemorySpace;
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA) && \
+    defined(KOKKOS_ENABLE_CUDA)
+typedef Kokkos::CudaSpace ActiveExecutionMemorySpace;
+#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_ROCM_GPU)
+typedef Kokkos::HostSpace ActiveExecutionMemorySpace;
+#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+typedef Kokkos::HostSpace ActiveExecutionMemorySpace;
 #else
 typedef void ActiveExecutionMemorySpace;
 #endif
 
-template< class ActiveSpace, class MemorySpace >
+template <class ActiveSpace, class MemorySpace>
 struct VerifyExecutionCanAccessMemorySpace {
-  enum {value = 0};
+  enum { value = 0 };
 };
 
-template< class Space >
-struct VerifyExecutionCanAccessMemorySpace< Space, Space >
-{
-  enum {value = 1};
+template <class Space>
+struct VerifyExecutionCanAccessMemorySpace<Space, Space> {
+  enum { value = 1 };
   KOKKOS_INLINE_FUNCTION static void verify(void) {}
   KOKKOS_INLINE_FUNCTION static void verify(const void *) {}
 };
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
-#define KOKKOS_RESTRICT_EXECUTION_TO_DATA( DATA_SPACE, DATA_PTR ) \
-  Kokkos::Impl::VerifyExecutionCanAccessMemorySpace< \
-    Kokkos::Impl::ActiveExecutionMemorySpace, DATA_SPACE >::verify( DATA_PTR )
+#define KOKKOS_RESTRICT_EXECUTION_TO_DATA(DATA_SPACE, DATA_PTR) \
+  Kokkos::Impl::VerifyExecutionCanAccessMemorySpace<            \
+      Kokkos::Impl::ActiveExecutionMemorySpace, DATA_SPACE>::verify(DATA_PTR)
 
-#define KOKKOS_RESTRICT_EXECUTION_TO_( DATA_SPACE ) \
+#define KOKKOS_RESTRICT_EXECUTION_TO_(DATA_SPACE)    \
   Kokkos::Impl::VerifyExecutionCanAccessMemorySpace< \
-    Kokkos::Impl::ActiveExecutionMemorySpace, DATA_SPACE >::verify()
+      Kokkos::Impl::ActiveExecutionMemorySpace, DATA_SPACE>::verify()
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
-  void fence();
+void fence();
 }
 
 //----------------------------------------------------------------------------
@@ -249,29 +254,33 @@ namespace Kokkos {
 
 namespace Impl {
 
-template< class DstSpace, class SrcSpace, class ExecutionSpace = typename DstSpace::execution_space >
+template <class DstSpace, class SrcSpace,
+          class ExecutionSpace = typename DstSpace::execution_space>
 struct DeepCopy;
 
-template<class ViewType, class Layout, class ExecSpace, int Rank, typename iType>
+template <class ViewType, class Layout, class ExecSpace, int Rank,
+          typename iType>
 struct ViewFillETIAvail;
 
-template<class ViewType, class Layout = typename ViewType::array_layout,
-         class ExecSpace = typename ViewType::execution_space, int Rank = ViewType::Rank, typename iType = int64_t,
-         bool EtiAvail = ViewFillETIAvail<ViewType,Layout,ExecSpace,Rank,iType>::value>
+template <class ViewType, class Layout = typename ViewType::array_layout,
+          class ExecSpace = typename ViewType::execution_space,
+          int Rank = ViewType::Rank, typename iType = int64_t,
+          bool EtiAvail =
+              ViewFillETIAvail<ViewType, Layout, ExecSpace, Rank, iType>::value>
 struct ViewFill;
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace, int Rank, typename iType>
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          int Rank, typename iType>
 struct ViewCopyETIAvail;
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace, int Rank, typename iType,
-         bool EtiAvail = ViewCopyETIAvail<ViewTypeA,ViewTypeB,Layout,ExecSpace,Rank,iType>::value>
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          int Rank, typename iType,
+          bool EtiAvail = ViewCopyETIAvail<ViewTypeA, ViewTypeB, Layout,
+                                           ExecSpace, Rank, iType>::value>
 struct ViewCopy;
 
-template< class Functor
-        , class Policy
-        , class EnableFunctor = void
-        , class EnablePolicy = void
-        >
+template <class Functor, class Policy, class EnableFunctor = void,
+          class EnablePolicy = void>
 struct FunctorPolicyExecutionSpace;
 
 //----------------------------------------------------------------------------
@@ -281,18 +290,20 @@ struct FunctorPolicyExecutionSpace;
 ///
 /// This is an implementation detail of parallel_for.  Users should
 /// skip this and go directly to the nonmember function parallel_for.
-template< class FunctorType, class ExecPolicy, class ExecutionSpace =
-          typename Impl::FunctorPolicyExecutionSpace< FunctorType, ExecPolicy >::execution_space
-        > class ParallelFor;
+template <class FunctorType, class ExecPolicy,
+          class ExecutionSpace = typename Impl::FunctorPolicyExecutionSpace<
+              FunctorType, ExecPolicy>::execution_space>
+class ParallelFor;
 
 /// \class ParallelReduce
 /// \brief Implementation detail of parallel_reduce.
 ///
 /// This is an implementation detail of parallel_reduce.  Users should
 /// skip this and go directly to the nonmember function parallel_reduce.
-template< class FunctorType, class ExecPolicy, class ReducerType = InvalidType, class ExecutionSpace =
-          typename Impl::FunctorPolicyExecutionSpace< FunctorType, ExecPolicy >::execution_space
-        > class ParallelReduce;
+template <class FunctorType, class ExecPolicy, class ReducerType = InvalidType,
+          class ExecutionSpace = typename Impl::FunctorPolicyExecutionSpace<
+              FunctorType, ExecPolicy>::execution_space>
+class ParallelReduce;
 
 /// \class ParallelScan
 /// \brief Implementation detail of parallel_scan.
@@ -300,56 +311,71 @@ template< class FunctorType, class ExecPolicy, class ReducerType = InvalidType,
 /// This is an implementation detail of parallel_scan.  Users should
 /// skip this and go directly to the documentation of the nonmember
 /// template function Kokkos::parallel_scan.
-template< class FunctorType, class ExecPolicy, class ExecutionSapce =
-          typename Impl::FunctorPolicyExecutionSpace< FunctorType, ExecPolicy >::execution_space
-        > class ParallelScan;
-
-template< class FunctorType, class ExecPolicy, class ReturnType = InvalidType, class ExecutionSapce =
-          typename Impl::FunctorPolicyExecutionSpace< FunctorType, ExecPolicy >::execution_space
-        > class ParallelScanWithTotal;
-
-} // namespace Impl
-
-template<class ScalarType , class Space = HostSpace> struct Sum;
-template<class ScalarType , class Space = HostSpace> struct Prod;
-template<class ScalarType , class Space = HostSpace> struct Min;
-template<class ScalarType , class Space = HostSpace> struct Max;
-template<class ScalarType , class Space = HostSpace> struct MinMax;
-template<class ScalarType , class Index, class Space = HostSpace> struct MinLoc;
-template<class ScalarType , class Index, class Space = HostSpace> struct MaxLoc;
-template<class ScalarType , class Index, class Space = HostSpace> struct MinMaxLoc;
-template<class ScalarType , class Space = HostSpace> struct BAnd;
-template<class ScalarType , class Space = HostSpace> struct BOr;
-template<class ScalarType , class Space = HostSpace> struct LAnd;
-template<class ScalarType , class Space = HostSpace> struct LOr;
-
-
-} // namespace Kokkos
+template <class FunctorType, class ExecPolicy,
+          class ExecutionSapce = typename Impl::FunctorPolicyExecutionSpace<
+              FunctorType, ExecPolicy>::execution_space>
+class ParallelScan;
+
+template <class FunctorType, class ExecPolicy, class ReturnType = InvalidType,
+          class ExecutionSapce = typename Impl::FunctorPolicyExecutionSpace<
+              FunctorType, ExecPolicy>::execution_space>
+class ParallelScanWithTotal;
+
+}  // namespace Impl
+
+template <class ScalarType, class Space = HostSpace>
+struct Sum;
+template <class ScalarType, class Space = HostSpace>
+struct Prod;
+template <class ScalarType, class Space = HostSpace>
+struct Min;
+template <class ScalarType, class Space = HostSpace>
+struct Max;
+template <class ScalarType, class Space = HostSpace>
+struct MinMax;
+template <class ScalarType, class Index, class Space = HostSpace>
+struct MinLoc;
+template <class ScalarType, class Index, class Space = HostSpace>
+struct MaxLoc;
+template <class ScalarType, class Index, class Space = HostSpace>
+struct MinMaxLoc;
+template <class ScalarType, class Space = HostSpace>
+struct BAnd;
+template <class ScalarType, class Space = HostSpace>
+struct BOr;
+template <class ScalarType, class Space = HostSpace>
+struct LAnd;
+template <class ScalarType, class Space = HostSpace>
+struct LOr;
+
+}  // namespace Kokkos
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-namespace Kokkos{
-  template<class ScalarType> struct MinMaxScalar;
-  template<class ScalarType, class Index> struct MinMaxLocScalar;
-  template<class ScalarType, class Index> struct ValLocScalar;
-
-  namespace Experimental {
-    using Kokkos::Sum;
-    using Kokkos::Prod;
-    using Kokkos::Min;
-    using Kokkos::Max;
-    using Kokkos::MinMax;
-    using Kokkos::MinLoc;
-    using Kokkos::MaxLoc;
-    using Kokkos::MinMaxLoc;
-    using Kokkos::BAnd;
-    using Kokkos::BOr;
-    using Kokkos::LAnd;
-    using Kokkos::LOr;
-    using Kokkos::MinMaxScalar;
-    using Kokkos::MinMaxLocScalar;
-    using Kokkos::ValLocScalar;
-  }
-}
+namespace Kokkos {
+template <class ScalarType>
+struct MinMaxScalar;
+template <class ScalarType, class Index>
+struct MinMaxLocScalar;
+template <class ScalarType, class Index>
+struct ValLocScalar;
+
+namespace Experimental {
+using Kokkos::BAnd;
+using Kokkos::BOr;
+using Kokkos::LAnd;
+using Kokkos::LOr;
+using Kokkos::Max;
+using Kokkos::MaxLoc;
+using Kokkos::Min;
+using Kokkos::MinLoc;
+using Kokkos::MinMax;
+using Kokkos::MinMaxLoc;
+using Kokkos::MinMaxLocScalar;
+using Kokkos::MinMaxScalar;
+using Kokkos::Prod;
+using Kokkos::Sum;
+using Kokkos::ValLocScalar;
+}  // namespace Experimental
+}  // namespace Kokkos
 #endif
 
 #endif /* #ifndef KOKKOS_CORE_FWD_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Crs.hpp b/lib/kokkos/core/src/Kokkos_Crs.hpp
index 8412ced9213d6c01dc2b6045446de5c8b8b6ec66..f57863263b6120ca2ef11bd6c4eddc80d29b79e1 100644
--- a/lib/kokkos/core/src/Kokkos_Crs.hpp
+++ b/lib/kokkos/core/src/Kokkos_Crs.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -76,26 +77,27 @@ namespace Kokkos {
 /// <li> <tt> entries( entry ,            i2 , i3 , ... ); </tt> </li>
 /// <li> <tt> entries( row_map[i0] + i1 , i2 , i3 , ... ); </tt> </li>
 /// </ul>
-template< class DataType,
-          class Arg1Type,
-          class Arg2Type = void,
-          typename SizeType = typename ViewTraits<DataType*, Arg1Type, Arg2Type, void >::size_type>
+template <class DataType, class Arg1Type, class Arg2Type = void,
+          typename SizeType = typename ViewTraits<DataType*, Arg1Type, Arg2Type,
+                                                  void>::size_type>
 class Crs {
-protected:
+ protected:
   typedef ViewTraits<DataType*, Arg1Type, Arg2Type, void> traits;
 
-public:
-  typedef DataType                                            data_type;
-  typedef typename traits::array_layout                       array_layout;
-  typedef typename traits::execution_space                    execution_space;
-  typedef typename traits::memory_space                       memory_space;
-  typedef typename traits::device_type                        device_type;
-  typedef SizeType                                            size_type;
-
-  typedef Crs< DataType , Arg1Type , Arg2Type , SizeType > staticcrsgraph_type;
-  typedef Crs< DataType , array_layout , typename traits::host_mirror_space , SizeType > HostMirror;
-  typedef View<size_type* , array_layout, device_type> row_map_type;
-  typedef View<DataType*  , array_layout, device_type> entries_type;
+ public:
+  typedef DataType data_type;
+  typedef typename traits::array_layout array_layout;
+  typedef typename traits::execution_space execution_space;
+  typedef typename traits::memory_space memory_space;
+  typedef typename traits::device_type device_type;
+  typedef SizeType size_type;
+
+  typedef Crs<DataType, Arg1Type, Arg2Type, SizeType> staticcrsgraph_type;
+  typedef Crs<DataType, array_layout, typename traits::host_mirror_space,
+              SizeType>
+      HostMirror;
+  typedef View<size_type*, array_layout, device_type> row_map_type;
+  typedef View<DataType*, array_layout, device_type> entries_type;
 
   row_map_type row_map;
   entries_type entries;
@@ -103,62 +105,49 @@ public:
   /*
    * Default Constructors, operators and destructor
    */
-  KOKKOS_FUNCTION Crs() = default;
-  KOKKOS_FUNCTION Crs(Crs const &) = default;
-  KOKKOS_FUNCTION Crs(Crs &&) = default;
-  KOKKOS_FUNCTION Crs& operator=(Crs const &) = default;
-  KOKKOS_FUNCTION Crs& operator=(Crs &&) = default;
-  KOKKOS_FUNCTION ~Crs() = default;
+  KOKKOS_FUNCTION Crs()           = default;
+  KOKKOS_FUNCTION Crs(Crs const&) = default;
+  KOKKOS_FUNCTION Crs(Crs&&)      = default;
+  KOKKOS_FUNCTION Crs& operator=(Crs const&) = default;
+  KOKKOS_FUNCTION Crs& operator=(Crs&&) = default;
+  KOKKOS_FUNCTION ~Crs()                = default;
 
   /** \brief Assign to a view of the rhs array.
    *         If the old view is the last view
    *         then allocated memory is deallocated.
    */
-  template<class EntriesType, class RowMapType>
-  KOKKOS_INLINE_FUNCTION
-  Crs(const RowMapType& row_map_, const EntriesType& entries_) 
-     : row_map(row_map_), entries(entries_)
-  {
-  }
+  template <class EntriesType, class RowMapType>
+  KOKKOS_INLINE_FUNCTION Crs(const RowMapType& row_map_,
+                             const EntriesType& entries_)
+      : row_map(row_map_), entries(entries_) {}
 
   /**  \brief  Return number of rows in the graph
    */
   KOKKOS_INLINE_FUNCTION
   size_type numRows() const {
-    return (row_map.extent(0) != 0) ?
-      row_map.extent(0) - static_cast<size_type> (1) :
-      static_cast<size_type> (0);
+    return (row_map.extent(0) != 0)
+               ? row_map.extent(0) - static_cast<size_type>(1)
+               : static_cast<size_type>(0);
   }
 };
 
 /*--------------------------------------------------------------------------*/
 
-template< class OutCounts,
-          class DataType,
-          class Arg1Type,
-          class Arg2Type,
+template <class OutCounts, class DataType, class Arg1Type, class Arg2Type,
           class SizeType>
 void get_crs_transpose_counts(
-    OutCounts& out,
-    Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in,
+    OutCounts& out, Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in,
     std::string const& name = "transpose_counts");
 
-template< class OutCounts,
-          class InCrs>
+template <class OutCounts, class InCrs>
 typename OutCounts::value_type get_crs_row_map_from_counts(
-    OutCounts& out,
-    InCrs const& in,
-    std::string const& name = "row_map");
+    OutCounts& out, InCrs const& in, std::string const& name = "row_map");
 
-template< class DataType,
-          class Arg1Type,
-          class Arg2Type,
-          class SizeType>
-void transpose_crs(
-    Crs<DataType, Arg1Type, Arg2Type, SizeType>& out,
-    Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in);
+template <class DataType, class Arg1Type, class Arg2Type, class SizeType>
+void transpose_crs(Crs<DataType, Arg1Type, Arg2Type, SizeType>& out,
+                   Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in);
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -171,21 +160,22 @@ template <class InCrs, class OutCounts>
 class GetCrsTransposeCounts {
  public:
   using execution_space = typename InCrs::execution_space;
-  using self_type = GetCrsTransposeCounts<InCrs, OutCounts>;
-  using index_type = typename InCrs::size_type;
+  using self_type       = GetCrsTransposeCounts<InCrs, OutCounts>;
+  using index_type      = typename InCrs::size_type;
+
  private:
   InCrs in;
   OutCounts out;
+
  public:
   KOKKOS_INLINE_FUNCTION
-  void operator()(index_type i) const {
-    atomic_increment( &out[in.entries(i)] );
-  }
-  GetCrsTransposeCounts(InCrs const& arg_in, OutCounts const& arg_out):
-    in(arg_in),out(arg_out) {
-    using policy_type = RangePolicy<index_type, execution_space>;
+  void operator()(index_type i) const { atomic_increment(&out[in.entries(i)]); }
+  GetCrsTransposeCounts(InCrs const& arg_in, OutCounts const& arg_out)
+      : in(arg_in), out(arg_out) {
+    using policy_type  = RangePolicy<index_type, execution_space>;
     using closure_type = Kokkos::Impl::ParallelFor<self_type, policy_type>;
-    const closure_type closure(*this, policy_type(0, index_type(in.entries.size())));
+    const closure_type closure(*this,
+                               policy_type(0, index_type(in.entries.size())));
     closure.execute();
     execution_space().fence();
   }
@@ -195,13 +185,15 @@ template <class InCounts, class OutRowMap>
 class CrsRowMapFromCounts {
  public:
   using execution_space = typename InCounts::execution_space;
-  using value_type = typename OutRowMap::value_type;
-  using index_type = typename InCounts::size_type;
+  using value_type      = typename OutRowMap::value_type;
+  using index_type      = typename InCounts::size_type;
   using last_value_type = Kokkos::View<value_type, execution_space>;
+
  private:
   InCounts m_in;
   OutRowMap m_out;
   last_value_type m_last_value;
+
  public:
   KOKKOS_INLINE_FUNCTION
   void operator()(index_type i, value_type& update, bool final_pass) const {
@@ -209,22 +201,22 @@ class CrsRowMapFromCounts {
       update += m_in(i);
       if (final_pass) m_out(i + 1) = update;
     } else if (final_pass) {
-      m_out(0) = 0;
+      m_out(0)       = 0;
       m_last_value() = update;
     }
   }
   KOKKOS_INLINE_FUNCTION
   void init(value_type& update) const { update = 0; }
   KOKKOS_INLINE_FUNCTION
-  void join(volatile value_type& update, const volatile value_type& input) const {
+  void join(volatile value_type& update,
+            const volatile value_type& input) const {
     update += input;
   }
   using self_type = CrsRowMapFromCounts<InCounts, OutRowMap>;
-  CrsRowMapFromCounts(InCounts const& arg_in, OutRowMap const& arg_out):
-    m_in(arg_in), m_out(arg_out), m_last_value("last_value") {
-  }
+  CrsRowMapFromCounts(InCounts const& arg_in, OutRowMap const& arg_out)
+      : m_in(arg_in), m_out(arg_out), m_last_value("last_value") {}
   value_type execute() {
-    using policy_type = RangePolicy<index_type, execution_space>;
+    using policy_type  = RangePolicy<index_type, execution_space>;
     using closure_type = Kokkos::Impl::ParallelScan<self_type, policy_type>;
     closure_type closure(*this, policy_type(0, m_in.size() + 1));
     closure.execute();
@@ -238,31 +230,32 @@ template <class InCrs, class OutCrs>
 class FillCrsTransposeEntries {
  public:
   using execution_space = typename InCrs::execution_space;
-  using memory_space = typename InCrs::memory_space;
-  using value_type = typename OutCrs::entries_type::value_type;
-  using index_type = typename InCrs::size_type;
+  using memory_space    = typename InCrs::memory_space;
+  using value_type      = typename OutCrs::entries_type::value_type;
+  using index_type      = typename InCrs::size_type;
+
  private:
   using counters_type = View<index_type*, memory_space>;
   InCrs in;
   OutCrs out;
   counters_type counters;
+
  public:
   KOKKOS_INLINE_FUNCTION
   void operator()(index_type i) const {
     auto begin = in.row_map(i);
-    auto end = in.row_map(i + 1);
+    auto end   = in.row_map(i + 1);
     for (auto j = begin; j < end; ++j) {
-      auto ti = in.entries(j);
-      auto tbegin = out.row_map(ti);
-      auto tj = atomic_fetch_add( &counters(ti), 1 );
-      out.entries( tbegin + tj ) = i;
+      auto ti                  = in.entries(j);
+      auto tbegin              = out.row_map(ti);
+      auto tj                  = atomic_fetch_add(&counters(ti), 1);
+      out.entries(tbegin + tj) = i;
     }
   }
   using self_type = FillCrsTransposeEntries<InCrs, OutCrs>;
-  FillCrsTransposeEntries(InCrs const& arg_in, OutCrs const& arg_out):
-    in(arg_in),out(arg_out),
-    counters("counters", arg_out.numRows()) {
-    using policy_type = RangePolicy<index_type, execution_space>;
+  FillCrsTransposeEntries(InCrs const& arg_in, OutCrs const& arg_out)
+      : in(arg_in), out(arg_out), counters("counters", arg_out.numRows()) {
+    using policy_type  = RangePolicy<index_type, execution_space>;
     using closure_type = Kokkos::Impl::ParallelFor<self_type, policy_type>;
     const closure_type closure(*this, policy_type(0, index_type(in.numRows())));
     closure.execute();
@@ -270,7 +263,8 @@ class FillCrsTransposeEntries {
   }
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -278,66 +272,51 @@ class FillCrsTransposeEntries {
 
 namespace Kokkos {
 
-template< class OutCounts,
-          class DataType,
-          class Arg1Type,
-          class Arg2Type,
+template <class OutCounts, class DataType, class Arg1Type, class Arg2Type,
           class SizeType>
 void get_crs_transpose_counts(
-    OutCounts& out,
-    Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in,
+    OutCounts& out, Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in,
     std::string const& name) {
   using InCrs = Crs<DataType, Arg1Type, Arg2Type, SizeType>;
-  out = OutCounts(name, in.numRows());
+  out         = OutCounts(name, in.numRows());
   Kokkos::Impl::GetCrsTransposeCounts<InCrs, OutCounts> functor(in, out);
 }
 
-template< class OutRowMap,
-          class InCounts>
+template <class OutRowMap, class InCounts>
 typename OutRowMap::value_type get_crs_row_map_from_counts(
-    OutRowMap& out,
-    InCounts const& in,
-    std::string const& name) {
+    OutRowMap& out, InCounts const& in, std::string const& name) {
   out = OutRowMap(ViewAllocateWithoutInitializing(name), in.size() + 1);
   Kokkos::Impl::CrsRowMapFromCounts<InCounts, OutRowMap> functor(in, out);
   return functor.execute();
 }
 
-template< class DataType,
-          class Arg1Type,
-          class Arg2Type,
-          class SizeType>
-void transpose_crs(
-    Crs<DataType, Arg1Type, Arg2Type, SizeType>& out,
-    Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in)
-{
-  typedef Crs<DataType, Arg1Type, Arg2Type, SizeType> crs_type ;
-  typedef typename crs_type::memory_space             memory_space ;
-  typedef View<SizeType*, memory_space>               counts_type ;
+template <class DataType, class Arg1Type, class Arg2Type, class SizeType>
+void transpose_crs(Crs<DataType, Arg1Type, Arg2Type, SizeType>& out,
+                   Crs<DataType, Arg1Type, Arg2Type, SizeType> const& in) {
+  typedef Crs<DataType, Arg1Type, Arg2Type, SizeType> crs_type;
+  typedef typename crs_type::memory_space memory_space;
+  typedef View<SizeType*, memory_space> counts_type;
   {
-  counts_type counts;
-  Kokkos::get_crs_transpose_counts(counts, in);
-  Kokkos::get_crs_row_map_from_counts(out.row_map, counts,
-      "tranpose_row_map");
+    counts_type counts;
+    Kokkos::get_crs_transpose_counts(counts, in);
+    Kokkos::get_crs_row_map_from_counts(out.row_map, counts,
+                                        "tranpose_row_map");
   }
   out.entries = decltype(out.entries)("transpose_entries", in.entries.size());
-  Kokkos::Impl::
-    FillCrsTransposeEntries<crs_type, crs_type> entries_functor(in, out);
+  Kokkos::Impl::FillCrsTransposeEntries<crs_type, crs_type> entries_functor(
+      in, out);
 }
 
-template< class CrsType,
-          class Functor,
+template <class CrsType, class Functor,
           class ExecutionSpace = typename CrsType::execution_space>
 struct CountAndFillBase;
 
-template< class CrsType,
-          class Functor,
-          class ExecutionSpace>
+template <class CrsType, class Functor, class ExecutionSpace>
 struct CountAndFillBase {
-  using data_type = typename CrsType::size_type;
-  using size_type = typename CrsType::size_type;
+  using data_type    = typename CrsType::size_type;
+  using size_type    = typename CrsType::size_type;
   using row_map_type = typename CrsType::row_map_type;
-  using counts_type = row_map_type;
+  using counts_type  = row_map_type;
   CrsType m_crs;
   Functor m_functor;
   counts_type m_counts;
@@ -348,30 +327,26 @@ struct CountAndFillBase {
   struct Fill {};
   inline void operator()(Fill, size_type i) const {
     auto j = m_crs.row_map(i);
-    /* we don't want to access entries(entries.size()), even if its just to get its
-       address and never use it.
-       this can happen when row (i) is empty and all rows after it are also empty.
-       we could compare to row_map(i + 1), but that is a read from global memory,
-       whereas dimension_0() should be part of the View in registers (or constant memory) */
-    data_type* fill =
-      (j == static_cast<decltype(j)>(m_crs.entries.extent(0))) ?
-      nullptr : (&(m_crs.entries(j)));
+    /* we don't want to access entries(entries.size()), even if its just to get
+       its address and never use it. this can happen when row (i) is empty and
+       all rows after it are also empty. we could compare to row_map(i + 1), but
+       that is a read from global memory, whereas dimension_0() should be part
+       of the View in registers (or constant memory) */
+    data_type* fill = (j == static_cast<decltype(j)>(m_crs.entries.extent(0)))
+                          ? nullptr
+                          : (&(m_crs.entries(j)));
     m_functor(i, fill);
   }
-  CountAndFillBase(CrsType& crs, Functor const& f):
-    m_crs(crs),
-    m_functor(f)
-  {}
+  CountAndFillBase(CrsType& crs, Functor const& f) : m_crs(crs), m_functor(f) {}
 };
 
-#if defined( KOKKOS_ENABLE_CUDA )
-template< class CrsType,
-          class Functor>
+#if defined(KOKKOS_ENABLE_CUDA)
+template <class CrsType, class Functor>
 struct CountAndFillBase<CrsType, Functor, Kokkos::Cuda> {
-  using data_type = typename CrsType::size_type;
-  using size_type = typename CrsType::size_type;
+  using data_type    = typename CrsType::size_type;
+  using size_type    = typename CrsType::size_type;
   using row_map_type = typename CrsType::row_map_type;
-  using counts_type = row_map_type;
+  using counts_type  = row_map_type;
   CrsType m_crs;
   Functor m_functor;
   counts_type m_counts;
@@ -382,70 +357,62 @@ struct CountAndFillBase<CrsType, Functor, Kokkos::Cuda> {
   struct Fill {};
   __device__ inline void operator()(Fill, size_type i) const {
     auto j = m_crs.row_map(i);
-    /* we don't want to access entries(entries.size()), even if its just to get its
-       address and never use it.
-       this can happen when row (i) is empty and all rows after it are also empty.
-       we could compare to row_map(i + 1), but that is a read from global memory,
-       whereas dimension_0() should be part of the View in registers (or constant memory) */
-    data_type* fill =
-      (j == static_cast<decltype(j)>(m_crs.entries.extent(0))) ?
-      nullptr : (&(m_crs.entries(j)));
+    /* we don't want to access entries(entries.size()), even if its just to get
+       its address and never use it. this can happen when row (i) is empty and
+       all rows after it are also empty. we could compare to row_map(i + 1), but
+       that is a read from global memory, whereas dimension_0() should be part
+       of the View in registers (or constant memory) */
+    data_type* fill = (j == static_cast<decltype(j)>(m_crs.entries.extent(0)))
+                          ? nullptr
+                          : (&(m_crs.entries(j)));
     m_functor(i, fill);
   }
-  CountAndFillBase(CrsType& crs, Functor const& f):
-    m_crs(crs),
-    m_functor(f)
-  {}
+  CountAndFillBase(CrsType& crs, Functor const& f) : m_crs(crs), m_functor(f) {}
 };
 #endif
 
-template< class CrsType,
-          class Functor>
+template <class CrsType, class Functor>
 struct CountAndFill : public CountAndFillBase<CrsType, Functor> {
   using base_type = CountAndFillBase<CrsType, Functor>;
-  using typename base_type::data_type;
-  using typename base_type::size_type;
-  using typename base_type::counts_type;
   using typename base_type::Count;
+  using typename base_type::counts_type;
+  using typename base_type::data_type;
   using typename base_type::Fill;
+  using typename base_type::size_type;
   using entries_type = typename CrsType::entries_type;
-  using self_type = CountAndFill<CrsType, Functor>;
-  CountAndFill(CrsType& crs, size_type nrows, Functor const& f):
-    base_type(crs, f)
-  {
+  using self_type    = CountAndFill<CrsType, Functor>;
+  CountAndFill(CrsType& crs, size_type nrows, Functor const& f)
+      : base_type(crs, f) {
     using execution_space = typename CrsType::execution_space;
-    this->m_counts = counts_type("counts", nrows);
+    this->m_counts        = counts_type("counts", nrows);
     {
-    using count_policy_type = RangePolicy<size_type, execution_space, Count>;
-    using count_closure_type =
-      Kokkos::Impl::ParallelFor<self_type, count_policy_type>;
-    const count_closure_type closure(*this, count_policy_type(0, nrows));
-    closure.execute();
+      using count_policy_type = RangePolicy<size_type, execution_space, Count>;
+      using count_closure_type =
+          Kokkos::Impl::ParallelFor<self_type, count_policy_type>;
+      const count_closure_type closure(*this, count_policy_type(0, nrows));
+      closure.execute();
     }
-    auto nentries = Kokkos::
-      get_crs_row_map_from_counts(this->m_crs.row_map, this->m_counts);
+    auto nentries  = Kokkos::get_crs_row_map_from_counts(this->m_crs.row_map,
+                                                        this->m_counts);
     this->m_counts = counts_type();
     this->m_crs.entries = entries_type("entries", nentries);
     {
-    using fill_policy_type = RangePolicy<size_type, execution_space, Fill>;
-    using fill_closure_type =
-      Kokkos::Impl::ParallelFor<self_type, fill_policy_type>;
-    const fill_closure_type closure(*this, fill_policy_type(0, nrows));
-    closure.execute();
+      using fill_policy_type = RangePolicy<size_type, execution_space, Fill>;
+      using fill_closure_type =
+          Kokkos::Impl::ParallelFor<self_type, fill_policy_type>;
+      const fill_closure_type closure(*this, fill_policy_type(0, nrows));
+      closure.execute();
     }
     crs = this->m_crs;
   }
 };
 
-template< class CrsType,
-          class Functor>
-void count_and_fill_crs(
-    CrsType& crs,
-    typename CrsType::size_type nrows,
-    Functor const& f) {
+template <class CrsType, class Functor>
+void count_and_fill_crs(CrsType& crs, typename CrsType::size_type nrows,
+                        Functor const& f) {
   Kokkos::CountAndFill<CrsType, Functor>(crs, nrows, f);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif /* #define KOKKOS_CRS_HPP */
diff --git a/lib/kokkos/core/src/Kokkos_Cuda.hpp b/lib/kokkos/core/src/Kokkos_Cuda.hpp
index 4eb8ab4d4bae25e43c217d97812727592da8373f..ad62ecf38357c2a8de9d2e99fb52f73ea0e770f3 100644
--- a/lib/kokkos/core/src/Kokkos_Cuda.hpp
+++ b/lib/kokkos/core/src/Kokkos_Cuda.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_CUDA_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 
 #include <Kokkos_Core_fwd.hpp>
 
@@ -62,37 +63,45 @@
 #include <Kokkos_MemoryTraits.hpp>
 #include <impl/Kokkos_Tags.hpp>
 
-
 /*--------------------------------------------------------------------------*/
 
 namespace Kokkos {
 namespace Impl {
-class CudaExec ;
-class CudaInternal ;
-} // namespace Impl
-} // namespace Kokkos
+class CudaExec;
+class CudaInternal;
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
 namespace Kokkos {
 
 namespace Impl {
-  namespace Experimental {
-    enum class CudaLaunchMechanism:unsigned{Default=0,ConstantMemory=1,GlobalMemory=2,LocalMemory=4};
-
-    constexpr inline CudaLaunchMechanism operator | (CudaLaunchMechanism p1, CudaLaunchMechanism p2) {
-      return static_cast<CudaLaunchMechanism>(static_cast<unsigned>(p1) |  static_cast<unsigned>(p2));
-    }
-    constexpr inline CudaLaunchMechanism operator & (CudaLaunchMechanism p1, CudaLaunchMechanism p2) {
-      return static_cast<CudaLaunchMechanism>(static_cast<unsigned>(p1) &  static_cast<unsigned>(p2));
-    }
-
-    template<CudaLaunchMechanism l>
-    struct CudaDispatchProperties {
-      CudaLaunchMechanism launch_mechanism = l;
-    };
-  }
+namespace Experimental {
+enum class CudaLaunchMechanism : unsigned {
+  Default        = 0,
+  ConstantMemory = 1,
+  GlobalMemory   = 2,
+  LocalMemory    = 4
+};
+
+constexpr inline CudaLaunchMechanism operator|(CudaLaunchMechanism p1,
+                                               CudaLaunchMechanism p2) {
+  return static_cast<CudaLaunchMechanism>(static_cast<unsigned>(p1) |
+                                          static_cast<unsigned>(p2));
 }
+constexpr inline CudaLaunchMechanism operator&(CudaLaunchMechanism p1,
+                                               CudaLaunchMechanism p2) {
+  return static_cast<CudaLaunchMechanism>(static_cast<unsigned>(p1) &
+                                          static_cast<unsigned>(p2));
+}
+
+template <CudaLaunchMechanism l>
+struct CudaDispatchProperties {
+  CudaLaunchMechanism launch_mechanism = l;
+};
+}  // namespace Experimental
+}  // namespace Impl
 /// \class Cuda
 /// \brief Kokkos Execution Space that uses CUDA to run on GPUs.
 ///
@@ -104,32 +113,32 @@ namespace Impl {
 /// sequentially.  The Cuda execution space uses NVIDIA's CUDA programming
 /// model to execute kernels in parallel on GPUs.
 class Cuda {
-public:
+ public:
   //! \name Type declarations that all Kokkos execution spaces must provide.
   //@{
 
   //! Tag this class as a kokkos execution space
-  typedef Cuda                  execution_space ;
+  typedef Cuda execution_space;
 
-#if defined( KOKKOS_ENABLE_CUDA_UVM )
+#if defined(KOKKOS_ENABLE_CUDA_UVM)
   //! This execution space's preferred memory space.
-  typedef CudaUVMSpace          memory_space ;
+  typedef CudaUVMSpace memory_space;
 #else
   //! This execution space's preferred memory space.
-  typedef CudaSpace             memory_space ;
+  typedef CudaSpace memory_space;
 #endif
 
   //! This execution space preferred device_type
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
   //! The size_type best suited for this execution space.
-  typedef memory_space::size_type  size_type ;
+  typedef memory_space::size_type size_type;
 
   //! This execution space's preferred array layout.
-  typedef LayoutLeft            array_layout ;
+  typedef LayoutLeft array_layout;
 
   //!
-  typedef ScratchMemorySpace< Cuda >  scratch_memory_space ;
+  typedef ScratchMemorySpace<Cuda> scratch_memory_space;
 
   //@}
   //--------------------------------------------------
@@ -139,7 +148,7 @@ public:
   /// \brief True if and only if this method is being called in a
   ///   thread-parallel function.
   KOKKOS_INLINE_FUNCTION static int in_parallel() {
-#if defined( __CUDA_ARCH__ )
+#if defined(__CUDA_ARCH__)
     return true;
 #else
     return false;
@@ -174,17 +183,17 @@ public:
   /// device have completed.
   static void impl_static_fence();
 
-  #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   static void fence();
-  #else
+#else
   void fence() const;
-  #endif
+#endif
 
   /** \brief  Return the maximum amount of concurrency.  */
   static int concurrency();
 
   //! Print configuration information to the given output stream.
-  static void print_configuration( std::ostream & , const bool detail = false );
+  static void print_configuration(std::ostream&, const bool detail = false);
 
   //@}
   //--------------------------------------------------
@@ -195,10 +204,10 @@ public:
 
   Cuda();
 
-  Cuda( Cuda && ) = default ;
-  Cuda( const Cuda & ) = default ;
-  Cuda & operator = ( Cuda && ) = default ;
-  Cuda & operator = ( const Cuda & ) = default ;
+  Cuda(Cuda&&)      = default;
+  Cuda(const Cuda&) = default;
+  Cuda& operator=(Cuda&&) = default;
+  Cuda& operator=(const Cuda&) = default;
 
   Cuda(cudaStream_t stream);
 
@@ -207,9 +216,9 @@ public:
   //@{
 
   struct SelectDevice {
-    int cuda_device_id ;
+    int cuda_device_id;
     SelectDevice() : cuda_device_id(0) {}
-    explicit SelectDevice( int id ) : cuda_device_id( id ) {}
+    explicit SelectDevice(int id) : cuda_device_id(id) {}
   };
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
@@ -220,8 +229,8 @@ public:
   static int is_initialized();
 
   //! Initialize, telling the CUDA run-time library which device to use.
-  static void initialize( const SelectDevice = SelectDevice()
-                        , const size_t num_instances = 1 );
+  static void initialize(const SelectDevice         = SelectDevice(),
+                         const size_t num_instances = 1);
 #else
   //! Free any resources being consumed by the device.
   static void impl_finalize();
@@ -230,8 +239,8 @@ public:
   static int impl_is_initialized();
 
   //! Initialize, telling the CUDA run-time library which device to use.
-  static void impl_initialize( const SelectDevice = SelectDevice()
-                        , const size_t num_instances = 1 );
+  static void impl_initialize(const SelectDevice         = SelectDevice(),
+                              const size_t num_instances = 1);
 #endif
 
   /// \brief Cuda device architecture of the selected device.
@@ -248,20 +257,22 @@ public:
   static std::vector<unsigned> detect_device_arch();
 
   cudaStream_t cuda_stream() const;
-  int          cuda_device() const;
+  int cuda_device() const;
 
   //@}
   //--------------------------------------------------------------------------
 
   static const char* name();
 
-  inline Impl::CudaInternal* impl_internal_space_instance() const { return m_space_instance; }
-private:
+  inline Impl::CudaInternal* impl_internal_space_instance() const {
+    return m_space_instance;
+  }
 
+ private:
   Impl::CudaInternal* m_space_instance;
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -269,18 +280,15 @@ private:
 namespace Kokkos {
 namespace Impl {
 
-template<>
-struct MemorySpaceAccess
-  < Kokkos::CudaSpace
-  , Kokkos::Cuda::scratch_memory_space
-  >
-{
+template <>
+struct MemorySpaceAccess<Kokkos::CudaSpace,
+                         Kokkos::Cuda::scratch_memory_space> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = false };
+  enum { deepcopy = false };
 };
 
-#if defined( KOKKOS_ENABLE_CUDA_UVM )
+#if defined(KOKKOS_ENABLE_CUDA_UVM)
 
 // If forcing use of UVM everywhere
 // then must assume that CudaUVMSpace
@@ -288,44 +296,34 @@ struct MemorySpaceAccess
 // This will fail when a strange host-side execution space
 // that defines CudaUVMSpace as its preferredmemory space.
 
-template<>
-struct MemorySpaceAccess
-  < Kokkos::CudaUVMSpace
-  , Kokkos::Cuda::scratch_memory_space
-  >
-{
+template <>
+struct MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                         Kokkos::Cuda::scratch_memory_space> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = false };
+  enum { deepcopy = false };
 };
 
 #endif
 
-
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::CudaSpace
-  , Kokkos::Cuda::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::CudaSpace,
+                                           Kokkos::Cuda::scratch_memory_space> {
   enum { value = true };
-  KOKKOS_INLINE_FUNCTION static void verify( void ) { }
-  KOKKOS_INLINE_FUNCTION static void verify( const void * ) { }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {}
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {}
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::HostSpace
-  , Kokkos::Cuda::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::HostSpace,
+                                           Kokkos::Cuda::scratch_memory_space> {
   enum { value = false };
-  inline static void verify( void ) { CudaSpace::access_error(); }
-  inline static void verify( const void * p ) { CudaSpace::access_error(p); }
+  inline static void verify(void) { CudaSpace::access_error(); }
+  inline static void verify(const void* p) { CudaSpace::access_error(p); }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -343,4 +341,3 @@ struct VerifyExecutionCanAccessMemorySpace
 
 #endif /* #if defined( KOKKOS_ENABLE_CUDA ) */
 #endif /* #ifndef KOKKOS_CUDA_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_CudaSpace.hpp b/lib/kokkos/core/src/Kokkos_CudaSpace.hpp
index 4b32811bfc32c6ee28646ee3d79646760d3369e3..34db47f1c0096aac753b2f9b3c9af66740377bf6 100644
--- a/lib/kokkos/core/src/Kokkos_CudaSpace.hpp
+++ b/lib/kokkos/core/src/Kokkos_CudaSpace.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_CUDASPACE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 
 #include <Kokkos_Core_fwd.hpp>
 
@@ -57,6 +58,11 @@
 
 #include <Cuda/Kokkos_Cuda_abort.hpp>
 
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+extern "C" bool kokkos_impl_cuda_pin_uvm_to_host();
+extern "C" void kokkos_impl_cuda_set_pin_uvm_to_host(bool);
+#endif
+
 /*--------------------------------------------------------------------------*/
 
 namespace Kokkos {
@@ -64,30 +70,28 @@ namespace Kokkos {
 /** \brief  Cuda on-device memory management */
 
 class CudaSpace {
-public:
-
+ public:
   //! Tag this class as a kokkos memory space
-  typedef CudaSpace             memory_space ;
-  typedef Kokkos::Cuda          execution_space ;
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef CudaSpace memory_space;
+  typedef Kokkos::Cuda execution_space;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
-  typedef unsigned int          size_type ;
+  typedef unsigned int size_type;
 
   /*--------------------------------*/
 
   CudaSpace();
-  CudaSpace( CudaSpace && rhs ) = default ;
-  CudaSpace( const CudaSpace & rhs ) = default ;
-  CudaSpace & operator = ( CudaSpace && rhs ) = default ;
-  CudaSpace & operator = ( const CudaSpace & rhs ) = default ;
-  ~CudaSpace() = default ;
+  CudaSpace(CudaSpace&& rhs)      = default;
+  CudaSpace(const CudaSpace& rhs) = default;
+  CudaSpace& operator=(CudaSpace&& rhs) = default;
+  CudaSpace& operator=(const CudaSpace& rhs) = default;
+  ~CudaSpace()                               = default;
 
   /**\brief  Allocate untracked memory in the cuda space */
-  void * allocate( const size_t arg_alloc_size ) const ;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the cuda space */
-  void deallocate( void * const arg_alloc_ptr
-                 , const size_t arg_alloc_size ) const ;
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return m_name; }
@@ -95,14 +99,13 @@ public:
   /*--------------------------------*/
   /** \brief  Error reporting for HostSpace attempt to access CudaSpace */
   static void access_error();
-  static void access_error( const void * const );
-
-private:
+  static void access_error(const void* const);
 
-  int  m_device ; ///< Which Cuda device
+ private:
+  int m_device;  ///< Which Cuda device
 
   static constexpr const char* m_name = "Cuda";
-  friend class Kokkos::Impl::SharedAllocationRecord< Kokkos::CudaSpace , void > ;
+  friend class Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>;
 };
 
 namespace Impl {
@@ -123,7 +126,8 @@ void init_lock_arrays_cuda_space();
 /// If the array is not yet allocated it will do so.
 int* atomic_lock_array_cuda_space_ptr(bool deallocate = false);
 
-/// \brief Retrieve the pointer to the scratch array for team and thread private global memory.
+/// \brief Retrieve the pointer to the scratch array for team and thread private
+/// global memory.
 ///
 /// Team and Thread private scratch allocations in
 /// global memory are acquired via locks.
@@ -138,8 +142,8 @@ int* scratch_lock_array_cuda_space_ptr(bool deallocate = false);
 /// This function retrieves the lock array pointer.
 /// If the array is not yet allocated it will do so.
 int* threadid_lock_array_cuda_space_ptr(bool deallocate = false);
-}
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -150,54 +154,56 @@ namespace Kokkos {
  *          through Cuda's unified virtual memory (UVM) runtime.
  */
 class CudaUVMSpace {
-public:
-
+ public:
   //! Tag this class as a kokkos memory space
-  typedef CudaUVMSpace          memory_space ;
-  typedef Cuda                  execution_space ;
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
-  typedef unsigned int          size_type ;
+  typedef CudaUVMSpace memory_space;
+  typedef Cuda execution_space;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
+  typedef unsigned int size_type;
 
   /** \brief  If UVM capability is available */
   static bool available();
 
-
   /*--------------------------------*/
   /** \brief  CudaUVMSpace specific routine */
   static int number_of_allocations();
 
   /*--------------------------------*/
 
-
   /*--------------------------------*/
 
   CudaUVMSpace();
-  CudaUVMSpace( CudaUVMSpace && rhs ) = default ;
-  CudaUVMSpace( const CudaUVMSpace & rhs ) = default ;
-  CudaUVMSpace & operator = ( CudaUVMSpace && rhs ) = default ;
-  CudaUVMSpace & operator = ( const CudaUVMSpace & rhs ) = default ;
-  ~CudaUVMSpace() = default ;
+  CudaUVMSpace(CudaUVMSpace&& rhs)      = default;
+  CudaUVMSpace(const CudaUVMSpace& rhs) = default;
+  CudaUVMSpace& operator=(CudaUVMSpace&& rhs) = default;
+  CudaUVMSpace& operator=(const CudaUVMSpace& rhs) = default;
+  ~CudaUVMSpace()                                  = default;
 
   /**\brief  Allocate untracked memory in the cuda space */
-  void * allocate( const size_t arg_alloc_size ) const ;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the cuda space */
-  void deallocate( void * const arg_alloc_ptr
-                 , const size_t arg_alloc_size ) const ;
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return m_name; }
 
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+  static bool cuda_pin_uvm_to_host();
+  static void cuda_set_pin_uvm_to_host(bool val);
+#endif
   /*--------------------------------*/
 
-private:
-  int  m_device ; ///< Which Cuda device
+ private:
+  int m_device;  ///< Which Cuda device
 
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+  static bool kokkos_impl_cuda_pin_uvm_to_host_v;
+#endif
   static constexpr const char* m_name = "CudaUVM";
-
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -208,42 +214,39 @@ namespace Kokkos {
  *          through Cuda's host-pinned memory allocation.
  */
 class CudaHostPinnedSpace {
-public:
-
+ public:
   //! Tag this class as a kokkos memory space
   /** \brief  Memory is in HostSpace so use the HostSpace::execution_space */
-  typedef HostSpace::execution_space  execution_space ;
-  typedef CudaHostPinnedSpace         memory_space ;
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
-  typedef unsigned int                size_type ;
+  typedef HostSpace::execution_space execution_space;
+  typedef CudaHostPinnedSpace memory_space;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
+  typedef unsigned int size_type;
 
   /*--------------------------------*/
 
   CudaHostPinnedSpace();
-  CudaHostPinnedSpace( CudaHostPinnedSpace && rhs ) = default ;
-  CudaHostPinnedSpace( const CudaHostPinnedSpace & rhs ) = default ;
-  CudaHostPinnedSpace & operator = ( CudaHostPinnedSpace && rhs ) = default ;
-  CudaHostPinnedSpace & operator = ( const CudaHostPinnedSpace & rhs ) = default ;
-  ~CudaHostPinnedSpace() = default ;
+  CudaHostPinnedSpace(CudaHostPinnedSpace&& rhs)      = default;
+  CudaHostPinnedSpace(const CudaHostPinnedSpace& rhs) = default;
+  CudaHostPinnedSpace& operator=(CudaHostPinnedSpace&& rhs) = default;
+  CudaHostPinnedSpace& operator=(const CudaHostPinnedSpace& rhs) = default;
+  ~CudaHostPinnedSpace()                                         = default;
 
   /**\brief  Allocate untracked memory in the space */
-  void * allocate( const size_t arg_alloc_size ) const ;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the space */
-  void deallocate( void * const arg_alloc_ptr
-                 , const size_t arg_alloc_size ) const ;
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return m_name; }
 
-private:
-
+ private:
   static constexpr const char* m_name = "CudaHostPinned";
 
   /*--------------------------------*/
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -251,119 +254,126 @@ private:
 namespace Kokkos {
 namespace Impl {
 
-static_assert( Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaSpace , Kokkos::CudaSpace >::assignable , "" );
-static_assert( Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace , Kokkos::CudaUVMSpace >::assignable , "" );
-static_assert( Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace , Kokkos::CudaHostPinnedSpace >::assignable , "" );
+static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                              Kokkos::CudaSpace>::assignable,
+              "");
+static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                              Kokkos::CudaUVMSpace>::assignable,
+              "");
+static_assert(
+    Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                    Kokkos::CudaHostPinnedSpace>::assignable,
+    "");
 
 //----------------------------------------
 
-template<>
-struct MemorySpaceAccess< Kokkos::HostSpace , Kokkos::CudaSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::HostSpace, Kokkos::CudaSpace> {
   enum { assignable = false };
   enum { accessible = false };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::HostSpace , Kokkos::CudaUVMSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::HostSpace, Kokkos::CudaUVMSpace> {
   // HostSpace::execution_space != CudaUVMSpace::execution_space
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::HostSpace , Kokkos::CudaHostPinnedSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::HostSpace, Kokkos::CudaHostPinnedSpace> {
   // HostSpace::execution_space == CudaHostPinnedSpace::execution_space
   enum { assignable = true };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
 //----------------------------------------
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaSpace , Kokkos::HostSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::CudaSpace, Kokkos::HostSpace> {
   enum { assignable = false };
   enum { accessible = false };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaSpace , Kokkos::CudaUVMSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::CudaSpace, Kokkos::CudaUVMSpace> {
   // CudaSpace::execution_space == CudaUVMSpace::execution_space
   enum { assignable = true };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaSpace , Kokkos::CudaHostPinnedSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::CudaSpace, Kokkos::CudaHostPinnedSpace> {
   // CudaSpace::execution_space != CudaHostPinnedSpace::execution_space
   enum { assignable = false };
-  enum { accessible = true }; // CudaSpace::execution_space
-  enum { deepcopy   = true };
+  enum { accessible = true };  // CudaSpace::execution_space
+  enum { deepcopy = true };
 };
 
 //----------------------------------------
 // CudaUVMSpace::execution_space == Cuda
 // CudaUVMSpace accessible to both Cuda and Host
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaUVMSpace , Kokkos::HostSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::CudaUVMSpace, Kokkos::HostSpace> {
   enum { assignable = false };
-  enum { accessible = false }; // Cuda cannot access HostSpace
-  enum { deepcopy   = true };
+  enum { accessible = false };  // Cuda cannot access HostSpace
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaUVMSpace , Kokkos::CudaSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::CudaUVMSpace, Kokkos::CudaSpace> {
   // CudaUVMSpace::execution_space == CudaSpace::execution_space
   // Can access CudaUVMSpace from Host but cannot access CudaSpace from Host
   enum { assignable = false };
 
   // CudaUVMSpace::execution_space can access CudaSpace
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaUVMSpace , Kokkos::CudaHostPinnedSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::CudaUVMSpace, Kokkos::CudaHostPinnedSpace> {
   // CudaUVMSpace::execution_space != CudaHostPinnedSpace::execution_space
   enum { assignable = false };
-  enum { accessible = true }; // CudaUVMSpace::execution_space
-  enum { deepcopy   = true };
+  enum { accessible = true };  // CudaUVMSpace::execution_space
+  enum { deepcopy = true };
 };
 
-
 //----------------------------------------
 // CudaHostPinnedSpace::execution_space == HostSpace::execution_space
 // CudaHostPinnedSpace accessible to both Cuda and Host
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaHostPinnedSpace , Kokkos::HostSpace > {
-  enum { assignable = false }; // Cannot access from Cuda
-  enum { accessible = true };  // CudaHostPinnedSpace::execution_space
-  enum { deepcopy   = true };
+template <>
+struct MemorySpaceAccess<Kokkos::CudaHostPinnedSpace, Kokkos::HostSpace> {
+  enum { assignable = false };  // Cannot access from Cuda
+  enum { accessible = true };   // CudaHostPinnedSpace::execution_space
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaHostPinnedSpace , Kokkos::CudaSpace > {
-  enum { assignable = false }; // Cannot access from Host
+template <>
+struct MemorySpaceAccess<Kokkos::CudaHostPinnedSpace, Kokkos::CudaSpace> {
+  enum { assignable = false };  // Cannot access from Host
   enum { accessible = false };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::CudaHostPinnedSpace , Kokkos::CudaUVMSpace > {
-  enum { assignable = false }; // different execution_space
-  enum { accessible = true };  // same accessibility
-  enum { deepcopy   = true };
+template <>
+struct MemorySpaceAccess<Kokkos::CudaHostPinnedSpace, Kokkos::CudaUVMSpace> {
+  enum { assignable = false };  // different execution_space
+  enum { accessible = true };   // same accessibility
+  enum { deepcopy = true };
 };
 
 //----------------------------------------
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -371,247 +381,223 @@ struct MemorySpaceAccess< Kokkos::CudaHostPinnedSpace , Kokkos::CudaUVMSpace > {
 namespace Kokkos {
 namespace Impl {
 
-void DeepCopyAsyncCuda( void * dst , const void * src , size_t n);
+void DeepCopyAsyncCuda(void* dst, const void* src, size_t n);
 
-template<> struct DeepCopy< CudaSpace , CudaSpace , Cuda>
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Cuda & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<CudaSpace, CudaSpace, Cuda> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Cuda&, void* dst, const void* src, size_t);
 };
 
-template<> struct DeepCopy< CudaSpace , HostSpace , Cuda >
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Cuda & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<CudaSpace, HostSpace, Cuda> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Cuda&, void* dst, const void* src, size_t);
 };
 
-template<> struct DeepCopy< HostSpace , CudaSpace , Cuda >
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Cuda & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<HostSpace, CudaSpace, Cuda> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Cuda&, void* dst, const void* src, size_t);
 };
 
-template<class ExecutionSpace> struct DeepCopy< CudaSpace , CudaSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , CudaSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaSpace, CudaSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< CudaSpace , HostSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , HostSpace , Cuda>( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaSpace, HostSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, HostSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< HostSpace , CudaSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , CudaSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, CudaSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< CudaSpace , CudaUVMSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , CudaSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaSpace, CudaUVMSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< CudaSpace , CudaHostPinnedSpace , ExecutionSpace>
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , HostSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaSpace, CudaHostPinnedSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, HostSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
+template <class ExecutionSpace>
+struct DeepCopy<CudaUVMSpace, CudaSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-template<class ExecutionSpace>
-struct DeepCopy< CudaUVMSpace , CudaSpace , ExecutionSpace>
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , CudaSpace , Cuda >( dst , src , n ); }
-
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< CudaUVMSpace , CudaUVMSpace , ExecutionSpace>
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , CudaSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaUVMSpace, CudaUVMSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< CudaUVMSpace , CudaHostPinnedSpace , ExecutionSpace>
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , HostSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaUVMSpace, CudaHostPinnedSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, HostSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< CudaUVMSpace , HostSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< CudaSpace , HostSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaUVMSpace, HostSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<CudaSpace, HostSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
+template <class ExecutionSpace>
+struct DeepCopy<CudaHostPinnedSpace, CudaSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-template<class ExecutionSpace> struct DeepCopy< CudaHostPinnedSpace , CudaSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , CudaSpace , Cuda >( dst , src , n ); }
-
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< CudaHostPinnedSpace , CudaUVMSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , CudaSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaHostPinnedSpace, CudaUVMSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< CudaHostPinnedSpace , CudaHostPinnedSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , HostSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaHostPinnedSpace, CudaHostPinnedSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, HostSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< CudaHostPinnedSpace , HostSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , HostSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<CudaHostPinnedSpace, HostSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, HostSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, CudaUVMSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, CudaSpace, Cuda>(dst, src, n);
+  }
 
-template<class ExecutionSpace> struct DeepCopy< HostSpace , CudaUVMSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , CudaSpace , Cuda >( dst , src , n ); }
-
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< HostSpace , CudaHostPinnedSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , HostSpace , Cuda >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, CudaHostPinnedSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, HostSpace, Cuda>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopyAsyncCuda (dst,src,n);
+    DeepCopyAsyncCuda(dst, src, n);
   }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -620,79 +606,83 @@ namespace Kokkos {
 namespace Impl {
 
 /** Running in CudaSpace attempting to access HostSpace: error */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::CudaSpace , Kokkos::HostSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::CudaSpace,
+                                           Kokkos::HostSpace> {
   enum { value = false };
-  KOKKOS_INLINE_FUNCTION static void verify( void )
-    { Kokkos::abort("Cuda code attempted to access HostSpace memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {
+    Kokkos::abort("Cuda code attempted to access HostSpace memory");
+  }
 
-  KOKKOS_INLINE_FUNCTION static void verify( const void * )
-    { Kokkos::abort("Cuda code attempted to access HostSpace memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {
+    Kokkos::abort("Cuda code attempted to access HostSpace memory");
+  }
 };
 
 /** Running in CudaSpace accessing CudaUVMSpace: ok */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::CudaSpace , Kokkos::CudaUVMSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::CudaSpace,
+                                           Kokkos::CudaUVMSpace> {
   enum { value = true };
-  KOKKOS_INLINE_FUNCTION static void verify( void ) { }
-  KOKKOS_INLINE_FUNCTION static void verify( const void * ) { }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {}
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {}
 };
 
 /** Running in CudaSpace accessing CudaHostPinnedSpace: ok */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::CudaSpace , Kokkos::CudaHostPinnedSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::CudaSpace,
+                                           Kokkos::CudaHostPinnedSpace> {
   enum { value = true };
-  KOKKOS_INLINE_FUNCTION static void verify( void ) { }
-  KOKKOS_INLINE_FUNCTION static void verify( const void * ) { }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {}
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {}
 };
 
 /** Running in CudaSpace attempting to access an unknown space: error */
-template< class OtherSpace >
+template <class OtherSpace>
 struct VerifyExecutionCanAccessMemorySpace<
-  typename enable_if< ! is_same<Kokkos::CudaSpace,OtherSpace>::value , Kokkos::CudaSpace >::type ,
-  OtherSpace >
-{
+    typename enable_if<!is_same<Kokkos::CudaSpace, OtherSpace>::value,
+                       Kokkos::CudaSpace>::type,
+    OtherSpace> {
   enum { value = false };
-  KOKKOS_INLINE_FUNCTION static void verify( void )
-    { Kokkos::abort("Cuda code attempted to access unknown Space memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {
+    Kokkos::abort("Cuda code attempted to access unknown Space memory");
+  }
 
-  KOKKOS_INLINE_FUNCTION static void verify( const void * )
-    { Kokkos::abort("Cuda code attempted to access unknown Space memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {
+    Kokkos::abort("Cuda code attempted to access unknown Space memory");
+  }
 };
 
 //----------------------------------------------------------------------------
 /** Running in HostSpace attempting to access CudaSpace */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::CudaSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::HostSpace,
+                                           Kokkos::CudaSpace> {
   enum { value = false };
-  inline static void verify( void ) { CudaSpace::access_error(); }
-  inline static void verify( const void * p ) { CudaSpace::access_error(p); }
+  inline static void verify(void) { CudaSpace::access_error(); }
+  inline static void verify(const void* p) { CudaSpace::access_error(p); }
 };
 
 /** Running in HostSpace accessing CudaUVMSpace is OK */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::CudaUVMSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::HostSpace,
+                                           Kokkos::CudaUVMSpace> {
   enum { value = true };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
 /** Running in HostSpace accessing CudaHostPinnedSpace is OK */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::CudaHostPinnedSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::HostSpace,
+                                           Kokkos::CudaHostPinnedSpace> {
   enum { value = true };
-  KOKKOS_INLINE_FUNCTION static void verify( void ) {}
-  KOKKOS_INLINE_FUNCTION static void verify( const void * ) {}
+  KOKKOS_INLINE_FUNCTION static void verify(void) {}
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -700,248 +690,214 @@ struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::CudaHost
 namespace Kokkos {
 namespace Impl {
 
-template<>
-class SharedAllocationRecord< Kokkos::CudaSpace , void >
-  : public SharedAllocationRecord< void , void >
-{
-private:
-
-  friend class SharedAllocationRecord< Kokkos::CudaUVMSpace , void > ;
+template <>
+class SharedAllocationRecord<Kokkos::CudaSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
+  friend class SharedAllocationRecord<Kokkos::CudaUVMSpace, void>;
 
-  typedef SharedAllocationRecord< void , void >  RecordBase ;
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static void deallocate( RecordBase * );
+  static void deallocate(RecordBase*);
 
-  static ::cudaTextureObject_t
-  attach_texture_object( const unsigned sizeof_alias
-                       , void * const   alloc_ptr
-                       , const size_t   alloc_size );
+  static ::cudaTextureObject_t attach_texture_object(
+      const unsigned sizeof_alias, void* const alloc_ptr,
+      const size_t alloc_size);
 
 #ifdef KOKKOS_DEBUG
-  static RecordBase s_root_record ;
+  static RecordBase s_root_record;
 #endif
 
-  ::cudaTextureObject_t   m_tex_obj ;
-  const Kokkos::CudaSpace m_space ;
-
-protected:
+  ::cudaTextureObject_t m_tex_obj;
+  const Kokkos::CudaSpace m_space;
 
+ protected:
   ~SharedAllocationRecord();
   SharedAllocationRecord() : RecordBase(), m_tex_obj(0), m_space() {}
 
-  SharedAllocationRecord( const Kokkos::CudaSpace        & arg_space
-                        , const std::string              & arg_label
-                        , const size_t                     arg_alloc_size
-                        , const RecordBase::function_type  arg_dealloc = & deallocate
-                        );
-
-public:
+  SharedAllocationRecord(
+      const Kokkos::CudaSpace& arg_space, const std::string& arg_label,
+      const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
 
-  std::string get_label() const ;
+ public:
+  std::string get_label() const;
 
-  static SharedAllocationRecord * allocate( const Kokkos::CudaSpace &  arg_space
-                                          , const std::string       &  arg_label
-                                          , const size_t               arg_alloc_size );
+  static SharedAllocationRecord* allocate(const Kokkos::CudaSpace& arg_space,
+                                          const std::string& arg_label,
+                                          const size_t arg_alloc_size);
 
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::CudaSpace & arg_space
-                         , const std::string & arg_label
-                         , const size_t arg_alloc_size );
+  static void* allocate_tracked(const Kokkos::CudaSpace& arg_space,
+                                const std::string& arg_label,
+                                const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
-
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
-
-  template< typename AliasType >
-  inline
-  ::cudaTextureObject_t attach_texture_object()
-    {
-      static_assert( ( std::is_same< AliasType , int >::value ||
-                       std::is_same< AliasType , ::int2 >::value ||
-                       std::is_same< AliasType , ::int4 >::value )
-                   , "Cuda texture fetch only supported for alias types of int, ::int2, or ::int4" );
-
-      if ( m_tex_obj == 0 ) {
-        m_tex_obj = attach_texture_object( sizeof(AliasType)
-                                         , (void*) RecordBase::m_alloc_ptr
-                                         , RecordBase::m_alloc_size );
-      }
-
-      return m_tex_obj ;
+  static void deallocate_tracked(void* const arg_alloc_ptr);
+
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
+
+  template <typename AliasType>
+  inline ::cudaTextureObject_t attach_texture_object() {
+    static_assert((std::is_same<AliasType, int>::value ||
+                   std::is_same<AliasType, ::int2>::value ||
+                   std::is_same<AliasType, ::int4>::value),
+                  "Cuda texture fetch only supported for alias types of int, "
+                  "::int2, or ::int4");
+
+    if (m_tex_obj == 0) {
+      m_tex_obj = attach_texture_object(sizeof(AliasType),
+                                        (void*)RecordBase::m_alloc_ptr,
+                                        RecordBase::m_alloc_size);
     }
 
-  template< typename AliasType >
-  inline
-  int attach_texture_object_offset( const AliasType * const ptr )
-    {
-      // Texture object is attached to the entire allocation range
-      return ptr - reinterpret_cast<AliasType*>( RecordBase::m_alloc_ptr );
-    }
-
-  static void print_records( std::ostream & , const Kokkos::CudaSpace & , bool detail = false );
-};
-
+    return m_tex_obj;
+  }
 
-template<>
-class SharedAllocationRecord< Kokkos::CudaUVMSpace , void >
-  : public SharedAllocationRecord< void , void >
-{
-private:
+  template <typename AliasType>
+  inline int attach_texture_object_offset(const AliasType* const ptr) {
+    // Texture object is attached to the entire allocation range
+    return ptr - reinterpret_cast<AliasType*>(RecordBase::m_alloc_ptr);
+  }
 
-  typedef SharedAllocationRecord< void , void >  RecordBase ;
+  static void print_records(std::ostream&, const Kokkos::CudaSpace&,
+                            bool detail = false);
+};
 
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
+template <>
+class SharedAllocationRecord<Kokkos::CudaUVMSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
-  static void deallocate( RecordBase * );
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static RecordBase s_root_record ;
+  static void deallocate(RecordBase*);
 
-  ::cudaTextureObject_t      m_tex_obj ;
-  const Kokkos::CudaUVMSpace m_space ;
+  static RecordBase s_root_record;
 
-protected:
+  ::cudaTextureObject_t m_tex_obj;
+  const Kokkos::CudaUVMSpace m_space;
 
+ protected:
   ~SharedAllocationRecord();
   SharedAllocationRecord() : RecordBase(), m_tex_obj(0), m_space() {}
 
-  SharedAllocationRecord( const Kokkos::CudaUVMSpace     & arg_space
-                        , const std::string              & arg_label
-                        , const size_t                     arg_alloc_size
-                        , const RecordBase::function_type  arg_dealloc = & deallocate
-                        );
+  SharedAllocationRecord(
+      const Kokkos::CudaUVMSpace& arg_space, const std::string& arg_label,
+      const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
 
-public:
+ public:
+  std::string get_label() const;
 
-  std::string get_label() const ;
-
-  static SharedAllocationRecord * allocate( const Kokkos::CudaUVMSpace &  arg_space
-                                          , const std::string          &  arg_label
-                                          , const size_t                  arg_alloc_size
-                                          );
+  static SharedAllocationRecord* allocate(const Kokkos::CudaUVMSpace& arg_space,
+                                          const std::string& arg_label,
+                                          const size_t arg_alloc_size);
 
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::CudaUVMSpace & arg_space
-                         , const std::string & arg_label
-                         , const size_t arg_alloc_size );
+  static void* allocate_tracked(const Kokkos::CudaUVMSpace& arg_space,
+                                const std::string& arg_label,
+                                const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
-
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
-
-
-  template< typename AliasType >
-  inline
-  ::cudaTextureObject_t attach_texture_object()
-    {
-      static_assert( ( std::is_same< AliasType , int >::value ||
-                       std::is_same< AliasType , ::int2 >::value ||
-                       std::is_same< AliasType , ::int4 >::value )
-                   , "Cuda texture fetch only supported for alias types of int, ::int2, or ::int4" );
-
-      if ( m_tex_obj == 0 ) {
-        m_tex_obj = SharedAllocationRecord< Kokkos::CudaSpace , void >::
-          attach_texture_object( sizeof(AliasType)
-                               , (void*) RecordBase::m_alloc_ptr
-                               , RecordBase::m_alloc_size );
-      }
-
-      return m_tex_obj ;
-    }
-
-  template< typename AliasType >
-  inline
-  int attach_texture_object_offset( const AliasType * const ptr )
-    {
-      // Texture object is attached to the entire allocation range
-      return ptr - reinterpret_cast<AliasType*>( RecordBase::m_alloc_ptr );
+  static void deallocate_tracked(void* const arg_alloc_ptr);
+
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
+
+  template <typename AliasType>
+  inline ::cudaTextureObject_t attach_texture_object() {
+    static_assert((std::is_same<AliasType, int>::value ||
+                   std::is_same<AliasType, ::int2>::value ||
+                   std::is_same<AliasType, ::int4>::value),
+                  "Cuda texture fetch only supported for alias types of int, "
+                  "::int2, or ::int4");
+
+    if (m_tex_obj == 0) {
+      m_tex_obj = SharedAllocationRecord<Kokkos::CudaSpace, void>::
+          attach_texture_object(sizeof(AliasType),
+                                (void*)RecordBase::m_alloc_ptr,
+                                RecordBase::m_alloc_size);
     }
 
-  static void print_records( std::ostream & , const Kokkos::CudaUVMSpace & , bool detail = false );
-};
+    return m_tex_obj;
+  }
 
-template<>
-class SharedAllocationRecord< Kokkos::CudaHostPinnedSpace , void >
-  : public SharedAllocationRecord< void , void >
-{
-private:
+  template <typename AliasType>
+  inline int attach_texture_object_offset(const AliasType* const ptr) {
+    // Texture object is attached to the entire allocation range
+    return ptr - reinterpret_cast<AliasType*>(RecordBase::m_alloc_ptr);
+  }
 
-  typedef SharedAllocationRecord< void , void >  RecordBase ;
+  static void print_records(std::ostream&, const Kokkos::CudaUVMSpace&,
+                            bool detail = false);
+};
 
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
+template <>
+class SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
-  static void deallocate( RecordBase * );
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static RecordBase s_root_record ;
+  static void deallocate(RecordBase*);
 
-  const Kokkos::CudaHostPinnedSpace m_space ;
+  static RecordBase s_root_record;
 
-protected:
+  const Kokkos::CudaHostPinnedSpace m_space;
 
+ protected:
   ~SharedAllocationRecord();
   SharedAllocationRecord() : RecordBase(), m_space() {}
 
-  SharedAllocationRecord( const Kokkos::CudaHostPinnedSpace     & arg_space
-                        , const std::string              & arg_label
-                        , const size_t                     arg_alloc_size
-                        , const RecordBase::function_type  arg_dealloc = & deallocate
-                        );
+  SharedAllocationRecord(
+      const Kokkos::CudaHostPinnedSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
 
-public:
+ public:
+  std::string get_label() const;
 
-  std::string get_label() const ;
-
-  static SharedAllocationRecord * allocate( const Kokkos::CudaHostPinnedSpace &  arg_space
-                                          , const std::string          &  arg_label
-                                          , const size_t                  arg_alloc_size
-                                          );
+  static SharedAllocationRecord* allocate(
+      const Kokkos::CudaHostPinnedSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size);
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::CudaHostPinnedSpace & arg_space
-                         , const std::string & arg_label
-                         , const size_t arg_alloc_size );
+  static void* allocate_tracked(const Kokkos::CudaHostPinnedSpace& arg_space,
+                                const std::string& arg_label,
+                                const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
-
+  static void deallocate_tracked(void* const arg_alloc_ptr);
 
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
 
-  static void print_records( std::ostream & , const Kokkos::CudaHostPinnedSpace & , bool detail = false );
+  static void print_records(std::ostream&, const Kokkos::CudaHostPinnedSpace&,
+                            bool detail = false);
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_CUDA ) */
 #endif /* #define KOKKOS_CUDASPACE_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_ExecPolicy.hpp b/lib/kokkos/core/src/Kokkos_ExecPolicy.hpp
index 5c85850fda545160e33ed01ed46c7d96baca954f..bf3a134b64b3e89d9e8f3a1650cd1cb2ef7c1794 100644
--- a/lib/kokkos/core/src/Kokkos_ExecPolicy.hpp
+++ b/lib/kokkos/core/src/Kokkos_ExecPolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,7 +54,7 @@
 #include <iostream>
 #if defined(KOKKOS_ENABLE_PROFILING)
 #include <typeinfo>
-#endif // KOKKOS_ENABLE_PROFILING
+#endif  // KOKKOS_ENABLE_PROFILING
 
 //----------------------------------------------------------------------------
 
@@ -65,7 +66,7 @@ struct ParallelReduceTag {};
 
 struct ChunkSize {
   int value;
-  ChunkSize(int value_):value(value_) {}
+  ChunkSize(int value_) : value(value_) {}
 };
 
 /** \brief  Execution policy for work over a range of an integral type.
@@ -89,210 +90,192 @@ struct ChunkSize {
  *
  *  Blocking is the granularity of partitioning the range among threads.
  */
-template<class ... Properties>
-class RangePolicy
-  : public Impl::PolicyTraits<Properties ... >
-{
-public:
-  typedef Impl::PolicyTraits<Properties ... > traits;
-private:
-
-  typename traits::execution_space m_space ;
-  typename traits::index_type  m_begin ;
-  typename traits::index_type  m_end ;
-  typename traits::index_type  m_granularity ;
-  typename traits::index_type  m_granularity_mask ;
-
-  template<class ... OtherProperties>
+template <class... Properties>
+class RangePolicy : public Impl::PolicyTraits<Properties...> {
+ public:
+  typedef Impl::PolicyTraits<Properties...> traits;
+
+ private:
+  typename traits::execution_space m_space;
+  typename traits::index_type m_begin;
+  typename traits::index_type m_end;
+  typename traits::index_type m_granularity;
+  typename traits::index_type m_granularity_mask;
+
+  template <class... OtherProperties>
   friend class RangePolicy;
 
-public:
+ public:
   //! Tag this class as an execution policy
   typedef RangePolicy execution_policy;
-  typedef typename traits::index_type member_type ;
+  typedef typename traits::index_type member_type;
   typedef typename traits::index_type index_type;
 
-  KOKKOS_INLINE_FUNCTION const typename traits::execution_space & space() const { return m_space ; }
-  KOKKOS_INLINE_FUNCTION member_type begin() const { return m_begin ; }
-  KOKKOS_INLINE_FUNCTION member_type end()   const { return m_end ; }
-
-  //TODO: find a better workaround for Clangs weird instantiation order
-  // This thing is here because of an instantiation error, where the RangePolicy is inserted into FunctorValue Traits, which
-  // tries decltype on the operator. It tries to do this even though the first argument of parallel for clearly doesn't match.
+  KOKKOS_INLINE_FUNCTION const typename traits::execution_space& space() const {
+    return m_space;
+  }
+  KOKKOS_INLINE_FUNCTION member_type begin() const { return m_begin; }
+  KOKKOS_INLINE_FUNCTION member_type end() const { return m_end; }
+
+  // TODO: find a better workaround for Clangs weird instantiation order
+  // This thing is here because of an instantiation error, where the RangePolicy
+  // is inserted into FunctorValue Traits, which tries decltype on the operator.
+  // It tries to do this even though the first argument of parallel for clearly
+  // doesn't match.
   void operator()(const int&) const {}
 
   RangePolicy(const RangePolicy&) = default;
-  RangePolicy(RangePolicy&&) = default;
+  RangePolicy(RangePolicy&&)      = default;
 
-  template<class ... OtherProperties>
+  template <class... OtherProperties>
   RangePolicy(const RangePolicy<OtherProperties...> p) {
-    m_space = p.m_space;
-    m_begin = p.m_begin;
-    m_end = p.m_end;
-    m_granularity = p.m_granularity;
+    m_space            = p.m_space;
+    m_begin            = p.m_begin;
+    m_end              = p.m_end;
+    m_granularity      = p.m_granularity;
     m_granularity_mask = p.m_granularity_mask;
   }
 
   inline RangePolicy() : m_space(), m_begin(0), m_end(0) {}
 
   /** \brief  Total range */
-  inline
-  RangePolicy( const typename traits::execution_space & work_space
-             , const member_type work_begin
-             , const member_type work_end
-             )
-    : m_space( work_space )
-    , m_begin( work_begin < work_end ? work_begin : 0 )
-    , m_end(   work_begin < work_end ? work_end : 0 )
-    , m_granularity(0)
-    , m_granularity_mask(0)
-    {
-      set_auto_chunk_size();
-    }
+  inline RangePolicy(const typename traits::execution_space& work_space,
+                     const member_type work_begin, const member_type work_end)
+      : m_space(work_space),
+        m_begin(work_begin < work_end ? work_begin : 0),
+        m_end(work_begin < work_end ? work_end : 0),
+        m_granularity(0),
+        m_granularity_mask(0) {
+    set_auto_chunk_size();
+  }
 
   /** \brief  Total range */
-  inline
-  RangePolicy( const member_type work_begin
-             , const member_type work_end
-             )
-    : RangePolicy( typename traits::execution_space()
-                 , work_begin , work_end )
-    {
-      set_auto_chunk_size();
-    }
+  inline RangePolicy(const member_type work_begin, const member_type work_end)
+      : RangePolicy(typename traits::execution_space(), work_begin, work_end) {
+    set_auto_chunk_size();
+  }
 
   /** \brief  Total range */
-  template<class ... Args>
-  inline
-  RangePolicy( const typename traits::execution_space & work_space
-             , const member_type work_begin
-             , const member_type work_end
-             , Args ... args
-             )
-    : m_space( work_space )
-    , m_begin( work_begin < work_end ? work_begin : 0 )
-    , m_end(   work_begin < work_end ? work_end : 0 )
-    , m_granularity(0)
-    , m_granularity_mask(0)
-    {
-      set_auto_chunk_size();
-      set(args...);
-    }
+  template <class... Args>
+  inline RangePolicy(const typename traits::execution_space& work_space,
+                     const member_type work_begin, const member_type work_end,
+                     Args... args)
+      : m_space(work_space),
+        m_begin(work_begin < work_end ? work_begin : 0),
+        m_end(work_begin < work_end ? work_end : 0),
+        m_granularity(0),
+        m_granularity_mask(0) {
+    set_auto_chunk_size();
+    set(args...);
+  }
 
   /** \brief  Total range */
-  template<class ... Args>
-  inline
-  RangePolicy( const member_type work_begin
-             , const member_type work_end
-             , Args ... args
-             )
-    : RangePolicy( typename traits::execution_space()
-                 , work_begin , work_end )
-    {
-      set_auto_chunk_size();
-      set(args...);
-    }
+  template <class... Args>
+  inline RangePolicy(const member_type work_begin, const member_type work_end,
+                     Args... args)
+      : RangePolicy(typename traits::execution_space(), work_begin, work_end) {
+    set_auto_chunk_size();
+    set(args...);
+  }
 
-private:
+ private:
   inline void set() {}
 
-public:
-  template<class ... Args>
-  inline void set(Args ...) {
-    static_assert( 0 == sizeof...(Args), "Kokkos::RangePolicy: unhandled constructor arguments encountered.");
+ public:
+  template <class... Args>
+  inline void set(Args...) {
+    static_assert(
+        0 == sizeof...(Args),
+        "Kokkos::RangePolicy: unhandled constructor arguments encountered.");
   }
 
-  template<class ... Args>
-  inline void set(const ChunkSize& chunksize, Args ... args) {
-    m_granularity = chunksize.value;
+  template <class... Args>
+  inline void set(const ChunkSize& chunksize, Args... args) {
+    m_granularity      = chunksize.value;
     m_granularity_mask = m_granularity - 1;
   }
 
-public:
+ public:
   /** \brief return chunk_size */
-  inline member_type chunk_size() const {
-    return m_granularity;
-  }
+  inline member_type chunk_size() const { return m_granularity; }
 
   /** \brief set chunk_size to a discrete value*/
   inline RangePolicy set_chunk_size(int chunk_size_) const {
-    RangePolicy p = *this;
-    p.m_granularity = chunk_size_;
+    RangePolicy p        = *this;
+    p.m_granularity      = chunk_size_;
     p.m_granularity_mask = p.m_granularity - 1;
     return p;
   }
 
-private:
+ private:
   /** \brief finalize chunk_size if it was set to AUTO*/
   inline void set_auto_chunk_size() {
+    typename traits::index_type concurrency =
+        traits::execution_space::concurrency();
+    if (concurrency == 0) concurrency = 1;
 
-   typename traits::index_type concurrency = traits::execution_space::concurrency();
-   if( concurrency==0 ) concurrency=1;
-
-   if(m_granularity > 0) {
-     if(!Impl::is_integral_power_of_two( m_granularity ))
-       Kokkos::abort("RangePolicy blocking granularity must be power of two" );
-   }
+    if (m_granularity > 0) {
+      if (!Impl::is_integral_power_of_two(m_granularity))
+        Kokkos::abort("RangePolicy blocking granularity must be power of two");
+    }
 
-   member_type new_chunk_size = 1;
-   while(new_chunk_size*100*concurrency < m_end-m_begin)
-     new_chunk_size *= 2;
-   if(new_chunk_size < 128) {
-     new_chunk_size = 1;
-     while( (new_chunk_size*40*concurrency < m_end-m_begin ) && (new_chunk_size<128) )
-       new_chunk_size*=2;
-   }
-   m_granularity = new_chunk_size;
-   m_granularity_mask = m_granularity - 1;
+    member_type new_chunk_size = 1;
+    while (new_chunk_size * 100 * concurrency < m_end - m_begin)
+      new_chunk_size *= 2;
+    if (new_chunk_size < 128) {
+      new_chunk_size = 1;
+      while ((new_chunk_size * 40 * concurrency < m_end - m_begin) &&
+             (new_chunk_size < 128))
+        new_chunk_size *= 2;
+    }
+    m_granularity      = new_chunk_size;
+    m_granularity_mask = m_granularity - 1;
   }
 
-public:
+ public:
   /** \brief  Subrange for a partition's rank and size.
    *
    *  Typically used to partition a range over a group of threads.
    */
   struct WorkRange {
-    typedef typename RangePolicy::work_tag     work_tag ;
-    typedef typename RangePolicy::member_type  member_type ;
+    typedef typename RangePolicy::work_tag work_tag;
+    typedef typename RangePolicy::member_type member_type;
 
-    KOKKOS_INLINE_FUNCTION member_type begin() const { return m_begin ; }
-    KOKKOS_INLINE_FUNCTION member_type end()   const { return m_end ; }
+    KOKKOS_INLINE_FUNCTION member_type begin() const { return m_begin; }
+    KOKKOS_INLINE_FUNCTION member_type end() const { return m_end; }
 
     /** \brief  Subrange for a partition's rank and size.
      *
      *  Typically used to partition a range over a group of threads.
      */
     KOKKOS_INLINE_FUNCTION
-    WorkRange( const RangePolicy & range
-             , const int part_rank
-             , const int part_size
-             )
-      : m_begin(0), m_end(0)
-      {
-        if ( part_size ) {
-
-          // Split evenly among partitions, then round up to the granularity.
-          const member_type work_part =
-            ( ( ( ( range.end() - range.begin() ) + ( part_size - 1 ) ) / part_size )
-              + range.m_granularity_mask ) & ~member_type(range.m_granularity_mask);
-
-          m_begin = range.begin() + work_part * part_rank ;
-          m_end   = m_begin       + work_part ;
-
-          if ( range.end() < m_begin ) m_begin = range.end() ;
-          if ( range.end() < m_end )   m_end   = range.end() ;
-        }
+    WorkRange(const RangePolicy& range, const int part_rank,
+              const int part_size)
+        : m_begin(0), m_end(0) {
+      if (part_size) {
+        // Split evenly among partitions, then round up to the granularity.
+        const member_type work_part =
+            ((((range.end() - range.begin()) + (part_size - 1)) / part_size) +
+             range.m_granularity_mask) &
+            ~member_type(range.m_granularity_mask);
+
+        m_begin = range.begin() + work_part * part_rank;
+        m_end   = m_begin + work_part;
+
+        if (range.end() < m_begin) m_begin = range.end();
+        if (range.end() < m_end) m_end = range.end();
       }
+    }
 
-  private:
-    member_type m_begin ;
-    member_type m_end ;
+   private:
+    member_type m_begin;
+    member_type m_end;
     WorkRange();
-    WorkRange & operator = ( const WorkRange & );
+    WorkRange& operator=(const WorkRange&);
   };
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -301,13 +284,12 @@ namespace Kokkos {
 
 namespace Impl {
 
-template< class ExecSpace, class ... Properties>
-class TeamPolicyInternal: public Impl::PolicyTraits<Properties ... > {
-private:
-  typedef Impl::PolicyTraits<Properties ... > traits;
+template <class ExecSpace, class... Properties>
+class TeamPolicyInternal : public Impl::PolicyTraits<Properties...> {
+ private:
+  typedef Impl::PolicyTraits<Properties...> traits;
 
-public:
-  
+ public:
   typedef typename traits::index_type index_type;
 
   //----------------------------------------
@@ -321,8 +303,8 @@ public:
    *  With multi-operator functors it cannot be determined
    *  which operator will be called.
    */
-  template< class FunctorType >
-  static int team_size_max( const FunctorType & );
+  template <class FunctorType>
+  static int team_size_max(const FunctorType&);
 
   /** \brief  Query recommended team size for a given functor.
    *
@@ -334,48 +316,56 @@ public:
    *  With multi-operator functors it cannot be determined
    *  which operator will be called.
    */
-  template< class FunctorType >
-  static int team_size_recommended( const FunctorType & );
+  template <class FunctorType>
+  static int team_size_recommended(const FunctorType&);
 
-  template< class FunctorType >
-  static int team_size_recommended( const FunctorType & , const int&);
+  template <class FunctorType>
+  static int team_size_recommended(const FunctorType&, const int&);
 
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType & functor , const int vector_length);
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType& functor,
+                            const int vector_length);
 
   //----------------------------------------
   /** \brief  Construct policy with the given instance of the execution space */
-  TeamPolicyInternal( const typename traits::execution_space & , int league_size_request , int team_size_request , int vector_length_request = 1 );
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request, int team_size_request,
+                     int vector_length_request = 1);
 
-  TeamPolicyInternal( const typename traits::execution_space & , int league_size_request , const Kokkos::AUTO_t & , int vector_length_request = 1 );
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request, const Kokkos::AUTO_t&,
+                     int vector_length_request = 1);
 
-  /** \brief  Construct policy with the default instance of the execution space */
-  TeamPolicyInternal( int league_size_request , int team_size_request , int vector_length_request = 1 );
+  /** \brief  Construct policy with the default instance of the execution space
+   */
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     int vector_length_request = 1);
 
-  TeamPolicyInternal( int league_size_request , const Kokkos::AUTO_t & , int vector_length_request = 1 );
+  TeamPolicyInternal(int league_size_request, const Kokkos::AUTO_t&,
+                     int vector_length_request = 1);
 
-/*  TeamPolicyInternal( int league_size_request , int team_size_request );
+  /*  TeamPolicyInternal( int league_size_request , int team_size_request );
 
-  TeamPolicyInternal( int league_size_request , const Kokkos::AUTO_t & );*/
+    TeamPolicyInternal( int league_size_request , const Kokkos::AUTO_t & );*/
 
   /** \brief  The actual league size (number of teams) of the policy.
    *
    *  This may be smaller than the requested league size due to limitations
    *  of the execution space.
    */
-  KOKKOS_INLINE_FUNCTION int league_size() const ;
+  KOKKOS_INLINE_FUNCTION int league_size() const;
 
   /** \brief  The actual team size (number of threads per team) of the policy.
    *
    *  This may be smaller than the requested team size due to limitations
    *  of the execution space.
    */
-  KOKKOS_INLINE_FUNCTION int team_size() const ;
+  KOKKOS_INLINE_FUNCTION int team_size() const;
 
-  inline typename traits::index_type chunk_size() const ;
+  inline typename traits::index_type chunk_size() const;
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  inline TeamPolicyInternal set_chunk_size(int chunk_size) const ;
+  inline TeamPolicyInternal set_chunk_size(int chunk_size) const;
 #else
   inline TeamPolicyInternal& set_chunk_size(int chunk_size);
 #endif
@@ -384,39 +374,38 @@ public:
    *          each member of the execution policy.
    */
   struct member_type {
-
     /** \brief  Handle to the currently executing team shared scratch memory */
     KOKKOS_INLINE_FUNCTION
-    typename traits::execution_space::scratch_memory_space team_shmem() const ;
+    typename traits::execution_space::scratch_memory_space team_shmem() const;
 
     /** \brief  Rank of this team within the league of teams */
-    KOKKOS_INLINE_FUNCTION int league_rank() const ;
+    KOKKOS_INLINE_FUNCTION int league_rank() const;
 
     /** \brief  Number of teams in the league */
-    KOKKOS_INLINE_FUNCTION int league_size() const ;
+    KOKKOS_INLINE_FUNCTION int league_size() const;
 
     /** \brief  Rank of this thread within this team */
-    KOKKOS_INLINE_FUNCTION int team_rank() const ;
+    KOKKOS_INLINE_FUNCTION int team_rank() const;
 
     /** \brief  Number of threads in this team */
-    KOKKOS_INLINE_FUNCTION int team_size() const ;
+    KOKKOS_INLINE_FUNCTION int team_size() const;
 
     /** \brief  Barrier among the threads of this team */
-    KOKKOS_INLINE_FUNCTION void team_barrier() const ;
+    KOKKOS_INLINE_FUNCTION void team_barrier() const;
 
-    /** \brief  Intra-team reduction. Returns join of all values of the team members. */
-    template< class JoinOp >
-    KOKKOS_INLINE_FUNCTION
-    typename JoinOp::value_type team_reduce( const typename JoinOp::value_type
-                                           , const JoinOp & ) const ;
+    /** \brief  Intra-team reduction. Returns join of all values of the team
+     * members. */
+    template <class JoinOp>
+    KOKKOS_INLINE_FUNCTION typename JoinOp::value_type team_reduce(
+        const typename JoinOp::value_type, const JoinOp&) const;
 
     /** \brief  Intra-team exclusive prefix sum with team_rank() ordering.
      *
      *  The highest rank thread can compute the reduction total as
      *    reduction_total = dev.team_scan( value ) + value ;
      */
-    template< typename Type >
-    KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value ) const ;
+    template <typename Type>
+    KOKKOS_INLINE_FUNCTION Type team_scan(const Type& value) const;
 
     /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
      *          with intra-team non-deterministic ordering accumulation.
@@ -427,44 +416,52 @@ public:
      *  As such the base value for each team's scan operation is similarly
      *  non-deterministic.
      */
-    template< typename Type >
-    KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value , Type * const global_accum ) const ;
+    template <typename Type>
+    KOKKOS_INLINE_FUNCTION Type team_scan(const Type& value,
+                                          Type* const global_accum) const;
   };
 };
 
+struct PerTeamValue {
+  int value;
+  PerTeamValue(int arg);
+};
 
-  struct PerTeamValue {
-    int value;
-    PerTeamValue(int arg);
-  };
-
-  struct PerThreadValue {
-    int value;
-    PerThreadValue(int arg);
-  };
-
-  template<class iType, class ... Args>
-  struct ExtractVectorLength {
-    static inline iType value(typename std::enable_if<std::is_integral<iType>::value,iType>::type val, Args...) {
-      return val;
-    }
-    static inline typename std::enable_if<!std::is_integral<iType>::value,int>::type value(typename std::enable_if<!std::is_integral<iType>::value,iType>::type, Args...) {
-      return 1;
-    }
-  };
+struct PerThreadValue {
+  int value;
+  PerThreadValue(int arg);
+};
 
-  template<class iType, class ... Args>
-  inline typename std::enable_if<std::is_integral<iType>::value,iType>::type extract_vector_length(iType val, Args...) {
+template <class iType, class... Args>
+struct ExtractVectorLength {
+  static inline iType value(
+      typename std::enable_if<std::is_integral<iType>::value, iType>::type val,
+      Args...) {
     return val;
   }
-
-  template<class iType, class ... Args>
-  inline typename std::enable_if<!std::is_integral<iType>::value,int>::type extract_vector_length(iType, Args...) {
+  static inline
+      typename std::enable_if<!std::is_integral<iType>::value, int>::type
+      value(
+          typename std::enable_if<!std::is_integral<iType>::value, iType>::type,
+          Args...) {
     return 1;
   }
+};
+
+template <class iType, class... Args>
+inline typename std::enable_if<std::is_integral<iType>::value, iType>::type
+extract_vector_length(iType val, Args...) {
+  return val;
+}
 
+template <class iType, class... Args>
+inline typename std::enable_if<!std::is_integral<iType>::value, int>::type
+extract_vector_length(iType, Args...) {
+  return 1;
 }
 
+}  // namespace Impl
+
 Impl::PerTeamValue PerTeam(const int& arg);
 Impl::PerThreadValue PerThread(const int& arg);
 
@@ -474,38 +471,41 @@ struct ScratchRequest {
   int per_team;
   int per_thread;
 
-  inline
-  ScratchRequest(const int& level_, const Impl::PerTeamValue& team_value) {
-    level = level_;
-    per_team = team_value.value;
+  inline ScratchRequest(const int& level_,
+                        const Impl::PerTeamValue& team_value) {
+    level      = level_;
+    per_team   = team_value.value;
     per_thread = 0;
   }
 
-  inline
-  ScratchRequest(const int& level_, const Impl::PerThreadValue& thread_value) {
-    level = level_;
-    per_team = 0;
-    per_thread = thread_value.value;;
+  inline ScratchRequest(const int& level_,
+                        const Impl::PerThreadValue& thread_value) {
+    level      = level_;
+    per_team   = 0;
+    per_thread = thread_value.value;
+    ;
   }
 
-  inline
-  ScratchRequest(const int& level_, const Impl::PerTeamValue& team_value, const Impl::PerThreadValue& thread_value) {
-    level = level_;
-    per_team = team_value.value;
-    per_thread = thread_value.value;;
+  inline ScratchRequest(const int& level_, const Impl::PerTeamValue& team_value,
+                        const Impl::PerThreadValue& thread_value) {
+    level      = level_;
+    per_team   = team_value.value;
+    per_thread = thread_value.value;
+    ;
   }
 
-  inline
-  ScratchRequest(const int& level_, const Impl::PerThreadValue& thread_value, const Impl::PerTeamValue& team_value) {
-    level = level_;
-    per_team = team_value.value;
-    per_thread = thread_value.value;;
+  inline ScratchRequest(const int& level_,
+                        const Impl::PerThreadValue& thread_value,
+                        const Impl::PerTeamValue& team_value) {
+    level      = level_;
+    per_team   = team_value.value;
+    per_thread = thread_value.value;
+    ;
   }
-
 };
 
-
-/** \brief  Execution policy for parallel work over a league of teams of threads.
+/** \brief  Execution policy for parallel work over a league of teams of
+ * threads.
  *
  *  The work functor is called for each thread of each team such that
  *  the team's member threads are guaranteed to be concurrent.
@@ -522,162 +522,197 @@ struct ScratchRequest {
  *  be omitted.
  *
  *  Possible Template arguments and their default values:
- *    ExecutionSpace (DefaultExecutionSpace): where to execute code. Must be enabled.
- *    WorkTag (none): Tag which is used as the first argument for the functor operator.
- *    Schedule<Type> (Schedule<Static>): Scheduling Policy (Dynamic, or Static).
- *    IndexType<Type> (IndexType<ExecutionSpace::size_type>: Integer Index type used to iterate over the Index space.
+ *    ExecutionSpace (DefaultExecutionSpace): where to execute code. Must be
+ * enabled. WorkTag (none): Tag which is used as the first argument for the
+ * functor operator. Schedule<Type> (Schedule<Static>): Scheduling Policy
+ * (Dynamic, or Static). IndexType<Type> (IndexType<ExecutionSpace::size_type>:
+ * Integer Index type used to iterate over the Index space.
  *    LaunchBounds<unsigned,unsigned> Launch Bounds for CUDA compilation,
  *    default of LaunchBounds<0,0> indicates no launch bounds specified.
  */
-template< class ... Properties>
-class TeamPolicy: public
-  Impl::TeamPolicyInternal<
-     typename Impl::PolicyTraits<Properties ... >::execution_space,
-     Properties ...> {
+template <class... Properties>
+class TeamPolicy
+    : public Impl::TeamPolicyInternal<
+          typename Impl::PolicyTraits<Properties...>::execution_space,
+          Properties...> {
   typedef Impl::TeamPolicyInternal<
-       typename Impl::PolicyTraits<Properties ... >::execution_space,
-       Properties ...> internal_policy;
+      typename Impl::PolicyTraits<Properties...>::execution_space,
+      Properties...>
+      internal_policy;
 
-  template<class ... OtherProperties>
+  template <class... OtherProperties>
   friend class TeamPolicy;
 
-public:
-  typedef Impl::PolicyTraits<Properties ... > traits;
+ public:
+  typedef Impl::PolicyTraits<Properties...> traits;
 
   typedef TeamPolicy execution_policy;
 
-  TeamPolicy& operator = (const TeamPolicy&) = default;
+  TeamPolicy& operator=(const TeamPolicy&) = default;
 
   /** \brief  Construct policy with the given instance of the execution space */
-  TeamPolicy( const typename traits::execution_space & space_ , int league_size_request , int team_size_request , int vector_length_request = 1 )
-    : internal_policy(space_,league_size_request,team_size_request, vector_length_request) {first_arg = false;}
+  TeamPolicy(const typename traits::execution_space& space_,
+             int league_size_request, int team_size_request,
+             int vector_length_request = 1)
+      : internal_policy(space_, league_size_request, team_size_request,
+                        vector_length_request) {
+    first_arg = false;
+  }
 
-  TeamPolicy( const typename traits::execution_space & space_, int league_size_request , const Kokkos::AUTO_t & , int vector_length_request = 1 )
-    : internal_policy(space_,league_size_request,Kokkos::AUTO(), vector_length_request) {first_arg = false;}
+  TeamPolicy(const typename traits::execution_space& space_,
+             int league_size_request, const Kokkos::AUTO_t&,
+             int vector_length_request = 1)
+      : internal_policy(space_, league_size_request, Kokkos::AUTO(),
+                        vector_length_request) {
+    first_arg = false;
+  }
 
-  /** \brief  Construct policy with the default instance of the execution space */
-  TeamPolicy( int league_size_request , int team_size_request , int vector_length_request = 1 )
-    : internal_policy(league_size_request,team_size_request, vector_length_request) {first_arg = false;}
+  /** \brief  Construct policy with the default instance of the execution space
+   */
+  TeamPolicy(int league_size_request, int team_size_request,
+             int vector_length_request = 1)
+      : internal_policy(league_size_request, team_size_request,
+                        vector_length_request) {
+    first_arg = false;
+  }
 
-  TeamPolicy( int league_size_request , const Kokkos::AUTO_t & , int vector_length_request = 1 )
-    : internal_policy(league_size_request,Kokkos::AUTO(), vector_length_request) {first_arg = false;}
+  TeamPolicy(int league_size_request, const Kokkos::AUTO_t&,
+             int vector_length_request = 1)
+      : internal_policy(league_size_request, Kokkos::AUTO(),
+                        vector_length_request) {
+    first_arg = false;
+  }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief  Construct policy with the given instance of the execution space */
-  template<class ... Args>
-  TeamPolicy( const typename traits::execution_space & , int league_size_request , int team_size_request , int vector_length_request,
-              Args ... args)
-    : internal_policy(typename traits::execution_space(),league_size_request,team_size_request, vector_length_request) {
+  template <class... Args>
+  TeamPolicy(const typename traits::execution_space&, int league_size_request,
+             int team_size_request, int vector_length_request, Args... args)
+      : internal_policy(typename traits::execution_space(), league_size_request,
+                        team_size_request, vector_length_request) {
     first_arg = false;
     set(args...);
   }
 
-  template<class ... Args>
-  TeamPolicy( const typename traits::execution_space & , int league_size_request , const Kokkos::AUTO_t & , int vector_length_request ,
-              Args ... args)
-    : internal_policy(typename traits::execution_space(),league_size_request,Kokkos::AUTO(), vector_length_request) {
+  template <class... Args>
+  TeamPolicy(const typename traits::execution_space&, int league_size_request,
+             const Kokkos::AUTO_t&, int vector_length_request, Args... args)
+      : internal_policy(typename traits::execution_space(), league_size_request,
+                        Kokkos::AUTO(), vector_length_request) {
     first_arg = false;
     set(args...);
   }
 
-  /** \brief  Construct policy with the default instance of the execution space */
-  template<class ... Args>
-  TeamPolicy( int league_size_request , int team_size_request , int vector_length_request ,
-              Args ... args)
-    : internal_policy(league_size_request,team_size_request, vector_length_request) {
+  /** \brief  Construct policy with the default instance of the execution space
+   */
+  template <class... Args>
+  TeamPolicy(int league_size_request, int team_size_request,
+             int vector_length_request, Args... args)
+      : internal_policy(league_size_request, team_size_request,
+                        vector_length_request) {
     first_arg = false;
     set(args...);
   }
 
-  template<class ... Args>
-  TeamPolicy( int league_size_request , const Kokkos::AUTO_t & , int vector_length_request ,
-              Args ... args)
-    : internal_policy(league_size_request,Kokkos::AUTO(), vector_length_request) {
+  template <class... Args>
+  TeamPolicy(int league_size_request, const Kokkos::AUTO_t&,
+             int vector_length_request, Args... args)
+      : internal_policy(league_size_request, Kokkos::AUTO(),
+                        vector_length_request) {
     first_arg = false;
     set(args...);
   }
 
   /** \brief  Construct policy with the given instance of the execution space */
-  template<class ... Args>
-  TeamPolicy( const typename traits::execution_space & , int league_size_request , int team_size_request ,
-              Args ... args)
-    : internal_policy(typename traits::execution_space(),league_size_request,team_size_request,
-                      Kokkos::Impl::extract_vector_length<Args...>(args...)) {
+  template <class... Args>
+  TeamPolicy(const typename traits::execution_space&, int league_size_request,
+             int team_size_request, Args... args)
+      : internal_policy(typename traits::execution_space(), league_size_request,
+                        team_size_request,
+                        Kokkos::Impl::extract_vector_length<Args...>(args...)) {
     first_arg = true;
     set(args...);
   }
 
-  template<class ... Args>
-  TeamPolicy( const typename traits::execution_space & , int league_size_request , const Kokkos::AUTO_t & ,
-              Args ... args)
-    : internal_policy(typename traits::execution_space(),league_size_request,Kokkos::AUTO(),
-                      Kokkos::Impl::extract_vector_length<Args...>(args...)) {
+  template <class... Args>
+  TeamPolicy(const typename traits::execution_space&, int league_size_request,
+             const Kokkos::AUTO_t&, Args... args)
+      : internal_policy(typename traits::execution_space(), league_size_request,
+                        Kokkos::AUTO(),
+                        Kokkos::Impl::extract_vector_length<Args...>(args...)) {
     first_arg = true;
     set(args...);
   }
 
-  /** \brief  Construct policy with the default instance of the execution space */
-  template<class ... Args>
-  TeamPolicy( int league_size_request , int team_size_request ,
-              Args ... args)
-    : internal_policy(league_size_request,team_size_request,
-                      Kokkos::Impl::extract_vector_length<Args...>(args...)) {
+  /** \brief  Construct policy with the default instance of the execution space
+   */
+  template <class... Args>
+  TeamPolicy(int league_size_request, int team_size_request, Args... args)
+      : internal_policy(league_size_request, team_size_request,
+                        Kokkos::Impl::extract_vector_length<Args...>(args...)) {
     first_arg = true;
     set(args...);
   }
 
-  template<class ... Args>
-  TeamPolicy( int league_size_request , const Kokkos::AUTO_t & ,
-              Args ... args)
-    : internal_policy(league_size_request,Kokkos::AUTO(),
-                      Kokkos::Impl::extract_vector_length<Args...>(args...)) {
+  template <class... Args>
+  TeamPolicy(int league_size_request, const Kokkos::AUTO_t&, Args... args)
+      : internal_policy(league_size_request, Kokkos::AUTO(),
+                        Kokkos::Impl::extract_vector_length<Args...>(args...)) {
     first_arg = true;
     set(args...);
   }
 #endif
 
-  template<class ... OtherProperties>
-  TeamPolicy(const TeamPolicy<OtherProperties...> p):internal_policy(p) {
+  template <class... OtherProperties>
+  TeamPolicy(const TeamPolicy<OtherProperties...> p) : internal_policy(p) {
     first_arg = p.first_arg;
   }
 
-private:
+ private:
   bool first_arg;
-  TeamPolicy(const internal_policy& p):internal_policy(p) {first_arg = false;}
+  TeamPolicy(const internal_policy& p) : internal_policy(p) {
+    first_arg = false;
+  }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   inline void set() {}
 #endif
 
-public:
+ public:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  template<class ... Args>
-  inline void set(Args ...) {
-    static_assert( 0 == sizeof...(Args), "Kokkos::TeamPolicy: unhandled constructor arguments encountered.");
+  template <class... Args>
+  inline void set(Args...) {
+    static_assert(
+        0 == sizeof...(Args),
+        "Kokkos::TeamPolicy: unhandled constructor arguments encountered.");
   }
 
-  template<class iType, class ... Args>
-  inline typename std::enable_if<std::is_integral<iType>::value>::type set(iType, Args ... args) {
-    if(first_arg) {
+  template <class iType, class... Args>
+  inline typename std::enable_if<std::is_integral<iType>::value>::type set(
+      iType, Args... args) {
+    if (first_arg) {
       first_arg = false;
       set(args...);
     } else {
       first_arg = false;
-      Kokkos::Impl::throw_runtime_exception("Kokkos::TeamPolicy: integer argument to constructor in illegal place.");
+      Kokkos::Impl::throw_runtime_exception(
+          "Kokkos::TeamPolicy: integer argument to constructor in illegal "
+          "place.");
     }
   }
 
-  template<class ... Args>
-  inline void set(const ChunkSize& chunksize, Args ... args) {
+  template <class... Args>
+  inline void set(const ChunkSize& chunksize, Args... args) {
     first_arg = false;
     internal_policy::internal_set_chunk_size(chunksize.value);
     set(args...);
   }
 
-  template<class ... Args>
-  inline void set(const ScratchRequest& scr_request, Args ... args) {
+  template <class... Args>
+  inline void set(const ScratchRequest& scr_request, Args... args) {
     first_arg = false;
-    internal_policy::internal_set_scratch_size(scr_request.level,Impl::PerTeamValue(scr_request.per_team),
+    internal_policy::internal_set_scratch_size(
+        scr_request.level, Impl::PerTeamValue(scr_request.per_team),
         Impl::PerThreadValue(scr_request.per_thread));
     set(args...);
   }
@@ -686,267 +721,287 @@ public:
     return TeamPolicy(internal_policy::set_chunk_size(chunk));
   }
 
-  inline TeamPolicy set_scratch_size(const int& level, const Impl::PerTeamValue& per_team) const {
-    return TeamPolicy(internal_policy::set_scratch_size(level,per_team));
+  inline TeamPolicy set_scratch_size(const int& level,
+                                     const Impl::PerTeamValue& per_team) const {
+    return TeamPolicy(internal_policy::set_scratch_size(level, per_team));
   }
-  inline TeamPolicy set_scratch_size(const int& level, const Impl::PerThreadValue& per_thread) const {
-    return TeamPolicy(internal_policy::set_scratch_size(level,per_thread));
+  inline TeamPolicy set_scratch_size(
+      const int& level, const Impl::PerThreadValue& per_thread) const {
+    return TeamPolicy(internal_policy::set_scratch_size(level, per_thread));
   }
-  inline TeamPolicy set_scratch_size(const int& level, const Impl::PerTeamValue& per_team, const Impl::PerThreadValue& per_thread) const {
-    return TeamPolicy(internal_policy::set_scratch_size(level, per_team, per_thread));
+  inline TeamPolicy set_scratch_size(
+      const int& level, const Impl::PerTeamValue& per_team,
+      const Impl::PerThreadValue& per_thread) const {
+    return TeamPolicy(
+        internal_policy::set_scratch_size(level, per_team, per_thread));
   }
-  inline TeamPolicy set_scratch_size(const int& level, const Impl::PerThreadValue& per_thread, const Impl::PerTeamValue& per_team) const {
-    return TeamPolicy(internal_policy::set_scratch_size(level, per_team, per_thread));
+  inline TeamPolicy set_scratch_size(const int& level,
+                                     const Impl::PerThreadValue& per_thread,
+                                     const Impl::PerTeamValue& per_team) const {
+    return TeamPolicy(
+        internal_policy::set_scratch_size(level, per_team, per_thread));
   }
 
 #else
   inline TeamPolicy& set_chunk_size(int chunk) {
-    static_assert(std::is_same<decltype(internal_policy::set_chunk_size(chunk)), internal_policy&>::value, "internal set_chunk_size should return a reference");
+    static_assert(std::is_same<decltype(internal_policy::set_chunk_size(chunk)),
+                               internal_policy&>::value,
+                  "internal set_chunk_size should return a reference");
     return static_cast<TeamPolicy&>(internal_policy::set_chunk_size(chunk));
   }
 
-  inline TeamPolicy& set_scratch_size(const int& level, const Impl::PerTeamValue& per_team) {
-    static_assert(std::is_same<decltype(internal_policy::set_scratch_size(level,per_team)), internal_policy&>::value, "internal set_chunk_size should return a reference");
-    return static_cast<TeamPolicy&>(internal_policy::set_scratch_size(level,per_team));
+  inline TeamPolicy& set_scratch_size(const int& level,
+                                      const Impl::PerTeamValue& per_team) {
+    static_assert(std::is_same<decltype(internal_policy::set_scratch_size(
+                                   level, per_team)),
+                               internal_policy&>::value,
+                  "internal set_chunk_size should return a reference");
+    return static_cast<TeamPolicy&>(
+        internal_policy::set_scratch_size(level, per_team));
   }
-  inline TeamPolicy& set_scratch_size(const int& level, const Impl::PerThreadValue& per_thread) {
-    return static_cast<TeamPolicy&>(internal_policy::set_scratch_size(level,per_thread));
+  inline TeamPolicy& set_scratch_size(const int& level,
+                                      const Impl::PerThreadValue& per_thread) {
+    return static_cast<TeamPolicy&>(
+        internal_policy::set_scratch_size(level, per_thread));
   }
-  inline TeamPolicy& set_scratch_size(const int& level, const Impl::PerTeamValue& per_team, const Impl::PerThreadValue& per_thread) {
-    return static_cast<TeamPolicy&>(internal_policy::set_scratch_size(level, per_team, per_thread));
+  inline TeamPolicy& set_scratch_size(const int& level,
+                                      const Impl::PerTeamValue& per_team,
+                                      const Impl::PerThreadValue& per_thread) {
+    return static_cast<TeamPolicy&>(
+        internal_policy::set_scratch_size(level, per_team, per_thread));
   }
-  inline TeamPolicy& set_scratch_size(const int& level, const Impl::PerThreadValue& per_thread, const Impl::PerTeamValue& per_team) {
-    return static_cast<TeamPolicy&>(internal_policy::set_scratch_size(level, per_team, per_thread));
+  inline TeamPolicy& set_scratch_size(const int& level,
+                                      const Impl::PerThreadValue& per_thread,
+                                      const Impl::PerTeamValue& per_team) {
+    return static_cast<TeamPolicy&>(
+        internal_policy::set_scratch_size(level, per_team, per_thread));
   }
 #endif
-
 };
 
 namespace Impl {
 
-template<typename iType, class TeamMemberType>
+template <typename iType, class TeamMemberType>
 struct TeamThreadRangeBoundariesStruct {
-private:
-
-  KOKKOS_INLINE_FUNCTION static
-  iType ibegin( const iType & arg_begin
-              , const iType & arg_end
-              , const iType & arg_rank
-              , const iType & arg_size
-              )
-    {
-      return arg_begin + ( ( arg_end - arg_begin + arg_size - 1 ) / arg_size ) * arg_rank ;
-    }
-
-  KOKKOS_INLINE_FUNCTION static
-  iType iend( const iType & arg_begin
-            , const iType & arg_end
-            , const iType & arg_rank
-            , const iType & arg_size
-            )
-    {
-      const iType end_ = arg_begin + ( ( arg_end - arg_begin + arg_size - 1 ) / arg_size ) * ( arg_rank + 1 );
-      return end_ < arg_end ? end_ : arg_end ;
-    }
+ private:
+  KOKKOS_INLINE_FUNCTION static iType ibegin(const iType& arg_begin,
+                                             const iType& arg_end,
+                                             const iType& arg_rank,
+                                             const iType& arg_size) {
+    return arg_begin +
+           ((arg_end - arg_begin + arg_size - 1) / arg_size) * arg_rank;
+  }
 
-public:
+  KOKKOS_INLINE_FUNCTION static iType iend(const iType& arg_begin,
+                                           const iType& arg_end,
+                                           const iType& arg_rank,
+                                           const iType& arg_size) {
+    const iType end_ =
+        arg_begin +
+        ((arg_end - arg_begin + arg_size - 1) / arg_size) * (arg_rank + 1);
+    return end_ < arg_end ? end_ : arg_end;
+  }
 
+ public:
   typedef iType index_type;
   const iType start;
   const iType end;
-  enum {increment = 1};
+  enum { increment = 1 };
   const TeamMemberType& thread;
 
   KOKKOS_INLINE_FUNCTION
-  TeamThreadRangeBoundariesStruct( const TeamMemberType& arg_thread
-                                 , const iType& arg_end
-                                 )
-    : start( ibegin( 0 , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , end(   iend(   0 , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , thread( arg_thread )
-    {}
+  TeamThreadRangeBoundariesStruct(const TeamMemberType& arg_thread,
+                                  const iType& arg_end)
+      : start(
+            ibegin(0, arg_end, arg_thread.team_rank(), arg_thread.team_size())),
+        end(iend(0, arg_end, arg_thread.team_rank(), arg_thread.team_size())),
+        thread(arg_thread) {}
 
   KOKKOS_INLINE_FUNCTION
-  TeamThreadRangeBoundariesStruct( const TeamMemberType& arg_thread
-                                , const iType& arg_begin
-                                , const iType& arg_end
-                                )
-    : start( ibegin( arg_begin , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , end(   iend(   arg_begin , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , thread( arg_thread )
-    {}
+  TeamThreadRangeBoundariesStruct(const TeamMemberType& arg_thread,
+                                  const iType& arg_begin, const iType& arg_end)
+      : start(ibegin(arg_begin, arg_end, arg_thread.team_rank(),
+                     arg_thread.team_size())),
+        end(iend(arg_begin, arg_end, arg_thread.team_rank(),
+                 arg_thread.team_size())),
+        thread(arg_thread) {}
 };
 
-template<typename iType, class TeamMemberType>
+template <typename iType, class TeamMemberType>
 struct TeamVectorRangeBoundariesStruct {
-private:
-
-  KOKKOS_INLINE_FUNCTION static
-  iType ibegin( const iType & arg_begin
-              , const iType & arg_end
-              , const iType & arg_rank
-              , const iType & arg_size
-              )
-    {
-      return arg_begin + ( ( arg_end - arg_begin + arg_size - 1 ) / arg_size ) * arg_rank ;
-    }
-
-  KOKKOS_INLINE_FUNCTION static
-  iType iend( const iType & arg_begin
-            , const iType & arg_end
-            , const iType & arg_rank
-            , const iType & arg_size
-            )
-    {
-      const iType end_ = arg_begin + ( ( arg_end - arg_begin + arg_size - 1 ) / arg_size ) * ( arg_rank + 1 );
-      return end_ < arg_end ? end_ : arg_end ;
-    }
+ private:
+  KOKKOS_INLINE_FUNCTION static iType ibegin(const iType& arg_begin,
+                                             const iType& arg_end,
+                                             const iType& arg_rank,
+                                             const iType& arg_size) {
+    return arg_begin +
+           ((arg_end - arg_begin + arg_size - 1) / arg_size) * arg_rank;
+  }
 
-public:
+  KOKKOS_INLINE_FUNCTION static iType iend(const iType& arg_begin,
+                                           const iType& arg_end,
+                                           const iType& arg_rank,
+                                           const iType& arg_size) {
+    const iType end_ =
+        arg_begin +
+        ((arg_end - arg_begin + arg_size - 1) / arg_size) * (arg_rank + 1);
+    return end_ < arg_end ? end_ : arg_end;
+  }
 
+ public:
   typedef iType index_type;
   const iType start;
   const iType end;
-  enum {increment = 1};
+  enum { increment = 1 };
   const TeamMemberType& thread;
 
   KOKKOS_INLINE_FUNCTION
-  TeamVectorRangeBoundariesStruct( const TeamMemberType& arg_thread
-                                 , const iType& arg_end
-                                 )
-    : start( ibegin( 0 , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , end(   iend(   0 , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , thread( arg_thread )
-    {}
+  TeamVectorRangeBoundariesStruct(const TeamMemberType& arg_thread,
+                                  const iType& arg_end)
+      : start(
+            ibegin(0, arg_end, arg_thread.team_rank(), arg_thread.team_size())),
+        end(iend(0, arg_end, arg_thread.team_rank(), arg_thread.team_size())),
+        thread(arg_thread) {}
 
   KOKKOS_INLINE_FUNCTION
-  TeamVectorRangeBoundariesStruct( const TeamMemberType& arg_thread
-                                , const iType& arg_begin
-                                , const iType& arg_end
-                                )
-    : start( ibegin( arg_begin , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , end(   iend(   arg_begin , arg_end , arg_thread.team_rank() , arg_thread.team_size() ) )
-    , thread( arg_thread )
-    {}
+  TeamVectorRangeBoundariesStruct(const TeamMemberType& arg_thread,
+                                  const iType& arg_begin, const iType& arg_end)
+      : start(ibegin(arg_begin, arg_end, arg_thread.team_rank(),
+                     arg_thread.team_size())),
+        end(iend(arg_begin, arg_end, arg_thread.team_rank(),
+                 arg_thread.team_size())),
+        thread(arg_thread) {}
 };
 
-template<typename iType, class TeamMemberType>
+template <typename iType, class TeamMemberType>
 struct ThreadVectorRangeBoundariesStruct {
   typedef iType index_type;
   const index_type start;
   const index_type end;
-  enum {increment = 1};
+  enum { increment = 1 };
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ThreadVectorRangeBoundariesStruct ( const TeamMemberType, const index_type& count ) noexcept 
-  : start( static_cast<index_type>(0) )
-  , end( count ) {}
+  constexpr ThreadVectorRangeBoundariesStruct(const TeamMemberType,
+                                              const index_type& count) noexcept
+      : start(static_cast<index_type>(0)), end(count) {}
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ThreadVectorRangeBoundariesStruct ( const index_type& count ) noexcept
-  : start( static_cast<index_type>(0) )
-  , end( count ) {}
+  constexpr ThreadVectorRangeBoundariesStruct(const index_type& count) noexcept
+      : start(static_cast<index_type>(0)), end(count) {}
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ThreadVectorRangeBoundariesStruct ( const TeamMemberType, const index_type& arg_begin, const index_type& arg_end ) noexcept 
-  : start( static_cast<index_type>(arg_begin) )
-  , end( arg_end ) {}
+  constexpr ThreadVectorRangeBoundariesStruct(
+      const TeamMemberType, const index_type& arg_begin,
+      const index_type& arg_end) noexcept
+      : start(static_cast<index_type>(arg_begin)), end(arg_end) {}
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ThreadVectorRangeBoundariesStruct ( const index_type& arg_begin, const index_type& arg_end ) noexcept
-  : start( static_cast<index_type>(arg_begin) )
-  , end( arg_end ) {}
+  constexpr ThreadVectorRangeBoundariesStruct(
+      const index_type& arg_begin, const index_type& arg_end) noexcept
+      : start(static_cast<index_type>(arg_begin)), end(arg_end) {}
 };
 
-template<class TeamMemberType>
+template <class TeamMemberType>
 struct ThreadSingleStruct {
   const TeamMemberType& team_member;
   KOKKOS_INLINE_FUNCTION
-  ThreadSingleStruct( const TeamMemberType& team_member_ ) : team_member( team_member_ ) {}
+  ThreadSingleStruct(const TeamMemberType& team_member_)
+      : team_member(team_member_) {}
 };
 
-template<class TeamMemberType>
+template <class TeamMemberType>
 struct VectorSingleStruct {
   const TeamMemberType& team_member;
   KOKKOS_INLINE_FUNCTION
-  VectorSingleStruct( const TeamMemberType& team_member_ ) : team_member( team_member_ ) {}
+  VectorSingleStruct(const TeamMemberType& team_member_)
+      : team_member(team_member_) {}
 };
 
-} // namespace Impl
+}  // namespace Impl
 
 /** \brief  Execution policy for parallel work over a threads within a team.
  *
- *  The range is split over all threads in a team. The Mapping scheme depends on the architecture.
- *  This policy is used together with a parallel pattern as a nested layer within a kernel launched
- *  with the TeamPolicy. This variant expects a single count. So the range is (0,count].
+ *  The range is split over all threads in a team. The Mapping scheme depends on
+ * the architecture. This policy is used together with a parallel pattern as a
+ * nested layer within a kernel launched with the TeamPolicy. This variant
+ * expects a single count. So the range is (0,count].
  */
-template<typename iType, class TeamMemberType, class _never_use_this_overload>
+template <typename iType, class TeamMemberType, class _never_use_this_overload>
 KOKKOS_INLINE_FUNCTION_DELETED
-Impl::TeamThreadRangeBoundariesStruct<iType,TeamMemberType>
-TeamThreadRange( const TeamMemberType&, const iType& count ) = delete;
+    Impl::TeamThreadRangeBoundariesStruct<iType, TeamMemberType>
+    TeamThreadRange(const TeamMemberType&, const iType& count) = delete;
 
 /** \brief  Execution policy for parallel work over a threads within a team.
  *
- *  The range is split over all threads in a team. The Mapping scheme depends on the architecture.
- *  This policy is used together with a parallel pattern as a nested layer within a kernel launched
- *  with the TeamPolicy. This variant expects a begin and end. So the range is (begin,end].
+ *  The range is split over all threads in a team. The Mapping scheme depends on
+ * the architecture. This policy is used together with a parallel pattern as a
+ * nested layer within a kernel launched with the TeamPolicy. This variant
+ * expects a begin and end. So the range is (begin,end].
  */
-template<typename iType1, typename iType2, class TeamMemberType, class _never_use_this_overload>
-KOKKOS_INLINE_FUNCTION_DELETED
-Impl::TeamThreadRangeBoundariesStruct<typename std::common_type<iType1, iType2>::type, TeamMemberType>
-TeamThreadRange( const TeamMemberType&, const iType1& begin, const iType2& end ) = delete;
+template <typename iType1, typename iType2, class TeamMemberType,
+          class _never_use_this_overload>
+KOKKOS_INLINE_FUNCTION_DELETED Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type, TeamMemberType>
+TeamThreadRange(const TeamMemberType&, const iType1& begin,
+                const iType2& end) = delete;
 
 /** \brief  Execution policy for parallel work over a threads within a team.
  *
- *  The range is split over all threads in a team. The Mapping scheme depends on the architecture.
- *  This policy is used together with a parallel pattern as a nested layer within a kernel launched
- *  with the TeamPolicy. This variant expects a single count. So the range is (0,count].
+ *  The range is split over all threads in a team. The Mapping scheme depends on
+ * the architecture. This policy is used together with a parallel pattern as a
+ * nested layer within a kernel launched with the TeamPolicy. This variant
+ * expects a single count. So the range is (0,count].
  */
-template<typename iType, class TeamMemberType, class _never_use_this_overload>
+template <typename iType, class TeamMemberType, class _never_use_this_overload>
 KOKKOS_INLINE_FUNCTION_DELETED
-Impl::TeamThreadRangeBoundariesStruct<iType,TeamMemberType>
-TeamVectorRange( const TeamMemberType&, const iType& count ) = delete;
+    Impl::TeamThreadRangeBoundariesStruct<iType, TeamMemberType>
+    TeamVectorRange(const TeamMemberType&, const iType& count) = delete;
 
 /** \brief  Execution policy for parallel work over a threads within a team.
  *
- *  The range is split over all threads in a team. The Mapping scheme depends on the architecture.
- *  This policy is used together with a parallel pattern as a nested layer within a kernel launched
- *  with the TeamPolicy. This variant expects a begin and end. So the range is (begin,end].
+ *  The range is split over all threads in a team. The Mapping scheme depends on
+ * the architecture. This policy is used together with a parallel pattern as a
+ * nested layer within a kernel launched with the TeamPolicy. This variant
+ * expects a begin and end. So the range is (begin,end].
  */
-template<typename iType1, typename iType2, class TeamMemberType, class _never_use_this_overload>
-KOKKOS_INLINE_FUNCTION_DELETED
-Impl::TeamThreadRangeBoundariesStruct<typename std::common_type<iType1, iType2>::type, TeamMemberType>
-TeamVectorRange( const TeamMemberType&, const iType1& begin, const iType2& end ) = delete;
+template <typename iType1, typename iType2, class TeamMemberType,
+          class _never_use_this_overload>
+KOKKOS_INLINE_FUNCTION_DELETED Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type, TeamMemberType>
+TeamVectorRange(const TeamMemberType&, const iType1& begin,
+                const iType2& end) = delete;
 
 /** \brief  Execution policy for a vector parallel loop.
  *
- *  The range is split over all vector lanes in a thread. The Mapping scheme depends on the architecture.
- *  This policy is used together with a parallel pattern as a nested layer within a kernel launched
- *  with the TeamPolicy. This variant expects a single count. So the range is (0,count].
+ *  The range is split over all vector lanes in a thread. The Mapping scheme
+ * depends on the architecture. This policy is used together with a parallel
+ * pattern as a nested layer within a kernel launched with the TeamPolicy. This
+ * variant expects a single count. So the range is (0,count].
  */
-template<typename iType, class TeamMemberType, class _never_use_this_overload>
+template <typename iType, class TeamMemberType, class _never_use_this_overload>
 KOKKOS_INLINE_FUNCTION_DELETED
-Impl::ThreadVectorRangeBoundariesStruct<iType,TeamMemberType>
-ThreadVectorRange( const TeamMemberType&, const iType& count ) = delete;
+    Impl::ThreadVectorRangeBoundariesStruct<iType, TeamMemberType>
+    ThreadVectorRange(const TeamMemberType&, const iType& count) = delete;
 
-template<typename iType, class TeamMemberType, class _never_use_this_overload>
+template <typename iType, class TeamMemberType, class _never_use_this_overload>
 KOKKOS_INLINE_FUNCTION_DELETED
-Impl::ThreadVectorRangeBoundariesStruct<iType,TeamMemberType>
-ThreadVectorRange( const TeamMemberType&, const iType& arg_begin, const iType& arg_end ) = delete;
+    Impl::ThreadVectorRangeBoundariesStruct<iType, TeamMemberType>
+    ThreadVectorRange(const TeamMemberType&, const iType& arg_begin,
+                      const iType& arg_end) = delete;
 
 #if defined(KOKKOS_ENABLE_PROFILING)
 namespace Impl {
 
-template<typename FunctorType, typename TagType,
-  bool HasTag = !std::is_same<TagType, void>::value >
+template <typename FunctorType, typename TagType,
+          bool HasTag = !std::is_same<TagType, void>::value>
 struct ParallelConstructName;
 
-template<typename FunctorType, typename TagType>
+template <typename FunctorType, typename TagType>
 struct ParallelConstructName<FunctorType, TagType, true> {
-  ParallelConstructName(std::string const& label):label_ref(label) {
+  ParallelConstructName(std::string const& label) : label_ref(label) {
     if (label.empty()) {
       default_name = std::string(typeid(FunctorType).name()) + "/" +
-        typeid(TagType).name();
+                     typeid(TagType).name();
     }
   }
   std::string const& get() {
@@ -956,9 +1011,9 @@ struct ParallelConstructName<FunctorType, TagType, true> {
   std::string default_name;
 };
 
-template<typename FunctorType, typename TagType>
+template <typename FunctorType, typename TagType>
 struct ParallelConstructName<FunctorType, TagType, false> {
-  ParallelConstructName(std::string const& label):label_ref(label) {
+  ParallelConstructName(std::string const& label) : label_ref(label) {
     if (label.empty()) {
       default_name = std::string(typeid(FunctorType).name());
     }
@@ -970,49 +1025,54 @@ struct ParallelConstructName<FunctorType, TagType, false> {
   std::string default_name;
 };
 
-} // namespace Impl
+}  // namespace Impl
 #endif /* defined KOKKOS_ENABLE_PROFILING */
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Experimental {
 
 namespace Impl {
-  template<class Property,class Policy>
-  struct PolicyPropertyAdaptor;
-
-  template<unsigned long P, class ... Properties>
-  struct PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,RangePolicy<Properties...>> {
-    typedef RangePolicy<Properties...> policy_in_t;
-    typedef RangePolicy<typename policy_in_t::traits::execution_space,
-                        typename policy_in_t::traits::schedule_type,
-                        typename policy_in_t::traits::work_tag,
-                        typename policy_in_t::traits::index_type,
-                        typename policy_in_t::traits::iteration_pattern,
-                        typename policy_in_t::traits::launch_bounds,
-                        WorkItemProperty::ImplWorkItemProperty<P>> policy_out_t;
-  };
-
-  template<unsigned long P, class ... Properties>
-  struct PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,TeamPolicy<Properties...>> {
-    typedef TeamPolicy<Properties...> policy_in_t;
-    typedef TeamPolicy<typename policy_in_t::traits::execution_space,
-                        typename policy_in_t::traits::schedule_type,
-                        typename policy_in_t::traits::work_tag,
-                        typename policy_in_t::traits::index_type,
-                        typename policy_in_t::traits::iteration_pattern,
-                        typename policy_in_t::traits::launch_bounds,
-                        WorkItemProperty::ImplWorkItemProperty<P>> policy_out_t;
-  };
-}
+template <class Property, class Policy>
+struct PolicyPropertyAdaptor;
+
+template <unsigned long P, class... Properties>
+struct PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,
+                             RangePolicy<Properties...>> {
+  typedef RangePolicy<Properties...> policy_in_t;
+  typedef RangePolicy<typename policy_in_t::traits::execution_space,
+                      typename policy_in_t::traits::schedule_type,
+                      typename policy_in_t::traits::work_tag,
+                      typename policy_in_t::traits::index_type,
+                      typename policy_in_t::traits::iteration_pattern,
+                      typename policy_in_t::traits::launch_bounds,
+                      WorkItemProperty::ImplWorkItemProperty<P>>
+      policy_out_t;
+};
 
-template<class PolicyType,unsigned long P>
-constexpr typename Impl::PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,PolicyType>::policy_out_t
-  require(const PolicyType p, WorkItemProperty::ImplWorkItemProperty<P>){
-    return typename Impl::PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,PolicyType>::policy_out_t(p);
+template <unsigned long P, class... Properties>
+struct PolicyPropertyAdaptor<WorkItemProperty::ImplWorkItemProperty<P>,
+                             TeamPolicy<Properties...>> {
+  typedef TeamPolicy<Properties...> policy_in_t;
+  typedef TeamPolicy<typename policy_in_t::traits::execution_space,
+                     typename policy_in_t::traits::schedule_type,
+                     typename policy_in_t::traits::work_tag,
+                     typename policy_in_t::traits::index_type,
+                     typename policy_in_t::traits::iteration_pattern,
+                     typename policy_in_t::traits::launch_bounds,
+                     WorkItemProperty::ImplWorkItemProperty<P>>
+      policy_out_t;
+};
+}  // namespace Impl
+
+template <class PolicyType, unsigned long P>
+constexpr typename Impl::PolicyPropertyAdaptor<
+    WorkItemProperty::ImplWorkItemProperty<P>, PolicyType>::policy_out_t
+require(const PolicyType p, WorkItemProperty::ImplWorkItemProperty<P>) {
+  return typename Impl::PolicyPropertyAdaptor<
+      WorkItemProperty::ImplWorkItemProperty<P>, PolicyType>::policy_out_t(p);
 }
-} //Experimental
-} //Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 #endif /* #define KOKKOS_EXECPOLICY_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Extents.hpp b/lib/kokkos/core/src/Kokkos_Extents.hpp
index c8b9110485f6336ca38731b3233e9ccbc000b244..2e07e8b76b69e6c2fa2932d57dc3c4941cb946ce 100644
--- a/lib/kokkos/core/src/Kokkos_Extents.hpp
+++ b/lib/kokkos/core/src/Kokkos_Extents.hpp
@@ -2,10 +2,10 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
+//                        Kokkos v. 3.0
 //              Copyright (2019) Sandia Corporation
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -60,9 +60,7 @@ template <class Exts, ptrdiff_t NewExtent>
 struct PrependExtent;
 
 template <ptrdiff_t... Exts, ptrdiff_t NewExtent>
-struct PrependExtent<
-  Extents<Exts...>, NewExtent
-> {
+struct PrependExtent<Extents<Exts...>, NewExtent> {
   using type = Extents<NewExtent, Exts...>;
 };
 
@@ -70,117 +68,101 @@ template <class Exts, ptrdiff_t NewExtent>
 struct AppendExtent;
 
 template <ptrdiff_t... Exts, ptrdiff_t NewExtent>
-struct AppendExtent<
-  Extents<Exts...>, NewExtent
-> {
+struct AppendExtent<Extents<Exts...>, NewExtent> {
   using type = Extents<Exts..., NewExtent>;
 };
 
-} // end namespace Experimental
+}  // end namespace Experimental
 
 namespace Impl {
 
 namespace _parse_view_extents_impl {
 
 template <class T>
-struct _all_remaining_extents_dynamic : std::true_type { };
+struct _all_remaining_extents_dynamic : std::true_type {};
 
 template <class T>
-struct _all_remaining_extents_dynamic<T*>
-  : _all_remaining_extents_dynamic<T>
-{ };
+struct _all_remaining_extents_dynamic<T*> : _all_remaining_extents_dynamic<T> {
+};
 
 template <class T, unsigned N>
-struct _all_remaining_extents_dynamic<T[N]>
-  : std::false_type
-{ };
+struct _all_remaining_extents_dynamic<T[N]> : std::false_type {};
 
-template <class T, class Result, class=void>
+template <class T, class Result, class = void>
 struct _parse_impl {
   using type = Result;
 };
 
-// We have to treat the case of int**[x] specially, since it *doesn't* go backwards
+// We have to treat the case of int**[x] specially, since it *doesn't* go
+// backwards
 template <class T, ptrdiff_t... ExtentSpec>
 struct _parse_impl<
-  T*, Experimental::Extents<ExtentSpec...>,
-  typename std::enable_if<_all_remaining_extents_dynamic<T>::value>::type
->
-  : _parse_impl<
-      T, Experimental::Extents<Experimental::dynamic_extent, ExtentSpec...>
-    >
-{ };
+    T*, Experimental::Extents<ExtentSpec...>,
+    typename std::enable_if<_all_remaining_extents_dynamic<T>::value>::type>
+    : _parse_impl<T, Experimental::Extents<Experimental::dynamic_extent,
+                                           ExtentSpec...>> {};
 
 // int*(*[x])[y] should still work also (meaning int[][x][][y])
 template <class T, ptrdiff_t... ExtentSpec>
-struct _parse_impl<
-  T*, Experimental::Extents<ExtentSpec...>,
-  typename std::enable_if<not _all_remaining_extents_dynamic<T>::value>::type
->
-{
+struct _parse_impl<T*, Experimental::Extents<ExtentSpec...>,
+                   typename std::enable_if<
+                       not _all_remaining_extents_dynamic<T>::value>::type> {
   using _next = Kokkos::Experimental::AppendExtent<
-    typename _parse_impl<T, Experimental::Extents<ExtentSpec...>, void>::type,
-    Experimental::dynamic_extent
-  >;
+      typename _parse_impl<T, Experimental::Extents<ExtentSpec...>, void>::type,
+      Experimental::dynamic_extent>;
   using type = typename _next::type;
 };
 
 template <class T, ptrdiff_t... ExtentSpec, unsigned N>
-struct _parse_impl<
-  T[N], Experimental::Extents<ExtentSpec...>, void
->
-  : _parse_impl<
-      T, Experimental::Extents<ExtentSpec..., ptrdiff_t(N)> // TODO @pedantic this could be a narrowing cast
-    >
-{ };
+struct _parse_impl<T[N], Experimental::Extents<ExtentSpec...>, void>
+    : _parse_impl<T, Experimental::Extents<ExtentSpec...,
+                                           ptrdiff_t(N)>  // TODO @pedantic this
+                                                          // could be a
+                                                          // narrowing cast
+                  > {};
 
-} // end namespace _parse_view_extents_impl
+}  // end namespace _parse_view_extents_impl
 
 template <class DataType>
 struct ParseViewExtents {
-  using type =
-    typename _parse_view_extents_impl
-      ::_parse_impl<DataType, Experimental::Extents<>>::type;
+  using type = typename _parse_view_extents_impl ::_parse_impl<
+      DataType, Experimental::Extents<>>::type;
 };
 
 template <class ValueType, ptrdiff_t Ext>
-struct ApplyExtent
-{
+struct ApplyExtent {
   using type = ValueType[Ext];
 };
 
 template <class ValueType>
-struct ApplyExtent<ValueType, Experimental::dynamic_extent>
-{
+struct ApplyExtent<ValueType, Experimental::dynamic_extent> {
   using type = ValueType*;
 };
 
 template <class ValueType, unsigned N, ptrdiff_t Ext>
-struct ApplyExtent<ValueType[N], Ext>
-{
+struct ApplyExtent<ValueType[N], Ext> {
   using type = typename ApplyExtent<ValueType, Ext>::type[N];
 };
 
 template <class ValueType, ptrdiff_t Ext>
-struct ApplyExtent<ValueType*, Ext>
-{
-  using type = ValueType*[Ext];
+struct ApplyExtent<ValueType*, Ext> {
+  using type = ValueType * [Ext];
 };
 
 template <class ValueType>
-struct ApplyExtent<ValueType*, Experimental::dynamic_extent>
-{
-  using type = typename ApplyExtent<ValueType, Experimental::dynamic_extent>::type*;
+struct ApplyExtent<ValueType*, Experimental::dynamic_extent> {
+  using type =
+      typename ApplyExtent<ValueType, Experimental::dynamic_extent>::type*;
 };
 
 template <class ValueType, unsigned N>
-struct ApplyExtent<ValueType[N], Experimental::dynamic_extent>
-{
-  using type = typename ApplyExtent<ValueType, Experimental::dynamic_extent>::type[N];
+struct ApplyExtent<ValueType[N], Experimental::dynamic_extent> {
+  using type =
+      typename ApplyExtent<ValueType, Experimental::dynamic_extent>::type[N];
 };
 
-} // end namespace Impl
+}  // end namespace Impl
 
-} // end namespace Kokkos
+}  // end namespace Kokkos
 
-#endif //KOKKOS_KOKKOS_EXTENTS_HPP
+#endif  // KOKKOS_KOKKOS_EXTENTS_HPP
diff --git a/lib/kokkos/core/src/Kokkos_Future.hpp b/lib/kokkos/core/src/Kokkos_Future.hpp
index 665ce71cf513c02be8fca72d84a3fade1c6a15bf..15a5d39aad989a89f0897be93fafa983863028f7 100644
--- a/lib/kokkos/core/src/Kokkos_Future.hpp
+++ b/lib/kokkos/core/src/Kokkos_Future.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 //----------------------------------------------------------------------------
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core_fwd.hpp>
 #include <Kokkos_TaskScheduler_fwd.hpp>
@@ -58,7 +59,7 @@
 #include <impl/Kokkos_TaskBase.hpp>
 #include <Kokkos_Atomic.hpp>
 
-#include <Kokkos_Concepts.hpp> // is_space
+#include <Kokkos_Concepts.hpp>  // is_space
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -66,202 +67,165 @@
 namespace Kokkos {
 
 // For now, hack this in as a partial specialization
-// TODO @tasking @cleanup Make this the "normal" class template and make the old code the specialization
+// TODO @tasking @cleanup Make this the "normal" class template and make the old
+// code the specialization
 template <typename ValueType, typename ExecutionSpace, typename QueueType>
-class BasicFuture<ValueType, SimpleTaskScheduler<ExecutionSpace, QueueType>>
-{
-public:
-
-  using value_type = ValueType;
+class BasicFuture<ValueType, SimpleTaskScheduler<ExecutionSpace, QueueType>> {
+ public:
+  using value_type      = ValueType;
   using execution_space = ExecutionSpace;
-  using scheduler_type = SimpleTaskScheduler<ExecutionSpace, QueueType>;
-  using queue_type = typename scheduler_type::task_queue_type;
-
-
-private:
+  using scheduler_type  = SimpleTaskScheduler<ExecutionSpace, QueueType>;
+  using queue_type      = typename scheduler_type::task_queue_type;
 
+ private:
   template <class, class>
   friend class SimpleTaskScheduler;
   template <class, class>
   friend class BasicFuture;
 
-  using task_base_type = typename scheduler_type::task_base_type;
+  using task_base_type  = typename scheduler_type::task_base_type;
   using task_queue_type = typename scheduler_type::task_queue_type;
 
   using task_queue_traits = typename scheduler_type::task_queue_traits;
-  using task_scheduling_info_type = typename scheduler_type::task_scheduling_info_type;
+  using task_scheduling_info_type =
+      typename scheduler_type::task_scheduling_info_type;
 
-  using result_storage_type =
-    Impl::TaskResultStorage<
+  using result_storage_type = Impl::TaskResultStorage<
       ValueType,
-      Impl::SchedulingInfoStorage<
-        Impl::RunnableTaskBase<task_queue_traits>,
-        task_scheduling_info_type
-      >
-    >;
-
-
+      Impl::SchedulingInfoStorage<Impl::RunnableTaskBase<task_queue_traits>,
+                                  task_scheduling_info_type>>;
 
   OwningRawPtr<task_base_type> m_task = nullptr;
 
   KOKKOS_INLINE_FUNCTION
-  explicit
-  BasicFuture(task_base_type* task)
-    : m_task(task)
-  {
+  explicit BasicFuture(task_base_type* task) : m_task(task) {
     // Note: reference count starts at 2 to account for initial increment
-    // TODO @tasking @minor DSH verify reference count here and/or encapsulate starting reference count closer to here
+    // TODO @tasking @minor DSH verify reference count here and/or encapsulate
+    // starting reference count closer to here
   }
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  BasicFuture() noexcept : m_task(nullptr) { }
+  BasicFuture() noexcept : m_task(nullptr) {}
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture(BasicFuture&& rhs) noexcept
-    : m_task(std::move(rhs.m_task))
-  {
+  BasicFuture(BasicFuture&& rhs) noexcept : m_task(std::move(rhs.m_task)) {
     rhs.m_task = nullptr;
   }
 
   KOKKOS_INLINE_FUNCTION
   BasicFuture(BasicFuture const& rhs)
-  //  : m_task(rhs.m_task)
-    : m_task(nullptr)
-  {
+      //  : m_task(rhs.m_task)
+      : m_task(nullptr) {
     *static_cast<task_base_type* volatile*>(&m_task) = rhs.m_task;
-    if(m_task) m_task->increment_reference_count();
+    if (m_task) m_task->increment_reference_count();
   }
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture& operator=(BasicFuture&& rhs) noexcept
-  {
-    if(m_task != rhs.m_task) {
+  BasicFuture& operator=(BasicFuture&& rhs) noexcept {
+    if (m_task != rhs.m_task) {
       clear();
-      //m_task = std::move(rhs.m_task);
+      // m_task = std::move(rhs.m_task);
       *static_cast<task_base_type* volatile*>(&m_task) = rhs.m_task;
       // rhs.m_task reference count is unchanged, since this is a move
-    }
-    else {
+    } else {
       // They're the same, but this is a move, so 1 fewer references now
       rhs.clear();
     }
     rhs.m_task = nullptr;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture& operator=(BasicFuture const& rhs)
-  {
-    if(m_task != rhs.m_task) {
+  BasicFuture& operator=(BasicFuture const& rhs) {
+    if (m_task != rhs.m_task) {
       clear();
-      //m_task = rhs.m_task;
+      // m_task = rhs.m_task;
       *static_cast<task_base_type* volatile*>(&m_task) = rhs.m_task;
     }
-    if(m_task != nullptr) { m_task->increment_reference_count(); }
+    if (m_task != nullptr) {
+      m_task->increment_reference_count();
+    }
     return *this;
   }
 
   //----------------------------------------
 
   template <class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture(BasicFuture<T, S>&& rhs) noexcept // NOLINT(google-explicit-constructor)
-    : m_task(std::move(rhs.m_task))
-  {
-    static_assert(
-      std::is_same<scheduler_type, void>::value ||
-        std::is_same<scheduler_type, S>::value,
-      "Moved Futures must have the same scheduler"
-    );
-
-    static_assert(
-      std::is_same<value_type, void>::value ||
-        std::is_same<value_type, T>::value,
-      "Moved Futures must have the same value_type"
-    );
+  KOKKOS_INLINE_FUNCTION BasicFuture(
+      BasicFuture<T, S>&& rhs) noexcept  // NOLINT(google-explicit-constructor)
+      : m_task(std::move(rhs.m_task)) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Moved Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Moved Futures must have the same value_type");
 
     // reference counts are unchanged, since this is a move
     rhs.m_task = nullptr;
   }
 
   template <class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture(BasicFuture<T, S> const& rhs) // NOLINT(google-explicit-constructor)
-    //: m_task(rhs.m_task)
-    : m_task(nullptr)
-  {
-    static_assert(
-      std::is_same<scheduler_type, void>::value ||
-        std::is_same<scheduler_type, S>::value,
-      "Copied Futures must have the same scheduler"
-    );
-
-    static_assert(
-      std::is_same<value_type, void>::value ||
-        std::is_same<value_type, T>::value,
-      "Copied Futures must have the same value_type"
-    );
+  KOKKOS_INLINE_FUNCTION BasicFuture(
+      BasicFuture<T, S> const& rhs)  // NOLINT(google-explicit-constructor)
+                                     //: m_task(rhs.m_task)
+      : m_task(nullptr) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Copied Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Copied Futures must have the same value_type");
 
     *static_cast<task_base_type* volatile*>(&m_task) = rhs.m_task;
-    if(m_task) m_task->increment_reference_count();
+    if (m_task) m_task->increment_reference_count();
   }
 
   template <class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture&
-  operator=(BasicFuture<T, S> const& rhs)
-  {
-    static_assert(
-      std::is_same<scheduler_type, void>::value ||
-        std::is_same<scheduler_type, S>::value,
-      "Assigned Futures must have the same scheduler"
-    );
-
-    static_assert(
-      std::is_same<value_type, void>::value ||
-        std::is_same<value_type, T>::value,
-      "Assigned Futures must have the same value_type"
-    );
-
-    if(m_task != rhs.m_task) {
+  KOKKOS_INLINE_FUNCTION BasicFuture& operator=(BasicFuture<T, S> const& rhs) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Assigned Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Assigned Futures must have the same value_type");
+
+    if (m_task != rhs.m_task) {
       clear();
-      //m_task = rhs.m_task;
+      // m_task = rhs.m_task;
       *static_cast<task_base_type* volatile*>(&m_task) = rhs.m_task;
-      if(m_task != nullptr) { m_task->increment_reference_count(); }
+      if (m_task != nullptr) {
+        m_task->increment_reference_count();
+      }
     }
     return *this;
   }
 
-  template<class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture& operator=(BasicFuture<T, S>&& rhs)
-  {
-    static_assert(
-      std::is_same<scheduler_type, void>::value ||
-        std::is_same<scheduler_type, S>::value,
-      "Assigned Futures must have the same scheduler"
-    );
-
-    static_assert(
-      std::is_same<value_type, void>::value ||
-        std::is_same<value_type, T>::value,
-      "Assigned Futures must have the same value_type"
-    );
-
-    if(m_task != rhs.m_task) {
+  template <class T, class S>
+  KOKKOS_INLINE_FUNCTION BasicFuture& operator=(BasicFuture<T, S>&& rhs) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Assigned Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Assigned Futures must have the same value_type");
+
+    if (m_task != rhs.m_task) {
       clear();
-      //m_task = std::move(rhs.m_task);
+      // m_task = std::move(rhs.m_task);
       *static_cast<task_base_type* volatile*>(&m_task) = rhs.m_task;
       // rhs.m_task reference count is unchanged, since this is a move
-    }
-    else {
+    } else {
       // They're the same, but this is a move, so 1 fewer references now
       rhs.clear();
     }
     rhs.m_task = nullptr;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -271,22 +235,19 @@ public:
 
   KOKKOS_INLINE_FUNCTION
   void clear() noexcept {
-    if(m_task) {
+    if (m_task) {
       bool should_delete = m_task->decrement_and_check_reference_count();
-      if(should_delete) {
+      if (should_delete) {
         static_cast<task_queue_type*>(m_task->ready_queue_base_ptr())
-          ->deallocate(std::move(*m_task));
+            ->deallocate(std::move(*m_task));
       }
     }
-    //m_task = nullptr;
+    // m_task = nullptr;
     *static_cast<task_base_type* volatile*>(&m_task) = nullptr;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool is_null() const noexcept {
-    return m_task == nullptr;
-  }
-
+  bool is_null() const noexcept { return m_task == nullptr; }
 
   KOKKOS_INLINE_FUNCTION
   bool is_ready() const noexcept {
@@ -294,14 +255,11 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  const typename Impl::TaskResult< ValueType >::reference_type
-  get() const
-  {
+  const typename Impl::TaskResult<ValueType>::reference_type get() const {
     KOKKOS_EXPECTS(is_ready());
     return static_cast<result_storage_type*>(m_task)->value_reference();
-    //return Impl::TaskResult<ValueType>::get(m_task);
+    // return Impl::TaskResult<ValueType>::get(m_task);
   }
-
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -310,57 +268,57 @@ public:
 
 template <typename ValueType, typename Scheduler>
 class BasicFuture {
-private:
-
-  template< typename , typename > friend class BasicTaskScheduler ;
-  template< typename , typename > friend class BasicFuture ;
-  friend class Impl::TaskBase ;
-  template< typename , typename , typename > friend class Impl::Task ;
-
+ private:
+  template <typename, typename>
+  friend class BasicTaskScheduler;
+  template <typename, typename>
+  friend class BasicFuture;
+  friend class Impl::TaskBase;
+  template <typename, typename, typename>
+  friend class Impl::Task;
 
   //----------------------------------------
 
-public:
-
+ public:
   //----------------------------------------
 
-  using scheduler_type = Scheduler;
-  using queue_type = typename scheduler_type::queue_type;
+  using scheduler_type  = Scheduler;
+  using queue_type      = typename scheduler_type::queue_type;
   using execution_space = typename scheduler_type::execution_space;
-  using value_type = ValueType;
+  using value_type      = ValueType;
 
   //----------------------------------------
 
-private:
-
+ private:
   //----------------------------------------
 
-  using task_base  = Impl::TaskBase;
+  using task_base = Impl::TaskBase;
 
-  task_base * m_task ;
+  task_base* m_task;
 
-  KOKKOS_INLINE_FUNCTION explicit
-  BasicFuture( task_base * task ) : m_task(0)
-  { if ( task ) queue_type::assign( & m_task , task ); }
+  KOKKOS_INLINE_FUNCTION explicit BasicFuture(task_base* task) : m_task(0) {
+    if (task) queue_type::assign(&m_task, task);
+  }
 
   //----------------------------------------
 
-public:
-
+ public:
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  bool is_null() const { return 0 == m_task ; }
+  bool is_null() const { return 0 == m_task; }
 
   KOKKOS_INLINE_FUNCTION
-  int reference_count() const
-  { return 0 != m_task ? m_task->reference_count() : 0 ; }
+  int reference_count() const {
+    return 0 != m_task ? m_task->reference_count() : 0;
+  }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  void clear()
-  { if ( m_task ) queue_type::assign( & m_task , (task_base*)0 ); }
+  void clear() {
+    if (m_task) queue_type::assign(&m_task, (task_base*)0);
+  }
 
   //----------------------------------------
 
@@ -370,141 +328,121 @@ public:
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture() noexcept : m_task(nullptr) { }
+  BasicFuture() noexcept : m_task(nullptr) {}
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture( BasicFuture && rhs ) noexcept
-    : m_task( rhs.m_task )
-  {
+  BasicFuture(BasicFuture&& rhs) noexcept : m_task(rhs.m_task) {
     rhs.m_task = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture( const BasicFuture & rhs )
-    : m_task(0)
-  { if ( rhs.m_task ) queue_type::assign( & m_task , rhs.m_task ); }
+  BasicFuture(const BasicFuture& rhs) : m_task(0) {
+    if (rhs.m_task) queue_type::assign(&m_task, rhs.m_task);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture& operator=(BasicFuture&& rhs) noexcept
-  {
+  BasicFuture& operator=(BasicFuture&& rhs) noexcept {
     clear();
-    m_task = rhs.m_task ;
-    rhs.m_task = 0 ;
-    return *this ;
+    m_task     = rhs.m_task;
+    rhs.m_task = 0;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  BasicFuture& operator=(BasicFuture const& rhs)
-  {
-    if ( m_task || rhs.m_task ) queue_type::assign( & m_task , rhs.m_task );
-    return *this ;
+  BasicFuture& operator=(BasicFuture const& rhs) {
+    if (m_task || rhs.m_task) queue_type::assign(&m_task, rhs.m_task);
+    return *this;
   }
 
   //----------------------------------------
 
   template <class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture(BasicFuture<T, S>&& rhs) noexcept // NOLINT(google-explicit-constructor)
-    : m_task( rhs.m_task )
-  {
-    static_assert
-      ( std::is_same<scheduler_type, void>::value ||
-          std::is_same<scheduler_type, S>::value
-        , "Assigned Futures must have the same scheduler" );
-
-    static_assert
-      ( std::is_same< value_type , void >::value ||
-          std::is_same<value_type, T>::value
-        , "Assigned Futures must have the same value_type" );
-
-    rhs.m_task = 0 ;
+  KOKKOS_INLINE_FUNCTION BasicFuture(
+      BasicFuture<T, S>&& rhs) noexcept  // NOLINT(google-explicit-constructor)
+      : m_task(rhs.m_task) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Assigned Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Assigned Futures must have the same value_type");
+
+    rhs.m_task = 0;
   }
 
   template <class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture(BasicFuture<T, S> const& rhs) // NOLINT(google-explicit-constructor)
-    : m_task(nullptr)
-  {
-    static_assert
-      ( std::is_same<scheduler_type, void>::value ||
-          std::is_same<scheduler_type, S>::value
-        , "Assigned Futures must have the same scheduler" );
-
-    static_assert
-      ( std::is_same< value_type , void >::value ||
-          std::is_same<value_type, T>::value
-        , "Assigned Futures must have the same value_type" );
-
-    if ( rhs.m_task ) queue_type::assign( & m_task , rhs.m_task );
+  KOKKOS_INLINE_FUNCTION BasicFuture(
+      BasicFuture<T, S> const& rhs)  // NOLINT(google-explicit-constructor)
+      : m_task(nullptr) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Assigned Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Assigned Futures must have the same value_type");
+
+    if (rhs.m_task) queue_type::assign(&m_task, rhs.m_task);
   }
 
   template <class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture&
-  operator=(BasicFuture<T, S> const& rhs)
-  {
-    static_assert
-      ( std::is_same<scheduler_type, void>::value ||
-          std::is_same<scheduler_type, S>::value
-        , "Assigned Futures must have the same scheduler" );
-
-    static_assert
-      ( std::is_same< value_type , void >::value ||
-          std::is_same<value_type, T>::value
-        , "Assigned Futures must have the same value_type" );
-
-    if ( m_task || rhs.m_task ) queue_type::assign( & m_task , rhs.m_task );
-    return *this ;
+  KOKKOS_INLINE_FUNCTION BasicFuture& operator=(BasicFuture<T, S> const& rhs) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Assigned Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Assigned Futures must have the same value_type");
+
+    if (m_task || rhs.m_task) queue_type::assign(&m_task, rhs.m_task);
+    return *this;
   }
 
-  template<class T, class S>
-  KOKKOS_INLINE_FUNCTION
-  BasicFuture& operator=(BasicFuture<T, S>&& rhs)
-  {
-    static_assert
-      ( std::is_same<scheduler_type, void>::value ||
-          std::is_same<scheduler_type, S>::value
-        , "Assigned Futures must have the same scheduler" );
-
-    static_assert
-      ( std::is_same< value_type , void >::value ||
-          std::is_same<value_type, T>::value
-        , "Assigned Futures must have the same value_type" );
+  template <class T, class S>
+  KOKKOS_INLINE_FUNCTION BasicFuture& operator=(BasicFuture<T, S>&& rhs) {
+    static_assert(std::is_same<scheduler_type, void>::value ||
+                      std::is_same<scheduler_type, S>::value,
+                  "Assigned Futures must have the same scheduler");
+
+    static_assert(std::is_same<value_type, void>::value ||
+                      std::is_same<value_type, T>::value,
+                  "Assigned Futures must have the same value_type");
 
     clear();
-    m_task = rhs.m_task ;
-    rhs.m_task = 0 ;
-    return *this ;
+    m_task     = rhs.m_task;
+    rhs.m_task = 0;
+    return *this;
   }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  int is_ready() const noexcept
-  { return ( 0 == m_task ) || ( ((task_base*) task_base::LockTag) == m_task->m_wait ); }
+  int is_ready() const noexcept {
+    return (0 == m_task) ||
+           (((task_base*)task_base::LockTag) == m_task->m_wait);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const typename Impl::TaskResult< ValueType >::reference_type
-  get() const
-  {
-    if ( 0 == m_task ) {
-      Kokkos::abort( "Kokkos:::Future::get ERROR: is_null()");
+  const typename Impl::TaskResult<ValueType>::reference_type get() const {
+    if (0 == m_task) {
+      Kokkos::abort("Kokkos:::Future::get ERROR: is_null()");
     }
-    return Impl::TaskResult< ValueType >::get( m_task );
+    return Impl::TaskResult<ValueType>::get(m_task);
   }
 };
 
 // Is a Future with the given execution space
-template< typename , typename ExecSpace = void >
+template <typename, typename ExecSpace = void>
 struct is_future : public std::false_type {};
 
-template<typename ValueType, typename Scheduler, typename ExecSpace>
+template <typename ValueType, typename Scheduler, typename ExecSpace>
 struct is_future<BasicFuture<ValueType, Scheduler>, ExecSpace>
-  : std::integral_constant<bool,
-      std::is_same<ExecSpace, typename Scheduler::execution_space>::value
-      || std::is_void<ExecSpace>::value
-    >
-{};
+    : std::integral_constant<
+          bool,
+          std::is_same<ExecSpace, typename Scheduler::execution_space>::value ||
+              std::is_void<ExecSpace>::value> {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // END OLD CODE
@@ -514,39 +452,32 @@ namespace Impl {
 
 template <class Arg1, class Arg2>
 class ResolveFutureArgOrder {
-private:
+ private:
   enum { Arg1_is_space = Kokkos::is_space<Arg1>::value };
   enum { Arg2_is_space = Kokkos::is_space<Arg2>::value };
   enum { Arg1_is_value = !Arg1_is_space && !std::is_same<Arg1, void>::value };
   enum { Arg2_is_value = !Arg2_is_space && !std::is_same<Arg2, void>::value };
 
-  static_assert(
-    ! ( Arg1_is_space && Arg2_is_space ),
-    "Future cannot be given two spaces"
-  );
-
-  static_assert(
-    ! ( Arg1_is_value && Arg2_is_value ),
-    "Future cannot be given two value types"
-  );
+  static_assert(!(Arg1_is_space && Arg2_is_space),
+                "Future cannot be given two spaces");
 
-  using value_type =
-    typename std::conditional<Arg1_is_value, Arg1,
-      typename std::conditional<Arg2_is_value, Arg2, void>::type
-    >::type;
+  static_assert(!(Arg1_is_value && Arg2_is_value),
+                "Future cannot be given two value types");
 
-  using execution_space =
-    typename std::conditional<Arg1_is_space, Arg1,
-      typename std::conditional<Arg2_is_space, Arg2, void>::type
-    >::type::execution_space;
+  using value_type = typename std::conditional<
+      Arg1_is_value, Arg1,
+      typename std::conditional<Arg2_is_value, Arg2, void>::type>::type;
 
-public:
+  using execution_space = typename std::conditional<
+      Arg1_is_space, Arg1,
+      typename std::conditional<Arg2_is_space, Arg2,
+                                void>::type>::type::execution_space;
 
+ public:
   using type = BasicFuture<value_type, TaskScheduler<execution_space>>;
-
 };
 
-} // end namespace Impl
+}  // end namespace Impl
 
 /**
  *
@@ -558,7 +489,7 @@ public:
 template <class Arg1 = void, class Arg2 = void>
 using Future = typename Impl::ResolveFutureArgOrder<Arg1, Arg2>::type;
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/lib/kokkos/core/src/Kokkos_HBWSpace.hpp b/lib/kokkos/core/src/Kokkos_HBWSpace.hpp
index aaac7cd7f9511fbb46e703bda73ece6a9ee10cc1..c1f03f8962b0ad14788b3eb092b115478635a51f 100644
--- a/lib/kokkos/core/src/Kokkos_HBWSpace.hpp
+++ b/lib/kokkos/core/src/Kokkos_HBWSpace.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -68,7 +69,7 @@ void init_lock_array_hbw_space();
 /// This function tries to acquire the lock for the hash value derived
 /// from the provided ptr. If the lock is successfully acquired the
 /// function returns true. Otherwise it returns false.
-bool lock_address_hbw_space( void* ptr );
+bool lock_address_hbw_space(void* ptr);
 
 /// \brief Release lock for the address
 ///
@@ -76,13 +77,13 @@ bool lock_address_hbw_space( void* ptr );
 /// from the provided ptr. This function should only be called
 /// after previously successfully acquiring a lock with
 /// lock_address.
-void unlock_address_hbw_space( void* ptr );
+void unlock_address_hbw_space(void* ptr);
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Experimental
+}  // namespace Experimental
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
@@ -94,10 +95,10 @@ namespace Experimental {
 /// HBWSpace is a memory space that governs host memory.  "Host"
 /// memory means the usual CPU-accessible memory.
 class HBWSpace {
-public:
+ public:
   //! Tag this class as a kokkos memory space
-  typedef HBWSpace  memory_space;
-  typedef size_t     size_type;
+  typedef HBWSpace memory_space;
+  typedef size_t size_type;
 
   /// \typedef execution_space
   /// \brief Default execution space for this memory space.
@@ -105,59 +106,64 @@ public:
   /// Every memory space has a default execution space.  This is
   /// useful for things like initializing a View (which happens in
   /// parallel using the View's default execution space).
-#if defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP )
-  typedef Kokkos::OpenMP    execution_space;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS )
-  typedef Kokkos::Threads   execution_space;
+#if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
+  typedef Kokkos::OpenMP execution_space;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
+  typedef Kokkos::Threads execution_space;
 //#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS )
 //  typedef Kokkos::Qthreads  execution_space;
-#elif defined( KOKKOS_ENABLE_OPENMP )
-  typedef Kokkos::OpenMP    execution_space;
-#elif defined( KOKKOS_ENABLE_THREADS )
-  typedef Kokkos::Threads   execution_space;
+#elif defined(KOKKOS_ENABLE_OPENMP)
+  typedef Kokkos::OpenMP execution_space;
+#elif defined(KOKKOS_ENABLE_THREADS)
+  typedef Kokkos::Threads execution_space;
 //#elif defined( KOKKOS_ENABLE_QTHREADS )
 //  typedef Kokkos::Qthreads  execution_space;
-#elif defined( KOKKOS_ENABLE_SERIAL )
-  typedef Kokkos::Serial    execution_space;
+#elif defined(KOKKOS_ENABLE_SERIAL)
+  typedef Kokkos::Serial execution_space;
 #else
-#  error "At least one of the following host execution spaces must be defined: Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qhreads, or Kokkos::Serial.  You might be seeing this message if you disabled the Kokkos::Serial device explicitly using the Kokkos_ENABLE_Serial:BOOL=OFF CMake option, but did not enable any of the other host execution space devices."
+#error \
+    "At least one of the following host execution spaces must be defined: Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qhreads, or Kokkos::Serial.  You might be seeing this message if you disabled the Kokkos::Serial device explicitly using the Kokkos_ENABLE_Serial:BOOL=OFF CMake option, but did not enable any of the other host execution space devices."
 #endif
 
   //! This memory space preferred device_type
-  typedef Kokkos::Device< execution_space, memory_space > device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
   /**\brief  Default memory space instance */
   HBWSpace();
-  HBWSpace( const HBWSpace & rhs ) = default;
-  HBWSpace & operator = ( const HBWSpace & ) = default;
-  ~HBWSpace() = default;
+  HBWSpace(const HBWSpace& rhs) = default;
+  HBWSpace& operator=(const HBWSpace&) = default;
+  ~HBWSpace()                          = default;
 
-  /**\brief  Non-default memory space instance to choose allocation mechansim, if available */
+  /**\brief  Non-default memory space instance to choose allocation mechansim,
+   * if available */
 
-  enum AllocationMechanism { STD_MALLOC, POSIX_MEMALIGN, POSIX_MMAP, INTEL_MM_ALLOC };
+  enum AllocationMechanism {
+    STD_MALLOC,
+    POSIX_MEMALIGN,
+    POSIX_MMAP,
+    INTEL_MM_ALLOC
+  };
 
-  explicit
-  HBWSpace( const AllocationMechanism & );
+  explicit HBWSpace(const AllocationMechanism&);
 
   /**\brief  Allocate untracked memory in the space */
-  void * allocate( const size_t arg_alloc_size ) const;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the space */
-  void deallocate( void * const arg_alloc_ptr
-                 , const size_t arg_alloc_size ) const;
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return "HBW"; }
 
-private:
-
-  AllocationMechanism  m_alloc_mech;
-  friend class Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::HBWSpace, void >;
+ private:
+  AllocationMechanism m_alloc_mech;
+  friend class Kokkos::Impl::SharedAllocationRecord<
+      Kokkos::Experimental::HBWSpace, void>;
 };
 
-} // namespace Experimental
+}  // namespace Experimental
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -165,20 +171,18 @@ namespace Kokkos {
 
 namespace Impl {
 
-template<>
-class SharedAllocationRecord< Kokkos::Experimental::HBWSpace, void >
-  : public SharedAllocationRecord< void, void >
-{
-private:
-
+template <>
+class SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
   friend Kokkos::Experimental::HBWSpace;
 
-  typedef SharedAllocationRecord< void, void >  RecordBase;
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete;
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static void deallocate( RecordBase * );
+  static void deallocate(RecordBase*);
 
 #ifdef KOKKOS_DEBUG
   /**\brief  Root record for tracked allocations from this HBWSpace instance */
@@ -187,61 +191,52 @@ private:
 
   const Kokkos::Experimental::HBWSpace m_space;
 
-protected:
-
+ protected:
   ~SharedAllocationRecord();
   SharedAllocationRecord() = default;
 
-  SharedAllocationRecord( const Kokkos::Experimental::HBWSpace & arg_space
-                        , const std::string                    & arg_label
-                        , const size_t                           arg_alloc_size
-                        , const RecordBase::function_type        arg_dealloc = & deallocate
-                        );
-
-public:
-
-  inline
-  std::string get_label() const
-    {
-      return std::string( RecordBase::head()->m_label );
-    }
-
-  KOKKOS_INLINE_FUNCTION static
-  SharedAllocationRecord * allocate( const Kokkos::Experimental::HBWSpace & arg_space
-                                   , const std::string                    & arg_label
-                                   , const size_t                           arg_alloc_size
-                                   )
-    {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      return new SharedAllocationRecord( arg_space, arg_label, arg_alloc_size );
+  SharedAllocationRecord(
+      const Kokkos::Experimental::HBWSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
+
+ public:
+  inline std::string get_label() const {
+    return std::string(RecordBase::head()->m_label);
+  }
+
+  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
+      const Kokkos::Experimental::HBWSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size) {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
 #else
-      return (SharedAllocationRecord *) 0;
+    return (SharedAllocationRecord*)0;
 #endif
-    }
+  }
 
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::Experimental::HBWSpace & arg_space
-                         , const std::string                    & arg_label
-                         , const size_t                           arg_alloc_size );
+  static void* allocate_tracked(const Kokkos::Experimental::HBWSpace& arg_space,
+                                const std::string& arg_label,
+                                const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
+  static void deallocate_tracked(void* const arg_alloc_ptr);
 
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
 
-  static void print_records( std::ostream &, const Kokkos::Experimental::HBWSpace &, bool detail = false );
+  static void print_records(std::ostream&,
+                            const Kokkos::Experimental::HBWSpace&,
+                            bool detail = false);
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -249,25 +244,28 @@ namespace Kokkos {
 
 namespace Impl {
 
-static_assert( Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::HBWSpace, Kokkos::Experimental::HBWSpace >::assignable, "" );
+static_assert(
+    Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::HBWSpace,
+                                    Kokkos::Experimental::HBWSpace>::assignable,
+    "");
 
-template<>
-struct MemorySpaceAccess< Kokkos::HostSpace, Kokkos::Experimental::HBWSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::HostSpace, Kokkos::Experimental::HBWSpace> {
   enum { assignable = true };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::Experimental::HBWSpace, Kokkos::HostSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::Experimental::HBWSpace, Kokkos::HostSpace> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -275,70 +273,64 @@ namespace Kokkos {
 
 namespace Impl {
 
-template< class ExecutionSpace >
-struct DeepCopy< Experimental::HBWSpace, Experimental::HBWSpace, ExecutionSpace > {
-  DeepCopy( void * dst, const void * src, size_t n ) {
-    memcpy( dst, src, n );
-  }
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::HBWSpace, Kokkos::Experimental::HBWSpace,
+                ExecutionSpace> {
+  DeepCopy(void* dst, const void* src, size_t n) { memcpy(dst, src, n); }
 
-  DeepCopy( const ExecutionSpace& exec, void * dst, const void * src, size_t n ) {
+  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence();
-    memcpy( dst, src, n );
+    memcpy(dst, src, n);
   }
 };
 
-template< class ExecutionSpace >
-struct DeepCopy< HostSpace, Experimental::HBWSpace, ExecutionSpace > {
-  DeepCopy( void * dst, const void * src, size_t n ) {
-    memcpy( dst, src, n );
-  }
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, Kokkos::Experimental::HBWSpace, ExecutionSpace> {
+  DeepCopy(void* dst, const void* src, size_t n) { memcpy(dst, src, n); }
 
-  DeepCopy( const ExecutionSpace& exec, void * dst, const void * src, size_t n ) {
+  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence();
-    memcpy( dst, src, n );
+    memcpy(dst, src, n);
   }
 };
 
-template< class ExecutionSpace >
-struct DeepCopy< Experimental::HBWSpace, HostSpace, ExecutionSpace > {
-  DeepCopy( void * dst, const void * src, size_t n ) {
-    memcpy( dst, src, n );
-  }
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::HBWSpace, HostSpace, ExecutionSpace> {
+  DeepCopy(void* dst, const void* src, size_t n) { memcpy(dst, src, n); }
 
-  DeepCopy( const ExecutionSpace& exec, void * dst, const void * src, size_t n ) {
+  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence();
-    memcpy( dst, src, n );
+    memcpy(dst, src, n);
   }
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
 namespace Impl {
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace, Kokkos::Experimental::HBWSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::HostSpace,
+                                           Kokkos::Experimental::HBWSpace> {
   enum { value = true };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::Experimental::HBWSpace, Kokkos::HostSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::Experimental::HBWSpace,
+                                           Kokkos::HostSpace> {
   enum { value = true };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif
-#endif // #define KOKKOS_HBWSPACE_HPP
-
+#endif  // #define KOKKOS_HBWSPACE_HPP
diff --git a/lib/kokkos/core/src/Kokkos_HPX.hpp b/lib/kokkos/core/src/Kokkos_HPX.hpp
index 79a2b74da493e8b3cc01f4877091cd363d55c3ae..46101c824f24e6a62512a9a927b776b67ab61e6f 100644
--- a/lib/kokkos/core/src/Kokkos_HPX.hpp
+++ b/lib/kokkos/core/src/Kokkos_HPX.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,6 +58,7 @@
 #include <Kokkos_HBWSpace.hpp>
 #endif
 
+#include <HPX/Kokkos_HPX_ChunkedRoundRobinExecutor.hpp>
 #include <Kokkos_HostSpace.hpp>
 #include <Kokkos_Layout.hpp>
 #include <Kokkos_MemoryTraits.hpp>
@@ -74,7 +76,7 @@
 #include <hpx/apply.hpp>
 #include <hpx/hpx_start.hpp>
 #include <hpx/lcos/local/barrier.hpp>
-#include <hpx/lcos/local/counting_semaphore.hpp>
+#include <hpx/lcos/local/latch.hpp>
 #include <hpx/parallel/algorithms/for_loop.hpp>
 #include <hpx/parallel/algorithms/reduce.hpp>
 #include <hpx/parallel/executors/static_chunk_size.hpp>
@@ -97,6 +99,7 @@
 // - 1: The manual way. This way is more verbose and does not take advantage of
 //      e.g. parallel::for_loop in HPX but it is significantly faster in many
 //      benchmarks.
+// - 2: Like 1, but spawn tasks using for_loop and a custom executor.
 //
 // In the long run 0 should be the preferred implementation, but until HPX is
 // improved 1 will be the default.
@@ -104,7 +107,7 @@
 #define KOKKOS_HPX_IMPLEMENTATION 1
 #endif
 
-#if (KOKKOS_HPX_IMPLEMENTATION < 0) || (KOKKOS_HPX_IMPLEMENTATION > 1)
+#if (KOKKOS_HPX_IMPLEMENTATION < 0) || (KOKKOS_HPX_IMPLEMENTATION > 2)
 #error "You have chosen an invalid value for KOKKOS_HPX_IMPLEMENTATION"
 #endif
 
@@ -123,9 +126,11 @@ class thread_buffer {
            m_cache_line_size;
   }
 
-public:
+ public:
   thread_buffer()
-      : m_num_threads(0), m_size_per_thread(0), m_size_total(0),
+      : m_num_threads(0),
+        m_size_per_thread(0),
+        m_size_total(0),
         m_data(nullptr) {}
   thread_buffer(const std::size_t num_threads,
                 const std::size_t size_per_thread) {
@@ -134,13 +139,13 @@ public:
   ~thread_buffer() { delete[] m_data; }
 
   thread_buffer(const thread_buffer &) = delete;
-  thread_buffer(thread_buffer &&) = delete;
+  thread_buffer(thread_buffer &&)      = delete;
   thread_buffer &operator=(const thread_buffer &) = delete;
   thread_buffer &operator=(thread_buffer) = delete;
 
   void resize(const std::size_t num_threads,
               const std::size_t size_per_thread) {
-    m_num_threads = num_threads;
+    m_num_threads     = num_threads;
     m_size_per_thread = size_per_thread;
 
     pad_to_cache_line(m_size_per_thread);
@@ -149,7 +154,7 @@ public:
 
     if (m_size_total < size_total_new) {
       delete[] m_data;
-      m_data = new char[size_total_new];
+      m_data       = new char[size_total_new];
       m_size_total = size_total_new;
     }
   }
@@ -165,23 +170,23 @@ public:
   std::size_t size_per_thread() const noexcept { return m_size_per_thread; }
   std::size_t size_total() const noexcept { return m_size_total; }
 };
-} // namespace Impl
+}  // namespace Impl
 
 namespace Experimental {
 class HPX {
-private:
+ private:
   static bool m_hpx_initialized;
   static Kokkos::Impl::thread_buffer m_buffer;
 #if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
   static hpx::future<void> m_future;
 #endif
 
-public:
-  using execution_space = HPX;
-  using memory_space = HostSpace;
-  using device_type = Kokkos::Device<execution_space, memory_space>;
-  using array_layout = LayoutRight;
-  using size_type = memory_space::size_type;
+ public:
+  using execution_space      = HPX;
+  using memory_space         = HostSpace;
+  using device_type          = Kokkos::Device<execution_space, memory_space>;
+  using array_layout         = LayoutRight;
+  using size_type            = memory_space::size_type;
   using scratch_memory_space = ScratchMemorySpace<HPX>;
 
   HPX() noexcept {}
@@ -192,26 +197,20 @@ public:
 
   static bool in_parallel(HPX const & = HPX()) noexcept { return false; }
   static void impl_static_fence(HPX const & = HPX())
-  #if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-    {
-      if (hpx::threads::get_self_ptr() == nullptr) {
-        hpx::threads::run_as_hpx_thread([]() { impl_get_future().wait(); });
-      } else {
-        impl_get_future().wait();
-      }
-    }
-  #else
-        noexcept {
+#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
+  {
+    if (hpx::threads::get_self_ptr() == nullptr) {
+      hpx::threads::run_as_hpx_thread([]() { impl_get_future().wait(); });
+    } else {
+      impl_get_future().wait();
     }
-  #endif
-
-  #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  static void fence(HPX const & = HPX()) {
-  #else
-  void fence() const {
-  #endif
-    impl_static_fence();
   }
+#else
+      noexcept {
+  }
+#endif
+
+  void fence() const { impl_static_fence(); }
 
   static bool is_asynchronous(HPX const & = HPX()) noexcept {
 #if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
@@ -222,8 +221,9 @@ public:
   }
 
   static std::vector<HPX> partition(...) {
-    Kokkos::abort("Kokkos::Experimental::HPX::partition_master: can't partition an HPX "
-                  "instance\n");
+    Kokkos::abort(
+        "Kokkos::Experimental::HPX::partition_master: can't partition an HPX "
+        "instance\n");
     return std::vector<HPX>();
   }
 
@@ -231,8 +231,9 @@ public:
   static void partition_master(F const &f, int requested_num_partitions = 0,
                                int requested_partition_size = 0) {
     if (requested_num_partitions > 1) {
-      Kokkos::abort("Kokkos::Experimental::HPX::partition_master: can't partition an "
-                    "HPX instance\n");
+      Kokkos::abort(
+          "Kokkos::Experimental::HPX::partition_master: can't partition an "
+          "HPX instance\n");
     }
   }
 
@@ -287,13 +288,14 @@ public:
   static Kokkos::Impl::thread_buffer &impl_get_buffer() noexcept {
     return m_buffer;
   }
+
 #if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
   static hpx::future<void> &impl_get_future() noexcept { return m_future; }
 #endif
 
   static constexpr const char *name() noexcept { return "HPX"; }
 };
-} // namespace Experimental
+}  // namespace Experimental
 
 namespace Impl {
 template <typename Closure>
@@ -302,15 +304,15 @@ inline void dispatch_execute_task(Closure *closure) {
   if (hpx::threads::get_self_ptr() == nullptr) {
     hpx::threads::run_as_hpx_thread([closure]() {
       hpx::future<void> &fut = Kokkos::Experimental::HPX::impl_get_future();
-      Closure closure_copy = *closure;
-      fut = fut.then([closure_copy](hpx::future<void> &&) {
+      Closure closure_copy   = *closure;
+      fut                    = fut.then([closure_copy](hpx::future<void> &&) {
         closure_copy.execute_task();
       });
     });
   } else {
     hpx::future<void> &fut = Kokkos::Experimental::HPX::impl_get_future();
-    Closure closure_copy = *closure;
-    fut = fut.then(
+    Closure closure_copy   = *closure;
+    fut                    = fut.then(
         [closure_copy](hpx::future<void> &&) { closure_copy.execute_task(); });
   }
 #else
@@ -321,8 +323,8 @@ inline void dispatch_execute_task(Closure *closure) {
   }
 #endif
 }
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
@@ -342,15 +344,16 @@ struct VerifyExecutionCanAccessMemorySpace<
   inline static void verify(void) {}
   inline static void verify(const void *) {}
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Experimental {
-template <> class UniqueToken<HPX, UniqueTokenScope::Instance> {
-public:
+template <>
+class UniqueToken<HPX, UniqueTokenScope::Instance> {
+ public:
   using execution_space = HPX;
-  using size_type = int;
+  using size_type       = int;
   UniqueToken(execution_space const & = execution_space()) noexcept {}
 
   // NOTE: Currently this assumes that there is no oversubscription.
@@ -361,10 +364,11 @@ public:
   void release(int) const noexcept {}
 };
 
-template <> class UniqueToken<HPX, UniqueTokenScope::Global> {
-public:
+template <>
+class UniqueToken<HPX, UniqueTokenScope::Global> {
+ public:
   using execution_space = HPX;
-  using size_type = int;
+  using size_type       = int;
   UniqueToken(execution_space const & = execution_space()) noexcept {}
 
   // NOTE: Currently this assumes that there is no oversubscription.
@@ -374,28 +378,27 @@ public:
   int acquire() const noexcept { return HPX::impl_hardware_thread_id(); }
   void release(int) const noexcept {}
 };
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 
 struct HPXTeamMember {
-public:
+ public:
   using execution_space = Kokkos::Experimental::HPX;
   using scratch_memory_space =
       Kokkos::ScratchMemorySpace<Kokkos::Experimental::HPX>;
 
-private:
+ private:
   scratch_memory_space m_team_shared;
-  std::size_t m_team_shared_size;
 
   int m_league_size;
   int m_league_rank;
   int m_team_size;
   int m_team_rank;
 
-public:
+ public:
   KOKKOS_INLINE_FUNCTION
   const scratch_memory_space &team_shmem() const {
     return m_team_shared.set_team_thread_mode(0, 1, 0);
@@ -423,14 +426,15 @@ public:
   KOKKOS_INLINE_FUNCTION int team_size() const noexcept { return m_team_size; }
 
   template <class... Properties>
-  constexpr KOKKOS_INLINE_FUNCTION
-  HPXTeamMember(const TeamPolicyInternal<Kokkos::Experimental::HPX,
-                                         Properties...> &policy,
-                const int team_rank, const int league_rank, void *scratch,
-                int scratch_size) noexcept
+  constexpr KOKKOS_INLINE_FUNCTION HPXTeamMember(
+      const TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>
+          &policy,
+      const int team_rank, const int league_rank, void *scratch,
+      int scratch_size) noexcept
       : m_team_shared(scratch, scratch_size, scratch, scratch_size),
-        m_team_shared_size(scratch_size), m_league_size(policy.league_size()),
-        m_league_rank(league_rank), m_team_size(policy.team_size()),
+        m_league_size(policy.league_size()),
+        m_league_rank(league_rank),
+        m_team_size(policy.team_size()),
         m_team_rank(team_rank) {}
 
   KOKKOS_INLINE_FUNCTION
@@ -482,7 +486,7 @@ class TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>
   std::size_t m_thread_scratch_size[2];
   int m_chunk_size;
 
-public:
+ public:
   using member_type = HPXTeamMember;
 
   // NOTE: Max size is 1 for simplicity. In most cases more than 1 is not
@@ -511,21 +515,35 @@ public:
   int team_size_max(const FunctorType &, const ParallelReduceTag &) const {
     return 1;
   }
+
+  template <class FunctorType, class ReducerType>
+  int team_size_max(const FunctorType &, const ReducerType &,
+                    const ParallelReduceTag &) const {
+    return 1;
+  }
+
   template <class FunctorType>
   int team_size_recommended(const FunctorType &, const ParallelForTag &) const {
     return 1;
   }
+
   template <class FunctorType>
   int team_size_recommended(const FunctorType &,
                             const ParallelReduceTag &) const {
     return 1;
   }
 
-private:
+  template <class FunctorType, class ReducerType>
+  int team_size_recommended(const FunctorType &, const ReducerType &,
+                            const ParallelReduceTag &) const {
+    return 1;
+  }
+
+ private:
   inline void init(const int league_size_request, const int team_size_request) {
-    m_league_size = league_size_request;
-    const int max_team_size = 1; // TODO: Can't use team_size_max(...) because
-                                 // it requires a functor as argument.
+    m_league_size           = league_size_request;
+    const int max_team_size = 1;  // TODO: Can't use team_size_max(...) because
+                                  // it requires a functor as argument.
     m_team_size =
         team_size_request > max_team_size ? max_team_size : team_size_request;
 
@@ -551,7 +569,7 @@ private:
     }
   }
 
-public:
+ public:
   inline int team_size() const { return m_team_size; }
   inline int league_size() const { return m_league_size; }
 
@@ -563,26 +581,32 @@ public:
            team_size_ * m_thread_scratch_size[level];
   }
 
-public:
+  inline static int scratch_size_max(int level) {
+    return (level == 0 ? 1024 * 32 :  // Roughly L1 size
+                20 * 1024 * 1024);    // Limit to keep compatibility with CUDA
+  }
+
+ public:
   template <class ExecSpace, class... OtherProperties>
   friend class TeamPolicyInternal;
 
   template <class... OtherProperties>
-  TeamPolicyInternal(
-      const TeamPolicyInternal<Kokkos::Experimental::HPX, OtherProperties...> &p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::Experimental::HPX,
+                                              OtherProperties...> &p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
   }
 
   TeamPolicyInternal(const typename traits::execution_space &,
                      int league_size_request, int team_size_request,
                      int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0}, m_thread_scratch_size{0, 0},
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
         m_chunk_size(0) {
     init(league_size_request, team_size_request);
   }
@@ -591,14 +615,16 @@ public:
                      int league_size_request,
                      const Kokkos::AUTO_t &team_size_request,
                      int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0}, m_thread_scratch_size{0, 0},
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
         m_chunk_size(0) {
     init(league_size_request, 1);
   }
 
   TeamPolicyInternal(int league_size_request, int team_size_request,
                      int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0}, m_thread_scratch_size{0, 0},
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
         m_chunk_size(0) {
     init(league_size_request, team_size_request);
   }
@@ -606,15 +632,16 @@ public:
   TeamPolicyInternal(int league_size_request,
                      const Kokkos::AUTO_t &team_size_request,
                      int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0}, m_thread_scratch_size{0, 0},
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
         m_chunk_size(0) {
     init(league_size_request, 1);
   }
 
   inline int chunk_size() const { return m_chunk_size; }
 
-  inline TeamPolicyInternal &
-  set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal &set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
@@ -625,22 +652,22 @@ public:
     return *this;
   }
 
-  inline TeamPolicyInternal &
-  set_scratch_size(const int &level, const PerThreadValue &per_thread) {
+  inline TeamPolicyInternal &set_scratch_size(
+      const int &level, const PerThreadValue &per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  inline TeamPolicyInternal &
-  set_scratch_size(const int &level, const PerTeamValue &per_team,
-                   const PerThreadValue &per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  inline TeamPolicyInternal &set_scratch_size(
+      const int &level, const PerTeamValue &per_team,
+      const PerThreadValue &per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
@@ -648,11 +675,11 @@ namespace Impl {
 template <class FunctorType, class... Traits>
 class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
                   Kokkos::Experimental::HPX> {
-private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-  using WorkTag = typename Policy::work_tag;
+ private:
+  using Policy    = Kokkos::RangePolicy<Traits...>;
+  using WorkTag   = typename Policy::work_tag;
   using WorkRange = typename Policy::WorkRange;
-  using Member = typename Policy::member_type;
+  using Member    = typename Policy::member_type;
 
   const FunctorType m_functor;
   const Policy m_policy;
@@ -689,7 +716,7 @@ private:
     }
   }
 
-public:
+ public:
   void execute() const { Kokkos::Impl::dispatch_execute_task(this); }
 
   void execute_task() const {
@@ -705,25 +732,44 @@ public:
 
 #elif KOKKOS_HPX_IMPLEMENTATION == 1
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
 
-    counting_semaphore sem(0);
-    std::size_t num_tasks = 0;
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    latch num_tasks_remaining(num_tasks);
+    ChunkedRoundRobinExecutor exec(num_tasks);
 
     for (Member i_begin = m_policy.begin(); i_begin < m_policy.end();
          i_begin += m_policy.chunk_size()) {
-      apply([this, &sem, i_begin]() {
+      apply(exec, [this, &num_tasks_remaining, i_begin]() {
         const Member i_end =
             (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
         execute_functor_range<WorkTag>(m_functor, i_begin, i_end);
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
-
-      ++num_tasks;
     }
 
-    sem.wait(num_tasks);
+    num_tasks_remaining.wait();
+
+#elif KOKKOS_HPX_IMPLEMENTATION == 2
+    using hpx::parallel::for_loop_strided;
+    using hpx::parallel::execution::par;
+    using hpx::parallel::execution::static_chunk_size;
+
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    ChunkedRoundRobinExecutor exec(num_tasks);
+
+    for_loop_strided(
+        par.on(exec).with(static_chunk_size(1)), m_policy.begin(),
+        m_policy.end(), m_policy.chunk_size(), [this](const Member i_begin) {
+          const Member i_end =
+              (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
+          execute_functor_range<WorkTag>(m_functor, i_begin, i_end);
+        });
 #endif
   }
 
@@ -734,12 +780,12 @@ public:
 template <class FunctorType, class... Traits>
 class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
                   Kokkos::Experimental::HPX> {
-private:
+ private:
   using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
-  using Policy = typename MDRangePolicy::impl_range_policy;
-  using WorkTag = typename MDRangePolicy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member = typename Policy::member_type;
+  using Policy        = typename MDRangePolicy::impl_range_policy;
+  using WorkTag       = typename MDRangePolicy::work_tag;
+  using WorkRange     = typename Policy::WorkRange;
+  using Member        = typename Policy::member_type;
   using iterate_type =
       typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
                                              WorkTag, void>;
@@ -748,7 +794,7 @@ private:
   const MDRangePolicy m_mdr_policy;
   const Policy m_policy;
 
-public:
+ public:
   void execute() const { dispatch_execute_task(this); }
 
   inline void execute_task() const {
@@ -764,47 +810,69 @@ public:
 
 #elif KOKKOS_HPX_IMPLEMENTATION == 1
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
 
-    counting_semaphore sem(0);
-    std::size_t num_tasks = 0;
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    latch num_tasks_remaining(num_tasks);
+    ChunkedRoundRobinExecutor exec(num_tasks);
 
     for (Member i_begin = m_policy.begin(); i_begin < m_policy.end();
          i_begin += m_policy.chunk_size()) {
-      apply([this, &sem, i_begin]() {
+      apply(exec, [this, &num_tasks_remaining, i_begin]() {
         const Member i_end =
             (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
         for (Member i = i_begin; i < i_end; ++i) {
           iterate_type(m_mdr_policy, m_functor)(i);
         }
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
-
-      ++num_tasks;
     }
 
-    sem.wait(num_tasks);
+    num_tasks_remaining.wait();
+
+#elif KOKKOS_HPX_IMPLEMENTATION == 2
+    using hpx::parallel::for_loop_strided;
+    using hpx::parallel::execution::par;
+    using hpx::parallel::execution::static_chunk_size;
+
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    ChunkedRoundRobinExecutor exec(num_tasks);
+
+    for_loop_strided(
+        par.on(exec).with(static_chunk_size(1)), m_policy.begin(),
+        m_policy.end(), m_policy.chunk_size(), [this](const Member i_begin) {
+          const Member i_end =
+              (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
+          for (Member i = i_begin; i < i_end; ++i) {
+            iterate_type(m_mdr_policy, m_functor)(i);
+          }
+        });
 #endif
   }
 
   inline ParallelFor(const FunctorType &arg_functor, MDRangePolicy arg_policy)
-      : m_functor(arg_functor), m_mdr_policy(arg_policy),
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
         m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)) {}
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 template <class FunctorType, class ReducerType, class... Traits>
 class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                      Kokkos::Experimental::HPX> {
-private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-  using WorkTag = typename Policy::work_tag;
+ private:
+  using Policy    = Kokkos::RangePolicy<Traits...>;
+  using WorkTag   = typename Policy::work_tag;
   using WorkRange = typename Policy::WorkRange;
-  using Member = typename Policy::member_type;
+  using Member    = typename Policy::member_type;
   using Analysis =
       FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, FunctorType>;
   using ReducerConditional =
@@ -814,11 +882,11 @@ private:
   using WorkTagFwd =
       typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
                                   WorkTag, void>::type;
-  using ValueInit = Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd>;
-  using ValueJoin = Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd>;
-  using ValueOps = Kokkos::Impl::FunctorValueOps<ReducerTypeFwd, WorkTagFwd>;
+  using ValueInit  = Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd>;
+  using ValueJoin  = Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd>;
+  using ValueOps   = Kokkos::Impl::FunctorValueOps<ReducerTypeFwd, WorkTagFwd>;
   using value_type = typename Analysis::value_type;
-  using pointer_type = typename Analysis::pointer_type;
+  using pointer_type   = typename Analysis::pointer_type;
   using reference_type = typename Analysis::reference_type;
 
   const FunctorType m_functor;
@@ -866,11 +934,11 @@ private:
   }
 
   class value_type_wrapper {
-  private:
+   private:
     std::size_t m_value_size;
     char *m_value_buffer;
 
-  public:
+   public:
     value_type_wrapper() : m_value_size(0), m_value_buffer(nullptr) {}
 
     value_type_wrapper(const std::size_t value_size)
@@ -880,7 +948,7 @@ private:
         : m_value_size(0), m_value_buffer(nullptr) {
       if (this != &other) {
         m_value_buffer = new char[other.m_value_size];
-        m_value_size = other.m_value_size;
+        m_value_size   = other.m_value_size;
 
         std::copy(other.m_value_buffer, other.m_value_buffer + m_value_size,
                   m_value_buffer);
@@ -893,10 +961,10 @@ private:
         : m_value_size(0), m_value_buffer(nullptr) {
       if (this != &other) {
         m_value_buffer = other.m_value_buffer;
-        m_value_size = other.m_value_size;
+        m_value_size   = other.m_value_size;
 
         other.m_value_buffer = nullptr;
-        other.m_value_size = 0;
+        other.m_value_size   = 0;
       }
     }
 
@@ -904,7 +972,7 @@ private:
       if (this != &other) {
         delete[] m_value_buffer;
         m_value_buffer = new char[other.m_value_size];
-        m_value_size = other.m_value_size;
+        m_value_size   = other.m_value_size;
 
         std::copy(other.m_value_buffer, other.m_value_buffer + m_value_size,
                   m_value_buffer);
@@ -917,10 +985,10 @@ private:
       if (this != &other) {
         delete[] m_value_buffer;
         m_value_buffer = other.m_value_buffer;
-        m_value_size = other.m_value_size;
+        m_value_size   = other.m_value_size;
 
         other.m_value_buffer = nullptr;
-        other.m_value_size = 0;
+        other.m_value_size   = 0;
       }
 
       return *this;
@@ -936,26 +1004,21 @@ private:
     }
   };
 
-public:
-  void execute() const {
-    dispatch_execute_task(this);
-  }
+ public:
+  void execute() const { dispatch_execute_task(this); }
 
   inline void execute_task() const {
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-
-    std::size_t value_size =
+    const std::size_t value_size =
         Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
 
-    using hpx::parallel::for_loop;
-    using hpx::parallel::execution::par;
-
 #if KOKKOS_HPX_IMPLEMENTATION == 0
     // NOTE: This version makes the most use of HPX functionality, but
     // requires the struct value_type_wrapper to handle different
     // reference_types. It is also significantly slower than the version
     // below due to not reusing the buffer used by other functions.
+    using hpx::parallel::for_loop;
     using hpx::parallel::reduction;
+    using hpx::parallel::execution::par;
     using hpx::parallel::execution::static_chunk_size;
 
     value_type_wrapper final_value(value_size);
@@ -983,37 +1046,99 @@ public:
     pointer_type final_value_ptr = final_value.pointer();
 
 #elif KOKKOS_HPX_IMPLEMENTATION == 1
+    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
+
     thread_buffer &buffer = Kokkos::Experimental::HPX::impl_get_buffer();
     buffer.resize(num_worker_threads, value_size);
 
-    for_loop(par, 0, num_worker_threads, [this, &buffer](std::size_t t) {
-      ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
-                      reinterpret_cast<pointer_type>(buffer.get(t)));
-    });
-
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
+
+    {
+      latch num_tasks_remaining(num_worker_threads);
+      ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+      for (int t = 0; t < num_worker_threads; ++t) {
+        apply(exec, [this, &num_tasks_remaining, &buffer, t]() {
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          reinterpret_cast<pointer_type>(buffer.get(t)));
+
+          num_tasks_remaining.count_down(1);
+        });
+      }
+
+      num_tasks_remaining.wait();
+    }
 
-    counting_semaphore sem(0);
-    std::size_t num_tasks = 0;
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    latch num_tasks_remaining(num_tasks);
+    ChunkedRoundRobinExecutor exec(num_tasks);
 
     for (Member i_begin = m_policy.begin(); i_begin < m_policy.end();
          i_begin += m_policy.chunk_size()) {
-      apply([this, &buffer, &sem, i_begin]() {
+      apply(exec, [this, &num_tasks_remaining, &buffer, i_begin]() {
         reference_type update =
-            ValueOps::reference(reinterpret_cast<pointer_type>(
-                buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id())));
+            ValueOps::reference(reinterpret_cast<pointer_type>(buffer.get(
+                Kokkos::Experimental::HPX::impl_hardware_thread_id())));
         const Member i_end =
             (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
         execute_functor_range<WorkTag>(update, i_begin, i_end);
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
+    }
+
+    num_tasks_remaining.wait();
 
-      ++num_tasks;
+    for (int i = 1; i < num_worker_threads; ++i) {
+      ValueJoin::join(ReducerConditional::select(m_functor, m_reducer),
+                      reinterpret_cast<pointer_type>(buffer.get(0)),
+                      reinterpret_cast<pointer_type>(buffer.get(i)));
     }
 
-    sem.wait(num_tasks);
+    pointer_type final_value_ptr =
+        reinterpret_cast<pointer_type>(buffer.get(0));
+
+#elif KOKKOS_HPX_IMPLEMENTATION == 2
+    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
+
+    thread_buffer &buffer = Kokkos::Experimental::HPX::impl_get_buffer();
+    buffer.resize(num_worker_threads, value_size);
+
+    using hpx::parallel::for_loop;
+    using hpx::parallel::for_loop_strided;
+    using hpx::parallel::execution::par;
+    using hpx::parallel::execution::static_chunk_size;
+
+    {
+      ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+      for_loop(par.on(exec).with(static_chunk_size(1)), std::size_t(0),
+               num_worker_threads, [this, &buffer](const std::size_t t) {
+                 ValueInit::init(
+                     ReducerConditional::select(m_functor, m_reducer),
+                     reinterpret_cast<pointer_type>(buffer.get(t)));
+               });
+    }
+
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    ChunkedRoundRobinExecutor exec(num_tasks);
+
+    for_loop_strided(
+        par.on(exec).with(static_chunk_size(1)), m_policy.begin(),
+        m_policy.end(), m_policy.chunk_size(),
+        [this, &buffer](const Member i_begin) {
+          reference_type update =
+              ValueOps::reference(reinterpret_cast<pointer_type>(buffer.get(
+                  Kokkos::Experimental::HPX::impl_hardware_thread_id())));
+          const Member i_end =
+              (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
+          execute_functor_range<WorkTag>(update, i_begin, i_end);
+        });
 
     for (int i = 1; i < num_worker_threads; ++i) {
       ValueJoin::join(ReducerConditional::select(m_functor, m_reducer),
@@ -1045,13 +1170,17 @@ public:
       typename std::enable_if<Kokkos::is_view<ViewType>::value &&
                                   !Kokkos::is_reducer_type<ReducerType>::value,
                               void *>::type = NULL)
-      : m_functor(arg_functor), m_policy(arg_policy), m_reducer(InvalidType()),
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
         m_result_ptr(arg_view.data()),
         m_force_synchronous(!arg_view.impl_track().has_record()) {}
 
   inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
                         const ReducerType &reducer)
-      : m_functor(arg_functor), m_policy(arg_policy), m_reducer(reducer),
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
         m_result_ptr(reducer.view().data()),
         m_force_synchronous(!reducer.view().impl_track().has_record()) {}
 };
@@ -1059,13 +1188,13 @@ public:
 template <class FunctorType, class ReducerType, class... Traits>
 class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
                      Kokkos::Experimental::HPX> {
-private:
+ private:
   using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
-  using Policy = typename MDRangePolicy::impl_range_policy;
-  using WorkTag = typename MDRangePolicy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member = typename Policy::member_type;
-  using Analysis = FunctorAnalysis<FunctorPatternInterface::REDUCE,
+  using Policy        = typename MDRangePolicy::impl_range_policy;
+  using WorkTag       = typename MDRangePolicy::work_tag;
+  using WorkRange     = typename Policy::WorkRange;
+  using Member        = typename Policy::member_type;
+  using Analysis      = FunctorAnalysis<FunctorPatternInterface::REDUCE,
                                    MDRangePolicy, FunctorType>;
   using ReducerConditional =
       Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
@@ -1076,9 +1205,9 @@ private:
                                   WorkTag, void>::type;
   using ValueInit = Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd>;
   using ValueJoin = Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd>;
-  using ValueOps = Kokkos::Impl::FunctorValueOps<ReducerTypeFwd, WorkTagFwd>;
-  using pointer_type = typename Analysis::pointer_type;
-  using value_type = typename Analysis::value_type;
+  using ValueOps  = Kokkos::Impl::FunctorValueOps<ReducerTypeFwd, WorkTagFwd>;
+  using pointer_type   = typename Analysis::pointer_type;
+  using value_type     = typename Analysis::value_type;
   using reference_type = typename Analysis::reference_type;
   using iterate_type =
       typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
@@ -1092,10 +1221,8 @@ private:
 
   bool m_force_synchronous;
 
-public:
-  void execute() const {
-    dispatch_execute_task(this);
-  }
+ public:
+  void execute() const { dispatch_execute_task(this); }
 
   inline void execute_task() const {
     const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
@@ -1105,17 +1232,16 @@ public:
     thread_buffer &buffer = Kokkos::Experimental::HPX::impl_get_buffer();
     buffer.resize(num_worker_threads, value_size);
 
+#if KOKKOS_HPX_IMPLEMENTATION == 0
     using hpx::parallel::for_loop;
     using hpx::parallel::execution::par;
+    using hpx::parallel::execution::static_chunk_size;
 
     for_loop(par, 0, num_worker_threads, [this, &buffer](std::size_t t) {
       ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
                       reinterpret_cast<pointer_type>(buffer.get(t)));
     });
 
-#if KOKKOS_HPX_IMPLEMENTATION == 0
-    using hpx::parallel::execution::static_chunk_size;
-
     for_loop(par.with(static_chunk_size(m_policy.chunk_size())),
              m_policy.begin(), m_policy.end(), [this, &buffer](const Member i) {
                reference_type update = ValueOps::reference(
@@ -1126,17 +1252,36 @@ public:
 
 #elif KOKKOS_HPX_IMPLEMENTATION == 1
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
+
+    {
+      latch num_tasks_remaining(num_worker_threads);
+      ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+      for (int t = 0; t < num_worker_threads; ++t) {
+        apply(exec, [this, &buffer, &num_tasks_remaining, t]() {
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          reinterpret_cast<pointer_type>(buffer.get(t)));
+
+          num_tasks_remaining.count_down(1);
+        });
+      }
 
-    counting_semaphore sem(0);
-    std::size_t num_tasks = 0;
+      num_tasks_remaining.wait();
+    }
+
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    latch num_tasks_remaining(num_tasks);
+    ChunkedRoundRobinExecutor exec(num_tasks);
 
     for (Member i_begin = m_policy.begin(); i_begin < m_policy.end();
          i_begin += m_policy.chunk_size()) {
-      apply([this, &buffer, &sem, i_begin]() {
+      apply(exec, [this, &num_tasks_remaining, &buffer, i_begin]() {
         reference_type update =
-            ValueOps::reference(reinterpret_cast<pointer_type>(
-                buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id())));
+            ValueOps::reference(reinterpret_cast<pointer_type>(buffer.get(
+                Kokkos::Experimental::HPX::impl_hardware_thread_id())));
         const Member i_end =
             (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
 
@@ -1144,13 +1289,48 @@ public:
           iterate_type(m_mdr_policy, m_functor, update)(i);
         }
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
+    }
+
+    num_tasks_remaining.wait();
+
+#elif KOKKOS_HPX_IMPLEMENTATION == 2
+    using hpx::parallel::for_loop;
+    using hpx::parallel::for_loop_strided;
+    using hpx::parallel::execution::par;
+    using hpx::parallel::execution::static_chunk_size;
 
-      ++num_tasks;
+    {
+      ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+      for_loop(par.on(exec).with(static_chunk_size(1)), std::size_t(0),
+               num_worker_threads, [this, &buffer](const std::size_t t) {
+                 ValueInit::init(
+                     ReducerConditional::select(m_functor, m_reducer),
+                     reinterpret_cast<pointer_type>(buffer.get(t)));
+               });
     }
 
-    sem.wait(num_tasks);
+    const int num_tasks =
+        (m_policy.end() - m_policy.begin() + m_policy.chunk_size() - 1) /
+        m_policy.chunk_size();
+    ChunkedRoundRobinExecutor exec(num_tasks);
+
+    for_loop_strided(
+        par.on(exec).with(static_chunk_size(1)), m_policy.begin(),
+        m_policy.end(), m_policy.chunk_size(),
+        [this, &buffer](const Member i_begin) {
+          reference_type update =
+              ValueOps::reference(reinterpret_cast<pointer_type>(buffer.get(
+                  Kokkos::Experimental::HPX::impl_hardware_thread_id())));
+          const Member i_end =
+              (std::min)(i_begin + m_policy.chunk_size(), m_policy.end());
+
+          for (Member i = i_begin; i < i_end; ++i) {
+            iterate_type(m_mdr_policy, m_functor, update)(i);
+          }
+        });
 #endif
 
     for (int i = 1; i < num_worker_threads; ++i) {
@@ -1180,20 +1360,24 @@ public:
       typename std::enable_if<Kokkos::is_view<ViewType>::value &&
                                   !Kokkos::is_reducer_type<ReducerType>::value,
                               void *>::type = NULL)
-      : m_functor(arg_functor), m_mdr_policy(arg_policy),
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
         m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
-        m_reducer(InvalidType()), m_result_ptr(arg_view.data()),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_view.data()),
         m_force_synchronous(!arg_view.impl_track().has_record()) {}
 
   inline ParallelReduce(const FunctorType &arg_functor,
                         MDRangePolicy arg_policy, const ReducerType &reducer)
-      : m_functor(arg_functor), m_mdr_policy(arg_policy),
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
         m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
-        m_reducer(reducer), m_result_ptr(reducer.view().data()),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
         m_force_synchronous(!reducer.view().impl_track().has_record()) {}
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
@@ -1201,19 +1385,19 @@ namespace Impl {
 template <class FunctorType, class... Traits>
 class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
                    Kokkos::Experimental::HPX> {
-private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-  using WorkTag = typename Policy::work_tag;
+ private:
+  using Policy    = Kokkos::RangePolicy<Traits...>;
+  using WorkTag   = typename Policy::work_tag;
   using WorkRange = typename Policy::WorkRange;
-  using Member = typename Policy::member_type;
+  using Member    = typename Policy::member_type;
   using Analysis =
       FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
-  using ValueInit = Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag>;
-  using ValueJoin = Kokkos::Impl::FunctorValueJoin<FunctorType, WorkTag>;
-  using ValueOps = Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag>;
-  using pointer_type = typename Analysis::pointer_type;
+  using ValueInit      = Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag>;
+  using ValueJoin      = Kokkos::Impl::FunctorValueJoin<FunctorType, WorkTag>;
+  using ValueOps       = Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag>;
+  using pointer_type   = typename Analysis::pointer_type;
   using reference_type = typename Analysis::reference_type;
-  using value_type = typename Analysis::value_type;
+  using value_type     = typename Analysis::value_type;
 
   const FunctorType m_functor;
   const Policy m_policy;
@@ -1241,64 +1425,70 @@ private:
     }
   }
 
-public:
+ public:
   void execute() const { dispatch_execute_task(this); }
 
   inline void execute_task() const {
     const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-    const int value_count = Analysis::value_count(m_functor);
+    const int value_count        = Analysis::value_count(m_functor);
     const std::size_t value_size = Analysis::value_size(m_functor);
 
     thread_buffer &buffer = Kokkos::Experimental::HPX::impl_get_buffer();
     buffer.resize(num_worker_threads, 2 * value_size);
 
+    using hpx::apply;
     using hpx::lcos::local::barrier;
-    using hpx::parallel::for_loop;
-    using hpx::parallel::execution::par;
-    using hpx::parallel::execution::static_chunk_size;
+    using hpx::lcos::local::latch;
 
     barrier bar(num_worker_threads);
+    latch num_tasks_remaining(num_worker_threads);
+    ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+    for (int t = 0; t < num_worker_threads; ++t) {
+      apply(exec, [this, &bar, &buffer, &num_tasks_remaining,
+                   num_worker_threads, value_count, value_size, t]() {
+        reference_type update_sum = ValueInit::init(
+            m_functor, reinterpret_cast<pointer_type>(buffer.get(t)));
+
+        const WorkRange range(m_policy, t, num_worker_threads);
+        execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
+                                       update_sum, false);
+
+        bar.wait();
+
+        if (t == 0) {
+          ValueInit::init(m_functor, reinterpret_cast<pointer_type>(
+                                         buffer.get(0) + value_size));
+
+          for (int i = 1; i < num_worker_threads; ++i) {
+            pointer_type ptr_1_prev =
+                reinterpret_cast<pointer_type>(buffer.get(i - 1));
+            pointer_type ptr_2_prev =
+                reinterpret_cast<pointer_type>(buffer.get(i - 1) + value_size);
+            pointer_type ptr_2 =
+                reinterpret_cast<pointer_type>(buffer.get(i) + value_size);
+
+            for (int j = 0; j < value_count; ++j) {
+              ptr_2[j] = ptr_2_prev[j];
+            }
+
+            ValueJoin::join(m_functor, ptr_2, ptr_1_prev);
+          }
+        }
 
-    for_loop(par.with(static_chunk_size(1)), 0, num_worker_threads,
-             [this, &buffer, &bar, num_worker_threads, value_count,
-              value_size](std::size_t const t) {
-               reference_type update_sum = ValueInit::init(
-                   m_functor, reinterpret_cast<pointer_type>(buffer.get(t)));
-
-               const WorkRange range(m_policy, t, num_worker_threads);
-               execute_functor_range<WorkTag>(m_functor, range.begin(),
-                                              range.end(), update_sum, false);
-
-               bar.wait();
-
-               if (t == 0) {
-                 ValueInit::init(m_functor, reinterpret_cast<pointer_type>(
-                                                buffer.get(0) + value_size));
-
-                 for (int i = 1; i < num_worker_threads; ++i) {
-                   pointer_type ptr_1_prev =
-                       reinterpret_cast<pointer_type>(buffer.get(i - 1));
-                   pointer_type ptr_2_prev = reinterpret_cast<pointer_type>(
-                       buffer.get(i - 1) + value_size);
-                   pointer_type ptr_2 = reinterpret_cast<pointer_type>(
-                       buffer.get(i) + value_size);
-
-                   for (int j = 0; j < value_count; ++j) {
-                     ptr_2[j] = ptr_2_prev[j];
-                   }
+        bar.wait();
 
-                   ValueJoin::join(m_functor, ptr_2, ptr_1_prev);
-                 }
-               }
+        reference_type update_base = ValueOps::reference(
+            reinterpret_cast<pointer_type>(buffer.get(t) + value_size));
 
-               bar.wait();
+        execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
+                                       update_base, true);
 
-               reference_type update_base = ValueOps::reference(
-                   reinterpret_cast<pointer_type>(buffer.get(t) + value_size));
+        num_tasks_remaining.count_down(1);
+      });
+    }
 
-               execute_functor_range<WorkTag>(m_functor, range.begin(),
-                                              range.end(), update_base, true);
-             });
+    num_tasks_remaining.wait();
   }
 
   inline ParallelScan(const FunctorType &arg_functor, const Policy &arg_policy)
@@ -1308,19 +1498,19 @@ public:
 template <class FunctorType, class ReturnType, class... Traits>
 class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
                             ReturnType, Kokkos::Experimental::HPX> {
-private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-  using WorkTag = typename Policy::work_tag;
+ private:
+  using Policy    = Kokkos::RangePolicy<Traits...>;
+  using WorkTag   = typename Policy::work_tag;
   using WorkRange = typename Policy::WorkRange;
-  using Member = typename Policy::member_type;
+  using Member    = typename Policy::member_type;
   using Analysis =
       FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
-  using ValueInit = Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag>;
-  using ValueJoin = Kokkos::Impl::FunctorValueJoin<FunctorType, WorkTag>;
-  using ValueOps = Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag>;
-  using pointer_type = typename Analysis::pointer_type;
+  using ValueInit      = Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag>;
+  using ValueJoin      = Kokkos::Impl::FunctorValueJoin<FunctorType, WorkTag>;
+  using ValueOps       = Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag>;
+  using pointer_type   = typename Analysis::pointer_type;
   using reference_type = typename Analysis::reference_type;
-  using value_type = typename Analysis::value_type;
+  using value_type     = typename Analysis::value_type;
 
   const FunctorType m_functor;
   const Policy m_policy;
@@ -1349,88 +1539,95 @@ private:
     }
   }
 
-public:
+ public:
   void execute() const { dispatch_execute_task(this); }
 
   inline void execute_task() const {
     const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-    const int value_count = Analysis::value_count(m_functor);
+    const int value_count        = Analysis::value_count(m_functor);
     const std::size_t value_size = Analysis::value_size(m_functor);
 
     thread_buffer &buffer = Kokkos::Experimental::HPX::impl_get_buffer();
     buffer.resize(num_worker_threads, 2 * value_size);
 
+    using hpx::apply;
     using hpx::lcos::local::barrier;
-    using hpx::parallel::for_loop;
-    using hpx::parallel::execution::par;
-    using hpx::parallel::execution::static_chunk_size;
+    using hpx::lcos::local::latch;
 
     barrier bar(num_worker_threads);
+    latch num_tasks_remaining(num_worker_threads);
+    ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+    for (int t = 0; t < num_worker_threads; ++t) {
+      apply(exec, [this, &bar, &buffer, &num_tasks_remaining,
+                   num_worker_threads, value_count, value_size, t]() {
+        reference_type update_sum = ValueInit::init(
+            m_functor, reinterpret_cast<pointer_type>(buffer.get(t)));
+
+        const WorkRange range(m_policy, t, num_worker_threads);
+        execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
+                                       update_sum, false);
+
+        bar.wait();
+
+        if (t == 0) {
+          ValueInit::init(m_functor, reinterpret_cast<pointer_type>(
+                                         buffer.get(0) + value_size));
+
+          for (int i = 1; i < num_worker_threads; ++i) {
+            pointer_type ptr_1_prev =
+                reinterpret_cast<pointer_type>(buffer.get(i - 1));
+            pointer_type ptr_2_prev =
+                reinterpret_cast<pointer_type>(buffer.get(i - 1) + value_size);
+            pointer_type ptr_2 =
+                reinterpret_cast<pointer_type>(buffer.get(i) + value_size);
+
+            for (int j = 0; j < value_count; ++j) {
+              ptr_2[j] = ptr_2_prev[j];
+            }
+
+            ValueJoin::join(m_functor, ptr_2, ptr_1_prev);
+          }
+        }
 
-    for_loop(par.with(static_chunk_size(1)), 0, num_worker_threads,
-             [this, &buffer, &bar, num_worker_threads, value_count,
-              value_size](std::size_t const t) {
-               reference_type update_sum = ValueInit::init(
-                   m_functor, reinterpret_cast<pointer_type>(buffer.get(t)));
-
-               const WorkRange range(m_policy, t, num_worker_threads);
-               execute_functor_range<WorkTag>(m_functor, range.begin(),
-                                              range.end(), update_sum, false);
-
-               bar.wait();
-
-               if (t == 0) {
-                 ValueInit::init(m_functor, reinterpret_cast<pointer_type>(
-                                                buffer.get(0) + value_size));
-
-                 for (int i = 1; i < num_worker_threads; ++i) {
-                   pointer_type ptr_1_prev =
-                       reinterpret_cast<pointer_type>(buffer.get(i - 1));
-                   pointer_type ptr_2_prev = reinterpret_cast<pointer_type>(
-                       buffer.get(i - 1) + value_size);
-                   pointer_type ptr_2 = reinterpret_cast<pointer_type>(
-                       buffer.get(i) + value_size);
-
-                   for (int j = 0; j < value_count; ++j) {
-                     ptr_2[j] = ptr_2_prev[j];
-                   }
+        bar.wait();
 
-                   ValueJoin::join(m_functor, ptr_2, ptr_1_prev);
-                 }
-               }
+        reference_type update_base = ValueOps::reference(
+            reinterpret_cast<pointer_type>(buffer.get(t) + value_size));
 
-               bar.wait();
+        execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
+                                       update_base, true);
 
-               reference_type update_base = ValueOps::reference(
-                   reinterpret_cast<pointer_type>(buffer.get(t) + value_size));
+        if (t == num_worker_threads - 1) {
+          m_returnvalue = update_base;
+        }
 
-               execute_functor_range<WorkTag>(m_functor, range.begin(),
-                                              range.end(), update_base, true);
+        num_tasks_remaining.count_down(1);
+      });
+    }
 
-               if (t == std::size_t(num_worker_threads - 1)) {
-                 m_returnvalue = update_base;
-               }
-             });
+    num_tasks_remaining.wait();
   }
 
   inline ParallelScanWithTotal(const FunctorType &arg_functor,
                                const Policy &arg_policy,
                                ReturnType &arg_returnvalue)
-      : m_functor(arg_functor), m_policy(arg_policy),
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
         m_returnvalue(arg_returnvalue) {}
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 template <class FunctorType, class... Properties>
 class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
                   Kokkos::Experimental::HPX> {
-private:
-  using Policy = TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>;
+ private:
+  using Policy  = TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>;
   using WorkTag = typename Policy::work_tag;
-  using Member = typename Policy::member_type;
+  using Member  = typename Policy::member_type;
   using memory_space = Kokkos::HostSpace;
 
   const FunctorType m_functor;
@@ -1485,7 +1682,7 @@ private:
     }
   }
 
-public:
+ public:
   void execute() const { dispatch_execute_task(this); }
 
   inline void execute_task() const {
@@ -1499,42 +1696,66 @@ public:
     using hpx::parallel::execution::par;
     using hpx::parallel::execution::static_chunk_size;
 
-    for_loop(par.with(static_chunk_size(m_policy.chunk_size())), 0,
-             m_policy.league_size(), [this, &buffer](const int league_rank) {
-               execute_functor<WorkTag>(
-                   m_functor, m_policy, league_rank,
-                   buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id()),
-                   m_shared);
-             });
+    for_loop(
+        par.with(static_chunk_size(m_policy.chunk_size())), 0,
+        m_policy.league_size(), [this, &buffer](const int league_rank) {
+          execute_functor<WorkTag>(
+              m_functor, m_policy, league_rank,
+              buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id()),
+              m_shared);
+        });
 
 #elif KOKKOS_HPX_IMPLEMENTATION == 1
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
 
-    counting_semaphore sem(0);
-    std::size_t num_tasks = 0;
+    const int num_tasks = (m_policy.league_size() + m_policy.chunk_size() - 1) /
+                          m_policy.chunk_size();
+    latch num_tasks_remaining(num_tasks);
+    ChunkedRoundRobinExecutor exec(num_tasks);
 
     for (int league_rank_begin = 0; league_rank_begin < m_policy.league_size();
          league_rank_begin += m_policy.chunk_size()) {
-      apply([this, &buffer, &sem, league_rank_begin]() {
+      apply(exec, [this, &buffer, &num_tasks_remaining, league_rank_begin]() {
         const int league_rank_end = (std::min)(
             league_rank_begin + m_policy.chunk_size(), m_policy.league_size());
         execute_functor_range<WorkTag>(
             m_functor, m_policy, league_rank_begin, league_rank_end,
-            buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id()), m_shared);
+            buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id()),
+            m_shared);
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
-
-      ++num_tasks;
     }
 
-    sem.wait(num_tasks);
+    num_tasks_remaining.wait();
+
+#elif KOKKOS_HPX_IMPLEMENTATION == 2
+    using hpx::parallel::for_loop_strided;
+    using hpx::parallel::execution::par;
+    using hpx::parallel::execution::static_chunk_size;
+
+    const int num_tasks = (m_policy.league_size() + m_policy.chunk_size() - 1) /
+                          m_policy.chunk_size();
+    ChunkedRoundRobinExecutor exec(num_tasks);
+
+    for_loop_strided(
+        par.on(exec).with(static_chunk_size(1)), 0, m_policy.league_size(),
+        m_policy.chunk_size(), [this, &buffer](const int league_rank_begin) {
+          const int league_rank_end =
+              (std::min)(league_rank_begin + m_policy.chunk_size(),
+                         m_policy.league_size());
+          execute_functor_range<WorkTag>(
+              m_functor, m_policy, league_rank_begin, league_rank_end,
+              buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id()),
+              m_shared);
+        });
 #endif
   }
 
   ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy),
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
         m_league(arg_policy.league_size()),
         m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
                  FunctorTeamShmemSize<FunctorType>::value(
@@ -1544,11 +1765,11 @@ public:
 template <class FunctorType, class ReducerType, class... Properties>
 class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                      ReducerType, Kokkos::Experimental::HPX> {
-private:
+ private:
   using Policy = TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>;
   using Analysis =
       FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, FunctorType>;
-  using Member = typename Policy::member_type;
+  using Member  = typename Policy::member_type;
   using WorkTag = typename Policy::work_tag;
   using ReducerConditional =
       Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
@@ -1559,10 +1780,10 @@ private:
                                   WorkTag, void>::type;
   using ValueInit = Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd>;
   using ValueJoin = Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd>;
-  using ValueOps = Kokkos::Impl::FunctorValueOps<ReducerTypeFwd, WorkTagFwd>;
-  using pointer_type = typename Analysis::pointer_type;
+  using ValueOps  = Kokkos::Impl::FunctorValueOps<ReducerTypeFwd, WorkTagFwd>;
+  using pointer_type   = typename Analysis::pointer_type;
   using reference_type = typename Analysis::reference_type;
-  using value_type = typename Analysis::value_type;
+  using value_type     = typename Analysis::value_type;
 
   const FunctorType m_functor;
   const int m_league;
@@ -1628,10 +1849,8 @@ private:
     }
   }
 
-public:
-  void execute() const {
-    dispatch_execute_task(this);
-  }
+ public:
+  void execute() const { dispatch_execute_task(this); }
 
   inline void execute_task() const {
     const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
@@ -1641,15 +1860,15 @@ public:
     thread_buffer &buffer = Kokkos::Experimental::HPX::impl_get_buffer();
     buffer.resize(num_worker_threads, value_size + m_shared);
 
+#if KOKKOS_HPX_IMPLEMENTATION == 0
     using hpx::parallel::for_loop;
     using hpx::parallel::execution::par;
 
-    for_loop(par, 0, num_worker_threads, [this, &buffer](std::size_t t) {
+    for_loop(par, 0, num_worker_threads, [this, &buffer](const std::size_t t) {
       ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
                       reinterpret_cast<pointer_type>(buffer.get(t)));
     });
 
-#if KOKKOS_HPX_IMPLEMENTATION == 0
     using hpx::parallel::execution::static_chunk_size;
 
     hpx::parallel::for_loop(
@@ -1667,14 +1886,33 @@ public:
 
 #elif KOKKOS_HPX_IMPLEMENTATION == 1
     using hpx::apply;
-    using hpx::lcos::local::counting_semaphore;
+    using hpx::lcos::local::latch;
 
-    counting_semaphore sem(0);
-    std::size_t num_tasks = 0;
+    {
+      latch num_tasks_remaining(num_worker_threads);
+      ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+      for (int t = 0; t < num_worker_threads; ++t) {
+        apply(exec, [this, &buffer, &num_tasks_remaining, t]() {
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          reinterpret_cast<pointer_type>(buffer.get(t)));
+
+          num_tasks_remaining.count_down(1);
+        });
+      }
+
+      num_tasks_remaining.wait();
+    }
+
+    const int num_tasks = (m_policy.league_size() + m_policy.chunk_size() - 1) /
+                          m_policy.chunk_size();
+    latch num_tasks_remaining(num_tasks);
+    ChunkedRoundRobinExecutor exec(num_tasks);
 
     for (int league_rank_begin = 0; league_rank_begin < m_policy.league_size();
          league_rank_begin += m_policy.chunk_size()) {
-      apply([this, &buffer, &sem, league_rank_begin, value_size]() {
+      apply(exec, [this, &buffer, &num_tasks_remaining, league_rank_begin,
+                   value_size]() {
         std::size_t t = Kokkos::Experimental::HPX::impl_hardware_thread_id();
         reference_type update =
             ValueOps::reference(reinterpret_cast<pointer_type>(buffer.get(t)));
@@ -1684,13 +1922,47 @@ public:
             m_functor, m_policy, league_rank_begin, league_rank_end,
             buffer.get(t) + value_size, m_shared, update);
 
-        sem.signal(1);
+        num_tasks_remaining.count_down(1);
       });
+    }
+
+    num_tasks_remaining.wait();
 
-      ++num_tasks;
+#elif KOKKOS_HPX_IMPLEMENTATION == 2
+    using hpx::parallel::for_loop;
+    using hpx::parallel::for_loop_strided;
+    using hpx::parallel::execution::par;
+    using hpx::parallel::execution::static_chunk_size;
+
+    {
+      ChunkedRoundRobinExecutor exec(num_worker_threads);
+
+      for_loop(par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
+               [this, &buffer](std::size_t const t) {
+                 ValueInit::init(
+                     ReducerConditional::select(m_functor, m_reducer),
+                     reinterpret_cast<pointer_type>(buffer.get(t)));
+               });
     }
 
-    sem.wait(num_tasks);
+    const int num_tasks = (m_policy.league_size() + m_policy.chunk_size() - 1) /
+                          m_policy.chunk_size();
+    ChunkedRoundRobinExecutor exec(num_tasks);
+
+    for_loop_strided(
+        par.on(exec).with(static_chunk_size(1)), 0, m_policy.league_size(),
+        m_policy.chunk_size(),
+        [this, &buffer, value_size](int const league_rank_begin) {
+          std::size_t t = Kokkos::Experimental::HPX::impl_hardware_thread_id();
+          reference_type update = ValueOps::reference(
+              reinterpret_cast<pointer_type>(buffer.get(t)));
+          const int league_rank_end =
+              (std::min)(league_rank_begin + m_policy.chunk_size(),
+                         m_policy.league_size());
+          execute_functor_range<WorkTag>(
+              m_functor, m_policy, league_rank_begin, league_rank_end,
+              buffer.get(t) + value_size, m_shared, update);
+        });
 #endif
 
     const pointer_type ptr = reinterpret_cast<pointer_type>(buffer.get(0));
@@ -1719,8 +1991,10 @@ public:
       typename std::enable_if<Kokkos::is_view<ViewType>::value &&
                                   !Kokkos::is_reducer_type<ReducerType>::value,
                               void *>::type = NULL)
-      : m_functor(arg_functor), m_league(arg_policy.league_size()),
-        m_policy(arg_policy), m_reducer(InvalidType()),
+      : m_functor(arg_functor),
+        m_league(arg_policy.league_size()),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
                  FunctorTeamShmemSize<FunctorType>::value(
@@ -1729,16 +2003,18 @@ public:
 
   inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
                         const ReducerType &reducer)
-      : m_functor(arg_functor), m_league(arg_policy.league_size()),
-        m_policy(arg_policy), m_reducer(reducer),
+      : m_functor(arg_functor),
+        m_league(arg_policy.league_size()),
+        m_policy(arg_policy),
+        m_reducer(reducer),
         m_result_ptr(reducer.view().data()),
         m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
                  FunctorTeamShmemSize<FunctorType>::value(
                      arg_functor, arg_policy.team_size())),
         m_force_synchronous(!reducer.view().impl_track().has_record()) {}
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 
@@ -1796,14 +2072,14 @@ KOKKOS_INLINE_FUNCTION
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::HPXTeamMember>
-PerTeam(const Impl::HPXTeamMember &thread) {
+Impl::ThreadSingleStruct<Impl::HPXTeamMember> PerTeam(
+    const Impl::HPXTeamMember &thread) {
   return Impl::ThreadSingleStruct<Impl::HPXTeamMember>(thread);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::HPXTeamMember>
-PerThread(const Impl::HPXTeamMember &thread) {
+Impl::VectorSingleStruct<Impl::HPXTeamMember> PerThread(
+    const Impl::HPXTeamMember &thread) {
   return Impl::VectorSingleStruct<Impl::HPXTeamMember>(thread);
 }
 
@@ -1950,7 +2226,7 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
         &loop_boundaries,
     const FunctorType &lambda) {
   using ValueTraits = Kokkos::Impl::FunctorValueTraits<FunctorType, void>;
-  using value_type = typename ValueTraits::value_type;
+  using value_type  = typename ValueTraits::value_type;
 
   value_type scan_val = value_type();
 
@@ -1964,34 +2240,34 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
 }
 
 template <class FunctorType>
-KOKKOS_INLINE_FUNCTION void
-single(const Impl::VectorSingleStruct<Impl::HPXTeamMember> &single_struct,
-       const FunctorType &lambda) {
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::HPXTeamMember> &single_struct,
+    const FunctorType &lambda) {
   lambda();
 }
 
 template <class FunctorType>
-KOKKOS_INLINE_FUNCTION void
-single(const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &single_struct,
-       const FunctorType &lambda) {
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &single_struct,
+    const FunctorType &lambda) {
   lambda();
 }
 
 template <class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION void
-single(const Impl::VectorSingleStruct<Impl::HPXTeamMember> &single_struct,
-       const FunctorType &lambda, ValueType &val) {
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::HPXTeamMember> &single_struct,
+    const FunctorType &lambda, ValueType &val) {
   lambda(val);
 }
 
 template <class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION void
-single(const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &single_struct,
-       const FunctorType &lambda, ValueType &val) {
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &single_struct,
+    const FunctorType &lambda, ValueType &val) {
   lambda(val);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #include <HPX/Kokkos_HPX_Task.hpp>
 
diff --git a/lib/kokkos/core/src/Kokkos_HostSpace.hpp b/lib/kokkos/core/src/Kokkos_HostSpace.hpp
index 06ccf6398743ef8a61828955933b84ec42c3fa07..c1b842c1c4a743eb7a85a9c698032c39be0e7715 100644
--- a/lib/kokkos/core/src/Kokkos_HostSpace.hpp
+++ b/lib/kokkos/core/src/Kokkos_HostSpace.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -86,11 +87,11 @@ bool lock_address_host_space(void* ptr);
 /// from the provided ptr. This function should only be called
 /// after previously successfully acquiring a lock with
 /// lock_address.
-void unlock_address_host_space( void* ptr );
+void unlock_address_host_space(void* ptr);
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
@@ -100,10 +101,10 @@ namespace Kokkos {
 /// HostSpace is a memory space that governs host memory.  "Host"
 /// memory means the usual CPU-accessible memory.
 class HostSpace {
-public:
+ public:
   //! Tag this class as a kokkos memory space
-  typedef HostSpace  memory_space;
-  typedef size_t     size_type;
+  typedef HostSpace memory_space;
+  typedef size_t size_type;
 
   /// \typedef execution_space
   /// \brief Default execution space for this memory space.
@@ -111,63 +112,68 @@ public:
   /// Every memory space has a default execution space.  This is
   /// useful for things like initializing a View (which happens in
   /// parallel using the View's default execution space).
-#if defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP )
-  typedef Kokkos::OpenMP    execution_space;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS )
-  typedef Kokkos::Threads   execution_space;
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX )
+#if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
+  typedef Kokkos::OpenMP execution_space;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
+  typedef Kokkos::Threads execution_space;
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX)
   typedef Kokkos::Experimental::HPX execution_space;
 //#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS )
 //  typedef Kokkos::Qthreads  execution_space;
-#elif defined( KOKKOS_ENABLE_OPENMP )
-  typedef Kokkos::OpenMP    execution_space;
-#elif defined( KOKKOS_ENABLE_THREADS )
-  typedef Kokkos::Threads   execution_space;
+#elif defined(KOKKOS_ENABLE_OPENMP)
+  typedef Kokkos::OpenMP execution_space;
+#elif defined(KOKKOS_ENABLE_THREADS)
+  typedef Kokkos::Threads execution_space;
 //#elif defined( KOKKOS_ENABLE_QTHREADS )
 //  typedef Kokkos::Qthreads  execution_space;
-#elif defined( KOKKOS_ENABLE_HPX )
+#elif defined(KOKKOS_ENABLE_HPX)
   typedef Kokkos::Experimental::HPX execution_space;
-#elif defined( KOKKOS_ENABLE_SERIAL )
-  typedef Kokkos::Serial    execution_space;
+#elif defined(KOKKOS_ENABLE_SERIAL)
+  typedef Kokkos::Serial execution_space;
 #else
-#  error "At least one of the following host execution spaces must be defined: Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qthreads, or Kokkos::Serial.  You might be seeing this message if you disabled the Kokkos::Serial device explicitly using the Kokkos_ENABLE_Serial:BOOL=OFF CMake option, but did not enable any of the other host execution space devices."
+#error \
+    "At least one of the following host execution spaces must be defined: Kokkos::OpenMP, Kokkos::Threads, Kokkos::Qthreads, or Kokkos::Serial.  You might be seeing this message if you disabled the Kokkos::Serial device explicitly using the Kokkos_ENABLE_Serial:BOOL=OFF CMake option, but did not enable any of the other host execution space devices."
 #endif
 
   //! This memory space preferred device_type
-  typedef Kokkos::Device< execution_space, memory_space > device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
   /**\brief  Default memory space instance */
   HostSpace();
-  HostSpace( HostSpace && rhs ) = default;
-  HostSpace( const HostSpace & rhs ) = default;
-  HostSpace & operator = ( HostSpace && ) = default;
-  HostSpace & operator = ( const HostSpace & ) = default;
-  ~HostSpace() = default;
+  HostSpace(HostSpace&& rhs)      = default;
+  HostSpace(const HostSpace& rhs) = default;
+  HostSpace& operator=(HostSpace&&) = default;
+  HostSpace& operator=(const HostSpace&) = default;
+  ~HostSpace()                           = default;
 
-  /**\brief  Non-default memory space instance to choose allocation mechansim, if available */
+  /**\brief  Non-default memory space instance to choose allocation mechansim,
+   * if available */
 
-  enum AllocationMechanism { STD_MALLOC, POSIX_MEMALIGN, POSIX_MMAP, INTEL_MM_ALLOC };
+  enum AllocationMechanism {
+    STD_MALLOC,
+    POSIX_MEMALIGN,
+    POSIX_MMAP,
+    INTEL_MM_ALLOC
+  };
 
-  explicit
-  HostSpace( const AllocationMechanism & );
+  explicit HostSpace(const AllocationMechanism&);
 
   /**\brief  Allocate untracked memory in the space */
-  void * allocate( const size_t arg_alloc_size ) const;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the space */
-  void deallocate( void * const arg_alloc_ptr
-                 , const size_t arg_alloc_size ) const;
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return m_name; }
 
-private:
-  AllocationMechanism  m_alloc_mech;
+ private:
+  AllocationMechanism m_alloc_mech;
   static constexpr const char* m_name = "Host";
-  friend class Kokkos::Impl::SharedAllocationRecord< Kokkos::HostSpace, void >;
+  friend class Kokkos::Impl::SharedAllocationRecord<Kokkos::HostSpace, void>;
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -175,38 +181,45 @@ namespace Kokkos {
 
 namespace Impl {
 
-static_assert( Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::HostSpace >::assignable, "" );
+static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                              Kokkos::HostSpace>::assignable,
+              "");
 
-template< typename S >
+template <typename S>
 struct HostMirror {
-private:
+ private:
   // If input execution space can access HostSpace then keep it.
   // Example: Kokkos::OpenMP can access, Kokkos::Cuda cannot
-  enum { keep_exe = Kokkos::Impl::MemorySpaceAccess
-                      < typename S::execution_space::memory_space, Kokkos::HostSpace >::accessible };
+  enum {
+    keep_exe = Kokkos::Impl::MemorySpaceAccess<
+        typename S::execution_space::memory_space,
+        Kokkos::HostSpace>::accessible
+  };
 
   // If HostSpace can access memory space then keep it.
   // Example:  Cannot access Kokkos::CudaSpace, can access Kokkos::CudaUVMSpace
-  enum { keep_mem = Kokkos::Impl::MemorySpaceAccess
-                      < Kokkos::HostSpace, typename S::memory_space >::accessible };
-
-public:
-
-  typedef typename std::conditional
-    < keep_exe && keep_mem /* Can keep whole space */
-    , S
-    , typename std::conditional
-        < keep_mem /* Can keep memory space, use default Host execution space */
-        , Kokkos::Device< Kokkos::HostSpace::execution_space
-                        , typename S::memory_space >
-        , Kokkos::HostSpace
-        >::type
-    >::type  Space;
+  enum {
+    keep_mem =
+        Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                        typename S::memory_space>::accessible
+  };
+
+ public:
+  typedef typename std::conditional<
+      keep_exe && keep_mem /* Can keep whole space */
+      ,
+      S,
+      typename std::conditional<
+          keep_mem /* Can keep memory space, use default Host execution space */
+          ,
+          Kokkos::Device<Kokkos::HostSpace::execution_space,
+                         typename S::memory_space>,
+          Kokkos::HostSpace>::type>::type Space;
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -214,19 +227,18 @@ namespace Kokkos {
 
 namespace Impl {
 
-template<>
-class SharedAllocationRecord< Kokkos::HostSpace, void >
-  : public SharedAllocationRecord< void, void >
-{
-private:
+template <>
+class SharedAllocationRecord<Kokkos::HostSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
   friend Kokkos::HostSpace;
 
-  typedef SharedAllocationRecord< void, void >  RecordBase;
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete;
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static void deallocate( RecordBase * );
+  static void deallocate(RecordBase*);
 
 #ifdef KOKKOS_DEBUG
   /**\brief  Root record for tracked allocations from this HostSpace instance */
@@ -235,61 +247,51 @@ private:
 
   const Kokkos::HostSpace m_space;
 
-protected:
+ protected:
   ~SharedAllocationRecord();
   SharedAllocationRecord() = default;
 
-  SharedAllocationRecord( const Kokkos::HostSpace        & arg_space
-                        , const std::string              & arg_label
-                        , const size_t                     arg_alloc_size
-                        , const RecordBase::function_type  arg_dealloc = & deallocate
-                        );
+  SharedAllocationRecord(
+      const Kokkos::HostSpace& arg_space, const std::string& arg_label,
+      const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
 
-public:
-
-  inline
-  std::string get_label() const
-  {
-    return std::string( RecordBase::head()->m_label );
+ public:
+  inline std::string get_label() const {
+    return std::string(RecordBase::head()->m_label);
   }
 
-  KOKKOS_INLINE_FUNCTION static
-  SharedAllocationRecord * allocate( const Kokkos::HostSpace &  arg_space
-                                   , const std::string       &  arg_label
-                                   , const size_t               arg_alloc_size
-                                   )
-  {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    return new SharedAllocationRecord( arg_space, arg_label, arg_alloc_size );
+  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
+      const Kokkos::HostSpace& arg_space, const std::string& arg_label,
+      const size_t arg_alloc_size) {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
 #else
-    return (SharedAllocationRecord *) 0;
+    return (SharedAllocationRecord*)0;
 #endif
   }
 
-
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::HostSpace & arg_space
-                         , const std::string & arg_label
-                         , const size_t arg_alloc_size );
+  static void* allocate_tracked(const Kokkos::HostSpace& arg_space,
+                                const std::string& arg_label,
+                                const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
+  static void deallocate_tracked(void* const arg_alloc_ptr);
 
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
 
-  static void print_records( std::ostream &, const Kokkos::HostSpace &, bool detail = false );
+  static void print_records(std::ostream&, const Kokkos::HostSpace&,
+                            bool detail = false);
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -297,24 +299,21 @@ namespace Kokkos {
 
 namespace Impl {
 
-#define PAR_DEEP_COPY_USE_MEMCPY
-
-template< class ExecutionSpace >
-struct DeepCopy< HostSpace, HostSpace, ExecutionSpace > {
-  DeepCopy( void * dst, const void * src, size_t n ) {
-    hostspace_parallel_deepcopy(dst,src,n);
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, HostSpace, ExecutionSpace> {
+  DeepCopy(void* dst, const void* src, size_t n) {
+    hostspace_parallel_deepcopy(dst, src, n);
   }
 
-  DeepCopy( const ExecutionSpace& exec, void * dst, const void * src, size_t n ) {
+  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence();
-    hostspace_parallel_deepcopy(dst,src,n);
+    hostspace_parallel_deepcopy(dst, src, n);
     exec.fence();
   }
 };
 
-} // namespace Impl
-
-} // namespace Kokkos
+}  // namespace Impl
 
-#endif // #define KOKKOS_HOSTSPACE_HPP
+}  // namespace Kokkos
 
+#endif  // #define KOKKOS_HOSTSPACE_HPP
diff --git a/lib/kokkos/core/src/Kokkos_Layout.hpp b/lib/kokkos/core/src/Kokkos_Layout.hpp
index 6f423d545f074ff8e35c6c352df1f60e35cea78e..d34bdb9150c52218b7e5efbf7644cb9bcbe30394 100644
--- a/lib/kokkos/core/src/Kokkos_Layout.hpp
+++ b/lib/kokkos/core/src/Kokkos_Layout.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -72,22 +73,22 @@ enum { ARRAY_LAYOUT_MAX_RANK = 8 };
 /// major."
 struct LayoutLeft {
   //! Tag this class as a kokkos array layout
-  typedef LayoutLeft array_layout ;
+  typedef LayoutLeft array_layout;
 
-  size_t dimension[ ARRAY_LAYOUT_MAX_RANK ];
+  size_t dimension[ARRAY_LAYOUT_MAX_RANK];
 
   enum { is_extent_constructible = true };
 
-  LayoutLeft( LayoutLeft const & ) = default ;
-  LayoutLeft( LayoutLeft && ) = default ;
-  LayoutLeft & operator = ( LayoutLeft const & ) = default ;
-  LayoutLeft & operator = ( LayoutLeft && ) = default ;
+  LayoutLeft(LayoutLeft const&) = default;
+  LayoutLeft(LayoutLeft&&)      = default;
+  LayoutLeft& operator=(LayoutLeft const&) = default;
+  LayoutLeft& operator=(LayoutLeft&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  explicit constexpr
-  LayoutLeft( size_t N0 = 0 , size_t N1 = 0 , size_t N2 = 0 , size_t N3 = 0
-            , size_t N4 = 0 , size_t N5 = 0 , size_t N6 = 0 , size_t N7 = 0 )
-    : dimension { N0 , N1 , N2 , N3 , N4 , N5 , N6 , N7 } {}
+  explicit constexpr LayoutLeft(size_t N0 = 0, size_t N1 = 0, size_t N2 = 0,
+                                size_t N3 = 0, size_t N4 = 0, size_t N5 = 0,
+                                size_t N6 = 0, size_t N7 = 0)
+      : dimension{N0, N1, N2, N3, N4, N5, N6, N7} {}
 };
 
 //----------------------------------------------------------------------------
@@ -106,22 +107,22 @@ struct LayoutLeft {
 /// two-dimensional array, "layout right" is also called "row major."
 struct LayoutRight {
   //! Tag this class as a kokkos array layout
-  typedef LayoutRight array_layout ;
+  typedef LayoutRight array_layout;
 
-  size_t dimension[ ARRAY_LAYOUT_MAX_RANK ];
+  size_t dimension[ARRAY_LAYOUT_MAX_RANK];
 
   enum { is_extent_constructible = true };
 
-  LayoutRight( LayoutRight const & ) = default ;
-  LayoutRight( LayoutRight && ) = default ;
-  LayoutRight & operator = ( LayoutRight const & ) = default ;
-  LayoutRight & operator = ( LayoutRight && ) = default ;
+  LayoutRight(LayoutRight const&) = default;
+  LayoutRight(LayoutRight&&)      = default;
+  LayoutRight& operator=(LayoutRight const&) = default;
+  LayoutRight& operator=(LayoutRight&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  explicit constexpr
-  LayoutRight( size_t N0 = 0 , size_t N1 = 0 , size_t N2 = 0 , size_t N3 = 0
-             , size_t N4 = 0 , size_t N5 = 0 , size_t N6 = 0 , size_t N7 = 0 )
-    : dimension { N0 , N1 , N2 , N3 , N4 , N5 , N6 , N7 } {}
+  explicit constexpr LayoutRight(size_t N0 = 0, size_t N1 = 0, size_t N2 = 0,
+                                 size_t N3 = 0, size_t N4 = 0, size_t N5 = 0,
+                                 size_t N6 = 0, size_t N7 = 0)
+      : dimension{N0, N1, N2, N3, N4, N5, N6, N7} {}
 };
 
 //----------------------------------------------------------------------------
@@ -129,19 +130,18 @@ struct LayoutRight {
 /// \brief  Memory layout tag indicated arbitrarily strided
 ///         multi-index mapping into contiguous memory.
 struct LayoutStride {
-
   //! Tag this class as a kokkos array layout
-  typedef LayoutStride array_layout ;
+  typedef LayoutStride array_layout;
 
-  size_t dimension[ ARRAY_LAYOUT_MAX_RANK ] ;
-  size_t stride[ ARRAY_LAYOUT_MAX_RANK ] ;
+  size_t dimension[ARRAY_LAYOUT_MAX_RANK];
+  size_t stride[ARRAY_LAYOUT_MAX_RANK];
 
   enum { is_extent_constructible = false };
 
-  LayoutStride( LayoutStride const & ) = default ;
-  LayoutStride( LayoutStride && ) = default ;
-  LayoutStride & operator = ( LayoutStride const & ) = default ;
-  LayoutStride & operator = ( LayoutStride && ) = default ;
+  LayoutStride(LayoutStride const&) = default;
+  LayoutStride(LayoutStride&&)      = default;
+  LayoutStride& operator=(LayoutStride const&) = default;
+  LayoutStride& operator=(LayoutStride&&) = default;
 
   /** \brief  Compute strides from ordered dimensions.
    *
@@ -150,47 +150,40 @@ struct LayoutStride {
    *  Order = {0,1,2,...} is LayoutLeft
    *  Order = {...,2,1,0} is LayoutRight
    */
-  template< typename iTypeOrder , typename iTypeDimen >
-  KOKKOS_INLINE_FUNCTION static
-  LayoutStride order_dimensions( int const rank
-                               , iTypeOrder const * const order
-                               , iTypeDimen const * const dimen )
-    {
-      LayoutStride tmp ;
-      // Verify valid rank order:
-      int check_input = ARRAY_LAYOUT_MAX_RANK < rank ? 0 : int( 1 << rank ) - 1 ;
-      for ( int r = 0 ; r < ARRAY_LAYOUT_MAX_RANK ; ++r ) {
-        tmp.dimension[r] = 0 ;
-        tmp.stride[r]    = 0 ;
-      }
-      for ( int r = 0 ; r < rank ; ++r ) {
-        check_input &= ~int( 1 << order[r] );
-      }
-      if ( 0 == check_input ) {
-        size_t n = 1 ;
-        for ( int r = 0 ; r < rank ; ++r ) {
-          tmp.stride[ order[r] ] = n ;
-          n *= ( dimen[order[r]] );
-          tmp.dimension[r] = dimen[r];
-        }
+  template <typename iTypeOrder, typename iTypeDimen>
+  KOKKOS_INLINE_FUNCTION static LayoutStride order_dimensions(
+      int const rank, iTypeOrder const* const order,
+      iTypeDimen const* const dimen) {
+    LayoutStride tmp;
+    // Verify valid rank order:
+    int check_input = ARRAY_LAYOUT_MAX_RANK < rank ? 0 : int(1 << rank) - 1;
+    for (int r = 0; r < ARRAY_LAYOUT_MAX_RANK; ++r) {
+      tmp.dimension[r] = 0;
+      tmp.stride[r]    = 0;
+    }
+    for (int r = 0; r < rank; ++r) {
+      check_input &= ~int(1 << order[r]);
+    }
+    if (0 == check_input) {
+      size_t n = 1;
+      for (int r = 0; r < rank; ++r) {
+        tmp.stride[order[r]] = n;
+        n *= (dimen[order[r]]);
+        tmp.dimension[r] = dimen[r];
       }
-      return tmp ;
     }
+    return tmp;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  explicit constexpr
-  LayoutStride( size_t N0 = 0 , size_t S0 = 0
-              , size_t N1 = 0 , size_t S1 = 0
-              , size_t N2 = 0 , size_t S2 = 0
-              , size_t N3 = 0 , size_t S3 = 0
-              , size_t N4 = 0 , size_t S4 = 0
-              , size_t N5 = 0 , size_t S5 = 0
-              , size_t N6 = 0 , size_t S6 = 0
-              , size_t N7 = 0 , size_t S7 = 0
-              )
-    : dimension { N0 , N1 , N2 , N3 , N4 , N5 , N6 , N7 }
-    , stride    { S0 , S1 , S2 , S3 , S4 , S5 , S6 , S7 }
-    {}
+  explicit constexpr LayoutStride(size_t N0 = 0, size_t S0 = 0, size_t N1 = 0,
+                                  size_t S1 = 0, size_t N2 = 0, size_t S2 = 0,
+                                  size_t N3 = 0, size_t S3 = 0, size_t N4 = 0,
+                                  size_t S4 = 0, size_t N5 = 0, size_t S5 = 0,
+                                  size_t N6 = 0, size_t S6 = 0, size_t N7 = 0,
+                                  size_t S7 = 0)
+      : dimension{N0, N1, N2, N3, N4, N5, N6, N7}, stride{S0, S1, S2, S3,
+                                                          S4, S5, S6, S7} {}
 };
 
 // ==========================================================================
@@ -213,81 +206,81 @@ struct LayoutStride {
 /// compile-time constants.  This speeds up index calculations.  If
 /// both tile dimensions are powers of two, Kokkos can optimize
 /// further.
-template < unsigned ArgN0 , unsigned ArgN1 ,
-           bool IsPowerOfTwo = ( Impl::is_integral_power_of_two(ArgN0) &&
-                                 Impl::is_integral_power_of_two(ArgN1) )
-         >
+template <unsigned ArgN0, unsigned ArgN1,
+          bool IsPowerOfTwo = (Impl::is_integral_power_of_two(ArgN0) &&
+                               Impl::is_integral_power_of_two(ArgN1))>
 struct LayoutTileLeft {
-
-  static_assert( Impl::is_integral_power_of_two(ArgN0) &&
-                 Impl::is_integral_power_of_two(ArgN1)
-               , "LayoutTileLeft must be given power-of-two tile dimensions" );
+  static_assert(Impl::is_integral_power_of_two(ArgN0) &&
+                    Impl::is_integral_power_of_two(ArgN1),
+                "LayoutTileLeft must be given power-of-two tile dimensions");
 
   //! Tag this class as a kokkos array layout
-  typedef LayoutTileLeft<ArgN0,ArgN1,IsPowerOfTwo> array_layout ;
+  typedef LayoutTileLeft<ArgN0, ArgN1, IsPowerOfTwo> array_layout;
 
   enum { N0 = ArgN0 };
   enum { N1 = ArgN1 };
 
-  size_t dimension[ ARRAY_LAYOUT_MAX_RANK ] ;
+  size_t dimension[ARRAY_LAYOUT_MAX_RANK];
 
   enum { is_extent_constructible = true };
 
-  LayoutTileLeft( LayoutTileLeft const & ) = default ;
-  LayoutTileLeft( LayoutTileLeft && ) = default ;
-  LayoutTileLeft & operator = ( LayoutTileLeft const & ) = default ;
-  LayoutTileLeft & operator = ( LayoutTileLeft && ) = default ;
+  LayoutTileLeft(LayoutTileLeft const&) = default;
+  LayoutTileLeft(LayoutTileLeft&&)      = default;
+  LayoutTileLeft& operator=(LayoutTileLeft const&) = default;
+  LayoutTileLeft& operator=(LayoutTileLeft&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  explicit constexpr
-  LayoutTileLeft( size_t argN0 = 0 , size_t argN1 = 0 , size_t argN2 = 0 , size_t argN3 = 0
-                , size_t argN4 = 0 , size_t argN5 = 0 , size_t argN6 = 0 , size_t argN7 = 0
-                )
-    : dimension { argN0 , argN1 , argN2 , argN3 , argN4 , argN5 , argN6 , argN7 } {}
+  explicit constexpr LayoutTileLeft(size_t argN0 = 0, size_t argN1 = 0,
+                                    size_t argN2 = 0, size_t argN3 = 0,
+                                    size_t argN4 = 0, size_t argN5 = 0,
+                                    size_t argN6 = 0, size_t argN7 = 0)
+      : dimension{argN0, argN1, argN2, argN3, argN4, argN5, argN6, argN7} {}
 };
 
-#endif   // KOKKOS_ENABLE_DEPRECATED_CODE
+#endif  // KOKKOS_ENABLE_DEPRECATED_CODE
 // ===================================================================================
 
 //////////////////////////////////////////////////////////////////////////////////////
 
-enum class Iterate
-{
+enum class Iterate {
   Default,
-  Left,    // Left indices stride fastest
-  Right   // Right indices stride fastest
+  Left,  // Left indices stride fastest
+  Right  // Right indices stride fastest
 };
 
 // To check for LayoutTiled
-// This is to hide extra compile-time 'identifier' info within the LayoutTiled class by not relying on template specialization to include the ArgN*'s
-template < typename LayoutTiledCheck, class Enable = void >
+// This is to hide extra compile-time 'identifier' info within the LayoutTiled
+// class by not relying on template specialization to include the ArgN*'s
+template <typename LayoutTiledCheck, class Enable = void>
 struct is_layouttiled : std::false_type {};
 
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-template < typename LayoutTiledCheck >
-struct is_layouttiled< LayoutTiledCheck, typename std::enable_if<LayoutTiledCheck::is_array_layout_tiled>::type > : std::true_type {};
+template <typename LayoutTiledCheck>
+struct is_layouttiled<
+    LayoutTiledCheck,
+    typename std::enable_if<LayoutTiledCheck::is_array_layout_tiled>::type>
+    : std::true_type {};
 
 namespace Experimental {
 
 /// LayoutTiled
 // Must have Rank >= 2
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-           unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 = 0,  unsigned ArgN3 = 0,  unsigned ArgN4 = 0,  unsigned ArgN5 = 0,  unsigned ArgN6 = 0,  unsigned ArgN7 = 0, 
-           bool IsPowerOfTwo = 
-           ( Kokkos::Impl::is_integral_power_of_two(ArgN0) &&
-               Kokkos::Impl::is_integral_power_of_two(ArgN1) &&
-             (Kokkos::Impl::is_integral_power_of_two(ArgN2) || (ArgN2 == 0) ) &&
-             (Kokkos::Impl::is_integral_power_of_two(ArgN3) || (ArgN3 == 0) ) &&
-             (Kokkos::Impl::is_integral_power_of_two(ArgN4) || (ArgN4 == 0) ) &&
-             (Kokkos::Impl::is_integral_power_of_two(ArgN5) || (ArgN5 == 0) ) &&
-             (Kokkos::Impl::is_integral_power_of_two(ArgN6) || (ArgN6 == 0) ) &&
-             (Kokkos::Impl::is_integral_power_of_two(ArgN7) || (ArgN7 == 0) )
-           )
-         >
+template <
+    Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+    unsigned ArgN1, unsigned ArgN2 = 0, unsigned ArgN3 = 0, unsigned ArgN4 = 0,
+    unsigned ArgN5 = 0, unsigned ArgN6 = 0, unsigned ArgN7 = 0,
+    bool IsPowerOfTwo =
+        (Kokkos::Impl::is_integral_power_of_two(ArgN0) &&
+         Kokkos::Impl::is_integral_power_of_two(ArgN1) &&
+         (Kokkos::Impl::is_integral_power_of_two(ArgN2) || (ArgN2 == 0)) &&
+         (Kokkos::Impl::is_integral_power_of_two(ArgN3) || (ArgN3 == 0)) &&
+         (Kokkos::Impl::is_integral_power_of_two(ArgN4) || (ArgN4 == 0)) &&
+         (Kokkos::Impl::is_integral_power_of_two(ArgN5) || (ArgN5 == 0)) &&
+         (Kokkos::Impl::is_integral_power_of_two(ArgN6) || (ArgN6 == 0)) &&
+         (Kokkos::Impl::is_integral_power_of_two(ArgN7) || (ArgN7 == 0)))>
 struct LayoutTiled {
-
-  static_assert( IsPowerOfTwo
-               , "LayoutTiled must be given power-of-two tile dimensions" );
+  static_assert(IsPowerOfTwo,
+                "LayoutTiled must be given power-of-two tile dimensions");
 
 #if 0
   static_assert( (Impl::is_integral_power_of_two(ArgN0) ) &&
@@ -301,7 +294,9 @@ struct LayoutTiled {
                , "LayoutTiled must be given power-of-two tile dimensions" );
 #endif
 
-  typedef LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, IsPowerOfTwo> array_layout ;
+  typedef LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5,
+                      ArgN6, ArgN7, IsPowerOfTwo>
+      array_layout;
   static constexpr Iterate outer_pattern = OuterP;
   static constexpr Iterate inner_pattern = InnerP;
 
@@ -314,79 +309,93 @@ struct LayoutTiled {
   enum { N6 = ArgN6 };
   enum { N7 = ArgN7 };
 
-  size_t dimension[ ARRAY_LAYOUT_MAX_RANK ] ;
+  size_t dimension[ARRAY_LAYOUT_MAX_RANK];
 
   enum { is_extent_constructible = true };
 
-  LayoutTiled( LayoutTiled const & ) = default ;
-  LayoutTiled( LayoutTiled && ) = default ;
-  LayoutTiled & operator = ( LayoutTiled const & ) = default ;
-  LayoutTiled & operator = ( LayoutTiled && ) = default ;
+  LayoutTiled(LayoutTiled const&) = default;
+  LayoutTiled(LayoutTiled&&)      = default;
+  LayoutTiled& operator=(LayoutTiled const&) = default;
+  LayoutTiled& operator=(LayoutTiled&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  explicit constexpr
-  LayoutTiled( size_t argN0 = 0 , size_t argN1 = 0 , size_t argN2 = 0 , size_t argN3 = 0
-                , size_t argN4 = 0 , size_t argN5 = 0 , size_t argN6 = 0 , size_t argN7 = 0
-                )
-    : dimension { argN0 , argN1 , argN2 , argN3 , argN4 , argN5 , argN6 , argN7 } {}
+  explicit constexpr LayoutTiled(size_t argN0 = 0, size_t argN1 = 0,
+                                 size_t argN2 = 0, size_t argN3 = 0,
+                                 size_t argN4 = 0, size_t argN5 = 0,
+                                 size_t argN6 = 0, size_t argN7 = 0)
+      : dimension{argN0, argN1, argN2, argN3, argN4, argN5, argN6, argN7} {}
 };
 
-} // namespace Experimental
+}  // namespace Experimental
 #endif
 
-
 // For use with view_copy
-template < typename ... Layout >
+template <typename... Layout>
 struct layout_iterate_type_selector {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Default ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Default ;
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::Iterate::Default;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::Iterate::Default;
 };
 
 template <>
-struct layout_iterate_type_selector< Kokkos::LayoutRight > {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right ;
+struct layout_iterate_type_selector<Kokkos::LayoutRight> {
+  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right;
+  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right;
 };
 
 template <>
-struct layout_iterate_type_selector< Kokkos::LayoutLeft > {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left ;
+struct layout_iterate_type_selector<Kokkos::LayoutLeft> {
+  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left;
+  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left;
 };
 
 template <>
-struct layout_iterate_type_selector< Kokkos::LayoutStride > {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Default ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Default ;
+struct layout_iterate_type_selector<Kokkos::LayoutStride> {
+  static const Kokkos::Iterate outer_iteration_pattern =
+      Kokkos::Iterate::Default;
+  static const Kokkos::Iterate inner_iteration_pattern =
+      Kokkos::Iterate::Default;
 };
 
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-template < unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 ,  unsigned ArgN6 ,  unsigned ArgN7 >
-struct layout_iterate_type_selector< Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Left, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, true> > {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left ;
+template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
+          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
+struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
+    Kokkos::Iterate::Left, Kokkos::Iterate::Left, ArgN0, ArgN1, ArgN2, ArgN3,
+    ArgN4, ArgN5, ArgN6, ArgN7, true> > {
+  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left;
+  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left;
 };
 
-template < unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 ,  unsigned ArgN6 ,  unsigned ArgN7 >
-struct layout_iterate_type_selector< Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Left, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, true> > {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left ;
+template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
+          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
+struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
+    Kokkos::Iterate::Right, Kokkos::Iterate::Left, ArgN0, ArgN1, ArgN2, ArgN3,
+    ArgN4, ArgN5, ArgN6, ArgN7, true> > {
+  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right;
+  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left;
 };
 
-template < unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 ,  unsigned ArgN6 ,  unsigned ArgN7 >
-struct layout_iterate_type_selector< Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Right, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, true> > {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right ;
+template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
+          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
+struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
+    Kokkos::Iterate::Left, Kokkos::Iterate::Right, ArgN0, ArgN1, ArgN2, ArgN3,
+    ArgN4, ArgN5, ArgN6, ArgN7, true> > {
+  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left;
+  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right;
 };
 
-template < unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 ,  unsigned ArgN6 ,  unsigned ArgN7 >
-struct layout_iterate_type_selector< Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Right, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, true> > {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right ;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right ;
+template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
+          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
+struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
+    Kokkos::Iterate::Right, Kokkos::Iterate::Right, ArgN0, ArgN1, ArgN2, ArgN3,
+    ArgN4, ArgN5, ArgN6, ArgN7, true> > {
+  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right;
+  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right;
 };
 #endif
 
-} // namespace Kokkos
-
-#endif // #ifndef KOKKOS_LAYOUT_HPP
+}  // namespace Kokkos
 
+#endif  // #ifndef KOKKOS_LAYOUT_HPP
diff --git a/lib/kokkos/core/src/Kokkos_Macros.hpp b/lib/kokkos/core/src/Kokkos_Macros.hpp
index 6b8ae02f824cfa8816bc52b9b3f3aacf6d385985..5649d12e97fbf187b24d8a48554f5848dcd34065 100644
--- a/lib/kokkos/core/src/Kokkos_Macros.hpp
+++ b/lib/kokkos/core/src/Kokkos_Macros.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,15 +53,16 @@
  *  KOKKOS_ENABLE_QTHREADS            Kokkos::Qthreads execution space
  *  KOKKOS_ENABLE_HPX                 Kokkos::Experimental::HPX execution space
  *  KOKKOS_ENABLE_OPENMP              Kokkos::OpenMP execution space
- *  KOKKOS_ENABLE_OPENMPTARGET        Kokkos::Experimental::OpenMPTarget execution space
- *  KOKKOS_ENABLE_HWLOC               HWLOC library is available.
+ *  KOKKOS_ENABLE_OPENMPTARGET        Kokkos::Experimental::OpenMPTarget
+ * execution space KOKKOS_ENABLE_HWLOC               HWLOC library is available.
  *  KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK  Insert array bounds checks, is expensive!
- *  KOKKOS_ENABLE_MPI                 Negotiate MPI/execution space interactions.
- *  KOKKOS_ENABLE_CUDA_UVM            Use CUDA UVM for Cuda memory space.
+ *  KOKKOS_ENABLE_MPI                 Negotiate MPI/execution space
+ * interactions. KOKKOS_ENABLE_CUDA_UVM            Use CUDA UVM for Cuda memory
+ * space.
  */
 
 #ifndef KOKKOS_DONT_INCLUDE_CORE_CONFIG_H
-  #include <KokkosCore_config.h>
+#include <KokkosCore_config.h>
 #endif
 
 #include <impl/Kokkos_OldMacros.hpp>
@@ -97,449 +99,461 @@
 
 //----------------------------------------------------------------------------
 
-#if defined(KOKKOS_ENABLE_SERIAL) || defined(KOKKOS_ENABLE_THREADS) || \
+#if defined(KOKKOS_ENABLE_SERIAL) || defined(KOKKOS_ENABLE_THREADS) ||  \
     defined(KOKKOS_ENABLE_OPENMP) || defined(KOKKOS_ENABLE_QTHREADS) || \
-    defined(KOKKOS_ENABLE_HPX) || \
-    defined(KOKKOS_ENABLE_ROCM) || defined(KOKKOS_ENABLE_OPENMPTARGET)
-  #define KOKKOS_INTERNAL_ENABLE_NON_CUDA_BACKEND
+    defined(KOKKOS_ENABLE_HPX) || defined(KOKKOS_ENABLE_ROCM) ||        \
+    defined(KOKKOS_ENABLE_OPENMPTARGET)
+#define KOKKOS_INTERNAL_ENABLE_NON_CUDA_BACKEND
 #endif
 
-#if !defined(KOKKOS_ENABLE_THREADS) && !defined(KOKKOS_ENABLE_CUDA) && \
+#if !defined(KOKKOS_ENABLE_THREADS) && !defined(KOKKOS_ENABLE_CUDA) &&    \
     !defined(KOKKOS_ENABLE_OPENMP) && !defined(KOKKOS_ENABLE_QTHREADS) && \
-    !defined(KOKKOS_ENABLE_HPX) && \
-    !defined(KOKKOS_ENABLE_ROCM) && !defined(KOKKOS_ENABLE_OPENMPTARGET)
-  #define KOKKOS_INTERNAL_NOT_PARALLEL
+    !defined(KOKKOS_ENABLE_HPX) && !defined(KOKKOS_ENABLE_ROCM) &&        \
+    !defined(KOKKOS_ENABLE_OPENMPTARGET)
+#define KOKKOS_INTERNAL_NOT_PARALLEL
 #endif
 
 #define KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
 
-#if defined( KOKKOS_ENABLE_CUDA ) && defined( __CUDACC__ )
-  // Compiling with a CUDA compiler.
-  //
-  //  Include <cuda.h> to pick up the CUDA_VERSION macro defined as:
-  //    CUDA_VERSION = ( MAJOR_VERSION * 1000 ) + ( MINOR_VERSION * 10 )
-  //
-  //  When generating device code the __CUDA_ARCH__ macro is defined as:
-  //    __CUDA_ARCH__ = ( MAJOR_CAPABILITY * 100 ) + ( MINOR_CAPABILITY * 10 )
-
-  #include <cuda_runtime.h>
-  #include <cuda.h>
-
-  #if !defined( CUDA_VERSION )
-    #error "#include <cuda.h> did not define CUDA_VERSION."
-  #endif
-
-  #if ( CUDA_VERSION < 7000 )
-    // CUDA supports C++11 in device code starting with version 7.0.
-    // This includes auto type and device code internal lambdas.
-    #error "Cuda version 7.0 or greater required."
-  #endif
-
-  #if defined( __CUDA_ARCH__ ) && ( __CUDA_ARCH__ < 300 )
-    // Compiling with CUDA compiler for device code.
-    #error "Cuda device capability >= 3.0 is required."
-  #endif
-
-  #ifdef KOKKOS_ENABLE_CUDA_LAMBDA
-    #if ( CUDA_VERSION < 7050 )
-      // CUDA supports C++11 lambdas generated in host code to be given
-      // to the device starting with version 7.5. But the release candidate (7.5.6)
-      // still identifies as 7.0.
-      #error "Cuda version 7.5 or greater required for host-to-device Lambda support."
-    #endif
-
-    #if ( CUDA_VERSION < 8000 ) && defined( __NVCC__ )
-      #define KOKKOS_LAMBDA [=]__device__
-      #if defined( KOKKOS_INTERNAL_ENABLE_NON_CUDA_BACKEND )
-        #undef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-      #endif
-    #else
-      #define KOKKOS_LAMBDA [=]__host__ __device__
-
-      #if defined( KOKKOS_ENABLE_CXX17 ) || defined( KOKKOS_ENABLE_CXX20 )
-        #define KOKKOS_CLASS_LAMBDA        [=,*this] __host__ __device__
-      #endif
-    #endif
-
-    #if defined( __NVCC__ )
-      #define KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER
-    #endif
-  #else // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
-    #undef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-  #endif // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
-
-  #if ( 9000 <= CUDA_VERSION ) && ( CUDA_VERSION < 10000 )
-    // CUDA 9 introduced an incorrect warning,
-    // see https://github.com/kokkos/kokkos/issues/1470
-    #define KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
-  #endif
-
-  #if ( 10000 > CUDA_VERSION )
-    #define KOKKOS_ENABLE_PRE_CUDA_10_DEPRECATION_API
-  #endif
-
-  #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 700)
-    // PTX atomics with memory order semantics are only available on volta and later
-    #if !defined(KOKKOS_DISABLE_CUDA_ASM)
-      #if !defined(KOKKOS_ENABLE_CUDA_ASM)
-        #define KOKKOS_ENABLE_CUDA_ASM
-        #if !defined(KOKKOS_DISABLE_CUDA_ASM_ATOMICS)
-          #define KOKKOS_ENABLE_CUDA_ASM_ATOMICS
-        #endif
-      #endif
-    #endif
-  #endif
-
-
-#endif // #if defined( KOKKOS_ENABLE_CUDA ) && defined( __CUDACC__ )
+#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDACC__)
+// Compiling with a CUDA compiler.
+//
+//  Include <cuda.h> to pick up the CUDA_VERSION macro defined as:
+//    CUDA_VERSION = ( MAJOR_VERSION * 1000 ) + ( MINOR_VERSION * 10 )
+//
+//  When generating device code the __CUDA_ARCH__ macro is defined as:
+//    __CUDA_ARCH__ = ( MAJOR_CAPABILITY * 100 ) + ( MINOR_CAPABILITY * 10 )
+
+#include <cuda_runtime.h>
+#include <cuda.h>
+
+#if !defined(CUDA_VERSION)
+#error "#include <cuda.h> did not define CUDA_VERSION."
+#endif
+
+#if (CUDA_VERSION < 7000)
+// CUDA supports C++11 in device code starting with version 7.0.
+// This includes auto type and device code internal lambdas.
+#error "Cuda version 7.0 or greater required."
+#endif
+
+#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 300)
+// Compiling with CUDA compiler for device code.
+#error "Cuda device capability >= 3.0 is required."
+#endif
+
+#ifdef KOKKOS_ENABLE_CUDA_LAMBDA
+#if (CUDA_VERSION < 7050)
+// CUDA supports C++11 lambdas generated in host code to be given
+// to the device starting with version 7.5. But the release candidate (7.5.6)
+// still identifies as 7.0.
+#error "Cuda version 7.5 or greater required for host-to-device Lambda support."
+#endif
+
+#if (CUDA_VERSION < 8000) && defined(__NVCC__)
+#define KOKKOS_LAMBDA [=] __device__
+#if defined(KOKKOS_INTERNAL_ENABLE_NON_CUDA_BACKEND)
+#undef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
+#endif
+#else
+#define KOKKOS_LAMBDA [=] __host__ __device__
+
+#if defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20)
+#define KOKKOS_CLASS_LAMBDA [ =, *this ] __host__ __device__
+#endif
+#endif
+
+#if defined(__NVCC__)
+#define KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER
+#endif
+#else  // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
+#undef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
+#endif  // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
 
+#if (9000 <= CUDA_VERSION) && (CUDA_VERSION < 10000)
+// CUDA 9 introduced an incorrect warning,
+// see https://github.com/kokkos/kokkos/issues/1470
+#define KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
+#endif
+
+#if (10000 > CUDA_VERSION)
+#define KOKKOS_ENABLE_PRE_CUDA_10_DEPRECATION_API
+#endif
+
+#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 700)
+// PTX atomics with memory order semantics are only available on volta and later
+#if !defined(KOKKOS_DISABLE_CUDA_ASM)
+#if !defined(KOKKOS_ENABLE_CUDA_ASM)
+#define KOKKOS_ENABLE_CUDA_ASM
+#if !defined(KOKKOS_DISABLE_CUDA_ASM_ATOMICS)
+#define KOKKOS_ENABLE_CUDA_ASM_ATOMICS
+#endif
+#endif
+#endif
+#endif
+
+#endif  // #if defined( KOKKOS_ENABLE_CUDA ) && defined( __CUDACC__ )
 
 //----------------------------------------------------------------------------
 // Mapping compiler built-ins to KOKKOS_COMPILER_*** macros
 
-#if defined( __NVCC__ )
-  // NVIDIA compiler is being used.
-  // Code is parsed and separated into host and device code.
-  // Host code is compiled again with another compiler.
-  // Device code is compile to 'ptx'.
-  #define KOKKOS_COMPILER_NVCC __NVCC__
-#endif // #if defined( __NVCC__ )
+#if defined(__NVCC__)
+// NVIDIA compiler is being used.
+// Code is parsed and separated into host and device code.
+// Host code is compiled again with another compiler.
+// Device code is compile to 'ptx'.
+#define KOKKOS_COMPILER_NVCC __NVCC__
+#endif  // #if defined( __NVCC__ )
 
-#if !defined( KOKKOS_LAMBDA )
-  #define KOKKOS_LAMBDA [=]
+#if !defined(KOKKOS_LAMBDA)
+#define KOKKOS_LAMBDA [=]
 #endif
 
-#if (defined( KOKKOS_ENABLE_CXX17 ) || defined( KOKKOS_ENABLE_CXX20) )&& !defined( KOKKOS_CLASS_LAMBDA )
-  #define KOKKOS_CLASS_LAMBDA [=,*this]
+#if (defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20)) && \
+    !defined(KOKKOS_CLASS_LAMBDA)
+#define KOKKOS_CLASS_LAMBDA [ =, *this ]
 #endif
 
 //#if !defined( __CUDA_ARCH__ ) // Not compiling Cuda code to 'ptx'.
 
 // Intel compiler for host code.
 
-#if defined( __INTEL_COMPILER )
-  #define KOKKOS_COMPILER_INTEL __INTEL_COMPILER
-#elif defined( __ICC )
-  // Old define
-  #define KOKKOS_COMPILER_INTEL __ICC
-#elif defined( __ECC )
-  // Very old define
-  #define KOKKOS_COMPILER_INTEL __ECC
+#if defined(__INTEL_COMPILER)
+#define KOKKOS_COMPILER_INTEL __INTEL_COMPILER
+#elif defined(__ICC)
+// Old define
+#define KOKKOS_COMPILER_INTEL __ICC
+#elif defined(__ECC)
+// Very old define
+#define KOKKOS_COMPILER_INTEL __ECC
 #endif
 
 // CRAY compiler for host code
-#if defined( _CRAYC )
-  #define KOKKOS_COMPILER_CRAYC _CRAYC
+#if defined(_CRAYC)
+#define KOKKOS_COMPILER_CRAYC _CRAYC
 #endif
 
-#if defined( __IBMCPP__ )
-  // IBM C++
-  #define KOKKOS_COMPILER_IBM __IBMCPP__
-#elif defined( __IBMC__ )
-  #define KOKKOS_COMPILER_IBM __IBMC__
+#if defined(__IBMCPP__)
+// IBM C++
+#define KOKKOS_COMPILER_IBM __IBMCPP__
+#elif defined(__IBMC__)
+#define KOKKOS_COMPILER_IBM __IBMC__
 #endif
 
-#if defined( __APPLE_CC__ )
-  #define KOKKOS_COMPILER_APPLECC __APPLE_CC__
+#if defined(__APPLE_CC__)
+#define KOKKOS_COMPILER_APPLECC __APPLE_CC__
 #endif
 
-#if defined( __clang__ ) && !defined( KOKKOS_COMPILER_INTEL )
-  #define KOKKOS_COMPILER_CLANG __clang_major__*100+__clang_minor__*10+__clang_patchlevel__
+#if defined(__clang__) && !defined(KOKKOS_COMPILER_INTEL)
+#define KOKKOS_COMPILER_CLANG \
+  __clang_major__ * 100 + __clang_minor__ * 10 + __clang_patchlevel__
 #endif
 
-#if !defined( __clang__ ) && !defined( KOKKOS_COMPILER_INTEL ) &&defined( __GNUC__ )
-  #define KOKKOS_COMPILER_GNU __GNUC__*100+__GNUC_MINOR__*10+__GNUC_PATCHLEVEL__
+#if !defined(__clang__) && !defined(KOKKOS_COMPILER_INTEL) && defined(__GNUC__)
+#define KOKKOS_COMPILER_GNU \
+  __GNUC__ * 100 + __GNUC_MINOR__ * 10 + __GNUC_PATCHLEVEL__
 
-  #if ( 472 > KOKKOS_COMPILER_GNU )
-    #error "Compiling with GCC version earlier than 4.7.2 is not supported."
-  #endif
+#if (472 > KOKKOS_COMPILER_GNU)
+#error "Compiling with GCC version earlier than 4.7.2 is not supported."
+#endif
 #endif
 
-#if defined( __PGIC__ )
-  #define KOKKOS_COMPILER_PGI __PGIC__*100+__PGIC_MINOR__*10+__PGIC_PATCHLEVEL__
+#if defined(__PGIC__)
+#define KOKKOS_COMPILER_PGI \
+  __PGIC__ * 100 + __PGIC_MINOR__ * 10 + __PGIC_PATCHLEVEL__
 
-  #if ( 1540 > KOKKOS_COMPILER_PGI )
-    #error "Compiling with PGI version earlier than 15.4 is not supported."
-  #endif
+#if (1540 > KOKKOS_COMPILER_PGI)
+#error "Compiling with PGI version earlier than 15.4 is not supported."
+#endif
 #endif
 
 //#endif // #if !defined( __CUDA_ARCH__ )
 //----------------------------------------------------------------------------
 // Language info: C++, CUDA, OPENMP
 
-#if defined( KOKKOS_ENABLE_CUDA )
-  // Compiling Cuda code to 'ptx'
+#if defined(KOKKOS_ENABLE_CUDA)
+// Compiling Cuda code to 'ptx'
 
-  #define KOKKOS_FORCEINLINE_FUNCTION  __device__  __host__  __forceinline__
-  #define KOKKOS_INLINE_FUNCTION       __device__  __host__  inline
-  #define KOKKOS_FUNCTION              __device__  __host__
-  #if defined( KOKKOS_COMPILER_NVCC )
-    #define KOKKOS_INLINE_FUNCTION_DELETED inline
-  #else
-    #define KOKKOS_INLINE_FUNCTION_DELETED __device__  __host__  inline
-  #endif
-#endif // #if defined( __CUDA_ARCH__ )
+#define KOKKOS_FORCEINLINE_FUNCTION __device__ __host__ __forceinline__
+#define KOKKOS_IMPL_FORCEINLINE __forceinline__
+#define KOKKOS_INLINE_FUNCTION __device__ __host__ inline
+#define KOKKOS_FUNCTION __device__ __host__
+#if defined(KOKKOS_COMPILER_NVCC)
+#define KOKKOS_INLINE_FUNCTION_DELETED inline
+#else
+#define KOKKOS_INLINE_FUNCTION_DELETED __device__ __host__ inline
+#endif
+#endif  // #if defined( __CUDA_ARCH__ )
 
-#if defined( KOKKOS_ENABLE_ROCM ) && defined( __HCC__ )
+#if defined(KOKKOS_ENABLE_ROCM) && defined(__HCC__)
 
-  #define KOKKOS_FORCEINLINE_FUNCTION  __attribute__((amp,cpu)) inline
-  #define KOKKOS_INLINE_FUNCTION       __attribute__((amp,cpu)) inline
-  #define KOKKOS_FUNCTION              __attribute__((amp,cpu))
-  #define KOKKOS_LAMBDA                [=] __attribute__((amp,cpu))
+#define KOKKOS_FORCEINLINE_FUNCTION __attribute__((amp, cpu)) inline
+#define KOKKOS_INLINE_FUNCTION __attribute__((amp, cpu)) inline
+#define KOKKOS_FUNCTION __attribute__((amp, cpu))
+#define KOKKOS_LAMBDA [=] __attribute__((amp, cpu))
 #endif
 
-#if defined( _OPENMP )
-  //  Compiling with OpenMP.
-  //  The value of _OPENMP is an integer value YYYYMM
-  //  where YYYY and MM are the year and month designation
-  //  of the supported OpenMP API version.
-#endif // #if defined( _OPENMP )
+#if defined(_OPENMP)
+//  Compiling with OpenMP.
+//  The value of _OPENMP is an integer value YYYYMM
+//  where YYYY and MM are the year and month designation
+//  of the supported OpenMP API version.
+#endif  // #if defined( _OPENMP )
 
 //----------------------------------------------------------------------------
 // Intel compiler macros
 
-#if defined( KOKKOS_COMPILER_INTEL )
-  #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
-  #define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
-  #define KOKKOS_ENABLE_PRAGMA_VECTOR 1
-  #if ( 1800 > KOKKOS_COMPILER_INTEL )
-    #define KOKKOS_ENABLE_PRAGMA_SIMD 1
-  #endif
-
-  #if ( __INTEL_COMPILER > 1400 )
-    #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
-  #endif
-
-  #if ! defined( KOKKOS_MEMORY_ALIGNMENT )
-    #define KOKKOS_MEMORY_ALIGNMENT 64
-  #endif
-
-  #define KOKKOS_RESTRICT __restrict__
-
-  #ifndef KOKKOS_IMPL_ALIGN_PTR
-    #define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((align_value(size)))
-  #endif
-
-  #if ( 1400 > KOKKOS_COMPILER_INTEL )
-    #if ( 1300 > KOKKOS_COMPILER_INTEL )
-      #error "Compiling with Intel version earlier than 13.0 is not supported. Official minimal version is 14.0."
-    #else
-      #warning "Compiling with Intel version 13.x probably works but is not officially supported. Official minimal version is 14.0."
-    #endif
-  #endif
-
-  #if !defined( KOKKOS_ENABLE_ASM ) && !defined( _WIN32 )
-    #define KOKKOS_ENABLE_ASM 1
-  #endif
-
-  #if !defined( KOKKOS_FORCEINLINE_FUNCTION )
-    #if !defined( _WIN32 )
-      #define KOKKOS_FORCEINLINE_FUNCTION  inline __attribute__((always_inline))
-    #else
-      #define KOKKOS_FORCEINLINE_FUNCTION inline
-    #endif
-  #endif
-
-  #if defined( KOKKOS_ARCH_AVX512MIC )
-      #define KOKKOS_ENABLE_RFO_PREFETCH 1
-      #if (KOKKOS_COMPILER_INTEL < 1800) && !defined(KOKKOS_KNL_USE_ASM_WORKAROUND)
-        #define KOKKOS_KNL_USE_ASM_WORKAROUND 1
-      #endif
-  #endif
-
-  #if defined( __MIC__ )
-    // Compiling for Xeon Phi
-  #endif
+#if defined(KOKKOS_COMPILER_INTEL)
+#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
+#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
+#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
+#if (1800 > KOKKOS_COMPILER_INTEL)
+#define KOKKOS_ENABLE_PRAGMA_SIMD 1
+#endif
+
+#if (__INTEL_COMPILER > 1400)
+#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
+#endif
+
+#if !defined(KOKKOS_MEMORY_ALIGNMENT)
+#define KOKKOS_MEMORY_ALIGNMENT 64
+#endif
+
+#define KOKKOS_RESTRICT __restrict__
+
+#ifndef KOKKOS_IMPL_ALIGN_PTR
+#define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((align_value(size)))
+#endif
+
+#if (1400 > KOKKOS_COMPILER_INTEL)
+#if (1300 > KOKKOS_COMPILER_INTEL)
+#error \
+    "Compiling with Intel version earlier than 13.0 is not supported. Official minimal version is 14.0."
+#else
+#warning \
+    "Compiling with Intel version 13.x probably works but is not officially supported. Official minimal version is 14.0."
+#endif
+#endif
+
+#if !defined(KOKKOS_ENABLE_ASM) && !defined(_WIN32)
+#define KOKKOS_ENABLE_ASM 1
+#endif
+
+#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
+#if !defined(_WIN32)
+#define KOKKOS_FORCEINLINE_FUNCTION inline __attribute__((always_inline))
+#define KOKKOS_IMPL_FORCEINLINE __attribute__((always_inline))
+#else
+#define KOKKOS_FORCEINLINE_FUNCTION inline
+#endif
+#endif
+
+#if defined(KOKKOS_ARCH_AVX512MIC)
+#define KOKKOS_ENABLE_RFO_PREFETCH 1
+#if (KOKKOS_COMPILER_INTEL < 1800) && !defined(KOKKOS_KNL_USE_ASM_WORKAROUND)
+#define KOKKOS_KNL_USE_ASM_WORKAROUND 1
+#endif
+#endif
+
+#if defined(__MIC__)
+// Compiling for Xeon Phi
+#endif
 #endif
 
 //----------------------------------------------------------------------------
 // Cray compiler macros
 
-#if defined( KOKKOS_COMPILER_CRAYC )
+#if defined(KOKKOS_COMPILER_CRAYC)
 #endif
 
 //----------------------------------------------------------------------------
 // IBM Compiler macros
 
-#if defined( KOKKOS_COMPILER_IBM )
-  #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
-  //#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
-  //#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
-  //#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
-  //#define KOKKOS_ENABLE_PRAGMA_SIMD 1
+#if defined(KOKKOS_COMPILER_IBM)
+#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
+//#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
+//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
+//#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
+//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
 
-  #if ! defined( KOKKOS_ENABLE_ASM )
-    #define KOKKOS_ENABLE_ASM 1
-  #endif
+#if !defined(KOKKOS_ENABLE_ASM)
+#define KOKKOS_ENABLE_ASM 1
+#endif
 #endif
 
 //----------------------------------------------------------------------------
 // CLANG compiler macros
 
-#if defined( KOKKOS_COMPILER_CLANG )
-  //#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
-  //#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
-  //#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
-  //#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
-  //#define KOKKOS_ENABLE_PRAGMA_SIMD 1
+#if defined(KOKKOS_COMPILER_CLANG)
+//#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
+//#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
+//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
+//#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
+//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
 
-  #if !defined( KOKKOS_FORCEINLINE_FUNCTION )
-    #define KOKKOS_FORCEINLINE_FUNCTION  inline __attribute__((always_inline))
-  #endif
+#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
+#define KOKKOS_FORCEINLINE_FUNCTION inline __attribute__((always_inline))
+#define KOKKOS_IMPL_FORCEINLINE __attribute__((always_inline))
+#endif
 
-  #if !defined( KOKKOS_IMPL_ALIGN_PTR )
-    #define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((aligned(size)))
-  #endif
+#if !defined(KOKKOS_IMPL_ALIGN_PTR)
+#define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((aligned(size)))
+#endif
 
 #endif
 
 //----------------------------------------------------------------------------
 // GNU Compiler macros
 
-#if defined( KOKKOS_COMPILER_GNU )
-  //#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
-  //#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
-  //#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
-  //#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
-  //#define KOKKOS_ENABLE_PRAGMA_SIMD 1
+#if defined(KOKKOS_COMPILER_GNU)
+//#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
+//#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
+//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
+//#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
+//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
 
-  #if defined( KOKKOS_ARCH_AVX512MIC )
-      #define KOKKOS_ENABLE_RFO_PREFETCH 1
-  #endif
+#if defined(KOKKOS_ARCH_AVX512MIC)
+#define KOKKOS_ENABLE_RFO_PREFETCH 1
+#endif
 
-  #if !defined( KOKKOS_FORCEINLINE_FUNCTION )
-    #define KOKKOS_FORCEINLINE_FUNCTION inline __attribute__((always_inline))
-  #endif
+#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
+#define KOKKOS_FORCEINLINE_FUNCTION inline __attribute__((always_inline))
+#define KOKKOS_IMPL_FORCEINLINE __attribute__((always_inline))
+#endif
 
-  #define KOKKOS_RESTRICT __restrict__
+#define KOKKOS_RESTRICT __restrict__
 
-  #if !defined( KOKKOS_ENABLE_ASM ) && !defined( __PGIC__ ) && \
-      ( defined( __amd64 ) || defined( __amd64__ ) || \
-        defined( __x86_64 ) || defined( __x86_64__ ) || \
-	defined(__PPC64__) )
-    #define KOKKOS_ENABLE_ASM 1
-  #endif
+#if !defined(KOKKOS_ENABLE_ASM) && !defined(__PGIC__) &&            \
+    (defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
+     defined(__x86_64__) || defined(__PPC64__))
+#define KOKKOS_ENABLE_ASM 1
+#endif
 #endif
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_COMPILER_PGI )
-  #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
-  #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
-  //#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
-  #define KOKKOS_ENABLE_PRAGMA_VECTOR 1
-  //#define KOKKOS_ENABLE_PRAGMA_SIMD 1
+#if defined(KOKKOS_COMPILER_PGI)
+#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
+#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
+//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
+#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
+//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
 #endif
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_COMPILER_NVCC )
-  #if defined( __CUDA_ARCH__ )
-    #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
-  #endif
+#if defined(KOKKOS_COMPILER_NVCC)
+#if defined(__CUDA_ARCH__)
+#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
+#endif
 #endif
 
 //----------------------------------------------------------------------------
 // Define function marking macros if compiler specific macros are undefined:
 
-#if !defined( KOKKOS_FORCEINLINE_FUNCTION )
-  define KOKKOS_FORCEINLINE_FUNCTION  inline
+#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
+#define KOKKOS_FORCEINLINE_FUNCTION inline
 #endif
 
-#if !defined( KOKKOS_INLINE_FUNCTION )
-  #define KOKKOS_INLINE_FUNCTION  inline
+#if !defined(KOKKOS_IMPL_FORCEINLINE)
+#define KOKKOS_IMPL_FORCEINLINE inline
 #endif
 
-#if !defined( KOKKOS_FUNCTION )
-  #define KOKKOS_FUNCTION /**/
+#if !defined(KOKKOS_INLINE_FUNCTION)
+#define KOKKOS_INLINE_FUNCTION inline
 #endif
 
-#if !defined( KOKKOS_INLINE_FUNCTION_DELETED )
-  #define KOKKOS_INLINE_FUNCTION_DELETED inline
+#if !defined(KOKKOS_FUNCTION)
+#define KOKKOS_FUNCTION /**/
+#endif
+
+#if !defined(KOKKOS_INLINE_FUNCTION_DELETED)
+#define KOKKOS_INLINE_FUNCTION_DELETED inline
 #endif
 //----------------------------------------------------------------------------
 // Define empty macro for restrict if necessary:
 
-#if !defined( KOKKOS_RESTRICT )
-  #define KOKKOS_RESTRICT
+#if !defined(KOKKOS_RESTRICT)
+#define KOKKOS_RESTRICT
 #endif
 
 //----------------------------------------------------------------------------
 // Define Macro for alignment:
 
-#if ! defined( KOKKOS_MEMORY_ALIGNMENT )
-  #define KOKKOS_MEMORY_ALIGNMENT 64
+#if !defined(KOKKOS_MEMORY_ALIGNMENT)
+#define KOKKOS_MEMORY_ALIGNMENT 64
 #endif
 
-#if ! defined( KOKKOS_MEMORY_ALIGNMENT_THRESHOLD )
-  #define KOKKOS_MEMORY_ALIGNMENT_THRESHOLD 1
+#if !defined(KOKKOS_MEMORY_ALIGNMENT_THRESHOLD)
+#define KOKKOS_MEMORY_ALIGNMENT_THRESHOLD 1
 #endif
 
-#if !defined( KOKKOS_IMPL_ALIGN_PTR )
-  #define KOKKOS_IMPL_ALIGN_PTR(size) /* */
+#if !defined(KOKKOS_IMPL_ALIGN_PTR)
+#define KOKKOS_IMPL_ALIGN_PTR(size) /* */
 #endif
 
 //----------------------------------------------------------------------------
 // Determine the default execution space for parallel dispatch.
 // There is zero or one default execution space specified.
 
-#if 1 < ( ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA ) ? 1 : 0 ) + \
-          ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM ) ? 1 : 0 ) + \
-          ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET ) ? 1 : 0 ) + \
-          ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP ) ? 1 : 0 ) + \
-          ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS ) ? 1 : 0 ) + \
-          ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS ) ? 1 : 0 ) + \
-          ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX ) ? 1 : 0 ) + \
-          ( defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL ) ? 1 : 0 ) )
-  #error "More than one KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_* specified."
+#if 1 < ((defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA) ? 1 : 0) +         \
+         (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM) ? 1 : 0) +         \
+         (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET) ? 1 : 0) + \
+         (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP) ? 1 : 0) +       \
+         (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS) ? 1 : 0) +      \
+         (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS) ? 1 : 0) +     \
+         (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX) ? 1 : 0) +          \
+         (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL) ? 1 : 0))
+#error "More than one KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_* specified."
 #endif
 
 // If default is not specified then chose from enabled execution spaces.
 // Priority: CUDA, OPENMP, THREADS, QTHREADS, HPX, SERIAL
-#if   defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA )
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM )
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET )
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP )
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS )
+#if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA)
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM)
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET)
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
 //#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS )
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX )
-#elif defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL )
-#elif defined( KOKKOS_ENABLE_CUDA )
-  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA
-#elif defined( KOKKOS_ENABLE_ROCM )
-  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM
-#elif defined( KOKKOS_ENABLE_OPENMPTARGET )
-  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET
-#elif defined( KOKKOS_ENABLE_OPENMP )
-  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP
-#elif defined( KOKKOS_ENABLE_THREADS )
-  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX)
+#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL)
+#elif defined(KOKKOS_ENABLE_CUDA)
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA
+#elif defined(KOKKOS_ENABLE_ROCM)
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM
+#elif defined(KOKKOS_ENABLE_OPENMPTARGET)
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET
+#elif defined(KOKKOS_ENABLE_OPENMP)
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP
+#elif defined(KOKKOS_ENABLE_THREADS)
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS
 //#elif defined( KOKKOS_ENABLE_QTHREADS )
 //  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS
-#elif defined( KOKKOS_ENABLE_HPX )
-  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX
+#elif defined(KOKKOS_ENABLE_HPX)
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX
 #else
-  #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL
 #endif
 
 //----------------------------------------------------------------------------
 // Determine for what space the code is being compiled:
 
-#if defined( __CUDACC__ ) && defined( __CUDA_ARCH__ ) && defined( KOKKOS_ENABLE_CUDA )
-  #define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA
-#elif   defined( __HCC__ ) && defined( __HCC_ACCELERATOR__ ) && defined( KOKKOS_ENABLE_ROCM )
-  #define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_ROCM_GPU
+#if defined(__CUDACC__) && defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA)
+#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA
+#elif defined(__HCC__) && defined(__HCC_ACCELERATOR__) && \
+    defined(KOKKOS_ENABLE_ROCM)
+#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_ROCM_GPU
 #else
-  #define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
+#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
 #endif
 
 //----------------------------------------------------------------------------
 
-#if ( defined( _POSIX_C_SOURCE ) && _POSIX_C_SOURCE >= 200112L ) || \
-    ( defined( _XOPEN_SOURCE )   && _XOPEN_SOURCE   >= 600 )
-  #if defined( KOKKOS_ENABLE_PERFORMANCE_POSIX_MEMALIGN )
-    #define KOKKOS_ENABLE_POSIX_MEMALIGN 1
-  #endif
+#if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
+    (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
+#if defined(KOKKOS_ENABLE_PERFORMANCE_POSIX_MEMALIGN)
+#define KOKKOS_ENABLE_POSIX_MEMALIGN 1
+#endif
 #endif
 
 //----------------------------------------------------------------------------
@@ -547,53 +561,65 @@
 // and use relocateable device code to enable the task policy.
 // nvcc relocatable device code option: --relocatable-device-code=true
 
-#if ( defined( KOKKOS_ENABLE_CUDA ) )
-  #if ( 8000 <= CUDA_VERSION ) && defined( KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE )
-  #define KOKKOS_ENABLE_TASKDAG
-  #endif
+#if (defined(KOKKOS_ENABLE_CUDA))
+#if (8000 <= CUDA_VERSION) && \
+    defined(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
+#define KOKKOS_ENABLE_TASKDAG
+#endif
 #else
-  #define KOKKOS_ENABLE_TASKDAG
+#define KOKKOS_ENABLE_TASKDAG
 #endif
 
-
-#if defined ( KOKKOS_ENABLE_CUDA )
-  #if ( 9000 <= CUDA_VERSION )
-  #define KOKKOS_IMPL_CUDA_VERSION_9_WORKAROUND
-  #if ( __CUDA_ARCH__ )
-    #define KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  #endif
-  #endif
+#if defined(KOKKOS_ENABLE_CUDA)
+#if (9000 <= CUDA_VERSION)
+#define KOKKOS_IMPL_CUDA_VERSION_9_WORKAROUND
+#if (__CUDA_ARCH__)
+#define KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
+#endif
+#endif
 #endif
 
 #define KOKKOS_INVALID_INDEX (~std::size_t(0))
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  #define KOKKOS_IMPL_CTOR_DEFAULT_ARG 0
+#define KOKKOS_IMPL_CTOR_DEFAULT_ARG 0
 #else
-  #define KOKKOS_IMPL_CTOR_DEFAULT_ARG KOKKOS_INVALID_INDEX
+#define KOKKOS_IMPL_CTOR_DEFAULT_ARG KOKKOS_INVALID_INDEX
 #endif
 
-#if (defined(KOKKOS_ENABLE_CXX14) || defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20))
-  #define KOKKOS_CONSTEXPR_14 constexpr
-  #define KOKKOS_DEPRECATED [[deprecated]]
-  #define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE
+#if (defined(KOKKOS_ENABLE_CXX14) || defined(KOKKOS_ENABLE_CXX17) || \
+     defined(KOKKOS_ENABLE_CXX20))
+#define KOKKOS_CONSTEXPR_14 constexpr
+#define KOKKOS_DEPRECATED [[deprecated]]
+#define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE
+#else
+#define KOKKOS_CONSTEXPR_14
+#if defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG)
+#define KOKKOS_DEPRECATED
+#define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE __attribute__((deprecated))
 #else
-  #define KOKKOS_CONSTEXPR_14
-  #if defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG)
-    #define KOKKOS_DEPRECATED
-    #define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE __attribute__ ((deprecated))
-  #else
-    #define KOKKOS_DEPRECATED
-    #define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE
-  #endif
+#define KOKKOS_DEPRECATED
+#define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE
+#endif
 #endif
-
 
 // DJS 05/28/2019: Bugfix: Issue 2155
-// Use KOKKOS_ENABLE_CUDA_LDG_INTRINSIC to avoid memory leak in RandomAccess View
+// Use KOKKOS_ENABLE_CUDA_LDG_INTRINSIC to avoid memory leak in RandomAccess
+// View
 #if defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC)
- #define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC
+#define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC
 #endif
 
-#endif // #ifndef KOKKOS_MACROS_HPP
+#if defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20)
+#define KOKKOS_ATTRIBUTE_NODISCARD [[nodiscard]]
+#else
+#define KOKKOS_ATTRIBUTE_NODISCARD
+#endif
+
+#if defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) || \
+    defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_PGI)
+#define KOKKOS_IMPL_ENABLE_STACKTRACE
+#define KOKKOS_IMPL_ENABLE_CXXABI
+#endif
 
+#endif  // #ifndef KOKKOS_MACROS_HPP
diff --git a/lib/kokkos/core/src/Kokkos_MasterLock.hpp b/lib/kokkos/core/src/Kokkos_MasterLock.hpp
index 2db22d2fdd6ce4131ca7c536b872130e8be7d0e3..3c45e131a0fba6e39f3f97ef2fd67451b9aef76c 100644
--- a/lib/kokkos/core/src/Kokkos_MasterLock.hpp
+++ b/lib/kokkos/core/src/Kokkos_MasterLock.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,7 +47,8 @@
 
 #include <Kokkos_Macros.hpp>
 
-namespace Kokkos { namespace Experimental {
+namespace Kokkos {
+namespace Experimental {
 
 // my be used to coordinate work between master instances
 // SHOULD NOT be used within a parallel algorithm
@@ -67,7 +69,7 @@ namespace Kokkos { namespace Experimental {
 template <typename ExecutionSpace>
 class MasterLock;
 
-}} // namespace Kokkos::Experimental
-
-#endif //KOKKOS_MASTER_LOCK_HPP
+}  // namespace Experimental
+}  // namespace Kokkos
 
+#endif  // KOKKOS_MASTER_LOCK_HPP
diff --git a/lib/kokkos/core/src/Kokkos_MemoryPool.hpp b/lib/kokkos/core/src/Kokkos_MemoryPool.hpp
index 365db2baecf139637173badc515ca30432200e22..5228f3661206d016e14dfa94fa4b6c2c2cec4b9b 100644
--- a/lib/kokkos/core/src/Kokkos_MemoryPool.hpp
+++ b/lib/kokkos/core/src/Kokkos_MemoryPool.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -55,37 +56,34 @@ namespace Kokkos {
 namespace Impl {
 /* Report violation of size constraints:
  *   min_block_alloc_size <= max_block_alloc_size
- *   max_block_alloc_size <= min_superblock_size 
+ *   max_block_alloc_size <= min_superblock_size
  *   min_superblock_size  <= max_superblock_size
  *   min_superblock_size  <= min_total_alloc_size
- *   min_superblock_size  <= min_block_alloc_size * 
+ *   min_superblock_size  <= min_block_alloc_size *
  *                           max_block_per_superblock
  */
-void memory_pool_bounds_verification
-  ( size_t min_block_alloc_size
-  , size_t max_block_alloc_size
-  , size_t min_superblock_size
-  , size_t max_superblock_size
-  , size_t max_block_per_superblock
-  , size_t min_total_alloc_size
-  );
-}
-}
+void memory_pool_bounds_verification(size_t min_block_alloc_size,
+                                     size_t max_block_alloc_size,
+                                     size_t min_superblock_size,
+                                     size_t max_superblock_size,
+                                     size_t max_block_per_superblock,
+                                     size_t min_total_alloc_size);
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template< typename DeviceType >
+template <typename DeviceType>
 class MemoryPool {
-private:
+ private:
+  typedef typename Kokkos::Impl::concurrent_bitset CB;
 
-  typedef typename Kokkos::Impl::concurrent_bitset CB ;
-
-  enum : uint32_t { bits_per_int_lg2  = CB::bits_per_int_lg2 };
-  enum : uint32_t { state_shift       = CB::state_shift };
-  enum : uint32_t { state_used_mask   = CB::state_used_mask };
+  enum : uint32_t { bits_per_int_lg2 = CB::bits_per_int_lg2 };
+  enum : uint32_t { state_shift = CB::state_shift };
+  enum : uint32_t { state_used_mask = CB::state_used_mask };
   enum : uint32_t { state_header_mask = CB::state_header_mask };
   enum : uint32_t { max_bit_count_lg2 = CB::max_bit_count_lg2 };
-  enum : uint32_t { max_bit_count     = CB::max_bit_count };
+  enum : uint32_t { max_bit_count = CB::max_bit_count };
 
   enum : uint32_t { HINT_PER_BLOCK_SIZE = 2 };
 
@@ -109,231 +107,219 @@ private:
    *  Thus A_block_size < B_block_size  <=>  A_block_state > B_block_state
    */
 
-  typedef typename DeviceType::memory_space base_memory_space ;
-
-  enum { accessible =
-           Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace 
-                                          , base_memory_space >::accessible };
-
-  typedef Kokkos::Impl::SharedAllocationTracker Tracker ;
-  typedef Kokkos::Impl::SharedAllocationRecord
-    < base_memory_space >  Record ;
+  typedef typename DeviceType::memory_space base_memory_space;
 
-  Tracker    m_tracker ;
-  uint32_t * m_sb_state_array ;
-  uint32_t   m_sb_state_size ;
-  uint32_t   m_sb_size_lg2 ;
-  uint32_t   m_max_block_size_lg2 ;
-  uint32_t   m_min_block_size_lg2 ;
-  int32_t    m_sb_count ;
-  int32_t    m_hint_offset ;   // Offset to K * #block_size array of hints
-  int32_t    m_data_offset ;   // Offset to 0th superblock data
-  int32_t    m_unused_padding ;
-
-public:
+  enum {
+    accessible = Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                                 base_memory_space>::accessible
+  };
 
+  typedef Kokkos::Impl::SharedAllocationTracker Tracker;
+  typedef Kokkos::Impl::SharedAllocationRecord<base_memory_space> Record;
+
+  Tracker m_tracker;
+  uint32_t *m_sb_state_array;
+  uint32_t m_sb_state_size;
+  uint32_t m_sb_size_lg2;
+  uint32_t m_max_block_size_lg2;
+  uint32_t m_min_block_size_lg2;
+  int32_t m_sb_count;
+  int32_t m_hint_offset;  // Offset to K * #block_size array of hints
+  int32_t m_data_offset;  // Offset to 0th superblock data
+  int32_t m_unused_padding;
+
+ public:
   using memory_space = typename DeviceType::memory_space;
 
   /**\brief  The maximum size of a superblock and block */
-  enum : uint32_t { max_superblock_size      = 1LU << 31 /* 2 gigabytes */ };
+  enum : uint32_t { max_superblock_size = 1LU << 31 /* 2 gigabytes */ };
   enum : uint32_t { max_block_per_superblock = max_bit_count };
 
   //--------------------------------------------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  bool operator==(MemoryPool const& other) const
-    { return m_sb_state_array == other.m_sb_state_array; }
+  bool operator==(MemoryPool const &other) const {
+    return m_sb_state_array == other.m_sb_state_array;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  size_t capacity() const noexcept
-    { return size_t(m_sb_count) << m_sb_size_lg2 ; }
+  size_t capacity() const noexcept {
+    return size_t(m_sb_count) << m_sb_size_lg2;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  size_t min_block_size() const noexcept
-    { return ( 1LU << m_min_block_size_lg2 ); }
+  size_t min_block_size() const noexcept {
+    return (1LU << m_min_block_size_lg2);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  size_t max_block_size() const noexcept
-    { return ( 1LU << m_max_block_size_lg2 ); }
+  size_t max_block_size() const noexcept {
+    return (1LU << m_max_block_size_lg2);
+  }
 
   struct usage_statistics {
-    size_t capacity_bytes ;       ///<  Capacity in bytes
-    size_t superblock_bytes ;     ///<  Superblock size in bytes
-    size_t max_block_bytes ;      ///<  Maximum block size in bytes
-    size_t min_block_bytes ;      ///<  Minimum block size in bytes
-    size_t capacity_superblocks ; ///<  Number of superblocks
-    size_t consumed_superblocks ; ///<  Superblocks assigned to allocations
-    size_t consumed_blocks ;  ///<  Number of allocations
-    size_t consumed_bytes ;   ///<  Bytes allocated
-    size_t reserved_blocks ;  ///<  Unallocated blocks in assigned superblocks
-    size_t reserved_bytes ;   ///<  Unallocated bytes in assigned superblocks
+    size_t capacity_bytes;        ///<  Capacity in bytes
+    size_t superblock_bytes;      ///<  Superblock size in bytes
+    size_t max_block_bytes;       ///<  Maximum block size in bytes
+    size_t min_block_bytes;       ///<  Minimum block size in bytes
+    size_t capacity_superblocks;  ///<  Number of superblocks
+    size_t consumed_superblocks;  ///<  Superblocks assigned to allocations
+    size_t consumed_blocks;       ///<  Number of allocations
+    size_t consumed_bytes;        ///<  Bytes allocated
+    size_t reserved_blocks;  ///<  Unallocated blocks in assigned superblocks
+    size_t reserved_bytes;   ///<  Unallocated bytes in assigned superblocks
   };
 
-  void get_usage_statistics( usage_statistics & stats ) const
-    {
-      Kokkos::HostSpace host ;
+  void get_usage_statistics(usage_statistics &stats) const {
+    Kokkos::HostSpace host;
 
-      const size_t alloc_size = m_hint_offset * sizeof(uint32_t);
+    const size_t alloc_size = m_hint_offset * sizeof(uint32_t);
 
-      uint32_t * const sb_state_array = 
-        accessible ? m_sb_state_array : (uint32_t *) host.allocate(alloc_size);
+    uint32_t *const sb_state_array =
+        accessible ? m_sb_state_array : (uint32_t *)host.allocate(alloc_size);
 
-      if ( ! accessible ) {
-        Kokkos::Impl::DeepCopy< Kokkos::HostSpace , base_memory_space >
-          ( sb_state_array , m_sb_state_array , alloc_size );
-      }
-
-      stats.superblock_bytes = ( 1LU << m_sb_size_lg2 );
-      stats.max_block_bytes  = ( 1LU << m_max_block_size_lg2 );
-      stats.min_block_bytes  = ( 1LU << m_min_block_size_lg2 );
-      stats.capacity_bytes   = stats.superblock_bytes * m_sb_count ;
-      stats.capacity_superblocks = m_sb_count ;
-      stats.consumed_superblocks = 0 ;
-      stats.consumed_blocks = 0 ;
-      stats.consumed_bytes  = 0 ;
-      stats.reserved_blocks = 0 ;
-      stats.reserved_bytes  = 0 ;
-
-      const uint32_t * sb_state_ptr = sb_state_array ;
-
-      for ( int32_t i = 0 ; i < m_sb_count
-          ; ++i , sb_state_ptr += m_sb_state_size ) {
-
-        const uint32_t block_count_lg2 = (*sb_state_ptr) >> state_shift ;
-
-        if ( block_count_lg2 ) {
-          const uint32_t block_count    = 1u << block_count_lg2 ;
-          const uint32_t block_size_lg2 = m_sb_size_lg2 - block_count_lg2 ;
-          const uint32_t block_size     = 1u << block_size_lg2 ;
-          const uint32_t block_used     = (*sb_state_ptr) & state_used_mask ;
-
-          stats.consumed_superblocks++ ;
-          stats.consumed_blocks += block_used ;
-          stats.consumed_bytes  += block_used * block_size ;
-          stats.reserved_blocks += block_count - block_used ;
-          stats.reserved_bytes  += (block_count - block_used ) * block_size ;
-        }
-      }
+    if (!accessible) {
+      Kokkos::Impl::DeepCopy<Kokkos::HostSpace, base_memory_space>(
+          sb_state_array, m_sb_state_array, alloc_size);
+    }
 
-      if ( ! accessible ) {
-        host.deallocate( sb_state_array, alloc_size );
+    stats.superblock_bytes     = (1LU << m_sb_size_lg2);
+    stats.max_block_bytes      = (1LU << m_max_block_size_lg2);
+    stats.min_block_bytes      = (1LU << m_min_block_size_lg2);
+    stats.capacity_bytes       = stats.superblock_bytes * m_sb_count;
+    stats.capacity_superblocks = m_sb_count;
+    stats.consumed_superblocks = 0;
+    stats.consumed_blocks      = 0;
+    stats.consumed_bytes       = 0;
+    stats.reserved_blocks      = 0;
+    stats.reserved_bytes       = 0;
+
+    const uint32_t *sb_state_ptr = sb_state_array;
+
+    for (int32_t i = 0; i < m_sb_count; ++i, sb_state_ptr += m_sb_state_size) {
+      const uint32_t block_count_lg2 = (*sb_state_ptr) >> state_shift;
+
+      if (block_count_lg2) {
+        const uint32_t block_count    = 1u << block_count_lg2;
+        const uint32_t block_size_lg2 = m_sb_size_lg2 - block_count_lg2;
+        const uint32_t block_size     = 1u << block_size_lg2;
+        const uint32_t block_used     = (*sb_state_ptr) & state_used_mask;
+
+        stats.consumed_superblocks++;
+        stats.consumed_blocks += block_used;
+        stats.consumed_bytes += block_used * block_size;
+        stats.reserved_blocks += block_count - block_used;
+        stats.reserved_bytes += (block_count - block_used) * block_size;
       }
     }
 
-  void print_state( std::ostream & s ) const
-    {
-      Kokkos::HostSpace host ;
-
-      const size_t alloc_size = m_hint_offset * sizeof(uint32_t);
+    if (!accessible) {
+      host.deallocate(sb_state_array, alloc_size);
+    }
+  }
 
-      uint32_t * const sb_state_array = 
-        accessible ? m_sb_state_array : (uint32_t *) host.allocate(alloc_size);
+  void print_state(std::ostream &s) const {
+    Kokkos::HostSpace host;
 
-      if ( ! accessible ) {
-        Kokkos::Impl::DeepCopy< Kokkos::HostSpace , base_memory_space >
-          ( sb_state_array , m_sb_state_array , alloc_size );
-      }
+    const size_t alloc_size = m_hint_offset * sizeof(uint32_t);
 
-      const uint32_t * sb_state_ptr = sb_state_array ;
+    uint32_t *const sb_state_array =
+        accessible ? m_sb_state_array : (uint32_t *)host.allocate(alloc_size);
 
-      s << "pool_size(" << ( size_t(m_sb_count) << m_sb_size_lg2 ) << ")"
-        << " superblock_size(" << ( 1LU << m_sb_size_lg2 ) << ")" << std::endl ;
+    if (!accessible) {
+      Kokkos::Impl::DeepCopy<Kokkos::HostSpace, base_memory_space>(
+          sb_state_array, m_sb_state_array, alloc_size);
+    }
 
-      for ( int32_t i = 0 ; i < m_sb_count
-          ; ++i , sb_state_ptr += m_sb_state_size ) {
+    const uint32_t *sb_state_ptr = sb_state_array;
 
-        if ( *sb_state_ptr ) {
+    s << "pool_size(" << (size_t(m_sb_count) << m_sb_size_lg2) << ")"
+      << " superblock_size(" << (1LU << m_sb_size_lg2) << ")" << std::endl;
 
-          const uint32_t block_count_lg2 = (*sb_state_ptr) >> state_shift ;
-          const uint32_t block_size_lg2  = m_sb_size_lg2 - block_count_lg2 ;
-          const uint32_t block_count     = 1u << block_count_lg2 ;
-          const uint32_t block_used      = (*sb_state_ptr) & state_used_mask ;
+    for (int32_t i = 0; i < m_sb_count; ++i, sb_state_ptr += m_sb_state_size) {
+      if (*sb_state_ptr) {
+        const uint32_t block_count_lg2 = (*sb_state_ptr) >> state_shift;
+        const uint32_t block_size_lg2  = m_sb_size_lg2 - block_count_lg2;
+        const uint32_t block_count     = 1u << block_count_lg2;
+        const uint32_t block_used      = (*sb_state_ptr) & state_used_mask;
 
-          s << "Superblock[ " << i << " / " << m_sb_count << " ] {"
-            << " block_size(" << ( 1 << block_size_lg2 ) << ")"
-            << " block_count( " << block_used
-            << " / " << block_count  << " )"
-            << std::endl ;
-        }
+        s << "Superblock[ " << i << " / " << m_sb_count << " ] {"
+          << " block_size(" << (1 << block_size_lg2) << ")"
+          << " block_count( " << block_used << " / " << block_count << " )"
+          << std::endl;
       }
+    }
 
-      if ( ! accessible ) {
-        host.deallocate( sb_state_array, alloc_size );
-      }
+    if (!accessible) {
+      host.deallocate(sb_state_array, alloc_size);
     }
+  }
 
   //--------------------------------------------------------------------------
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
-  KOKKOS_INLINE_FUNCTION MemoryPool( MemoryPool && rhs )
-    : m_tracker(std::move(rhs.m_tracker))
-    , m_sb_state_array(std::move(rhs.m_sb_state_array))
-    , m_sb_state_size(std::move(rhs.m_sb_state_size))
-    , m_sb_size_lg2(std::move(rhs.m_sb_size_lg2))
-    , m_max_block_size_lg2(std::move(rhs.m_max_block_size_lg2))
-    , m_min_block_size_lg2(std::move(rhs.m_min_block_size_lg2))
-    , m_sb_count(std::move(rhs.m_sb_count))
-    , m_hint_offset(std::move(rhs.m_hint_offset))
-    , m_data_offset(std::move(rhs.m_data_offset))
-  {
-  }
-  KOKKOS_INLINE_FUNCTION MemoryPool( const MemoryPool & rhs )
-    : m_tracker(rhs.m_tracker)
-    , m_sb_state_array(rhs.m_sb_state_array)
-    , m_sb_state_size(rhs.m_sb_state_size)
-    , m_sb_size_lg2(rhs.m_sb_size_lg2)
-    , m_max_block_size_lg2(rhs.m_max_block_size_lg2)
-    , m_min_block_size_lg2(rhs.m_min_block_size_lg2)
-    , m_sb_count(rhs.m_sb_count)
-    , m_hint_offset(rhs.m_hint_offset)
-    , m_data_offset(rhs.m_data_offset)
-  {
-  }
-  KOKKOS_INLINE_FUNCTION MemoryPool & operator = ( MemoryPool && rhs )
-  {
-    m_tracker = std::move(rhs.m_tracker);
-    m_sb_state_array = std::move(rhs.m_sb_state_array);
-    m_sb_state_size = std::move(rhs.m_sb_state_size);
-    m_sb_size_lg2 = std::move(rhs.m_sb_size_lg2);
+  KOKKOS_INLINE_FUNCTION MemoryPool(MemoryPool &&rhs)
+      : m_tracker(std::move(rhs.m_tracker)),
+        m_sb_state_array(std::move(rhs.m_sb_state_array)),
+        m_sb_state_size(std::move(rhs.m_sb_state_size)),
+        m_sb_size_lg2(std::move(rhs.m_sb_size_lg2)),
+        m_max_block_size_lg2(std::move(rhs.m_max_block_size_lg2)),
+        m_min_block_size_lg2(std::move(rhs.m_min_block_size_lg2)),
+        m_sb_count(std::move(rhs.m_sb_count)),
+        m_hint_offset(std::move(rhs.m_hint_offset)),
+        m_data_offset(std::move(rhs.m_data_offset)) {}
+  KOKKOS_INLINE_FUNCTION MemoryPool(const MemoryPool &rhs)
+      : m_tracker(rhs.m_tracker),
+        m_sb_state_array(rhs.m_sb_state_array),
+        m_sb_state_size(rhs.m_sb_state_size),
+        m_sb_size_lg2(rhs.m_sb_size_lg2),
+        m_max_block_size_lg2(rhs.m_max_block_size_lg2),
+        m_min_block_size_lg2(rhs.m_min_block_size_lg2),
+        m_sb_count(rhs.m_sb_count),
+        m_hint_offset(rhs.m_hint_offset),
+        m_data_offset(rhs.m_data_offset) {}
+  KOKKOS_INLINE_FUNCTION MemoryPool &operator=(MemoryPool &&rhs) {
+    m_tracker            = std::move(rhs.m_tracker);
+    m_sb_state_array     = std::move(rhs.m_sb_state_array);
+    m_sb_state_size      = std::move(rhs.m_sb_state_size);
+    m_sb_size_lg2        = std::move(rhs.m_sb_size_lg2);
     m_max_block_size_lg2 = std::move(rhs.m_max_block_size_lg2);
     m_min_block_size_lg2 = std::move(rhs.m_min_block_size_lg2);
-    m_sb_count = std::move(rhs.m_sb_count);
-    m_hint_offset = std::move(rhs.m_hint_offset);
-    m_data_offset = std::move(rhs.m_data_offset);
+    m_sb_count           = std::move(rhs.m_sb_count);
+    m_hint_offset        = std::move(rhs.m_hint_offset);
+    m_data_offset        = std::move(rhs.m_data_offset);
     return *this;
   }
-  KOKKOS_INLINE_FUNCTION MemoryPool & operator = ( const MemoryPool & rhs )
-  {
-    m_tracker = rhs.m_tracker;
-    m_sb_state_array = rhs.m_sb_state_array;
-    m_sb_state_size = rhs.m_sb_state_size;
-    m_sb_size_lg2 = rhs.m_sb_size_lg2;
+  KOKKOS_INLINE_FUNCTION MemoryPool &operator=(const MemoryPool &rhs) {
+    m_tracker            = rhs.m_tracker;
+    m_sb_state_array     = rhs.m_sb_state_array;
+    m_sb_state_size      = rhs.m_sb_state_size;
+    m_sb_size_lg2        = rhs.m_sb_size_lg2;
     m_max_block_size_lg2 = rhs.m_max_block_size_lg2;
     m_min_block_size_lg2 = rhs.m_min_block_size_lg2;
-    m_sb_count = rhs.m_sb_count;
-    m_hint_offset = rhs.m_hint_offset;
-    m_data_offset = rhs.m_data_offset;
+    m_sb_count           = rhs.m_sb_count;
+    m_hint_offset        = rhs.m_hint_offset;
+    m_data_offset        = rhs.m_data_offset;
     return *this;
   }
 #else
-  KOKKOS_INLINE_FUNCTION MemoryPool( MemoryPool && ) = default ;
-  KOKKOS_INLINE_FUNCTION MemoryPool( const MemoryPool & ) = default ;
-  KOKKOS_INLINE_FUNCTION MemoryPool & operator = ( MemoryPool && ) = default ;
-  KOKKOS_INLINE_FUNCTION MemoryPool & operator = ( const MemoryPool & ) = default ;
+  KOKKOS_INLINE_FUNCTION MemoryPool(MemoryPool &&)      = default;
+  KOKKOS_INLINE_FUNCTION MemoryPool(const MemoryPool &) = default;
+  KOKKOS_INLINE_FUNCTION MemoryPool &operator=(MemoryPool &&) = default;
+  KOKKOS_INLINE_FUNCTION MemoryPool &operator=(const MemoryPool &) = default;
 #endif
 
   KOKKOS_INLINE_FUNCTION MemoryPool()
-    : m_tracker()
-    , m_sb_state_array(0)
-    , m_sb_state_size(0)
-    , m_sb_size_lg2(0)
-    , m_max_block_size_lg2(0)
-    , m_min_block_size_lg2(0)
-    , m_sb_count(0)
-    , m_hint_offset(0)
-    , m_data_offset(0)
-    , m_unused_padding(0)
-    {}
+      : m_tracker(),
+        m_sb_state_array(0),
+        m_sb_state_size(0),
+        m_sb_size_lg2(0),
+        m_max_block_size_lg2(0),
+        m_min_block_size_lg2(0),
+        m_sb_count(0),
+        m_hint_offset(0),
+        m_data_offset(0),
+        m_unused_padding(0) {}
 
   /**\brief  Allocate a memory pool from 'memspace'.
    *
@@ -349,221 +335,199 @@ public:
    *  is also a power-of-two.  These roundings are made to enable
    *  significant runtime performance improvements.
    */
-  MemoryPool( const base_memory_space & memspace
-            , const size_t min_total_alloc_size
-            , size_t min_block_alloc_size = 0
-            , size_t max_block_alloc_size = 0
-            , size_t min_superblock_size  = 0
-            )
-    : m_tracker()
-    , m_sb_state_array(0)
-    , m_sb_state_size(0)
-    , m_sb_size_lg2(0)
-    , m_max_block_size_lg2(0)
-    , m_min_block_size_lg2(0)
-    , m_sb_count(0)
-    , m_hint_offset(0)
-    , m_data_offset(0)
-    , m_unused_padding(0)
-    {
-      const uint32_t int_align_lg2   = 3 ; /* align as int[8] */
-      const uint32_t int_align_mask  = ( 1u << int_align_lg2 ) - 1 ;
-      const uint32_t default_min_block_size       = 1u << 6  ; /* 64 bytes */
-      const uint32_t default_max_block_size       = 1u << 12 ;/* 4k bytes */
-      const uint32_t default_min_superblock_size  = 1u << 20 ;/* 1M bytes */
-
-      //--------------------------------------------------
-      // Default block and superblock sizes:
-
-      if ( 0 == min_block_alloc_size ) {
-        // Default all sizes:
-
-        min_superblock_size =
-          std::min( size_t(default_min_superblock_size)
-                  , min_total_alloc_size );
-
-        min_block_alloc_size =
-          std::min( size_t(default_min_block_size)
-                  , min_superblock_size );
-
-        max_block_alloc_size =
-          std::min( size_t(default_max_block_size)
-                  , min_superblock_size );
-      }
-      else if ( 0 == min_superblock_size ) {
-
-        // Choose superblock size as minimum of:
-        //   max_block_per_superblock * min_block_size
-        //   max_superblock_size
-        //   min_total_alloc_size
+  MemoryPool(const base_memory_space &memspace,
+             const size_t min_total_alloc_size, size_t min_block_alloc_size = 0,
+             size_t max_block_alloc_size = 0, size_t min_superblock_size = 0)
+      : m_tracker(),
+        m_sb_state_array(0),
+        m_sb_state_size(0),
+        m_sb_size_lg2(0),
+        m_max_block_size_lg2(0),
+        m_min_block_size_lg2(0),
+        m_sb_count(0),
+        m_hint_offset(0),
+        m_data_offset(0),
+        m_unused_padding(0) {
+    const uint32_t int_align_lg2               = 3; /* align as int[8] */
+    const uint32_t int_align_mask              = (1u << int_align_lg2) - 1;
+    const uint32_t default_min_block_size      = 1u << 6;  /* 64 bytes */
+    const uint32_t default_max_block_size      = 1u << 12; /* 4k bytes */
+    const uint32_t default_min_superblock_size = 1u << 20; /* 1M bytes */
+
+    //--------------------------------------------------
+    // Default block and superblock sizes:
+
+    if (0 == min_block_alloc_size) {
+      // Default all sizes:
+
+      min_superblock_size =
+          std::min(size_t(default_min_superblock_size), min_total_alloc_size);
+
+      min_block_alloc_size =
+          std::min(size_t(default_min_block_size), min_superblock_size);
+
+      max_block_alloc_size =
+          std::min(size_t(default_max_block_size), min_superblock_size);
+    } else if (0 == min_superblock_size) {
+      // Choose superblock size as minimum of:
+      //   max_block_per_superblock * min_block_size
+      //   max_superblock_size
+      //   min_total_alloc_size
+
+      const size_t max_superblock =
+          min_block_alloc_size * max_block_per_superblock;
+
+      min_superblock_size =
+          std::min(max_superblock,
+                   std::min(size_t(max_superblock_size), min_total_alloc_size));
+    }
 
-        const size_t max_superblock =
-          min_block_alloc_size * max_block_per_superblock ;
+    if (0 == max_block_alloc_size) {
+      max_block_alloc_size = min_superblock_size;
+    }
 
-        min_superblock_size =
-          std::min( max_superblock ,
-          std::min( size_t(max_superblock_size)
-                  , min_total_alloc_size ) );
-      }
+    //--------------------------------------------------
 
-      if ( 0 == max_block_alloc_size ) {
-        max_block_alloc_size = min_superblock_size ;
-      }
+    /* Enforce size constraints:
+     *   min_block_alloc_size <= max_block_alloc_size
+     *   max_block_alloc_size <= min_superblock_size
+     *   min_superblock_size  <= max_superblock_size
+     *   min_superblock_size  <= min_total_alloc_size
+     *   min_superblock_size  <= min_block_alloc_size *
+     *                           max_block_per_superblock
+     */
 
-      //--------------------------------------------------
-
-      /* Enforce size constraints:
-       *   min_block_alloc_size <= max_block_alloc_size
-       *   max_block_alloc_size <= min_superblock_size 
-       *   min_superblock_size  <= max_superblock_size
-       *   min_superblock_size  <= min_total_alloc_size
-       *   min_superblock_size  <= min_block_alloc_size * 
-       *                           max_block_per_superblock
-       */
-
-      Kokkos::Impl::memory_pool_bounds_verification
-        ( min_block_alloc_size
-        , max_block_alloc_size
-        , min_superblock_size
-        , max_superblock_size
-        , max_block_per_superblock
-        , min_total_alloc_size
-        );
+    Kokkos::Impl::memory_pool_bounds_verification(
+        min_block_alloc_size, max_block_alloc_size, min_superblock_size,
+        max_superblock_size, max_block_per_superblock, min_total_alloc_size);
 
-      //--------------------------------------------------
-      // Block and superblock size is power of two:
-      // Maximum value is 'max_superblock_size'
+    //--------------------------------------------------
+    // Block and superblock size is power of two:
+    // Maximum value is 'max_superblock_size'
 
-      m_min_block_size_lg2 =
+    m_min_block_size_lg2 =
         Kokkos::Impl::integral_power_of_two_that_contains(min_block_alloc_size);
 
-      m_max_block_size_lg2 =
+    m_max_block_size_lg2 =
         Kokkos::Impl::integral_power_of_two_that_contains(max_block_alloc_size);
-  
-      m_sb_size_lg2 =
+
+    m_sb_size_lg2 =
         Kokkos::Impl::integral_power_of_two_that_contains(min_superblock_size);
 
-      {
-        // number of superblocks is multiple of superblock size that
-        // can hold min_total_alloc_size.
+    {
+      // number of superblocks is multiple of superblock size that
+      // can hold min_total_alloc_size.
 
-        const uint64_t sb_size_mask = ( 1LU << m_sb_size_lg2 ) - 1 ;
+      const uint64_t sb_size_mask = (1LU << m_sb_size_lg2) - 1;
 
-        m_sb_count = ( min_total_alloc_size + sb_size_mask ) >> m_sb_size_lg2 ;
-      }
+      m_sb_count = (min_total_alloc_size + sb_size_mask) >> m_sb_size_lg2;
+    }
 
-      {
-        // Any superblock can be assigned to the smallest size block
-        // Size the block bitset to maximum number of blocks
+    {
+      // Any superblock can be assigned to the smallest size block
+      // Size the block bitset to maximum number of blocks
 
-        const uint32_t max_block_count_lg2 =
-          m_sb_size_lg2 - m_min_block_size_lg2 ;
+      const uint32_t max_block_count_lg2 = m_sb_size_lg2 - m_min_block_size_lg2;
 
-        m_sb_state_size =
-          ( CB::buffer_bound_lg2( max_block_count_lg2 ) + int_align_mask ) & ~int_align_mask ;
-      }
+      m_sb_state_size =
+          (CB::buffer_bound_lg2(max_block_count_lg2) + int_align_mask) &
+          ~int_align_mask;
+    }
 
-      // Array of all superblock states
+    // Array of all superblock states
 
-      const size_t all_sb_state_size =
-        ( m_sb_count * m_sb_state_size + int_align_mask ) & ~int_align_mask ;
+    const size_t all_sb_state_size =
+        (m_sb_count * m_sb_state_size + int_align_mask) & ~int_align_mask;
 
-      // Number of block sizes
+    // Number of block sizes
 
-      const int32_t number_block_sizes =
-         1 + m_max_block_size_lg2 - m_min_block_size_lg2 ;
+    const int32_t number_block_sizes =
+        1 + m_max_block_size_lg2 - m_min_block_size_lg2;
 
-      // Array length for possible block sizes
-      // Hint array is one uint32_t per block size
+    // Array length for possible block sizes
+    // Hint array is one uint32_t per block size
 
-      const int32_t block_size_array_size =
-        ( number_block_sizes + int_align_mask ) & ~int_align_mask ;
+    const int32_t block_size_array_size =
+        (number_block_sizes + int_align_mask) & ~int_align_mask;
 
-      m_hint_offset = all_sb_state_size ;
-      m_data_offset = m_hint_offset +
-                      block_size_array_size * HINT_PER_BLOCK_SIZE ;
+    m_hint_offset = all_sb_state_size;
+    m_data_offset = m_hint_offset + block_size_array_size * HINT_PER_BLOCK_SIZE;
 
-      // Allocation:
+    // Allocation:
 
-      const size_t header_size = m_data_offset * sizeof(uint32_t);
-      const size_t alloc_size  = header_size +
-                                 ( size_t(m_sb_count) << m_sb_size_lg2 );
+    const size_t header_size = m_data_offset * sizeof(uint32_t);
+    const size_t alloc_size =
+        header_size + (size_t(m_sb_count) << m_sb_size_lg2);
 
-      Record * rec = Record::allocate( memspace , "MemoryPool" , alloc_size );
+    Record *rec = Record::allocate(memspace, "MemoryPool", alloc_size);
 
-      m_tracker.assign_allocated_record_to_uninitialized( rec );
+    m_tracker.assign_allocated_record_to_uninitialized(rec);
 
-      m_sb_state_array = (uint32_t *) rec->data();
+    m_sb_state_array = (uint32_t *)rec->data();
 
-      Kokkos::HostSpace host ;
+    Kokkos::HostSpace host;
 
-      uint32_t * const sb_state_array = 
-        accessible ? m_sb_state_array
-                   : (uint32_t *) host.allocate(header_size);
+    uint32_t *const sb_state_array =
+        accessible ? m_sb_state_array : (uint32_t *)host.allocate(header_size);
 
-      for ( int32_t i = 0 ; i < m_data_offset ; ++i ) sb_state_array[i] = 0 ;
+    for (int32_t i = 0; i < m_data_offset; ++i) sb_state_array[i] = 0;
 
-      // Initial assignment of empty superblocks to block sizes:
+    // Initial assignment of empty superblocks to block sizes:
 
-      for ( int32_t i = 0 ; i < number_block_sizes ; ++i ) {
-        const uint32_t block_size_lg2  = i + m_min_block_size_lg2 ;
-        const uint32_t block_count_lg2 = m_sb_size_lg2 - block_size_lg2 ;
-        const uint32_t block_state     = block_count_lg2 << state_shift ;
-        const uint32_t hint_begin = m_hint_offset + i * HINT_PER_BLOCK_SIZE ;
+    for (int32_t i = 0; i < number_block_sizes; ++i) {
+      const uint32_t block_size_lg2  = i + m_min_block_size_lg2;
+      const uint32_t block_count_lg2 = m_sb_size_lg2 - block_size_lg2;
+      const uint32_t block_state     = block_count_lg2 << state_shift;
+      const uint32_t hint_begin      = m_hint_offset + i * HINT_PER_BLOCK_SIZE;
 
-        // for block size index 'i':
-        //   sb_id_hint  = sb_state_array[ hint_begin ];
-        //   sb_id_begin = sb_state_array[ hint_begin + 1 ];
+      // for block size index 'i':
+      //   sb_id_hint  = sb_state_array[ hint_begin ];
+      //   sb_id_begin = sb_state_array[ hint_begin + 1 ];
 
-        const int32_t jbeg = ( i * m_sb_count ) / number_block_sizes ;
-        const int32_t jend = ( ( i + 1 ) * m_sb_count ) / number_block_sizes ;
+      const int32_t jbeg = (i * m_sb_count) / number_block_sizes;
+      const int32_t jend = ((i + 1) * m_sb_count) / number_block_sizes;
 
-        sb_state_array[ hint_begin ] = uint32_t(jbeg);
-        sb_state_array[ hint_begin + 1 ] = uint32_t(jbeg);
+      sb_state_array[hint_begin]     = uint32_t(jbeg);
+      sb_state_array[hint_begin + 1] = uint32_t(jbeg);
 
-        for ( int32_t j = jbeg ; j < jend ; ++j ) {
-          sb_state_array[ j * m_sb_state_size ] = block_state ;
-        }
+      for (int32_t j = jbeg; j < jend; ++j) {
+        sb_state_array[j * m_sb_state_size] = block_state;
       }
+    }
 
-      // Write out initialized state:
+    // Write out initialized state:
 
-      if ( ! accessible ) {
-        Kokkos::Impl::DeepCopy< base_memory_space , Kokkos::HostSpace >
-          ( m_sb_state_array , sb_state_array , header_size );
+    if (!accessible) {
+      Kokkos::Impl::DeepCopy<base_memory_space, Kokkos::HostSpace>(
+          m_sb_state_array, sb_state_array, header_size);
 
-        host.deallocate( sb_state_array, header_size );
-      }
-      else {
-        Kokkos::memory_fence();
-      }
+      host.deallocate(sb_state_array, header_size);
+    } else {
+      Kokkos::memory_fence();
     }
+  }
 
   //--------------------------------------------------------------------------
 
-private:
-
+ private:
   /* Given a size 'n' get the block size in which it can be allocated.
    * Restrict lower bound to minimum block size.
    */
   KOKKOS_FORCEINLINE_FUNCTION
-  uint32_t get_block_size_lg2( uint32_t n ) const noexcept
-    {
-      const unsigned i = Kokkos::Impl::integral_power_of_two_that_contains( n );
-
-      return i < m_min_block_size_lg2 ? m_min_block_size_lg2 : i ;
-    }
+  uint32_t get_block_size_lg2(uint32_t n) const noexcept {
+    const unsigned i = Kokkos::Impl::integral_power_of_two_that_contains(n);
 
-public:
+    return i < m_min_block_size_lg2 ? m_min_block_size_lg2 : i;
+  }
 
+ public:
   /* Return 0 for invalid block size */
   KOKKOS_INLINE_FUNCTION
-  uint32_t allocate_block_size( uint64_t alloc_size ) const noexcept
-    {
-      return alloc_size <= (1UL << m_max_block_size_lg2)
-           ? ( 1UL << get_block_size_lg2( uint32_t(alloc_size) ) )
-           : 0 ;
-    }
+  uint32_t allocate_block_size(uint64_t alloc_size) const noexcept {
+    return alloc_size <= (1UL << m_max_block_size_lg2)
+               ? (1UL << get_block_size_lg2(uint32_t(alloc_size)))
+               : 0;
+  }
 
   //--------------------------------------------------------------------------
   /**\brief  Allocate a block of memory that is at least 'alloc_size'
@@ -576,105 +540,98 @@ public:
    *  The allocation attempt will try up to 'attempt_limit' times.
    */
   KOKKOS_FUNCTION
-  void * allocate( size_t alloc_size
-                 , int32_t attempt_limit = 1 ) const noexcept
-    {
-      if ( size_t(1LU << m_max_block_size_lg2) < alloc_size ) {
-        Kokkos::abort("Kokkos MemoryPool allocation request exceeded specified maximum allocation size");
-      }
+  void *allocate(size_t alloc_size, int32_t attempt_limit = 1) const noexcept {
+    if (size_t(1LU << m_max_block_size_lg2) < alloc_size) {
+      Kokkos::abort(
+          "Kokkos MemoryPool allocation request exceeded specified maximum "
+          "allocation size");
+    }
 
-      if ( 0 == alloc_size ) return (void*) 0 ;
+    if (0 == alloc_size) return (void *)0;
 
-      void * p = 0 ;
+    void *p = 0;
 
-      const uint32_t block_size_lg2 = get_block_size_lg2( alloc_size );
+    const uint32_t block_size_lg2 = get_block_size_lg2(alloc_size);
 
-      // Allocation will fit within a superblock
-      // that has block sizes ( 1 << block_size_lg2 )
+    // Allocation will fit within a superblock
+    // that has block sizes ( 1 << block_size_lg2 )
 
-      const uint32_t block_count_lg2 = m_sb_size_lg2 - block_size_lg2 ;
-      const uint32_t block_state     = block_count_lg2 << state_shift ;
-      const uint32_t block_count     = 1u << block_count_lg2 ;
+    const uint32_t block_count_lg2 = m_sb_size_lg2 - block_size_lg2;
+    const uint32_t block_state     = block_count_lg2 << state_shift;
+    const uint32_t block_count     = 1u << block_count_lg2;
 
-      // Superblock hints for this block size:
-      //   hint_sb_id_ptr[0] is the dynamically changing hint
-      //   hint_sb_id_ptr[1] is the static start point
+    // Superblock hints for this block size:
+    //   hint_sb_id_ptr[0] is the dynamically changing hint
+    //   hint_sb_id_ptr[1] is the static start point
 
-      volatile uint32_t * const hint_sb_id_ptr
-        = m_sb_state_array     /* memory pool state array */
-        + m_hint_offset        /* offset to hint portion of array */
-        + HINT_PER_BLOCK_SIZE  /* number of hints per block size */
-          * ( block_size_lg2 - m_min_block_size_lg2 ); /* block size id */
+    volatile uint32_t *const hint_sb_id_ptr =
+        m_sb_state_array      /* memory pool state array */
+        + m_hint_offset       /* offset to hint portion of array */
+        + HINT_PER_BLOCK_SIZE /* number of hints per block size */
+              * (block_size_lg2 - m_min_block_size_lg2); /* block size id */
 
-      const int32_t sb_id_begin = int32_t( hint_sb_id_ptr[1] );
+    const int32_t sb_id_begin = int32_t(hint_sb_id_ptr[1]);
 
-      // Fast query clock register 'tic' to pseudo-randomize
-      // the guess for which block within a superblock should
-      // be claimed.  If not available then a search occurs.
+    // Fast query clock register 'tic' to pseudo-randomize
+    // the guess for which block within a superblock should
+    // be claimed.  If not available then a search occurs.
 
-      const uint32_t block_id_hint =
-        (uint32_t)( Kokkos::Impl::clock_tic()
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA )
-        // Spread out potentially concurrent access
-        // by threads within a warp or thread block.
-        + ( threadIdx.x + blockDim.x * threadIdx.y )
+    const uint32_t block_id_hint =
+        (uint32_t)(Kokkos::Impl::clock_tic()
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
+                   // Spread out potentially concurrent access
+                   // by threads within a warp or thread block.
+                   + (threadIdx.x + blockDim.x * threadIdx.y)
 #endif
         );
 
-      // expected state of superblock for allocation
-      uint32_t sb_state = block_state ;
-
-      int32_t sb_id = -1 ;
+    // expected state of superblock for allocation
+    uint32_t sb_state = block_state;
 
-      volatile uint32_t * sb_state_array = 0 ;
+    int32_t sb_id = -1;
 
-      while ( attempt_limit ) {
+    volatile uint32_t *sb_state_array = 0;
 
-        int32_t hint_sb_id = -1 ;
+    while (attempt_limit) {
+      int32_t hint_sb_id = -1;
 
-        if ( sb_id < 0 ) {
+      if (sb_id < 0) {
+        // No superblock specified, try the hint for this block size
 
-          // No superblock specified, try the hint for this block size
+        sb_id = hint_sb_id = int32_t(*hint_sb_id_ptr);
 
-          sb_id = hint_sb_id = int32_t( *hint_sb_id_ptr );
-
-          sb_state_array = m_sb_state_array + ( sb_id * m_sb_state_size );
-        }
-
-        // Require:
-        //   0 <= sb_id
-        //   sb_state_array == m_sb_state_array + m_sb_state_size * sb_id
+        sb_state_array = m_sb_state_array + (sb_id * m_sb_state_size);
+      }
 
-        if ( sb_state == ( state_header_mask & *sb_state_array ) ) {
+      // Require:
+      //   0 <= sb_id
+      //   sb_state_array == m_sb_state_array + m_sb_state_size * sb_id
 
-          // This superblock state is as expected, for the moment.
-          // Attempt to claim a bit.  The attempt updates the state
-          // so have already made sure the state header is as expected.
+      if (sb_state == (state_header_mask & *sb_state_array)) {
+        // This superblock state is as expected, for the moment.
+        // Attempt to claim a bit.  The attempt updates the state
+        // so have already made sure the state header is as expected.
 
-          const uint32_t count_lg2 = sb_state >> state_shift ;
-          const uint32_t mask      = ( 1u << count_lg2 ) - 1 ;
+        const uint32_t count_lg2 = sb_state >> state_shift;
+        const uint32_t mask      = (1u << count_lg2) - 1;
 
-          const Kokkos::pair<int,int> result =
-            CB::acquire_bounded_lg2( sb_state_array
-                                   , count_lg2
-                                   , block_id_hint & mask
-                                   , sb_state
-                                   );
+        const Kokkos::pair<int, int> result = CB::acquire_bounded_lg2(
+            sb_state_array, count_lg2, block_id_hint & mask, sb_state);
 
-          // If result.first < 0 then failed to acquire
-          // due to either full or buffer was wrong state.
-          // Could be wrong state if a deallocation raced the
-          // superblock to empty before the acquire could succeed.
+        // If result.first < 0 then failed to acquire
+        // due to either full or buffer was wrong state.
+        // Could be wrong state if a deallocation raced the
+        // superblock to empty before the acquire could succeed.
 
-          if ( 0 <= result.first ) { // acquired a bit
+        if (0 <= result.first) {  // acquired a bit
 
-            const uint32_t size_lg2 = m_sb_size_lg2 - count_lg2 ;
+          const uint32_t size_lg2 = m_sb_size_lg2 - count_lg2;
 
-            // Set the allocated block pointer
+          // Set the allocated block pointer
 
-            p = ((char*)( m_sb_state_array + m_data_offset ))
-              + ( uint64_t(sb_id) << m_sb_size_lg2 ) // superblock memory
-              + ( uint64_t(result.first) << size_lg2 ); // block memory
+          p = ((char *)(m_sb_state_array + m_data_offset)) +
+              (uint64_t(sb_id) << m_sb_size_lg2)       // superblock memory
+              + (uint64_t(result.first) << size_lg2);  // block memory
 
 #if 0
   printf( "  MemoryPool(0x%lx) pointer(0x%lx) allocate(%lu) sb_id(%d) sb_state(0x%x) block_size(%d) block_capacity(%d) block_id(%d) block_claimed(%d)\n"
@@ -689,146 +646,133 @@ public:
         , result.second );
 #endif
 
-            break ; // Success
-          }
+          break;  // Success
         }
-        //------------------------------------------------------------------
-        //  Arrive here if failed to acquire a block.
-        //  Must find a new superblock.
-
-        //  Start searching at designated index for this block size.
-        //  Look for superblock that, in preferential order,
-        //  1) part-full superblock of this block size
-        //  2) empty superblock to claim for this block size
-        //  3) part-full superblock of the next larger block size
-
-        sb_state = block_state ; // Expect to find the desired state
-        sb_id = -1 ;
-
-        bool update_hint = false ;
-        int32_t sb_id_empty = -1 ;
-        int32_t sb_id_large = -1 ;
-        uint32_t sb_state_large = 0 ;
-
-        sb_state_array = m_sb_state_array + sb_id_begin * m_sb_state_size ;
-
-        for ( int32_t i = 0 , id = sb_id_begin ; i < m_sb_count ; ++i ) {
-
-          //  Query state of the candidate superblock.
-          //  Note that the state may change at any moment
-          //  as concurrent allocations and deallocations occur.
-          
-          const uint32_t full_state = *sb_state_array ;
-          const uint32_t used       = full_state & state_used_mask ;
-          const uint32_t state      = full_state & state_header_mask ;
+      }
+      //------------------------------------------------------------------
+      //  Arrive here if failed to acquire a block.
+      //  Must find a new superblock.
 
-          if ( state == block_state ) {
+      //  Start searching at designated index for this block size.
+      //  Look for superblock that, in preferential order,
+      //  1) part-full superblock of this block size
+      //  2) empty superblock to claim for this block size
+      //  3) part-full superblock of the next larger block size
 
-            //  Superblock is assigned to this block size
+      sb_state = block_state;  // Expect to find the desired state
+      sb_id    = -1;
 
-            if ( used < block_count ) {
+      bool update_hint        = false;
+      int32_t sb_id_empty     = -1;
+      int32_t sb_id_large     = -1;
+      uint32_t sb_state_large = 0;
 
-              // There is room to allocate one block
+      sb_state_array = m_sb_state_array + sb_id_begin * m_sb_state_size;
 
-              sb_id = id ;
+      for (int32_t i = 0, id = sb_id_begin; i < m_sb_count; ++i) {
+        //  Query state of the candidate superblock.
+        //  Note that the state may change at any moment
+        //  as concurrent allocations and deallocations occur.
 
-              // Is there room to allocate more than one block?
+        const uint32_t full_state = *sb_state_array;
+        const uint32_t used       = full_state & state_used_mask;
+        const uint32_t state      = full_state & state_header_mask;
 
-              update_hint = used + 1 < block_count ;
+        if (state == block_state) {
+          //  Superblock is assigned to this block size
 
-              break ;
-            }
-          }
-          else if ( 0 == used ) {
+          if (used < block_count) {
+            // There is room to allocate one block
 
-            // Superblock is empty
+            sb_id = id;
 
-            if ( -1 == sb_id_empty ) {
+            // Is there room to allocate more than one block?
 
-              // Superblock is not assigned to this block size
-              // and is the first empty superblock encountered.
-              // Save this id to use if a partfull superblock is not found.
+            update_hint = used + 1 < block_count;
 
-              sb_id_empty = id ;
-            }
-          }
-          else if ( ( -1 == sb_id_empty /* have not found an empty */ ) &&
-                    ( -1 == sb_id_large /* have not found a larger */ ) &&
-                    ( state < block_state /* a larger block */ ) &&
-                    // is not full:
-                    ( used < ( 1u << ( state >> state_shift ) ) ) ) {
-            //  First superblock encountered that is
-            //  larger than this block size and
-            //  has room for an allocation.
-            //  Save this id to use of partfull or empty superblock not found
-            sb_id_large    = id ;
-            sb_state_large = state ;
+            break;
           }
+        } else if (0 == used) {
+          // Superblock is empty
 
-          // Iterate around the superblock array:
+          if (-1 == sb_id_empty) {
+            // Superblock is not assigned to this block size
+            // and is the first empty superblock encountered.
+            // Save this id to use if a partfull superblock is not found.
 
-          if ( ++id < m_sb_count ) {
-            sb_state_array += m_sb_state_size ;
-          }
-          else {
-            id = 0 ;
-            sb_state_array = m_sb_state_array ;
+            sb_id_empty = id;
           }
+        } else if ((-1 == sb_id_empty /* have not found an empty */) &&
+                   (-1 == sb_id_large /* have not found a larger */) &&
+                   (state < block_state /* a larger block */) &&
+                   // is not full:
+                   (used < (1u << (state >> state_shift)))) {
+          //  First superblock encountered that is
+          //  larger than this block size and
+          //  has room for an allocation.
+          //  Save this id to use of partfull or empty superblock not found
+          sb_id_large    = id;
+          sb_state_large = state;
         }
 
- // printf("  search m_sb_count(%d) sb_id(%d) sb_id_empty(%d) sb_id_large(%d)\n" , m_sb_count , sb_id , sb_id_empty , sb_id_large);
+        // Iterate around the superblock array:
 
-        if ( sb_id < 0 ) {
+        if (++id < m_sb_count) {
+          sb_state_array += m_sb_state_size;
+        } else {
+          id             = 0;
+          sb_state_array = m_sb_state_array;
+        }
+      }
 
-          //  Did not find a partfull superblock for this block size.
+      // printf("  search m_sb_count(%d) sb_id(%d) sb_id_empty(%d)
+      // sb_id_large(%d)\n" , m_sb_count , sb_id , sb_id_empty , sb_id_large);
 
-          if ( 0 <= sb_id_empty ) {
+      if (sb_id < 0) {
+        //  Did not find a partfull superblock for this block size.
 
-            //  Found first empty superblock following designated superblock
-            //  Attempt to claim it for this block size.
-            //  If the claim fails assume that another thread claimed it
-            //  for this block size and try to use it anyway,
-            //  but do not update hint.
+        if (0 <= sb_id_empty) {
+          //  Found first empty superblock following designated superblock
+          //  Attempt to claim it for this block size.
+          //  If the claim fails assume that another thread claimed it
+          //  for this block size and try to use it anyway,
+          //  but do not update hint.
 
-            sb_id = sb_id_empty ;
+          sb_id = sb_id_empty;
 
-            sb_state_array = m_sb_state_array + ( sb_id * m_sb_state_size );
+          sb_state_array = m_sb_state_array + (sb_id * m_sb_state_size);
 
-            //  If successfully changed assignment of empty superblock 'sb_id'
-            //  to this block_size then update the hint.
+          //  If successfully changed assignment of empty superblock 'sb_id'
+          //  to this block_size then update the hint.
 
-            const uint32_t state_empty = state_header_mask & *sb_state_array ;
+          const uint32_t state_empty = state_header_mask & *sb_state_array;
 
-            // If this thread claims the empty block then update the hint
-            update_hint =
-              state_empty ==
-                Kokkos::atomic_compare_exchange
-                  (sb_state_array,state_empty,block_state);
-          }
-          else if ( 0 <= sb_id_large ) {
+          // If this thread claims the empty block then update the hint
+          update_hint =
+              state_empty == Kokkos::atomic_compare_exchange(
+                                 sb_state_array, state_empty, block_state);
+        } else if (0 <= sb_id_large) {
+          // Found a larger superblock with space available
 
-            // Found a larger superblock with space available
+          sb_id    = sb_id_large;
+          sb_state = sb_state_large;
 
-            sb_id    = sb_id_large ;
-            sb_state = sb_state_large ;
-
-            sb_state_array = m_sb_state_array + ( sb_id * m_sb_state_size );
-          }
-          else {
-            // Did not find a potentially usable superblock
-            --attempt_limit ;
-          }
+          sb_state_array = m_sb_state_array + (sb_id * m_sb_state_size);
+        } else {
+          // Did not find a potentially usable superblock
+          --attempt_limit;
         }
+      }
 
-        if ( update_hint ) {
-          Kokkos::atomic_compare_exchange
-            ( hint_sb_id_ptr , uint32_t(hint_sb_id) , uint32_t(sb_id) );
-        }
-      } // end allocation attempt loop
-      //--------------------------------------------------------------------
+      if (update_hint) {
+        Kokkos::atomic_compare_exchange(hint_sb_id_ptr, uint32_t(hint_sb_id),
+                                        uint32_t(sb_id));
+      }
+    }  // end allocation attempt loop
+    //--------------------------------------------------------------------
 
-      return p ;
-    }
+    return p;
+  }
   // end allocate
   //--------------------------------------------------------------------------
 
@@ -839,47 +783,43 @@ public:
    *  For now the alloc_size is ignored.
    */
   KOKKOS_INLINE_FUNCTION
-  void deallocate( void * p , size_t /* alloc_size */ ) const noexcept
-    {
-      if ( 0 == p ) return ;
-
-      // Determine which superblock and block
-      const ptrdiff_t d =
-        ((char*)p) - ((char*)( m_sb_state_array + m_data_offset ));
+  void deallocate(void *p, size_t /* alloc_size */) const noexcept {
+    if (0 == p) return;
 
-      // Verify contained within the memory pool's superblocks:
-      const int ok_contains =
-        ( 0 <= d ) && ( size_t(d) < ( size_t(m_sb_count) << m_sb_size_lg2 ) );
+    // Determine which superblock and block
+    const ptrdiff_t d =
+        ((char *)p) - ((char *)(m_sb_state_array + m_data_offset));
 
-      int ok_block_aligned = 0 ;
-      int ok_dealloc_once  = 0 ;
+    // Verify contained within the memory pool's superblocks:
+    const int ok_contains =
+        (0 <= d) && (size_t(d) < (size_t(m_sb_count) << m_sb_size_lg2));
 
-      if ( ok_contains ) {
+    int ok_block_aligned = 0;
+    int ok_dealloc_once  = 0;
 
-        const int sb_id = d >> m_sb_size_lg2 ;
+    if (ok_contains) {
+      const int sb_id = d >> m_sb_size_lg2;
 
-        // State array for the superblock.
-        volatile uint32_t * const sb_state_array =
-          m_sb_state_array + ( sb_id * m_sb_state_size );
+      // State array for the superblock.
+      volatile uint32_t *const sb_state_array =
+          m_sb_state_array + (sb_id * m_sb_state_size);
 
-        const uint32_t block_state    = (*sb_state_array) & state_header_mask ;
-        const uint32_t block_size_lg2 =
-          m_sb_size_lg2 - ( block_state >> state_shift );
+      const uint32_t block_state = (*sb_state_array) & state_header_mask;
+      const uint32_t block_size_lg2 =
+          m_sb_size_lg2 - (block_state >> state_shift);
 
-        ok_block_aligned = 0 == ( d & ( ( 1UL << block_size_lg2 ) - 1 ) );
+      ok_block_aligned = 0 == (d & ((1UL << block_size_lg2) - 1));
 
-        if ( ok_block_aligned ) {
+      if (ok_block_aligned) {
+        // Map address to block's bit
+        // mask into superblock and then shift down for block index
 
-          // Map address to block's bit
-          // mask into superblock and then shift down for block index
+        const uint32_t bit =
+            (d & (ptrdiff_t(1LU << m_sb_size_lg2) - 1)) >> block_size_lg2;
 
-          const uint32_t bit =
-            ( d & ( ptrdiff_t( 1LU << m_sb_size_lg2 ) - 1 ) ) >> block_size_lg2 ;
+        const int result = CB::release(sb_state_array, bit, block_state);
 
-          const int result =
-            CB::release( sb_state_array , bit , block_state );
-
-          ok_dealloc_once = 0 <= result ;
+        ok_dealloc_once = 0 <= result;
 
 #if 0
   printf( "  MemoryPool(0x%lx) pointer(0x%lx) deallocate sb_id(%d) block_size(%d) block_capacity(%d) block_id(%d) block_claimed(%d)\n"
@@ -891,10 +831,10 @@ public:
         , bit
         , result );
 #endif
-        }
       }
+    }
 
-      if ( ! ok_contains || ! ok_block_aligned || ! ok_dealloc_once ) {
+    if (!ok_contains || !ok_block_aligned || !ok_dealloc_once) {
 #if 0
   printf( "  MemoryPool(0x%lx) pointer(0x%lx) deallocate ok_contains(%d) ok_block_aligned(%d) ok_dealloc_once(%d)\n"
         , (uintptr_t)m_sb_state_array
@@ -903,44 +843,40 @@ public:
         , int(ok_block_aligned)
         , int(ok_dealloc_once) );
 #endif
-        Kokkos::abort("Kokkos MemoryPool::deallocate given erroneous pointer");
-      }
+      Kokkos::abort("Kokkos MemoryPool::deallocate given erroneous pointer");
     }
+  }
   // end deallocate
   //--------------------------------------------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  int number_of_superblocks() const noexcept { return m_sb_count ; }
+  int number_of_superblocks() const noexcept { return m_sb_count; }
 
   KOKKOS_INLINE_FUNCTION
-  void superblock_state( int sb_id
-                       , int & block_size
-                       , int & block_count_capacity
-                       , int & block_count_used ) const noexcept
-    {
-      block_size           = 0 ;
-      block_count_capacity = 0 ;
-      block_count_used     = 0 ;
-
-      if ( Kokkos::Impl::MemorySpaceAccess
-             < Kokkos::Impl::ActiveExecutionMemorySpace
-             , base_memory_space >::accessible ) {
-       // Can access the state array
-       
-        const uint32_t state =
-          ((uint32_t volatile *)m_sb_state_array)[sb_id*m_sb_state_size];
-
-        const uint32_t block_count_lg2 = state >> state_shift ;
-        const uint32_t block_used      = state & state_used_mask ;
-
-        block_size           = 1LU << ( m_sb_size_lg2 - block_count_lg2 );
-        block_count_capacity = 1LU << block_count_lg2 ;
-        block_count_used     = block_used ;
-      }
+  void superblock_state(int sb_id, int &block_size, int &block_count_capacity,
+                        int &block_count_used) const noexcept {
+    block_size           = 0;
+    block_count_capacity = 0;
+    block_count_used     = 0;
+
+    if (Kokkos::Impl::MemorySpaceAccess<
+            Kokkos::Impl::ActiveExecutionMemorySpace,
+            base_memory_space>::accessible) {
+      // Can access the state array
+
+      const uint32_t state =
+          ((uint32_t volatile *)m_sb_state_array)[sb_id * m_sb_state_size];
+
+      const uint32_t block_count_lg2 = state >> state_shift;
+      const uint32_t block_used      = state & state_used_mask;
+
+      block_size           = 1LU << (m_sb_size_lg2 - block_count_lg2);
+      block_count_capacity = 1LU << block_count_lg2;
+      block_count_used     = block_used;
     }
+  }
 };
 
-} // namespace Kokkos 
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_MEMORYPOOL_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_MemoryTraits.hpp b/lib/kokkos/core/src/Kokkos_MemoryTraits.hpp
index 509ac6499e2563a3a8334d299fa09f2f345753bb..75d3d4014467351cd48f5dee2e122aed9aa0863c 100644
--- a/lib/kokkos/core/src/Kokkos_MemoryTraits.hpp
+++ b/lib/kokkos/core/src/Kokkos_MemoryTraits.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -59,53 +60,64 @@ namespace Kokkos {
  *  A zero value is the default for a View, indicating that none of
  *  these traits are present.
  */
-enum MemoryTraitsFlags
-  { Unmanaged  = 0x01
-  , RandomAccess = 0x02
-  , Atomic = 0x04
-  , Restrict = 0x08
-  , Aligned = 0x10
-  };
+enum MemoryTraitsFlags {
+  Unmanaged    = 0x01,
+  RandomAccess = 0x02,
+  Atomic       = 0x04,
+  Restrict     = 0x08,
+  Aligned      = 0x10
+};
 
-template < unsigned T >
+template <unsigned T>
 struct MemoryTraits {
   //! Tag this class as a kokkos memory traits:
-  typedef MemoryTraits memory_traits ;
+  typedef MemoryTraits memory_traits;
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  enum : bool { Unmanaged    = (unsigned(0) != (T & unsigned(Kokkos::Unmanaged))) };
-  enum : bool { RandomAccess = (unsigned(0) != (T & unsigned(Kokkos::RandomAccess))) };
-  enum : bool { Atomic       = (unsigned(0) != (T & unsigned(Kokkos::Atomic))) };
-  enum : bool { Restrict     = (unsigned(0) != (T & unsigned(Kokkos::Restrict))) };
-  enum : bool { Aligned      = (unsigned(0) != (T & unsigned(Kokkos::Aligned))) };
+  enum : bool {
+    Unmanaged = (unsigned(0) != (T & unsigned(Kokkos::Unmanaged)))
+  };
+  enum : bool {
+    RandomAccess = (unsigned(0) != (T & unsigned(Kokkos::RandomAccess)))
+  };
+  enum : bool { Atomic = (unsigned(0) != (T & unsigned(Kokkos::Atomic))) };
+  enum : bool { Restrict = (unsigned(0) != (T & unsigned(Kokkos::Restrict))) };
+  enum : bool { Aligned = (unsigned(0) != (T & unsigned(Kokkos::Aligned))) };
 #endif
-  enum : bool { is_unmanaged    = (unsigned(0) != (T & unsigned(Kokkos::Unmanaged))) };
-  enum : bool { is_random_access = (unsigned(0) != (T & unsigned(Kokkos::RandomAccess))) };
-  enum : bool { is_atomic       = (unsigned(0) != (T & unsigned(Kokkos::Atomic))) };
-  enum : bool { is_restrict     = (unsigned(0) != (T & unsigned(Kokkos::Restrict))) };
-  enum : bool { is_aligned      = (unsigned(0) != (T & unsigned(Kokkos::Aligned))) };
+  enum : bool {
+    is_unmanaged = (unsigned(0) != (T & unsigned(Kokkos::Unmanaged)))
+  };
+  enum : bool {
+    is_random_access = (unsigned(0) != (T & unsigned(Kokkos::RandomAccess)))
+  };
+  enum : bool { is_atomic = (unsigned(0) != (T & unsigned(Kokkos::Atomic))) };
+  enum : bool {
+    is_restrict = (unsigned(0) != (T & unsigned(Kokkos::Restrict)))
+  };
+  enum : bool { is_aligned = (unsigned(0) != (T & unsigned(Kokkos::Aligned))) };
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-typedef Kokkos::MemoryTraits<0> MemoryManaged ;
-typedef Kokkos::MemoryTraits< Kokkos::Unmanaged > MemoryUnmanaged ;
-typedef Kokkos::MemoryTraits< Kokkos::Unmanaged | Kokkos::RandomAccess > MemoryRandomAccess ;
+typedef Kokkos::MemoryTraits<0> MemoryManaged;
+typedef Kokkos::MemoryTraits<Kokkos::Unmanaged> MemoryUnmanaged;
+typedef Kokkos::MemoryTraits<Kokkos::Unmanaged | Kokkos::RandomAccess>
+    MemoryRandomAccess;
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-static_assert(
-  ( 0 < int(KOKKOS_MEMORY_ALIGNMENT) ) &&
-  ( 0 == ( int(KOKKOS_MEMORY_ALIGNMENT) & (int(KOKKOS_MEMORY_ALIGNMENT)-1))) ,
-  "KOKKOS_MEMORY_ALIGNMENT must be a power of two" );
+static_assert((0 < int(KOKKOS_MEMORY_ALIGNMENT)) &&
+                  (0 == (int(KOKKOS_MEMORY_ALIGNMENT) &
+                         (int(KOKKOS_MEMORY_ALIGNMENT) - 1))),
+              "KOKKOS_MEMORY_ALIGNMENT must be a power of two");
 
 /** \brief Memory alignment settings
  *
@@ -113,13 +125,12 @@ static_assert(
  *  Enable compatibility of views from different devices with static stride.
  *  Use compiler flag to enable overwrites.
  */
-enum : unsigned
-  { MEMORY_ALIGNMENT           = KOKKOS_MEMORY_ALIGNMENT
-  , MEMORY_ALIGNMENT_THRESHOLD = KOKKOS_MEMORY_ALIGNMENT_THRESHOLD
-  };
+enum : unsigned {
+  MEMORY_ALIGNMENT           = KOKKOS_MEMORY_ALIGNMENT,
+  MEMORY_ALIGNMENT_THRESHOLD = KOKKOS_MEMORY_ALIGNMENT_THRESHOLD
+};
 
-} //namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_MEMORYTRAITS_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_NumericTraits.hpp b/lib/kokkos/core/src/Kokkos_NumericTraits.hpp
index baac78254526d9fc375c05be3ae468c6d2171006..666bb3326623ec84d0d8fb92edebf22e29ef602d 100644
--- a/lib/kokkos/core/src/Kokkos_NumericTraits.hpp
+++ b/lib/kokkos/core/src/Kokkos_NumericTraits.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,176 +45,347 @@
 #ifndef KOKKOS_NUMERICTRAITS_HPP
 #define KOKKOS_NUMERICTRAITS_HPP
 
-#include<climits>
-#include<cfloat>
+#include <climits>
+#include <cfloat>
 
 namespace Kokkos {
 
-template<class T>
+template <class T>
 struct reduction_identity; /*{
   KOKKOS_FORCEINLINE_FUNCTION constexpr static T sum() { return T(); }  // 0
   KOKKOS_FORCEINLINE_FUNCTION constexpr static T prod()  // 1
-    { static_assert( false, "Missing specialization of Kokkos::reduction_identity for custom prod reduction type"); return T(); }
+    { static_assert( false, "Missing specialization of
+Kokkos::reduction_identity for custom prod reduction type"); return T(); }
   KOKKOS_FORCEINLINE_FUNCTION constexpr static T max()   // minimum value
-    { static_assert( false, "Missing specialization of Kokkos::reduction_identity for custom max reduction type"); return T(); }
+    { static_assert( false, "Missing specialization of
+Kokkos::reduction_identity for custom max reduction type"); return T(); }
   KOKKOS_FORCEINLINE_FUNCTION constexpr static T min()   // maximum value
-    { static_assert( false, "Missing specialization of Kokkos::reduction_identity for custom min reduction type"); return T(); }
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static T bor()   // 0, only for integer type
-    { static_assert( false, "Missing specialization of Kokkos::reduction_identity for custom bor reduction type"); return T(); }
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static T band()  // !0, only for integer type
-    { static_assert( false, "Missing specialization of Kokkos::reduction_identity for custom band reduction type"); return T(); }
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static T lor()   // 0, only for integer type
-    { static_assert( false, "Missing specialization of Kokkos::reduction_identity for custom lor reduction type"); return T(); }
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static T land()  // !0, only for integer type
-    { static_assert( false, "Missing specialization of Kokkos::reduction_identity for custom land reduction type"); return T(); }
+    { static_assert( false, "Missing specialization of
+Kokkos::reduction_identity for custom min reduction type"); return T(); }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static T bor()   // 0, only for integer
+type { static_assert( false, "Missing specialization of
+Kokkos::reduction_identity for custom bor reduction type"); return T(); }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static T band()  // !0, only for integer
+type { static_assert( false, "Missing specialization of
+Kokkos::reduction_identity for custom band reduction type"); return T(); }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static T lor()   // 0, only for integer
+type { static_assert( false, "Missing specialization of
+Kokkos::reduction_identity for custom lor reduction type"); return T(); }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static T land()  // !0, only for integer
+type { static_assert( false, "Missing specialization of
+Kokkos::reduction_identity for custom land reduction type"); return T(); }
 };*/
 
-template<>
+template <>
 struct reduction_identity<signed char> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char sum()  {return static_cast<signed char>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char prod() {return static_cast<signed char>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char max()  {return SCHAR_MIN;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char min()  {return SCHAR_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char bor()  {return static_cast<signed char>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char band() {return ~static_cast<signed char>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char lor()  {return static_cast<signed char>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char land() {return static_cast<signed char>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char sum() {
+    return static_cast<signed char>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char prod() {
+    return static_cast<signed char>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char max() {
+    return SCHAR_MIN;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char min() {
+    return SCHAR_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char bor() {
+    return static_cast<signed char>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char band() {
+    return ~static_cast<signed char>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char lor() {
+    return static_cast<signed char>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static signed char land() {
+    return static_cast<signed char>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<short> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short sum()  {return static_cast<short>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short prod() {return static_cast<short>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short max()  {return SHRT_MIN;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short min()  {return SHRT_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short bor()  {return static_cast<short>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short band() {return ~static_cast<short>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short lor()  {return static_cast<short>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static short land() {return static_cast<short>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short sum() {
+    return static_cast<short>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short prod() {
+    return static_cast<short>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short max() { return SHRT_MIN; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short min() { return SHRT_MAX; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short bor() {
+    return static_cast<short>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short band() {
+    return ~static_cast<short>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short lor() {
+    return static_cast<short>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static short land() {
+    return static_cast<short>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<int> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int sum()  {return static_cast<int>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int prod() {return static_cast<int>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int max()  {return INT_MIN;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int min()  {return INT_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int bor()  {return static_cast<int>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int band() {return ~static_cast<int>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int lor()  {return static_cast<int>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static int land() {return static_cast<int>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int sum() {
+    return static_cast<int>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int prod() {
+    return static_cast<int>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int max() { return INT_MIN; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int min() { return INT_MAX; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int bor() {
+    return static_cast<int>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int band() {
+    return ~static_cast<int>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int lor() {
+    return static_cast<int>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static int land() {
+    return static_cast<int>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<long> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long sum()  {return static_cast<long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long prod() {return static_cast<long>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long max()  {return LLONG_MIN;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long min()  {return LLONG_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long bor()  {return static_cast<long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long band() {return ~static_cast<long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long lor()  {return static_cast<long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long land() {return static_cast<long>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long sum() {
+    return static_cast<long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long prod() {
+    return static_cast<long>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long max() { return LLONG_MIN; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long min() { return LLONG_MAX; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long bor() {
+    return static_cast<long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long band() {
+    return ~static_cast<long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long lor() {
+    return static_cast<long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long land() {
+    return static_cast<long>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<long long> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long sum()  {return static_cast<long long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long prod() {return static_cast<long long>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long max()  {return LLONG_MIN;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long min()  {return LLONG_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long bor()  {return static_cast<long long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long band() {return ~static_cast<long long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long lor()  {return static_cast<long long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long land() {return static_cast<long long>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long sum() {
+    return static_cast<long long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long prod() {
+    return static_cast<long long>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long max() {
+    return LLONG_MIN;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long min() {
+    return LLONG_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long bor() {
+    return static_cast<long long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long band() {
+    return ~static_cast<long long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long lor() {
+    return static_cast<long long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long long land() {
+    return static_cast<long long>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<unsigned char> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char sum()  {return static_cast<unsigned char>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char prod() {return static_cast<unsigned char>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char max()  {return static_cast<unsigned char>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char min()  {return UCHAR_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char bor()  {return static_cast<unsigned char>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char band() {return ~static_cast<unsigned char>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char lor()  {return static_cast<unsigned char>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char land() {return static_cast<unsigned char>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char sum() {
+    return static_cast<unsigned char>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char prod() {
+    return static_cast<unsigned char>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char max() {
+    return static_cast<unsigned char>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char min() {
+    return UCHAR_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char bor() {
+    return static_cast<unsigned char>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char band() {
+    return ~static_cast<unsigned char>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char lor() {
+    return static_cast<unsigned char>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned char land() {
+    return static_cast<unsigned char>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<unsigned short> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short sum()  {return static_cast<unsigned short>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short prod() {return static_cast<unsigned short>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short max()  {return static_cast<unsigned short>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short min()  {return USHRT_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short bor()  {return static_cast<unsigned short>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short band() {return ~static_cast<unsigned short>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short lor()  {return static_cast<unsigned short>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short land() {return static_cast<unsigned short>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short sum() {
+    return static_cast<unsigned short>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short prod() {
+    return static_cast<unsigned short>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short max() {
+    return static_cast<unsigned short>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short min() {
+    return USHRT_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short bor() {
+    return static_cast<unsigned short>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short band() {
+    return ~static_cast<unsigned short>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short lor() {
+    return static_cast<unsigned short>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned short land() {
+    return static_cast<unsigned short>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<unsigned int> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int sum()  {return static_cast<unsigned int>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int prod() {return static_cast<unsigned int>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int max()  {return static_cast<unsigned int>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int min()  {return UINT_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int bor()  {return static_cast<unsigned int>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int band() {return ~static_cast<unsigned int>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int lor()  {return static_cast<unsigned int>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int land() {return static_cast<unsigned int>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int sum() {
+    return static_cast<unsigned int>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int prod() {
+    return static_cast<unsigned int>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int max() {
+    return static_cast<unsigned int>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int min() {
+    return UINT_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int bor() {
+    return static_cast<unsigned int>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int band() {
+    return ~static_cast<unsigned int>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int lor() {
+    return static_cast<unsigned int>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned int land() {
+    return static_cast<unsigned int>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<unsigned long> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long sum()  {return static_cast<unsigned long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long prod() {return static_cast<unsigned long>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long max()  {return static_cast<unsigned long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long min()  {return ULONG_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long bor()  {return static_cast<unsigned long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long band() {return ~static_cast<unsigned long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long lor()  {return static_cast<unsigned long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long land() {return static_cast<unsigned long>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long sum() {
+    return static_cast<unsigned long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long prod() {
+    return static_cast<unsigned long>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long max() {
+    return static_cast<unsigned long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long min() {
+    return ULONG_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long bor() {
+    return static_cast<unsigned long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long band() {
+    return ~static_cast<unsigned long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long lor() {
+    return static_cast<unsigned long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long land() {
+    return static_cast<unsigned long>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<unsigned long long> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long sum()  {return static_cast<unsigned long long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long prod() {return static_cast<unsigned long long>(1);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long max()  {return static_cast<unsigned long long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long min()  {return ULLONG_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long bor()  {return static_cast<unsigned long long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long band() {return ~static_cast<unsigned long long>(0x0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long lor()  {return static_cast<unsigned long long>(0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long land() {return static_cast<unsigned long long>(1);}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long sum() {
+    return static_cast<unsigned long long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long prod() {
+    return static_cast<unsigned long long>(1);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long max() {
+    return static_cast<unsigned long long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long min() {
+    return ULLONG_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long bor() {
+    return static_cast<unsigned long long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long band() {
+    return ~static_cast<unsigned long long>(0x0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long lor() {
+    return static_cast<unsigned long long>(0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static unsigned long long land() {
+    return static_cast<unsigned long long>(1);
+  }
 };
 
-template<>
+template <>
 struct reduction_identity<float> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static float sum()  {return static_cast<float>(0.0f);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static float prod() {return static_cast<float>(1.0f);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static float max()  {return -FLT_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static float min()  {return FLT_MAX;}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float sum() {
+    return static_cast<float>(0.0f);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float prod() {
+    return static_cast<float>(1.0f);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float max() { return -FLT_MAX; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float min() { return FLT_MAX; }
 };
 
-template<>
+template <>
 struct reduction_identity<double> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static double sum()  {return static_cast<double>(0.0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static double prod() {return static_cast<double>(1.0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static double max()  {return -DBL_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static double min()  {return DBL_MAX;}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static double sum() {
+    return static_cast<double>(0.0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static double prod() {
+    return static_cast<double>(1.0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static double max() { return -DBL_MAX; }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static double min() { return DBL_MAX; }
 };
 
-#if !defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA )
-template<>
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
+template <>
 struct reduction_identity<long double> {
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double sum()  {return static_cast<long double>(0.0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double prod() {return static_cast<long double>(1.0);}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double max()  {return -LDBL_MAX;}
-  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double min()  {return LDBL_MAX;}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double sum() {
+    return static_cast<long double>(0.0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double prod() {
+    return static_cast<long double>(1.0);
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double max() {
+    return -LDBL_MAX;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static long double min() {
+    return LDBL_MAX;
+  }
 };
 #endif
 
-}
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/Kokkos_OpenMP.hpp b/lib/kokkos/core/src/Kokkos_OpenMP.hpp
index 6ee8f08dc89541187b9d31258997ef1e2a7d654f..3955c061562e17017b71b1b1ca6b21afcf47f17f 100644
--- a/lib/kokkos/core/src/Kokkos_OpenMP.hpp
+++ b/lib/kokkos/core/src/Kokkos_OpenMP.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_OPENMP_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP)
+#if defined(KOKKOS_ENABLE_OPENMP)
 
 #include <Kokkos_Core_fwd.hpp>
 
@@ -76,53 +77,48 @@ class OpenMPExec;
 /// \class OpenMP
 /// \brief Kokkos device for multicore processors in the host memory space.
 class OpenMP {
-public:
+ public:
   //! Tag this class as a kokkos execution space
   using execution_space = OpenMP;
 
   using memory_space =
-  #ifdef KOKKOS_ENABLE_HBWSPACE
-    Experimental::HBWSpace;
-  #else
-    HostSpace;
-  #endif
+#ifdef KOKKOS_ENABLE_HBWSPACE
+      Experimental::HBWSpace;
+#else
+      HostSpace;
+#endif
 
   //! This execution space preferred device_type
-  using device_type          = Kokkos::Device< execution_space, memory_space >;
+  using device_type          = Kokkos::Device<execution_space, memory_space>;
   using array_layout         = LayoutRight;
   using size_type            = memory_space::size_type;
-  using scratch_memory_space = ScratchMemorySpace< OpenMP >;
+  using scratch_memory_space = ScratchMemorySpace<OpenMP>;
 
   /// \brief Get a handle to the default execution space instance
-  inline
-  OpenMP() noexcept;
+  inline OpenMP() noexcept;
 
   /// \brief Print configuration information to the given output stream.
-  static void print_configuration( std::ostream & , const bool verbose = false );
+  static void print_configuration(std::ostream&, const bool verbose = false);
 
   /// \brief is the instance running a parallel algorithm
-  inline
-  static bool in_parallel( OpenMP const& = OpenMP() ) noexcept;
+  inline static bool in_parallel(OpenMP const& = OpenMP()) noexcept;
 
   /// \brief Wait until all dispatched functors complete on the given instance
   ///
   ///  This is a no-op on OpenMP
-  static void impl_static_fence( OpenMP const& = OpenMP() ) noexcept;
+  static void impl_static_fence(OpenMP const& = OpenMP()) noexcept;
 
-  #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  static void fence( OpenMP const& = OpenMP() ) noexcept;
-  #else
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
+  static void fence(OpenMP const& = OpenMP()) noexcept;
+#else
   void fence() const;
-  #endif
-
+#endif
 
   /// \brief Does the given instance return immediately after launching
   /// a parallel algorithm
   ///
   /// This always returns false on OpenMP
-  inline
-  static bool is_asynchronous( OpenMP const& = OpenMP() ) noexcept;
-
+  inline static bool is_asynchronous(OpenMP const& = OpenMP()) noexcept;
 
   /// \brief Partition the default instance into new instances without creating
   ///  new masters
@@ -137,24 +133,22 @@ public:
   /// This is a no-op on OpenMP since a non default instance cannot be created
   static OpenMP create_instance(...);
 
-  /// \brief Partition the default instance and call 'f' on each new 'master' thread
+  /// \brief Partition the default instance and call 'f' on each new 'master'
+  /// thread
   ///
   /// Func is a functor with the following signiture
   ///   void( int partition_id, int num_partitions )
   template <typename F>
-  static void partition_master( F const& f
-                              , int requested_num_partitions = 0
-                              , int requested_partition_size = 0
-                              );
+  static void partition_master(F const& f, int requested_num_partitions = 0,
+                               int requested_partition_size = 0);
 
   // use UniqueToken
   static int concurrency();
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /// \brief Initialize the default execution space
-  static void initialize( int thread_count,
-                          int use_numa_count,
-                          int use_cores_per_numa = 0);
+  static void initialize(int thread_count, int use_numa_count,
+                         int use_cores_per_numa = 0);
 
   /// \brief Initialize the default execution space
   ///
@@ -166,66 +160,62 @@ public:
   /// if ( thread_count > 0 )
   ///   then force openmp to use the given number of threads and change
   ///   the default number of threads
-  static void initialize( int thread_count = -1 );
+  static void initialize(int thread_count = -1);
 
-  /// \brief is the default execution space initialized for current 'master' thread
+  /// \brief is the default execution space initialized for current 'master'
+  /// thread
   static bool is_initialized() noexcept;
 
   /// \brief Free any resources being consumed by the default execution space
   static void finalize();
 
-  inline
-  static int thread_pool_size() noexcept;
+  inline static int thread_pool_size() noexcept;
 
   /** \brief  The rank of the executing thread in this thread pool */
   KOKKOS_INLINE_FUNCTION
   static int thread_pool_rank() noexcept;
 
-  inline
-  static int thread_pool_size( int depth );
+  inline static int thread_pool_size(int depth);
 
-  static void sleep() {};
-  static void wake() {};
+  static void sleep(){};
+  static void wake(){};
 
   // Using omp_get_max_threads(); is problematic
   // On Intel (essentially an initial call to the OpenMP runtime
   // without a parallel region before will set a process mask for a single core
-  // The runtime will than bind threads for a parallel region to other cores on the
-  // entering the first parallel region and make the process mask the aggregate of
-  // the thread masks. The intend seems to be to make serial code run fast, if you
-  // compile with OpenMP enabled but don't actually use parallel regions or so
-  // static int omp_max_threads = omp_get_max_threads();
+  // The runtime will than bind threads for a parallel region to other cores on
+  // the entering the first parallel region and make the process mask the
+  // aggregate of the thread masks. The intend seems to be to make serial code
+  // run fast, if you compile with OpenMP enabled but don't actually use
+  // parallel regions or so static int omp_max_threads = omp_get_max_threads();
   static int get_current_max_threads() noexcept;
 
   // use UniqueToken
-  inline
-  static int max_hardware_threads() noexcept;
+  inline static int max_hardware_threads() noexcept;
 
   // use UniqueToken
   KOKKOS_INLINE_FUNCTION
   static int hardware_thread_id() noexcept;
 #else
-  static void impl_initialize( int thread_count = -1 );
+  static void impl_initialize(int thread_count = -1);
 
-  /// \brief is the default execution space initialized for current 'master' thread
+  /// \brief is the default execution space initialized for current 'master'
+  /// thread
   static bool impl_is_initialized() noexcept;
 
   /// \brief Free any resources being consumed by the default execution space
   static void impl_finalize();
 
-  inline
-  static int impl_thread_pool_size() noexcept;
+  inline static int impl_thread_pool_size() noexcept;
 
   /** \brief  The rank of the executing thread in this thread pool */
   KOKKOS_INLINE_FUNCTION
   static int impl_thread_pool_rank() noexcept;
 
-  inline
-  static int impl_thread_pool_size( int depth );
+  inline static int impl_thread_pool_size(int depth);
 
   // use UniqueToken
-  inline
-  static int impl_max_hardware_threads() noexcept;
+  inline static int impl_max_hardware_threads() noexcept;
 
   // use UniqueToken
   KOKKOS_INLINE_FUNCTION
@@ -237,7 +227,7 @@ public:
   static constexpr const char* name() noexcept { return "OpenMP"; }
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -245,30 +235,24 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template<>
-struct MemorySpaceAccess
-  < Kokkos::OpenMP::memory_space
-  , Kokkos::OpenMP::scratch_memory_space
-  >
-{
+template <>
+struct MemorySpaceAccess<Kokkos::OpenMP::memory_space,
+                         Kokkos::OpenMP::scratch_memory_space> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = false };
+  enum { deepcopy = false };
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::OpenMP::memory_space
-  , Kokkos::OpenMP::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::OpenMP::memory_space, Kokkos::OpenMP::scratch_memory_space> {
   enum { value = true };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -283,4 +267,3 @@ struct VerifyExecutionCanAccessMemorySpace
 
 #endif /* #if defined( KOKKOS_ENABLE_OPENMP ) && defined( _OPENMP ) */
 #endif /* #ifndef KOKKOS_OPENMP_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_OpenMPTarget.hpp b/lib/kokkos/core/src/Kokkos_OpenMPTarget.hpp
index e2dd249ff7897cf1dea0c58ca1e10307845dfa64..9706751f9cf8de95bed61f36f0cb6255a4ccb717 100644
--- a/lib/kokkos/core/src/Kokkos_OpenMPTarget.hpp
+++ b/lib/kokkos/core/src/Kokkos_OpenMPTarget.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,7 +47,7 @@
 
 #include <Kokkos_Core_fwd.hpp>
 
-#if defined( KOKKOS_ENABLE_OPENMPTARGET ) && defined( _OPENMP )
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(_OPENMP)
 
 #include <omp.h>
 
@@ -67,21 +68,21 @@ namespace Experimental {
 /// \class OpenMPTarget
 /// \brief Kokkos device for multicore processors in the host memory space.
 class OpenMPTarget {
-public:
+ public:
   //------------------------------------
   //! \name Type declarations that all Kokkos devices must provide.
   //@{
 
   //! Tag this class as a kokkos execution space
-  typedef OpenMPTarget                execution_space ;
-  typedef OpenMPTargetSpace           memory_space ;
+  typedef OpenMPTarget execution_space;
+  typedef OpenMPTargetSpace memory_space;
   //! This execution space preferred device_type
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
-  typedef LayoutLeft           array_layout ;
-  typedef memory_space::size_type  size_type ;
+  typedef LayoutLeft array_layout;
+  typedef memory_space::size_type size_type;
 
-  typedef ScratchMemorySpace< OpenMPTarget > scratch_memory_space ;
+  typedef ScratchMemorySpace<OpenMPTarget> scratch_memory_space;
 
   //@}
   //------------------------------------
@@ -96,11 +97,12 @@ public:
   /** \brief Wake the device from the 'sleep' state. A noop for OpenMPTarget. */
   static bool wake();
 
-  /** \brief Wait until all dispatched functors complete. A noop for OpenMPTarget. */
+  /** \brief Wait until all dispatched functors complete. A noop for
+   * OpenMPTarget. */
   static void fence() {}
 
   /// \brief Print configuration information to the given output stream.
-  static void print_configuration( std::ostream & , const bool detail = false );
+  static void print_configuration(std::ostream&, const bool detail = false);
 
   /// \brief Free any resources being consumed by the device.
   static void finalize();
@@ -114,9 +116,8 @@ public:
    *  2) Allocate a HostThread for each OpenMPTarget thread to hold its
    *     topology and fan in/out data.
    */
-  static void initialize( unsigned thread_count = 0 ,
-                          unsigned use_numa_count = 0 ,
-                          unsigned use_cores_per_numa = 0 );
+  static void initialize(unsigned thread_count = 0, unsigned use_numa_count = 0,
+                         unsigned use_cores_per_numa = 0);
 
   static int is_initialized();
 
@@ -125,14 +126,16 @@ public:
 
   //@}
   //------------------------------------
-  /** \brief  This execution space has a topological thread pool which can be queried.
+  /** \brief  This execution space has a topological thread pool which can be
+   * queried.
    *
-   *  All threads within a pool have a common memory space for which they are cache coherent.
-   *    depth = 0  gives the number of threads in the whole pool.
-   *    depth = 1  gives the number of threads in a NUMA region, typically sharing L3 cache.
-   *    depth = 2  gives the number of threads at the finest granularity, typically sharing L1 cache.
+   *  All threads within a pool have a common memory space for which they are
+   * cache coherent. depth = 0  gives the number of threads in the whole pool.
+   *    depth = 1  gives the number of threads in a NUMA region, typically
+   * sharing L3 cache. depth = 2  gives the number of threads at the finest
+   * granularity, typically sharing L1 cache.
    */
-  inline static int thread_pool_size( int depth = 0 );
+  inline static int thread_pool_size(int depth = 0);
 
   /** \brief  The rank of the executing thread in this thread pool */
   KOKKOS_INLINE_FUNCTION static int thread_pool_rank();
@@ -141,15 +144,17 @@ public:
 
   inline static unsigned max_hardware_threads() { return thread_pool_size(0); }
 
-  KOKKOS_INLINE_FUNCTION static
-  unsigned hardware_thread_id() { return thread_pool_rank(); }
+  KOKKOS_INLINE_FUNCTION static unsigned hardware_thread_id() {
+    return thread_pool_rank();
+  }
 
   static const char* name();
-private:
+
+ private:
   static bool m_is_initialized;
 };
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -157,19 +162,17 @@ private:
 namespace Kokkos {
 namespace Impl {
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::Experimental::OpenMPTarget::memory_space
-  , Kokkos::Experimental::OpenMPTarget::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::Experimental::OpenMPTarget::memory_space,
+    Kokkos::Experimental::OpenMPTarget::scratch_memory_space> {
   enum { value = true };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -182,5 +185,3 @@ struct VerifyExecutionCanAccessMemorySpace
 
 #endif /* #if defined( KOKKOS_ENABLE_OPENMPTARGET ) && defined( _OPENMP ) */
 #endif /* #ifndef KOKKOS_OPENMPTARGET_HPP */
-
-
diff --git a/lib/kokkos/core/src/Kokkos_OpenMPTargetSpace.hpp b/lib/kokkos/core/src/Kokkos_OpenMPTargetSpace.hpp
index abb0b8588d8a1630ecb05a5c19cd52572073c646..eef5893be5bf4ed8d3f53cef6f92c80815e487e6 100644
--- a/lib/kokkos/core/src/Kokkos_OpenMPTargetSpace.hpp
+++ b/lib/kokkos/core/src/Kokkos_OpenMPTargetSpace.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -66,14 +67,14 @@ namespace Impl {
 /// where the hash value is derived from the address of the
 /// object for which an atomic operation is performed.
 /// This function initializes the locks to zero (unset).
-//void init_lock_array_host_space();
+// void init_lock_array_host_space();
 
 /// \brief Acquire a lock for the address
 ///
 /// This function tries to acquire the lock for the hash value derived
 /// from the provided ptr. If the lock is successfully acquired the
 /// function returns true. Otherwise it returns false.
-//bool lock_address_host_space(void* ptr);
+// bool lock_address_host_space(void* ptr);
 
 /// \brief Release lock for the address
 ///
@@ -81,10 +82,10 @@ namespace Impl {
 /// from the provided ptr. This function should only be called
 /// after previously successfully acquiring a lock with
 /// lock_address.
-//void unlock_address_host_space(void* ptr);
+// void unlock_address_host_space(void* ptr);
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Experimental {
@@ -95,11 +96,10 @@ namespace Experimental {
 /// OpenMPTargetSpace is a memory space that governs host memory.  "Host"
 /// memory means the usual CPU-accessible memory.
 class OpenMPTargetSpace {
-public:
-
+ public:
   //! Tag this class as a kokkos memory space
-  typedef OpenMPTargetSpace  memory_space ;
-  typedef size_t     size_type ;
+  typedef OpenMPTargetSpace memory_space;
+  typedef size_t size_type;
 
   /// \typedef execution_space
   /// \brief Default execution space for this memory space.
@@ -107,34 +107,33 @@ public:
   /// Every memory space has a default execution space.  This is
   /// useful for things like initializing a View (which happens in
   /// parallel using the View's default execution space).
-  typedef Kokkos::Experimental::OpenMPTarget   execution_space ;
+  typedef Kokkos::Experimental::OpenMPTarget execution_space;
 
   //! This memory space preferred device_type
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
   /*--------------------------------*/
 
   /**\brief  Default memory space instance */
   OpenMPTargetSpace();
-  OpenMPTargetSpace( OpenMPTargetSpace && rhs ) = default ;
-  OpenMPTargetSpace( const OpenMPTargetSpace & rhs ) = default ;
-  OpenMPTargetSpace & operator = ( OpenMPTargetSpace && ) = default ;
-  OpenMPTargetSpace & operator = ( const OpenMPTargetSpace & ) = default ;
-  ~OpenMPTargetSpace() = default ;
+  OpenMPTargetSpace(OpenMPTargetSpace&& rhs)      = default;
+  OpenMPTargetSpace(const OpenMPTargetSpace& rhs) = default;
+  OpenMPTargetSpace& operator=(OpenMPTargetSpace&&) = default;
+  OpenMPTargetSpace& operator=(const OpenMPTargetSpace&) = default;
+  ~OpenMPTargetSpace()                                   = default;
 
   /**\brief  Allocate untracked memory in the space */
-  void * allocate( const size_t arg_alloc_size ) const ;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the space */
-  void deallocate( void * const arg_alloc_ptr 
-                 , const size_t arg_alloc_size ) const ;
-
-private:
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
-  friend class Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void > ;
+ private:
+  friend class Kokkos::Impl::SharedAllocationRecord<
+      Kokkos::Experimental::OpenMPTargetSpace, void>;
 };
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -142,70 +141,62 @@ private:
 namespace Kokkos {
 namespace Impl {
 
-template<>
-class SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >
-  : public SharedAllocationRecord< void , void >
-{
-private:
-
-  friend Kokkos::Experimental::OpenMPTargetSpace ;
+template <>
+class SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
+  friend Kokkos::Experimental::OpenMPTargetSpace;
 
-  typedef SharedAllocationRecord< void , void >  RecordBase ;
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static void deallocate( RecordBase * );
+  static void deallocate(RecordBase*);
 
-  /**\brief  Root record for tracked allocations from this OpenMPTargetSpace instance */
-  static RecordBase s_root_record ;
+  /**\brief  Root record for tracked allocations from this OpenMPTargetSpace
+   * instance */
+  static RecordBase s_root_record;
 
-  const Kokkos::Experimental::OpenMPTargetSpace m_space ;
-
-protected:
+  const Kokkos::Experimental::OpenMPTargetSpace m_space;
 
+ protected:
   ~SharedAllocationRecord();
-  SharedAllocationRecord() = default ;
-
-  SharedAllocationRecord( const Kokkos::Experimental::OpenMPTargetSpace        & arg_space
-                        , const std::string              & arg_label
-                        , const size_t                     arg_alloc_size
-                        , const RecordBase::function_type  arg_dealloc = & deallocate
-                        );
+  SharedAllocationRecord() = default;
 
-public:
+  SharedAllocationRecord(
+      const Kokkos::Experimental::OpenMPTargetSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
 
+ public:
   std::string get_label() const;
 
-  KOKKOS_INLINE_FUNCTION static
-  SharedAllocationRecord * allocate( const Kokkos::Experimental::OpenMPTargetSpace &  arg_space
-                                   , const std::string       &  arg_label
-                                   , const size_t               arg_alloc_size
-                                   );
+  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
+      const Kokkos::Experimental::OpenMPTargetSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size);
 
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::Experimental::OpenMPTargetSpace & arg_space
-                         , const std::string & arg_label
-                         , const size_t arg_alloc_size );
+  static void* allocate_tracked(
+      const Kokkos::Experimental::OpenMPTargetSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
-
+  static void deallocate_tracked(void* const arg_alloc_ptr);
 
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
 
-  static void print_records( std::ostream & , const Kokkos::Experimental::OpenMPTargetSpace & , bool detail = false );
+  static void print_records(std::ostream&,
+                            const Kokkos::Experimental::OpenMPTargetSpace&,
+                            bool detail = false);
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -213,53 +204,59 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-//TODO: implement all possible deep_copies
-template<class ExecutionSpace>
-struct DeepCopy<Kokkos::Experimental::OpenMPTargetSpace,Kokkos::Experimental::OpenMPTargetSpace,ExecutionSpace> {
-  DeepCopy( void * dst , const void * src , size_t n ) {
-    omp_target_memcpy( dst , const_cast<void*> (src) , n, 0, 0, omp_get_default_device(), omp_get_default_device());
+// TODO: implement all possible deep_copies
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::OpenMPTargetSpace,
+                Kokkos::Experimental::OpenMPTargetSpace, ExecutionSpace> {
+  DeepCopy(void* dst, const void* src, size_t n) {
+    omp_target_memcpy(dst, const_cast<void*>(src), n, 0, 0,
+                      omp_get_default_device(), omp_get_default_device());
   }
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n ) {
+  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence();
-    omp_target_memcpy( dst , const_cast<void*> (src) , n, 0, 0, omp_get_default_device(), omp_get_default_device());
+    omp_target_memcpy(dst, const_cast<void*>(src), n, 0, 0,
+                      omp_get_default_device(), omp_get_default_device());
   }
 };
 
-
-template<class ExecutionSpace>
-struct DeepCopy<Kokkos::Experimental::OpenMPTargetSpace,HostSpace,ExecutionSpace> {
-  DeepCopy( void * dst , const void * src , size_t n ) {
-    omp_target_memcpy( dst , const_cast<void*> (src) , n, 0, 0, omp_get_default_device(), omp_get_initial_device());
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::OpenMPTargetSpace, HostSpace,
+                ExecutionSpace> {
+  DeepCopy(void* dst, const void* src, size_t n) {
+    omp_target_memcpy(dst, const_cast<void*>(src), n, 0, 0,
+                      omp_get_default_device(), omp_get_initial_device());
   }
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n ) {
+  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence();
-    omp_target_memcpy( dst , const_cast<void*> (src) , n, 0, 0, omp_get_default_device(), omp_get_initial_device());
+    omp_target_memcpy(dst, const_cast<void*>(src), n, 0, 0,
+                      omp_get_default_device(), omp_get_initial_device());
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy<HostSpace,Kokkos::Experimental::OpenMPTargetSpace,ExecutionSpace> {
-  DeepCopy( void * dst , const void * src , size_t n ) {
-    omp_target_memcpy( dst , const_cast<void*> (src) , n, 0, 0, omp_get_initial_device(), omp_get_default_device());
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, Kokkos::Experimental::OpenMPTargetSpace,
+                ExecutionSpace> {
+  DeepCopy(void* dst, const void* src, size_t n) {
+    omp_target_memcpy(dst, const_cast<void*>(src), n, 0, 0,
+                      omp_get_initial_device(), omp_get_default_device());
   }
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n ) {
+  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence();
-    omp_target_memcpy( dst , const_cast<void*> (src) , n, 0, 0, omp_get_initial_device(), omp_get_default_device());
+    omp_target_memcpy(dst, const_cast<void*>(src), n, 0, 0,
+                      omp_get_initial_device(), omp_get_default_device());
   }
 };
 
-
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::Experimental::OpenMPTargetSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::HostSpace, Kokkos::Experimental::OpenMPTargetSpace> {
   enum { value = false };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
 #endif /* #define KOKKOS_OPENMPTARGETSPACE_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Pair.hpp b/lib/kokkos/core/src/Kokkos_Pair.hpp
index ab0ab8152a46f49422a785ea77c06bfd1bd83a79..ee9797b4b34f5ed8b1e60869fe55630248400876 100644
--- a/lib/kokkos/core/src/Kokkos_Pair.hpp
+++ b/lib/kokkos/core/src/Kokkos_Pair.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -61,15 +62,14 @@ namespace Kokkos {
 /// implements the same interface as std::pair, but can be used on a
 /// CUDA device as well as on the host.
 template <class T1, class T2>
-struct pair
-{
+struct pair {
   //! The first template parameter of this class.
   typedef T1 first_type;
   //! The second template parameter of this class.
   typedef T2 second_type;
 
   //! The first element of the pair.
-  first_type  first;
+  first_type first;
   //! The second element of the pair.
   second_type second;
 
@@ -80,54 +80,48 @@ struct pair
   /// public.
   KOKKOS_FORCEINLINE_FUNCTION constexpr
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
-  pair() : first(), second() {}
+      pair()
+      : first(), second() {
+  }
 #else
-  pair() = default;
+      pair() = default;
 #endif
 
   /// \brief Constructor that takes both elements of the pair.
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair(first_type const& f, second_type const& s)
-    : first(f), second(s)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(first_type const& f,
+                                             second_type const& s)
+      : first(f), second(s) {}
 
   /// \brief Copy constructor.
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair( const pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const pair<U, V>& p)
+      : first(p.first), second(p.second) {}
 
   /// \brief Copy constructor.
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair( const volatile pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const volatile pair<U, V>& p)
+      : first(p.first), second(p.second) {}
 
   /// \brief Assignment operator.
   ///
   /// This calls the assignment operators of T1 and T2.  It won't
   /// compile if the assignment operators are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION
-  pair<T1, T2> & operator=(const pair<U,V> &p)
-  {
-    first = p.first;
+  KOKKOS_FORCEINLINE_FUNCTION pair<T1, T2>& operator=(const pair<U, V>& p) {
+    first  = p.first;
     second = p.second;
     return *this;
   }
 
-
   /// \brief Assignment operator, for volatile <tt>*this</tt>.
   ///
   /// \param p [in] Input; right-hand side of the assignment.
@@ -140,10 +134,9 @@ struct pair
   /// practice, this means that you should not chain assignments with
   /// volatile lvalues.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION
-  void operator=(const volatile pair<U,V> &p) volatile
-  {
-    first = p.first;
+  KOKKOS_FORCEINLINE_FUNCTION void operator=(
+      const volatile pair<U, V>& p) volatile {
+    first  = p.first;
     second = p.second;
     // We deliberately do not return anything here.  See explanation
     // in public documentation above.
@@ -151,9 +144,7 @@ struct pair
 
   // from std::pair<U,V>
   template <class U, class V>
-  pair( const std::pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  pair(const std::pair<U, V>& p) : first(p.first), second(p.second) {}
 
   /// \brief Return the std::pair version of this object.
   ///
@@ -164,20 +155,20 @@ struct pair
   /// \note This is not a conversion operator, since defining a
   ///   conversion operator made the relational operators have
   ///   ambiguous definitions.
-  std::pair<T1,T2> to_std_pair() const
-  { return std::make_pair(first,second); }
+  std::pair<T1, T2> to_std_pair() const {
+    return std::make_pair(first, second);
+  }
 };
 
 template <class T1, class T2>
-struct pair<T1&, T2&>
-{
+struct pair<T1&, T2&> {
   //! The first template parameter of this class.
   typedef T1& first_type;
   //! The second template parameter of this class.
   typedef T2& second_type;
 
   //! The first element of the pair.
-  first_type  first;
+  first_type first;
   //! The second element of the pair.
   second_type second;
 
@@ -185,36 +176,29 @@ struct pair<T1&, T2&>
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair(first_type f, second_type s)
-    : first(f), second(s)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(first_type f, second_type s)
+      : first(f), second(s) {}
 
   /// \brief Copy constructor.
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair( const pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const pair<U, V>& p)
+      : first(p.first), second(p.second) {}
 
   // from std::pair<U,V>
   template <class U, class V>
-  pair( const std::pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  pair(const std::pair<U, V>& p) : first(p.first), second(p.second) {}
 
   /// \brief Assignment operator.
   ///
   /// This calls the assignment operators of T1 and T2.  It won't
   /// compile if the assignment operators are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION
-  pair<first_type, second_type> & operator=(const pair<U,V> &p)
-  {
-    first = p.first;
+  KOKKOS_FORCEINLINE_FUNCTION pair<first_type, second_type>& operator=(
+      const pair<U, V>& p) {
+    first  = p.first;
     second = p.second;
     return *this;
   }
@@ -228,20 +212,20 @@ struct pair<T1&, T2&>
   /// \note This is not a conversion operator, since defining a
   ///   conversion operator made the relational operators have
   ///   ambiguous definitions.
-  std::pair<T1,T2> to_std_pair() const
-  { return std::make_pair(first,second); }
+  std::pair<T1, T2> to_std_pair() const {
+    return std::make_pair(first, second);
+  }
 };
 
 template <class T1, class T2>
-struct pair<T1, T2&>
-{
+struct pair<T1, T2&> {
   //! The first template parameter of this class.
-  typedef T1  first_type;
+  typedef T1 first_type;
   //! The second template parameter of this class.
   typedef T2& second_type;
 
   //! The first element of the pair.
-  first_type  first;
+  first_type first;
   //! The second element of the pair.
   second_type second;
 
@@ -249,36 +233,29 @@ struct pair<T1, T2&>
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair(first_type const& f, second_type s)
-    : first(f), second(s)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(first_type const& f, second_type s)
+      : first(f), second(s) {}
 
   /// \brief Copy constructor.
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair( const pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const pair<U, V>& p)
+      : first(p.first), second(p.second) {}
 
   // from std::pair<U,V>
   template <class U, class V>
-  pair( const std::pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  pair(const std::pair<U, V>& p) : first(p.first), second(p.second) {}
 
   /// \brief Assignment operator.
   ///
   /// This calls the assignment operators of T1 and T2.  It won't
   /// compile if the assignment operators are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION
-  pair<first_type, second_type> & operator=(const pair<U,V> &p)
-  {
-    first = p.first;
+  KOKKOS_FORCEINLINE_FUNCTION pair<first_type, second_type>& operator=(
+      const pair<U, V>& p) {
+    first  = p.first;
     second = p.second;
     return *this;
   }
@@ -292,20 +269,20 @@ struct pair<T1, T2&>
   /// \note This is not a conversion operator, since defining a
   ///   conversion operator made the relational operators have
   ///   ambiguous definitions.
-  std::pair<T1,T2> to_std_pair() const
-  { return std::make_pair(first,second); }
+  std::pair<T1, T2> to_std_pair() const {
+    return std::make_pair(first, second);
+  }
 };
 
 template <class T1, class T2>
-struct pair<T1&, T2>
-{
+struct pair<T1&, T2> {
   //! The first template parameter of this class.
-  typedef T1&  first_type;
+  typedef T1& first_type;
   //! The second template parameter of this class.
   typedef T2 second_type;
 
   //! The first element of the pair.
-  first_type  first;
+  first_type first;
   //! The second element of the pair.
   second_type second;
 
@@ -313,36 +290,29 @@ struct pair<T1&, T2>
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair(first_type f, second_type const& s)
-    : first(f), second(s)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(first_type f, second_type const& s)
+      : first(f), second(s) {}
 
   /// \brief Copy constructor.
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair( const pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const pair<U, V>& p)
+      : first(p.first), second(p.second) {}
 
   // from std::pair<U,V>
   template <class U, class V>
-  pair( const std::pair<U,V> &p)
-    : first(p.first), second(p.second)
-  {}
+  pair(const std::pair<U, V>& p) : first(p.first), second(p.second) {}
 
   /// \brief Assignment operator.
   ///
   /// This calls the assignment operators of T1 and T2.  It won't
   /// compile if the assignment operators are not defined and public.
   template <class U, class V>
-  KOKKOS_FORCEINLINE_FUNCTION
-  pair<first_type, second_type> & operator=(const pair<U,V> &p)
-  {
-    first = p.first;
+  KOKKOS_FORCEINLINE_FUNCTION pair<first_type, second_type>& operator=(
+      const pair<U, V>& p) {
+    first  = p.first;
     second = p.second;
     return *this;
   }
@@ -356,54 +326,62 @@ struct pair<T1&, T2>
   /// \note This is not a conversion operator, since defining a
   ///   conversion operator made the relational operators have
   ///   ambiguous definitions.
-  std::pair<T1,T2> to_std_pair() const
-  { return std::make_pair(first,second); }
+  std::pair<T1, T2> to_std_pair() const {
+    return std::make_pair(first, second);
+  }
 };
 
 //! Equality operator for Kokkos::pair.
 template <class T1, class T2>
-KOKKOS_FORCEINLINE_FUNCTION
-bool operator== (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
-{ return lhs.first==rhs.first && lhs.second==rhs.second; }
+KOKKOS_FORCEINLINE_FUNCTION bool operator==(const pair<T1, T2>& lhs,
+                                            const pair<T1, T2>& rhs) {
+  return lhs.first == rhs.first && lhs.second == rhs.second;
+}
 
 //! Inequality operator for Kokkos::pair.
 template <class T1, class T2>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator!= (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
-{ return !(lhs==rhs); }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator!=(const pair<T1, T2>& lhs,
+                                                      const pair<T1, T2>& rhs) {
+  return !(lhs == rhs);
+}
 
 //! Less-than operator for Kokkos::pair.
 template <class T1, class T2>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator<  (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
-{ return lhs.first<rhs.first || (!(rhs.first<lhs.first) && lhs.second<rhs.second); }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<(const pair<T1, T2>& lhs,
+                                                     const pair<T1, T2>& rhs) {
+  return lhs.first < rhs.first ||
+         (!(rhs.first < lhs.first) && lhs.second < rhs.second);
+}
 
 //! Less-than-or-equal-to operator for Kokkos::pair.
 template <class T1, class T2>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator<= (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
-{ return !(rhs<lhs); }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<=(const pair<T1, T2>& lhs,
+                                                      const pair<T1, T2>& rhs) {
+  return !(rhs < lhs);
+}
 
 //! Greater-than operator for Kokkos::pair.
 template <class T1, class T2>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator>  (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
-{ return rhs<lhs; }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>(const pair<T1, T2>& lhs,
+                                                     const pair<T1, T2>& rhs) {
+  return rhs < lhs;
+}
 
 //! Greater-than-or-equal-to operator for Kokkos::pair.
 template <class T1, class T2>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator>= (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
-{ return !(lhs<rhs); }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>=(const pair<T1, T2>& lhs,
+                                                      const pair<T1, T2>& rhs) {
+  return !(lhs < rhs);
+}
 
 /// \brief Return a new pair.
 ///
 /// This is a "nonmember constructor" for Kokkos::pair.  It works just
 /// like std::make_pair.
-template <class T1,class T2>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-pair<T1,T2> make_pair (T1 x, T2 y)
-{ return ( pair<T1,T2>(x,y) ); }
+template <class T1, class T2>
+KOKKOS_FORCEINLINE_FUNCTION constexpr pair<T1, T2> make_pair(T1 x, T2 y) {
+  return (pair<T1, T2>(x, y));
+}
 
 /// \brief Return a pair of references to the input arguments.
 ///
@@ -444,51 +422,44 @@ pair<T1,T2> make_pair (T1 x, T2 y)
 /// element of the pair.  The latter could be significant if one or
 /// both elements of the pair are more substantial objects than \c int
 /// or \c bool.
-template <class T1,class T2>
-KOKKOS_FORCEINLINE_FUNCTION
-pair<T1 &,T2 &> tie (T1 & x, T2 & y)
-{ return ( pair<T1 &,T2 &>(x,y) ); }
+template <class T1, class T2>
+KOKKOS_FORCEINLINE_FUNCTION pair<T1&, T2&> tie(T1& x, T2& y) {
+  return (pair<T1&, T2&>(x, y));
+}
 
 //
 // Specialization of Kokkos::pair for a \c void second argument.  This
 // is not actually a "pair"; it only contains one element, the first.
 //
 template <class T1>
-struct pair<T1,void>
-{
+struct pair<T1, void> {
   typedef T1 first_type;
   typedef void second_type;
 
-  first_type  first;
+  first_type first;
   enum { second = 0 };
 
   KOKKOS_FORCEINLINE_FUNCTION constexpr
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
-  pair() : first() {}
+      pair()
+      : first() {
+  }
 #else
-  pair() = default;
+      pair() = default;
 #endif
 
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair(const first_type & f)
-    : first(f)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const first_type& f) : first(f) {}
 
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair(const first_type & f, int)
-    : first(f)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const first_type& f, int)
+      : first(f) {}
 
   template <class U>
-  KOKKOS_FORCEINLINE_FUNCTION constexpr
-  pair( const pair<U,void> &p)
-    : first(p.first)
-  {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr pair(const pair<U, void>& p)
+      : first(p.first) {}
 
   template <class U>
-  KOKKOS_FORCEINLINE_FUNCTION
-  pair<T1, void> & operator=(const pair<U,void> &p)
-  {
+  KOKKOS_FORCEINLINE_FUNCTION pair<T1, void>& operator=(
+      const pair<U, void>& p) {
     first = p.first;
     return *this;
   }
@@ -499,46 +470,52 @@ struct pair<T1,void>
 //
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator== (const pair<T1,void>& lhs, const pair<T1,void>& rhs)
-{ return lhs.first==rhs.first; }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator==(
+    const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
+  return lhs.first == rhs.first;
+}
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator!= (const pair<T1,void>& lhs, const pair<T1,void>& rhs)
-{ return !(lhs==rhs); }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator!=(
+    const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
+  return !(lhs == rhs);
+}
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator<  (const pair<T1,void>& lhs, const pair<T1,void>& rhs)
-{ return lhs.first<rhs.first; }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<(
+    const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
+  return lhs.first < rhs.first;
+}
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator<= (const pair<T1,void>& lhs, const pair<T1,void>& rhs)
-{ return !(rhs<lhs); }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<=(
+    const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
+  return !(rhs < lhs);
+}
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator>  (const pair<T1,void>& lhs, const pair<T1,void>& rhs)
-{ return rhs<lhs; }
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>(
+    const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
+  return rhs < lhs;
+}
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr
-bool operator>= (const pair<T1,void>& lhs, const pair<T1,void>& rhs)
-{ return !(lhs<rhs); }
-
+KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>=(
+    const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
+  return !(lhs < rhs);
+}
 
 namespace Impl {
 
-template <class T> struct is_pair_like : std::false_type { };
-template <class T, class U> struct is_pair_like<Kokkos::pair<T, U>> : std::true_type { };
-template <class T, class U> struct is_pair_like<std::pair<T, U>> : std::true_type { };
-
-} // end namespace Impl
-
-} // namespace Kokkos
+template <class T>
+struct is_pair_like : std::false_type {};
+template <class T, class U>
+struct is_pair_like<Kokkos::pair<T, U>> : std::true_type {};
+template <class T, class U>
+struct is_pair_like<std::pair<T, U>> : std::true_type {};
 
+}  // end namespace Impl
 
-#endif //KOKKOS_PAIR_HPP
+}  // namespace Kokkos
 
+#endif  // KOKKOS_PAIR_HPP
diff --git a/lib/kokkos/core/src/Kokkos_Parallel.hpp b/lib/kokkos/core/src/Kokkos_Parallel.hpp
index 09dcf60b111aaa6a907f801437adc43d4072f576..7277ce287a17df96799d734eddb57c01fc746435 100644
--- a/lib/kokkos/core/src/Kokkos_Parallel.hpp
+++ b/lib/kokkos/core/src/Kokkos_Parallel.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -63,7 +64,7 @@
 #include <impl/Kokkos_FunctorAdapter.hpp>
 
 #ifdef KOKKOS_DEBUG
-#include<iostream>
+#include <iostream>
 #endif
 
 //----------------------------------------------------------------------------
@@ -80,67 +81,52 @@ namespace Impl {
  *  else if  the Functor has a device_type use that for backward compatibility
  *  else     use the default
  */
-template< class Functor
-        , class Policy
-        , class EnableFunctor
-        , class EnablePolicy
-        >
+template <class Functor, class Policy, class EnableFunctor, class EnablePolicy>
 struct FunctorPolicyExecutionSpace {
-  typedef Kokkos::DefaultExecutionSpace execution_space ;
+  typedef Kokkos::DefaultExecutionSpace execution_space;
 };
 
-template< class Functor , class Policy >
-struct FunctorPolicyExecutionSpace
-  < Functor , Policy
-  , typename enable_if_type< typename Functor::device_type     >::type
-  , typename enable_if_type< typename Policy ::execution_space >::type
-  >
-{
-  typedef typename Policy ::execution_space execution_space ;
+template <class Functor, class Policy>
+struct FunctorPolicyExecutionSpace<
+    Functor, Policy,
+    typename enable_if_type<typename Functor::device_type>::type,
+    typename enable_if_type<typename Policy ::execution_space>::type> {
+  typedef typename Policy ::execution_space execution_space;
 };
 
-template< class Functor , class Policy >
-struct FunctorPolicyExecutionSpace
-  < Functor , Policy
-  , typename enable_if_type< typename Functor::execution_space >::type
-  , typename enable_if_type< typename Policy ::execution_space >::type
-  >
-{
-  typedef typename Policy ::execution_space execution_space ;
+template <class Functor, class Policy>
+struct FunctorPolicyExecutionSpace<
+    Functor, Policy,
+    typename enable_if_type<typename Functor::execution_space>::type,
+    typename enable_if_type<typename Policy ::execution_space>::type> {
+  typedef typename Policy ::execution_space execution_space;
 };
 
-template< class Functor , class Policy , class EnableFunctor >
-struct FunctorPolicyExecutionSpace
-  < Functor , Policy
-  , EnableFunctor
-  , typename enable_if_type< typename Policy::execution_space >::type
-  >
-{
-  typedef typename Policy ::execution_space execution_space ;
+template <class Functor, class Policy, class EnableFunctor>
+struct FunctorPolicyExecutionSpace<
+    Functor, Policy, EnableFunctor,
+    typename enable_if_type<typename Policy::execution_space>::type> {
+  typedef typename Policy ::execution_space execution_space;
 };
 
-template< class Functor , class Policy , class EnablePolicy >
-struct FunctorPolicyExecutionSpace
-  < Functor , Policy
-  , typename enable_if_type< typename Functor::device_type >::type
-  , EnablePolicy
-  >
-{
-  typedef typename Functor::device_type execution_space ;
+template <class Functor, class Policy, class EnablePolicy>
+struct FunctorPolicyExecutionSpace<
+    Functor, Policy,
+    typename enable_if_type<typename Functor::device_type>::type,
+    EnablePolicy> {
+  typedef typename Functor::device_type execution_space;
 };
 
-template< class Functor , class Policy , class EnablePolicy >
-struct FunctorPolicyExecutionSpace
-  < Functor , Policy
-  , typename enable_if_type< typename Functor::execution_space >::type
-  , EnablePolicy
-  >
-{
-  typedef typename Functor::execution_space execution_space ;
+template <class Functor, class Policy, class EnablePolicy>
+struct FunctorPolicyExecutionSpace<
+    Functor, Policy,
+    typename enable_if_type<typename Functor::execution_space>::type,
+    EnablePolicy> {
+  typedef typename Functor::execution_space execution_space;
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -168,89 +154,82 @@ namespace Kokkos {
  * This compares to a single iteration \c iwork of a \c for loop.
  * If \c execution_space is not defined DefaultExecutionSpace will be used.
  */
-template< class ExecPolicy , class FunctorType >
-inline
-void parallel_for( const ExecPolicy  & policy
-                 , const FunctorType & functor
-                 , const std::string& str = ""
-                 , typename Impl::enable_if< Kokkos::Impl::is_execution_policy< ExecPolicy >::value >::type * = 0
-                 )
-{
+template <class ExecPolicy, class FunctorType>
+inline void parallel_for(
+    const ExecPolicy& policy, const FunctorType& functor,
+    const std::string& str = "",
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<ExecPolicy>::value>::type* = 0) {
 #if defined(KOKKOS_ENABLE_PROFILING)
   uint64_t kpID = 0;
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Impl::ParallelConstructName<FunctorType, typename ExecPolicy::work_tag> name(str);
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Impl::ParallelConstructName<FunctorType,
+                                        typename ExecPolicy::work_tag>
+        name(str);
     Kokkos::Profiling::beginParallelFor(name.get(), 0, &kpID);
   }
 #endif
 
-    Kokkos::Impl::shared_allocation_tracking_disable();
-    Impl::ParallelFor< FunctorType , ExecPolicy > closure( functor , policy );
-    Kokkos::Impl::shared_allocation_tracking_enable();
+  Kokkos::Impl::shared_allocation_tracking_disable();
+  Impl::ParallelFor<FunctorType, ExecPolicy> closure(functor, policy);
+  Kokkos::Impl::shared_allocation_tracking_enable();
 
-   closure.execute();
+  closure.execute();
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::endParallelFor(kpID);
   }
 #endif
 }
 
-template< class FunctorType >
-inline
-void parallel_for( const size_t        work_count
-                 , const FunctorType & functor
-                 , const std::string& str = ""
-                 )
-{
-  typedef typename
-    Impl::FunctorPolicyExecutionSpace< FunctorType , void >::execution_space
-      execution_space ;
-  typedef RangePolicy< execution_space > policy ;
+template <class FunctorType>
+inline void parallel_for(const size_t work_count, const FunctorType& functor,
+                         const std::string& str = "") {
+  typedef typename Impl::FunctorPolicyExecutionSpace<
+      FunctorType, void>::execution_space execution_space;
+  typedef RangePolicy<execution_space> policy;
 
 #if defined(KOKKOS_ENABLE_PROFILING)
   uint64_t kpID = 0;
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Impl::ParallelConstructName<FunctorType, void> name(str);
     Kokkos::Profiling::beginParallelFor(name.get(), 0, &kpID);
   }
 #endif
 
   Kokkos::Impl::shared_allocation_tracking_disable();
-  Impl::ParallelFor< FunctorType , policy > closure( functor , policy(0,work_count) );
+  Impl::ParallelFor<FunctorType, policy> closure(functor,
+                                                 policy(0, work_count));
   Kokkos::Impl::shared_allocation_tracking_enable();
 
   closure.execute();
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-     if(Kokkos::Profiling::profileLibraryLoaded()) {
-	Kokkos::Profiling::endParallelFor(kpID);
-     }
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::endParallelFor(kpID);
+  }
 #endif
 }
 
-template< class ExecPolicy , class FunctorType >
-inline
-void parallel_for( const std::string & str
-                 , const ExecPolicy  & policy
-                 , const FunctorType & functor )
-{
-  #if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
+template <class ExecPolicy, class FunctorType>
+inline void parallel_for(const std::string& str, const ExecPolicy& policy,
+                         const FunctorType& functor) {
+#if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
   Kokkos::fence();
   std::cout << "KOKKOS_DEBUG Start parallel_for kernel: " << str << std::endl;
-  #endif
+#endif
 
-  ::Kokkos::parallel_for(policy,functor,str);
+  ::Kokkos::parallel_for(policy, functor, str);
 
-  #if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
+#if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
   Kokkos::fence();
   std::cout << "KOKKOS_DEBUG End   parallel_for kernel: " << str << std::endl;
-  #endif
-  (void) str;
+#endif
+  (void)str;
 }
 
-}
+}  // namespace Kokkos
 
 #include <Kokkos_Parallel_Reduce.hpp>
 //----------------------------------------------------------------------------
@@ -291,9 +270,9 @@ namespace Kokkos {
 ///   // operator() or join().
 ///   typedef PodType value_type;
 ///
-///   void operator () (const ExecPolicy::member_type & i, value_type& update, const bool final_pass) const;
-///   void init (value_type& update) const;
-///   void join (volatile value_type& update, volatile const value_type& input) const
+///   void operator () (const ExecPolicy::member_type & i, value_type& update,
+///   const bool final_pass) const; void init (value_type& update) const; void
+///   join (volatile value_type& update, volatile const value_type& input) const
 /// };
 /// \endcode
 ///
@@ -310,9 +289,11 @@ namespace Kokkos {
 ///   typedef typename SpaceType::size_type size_type;
 ///
 ///   InclScanFunctor( Kokkos::View<value_type*, execution_space> x
-///                  , Kokkos::View<value_type*, execution_space> y ) : m_x(x), m_y(y) {}
+///                  , Kokkos::View<value_type*, execution_space> y ) : m_x(x),
+///                  m_y(y) {}
 ///
-///   void operator () (const size_type i, value_type& update, const bool final_pass) const {
+///   void operator () (const size_type i, value_type& update, const bool
+///   final_pass) const {
 ///     update += m_x(i);
 ///     if (final_pass) {
 ///       m_y(i) = update;
@@ -321,7 +302,8 @@ namespace Kokkos {
 ///   void init (value_type& update) const {
 ///     update = 0;
 ///   }
-///   void join (volatile value_type& update, volatile const value_type& input) const {
+///   void join (volatile value_type& update, volatile const value_type& input)
+///   const {
 ///     update += input;
 ///   }
 ///
@@ -347,7 +329,8 @@ namespace Kokkos {
 ///
 ///   ExclScanFunctor (Kokkos::View<value_type*, execution_space> x) : x_ (x) {}
 ///
-///   void operator () (const size_type i, value_type& update, const bool final_pass) const {
+///   void operator () (const size_type i, value_type& update, const bool
+///   final_pass) const {
 ///     const value_type x_i = x_(i);
 ///     if (final_pass) {
 ///       x_(i) = update;
@@ -357,7 +340,8 @@ namespace Kokkos {
 ///   void init (value_type& update) const {
 ///     update = 0;
 ///   }
-///   void join (volatile value_type& update, volatile const value_type& input) const {
+///   void join (volatile value_type& update, volatile const value_type& input)
+///   const {
 ///     update += input;
 ///   }
 ///
@@ -385,10 +369,12 @@ namespace Kokkos {
 ///   // If x has length zero, then lastIndex_ won't be used anyway.
 ///   OffsetScanFunctor( Kokkos::View<value_type*, execution_space> x
 ///                    , Kokkos::View<value_type*, execution_space> y )
-///      : m_x(x), m_y(y), last_index_ (x.dimension_0 () == 0 ? 0 : x.dimension_0 () - 1)
+///      : m_x(x), m_y(y), last_index_ (x.dimension_0 () == 0 ? 0 :
+///      x.dimension_0 () - 1)
 ///   {}
 ///
-///   void operator () (const size_type i, int& update, const bool final_pass) const {
+///   void operator () (const size_type i, int& update, const bool final_pass)
+///   const {
 ///     if (final_pass) {
 ///       m_y(i) = update;
 ///     }
@@ -396,12 +382,13 @@ namespace Kokkos {
 ///     // The last entry of m_y gets the final sum.
 ///     if (final_pass && i == last_index_) {
 ///       m_y(i+1) = update;
-//i/     }
+// i/     }
 ///   }
 ///   void init (value_type& update) const {
 ///     update = 0;
 ///   }
-///   void join (volatile value_type& update, volatile const value_type& input) const {
+///   void join (volatile value_type& update, volatile const value_type& input)
+///   const {
 ///     update += input;
 ///   }
 ///
@@ -412,181 +399,164 @@ namespace Kokkos {
 /// };
 /// \endcode
 ///
-template< class ExecutionPolicy , class FunctorType >
-inline
-void parallel_scan( const ExecutionPolicy & policy
-                  , const FunctorType     & functor
-                  , const std::string& str = ""
-                  , typename Impl::enable_if< Kokkos::Impl::is_execution_policy< ExecutionPolicy >::value >::type * = 0
-                  )
-{
+template <class ExecutionPolicy, class FunctorType>
+inline void parallel_scan(
+    const ExecutionPolicy& policy, const FunctorType& functor,
+    const std::string& str = "",
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<ExecutionPolicy>::value>::type* = 0) {
 #if defined(KOKKOS_ENABLE_PROFILING)
   uint64_t kpID = 0;
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Impl::ParallelConstructName<FunctorType, typename ExecutionPolicy::work_tag> name(str);
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Impl::ParallelConstructName<FunctorType,
+                                        typename ExecutionPolicy::work_tag>
+        name(str);
     Kokkos::Profiling::beginParallelScan(name.get(), 0, &kpID);
   }
 #endif
 
   Kokkos::Impl::shared_allocation_tracking_disable();
-  Impl::ParallelScan< FunctorType , ExecutionPolicy > closure( functor , policy );
+  Impl::ParallelScan<FunctorType, ExecutionPolicy> closure(functor, policy);
   Kokkos::Impl::shared_allocation_tracking_enable();
-  
+
   closure.execute();
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::endParallelScan(kpID);
   }
 #endif
-
 }
 
-template< class FunctorType >
-inline
-void parallel_scan( const size_t        work_count
-                  , const FunctorType & functor
-                  , const std::string& str = "" )
-{
-  typedef typename
-    Kokkos::Impl::FunctorPolicyExecutionSpace< FunctorType , void >::execution_space
-      execution_space ;
+template <class FunctorType>
+inline void parallel_scan(const size_t work_count, const FunctorType& functor,
+                          const std::string& str = "") {
+  typedef typename Kokkos::Impl::FunctorPolicyExecutionSpace<
+      FunctorType, void>::execution_space execution_space;
 
-  typedef Kokkos::RangePolicy< execution_space > policy ;
+  typedef Kokkos::RangePolicy<execution_space> policy;
 
 #if defined(KOKKOS_ENABLE_PROFILING)
   uint64_t kpID = 0;
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Impl::ParallelConstructName<FunctorType, void> name(str);
     Kokkos::Profiling::beginParallelScan(name.get(), 0, &kpID);
   }
 #endif
 
   Kokkos::Impl::shared_allocation_tracking_disable();
-  Impl::ParallelScan< FunctorType , policy > closure( functor , policy(0,work_count) );
+  Impl::ParallelScan<FunctorType, policy> closure(functor,
+                                                  policy(0, work_count));
   Kokkos::Impl::shared_allocation_tracking_enable();
-  
+
   closure.execute();
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::endParallelScan(kpID);
   }
 #endif
-
 }
 
-template< class ExecutionPolicy , class FunctorType >
-inline
-void parallel_scan( const std::string& str
-                  , const ExecutionPolicy & policy
-                  , const FunctorType     & functor)
-{
-  #if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
+template <class ExecutionPolicy, class FunctorType>
+inline void parallel_scan(const std::string& str, const ExecutionPolicy& policy,
+                          const FunctorType& functor) {
+#if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
   Kokkos::fence();
   std::cout << "KOKKOS_DEBUG Start parallel_scan kernel: " << str << std::endl;
-  #endif
-  
-  ::Kokkos::parallel_scan(policy,functor,str);
+#endif
+
+  ::Kokkos::parallel_scan(policy, functor, str);
 
-  #if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
+#if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
   Kokkos::fence();
   std::cout << "KOKKOS_DEBUG End parallel_scan kernel: " << str << std::endl;
-  #endif
-  (void) str;
+#endif
+  (void)str;
 }
 
-
-template< class ExecutionPolicy , class FunctorType, class ReturnType >
-inline
-void parallel_scan( const ExecutionPolicy & policy
-                  , const FunctorType     & functor
-                  , ReturnType            & return_value
-                  , const std::string& str = ""
-                  , typename Impl::enable_if< Kokkos::Impl::is_execution_policy< ExecutionPolicy >::value >::type * = 0
-                  )
-{
+template <class ExecutionPolicy, class FunctorType, class ReturnType>
+inline void parallel_scan(
+    const ExecutionPolicy& policy, const FunctorType& functor,
+    ReturnType& return_value, const std::string& str = "",
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<ExecutionPolicy>::value>::type* = 0) {
 #if defined(KOKKOS_ENABLE_PROFILING)
   uint64_t kpID = 0;
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Impl::ParallelConstructName<FunctorType, typename ExecutionPolicy::work_tag> name(str);
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Impl::ParallelConstructName<FunctorType,
+                                        typename ExecutionPolicy::work_tag>
+        name(str);
     Kokkos::Profiling::beginParallelScan(name.get(), 0, &kpID);
   }
 #endif
 
   Kokkos::Impl::shared_allocation_tracking_disable();
-  Impl::ParallelScanWithTotal< FunctorType , ExecutionPolicy, ReturnType > closure( functor, policy, return_value );
+  Impl::ParallelScanWithTotal<FunctorType, ExecutionPolicy, ReturnType> closure(
+      functor, policy, return_value);
   Kokkos::Impl::shared_allocation_tracking_enable();
-  
+
   closure.execute();
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::endParallelScan(kpID);
   }
 #endif
   Kokkos::fence();
 }
 
-template< class FunctorType, class ReturnType >
-inline
-void parallel_scan( const size_t        work_count
-                  , const FunctorType & functor
-                  , ReturnType        & return_value
-                  , const std::string & str = "" )
-{
-  typedef typename
-    Kokkos::Impl::FunctorPolicyExecutionSpace< FunctorType , void >::execution_space
-      execution_space ;
+template <class FunctorType, class ReturnType>
+inline void parallel_scan(const size_t work_count, const FunctorType& functor,
+                          ReturnType& return_value,
+                          const std::string& str = "") {
+  typedef typename Kokkos::Impl::FunctorPolicyExecutionSpace<
+      FunctorType, void>::execution_space execution_space;
 
-  typedef Kokkos::RangePolicy< execution_space > policy ;
+  typedef Kokkos::RangePolicy<execution_space> policy;
 
 #if defined(KOKKOS_ENABLE_PROFILING)
   uint64_t kpID = 0;
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Impl::ParallelConstructName<FunctorType, void> name(str);
     Kokkos::Profiling::beginParallelScan(name.get(), 0, &kpID);
   }
 #endif
 
   Kokkos::Impl::shared_allocation_tracking_disable();
-  Impl::ParallelScanWithTotal< FunctorType, policy, ReturnType > closure( functor, policy(0,work_count), return_value );
+  Impl::ParallelScanWithTotal<FunctorType, policy, ReturnType> closure(
+      functor, policy(0, work_count), return_value);
   Kokkos::Impl::shared_allocation_tracking_enable();
- 
+
   closure.execute();
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::endParallelScan(kpID);
   }
 #endif
   Kokkos::fence();
 }
 
-template< class ExecutionPolicy, class FunctorType, class ReturnType >
-inline
-void parallel_scan( const std::string& str
-                  , const ExecutionPolicy & policy
-                  , const FunctorType     & functor
-                  , ReturnType            & return_value)
-{
-  #if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
+template <class ExecutionPolicy, class FunctorType, class ReturnType>
+inline void parallel_scan(const std::string& str, const ExecutionPolicy& policy,
+                          const FunctorType& functor,
+                          ReturnType& return_value) {
+#if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
   Kokkos::fence();
   std::cout << "KOKKOS_DEBUG Start parallel_scan kernel: " << str << std::endl;
-  #endif
-  
-  ::Kokkos::parallel_scan(policy,functor,return_value,str);
+#endif
+
+  ::Kokkos::parallel_scan(policy, functor, return_value, str);
 
-  #if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
+#if KOKKOS_ENABLE_DEBUG_PRINT_KERNEL_NAMES
   Kokkos::fence();
   std::cout << "KOKKOS_DEBUG End parallel_scan kernel: " << str << std::endl;
-  #endif
-  (void) str;
+#endif
+  (void)str;
 }
 
-
-
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -594,29 +564,35 @@ void parallel_scan( const std::string& str
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class Enable = void >
-struct FunctorTeamShmemSize
-{
-  KOKKOS_INLINE_FUNCTION static size_t value( const FunctorType & , int ) { return 0 ; }
+template <class FunctorType, class Enable = void>
+struct FunctorTeamShmemSize {
+  KOKKOS_INLINE_FUNCTION static size_t value(const FunctorType&, int) {
+    return 0;
+  }
 };
 
-template< class FunctorType >
-struct FunctorTeamShmemSize< FunctorType , typename Impl::enable_if< 0 < sizeof( & FunctorType::team_shmem_size ) >::type >
-{
-  static inline size_t value( const FunctorType & f , int team_size ) { return f.team_shmem_size( team_size ) ; }
+template <class FunctorType>
+struct FunctorTeamShmemSize<
+    FunctorType,
+    typename Impl::enable_if<0 < sizeof(&FunctorType::team_shmem_size)>::type> {
+  static inline size_t value(const FunctorType& f, int team_size) {
+    return f.team_shmem_size(team_size);
+  }
 };
 
-template< class FunctorType >
-struct FunctorTeamShmemSize< FunctorType , typename Impl::enable_if< 0 < sizeof( & FunctorType::shmem_size ) >::type >
-{
-  static inline size_t value( const FunctorType & f , int team_size ) { return f.shmem_size( team_size ) ; }
+template <class FunctorType>
+struct FunctorTeamShmemSize<
+    FunctorType,
+    typename Impl::enable_if<0 < sizeof(&FunctorType::shmem_size)>::type> {
+  static inline size_t value(const FunctorType& f, int team_size) {
+    return f.shmem_size(team_size);
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* KOKKOS_PARALLEL_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Parallel_Reduce.hpp b/lib/kokkos/core/src/Kokkos_Parallel_Reduce.hpp
index 0e02c468e49bf82dedc75cdaf5aa34f89e0d3eda..dbd33860fbc32a744a50c81970626eff61b594e7 100644
--- a/lib/kokkos/core/src/Kokkos_Parallel_Reduce.hpp
+++ b/lib/kokkos/core/src/Kokkos_Parallel_Reduce.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,46 +49,43 @@
 
 namespace Kokkos {
 
-template<class T, class Enable = void>
+template <class T, class Enable = void>
 struct is_reducer_type {
   enum { value = 0 };
 };
 
-
-template<class T>
-struct is_reducer_type<T,typename std::enable_if<
-                       std::is_same<typename std::remove_cv<T>::type,
-                                    typename std::remove_cv<typename T::reducer>::type>::value
-                      >::type> {
+template <class T>
+struct is_reducer_type<
+    T, typename std::enable_if<std::is_same<
+           typename std::remove_cv<T>::type,
+           typename std::remove_cv<typename T::reducer>::type>::value>::type> {
   enum { value = 1 };
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct Sum {
-public:
-  //Required
+ public:
+  // Required
   typedef Sum reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  Sum(value_type& value_): value(&value_),references_scalar_v(true) {}
+  Sum(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  Sum(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  Sum(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    dest += src;
-  }
+  void join(value_type& dest, const value_type& src) const { dest += src; }
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
@@ -95,52 +93,44 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::sum();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct Prod {
-public:
-  //Required
+ public:
+  // Required
   typedef Prod reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  Prod(value_type& value_): value(&value_),references_scalar_v(true) {}
+  Prod(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  Prod(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  Prod(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    dest *= src;
-  }
+  void join(value_type& dest, const value_type& src) const { dest *= src; }
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
@@ -148,160 +138,138 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::prod();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct Min {
-public:
-  //Required
+ public:
+  // Required
   typedef Min reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  Min(value_type& value_): value(&value_),references_scalar_v(true) {}
+  Min(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  Min(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  Min(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    if ( src < dest )
-      dest = src;
+  void join(value_type& dest, const value_type& src) const {
+    if (src < dest) dest = src;
   }
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
-    if ( src < dest )
-      dest = src;
+    if (src < dest) dest = src;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::min();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct Max {
-public:
-  //Required
+ public:
+  // Required
   typedef Max reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  Max(value_type& value_): value(&value_),references_scalar_v(true) {}
+  Max(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  Max(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  Max(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    if ( src > dest )
-      dest = src;
+  void join(value_type& dest, const value_type& src) const {
+    if (src > dest) dest = src;
   }
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
-    if ( src > dest )
-      dest = src;
+    if (src > dest) dest = src;
   }
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::max();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct LAnd {
-public:
-  //Required
+ public:
+  // Required
   typedef LAnd reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  LAnd(value_type& value_): value(&value_),references_scalar_v(true) {}
+  LAnd(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  LAnd(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  LAnd(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
+  void join(value_type& dest, const value_type& src) const {
     dest = dest && src;
   }
 
@@ -311,50 +279,44 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::land();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct LOr {
-public:
-  //Required
+ public:
+  // Required
   typedef LOr reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  LOr(value_type& value_): value(&value_),references_scalar_v(true) {}
+  LOr(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  LOr(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  LOr(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
+  void join(value_type& dest, const value_type& src) const {
     dest = dest || src;
   }
 
@@ -364,51 +326,45 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::lor();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct BAnd {
-public:
-  //Required
+ public:
+  // Required
   typedef BAnd reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  BAnd(value_type& value_): value(&value_),references_scalar_v(true) {}
+  BAnd(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  BAnd(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  BAnd(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-      dest = dest & src;
+  void join(value_type& dest, const value_type& src) const {
+    dest = dest & src;
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -417,51 +373,45 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::band();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct BOr {
-public:
-  //Required
+ public:
+  // Required
   typedef BOr reducer;
   typedef typename std::remove_cv<Scalar>::type value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  BOr(value_type& value_): value(&value_),references_scalar_v(true) {}
+  BOr(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  BOr(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  BOr(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-      dest = dest | src;
+  void join(value_type& dest, const value_type& src) const {
+    dest = dest | src;
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -470,256 +420,229 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val = reduction_identity<value_type>::bor();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Index>
+template <class Scalar, class Index>
 struct ValLocScalar {
   Scalar val;
   Index loc;
 
   KOKKOS_INLINE_FUNCTION
-  void operator = (const ValLocScalar& rhs) {
+  void operator=(const ValLocScalar& rhs) {
     val = rhs.val;
     loc = rhs.loc;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator = (const volatile ValLocScalar& rhs) volatile {
+  void operator=(const volatile ValLocScalar& rhs) volatile {
     val = rhs.val;
     loc = rhs.loc;
   }
 };
 
-template<class Scalar, class Index, class Space>
+template <class Scalar, class Index, class Space>
 struct MinLoc {
-private:
+ private:
   typedef typename std::remove_cv<Scalar>::type scalar_type;
   typedef typename std::remove_cv<Index>::type index_type;
 
-public:
-  //Required
+ public:
+  // Required
   typedef MinLoc reducer;
-  typedef ValLocScalar<scalar_type,index_type> value_type;
+  typedef ValLocScalar<scalar_type, index_type> value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  MinLoc(value_type& value_): value(&value_),references_scalar_v(true) {}
+  MinLoc(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  MinLoc(const result_view_type& value_): value(value_),references_scalar_v(false) {}
-
+  MinLoc(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    if ( src.val < dest.val )
-      dest = src;
+  void join(value_type& dest, const value_type& src) const {
+    if (src.val < dest.val) dest = src;
   }
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
-    if ( src.val < dest.val )
-      dest = src;
+    if (src.val < dest.val) dest = src;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
+  void init(value_type& val) const {
     val.val = reduction_identity<scalar_type>::min();
     val.loc = reduction_identity<index_type>::min();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Index, class Space>
+template <class Scalar, class Index, class Space>
 struct MaxLoc {
-private:
+ private:
   typedef typename std::remove_cv<Scalar>::type scalar_type;
   typedef typename std::remove_cv<Index>::type index_type;
 
-public:
-  //Required
+ public:
+  // Required
   typedef MaxLoc reducer;
-  typedef ValLocScalar<scalar_type,index_type> value_type;
+  typedef ValLocScalar<scalar_type, index_type> value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  MaxLoc(value_type& value_): value(&value_),references_scalar_v(true) {}
+  MaxLoc(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  MaxLoc(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  MaxLoc(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    if ( src.val > dest.val )
-      dest = src;
+  void join(value_type& dest, const value_type& src) const {
+    if (src.val > dest.val) dest = src;
   }
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
-    if ( src.val > dest.val )
-      dest = src;
+    if (src.val > dest.val) dest = src;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
-    val.val = reduction_identity<scalar_type>::max();;
+  void init(value_type& val) const {
+    val.val = reduction_identity<scalar_type>::max();
+    ;
     val.loc = reduction_identity<index_type>::min();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar>
+template <class Scalar>
 struct MinMaxScalar {
-  Scalar min_val,max_val;
+  Scalar min_val, max_val;
 
   KOKKOS_INLINE_FUNCTION
-  void operator = (const MinMaxScalar& rhs) {
+  void operator=(const MinMaxScalar& rhs) {
     min_val = rhs.min_val;
     max_val = rhs.max_val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator = (const volatile MinMaxScalar& rhs) volatile {
+  void operator=(const volatile MinMaxScalar& rhs) volatile {
     min_val = rhs.min_val;
     max_val = rhs.max_val;
   }
 };
 
-template<class Scalar, class Space>
+template <class Scalar, class Space>
 struct MinMax {
-private:
+ private:
   typedef typename std::remove_cv<Scalar>::type scalar_type;
 
-public:
-  //Required
+ public:
+  // Required
   typedef MinMax reducer;
   typedef MinMaxScalar<scalar_type> value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  MinMax(value_type& value_): value(&value_),references_scalar_v(true) {}
+  MinMax(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  MinMax(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  MinMax(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    if ( src.min_val < dest.min_val ) {
+  void join(value_type& dest, const value_type& src) const {
+    if (src.min_val < dest.min_val) {
       dest.min_val = src.min_val;
     }
-    if ( src.max_val > dest.max_val ) {
+    if (src.max_val > dest.max_val) {
       dest.max_val = src.max_val;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
-    if ( src.min_val < dest.min_val ) {
+    if (src.min_val < dest.min_val) {
       dest.min_val = src.min_val;
     }
-    if ( src.max_val > dest.max_val ) {
+    if (src.max_val > dest.max_val) {
       dest.max_val = src.max_val;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
-    val.max_val = reduction_identity<scalar_type>::max();;
+  void init(value_type& val) const {
+    val.max_val = reduction_identity<scalar_type>::max();
+    ;
     val.min_val = reduction_identity<scalar_type>::min();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
 
-template<class Scalar, class Index>
+template <class Scalar, class Index>
 struct MinMaxLocScalar {
-  Scalar min_val,max_val;
-  Index min_loc,max_loc;
+  Scalar min_val, max_val;
+  Index min_loc, max_loc;
 
   KOKKOS_INLINE_FUNCTION
-  void operator = (const MinMaxLocScalar& rhs) {
+  void operator=(const MinMaxLocScalar& rhs) {
     min_val = rhs.min_val;
     min_loc = rhs.min_loc;
     max_val = rhs.max_val;
@@ -727,7 +650,7 @@ struct MinMaxLocScalar {
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator = (const volatile MinMaxLocScalar& rhs) volatile {
+  void operator=(const volatile MinMaxLocScalar& rhs) volatile {
     min_val = rhs.min_val;
     min_loc = rhs.min_loc;
     max_val = rhs.max_val;
@@ -735,39 +658,39 @@ struct MinMaxLocScalar {
   }
 };
 
-template<class Scalar, class Index, class Space>
+template <class Scalar, class Index, class Space>
 struct MinMaxLoc {
-private:
+ private:
   typedef typename std::remove_cv<Scalar>::type scalar_type;
   typedef typename std::remove_cv<Index>::type index_type;
 
-public:
-  //Required
+ public:
+  // Required
   typedef MinMaxLoc reducer;
-  typedef MinMaxLocScalar<scalar_type,index_type> value_type;
+  typedef MinMaxLocScalar<scalar_type, index_type> value_type;
 
   typedef Kokkos::View<value_type, Space> result_view_type;
 
-private:
+ private:
   result_view_type value;
   bool references_scalar_v;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  MinMaxLoc(value_type& value_): value(&value_),references_scalar_v(true) {}
+  MinMaxLoc(value_type& value_) : value(&value_), references_scalar_v(true) {}
 
   KOKKOS_INLINE_FUNCTION
-  MinMaxLoc(const result_view_type& value_): value(value_),references_scalar_v(false) {}
+  MinMaxLoc(const result_view_type& value_)
+      : value(value_), references_scalar_v(false) {}
 
-  //Required
+  // Required
   KOKKOS_INLINE_FUNCTION
-  void join(value_type& dest, const value_type& src)  const {
-    if ( src.min_val < dest.min_val ) {
+  void join(value_type& dest, const value_type& src) const {
+    if (src.min_val < dest.min_val) {
       dest.min_val = src.min_val;
       dest.min_loc = src.min_loc;
     }
-    if ( src.max_val > dest.max_val ) {
+    if (src.max_val > dest.max_val) {
       dest.max_val = src.max_val;
       dest.max_loc = src.max_loc;
     }
@@ -775,71 +698,68 @@ public:
 
   KOKKOS_INLINE_FUNCTION
   void join(volatile value_type& dest, const volatile value_type& src) const {
-    if ( src.min_val < dest.min_val ) {
+    if (src.min_val < dest.min_val) {
       dest.min_val = src.min_val;
       dest.min_loc = src.min_loc;
     }
-    if ( src.max_val > dest.max_val ) {
+    if (src.max_val > dest.max_val) {
       dest.max_val = src.max_val;
       dest.max_loc = src.max_loc;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type& val)  const {
-    val.max_val = reduction_identity<scalar_type>::max();;
+  void init(value_type& val) const {
+    val.max_val = reduction_identity<scalar_type>::max();
+    ;
     val.min_val = reduction_identity<scalar_type>::min();
     val.max_loc = reduction_identity<index_type>::min();
     val.min_loc = reduction_identity<index_type>::min();
   }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return *value.data();
-  }
+  value_type& reference() const { return *value.data(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return value;
-  }
+  result_view_type view() const { return value; }
 
   KOKKOS_INLINE_FUNCTION
-  bool references_scalar() const {
-    return references_scalar_v;
-  }
+  bool references_scalar() const { return references_scalar_v; }
 };
-}
-namespace Kokkos{
+}  // namespace Kokkos
+namespace Kokkos {
 namespace Impl {
 
-template< class T, class ReturnType , class ValueTraits>
+template <class T, class ReturnType, class ValueTraits>
 struct ParallelReduceReturnValue;
 
-template< class ReturnType , class FunctorType >
-struct ParallelReduceReturnValue<typename std::enable_if<Kokkos::is_view<ReturnType>::value>::type, ReturnType, FunctorType> {
+template <class ReturnType, class FunctorType>
+struct ParallelReduceReturnValue<
+    typename std::enable_if<Kokkos::is_view<ReturnType>::value>::type,
+    ReturnType, FunctorType> {
   typedef ReturnType return_type;
   typedef InvalidType reducer_type;
 
   typedef typename return_type::value_type value_type_scalar;
   typedef typename return_type::value_type* const value_type_array;
 
-  typedef typename if_c<return_type::rank==0,value_type_scalar,value_type_array>::type value_type;
+  typedef typename if_c<return_type::rank == 0, value_type_scalar,
+                        value_type_array>::type value_type;
 
   static return_type& return_value(ReturnType& return_val, const FunctorType&) {
     return return_val;
   }
 };
 
-template< class ReturnType , class FunctorType>
-struct ParallelReduceReturnValue<typename std::enable_if<
-                                   !Kokkos::is_view<ReturnType>::value &&
-                                  (!std::is_array<ReturnType>::value && !std::is_pointer<ReturnType>::value) &&
-                                   !Kokkos::is_reducer_type<ReturnType>::value
-                                 >::type, ReturnType, FunctorType> {
-  typedef Kokkos::View<  ReturnType
-                       , Kokkos::HostSpace
-                       , Kokkos::MemoryUnmanaged
-      > return_type;
+template <class ReturnType, class FunctorType>
+struct ParallelReduceReturnValue<
+    typename std::enable_if<!Kokkos::is_view<ReturnType>::value &&
+                            (!std::is_array<ReturnType>::value &&
+                             !std::is_pointer<ReturnType>::value) &&
+                            !Kokkos::is_reducer_type<ReturnType>::value>::type,
+    ReturnType, FunctorType> {
+  typedef Kokkos::View<ReturnType, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      return_type;
 
   typedef InvalidType reducer_type;
 
@@ -850,14 +770,14 @@ struct ParallelReduceReturnValue<typename std::enable_if<
   }
 };
 
-template< class ReturnType , class FunctorType>
-struct ParallelReduceReturnValue<typename std::enable_if<
-                                  (is_array<ReturnType>::value || std::is_pointer<ReturnType>::value)
-                                >::type, ReturnType, FunctorType> {
-  typedef Kokkos::View<  typename std::remove_const<ReturnType>::type
-                       , Kokkos::HostSpace
-                       , Kokkos::MemoryUnmanaged
-      > return_type;
+template <class ReturnType, class FunctorType>
+struct ParallelReduceReturnValue<
+    typename std::enable_if<(is_array<ReturnType>::value ||
+                             std::is_pointer<ReturnType>::value)>::type,
+    ReturnType, FunctorType> {
+  typedef Kokkos::View<typename std::remove_const<ReturnType>::type,
+                       Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      return_type;
 
   typedef InvalidType reducer_type;
 
@@ -866,150 +786,154 @@ struct ParallelReduceReturnValue<typename std::enable_if<
   static return_type return_value(ReturnType& return_val,
                                   const FunctorType& functor) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    return return_type(return_val,functor.value_count);
+    return return_type(return_val, functor.value_count);
 #else
-    if ( is_array<ReturnType>::value )
+    if (is_array<ReturnType>::value)
       return return_type(return_val);
     else
-      return return_type(return_val,functor.value_count);
+      return return_type(return_val, functor.value_count);
 #endif
   }
 };
 
-template< class ReturnType , class FunctorType>
-struct ParallelReduceReturnValue<typename std::enable_if<
-                                   Kokkos::is_reducer_type<ReturnType>::value
-                                >::type, ReturnType, FunctorType> {
+template <class ReturnType, class FunctorType>
+struct ParallelReduceReturnValue<
+    typename std::enable_if<Kokkos::is_reducer_type<ReturnType>::value>::type,
+    ReturnType, FunctorType> {
   typedef ReturnType return_type;
   typedef ReturnType reducer_type;
   typedef typename return_type::value_type value_type;
 
-  static return_type return_value(ReturnType& return_val,
-                                  const FunctorType&) {
+  static return_type return_value(ReturnType& return_val, const FunctorType&) {
     return return_val;
   }
 };
 
-template< class T, class ReturnType , class FunctorType>
+template <class T, class ReturnType, class FunctorType>
 struct ParallelReducePolicyType;
 
-template< class PolicyType , class FunctorType >
-struct ParallelReducePolicyType<typename std::enable_if<Kokkos::Impl::is_execution_policy<PolicyType>::value>::type, PolicyType,FunctorType> {
-
+template <class PolicyType, class FunctorType>
+struct ParallelReducePolicyType<
+    typename std::enable_if<
+        Kokkos::Impl::is_execution_policy<PolicyType>::value>::type,
+    PolicyType, FunctorType> {
   typedef PolicyType policy_type;
-  static PolicyType policy(const PolicyType& policy_) {
-    return policy_;
-  }
+  static PolicyType policy(const PolicyType& policy_) { return policy_; }
 };
 
-template< class PolicyType , class FunctorType >
-struct ParallelReducePolicyType<typename std::enable_if<std::is_integral<PolicyType>::value>::type, PolicyType,FunctorType> {
-  typedef typename
-    Impl::FunctorPolicyExecutionSpace< FunctorType , void >::execution_space
-      execution_space ;
+template <class PolicyType, class FunctorType>
+struct ParallelReducePolicyType<
+    typename std::enable_if<std::is_integral<PolicyType>::value>::type,
+    PolicyType, FunctorType> {
+  typedef typename Impl::FunctorPolicyExecutionSpace<
+      FunctorType, void>::execution_space execution_space;
 
   typedef Kokkos::RangePolicy<execution_space> policy_type;
 
   static policy_type policy(const PolicyType& policy_) {
-    return policy_type(0,policy_);
+    return policy_type(0, policy_);
   }
 };
 
+template <class FunctorType, class ExecPolicy, class ValueType,
+          class ExecutionSpace>
+struct ParallelReduceFunctorType {
+  typedef FunctorType functor_type;
+  static const functor_type& functor(const functor_type& functor) {
+    return functor;
+  }
+};
 
-  template< class FunctorType, class ExecPolicy, class ValueType, class ExecutionSpace>
-  struct ParallelReduceFunctorType {
-    typedef FunctorType functor_type;
-    static const functor_type& functor(const functor_type& functor) {
-      return functor;
+template <class PolicyType, class FunctorType, class ReturnType>
+struct ParallelReduceAdaptor {
+  typedef Impl::ParallelReduceReturnValue<void, ReturnType, FunctorType>
+      return_value_adapter;
+#ifdef KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER
+  typedef Impl::ParallelReduceFunctorType<
+      FunctorType, PolicyType, typename return_value_adapter::value_type,
+      typename PolicyType::execution_space>
+      functor_adaptor;
+#endif
+  static inline void execute(const std::string& label, const PolicyType& policy,
+                             const FunctorType& functor,
+                             ReturnType& return_value) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+    uint64_t kpID = 0;
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Impl::ParallelConstructName<FunctorType,
+                                          typename PolicyType::work_tag>
+          name(label);
+      Kokkos::Profiling::beginParallelReduce(name.get(), 0, &kpID);
     }
-  };
+#endif
 
-  template< class PolicyType, class FunctorType, class ReturnType >
-  struct ParallelReduceAdaptor {
-    typedef Impl::ParallelReduceReturnValue<void,ReturnType,FunctorType> return_value_adapter;
-    #ifdef KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER
-    typedef Impl::ParallelReduceFunctorType<FunctorType,PolicyType,
-                                            typename return_value_adapter::value_type,
-                                            typename PolicyType::execution_space> functor_adaptor;
-    #endif
-    static inline
-    void execute(const std::string& label,
-        const PolicyType& policy,
-        const FunctorType& functor,
-        ReturnType& return_value) {
-          #if defined(KOKKOS_ENABLE_PROFILING)
-          uint64_t kpID = 0;
-          if(Kokkos::Profiling::profileLibraryLoaded()) {
-            Kokkos::Impl::ParallelConstructName<FunctorType, typename PolicyType::work_tag> name(label);
-            Kokkos::Profiling::beginParallelReduce(name.get(), 0, &kpID);
-          }
-          #endif
-
-          Kokkos::Impl::shared_allocation_tracking_disable();
-          #ifdef KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER
-          Impl::ParallelReduce<typename functor_adaptor::functor_type, PolicyType, typename return_value_adapter::reducer_type >
-             closure(functor_adaptor::functor(functor),
-                     policy,
-                     return_value_adapter::return_value(return_value,functor));
-          #else
-          Impl::ParallelReduce<FunctorType, PolicyType, typename return_value_adapter::reducer_type >
-             closure(functor,
-                     policy,
-                     return_value_adapter::return_value(return_value,functor));
-          #endif
-          Kokkos::Impl::shared_allocation_tracking_enable();
-          closure.execute();
-
-          #if defined(KOKKOS_ENABLE_PROFILING)
-          if(Kokkos::Profiling::profileLibraryLoaded()) {
-            Kokkos::Profiling::endParallelReduce(kpID);
-          }
-          #endif
-        }
+    Kokkos::Impl::shared_allocation_tracking_disable();
+#ifdef KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER
+    Impl::ParallelReduce<typename functor_adaptor::functor_type, PolicyType,
+                         typename return_value_adapter::reducer_type>
+        closure(functor_adaptor::functor(functor), policy,
+                return_value_adapter::return_value(return_value, functor));
+#else
+    Impl::ParallelReduce<FunctorType, PolicyType,
+                         typename return_value_adapter::reducer_type>
+        closure(functor, policy,
+                return_value_adapter::return_value(return_value, functor));
+#endif
+    Kokkos::Impl::shared_allocation_tracking_enable();
+    closure.execute();
 
-  };
-}
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endParallelReduce(kpID);
+    }
+#endif
+  }
+};
+}  // namespace Impl
 
 //----------------------------------------------------------------------------
 
 /*! \fn void parallel_reduce(label,policy,functor,return_argument)
     \brief Perform a parallel reduction.
-    \param label An optional Label giving the call name. Must be able to construct a std::string from the argument.
-    \param policy A Kokkos Execution Policy, such as an integer, a RangePolicy or a TeamPolicy.
-    \param functor A functor with a reduction operator, and optional init, join and final functions.
-    \param return_argument A return argument which can be a scalar, a View, or a ReducerStruct. This argument can be left out if the functor has a final function.
+    \param label An optional Label giving the call name. Must be able to
+   construct a std::string from the argument. \param policy A Kokkos Execution
+   Policy, such as an integer, a RangePolicy or a TeamPolicy. \param functor A
+   functor with a reduction operator, and optional init, join and final
+   functions. \param return_argument A return argument which can be a scalar, a
+   View, or a ReducerStruct. This argument can be left out if the functor has a
+   final function.
 */
 
 // Parallel Reduce Blocking behavior
 
 namespace Impl {
 template <typename T>
-  struct ReducerHasTestReferenceFunction
-  {
-    template <typename E> static std::true_type test_func( decltype(&E::references_scalar) ) ;
-    template <typename E> static std::false_type test_func(...);
-
-    enum { value = std::is_same<std::true_type,decltype(test_func<T>(0))>::value };
+struct ReducerHasTestReferenceFunction {
+  template <typename E>
+  static std::true_type test_func(decltype(&E::references_scalar));
+  template <typename E>
+  static std::false_type test_func(...);
+
+  enum {
+    value = std::is_same<std::true_type, decltype(test_func<T>(0))>::value
   };
+};
 
-  template<class T, bool is_reducer =  ReducerHasTestReferenceFunction<T>::value>
-  struct ParallelReduceFence {
-    static void fence(const T&) {
-      Kokkos::fence();
-    }
-  };
-  template<class ... Args>
-  struct ParallelReduceFence<View<Args...>, false> {
-    static void fence(const View<Args...>) {};
-  };
-  template<class T>
-  struct ParallelReduceFence<T,true> {
-    static void fence(const T& reducer) {
-      if(reducer.references_scalar())
-        Kokkos::fence();
-    }
-  };
-}
+template <class T, bool is_reducer = ReducerHasTestReferenceFunction<T>::value>
+struct ParallelReduceFence {
+  static void fence(const T&) { Kokkos::fence(); }
+};
+template <class... Args>
+struct ParallelReduceFence<View<Args...>, false> {
+  static void fence(const View<Args...>){};
+};
+template <class T>
+struct ParallelReduceFence<T, true> {
+  static void fence(const T& reducer) {
+    if (reducer.references_scalar()) Kokkos::fence();
+  }
+};
+}  // namespace Impl
 
 /** \brief  Parallel reduction
  *
@@ -1033,16 +957,12 @@ template <typename T>
  *  };
  * \endcode
  *
- * Example of a parallel_reduce functor for an array of POD (plain old data) values:
- * \code
- *  class FunctorType { // For array of POD value
- *  public:
- *    typedef    ...     execution_space ;
- *    typedef <podType>  value_type[] ;
- *    void operator()( <intType> , <podType> update[] ) const ;
- *    void init( <podType> update[] ) const ;
- *    void join( volatile       <podType> update[] ,
- *               volatile const <podType> input[] ) const ;
+ * Example of a parallel_reduce functor for an array of POD (plain old data)
+ * values: \code class FunctorType { // For array of POD value public: typedef
+ * ...     execution_space ; typedef <podType>  value_type[] ; void operator()(
+ * <intType> , <podType> update[] ) const ; void init( <podType> update[] )
+ * const ; void join( volatile       <podType> update[] , volatile const
+ * <podType> input[] ) const ;
  *
  *    typedef true_type has_final ;
  *    void final( <podType> update[] ) const ;
@@ -1052,226 +972,223 @@ template <typename T>
 
 // ReturnValue is scalar or array: take by reference
 
-template< class PolicyType, class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const std::string& label,
-                     const PolicyType& policy,
-                     const FunctorType& functor,
-                     ReturnType& return_value,
-                     typename Impl::enable_if<
-                       Kokkos::Impl::is_execution_policy<PolicyType>::value
-                     >::type * = 0) {
-  Impl::ParallelReduceAdaptor<PolicyType,FunctorType,ReturnType>::execute(label,policy,functor,return_value);
+template <class PolicyType, class FunctorType, class ReturnType>
+inline void parallel_reduce(
+    const std::string& label, const PolicyType& policy,
+    const FunctorType& functor, ReturnType& return_value,
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<PolicyType>::value>::type* = 0) {
+  Impl::ParallelReduceAdaptor<PolicyType, FunctorType, ReturnType>::execute(
+      label, policy, functor, return_value);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
-template< class PolicyType, class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const PolicyType& policy,
-                     const FunctorType& functor,
-                     ReturnType& return_value,
-                     typename Impl::enable_if<
-                       Kokkos::Impl::is_execution_policy<PolicyType>::value
-                     >::type * = 0) {
-  Impl::ParallelReduceAdaptor<PolicyType,FunctorType,ReturnType>::execute("",policy,functor,return_value);
+template <class PolicyType, class FunctorType, class ReturnType>
+inline void parallel_reduce(
+    const PolicyType& policy, const FunctorType& functor,
+    ReturnType& return_value,
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<PolicyType>::value>::type* = 0) {
+  Impl::ParallelReduceAdaptor<PolicyType, FunctorType, ReturnType>::execute(
+      "", policy, functor, return_value);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
-template< class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const size_t& policy,
-                     const FunctorType& functor,
-                     ReturnType& return_value) {
-  typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
-  Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute("",policy_type(0,policy),functor,return_value);
+template <class FunctorType, class ReturnType>
+inline void parallel_reduce(const size_t& policy, const FunctorType& functor,
+                            ReturnType& return_value) {
+  typedef typename Impl::ParallelReducePolicyType<
+      void, size_t, FunctorType>::policy_type policy_type;
+  Impl::ParallelReduceAdaptor<policy_type, FunctorType, ReturnType>::execute(
+      "", policy_type(0, policy), functor, return_value);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
-template< class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const std::string& label,
-                     const size_t& policy,
-                     const FunctorType& functor,
-                     ReturnType& return_value) {
-  typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
-  Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute(label,policy_type(0,policy),functor,return_value);
+template <class FunctorType, class ReturnType>
+inline void parallel_reduce(const std::string& label, const size_t& policy,
+                            const FunctorType& functor,
+                            ReturnType& return_value) {
+  typedef typename Impl::ParallelReducePolicyType<
+      void, size_t, FunctorType>::policy_type policy_type;
+  Impl::ParallelReduceAdaptor<policy_type, FunctorType, ReturnType>::execute(
+      label, policy_type(0, policy), functor, return_value);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
 // ReturnValue as View or Reducer: take by copy to allow for inline construction
 
-template< class PolicyType, class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const std::string& label,
-                     const PolicyType& policy,
-                     const FunctorType& functor,
-                     const ReturnType& return_value,
-                     typename Impl::enable_if<
-                       Kokkos::Impl::is_execution_policy<PolicyType>::value
-                     >::type * = 0) {
+template <class PolicyType, class FunctorType, class ReturnType>
+inline void parallel_reduce(
+    const std::string& label, const PolicyType& policy,
+    const FunctorType& functor, const ReturnType& return_value,
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<PolicyType>::value>::type* = 0) {
   ReturnType return_value_impl = return_value;
-  Impl::ParallelReduceAdaptor<PolicyType,FunctorType,ReturnType>::execute(label,policy,functor,return_value_impl);
+  Impl::ParallelReduceAdaptor<PolicyType, FunctorType, ReturnType>::execute(
+      label, policy, functor, return_value_impl);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
-template< class PolicyType, class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const PolicyType& policy,
-                     const FunctorType& functor,
-                     const ReturnType& return_value,
-                     typename Impl::enable_if<
-                       Kokkos::Impl::is_execution_policy<PolicyType>::value
-                     >::type * = 0) {
+template <class PolicyType, class FunctorType, class ReturnType>
+inline void parallel_reduce(
+    const PolicyType& policy, const FunctorType& functor,
+    const ReturnType& return_value,
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<PolicyType>::value>::type* = 0) {
   ReturnType return_value_impl = return_value;
-  Impl::ParallelReduceAdaptor<PolicyType,FunctorType,ReturnType>::execute("",policy,functor,return_value_impl);
+  Impl::ParallelReduceAdaptor<PolicyType, FunctorType, ReturnType>::execute(
+      "", policy, functor, return_value_impl);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
-template< class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const size_t& policy,
-                     const FunctorType& functor,
-                     const ReturnType& return_value) {
-  typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
+template <class FunctorType, class ReturnType>
+inline void parallel_reduce(const size_t& policy, const FunctorType& functor,
+                            const ReturnType& return_value) {
+  typedef typename Impl::ParallelReducePolicyType<
+      void, size_t, FunctorType>::policy_type policy_type;
   ReturnType return_value_impl = return_value;
-  Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute("",policy_type(0,policy),functor,return_value_impl);
+  Impl::ParallelReduceAdaptor<policy_type, FunctorType, ReturnType>::execute(
+      "", policy_type(0, policy), functor, return_value_impl);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
-template< class FunctorType, class ReturnType >
-inline
-void parallel_reduce(const std::string& label,
-                     const size_t& policy,
-                     const FunctorType& functor,
-                     const ReturnType& return_value) {
-  typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
+template <class FunctorType, class ReturnType>
+inline void parallel_reduce(const std::string& label, const size_t& policy,
+                            const FunctorType& functor,
+                            const ReturnType& return_value) {
+  typedef typename Impl::ParallelReducePolicyType<
+      void, size_t, FunctorType>::policy_type policy_type;
   ReturnType return_value_impl = return_value;
-  Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute(label,policy_type(0,policy),functor,return_value_impl);
+  Impl::ParallelReduceAdaptor<policy_type, FunctorType, ReturnType>::execute(
+      label, policy_type(0, policy), functor, return_value_impl);
   Impl::ParallelReduceFence<ReturnType>::fence(return_value);
 }
 
 // No Return Argument
 
-template< class PolicyType, class FunctorType>
-inline
-void parallel_reduce(const std::string& label,
-                     const PolicyType& policy,
-                     const FunctorType& functor,
-                     typename Impl::enable_if<
-                       Kokkos::Impl::is_execution_policy<PolicyType>::value
-                     >::type * = 0) {
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void >  ValueTraits ;
-  typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
-                                     , typename ValueTraits::value_type
-                                     , typename ValueTraits::pointer_type
-                                     >::type value_type ;
-
-  static_assert(Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,PolicyType,FunctorType>::
-                 has_final_member_function,"Calling parallel_reduce without either return value or final function.");
-
-  typedef Kokkos::View< value_type
-              , Kokkos::HostSpace
-              , Kokkos::MemoryUnmanaged
-              > result_view_type;
-  result_view_type result_view ;
-
-  Impl::ParallelReduceAdaptor<PolicyType,FunctorType,result_view_type>::execute(label,policy,functor,result_view);
+template <class PolicyType, class FunctorType>
+inline void parallel_reduce(
+    const std::string& label, const PolicyType& policy,
+    const FunctorType& functor,
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<PolicyType>::value>::type* = 0) {
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename Kokkos::Impl::if_c<
+      (ValueTraits::StaticValueSize != 0), typename ValueTraits::value_type,
+      typename ValueTraits::pointer_type>::type value_type;
+
+  static_assert(
+      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
+                            FunctorType>::has_final_member_function,
+      "Calling parallel_reduce without either return value or final function.");
+
+  typedef Kokkos::View<value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      result_view_type;
+  result_view_type result_view;
+
+  Impl::ParallelReduceAdaptor<PolicyType, FunctorType,
+                              result_view_type>::execute(label, policy, functor,
+                                                         result_view);
 }
 
-template< class PolicyType, class FunctorType >
-inline
-void parallel_reduce(const PolicyType& policy,
-                     const FunctorType& functor,
-                     typename Impl::enable_if<
-                       Kokkos::Impl::is_execution_policy<PolicyType>::value
-                     >::type * = 0) {
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void >  ValueTraits ;
-  typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
-                                     , typename ValueTraits::value_type
-                                     , typename ValueTraits::pointer_type
-                                     >::type value_type ;
-
-  static_assert(Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,PolicyType,FunctorType>::
-                 has_final_member_function,"Calling parallel_reduce without either return value or final function.");
-
-  typedef Kokkos::View< value_type
-              , Kokkos::HostSpace
-              , Kokkos::MemoryUnmanaged
-              > result_view_type;
-  result_view_type result_view ;
-
-  Impl::ParallelReduceAdaptor<PolicyType,FunctorType,result_view_type>::execute("",policy,functor,result_view);
+template <class PolicyType, class FunctorType>
+inline void parallel_reduce(
+    const PolicyType& policy, const FunctorType& functor,
+    typename Impl::enable_if<
+        Kokkos::Impl::is_execution_policy<PolicyType>::value>::type* = 0) {
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename Kokkos::Impl::if_c<
+      (ValueTraits::StaticValueSize != 0), typename ValueTraits::value_type,
+      typename ValueTraits::pointer_type>::type value_type;
+
+  static_assert(
+      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
+                            FunctorType>::has_final_member_function,
+      "Calling parallel_reduce without either return value or final function.");
+
+  typedef Kokkos::View<value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      result_view_type;
+  result_view_type result_view;
+
+  Impl::ParallelReduceAdaptor<PolicyType, FunctorType,
+                              result_view_type>::execute("", policy, functor,
+                                                         result_view);
 }
 
-template< class FunctorType >
-inline
-void parallel_reduce(const size_t& policy,
-                     const FunctorType& functor) {
-  typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void >  ValueTraits ;
-  typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
-                                     , typename ValueTraits::value_type
-                                     , typename ValueTraits::pointer_type
-                                     >::type value_type ;
-
-  static_assert(Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,RangePolicy<>,FunctorType>::
-                 has_final_member_function,"Calling parallel_reduce without either return value or final function.");
-
-  typedef Kokkos::View< value_type
-              , Kokkos::HostSpace
-              , Kokkos::MemoryUnmanaged
-              > result_view_type;
-  result_view_type result_view ;
-
-  Impl::ParallelReduceAdaptor<policy_type,FunctorType,result_view_type>::execute("",policy_type(0,policy),functor,result_view);
+template <class FunctorType>
+inline void parallel_reduce(const size_t& policy, const FunctorType& functor) {
+  typedef typename Impl::ParallelReducePolicyType<
+      void, size_t, FunctorType>::policy_type policy_type;
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename Kokkos::Impl::if_c<
+      (ValueTraits::StaticValueSize != 0), typename ValueTraits::value_type,
+      typename ValueTraits::pointer_type>::type value_type;
+
+  static_assert(
+      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                            RangePolicy<>,
+                            FunctorType>::has_final_member_function,
+      "Calling parallel_reduce without either return value or final function.");
+
+  typedef Kokkos::View<value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      result_view_type;
+  result_view_type result_view;
+
+  Impl::ParallelReduceAdaptor<policy_type, FunctorType,
+                              result_view_type>::execute("",
+                                                         policy_type(0, policy),
+                                                         functor, result_view);
 }
 
-template< class FunctorType>
-inline
-void parallel_reduce(const std::string& label,
-                     const size_t& policy,
-                     const FunctorType& functor) {
-  typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void >  ValueTraits ;
-  typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
-                                     , typename ValueTraits::value_type
-                                     , typename ValueTraits::pointer_type
-                                     >::type value_type ;
-
-  static_assert(Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,RangePolicy<>,FunctorType>::
-                 has_final_member_function,"Calling parallel_reduce without either return value or final function.");
-
-  typedef Kokkos::View< value_type
-              , Kokkos::HostSpace
-              , Kokkos::MemoryUnmanaged
-              > result_view_type;
-  result_view_type result_view ;
-
-  Impl::ParallelReduceAdaptor<policy_type,FunctorType,result_view_type>::execute(label,policy_type(0,policy),functor,result_view);
+template <class FunctorType>
+inline void parallel_reduce(const std::string& label, const size_t& policy,
+                            const FunctorType& functor) {
+  typedef typename Impl::ParallelReducePolicyType<
+      void, size_t, FunctorType>::policy_type policy_type;
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename Kokkos::Impl::if_c<
+      (ValueTraits::StaticValueSize != 0), typename ValueTraits::value_type,
+      typename ValueTraits::pointer_type>::type value_type;
+
+  static_assert(
+      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                            RangePolicy<>,
+                            FunctorType>::has_final_member_function,
+      "Calling parallel_reduce without either return value or final function.");
+
+  typedef Kokkos::View<value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      result_view_type;
+  result_view_type result_view;
+
+  Impl::ParallelReduceAdaptor<policy_type, FunctorType,
+                              result_view_type>::execute(label,
+                                                         policy_type(0, policy),
+                                                         functor, result_view);
 }
 
-} //namespace Kokkos
+}  // namespace Kokkos
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-//backwards compatibility for Kokkos::Experimental reducers
-namespace Kokkos { namespace Experimental {
-using Kokkos::Sum;
-using Kokkos::Prod;
-using Kokkos::Min;
-using Kokkos::Max;
-using Kokkos::LAnd;
-using Kokkos::LOr;
+// backwards compatibility for Kokkos::Experimental reducers
+namespace Kokkos {
+namespace Experimental {
 using Kokkos::BAnd;
 using Kokkos::BOr;
-using Kokkos::ValLocScalar;
-using Kokkos::MinLoc;
+using Kokkos::LAnd;
+using Kokkos::LOr;
+using Kokkos::Max;
 using Kokkos::MaxLoc;
-using Kokkos::MinMaxScalar;
+using Kokkos::Min;
+using Kokkos::MinLoc;
 using Kokkos::MinMax;
-using Kokkos::MinMaxLocScalar;
 using Kokkos::MinMaxLoc;
-}} //namespace Kokkos::Experimental
+using Kokkos::MinMaxLocScalar;
+using Kokkos::MinMaxScalar;
+using Kokkos::Prod;
+using Kokkos::Sum;
+using Kokkos::ValLocScalar;
+}  // namespace Experimental
+}  // namespace Kokkos
 #endif
 
-#endif // KOKKOS_PARALLEL_REDUCE_HPP
-
+#endif  // KOKKOS_PARALLEL_REDUCE_HPP
diff --git a/lib/kokkos/core/src/Kokkos_PointerOwnership.hpp b/lib/kokkos/core/src/Kokkos_PointerOwnership.hpp
index be76ec3defa855290db04cfc4c22b26c8f1cc56b..f1f168c38fea159835b34c1c25e0479f653cc76a 100644
--- a/lib/kokkos/core/src/Kokkos_PointerOwnership.hpp
+++ b/lib/kokkos/core/src/Kokkos_PointerOwnership.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -63,12 +64,9 @@ using OwningRawPtr = T*;
 template <class T>
 using ObservingRawPtr = T*;
 
-} // end namespace Kokkos
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
-
 #endif /* #ifndef KOKKOS_IMPL_POINTEROWNERSHIP_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Profiling_ProfileSection.hpp b/lib/kokkos/core/src/Kokkos_Profiling_ProfileSection.hpp
index b3fd3af70b25e6971aa0e1ea7d375c4822571cb7..3c667f4432030862311dbfa533299f2341aac3f8 100644
--- a/lib/kokkos/core/src/Kokkos_Profiling_ProfileSection.hpp
+++ b/lib/kokkos/core/src/Kokkos_Profiling_ProfileSection.hpp
@@ -1,45 +1,46 @@
 /*
- //@HEADER
- // ************************************************************************
- //
- //                        Kokkos v. 2.0
- //              Copyright (2014) Sandia Corporation
- //
- // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
- // the U.S. Government retains certain rights in this software.
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // 1. Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- //
- // 2. Redistributions in binary form must reproduce the above copyright
- // notice, this list of conditions and the following disclaimer in the
- // documentation and/or other materials provided with the distribution.
- //
- // 3. Neither the name of the Corporation nor the names of the
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
- // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
- // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- //
- // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
- //
- // ************************************************************************
- //@HEADER
- */
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
 
 #ifndef KOKKOSP_PROFILE_SECTION_HPP
 #define KOKKOSP_PROFILE_SECTION_HPP
@@ -53,59 +54,51 @@ namespace Kokkos {
 namespace Profiling {
 
 class ProfilingSection {
+ public:
+  ProfilingSection(const std::string& sectionName) : secName(sectionName) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::createProfileSection(secName, &secID);
+    }
+#else
+    secID = 0;
+#endif
+  }
 
-public:
-	ProfilingSection(const std::string& sectionName) :
-		secName(sectionName) {
+  void start() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::startSection(secID);
+    }
+#endif
+  }
 
-		#if defined( KOKKOS_ENABLE_PROFILING )
-			if(Kokkos::Profiling::profileLibraryLoaded()) {
-				Kokkos::Profiling::createProfileSection(secName, &secID);
-			}
-		#else
-			secID = 0;
-		#endif
-	}
-	
-	void start() {
-		#if defined( KOKKOS_ENABLE_PROFILING )
-			if(Kokkos::Profiling::profileLibraryLoaded()) {
-				Kokkos::Profiling::startSection(secID);
-			}
-		#endif
-	}
-	
-	void stop() {
-		#if defined( KOKKOS_ENABLE_PROFILING )
-			if(Kokkos::Profiling::profileLibraryLoaded()) {
-				Kokkos::Profiling::stopSection(secID);
-			}
-		#endif
-	}
-	
-	~ProfilingSection() {
-		#if defined( KOKKOS_ENABLE_PROFILING )
-			if(Kokkos::Profiling::profileLibraryLoaded()) {
-				Kokkos::Profiling::destroyProfileSection(secID);
-			}
-		#endif
-	}
-	
-	std::string getName() {
-		return secName;
-	}
-	
-	uint32_t getSectionID() {
-		return secID;
-	}
-	
-protected:
-	const std::string secName;
-	uint32_t secID;
+  void stop() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::stopSection(secID);
+    }
+#endif
+  }
 
+  ~ProfilingSection() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::destroyProfileSection(secID);
+    }
+#endif
+  }
+
+  std::string getName() { return secName; }
+
+  uint32_t getSectionID() { return secID; }
+
+ protected:
+  const std::string secName;
+  uint32_t secID;
 };
 
-}
-}
+}  // namespace Profiling
+}  // namespace Kokkos
 
-#endif
\ No newline at end of file
+#endif
diff --git a/lib/kokkos/core/src/Kokkos_Qthreads.hpp b/lib/kokkos/core/src/Kokkos_Qthreads.hpp
index 16702f864736a17bd9c77980d06de949d50d688b..e10bd48593aa19b43c75acaba74c16911338b497 100644
--- a/lib/kokkos/core/src/Kokkos_Qthreads.hpp
+++ b/lib/kokkos/core/src/Kokkos_Qthreads.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_QTHREADS_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS )
+#if defined(KOKKOS_ENABLE_QTHREADS)
 
 #include <Kokkos_Core_fwd.hpp>
 
@@ -76,9 +77,9 @@ namespace Impl {
 
 class QthreadsExec;
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -86,26 +87,26 @@ namespace Kokkos {
 
 /** \brief  Execution space supported by Qthreads */
 class Qthreads {
-public:
+ public:
   //! \name Type declarations that all Kokkos devices must provide.
   //@{
 
   //! Tag this class as an execution space
-  typedef Qthreads                 execution_space;
-  typedef Kokkos::HostSpace        memory_space;
+  typedef Qthreads execution_space;
+  typedef Kokkos::HostSpace memory_space;
   //! This execution space preferred device_type
-  typedef Kokkos::Device< execution_space, memory_space > device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
-  typedef Kokkos::LayoutRight      array_layout;
-  typedef memory_space::size_type  size_type;
+  typedef Kokkos::LayoutRight array_layout;
+  typedef memory_space::size_type size_type;
 
-  typedef ScratchMemorySpace< Qthreads > scratch_memory_space;
+  typedef ScratchMemorySpace<Qthreads> scratch_memory_space;
 
   //@}
   /*------------------------------------------------------------------------*/
 
   /** \brief  Initialization will construct one or more instances */
-  static Qthreads & instance( int = 0 );
+  static Qthreads& instance(int = 0);
 
   /** \brief  Set the execution space to a "sleep" state.
    *
@@ -143,11 +144,11 @@ public:
   /** \brief  Return maximum amount of concurrency */
   static int concurrency();
 
-  static void initialize( int thread_count );
+  static void initialize(int thread_count);
   static void finalize();
 
   /** \brief Print configuration information to the given output stream. */
-  static void print_configuration( std::ostream &, const bool detail = false );
+  static void print_configuration(std::ostream&, const bool detail = false);
 
   int shepherd_size() const;
   int shepherd_worker_size() const;
@@ -155,7 +156,7 @@ public:
   static const char* name();
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -163,39 +164,33 @@ namespace Kokkos {
 
 namespace Impl {
 
-template<>
-struct MemorySpaceAccess
-  < Kokkos::Qthreads::memory_space
-  , Kokkos::Qthreads::scratch_memory_space
-  >
-{
+template <>
+struct MemorySpaceAccess<Kokkos::Qthreads::memory_space,
+                         Kokkos::Qthreads::scratch_memory_space> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = false };
+  enum { deepcopy = false };
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::Qthreads::memory_space
-  , Kokkos::Qthreads::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::Qthreads::memory_space, Kokkos::Qthreads::scratch_memory_space> {
   enum { value = true };
-  inline static void verify( void ) {}
-  inline static void verify( const void * ) {}
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
 #include <Qthreads/Kokkos_QthreadsExec.hpp>
 #include <Qthreads/Kokkos_Qthreads_Parallel.hpp>
-//#include <Qthreads/Kokkos_Qthreads_Task.hpp> // Uncomment when Tasking working.
-//#include <Qthreads/Kokkos_Qthreads_TaskQueue.hpp> // Uncomment when Tasking working.
-
-#endif // #define KOKKOS_ENABLE_QTHREADS
-#endif // #define KOKKOS_QTHREADS_HPP
+//#include <Qthreads/Kokkos_Qthreads_Task.hpp> // Uncomment when Tasking
+// working. #include <Qthreads/Kokkos_Qthreads_TaskQueue.hpp> // Uncomment when
+// Tasking working.
 
+#endif  // #define KOKKOS_ENABLE_QTHREADS
+#endif  // #define KOKKOS_QTHREADS_HPP
diff --git a/lib/kokkos/core/src/Kokkos_ROCm.hpp b/lib/kokkos/core/src/Kokkos_ROCm.hpp
index 96207e73c65e0822c320c501fec642530ad8839e..57113452b8402b0fd40af7a791ee000ce874e704 100644
--- a/lib/kokkos/core/src/Kokkos_ROCm.hpp
+++ b/lib/kokkos/core/src/Kokkos_ROCm.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,12 +47,12 @@
 
 #include <Kokkos_Core_fwd.hpp>
 
-#if defined( KOKKOS_ENABLE_ROCM )
+#if defined(KOKKOS_ENABLE_ROCM)
 
 class dim3 {
-public:
-int x,y,z;
-dim3(int _x, int _y, int _z):x(_x),y(_y),z(_z) {};
+ public:
+  int x, y, z;
+  dim3(int _x, int _y, int _z) : x(_x), y(_y), z(_z){};
 };
 
 #include <ROCm/hc_math_std.hpp>
@@ -74,9 +75,9 @@ dim3(int _x, int _y, int _z):x(_x),y(_y),z(_z) {};
 #include <hc_am.hpp>
 #include <amp_math.h>
 
-#if defined( __HCC_ACCELERATOR__ )
+#if defined(__HCC_ACCELERATOR__)
 
-using namespace ::Concurrency::precise_math ;
+using namespace ::Concurrency::precise_math;
 
 #endif
 
@@ -84,9 +85,9 @@ using namespace ::Concurrency::precise_math ;
 
 namespace Kokkos {
 namespace Impl {
-class ROCmExec ;
-} // namespace Impl
-} // namespace Kokkos
+class ROCmExec;
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -95,30 +96,29 @@ namespace Experimental {
 /// \class ROCm
 /// \brief Kokkos device for multicore processors in the host memory space.
 class ROCm {
-public:
+ public:
   //------------------------------------
   //! \name Type declarations that all Kokkos devices must provide.
   //@{
 
   //! Tag this class as a kokkos execution space
-  typedef ROCm                  execution_space ;
-  typedef ROCmSpace             memory_space ;
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef ROCm execution_space;
+  typedef ROCmSpace memory_space;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
-  typedef LayoutLeft            array_layout ;
-  typedef HostSpace::size_type  size_type ;
+  typedef LayoutLeft array_layout;
+  typedef HostSpace::size_type size_type;
 
-  typedef ScratchMemorySpace< ROCm > scratch_memory_space ;
+  typedef ScratchMemorySpace<ROCm> scratch_memory_space;
 
   ~ROCm() {}
   ROCm();
-//  explicit ROCm( const int instance_id );
-
-  ROCm( ROCm && ) = default ;
-  ROCm( const ROCm & ) = default ;
-  ROCm & operator = ( ROCm && ) = default ;
-  ROCm & operator = ( const ROCm & ) = default ;
+  //  explicit ROCm( const int instance_id );
 
+  ROCm(ROCm&&)      = default;
+  ROCm(const ROCm&) = default;
+  ROCm& operator=(ROCm&&) = default;
+  ROCm& operator=(const ROCm&) = default;
 
   //@}
   //------------------------------------
@@ -126,7 +126,7 @@ public:
   //@{
 
   KOKKOS_INLINE_FUNCTION static int in_parallel() {
-#if defined( __HCC_ACCELERATOR__ )
+#if defined(__HCC_ACCELERATOR__)
     return true;
 #else
     return false;
@@ -134,122 +134,109 @@ public:
   }
 
   /** \brief  Set the device in a "sleep" state. */
-  static bool sleep() ;
+  static bool sleep();
 
   /** \brief Wake the device from the 'sleep' state. A noop for OpenMP. */
-  static bool wake() ;
+  static bool wake();
 
   /** \brief Wait until all dispatched functors complete. A noop for OpenMP. */
   static void impl_static_fence();
 
-  #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   static void fence();
-  #else
+#else
   void fence() const;
-  #endif
-
+#endif
 
   /// \brief Print configuration information to the given output stream.
-  static void print_configuration( std::ostream & , const bool detail = false );
+  static void print_configuration(std::ostream&, const bool detail = false);
 
   /// \brief Free any resources being consumed by the device.
-  static void finalize() ;
+  static void finalize();
 
   /** \brief  Initialize the device.
    *
    */
   struct SelectDevice {
-    int rocm_device_id ;
+    int rocm_device_id;
     SelectDevice() : rocm_device_id(1) {}
-    explicit SelectDevice( int id ) : rocm_device_id( id+1 ) {}
+    explicit SelectDevice(int id) : rocm_device_id(id + 1) {}
   };
 
-  int          rocm_device() const { return m_device ; }
-  bool         isAPU();
-  bool         isAPU(int device);
+  int rocm_device() const { return m_device; }
+  bool isAPU();
+  bool isAPU(int device);
 
-  static void initialize( const SelectDevice = SelectDevice());
+  static void initialize(const SelectDevice = SelectDevice());
 
   static int is_initialized();
 
-//  static size_type device_arch();
+  //  static size_type device_arch();
 
-//  static size_type detect_device_count();
+  //  static size_type detect_device_count();
 
-
-  static int concurrency() ;
+  static int concurrency();
   static const char* name();
-private:
-  int          m_device ;
 
+ private:
+  int m_device;
 };
-}
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 
-template<>
-struct MemorySpaceAccess
-  < Kokkos::Experimental::ROCmSpace
-  , Kokkos::Experimental::ROCm::scratch_memory_space
-  >
-{
+template <>
+struct MemorySpaceAccess<Kokkos::Experimental::ROCmSpace,
+                         Kokkos::Experimental::ROCm::scratch_memory_space> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = false };
+  enum { deepcopy = false };
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::Experimental::ROCm::memory_space
-  , Kokkos::Experimental::ROCm::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::Experimental::ROCm::memory_space,
+    Kokkos::Experimental::ROCm::scratch_memory_space> {
   enum { value = true };
-  KOKKOS_INLINE_FUNCTION static void verify( void ) { }
-  KOKKOS_INLINE_FUNCTION static void verify( const void * ) { }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {}
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {}
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::HostSpace
-  , Kokkos::Experimental::ROCm::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::HostSpace, Kokkos::Experimental::ROCm::scratch_memory_space> {
   enum { value = false };
-  inline static void verify( void ) { Kokkos::Experimental::ROCmSpace::access_error(); }
-  inline static void verify( const void * p ) { Kokkos::Experimental::ROCmSpace::access_error(p); }
+  inline static void verify(void) {
+    Kokkos::Experimental::ROCmSpace::access_error();
+  }
+  inline static void verify(const void* p) {
+    Kokkos::Experimental::ROCmSpace::access_error(p);
+  }
 };
 
-} // namespace Experimental
-} // namespace Kokkos
-
-
-
-
+}  // namespace Impl
+}  // namespace Kokkos
 
 #define threadIdx_x (hc_get_workitem_id(0))
 #define threadIdx_y (hc_get_workitem_id(1))
 #define threadIdx_z (hc_get_workitem_id(2))
 
-#define blockIdx_x  (hc_get_group_id(0))
-#define blockIdx_y  (hc_get_group_id(1))
-#define blockIdx_z  (hc_get_group_id(2))
+#define blockIdx_x (hc_get_group_id(0))
+#define blockIdx_y (hc_get_group_id(1))
+#define blockIdx_z (hc_get_group_id(2))
 
-#define blockDim_x  (hc_get_group_size(0))
-#define blockDim_y  (hc_get_group_size(1))
-#define blockDim_z  (hc_get_group_size(2))
-
-#define gridDim_x   (hc_get_num_groups(0))
-#define gridDim_y   (hc_get_num_groups(1))
-#define gridDim_z   (hc_get_num_groups(2))
+#define blockDim_x (hc_get_group_size(0))
+#define blockDim_y (hc_get_group_size(1))
+#define blockDim_z (hc_get_group_size(2))
 
+#define gridDim_x (hc_get_num_groups(0))
+#define gridDim_y (hc_get_num_groups(1))
+#define gridDim_z (hc_get_num_groups(2))
 
 #include <ROCm/Kokkos_ROCm_Parallel.hpp>
 #include <ROCm/Kokkos_ROCm_Task.hpp>
 
 #endif
 #endif
-
-
diff --git a/lib/kokkos/core/src/Kokkos_ROCmSpace.hpp b/lib/kokkos/core/src/Kokkos_ROCmSpace.hpp
index c0b7158fde797a23c8de2e5ad548ee03d2c57e7b..df13a7c2aae6f6f1794dff03a91c591c9da7fc00 100644
--- a/lib/kokkos/core/src/Kokkos_ROCmSpace.hpp
+++ b/lib/kokkos/core/src/Kokkos_ROCmSpace.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -46,7 +47,7 @@
 
 #include <Kokkos_Core_fwd.hpp>
 
-#if defined( KOKKOS_ENABLE_ROCM )
+#if defined(KOKKOS_ENABLE_ROCM)
 
 #include <iosfwd>
 #include <typeinfo>
@@ -54,7 +55,6 @@
 
 #include <Kokkos_HostSpace.hpp>
 
-
 /*--------------------------------------------------------------------------*/
 
 namespace Kokkos {
@@ -62,30 +62,28 @@ namespace Experimental {
 /** \brief  ROCm on-device memory management */
 
 class ROCmSpace {
-public:
-
+ public:
   //! Tag this class as a kokkos memory space
-  typedef ROCmSpace             memory_space ;
-  typedef Kokkos::Experimental::ROCm          execution_space ;
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef ROCmSpace memory_space;
+  typedef Kokkos::Experimental::ROCm execution_space;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
-  typedef unsigned int          size_type ;
+  typedef unsigned int size_type;
 
   /*--------------------------------*/
 
   ROCmSpace();
-  ROCmSpace( ROCmSpace && rhs ) = default ;
-  ROCmSpace( const ROCmSpace & rhs ) = default ;
-  ROCmSpace & operator = ( ROCmSpace && rhs ) = default ;
-  ROCmSpace & operator = ( const ROCmSpace & rhs ) = default ;
-  ~ROCmSpace() = default ;
+  ROCmSpace(ROCmSpace&& rhs)      = default;
+  ROCmSpace(const ROCmSpace& rhs) = default;
+  ROCmSpace& operator=(ROCmSpace&& rhs) = default;
+  ROCmSpace& operator=(const ROCmSpace& rhs) = default;
+  ~ROCmSpace()                               = default;
 
   /**\brief  Allocate untracked memory in the rocm space */
-  void * allocate( const size_t arg_alloc_size ) const ;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the rocm space */
-  void deallocate( void * const arg_alloc_ptr
-                 , const size_t arg_alloc_size ) const ;
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return m_name; };
@@ -93,23 +91,23 @@ public:
   /*--------------------------------*/
   /** \brief  Error reporting for HostSpace attempt to access ROCmSpace */
   static void access_error();
-  static void access_error( const void * const );
-
-private:
+  static void access_error(const void* const);
 
-  int  m_device ; ///< Which ROCm device
+ private:
+  int m_device;  ///< Which ROCm device
 
   static constexpr const char* m_name = "ROCm";
-  friend class Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void > ;
+  friend class Kokkos::Impl::SharedAllocationRecord<
+      Kokkos::Experimental::ROCmSpace, void>;
 };
 
-} // namespace Experimental
+}  // namespace Experimental
 
 namespace Impl {
 
-void * rocm_device_allocate(int);
-void * rocm_hostpinned_allocate(int);
-void rocm_device_free(void * );
+void* rocm_device_allocate(int);
+void* rocm_hostpinned_allocate(int);
+void rocm_device_free(void*);
 
 /// \brief Initialize lock array for arbitrary size atomics.
 ///
@@ -128,7 +126,8 @@ void init_lock_arrays_rocm_space();
 /// If the array is not yet allocated it will do so.
 int* atomic_lock_array_rocm_space_ptr(bool deallocate = false);
 
-/// \brief Retrieve the pointer to the scratch array for team and thread private global memory.
+/// \brief Retrieve the pointer to the scratch array for team and thread private
+/// global memory.
 ///
 /// Team and Thread private scratch allocations in
 /// global memory are acquired via locks.
@@ -143,55 +142,51 @@ int* scratch_lock_array_rocm_space_ptr(bool deallocate = false);
 /// This function retrieves the lock array pointer.
 /// If the array is not yet allocated it will do so.
 int* threadid_lock_array_rocm_space_ptr(bool deallocate = false);
-}
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
-
 namespace Kokkos {
 namespace Experimental {
 /** \brief  Host memory that is accessible to ROCm execution space
  *          through ROCm's host-pinned memory allocation.
  */
 class ROCmHostPinnedSpace {
-public:
-
+ public:
   //! Tag this class as a kokkos memory space
   /** \brief  Memory is in HostSpace so use the HostSpace::execution_space */
-  typedef HostSpace::execution_space  execution_space ;
-  typedef ROCmHostPinnedSpace         memory_space ;
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
-  typedef unsigned int                size_type ;
+  typedef HostSpace::execution_space execution_space;
+  typedef ROCmHostPinnedSpace memory_space;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
+  typedef unsigned int size_type;
 
   /*--------------------------------*/
 
   ROCmHostPinnedSpace();
-  ROCmHostPinnedSpace( ROCmHostPinnedSpace && rhs ) = default ;
-  ROCmHostPinnedSpace( const ROCmHostPinnedSpace & rhs ) = default ;
-  ROCmHostPinnedSpace & operator = ( ROCmHostPinnedSpace && rhs ) = default ;
-  ROCmHostPinnedSpace & operator = ( const ROCmHostPinnedSpace & rhs ) = default ;
-  ~ROCmHostPinnedSpace() = default ;
+  ROCmHostPinnedSpace(ROCmHostPinnedSpace&& rhs)      = default;
+  ROCmHostPinnedSpace(const ROCmHostPinnedSpace& rhs) = default;
+  ROCmHostPinnedSpace& operator=(ROCmHostPinnedSpace&& rhs) = default;
+  ROCmHostPinnedSpace& operator=(const ROCmHostPinnedSpace& rhs) = default;
+  ~ROCmHostPinnedSpace()                                         = default;
 
   /**\brief  Allocate untracked memory in the space */
-  void * allocate( const size_t arg_alloc_size ) const ;
+  void* allocate(const size_t arg_alloc_size) const;
 
   /**\brief  Deallocate untracked memory in the space */
-  void deallocate( void * const arg_alloc_ptr
-                 , const size_t arg_alloc_size ) const ;
+  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
 
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return m_name; };
 
-private:
-
+ private:
   static constexpr const char* m_name = "ROCmHostPinned";
 
   /*--------------------------------*/
 };
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -199,65 +194,71 @@ private:
 namespace Kokkos {
 namespace Impl {
 
-static_assert( Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCmSpace >::assignable , "" );
+static_assert(Kokkos::Impl::MemorySpaceAccess<
+                  Kokkos::Experimental::ROCmSpace,
+                  Kokkos::Experimental::ROCmSpace>::assignable,
+              "");
 
 //----------------------------------------
 
-template<>
-struct MemorySpaceAccess< Kokkos::HostSpace , Kokkos::Experimental::ROCmSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace> {
   enum { assignable = false };
   enum { accessible = false };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::HostSpace , Kokkos::Experimental::ROCmHostPinnedSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::HostSpace,
+                         Kokkos::Experimental::ROCmHostPinnedSpace> {
   // HostSpace::execution_space == ROCmHostPinnedSpace::execution_space
   enum { assignable = true };
   enum { accessible = true };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
 //----------------------------------------
 
-template<>
-struct MemorySpaceAccess< Kokkos::Experimental::ROCmSpace , Kokkos::HostSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::Experimental::ROCmSpace, Kokkos::HostSpace> {
   enum { assignable = false };
   enum { accessible = false };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCmHostPinnedSpace > {
+template <>
+struct MemorySpaceAccess<Kokkos::Experimental::ROCmSpace,
+                         Kokkos::Experimental::ROCmHostPinnedSpace> {
   // ROCmSpace::execution_space != ROCmHostPinnedSpace::execution_space
   enum { assignable = false };
-  enum { accessible = true }; // ROCmSpace::execution_space
-  enum { deepcopy   = true };
+  enum { accessible = true };  // ROCmSpace::execution_space
+  enum { deepcopy = true };
 };
 
-
 //----------------------------------------
 // ROCmHostPinnedSpace::execution_space == HostSpace::execution_space
 // ROCmHostPinnedSpace accessible to both ROCm and Host
 
-template<>
-struct MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::HostSpace > {
-  enum { assignable = false }; // Cannot access from ROCm
-  enum { accessible = true };  // ROCmHostPinnedSpace::execution_space
-  enum { deepcopy   = true };
+template <>
+struct MemorySpaceAccess<Kokkos::Experimental::ROCmHostPinnedSpace,
+                         Kokkos::HostSpace> {
+  enum { assignable = false };  // Cannot access from ROCm
+  enum { accessible = true };   // ROCmHostPinnedSpace::execution_space
+  enum { deepcopy = true };
 };
 
-template<>
-struct MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCmSpace > {
-  enum { assignable = false }; // Cannot access from Host
+template <>
+struct MemorySpaceAccess<Kokkos::Experimental::ROCmHostPinnedSpace,
+                         Kokkos::Experimental::ROCmSpace> {
+  enum { assignable = false };  // Cannot access from Host
   enum { accessible = false };
-  enum { deepcopy   = true };
+  enum { deepcopy = true };
 };
 
-};
+};  // namespace Impl
 //----------------------------------------
 
-} // namespace Kokkos::Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -265,171 +266,187 @@ struct MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Ex
 namespace Kokkos {
 namespace Impl {
 
-hc::completion_future DeepCopyAsyncROCm( void * dst , const void * src , size_t n);
+hc::completion_future DeepCopyAsyncROCm(void* dst, const void* src, size_t n);
 
-template<> struct DeepCopy< Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCm>
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Kokkos::Experimental::ROCm & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<Kokkos::Experimental::ROCmSpace,
+                Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCm> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Kokkos::Experimental::ROCm&, void* dst, const void* src,
+           size_t);
 };
 
-template<> struct DeepCopy< Kokkos::Experimental::ROCmSpace , HostSpace , Kokkos::Experimental::ROCm >
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Kokkos::Experimental::ROCm & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace,
+                Kokkos::Experimental::ROCm> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Kokkos::Experimental::ROCm&, void* dst, const void* src,
+           size_t);
 };
 
-template<> struct DeepCopy< HostSpace , Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCm >
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Kokkos::Experimental::ROCm & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace,
+                Kokkos::Experimental::ROCm> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Kokkos::Experimental::ROCm&, void* dst, const void* src,
+           size_t);
 };
 
-template<class ExecutionSpace> struct DeepCopy< Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCmSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCm >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::ROCmSpace,
+                Kokkos::Experimental::ROCmSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<Kokkos::Experimental::ROCmSpace,
+                   Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCm>(
+        dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    hc::completion_future fut = DeepCopyAsyncROCm (dst,src,n);
+    hc::completion_future fut = DeepCopyAsyncROCm(dst, src, n);
     fut.wait();
-//    DeepCopy (dst,src,n);
+    //    DeepCopy (dst,src,n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< Kokkos::Experimental::ROCmSpace , HostSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< Kokkos::Experimental::ROCmSpace , HostSpace , Kokkos::Experimental::ROCm>( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace,
+                   Kokkos::Experimental::ROCm>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopy (dst,src,n);
+    DeepCopy(dst, src, n);
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< HostSpace , Kokkos::Experimental::ROCmSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCm >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace,
+                   Kokkos::Experimental::ROCm>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopy (dst,src,n);
+    DeepCopy(dst, src, n);
   }
 };
 
-template<> struct DeepCopy< Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCm>
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Kokkos::Experimental::ROCm & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,
+                Kokkos::Experimental::ROCmHostPinnedSpace,
+                Kokkos::Experimental::ROCm> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Kokkos::Experimental::ROCm&, void* dst, const void* src,
+           size_t);
 };
 
-template<> struct DeepCopy< Kokkos::Experimental::ROCmHostPinnedSpace , HostSpace , Kokkos::Experimental::ROCm >
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Kokkos::Experimental::ROCm & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace, HostSpace,
+                Kokkos::Experimental::ROCm> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Kokkos::Experimental::ROCm&, void* dst, const void* src,
+           size_t);
 };
 
-template<> struct DeepCopy< HostSpace , Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCm >
-{
-  DeepCopy( void * dst , const void * src , size_t );
-  DeepCopy( const Kokkos::Experimental::ROCm & , void * dst , const void * src , size_t );
+template <>
+struct DeepCopy<HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace,
+                Kokkos::Experimental::ROCm> {
+  DeepCopy(void* dst, const void* src, size_t);
+  DeepCopy(const Kokkos::Experimental::ROCm&, void* dst, const void* src,
+           size_t);
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCmHostPinnedSpace , ExecutionSpace>
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< Kokkos::Experimental::ROCmSpace , HostSpace , Kokkos::Experimental::ROCm >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::ROCmSpace,
+                Kokkos::Experimental::ROCmHostPinnedSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace,
+                   Kokkos::Experimental::ROCm>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    hc::completion_future fut = DeepCopyAsyncROCm (dst,src,n);
+    hc::completion_future fut = DeepCopyAsyncROCm(dst, src, n);
     fut.wait();
-//    DeepCopyROCm (dst,src,n);
+    //    DeepCopyROCm (dst,src,n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCmSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCm >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,
+                Kokkos::Experimental::ROCmSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace,
+                   Kokkos::Experimental::ROCm>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    hc::completion_future fut = DeepCopyAsyncROCm (dst,src,n);
+    hc::completion_future fut = DeepCopyAsyncROCm(dst, src, n);
     fut.wait();
-//    DeepCopyROCm (dst,src,n);
+    //    DeepCopyROCm (dst,src,n);
   }
 };
 
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,
+                Kokkos::Experimental::ROCmHostPinnedSpace, ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,
+                   Kokkos::Experimental::ROCmHostPinnedSpace,
+                   Kokkos::Experimental::ROCm>(dst, src, n);
+  }
 
-
-template<class ExecutionSpace> struct DeepCopy< Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCmHostPinnedSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCm >( dst , src , n ); }
-
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-//    hc::completion_future fut = DeepCopyAsyncROCm (dst,src,n);
-//    fut.wait();
-//    DeepCopyAsyncROCm (dst,src,n);
-    DeepCopy (dst,src,n);
+    //    hc::completion_future fut = DeepCopyAsyncROCm (dst,src,n);
+    //    fut.wait();
+    //    DeepCopyAsyncROCm (dst,src,n);
+    DeepCopy(dst, src, n);
   }
 };
 
-template<class ExecutionSpace> struct DeepCopy< Kokkos::Experimental::ROCmHostPinnedSpace , HostSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< Kokkos::Experimental::ROCmHostPinnedSpace , HostSpace , Kokkos::Experimental::ROCm>( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace, HostSpace,
+                ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace, HostSpace,
+                   Kokkos::Experimental::ROCm>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopy (dst,src,n);
+    DeepCopy(dst, src, n);
   }
 };
 
-template<class ExecutionSpace>
-struct DeepCopy< HostSpace , Kokkos::Experimental::ROCmHostPinnedSpace , ExecutionSpace >
-{
-  inline
-  DeepCopy( void * dst , const void * src , size_t n )
-  { (void) DeepCopy< HostSpace , Kokkos::Experimental::ROCmHostPinnedSpace , Kokkos::Experimental::ROCm >( dst , src , n ); }
+template <class ExecutionSpace>
+struct DeepCopy<HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace,
+                ExecutionSpace> {
+  inline DeepCopy(void* dst, const void* src, size_t n) {
+    (void)DeepCopy<HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace,
+                   Kokkos::Experimental::ROCm>(dst, src, n);
+  }
 
-  inline
-  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n )
-  {
+  inline DeepCopy(const ExecutionSpace& exec, void* dst, const void* src,
+                  size_t n) {
     exec.fence();
-    DeepCopy (dst,src,n);
+    DeepCopy(dst, src, n);
   }
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -438,60 +455,70 @@ namespace Kokkos {
 namespace Impl {
 
 /** Running in ROCmSpace attempting to access HostSpace: error */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::Experimental::ROCmSpace , Kokkos::HostSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::Experimental::ROCmSpace,
+                                           Kokkos::HostSpace> {
   enum { value = false };
-  KOKKOS_INLINE_FUNCTION static void verify( void )
-    { Kokkos::abort("ROCm code attempted to access HostSpace memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {
+    Kokkos::abort("ROCm code attempted to access HostSpace memory");
+  }
 
-  KOKKOS_INLINE_FUNCTION static void verify( const void * )
-    { Kokkos::abort("ROCm code attempted to access HostSpace memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {
+    Kokkos::abort("ROCm code attempted to access HostSpace memory");
+  }
 };
 
 /** Running in ROCmSpace accessing ROCmHostPinnedSpace: ok */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::Experimental::ROCmSpace , Kokkos::Experimental::ROCmHostPinnedSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::Experimental::ROCmSpace,
+    Kokkos::Experimental::ROCmHostPinnedSpace> {
   enum { value = true };
-  KOKKOS_INLINE_FUNCTION static void verify( void ) { }
-  KOKKOS_INLINE_FUNCTION static void verify( const void * ) { }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {}
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {}
 };
 
 /** Running in ROCmSpace attempting to access an unknown space: error */
-template< class OtherSpace >
+template <class OtherSpace>
 struct VerifyExecutionCanAccessMemorySpace<
-  typename enable_if< ! is_same<Kokkos::Experimental::ROCmSpace,OtherSpace>::value , Kokkos::Experimental::ROCmSpace >::type ,
-  OtherSpace >
-{
+    typename enable_if<
+        !is_same<Kokkos::Experimental::ROCmSpace, OtherSpace>::value,
+        Kokkos::Experimental::ROCmSpace>::type,
+    OtherSpace> {
   enum { value = false };
-  KOKKOS_INLINE_FUNCTION static void verify( void )
-    { Kokkos::abort("ROCm code attempted to access unknown Space memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(void) {
+    Kokkos::abort("ROCm code attempted to access unknown Space memory");
+  }
 
-  KOKKOS_INLINE_FUNCTION static void verify( const void * )
-    { Kokkos::abort("ROCm code attempted to access unknown Space memory"); }
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {
+    Kokkos::abort("ROCm code attempted to access unknown Space memory");
+  }
 };
 
 //----------------------------------------------------------------------------
 /** Running in HostSpace attempting to access ROCmSpace */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::Experimental::ROCmSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<Kokkos::HostSpace,
+                                           Kokkos::Experimental::ROCmSpace> {
   enum { value = false };
-  inline static void verify( void ) { Kokkos::Experimental::ROCmSpace::access_error(); }
-  inline static void verify( const void * p ) { Kokkos::Experimental::ROCmSpace::access_error(p); }
+  inline static void verify(void) {
+    Kokkos::Experimental::ROCmSpace::access_error();
+  }
+  inline static void verify(const void* p) {
+    Kokkos::Experimental::ROCmSpace::access_error(p);
+  }
 };
 
 /** Running in HostSpace accessing ROCmHostPinnedSpace is OK */
-template<>
-struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::Experimental::ROCmHostPinnedSpace >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace> {
   enum { value = true };
-  KOKKOS_INLINE_FUNCTION static void verify( void ) {}
-  KOKKOS_INLINE_FUNCTION static void verify( const void * ) {}
+  KOKKOS_INLINE_FUNCTION static void verify(void) {}
+  KOKKOS_INLINE_FUNCTION static void verify(const void*) {}
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -499,128 +526,112 @@ struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::Experime
 namespace Kokkos {
 namespace Impl {
 
-template<>
-class SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >
-  : public SharedAllocationRecord< void , void >
-{
-private:
+template <>
+class SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  typedef SharedAllocationRecord< void , void >  RecordBase ;
-
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
-
-  static void deallocate( RecordBase * );
+  static void deallocate(RecordBase*);
 
 #ifdef KOKKOS_DEBUG
-  static RecordBase s_root_record ;
+  static RecordBase s_root_record;
 #endif
 
-  const Kokkos::Experimental::ROCmSpace m_space ;
-
-protected:
+  const Kokkos::Experimental::ROCmSpace m_space;
 
+ protected:
   ~SharedAllocationRecord();
 
-  SharedAllocationRecord( const Kokkos::Experimental::ROCmSpace        & arg_space
-                        , const std::string              & arg_label
-                        , const size_t                     arg_alloc_size
-                        , const RecordBase::function_type  arg_dealloc = & deallocate
-                        );
+  SharedAllocationRecord(
+      const Kokkos::Experimental::ROCmSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
 
-public:
+ public:
+  std::string get_label() const;
 
-  std::string get_label() const ;
-
-  static SharedAllocationRecord * allocate( const Kokkos::Experimental::ROCmSpace &  arg_space
-                                          , const std::string       &  arg_label
-                                          , const size_t               arg_alloc_size );
+  static SharedAllocationRecord* allocate(
+      const Kokkos::Experimental::ROCmSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size);
 
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::Experimental::ROCmSpace & arg_space
-                         , const std::string & arg_label
-                         , const size_t arg_alloc_size );
+  static void* allocate_tracked(
+      const Kokkos::Experimental::ROCmSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
+  static void deallocate_tracked(void* const arg_alloc_ptr);
 
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
 
-  static void print_records( std::ostream & , const Kokkos::Experimental::ROCmSpace & , bool detail = false );
+  static void print_records(std::ostream&,
+                            const Kokkos::Experimental::ROCmSpace&,
+                            bool detail = false);
 };
 
-template<>
-class SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >
-  : public SharedAllocationRecord< void , void >
-{
-private:
-
-  typedef SharedAllocationRecord< void , void >  RecordBase ;
+template <>
+class SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace, void>
+    : public SharedAllocationRecord<void, void> {
+ private:
+  typedef SharedAllocationRecord<void, void> RecordBase;
 
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static void deallocate( RecordBase * );
+  static void deallocate(RecordBase*);
 
 #ifdef KOKKOS_DEBUG
-  static RecordBase s_root_record ;
+  static RecordBase s_root_record;
 #endif
 
-  const Kokkos::Experimental::ROCmHostPinnedSpace m_space ;
-
-protected:
+  const Kokkos::Experimental::ROCmHostPinnedSpace m_space;
 
+ protected:
   ~SharedAllocationRecord();
   SharedAllocationRecord() : RecordBase(), m_space() {}
 
-  SharedAllocationRecord( const Kokkos::Experimental::ROCmHostPinnedSpace     & arg_space
-                        , const std::string              & arg_label
-                        , const size_t                     arg_alloc_size
-                        , const RecordBase::function_type  arg_dealloc = & deallocate
-                        );
-
-public:
+  SharedAllocationRecord(
+      const Kokkos::Experimental::ROCmHostPinnedSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size,
+      const RecordBase::function_type arg_dealloc = &deallocate);
 
-  std::string get_label() const ;
+ public:
+  std::string get_label() const;
 
-  static SharedAllocationRecord * allocate( const Kokkos::Experimental::ROCmHostPinnedSpace &  arg_space
-                                          , const std::string          &  arg_label
-                                          , const size_t                  arg_alloc_size
-                                          );
+  static SharedAllocationRecord* allocate(
+      const Kokkos::Experimental::ROCmHostPinnedSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size);
   /**\brief  Allocate tracked memory in the space */
-  static
-  void * allocate_tracked( const Kokkos::Experimental::ROCmHostPinnedSpace & arg_space
-                         , const std::string & arg_label
-                         , const size_t arg_alloc_size );
+  static void* allocate_tracked(
+      const Kokkos::Experimental::ROCmHostPinnedSpace& arg_space,
+      const std::string& arg_label, const size_t arg_alloc_size);
 
   /**\brief  Reallocate tracked memory in the space */
-  static
-  void * reallocate_tracked( void * const arg_alloc_ptr
-                           , const size_t arg_alloc_size );
+  static void* reallocate_tracked(void* const arg_alloc_ptr,
+                                  const size_t arg_alloc_size);
 
   /**\brief  Deallocate tracked memory in the space */
-  static
-  void deallocate_tracked( void * const arg_alloc_ptr );
+  static void deallocate_tracked(void* const arg_alloc_ptr);
 
+  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
 
-  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
-
-  static void print_records( std::ostream & , const Kokkos::Experimental::ROCmHostPinnedSpace & , bool detail = false );
+  static void print_records(std::ostream&,
+                            const Kokkos::Experimental::ROCmHostPinnedSpace&,
+                            bool detail = false);
 };
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_ROCM ) */
 #endif /* #define KOKKOS_ROCMSPACE_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_ScratchSpace.hpp b/lib/kokkos/core/src/Kokkos_ScratchSpace.hpp
index 86d803ccc972ad274043f708fac5e35400418b3e..c2337f08a111d5e875977f8fbf9af3d64e108362 100644
--- a/lib/kokkos/core/src/Kokkos_ScratchSpace.hpp
+++ b/lib/kokkos/core/src/Kokkos_ScratchSpace.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -55,158 +56,157 @@ namespace Kokkos {
 /** \brief  Scratch memory space associated with an execution space.
  *
  */
-template< class ExecSpace >
+template <class ExecSpace>
 class ScratchMemorySpace {
-  static_assert (is_execution_space<ExecSpace>::value,"Instantiating ScratchMemorySpace on non-execution-space type.");
-public:
+  static_assert(
+      is_execution_space<ExecSpace>::value,
+      "Instantiating ScratchMemorySpace on non-execution-space type.");
 
+ public:
   // Alignment of memory chunks returned by 'get'
   // must be a power of two
   enum { ALIGN = 8 };
 
-private:
-
-  mutable char * m_iter_L0 ;
-  char *         m_end_L0 ;
-  mutable char * m_iter_L1 ;
-  char *         m_end_L1 ;
-
+ private:
+  mutable char* m_iter_L0;
+  char* m_end_L0;
+  mutable char* m_iter_L1;
+  char* m_end_L1;
 
   mutable int m_multiplier;
   mutable int m_offset;
   mutable int m_default_level;
 
   ScratchMemorySpace();
-  ScratchMemorySpace & operator = ( const ScratchMemorySpace & );
-
-  enum { MASK = ALIGN - 1 }; // Alignment used by View::shmem_size
+  ScratchMemorySpace& operator=(const ScratchMemorySpace&);
 
-public:
+  enum { MASK = ALIGN - 1 };  // Alignment used by View::shmem_size
 
+ public:
   //! Tag this class as a memory space
-  typedef ScratchMemorySpace                memory_space ;
-  typedef ExecSpace                         execution_space ;
+  typedef ScratchMemorySpace memory_space;
+  typedef ExecSpace execution_space;
   //! This execution space preferred device_type
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
-  typedef typename ExecSpace::array_layout  array_layout ;
-  typedef typename ExecSpace::size_type     size_type ;
+  typedef typename ExecSpace::array_layout array_layout;
+  typedef typename ExecSpace::size_type size_type;
 
-  template< typename IntType >
-  KOKKOS_INLINE_FUNCTION static
-  IntType align( const IntType & size )
-    { return ( size + MASK ) & ~MASK ; }
+  template <typename IntType>
+  KOKKOS_INLINE_FUNCTION static IntType align(const IntType& size) {
+    return (size + MASK) & ~MASK;
+  }
 
-  template< typename IntType >
-  KOKKOS_INLINE_FUNCTION
-  void* get_shmem (const IntType& size, int level = -1) const {
-    if(level == -1)
-      level = m_default_level;
-    if(level == 0) {
-      void* tmp = m_iter_L0 + m_offset * align (size);
-      if (m_end_L0 < (m_iter_L0 += align (size) * m_multiplier)) {
-        m_iter_L0 -= align (size) * m_multiplier; // put it back like it was
-        #ifdef KOKKOS_DEBUG
+  template <typename IntType>
+  KOKKOS_INLINE_FUNCTION void* get_shmem(const IntType& size,
+                                         int level = -1) const {
+    if (level == -1) level = m_default_level;
+    if (level == 0) {
+      void* tmp = m_iter_L0 + m_offset * align(size);
+      if (m_end_L0 < (m_iter_L0 += align(size) * m_multiplier)) {
+        m_iter_L0 -= align(size) * m_multiplier;  // put it back like it was
+#ifdef KOKKOS_DEBUG
         // mfh 23 Jun 2015: printf call consumes 25 registers
         // in a CUDA build, so only print in debug mode.  The
         // function still returns NULL if not enough memory.
-        printf ("ScratchMemorySpace<...>::get_shmem: Failed to allocate "
-                "%ld byte(s); remaining capacity is %ld byte(s)\n", long(size),
-                long(m_end_L0-m_iter_L0));
-        #endif // KOKKOS_DEBUG
+        printf(
+            "ScratchMemorySpace<...>::get_shmem: Failed to allocate "
+            "%ld byte(s); remaining capacity is %ld byte(s)\n",
+            long(size), long(m_end_L0 - m_iter_L0));
+#endif  // KOKKOS_DEBUG
         tmp = 0;
       }
       return tmp;
     } else {
-      void* tmp = m_iter_L1 + m_offset * align (size);
-      if (m_end_L1 < (m_iter_L1 += align (size) * m_multiplier)) {
-        m_iter_L1 -= align (size) * m_multiplier; // put it back like it was
-        #ifdef KOKKOS_DEBUG
+      void* tmp = m_iter_L1 + m_offset * align(size);
+      if (m_end_L1 < (m_iter_L1 += align(size) * m_multiplier)) {
+        m_iter_L1 -= align(size) * m_multiplier;  // put it back like it was
+#ifdef KOKKOS_DEBUG
         // mfh 23 Jun 2015: printf call consumes 25 registers
         // in a CUDA build, so only print in debug mode.  The
         // function still returns NULL if not enough memory.
-        printf ("ScratchMemorySpace<...>::get_shmem: Failed to allocate "
-                "%ld byte(s); remaining capacity is %ld byte(s)\n", long(size),
-                long(m_end_L1-m_iter_L1));
-        #endif // KOKKOS_DEBUG
+        printf(
+            "ScratchMemorySpace<...>::get_shmem: Failed to allocate "
+            "%ld byte(s); remaining capacity is %ld byte(s)\n",
+            long(size), long(m_end_L1 - m_iter_L1));
+#endif  // KOKKOS_DEBUG
         tmp = 0;
       }
       return tmp;
-
     }
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void* get_shmem_aligned (const ptrdiff_t size, const ptrdiff_t alignment, int level = -1) const {
-    if(level == -1)
-      level = m_default_level;
-    if(level == 0) {
-
-      char* previous = m_iter_L0;
-      const ptrdiff_t missalign = size_t(m_iter_L0)%alignment;
-      if(missalign) m_iter_L0 += alignment-missalign;
+  void* get_shmem_aligned(const ptrdiff_t size, const ptrdiff_t alignment,
+                          int level = -1) const {
+    if (level == -1) level = m_default_level;
+    if (level == 0) {
+      char* previous            = m_iter_L0;
+      const ptrdiff_t missalign = size_t(m_iter_L0) % alignment;
+      if (missalign) m_iter_L0 += alignment - missalign;
 
       void* tmp = m_iter_L0 + m_offset * size;
       if (m_end_L0 < (m_iter_L0 += size * m_multiplier)) {
-        m_iter_L0 = previous; // put it back like it was
-        #ifdef KOKKOS_DEBUG
+        m_iter_L0 = previous;  // put it back like it was
+#ifdef KOKKOS_DEBUG
         // mfh 23 Jun 2015: printf call consumes 25 registers
         // in a CUDA build, so only print in debug mode.  The
         // function still returns NULL if not enough memory.
-        printf ("ScratchMemorySpace<...>::get_shmem: Failed to allocate "
-                "%ld byte(s); remaining capacity is %ld byte(s)\n", long(size),
-                long(m_end_L0-m_iter_L0));
-        #endif // KOKKOS_DEBUG
+        printf(
+            "ScratchMemorySpace<...>::get_shmem: Failed to allocate "
+            "%ld byte(s); remaining capacity is %ld byte(s)\n",
+            long(size), long(m_end_L0 - m_iter_L0));
+#endif  // KOKKOS_DEBUG
         tmp = 0;
       }
       return tmp;
     } else {
-
-      char* previous = m_iter_L1;
-      const ptrdiff_t missalign =  size_t(m_iter_L1)%alignment;
-      if(missalign) m_iter_L1 += alignment-missalign;
+      char* previous            = m_iter_L1;
+      const ptrdiff_t missalign = size_t(m_iter_L1) % alignment;
+      if (missalign) m_iter_L1 += alignment - missalign;
 
       void* tmp = m_iter_L1 + m_offset * size;
       if (m_end_L1 < (m_iter_L1 += size * m_multiplier)) {
-        m_iter_L1 = previous; // put it back like it was
-        #ifdef KOKKOS_DEBUG
+        m_iter_L1 = previous;  // put it back like it was
+#ifdef KOKKOS_DEBUG
         // mfh 23 Jun 2015: printf call consumes 25 registers
         // in a CUDA build, so only print in debug mode.  The
         // function still returns NULL if not enough memory.
-        printf ("ScratchMemorySpace<...>::get_shmem: Failed to allocate "
-                "%ld byte(s); remaining capacity is %ld byte(s)\n", long(size),
-                long(m_end_L1-m_iter_L1));
-        #endif // KOKKOS_DEBUG
+        printf(
+            "ScratchMemorySpace<...>::get_shmem: Failed to allocate "
+            "%ld byte(s); remaining capacity is %ld byte(s)\n",
+            long(size), long(m_end_L1 - m_iter_L1));
+#endif  // KOKKOS_DEBUG
         tmp = 0;
       }
       return tmp;
-
     }
   }
 
-  template< typename IntType >
-  KOKKOS_INLINE_FUNCTION
-  ScratchMemorySpace( void * ptr_L0 , const IntType & size_L0 , void * ptr_L1 = NULL , const IntType & size_L1 = 0)
-    : m_iter_L0( (char *) ptr_L0 )
-    , m_end_L0(  m_iter_L0 + size_L0 )
-    , m_iter_L1( (char *) ptr_L1 )
-    , m_end_L1(  m_iter_L1 + size_L1 )
-    , m_multiplier( 1 )
-    , m_offset( 0 )
-    , m_default_level( 0 )
-    {}
+  template <typename IntType>
+  KOKKOS_INLINE_FUNCTION ScratchMemorySpace(void* ptr_L0,
+                                            const IntType& size_L0,
+                                            void* ptr_L1           = NULL,
+                                            const IntType& size_L1 = 0)
+      : m_iter_L0((char*)ptr_L0),
+        m_end_L0(m_iter_L0 + size_L0),
+        m_iter_L1((char*)ptr_L1),
+        m_end_L1(m_iter_L1 + size_L1),
+        m_multiplier(1),
+        m_offset(0),
+        m_default_level(0) {}
 
   KOKKOS_INLINE_FUNCTION
-  const ScratchMemorySpace& set_team_thread_mode(const int& level, const int& multiplier, const int& offset) const {
+  const ScratchMemorySpace& set_team_thread_mode(const int& level,
+                                                 const int& multiplier,
+                                                 const int& offset) const {
     m_default_level = level;
-    m_multiplier = multiplier;
-    m_offset = offset;
+    m_multiplier    = multiplier;
+    m_offset        = offset;
     return *this;
   }
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_SCRATCHSPACE_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Serial.hpp b/lib/kokkos/core/src/Kokkos_Serial.hpp
index 5821b0c0c5ecc57e393bbadf0917a2096bd9f875..e30598be21244e28b565f2b2c6bb80300ee339b6 100644
--- a/lib/kokkos/core/src/Kokkos_Serial.hpp
+++ b/lib/kokkos/core/src/Kokkos_Serial.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,7 +49,7 @@
 #define KOKKOS_SERIAL_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_SERIAL )
+#if defined(KOKKOS_ENABLE_SERIAL)
 
 #include <cstddef>
 #include <iosfwd>
@@ -83,24 +84,24 @@ namespace Kokkos {
 /// threads, or if you want to explore different combinations of MPI
 /// and shared-memory parallel programming models.
 class Serial {
-public:
+ public:
   //! \name Type declarations that all Kokkos devices must provide.
   //@{
 
   //! Tag this class as an execution space:
-  typedef Serial                execution_space ;
+  typedef Serial execution_space;
   //! The size_type typedef best suited for this device.
-  typedef HostSpace::size_type  size_type ;
+  typedef HostSpace::size_type size_type;
   //! This device's preferred memory space.
-  typedef HostSpace             memory_space ;
+  typedef HostSpace memory_space;
   //! This execution space preferred device_type
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
   //! This device's preferred array layout.
-  typedef LayoutRight           array_layout ;
+  typedef LayoutRight array_layout;
 
   /// \brief  Scratch memory space
-  typedef ScratchMemorySpace< Kokkos::Serial >  scratch_memory_space ;
+  typedef ScratchMemorySpace<Kokkos::Serial> scratch_memory_space;
 
   //@}
 
@@ -110,7 +111,7 @@ public:
   /// For the Serial device, this method <i>always</i> returns false,
   /// because parallel_for or parallel_reduce with the Serial device
   /// always execute sequentially.
-  inline static int in_parallel() { return false ; }
+  inline static int in_parallel() { return false; }
 
   /// \brief Wait until all dispatched functors complete.
   ///
@@ -120,26 +121,27 @@ public:
   /// device have completed.
   static void impl_static_fence() {}
 
-  #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   static void fence() {}
-  #else
+#else
   void fence() const {}
-  #endif
+#endif
 
   /** \brief  Return the maximum amount of concurrency.  */
-  static int concurrency() {return 1;}
+  static int concurrency() { return 1; }
 
   //! Print configuration information to the given output stream.
-  static void print_configuration( std::ostream & , const bool /* detail */ = false ) {}
+  static void print_configuration(std::ostream&,
+                                  const bool /* detail */ = false) {}
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   static bool sleep();
   static bool wake();
 
-  static void initialize( unsigned threads_count = 1 ,
-                          unsigned use_numa_count = 0 ,
-                          unsigned use_cores_per_numa = 0 ,
-                          bool allow_asynchronous_threadpool = false);
+  static void initialize(unsigned threads_count             = 1,
+                         unsigned use_numa_count            = 0,
+                         unsigned use_cores_per_numa        = 0,
+                         bool allow_asynchronous_threadpool = false);
 
   static bool is_initialized();
 
@@ -148,12 +150,14 @@ public:
 
   //--------------------------------------------------------------------------
 
-  inline static int thread_pool_size( int = 0 ) { return 1 ; }
-  KOKKOS_INLINE_FUNCTION static int thread_pool_rank() { return 0 ; }
+  inline static int thread_pool_size(int = 0) { return 1; }
+  KOKKOS_INLINE_FUNCTION static int thread_pool_rank() { return 0; }
 
   //--------------------------------------------------------------------------
 
-  KOKKOS_INLINE_FUNCTION static unsigned hardware_thread_id() { return thread_pool_rank(); }
+  KOKKOS_INLINE_FUNCTION static unsigned hardware_thread_id() {
+    return thread_pool_rank();
+  }
   inline static unsigned max_hardware_threads() { return thread_pool_size(0); }
 #else
   static void impl_initialize();
@@ -165,20 +169,24 @@ public:
 
   //--------------------------------------------------------------------------
 
-  inline static int impl_thread_pool_size( int = 0 ) { return 1 ; }
-  KOKKOS_INLINE_FUNCTION static int impl_thread_pool_rank() { return 0 ; }
+  inline static int impl_thread_pool_size(int = 0) { return 1; }
+  KOKKOS_INLINE_FUNCTION static int impl_thread_pool_rank() { return 0; }
 
   //--------------------------------------------------------------------------
 
-  KOKKOS_INLINE_FUNCTION static unsigned impl_hardware_thread_id() { return impl_thread_pool_rank(); }
-  inline static unsigned impl_max_hardware_threads() { return impl_thread_pool_size(0); }
+  KOKKOS_INLINE_FUNCTION static unsigned impl_hardware_thread_id() {
+    return impl_thread_pool_rank();
+  }
+  inline static unsigned impl_max_hardware_threads() {
+    return impl_thread_pool_size(0);
+  }
 #endif
 
   static const char* name();
   //--------------------------------------------------------------------------
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -186,30 +194,24 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template<>
-struct MemorySpaceAccess
-  < Kokkos::Serial::memory_space
-  , Kokkos::Serial::scratch_memory_space
-  >
-{
+template <>
+struct MemorySpaceAccess<Kokkos::Serial::memory_space,
+                         Kokkos::Serial::scratch_memory_space> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = false };
+  enum { deepcopy = false };
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::Serial::memory_space
-  , Kokkos::Serial::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::Serial::memory_space, Kokkos::Serial::scratch_memory_space> {
   enum { value = true };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -218,247 +220,294 @@ namespace Kokkos {
 namespace Impl {
 
 // Resize thread team data scratch memory
-void serial_resize_thread_team_data( size_t pool_reduce_bytes
-                                   , size_t team_reduce_bytes
-                                   , size_t team_shared_bytes
-                                   , size_t thread_local_bytes );
+void serial_resize_thread_team_data(size_t pool_reduce_bytes,
+                                    size_t team_reduce_bytes,
+                                    size_t team_shared_bytes,
+                                    size_t thread_local_bytes);
 
-HostThreadTeamData * serial_get_thread_team_data();
+HostThreadTeamData* serial_get_thread_team_data();
 
 } /* namespace Impl */
 } /* namespace Kokkos */
 
-
 namespace Kokkos {
 namespace Impl {
 
 /*
  * < Kokkos::Serial , WorkArgTag >
- * < WorkArgTag , Impl::enable_if< std::is_same< Kokkos::Serial , Kokkos::DefaultExecutionSpace >::value >::type >
+ * < WorkArgTag , Impl::enable_if< std::is_same< Kokkos::Serial ,
+ * Kokkos::DefaultExecutionSpace >::value >::type >
  *
  */
-template< class ... Properties >
-class TeamPolicyInternal< Kokkos::Serial , Properties ... >:public PolicyTraits<Properties...>
-{
-private:
-
-  size_t m_team_scratch_size[2] ;
-  size_t m_thread_scratch_size[2] ;
-  int    m_league_size ;
-  int    m_chunk_size;
-
-public:
-
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Serial, Properties...>
+    : public PolicyTraits<Properties...> {
+ private:
+  size_t m_team_scratch_size[2];
+  size_t m_thread_scratch_size[2];
+  int m_league_size;
+  int m_chunk_size;
+
+ public:
   //! Tag this class as a kokkos execution policy
-  typedef TeamPolicyInternal      execution_policy ;
+  typedef TeamPolicyInternal execution_policy;
 
-  typedef PolicyTraits<Properties ... > traits;
+  typedef PolicyTraits<Properties...> traits;
 
   //! Execution space of this execution policy:
-  typedef Kokkos::Serial  execution_space ;
+  typedef Kokkos::Serial execution_space;
 
-  TeamPolicyInternal& operator = (const TeamPolicyInternal& p) {
-    m_league_size = p.m_league_size;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  TeamPolicyInternal& operator=(const TeamPolicyInternal& p) {
+    m_league_size            = p.m_league_size;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
     return *this;
   }
 
-  template<class ExecSpace, class ... OtherProperties >
+  template <class ExecSpace, class... OtherProperties>
   friend class TeamPolicyInternal;
 
-  template< class ... OtherProperties >
-  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::Serial,OtherProperties...>& p) {
-    m_league_size = p.m_league_size;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  template <class... OtherProperties>
+  TeamPolicyInternal(
+      const TeamPolicyInternal<Kokkos::Serial, OtherProperties...>& p) {
+    m_league_size            = p.m_league_size;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
   }
 
-
   //----------------------------------------
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  template< class FunctorType >
-  static
-  int team_size_max( const FunctorType & ) { return 1 ; }
+  template <class FunctorType>
+  static int team_size_max(const FunctorType&) {
+    return 1;
+  }
 
-  template< class FunctorType >
-  static
-  int team_size_recommended( const FunctorType & ) { return 1 ; }
+  template <class FunctorType>
+  static int team_size_recommended(const FunctorType&) {
+    return 1;
+  }
 
-  template< class FunctorType >
-  static
-  int team_size_recommended( const FunctorType & , const int& ) { return 1 ; }
+  template <class FunctorType>
+  static int team_size_recommended(const FunctorType&, const int&) {
+    return 1;
+  }
 #endif
 
-  template<class FunctorType>
-  int team_size_max( const FunctorType&, const ParallelForTag& ) const { return 1 ; }
-  template<class FunctorType>
-  int team_size_max( const FunctorType&, const ParallelReduceTag& ) const { return 1 ; }
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType&, const ParallelForTag& ) const { return 1 ; }
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType&, const ParallelReduceTag& ) const { return 1 ; }
+  template <class FunctorType>
+  int team_size_max(const FunctorType&, const ParallelForTag&) const {
+    return 1;
+  }
+  template <class FunctorType>
+  int team_size_max(const FunctorType&, const ParallelReduceTag&) const {
+    return 1;
+  }
+  template <class FunctorType, class ReducerType>
+  int team_size_max(const FunctorType&, const ReducerType&,
+                    const ParallelReduceTag&) const {
+    return 1;
+  }
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType&, const ParallelForTag&) const {
+    return 1;
+  }
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType&,
+                            const ParallelReduceTag&) const {
+    return 1;
+  }
+  template <class FunctorType, class ReducerType>
+  int team_size_recommended(const FunctorType&, const ReducerType&,
+                            const ParallelReduceTag&) const {
+    return 1;
+  }
 
   //----------------------------------------
 
-  inline int team_size() const { return 1 ; }
-  inline int league_size() const { return m_league_size ; }
-  inline size_t scratch_size(const int& level, int = 0) const { return m_team_scratch_size[level] + m_thread_scratch_size[level]; }
+  inline int team_size() const { return 1; }
+  inline int league_size() const { return m_league_size; }
+  inline size_t scratch_size(const int& level, int = 0) const {
+    return m_team_scratch_size[level] + m_thread_scratch_size[level];
+  }
 
-  inline static
-  int vector_length_max()
-    { return 1024; } // Use arbitrary large number, is meant as a vectorizable length
+  inline static int vector_length_max() {
+    return 1024;
+  }  // Use arbitrary large number, is meant as a vectorizable length
 
-  inline static
-  int scratch_size_max(int level)
-  { return (level==0?
-        1024*32:
-        20*1024*1024);
+  inline static int scratch_size_max(int level) {
+    return (level == 0 ? 1024 * 32 : 20 * 1024 * 1024);
   }
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal( const execution_space &
-            , int league_size_request
+  TeamPolicyInternal(const execution_space&, int league_size_request
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-            , int team_size_request
+                     ,
+                     int team_size_request
 #else
-            , int /* team_size_request */
+                     ,
+                     int /* team_size_request */
 #endif
-            , int /* vector_length_request */ = 1 )
-    : m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_league_size( league_size_request )
-    , m_chunk_size ( 32 )
-    {
-      #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-      if(team_size_request > 1) Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
-      #endif
-    }
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_league_size(league_size_request),
+        m_chunk_size(32) {
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE
+    if (team_size_request > 1)
+      Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
+#endif
+  }
+
+  TeamPolicyInternal(const execution_space&, int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_league_size(league_size_request),
+        m_chunk_size(32) {}
 
-  TeamPolicyInternal( const execution_space &
-            , int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int /* vector_length_request */ = 1 )
-    : m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_league_size( league_size_request )
-    , m_chunk_size ( 32 )
-    {}
-
-  TeamPolicyInternal( int league_size_request
+  TeamPolicyInternal(int league_size_request
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-            , int team_size_request
+                     ,
+                     int team_size_request
 #else
-            , int /* team_size_request */
+                     ,
+                     int /* team_size_request */
 #endif
-            , int /* vector_length_request */ = 1 )
-    : m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_league_size( league_size_request )
-    , m_chunk_size ( 32 )
-    {
-      #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-      if(team_size_request > 1) Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
-      #endif
-    }
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_league_size(league_size_request),
+        m_chunk_size(32) {
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE
+    if (team_size_request > 1)
+      Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
+#endif
+  }
 
-  TeamPolicyInternal( int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int /* vector_length_request */ = 1 )
-    : m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_league_size( league_size_request )
-    , m_chunk_size ( 32 )
-    {}
+  TeamPolicyInternal(int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_league_size(league_size_request),
+        m_chunk_size(32) {}
 
-  inline int chunk_size() const { return m_chunk_size ; }
+  inline int chunk_size() const { return m_chunk_size; }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal set_chunk_size(typename traits::index_type chunk_size_) const {
+  inline TeamPolicyInternal set_chunk_size(
+      typename traits::index_type chunk_size_) const {
     TeamPolicyInternal p = *this;
-    p.m_chunk_size = chunk_size_;
+    p.m_chunk_size       = chunk_size_;
     return p;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team) const {
+    TeamPolicyInternal p         = *this;
     p.m_team_scratch_size[level] = per_team.value;
     return p;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
-    p.m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
+    p.m_team_scratch_size[level]   = per_team.value;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 #else
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal& set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal& set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(const int& level,
+                                              const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-  typedef Impl::HostThreadTeamMember< Kokkos::Serial >  member_type ;
+  typedef Impl::HostThreadTeamMember<Kokkos::Serial> member_type;
 
-protected:
+ protected:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal internal_set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal internal_set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
@@ -474,339 +523,280 @@ protected:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType ,
-                   Kokkos::RangePolicy< Traits ... > ,
-                   Kokkos::Serial
-                 >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
-
-  const FunctorType m_functor ;
-  const Policy      m_policy ;
-
-  template< class TagType >
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec() const
-    {
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( i );
-      }
-    }
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Serial> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  template< class TagType >
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec() const
-    {
-      const TagType t{} ;
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( t , i );
-      }
+  template <class TagType>
+  typename std::enable_if<std::is_same<TagType, void>::value>::type exec()
+      const {
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(i);
     }
+  }
 
-public:
+  template <class TagType>
+  typename std::enable_if<!std::is_same<TagType, void>::value>::type exec()
+      const {
+    const TagType t{};
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(t, i);
+    }
+  }
 
-  inline
-  void execute() const
-    { this-> template exec< typename Policy::work_tag >(); }
+ public:
+  inline void execute() const {
+    this->template exec<typename Policy::work_tag>();
+  }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
 /*--------------------------------------------------------------------------*/
 
-template< class FunctorType , class ReducerType , class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::RangePolicy< Traits ... >
-                    , ReducerType
-                    , Kokkos::Serial
-                    >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
-  typedef typename Policy::work_tag                                  WorkTag ;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+                     Kokkos::Serial> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::work_tag WorkTag;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
 
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
-  typedef FunctorAnalysis< FunctorPatternInterface::REDUCE , Policy , FunctorType > Analysis ;
+  typedef FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, FunctorType>
+      Analysis;
 
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd >  ValueInit ;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
 
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
 
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
 
-  template< class TagType >
-  inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec( reference_type update ) const
-    {
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( i , update );
-      }
+  template <class TagType>
+  inline typename std::enable_if<std::is_same<TagType, void>::value>::type exec(
+      reference_type update) const {
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(i, update);
     }
+  }
 
-  template< class TagType >
-  inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec( reference_type update ) const
-    {
-      const TagType t{} ;
-
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( t , i , update );
-      }
-    }
+  template <class TagType>
+  inline typename std::enable_if<!std::is_same<TagType, void>::value>::type
+  exec(reference_type update) const {
+    const TagType t{};
 
-public:
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(t, i, update);
+    }
+  }
 
-  inline
-  void execute() const
-    {
-      const size_t pool_reduce_size =
-        Analysis::value_size( ReducerConditional::select(m_functor , m_reducer) );
-      const size_t team_reduce_size  = 0 ; // Never shrinks
-      const size_t team_shared_size  = 0 ; // Never shrinks
-      const size_t thread_local_size = 0 ; // Never shrinks
+ public:
+  inline void execute() const {
+    const size_t pool_reduce_size =
+        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
+    const size_t team_reduce_size  = 0;  // Never shrinks
+    const size_t team_shared_size  = 0;  // Never shrinks
+    const size_t thread_local_size = 0;  // Never shrinks
 
-      serial_resize_thread_team_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    serial_resize_thread_team_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
-      HostThreadTeamData & data = *serial_get_thread_team_data();
+    HostThreadTeamData& data = *serial_get_thread_team_data();
 
-      pointer_type ptr =
+    pointer_type ptr =
         m_result_ptr ? m_result_ptr : pointer_type(data.pool_reduce_local());
 
-      reference_type update =
-        ValueInit::init(  ReducerConditional::select(m_functor , m_reducer) , ptr );
+    reference_type update =
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer), ptr);
 
-      this-> template exec< WorkTag >( update );
+    this->template exec<WorkTag>(update);
 
-      Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::
-        final(  ReducerConditional::select(m_functor , m_reducer) , ptr );
-    }
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), ptr);
+  }
 
-  template< class HostViewType >
-  ParallelReduce( const FunctorType  & arg_functor ,
-                  const Policy       & arg_policy ,
-                  const HostViewType & arg_result_view ,
-                  typename std::enable_if<
-                               Kokkos::is_view< HostViewType >::value &&
-                              !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result_view.data() )
-    {
-      static_assert( Kokkos::is_view< HostViewType >::value
-        , "Kokkos::Serial reduce result must be a View" );
-
-      static_assert( std::is_same< typename HostViewType::memory_space , HostSpace >::value
-        , "Kokkos::Serial reduce result must be a View in HostSpace" );
-    }
+  template <class HostViewType>
+  ParallelReduce(
+      const FunctorType& arg_functor, const Policy& arg_policy,
+      const HostViewType& arg_result_view,
+      typename std::enable_if<Kokkos::is_view<HostViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result_view.data()) {
+    static_assert(Kokkos::is_view<HostViewType>::value,
+                  "Kokkos::Serial reduce result must be a View");
+
+    static_assert(
+        std::is_same<typename HostViewType::memory_space, HostSpace>::value,
+        "Kokkos::Serial reduce result must be a View in HostSpace");
+  }
 
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ReducerType& reducer )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.view().data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
+  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                        const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 };
 
-
 /*--------------------------------------------------------------------------*/
 
-template< class FunctorType , class ... Traits >
-class ParallelScan< FunctorType
-                  , Kokkos::RangePolicy< Traits ... >
-                  , Kokkos::Serial
-                  >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Serial> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::work_tag WorkTag;
 
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
-  typedef typename Policy::work_tag                                  WorkTag ;
+  typedef FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>
+      Analysis;
 
-  typedef FunctorAnalysis< FunctorPatternInterface::SCAN , Policy , FunctorType > Analysis ;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
 
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType , WorkTag >  ValueInit ;
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
 
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-
-  template< class TagType >
-  inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec( reference_type update ) const
-    {
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( i , update , true );
-      }
+  template <class TagType>
+  inline typename std::enable_if<std::is_same<TagType, void>::value>::type exec(
+      reference_type update) const {
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(i, update, true);
     }
+  }
 
-  template< class TagType >
-  inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec( reference_type update ) const
-    {
-      const TagType t{} ;
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( t , i , update , true );
-      }
+  template <class TagType>
+  inline typename std::enable_if<!std::is_same<TagType, void>::value>::type
+  exec(reference_type update) const {
+    const TagType t{};
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(t, i, update, true);
     }
+  }
 
-public:
-
-  inline
-  void execute() const
-    {
-      const size_t pool_reduce_size = Analysis::value_size( m_functor );
-      const size_t team_reduce_size  = 0 ; // Never shrinks
-      const size_t team_shared_size  = 0 ; // Never shrinks
-      const size_t thread_local_size = 0 ; // Never shrinks
+ public:
+  inline void execute() const {
+    const size_t pool_reduce_size  = Analysis::value_size(m_functor);
+    const size_t team_reduce_size  = 0;  // Never shrinks
+    const size_t team_shared_size  = 0;  // Never shrinks
+    const size_t thread_local_size = 0;  // Never shrinks
 
-      serial_resize_thread_team_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    serial_resize_thread_team_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
-      HostThreadTeamData & data = *serial_get_thread_team_data();
+    HostThreadTeamData& data = *serial_get_thread_team_data();
 
-      reference_type update =
-        ValueInit::init( m_functor , pointer_type(data.pool_reduce_local()) );
+    reference_type update =
+        ValueInit::init(m_functor, pointer_type(data.pool_reduce_local()));
 
-      this-> template exec< WorkTag >( update );
-    }
+    this->template exec<WorkTag>(update);
+  }
 
-  inline
-  ParallelScan( const FunctorType & arg_functor
-              , const Policy      & arg_policy
-              )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    {}
+  inline ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
 /*--------------------------------------------------------------------------*/
-template< class FunctorType , class ReturnType, class ... Traits >
-class ParallelScanWithTotal< FunctorType
-                           , Kokkos::RangePolicy< Traits ... >
-                           , ReturnType
-                           , Kokkos::Serial
-                           >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
-  typedef typename Policy::work_tag                                  WorkTag ;
-
-  typedef FunctorAnalysis< FunctorPatternInterface::SCAN , Policy , FunctorType > Analysis ;
-
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType , WorkTag >  ValueInit ;
-
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
-
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-  ReturnType & m_returnvalue;
-
-  template< class TagType >
-  inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec( reference_type update ) const
-    {
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( i , update , true );
-      }
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::Serial> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::work_tag WorkTag;
+
+  typedef FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>
+      Analysis;
+
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
+
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  ReturnType& m_returnvalue;
+
+  template <class TagType>
+  inline typename std::enable_if<std::is_same<TagType, void>::value>::type exec(
+      reference_type update) const {
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(i, update, true);
     }
+  }
 
-  template< class TagType >
-  inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec( reference_type update ) const
-    {
-      const TagType t{} ;
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        m_functor( t , i , update , true );
-      }
+  template <class TagType>
+  inline typename std::enable_if<!std::is_same<TagType, void>::value>::type
+  exec(reference_type update) const {
+    const TagType t{};
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      m_functor(t, i, update, true);
     }
+  }
 
-public:
-
-  inline
-  void execute()
-    {
-      const size_t pool_reduce_size = Analysis::value_size( m_functor );
-      const size_t team_reduce_size  = 0 ; // Never shrinks
-      const size_t team_shared_size  = 0 ; // Never shrinks
-      const size_t thread_local_size = 0 ; // Never shrinks
+ public:
+  inline void execute() {
+    const size_t pool_reduce_size  = Analysis::value_size(m_functor);
+    const size_t team_reduce_size  = 0;  // Never shrinks
+    const size_t team_shared_size  = 0;  // Never shrinks
+    const size_t thread_local_size = 0;  // Never shrinks
 
-     serial_resize_thread_team_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    serial_resize_thread_team_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
-      HostThreadTeamData & data = *serial_get_thread_team_data();
+    HostThreadTeamData& data = *serial_get_thread_team_data();
 
-      reference_type update =
-        ValueInit::init( m_functor , pointer_type(data.pool_reduce_local()) );
+    reference_type update =
+        ValueInit::init(m_functor, pointer_type(data.pool_reduce_local()));
 
-      this-> template exec< WorkTag >( update );
+    this->template exec<WorkTag>(update);
 
-      m_returnvalue = update;
-    }
+    m_returnvalue = update;
+  }
 
-  inline
-  ParallelScanWithTotal( const FunctorType & arg_functor
-                       , const Policy      & arg_policy
-                       , ReturnType        & arg_returnvalue
-                       )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_returnvalue(  arg_returnvalue )
-    {}
+  inline ParallelScanWithTotal(const FunctorType& arg_functor,
+                               const Policy& arg_policy,
+                               ReturnType& arg_returnvalue)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_returnvalue(arg_returnvalue) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
-
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -815,169 +805,143 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType ,
-                   Kokkos::MDRangePolicy< Traits ... > ,
-                   Kokkos::Serial
-                 >
-{
-private:
-
-  typedef Kokkos::MDRangePolicy< Traits ... > MDRangePolicy ;
-  typedef typename MDRangePolicy::impl_range_policy Policy ;
-
-  typedef typename Kokkos::Impl::HostIterateTile< MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void > iterate_type;
-
-  const FunctorType   m_functor ;
-  const MDRangePolicy m_mdr_policy ;
-  const Policy        m_policy ;
-
-  void
-  exec() const
-    {
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        iterate_type( m_mdr_policy, m_functor )( i );
-      }
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::Serial> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> MDRangePolicy;
+  typedef typename MDRangePolicy::impl_range_policy Policy;
+
+  typedef typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void>
+      iterate_type;
+
+  const FunctorType m_functor;
+  const MDRangePolicy m_mdr_policy;
+  const Policy m_policy;
+
+  void exec() const {
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      iterate_type(m_mdr_policy, m_functor)(i);
     }
+  }
 
-public:
-
-  inline
-  void execute() const
-    { this->exec(); }
+ public:
+  inline void execute() const { this->exec(); }
 
-  inline
-  ParallelFor( const FunctorType   & arg_functor
-             , const MDRangePolicy & arg_policy )
-    : m_functor( arg_functor )
-    , m_mdr_policy(  arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor,
+                     const MDRangePolicy& arg_policy)
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)) {}
 };
 
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
+                     Kokkos::Serial> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> MDRangePolicy;
+  typedef typename MDRangePolicy::impl_range_policy Policy;
 
-template< class FunctorType , class ReducerType , class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::MDRangePolicy< Traits ... >
-                    , ReducerType
-                    , Kokkos::Serial
-                    >
-{
-private:
+  typedef typename MDRangePolicy::work_tag WorkTag;
 
-  typedef Kokkos::MDRangePolicy< Traits ... > MDRangePolicy ;
-  typedef typename MDRangePolicy::impl_range_policy Policy ;
-
-  typedef typename MDRangePolicy::work_tag                                  WorkTag ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
-
-  typedef FunctorAnalysis< FunctorPatternInterface::REDUCE , MDRangePolicy , FunctorType > Analysis ;
-
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd >  ValueInit ;
-
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::value_type      value_type ;
-  typedef typename Analysis::reference_type  reference_type ;
-
-
-  using iterate_type = typename Kokkos::Impl::HostIterateTile< MDRangePolicy
-                                                             , FunctorType
-                                                             , WorkTag
-                                                             , reference_type
-                                                             >;
-
-
-  const FunctorType   m_functor ;
-  const MDRangePolicy m_mdr_policy ;
-  const Policy        m_policy ;
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
-
-  inline
-  void
-  exec( reference_type update ) const
-    {
-      const typename Policy::member_type e = m_policy.end();
-      for ( typename Policy::member_type i = m_policy.begin() ; i < e ; ++i ) {
-        iterate_type( m_mdr_policy, m_functor, update )( i );
-      }
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef FunctorAnalysis<FunctorPatternInterface::REDUCE, MDRangePolicy,
+                          FunctorType>
+      Analysis;
+
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::value_type value_type;
+  typedef typename Analysis::reference_type reference_type;
+
+  using iterate_type =
+      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
+                                             WorkTag, reference_type>;
+
+  const FunctorType m_functor;
+  const MDRangePolicy m_mdr_policy;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+
+  inline void exec(reference_type update) const {
+    const typename Policy::member_type e = m_policy.end();
+    for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
+      iterate_type(m_mdr_policy, m_functor, update)(i);
     }
+  }
 
-public:
-
-  inline
-  void execute() const
-    {
-      const size_t pool_reduce_size =
-        Analysis::value_size( ReducerConditional::select(m_functor , m_reducer) );
-      const size_t team_reduce_size  = 0 ; // Never shrinks
-      const size_t team_shared_size  = 0 ; // Never shrinks
-      const size_t thread_local_size = 0 ; // Never shrinks
+ public:
+  inline void execute() const {
+    const size_t pool_reduce_size =
+        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
+    const size_t team_reduce_size  = 0;  // Never shrinks
+    const size_t team_shared_size  = 0;  // Never shrinks
+    const size_t thread_local_size = 0;  // Never shrinks
 
-      serial_resize_thread_team_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    serial_resize_thread_team_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
-      HostThreadTeamData & data = *serial_get_thread_team_data();
+    HostThreadTeamData& data = *serial_get_thread_team_data();
 
-      pointer_type ptr =
+    pointer_type ptr =
         m_result_ptr ? m_result_ptr : pointer_type(data.pool_reduce_local());
 
-      reference_type update =
-        ValueInit::init(  ReducerConditional::select(m_functor , m_reducer) , ptr );
+    reference_type update =
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer), ptr);
 
-      this-> exec( update );
+    this->exec(update);
 
-      Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::
-        final(  ReducerConditional::select(m_functor , m_reducer) , ptr );
-    }
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), ptr);
+  }
 
-  template< class HostViewType >
-  ParallelReduce( const FunctorType  & arg_functor ,
-                  const MDRangePolicy       & arg_policy ,
-                  const HostViewType & arg_result_view ,
-                  typename std::enable_if<
-                               Kokkos::is_view< HostViewType >::value &&
-                              !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_mdr_policy( arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result_view.data() )
-    {
-      static_assert( Kokkos::is_view< HostViewType >::value
-        , "Kokkos::Serial reduce result must be a View" );
-
-      static_assert( std::is_same< typename HostViewType::memory_space , HostSpace >::value
-        , "Kokkos::Serial reduce result must be a View in HostSpace" );
-    }
+  template <class HostViewType>
+  ParallelReduce(
+      const FunctorType& arg_functor, const MDRangePolicy& arg_policy,
+      const HostViewType& arg_result_view,
+      typename std::enable_if<Kokkos::is_view<HostViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result_view.data()) {
+    static_assert(Kokkos::is_view<HostViewType>::value,
+                  "Kokkos::Serial reduce result must be a View");
+
+    static_assert(
+        std::is_same<typename HostViewType::memory_space, HostSpace>::value,
+        "Kokkos::Serial reduce result must be a View in HostSpace");
+  }
 
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , MDRangePolicy       arg_policy
-                , const ReducerType& reducer )
-    : m_functor( arg_functor )
-    , m_mdr_policy(  arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.view().data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
+  inline ParallelReduce(const FunctorType& arg_functor,
+                        MDRangePolicy arg_policy, const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 };
 
-
-
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -986,225 +950,193 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Properties >
-class ParallelFor< FunctorType
-                 , Kokkos::TeamPolicy< Properties ... >
-                 , Kokkos::Serial
-                 >
-{
-private:
-
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::Serial> {
+ private:
   enum { TEAM_REDUCE_SIZE = 512 };
 
-  typedef TeamPolicyInternal< Kokkos::Serial , Properties ...> Policy ;
-  typedef typename Policy::member_type                       Member ;
-
-  const FunctorType  m_functor ;
-  const int          m_league ;
-  const int          m_shared ;
-
-  template< class TagType >
-  inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec( HostThreadTeamData & data ) const
-    {
-      for ( int ileague = 0 ; ileague < m_league ; ++ileague ) {
-        m_functor( Member(data,ileague,m_league) );
-      }
-    }
+  typedef TeamPolicyInternal<Kokkos::Serial, Properties...> Policy;
+  typedef typename Policy::member_type Member;
 
-  template< class TagType >
-  inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec( HostThreadTeamData & data ) const
-    {
-      const TagType t{} ;
-      for ( int ileague = 0 ; ileague < m_league ; ++ileague ) {
-        m_functor( t , Member(data,ileague,m_league) );
-      }
+  const FunctorType m_functor;
+  const int m_league;
+  const int m_shared;
+
+  template <class TagType>
+  inline typename std::enable_if<std::is_same<TagType, void>::value>::type exec(
+      HostThreadTeamData& data) const {
+    for (int ileague = 0; ileague < m_league; ++ileague) {
+      m_functor(Member(data, ileague, m_league));
     }
+  }
 
-public:
+  template <class TagType>
+  inline typename std::enable_if<!std::is_same<TagType, void>::value>::type
+  exec(HostThreadTeamData& data) const {
+    const TagType t{};
+    for (int ileague = 0; ileague < m_league; ++ileague) {
+      m_functor(t, Member(data, ileague, m_league));
+    }
+  }
 
-  inline
-  void execute() const
-    {
-      const size_t pool_reduce_size  = 0 ; // Never shrinks
-      const size_t team_reduce_size  = TEAM_REDUCE_SIZE ;
-      const size_t team_shared_size  = m_shared ;
-      const size_t thread_local_size = 0 ; // Never shrinks
+ public:
+  inline void execute() const {
+    const size_t pool_reduce_size  = 0;  // Never shrinks
+    const size_t team_reduce_size  = TEAM_REDUCE_SIZE;
+    const size_t team_shared_size  = m_shared;
+    const size_t thread_local_size = 0;  // Never shrinks
 
-      serial_resize_thread_team_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    serial_resize_thread_team_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
-      HostThreadTeamData & data = *serial_get_thread_team_data();
+    HostThreadTeamData& data = *serial_get_thread_team_data();
 
-      this->template exec< typename Policy::work_tag >( data );
-    }
+    this->template exec<typename Policy::work_tag>(data);
+  }
 
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_league(  arg_policy.league_size() )
-    , m_shared( arg_policy.scratch_size(0) +
-                arg_policy.scratch_size(1) +
-                FunctorTeamShmemSize< FunctorType >::value( arg_functor , 1 ) )
-    { }
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor),
+        m_league(arg_policy.league_size()),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(arg_functor, 1)) {}
 };
 
 /*--------------------------------------------------------------------------*/
 
-template< class FunctorType , class ReducerType , class ... Properties >
-class ParallelReduce< FunctorType
-                    , Kokkos::TeamPolicy< Properties ... >
-                    , ReducerType
-                    , Kokkos::Serial
-                    >
-{
-private:
-
+template <class FunctorType, class ReducerType, class... Properties>
+class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                     ReducerType, Kokkos::Serial> {
+ private:
   enum { TEAM_REDUCE_SIZE = 512 };
 
-  typedef TeamPolicyInternal< Kokkos::Serial, Properties ... > Policy ;
+  typedef TeamPolicyInternal<Kokkos::Serial, Properties...> Policy;
 
-  typedef FunctorAnalysis< FunctorPatternInterface::REDUCE , Policy , FunctorType > Analysis ;
+  typedef FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, FunctorType>
+      Analysis;
 
-  typedef typename Policy::member_type                       Member ;
-  typedef typename Policy::work_tag                          WorkTag ;
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::work_tag WorkTag;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
-
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd >  ValueInit ;
-
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
-
-  const FunctorType  m_functor ;
-  const int          m_league ;
-  const ReducerType  m_reducer ;
-        pointer_type m_result_ptr ;
-  const int          m_shared ;
-
-  template< class TagType >
-  inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec( HostThreadTeamData & data , reference_type update ) const
-    {
-      for ( int ileague = 0 ; ileague < m_league ; ++ileague ) {
-        m_functor( Member(data,ileague,m_league) , update );
-      }
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
+
+  const FunctorType m_functor;
+  const int m_league;
+  const ReducerType m_reducer;
+  pointer_type m_result_ptr;
+  const int m_shared;
+
+  template <class TagType>
+  inline typename std::enable_if<std::is_same<TagType, void>::value>::type exec(
+      HostThreadTeamData& data, reference_type update) const {
+    for (int ileague = 0; ileague < m_league; ++ileague) {
+      m_functor(Member(data, ileague, m_league), update);
     }
+  }
 
-  template< class TagType >
-  inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec( HostThreadTeamData & data , reference_type update ) const
-    {
-      const TagType t{} ;
+  template <class TagType>
+  inline typename std::enable_if<!std::is_same<TagType, void>::value>::type
+  exec(HostThreadTeamData& data, reference_type update) const {
+    const TagType t{};
 
-      for ( int ileague = 0 ; ileague < m_league ; ++ileague ) {
-        m_functor( t , Member(data,ileague,m_league) , update );
-      }
+    for (int ileague = 0; ileague < m_league; ++ileague) {
+      m_functor(t, Member(data, ileague, m_league), update);
     }
+  }
 
-public:
-
-  inline
-  void execute() const
-    {
-      const size_t pool_reduce_size  =
-        Analysis::value_size( ReducerConditional::select(m_functor, m_reducer));
-
-      const size_t team_reduce_size  = TEAM_REDUCE_SIZE ;
-      const size_t team_shared_size  = m_shared ;
-      const size_t thread_local_size = 0 ; // Never shrinks
+ public:
+  inline void execute() const {
+    const size_t pool_reduce_size =
+        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
 
-      serial_resize_thread_team_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    const size_t team_reduce_size  = TEAM_REDUCE_SIZE;
+    const size_t team_shared_size  = m_shared;
+    const size_t thread_local_size = 0;  // Never shrinks
 
+    serial_resize_thread_team_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
-      HostThreadTeamData & data = *serial_get_thread_team_data();
+    HostThreadTeamData& data = *serial_get_thread_team_data();
 
-      pointer_type ptr =
+    pointer_type ptr =
         m_result_ptr ? m_result_ptr : pointer_type(data.pool_reduce_local());
 
-      reference_type update =
-        ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , ptr );
+    reference_type update =
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer), ptr);
 
-      this-> template exec< WorkTag >( data , update );
+    this->template exec<WorkTag>(data, update);
 
-      Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::
-        final(  ReducerConditional::select(m_functor , m_reducer) , ptr );
-    }
-
-  template< class ViewType >
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ViewType     & arg_result ,
-                typename std::enable_if<
-                  Kokkos::is_view< ViewType >::value &&
-                  !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_league( arg_policy.league_size() )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result.data() )
-    , m_shared( arg_policy.scratch_size(0) +
-                arg_policy.scratch_size(1) +
-                FunctorTeamShmemSize< FunctorType >::value( m_functor , 1 ) )
-    {
-      static_assert( Kokkos::is_view< ViewType >::value
-        , "Reduction result on Kokkos::Serial must be a Kokkos::View" );
-
-      static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::Serial must be a Kokkos::View in HostSpace" );
-    }
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), ptr);
+  }
 
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ReducerType& reducer )
-    : m_functor( arg_functor )
-    , m_league(  arg_policy.league_size() )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.view().data() )
-    , m_shared( arg_policy.scratch_size(0) +
-                arg_policy.scratch_size(1) +
-                FunctorTeamShmemSize< FunctorType >::value( arg_functor , 1 ) )
-  {
-  /*static_assert( std::is_same< typename ViewType::memory_space
-                          , Kokkos::HostSpace >::value
-  , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
+  template <class ViewType>
+  ParallelReduce(
+      const FunctorType& arg_functor, const Policy& arg_policy,
+      const ViewType& arg_result,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_league(arg_policy.league_size()),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.data()),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(m_functor, 1)) {
+    static_assert(Kokkos::is_view<ViewType>::value,
+                  "Reduction result on Kokkos::Serial must be a Kokkos::View");
+
+    static_assert(
+        std::is_same<typename ViewType::memory_space, Kokkos::HostSpace>::value,
+        "Reduction result on Kokkos::Serial must be a Kokkos::View in "
+        "HostSpace");
   }
 
+  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                        const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_league(arg_policy.league_size()),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(arg_functor, 1)) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                            , Kokkos::HostSpace >::value
+    , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+    );*/
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
-namespace Kokkos { namespace Experimental {
+namespace Kokkos {
+namespace Experimental {
 
-template<>
-class UniqueToken< Serial, UniqueTokenScope::Instance>
-{
-public:
+template <>
+class UniqueToken<Serial, UniqueTokenScope::Instance> {
+ public:
   using execution_space = Serial;
   using size_type       = int;
 
   /// \brief create object size for concurrency on the given instance
   ///
   /// This object should not be shared between instances
-  UniqueToken( execution_space const& = execution_space() ) noexcept {}
+  UniqueToken(execution_space const& = execution_space()) noexcept {}
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
@@ -1212,24 +1144,23 @@ public:
 
   /// \brief acquire value such that 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  int acquire() const  noexcept { return 0; }
+  int acquire() const noexcept { return 0; }
 
   /// \brief release a value acquired by generate
   KOKKOS_INLINE_FUNCTION
-  void release( int ) const noexcept {}
+  void release(int) const noexcept {}
 };
 
-template<>
-class UniqueToken< Serial, UniqueTokenScope::Global>
-{
-public:
+template <>
+class UniqueToken<Serial, UniqueTokenScope::Global> {
+ public:
   using execution_space = Serial;
   using size_type       = int;
 
   /// \brief create object size for concurrency on the given instance
   ///
   /// This object should not be shared between instances
-  UniqueToken( execution_space const& = execution_space() ) noexcept {}
+  UniqueToken(execution_space const& = execution_space()) noexcept {}
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
@@ -1237,17 +1168,17 @@ public:
 
   /// \brief acquire value such that 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  int acquire() const  noexcept { return 0; }
+  int acquire() const noexcept { return 0; }
 
   /// \brief release a value acquired by generate
   KOKKOS_INLINE_FUNCTION
-  void release( int ) const noexcept {}
+  void release(int) const noexcept {}
 };
 
-}} // namespace Kokkos::Experimental
+}  // namespace Experimental
+}  // namespace Kokkos
 
 #include <impl/Kokkos_Serial_Task.hpp>
 
-#endif // defined( KOKKOS_ENABLE_SERIAL )
-#endif /* #define KOKKOS_SERIAL_HPP */
-
+#endif  // defined( KOKKOS_ENABLE_SERIAL )
+#endif  /* #define KOKKOS_SERIAL_HPP */
diff --git a/lib/kokkos/core/src/Kokkos_TaskPolicy.hpp b/lib/kokkos/core/src/Kokkos_TaskPolicy.hpp
index 00bceec2b5dba1f5d664831d3f7c86b625b6f4c3..91e079a0e78e314cdb4b22a42876564f25143a4c 100644
--- a/lib/kokkos/core/src/Kokkos_TaskPolicy.hpp
+++ b/lib/kokkos/core/src/Kokkos_TaskPolicy.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -44,4 +45,3 @@
 // For backward compatibility:
 
 #include <Kokkos_TaskScheduler.hpp>
-
diff --git a/lib/kokkos/core/src/Kokkos_TaskScheduler.hpp b/lib/kokkos/core/src/Kokkos_TaskScheduler.hpp
index 1c3d58af08864e0c67de29eca1884b453fd7f142..4a78d6aca1cbf4717032271f5217d9d23802ca76 100644
--- a/lib/kokkos/core/src/Kokkos_TaskScheduler.hpp
+++ b/lib/kokkos/core/src/Kokkos_TaskScheduler.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 //----------------------------------------------------------------------------
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core_fwd.hpp>
 #include <Kokkos_TaskScheduler_fwd.hpp>
@@ -74,36 +75,33 @@ namespace Impl {
 template <class, class>
 class TaskExec;
 
-} // end namespace Impl
-
-
-template<class ExecSpace, class QueueType>
-class BasicTaskScheduler : public Impl::TaskSchedulerBase
-{
-public:
-
-  using scheduler_type = BasicTaskScheduler;
-  using execution_space = ExecSpace;
-  using queue_type = QueueType;
-  using memory_space = typename queue_type::memory_space;
-  using memory_pool = typename queue_type::memory_pool;
-  using specialization = Impl::TaskQueueSpecialization<BasicTaskScheduler>;
-  using member_type = typename specialization::member_type;
+}  // end namespace Impl
+
+template <class ExecSpace, class QueueType>
+class BasicTaskScheduler : public Impl::TaskSchedulerBase {
+ public:
+  using scheduler_type      = BasicTaskScheduler;
+  using execution_space     = ExecSpace;
+  using queue_type          = QueueType;
+  using memory_space        = typename queue_type::memory_space;
+  using memory_pool         = typename queue_type::memory_pool;
+  using specialization      = Impl::TaskQueueSpecialization<BasicTaskScheduler>;
+  using member_type         = typename specialization::member_type;
   using team_scheduler_type = BasicTaskScheduler;
   template <class Functor>
-  using runnable_task_type = Impl::Task<scheduler_type, typename Functor::value_type, Functor>;
+  using runnable_task_type =
+      Impl::Task<scheduler_type, typename Functor::value_type, Functor>;
   template <class ValueType>
   using future_type = Kokkos::BasicFuture<ValueType, BasicTaskScheduler>;
   template <class FunctorType>
   using future_type_for_functor = future_type<typename FunctorType::value_type>;
 
-private:
-
-  using track_type = Kokkos::Impl::SharedAllocationTracker ;
+ private:
+  using track_type = Kokkos::Impl::SharedAllocationTracker;
   using task_base  = Impl::TaskBase;
 
   track_type m_track;
-  queue_type * m_queue;
+  queue_type* m_queue;
 
   //----------------------------------------
 
@@ -121,17 +119,12 @@ private:
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  BasicTaskScheduler(
-    track_type arg_track,
-    queue_type* arg_queue
-  )
-    : m_track(std::move(arg_track)),
-      m_queue(std::move(arg_queue))
-  { }
+  BasicTaskScheduler(track_type arg_track, queue_type* arg_queue)
+      : m_track(std::move(arg_track)), m_queue(std::move(arg_queue)) {}
 
   KOKKOS_INLINE_FUNCTION
   team_scheduler_type get_team_scheduler(int team_rank) const {
-    return { m_track, &m_queue->get_team_queue(team_rank) };
+    return {m_track, &m_queue->get_team_queue(team_rank)};
   }
 
   //----------------------------------------
@@ -140,25 +133,23 @@ private:
   static constexpr task_base* _get_task_ptr(std::nullptr_t) { return nullptr; }
 
   template <class ValueType>
-  KOKKOS_INLINE_FUNCTION
-  static constexpr task_base* _get_task_ptr(future_type<ValueType>&& f)
-  {
+  KOKKOS_INLINE_FUNCTION static constexpr task_base* _get_task_ptr(
+      future_type<ValueType>&& f) {
     return f.m_task;
   }
 
-  template< int TaskEnum , typename DepTaskType , typename FunctorType >
+  template <int TaskEnum, typename DepTaskType, typename FunctorType>
   KOKKOS_FUNCTION
-  Kokkos::BasicFuture<typename FunctorType::value_type, scheduler_type>
-  _spawn_impl(
-    DepTaskType* arg_predecessor_task,
-    TaskPriority arg_priority,
-    typename task_base::function_type arg_function,
-    typename task_base::destroy_type arg_destroy,
-    FunctorType&& arg_functor
-  )
-  {
-    using functor_future_type = future_type_for_functor<typename std::decay<FunctorType>::type>;
-    using task_type = Impl::Task<BasicTaskScheduler, typename functor_future_type::value_type, FunctorType>;
+      Kokkos::BasicFuture<typename FunctorType::value_type, scheduler_type>
+      _spawn_impl(DepTaskType* arg_predecessor_task, TaskPriority arg_priority,
+                  typename task_base::function_type arg_function,
+                  typename task_base::destroy_type arg_destroy,
+                  FunctorType&& arg_functor) {
+    using functor_future_type =
+        future_type_for_functor<typename std::decay<FunctorType>::type>;
+    using task_type =
+        Impl::Task<BasicTaskScheduler, typename functor_future_type::value_type,
+                   FunctorType>;
 
     //----------------------------------------
     // Give single-thread back-ends an opportunity to clear
@@ -169,25 +160,25 @@ private:
 
     //----------------------------------------
 
-    functor_future_type f ;
+    functor_future_type f;
 
     // Allocate task from memory pool
 
     const size_t alloc_size =
-      m_queue->template spawn_allocation_size< FunctorType >();
+        m_queue->template spawn_allocation_size<FunctorType>();
 
     void* task_storage = m_queue->allocate(alloc_size);
 
     if (task_storage) {
-
       // Placement new construction
       // Reference count starts at two:
       //   +1 for the matching decrement when task is complete
       //   +1 for the future
-      f.m_task = new (task_storage) task_type( std::forward<FunctorType>(arg_functor) );
+      f.m_task =
+          new (task_storage) task_type(std::forward<FunctorType>(arg_functor));
 
-      f.m_task->m_apply      = arg_function;
-      //f.m_task->m_destroy    = arg_destroy;
+      f.m_task->m_apply = arg_function;
+      // f.m_task->m_destroy    = arg_destroy;
       f.m_task->m_queue      = m_queue;
       f.m_task->m_next       = arg_predecessor_task;
       f.m_task->m_ref_count  = 2;
@@ -202,81 +193,70 @@ private:
       // reference count does not need to be incremented for
       // the assignment.
 
-      m_queue->schedule_runnable( f.m_task );
+      m_queue->schedule_runnable(f.m_task);
       // This task may be updated or executed at any moment,
       // even during the call to 'schedule'.
     }
 
     return f;
-
   }
 
-public:
-
-
+ public:
   KOKKOS_INLINE_FUNCTION
   BasicTaskScheduler() : m_track(), m_queue(0) {}
 
   KOKKOS_INLINE_FUNCTION
-  BasicTaskScheduler( BasicTaskScheduler && rhs ) noexcept
-    : m_track(rhs.m_track),  // probably should be a move, but this is deprecated code anyway
-      m_queue(std::move(rhs.m_queue))
-  { }
+  BasicTaskScheduler(BasicTaskScheduler&& rhs) noexcept
+      : m_track(rhs.m_track),  // probably should be a move, but this is
+                               // deprecated code anyway
+        m_queue(std::move(rhs.m_queue)) {}
 
   KOKKOS_INLINE_FUNCTION
-  BasicTaskScheduler( BasicTaskScheduler const & rhs )
-    : m_track(rhs.m_track),
-      m_queue(rhs.m_queue)
-  { }
+  BasicTaskScheduler(BasicTaskScheduler const& rhs)
+      : m_track(rhs.m_track), m_queue(rhs.m_queue) {}
 
   KOKKOS_INLINE_FUNCTION
-  BasicTaskScheduler& operator=(BasicTaskScheduler&& rhs) noexcept
-  {
-    m_track = rhs.m_track;  // probably should be a move, but this is deprecated code anyway
+  BasicTaskScheduler& operator=(BasicTaskScheduler&& rhs) noexcept {
+    m_track = rhs.m_track;  // probably should be a move, but this is deprecated
+                            // code anyway
     m_queue = std::move(rhs.m_queue);
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  BasicTaskScheduler& operator=(BasicTaskScheduler const& rhs)
-  {
+  BasicTaskScheduler& operator=(BasicTaskScheduler const& rhs) {
     m_track = rhs.m_track;
     m_queue = rhs.m_queue;
     return *this;
   }
 
-  explicit BasicTaskScheduler(memory_pool const & arg_memory_pool) noexcept
-    : m_track(), m_queue(0)
-    {
-      typedef Kokkos::Impl::SharedAllocationRecord
-        < memory_space , typename queue_type::Destroy >
-          record_type ;
+  explicit BasicTaskScheduler(memory_pool const& arg_memory_pool) noexcept
+      : m_track(), m_queue(0) {
+    typedef Kokkos::Impl::SharedAllocationRecord<memory_space,
+                                                 typename queue_type::Destroy>
+        record_type;
 
-      record_type * record =
-        record_type::allocate( memory_space()
-                             , "TaskQueue"
-                             , sizeof(queue_type)
-                             );
+    record_type* record =
+        record_type::allocate(memory_space(), "TaskQueue", sizeof(queue_type));
 
-      m_queue = new( record->data() ) queue_type( arg_memory_pool );
+    m_queue = new (record->data()) queue_type(arg_memory_pool);
 
-      record->m_destroy.m_queue = m_queue ;
+    record->m_destroy.m_queue = m_queue;
 
-      m_track.assign_allocated_record_to_uninitialized( record );
-    }
+    m_track.assign_allocated_record_to_uninitialized(record);
+  }
 
-  BasicTaskScheduler( memory_space const & arg_memory_space
-               , size_t const mempool_capacity
-               , unsigned const mempool_min_block_size  // = 1u << 6
-               , unsigned const mempool_max_block_size  // = 1u << 10
-               , unsigned const mempool_superblock_size // = 1u << 12
-               )
-    : BasicTaskScheduler( memory_pool( arg_memory_space
-                                , mempool_capacity
-                                , mempool_min_block_size
-                                , mempool_max_block_size
-                                , mempool_superblock_size ) )
-    {}
+  BasicTaskScheduler(memory_space const& arg_memory_space,
+                     size_t const mempool_capacity,
+                     unsigned const mempool_min_block_size  // = 1u << 6
+                     ,
+                     unsigned const mempool_max_block_size  // = 1u << 10
+                     ,
+                     unsigned const mempool_superblock_size  // = 1u << 12
+                     )
+      : BasicTaskScheduler(memory_pool(
+            arg_memory_space, mempool_capacity, mempool_min_block_size,
+            mempool_max_block_size, mempool_superblock_size)) {}
 
   //----------------------------------------
 
@@ -287,104 +267,89 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  memory_pool * memory() const noexcept
-    { return m_queue ? &( m_queue->m_memory ) : (memory_pool*) 0 ; }
+  memory_pool* memory() const noexcept {
+    return m_queue ? &(m_queue->m_memory) : (memory_pool*)0;
+  }
 
   //----------------------------------------
   /**\brief  Allocation size for a spawned task */
-  template< typename FunctorType >
-  KOKKOS_FUNCTION
-  size_t spawn_allocation_size() const
-    { return m_queue->template spawn_allocation_size< FunctorType >(); }
+  template <typename FunctorType>
+  KOKKOS_FUNCTION size_t spawn_allocation_size() const {
+    return m_queue->template spawn_allocation_size<FunctorType>();
+  }
 
   /**\brief  Allocation size for a when_all aggregate */
   KOKKOS_FUNCTION
-  size_t when_all_allocation_size( int narg ) const
-    { return m_queue->when_all_allocation_size( narg ); }
-
+  size_t when_all_allocation_size(int narg) const {
+    return m_queue->when_all_allocation_size(narg);
+  }
 
   //----------------------------------------
 
   template <int TaskEnum, typename DepFutureType, typename FunctorType>
-  KOKKOS_FUNCTION static
-  Kokkos::BasicFuture<typename FunctorType::value_type, scheduler_type>
-  spawn(
-    Impl::TaskPolicyWithScheduler<TaskEnum, scheduler_type, DepFutureType>&& arg_policy,
-    typename task_base::function_type arg_function,
-    typename task_base::destroy_type arg_destroy,
-    FunctorType&& arg_functor
-  )
-  {
-    return std::move(arg_policy.scheduler()).template _spawn_impl<TaskEnum>(
-      _get_task_ptr(std::move(arg_policy.predecessor())),
-      arg_policy.priority(),
-      arg_function,
-      arg_destroy,
-      std::forward<FunctorType>(arg_functor)
-    );
+  KOKKOS_FUNCTION static Kokkos::BasicFuture<typename FunctorType::value_type,
+                                             scheduler_type>
+  spawn(Impl::TaskPolicyWithScheduler<TaskEnum, scheduler_type, DepFutureType>&&
+            arg_policy,
+        typename task_base::function_type arg_function,
+        typename task_base::destroy_type arg_destroy,
+        FunctorType&& arg_functor) {
+    return std::move(arg_policy.scheduler())
+        .template _spawn_impl<TaskEnum>(
+            _get_task_ptr(std::move(arg_policy.predecessor())),
+            arg_policy.priority(), arg_function, arg_destroy,
+            std::forward<FunctorType>(arg_functor));
   }
 
   template <int TaskEnum, typename DepFutureType, typename FunctorType>
   KOKKOS_FUNCTION
-  future_type_for_functor<typename std::decay<FunctorType>::type>
-  spawn(
-    Impl::TaskPolicyWithPredecessor<TaskEnum, DepFutureType>&& arg_policy,
-    FunctorType&& arg_functor
-  )
-  {
+      future_type_for_functor<typename std::decay<FunctorType>::type>
+      spawn(
+          Impl::TaskPolicyWithPredecessor<TaskEnum, DepFutureType>&& arg_policy,
+          FunctorType&& arg_functor) {
     using task_type = runnable_task_type<FunctorType>;
     typename task_type::function_type const ptr = task_type::apply;
     typename task_type::destroy_type const dtor = task_type::destroy;
 
     return _spawn_impl<TaskEnum>(
-      _get_task_ptr(std::move(arg_policy).predecessor()),
-      arg_policy.priority(),
-      ptr, dtor,
-      std::forward<FunctorType>(arg_functor)
-    );
+        _get_task_ptr(std::move(arg_policy).predecessor()),
+        arg_policy.priority(), ptr, dtor,
+        std::forward<FunctorType>(arg_functor));
   }
 
-  template<typename FunctorType, typename ValueType, typename Scheduler>
-  KOKKOS_FUNCTION static
-  void
-  respawn(
-    FunctorType* arg_self,
-    BasicFuture<ValueType,Scheduler> const & arg_dependence,
-    TaskPriority  const & arg_priority
-  ) {
+  template <typename FunctorType, typename ValueType, typename Scheduler>
+  KOKKOS_FUNCTION static void respawn(
+      FunctorType* arg_self,
+      BasicFuture<ValueType, Scheduler> const& arg_dependence,
+      TaskPriority const& arg_priority) {
     // Precondition: task is in Executing state
 
-    using value_type  = typename FunctorType::value_type ;
-    using task_type = Impl::Task<BasicTaskScheduler, value_type, FunctorType>;
+    using value_type = typename FunctorType::value_type;
+    using task_type  = Impl::Task<BasicTaskScheduler, value_type, FunctorType>;
 
-    task_type * const task = static_cast< task_type * >( arg_self );
+    task_type* const task = static_cast<task_type*>(arg_self);
 
     task->m_priority = static_cast<int>(arg_priority);
 
-    task->add_dependence( arg_dependence.m_task );
+    task->add_dependence(arg_dependence.m_task);
 
     // Postcondition: task is in Executing-Respawn state
   }
 
-  template< typename FunctorType >
-  KOKKOS_FUNCTION static
-  void
-  respawn(
-    FunctorType* arg_self,
-    BasicTaskScheduler const &,
-    TaskPriority  const & arg_priority
-  )
-  {
+  template <typename FunctorType>
+  KOKKOS_FUNCTION static void respawn(FunctorType* arg_self,
+                                      BasicTaskScheduler const&,
+                                      TaskPriority const& arg_priority) {
     // Precondition: task is in Executing state
 
     using value_type = typename FunctorType::value_type;
-    using task_type = Impl::Task<BasicTaskScheduler, value_type, FunctorType>;
+    using task_type  = Impl::Task<BasicTaskScheduler, value_type, FunctorType>;
 
-    task_type * const task = static_cast< task_type * >( arg_self );
+    task_type* const task = static_cast<task_type*>(arg_self);
 
     task->m_priority = static_cast<int>(arg_priority);
 
-    task->add_dependence( (task_base*) 0 );
+    task->add_dependence((task_base*)0);
 
     // Postcondition: task is in Executing-Respawn state
   }
@@ -393,162 +358,153 @@ public:
   /**\brief  Return a future that is complete
    *         when all input futures are complete.
    */
-  template<typename ValueType>
-  KOKKOS_FUNCTION
-  BasicFuture< void, scheduler_type >
-  when_all(BasicFuture<ValueType, BasicTaskScheduler> const arg[], int narg)
-  {
-
-    future_type<void> f ;
-
-    if ( narg ) {
+  template <typename ValueType>
+  KOKKOS_FUNCTION BasicFuture<void, scheduler_type> when_all(
+      BasicFuture<ValueType, BasicTaskScheduler> const arg[], int narg) {
+    future_type<void> f;
 
+    if (narg) {
       queue_type* q = m_queue;
 
-      //BasicTaskScheduler const* scheduler_ptr = nullptr;
+      // BasicTaskScheduler const* scheduler_ptr = nullptr;
 
-      for ( int i = 0 ; i < narg ; ++i ) {
-        task_base * const t = arg[i].m_task ;
-        if ( nullptr != t ) {
+      for (int i = 0; i < narg; ++i) {
+        task_base* const t = arg[i].m_task;
+        if (nullptr != t) {
           // Increment reference count to track subsequent assignment.
-          Kokkos::atomic_increment( &(t->m_ref_count) );
-          if(q != static_cast< queue_type const* >(t->m_queue)) {
-            Kokkos::abort("Kokkos when_all Futures must be in the same scheduler" );
+          Kokkos::atomic_increment(&(t->m_ref_count));
+          if (q != static_cast<queue_type const*>(t->m_queue)) {
+            Kokkos::abort(
+                "Kokkos when_all Futures must be in the same scheduler");
           }
         }
       }
 
-      if ( q != 0 ) { // this should probably handle the queue == 0 case, but this is deprecated code anyway
-
-        size_t const alloc_size = q->when_all_allocation_size( narg );
+      if (q != 0) {  // this should probably handle the queue == 0 case, but
+                     // this is deprecated code anyway
 
-        f.m_task =
-          reinterpret_cast< task_base * >( q->allocate( alloc_size ) );
-        //f.m_scheduler = *scheduler_ptr;
+        size_t const alloc_size = q->when_all_allocation_size(narg);
 
-        if ( f.m_task ) {
+        f.m_task = reinterpret_cast<task_base*>(q->allocate(alloc_size));
+        // f.m_scheduler = *scheduler_ptr;
 
+        if (f.m_task) {
           // Reference count starts at two:
           // +1 to match decrement when task completes
           // +1 for the future
 
-          new( f.m_task ) task_base();
+          new (f.m_task) task_base();
 
-          f.m_task->m_queue = q;
-          f.m_task->m_ref_count = 2 ;
+          f.m_task->m_queue      = q;
+          f.m_task->m_ref_count  = 2;
           f.m_task->m_alloc_size = static_cast<int32_t>(alloc_size);
-          f.m_task->m_dep_count = narg ;
-          f.m_task->m_task_type = task_base::Aggregate ;
+          f.m_task->m_dep_count  = narg;
+          f.m_task->m_task_type  = task_base::Aggregate;
 
           // Assign dependences, reference counts were already incremented
 
-          task_base * volatile * const dep =
-            f.m_task->aggregate_dependences();
+          task_base* volatile* const dep = f.m_task->aggregate_dependences();
 
-          for ( int i = 0 ; i < narg ; ++i ) { dep[i] = arg[i].m_task ; }
+          for (int i = 0; i < narg; ++i) {
+            dep[i] = arg[i].m_task;
+          }
 
           Kokkos::memory_fence();
 
-          q->schedule_aggregate( f.m_task );
+          q->schedule_aggregate(f.m_task);
           // this when_all may be processed at any moment
         }
       }
     }
 
-    return f ;
+    return f;
   }
 
-  template < class F >
-  KOKKOS_FUNCTION
-  BasicFuture< void, scheduler_type >
-  when_all( int narg , F const func )
-    {
-      using input_type  = decltype( func(0) );
+  template <class F>
+  KOKKOS_FUNCTION BasicFuture<void, scheduler_type> when_all(int narg,
+                                                             F const func) {
+    using input_type = decltype(func(0));
 
-      static_assert( is_future< input_type >::value
-                   , "Functor must return a Kokkos::Future" );
+    static_assert(is_future<input_type>::value,
+                  "Functor must return a Kokkos::Future");
 
-      future_type<void> f ;
+    future_type<void> f;
 
-      if ( 0 == narg ) return f ;
+    if (0 == narg) return f;
 
-      size_t const alloc_size = m_queue->when_all_allocation_size( narg );
+    size_t const alloc_size = m_queue->when_all_allocation_size(narg);
 
-      f.m_task =
-        reinterpret_cast< task_base * >( m_queue->allocate( alloc_size ) );
-
-      if ( f.m_task ) {
-
-        // Reference count starts at two:
-        // +1 to match decrement when task completes
-        // +1 for the future
-
-        new( f.m_task ) task_base();
-        //f.m_scheduler = *this;
-
-        //f.m_task->m_scheduler = &f.m_scheduler;
-        f.m_task->m_queue = m_queue;
-        f.m_task->m_ref_count = 2 ;
-        f.m_task->m_alloc_size = static_cast<int32_t>(alloc_size);
-        f.m_task->m_dep_count = narg ;
-        f.m_task->m_task_type = task_base::Aggregate ;
-        //f.m_task->m_apply = nullptr;
-        //f.m_task->m_destroy = nullptr;
-
-        // Assign dependences, reference counts were already incremented
-
-        task_base * volatile * const dep =
-          f.m_task->aggregate_dependences();
-
-        for ( int i = 0 ; i < narg ; ++i ) {
-          const input_type arg_f = func(i);
-          if ( 0 != arg_f.m_task ) {
-
-            // Not scheduled, so task scheduler is not yet set
-            //if ( m_queue != static_cast< BasicTaskScheduler const * >( arg_f.m_task->m_scheduler )->m_queue ) {
-            //  Kokkos::abort("Kokkos when_all Futures must be in the same scheduler" );
-            //}
-            // Increment reference count to track subsequent assignment.
-            Kokkos::atomic_increment( &(arg_f.m_task->m_ref_count) );
-            dep[i] = arg_f.m_task ;
-          }
-        }
+    f.m_task = reinterpret_cast<task_base*>(m_queue->allocate(alloc_size));
 
-        Kokkos::memory_fence();
+    if (f.m_task) {
+      // Reference count starts at two:
+      // +1 to match decrement when task completes
+      // +1 for the future
+
+      new (f.m_task) task_base();
+      // f.m_scheduler = *this;
 
-        m_queue->schedule_aggregate( f.m_task );
-        // this when_all may be processed at any moment
+      // f.m_task->m_scheduler = &f.m_scheduler;
+      f.m_task->m_queue      = m_queue;
+      f.m_task->m_ref_count  = 2;
+      f.m_task->m_alloc_size = static_cast<int32_t>(alloc_size);
+      f.m_task->m_dep_count  = narg;
+      f.m_task->m_task_type  = task_base::Aggregate;
+      // f.m_task->m_apply = nullptr;
+      // f.m_task->m_destroy = nullptr;
+
+      // Assign dependences, reference counts were already incremented
+
+      task_base* volatile* const dep = f.m_task->aggregate_dependences();
+
+      for (int i = 0; i < narg; ++i) {
+        const input_type arg_f = func(i);
+        if (0 != arg_f.m_task) {
+          // Not scheduled, so task scheduler is not yet set
+          // if ( m_queue != static_cast< BasicTaskScheduler const * >(
+          // arg_f.m_task->m_scheduler )->m_queue ) {
+          //  Kokkos::abort("Kokkos when_all Futures must be in the same
+          //  scheduler" );
+          //}
+          // Increment reference count to track subsequent assignment.
+          Kokkos::atomic_increment(&(arg_f.m_task->m_ref_count));
+          dep[i] = arg_f.m_task;
+        }
       }
-      return f ;
+
+      Kokkos::memory_fence();
+
+      m_queue->schedule_aggregate(f.m_task);
+      // this when_all may be processed at any moment
     }
+    return f;
+  }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  int allocation_capacity() const noexcept
-    { return m_queue->m_memory.capacity(); }
+  int allocation_capacity() const noexcept {
+    return m_queue->m_memory.capacity();
+  }
 
   KOKKOS_INLINE_FUNCTION
-  int allocated_task_count() const noexcept
-    { return m_queue->m_count_alloc ; }
+  int allocated_task_count() const noexcept { return m_queue->m_count_alloc; }
 
   KOKKOS_INLINE_FUNCTION
-  int allocated_task_count_max() const noexcept
-    { return m_queue->m_max_alloc ; }
+  int allocated_task_count_max() const noexcept { return m_queue->m_max_alloc; }
 
   KOKKOS_INLINE_FUNCTION
-  long allocated_task_count_accum() const noexcept
-    { return m_queue->m_accum_alloc ; }
+  long allocated_task_count_accum() const noexcept {
+    return m_queue->m_accum_alloc;
+  }
 
   //----------------------------------------
 
-  template<class S, class Q>
-  friend
-  void wait(Kokkos::BasicTaskScheduler<S, Q> const&);
-
+  template <class S, class Q>
+  friend void wait(Kokkos::BasicTaskScheduler<S, Q> const&);
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -559,121 +515,77 @@ namespace Kokkos {
 // Construct a TaskTeam execution policy
 
 template <class T, class Scheduler>
-Impl::TaskPolicyWithPredecessor<
-  Impl::TaskType::TaskTeam,
-  Kokkos::BasicFuture<T, Scheduler>
->
-KOKKOS_INLINE_FUNCTION
-TaskTeam(
-  Kokkos::BasicFuture<T, Scheduler> arg_future,
-  TaskPriority arg_priority = TaskPriority::Regular
-)
-{
-  return { std::move(arg_future), arg_priority };
+Impl::TaskPolicyWithPredecessor<Impl::TaskType::TaskTeam,
+                                Kokkos::BasicFuture<T, Scheduler> >
+    KOKKOS_INLINE_FUNCTION
+    TaskTeam(Kokkos::BasicFuture<T, Scheduler> arg_future,
+             TaskPriority arg_priority = TaskPriority::Regular) {
+  return {std::move(arg_future), arg_priority};
 }
 
 template <class Scheduler>
-Impl::TaskPolicyWithScheduler<
-  Impl::TaskType::TaskTeam, Scheduler
->
-KOKKOS_INLINE_FUNCTION
-TaskTeam(
-  Scheduler arg_scheduler,
-  typename std::enable_if<
-    Kokkos::is_scheduler<Scheduler>::value,
-    TaskPriority
-  >::type arg_priority = TaskPriority::Regular
-)
-{
-  return { std::move(arg_scheduler), arg_priority };
+Impl::TaskPolicyWithScheduler<Impl::TaskType::TaskTeam, Scheduler>
+    KOKKOS_INLINE_FUNCTION
+    TaskTeam(Scheduler arg_scheduler,
+             typename std::enable_if<Kokkos::is_scheduler<Scheduler>::value,
+                                     TaskPriority>::type arg_priority =
+                 TaskPriority::Regular) {
+  return {std::move(arg_scheduler), arg_priority};
 }
 
-template<
-  class Scheduler,
-  class PredecessorFuture
->
-Impl::TaskPolicyWithScheduler<
-  Kokkos::Impl::TaskType::TaskTeam,
-  Scheduler,
-  PredecessorFuture
->
-KOKKOS_INLINE_FUNCTION
-TaskTeam(
-  Scheduler arg_scheduler,
-  PredecessorFuture arg_future,
-  typename std::enable_if<
-    Kokkos::is_scheduler<Scheduler>::value
-      && Kokkos::is_future<PredecessorFuture>::value,
-    TaskPriority
-  >::type arg_priority = TaskPriority::Regular
-)
-{
-  static_assert(
-    std::is_same<typename PredecessorFuture::scheduler_type, Scheduler>::value,
-    "Can't create a task policy from a scheduler and a future from a different scheduler"
-  );
-
-  return { std::move(arg_scheduler), std::move(arg_future), arg_priority };
+template <class Scheduler, class PredecessorFuture>
+Impl::TaskPolicyWithScheduler<Kokkos::Impl::TaskType::TaskTeam, Scheduler,
+                              PredecessorFuture>
+    KOKKOS_INLINE_FUNCTION TaskTeam(
+        Scheduler arg_scheduler, PredecessorFuture arg_future,
+        typename std::enable_if<Kokkos::is_scheduler<Scheduler>::value &&
+                                    Kokkos::is_future<PredecessorFuture>::value,
+                                TaskPriority>::type arg_priority =
+            TaskPriority::Regular) {
+  static_assert(std::is_same<typename PredecessorFuture::scheduler_type,
+                             Scheduler>::value,
+                "Can't create a task policy from a scheduler and a future from "
+                "a different scheduler");
+
+  return {std::move(arg_scheduler), std::move(arg_future), arg_priority};
 }
 
 // Construct a TaskSingle execution policy
 
 template <class T, class Scheduler>
-Impl::TaskPolicyWithPredecessor<
-  Impl::TaskType::TaskSingle,
-  Kokkos::BasicFuture<T, Scheduler>
->
-KOKKOS_INLINE_FUNCTION
-TaskSingle(
-  Kokkos::BasicFuture<T, Scheduler> arg_future,
-  TaskPriority arg_priority = TaskPriority::Regular
-)
-{
-  return { std::move(arg_future), arg_priority };
+Impl::TaskPolicyWithPredecessor<Impl::TaskType::TaskSingle,
+                                Kokkos::BasicFuture<T, Scheduler> >
+    KOKKOS_INLINE_FUNCTION
+    TaskSingle(Kokkos::BasicFuture<T, Scheduler> arg_future,
+               TaskPriority arg_priority = TaskPriority::Regular) {
+  return {std::move(arg_future), arg_priority};
 }
 
 template <class Scheduler>
-Impl::TaskPolicyWithScheduler<
-  Impl::TaskType::TaskSingle, Scheduler
->
-KOKKOS_INLINE_FUNCTION
-TaskSingle(
-  Scheduler arg_scheduler,
-  typename std::enable_if<
-    Kokkos::is_scheduler<Scheduler>::value,
-    TaskPriority
-  >::type arg_priority = TaskPriority::Regular
-)
-{
-  return { std::move(arg_scheduler), arg_priority };
+Impl::TaskPolicyWithScheduler<Impl::TaskType::TaskSingle, Scheduler>
+    KOKKOS_INLINE_FUNCTION
+    TaskSingle(Scheduler arg_scheduler,
+               typename std::enable_if<Kokkos::is_scheduler<Scheduler>::value,
+                                       TaskPriority>::type arg_priority =
+                   TaskPriority::Regular) {
+  return {std::move(arg_scheduler), arg_priority};
 }
 
-template<
-  class Scheduler,
-  class PredecessorFuture
->
-Impl::TaskPolicyWithScheduler<
-  Kokkos::Impl::TaskType::TaskSingle,
-  Scheduler,
-  PredecessorFuture
->
-KOKKOS_INLINE_FUNCTION
-TaskSingle(
-  Scheduler arg_scheduler,
-  PredecessorFuture arg_future,
-  typename std::enable_if<
-    Kokkos::is_scheduler<Scheduler>::value
-      && Kokkos::is_future<PredecessorFuture>::value,
-    TaskPriority
-  >::type arg_priority = TaskPriority::Regular
-)
-{
-  static_assert(
-    std::is_same<typename PredecessorFuture::scheduler_type, Scheduler>::value,
-    "Can't create a task policy from a scheduler and a future from a different scheduler"
-  );
-
-  return { std::move(arg_scheduler), std::move(arg_future), arg_priority };
+template <class Scheduler, class PredecessorFuture>
+Impl::TaskPolicyWithScheduler<Kokkos::Impl::TaskType::TaskSingle, Scheduler,
+                              PredecessorFuture>
+    KOKKOS_INLINE_FUNCTION TaskSingle(
+        Scheduler arg_scheduler, PredecessorFuture arg_future,
+        typename std::enable_if<Kokkos::is_scheduler<Scheduler>::value &&
+                                    Kokkos::is_future<PredecessorFuture>::value,
+                                TaskPriority>::type arg_priority =
+            TaskPriority::Regular) {
+  static_assert(std::is_same<typename PredecessorFuture::scheduler_type,
+                             Scheduler>::value,
+                "Can't create a task policy from a scheduler and a future from "
+                "a different scheduler");
+
+  return {std::move(arg_scheduler), std::move(arg_future), arg_priority};
 }
 
 //----------------------------------------------------------------------------
@@ -684,31 +596,30 @@ TaskSingle(
  *  2) With scheduler or dependence
  *  3) High, Normal, or Low priority
  */
-template<int TaskEnum, typename Scheduler, typename DepFutureType, typename FunctorType>
-typename Scheduler::template future_type_for_functor<typename std::decay<FunctorType>::type>
-host_spawn(
-  Impl::TaskPolicyWithScheduler<TaskEnum, Scheduler, DepFutureType> arg_policy,
-  FunctorType&& arg_functor
-) {
+template <int TaskEnum, typename Scheduler, typename DepFutureType,
+          typename FunctorType>
+typename Scheduler::template future_type_for_functor<
+    typename std::decay<FunctorType>::type>
+host_spawn(Impl::TaskPolicyWithScheduler<TaskEnum, Scheduler, DepFutureType>
+               arg_policy,
+           FunctorType&& arg_functor) {
   using scheduler_type = Scheduler;
   using task_type =
-    typename scheduler_type::template runnable_task_type<FunctorType>;
+      typename scheduler_type::template runnable_task_type<FunctorType>;
 
-  static_assert(
-    TaskEnum == Impl::TaskType::TaskTeam || TaskEnum == Impl::TaskType::TaskSingle,
-    "Kokkos host_spawn requires TaskTeam or TaskSingle"
-  );
+  static_assert(TaskEnum == Impl::TaskType::TaskTeam ||
+                    TaskEnum == Impl::TaskType::TaskSingle,
+                "Kokkos host_spawn requires TaskTeam or TaskSingle");
 
   // May be spawning a Cuda task, must use the specialization
   // to query on-device function pointer.
   typename task_type::function_type ptr;
   typename task_type::destroy_type dtor;
-  Kokkos::Impl::TaskQueueSpecialization< scheduler_type >::
-    template get_function_pointer< task_type >(ptr, dtor);
+  Kokkos::Impl::TaskQueueSpecialization<
+      scheduler_type>::template get_function_pointer<task_type>(ptr, dtor);
 
-  return scheduler_type::spawn(
-    std::move(arg_policy), ptr, dtor, std::forward<FunctorType>(arg_functor)
-  );
+  return scheduler_type::spawn(std::move(arg_policy), ptr, dtor,
+                               std::forward<FunctorType>(arg_functor));
 }
 
 /**\brief  A task spawns a task with options
@@ -717,38 +628,38 @@ host_spawn(
  *  2) With scheduler or dependence
  *  3) High, Normal, or Low priority
  */
-template<int TaskEnum, typename Scheduler, typename DepFutureType, typename FunctorType>
-typename Scheduler::template future_type_for_functor<typename std::decay<FunctorType>::type>
-KOKKOS_INLINE_FUNCTION
-task_spawn(
-  Impl::TaskPolicyWithScheduler<TaskEnum, Scheduler, DepFutureType> arg_policy,
-  FunctorType&& arg_functor
-)
-{
+template <int TaskEnum, typename Scheduler, typename DepFutureType,
+          typename FunctorType>
+typename Scheduler::template future_type_for_functor<
+    typename std::decay<FunctorType>::type>
+    KOKKOS_INLINE_FUNCTION
+    task_spawn(Impl::TaskPolicyWithScheduler<TaskEnum, Scheduler, DepFutureType>
+                   arg_policy,
+               FunctorType&& arg_functor) {
   using scheduler_type = Scheduler;
 
   using task_type =
-    typename scheduler_type::template runnable_task_type<FunctorType>;
+      typename scheduler_type::template runnable_task_type<FunctorType>;
 
- #if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST ) && \
-     defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST) && \
+    defined(KOKKOS_ENABLE_CUDA)
 
-   static_assert( ! std::is_same< Kokkos::Cuda , typename Scheduler::execution_space >::value
-                , "Error calling Kokkos::task_spawn for Cuda space within Host code" );
+  // This doesn't work with clang cuda
+  // static_assert(
+  //    !std::is_same<Kokkos::Cuda, typename Scheduler::execution_space>::value,
+  //    "Error calling Kokkos::task_spawn for Cuda space within Host code");
 
- #endif
+#endif
 
-  static_assert(
-    TaskEnum == Impl::TaskType::TaskTeam || TaskEnum == Impl::TaskType::TaskSingle,
-    "Kokkos task_spawn requires TaskTeam or TaskSingle"
-  );
+  static_assert(TaskEnum == Impl::TaskType::TaskTeam ||
+                    TaskEnum == Impl::TaskType::TaskSingle,
+                "Kokkos task_spawn requires TaskTeam or TaskSingle");
 
-  typename task_type::function_type const ptr = task_type::apply ;
-  typename task_type::destroy_type const dtor = task_type::destroy ;
+  typename task_type::function_type const ptr = task_type::apply;
+  typename task_type::destroy_type const dtor = task_type::destroy;
 
   return scheduler_type::spawn(std::move(arg_policy), ptr, dtor,
-    std::forward<FunctorType>(arg_functor)
-  );
+                               std::forward<FunctorType>(arg_functor));
 }
 
 /**\brief  A task respawns itself with options
@@ -756,29 +667,22 @@ task_spawn(
  *  1) With scheduler or dependence
  *  2) High, Normal, or Low priority
  */
-template< typename FunctorType , typename T >
-void
-KOKKOS_INLINE_FUNCTION
-respawn( FunctorType         * arg_self
-       , T             const & arg
-       , TaskPriority  const & arg_priority = TaskPriority::Regular
-       )
-{
-  static_assert( Kokkos::is_future<T>::value ||
-                 Kokkos::is_scheduler<T>::value
-               , "Kokkos respawn argument must be Future or TaskScheduler" );
-
-  T::scheduler_type::respawn(
-    arg_self , arg , arg_priority
-  );
+template <typename FunctorType, typename T>
+void KOKKOS_INLINE_FUNCTION
+respawn(FunctorType* arg_self, T const& arg,
+        TaskPriority const& arg_priority = TaskPriority::Regular) {
+  static_assert(Kokkos::is_future<T>::value || Kokkos::is_scheduler<T>::value,
+                "Kokkos respawn argument must be Future or TaskScheduler");
+
+  T::scheduler_type::respawn(arg_self, arg, arg_priority);
 }
 
 //----------------------------------------------------------------------------
 
-//template<typename ValueType, typename Scheduler>
-//KOKKOS_INLINE_FUNCTION
-//BasicFuture<void, Scheduler>
-//when_all(BasicFuture<ValueType, Scheduler> const arg[], int narg)
+// template<typename ValueType, typename Scheduler>
+// KOKKOS_INLINE_FUNCTION
+// BasicFuture<void, Scheduler>
+// when_all(BasicFuture<ValueType, Scheduler> const arg[], int narg)
 //{
 //  return BasicFuture<void, Scheduler>::scheduler_type::when_all(arg, narg);
 //}
@@ -786,16 +690,14 @@ respawn( FunctorType         * arg_self
 //----------------------------------------------------------------------------
 // Wait for all runnable tasks to complete
 
-template<class ExecSpace, class QueueType>
-inline
-void wait(BasicTaskScheduler<ExecSpace, QueueType> const& scheduler)
-{
+template <class ExecSpace, class QueueType>
+inline void wait(BasicTaskScheduler<ExecSpace, QueueType> const& scheduler) {
   using scheduler_type = BasicTaskScheduler<ExecSpace, QueueType>;
   scheduler_type::specialization::execute(scheduler);
-  //scheduler.m_queue->execute();
+  // scheduler.m_queue->execute();
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -806,4 +708,3 @@ void wait(BasicTaskScheduler<ExecSpace, QueueType> const& scheduler)
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_TASKSCHEDULER_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_TaskScheduler_fwd.hpp b/lib/kokkos/core/src/Kokkos_TaskScheduler_fwd.hpp
index 79d502c729793569bc4261f03db1378217f10429..c5f880775d9173220d93097b69ef03ec50aaeadc 100644
--- a/lib/kokkos/core/src/Kokkos_TaskScheduler_fwd.hpp
+++ b/lib/kokkos/core/src/Kokkos_TaskScheduler_fwd.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 //----------------------------------------------------------------------------
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core_fwd.hpp>
 //----------------------------------------------------------------------------
@@ -65,22 +66,20 @@ class SimpleTaskScheduler;
 template <class Space, class Queue>
 class BasicTaskScheduler;
 
-template< typename Space >
+template <typename Space>
 struct is_scheduler : public std::false_type {};
 
-template<class Space, class Queue>
-struct is_scheduler<BasicTaskScheduler<Space, Queue>> : public std::true_type {};
-
-template<class Space, class Queue>
-struct is_scheduler<SimpleTaskScheduler<Space, Queue>> : public std::true_type {};
+template <class Space, class Queue>
+struct is_scheduler<BasicTaskScheduler<Space, Queue>> : public std::true_type {
+};
 
-enum class TaskPriority : int {
-  High = 0,
-  Regular = 1,
-  Low = 2
+template <class Space, class Queue>
+struct is_scheduler<SimpleTaskScheduler<Space, Queue>> : public std::true_type {
 };
 
-} // namespace Kokkos
+enum class TaskPriority : int { High = 0, Regular = 1, Low = 2 };
+
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -110,140 +109,124 @@ class TaskBase;
  *      : TaskBase< Space , void , void >
  *      { ... };
  */
-template< typename Space , typename ResultType , typename FunctorType >
+template <typename Space, typename ResultType, typename FunctorType>
 class Task;
 
 class TaskQueueBase;
 
-template< typename Space, typename MemorySpace>
+template <typename Space, typename MemorySpace>
 class TaskQueue;
 
-template< typename ExecSpace, typename MemorySpace>
+template <typename ExecSpace, typename MemorySpace>
 class TaskQueueMultiple;
 
-template<
-  typename ExecSpace, typename MemSpace, typename TaskQueueTraits,
-  class MemoryPool = Kokkos::MemoryPool<Kokkos::Device<ExecSpace, MemSpace>>
->
+template <typename ExecSpace, typename MemSpace, typename TaskQueueTraits,
+          class MemoryPool =
+              Kokkos::MemoryPool<Kokkos::Device<ExecSpace, MemSpace>>>
 class SingleTaskQueue;
 
-template< typename ExecSpace, typename MemSpace, typename TaskQueueTraits, class MemoryPool>
+template <typename ExecSpace, typename MemSpace, typename TaskQueueTraits,
+          class MemoryPool>
 class MultipleTaskQueue;
 
 struct TaskQueueTraitsLockBased;
 
-template <size_t CircularBufferSize=64>
+template <size_t CircularBufferSize = 64>
 struct TaskQueueTraitsChaseLev;
 
-template< typename ResultType >
+template <typename ResultType>
 struct TaskResult;
 
 struct TaskSchedulerBase;
 
 template <class ExecSpace>
-struct default_tasking_memory_space_for_execution_space
-{
+struct default_tasking_memory_space_for_execution_space {
   using type = typename ExecSpace::memory_space;
 };
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 template <>
-struct default_tasking_memory_space_for_execution_space<Kokkos::Cuda>
-{
+struct default_tasking_memory_space_for_execution_space<Kokkos::Cuda> {
   using type = Kokkos::CudaUVMSpace;
 };
 #endif
 
 template <class ExecSpace>
 using default_tasking_memory_space_for_execution_space_t =
-  typename default_tasking_memory_space_for_execution_space<ExecSpace>::type;
+    typename default_tasking_memory_space_for_execution_space<ExecSpace>::type;
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-template< typename Space >
+template <typename Space>
 using DeprecatedTaskScheduler = BasicTaskScheduler<
-  Space,
-  Impl::TaskQueue<Space, Impl::default_tasking_memory_space_for_execution_space_t<Space>>
->;
+    Space,
+    Impl::TaskQueue<
+        Space,
+        Impl::default_tasking_memory_space_for_execution_space_t<Space>>>;
 
-template< typename Space >
+template <typename Space>
 using DeprecatedTaskSchedulerMultiple = BasicTaskScheduler<
-  Space,
-  Impl::TaskQueueMultiple<Space, Impl::default_tasking_memory_space_for_execution_space_t<Space>>
->;
+    Space,
+    Impl::TaskQueueMultiple<
+        Space,
+        Impl::default_tasking_memory_space_for_execution_space_t<Space>>>;
 
-template< typename Space >
+template <typename Space>
 using TaskScheduler = SimpleTaskScheduler<
-  Space,
-  Impl::SingleTaskQueue<
     Space,
-    Impl::default_tasking_memory_space_for_execution_space_t<Space>,
-    Impl::TaskQueueTraitsLockBased
-  >
->;
+    Impl::SingleTaskQueue<
+        Space, Impl::default_tasking_memory_space_for_execution_space_t<Space>,
+        Impl::TaskQueueTraitsLockBased>>;
 
-template< typename Space >
+template <typename Space>
 using TaskSchedulerMultiple = SimpleTaskScheduler<
-  Space,
-  Impl::MultipleTaskQueue<
     Space,
-    Impl::default_tasking_memory_space_for_execution_space_t<Space>,
-    Impl::TaskQueueTraitsLockBased,
-    Kokkos::MemoryPool<
-      Kokkos::Device<
-        Space,
-        Impl::default_tasking_memory_space_for_execution_space_t<Space>
-      >
-    >
-  >
->;
-
-template< typename Space >
+    Impl::MultipleTaskQueue<
+        Space, Impl::default_tasking_memory_space_for_execution_space_t<Space>,
+        Impl::TaskQueueTraitsLockBased,
+        Kokkos::MemoryPool<Kokkos::Device<
+            Space,
+            Impl::default_tasking_memory_space_for_execution_space_t<Space>>>>>;
+
+template <typename Space>
 using ChaseLevTaskScheduler = SimpleTaskScheduler<
-  Space,
-  Impl::MultipleTaskQueue<
     Space,
-    Impl::default_tasking_memory_space_for_execution_space_t<Space>,
-    Impl::TaskQueueTraitsChaseLev<>,
-    Kokkos::MemoryPool<
-      Kokkos::Device<
-        Space,
-        Impl::default_tasking_memory_space_for_execution_space_t<Space>
-      >
-    >
-  >
->;
-
-template<class Space, class QueueType>
+    Impl::MultipleTaskQueue<
+        Space, Impl::default_tasking_memory_space_for_execution_space_t<Space>,
+        Impl::TaskQueueTraitsChaseLev<>,
+        Kokkos::MemoryPool<Kokkos::Device<
+            Space,
+            Impl::default_tasking_memory_space_for_execution_space_t<Space>>>>>;
+
+template <class Space, class QueueType>
 void wait(BasicTaskScheduler<Space, QueueType> const&);
 
 namespace Impl {
 
-struct TaskSchedulerBase { };
+struct TaskSchedulerBase {};
 
-class TaskQueueBase { };
+class TaskQueueBase {};
 
-template <typename Scheduler, typename EnableIfConstraint=void>
-class TaskQueueSpecializationConstrained { };
+template <typename Scheduler, typename EnableIfConstraint = void>
+class TaskQueueSpecializationConstrained {};
 
 template <typename Scheduler>
-struct TaskQueueSpecialization : TaskQueueSpecializationConstrained<Scheduler> { };
+struct TaskQueueSpecialization : TaskQueueSpecializationConstrained<Scheduler> {
+};
 
 template <int, typename>
 struct TaskPolicyData;
 
+}  // end namespace Impl
 
-} // end namespace Impl
-
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_TASKSCHEDULER_FWD_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Threads.hpp b/lib/kokkos/core/src/Kokkos_Threads.hpp
index 03dab1acafe1215f0d3c963086d0d95f2e56e5e9..d44042b062b5bd98e020e1bc6298ecffebd4df8f 100644
--- a/lib/kokkos/core/src/Kokkos_Threads.hpp
+++ b/lib/kokkos/core/src/Kokkos_Threads.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_THREADS_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 
 #include <Kokkos_Core_fwd.hpp>
 
@@ -61,9 +62,9 @@
 
 namespace Kokkos {
 namespace Impl {
-class ThreadsExec ;
-} // namespace Impl
-} // namespace Kokkos
+class ThreadsExec;
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -71,21 +72,20 @@ namespace Kokkos {
 
 /** \brief  Execution space for a pool of Pthreads or C11 threads on a CPU. */
 class Threads {
-public:
+ public:
   //! \name Type declarations that all Kokkos devices must provide.
   //@{
   //! Tag this class as a kokkos execution space
-  typedef Threads                  execution_space ;
-  typedef Kokkos::HostSpace        memory_space ;
+  typedef Threads execution_space;
+  typedef Kokkos::HostSpace memory_space;
 
   //! This execution space preferred device_type
-  typedef Kokkos::Device<execution_space,memory_space> device_type;
+  typedef Kokkos::Device<execution_space, memory_space> device_type;
 
-  typedef Kokkos::LayoutRight      array_layout ;
-  typedef memory_space::size_type  size_type ;
-
-  typedef ScratchMemorySpace< Threads >  scratch_memory_space ;
+  typedef Kokkos::LayoutRight array_layout;
+  typedef memory_space::size_type size_type;
 
+  typedef ScratchMemorySpace<Threads> scratch_memory_space;
 
   //@}
   /*------------------------------------------------------------------------*/
@@ -97,7 +97,7 @@ public:
   static int in_parallel();
 
   /// \brief Print configuration information to the given output stream.
-  static void print_configuration( std::ostream & , const bool detail = false );
+  static void print_configuration(std::ostream&, const bool detail = false);
 
   /// \brief Wait until all dispatched functors complete.
   ///
@@ -107,11 +107,11 @@ public:
   /// device have completed.
   static void impl_static_fence();
 
-  #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   static void fence();
-  #else
+#else
   void fence() const;
-  #endif
+#endif
 
   /** \brief  Return the maximum amount of concurrency.  */
   static int concurrency();
@@ -123,26 +123,28 @@ public:
 
   static void finalize();
 
-  static void initialize( unsigned threads_count = 0 ,
-                          unsigned use_numa_count = 0 ,
-                          unsigned use_cores_per_numa = 0 ,
-                          bool allow_asynchronous_threadpool = false );
+  static void initialize(unsigned threads_count             = 0,
+                         unsigned use_numa_count            = 0,
+                         unsigned use_cores_per_numa        = 0,
+                         bool allow_asynchronous_threadpool = false);
 
   static int is_initialized();
 
-  static Threads & instance( int = 0 );
+  static Threads& instance(int = 0);
 
   //----------------------------------------
 
-  static int thread_pool_size( int depth = 0 );
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+  static int thread_pool_size(int depth = 0);
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
   static int thread_pool_rank();
 #else
-  KOKKOS_INLINE_FUNCTION static int thread_pool_rank() { return 0 ; }
+  KOKKOS_INLINE_FUNCTION static int thread_pool_rank() { return 0; }
 #endif
 
   inline static unsigned max_hardware_threads() { return thread_pool_size(0); }
-  KOKKOS_INLINE_FUNCTION static unsigned hardware_thread_id() { return thread_pool_rank(); }
+  KOKKOS_INLINE_FUNCTION static unsigned hardware_thread_id() {
+    return thread_pool_rank();
+  }
 #else
   /// \brief Free any resources being consumed by the device.
   ///
@@ -172,26 +174,30 @@ public:
    *  If the 'use_' arguments are not supplied the hwloc is queried
    *  to use all available cores.
    */
-  static void impl_initialize( unsigned threads_count = 0 ,
-                          unsigned use_numa_count = 0 ,
-                          unsigned use_cores_per_numa = 0 ,
-                          bool allow_asynchronous_threadpool = false );
+  static void impl_initialize(unsigned threads_count             = 0,
+                              unsigned use_numa_count            = 0,
+                              unsigned use_cores_per_numa        = 0,
+                              bool allow_asynchronous_threadpool = false);
 
   static int impl_is_initialized();
 
-  static Threads & impl_instance( int = 0 );
+  static Threads& impl_instance(int = 0);
 
   //----------------------------------------
 
-  static int impl_thread_pool_size( int depth = 0 );
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+  static int impl_thread_pool_size(int depth = 0);
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
   static int impl_thread_pool_rank();
 #else
-  KOKKOS_INLINE_FUNCTION static int impl_thread_pool_rank() { return 0 ; }
+  KOKKOS_INLINE_FUNCTION static int impl_thread_pool_rank() { return 0; }
 #endif
 
-  inline static unsigned impl_max_hardware_threads() { return impl_thread_pool_size(0); }
-  KOKKOS_INLINE_FUNCTION static unsigned impl_hardware_thread_id() { return impl_thread_pool_rank(); }
+  inline static unsigned impl_max_hardware_threads() {
+    return impl_thread_pool_size(0);
+  }
+  KOKKOS_INLINE_FUNCTION static unsigned impl_hardware_thread_id() {
+    return impl_thread_pool_rank();
+  }
 #endif
 
   static const char* name();
@@ -199,37 +205,31 @@ public:
   //----------------------------------------
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
 namespace Kokkos {
 namespace Impl {
 
-template<>
-struct MemorySpaceAccess
-  < Kokkos::Threads::memory_space
-  , Kokkos::Threads::scratch_memory_space
-  >
-{
+template <>
+struct MemorySpaceAccess<Kokkos::Threads::memory_space,
+                         Kokkos::Threads::scratch_memory_space> {
   enum { assignable = false };
   enum { accessible = true };
-  enum { deepcopy   = false };
+  enum { deepcopy = false };
 };
 
-template<>
-struct VerifyExecutionCanAccessMemorySpace
-  < Kokkos::Threads::memory_space
-  , Kokkos::Threads::scratch_memory_space
-  >
-{
+template <>
+struct VerifyExecutionCanAccessMemorySpace<
+    Kokkos::Threads::memory_space, Kokkos::Threads::scratch_memory_space> {
   enum { value = true };
-  inline static void verify( void ) { }
-  inline static void verify( const void * ) { }
+  inline static void verify(void) {}
+  inline static void verify(const void*) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -246,4 +246,3 @@ struct VerifyExecutionCanAccessMemorySpace
 
 #endif /* #if defined( KOKKOS_ENABLE_THREADS ) */
 #endif /* #define KOKKOS_THREADS_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_Timer.hpp b/lib/kokkos/core/src/Kokkos_Timer.hpp
index eb869fd1b03518a5de594deabc10d519bb613e2e..117f097f66d01d46812431c7fdb58dc834526dac 100644
--- a/lib/kokkos/core/src/Kokkos_Timer.hpp
+++ b/lib/kokkos/core/src/Kokkos_Timer.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,33 +52,27 @@ namespace Kokkos {
 /** \brief  Time since construction */
 
 class Timer {
-private:
+ private:
   std::chrono::high_resolution_clock::time_point m_old;
-  Timer( const Timer & );
-  Timer & operator = ( const Timer & );
-public:
+  Timer(const Timer&);
+  Timer& operator=(const Timer&);
 
-  inline
-  void reset() {
-    m_old = std::chrono::high_resolution_clock::now();
-  }
+ public:
+  inline void reset() { m_old = std::chrono::high_resolution_clock::now(); }
 
-  inline
-  ~Timer() {}
+  inline ~Timer() {}
 
-  inline
-  Timer() { reset(); }
+  inline Timer() { reset(); }
 
-  inline
-  double seconds() const
-  {
+  inline double seconds() const {
     std::chrono::high_resolution_clock::time_point m_new =
         std::chrono::high_resolution_clock::now();
-    return std::chrono::duration_cast<std::chrono::duration<double>>(m_new - m_old).count();
+    return std::chrono::duration_cast<std::chrono::duration<double>>(m_new -
+                                                                     m_old)
+        .count();
   }
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_TIMER_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_UniqueToken.hpp b/lib/kokkos/core/src/Kokkos_UniqueToken.hpp
index d89542631d658af1ede69cab5956af9b7ac6e448..523ccad9481acdeeb01accb2ecb0cff55c1784c9 100644
--- a/lib/kokkos/core/src/Kokkos_UniqueToken.hpp
+++ b/lib/kokkos/core/src/Kokkos_UniqueToken.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,43 +47,42 @@
 
 #include <Kokkos_Macros.hpp>
 
-namespace Kokkos { namespace Experimental {
+namespace Kokkos {
+namespace Experimental {
 
-enum class UniqueTokenScope : int
-{
-  Instance,
-  Global
-};
+enum class UniqueTokenScope : int { Instance, Global };
 
-/// \brief class to generate unique ids base on the required amount of concurrency
+/// \brief class to generate unique ids base on the required amount of
+/// concurrency
 ///
 /// This object should behave like a ref-counted object, so that when the last
 /// instance is destroy resources are free if needed
-template <typename ExecutionSpace, UniqueTokenScope = UniqueTokenScope::Instance >
-class UniqueToken
-{
-public:
+template <typename ExecutionSpace,
+          UniqueTokenScope = UniqueTokenScope::Instance>
+class UniqueToken {
+ public:
   using execution_space = ExecutionSpace;
   using size_type       = typename execution_space::size_type;
 
   /// \brief create object size for concurrency on the given instance
   ///
   /// This object should not be shared between instances
-  UniqueToken( execution_space const& = execution_space() );
+  UniqueToken(execution_space const& = execution_space());
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  size_type size() const ;
+  size_type size() const;
 
   /// \brief acquire value such that 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  size_type acquire() const ;
+  size_type acquire() const;
 
   /// \brief release a value acquired by generate
   KOKKOS_INLINE_FUNCTION
-  void release( size_type ) const ;
+  void release(size_type) const;
 };
 
-}} // namespace Kokkos::Experimental
+}  // namespace Experimental
+}  // namespace Kokkos
 
-#endif //KOKKOS_UNIQUE_TOKEN_HPP
+#endif  // KOKKOS_UNIQUE_TOKEN_HPP
diff --git a/lib/kokkos/core/src/Kokkos_Vectorization.hpp b/lib/kokkos/core/src/Kokkos_Vectorization.hpp
index f5b6cad4b7f4285d6cddac640e4e8f68eecf65f9..2604538b1c113c001f74be77069784510f691686 100644
--- a/lib/kokkos/core/src/Kokkos_Vectorization.hpp
+++ b/lib/kokkos/core/src/Kokkos_Vectorization.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 #ifndef KOKKOS_VECTORIZATION_HPP
 #define KOKKOS_VECTORIZATION_HPP
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 #include <Cuda/Kokkos_Cuda_Vectorization.hpp>
 #endif
 
 #endif
-
diff --git a/lib/kokkos/core/src/Kokkos_View.hpp b/lib/kokkos/core/src/Kokkos_View.hpp
index 3fe8e6f06731f51520dc6b0eb5bdd0d2c28afd70..6610bb842bd549ade6c015ec786d3a4a2b49d510 100644
--- a/lib/kokkos/core/src/Kokkos_View.hpp
+++ b/lib/kokkos/core/src/Kokkos_View.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -64,122 +65,88 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class DataType >
-struct ViewArrayAnalysis ;
+template <class DataType>
+struct ViewArrayAnalysis;
 
-template< class DataType , class ArrayLayout
-        , typename ValueType =
-          typename ViewArrayAnalysis< DataType >::non_const_value_type
-        >
-struct ViewDataAnalysis ;
+template <class DataType, class ArrayLayout,
+          typename ValueType =
+              typename ViewArrayAnalysis<DataType>::non_const_value_type>
+struct ViewDataAnalysis;
 
-template< class , class ... >
+template <class, class...>
 class ViewMapping {
-  public:
+ public:
   enum { is_assignable_data_type = false };
   enum { is_assignable = false };
 };
 
-
-
 template <typename IntType>
-KOKKOS_INLINE_FUNCTION
-std::size_t count_valid_integers(const IntType i0,
-                            const IntType i1,
-                            const IntType i2,
-                            const IntType i3,
-                            const IntType i4,
-                            const IntType i5,
-                            const IntType i6,
-                            const IntType i7 ){
-  static_assert(std::is_integral<IntType>::value, "count_valid_integers() must have integer arguments.");
-
-  return ( i0 !=KOKKOS_INVALID_INDEX ) + ( i1 !=KOKKOS_INVALID_INDEX ) + ( i2 !=KOKKOS_INVALID_INDEX ) +
-      ( i3 !=KOKKOS_INVALID_INDEX ) + ( i4 !=KOKKOS_INVALID_INDEX ) + ( i5 !=KOKKOS_INVALID_INDEX ) +
-      ( i6 !=KOKKOS_INVALID_INDEX ) + ( i7 !=KOKKOS_INVALID_INDEX );
-
-
+KOKKOS_INLINE_FUNCTION std::size_t count_valid_integers(
+    const IntType i0, const IntType i1, const IntType i2, const IntType i3,
+    const IntType i4, const IntType i5, const IntType i6, const IntType i7) {
+  static_assert(std::is_integral<IntType>::value,
+                "count_valid_integers() must have integer arguments.");
+
+  return (i0 != KOKKOS_INVALID_INDEX) + (i1 != KOKKOS_INVALID_INDEX) +
+         (i2 != KOKKOS_INVALID_INDEX) + (i3 != KOKKOS_INVALID_INDEX) +
+         (i4 != KOKKOS_INVALID_INDEX) + (i5 != KOKKOS_INVALID_INDEX) +
+         (i6 != KOKKOS_INVALID_INDEX) + (i7 != KOKKOS_INVALID_INDEX);
 }
 
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
 KOKKOS_INLINE_FUNCTION
-void runtime_check_rank_device(const size_t dyn_rank,
-                        const bool is_void_spec,
-                        const size_t i0,
-                        const size_t i1,
-                        const size_t i2,
-                        const size_t i3,
-                        const size_t i4,
-                        const size_t i5,
-                        const size_t i6,
-                        const size_t i7 ){
-
-  if ( is_void_spec ) {
-    const size_t num_passed_args = count_valid_integers(i0, i1, i2, i3,
-        i4, i5, i6, i7);
-
-    if ( num_passed_args != dyn_rank && is_void_spec ) {
-
-      Kokkos::abort("Number of arguments passed to Kokkos::View() constructor must match the dynamic rank of the view.") ;
-
+void runtime_check_rank_device(const size_t dyn_rank, const bool is_void_spec,
+                               const size_t i0, const size_t i1,
+                               const size_t i2, const size_t i3,
+                               const size_t i4, const size_t i5,
+                               const size_t i6, const size_t i7) {
+  if (is_void_spec) {
+    const size_t num_passed_args =
+        count_valid_integers(i0, i1, i2, i3, i4, i5, i6, i7);
+
+    if (num_passed_args != dyn_rank && is_void_spec) {
+      Kokkos::abort(
+          "Number of arguments passed to Kokkos::View() constructor must match "
+          "the dynamic rank of the view.");
     }
   }
 }
 #else
 KOKKOS_INLINE_FUNCTION
-void runtime_check_rank_device(const size_t ,
-                        const bool ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t  ){
-
-}
+void runtime_check_rank_device(const size_t, const bool, const size_t,
+                               const size_t, const size_t, const size_t,
+                               const size_t, const size_t, const size_t,
+                               const size_t) {}
 #endif
 
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
 KOKKOS_INLINE_FUNCTION
-void runtime_check_rank_host(const size_t dyn_rank,
-                        const bool is_void_spec,
-                        const size_t i0,
-                        const size_t i1,
-                        const size_t i2,
-                        const size_t i3,
-                        const size_t i4,
-                        const size_t i5,
-                        const size_t i6,
-                        const size_t i7, const std::string & label ){
-
-
-  if ( is_void_spec ) {
-    const size_t num_passed_args = count_valid_integers(i0, i1, i2, i3,
-        i4, i5, i6, i7);
-
-    if ( num_passed_args != dyn_rank ) {
-
-      const std::string message = "Constructor for Kokkos View '" + label + "' has mismatched number of arguments. Number of arguments = "
-        + std::to_string(num_passed_args) + " but dynamic rank = " + std::to_string(dyn_rank) + " \n";
-      Kokkos::abort(message.c_str()) ;
+void runtime_check_rank_host(const size_t dyn_rank, const bool is_void_spec,
+                             const size_t i0, const size_t i1, const size_t i2,
+                             const size_t i3, const size_t i4, const size_t i5,
+                             const size_t i6, const size_t i7,
+                             const std::string& label) {
+  if (is_void_spec) {
+    const size_t num_passed_args =
+        count_valid_integers(i0, i1, i2, i3, i4, i5, i6, i7);
+
+    if (num_passed_args != dyn_rank) {
+      const std::string message =
+          "Constructor for Kokkos View '" + label +
+          "' has mismatched number of arguments. Number of arguments = " +
+          std::to_string(num_passed_args) +
+          " but dynamic rank = " + std::to_string(dyn_rank) + " \n";
+      Kokkos::abort(message.c_str());
     }
   }
 }
 #else
 KOKKOS_INLINE_FUNCTION
-void runtime_check_rank_host(const size_t ,
-                        const bool ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t ,
-                        const size_t , const std::string &){}
+void runtime_check_rank_host(const size_t, const bool, const size_t,
+                             const size_t, const size_t, const size_t,
+                             const size_t, const size_t, const size_t,
+                             const size_t, const std::string&) {}
 #endif
 #endif
 
@@ -189,10 +156,10 @@ void runtime_check_rank_host(const size_t ,
 // Class to provide a uniform type
 namespace Kokkos {
 namespace Impl {
-  template< class ViewType , int Traits = 0 >
-  struct ViewUniformType;
-}
+template <class ViewType, int Traits = 0>
+struct ViewUniformType;
 }
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -216,183 +183,183 @@ namespace Kokkos {
  *   - View< DataType , MemoryTraits >
  */
 
-template< class DataType , class ... Properties >
-struct ViewTraits ;
-
-template<>
-struct ViewTraits< void >
-{
-  typedef void  execution_space ;
-  typedef void  memory_space ;
-  typedef void  HostMirrorSpace ;
-  typedef void  array_layout ;
-  typedef void  memory_traits ;
-  typedef void  specialize ;
+template <class DataType, class... Properties>
+struct ViewTraits;
+
+template <>
+struct ViewTraits<void> {
+  typedef void execution_space;
+  typedef void memory_space;
+  typedef void HostMirrorSpace;
+  typedef void array_layout;
+  typedef void memory_traits;
+  typedef void specialize;
 };
 
-template< class ... Prop >
-struct ViewTraits< void , void , Prop ... >
-{
+template <class... Prop>
+struct ViewTraits<void, void, Prop...> {
   // Ignore an extraneous 'void'
-  typedef typename ViewTraits<void,Prop...>::execution_space  execution_space ;
-  typedef typename ViewTraits<void,Prop...>::memory_space     memory_space ;
-  typedef typename ViewTraits<void,Prop...>::HostMirrorSpace  HostMirrorSpace ;
-  typedef typename ViewTraits<void,Prop...>::array_layout     array_layout ;
-  typedef typename ViewTraits<void,Prop...>::memory_traits    memory_traits ;
-  typedef typename ViewTraits<void,Prop...>::specialize       specialize ;
+  typedef typename ViewTraits<void, Prop...>::execution_space execution_space;
+  typedef typename ViewTraits<void, Prop...>::memory_space memory_space;
+  typedef typename ViewTraits<void, Prop...>::HostMirrorSpace HostMirrorSpace;
+  typedef typename ViewTraits<void, Prop...>::array_layout array_layout;
+  typedef typename ViewTraits<void, Prop...>::memory_traits memory_traits;
+  typedef typename ViewTraits<void, Prop...>::specialize specialize;
 };
 
-template< class ArrayLayout , class ... Prop >
-struct ViewTraits< typename std::enable_if< Kokkos::Impl::is_array_layout<ArrayLayout>::value >::type , ArrayLayout , Prop ... >
-{
+template <class ArrayLayout, class... Prop>
+struct ViewTraits<typename std::enable_if<
+                      Kokkos::Impl::is_array_layout<ArrayLayout>::value>::type,
+                  ArrayLayout, Prop...> {
   // Specify layout, keep subsequent space and memory traits arguments
 
-  typedef typename ViewTraits<void,Prop...>::execution_space  execution_space ;
-  typedef typename ViewTraits<void,Prop...>::memory_space     memory_space ;
-  typedef typename ViewTraits<void,Prop...>::HostMirrorSpace  HostMirrorSpace ;
-  typedef          ArrayLayout                                array_layout ;
-  typedef typename ViewTraits<void,Prop...>::memory_traits    memory_traits ;
-  typedef typename ViewTraits<void,Prop...>::specialize       specialize ;
+  typedef typename ViewTraits<void, Prop...>::execution_space execution_space;
+  typedef typename ViewTraits<void, Prop...>::memory_space memory_space;
+  typedef typename ViewTraits<void, Prop...>::HostMirrorSpace HostMirrorSpace;
+  typedef ArrayLayout array_layout;
+  typedef typename ViewTraits<void, Prop...>::memory_traits memory_traits;
+  typedef typename ViewTraits<void, Prop...>::specialize specialize;
 };
 
-template< class Space , class ... Prop >
-struct ViewTraits< typename std::enable_if< Kokkos::Impl::is_space<Space>::value >::type , Space , Prop ... >
-{
+template <class Space, class... Prop>
+struct ViewTraits<
+    typename std::enable_if<Kokkos::Impl::is_space<Space>::value>::type, Space,
+    Prop...> {
   // Specify Space, memory traits should be the only subsequent argument.
 
-  static_assert( std::is_same< typename ViewTraits<void,Prop...>::execution_space , void >::value &&
-                 std::is_same< typename ViewTraits<void,Prop...>::memory_space    , void >::value &&
-                 std::is_same< typename ViewTraits<void,Prop...>::HostMirrorSpace , void >::value &&
-                 std::is_same< typename ViewTraits<void,Prop...>::array_layout    , void >::value
-               , "Only one View Execution or Memory Space template argument" );
-
-  typedef typename Space::execution_space                   execution_space ;
-  typedef typename Space::memory_space                      memory_space ;
-  typedef typename Kokkos::Impl::HostMirror< Space >::Space HostMirrorSpace ;
-  typedef typename execution_space::array_layout            array_layout ;
-  typedef typename ViewTraits<void,Prop...>::memory_traits  memory_traits ;
-  typedef typename ViewTraits<void,Prop...>::specialize       specialize ;
+  static_assert(
+      std::is_same<typename ViewTraits<void, Prop...>::execution_space,
+                   void>::value &&
+          std::is_same<typename ViewTraits<void, Prop...>::memory_space,
+                       void>::value &&
+          std::is_same<typename ViewTraits<void, Prop...>::HostMirrorSpace,
+                       void>::value &&
+          std::is_same<typename ViewTraits<void, Prop...>::array_layout,
+                       void>::value,
+      "Only one View Execution or Memory Space template argument");
+
+  typedef typename Space::execution_space execution_space;
+  typedef typename Space::memory_space memory_space;
+  typedef typename Kokkos::Impl::HostMirror<Space>::Space::memory_space
+      HostMirrorSpace;
+  typedef typename execution_space::array_layout array_layout;
+  typedef typename ViewTraits<void, Prop...>::memory_traits memory_traits;
+  typedef typename ViewTraits<void, Prop...>::specialize specialize;
 };
 
-template< class MemoryTraits , class ... Prop >
-struct ViewTraits< typename std::enable_if< Kokkos::Impl::is_memory_traits<MemoryTraits>::value >::type , MemoryTraits , Prop ... >
-{
+template <class MemoryTraits, class... Prop>
+struct ViewTraits<typename std::enable_if<Kokkos::Impl::is_memory_traits<
+                      MemoryTraits>::value>::type,
+                  MemoryTraits, Prop...> {
   // Specify memory trait, should not be any subsequent arguments
 
-  static_assert( std::is_same< typename ViewTraits<void,Prop...>::execution_space , void >::value &&
-                 std::is_same< typename ViewTraits<void,Prop...>::memory_space    , void >::value &&
-                 std::is_same< typename ViewTraits<void,Prop...>::array_layout    , void >::value &&
-                 std::is_same< typename ViewTraits<void,Prop...>::memory_traits   , void >::value
-               , "MemoryTrait is the final optional template argument for a View" );
-
-  typedef void          execution_space ;
-  typedef void          memory_space ;
-  typedef void          HostMirrorSpace ;
-  typedef void          array_layout ;
-  typedef MemoryTraits  memory_traits ;
-  typedef void          specialize ;
+  static_assert(
+      std::is_same<typename ViewTraits<void, Prop...>::execution_space,
+                   void>::value &&
+          std::is_same<typename ViewTraits<void, Prop...>::memory_space,
+                       void>::value &&
+          std::is_same<typename ViewTraits<void, Prop...>::array_layout,
+                       void>::value &&
+          std::is_same<typename ViewTraits<void, Prop...>::memory_traits,
+                       void>::value,
+      "MemoryTrait is the final optional template argument for a View");
+
+  typedef void execution_space;
+  typedef void memory_space;
+  typedef void HostMirrorSpace;
+  typedef void array_layout;
+  typedef MemoryTraits memory_traits;
+  typedef void specialize;
 };
 
-
-template< class DataType , class ... Properties >
+template <class DataType, class... Properties>
 struct ViewTraits {
-private:
-
+ private:
   // Unpack the properties arguments
-  typedef ViewTraits< void , Properties ... >  prop ;
-
-  typedef typename
-    std::conditional< ! std::is_same< typename prop::execution_space , void >::value
-                    , typename prop::execution_space
-                    , Kokkos::DefaultExecutionSpace
-                    >::type
-      ExecutionSpace ;
-
-  typedef typename
-    std::conditional< ! std::is_same< typename prop::memory_space , void >::value
-                    , typename prop::memory_space
-                    , typename ExecutionSpace::memory_space
-                    >::type
-      MemorySpace ;
-
-  typedef typename
-    std::conditional< ! std::is_same< typename prop::array_layout , void >::value
-                    , typename prop::array_layout
-                    , typename ExecutionSpace::array_layout
-                    >::type
-      ArrayLayout ;
-
-  typedef typename
-    std::conditional
-      < ! std::is_same< typename prop::HostMirrorSpace , void >::value
-      , typename prop::HostMirrorSpace
-      , typename Kokkos::Impl::HostMirror< ExecutionSpace >::Space
-      >::type
-      HostMirrorSpace ;
-
-  typedef typename
-    std::conditional< ! std::is_same< typename prop::memory_traits , void >::value
-                    , typename prop::memory_traits
-                    , typename Kokkos::MemoryManaged
-                    >::type
-      MemoryTraits ;
+  typedef ViewTraits<void, Properties...> prop;
+
+  typedef typename std::conditional<
+      !std::is_same<typename prop::execution_space, void>::value,
+      typename prop::execution_space, Kokkos::DefaultExecutionSpace>::type
+      ExecutionSpace;
+
+  typedef typename std::conditional<
+      !std::is_same<typename prop::memory_space, void>::value,
+      typename prop::memory_space, typename ExecutionSpace::memory_space>::type
+      MemorySpace;
+
+  typedef typename std::conditional<
+      !std::is_same<typename prop::array_layout, void>::value,
+      typename prop::array_layout, typename ExecutionSpace::array_layout>::type
+      ArrayLayout;
+
+  typedef typename std::conditional<
+      !std::is_same<typename prop::HostMirrorSpace, void>::value,
+      typename prop::HostMirrorSpace,
+      typename Kokkos::Impl::HostMirror<ExecutionSpace>::Space>::type
+      HostMirrorSpace;
+
+  typedef typename std::conditional<
+      !std::is_same<typename prop::memory_traits, void>::value,
+      typename prop::memory_traits, typename Kokkos::MemoryManaged>::type
+      MemoryTraits;
 
   // Analyze data type's properties,
   // May be specialized based upon the layout and value type
-  typedef Kokkos::Impl::ViewDataAnalysis< DataType , ArrayLayout > data_analysis ;
-
-public:
+  typedef Kokkos::Impl::ViewDataAnalysis<DataType, ArrayLayout> data_analysis;
 
+ public:
   //------------------------------------
   // Data type traits:
 
-  typedef typename data_analysis::type            data_type ;
-  typedef typename data_analysis::const_type      const_data_type ;
-  typedef typename data_analysis::non_const_type  non_const_data_type ;
+  typedef typename data_analysis::type data_type;
+  typedef typename data_analysis::const_type const_data_type;
+  typedef typename data_analysis::non_const_type non_const_data_type;
 
   //------------------------------------
   // Compatible array of trivial type traits:
 
-  typedef typename data_analysis::scalar_array_type            scalar_array_type ;
-  typedef typename data_analysis::const_scalar_array_type      const_scalar_array_type ;
-  typedef typename data_analysis::non_const_scalar_array_type  non_const_scalar_array_type ;
+  typedef typename data_analysis::scalar_array_type scalar_array_type;
+  typedef
+      typename data_analysis::const_scalar_array_type const_scalar_array_type;
+  typedef typename data_analysis::non_const_scalar_array_type
+      non_const_scalar_array_type;
 
   //------------------------------------
   // Value type traits:
 
-  typedef typename data_analysis::value_type            value_type ;
-  typedef typename data_analysis::const_value_type      const_value_type ;
-  typedef typename data_analysis::non_const_value_type  non_const_value_type ;
+  typedef typename data_analysis::value_type value_type;
+  typedef typename data_analysis::const_value_type const_value_type;
+  typedef typename data_analysis::non_const_value_type non_const_value_type;
 
   //------------------------------------
   // Mapping traits:
 
-  typedef ArrayLayout                         array_layout ;
-  typedef typename data_analysis::dimension   dimension ;
+  typedef ArrayLayout array_layout;
+  typedef typename data_analysis::dimension dimension;
 
   typedef typename std::conditional<
-                      std::is_same<typename data_analysis::specialize,void>::value
-                      ,typename prop::specialize
-                      ,typename data_analysis::specialize>::type
-                   specialize ; /* mapping specialization tag */
+      std::is_same<typename data_analysis::specialize, void>::value,
+      typename prop::specialize, typename data_analysis::specialize>::type
+      specialize; /* mapping specialization tag */
 
-  enum { rank         = dimension::rank };
+  enum { rank = dimension::rank };
   enum { rank_dynamic = dimension::rank_dynamic };
 
   //------------------------------------
   // Execution space, memory space, memory access traits, and host mirror space.
 
-  typedef ExecutionSpace                              execution_space ;
-  typedef MemorySpace                                 memory_space ;
-  typedef Kokkos::Device<ExecutionSpace,MemorySpace>  device_type ;
-  typedef MemoryTraits                                memory_traits ;
-  typedef HostMirrorSpace                             host_mirror_space ;
+  typedef ExecutionSpace execution_space;
+  typedef MemorySpace memory_space;
+  typedef Kokkos::Device<ExecutionSpace, MemorySpace> device_type;
+  typedef MemoryTraits memory_traits;
+  typedef HostMirrorSpace host_mirror_space;
 
-  typedef typename MemorySpace::size_type  size_type ;
+  typedef typename MemorySpace::size_type size_type;
 
-  enum { is_hostspace      = std::is_same< MemorySpace , HostSpace >::value };
-  enum { is_managed        = MemoryTraits::is_unmanaged    == 0 };
-  enum { is_random_access  = MemoryTraits::is_random_access == 1 };
+  enum { is_hostspace = std::is_same<MemorySpace, HostSpace>::value };
+  enum { is_managed = MemoryTraits::is_unmanaged == 0 };
+  enum { is_random_access = MemoryTraits::is_random_access == 1 };
 
   //------------------------------------
 };
@@ -450,7 +417,8 @@ public:
  *
  * \section Kokkos_View_MT MemoryTraits discussion
  *
- * \subsection Kokkos_View_MT_Interp MemoryTraits interpretation depends on Space
+ * \subsection Kokkos_View_MT_Interp MemoryTraits interpretation depends on
+ * Space
  *
  * Some \c MemoryTraits options may have different interpretations for
  * different \c Space types.  For example, with the Cuda device,
@@ -479,8 +447,8 @@ public:
  * }
  * \endcode
  */
-template< class DataType , class ... Properties >
-class View ;
+template <class DataType, class... Properties>
+class View;
 
 } /* namespace Kokkos */
 
@@ -497,16 +465,15 @@ namespace Kokkos {
 
 namespace {
 
-constexpr Kokkos::Impl::ALL_t
-  ALL = Kokkos::Impl::ALL_t();
+constexpr Kokkos::Impl::ALL_t ALL = Kokkos::Impl::ALL_t();
 
-constexpr Kokkos::Impl::WithoutInitializing_t
-  WithoutInitializing = Kokkos::Impl::WithoutInitializing_t();
+constexpr Kokkos::Impl::WithoutInitializing_t WithoutInitializing =
+    Kokkos::Impl::WithoutInitializing_t();
 
-constexpr Kokkos::Impl::AllowPadding_t
-  AllowPadding        = Kokkos::Impl::AllowPadding_t();
+constexpr Kokkos::Impl::AllowPadding_t AllowPadding =
+    Kokkos::Impl::AllowPadding_t();
 
-}
+}  // namespace
 
 /** \brief  Create View allocation parameter bundle from argument list.
  *
@@ -515,39 +482,34 @@ constexpr Kokkos::Impl::AllowPadding_t
  *    2) memory space instance of the View::memory_space type
  *    3) execution space instance compatible with the View::memory_space
  *    4) Kokkos::WithoutInitializing to bypass initialization
- *    4) Kokkos::AllowPadding to allow allocation to pad dimensions for memory alignment
+ *    4) Kokkos::AllowPadding to allow allocation to pad dimensions for memory
+ * alignment
  */
-template< class ... Args >
-inline
-Impl::ViewCtorProp< typename Impl::ViewCtorProp< void , Args >::type ... >
-view_alloc( Args const & ... args )
-{
-  typedef
-    Impl::ViewCtorProp< typename Impl::ViewCtorProp< void , Args >::type ... >
-      return_type ;
+template <class... Args>
+inline Impl::ViewCtorProp<typename Impl::ViewCtorProp<void, Args>::type...>
+view_alloc(Args const&... args) {
+  typedef Impl::ViewCtorProp<typename Impl::ViewCtorProp<void, Args>::type...>
+      return_type;
 
-  static_assert( ! return_type::has_pointer
-               , "Cannot give pointer-to-memory for view allocation" );
+  static_assert(!return_type::has_pointer,
+                "Cannot give pointer-to-memory for view allocation");
 
-  return return_type( args... );
+  return return_type(args...);
 }
 
-template< class ... Args >
+template <class... Args>
 KOKKOS_INLINE_FUNCTION
-Impl::ViewCtorProp< typename Impl::ViewCtorProp< void , Args >::type ... >
-view_wrap( Args const & ... args )
-{
-  typedef
-    Impl::ViewCtorProp< typename Impl::ViewCtorProp< void , Args >::type ... >
-      return_type ;
+    Impl::ViewCtorProp<typename Impl::ViewCtorProp<void, Args>::type...>
+    view_wrap(Args const&... args) {
+  typedef Impl::ViewCtorProp<typename Impl::ViewCtorProp<void, Args>::type...>
+      return_type;
 
-  static_assert( ! return_type::has_memory_space &&
-                 ! return_type::has_execution_space &&
-                 ! return_type::has_label &&
-                 return_type::has_pointer
-               , "Must only give pointer-to-memory for view wrapping" );
+  static_assert(!return_type::has_memory_space &&
+                    !return_type::has_execution_space &&
+                    !return_type::has_label && return_type::has_pointer,
+                "Must only give pointer-to-memory for view wrapping");
 
-  return return_type( args... );
+  return return_type(args...);
 }
 
 } /* namespace Kokkos */
@@ -557,113 +519,120 @@ view_wrap( Args const & ... args )
 
 namespace Kokkos {
 
-template< class DataType , class ... Properties >
-class View ;
-
-template< class > struct is_view : public std::false_type {};
-
-template< class D, class ... P >
-struct is_view< View<D,P...> > : public std::true_type {};
-
-template< class D, class ... P >
-struct is_view< const View<D,P...> > : public std::true_type {};
+template <class DataType, class... Properties>
+class View;
 
-template< class DataType , class ... Properties >
-class View : public ViewTraits< DataType , Properties ... > {
-private:
+template <class>
+struct is_view : public std::false_type {};
 
-  template< class , class ... > friend class View ;
-  template< class , class ... > friend class Kokkos::Impl::ViewMapping ;
+template <class D, class... P>
+struct is_view<View<D, P...>> : public std::true_type {};
 
-public:
+template <class D, class... P>
+struct is_view<const View<D, P...>> : public std::true_type {};
 
-  typedef ViewTraits< DataType , Properties ... > traits ;
+template <class DataType, class... Properties>
+class View : public ViewTraits<DataType, Properties...> {
+ private:
+  template <class, class...>
+  friend class View;
+  template <class, class...>
+  friend class Kokkos::Impl::ViewMapping;
 
-private:
+ public:
+  typedef ViewTraits<DataType, Properties...> traits;
 
-  typedef Kokkos::Impl::ViewMapping< traits , typename traits::specialize > map_type ;
-  typedef Kokkos::Impl::SharedAllocationTracker      track_type ;
+ private:
+  typedef Kokkos::Impl::ViewMapping<traits, typename traits::specialize>
+      map_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
 
-  track_type  m_track ;
-  map_type    m_map ;
-
-public:
+  track_type m_track;
+  map_type m_map;
 
+ public:
   //----------------------------------------
   /** \brief  Compatible view of array of scalar types */
-  typedef View< typename traits::scalar_array_type ,
-                typename traits::array_layout ,
-                typename traits::device_type ,
-                typename traits::memory_traits >
-    array_type ;
+  typedef View<typename traits::scalar_array_type,
+               typename traits::array_layout, typename traits::device_type,
+               typename traits::memory_traits>
+      array_type;
 
   /** \brief  Compatible view of const data type */
-  typedef View< typename traits::const_data_type ,
-                typename traits::array_layout ,
-                typename traits::device_type ,
-                typename traits::memory_traits >
-    const_type ;
+  typedef View<typename traits::const_data_type, typename traits::array_layout,
+               typename traits::device_type, typename traits::memory_traits>
+      const_type;
 
   /** \brief  Compatible view of non-const data type */
-  typedef View< typename traits::non_const_data_type ,
-                typename traits::array_layout ,
-                typename traits::device_type ,
-                typename traits::memory_traits >
-    non_const_type ;
+  typedef View<typename traits::non_const_data_type,
+               typename traits::array_layout, typename traits::device_type,
+               typename traits::memory_traits>
+      non_const_type;
 
   /** \brief  Compatible HostMirror view */
-  typedef View< typename traits::non_const_data_type ,
-                typename traits::array_layout ,
-                typename traits::host_mirror_space >
-    HostMirror ;
+  typedef View<typename traits::non_const_data_type,
+               typename traits::array_layout,
+               Device<DefaultHostExecutionSpace,
+                      typename traits::host_mirror_space::memory_space>>
+      HostMirror;
 
   /** \brief  Compatible HostMirror view */
-  typedef View< typename traits::non_const_data_type ,
-                typename traits::array_layout ,
-                typename traits::host_mirror_space >
-    host_mirror_type ;
+  typedef View<typename traits::non_const_data_type,
+               typename traits::array_layout,
+               typename traits::host_mirror_space>
+      host_mirror_type;
 
   /** \brief Unified types */
-  typedef typename Impl::ViewUniformType<View,0>::type uniform_type;
-  typedef typename Impl::ViewUniformType<View,0>::const_type uniform_const_type;
-  typedef typename Impl::ViewUniformType<View,0>::runtime_type uniform_runtime_type;
-  typedef typename Impl::ViewUniformType<View,0>::runtime_const_type uniform_runtime_const_type;
-  typedef typename Impl::ViewUniformType<View,0>::nomemspace_type uniform_nomemspace_type;
-  typedef typename Impl::ViewUniformType<View,0>::const_nomemspace_type uniform_const_nomemspace_type;
-  typedef typename Impl::ViewUniformType<View,0>::runtime_nomemspace_type uniform_runtime_nomemspace_type;
-  typedef typename Impl::ViewUniformType<View,0>::runtime_const_nomemspace_type uniform_runtime_const_nomemspace_type;
+  typedef typename Impl::ViewUniformType<View, 0>::type uniform_type;
+  typedef
+      typename Impl::ViewUniformType<View, 0>::const_type uniform_const_type;
+  typedef typename Impl::ViewUniformType<View, 0>::runtime_type
+      uniform_runtime_type;
+  typedef typename Impl::ViewUniformType<View, 0>::runtime_const_type
+      uniform_runtime_const_type;
+  typedef typename Impl::ViewUniformType<View, 0>::nomemspace_type
+      uniform_nomemspace_type;
+  typedef typename Impl::ViewUniformType<View, 0>::const_nomemspace_type
+      uniform_const_nomemspace_type;
+  typedef typename Impl::ViewUniformType<View, 0>::runtime_nomemspace_type
+      uniform_runtime_nomemspace_type;
+  typedef typename Impl::ViewUniformType<View, 0>::runtime_const_nomemspace_type
+      uniform_runtime_const_nomemspace_type;
 
   //----------------------------------------
   // Domain rank and extents
 
   enum { Rank = map_type::Rank };
 
- /** \brief rank() to be implemented
-  */
-  //KOKKOS_INLINE_FUNCTION
-  //static
-  //constexpr unsigned rank() { return map_type::Rank; }
+  /** \brief rank() to be implemented
+   */
+  // KOKKOS_INLINE_FUNCTION
+  // static
+  // constexpr unsigned rank() { return map_type::Rank; }
 
-  template< typename iType >
+  template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr
-  typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-  extent( const iType & r ) const noexcept
-    { return m_map.extent(r); }
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      extent(const iType& r) const noexcept {
+    return m_map.extent(r);
+  }
 
-  static KOKKOS_INLINE_FUNCTION constexpr
-  size_t
-  static_extent( const unsigned r ) noexcept
-    { return map_type::static_extent(r); }
+  static KOKKOS_INLINE_FUNCTION constexpr size_t static_extent(
+      const unsigned r) noexcept {
+    return map_type::static_extent(r);
+  }
 
-  template< typename iType >
+  template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr
-  typename std::enable_if< std::is_integral<iType>::value , int >::type
-  extent_int( const iType & r ) const noexcept
-    { return static_cast<int>(m_map.extent(r)); }
+      typename std::enable_if<std::is_integral<iType>::value, int>::type
+      extent_int(const iType& r) const noexcept {
+    return static_cast<int>(m_map.extent(r));
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr
-  typename traits::array_layout layout() const
-    { return m_map.layout(); }
+  KOKKOS_INLINE_FUNCTION constexpr typename traits::array_layout layout()
+      const {
+    return m_map.layout();
+  }
 
   //----------------------------------------
   /*  Deprecate all 'dimension' functions in favor of
@@ -672,80 +641,134 @@ public:
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
 
-  template< typename iType >
+  template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr
-  typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-  dimension( const iType & r ) const { return extent( r ); }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const { return m_map.dimension_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return m_map.dimension_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return m_map.dimension_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return m_map.dimension_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return m_map.dimension_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return m_map.dimension_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return m_map.dimension_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return m_map.dimension_7(); }
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      dimension(const iType& r) const {
+    return extent(r);
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const {
+    return m_map.dimension_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const {
+    return m_map.dimension_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const {
+    return m_map.dimension_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const {
+    return m_map.dimension_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const {
+    return m_map.dimension_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const {
+    return m_map.dimension_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const {
+    return m_map.dimension_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const {
+    return m_map.dimension_7();
+  }
 
 #endif
 
   //----------------------------------------
 
-  KOKKOS_INLINE_FUNCTION constexpr size_t size() const { return m_map.dimension_0() *
-                                                                m_map.dimension_1() *
-                                                                m_map.dimension_2() *
-                                                                m_map.dimension_3() *
-                                                                m_map.dimension_4() *
-                                                                m_map.dimension_5() *
-                                                                m_map.dimension_6() *
-                                                                m_map.dimension_7(); }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return m_map.stride_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return m_map.stride_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return m_map.stride_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return m_map.stride_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return m_map.stride_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return m_map.stride_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return m_map.stride_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return m_map.stride_7(); }
-
-  template< typename iType >
+  KOKKOS_INLINE_FUNCTION constexpr size_t size() const {
+    return m_map.dimension_0() * m_map.dimension_1() * m_map.dimension_2() *
+           m_map.dimension_3() * m_map.dimension_4() * m_map.dimension_5() *
+           m_map.dimension_6() * m_map.dimension_7();
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const {
+    return m_map.stride_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const {
+    return m_map.stride_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const {
+    return m_map.stride_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const {
+    return m_map.stride_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const {
+    return m_map.stride_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const {
+    return m_map.stride_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const {
+    return m_map.stride_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const {
+    return m_map.stride_7();
+  }
+
+  template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr
-  typename std::enable_if< std::is_integral<iType>::value , size_t >::type
-  stride(iType r) const {
-    return (r == 0 ? m_map.stride_0() :
-           (r == 1 ? m_map.stride_1() :
-           (r == 2 ? m_map.stride_2() :
-           (r == 3 ? m_map.stride_3() :
-           (r == 4 ? m_map.stride_4() :
-           (r == 5 ? m_map.stride_5() :
-           (r == 6 ? m_map.stride_6() :
-                     m_map.stride_7())))))));
+      typename std::enable_if<std::is_integral<iType>::value, size_t>::type
+      stride(iType r) const {
+    return (
+        r == 0
+            ? m_map.stride_0()
+            : (r == 1
+                   ? m_map.stride_1()
+                   : (r == 2
+                          ? m_map.stride_2()
+                          : (r == 3
+                                 ? m_map.stride_3()
+                                 : (r == 4
+                                        ? m_map.stride_4()
+                                        : (r == 5
+                                               ? m_map.stride_5()
+                                               : (r == 6
+                                                      ? m_map.stride_6()
+                                                      : m_map.stride_7())))))));
   }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION void stride( iType * const s ) const { m_map.stride(s); }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    m_map.stride(s);
+  }
 
   //----------------------------------------
   // Range span is the span which contains all members.
 
-  typedef typename map_type::reference_type  reference_type ;
-  typedef typename map_type::pointer_type    pointer_type ;
+  typedef typename map_type::reference_type reference_type;
+  typedef typename map_type::pointer_type pointer_type;
 
-  enum { reference_type_is_lvalue_reference = std::is_lvalue_reference< reference_type >::value };
+  enum {
+    reference_type_is_lvalue_reference =
+        std::is_lvalue_reference<reference_type>::value
+  };
 
   KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return m_map.span(); }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   // Deprecated, use 'span()' instead
-  KOKKOS_INLINE_FUNCTION constexpr size_t capacity() const { return m_map.span(); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t capacity() const {
+    return m_map.span();
+  }
 #endif
-  KOKKOS_INLINE_FUNCTION bool span_is_contiguous() const { return m_map.span_is_contiguous(); }
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return m_map.data(); }
+  KOKKOS_INLINE_FUNCTION bool span_is_contiguous() const {
+    return m_map.span_is_contiguous();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const {
+    return m_map.data();
+  }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   // Deprecated, use 'span_is_contigous()' instead
-  KOKKOS_INLINE_FUNCTION constexpr bool   is_contiguous() const { return m_map.span_is_contiguous(); }
+  KOKKOS_INLINE_FUNCTION constexpr bool is_contiguous() const {
+    return m_map.span_is_contiguous();
+  }
   // Deprecated, use 'data()' instead
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type ptr_on_device() const { return m_map.data(); }
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type ptr_on_device() const {
+    return m_map.data();
+  }
 #endif
 
   //----------------------------------------
@@ -753,1215 +776,946 @@ public:
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   KOKKOS_INLINE_FUNCTION
-  const Kokkos::Impl::ViewMapping< traits , typename traits::specialize > &
-  implementation_map() const { return m_map ; }
+  const Kokkos::Impl::ViewMapping<traits, typename traits::specialize>&
+  implementation_map() const {
+    return m_map;
+  }
 #endif
   KOKKOS_INLINE_FUNCTION
-  const Kokkos::Impl::ViewMapping< traits , typename traits::specialize > &
-  impl_map() const { return m_map ; }
+  const Kokkos::Impl::ViewMapping<traits, typename traits::specialize>&
+  impl_map() const {
+    return m_map;
+  }
   KOKKOS_INLINE_FUNCTION
-  const Kokkos::Impl::SharedAllocationTracker &
-  impl_track() const { return m_track ; }
+  const Kokkos::Impl::SharedAllocationTracker& impl_track() const {
+    return m_track;
+  }
   //----------------------------------------
 
-private:
-
+ private:
   enum {
-    is_layout_left = std::is_same< typename traits::array_layout
-                                  , Kokkos::LayoutLeft >::value ,
+    is_layout_left =
+        std::is_same<typename traits::array_layout, Kokkos::LayoutLeft>::value,
 
-    is_layout_right = std::is_same< typename traits::array_layout
-                                  , Kokkos::LayoutRight >::value ,
+    is_layout_right =
+        std::is_same<typename traits::array_layout, Kokkos::LayoutRight>::value,
 
-    is_layout_stride = std::is_same< typename traits::array_layout
-                                   , Kokkos::LayoutStride >::value ,
+    is_layout_stride = std::is_same<typename traits::array_layout,
+                                    Kokkos::LayoutStride>::value,
 
-    is_default_map =
-      std::is_same< typename traits::specialize , void >::value &&
-      ( is_layout_left || is_layout_right || is_layout_stride )
+    is_default_map = std::is_same<typename traits::specialize, void>::value &&
+                     (is_layout_left || is_layout_right || is_layout_stride)
   };
 
-  template< class Space , bool = Kokkos::Impl::MemorySpaceAccess< Space , typename traits::memory_space >::accessible > struct verify_space
-    { KOKKOS_FORCEINLINE_FUNCTION static void check() {} };
+  template <class Space, bool = Kokkos::Impl::MemorySpaceAccess<
+                             Space, typename traits::memory_space>::accessible>
+  struct verify_space {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {}
+  };
 
-  template< class Space > struct verify_space<Space,false>
-    { KOKKOS_FORCEINLINE_FUNCTION static void check()
-        { Kokkos::abort("Kokkos::View ERROR: attempt to access inaccessible memory space"); };
+  template <class Space>
+  struct verify_space<Space, false> {
+    KOKKOS_FORCEINLINE_FUNCTION static void check() {
+      Kokkos::abort(
+          "Kokkos::View ERROR: attempt to access inaccessible memory space");
     };
+  };
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
 
-#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( ARG ) \
-  View::template verify_space< Kokkos::Impl::ActiveExecutionMemorySpace >::check(); \
-  Kokkos::Impl::view_verify_operator_bounds< typename traits::memory_space > ARG ;
+#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG)             \
+  View::template verify_space<                            \
+      Kokkos::Impl::ActiveExecutionMemorySpace>::check(); \
+  Kokkos::Impl::view_verify_operator_bounds<typename traits::memory_space> ARG;
 
 #else
 
-#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( ARG ) \
-  View::template verify_space< Kokkos::Impl::ActiveExecutionMemorySpace >::check();
+#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG) \
+  View::template verify_space<                \
+      Kokkos::Impl::ActiveExecutionMemorySpace>::check();
 
 #endif
 
-public:
+ public:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-   template< class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<( Kokkos::Impl::are_integral<Args...>::value
-                             && ( 0 == Rank )
-                           ), reference_type >::type
-   operator()( Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,args...) )
-       return m_map.reference();
-     }
-
-   template< typename I0
-              , class ... Args>
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,Args...>::value
-       && ( 1 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0,
-               Args ... args) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,args...) )
-       return m_map.reference(i0);
-     }
-
-   template< typename I0
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,Args...>::value
-       && ( 1 == Rank )
-       && is_default_map
-       && ! is_layout_stride
-     ), reference_type >::type
-   operator()( const I0 & i0
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,args...) )
-       return m_map.m_impl_handle[ i0 ];
-     }
-
-   template< typename I0
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,Args...>::value
-       && ( 1 == Rank )
-       && is_default_map
-       && is_layout_stride
-     ), reference_type >::type
-   operator()( const I0 & i0
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset.m_stride.S0 * i0 ];
-     }
-
-   //------------------------------
-     // Rank 1 operator[]
-
-     template< typename I0 >
-     KOKKOS_FORCEINLINE_FUNCTION
-     typename std::enable_if<
-       ( Kokkos::Impl::are_integral<I0>::value
-         && ( 1 == Rank )
-         && ! is_default_map
-       ), reference_type >::type
-     operator[]( const I0 & i0 ) const
-       {
-         KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-         return m_map.reference(i0);
-       }
-
-    template< typename I0 >
-     KOKKOS_FORCEINLINE_FUNCTION
-     typename std::enable_if<
-       ( Kokkos::Impl::are_integral<I0>::value
-         && ( 1 == Rank )
-         && is_default_map
-         && ! is_layout_stride
-       ), reference_type >::type
-     operator[]( const I0 & i0 ) const
-       {
-         KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-         return m_map.m_impl_handle[ i0 ];
-       }
-
-     template< typename I0 >
-     KOKKOS_FORCEINLINE_FUNCTION
-     typename std::enable_if<
-       ( Kokkos::Impl::are_integral<I0>::value
-         && ( 1 == Rank )
-         && is_default_map
-         && is_layout_stride
-       ), reference_type >::type
-     operator[]( const I0 & i0 ) const
-       {
-         KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-         return m_map.m_impl_handle[ m_map.m_impl_offset.m_stride.S0 * i0 ];
-       }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.reference(i0,i1);
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_left && ( traits::rank_dynamic == 0 )
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i0 + m_map.m_impl_offset.m_dim.N0 * i1 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_left && ( traits::rank_dynamic != 0 )
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i0 + m_map.m_impl_offset.m_stride * i1 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_right && ( traits::rank_dynamic == 0 )
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i1 + m_map.m_impl_offset.m_dim.N1 * i0 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_right && ( traits::rank_dynamic != 0 )
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i1 + m_map.m_impl_offset.m_stride * i0 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_stride
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i0 * m_map.m_impl_offset.m_stride.S0 +
-                              i1 * m_map.m_impl_offset.m_stride.S1 ];
-     }
-
-   //------------------------------
-   // Rank 3
-
-   template< typename I0 , typename I1 , typename I2
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,Args...>::value
-       && ( 3 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,Args...>::value
-       && ( 3 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,args...) )
-       return m_map.reference(i0,i1,i2);
-     }
-
-   //------------------------------
-   // Rank 4
-
- template< typename I0 , typename I1 , typename I2 , typename I3
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,Args...>::value
-       && ( 4 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,Args...>::value
-       && ( 4 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,args...) )
-       return m_map.reference(i0,i1,i2,i3);
-     }
-
-   //------------------------------
-   // Rank 5
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,Args...>::value
-       && ( 5 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,Args...>::value
-       && ( 5 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4);
-     }
-
-   //------------------------------
-   // Rank 6
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,Args...>::value
-       && ( 6 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,Args...>::value
-       && ( 6 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4,i5);
-     }
-
-   //------------------------------
-   // Rank 7
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,Args...>::value
-       && ( 7 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5,i6) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,Args...>::value
-       && ( 7 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4,i5,i6);
-     }
-
-   //------------------------------
-   // Rank 8
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6 , typename I7
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7,Args...>::value
-       && ( 8 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,i7,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5,i6,i7) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6 , typename I7
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7,Args...>::value
-       && ( 8 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,i7,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4,i5,i6,i7);
-     }
-
-
-  #else
+  template <class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<Args...>::value &&
+                               (0 == Rank)),
+                              reference_type>::type
+      operator()(Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, args...))
+    return m_map.reference();
+  }
+
+  template <typename I0, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, Args...>::value &&
+                               (1 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, args...))
+    return m_map.reference(i0);
+  }
+
+  template <typename I0, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, Args...>::value &&
+                               (1 == Rank) && is_default_map &&
+                               !is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, args...))
+    return m_map.m_impl_handle[i0];
+  }
+
+  template <typename I0, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, Args...>::value &&
+                               (1 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
+  }
+
+  //------------------------------
+  // Rank 1 operator[]
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.reference(i0);
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               !is_layout_stride),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.m_impl_handle[i0];
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.reference(i0, i1);
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_left && (traits::rank_dynamic == 0)),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_left && (traits::rank_dynamic != 0)),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_right && (traits::rank_dynamic == 0)),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_right && (traits::rank_dynamic != 0)),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_stride),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
+                               i1 * m_map.m_impl_offset.m_stride.S1];
+  }
+
+  //------------------------------
+  // Rank 3
+
+  template <typename I0, typename I1, typename I2, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, Args...>::value && (3 == Rank) &&
+       is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2)];
+  }
+
+  template <typename I0, typename I1, typename I2, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, Args...>::value && (3 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, args...))
+    return m_map.reference(i0, i1, i2);
+  }
+
+  //------------------------------
+  // Rank 4
+
+  template <typename I0, typename I1, typename I2, typename I3, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, Args...>::value &&
+       (4 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, Args...>::value &&
+       (4 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, args...))
+    return m_map.reference(i0, i1, i2, i3);
+  }
+
+  //------------------------------
+  // Rank 5
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, Args...>::value &&
+       (5 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, Args...>::value &&
+       (5 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, args...))
+    return m_map.reference(i0, i1, i2, i3, i4);
+  }
+
+  //------------------------------
+  // Rank 6
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, Args...>::value &&
+       (6 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, Args...>::value &&
+       (6 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, args...))
+    return m_map.reference(i0, i1, i2, i3, i4, i5);
+  }
+
+  //------------------------------
+  // Rank 7
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, Args...>::value &&
+       (7 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, Args...>::value &&
+       (7 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, args...))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
+  }
+
+  //------------------------------
+  // Rank 8
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7,
+                                  Args...>::value &&
+       (8 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, const I7& i7,
+             Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, i7, args...))
+    return m_map
+        .m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6, i7)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7,
+                                  Args...>::value &&
+       (8 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, const I7& i7,
+             Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, i7, args...))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6, i7);
+  }
+
+#else
   //------------------------------
   // Rank 0 operator()
 
- KOKKOS_FORCEINLINE_FUNCTION
-  reference_type
-  operator()() const
-    {
-      return m_map.reference();
-    }
+  KOKKOS_FORCEINLINE_FUNCTION
+  reference_type operator()() const { return m_map.reference(); }
   //------------------------------
   // Rank 1 operator()
 
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.reference(i0);
+  }
 
-  template< typename I0>
+  template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0>::value
-      && ( 1 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-      return m_map.reference(i0);
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               !is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.m_impl_handle[i0];
+  }
 
-  template< typename I0>
+  template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0>::value
-      && ( 1 == Rank )
-      && is_default_map
-      && ! is_layout_stride
-    ), reference_type >::type
-  operator()( const I0 & i0 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-      return m_map.m_impl_handle[ i0 ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
+  }
+  //------------------------------
+  // Rank 1 operator[]
 
-  template< typename I0 >
+  template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0>::value
-      && ( 1 == Rank )
-      && is_default_map
-      && is_layout_stride
-    ), reference_type >::type
-  operator()( const I0 & i0) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-      return m_map.m_impl_handle[ m_map.m_impl_offset.m_stride.S0 * i0 ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.reference(i0);
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               !is_layout_stride),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.m_impl_handle[i0];
+  }
+
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
+                               (1 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator[](const I0& i0) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0))
+    return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
+  }
+
   //------------------------------
-    // Rank 1 operator[]
-
-    template< typename I0 >
-    KOKKOS_FORCEINLINE_FUNCTION
-    typename std::enable_if<
-      ( Kokkos::Impl::are_integral<I0>::value
-        && ( 1 == Rank )
-        && ! is_default_map
-      ), reference_type >::type
-    operator[]( const I0 & i0 ) const
-      {
-        KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-        return m_map.reference(i0);
-      }
-
-    template< typename I0 >
-    KOKKOS_FORCEINLINE_FUNCTION
-    typename std::enable_if<
-      ( Kokkos::Impl::are_integral<I0>::value
-        && ( 1 == Rank )
-        && is_default_map
-        && ! is_layout_stride
-      ), reference_type >::type
-    operator[]( const I0 & i0 ) const
-      {
-        KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-        return m_map.m_impl_handle[ i0 ];
-      }
-
-    template< typename I0 >
-    KOKKOS_FORCEINLINE_FUNCTION
-    typename std::enable_if<
-      ( Kokkos::Impl::are_integral<I0>::value
-        && ( 1 == Rank )
-        && is_default_map
-        && is_layout_stride
-      ), reference_type >::type
-    operator[]( const I0 & i0 ) const
-      {
-        KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0) )
-        return m_map.m_impl_handle[ m_map.m_impl_offset.m_stride.S0 * i0 ];
-      }
-
-
-    //------------------------------
   // Rank 2
 
-  template< typename I0 , typename I1 >
+  template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1>::value
-      && ( 2 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1) )
-      return m_map.reference(i0,i1);
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1))
+    return m_map.reference(i0, i1);
+  }
 
-  template< typename I0 , typename I1 >
+  template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1>::value
-      && ( 2 == Rank )
-      && is_default_map
-      && is_layout_left && ( traits::rank_dynamic == 0 )
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1) )
-      return m_map.m_impl_handle[ i0 + m_map.m_impl_offset.m_dim.N0 * i1 ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_left && (traits::rank_dynamic == 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1))
+    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
+  }
 
-  template< typename I0 , typename I1>
+  template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1>::value
-      && ( 2 == Rank )
-      && is_default_map
-      && is_layout_left && ( traits::rank_dynamic != 0 )
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1) )
-      return m_map.m_impl_handle[ i0 + m_map.m_impl_offset.m_stride * i1 ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_left && (traits::rank_dynamic != 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1))
+    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
+  }
 
-  template< typename I0 , typename I1 >
+  template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1>::value
-      && ( 2 == Rank )
-      && is_default_map
-      && is_layout_right && ( traits::rank_dynamic == 0 )
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1) )
-      return m_map.m_impl_handle[ i1 + m_map.m_impl_offset.m_dim.N1 * i0 ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_right && (traits::rank_dynamic == 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1))
+    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
+  }
 
-  template< typename I0 , typename I1 >
+  template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1>::value
-      && ( 2 == Rank )
-      && is_default_map
-      && is_layout_right && ( traits::rank_dynamic != 0 )
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1) )
-      return m_map.m_impl_handle[ i1 + m_map.m_impl_offset.m_stride * i0 ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_right && (traits::rank_dynamic != 0)),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1))
+    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
+  }
 
-  template< typename I0 , typename I1>
+  template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1>::value
-      && ( 2 == Rank )
-      && is_default_map
-      && is_layout_stride
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1) )
-      return m_map.m_impl_handle[ i0 * m_map.m_impl_offset.m_stride.S0 +
-                             i1 * m_map.m_impl_offset.m_stride.S1 ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
+                               (2 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1))
+    return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
+                               i1 * m_map.m_impl_offset.m_stride.S1];
+  }
 
   //------------------------------
   // Rank 3
 
-  template< typename I0 , typename I1 , typename I2 >
+  template <typename I0, typename I1, typename I2>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2>::value
-      && ( 3 == Rank )
-      && is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2) )
-      return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2) ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1, I2>::value &&
+                               (3 == Rank) && is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1, const I2& i2) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2)];
+  }
 
-  template< typename I0 , typename I1 , typename I2>
+  template <typename I0, typename I1, typename I2>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2>::value
-      && ( 3 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2) )
-      return m_map.reference(i0,i1,i2);
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1, I2>::value &&
+                               (3 == Rank) && !is_default_map),
+                              reference_type>::type
+      operator()(const I0& i0, const I1& i1, const I2& i2) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2))
+    return m_map.reference(i0, i1, i2);
+  }
 
   //------------------------------
   // Rank 4
 
-  template< typename I0 , typename I1 , typename I2 , typename I3>
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3>::value
-      && ( 4 == Rank )
-      && is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3) )
-      return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3) ];
-    }
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3>::value && (4 == Rank) &&
+       is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3>::value
-      && ( 4 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3) )
-      return m_map.reference(i0,i1,i2,i3);
-    }
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3>::value && (4 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3))
+    return m_map.reference(i0, i1, i2, i3);
+  }
 
   //------------------------------
   // Rank 5
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4>
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4>::value
-      && ( 5 == Rank )
-      && is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4) )
-      return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4) ];
-    }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4>::value && (5 == Rank) &&
+       is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, i4))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4>
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4>::value
-      && ( 5 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4) )
-      return m_map.reference(i0,i1,i2,i3,i4);
-    }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4>::value && (5 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, i4))
+    return m_map.reference(i0, i1, i2, i3, i4);
+  }
 
   //------------------------------
   // Rank 6
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5>::value
-      && ( 6 == Rank )
-      && is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4 , const I5 & i5 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5) )
-      return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5) ];
-    }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5>::value &&
+       (6 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, i4, i5))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5>
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5>::value
-      && ( 6 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4 , const I5 & i5) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5);
-    }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5>::value &&
+       (6 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, i4, i5))
+    return m_map.reference(i0, i1, i2, i3, i4, i5);
+  }
 
   //------------------------------
   // Rank 7
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6>
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6>::value
-      && ( 7 == Rank )
-      && is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4 , const I5 & i5 , const I6 & i6) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6) )
-      return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5,i6) ];
-    }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6>::value &&
+       (7 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6>::value
-      && ( 7 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4 , const I5 & i5 , const I6 & i6) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5,i6);
-    }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6>::value &&
+       (7 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
+  }
 
   //------------------------------
   // Rank 8
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6 , typename I7 >
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7>::value &&
+       (8 == Rank) && is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, const I7& i7) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, i7))
+    return m_map
+        .m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6, i7)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7>::value &&
+       (8 == Rank) && !is_default_map),
+      reference_type>::type
+  operator()(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+             const I4& i4, const I5& i5, const I6& i6, const I7& i7) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, i7))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6, i7);
+  }
+
+#endif
+  template <class... Args>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7>::value
-      && ( 8 == Rank )
-      && is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,i7) )
-      return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5,i6,i7) ];
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<Args...>::value &&
+                               (0 == Rank)),
+                              reference_type>::type
+      access(Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, args...))
+    return m_map.reference();
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6 , typename I7>
+  template <typename I0, class... Args>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<
-    ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7>::value
-      && ( 8 == Rank )
-      && ! is_default_map
-    ), reference_type >::type
-  operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-            , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7 ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,i7) )
-      return m_map.reference(i0,i1,i2,i3,i4,i5,i6,i7);
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, Args...>::value &&
+                               (1 == Rank) && !is_default_map),
+                              reference_type>::type
+      access(const I0& i0, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, args...))
+    return m_map.reference(i0);
+  }
 
-#endif
-  template< class ... Args >
+  template <typename I0, class... Args>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename std::enable_if<( Kokkos::Impl::are_integral<Args...>::value
-                            && ( 0 == Rank )
-                          ), reference_type >::type
-  access( Args ... args ) const
-    {
-      KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,args...) )
-      return m_map.reference();
-    }
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, Args...>::value &&
+                               (1 == Rank) && is_default_map &&
+                               !is_layout_stride),
+                              reference_type>::type
+      access(const I0& i0, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, args...))
+    return m_map.m_impl_handle[i0];
+  }
+
+  template <typename I0, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION
+      typename std::enable_if<(Kokkos::Impl::are_integral<I0, Args...>::value &&
+                               (1 == Rank) && is_default_map &&
+                               is_layout_stride),
+                              reference_type>::type
+      access(const I0& i0, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.reference(i0, i1);
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_left && (traits::rank_dynamic == 0)),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_left && (traits::rank_dynamic != 0)),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_right && (traits::rank_dynamic == 0)),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_right && (traits::rank_dynamic != 0)),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
+  }
+
+  template <typename I0, typename I1, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, Args...>::value && (2 == Rank) &&
+       is_default_map && is_layout_stride),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, args...))
+    return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
+                               i1 * m_map.m_impl_offset.m_stride.S1];
+  }
+
+  //------------------------------
+  // Rank 3
+
+  template <typename I0, typename I1, typename I2, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, Args...>::value && (3 == Rank) &&
+       is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2)];
+  }
+
+  template <typename I0, typename I1, typename I2, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, Args...>::value && (3 == Rank) &&
+       !is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, args...))
+    return m_map.reference(i0, i1, i2);
+  }
+
+  //------------------------------
+  // Rank 4
+
+  template <typename I0, typename I1, typename I2, typename I3, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, Args...>::value &&
+       (4 == Rank) && is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+         Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, Args...>::value &&
+       (4 == Rank) && !is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+         Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((m_track, m_map, i0, i1, i2, i3, args...))
+    return m_map.reference(i0, i1, i2, i3);
+  }
+
+  //------------------------------
+  // Rank 5
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, Args...>::value &&
+       (5 == Rank) && is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, Args...>::value &&
+       (5 == Rank) && !is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, args...))
+    return m_map.reference(i0, i1, i2, i3, i4);
+  }
+
+  //------------------------------
+  // Rank 6
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, Args...>::value &&
+       (6 == Rank) && is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         const I5& i5, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, Args...>::value &&
+       (6 == Rank) && !is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         const I5& i5, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, args...))
+    return m_map.reference(i0, i1, i2, i3, i4, i5);
+  }
+
+  //------------------------------
+  // Rank 7
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, Args...>::value &&
+       (7 == Rank) && is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         const I5& i5, const I6& i6, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, args...))
+    return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6)];
+  }
 
-   template< typename I0
-               , class ... Args>
-    KOKKOS_FORCEINLINE_FUNCTION
-    typename std::enable_if<
-      ( Kokkos::Impl::are_integral<I0,Args...>::value
-        && ( 1 == Rank )
-        && ! is_default_map
-      ), reference_type >::type
-    access( const I0 & i0,
-                Args ... args) const
-      {
-        KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,args...) )
-        return m_map.reference(i0);
-      }
-
-   template< typename I0
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,Args...>::value
-       && ( 1 == Rank )
-       && is_default_map
-       && ! is_layout_stride
-     ), reference_type >::type
-   access( const I0 & i0
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,args...) )
-       return m_map.m_impl_handle[ i0 ];
-     }
-
-   template< typename I0
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,Args...>::value
-       && ( 1 == Rank )
-       && is_default_map
-       && is_layout_stride
-     ), reference_type >::type
-   access( const I0 & i0
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset.m_stride.S0 * i0 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.reference(i0,i1);
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_left && ( traits::rank_dynamic == 0 )
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i0 + m_map.m_impl_offset.m_dim.N0 * i1 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_left && ( traits::rank_dynamic != 0 )
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i0 + m_map.m_impl_offset.m_stride * i1 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_right && ( traits::rank_dynamic == 0 )
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i1 + m_map.m_impl_offset.m_dim.N1 * i0 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_right && ( traits::rank_dynamic != 0 )
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i1 + m_map.m_impl_offset.m_stride * i0 ];
-     }
-
-   template< typename I0 , typename I1
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,Args...>::value
-       && ( 2 == Rank )
-       && is_default_map
-       && is_layout_stride
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,args...) )
-       return m_map.m_impl_handle[ i0 * m_map.m_impl_offset.m_stride.S0 +
-                              i1 * m_map.m_impl_offset.m_stride.S1 ];
-     }
-
-   //------------------------------
-   // Rank 3
-
-   template< typename I0 , typename I1 , typename I2
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,Args...>::value
-       && ( 3 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,Args...>::value
-       && ( 3 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,args...) )
-       return m_map.reference(i0,i1,i2);
-     }
-
-   //------------------------------
-   // Rank 4
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,Args...>::value
-       && ( 4 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,Args...>::value
-       && ( 4 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,args...) )
-       return m_map.reference(i0,i1,i2,i3);
-     }
-
-   //------------------------------
-   // Rank 5
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,Args...>::value
-       && ( 5 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,Args...>::value
-       && ( 5 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4);
-     }
-
-   //------------------------------
-   // Rank 6
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,Args...>::value
-       && ( 6 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,Args...>::value
-       && ( 6 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4,i5);
-     }
-
-   //------------------------------
-   // Rank 7
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,Args...>::value
-       && ( 7 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5,i6) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,Args...>::value
-       && ( 7 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4,i5,i6);
-     }
-
-   //------------------------------
-   // Rank 8
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6 , typename I7
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7,Args...>::value
-       && ( 8 == Rank )
-       && is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,i7,args...) )
-       return m_map.m_impl_handle[ m_map.m_impl_offset(i0,i1,i2,i3,i4,i5,i6,i7) ];
-     }
-
-   template< typename I0 , typename I1 , typename I2 , typename I3
-           , typename I4 , typename I5 , typename I6 , typename I7
-           , class ... Args >
-   KOKKOS_FORCEINLINE_FUNCTION
-   typename std::enable_if<
-     ( Kokkos::Impl::are_integral<I0,I1,I2,I3,I4,I5,I6,I7,Args...>::value
-       && ( 8 == Rank )
-       && ! is_default_map
-     ), reference_type >::type
-   access( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-             , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7
-             , Args ... args ) const
-     {
-       KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (m_track,m_map,i0,i1,i2,i3,i4,i5,i6,i7,args...) )
-       return m_map.reference(i0,i1,i2,i3,i4,i5,i6,i7);
-     }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, Args...>::value &&
+       (7 == Rank) && !is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         const I5& i5, const I6& i6, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, args...))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
+  }
+
+  //------------------------------
+  // Rank 8
 
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7,
+                                  Args...>::value &&
+       (8 == Rank) && is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         const I5& i5, const I6& i6, const I7& i7, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, i7, args...))
+    return m_map
+        .m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6, i7)];
+  }
+
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION typename std::enable_if<
+      (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7,
+                                  Args...>::value &&
+       (8 == Rank) && !is_default_map),
+      reference_type>::type
+  access(const I0& i0, const I1& i1, const I2& i2, const I3& i3, const I4& i4,
+         const I5& i5, const I6& i6, const I7& i7, Args... args) const {
+    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
+        (m_track, m_map, i0, i1, i2, i3, i4, i5, i6, i7, args...))
+    return m_map.reference(i0, i1, i2, i3, i4, i5, i6, i7);
+  }
 
 #undef KOKKOS_IMPL_VIEW_OPERATOR_VERIFY
 
@@ -1975,546 +1729,522 @@ public:
   View() : m_track(), m_map() {}
 
   KOKKOS_INLINE_FUNCTION
-  View( const View & rhs ) : m_track( rhs.m_track, traits::is_managed ), m_map( rhs.m_map ) {}
+  View(const View& rhs)
+      : m_track(rhs.m_track, traits::is_managed), m_map(rhs.m_map) {}
 
   KOKKOS_INLINE_FUNCTION
-  View( View && rhs ) : m_track( std::move(rhs.m_track) ), m_map( std::move(rhs.m_map) ) {}
+  View(View&& rhs)
+      : m_track(std::move(rhs.m_track)), m_map(std::move(rhs.m_map)) {}
 
   KOKKOS_INLINE_FUNCTION
-  View & operator = ( const View & rhs ) { m_track = rhs.m_track ; m_map = rhs.m_map ; return *this ; }
+  View& operator=(const View& rhs) {
+    m_track = rhs.m_track;
+    m_map   = rhs.m_map;
+    return *this;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  View & operator = ( View && rhs ) { m_track = std::move(rhs.m_track) ; m_map = std::move(rhs.m_map) ; return *this ; }
-
-
+  View& operator=(View&& rhs) {
+    m_track = std::move(rhs.m_track);
+    m_map   = std::move(rhs.m_map);
+    return *this;
+  }
 
   //----------------------------------------
   // Compatible view copy constructor and assignment
   // may assign unmanaged from managed.
 
-  template< class RT , class ... RP >
-  KOKKOS_INLINE_FUNCTION
-  View( const View<RT,RP...> & rhs,
-        typename std::enable_if<Kokkos::Impl::ViewMapping<
-        traits , typename View<RT,RP...>::traits , typename traits::specialize >::is_assignable_data_type>::type* = 0
-     )
-    : m_track( rhs.m_track , traits::is_managed )
-    , m_map()
-    {
-      typedef typename View<RT,RP...>::traits  SrcTraits ;
-      typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , typename traits::specialize >  Mapping ;
-      static_assert( Mapping::is_assignable , "Incompatible View copy construction" );
-      Mapping::assign( m_map , rhs.m_map , rhs.m_track );
-    }
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION View(
+      const View<RT, RP...>& rhs,
+      typename std::enable_if<Kokkos::Impl::ViewMapping<
+          traits, typename View<RT, RP...>::traits,
+          typename traits::specialize>::is_assignable_data_type>::type* = 0)
+      : m_track(rhs.m_track, traits::is_managed), m_map() {
+    typedef typename View<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits,
+                                      typename traits::specialize>
+        Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible View copy construction");
+    Mapping::assign(m_map, rhs.m_map, rhs.m_track);
+  }
 
-  template< class RT , class ... RP >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if<Kokkos::Impl::ViewMapping<
-     traits , typename View<RT,RP...>::traits , typename traits::specialize >::is_assignable_data_type,
-     View>::type & operator = ( const View<RT,RP...> & rhs )
-    {
-      typedef typename View<RT,RP...>::traits  SrcTraits ;
-      typedef Kokkos::Impl::ViewMapping< traits , SrcTraits , typename traits::specialize >  Mapping ;
-      static_assert( Mapping::is_assignable , "Incompatible View copy assignment" );
-      Mapping::assign( m_map , rhs.m_map , rhs.m_track );
-      m_track.assign( rhs.m_track , traits::is_managed );
-      return *this ;
-    }
+  template <class RT, class... RP>
+  KOKKOS_INLINE_FUNCTION typename std::enable_if<
+      Kokkos::Impl::ViewMapping<
+          traits, typename View<RT, RP...>::traits,
+          typename traits::specialize>::is_assignable_data_type,
+      View>::type&
+  operator=(const View<RT, RP...>& rhs) {
+    typedef typename View<RT, RP...>::traits SrcTraits;
+    typedef Kokkos::Impl::ViewMapping<traits, SrcTraits,
+                                      typename traits::specialize>
+        Mapping;
+    static_assert(Mapping::is_assignable, "Incompatible View copy assignment");
+    Mapping::assign(m_map, rhs.m_map, rhs.m_track);
+    m_track.assign(rhs.m_track, traits::is_managed);
+    return *this;
+  }
 
   //----------------------------------------
   // Compatible subview constructor
   // may assign unmanaged from managed.
 
-  template< class RT , class ... RP , class Arg0 , class ... Args >
-  KOKKOS_INLINE_FUNCTION
-  View( const View< RT , RP... > & src_view
-      , const Arg0 arg0 , Args ... args )
-    : m_track( src_view.m_track , traits::is_managed )
-    , m_map()
-    {
-      typedef View< RT , RP... > SrcType ;
+  template <class RT, class... RP, class Arg0, class... Args>
+  KOKKOS_INLINE_FUNCTION View(const View<RT, RP...>& src_view, const Arg0 arg0,
+                              Args... args)
+      : m_track(src_view.m_track, traits::is_managed), m_map() {
+    typedef View<RT, RP...> SrcType;
 
-      typedef Kokkos::Impl::ViewMapping
-        < void /* deduce destination view type from source view traits */
-        , typename SrcType::traits
-        , Arg0 , Args... > Mapping ;
+    typedef Kokkos::Impl::ViewMapping<void /* deduce destination view type from
+                                              source view traits */
+                                      ,
+                                      typename SrcType::traits, Arg0, Args...>
+        Mapping;
 
-      typedef typename Mapping::type DstType ;
+    typedef typename Mapping::type DstType;
 
-      static_assert( Kokkos::Impl::ViewMapping< traits , typename DstType::traits , typename traits::specialize >::is_assignable
-        , "Subview construction requires compatible view and subview arguments" );
+    static_assert(
+        Kokkos::Impl::ViewMapping<traits, typename DstType::traits,
+                                  typename traits::specialize>::is_assignable,
+        "Subview construction requires compatible view and subview arguments");
 
-      Mapping::assign( m_map, src_view.m_map, arg0 , args... );
-    }
+    Mapping::assign(m_map, src_view.m_map, arg0, args...);
+  }
 
   //----------------------------------------
   // Allocation tracking properties
 
   KOKKOS_INLINE_FUNCTION
-  int use_count() const
-    { return m_track.use_count(); }
+  int use_count() const { return m_track.use_count(); }
 
-  inline
-  const std::string label() const
-    { return m_track.template get_label< typename traits::memory_space >(); }
+  inline const std::string label() const {
+    return m_track.template get_label<typename traits::memory_space>();
+  }
 
   //----------------------------------------
   // Allocation according to allocation properties and array layout
 
-  template< class ... P >
-  explicit inline
-  View( const Impl::ViewCtorProp< P ... > & arg_prop
-      , typename std::enable_if< ! Impl::ViewCtorProp< P... >::has_pointer
-                               , typename traits::array_layout
-                               >::type const & arg_layout
-      )
-    : m_track()
-    , m_map()
-    {
-      // Append layout and spaces if not input
-      typedef Impl::ViewCtorProp< P ... > alloc_prop_input ;
-
-      // use 'std::integral_constant<unsigned,I>' for non-types
-      // to avoid duplicate class error.
-      typedef Impl::ViewCtorProp
-        < P ...
-        , typename std::conditional
-            < alloc_prop_input::has_label
-            , std::integral_constant<unsigned,0>
-            , typename std::string
-            >::type
-        , typename std::conditional
-            < alloc_prop_input::has_memory_space
-            , std::integral_constant<unsigned,1>
-            , typename traits::device_type::memory_space
-            >::type
-        , typename std::conditional
-            < alloc_prop_input::has_execution_space
-            , std::integral_constant<unsigned,2>
-            , typename traits::device_type::execution_space
-            >::type
-        > alloc_prop ;
-
-      static_assert( traits::is_managed
-                   , "View allocation constructor requires managed memory" );
-
-      if ( alloc_prop::initialize &&
+  template <class... P>
+  explicit inline View(
+      const Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<!Impl::ViewCtorProp<P...>::has_pointer,
+                              typename traits::array_layout>::type const&
+          arg_layout)
+      : m_track(), m_map() {
+    // Append layout and spaces if not input
+    typedef Impl::ViewCtorProp<P...> alloc_prop_input;
+
+    // use 'std::integral_constant<unsigned,I>' for non-types
+    // to avoid duplicate class error.
+    typedef Impl::ViewCtorProp<
+        P...,
+        typename std::conditional<alloc_prop_input::has_label,
+                                  std::integral_constant<unsigned, 0>,
+                                  typename std::string>::type,
+        typename std::conditional<
+            alloc_prop_input::has_memory_space,
+            std::integral_constant<unsigned, 1>,
+            typename traits::device_type::memory_space>::type,
+        typename std::conditional<
+            alloc_prop_input::has_execution_space,
+            std::integral_constant<unsigned, 2>,
+            typename traits::device_type::execution_space>::type>
+        alloc_prop;
+
+    static_assert(traits::is_managed,
+                  "View allocation constructor requires managed memory");
+
+    if (alloc_prop::initialize &&
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-           ! alloc_prop::execution_space::is_initialized()
+        !alloc_prop::execution_space::is_initialized()
 #else
-           ! alloc_prop::execution_space::impl_is_initialized()
+        !alloc_prop::execution_space::impl_is_initialized()
 #endif
-           ) {
-        // If initializing view data then
-        // the execution space must be initialized.
-        Kokkos::Impl::throw_runtime_exception("Constructing View and initializing data with uninitialized execution space");
-      }
+    ) {
+      // If initializing view data then
+      // the execution space must be initialized.
+      Kokkos::Impl::throw_runtime_exception(
+          "Constructing View and initializing data with uninitialized "
+          "execution space");
+    }
 
-      // Copy the input allocation properties with possibly defaulted properties
-      alloc_prop prop_copy( arg_prop );
+    // Copy the input allocation properties with possibly defaulted properties
+    alloc_prop prop_copy(arg_prop);
 
 //------------------------------------------------------------
-#if defined( KOKKOS_ENABLE_CUDA )
-      // If allocating in CudaUVMSpace must fence before and after
-      // the allocation to protect against possible concurrent access
-      // on the CPU and the GPU.
-      // Fence using the trait's executon space (which will be Kokkos::Cuda)
-      // to avoid incomplete type errors from usng Kokkos::Cuda directly.
-      if ( std::is_same< Kokkos::CudaUVMSpace , typename traits::device_type::memory_space >::value ) {
-        typename traits::device_type::memory_space::execution_space().fence();
-      }
+#if defined(KOKKOS_ENABLE_CUDA)
+    // If allocating in CudaUVMSpace must fence before and after
+    // the allocation to protect against possible concurrent access
+    // on the CPU and the GPU.
+    // Fence using the trait's executon space (which will be Kokkos::Cuda)
+    // to avoid incomplete type errors from usng Kokkos::Cuda directly.
+    if (std::is_same<Kokkos::CudaUVMSpace,
+                     typename traits::device_type::memory_space>::value) {
+      typename traits::device_type::memory_space::execution_space().fence();
+    }
 #endif
-//------------------------------------------------------------
+    //------------------------------------------------------------
 
-      Kokkos::Impl::SharedAllocationRecord<> *
-        record = m_map.allocate_shared( prop_copy , arg_layout );
+    Kokkos::Impl::SharedAllocationRecord<>* record =
+        m_map.allocate_shared(prop_copy, arg_layout);
 
 //------------------------------------------------------------
-#if defined( KOKKOS_ENABLE_CUDA )
-      if ( std::is_same< Kokkos::CudaUVMSpace , typename traits::device_type::memory_space >::value ) {
-        typename traits::device_type::memory_space::execution_space().fence();
-      }
+#if defined(KOKKOS_ENABLE_CUDA)
+    if (std::is_same<Kokkos::CudaUVMSpace,
+                     typename traits::device_type::memory_space>::value) {
+      typename traits::device_type::memory_space::execution_space().fence();
+    }
 #endif
-//------------------------------------------------------------
+    //------------------------------------------------------------
 
-      // Setup and initialization complete, start tracking
-      m_track.assign_allocated_record_to_uninitialized( record );
-    }
+    // Setup and initialization complete, start tracking
+    m_track.assign_allocated_record_to_uninitialized(record);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void assign_data( pointer_type arg_data )
-    {
-      m_track.clear();
-      m_map.assign_data( arg_data );
-    }
+  void assign_data(pointer_type arg_data) {
+    m_track.clear();
+    m_map.assign_data(arg_data);
+  }
 
   // Wrap memory according to properties and array layout
-  template< class ... P >
-  explicit KOKKOS_INLINE_FUNCTION
-  View( const Impl::ViewCtorProp< P ... > & arg_prop
-      , typename std::enable_if< Impl::ViewCtorProp< P... >::has_pointer
-                               , typename traits::array_layout
-                               >::type const & arg_layout
-      )
-    : m_track() // No memory tracking
-    , m_map( arg_prop , arg_layout )
-    {
-      static_assert(
-        std::is_same< pointer_type
-                    , typename Impl::ViewCtorProp< P... >::pointer_type
-                    >::value ,
-        "Constructing View to wrap user memory must supply matching pointer type" );
-    }
+  template <class... P>
+  explicit KOKKOS_INLINE_FUNCTION View(
+      const Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<Impl::ViewCtorProp<P...>::has_pointer,
+                              typename traits::array_layout>::type const&
+          arg_layout)
+      : m_track()  // No memory tracking
+        ,
+        m_map(arg_prop, arg_layout) {
+    static_assert(
+        std::is_same<pointer_type,
+                     typename Impl::ViewCtorProp<P...>::pointer_type>::value,
+        "Constructing View to wrap user memory must supply matching pointer "
+        "type");
+  }
 
   // Simple dimension-only layout
-  template< class ... P >
-  explicit inline
-  View( const Impl::ViewCtorProp< P ... > & arg_prop
-      , typename std::enable_if< ! Impl::ViewCtorProp< P... >::has_pointer
-                               , size_t
-                               >::type const arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      )
-    : View( arg_prop
-          , typename traits::array_layout
-              ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-              , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-          )
-    {
+  template <class... P>
+  explicit inline View(
+      const Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<!Impl::ViewCtorProp<P...>::has_pointer,
+                              size_t>::type const arg_N0 =
+          KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+      : View(arg_prop,
+             typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                           arg_N4, arg_N5, arg_N6, arg_N7)) {
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-    Impl::runtime_check_rank_host(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7, label());
+    Impl::runtime_check_rank_host(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7, label());
 #else
-    Impl::runtime_check_rank_device(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7);
+    Impl::runtime_check_rank_device(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
 #endif
+  }
 
-    }
-
-  template< class ... P >
-  explicit KOKKOS_INLINE_FUNCTION
-  View( const Impl::ViewCtorProp< P ... > & arg_prop
-      , typename std::enable_if< Impl::ViewCtorProp< P... >::has_pointer
-                               , size_t
-                               >::type const arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      )
-    : View( arg_prop
-          , typename traits::array_layout
-              ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-              , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-          )
-    {
+  template <class... P>
+  explicit KOKKOS_INLINE_FUNCTION View(
+      const Impl::ViewCtorProp<P...>& arg_prop,
+      typename std::enable_if<Impl::ViewCtorProp<P...>::has_pointer,
+                              size_t>::type const arg_N0 =
+          KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+      : View(arg_prop,
+             typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                           arg_N4, arg_N5, arg_N6, arg_N7)) {
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-    Impl::runtime_check_rank_host(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7, label());
+    Impl::runtime_check_rank_host(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7, label());
 #else
-    Impl::runtime_check_rank_device(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7);
+    Impl::runtime_check_rank_device(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
 #endif
-
-    }
+  }
 
   // Allocate with label and layout
-  template< typename Label >
-  explicit inline
-  View( const Label & arg_label
-      , typename std::enable_if<
-          Kokkos::Impl::is_view_label<Label>::value ,
-          typename traits::array_layout >::type const & arg_layout
-      )
-    : View( Impl::ViewCtorProp< std::string >( arg_label ) , arg_layout )
-    {}
+  template <typename Label>
+  explicit inline View(
+      const Label& arg_label,
+      typename std::enable_if<Kokkos::Impl::is_view_label<Label>::value,
+                              typename traits::array_layout>::type const&
+          arg_layout)
+      : View(Impl::ViewCtorProp<std::string>(arg_label), arg_layout) {}
 
   // Allocate label and layout, must disambiguate from subview constructor.
-  template< typename Label >
-  explicit inline
-  View( const Label & arg_label
-      , typename std::enable_if<
-          Kokkos::Impl::is_view_label<Label>::value ,
-        const size_t >::type arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      )
-    : View( Impl::ViewCtorProp< std::string >( arg_label )
-          , typename traits::array_layout
-              ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-              , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-          )
-    {
-      static_assert ( traits::array_layout::is_extent_constructible , "Layout is not extent constructible. A layout object should be passed too.\n" );
-	  
+  template <typename Label>
+  explicit inline View(
+      const Label& arg_label,
+      typename std::enable_if<Kokkos::Impl::is_view_label<Label>::value,
+                              const size_t>::type arg_N0 =
+          KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+      : View(Impl::ViewCtorProp<std::string>(arg_label),
+             typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                           arg_N4, arg_N5, arg_N6, arg_N7)) {
+    static_assert(traits::array_layout::is_extent_constructible,
+                  "Layout is not extent constructible. A layout object should "
+                  "be passed too.\n");
+
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-    Impl::runtime_check_rank_host(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7, label());
+    Impl::runtime_check_rank_host(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7, label());
 #else
-    Impl::runtime_check_rank_device(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7);
+    Impl::runtime_check_rank_device(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
 #endif
-
-
-
-    }
+  }
 
   // For backward compatibility
-  explicit inline
-  View( const ViewAllocateWithoutInitializing & arg_prop
-      , const typename traits::array_layout & arg_layout
-      )
-    : View( Impl::ViewCtorProp< std::string , Kokkos::Impl::WithoutInitializing_t >( arg_prop.label , Kokkos::WithoutInitializing )
-          , arg_layout
-          )
-    {}
-
-  explicit inline
-  View( const ViewAllocateWithoutInitializing & arg_prop
-      , const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      )
-    : View( Impl::ViewCtorProp< std::string , Kokkos::Impl::WithoutInitializing_t >( arg_prop.label , Kokkos::WithoutInitializing )
-          , typename traits::array_layout
-              ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-              , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-          )
-    {
+  explicit inline View(const ViewAllocateWithoutInitializing& arg_prop,
+                       const typename traits::array_layout& arg_layout)
+      : View(Impl::ViewCtorProp<std::string,
+                                Kokkos::Impl::WithoutInitializing_t>(
+                 arg_prop.label, Kokkos::WithoutInitializing),
+             arg_layout) {}
+
+  explicit inline View(const ViewAllocateWithoutInitializing& arg_prop,
+                       const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+      : View(Impl::ViewCtorProp<std::string,
+                                Kokkos::Impl::WithoutInitializing_t>(
+                 arg_prop.label, Kokkos::WithoutInitializing),
+             typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                           arg_N4, arg_N5, arg_N6, arg_N7)) {
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-    Impl::runtime_check_rank_host(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7, label());
+    Impl::runtime_check_rank_host(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7, label());
 #else
-    Impl::runtime_check_rank_device(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7);
+    Impl::runtime_check_rank_device(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
 #endif
-
-    }
+  }
   template <class Traits>
-  KOKKOS_INLINE_FUNCTION
-  View( const track_type & track,  const Kokkos::Impl::ViewMapping< Traits , typename Traits::specialize >  &map ) :
-  m_track(track), m_map()
-  {
-    typedef Kokkos::Impl::ViewMapping< traits , Traits , typename traits::specialize >  Mapping ;
-    static_assert( Mapping::is_assignable , "Incompatible View copy construction" );
-    Mapping::assign( m_map , map , track );
+  KOKKOS_INLINE_FUNCTION View(
+      const track_type& track,
+      const Kokkos::Impl::ViewMapping<Traits, typename Traits::specialize>& map)
+      : m_track(track), m_map() {
+    typedef Kokkos::Impl::ViewMapping<traits, Traits,
+                                      typename traits::specialize>
+        Mapping;
+    static_assert(Mapping::is_assignable,
+                  "Incompatible View copy construction");
+    Mapping::assign(m_map, map, track);
   }
 
   //----------------------------------------
   // Memory span required to wrap these dimensions.
   static constexpr size_t required_allocation_size(
-                                       const size_t arg_N0 = 0
-                                     , const size_t arg_N1 = 0
-                                     , const size_t arg_N2 = 0
-                                     , const size_t arg_N3 = 0
-                                     , const size_t arg_N4 = 0
-                                     , const size_t arg_N5 = 0
-                                     , const size_t arg_N6 = 0
-                                     , const size_t arg_N7 = 0
-                                     )
-    {
-      return map_type::memory_span(
-        typename traits::array_layout
-          ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-          , arg_N4 , arg_N5 , arg_N6 , arg_N7 ) );
-    }
+      const size_t arg_N0 = 0, const size_t arg_N1 = 0, const size_t arg_N2 = 0,
+      const size_t arg_N3 = 0, const size_t arg_N4 = 0, const size_t arg_N5 = 0,
+      const size_t arg_N6 = 0, const size_t arg_N7 = 0) {
+    return map_type::memory_span(typename traits::array_layout(
+        arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
+  }
 
-  explicit KOKKOS_INLINE_FUNCTION
-  View( pointer_type arg_ptr
-      , const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      )
-    : View( Impl::ViewCtorProp<pointer_type>(arg_ptr)
-          , typename traits::array_layout
-             ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-             , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-          )
-    {
+  explicit KOKKOS_INLINE_FUNCTION View(
+      pointer_type arg_ptr, const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+      : View(Impl::ViewCtorProp<pointer_type>(arg_ptr),
+             typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                           arg_N4, arg_N5, arg_N6, arg_N7)) {
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-    Impl::runtime_check_rank_host(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7, label());
+    Impl::runtime_check_rank_host(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7, label());
 #else
-    Impl::runtime_check_rank_device(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7);
+    Impl::runtime_check_rank_device(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
 #endif
-    }
+  }
 
-  explicit KOKKOS_INLINE_FUNCTION
-  View( pointer_type arg_ptr
-      , const typename traits::array_layout & arg_layout
-      )
-    : View( Impl::ViewCtorProp<pointer_type>(arg_ptr) , arg_layout )
-    {
-
-    }
+  explicit KOKKOS_INLINE_FUNCTION View(
+      pointer_type arg_ptr, const typename traits::array_layout& arg_layout)
+      : View(Impl::ViewCtorProp<pointer_type>(arg_ptr), arg_layout) {}
 
   //----------------------------------------
   // Shared scratch memory constructor
 
-  static inline
-  size_t
-  shmem_size( const size_t arg_N0 = KOKKOS_INVALID_INDEX,
-              const size_t arg_N1 = KOKKOS_INVALID_INDEX,
-              const size_t arg_N2 = KOKKOS_INVALID_INDEX,
-              const size_t arg_N3 = KOKKOS_INVALID_INDEX,
-              const size_t arg_N4 = KOKKOS_INVALID_INDEX,
-              const size_t arg_N5 = KOKKOS_INVALID_INDEX,
-              const size_t arg_N6 = KOKKOS_INVALID_INDEX,
-              const size_t arg_N7 = KOKKOS_INVALID_INDEX )
-  {
-    if ( is_layout_stride ) {
-      Kokkos::abort( "Kokkos::View::shmem_size(extents...) doesn't work with LayoutStride. Pass a LayoutStride object instead" );
+  static inline size_t shmem_size(const size_t arg_N0 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N1 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N2 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N3 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N4 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N5 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N6 = KOKKOS_INVALID_INDEX,
+                                  const size_t arg_N7 = KOKKOS_INVALID_INDEX) {
+    if (is_layout_stride) {
+      Kokkos::abort(
+          "Kokkos::View::shmem_size(extents...) doesn't work with "
+          "LayoutStride. Pass a LayoutStride object instead");
     }
-    const size_t num_passed_args = Impl::count_valid_integers(arg_N0, arg_N1, arg_N2, arg_N3,
-                                                              arg_N4, arg_N5, arg_N6, arg_N7);
+    const size_t num_passed_args = Impl::count_valid_integers(
+        arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
-    if ( std::is_same<typename traits::specialize,void>::value && num_passed_args != traits::rank_dynamic ) {
-      Kokkos::abort( "Kokkos::View::shmem_size() rank_dynamic != number of arguments.\n" );
+    if (std::is_same<typename traits::specialize, void>::value &&
+        num_passed_args != traits::rank_dynamic) {
+      Kokkos::abort(
+          "Kokkos::View::shmem_size() rank_dynamic != number of arguments.\n");
     }
 
-    return View::shmem_size(
-           typename traits::array_layout
-            ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-            , arg_N4 , arg_N5 , arg_N6 , arg_N7 ) );
-  }
-
-  static inline
-  size_t shmem_size( typename traits::array_layout const& arg_layout )
-  {
-    return map_type::memory_span( arg_layout )+sizeof(typename traits::value_type);
-  }
-
-  explicit KOKKOS_INLINE_FUNCTION
-  View( const typename traits::execution_space::scratch_memory_space & arg_space
-      , const typename traits::array_layout & arg_layout )
-    : View( Impl::ViewCtorProp<pointer_type>(
-              reinterpret_cast<pointer_type>(
-                arg_space.get_shmem_aligned( map_type::memory_span( arg_layout ), sizeof(typename traits::value_type) ) ) )
-         , arg_layout )
-    {}
-
-  explicit KOKKOS_INLINE_FUNCTION
-  View( const typename traits::execution_space::scratch_memory_space & arg_space
-      , const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG
-      , const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG )
-    : View( Impl::ViewCtorProp<pointer_type>(
-              reinterpret_cast<pointer_type>(
-                arg_space.get_shmem_aligned(
-                  map_type::memory_span(
-                    typename traits::array_layout
-                     ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-                     , arg_N4 , arg_N5 , arg_N6 , arg_N7 ) ), sizeof(typename traits::value_type) ) ) )
-          , typename traits::array_layout
-             ( arg_N0 , arg_N1 , arg_N2 , arg_N3
-             , arg_N4 , arg_N5 , arg_N6 , arg_N7 )
-       )
-    {
+    return View::shmem_size(typename traits::array_layout(
+        arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
+  }
 
+  static inline size_t shmem_size(
+      typename traits::array_layout const& arg_layout) {
+    return map_type::memory_span(arg_layout) +
+           sizeof(typename traits::value_type);
+  }
+
+  explicit KOKKOS_INLINE_FUNCTION View(
+      const typename traits::execution_space::scratch_memory_space& arg_space,
+      const typename traits::array_layout& arg_layout)
+      : View(Impl::ViewCtorProp<pointer_type>(
+                 reinterpret_cast<pointer_type>(arg_space.get_shmem_aligned(
+                     map_type::memory_span(arg_layout),
+                     sizeof(typename traits::value_type)))),
+             arg_layout) {}
+
+  explicit KOKKOS_INLINE_FUNCTION View(
+      const typename traits::execution_space::scratch_memory_space& arg_space,
+      const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+      const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
+      : View(Impl::ViewCtorProp<pointer_type>(
+                 reinterpret_cast<pointer_type>(arg_space.get_shmem_aligned(
+                     map_type::memory_span(typename traits::array_layout(
+                         arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6,
+                         arg_N7)),
+                     sizeof(typename traits::value_type)))),
+             typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
+                                           arg_N4, arg_N5, arg_N6, arg_N7)) {
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-    Impl::runtime_check_rank_host(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7, label());
+    Impl::runtime_check_rank_host(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7, label());
 #else
-    Impl::runtime_check_rank_device(traits::rank_dynamic, std::is_same<typename traits::specialize,void>::value, arg_N0, arg_N1, arg_N2, arg_N3,
-                             arg_N4, arg_N5, arg_N6, arg_N7);
+    Impl::runtime_check_rank_device(
+        traits::rank_dynamic,
+        std::is_same<typename traits::specialize, void>::value, arg_N0, arg_N1,
+        arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
 #endif
-    }
+  }
 };
 
-
- /** \brief Temporary free function rank()
-  *         until rank() is implemented
-  *         in the View
-  */
-  template < typename D , class ... P >
-  KOKKOS_INLINE_FUNCTION
-  constexpr unsigned rank( const View<D , P...> & V ) { return V.Rank; } //Temporary until added to view
+/** \brief Temporary free function rank()
+ *         until rank() is implemented
+ *         in the View
+ */
+template <typename D, class... P>
+KOKKOS_INLINE_FUNCTION constexpr unsigned rank(const View<D, P...>& V) {
+  return V.Rank;
+}  // Temporary until added to view
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template< class V , class ... Args >
+template <class V, class... Args>
 using Subview =
-  typename Kokkos::Impl::ViewMapping
-    < void /* deduce subview type from source view traits */
-    , typename V::traits
-    , Args ...
-    >::type ;
+    typename Kokkos::Impl::ViewMapping<void /* deduce subview type from source
+                                               view traits */
+                                       ,
+                                       typename V::traits, Args...>::type;
 
-template< class D, class ... P , class ... Args >
+template <class D, class... P, class... Args>
 KOKKOS_INLINE_FUNCTION
-typename Kokkos::Impl::ViewMapping
-  < void /* deduce subview type from source view traits */
-  , ViewTraits< D , P... >
-  , Args ...
-  >::type
-subview( const View< D, P... > & src , Args ... args )
-{
-  static_assert( View< D , P... >::Rank == sizeof...(Args) ,
-    "subview requires one argument for each source View rank" );
-
-  return typename
-    Kokkos::Impl::ViewMapping
-      < void /* deduce subview type from source view traits */
-      , ViewTraits< D , P ... >
-      , Args ... >::type( src , args ... );
+    typename Kokkos::Impl::ViewMapping<void /* deduce subview type from source
+                                               view traits */
+                                       ,
+                                       ViewTraits<D, P...>, Args...>::type
+    subview(const View<D, P...>& src, Args... args) {
+  static_assert(View<D, P...>::Rank == sizeof...(Args),
+                "subview requires one argument for each source View rank");
+
+  return typename Kokkos::Impl::ViewMapping<
+      void /* deduce subview type from source view traits */
+      ,
+      ViewTraits<D, P...>, Args...>::type(src, args...);
 }
 
-template< class MemoryTraits , class D, class ... P , class ... Args >
-KOKKOS_INLINE_FUNCTION
-typename Kokkos::Impl::ViewMapping
-  < void /* deduce subview type from source view traits */
-  , ViewTraits< D , P... >
-  , Args ...
-  >::template apply< MemoryTraits >::type
-subview( const View< D, P... > & src , Args ... args )
-{
-  static_assert( View< D , P... >::Rank == sizeof...(Args) ,
-    "subview requires one argument for each source View rank" );
-
-  return typename
-    Kokkos::Impl::ViewMapping
-      < void /* deduce subview type from source view traits */
-      , ViewTraits< D , P ... >
-      , Args ... >
-      ::template apply< MemoryTraits >
-      ::type( src , args ... );
+template <class MemoryTraits, class D, class... P, class... Args>
+KOKKOS_INLINE_FUNCTION typename Kokkos::Impl::ViewMapping<
+    void /* deduce subview type from source view traits */
+    ,
+    ViewTraits<D, P...>, Args...>::template apply<MemoryTraits>::type
+subview(const View<D, P...>& src, Args... args) {
+  static_assert(View<D, P...>::Rank == sizeof...(Args),
+                "subview requires one argument for each source View rank");
+
+  return typename Kokkos::Impl::ViewMapping<
+      void /* deduce subview type from source view traits */
+      ,
+      ViewTraits<D, P...>,
+      Args...>::template apply<MemoryTraits>::type(src, args...);
 }
 
 } /* namespace Kokkos */
@@ -2524,41 +2254,31 @@ subview( const View< D, P... > & src , Args ... args )
 
 namespace Kokkos {
 
-template< class LT , class ... LP , class RT , class ... RP >
-KOKKOS_INLINE_FUNCTION
-bool operator == ( const View<LT,LP...> & lhs ,
-                   const View<RT,RP...> & rhs )
-{
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator==(const View<LT, LP...>& lhs,
+                                       const View<RT, RP...>& rhs) {
   // Same data, layout, dimensions
-  typedef ViewTraits<LT,LP...>  lhs_traits ;
-  typedef ViewTraits<RT,RP...>  rhs_traits ;
-
-  return
-    std::is_same< typename lhs_traits::const_value_type ,
-                  typename rhs_traits::const_value_type >::value &&
-    std::is_same< typename lhs_traits::array_layout ,
-                  typename rhs_traits::array_layout >::value &&
-    std::is_same< typename lhs_traits::memory_space ,
-                  typename rhs_traits::memory_space >::value &&
-    unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
-    lhs.data()        == rhs.data() &&
-    lhs.span()        == rhs.span() &&
-    lhs.extent(0) == rhs.extent(0) &&
-    lhs.extent(1) == rhs.extent(1) &&
-    lhs.extent(2) == rhs.extent(2) &&
-    lhs.extent(3) == rhs.extent(3) &&
-    lhs.extent(4) == rhs.extent(4) &&
-    lhs.extent(5) == rhs.extent(5) &&
-    lhs.extent(6) == rhs.extent(6) &&
-    lhs.extent(7) == rhs.extent(7);
+  typedef ViewTraits<LT, LP...> lhs_traits;
+  typedef ViewTraits<RT, RP...> rhs_traits;
+
+  return std::is_same<typename lhs_traits::const_value_type,
+                      typename rhs_traits::const_value_type>::value &&
+         std::is_same<typename lhs_traits::array_layout,
+                      typename rhs_traits::array_layout>::value &&
+         std::is_same<typename lhs_traits::memory_space,
+                      typename rhs_traits::memory_space>::value &&
+         unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
+         lhs.data() == rhs.data() && lhs.span() == rhs.span() &&
+         lhs.extent(0) == rhs.extent(0) && lhs.extent(1) == rhs.extent(1) &&
+         lhs.extent(2) == rhs.extent(2) && lhs.extent(3) == rhs.extent(3) &&
+         lhs.extent(4) == rhs.extent(4) && lhs.extent(5) == rhs.extent(5) &&
+         lhs.extent(6) == rhs.extent(6) && lhs.extent(7) == rhs.extent(7);
 }
 
-template< class LT , class ... LP , class RT , class ... RP >
-KOKKOS_INLINE_FUNCTION
-bool operator != ( const View<LT,LP...> & lhs ,
-                   const View<RT,RP...> & rhs )
-{
-  return ! ( operator==(lhs,rhs) );
+template <class LT, class... LP, class RT, class... RP>
+KOKKOS_INLINE_FUNCTION bool operator!=(const View<LT, LP...>& lhs,
+                                       const View<RT, RP...>& rhs) {
+  return !(operator==(lhs, rhs));
 }
 
 } /* namespace Kokkos */
@@ -2569,13 +2289,13 @@ bool operator != ( const View<LT,LP...> & lhs ,
 namespace Kokkos {
 namespace Impl {
 
-inline
-void shared_allocation_tracking_disable()
-{ Kokkos::Impl::SharedAllocationRecord<void,void>::tracking_disable(); }
+inline void shared_allocation_tracking_disable() {
+  Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_disable();
+}
 
-inline
-void shared_allocation_tracking_enable()
-{ Kokkos::Impl::SharedAllocationRecord<void,void>::tracking_enable(); }
+inline void shared_allocation_tracking_enable() {
+  Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_enable();
+}
 
 } /* namespace Impl */
 } /* namespace Kokkos */
@@ -2583,60 +2303,53 @@ void shared_allocation_tracking_enable()
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
-template < class Specialize, typename A, typename B >
+template <class Specialize, typename A, typename B>
 struct CommonViewValueType;
 
-template < typename A, typename B >
-struct CommonViewValueType< void, A, B >
-{
-  using value_type = typename std::common_type< A , B >::type;
+template <typename A, typename B>
+struct CommonViewValueType<void, A, B> {
+  using value_type = typename std::common_type<A, B>::type;
 };
 
-
-template < class Specialize, class ValueType >
+template <class Specialize, class ValueType>
 struct CommonViewAllocProp;
 
-template < class ValueType >
-struct CommonViewAllocProp< void, ValueType >
-{
-  using value_type = ValueType;
+template <class ValueType>
+struct CommonViewAllocProp<void, ValueType> {
+  using value_type        = ValueType;
   using scalar_array_type = ValueType;
 
-  template < class ... Views >
-  KOKKOS_INLINE_FUNCTION
-  CommonViewAllocProp( const Views & ... ) {}
+  template <class... Views>
+  KOKKOS_INLINE_FUNCTION CommonViewAllocProp(const Views&...) {}
 };
 
-
-template < class ... Views >
+template <class... Views>
 struct DeduceCommonViewAllocProp;
 
 // Base case must provide types for:
 // 1. specialize  2. value_type  3. is_view  4. prop_type
-template < class FirstView >
-struct DeduceCommonViewAllocProp< FirstView >
-{
+template <class FirstView>
+struct DeduceCommonViewAllocProp<FirstView> {
   using specialize = typename FirstView::traits::specialize;
 
   using value_type = typename FirstView::traits::value_type;
 
-  enum : bool { is_view = is_view< FirstView >::value };
+  enum : bool { is_view = is_view<FirstView>::value };
 
-  using prop_type = CommonViewAllocProp< specialize, value_type >;
+  using prop_type = CommonViewAllocProp<specialize, value_type>;
 };
 
-
-template < class FirstView, class ... NextViews >
-struct DeduceCommonViewAllocProp< FirstView, NextViews... >
-{
-  using NextTraits = DeduceCommonViewAllocProp< NextViews... >;
+template <class FirstView, class... NextViews>
+struct DeduceCommonViewAllocProp<FirstView, NextViews...> {
+  using NextTraits = DeduceCommonViewAllocProp<NextViews...>;
 
   using first_specialize = typename FirstView::traits::specialize;
   using first_value_type = typename FirstView::traits::value_type;
 
-  enum : bool { first_is_view = is_view< FirstView >::value };
+  enum : bool { first_is_view = is_view<FirstView>::value };
 
   using next_specialize = typename NextTraits::specialize;
   using next_value_type = typename NextTraits::value_type;
@@ -2646,47 +2359,48 @@ struct DeduceCommonViewAllocProp< FirstView, NextViews... >
   // common types
 
   // determine specialize type
-  // if first and next specialize differ, but are not the same specialize, error out
-  static_assert( !(!std::is_same< first_specialize, next_specialize >::value && !std::is_same< first_specialize, void>::value && !std::is_same< void, next_specialize >::value)  , "Kokkos DeduceCommonViewAllocProp ERROR: Only one non-void specialize trait allowed" );
+  // if first and next specialize differ, but are not the same specialize, error
+  // out
+  static_assert(!(!std::is_same<first_specialize, next_specialize>::value &&
+                  !std::is_same<first_specialize, void>::value &&
+                  !std::is_same<void, next_specialize>::value),
+                "Kokkos DeduceCommonViewAllocProp ERROR: Only one non-void "
+                "specialize trait allowed");
 
   // otherwise choose non-void specialize if either/both are non-void
-  using specialize = typename std::conditional< std::is_same< first_specialize, next_specialize >::value
-                                              , first_specialize
-                                              , typename std::conditional< ( std::is_same< first_specialize, void >::value
-                                                                             && !std::is_same< next_specialize, void >::value)
-                                                                           , next_specialize
-                                                                           , first_specialize
-                                                                         >::type
-                                               >::type;
+  using specialize = typename std::conditional<
+      std::is_same<first_specialize, next_specialize>::value, first_specialize,
+      typename std::conditional<(std::is_same<first_specialize, void>::value &&
+                                 !std::is_same<next_specialize, void>::value),
+                                next_specialize, first_specialize>::type>::type;
 
-  using value_type = typename CommonViewValueType< specialize, first_value_type, next_value_type >::value_type;
+  using value_type = typename CommonViewValueType<specialize, first_value_type,
+                                                  next_value_type>::value_type;
 
   enum : bool { is_view = (first_is_view && next_is_view) };
 
-  using prop_type = CommonViewAllocProp< specialize, value_type >;
+  using prop_type = CommonViewAllocProp<specialize, value_type>;
 };
 
-} // end namespace Impl
+}  // end namespace Impl
 
-template < class ... Views >
-using DeducedCommonPropsType = typename Impl::DeduceCommonViewAllocProp<Views...>::prop_type ;
+template <class... Views>
+using DeducedCommonPropsType =
+    typename Impl::DeduceCommonViewAllocProp<Views...>::prop_type;
 
 // User function
-template < class ... Views >
-KOKKOS_INLINE_FUNCTION
-DeducedCommonPropsType<Views...> 
-common_view_alloc_prop( Views const & ... views )
-{
-  return DeducedCommonPropsType<Views...>( views... );
+template <class... Views>
+KOKKOS_INLINE_FUNCTION DeducedCommonPropsType<Views...> common_view_alloc_prop(
+    Views const&... views) {
+  return DeducedCommonPropsType<Views...>(views...);
 }
 
-} // namespace Kokkos
-
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 
-using Kokkos::is_view ;
+using Kokkos::is_view;
 
 } /* namespace Impl */
 } /* namespace Kokkos */
@@ -2698,4 +2412,3 @@ using Kokkos::is_view ;
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_VIEW_HPP */
-
diff --git a/lib/kokkos/core/src/Kokkos_WorkGraphPolicy.hpp b/lib/kokkos/core/src/Kokkos_WorkGraphPolicy.hpp
index dd5e29a400b52dbf432fefec3115f76ab1d67b11..26df7e03a287d6c04ae108d211f2f17699fb5b83 100644
--- a/lib/kokkos/core/src/Kokkos_WorkGraphPolicy.hpp
+++ b/lib/kokkos/core/src/Kokkos_WorkGraphPolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,34 +48,33 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class functor_type , class execution_space, class ... policy_args >
+template <class functor_type, class execution_space, class... policy_args>
 class WorkGraphExec;
 
-}} // namespace Kokkos::Impl
+}
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template< class ... Properties >
-class WorkGraphPolicy: public Kokkos::Impl::PolicyTraits<Properties ... >
-{
-public:
-
-  using execution_policy = WorkGraphPolicy<Properties ... >;
-  using self_type       = WorkGraphPolicy<Properties ... >;
-  using traits          = Kokkos::Impl::PolicyTraits<Properties ... >;
-  using index_type      = typename traits::index_type;
-  using member_type     = index_type;
-  using execution_space = typename traits::execution_space;
-  using memory_space    = typename execution_space::memory_space;
-  using graph_type      = Kokkos::Crs<index_type,execution_space,void,index_type>;
+template <class... Properties>
+class WorkGraphPolicy : public Kokkos::Impl::PolicyTraits<Properties...> {
+ public:
+  using execution_policy = WorkGraphPolicy<Properties...>;
+  using self_type        = WorkGraphPolicy<Properties...>;
+  using traits           = Kokkos::Impl::PolicyTraits<Properties...>;
+  using index_type       = typename traits::index_type;
+  using member_type      = index_type;
+  using execution_space  = typename traits::execution_space;
+  using memory_space     = typename execution_space::memory_space;
+  using graph_type = Kokkos::Crs<index_type, execution_space, void, index_type>;
 
   enum : std::int32_t {
-    END_TOKEN       = -1 ,
-    BEGIN_TOKEN     = -2 ,
-    COMPLETED_TOKEN = -3 };
-
-private:
+    END_TOKEN       = -1,
+    BEGIN_TOKEN     = -2,
+    COMPLETED_TOKEN = -3
+  };
 
+ private:
   using ints_type = Kokkos::View<std::int32_t*, memory_space>;
 
   // Let N = m_graph.numRows(), the total work
@@ -83,30 +83,27 @@ private:
   // m_queue[2*N .. 2*N+2] = the ready queue hints
 
   graph_type const m_graph;
-  ints_type        m_queue ;
+  ints_type m_queue;
 
   KOKKOS_INLINE_FUNCTION
-  void push_work( const std::int32_t w ) const noexcept
-    {
-      const std::int32_t N = m_graph.numRows();
+  void push_work(const std::int32_t w) const noexcept {
+    const std::int32_t N = m_graph.numRows();
 
-      std::int32_t volatile * const ready_queue = & m_queue[0] ;
-      std::int32_t volatile * const end_hint    = & m_queue[2*N+1] ;
+    std::int32_t volatile* const ready_queue = &m_queue[0];
+    std::int32_t volatile* const end_hint    = &m_queue[2 * N + 1];
 
-      // Push work to end of queue
-      const std::int32_t j = atomic_fetch_add( end_hint , 1 );
-
-      if ( ( N <= j ) ||
-           ( END_TOKEN != atomic_exchange(ready_queue+j,w) ) ) {
-        // ERROR: past the end of queue or did not replace END_TOKEN
-        Kokkos::abort("WorkGraphPolicy push_work error");
-      }
+    // Push work to end of queue
+    const std::int32_t j = atomic_fetch_add(end_hint, 1);
 
-      memory_fence();
+    if ((N <= j) || (END_TOKEN != atomic_exchange(ready_queue + j, w))) {
+      // ERROR: past the end of queue or did not replace END_TOKEN
+      Kokkos::abort("WorkGraphPolicy push_work error");
     }
 
-public:
+    memory_fence();
+  }
 
+ public:
   /**\brief  Attempt to pop the work item at the head of the queue.
    *
    *  Find entry 'i' such that
@@ -119,60 +116,59 @@ public:
    *    return END_TOKEN
    *  else
    *    return COMPLETED_TOKEN
-   *  
+   *
    */
   KOKKOS_INLINE_FUNCTION
-  std::int32_t pop_work() const noexcept
-    {
-      const std::int32_t N = m_graph.numRows();
-
-      std::int32_t volatile * const ready_queue = & m_queue[0] ;
-      std::int32_t volatile * const begin_hint  = & m_queue[2*N] ;
-
-      // begin hint is guaranteed to be less than or equal to
-      // actual begin location in the queue.
+  std::int32_t pop_work() const noexcept {
+    const std::int32_t N = m_graph.numRows();
 
-      for ( std::int32_t i = *begin_hint ; i < N ; ++i ) {
+    std::int32_t volatile* const ready_queue = &m_queue[0];
+    std::int32_t volatile* const begin_hint  = &m_queue[2 * N];
 
-        const std::int32_t w = ready_queue[i] ;
+    // begin hint is guaranteed to be less than or equal to
+    // actual begin location in the queue.
 
-        if ( w == END_TOKEN ) { return END_TOKEN ; }
+    for (std::int32_t i = *begin_hint; i < N; ++i) {
+      const std::int32_t w = ready_queue[i];
 
-        if ( ( w != BEGIN_TOKEN ) &&
-             ( w == atomic_compare_exchange(ready_queue+i,w,(std::int32_t)BEGIN_TOKEN) ) ) {
-          // Attempt to claim ready work index succeeded,
-          // update the hint and return work index
-          atomic_increment( begin_hint );
-          return w ;
-        }
-        // arrive here when ready_queue[i] == BEGIN_TOKEN
+      if (w == END_TOKEN) {
+        return END_TOKEN;
       }
 
-      return COMPLETED_TOKEN ;
+      if ((w != BEGIN_TOKEN) &&
+          (w == atomic_compare_exchange(ready_queue + i, w,
+                                        (std::int32_t)BEGIN_TOKEN))) {
+        // Attempt to claim ready work index succeeded,
+        // update the hint and return work index
+        atomic_increment(begin_hint);
+        return w;
+      }
+      // arrive here when ready_queue[i] == BEGIN_TOKEN
     }
 
+    return COMPLETED_TOKEN;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void completed_work( std::int32_t w ) const noexcept
-    {
-      Kokkos::memory_fence();
+  void completed_work(std::int32_t w) const noexcept {
+    Kokkos::memory_fence();
 
-      // Make sure the completed work function's memory accesses are flushed.
+    // Make sure the completed work function's memory accesses are flushed.
 
-      const std::int32_t N = m_graph.numRows();
+    const std::int32_t N = m_graph.numRows();
 
-      std::int32_t volatile * const count_queue = & m_queue[N] ;
+    std::int32_t volatile* const count_queue = &m_queue[N];
 
-      const std::int32_t B = m_graph.row_map(w);
-      const std::int32_t E = m_graph.row_map(w+1);
+    const std::int32_t B = m_graph.row_map(w);
+    const std::int32_t E = m_graph.row_map(w + 1);
 
-      for ( std::int32_t i = B ; i < E ; ++i ) {
-        const std::int32_t j = m_graph.entries(i);
-        if ( 1 == atomic_fetch_add(count_queue+j,-1) ) {
-          push_work(j);
-        }
+    for (std::int32_t i = B; i < E; ++i) {
+      const std::int32_t j = m_graph.entries(i);
+      if (1 == atomic_fetch_add(count_queue + j, -1)) {
+        push_work(j);
       }
     }
+  }
 
   struct TagInit {};
   struct TagCount {};
@@ -185,59 +181,55 @@ public:
    *  m_queue[2*N..2*N+1] = 0, begin/end hints for ready queue
    */
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagInit , int i ) const noexcept
-    { m_queue[i] = i < m_graph.numRows() ? END_TOKEN : 0 ; }
+  void operator()(const TagInit, int i) const noexcept {
+    m_queue[i] = i < m_graph.numRows() ? END_TOKEN : 0;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagCount , int i ) const noexcept
-    {
-      std::int32_t volatile * const count_queue =
-        & m_queue[ m_graph.numRows() ] ;
+  void operator()(const TagCount, int i) const noexcept {
+    std::int32_t volatile* const count_queue = &m_queue[m_graph.numRows()];
 
-      atomic_increment( count_queue + m_graph.entries[i] );
-    }
+    atomic_increment(count_queue + m_graph.entries[i]);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagReady , int w ) const noexcept
-    {
-      std::int32_t const * const count_queue =
-        & m_queue[ m_graph.numRows() ] ;
+  void operator()(const TagReady, int w) const noexcept {
+    std::int32_t const* const count_queue = &m_queue[m_graph.numRows()];
 
-      if ( 0 == count_queue[w] ) push_work(w);
-    }
+    if (0 == count_queue[w]) push_work(w);
+  }
 
-  WorkGraphPolicy( const graph_type & arg_graph )
-    : m_graph(arg_graph)
-    , m_queue( view_alloc( "queue" , WithoutInitializing )
-             , arg_graph.numRows() * 2 + 2 )
-  {
-    { // Initialize
-      using policy_type = RangePolicy<std::int32_t, execution_space, TagInit>;
+  WorkGraphPolicy(const graph_type& arg_graph)
+      : m_graph(arg_graph),
+        m_queue(view_alloc("queue", WithoutInitializing),
+                arg_graph.numRows() * 2 + 2) {
+    {  // Initialize
+      using policy_type  = RangePolicy<std::int32_t, execution_space, TagInit>;
       using closure_type = Kokkos::Impl::ParallelFor<self_type, policy_type>;
       const closure_type closure(*this, policy_type(0, m_queue.size()));
       closure.execute();
       execution_space().fence();
     }
 
-    { // execute-after counts
-      using policy_type = RangePolicy<std::int32_t, execution_space, TagCount>;
+    {  // execute-after counts
+      using policy_type  = RangePolicy<std::int32_t, execution_space, TagCount>;
       using closure_type = Kokkos::Impl::ParallelFor<self_type, policy_type>;
-      const closure_type closure(*this,policy_type(0,m_graph.entries.size()));
+      const closure_type closure(*this, policy_type(0, m_graph.entries.size()));
       closure.execute();
       execution_space().fence();
     }
 
-    { // Scheduling ready tasks
-      using policy_type = RangePolicy<std::int32_t, execution_space, TagReady>;
+    {  // Scheduling ready tasks
+      using policy_type  = RangePolicy<std::int32_t, execution_space, TagReady>;
       using closure_type = Kokkos::Impl::ParallelFor<self_type, policy_type>;
-      const closure_type closure(*this,policy_type(0,m_graph.numRows()));
+      const closure_type closure(*this, policy_type(0, m_graph.numRows()));
       closure.execute();
       execution_space().fence();
     }
   }
 };
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #ifdef KOKKOS_ENABLE_SERIAL
 #include "impl/Kokkos_Serial_WorkGraphPolicy.hpp"
diff --git a/lib/kokkos/core/src/Kokkos_hwloc.hpp b/lib/kokkos/core/src/Kokkos_hwloc.hpp
index 064e5816a5c5e4fbdad6c0f8cdd42033f0f11dbf..f343ef80b4f8e22830481f9e0cdf10b0a7fab7c6 100644
--- a/lib/kokkos/core/src/Kokkos_hwloc.hpp
+++ b/lib/kokkos/core/src/Kokkos_hwloc.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -77,7 +78,8 @@ unsigned get_available_numa_count();
  */
 unsigned get_available_cores_per_numa();
 
-/** \brief  Query number of available "hard" threads per core; i.e., hyperthreads */
+/** \brief  Query number of available "hard" threads per core; i.e.,
+ * hyperthreads */
 unsigned get_available_threads_per_core();
 
 } /* namespace hwloc */
@@ -99,12 +101,10 @@ namespace hwloc {
  * Return 0 if asynchronous,
  * Return 1 if synchronous and threads_coord[0] is process core
  */
-unsigned thread_mapping( const char * const label ,
-                         const bool allow_async ,
-                         unsigned & thread_count ,
-                         unsigned & use_numa_count ,
-                         unsigned & use_cores_per_numa ,
-                         std::pair<unsigned,unsigned> threads_coord[] );
+unsigned thread_mapping(const char* const label, const bool allow_async,
+                        unsigned& thread_count, unsigned& use_numa_count,
+                        unsigned& use_cores_per_numa,
+                        std::pair<unsigned, unsigned> threads_coord[]);
 
 /** \brief  Query core-coordinate of the current thread
  *          with respect to the core_topology.
@@ -115,11 +115,10 @@ unsigned thread_mapping( const char * const label ,
  *  core_coordinate.first  < core_topology.first
  *  core_coordinate.second < core_topology.second
  */
-std::pair<unsigned,unsigned> get_this_thread_coordinate();
+std::pair<unsigned, unsigned> get_this_thread_coordinate();
 
 /** \brief  Bind the current thread to a core. */
-bool bind_this_thread( const std::pair<unsigned,unsigned> );
-
+bool bind_this_thread(const std::pair<unsigned, unsigned>);
 
 /** \brief Can hwloc bind threads? */
 bool can_bind_threads();
@@ -128,8 +127,8 @@ bool can_bind_threads();
  *          Set that entry to (~0,~0) and return the index.
  *          If binding fails return ~0.
  */
-unsigned bind_this_thread( const unsigned               coordinate_count ,
-                           std::pair<unsigned,unsigned> coordinate[] );
+unsigned bind_this_thread(const unsigned coordinate_count,
+                          std::pair<unsigned, unsigned> coordinate[]);
 
 /** \brief  Unbind the current thread back to the original process binding */
 bool unbind_this_thread();
@@ -141,4 +140,3 @@ bool unbind_this_thread();
 //----------------------------------------------------------------------------
 
 #endif /* #define KOKKOS_HWLOC_HPP */
-
diff --git a/lib/kokkos/core/src/Makefile b/lib/kokkos/core/src/Makefile
deleted file mode 100644
index ae8dc17510d7c35154732221454c95dc399b92b5..0000000000000000000000000000000000000000
--- a/lib/kokkos/core/src/Makefile
+++ /dev/null
@@ -1,117 +0,0 @@
-ifndef KOKKOS_PATH
-  MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-  KOKKOS_PATH = $(subst Makefile,,$(MAKEFILE_PATH))../..
-endif
-
-PREFIX ?= /usr/local/lib/kokkos
-
-default: build-lib
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX ?= $(KOKKOS_PATH)/bin/nvcc_wrapper
-else
-  CXX ?= g++
-endif
-
-CXXFLAGS ?= -O3
-LINK ?= $(CXX)
-LDFLAGS ?=
-CP = cp
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-include $(KOKKOS_PATH)/core/src/Makefile.generate_header_lists
-include $(KOKKOS_PATH)/core/src/Makefile.generate_build_files
-
-CONDITIONAL_COPIES =
-
-ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
-  CONDITIONAL_COPIES += copy-cuda
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
-  CONDITIONAL_COPIES += copy-threads
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_QTHREADS), 1)
-  CONDITIONAL_COPIES += copy-qthreads
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
-  CONDITIONAL_COPIES += copy-openmp
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
-  CONDITIONAL_COPIES += copy-hpx
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_ROCM), 1)
-  CONDITIONAL_COPIES += copy-rocm
-endif
-
-ifeq ($(KOKKOS_OS),CYGWIN)
-  COPY_FLAG = -u
-endif
-ifeq ($(KOKKOS_OS),Linux)
-  COPY_FLAG = -u
-endif
-ifeq ($(KOKKOS_OS),Darwin)
-  COPY_FLAG = 
-  # If Homebrew coreutils is installed, its cp will have the -u option
-  ifneq ("$(wildcard /usr/local/opt/coreutils/libexec/gnubin/cp)","")
-    CP = /usr/local/opt/coreutils/libexec/gnubin/cp
-    COPY_FLAG = -u
-  endif
-endif
-
-ifeq ($(KOKKOS_DEBUG),"no")
-  KOKKOS_DEBUG_CMAKE = OFF
-else
-  KOKKOS_DEBUG_CMAKE = ON
-endif
-
-build-lib: $(KOKKOS_LINK_DEPENDS)
-
-mkdir:
-	mkdir -p $(PREFIX)
-	mkdir -p $(PREFIX)/bin
-	mkdir -p $(PREFIX)/include
-	mkdir -p $(PREFIX)/lib
-	mkdir -p $(PREFIX)/lib/pkgconfig
-	mkdir -p $(PREFIX)/include/impl
-
-copy-cuda: mkdir
-	mkdir -p $(PREFIX)/include/Cuda
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_CUDA) $(PREFIX)/include/Cuda
-
-copy-threads: mkdir
-	mkdir -p $(PREFIX)/include/Threads
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_THREADS) $(PREFIX)/include/Threads
-
-copy-qthreads: mkdir
-	mkdir -p $(PREFIX)/include/Qthreads
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_QTHREADS) $(PREFIX)/include/Qthreads
-
-copy-openmp: mkdir
-	mkdir -p $(PREFIX)/include/OpenMP
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_OPENMP) $(PREFIX)/include/OpenMP
-
-copy-hpx: mkdir
-	mkdir -p $(PREFIX)/include/HPX
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_HPX) $(PREFIX)/include/HPX
-
-copy-rocm: mkdir
-	mkdir -p $(PREFIX)/include/ROCm
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_ROCM) $(PREFIX)/include/ROCm
-
-install: mkdir $(CONDITIONAL_COPIES) build-lib generate_build_settings
-	$(CP) $(COPY_FLAG) $(NVCC_WRAPPER) $(PREFIX)/bin
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_INCLUDE) $(PREFIX)/include
-	$(CP) $(COPY_FLAG) $(KOKKOS_HEADERS_INCLUDE_IMPL) $(PREFIX)/include/impl
-	$(CP) $(COPY_FLAG) $(KOKKOS_MAKEFILE)  $(PREFIX)
-	$(CP) $(COPY_FLAG) $(KOKKOS_CMAKEFILE)  $(PREFIX)
-	$(CP) $(COPY_FLAG) $(KOKKOS_PKGCONFIG)  $(PREFIX)/lib/pkgconfig
-	$(CP) $(COPY_FLAG) libkokkos.a $(PREFIX)/lib
-	$(CP) $(COPY_FLAG) $(KOKKOS_CONFIG_HEADER) $(PREFIX)/include
-
-clean: kokkos-clean
-	rm -f $(KOKKOS_MAKEFILE) $(KOKKOS_CMAKEFILE) $(KOKKOS_PKGCONFIG) 
diff --git a/lib/kokkos/core/src/Makefile.generate_build_files b/lib/kokkos/core/src/Makefile.generate_build_files
deleted file mode 100644
index 651b9d5fe9df2f3a5217f8864bd691b500ec9bdf..0000000000000000000000000000000000000000
--- a/lib/kokkos/core/src/Makefile.generate_build_files
+++ /dev/null
@@ -1,125 +0,0 @@
-# This file is responsible for generating files which will be used 
-# by build system (make and cmake) in scenarios where the kokkos library
-# gets installed before building the app 
-
-# These files are generated by this makefile
-KOKKOS_MAKEFILE=Makefile.kokkos
-KOKKOS_CMAKEFILE=kokkos_generated_settings.cmake
-KOKKOS_PKGCONFIG=kokkos.pc
-
-ifeq ($(KOKKOS_DEBUG),"no")
-  KOKKOS_DEBUG_CMAKE = OFF
-else
-  KOKKOS_DEBUG_CMAKE = ON
-endif
-
-# Functions for generating makefile and cmake file
-# In calling these routines, do not put space after ,
-# e.g., $(call kokkos_append_var,KOKKOS_PATH,$(PREFIX))
-kokkos_append_makefile = echo $1 >> $(KOKKOS_MAKEFILE)
-kokkos_append_cmakefile = echo $1 >> $(KOKKOS_CMAKEFILE)
-
-kokkos_setvar_cmakefile = echo set\($1 $2\) >> $(KOKKOS_CMAKEFILE)
-kokkos_setlist_cmakefile = echo set\($1 \"$2\"\) >> $(KOKKOS_CMAKEFILE)
-
-kokkos_appendvar_makefile = echo $1 = $($(1)) >> $(KOKKOS_MAKEFILE)
-kokkos_appendvar2_makefile = echo $1 ?= $($(1)) >> $(KOKKOS_MAKEFILE)
-kokkos_appendvar_cmakefile = echo set\($1 $($(1)) CACHE $2 FORCE\) >> $(KOKKOS_CMAKEFILE)
-kokkos_appendval_makefile = echo $1 = $2 >> $(KOKKOS_MAKEFILE)
-kokkos_appendval_cmakefile = echo set\($1 $2 CACHE $3 FORCE\) >> $(KOKKOS_CMAKEFILE)
-kokkos_append_gmakevar_cmakefile = echo set\(KOKKOS_GMAKE_$(1:KOKKOS_%=%) \"$($(1))\" CACHE $2 FORCE\) >> $(KOKKOS_CMAKEFILE)
-
-kokkos_append_string = $(call kokkos_append_makefile,$1); $(call kokkos_append_cmakefile,$1)
-kokkos_append_var = $(call kokkos_appendvar_makefile,$1); $(call kokkos_appendvar_cmakefile,$1,$2)
-kokkos_append_var2 = $(call kokkos_appendvar2_makefile,$1); $(call kokkos_appendvar_cmakefile,$1,$2)
-kokkos_append_varval = $(call kokkos_appendval_makefile,$1,$2); $(call kokkos_appendval_cmakefile,$1,$2,$3)
-
-kokkos_fixup_sed_impl = sed \
-		-e 's|$(KOKKOS_PATH)/core/src|$(PREFIX)/include|g' \
-		-e 's|$(KOKKOS_PATH)/containers/src|$(PREFIX)/include|g' \
-		-e 's|$(KOKKOS_PATH)/algorithms/src|$(PREFIX)/include|g' \
-		-e 's|-L$(PWD)|-L$(PREFIX)/lib|g' \
-		-e 's|= libkokkos.a|= $(PREFIX)/lib/libkokkos.a|g' \
-		-e 's|= $(KOKKOS_CONFIG_HEADER)|= $(PREFIX)/include/$(KOKKOS_CONFIG_HEADER)|g' $1 \
-		> $1.tmp && mv -f $1.tmp $1
-
-$(KOKKOS_PKGCONFIG): $(KOKKOS_PATH)/core/src/$(KOKKOS_PKGCONFIG).in
-	@sed -e 's|@CMAKE_INSTALL_PREFIX@|$(PREFIX)|g' \
-	    -e 's|@KOKKOS_CXXFLAGS@|$(patsubst -I%,,$(KOKKOS_CXXFLAGS))|g' \
-	    -e 's|@KOKKOS_EXTRA_LIBS_LIST@|$(KOKKOS_EXTRA_LIBS)|g' \
-	    -e 's|@KOKKOS_LINK_FLAGS@|$(KOKKOS_LINK_FLAGS)|g' \
-	     $< > $@
-
-kokkos_fixup_sed = $(call kokkos_fixup_sed_impl,$(KOKKOS_MAKEFILE)); $(call kokkos_fixup_sed_impl,$(KOKKOS_CMAKEFILE))
-
-#This function should be used for variables whose values are different in GNU Make versus CMake,
-#especially lists which are delimited by commas in one case and semicolons in another
-kokkos_append_gmakevar = $(call kokkos_appendvar_makefile,$1); $(call kokkos_append_gmakevar_cmakefile,$1,$2)
-
-generate_build_settings: $(KOKKOS_CONFIG_HEADER) $(KOKKOS_PKGCONFIG)
-	@rm -f $(KOKKOS_MAKEFILE)
-	@rm -f $(KOKKOS_CMAKEFILE)
-	@$(call kokkos_append_string, "#Global Settings used to generate this library")
-	@$(call kokkos_append_varval,KOKKOS_PATH,$(KOKKOS_INSTALL_PATH),'FILEPATH "Kokkos installation path"')
-	@$(call kokkos_append_gmakevar,KOKKOS_DEVICES,'STRING "Kokkos devices list"')
-	@$(call kokkos_append_gmakevar,KOKKOS_ARCH,'STRING "Kokkos architecture flags"')
-	@$(call kokkos_appendvar_makefile,KOKKOS_DEBUG)
-	@$(call kokkos_appendvar_cmakefile,KOKKOS_DEBUG_CMAKE,'BOOL "Kokkos debug enabled ?"')
-	@$(call kokkos_append_gmakevar,KOKKOS_USE_TPLS,'STRING "Kokkos templates list"')
-	@$(call kokkos_append_var,KOKKOS_CXX_STANDARD,'STRING "Kokkos C++ standard"')
-	@$(call kokkos_append_gmakevar,KOKKOS_OPTIONS,'STRING "Kokkos options"')
-	@$(call kokkos_append_gmakevar,KOKKOS_CUDA_OPTIONS,'STRING "Kokkos Cuda options"')
-	@$(call kokkos_append_gmakevar,KOKKOS_TPL_INCLUDE_DIRS,'STRING "Kokkos TPL include directories"')
-	@$(call kokkos_append_gmakevar,KOKKOS_TPL_LIBRARY_DIRS,'STRING "Kokkos TPL library directories"')
-	@$(call kokkos_append_gmakevar,KOKKOS_TPL_LIBRARY_NAMES,'STRING "Kokkos TPL library names"')
-	@$(call kokkos_appendvar2,CXX,'KOKKOS C++ Compiler')
-	@$(call kokkos_append_cmakefile,"if(NOT DEFINED ENV{NVCC_WRAPPER})")
-	@$(call kokkos_append_var2,NVCC_WRAPPER,'FILEPATH "Path to command nvcc_wrapper"')
-	@$(call kokkos_append_cmakefile,"else()")
-	@$(call kokkos_append_cmakefile,'  set(NVCC_WRAPPER $$ENV{NVCC_WRAPPER} CACHE FILEPATH "Path to command nvcc_wrapper")')
-	@$(call kokkos_append_cmakefile,"endif()")
-	@$(call kokkos_append_string,"")
-	@$(call kokkos_append_string,"#Source and Header files of Kokkos relative to KOKKOS_PATH")
-	@$(call kokkos_append_var,KOKKOS_HEADERS,'STRING "Kokkos headers list"')
-	@$(call kokkos_append_var,KOKKOS_HEADERS_IMPL,'STRING "Kokkos headers impl list"')
-	@$(call kokkos_append_var,KOKKOS_HEADERS_CUDA,'STRING "Kokkos headers Cuda list"')
-	@$(call kokkos_append_var,KOKKOS_HEADERS_OPENMP,'STRING "Kokkos headers OpenMP list"')
-	@$(call kokkos_append_var,KOKKOS_HEADERS_HPX,'STRING "Kokkos headers HPX list"')
-	@$(call kokkos_append_var,KOKKOS_HEADERS_ROCM,'STRING "Kokkos headers ROCm list"')
-	@$(call kokkos_append_var,KOKKOS_HEADERS_THREADS,'STRING "Kokkos headers Threads list"')
-	@$(call kokkos_append_var,KOKKOS_HEADERS_QTHREADS,'STRING "Kokkos headers QThreads list"')
-	@$(call kokkos_append_string,"")
-	@$(call kokkos_append_string,"#Variables used in application Makefiles")
-	@$(call kokkos_append_var,KOKKOS_OS,'STRING ""')  # This was not in original cmake gen
-	@$(call kokkos_append_var,KOKKOS_CPP_DEPENDS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_LINK_DEPENDS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_CXXFLAGS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_CPPFLAGS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_LDFLAGS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_CXXLDFLAGS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_LIBS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_EXTRA_LIBS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_LINK_FLAGS,'STRING "extra flags to the link step (e.g. OpenMP)"')
-	@$(call kokkos_append_string,"")
-	@$(call kokkos_append_string,"#Internal settings which need to propagated for Kokkos examples")
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_CUDA,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_OPENMP,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_HPX,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_PTHREADS,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_SERIAL,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_ROCM,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_HPX,'STRING ""')
-	@$(call kokkos_append_var,KOKKOS_INTERNAL_USE_QTHREADS,'STRING ""') # Not in original cmake gen
-	@$(call kokkos_append_cmakefile "mark_as_advanced(KOKKOS_HEADERS KOKKOS_SRC KOKKOS_INTERNAL_USE_CUDA KOKKOS_INTERNAL_USE_OPENMP KOKKOS_INTERNAL_USE_HPX KOKKOS_INTERNAL_USE_PTHREADS KOKKOS_INTERNAL_USE_SERIAL)")
-	@$(call kokkos_append_makefile,"")
-	@$(call kokkos_append_makefile,"#Fake kokkos-clean target")
-	@$(call kokkos_append_makefile,"kokkos-clean:")
-	@$(call kokkos_append_makefile,"")
-	@$(call kokkos_fixup_sed)
-	@$(call kokkos_append_var,KOKKOS_SRC,'STRING "Kokkos source list"')
-	@$(call kokkos_setvar_cmakefile,KOKKOS_CXX_FLAGS,$(KOKKOS_CXXFLAGS))
-	@$(call kokkos_setvar_cmakefile,KOKKOS_CPP_FLAGS,$(KOKKOS_CPPFLAGS))
-	@$(call kokkos_setvar_cmakefile,KOKKOS_LD_FLAGS,$(KOKKOS_LDFLAGS))
-	@$(call kokkos_setlist_cmakefile,KOKKOS_LIBS_LIST,$(KOKKOS_LIBS))
-	@$(call kokkos_setlist_cmakefile,KOKKOS_EXTRA_LIBS_LIST,$(KOKKOS_EXTRA_LIBS))
-	@$(call kokkos_setvar_cmakefile,KOKKOS_LINK_FLAGS,$(KOKKOS_LINK_FLAGS))
diff --git a/lib/kokkos/core/src/Makefile.generate_header_lists b/lib/kokkos/core/src/Makefile.generate_header_lists
deleted file mode 100644
index afbefb380620cb0ebd525c46392c1a67ecdb69be..0000000000000000000000000000000000000000
--- a/lib/kokkos/core/src/Makefile.generate_header_lists
+++ /dev/null
@@ -1,32 +0,0 @@
-# Build a List of Header Files
-
-KOKKOS_HEADERS_INCLUDE       = $(wildcard $(KOKKOS_PATH)/core/src/*.hpp)
-KOKKOS_HEADERS_INCLUDE_IMPL  = $(wildcard $(KOKKOS_PATH)/core/src/impl/*.hpp)
-KOKKOS_HEADERS_INCLUDE      += $(wildcard $(KOKKOS_PATH)/containers/src/*.hpp)
-KOKKOS_HEADERS_INCLUDE_IMPL += $(wildcard $(KOKKOS_PATH)/containers/src/impl/*.hpp)
-KOKKOS_HEADERS_INCLUDE      += $(wildcard $(KOKKOS_PATH)/algorithms/src/*.hpp)
-
-ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
-  KOKKOS_HEADERS_CUDA += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.hpp)
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
-  KOKKOS_HEADERS_THREADS += $(wildcard $(KOKKOS_PATH)/core/src/Threads/*.hpp)
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_QTHREADS), 1)
-  KOKKOS_HEADERS_QTHREADS += $(wildcard $(KOKKOS_PATH)/core/src/Qthreads/*.hpp)
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
-  KOKKOS_HEADERS_OPENMP += $(wildcard $(KOKKOS_PATH)/core/src/OpenMP/*.hpp)
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
-  KOKKOS_HEADERS_HPX += $(wildcard $(KOKKOS_PATH)/core/src/HPX/*.hpp)
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_ROCM), 1)
-  KOKKOS_HEADERS_ROCM += $(wildcard $(KOKKOS_PATH)/core/src/ROCm/*.hpp)
-endif
-
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.cpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.cpp
index 1946c107417e92bb3855a0681041761be44e394d..d152fd62dc47e3cb247cec400a18c9422dde7d7a 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.cpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP )
+#if defined(KOKKOS_ENABLE_OPENMP)
 
 #include <cstdio>
 #include <cstdlib>
@@ -57,30 +58,25 @@
 #include <impl/Kokkos_CPUDiscovery.hpp>
 #include <impl/Kokkos_Profiling_Interface.hpp>
 
-
 namespace Kokkos {
 namespace Impl {
 
 int g_openmp_hardware_max_threads = 1;
 
-__thread int t_openmp_hardware_id = 0;
-__thread Impl::OpenMPExec * t_openmp_instance = nullptr;
+__thread int t_openmp_hardware_id            = 0;
+__thread Impl::OpenMPExec *t_openmp_instance = nullptr;
 
-void OpenMPExec::validate_partition( const int nthreads
-                                   , int & num_partitions
-                                   , int & partition_size
-                                  )
-{
+void OpenMPExec::validate_partition(const int nthreads, int &num_partitions,
+                                    int &partition_size) {
   if (nthreads == 1) {
     num_partitions = 1;
     partition_size = 1;
-  }
-  else if( num_partitions < 1 && partition_size < 1) {
+  } else if (num_partitions < 1 && partition_size < 1) {
     int idle = nthreads;
-    for (int np = 2; np <= nthreads ; ++np) {
-      for (int ps = 1; ps <= nthreads/np; ++ps) {
-        if (nthreads - np*ps < idle) {
-          idle = nthreads - np*ps;
+    for (int np = 2; np <= nthreads; ++np) {
+      for (int ps = 1; ps <= nthreads / np; ++ps) {
+        if (nthreads - np * ps < idle) {
+          idle           = nthreads - np * ps;
           num_partitions = np;
           partition_size = ps;
         }
@@ -89,34 +85,28 @@ void OpenMPExec::validate_partition( const int nthreads
         }
       }
     }
-  }
-  else if( num_partitions < 1 && partition_size > 0 ) {
-    if ( partition_size <= nthreads ) {
+  } else if (num_partitions < 1 && partition_size > 0) {
+    if (partition_size <= nthreads) {
       num_partitions = nthreads / partition_size;
-    }
-    else {
+    } else {
       num_partitions = 1;
       partition_size = nthreads;
     }
-  }
-  else if( num_partitions > 0 && partition_size < 1 ) {
-    if ( num_partitions <= nthreads ) {
+  } else if (num_partitions > 0 && partition_size < 1) {
+    if (num_partitions <= nthreads) {
       partition_size = nthreads / num_partitions;
-    }
-    else {
+    } else {
       num_partitions = nthreads;
       partition_size = 1;
     }
-  }
-  else if ( num_partitions * partition_size > nthreads ) {
-    int idle = nthreads;
+  } else if (num_partitions * partition_size > nthreads) {
+    int idle     = nthreads;
     const int NP = num_partitions;
     const int PS = partition_size;
     for (int np = NP; np > 0; --np) {
       for (int ps = PS; ps > 0; --ps) {
-        if (  (np*ps <= nthreads)
-           && (nthreads - np*ps < idle) ) {
-          idle = nthreads - np*ps;
+        if ((np * ps <= nthreads) && (nthreads - np * ps < idle)) {
+          idle           = nthreads - np * ps;
           num_partitions = np;
           partition_size = ps;
         }
@@ -126,22 +116,18 @@ void OpenMPExec::validate_partition( const int nthreads
       }
     }
   }
-
 }
 
-void OpenMPExec::verify_is_master( const char * const label )
-{
-  if ( !t_openmp_instance )
-  {
-    std::string msg( label );
-    msg.append( " ERROR: in parallel or not initialized" );
-    Kokkos::Impl::throw_runtime_exception( msg );
+void OpenMPExec::verify_is_master(const char *const label) {
+  if (!t_openmp_instance) {
+    std::string msg(label);
+    msg.append(" ERROR: in parallel or not initialized");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
 }
 
-
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -149,109 +135,113 @@ void OpenMPExec::verify_is_master( const char * const label )
 namespace Kokkos {
 namespace Impl {
 
-void OpenMPExec::clear_thread_data()
-{
+void OpenMPExec::clear_thread_data() {
   const size_t member_bytes =
-    sizeof(int64_t) *
-    HostThreadTeamData::align_to_int64( sizeof(HostThreadTeamData) );
+      sizeof(int64_t) *
+      HostThreadTeamData::align_to_int64(sizeof(HostThreadTeamData));
 
   const int old_alloc_bytes =
-    m_pool[0] ? ( member_bytes + m_pool[0]->scratch_bytes() ) : 0 ;
+      m_pool[0] ? (member_bytes + m_pool[0]->scratch_bytes()) : 0;
 
-  OpenMP::memory_space space ;
+  OpenMP::memory_space space;
 
-  #pragma omp parallel num_threads( m_pool_size )
+#pragma omp parallel num_threads(m_pool_size)
   {
     const int rank = omp_get_thread_num();
 
-    if ( 0 != m_pool[rank] ) {
-
+    if (0 != m_pool[rank]) {
       m_pool[rank]->disband_pool();
 
-      space.deallocate( m_pool[rank] , old_alloc_bytes );
+      space.deallocate(m_pool[rank], old_alloc_bytes);
 
-      m_pool[rank] = 0 ;
+      m_pool[rank] = 0;
     }
   }
-/* END #pragma omp parallel */
+  /* END #pragma omp parallel */
 }
 
-void OpenMPExec::resize_thread_data( size_t pool_reduce_bytes
-                                   , size_t team_reduce_bytes
-                                   , size_t team_shared_bytes
-                                   , size_t thread_local_bytes )
-{
+void OpenMPExec::resize_thread_data(size_t pool_reduce_bytes,
+                                    size_t team_reduce_bytes,
+                                    size_t team_shared_bytes,
+                                    size_t thread_local_bytes) {
   const size_t member_bytes =
-    sizeof(int64_t) *
-    HostThreadTeamData::align_to_int64( sizeof(HostThreadTeamData) );
+      sizeof(int64_t) *
+      HostThreadTeamData::align_to_int64(sizeof(HostThreadTeamData));
 
-  HostThreadTeamData * root = m_pool[0] ;
+  HostThreadTeamData *root = m_pool[0];
 
-  const size_t old_pool_reduce  = root ? root->pool_reduce_bytes() : 0 ;
-  const size_t old_team_reduce  = root ? root->team_reduce_bytes() : 0 ;
-  const size_t old_team_shared  = root ? root->team_shared_bytes() : 0 ;
-  const size_t old_thread_local = root ? root->thread_local_bytes() : 0 ;
-  const size_t old_alloc_bytes  = root ? ( member_bytes + root->scratch_bytes() ) : 0 ;
+  const size_t old_pool_reduce  = root ? root->pool_reduce_bytes() : 0;
+  const size_t old_team_reduce  = root ? root->team_reduce_bytes() : 0;
+  const size_t old_team_shared  = root ? root->team_shared_bytes() : 0;
+  const size_t old_thread_local = root ? root->thread_local_bytes() : 0;
+  const size_t old_alloc_bytes =
+      root ? (member_bytes + root->scratch_bytes()) : 0;
 
   // Allocate if any of the old allocation is tool small:
 
-  const bool allocate = ( old_pool_reduce  < pool_reduce_bytes ) ||
-                        ( old_team_reduce  < team_reduce_bytes ) ||
-                        ( old_team_shared  < team_shared_bytes ) ||
-                        ( old_thread_local < thread_local_bytes );
-
-  if ( allocate ) {
+  const bool allocate = (old_pool_reduce < pool_reduce_bytes) ||
+                        (old_team_reduce < team_reduce_bytes) ||
+                        (old_team_shared < team_shared_bytes) ||
+                        (old_thread_local < thread_local_bytes);
 
-    if ( pool_reduce_bytes < old_pool_reduce ) { pool_reduce_bytes = old_pool_reduce ; }
-    if ( team_reduce_bytes < old_team_reduce ) { team_reduce_bytes = old_team_reduce ; }
-    if ( team_shared_bytes < old_team_shared ) { team_shared_bytes = old_team_shared ; }
-    if ( thread_local_bytes < old_thread_local ) { thread_local_bytes = old_thread_local ; }
+  if (allocate) {
+    if (pool_reduce_bytes < old_pool_reduce) {
+      pool_reduce_bytes = old_pool_reduce;
+    }
+    if (team_reduce_bytes < old_team_reduce) {
+      team_reduce_bytes = old_team_reduce;
+    }
+    if (team_shared_bytes < old_team_shared) {
+      team_shared_bytes = old_team_shared;
+    }
+    if (thread_local_bytes < old_thread_local) {
+      thread_local_bytes = old_thread_local;
+    }
 
     const size_t alloc_bytes =
-      member_bytes +
-      HostThreadTeamData::scratch_size( pool_reduce_bytes
-                                      , team_reduce_bytes
-                                      , team_shared_bytes
-                                      , thread_local_bytes );
+        member_bytes +
+        HostThreadTeamData::scratch_size(pool_reduce_bytes, team_reduce_bytes,
+                                         team_shared_bytes, thread_local_bytes);
 
-    OpenMP::memory_space space ;
+    OpenMP::memory_space space;
 
     memory_fence();
 
-    #pragma omp parallel num_threads(m_pool_size)
+#pragma omp parallel num_threads(m_pool_size)
     {
       const int rank = omp_get_thread_num();
 
-      if ( 0 != m_pool[rank] ) {
-
+      if (0 != m_pool[rank]) {
         m_pool[rank]->disband_pool();
 
-        space.deallocate( m_pool[rank] , old_alloc_bytes );
+        space.deallocate(m_pool[rank], old_alloc_bytes);
       }
 
-      void * const ptr = space.allocate( alloc_bytes );
+      void *ptr = nullptr;
+      try {
+        ptr = space.allocate(alloc_bytes);
+      } catch (
+          Kokkos::Experimental::RawMemoryAllocationFailure const &failure) {
+        // For now, just rethrow the error message the existing way
+        Kokkos::Impl::throw_runtime_exception(failure.get_error_message());
+      }
 
-      m_pool[ rank ] = new( ptr ) HostThreadTeamData();
+      m_pool[rank] = new (ptr) HostThreadTeamData();
 
-      m_pool[ rank ]->
-        scratch_assign( ((char *)ptr) + member_bytes
-                      , alloc_bytes
-                      , pool_reduce_bytes
-                      , team_reduce_bytes
-                      , team_shared_bytes
-                      , thread_local_bytes
-                      );
+      m_pool[rank]->scratch_assign(((char *)ptr) + member_bytes, alloc_bytes,
+                                   pool_reduce_bytes, team_reduce_bytes,
+                                   team_shared_bytes, thread_local_bytes);
 
       memory_fence();
     }
-/* END #pragma omp parallel */
+    /* END #pragma omp parallel */
 
-    HostThreadTeamData::organize_pool( m_pool , m_pool_size );
+    HostThreadTeamData::organize_pool(m_pool, m_pool_size);
   }
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -269,46 +259,49 @@ int OpenMP::impl_get_current_max_threads() noexcept
   // Using omp_get_max_threads(); is problematic in conjunction with
   // Hwloc on Intel (essentially an initial call to the OpenMP runtime
   // without a parallel region before will set a process mask for a single core
-  // The runtime will than bind threads for a parallel region to other cores on the
-  // entering the first parallel region and make the process mask the aggregate of
-  // the thread masks. The intend seems to be to make serial code run fast, if you
-  // compile with OpenMP enabled but don't actually use parallel regions or so
-  // static int omp_max_threads = omp_get_max_threads();
+  // The runtime will than bind threads for a parallel region to other cores on
+  // the entering the first parallel region and make the process mask the
+  // aggregate of the thread masks. The intend seems to be to make serial code
+  // run fast, if you compile with OpenMP enabled but don't actually use
+  // parallel regions or so static int omp_max_threads = omp_get_max_threads();
 
   int count = 0;
-  #pragma omp parallel
+#pragma omp parallel
   {
-    #pragma omp atomic
-     ++count;
+#pragma omp atomic
+    ++count;
   }
   return count;
 }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-void OpenMP::initialize( int thread_count )
+void OpenMP::initialize(int thread_count)
 #else
-void OpenMP::impl_initialize( int thread_count )
+void OpenMP::impl_initialize(int thread_count)
 #endif
 {
-  if ( omp_in_parallel() ) {
+  if (omp_in_parallel()) {
     std::string msg("Kokkos::OpenMP::initialize ERROR : in parallel");
     Kokkos::Impl::throw_runtime_exception(msg);
   }
 
-  if ( Impl::t_openmp_instance )
-  {
+  if (Impl::t_openmp_instance) {
     finalize();
   }
 
   {
-    if ( Kokkos::show_warnings() && nullptr == std::getenv("OMP_PROC_BIND") ) {
-      printf("Kokkos::OpenMP::initialize WARNING: OMP_PROC_BIND environment variable not set\n");
-      printf("  In general, for best performance with OpenMP 4.0 or better set OMP_PROC_BIND=spread and OMP_PLACES=threads\n");
+    if (Kokkos::show_warnings() && nullptr == std::getenv("OMP_PROC_BIND")) {
+      printf(
+          "Kokkos::OpenMP::initialize WARNING: OMP_PROC_BIND environment "
+          "variable not set\n");
+      printf(
+          "  In general, for best performance with OpenMP 4.0 or better set "
+          "OMP_PROC_BIND=spread and OMP_PLACES=threads\n");
       printf("  For best performance with OpenMP 3.1 set OMP_PROC_BIND=true\n");
       printf("  For unit testing set OMP_PROC_BIND=false\n");
     }
 
-    OpenMP::memory_space space ;
+    OpenMP::memory_space space;
 
     // Before any other call to OMP query the maximum number of threads
     // and save the value for re-initialization unit testing.
@@ -321,72 +314,87 @@ void OpenMP::impl_initialize( int thread_count )
 
     int process_num_threads = Impl::g_openmp_hardware_max_threads;
 
-    if ( Kokkos::hwloc::available() ) {
-      process_num_threads = Kokkos::hwloc::get_available_numa_count()
-                          * Kokkos::hwloc::get_available_cores_per_numa()
-                          * Kokkos::hwloc::get_available_threads_per_core();
+    if (Kokkos::hwloc::available()) {
+      process_num_threads = Kokkos::hwloc::get_available_numa_count() *
+                            Kokkos::hwloc::get_available_cores_per_numa() *
+                            Kokkos::hwloc::get_available_threads_per_core();
     }
 
     // if thread_count  < 0, use g_openmp_hardware_max_threads;
-    // if thread_count == 0, set g_openmp_hardware_max_threads to process_num_threads
-    // if thread_count  > 0, set g_openmp_hardware_max_threads to thread_count
-    if (thread_count < 0 ) {
+    // if thread_count == 0, set g_openmp_hardware_max_threads to
+    // process_num_threads if thread_count  > 0, set
+    // g_openmp_hardware_max_threads to thread_count
+    if (thread_count < 0) {
       thread_count = Impl::g_openmp_hardware_max_threads;
-    }
-    else if( thread_count == 0 && Impl::g_openmp_hardware_max_threads != process_num_threads ) {
+    } else if (thread_count == 0 &&
+               Impl::g_openmp_hardware_max_threads != process_num_threads) {
       Impl::g_openmp_hardware_max_threads = process_num_threads;
       omp_set_num_threads(Impl::g_openmp_hardware_max_threads);
-    }
-    else {
-      if( Kokkos::show_warnings() && thread_count > process_num_threads ) {
-        printf( "Kokkos::OpenMP::initialize WARNING: You are likely oversubscribing your CPU cores.\n");
-        printf( "  process threads available : %3d,  requested thread : %3d\n", process_num_threads, thread_count );
+    } else {
+      if (Kokkos::show_warnings() && thread_count > process_num_threads) {
+        printf(
+            "Kokkos::OpenMP::initialize WARNING: You are likely "
+            "oversubscribing your CPU cores.\n");
+        printf("  process threads available : %3d,  requested thread : %3d\n",
+               process_num_threads, thread_count);
       }
       Impl::g_openmp_hardware_max_threads = thread_count;
       omp_set_num_threads(Impl::g_openmp_hardware_max_threads);
     }
 
-    // setup thread local
-    #pragma omp parallel num_threads(Impl::g_openmp_hardware_max_threads)
+// setup thread local
+#pragma omp parallel num_threads(Impl::g_openmp_hardware_max_threads)
     {
-      Impl::t_openmp_instance = nullptr;
+      Impl::t_openmp_instance    = nullptr;
       Impl::t_openmp_hardware_id = omp_get_thread_num();
-      Impl::SharedAllocationRecord< void, void >::tracking_enable();
+      Impl::SharedAllocationRecord<void, void>::tracking_enable();
     }
 
-    void * const ptr = space.allocate( sizeof(Impl::OpenMPExec) );
+    void *ptr = nullptr;
+    try {
+      ptr = space.allocate(sizeof(Impl::OpenMPExec));
+    } catch (Kokkos::Experimental::RawMemoryAllocationFailure const &f) {
+      // For now, just rethrow the error message the existing way
+      Kokkos::Impl::throw_runtime_exception(f.get_error_message());
+    }
 
-    Impl::t_openmp_instance = new (ptr) Impl::OpenMPExec( Impl::g_openmp_hardware_max_threads );
+    Impl::t_openmp_instance =
+        new (ptr) Impl::OpenMPExec(Impl::g_openmp_hardware_max_threads);
 
     // New, unified host thread team data:
     {
-      size_t pool_reduce_bytes  =   32 * thread_count ;
-      size_t team_reduce_bytes  =   32 * thread_count ;
-      size_t team_shared_bytes  = 1024 * thread_count ;
-      size_t thread_local_bytes = 1024 ;
-
-      Impl::t_openmp_instance->resize_thread_data( pool_reduce_bytes
-                                                 , team_reduce_bytes
-                                                 , team_shared_bytes
-                                                 , thread_local_bytes
-                                                 );
+      size_t pool_reduce_bytes  = 32 * thread_count;
+      size_t team_reduce_bytes  = 32 * thread_count;
+      size_t team_shared_bytes  = 1024 * thread_count;
+      size_t thread_local_bytes = 1024;
+
+      Impl::t_openmp_instance->resize_thread_data(
+          pool_reduce_bytes, team_reduce_bytes, team_shared_bytes,
+          thread_local_bytes);
     }
   }
 
-
   // Check for over-subscription
-  if( Kokkos::show_warnings() && (Impl::mpi_ranks_per_node() * long(thread_count) > Impl::processors_per_node()) ) {
-    std::cerr << "Kokkos::OpenMP::initialize WARNING: You are likely oversubscribing your CPU cores." << std::endl;
-    std::cerr << "                                    Detected: " << Impl::processors_per_node() << " cores per node." << std::endl;
-    std::cerr << "                                    Detected: " << Impl::mpi_ranks_per_node() << " MPI_ranks per node." << std::endl;
-    std::cerr << "                                    Requested: " << thread_count << " threads per process." << std::endl;
+  if (Kokkos::show_warnings() &&
+      (Impl::mpi_ranks_per_node() * long(thread_count) >
+       Impl::processors_per_node())) {
+    std::cerr << "Kokkos::OpenMP::initialize WARNING: You are likely "
+                 "oversubscribing your CPU cores."
+              << std::endl;
+    std::cerr << "                                    Detected: "
+              << Impl::processors_per_node() << " cores per node." << std::endl;
+    std::cerr << "                                    Detected: "
+              << Impl::mpi_ranks_per_node() << " MPI_ranks per node."
+              << std::endl;
+    std::cerr << "                                    Requested: "
+              << thread_count << " threads per process." << std::endl;
   }
   // Init the array for used for arbitrarily sized atomics
   Impl::init_lock_array_host_space();
 
-  #if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && defined(KOKKOS_ENABLE_PROFILING)
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && defined(KOKKOS_ENABLE_PROFILING)
   Kokkos::Profiling::initialize();
-  #endif
+#endif
 }
 
 //----------------------------------------------------------------------------
@@ -397,80 +405,72 @@ void OpenMP::finalize()
 void OpenMP::impl_finalize()
 #endif
 {
-  if ( omp_in_parallel() )
-  {
+  if (omp_in_parallel()) {
     std::string msg("Kokkos::OpenMP::finalize ERROR ");
-    if( !Impl::t_openmp_instance ) msg.append(": not initialized");
-    if( omp_in_parallel() ) msg.append(": in parallel");
+    if (!Impl::t_openmp_instance) msg.append(": not initialized");
+    if (omp_in_parallel()) msg.append(": in parallel");
     Kokkos::Impl::throw_runtime_exception(msg);
   }
 
-  if ( Impl::t_openmp_instance ) {
+  if (Impl::t_openmp_instance) {
     // Silence Cuda Warning
-    const int nthreads = Impl::t_openmp_instance->m_pool_size <= Impl::g_openmp_hardware_max_threads
-                       ? Impl::g_openmp_hardware_max_threads
-                       : Impl::t_openmp_instance->m_pool_size;
-    (void) nthreads;
-
-    using Exec = Impl::OpenMPExec;
-    Exec * instance = Impl::t_openmp_instance;
+    const int nthreads = Impl::t_openmp_instance->m_pool_size <=
+                                 Impl::g_openmp_hardware_max_threads
+                             ? Impl::g_openmp_hardware_max_threads
+                             : Impl::t_openmp_instance->m_pool_size;
+    (void)nthreads;
+
+    using Exec     = Impl::OpenMPExec;
+    Exec *instance = Impl::t_openmp_instance;
     instance->~Exec();
 
     OpenMP::memory_space space;
-    space.deallocate( instance, sizeof(Exec) );
+    space.deallocate(instance, sizeof(Exec));
 
-    #pragma omp parallel num_threads(nthreads)
+#pragma omp parallel num_threads(nthreads)
     {
       Impl::t_openmp_hardware_id = 0;
       Impl::t_openmp_instance    = nullptr;
-      Impl::SharedAllocationRecord< void, void >::tracking_disable();
+      Impl::SharedAllocationRecord<void, void>::tracking_disable();
     }
 
     // allow main thread to track
-    Impl::SharedAllocationRecord< void, void >::tracking_enable();
+    Impl::SharedAllocationRecord<void, void>::tracking_enable();
 
     Impl::g_openmp_hardware_max_threads = 1;
   }
 
-  #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::finalize();
-  #endif
+#if defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::finalize();
+#endif
 }
 
 //----------------------------------------------------------------------------
 
-void OpenMP::print_configuration( std::ostream & s , const bool verbose )
-{
-  s << "Kokkos::OpenMP" ;
+void OpenMP::print_configuration(std::ostream &s, const bool verbose) {
+  s << "Kokkos::OpenMP";
 
-  const bool is_initialized =  Impl::t_openmp_instance != nullptr;
+  const bool is_initialized = Impl::t_openmp_instance != nullptr;
 
-  if ( is_initialized ) {
-    Impl::OpenMPExec::verify_is_master( "OpenMP::print_configuration" );
+  if (is_initialized) {
+    Impl::OpenMPExec::verify_is_master("OpenMP::print_configuration");
 
     const int numa_count      = 1;
     const int core_per_numa   = Impl::g_openmp_hardware_max_threads;
     const int thread_per_core = 1;
 
-    s << " thread_pool_topology[ " << numa_count
-      << " x " << core_per_numa
-      << " x " << thread_per_core
-      << " ]"
-      << std::endl ;
-  }
-  else {
-    s << " not initialized" << std::endl ;
+    s << " thread_pool_topology[ " << numa_count << " x " << core_per_numa
+      << " x " << thread_per_core << " ]" << std::endl;
+  } else {
+    s << " not initialized" << std::endl;
   }
 }
 
-std::vector<OpenMP> OpenMP::partition(...)
-{ return std::vector<OpenMP>(1); }
+std::vector<OpenMP> OpenMP::partition(...) { return std::vector<OpenMP>(1); }
 
 OpenMP OpenMP::create_instance(...) { return OpenMP(); }
 
-int OpenMP::concurrency() {
-  return Impl::g_openmp_hardware_max_threads;
-}
+int OpenMP::concurrency() { return Impl::g_openmp_hardware_max_threads; }
 
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
 void OpenMP::fence() const {}
@@ -478,16 +478,14 @@ void OpenMP::fence() const {}
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
 
-void OpenMP::initialize( int thread_count , int, int )
-{
+void OpenMP::initialize(int thread_count, int, int) {
   initialize(thread_count);
 }
 
 #endif
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #else
 void KOKKOS_CORE_SRC_OPENMP_EXEC_PREVENT_LINK_ERROR() {}
-#endif //KOKKOS_ENABLE_OPENMP
-
+#endif  // KOKKOS_ENABLE_OPENMP
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.hpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.hpp
index 5178199ac2f7f4aa59c18fe06c79c814bd581c61..6a8773a58f53fd61c4f9c4a0ceef64742369b450 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.hpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Exec.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,10 +46,11 @@
 #define KOKKOS_OPENMPEXEC_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP )
+#if defined(KOKKOS_ENABLE_OPENMP)
 
 #if !defined(_OPENMP) && !defined(__CUDA_ARCH__)
-#error "You enabled Kokkos OpenMP support without enabling OpenMP in the compiler!"
+#error \
+    "You enabled Kokkos OpenMP support without enabling OpenMP in the compiler!"
 #endif
 
 #include <Kokkos_OpenMP.hpp>
@@ -69,105 +71,95 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 class OpenMPExec;
 
 extern int g_openmp_hardware_max_threads;
 
 extern __thread int t_openmp_hardware_id;
-extern __thread OpenMPExec * t_openmp_instance;
+extern __thread OpenMPExec* t_openmp_instance;
 
 //----------------------------------------------------------------------------
 /** \brief  Data for OpenMP thread execution */
 
 class OpenMPExec {
-public:
-
-  friend class Kokkos::OpenMP ;
+ public:
+  friend class Kokkos::OpenMP;
 
   enum { MAX_THREAD_COUNT = 512 };
 
   void clear_thread_data();
 
-  static void validate_partition( const int nthreads
-                                , int & num_partitions
-                                , int & partition_size
-                                );
-
-private:
-  OpenMPExec( int arg_pool_size )
-    : m_pool_size{ arg_pool_size }
-    , m_level{ omp_get_level() }
-    , m_pool()
-  {}
-
-  ~OpenMPExec()
-  {
-    clear_thread_data();
-  }
+  static void validate_partition(const int nthreads, int& num_partitions,
+                                 int& partition_size);
+
+ private:
+  OpenMPExec(int arg_pool_size)
+      : m_pool_size{arg_pool_size}, m_level{omp_get_level()}, m_pool() {}
+
+  ~OpenMPExec() { clear_thread_data(); }
 
   int m_pool_size;
   int m_level;
 
-  HostThreadTeamData * m_pool[ MAX_THREAD_COUNT ];
-
-public:
+  HostThreadTeamData* m_pool[MAX_THREAD_COUNT];
 
-  static void verify_is_master( const char * const );
+ public:
+  static void verify_is_master(const char* const);
 
-  void resize_thread_data( size_t pool_reduce_bytes
-                         , size_t team_reduce_bytes
-                         , size_t team_shared_bytes
-                         , size_t thread_local_bytes );
+  void resize_thread_data(size_t pool_reduce_bytes, size_t team_reduce_bytes,
+                          size_t team_shared_bytes, size_t thread_local_bytes);
 
-  inline
-  HostThreadTeamData * get_thread_data() const noexcept
-  { return m_pool[ m_level == omp_get_level() ? 0 : omp_get_thread_num() ]; }
+  inline HostThreadTeamData* get_thread_data() const noexcept {
+    return m_pool[m_level == omp_get_level() ? 0 : omp_get_thread_num()];
+  }
 
-  inline
-  HostThreadTeamData * get_thread_data( int i ) const noexcept
-  { return m_pool[i]; }
+  inline HostThreadTeamData* get_thread_data(int i) const noexcept {
+    return m_pool[i];
+  }
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-inline OpenMP::OpenMP() noexcept
-{}
+inline OpenMP::OpenMP() noexcept {}
 
 inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-bool OpenMP::is_initialized() noexcept
+    bool
+    OpenMP::is_initialized() noexcept
 #else
-bool OpenMP::impl_is_initialized() noexcept
+    bool
+    OpenMP::impl_is_initialized() noexcept
 #endif
-{ return Impl::t_openmp_instance != nullptr; }
-
-inline
-bool OpenMP::in_parallel( OpenMP const& ) noexcept
 {
-  //t_openmp_instance is only non-null on a master thread
-  return   !Impl::t_openmp_instance
-         || Impl::t_openmp_instance->m_level < omp_get_level()
-         ;
+  return Impl::t_openmp_instance != nullptr;
+}
+
+inline bool OpenMP::in_parallel(OpenMP const&) noexcept {
+  // t_openmp_instance is only non-null on a master thread
+  return !Impl::t_openmp_instance ||
+         Impl::t_openmp_instance->m_level < omp_get_level();
 }
 
 inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-int OpenMP::thread_pool_size() noexcept
+    int
+    OpenMP::thread_pool_size() noexcept
 #else
-int OpenMP::impl_thread_pool_size() noexcept
+    int
+    OpenMP::impl_thread_pool_size() noexcept
 #endif
 {
-  return   OpenMP::in_parallel()
-         ? omp_get_num_threads()
-         : Impl::t_openmp_instance->m_pool_size
-         ;
+  return OpenMP::in_parallel() ? omp_get_num_threads()
+                               : Impl::t_openmp_instance->m_pool_size;
 }
 
 KOKKOS_INLINE_FUNCTION
@@ -177,199 +169,192 @@ int OpenMP::thread_pool_rank() noexcept
 int OpenMP::impl_thread_pool_rank() noexcept
 #endif
 {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
   return Impl::t_openmp_instance ? 0 : omp_get_thread_num();
 #else
-  return -1 ;
+  return -1;
 #endif
 }
 
-inline
-void OpenMP::impl_static_fence( OpenMP const& instance ) noexcept {}
+inline void OpenMP::impl_static_fence(OpenMP const& instance) noexcept {}
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-inline
-void OpenMP::fence( OpenMP const& instance ) noexcept {}
+inline void OpenMP::fence(OpenMP const& instance) noexcept {}
 #endif
 
-inline
-bool OpenMP::is_asynchronous( OpenMP const& instance ) noexcept
-{ return false; }
+inline bool OpenMP::is_asynchronous(OpenMP const& instance) noexcept {
+  return false;
+}
 
 template <typename F>
-void OpenMP::partition_master( F const& f
-                             , int num_partitions
-                             , int partition_size
-                             )
-{
+void OpenMP::partition_master(F const& f, int num_partitions,
+                              int partition_size) {
   if (omp_get_nested()) {
     using Exec = Impl::OpenMPExec;
 
-    Exec * prev_instance = Impl::t_openmp_instance;
+    Exec* prev_instance = Impl::t_openmp_instance;
 
-    Exec::validate_partition( prev_instance->m_pool_size, num_partitions, partition_size );
+    Exec::validate_partition(prev_instance->m_pool_size, num_partitions,
+                             partition_size);
 
     OpenMP::memory_space space;
 
-    #pragma omp parallel num_threads(num_partitions)
+#pragma omp parallel num_threads(num_partitions)
     {
-      void * const ptr = space.allocate( sizeof(Exec) );
-
-      Impl::t_openmp_instance = new (ptr) Exec( partition_size );
-
-      size_t pool_reduce_bytes  =   32 * partition_size ;
-      size_t team_reduce_bytes  =   32 * partition_size ;
-      size_t team_shared_bytes  = 1024 * partition_size ;
-      size_t thread_local_bytes = 1024 ;
-
-      Impl::t_openmp_instance->resize_thread_data( pool_reduce_bytes
-                                                 , team_reduce_bytes
-                                                 , team_shared_bytes
-                                                 , thread_local_bytes
-                                                 );
+      void* ptr = nullptr;
+      try {
+        ptr = space.allocate(sizeof(Exec));
+      } catch (
+          Kokkos::Experimental::RawMemoryAllocationFailure const& failure) {
+        // For now, just rethrow the error message the existing way
+        Kokkos::Impl::throw_runtime_exception(failure.get_error_message());
+      }
+
+      Impl::t_openmp_instance = new (ptr) Exec(partition_size);
+
+      size_t pool_reduce_bytes  = 32 * partition_size;
+      size_t team_reduce_bytes  = 32 * partition_size;
+      size_t team_shared_bytes  = 1024 * partition_size;
+      size_t thread_local_bytes = 1024;
+
+      Impl::t_openmp_instance->resize_thread_data(
+          pool_reduce_bytes, team_reduce_bytes, team_shared_bytes,
+          thread_local_bytes);
 
       omp_set_num_threads(partition_size);
-      f( omp_get_thread_num(), omp_get_num_threads() );
+      f(omp_get_thread_num(), omp_get_num_threads());
 
       Impl::t_openmp_instance->~Exec();
-      space.deallocate( Impl::t_openmp_instance, sizeof(Exec) );
+      space.deallocate(Impl::t_openmp_instance, sizeof(Exec));
       Impl::t_openmp_instance = nullptr;
     }
 
-    Impl::t_openmp_instance  = prev_instance;
-  }
-  else {
+    Impl::t_openmp_instance = prev_instance;
+  } else {
     // nested openmp not enabled
-    f(0,1);
+    f(0, 1);
   }
 }
 
-
 namespace Experimental {
 
-template<>
-class MasterLock<OpenMP>
-{
-public:
-  void lock()     { omp_set_lock( &m_lock );   }
-  void unlock()   { omp_unset_lock( &m_lock ); }
-  bool try_lock() { return static_cast<bool>(omp_test_lock( &m_lock )); }
+template <>
+class MasterLock<OpenMP> {
+ public:
+  void lock() { omp_set_lock(&m_lock); }
+  void unlock() { omp_unset_lock(&m_lock); }
+  bool try_lock() { return static_cast<bool>(omp_test_lock(&m_lock)); }
 
-  MasterLock()  { omp_init_lock( &m_lock ); }
-  ~MasterLock() { omp_destroy_lock( &m_lock ); }
+  MasterLock() { omp_init_lock(&m_lock); }
+  ~MasterLock() { omp_destroy_lock(&m_lock); }
 
-  MasterLock( MasterLock const& ) = delete;
-  MasterLock( MasterLock && )     = delete;
-  MasterLock & operator=( MasterLock const& ) = delete;
-  MasterLock & operator=( MasterLock && )     = delete;
+  MasterLock(MasterLock const&) = delete;
+  MasterLock(MasterLock&&)      = delete;
+  MasterLock& operator=(MasterLock const&) = delete;
+  MasterLock& operator=(MasterLock&&) = delete;
 
-private:
+ private:
   omp_lock_t m_lock;
-
 };
 
-template<>
-class UniqueToken< OpenMP, UniqueTokenScope::Instance>
-{
-public:
+template <>
+class UniqueToken<OpenMP, UniqueTokenScope::Instance> {
+ public:
   using execution_space = OpenMP;
   using size_type       = int;
 
   /// \brief create object size for concurrency on the given instance
   ///
   /// This object should not be shared between instances
-  UniqueToken( execution_space const& = execution_space() ) noexcept {}
+  UniqueToken(execution_space const& = execution_space()) noexcept {}
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  int size() const noexcept
-    {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-#if defined( KOKKOS_ENABLE_DEPRECATED_CODE )
-      return Kokkos::OpenMP::thread_pool_size();
+  int size() const noexcept {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE)
+    return Kokkos::OpenMP::thread_pool_size();
 #else
-      return Kokkos::OpenMP::impl_thread_pool_size();
+    return Kokkos::OpenMP::impl_thread_pool_size();
 #endif
 #else
-      return 0 ;
+    return 0;
 #endif
-    }
+  }
 
   /// \brief acquire value such that 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  int acquire() const  noexcept
-    {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-#if defined( KOKKOS_ENABLE_DEPRECATED_CODE )
-      return Kokkos::OpenMP::thread_pool_rank();
+  int acquire() const noexcept {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE)
+    return Kokkos::OpenMP::thread_pool_rank();
 #else
-      return Kokkos::OpenMP::impl_thread_pool_rank();
+    return Kokkos::OpenMP::impl_thread_pool_rank();
 #endif
 #else
-      return 0 ;
+    return 0;
 #endif
-    }
+  }
 
   /// \brief release a value acquired by generate
   KOKKOS_INLINE_FUNCTION
-  void release( int ) const noexcept {}
+  void release(int) const noexcept {}
 };
 
-template<>
-class UniqueToken< OpenMP, UniqueTokenScope::Global>
-{
-public:
+template <>
+class UniqueToken<OpenMP, UniqueTokenScope::Global> {
+ public:
   using execution_space = OpenMP;
   using size_type       = int;
 
   /// \brief create object size for concurrency on the given instance
   ///
   /// This object should not be shared between instances
-  UniqueToken( execution_space const& = execution_space() ) noexcept {}
+  UniqueToken(execution_space const& = execution_space()) noexcept {}
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  int size() const noexcept
-    {
-      #if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      return Kokkos::Impl::g_openmp_hardware_max_threads ;
-      #else
-      return 0 ;
-      #endif
-    }
+  int size() const noexcept {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    return Kokkos::Impl::g_openmp_hardware_max_threads;
+#else
+    return 0;
+#endif
+  }
 
   /// \brief acquire value such that 0 <= value < size()
   KOKKOS_INLINE_FUNCTION
-  int acquire() const noexcept
-    {
-      #if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      return Kokkos::Impl::t_openmp_hardware_id ;
-      #else
-      return 0 ;
-      #endif
-    }
+  int acquire() const noexcept {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    return Kokkos::Impl::t_openmp_hardware_id;
+#else
+    return 0;
+#endif
+  }
 
   /// \brief release a value acquired by generate
   KOKKOS_INLINE_FUNCTION
-  void release( int ) const noexcept {}
+  void release(int) const noexcept {}
 };
 
-} // namespace Experimental
+}  // namespace Experimental
 
 inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-int OpenMP::thread_pool_size( int depth )
+    int
+    OpenMP::thread_pool_size(int depth)
 #else
-int OpenMP::impl_thread_pool_size( int depth )
+    int
+    OpenMP::impl_thread_pool_size(int depth)
 #endif
 {
   return depth < 2
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-         ? thread_pool_size()
+             ? thread_pool_size()
 #else
-         ? impl_thread_pool_size()
+             ? impl_thread_pool_size()
 #endif
-         : 1;
+             : 1;
 }
 
 KOKKOS_INLINE_FUNCTION
@@ -379,25 +364,26 @@ int OpenMP::hardware_thread_id() noexcept
 int OpenMP::impl_hardware_thread_id() noexcept
 #endif
 {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
   return Impl::t_openmp_hardware_id;
 #else
-  return -1 ;
+  return -1;
 #endif
 }
 
 inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-int OpenMP::max_hardware_threads() noexcept
+    int
+    OpenMP::max_hardware_threads() noexcept
 #else
-int OpenMP::impl_max_hardware_threads() noexcept
+    int
+    OpenMP::impl_max_hardware_threads() noexcept
 #endif
 {
   return Impl::g_openmp_hardware_max_threads;
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif
 #endif /* #ifndef KOKKOS_OPENMPEXEC_HPP */
-
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp
index 52f8e983d2979758759b80c9496db7a9f63ce970..5442119e73678544d74a8ac8d7200bdba0078980 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_OPENMP_PARALLEL_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP )
+#if defined(KOKKOS_ENABLE_OPENMP)
 
 #include <omp.h>
 #include <iostream>
@@ -60,218 +61,187 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::RangePolicy< Traits ... >
-                 , Kokkos::OpenMP
-                 >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::OpenMP> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::RangePolicy< Traits ...  > Policy ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-        OpenMPExec   * m_instance ;
-  const FunctorType    m_functor ;
-  const Policy         m_policy ;
-
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend )
-    {
-      #ifdef KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
-      #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-      #pragma ivdep
-      #endif
-      #endif
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( iwork );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend) {
+#ifdef KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#endif
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(iwork);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend )
-    {
-      const TagType t{} ;
-      #ifdef KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
-      #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-      #pragma ivdep
-      #endif
-      #endif
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( t , iwork );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend) {
+    const TagType t{};
+#ifdef KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#endif
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(t, iwork);
     }
+  }
 
-public:
-
-  inline void execute() const
-  {
-    enum { is_dynamic = std::is_same< typename Policy::schedule_type::type
-         , Kokkos::Dynamic >::value
-         };
-
-    if ( OpenMP::in_parallel() ) {
-      exec_range< WorkTag >( m_functor
-                           , m_policy.begin()
-                           , m_policy.end() );
-    }
-    else {
+ public:
+  inline void execute() const {
+    enum {
+      is_dynamic = std::is_same<typename Policy::schedule_type::type,
+                                Kokkos::Dynamic>::value
+    };
 
+    if (OpenMP::in_parallel()) {
+      exec_range<WorkTag>(m_functor, m_policy.begin(), m_policy.end());
+    } else {
       OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_for");
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      #pragma omp parallel num_threads(OpenMP::thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::thread_pool_size())
 #else
-      #pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
 #endif
       {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
+        HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        data.set_work_partition( m_policy.end() - m_policy.begin()
-            , m_policy.chunk_size() );
+        data.set_work_partition(m_policy.end() - m_policy.begin(),
+                                m_policy.chunk_size());
 
-        if ( is_dynamic ) {
+        if (is_dynamic) {
           // Make sure work partition is set before stealing
-          if ( data.pool_rendezvous() ) data.pool_rendezvous_release();
+          if (data.pool_rendezvous()) data.pool_rendezvous_release();
         }
 
-        std::pair<int64_t,int64_t> range(0,0);
+        std::pair<int64_t, int64_t> range(0, 0);
 
         do {
-
           range = is_dynamic ? data.get_work_stealing_chunk()
                              : data.get_work_partition();
 
-          ParallelFor::template
-            exec_range< WorkTag >( m_functor
-                , range.first  + m_policy.begin()
-                , range.second + m_policy.begin() );
+          ParallelFor::template exec_range<WorkTag>(
+              m_functor, range.first + m_policy.begin(),
+              range.second + m_policy.begin());
 
-        } while ( is_dynamic && 0 <= range.first );
+        } while (is_dynamic && 0 <= range.first);
       }
     }
   }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , Policy arg_policy )
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy) {}
 };
 
-
 // MDRangePolicy impl
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::MDRangePolicy< Traits ... >
-                 , Kokkos::OpenMP
-                 >
-{
-private:
-
-  typedef Kokkos::MDRangePolicy< Traits ... > MDRangePolicy ;
-  typedef typename MDRangePolicy::impl_range_policy         Policy ;
-  typedef typename MDRangePolicy::work_tag                  WorkTag ;
-
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
-
-  typedef typename Kokkos::Impl::HostIterateTile< MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void > iterate_type;
-
-        OpenMPExec   * m_instance ;
-  const FunctorType   m_functor ;
-  const MDRangePolicy m_mdr_policy ;
-  const Policy        m_policy ;  // construct as RangePolicy( 0, num_tiles ).set_chunk_size(1) in ctor
-
-  inline static
-  void
-  exec_range( const MDRangePolicy & mdr_policy
-            , const FunctorType & functor
-            , const Member ibeg , const Member iend )
-    {
-      #ifdef KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
-      #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-      #pragma ivdep
-      #endif
-      #endif
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        iterate_type( mdr_policy, functor )( iwork );
-      }
-    }
-
-public:
-
-  inline void execute() const
-  {
-      enum { is_dynamic = std::is_same< typename Policy::schedule_type::type
-                                      , Kokkos::Dynamic >::value };
-
-    if ( OpenMP::in_parallel() ) {
-      ParallelFor::exec_range ( m_mdr_policy
-                              , m_functor
-                              , m_policy.begin()
-                              , m_policy.end() );
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::OpenMP> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> MDRangePolicy;
+  typedef typename MDRangePolicy::impl_range_policy Policy;
+  typedef typename MDRangePolicy::work_tag WorkTag;
+
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
+
+  typedef typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void>
+      iterate_type;
+
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const MDRangePolicy m_mdr_policy;
+  const Policy m_policy;  // construct as RangePolicy( 0, num_tiles
+                          // ).set_chunk_size(1) in ctor
+
+  inline static void exec_range(const MDRangePolicy& mdr_policy,
+                                const FunctorType& functor, const Member ibeg,
+                                const Member iend) {
+#ifdef KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#endif
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      iterate_type(mdr_policy, functor)(iwork);
     }
-    else {
+  }
 
+ public:
+  inline void execute() const {
+    enum {
+      is_dynamic = std::is_same<typename Policy::schedule_type::type,
+                                Kokkos::Dynamic>::value
+    };
+
+    if (OpenMP::in_parallel()) {
+      ParallelFor::exec_range(m_mdr_policy, m_functor, m_policy.begin(),
+                              m_policy.end());
+    } else {
       OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_for");
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      #pragma omp parallel num_threads(OpenMP::thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::thread_pool_size())
 #else
-      #pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
 #endif
       {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
+        HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        data.set_work_partition( m_policy.end() - m_policy.begin()
-                               , m_policy.chunk_size() );
+        data.set_work_partition(m_policy.end() - m_policy.begin(),
+                                m_policy.chunk_size());
 
-        if ( is_dynamic ) {
+        if (is_dynamic) {
           // Make sure work partition is set before stealing
-          if ( data.pool_rendezvous() ) data.pool_rendezvous_release();
+          if (data.pool_rendezvous()) data.pool_rendezvous_release();
         }
 
-        std::pair<int64_t,int64_t> range(0,0);
+        std::pair<int64_t, int64_t> range(0, 0);
 
         do {
-
           range = is_dynamic ? data.get_work_stealing_chunk()
                              : data.get_work_partition();
 
-          ParallelFor::exec_range( m_mdr_policy
-                                 , m_functor
-                                 , range.first  + m_policy.begin()
-                                 , range.second + m_policy.begin() );
+          ParallelFor::exec_range(m_mdr_policy, m_functor,
+                                  range.first + m_policy.begin(),
+                                  range.second + m_policy.begin());
 
-        } while ( is_dynamic && 0 <= range.first );
+        } while (is_dynamic && 0 <= range.first);
       }
       // END #pragma omp parallel
     }
   }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , MDRangePolicy arg_policy )
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_mdr_policy( arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor, MDRangePolicy arg_policy)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -279,352 +249,338 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ReducerType, class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::RangePolicy< Traits ...>
-                    , ReducerType
-                    , Kokkos::OpenMP
-                    >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+                     Kokkos::OpenMP> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef FunctorAnalysis< FunctorPatternInterface::REDUCE , Policy , FunctorType > Analysis ;
+  typedef FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, FunctorType>
+      Analysis;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
   // Static Assert WorkTag void if ReducerType not InvalidType
 
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd, WorkTagFwd > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd, WorkTagFwd > ValueJoin ;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
 
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
 
-        OpenMPExec   * m_instance;
-  const FunctorType    m_functor;
-  const Policy         m_policy;
-  const ReducerType    m_reducer;
-  const pointer_type   m_result_ptr;
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update )
-    {
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( iwork , update );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update) {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(iwork, update);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update )
-    {
-      const TagType t{} ;
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( t , iwork , update );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update) {
+    const TagType t{};
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(t, iwork, update);
     }
+  }
 
-public:
-
-  inline void execute() const
-    {
-      enum { is_dynamic = std::is_same< typename Policy::schedule_type::type
-                                      , Kokkos::Dynamic >::value };
+ public:
+  inline void execute() const {
+    enum {
+      is_dynamic = std::is_same<typename Policy::schedule_type::type,
+                                Kokkos::Dynamic>::value
+    };
 
-      OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_reduce");
+    OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_reduce");
 
-      const size_t pool_reduce_bytes =
-        Analysis::value_size( ReducerConditional::select(m_functor, m_reducer));
+    const size_t pool_reduce_bytes =
+        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
 
-      m_instance->resize_thread_data( pool_reduce_bytes
-                                    , 0 // team_reduce_bytes
-                                    , 0 // team_shared_bytes
-                                    , 0 // thread_local_bytes
-                                    );
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int pool_size = OpenMP::thread_pool_size();
+    const int pool_size = OpenMP::thread_pool_size();
 #else
-      const int pool_size = OpenMP::impl_thread_pool_size();
+    const int pool_size = OpenMP::impl_thread_pool_size();
 #endif
-      #pragma omp parallel num_threads(pool_size)
-      {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
-
-        data.set_work_partition( m_policy.end() - m_policy.begin()
-                               , m_policy.chunk_size() );
+#pragma omp parallel num_threads(pool_size)
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        if ( is_dynamic ) {
-          // Make sure work partition is set before stealing
-          if ( data.pool_rendezvous() ) data.pool_rendezvous_release();
-        }
+      data.set_work_partition(m_policy.end() - m_policy.begin(),
+                              m_policy.chunk_size());
 
-        reference_type update =
-          ValueInit::init( ReducerConditional::select(m_functor , m_reducer)
-                         , data.pool_reduce_local() );
+      if (is_dynamic) {
+        // Make sure work partition is set before stealing
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
 
-        std::pair<int64_t,int64_t> range(0,0);
+      reference_type update =
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          data.pool_reduce_local());
 
-        do {
+      std::pair<int64_t, int64_t> range(0, 0);
 
-          range = is_dynamic ? data.get_work_stealing_chunk()
-                             : data.get_work_partition();
+      do {
+        range = is_dynamic ? data.get_work_stealing_chunk()
+                           : data.get_work_partition();
 
-          ParallelReduce::template
-            exec_range< WorkTag >( m_functor
-                                 , range.first  + m_policy.begin()
-                                 , range.second + m_policy.begin()
-                                 , update );
+        ParallelReduce::template exec_range<WorkTag>(
+            m_functor, range.first + m_policy.begin(),
+            range.second + m_policy.begin(), update);
 
-        } while ( is_dynamic && 0 <= range.first );
-      }
+      } while (is_dynamic && 0 <= range.first);
+    }
 
-      // Reduction:
+    // Reduction:
 
-      const pointer_type ptr = pointer_type( m_instance->get_thread_data(0)->pool_reduce_local() );
+    const pointer_type ptr =
+        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
 
-      for ( int i = 1 ; i < pool_size ; ++i ) {
-        ValueJoin::join( ReducerConditional::select(m_functor , m_reducer)
-                       , ptr
-                       , m_instance->get_thread_data(i)->pool_reduce_local() );
-      }
+    for (int i = 1; i < pool_size; ++i) {
+      ValueJoin::join(ReducerConditional::select(m_functor, m_reducer), ptr,
+                      m_instance->get_thread_data(i)->pool_reduce_local());
+    }
 
-      Kokkos::Impl::FunctorFinal<  ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , ptr );
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), ptr);
 
-      if ( m_result_ptr ) {
-        const int n = Analysis::value_count( ReducerConditional::select(m_functor , m_reducer) );
+    if (m_result_ptr) {
+      const int n = Analysis::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
 
-        for ( int j = 0 ; j < n ; ++j ) { m_result_ptr[j] = ptr[j] ; }
+      for (int j = 0; j < n; ++j) {
+        m_result_ptr[j] = ptr[j];
       }
     }
+  }
 
   //----------------------------------------
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ViewType    & arg_view
-                , typename std::enable_if<
-                           Kokkos::is_view< ViewType >::value &&
-                           !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr(  arg_view.data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ReducerType& reducer )
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.view().data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType& arg_functor, Policy arg_policy,
+      const ViewType& arg_view,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_view.data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 
+  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                        const ReducerType& reducer)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 };
 
-
 // MDRangePolicy impl
-template< class FunctorType , class ReducerType, class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::MDRangePolicy< Traits ...>
-                    , ReducerType
-                    , Kokkos::OpenMP
-                    >
-{
-private:
-
-  typedef Kokkos::MDRangePolicy< Traits ... > MDRangePolicy ;
-  typedef typename MDRangePolicy::impl_range_policy         Policy ;
-
-  typedef typename MDRangePolicy::work_tag                  WorkTag ;
-  typedef typename Policy::WorkRange                        WorkRange ;
-  typedef typename Policy::member_type                      Member ;
-
-  typedef FunctorAnalysis< FunctorPatternInterface::REDUCE , MDRangePolicy , FunctorType > Analysis ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
+                     Kokkos::OpenMP> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> MDRangePolicy;
+  typedef typename MDRangePolicy::impl_range_policy Policy;
+
+  typedef typename MDRangePolicy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
+
+  typedef FunctorAnalysis<FunctorPatternInterface::REDUCE, MDRangePolicy,
+                          FunctorType>
+      Analysis;
+
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
-
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd, WorkTagFwd > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd, WorkTagFwd > ValueJoin ;
-
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::value_type      value_type ;
-  typedef typename Analysis::reference_type  reference_type ;
-
-  using iterate_type = typename Kokkos::Impl::HostIterateTile< MDRangePolicy
-                                                             , FunctorType
-                                                             , WorkTag
-                                                             , reference_type
-                                                             >;
-
-        OpenMPExec   * m_instance ;
-  const FunctorType   m_functor ;
-  const MDRangePolicy m_mdr_policy ;
-  const Policy        m_policy ;     // construct as RangePolicy( 0, num_tiles ).set_chunk_size(1) in ctor
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
-
-  inline static
-  void
-  exec_range( const MDRangePolicy & mdr_policy
-            , const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update )
-    {
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        iterate_type( mdr_policy, functor, update )( iwork );
-      }
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
+
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::value_type value_type;
+  typedef typename Analysis::reference_type reference_type;
+
+  using iterate_type =
+      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
+                                             WorkTag, reference_type>;
+
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const MDRangePolicy m_mdr_policy;
+  const Policy m_policy;  // construct as RangePolicy( 0, num_tiles
+                          // ).set_chunk_size(1) in ctor
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+
+  inline static void exec_range(const MDRangePolicy& mdr_policy,
+                                const FunctorType& functor, const Member ibeg,
+                                const Member iend, reference_type update) {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      iterate_type(mdr_policy, functor, update)(iwork);
     }
+  }
 
-public:
-
-  inline void execute() const
-    {
-      enum { is_dynamic = std::is_same< typename Policy::schedule_type::type
-                                      , Kokkos::Dynamic >::value };
+ public:
+  inline void execute() const {
+    enum {
+      is_dynamic = std::is_same<typename Policy::schedule_type::type,
+                                Kokkos::Dynamic>::value
+    };
 
-      OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_reduce");
+    OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_reduce");
 
-      const size_t pool_reduce_bytes =
-        Analysis::value_size( ReducerConditional::select(m_functor, m_reducer));
+    const size_t pool_reduce_bytes =
+        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
 
-      m_instance->resize_thread_data( pool_reduce_bytes
-                                    , 0 // team_reduce_bytes
-                                    , 0 // team_shared_bytes
-                                    , 0 // thread_local_bytes
-                                    );
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int pool_size = OpenMP::thread_pool_size();
+    const int pool_size = OpenMP::thread_pool_size();
 #else
-      const int pool_size = OpenMP::impl_thread_pool_size();
+    const int pool_size = OpenMP::impl_thread_pool_size();
 #endif
-      #pragma omp parallel num_threads(pool_size)
-      {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
+#pragma omp parallel num_threads(pool_size)
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        data.set_work_partition( m_policy.end() - m_policy.begin()
-                               , m_policy.chunk_size() );
+      data.set_work_partition(m_policy.end() - m_policy.begin(),
+                              m_policy.chunk_size());
 
-        if ( is_dynamic ) {
-          // Make sure work partition is set before stealing
-          if ( data.pool_rendezvous() ) data.pool_rendezvous_release();
-        }
-
-        reference_type update =
-          ValueInit::init( ReducerConditional::select(m_functor , m_reducer)
-                         , data.pool_reduce_local() );
+      if (is_dynamic) {
+        // Make sure work partition is set before stealing
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
 
-        std::pair<int64_t,int64_t> range(0,0);
+      reference_type update =
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          data.pool_reduce_local());
 
-        do {
+      std::pair<int64_t, int64_t> range(0, 0);
 
-          range = is_dynamic ? data.get_work_stealing_chunk()
-                             : data.get_work_partition();
+      do {
+        range = is_dynamic ? data.get_work_stealing_chunk()
+                           : data.get_work_partition();
 
-          ParallelReduce::exec_range ( m_mdr_policy, m_functor
-                                     , range.first  + m_policy.begin()
-                                     , range.second + m_policy.begin()
-                                     , update );
+        ParallelReduce::exec_range(m_mdr_policy, m_functor,
+                                   range.first + m_policy.begin(),
+                                   range.second + m_policy.begin(), update);
 
-        } while ( is_dynamic && 0 <= range.first );
-      }
-// END #pragma omp parallel
+      } while (is_dynamic && 0 <= range.first);
+    }
+    // END #pragma omp parallel
 
-      // Reduction:
+    // Reduction:
 
-      const pointer_type ptr = pointer_type( m_instance->get_thread_data(0)->pool_reduce_local() );
+    const pointer_type ptr =
+        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
 
-      for ( int i = 1 ; i < pool_size ; ++i ) {
-        ValueJoin::join( ReducerConditional::select(m_functor , m_reducer)
-                       , ptr
-                       , m_instance->get_thread_data(i)->pool_reduce_local() );
-      }
+    for (int i = 1; i < pool_size; ++i) {
+      ValueJoin::join(ReducerConditional::select(m_functor, m_reducer), ptr,
+                      m_instance->get_thread_data(i)->pool_reduce_local());
+    }
 
-      Kokkos::Impl::FunctorFinal<  ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , ptr );
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), ptr);
 
-      if ( m_result_ptr ) {
-        const int n = Analysis::value_count( ReducerConditional::select(m_functor , m_reducer) );
+    if (m_result_ptr) {
+      const int n = Analysis::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
 
-        for ( int j = 0 ; j < n ; ++j ) { m_result_ptr[j] = ptr[j] ; }
+      for (int j = 0; j < n; ++j) {
+        m_result_ptr[j] = ptr[j];
       }
     }
+  }
 
   //----------------------------------------
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , MDRangePolicy       arg_policy
-                , const ViewType    & arg_view
-                , typename std::enable_if<
-                           Kokkos::is_view< ViewType >::value &&
-                           !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_mdr_policy(  arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    , m_reducer( InvalidType() )
-    , m_result_ptr(  arg_view.data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , MDRangePolicy       arg_policy
-                , const ReducerType& reducer )
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_mdr_policy(  arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.view().data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType& arg_functor, MDRangePolicy arg_policy,
+      const ViewType& arg_view,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_view.data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 
+  inline ParallelReduce(const FunctorType& arg_functor,
+                        MDRangePolicy arg_policy, const ReducerType& reducer)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -632,283 +588,251 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelScan< FunctorType
-                  , Kokkos::RangePolicy< Traits ... >
-                  , Kokkos::OpenMP
-                  >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::OpenMP> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
+  typedef FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>
+      Analysis;
 
-  typedef FunctorAnalysis< FunctorPatternInterface::SCAN , Policy , FunctorType > Analysis ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<FunctorType, WorkTag> ValueJoin;
+  typedef Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag> ValueOps;
 
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   FunctorType, WorkTag > ValueJoin ;
-  typedef Kokkos::Impl::FunctorValueOps<    FunctorType, WorkTag > ValueOps ;
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
 
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-        OpenMPExec   * m_instance;
-  const FunctorType    m_functor;
-  const Policy         m_policy;
-
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( iwork , update , final );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update, const bool final) {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(iwork, update, final);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      const TagType t{} ;
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( t , iwork , update , final );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update, const bool final) {
+    const TagType t{};
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(t, iwork, update, final);
     }
+  }
 
-public:
-
-  inline
-  void execute() const
-    {
-      OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_scan");
+ public:
+  inline void execute() const {
+    OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_scan");
 
-      const int    value_count       = Analysis::value_count( m_functor );
-      const size_t pool_reduce_bytes = 2 * Analysis::value_size( m_functor );
+    const int value_count          = Analysis::value_count(m_functor);
+    const size_t pool_reduce_bytes = 2 * Analysis::value_size(m_functor);
 
-      m_instance->resize_thread_data( pool_reduce_bytes
-                                    , 0 // team_reduce_bytes
-                                    , 0 // team_shared_bytes
-                                    , 0 // thread_local_bytes
-                                    );
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      #pragma omp parallel num_threads(OpenMP::thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::thread_pool_size())
 #else
-      #pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
 #endif
-      {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
-
-        const WorkRange range( m_policy, omp_get_thread_num(), omp_get_num_threads() );
-
-        reference_type update_sum =
-          ValueInit::init( m_functor , data.pool_reduce_local() );
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        ParallelScan::template exec_range< WorkTag >
-          ( m_functor , range.begin() , range.end() , update_sum , false );
+      const WorkRange range(m_policy, omp_get_thread_num(),
+                            omp_get_num_threads());
 
-        if ( data.pool_rendezvous() ) {
+      reference_type update_sum =
+          ValueInit::init(m_functor, data.pool_reduce_local());
 
-          pointer_type ptr_prev = 0 ;
+      ParallelScan::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_sum, false);
 
-          const int n = omp_get_num_threads();
+      if (data.pool_rendezvous()) {
+        pointer_type ptr_prev = 0;
 
-          for ( int i = 0 ; i < n ; ++i ) {
+        const int n = omp_get_num_threads();
 
-            pointer_type ptr = (pointer_type)
-              data.pool_member(i)->pool_reduce_local();
+        for (int i = 0; i < n; ++i) {
+          pointer_type ptr =
+              (pointer_type)data.pool_member(i)->pool_reduce_local();
 
-            if ( i ) {
-              for ( int j = 0 ; j < value_count ; ++j ) {
-                ptr[j+value_count] = ptr_prev[j+value_count] ;
-              }
-              ValueJoin::join( m_functor , ptr + value_count , ptr_prev );
+          if (i) {
+            for (int j = 0; j < value_count; ++j) {
+              ptr[j + value_count] = ptr_prev[j + value_count];
             }
-            else {
-              ValueInit::init( m_functor , ptr + value_count );
-            }
-
-            ptr_prev = ptr ;
+            ValueJoin::join(m_functor, ptr + value_count, ptr_prev);
+          } else {
+            ValueInit::init(m_functor, ptr + value_count);
           }
 
-          data.pool_rendezvous_release();
+          ptr_prev = ptr;
         }
 
-        reference_type update_base =
-          ValueOps::reference
-            ( ((pointer_type)data.pool_reduce_local()) + value_count );
-
-        ParallelScan::template exec_range< WorkTag >
-          ( m_functor , range.begin() , range.end() , update_base , true );
+        data.pool_rendezvous_release();
       }
 
+      reference_type update_base = ValueOps::reference(
+          ((pointer_type)data.pool_reduce_local()) + value_count);
+
+      ParallelScan::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_base, true);
     }
+  }
 
   //----------------------------------------
 
-  inline
-  ParallelScan( const FunctorType & arg_functor
-              , const Policy      & arg_policy )
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_policy(  arg_policy )
-  {}
+  inline ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy) {}
 
   //----------------------------------------
 };
-  
-template< class FunctorType, class ReturnType, class ... Traits >
-class ParallelScanWithTotal< FunctorType
-                           , Kokkos::RangePolicy< Traits ... >
-                           , ReturnType
-                           , Kokkos::OpenMP
-                           >
-{
-private:
 
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::OpenMP> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef FunctorAnalysis< FunctorPatternInterface::SCAN , Policy , FunctorType > Analysis ;
+  typedef FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>
+      Analysis;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   FunctorType, WorkTag > ValueJoin ;
-  typedef Kokkos::Impl::FunctorValueOps<    FunctorType, WorkTag > ValueOps ;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<FunctorType, WorkTag> ValueJoin;
+  typedef Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag> ValueOps;
 
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
 
-        OpenMPExec   * m_instance;
-  const FunctorType    m_functor;
-  const Policy         m_policy;
-        ReturnType   & m_returnvalue;
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  ReturnType& m_returnvalue;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( iwork , update , final );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update, const bool final) {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(iwork, update, final);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      const TagType t{} ;
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( t , iwork , update , final );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update, const bool final) {
+    const TagType t{};
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(t, iwork, update, final);
     }
+  }
 
-public:
-
-  inline
-  void execute() const
-    {
-      OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_scan");
+ public:
+  inline void execute() const {
+    OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_scan");
 
-      const int    value_count       = Analysis::value_count( m_functor );
-      const size_t pool_reduce_bytes = 2 * Analysis::value_size( m_functor );
+    const int value_count          = Analysis::value_count(m_functor);
+    const size_t pool_reduce_bytes = 2 * Analysis::value_size(m_functor);
 
-      m_instance->resize_thread_data( pool_reduce_bytes
-                                    , 0 // team_reduce_bytes
-                                    , 0 // team_shared_bytes
-                                    , 0 // thread_local_bytes
-                                    );
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      #pragma omp parallel num_threads(OpenMP::thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::thread_pool_size())
 #else
-      #pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
 #endif
-      {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
-
-        const WorkRange range( m_policy, omp_get_thread_num(), omp_get_num_threads() );
-        reference_type update_sum =
-          ValueInit::init( m_functor , data.pool_reduce_local() );
-
-        ParallelScanWithTotal::template exec_range< WorkTag >
-          ( m_functor , range.begin() , range.end() , update_sum , false );
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        if ( data.pool_rendezvous() ) {
+      const WorkRange range(m_policy, omp_get_thread_num(),
+                            omp_get_num_threads());
+      reference_type update_sum =
+          ValueInit::init(m_functor, data.pool_reduce_local());
 
-          pointer_type ptr_prev = 0 ;
+      ParallelScanWithTotal::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_sum, false);
 
-          const int n = omp_get_num_threads();
+      if (data.pool_rendezvous()) {
+        pointer_type ptr_prev = 0;
 
-          for ( int i = 0 ; i < n ; ++i ) {
+        const int n = omp_get_num_threads();
 
-            pointer_type ptr = (pointer_type)
-              data.pool_member(i)->pool_reduce_local();
+        for (int i = 0; i < n; ++i) {
+          pointer_type ptr =
+              (pointer_type)data.pool_member(i)->pool_reduce_local();
 
-            if ( i ) {
-              for ( int j = 0 ; j < value_count ; ++j ) {
-                ptr[j+value_count] = ptr_prev[j+value_count] ;
-              }
-              ValueJoin::join( m_functor , ptr + value_count , ptr_prev );
-            }
-            else {
-              ValueInit::init( m_functor , ptr + value_count );
+          if (i) {
+            for (int j = 0; j < value_count; ++j) {
+              ptr[j + value_count] = ptr_prev[j + value_count];
             }
-
-            ptr_prev = ptr ;
+            ValueJoin::join(m_functor, ptr + value_count, ptr_prev);
+          } else {
+            ValueInit::init(m_functor, ptr + value_count);
           }
 
-          data.pool_rendezvous_release();
+          ptr_prev = ptr;
         }
 
-        reference_type update_base =
-          ValueOps::reference
-            ( ((pointer_type)data.pool_reduce_local()) + value_count );
+        data.pool_rendezvous_release();
+      }
 
-        ParallelScanWithTotal::template exec_range< WorkTag >
-          ( m_functor , range.begin() , range.end() , update_base , true );
+      reference_type update_base = ValueOps::reference(
+          ((pointer_type)data.pool_reduce_local()) + value_count);
 
-        if (omp_get_thread_num()==omp_get_num_threads()-1) {
-          m_returnvalue = update_base;
-        }
-      }
+      ParallelScanWithTotal::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_base, true);
 
+      if (omp_get_thread_num() == omp_get_num_threads() - 1) {
+        m_returnvalue = update_base;
+      }
     }
+  }
 
   //----------------------------------------
 
-  inline
-  ParallelScanWithTotal( const FunctorType & arg_functor
-                       , const Policy      & arg_policy
-                       , ReturnType        & arg_returnvalue )
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_returnvalue(  arg_returnvalue )
-  {}
+  inline ParallelScanWithTotal(const FunctorType& arg_functor,
+                               const Policy& arg_policy,
+                               ReturnType& arg_returnvalue)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_returnvalue(arg_returnvalue) {}
 
   //----------------------------------------
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -916,382 +840,344 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Properties >
-class ParallelFor< FunctorType
-                 , Kokkos::TeamPolicy< Properties ... >
-                 , Kokkos::OpenMP
-                 >
-{
-private:
-
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::OpenMP> {
+ private:
   enum { TEAM_REDUCE_SIZE = 512 };
 
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::OpenMP, Properties ... > Policy ;
-  typedef typename Policy::work_tag             WorkTag ;
-  typedef typename Policy::schedule_type::type  SchedTag ;
-  typedef typename Policy::member_type          Member ;
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::OpenMP, Properties...>
+      Policy;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::schedule_type::type SchedTag;
+  typedef typename Policy::member_type Member;
 
-        OpenMPExec   * m_instance;
-  const FunctorType    m_functor;
-  const Policy         m_policy;
-  const int            m_shmem_size;
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const int m_shmem_size;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ( std::is_same< TagType , void >::value ) >::type
-  exec_team( const FunctorType & functor
-           , HostThreadTeamData & data
-           , const int league_rank_begin
-           , const int league_rank_end
-           , const int league_size )
-    {
-      for ( int r = league_rank_begin ; r < league_rank_end ; ) {
-
-        functor( Member( data, r , league_size ) );
-
-        if ( ++r < league_rank_end ) {
-          // Don't allow team members to lap one another
-          // so that they don't overwrite shared memory.
-          if ( data.team_rendezvous() ) { data.team_rendezvous_release(); }
+      typename std::enable_if<(std::is_same<TagType, void>::value)>::type
+      exec_team(const FunctorType& functor, HostThreadTeamData& data,
+                const int league_rank_begin, const int league_rank_end,
+                const int league_size) {
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(Member(data, r, league_size));
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
         }
       }
     }
+  }
 
-
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ( ! std::is_same< TagType , void >::value ) >::type
-  exec_team( const FunctorType & functor
-           , HostThreadTeamData & data
-           , const int league_rank_begin
-           , const int league_rank_end
-           , const int league_size )
-    {
-      const TagType t{};
-
-      for ( int r = league_rank_begin ; r < league_rank_end ; ) {
-
-        functor( t , Member( data, r , league_size ) );
-
-        if ( ++r < league_rank_end ) {
-          // Don't allow team members to lap one another
-          // so that they don't overwrite shared memory.
-          if ( data.team_rendezvous() ) { data.team_rendezvous_release(); }
+      typename std::enable_if<(!std::is_same<TagType, void>::value)>::type
+      exec_team(const FunctorType& functor, HostThreadTeamData& data,
+                const int league_rank_begin, const int league_rank_end,
+                const int league_size) {
+    const TagType t{};
+
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(t, Member(data, r, league_size));
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
         }
       }
     }
+  }
 
-public:
-
-  inline
-  void execute() const
-    {
-      enum { is_dynamic = std::is_same< SchedTag , Kokkos::Dynamic >::value };
+ public:
+  inline void execute() const {
+    enum { is_dynamic = std::is_same<SchedTag, Kokkos::Dynamic>::value };
 
-      OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_for");
+    OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_for");
 
-      const size_t pool_reduce_size = 0 ; // Never shrinks
-      const size_t team_reduce_size = TEAM_REDUCE_SIZE * m_policy.team_size();
-      const size_t team_shared_size = m_shmem_size + m_policy.scratch_size(1);
-      const size_t thread_local_size = 0 ; // Never shrinks
+    const size_t pool_reduce_size  = 0;  // Never shrinks
+    const size_t team_reduce_size  = TEAM_REDUCE_SIZE * m_policy.team_size();
+    const size_t team_shared_size  = m_shmem_size + m_policy.scratch_size(1);
+    const size_t thread_local_size = 0;  // Never shrinks
 
-      m_instance->resize_thread_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    m_instance->resize_thread_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      #pragma omp parallel num_threads(OpenMP::thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::thread_pool_size())
 #else
-      #pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
 #endif
-      {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
-
-        const int active = data.organize_team( m_policy.team_size() );
-
-        if ( active ) {
-          data.set_work_partition( m_policy.league_size()
-                                 , ( 0 < m_policy.chunk_size()
-                                   ? m_policy.chunk_size()
-                                   : m_policy.team_iter() ) );
-        }
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        if ( is_dynamic ) {
-          // Must synchronize to make sure each team has set its
-          // partition before beginning the work stealing loop.
-          if ( data.pool_rendezvous() ) data.pool_rendezvous_release();
-        }
+      const int active = data.organize_team(m_policy.team_size());
 
-        if ( active ) {
+      if (active) {
+        data.set_work_partition(
+            m_policy.league_size(),
+            (0 < m_policy.chunk_size() ? m_policy.chunk_size()
+                                       : m_policy.team_iter()));
+      }
 
-          std::pair<int64_t,int64_t> range(0,0);
+      if (is_dynamic) {
+        // Must synchronize to make sure each team has set its
+        // partition before beginning the work stealing loop.
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
 
-          do {
+      if (active) {
+        std::pair<int64_t, int64_t> range(0, 0);
 
-            range = is_dynamic ? data.get_work_stealing_chunk()
-                               : data.get_work_partition();
+        do {
+          range = is_dynamic ? data.get_work_stealing_chunk()
+                             : data.get_work_partition();
 
-            ParallelFor::template exec_team< WorkTag >
-              ( m_functor , data
-              , range.first , range.second , m_policy.league_size() );
+          ParallelFor::template exec_team<WorkTag>(m_functor, data, range.first,
+                                                   range.second,
+                                                   m_policy.league_size());
 
-          } while ( is_dynamic && 0 <= range.first );
-        }
-
-        data.disband_team();
+        } while (is_dynamic && 0 <= range.first);
       }
-    }
 
+      data.disband_team();
+    }
+  }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor ,
-               const Policy      & arg_policy )
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_shmem_size( arg_policy.scratch_size(0) +
-                    arg_policy.scratch_size(1) +
-                    FunctorTeamShmemSize< FunctorType >
-                      ::value( arg_functor , arg_policy.team_size() ) )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                     FunctorTeamShmemSize<FunctorType>::value(
+                         arg_functor, arg_policy.team_size())) {}
 };
 
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ReducerType, class ... Properties >
-class ParallelReduce< FunctorType
-                    , Kokkos::TeamPolicy< Properties ... >
-                    , ReducerType
-                    , Kokkos::OpenMP
-                    >
-{
-private:
-
+template <class FunctorType, class ReducerType, class... Properties>
+class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                     ReducerType, Kokkos::OpenMP> {
+ private:
   enum { TEAM_REDUCE_SIZE = 512 };
 
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::OpenMP, Properties ... >         Policy ;
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::OpenMP, Properties...>
+      Policy;
 
-  typedef FunctorAnalysis< FunctorPatternInterface::REDUCE , Policy , FunctorType > Analysis ;
+  typedef FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, FunctorType>
+      Analysis;
 
-  typedef typename Policy::work_tag             WorkTag ;
-  typedef typename Policy::schedule_type::type  SchedTag ;
-  typedef typename Policy::member_type          Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::schedule_type::type SchedTag;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value
-                            , FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
 
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd >  ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd , WorkTagFwd >  ValueJoin ;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
 
-  typedef typename Analysis::pointer_type    pointer_type ;
-  typedef typename Analysis::reference_type  reference_type ;
+  typedef typename Analysis::pointer_type pointer_type;
+  typedef typename Analysis::reference_type reference_type;
 
-        OpenMPExec   * m_instance;
-  const FunctorType    m_functor;
-  const Policy         m_policy;
-  const ReducerType    m_reducer;
-  const pointer_type   m_result_ptr;
-  const int            m_shmem_size;
+  OpenMPExec* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+  const int m_shmem_size;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ( std::is_same< TagType , void >::value ) >::type
-  exec_team( const FunctorType & functor
-           , HostThreadTeamData & data
-           , reference_type     & update
-           , const int league_rank_begin
-           , const int league_rank_end
-           , const int league_size )
-    {
-      for ( int r = league_rank_begin ; r < league_rank_end ; ) {
-
-        functor( Member( data, r , league_size ) , update );
-
-        if ( ++r < league_rank_end ) {
-          // Don't allow team members to lap one another
-          // so that they don't overwrite shared memory.
-          if ( data.team_rendezvous() ) { data.team_rendezvous_release(); }
+      typename std::enable_if<(std::is_same<TagType, void>::value)>::type
+      exec_team(const FunctorType& functor, HostThreadTeamData& data,
+                reference_type& update, const int league_rank_begin,
+                const int league_rank_end, const int league_size) {
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(Member(data, r, league_size), update);
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
         }
       }
     }
+  }
 
-
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ( ! std::is_same< TagType , void >::value ) >::type
-  exec_team( const FunctorType & functor
-           , HostThreadTeamData & data
-           , reference_type     & update
-           , const int league_rank_begin
-           , const int league_rank_end
-           , const int league_size )
-    {
-      const TagType t{};
-
-      for ( int r = league_rank_begin ; r < league_rank_end ; ) {
-
-        functor( t , Member( data, r , league_size ) , update );
-
-        if ( ++r < league_rank_end ) {
-          // Don't allow team members to lap one another
-          // so that they don't overwrite shared memory.
-          if ( data.team_rendezvous() ) { data.team_rendezvous_release(); }
+      typename std::enable_if<(!std::is_same<TagType, void>::value)>::type
+      exec_team(const FunctorType& functor, HostThreadTeamData& data,
+                reference_type& update, const int league_rank_begin,
+                const int league_rank_end, const int league_size) {
+    const TagType t{};
+
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(t, Member(data, r, league_size), update);
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
         }
       }
     }
+  }
 
-public:
+ public:
+  inline void execute() const {
+    enum { is_dynamic = std::is_same<SchedTag, Kokkos::Dynamic>::value };
 
-  inline
-  void execute() const
-    {
-      enum { is_dynamic = std::is_same< SchedTag , Kokkos::Dynamic >::value };
+    OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_reduce");
 
-      OpenMPExec::verify_is_master("Kokkos::OpenMP parallel_reduce");
+    const size_t pool_reduce_size =
+        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
 
-      const size_t pool_reduce_size =
-        Analysis::value_size( ReducerConditional::select(m_functor, m_reducer));
+    const size_t team_reduce_size  = TEAM_REDUCE_SIZE * m_policy.team_size();
+    const size_t team_shared_size  = m_shmem_size + m_policy.scratch_size(1);
+    const size_t thread_local_size = 0;  // Never shrinks
 
-      const size_t team_reduce_size = TEAM_REDUCE_SIZE * m_policy.team_size();
-      const size_t team_shared_size = m_shmem_size + m_policy.scratch_size(1);
-      const size_t thread_local_size = 0 ; // Never shrinks
-
-      m_instance->resize_thread_data( pool_reduce_size
-                                    , team_reduce_size
-                                    , team_shared_size
-                                    , thread_local_size );
+    m_instance->resize_thread_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int pool_size = OpenMP::thread_pool_size();
+    const int pool_size = OpenMP::thread_pool_size();
 #else
-      const int pool_size = OpenMP::impl_thread_pool_size();
+    const int pool_size = OpenMP::impl_thread_pool_size();
 #endif
-      #pragma omp parallel num_threads(pool_size)
-      {
-        HostThreadTeamData & data = *(m_instance->get_thread_data());
-
-        const int active = data.organize_team( m_policy.team_size() );
+#pragma omp parallel num_threads(pool_size)
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
 
-        if ( active ) {
-          data.set_work_partition( m_policy.league_size()
-                                 , ( 0 < m_policy.chunk_size()
-                                   ? m_policy.chunk_size()
-                                   : m_policy.team_iter() ) );
-        }
+      const int active = data.organize_team(m_policy.team_size());
 
-        if ( is_dynamic ) {
-          // Must synchronize to make sure each team has set its
-          // partition before beginning the work stealing loop.
-          if ( data.pool_rendezvous() ) data.pool_rendezvous_release();
-        }
+      if (active) {
+        data.set_work_partition(
+            m_policy.league_size(),
+            (0 < m_policy.chunk_size() ? m_policy.chunk_size()
+                                       : m_policy.team_iter()));
+      }
 
-        if ( active ) {
-          reference_type update =
-            ValueInit::init( ReducerConditional::select(m_functor , m_reducer)
-                           , data.pool_reduce_local() );
+      if (is_dynamic) {
+        // Must synchronize to make sure each team has set its
+        // partition before beginning the work stealing loop.
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
 
-          std::pair<int64_t,int64_t> range(0,0);
+      if (active) {
+        reference_type update =
+            ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                            data.pool_reduce_local());
 
-          do {
+        std::pair<int64_t, int64_t> range(0, 0);
 
-            range = is_dynamic ? data.get_work_stealing_chunk()
-                               : data.get_work_partition();
+        do {
+          range = is_dynamic ? data.get_work_stealing_chunk()
+                             : data.get_work_partition();
 
-            ParallelReduce::template exec_team< WorkTag >
-              ( m_functor , data , update
-              , range.first , range.second , m_policy.league_size() );
+          ParallelReduce::template exec_team<WorkTag>(m_functor, data, update,
+                                                      range.first, range.second,
+                                                      m_policy.league_size());
 
-          } while ( is_dynamic && 0 <= range.first );
-        } else {
-          ValueInit::init( ReducerConditional::select(m_functor , m_reducer)
-                           , data.pool_reduce_local() );
-        }
+        } while (is_dynamic && 0 <= range.first);
+      } else {
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                        data.pool_reduce_local());
+      }
 
-        data.disband_team();
+      data.disband_team();
 
-        //  This thread has updated 'pool_reduce_local()' with its
-        //  contributions to the reduction.  The parallel region is
-        //  about to terminate and the master thread will load and
-        //  reduce each 'pool_reduce_local()' contribution.
-        //  Must 'memory_fence()' to guarantee that storing the update to
-        //  'pool_reduce_local()' will complete before this thread
-        //  exits the parallel region.
+      //  This thread has updated 'pool_reduce_local()' with its
+      //  contributions to the reduction.  The parallel region is
+      //  about to terminate and the master thread will load and
+      //  reduce each 'pool_reduce_local()' contribution.
+      //  Must 'memory_fence()' to guarantee that storing the update to
+      //  'pool_reduce_local()' will complete before this thread
+      //  exits the parallel region.
 
-        memory_fence();
-      }
+      memory_fence();
+    }
 
-      // Reduction:
+    // Reduction:
 
-      const pointer_type ptr = pointer_type( m_instance->get_thread_data(0)->pool_reduce_local() );
+    const pointer_type ptr =
+        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
 
-      for ( int i = 1 ; i < pool_size ; ++i ) {
-        ValueJoin::join( ReducerConditional::select(m_functor , m_reducer)
-                       , ptr
-                       , m_instance->get_thread_data(i)->pool_reduce_local() );
-      }
+    for (int i = 1; i < pool_size; ++i) {
+      ValueJoin::join(ReducerConditional::select(m_functor, m_reducer), ptr,
+                      m_instance->get_thread_data(i)->pool_reduce_local());
+    }
 
-      Kokkos::Impl::FunctorFinal<  ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , ptr );
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), ptr);
 
-      if ( m_result_ptr ) {
-        const int n = Analysis::value_count( ReducerConditional::select(m_functor , m_reducer) );
+    if (m_result_ptr) {
+      const int n = Analysis::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
 
-        for ( int j = 0 ; j < n ; ++j ) { m_result_ptr[j] = ptr[j] ; }
+      for (int j = 0; j < n; ++j) {
+        m_result_ptr[j] = ptr[j];
       }
     }
+  }
 
   //----------------------------------------
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType  & arg_functor ,
-                  const Policy       & arg_policy ,
-                  const ViewType     & arg_result ,
-                  typename std::enable_if<
-                    Kokkos::is_view< ViewType >::value &&
-                    !Kokkos::is_reducer_type<ReducerType>::value
-                    ,void*>::type = NULL)
-    : m_instance( t_openmp_instance )
-    , m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result.data() )
-    , m_shmem_size( arg_policy.scratch_size(0) +
-                    arg_policy.scratch_size(1) +
-                    FunctorTeamShmemSize< FunctorType >
-                      ::value( arg_functor , arg_policy.team_size() ) )
-    {}
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-    , Policy       arg_policy
-    , const ReducerType& reducer )
-  : m_instance( t_openmp_instance )
-  , m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr(  reducer.view().data() )
-  , m_shmem_size( arg_policy.scratch_size(0) +
-                  arg_policy.scratch_size(1) +
-                  FunctorTeamShmemSize< FunctorType >
-                    ::value( arg_functor , arg_policy.team_size() ) )
-  {
-  /*static_assert( std::is_same< typename ViewType::memory_space
-                          , Kokkos::HostSpace >::value
-  , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType& arg_functor, const Policy& arg_policy,
+      const ViewType& arg_result,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.data()),
+        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                     FunctorTeamShmemSize<FunctorType>::value(
+                         arg_functor, arg_policy.team_size())) {}
+
+  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                        const ReducerType& reducer)
+      : m_instance(t_openmp_instance),
+        m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
+        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                     FunctorTeamShmemSize<FunctorType>::value(
+                         arg_functor, arg_policy.team_size())) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                            , Kokkos::HostSpace >::value
+    , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+    );*/
   }
-
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif
 #endif /* KOKKOS_OPENMP_PARALLEL_HPP */
-
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.cpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.cpp
index 3b1c187c6d2e299232030678e612faaa6b934f28..f7338819af53300839895021ada12c11323a2f82 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.cpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP ) && defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_OPENMP) && defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core.hpp>
 
@@ -57,50 +58,53 @@
 namespace Kokkos {
 namespace Impl {
 
-template class TaskQueue< Kokkos::OpenMP, typename Kokkos::OpenMP::memory_space > ;
+template class TaskQueue<Kokkos::OpenMP, typename Kokkos::OpenMP::memory_space>;
 
-HostThreadTeamData& HostThreadTeamDataSingleton::singleton()
-{
+HostThreadTeamData& HostThreadTeamDataSingleton::singleton() {
   static HostThreadTeamDataSingleton s;
   return s;
 }
 
 HostThreadTeamDataSingleton::HostThreadTeamDataSingleton()
-  : HostThreadTeamData()
-{
-  Kokkos::OpenMP::memory_space space ;
-  const size_t num_pool_reduce_bytes  =   32 ;
-  const size_t num_team_reduce_bytes  =   32 ;
-  const size_t num_team_shared_bytes  = 1024 ;
-  const size_t num_thread_local_bytes = 1024 ;
-  const size_t alloc_bytes =
-    HostThreadTeamData::scratch_size( num_pool_reduce_bytes
-      , num_team_reduce_bytes
-      , num_team_shared_bytes
-      , num_thread_local_bytes );
+    : HostThreadTeamData() {
+  Kokkos::OpenMP::memory_space space;
+  const size_t num_pool_reduce_bytes  = 32;
+  const size_t num_team_reduce_bytes  = 32;
+  const size_t num_team_shared_bytes  = 1024;
+  const size_t num_thread_local_bytes = 1024;
+  const size_t alloc_bytes            = HostThreadTeamData::scratch_size(
+      num_pool_reduce_bytes, num_team_reduce_bytes, num_team_shared_bytes,
+      num_thread_local_bytes);
 
-  HostThreadTeamData::scratch_assign
-    ( space.allocate( alloc_bytes )
-      , alloc_bytes
-      , num_pool_reduce_bytes
-      , num_team_reduce_bytes
-      , num_team_shared_bytes
-      , num_thread_local_bytes );
+  void* ptr = nullptr;
+  try {
+    ptr = space.allocate(alloc_bytes);
+  } catch (Kokkos::Experimental::RawMemoryAllocationFailure const& f) {
+    // For now, just rethrow the error message with a note
+    // Note that this could, in turn, trigger an out of memory exception,
+    // but it's pretty unlikely, so we won't worry about it for now.
+    // TODO reasonable error message when `std::string` causes OOM error
+    Kokkos::Impl::throw_runtime_exception(
+        std::string("Failure to allocate scratch memory:  ") +
+        f.get_error_message());
+  }
+
+  HostThreadTeamData::scratch_assign(
+      ptr, alloc_bytes, num_pool_reduce_bytes, num_team_reduce_bytes,
+      num_team_shared_bytes, num_thread_local_bytes);
 }
 
-HostThreadTeamDataSingleton::~HostThreadTeamDataSingleton()
-{
-  Kokkos::OpenMP::memory_space space ;
-  space.deallocate(
-    HostThreadTeamData::scratch_buffer(),
-    static_cast<size_t>(HostThreadTeamData::scratch_bytes())
-  );
+HostThreadTeamDataSingleton::~HostThreadTeamDataSingleton() {
+  Kokkos::OpenMP::memory_space space;
+  space.deallocate(HostThreadTeamData::scratch_buffer(),
+                   static_cast<size_t>(HostThreadTeamData::scratch_bytes()));
 }
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 #else
 void KOKKOS_CORE_SRC_OPENMP_KOKKOS_OPENMP_TASK_PREVENT_LINK_ERROR() {}
-#endif /* #if defined( KOKKOS_ENABLE_OPENMP ) && defined( KOKKOS_ENABLE_TASKDAG ) */
-
+#endif /* #if defined( KOKKOS_ENABLE_OPENMP ) && defined( \
+          KOKKOS_ENABLE_TASKDAG ) */
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.hpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
index 4029c015b3ebf6a0c34b3036fea0bd7a58351d31..0cbdfbbdaa64c27b76cef3b0d1478b105c54ea9b 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_IMPL_OPENMP_TASK_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP ) && defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_OPENMP) && defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
@@ -62,75 +63,68 @@ namespace Kokkos {
 namespace Impl {
 
 class HostThreadTeamDataSingleton : private HostThreadTeamData {
-private:
-
+ private:
   HostThreadTeamDataSingleton();
   ~HostThreadTeamDataSingleton();
 
-public:
-
-  static HostThreadTeamData & singleton();
-
+ public:
+  static HostThreadTeamData& singleton();
 };
 
 // Hack this as a partial specialization for now
-// TODO @tasking @cleanup DSH Make this the general class template and make the old code the partial specialization
+// TODO @tasking @cleanup DSH Make this the general class template and make the
+// old code the partial specialization
 template <class QueueType>
-class TaskQueueSpecialization<
-  SimpleTaskScheduler<Kokkos::OpenMP, QueueType>
->
-{
-public:
-
+class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::OpenMP, QueueType> > {
+ public:
   using execution_space = Kokkos::OpenMP;
-  using scheduler_type = SimpleTaskScheduler<Kokkos::OpenMP, QueueType>;
-  using member_type = TaskTeamMemberAdapter<
-    Kokkos::Impl::HostThreadTeamMember<execution_space>,
-    scheduler_type
-  >;
+  using scheduler_type  = SimpleTaskScheduler<Kokkos::OpenMP, QueueType>;
+  using member_type =
+      TaskTeamMemberAdapter<Kokkos::Impl::HostThreadTeamMember<execution_space>,
+                            scheduler_type>;
   using memory_space = Kokkos::HostSpace;
 
   enum : int { max_league_size = HostThreadTeamData::max_pool_members };
 
   // Must provide task queue execution function
-  static void execute(scheduler_type const& scheduler)
-  {
+  static void execute(scheduler_type const& scheduler) {
     using task_base_type = typename scheduler_type::task_base_type;
 
-    // Unused; ChaseLev queue still needs worker ID even in single case (so we need to use
-    // the thread data from inside of the parallel region.  Team size is fixed at 1 for now
-    // anyway
-    //HostThreadTeamData& team_data_single = HostThreadTeamDataSingleton::singleton();
+    // Unused; ChaseLev queue still needs worker ID even in single case (so we
+    // need to use the thread data from inside of the parallel region.  Team
+    // size is fixed at 1 for now anyway
+    // HostThreadTeamData& team_data_single =
+    // HostThreadTeamDataSingleton::singleton();
 
-    // TODO @tasking @generalization DSH use scheduler.get_execution_space().impl() (or something like that) instead of the thread-local variable
+    // TODO @tasking @generalization DSH use
+    // scheduler.get_execution_space().impl() (or something like that) instead
+    // of the thread-local variable
     Impl::OpenMPExec* instance = t_openmp_instance;
     const int pool_size = get_max_team_count(scheduler.get_execution_space());
 
     // TODO @tasking @new_feature DSH allow team sizes other than 1
-    const int team_size = 1;  // Threads per core
-    instance->resize_thread_data(
-      0, /* global reduce buffer */
-      512 * team_size, /* team reduce buffer */
-      0, /* team shared buffer */
-      0 /* thread local buffer */
+    const int team_size = 1;                      // Threads per core
+    instance->resize_thread_data(0,               /* global reduce buffer */
+                                 512 * team_size, /* team reduce buffer */
+                                 0,               /* team shared buffer */
+                                 0                /* thread local buffer */
     );
     assert(pool_size % team_size == 0);
 
     auto& queue = scheduler.queue();
 
-    //queue.initialize_team_queues(pool_size / team_size);
+    // queue.initialize_team_queues(pool_size / team_size);
 
-    #pragma omp parallel num_threads(pool_size)
+#pragma omp parallel num_threads(pool_size)
     {
-      Impl::HostThreadTeamData & self = *(instance->get_thread_data());
+      Impl::HostThreadTeamData& self = *(instance->get_thread_data());
 
       // Organizing threads into a team performs a barrier across the
       // entire pool to insure proper initialization of the team
       // rendezvous mechanism before a team rendezvous can be performed.
 
       // organize_team() returns true if this is an active team member
-      if(self.organize_team(team_size)) {
-
+      if (self.organize_team(team_size)) {
         member_type single_exec(scheduler, self);
         member_type team_exec(scheduler, self);
 
@@ -138,68 +132,56 @@ public:
 
         auto current_task = OptionalRef<task_base_type>(nullptr);
 
-        while(not queue.is_done()) {
-
+        while (not queue.is_done()) {
           // Each team lead attempts to acquire either a thread team task
           // or a single thread task for the team.
-          if(team_exec.team_rank() == 0) {
-
+          if (team_exec.team_rank() == 0) {
             // loop while both:
             //   - the queue is not done
             //   - the most recently popped task is a single task or empty
-            while(not queue.is_done()) {
-
-              current_task = queue.pop_ready_task(team_scheduler.team_scheduler_info());
+            while (not queue.is_done()) {
+              current_task =
+                  queue.pop_ready_task(team_scheduler.team_scheduler_info());
 
-              if(current_task) {
-
-                if(current_task->is_team_runnable()) {
+              if (current_task) {
+                if (current_task->is_team_runnable()) {
                   // break out of the team leader loop to run the team task
                   break;
-                }
-                else {
+                } else {
                   KOKKOS_ASSERT(current_task->is_single_runnable());
                   current_task->as_runnable_task().run(single_exec);
                   // Respawns are handled in the complete function
-                  queue.complete(
-                    (*std::move(current_task)).as_runnable_task(),
-                    team_scheduler.team_scheduler_info()
-                  );
+                  queue.complete((*std::move(current_task)).as_runnable_task(),
+                                 team_scheduler.team_scheduler_info());
                 }
 
-              } // end if current_task is not null
+              }  // end if current_task is not null
 
               current_task = nullptr;
 
-            } // end team leader loop
-
+            }  // end team leader loop
           }
 
           // Otherwise, make sure everyone in the team has the same task
           team_exec.team_broadcast(current_task, 0);
 
-          if(current_task) {
+          if (current_task) {
             KOKKOS_ASSERT(current_task->is_team_runnable());
             current_task->as_runnable_task().run(team_exec);
 
-            if(team_exec.team_rank() == 0) {
+            if (team_exec.team_rank() == 0) {
               // Respawns are handled in the complete function
-              queue.complete(
-                (*std::move(current_task)).as_runnable_task(),
-                team_scheduler.team_scheduler_info()
-              );
+              queue.complete((*std::move(current_task)).as_runnable_task(),
+                             team_scheduler.team_scheduler_info());
             }
-
           }
-
         }
       }
       self.disband_team();
-    } // end pragma omp parallel
+    }  // end pragma omp parallel
   }
 
-  static uint32_t
-  get_max_team_count(execution_space const& espace) {
+  static uint32_t get_max_team_count(execution_space const& espace) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     return static_cast<uint32_t>(espace.thread_pool_size());
 #else
@@ -207,109 +189,100 @@ public:
 #endif
   }
 
-  // TODO @tasking @optimization DSH specialize this for trivially destructible types
+  // TODO @tasking @optimization DSH specialize this for trivially destructible
+  // types
   template <typename TaskType>
-  static void
-  get_function_pointer(
-    typename TaskType::function_type& ptr,
-    typename TaskType::destroy_type& dtor
-  ) {
-    ptr = TaskType::apply;
+  static void get_function_pointer(typename TaskType::function_type& ptr,
+                                   typename TaskType::destroy_type& dtor) {
+    ptr  = TaskType::apply;
     dtor = TaskType::destroy;
   }
 };
 
-
-template<class Scheduler>
+template <class Scheduler>
 class TaskQueueSpecializationConstrained<
-  Scheduler,
-  typename std::enable_if<
-    std::is_same<typename Scheduler::execution_space, Kokkos::OpenMP>::value
-  >::type
->
-{
-public:
-
+    Scheduler,
+    typename std::enable_if<std::is_same<typename Scheduler::execution_space,
+                                         Kokkos::OpenMP>::value>::type> {
+ public:
   using execution_space = Kokkos::OpenMP;
-  using scheduler_type = Scheduler;
-  using member_type = TaskTeamMemberAdapter<
-    Kokkos::Impl::HostThreadTeamMember<execution_space>,
-    scheduler_type
-  >;
-  using memory_space = Kokkos::HostSpace ;
+  using scheduler_type  = Scheduler;
+  using member_type =
+      TaskTeamMemberAdapter<Kokkos::Impl::HostThreadTeamMember<execution_space>,
+                            scheduler_type>;
+  using memory_space = Kokkos::HostSpace;
 
   enum : int { max_league_size = HostThreadTeamData::max_pool_members };
 
-  static
-  void iff_single_thread_recursive_execute( scheduler_type const& scheduler ) {
+  static void iff_single_thread_recursive_execute(
+      scheduler_type const& scheduler) {
     using task_base_type = typename scheduler_type::task_base;
-    using queue_type = typename scheduler_type::queue_type;
+    using queue_type     = typename scheduler_type::queue_type;
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    if ( 1 == OpenMP::thread_pool_size() )
+    if (1 == OpenMP::thread_pool_size())
 #else
-    if ( 1 == OpenMP::impl_thread_pool_size() )
+    if (1 == OpenMP::impl_thread_pool_size())
 #endif
     {
 
-      task_base_type * const end = (task_base_type *) task_base_type::EndTag ;
+      task_base_type* const end = (task_base_type*)task_base_type::EndTag;
 
-      HostThreadTeamData & team_data_single =
-        HostThreadTeamDataSingleton::singleton();
+      HostThreadTeamData& team_data_single =
+          HostThreadTeamDataSingleton::singleton();
 
-      member_type single_exec( scheduler, team_data_single );
+      member_type single_exec(scheduler, team_data_single);
 
-      task_base_type * task = end ;
+      task_base_type* task = end;
 
       do {
-
-        task = end ;
+        task = end;
 
         // Loop by priority and then type
-        for ( int i = 0 ; i < queue_type::NumQueue && end == task ; ++i ) {
-          for ( int j = 0 ; j < 2 && end == task ; ++j ) {
-            task = queue_type::pop_ready_task( & scheduler.m_queue->m_ready[i][j] );
+        for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+          for (int j = 0; j < 2 && end == task; ++j) {
+            task =
+                queue_type::pop_ready_task(&scheduler.m_queue->m_ready[i][j]);
           }
         }
 
-        if ( end == task ) break ;
+        if (end == task) break;
 
-        (*task->m_apply)( task , & single_exec );
+        (*task->m_apply)(task, &single_exec);
 
-        scheduler.m_queue->complete( task );
+        scheduler.m_queue->complete(task);
 
-      } while(1);
+      } while (1);
     }
-
   }
 
   // Must provide task queue execution function
-  static void execute(scheduler_type const& scheduler)
-  {
+  static void execute(scheduler_type const& scheduler) {
     using task_base_type = typename scheduler_type::task_base;
-    using queue_type = typename scheduler_type::queue_type;
+    using queue_type     = typename scheduler_type::queue_type;
 
-    static task_base_type * const end =
-      (task_base_type *) task_base_type::EndTag ;
+    static task_base_type* const end = (task_base_type*)task_base_type::EndTag;
 
     constexpr task_base_type* no_more_tasks_sentinel = nullptr;
 
+    HostThreadTeamData& team_data_single =
+        HostThreadTeamDataSingleton::singleton();
 
-    HostThreadTeamData & team_data_single =
-      HostThreadTeamDataSingleton::singleton();
-
-    Impl::OpenMPExec * instance = t_openmp_instance;
+    Impl::OpenMPExec* instance = t_openmp_instance;
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     const int pool_size = OpenMP::thread_pool_size();
 #else
     const int pool_size = OpenMP::impl_thread_pool_size();
 #endif
 
-    const int team_size = 1;  // Threads per core
-    instance->resize_thread_data( 0 /* global reduce buffer */
-      , 512 * team_size /* team reduce buffer */
-      , 0 /* team shared buffer */
-      , 0 /* thread local buffer */
+    const int team_size = 1;       // Threads per core
+    instance->resize_thread_data(0 /* global reduce buffer */
+                                 ,
+                                 512 * team_size /* team reduce buffer */
+                                 ,
+                                 0 /* team shared buffer */
+                                 ,
+                                 0 /* thread local buffer */
     );
     assert(pool_size % team_size == 0);
     auto& queue = scheduler.queue();
@@ -317,15 +290,14 @@ public:
 
 #pragma omp parallel num_threads(pool_size)
     {
-      Impl::HostThreadTeamData & self = *(instance->get_thread_data());
+      Impl::HostThreadTeamData& self = *(instance->get_thread_data());
 
       // Organizing threads into a team performs a barrier across the
       // entire pool to insure proper initialization of the team
       // rendezvous mechanism before a team rendezvous can be performed.
 
       // organize_team() returns true if this is an active team member
-      if ( self.organize_team( team_size ) ) {
-
+      if (self.organize_team(team_size)) {
         member_type single_exec(scheduler, team_data_single);
         member_type team_exec(scheduler, self);
 
@@ -333,108 +305,100 @@ public:
 
         // Loop until all queues are empty and no tasks in flight
 
-        task_base_type * task = no_more_tasks_sentinel;
-
+        task_base_type* task = no_more_tasks_sentinel;
 
         do {
           // Each team lead attempts to acquire either a thread team task
           // or a single thread task for the team.
 
-          if ( 0 == team_exec.team_rank() ) {
-
-            bool leader_loop = false ;
+          if (0 == team_exec.team_rank()) {
+            bool leader_loop = false;
 
             do {
-
-              if ( task != no_more_tasks_sentinel && task != end ) {
+              if (task != no_more_tasks_sentinel && task != end) {
                 // team member #0 completes the previously executed task,
                 // completion may delete the task
-                team_queue.complete( task );
+                team_queue.complete(task);
               }
 
               // If 0 == m_ready_count then set task = 0
 
-              if( *((volatile int *) & team_queue.m_ready_count) > 0 ) {
+              if (*((volatile int*)&team_queue.m_ready_count) > 0) {
                 task = end;
                 // Attempt to acquire a task
                 // Loop by priority and then type
-                for ( int i = 0 ; i < queue_type::NumQueue && end == task ; ++i ) {
-                  for ( int j = 0 ; j < 2 && end == task ; ++j ) {
-                    task = queue_type::pop_ready_task( & team_queue.m_ready[i][j] );
+                for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+                  for (int j = 0; j < 2 && end == task; ++j) {
+                    task =
+                        queue_type::pop_ready_task(&team_queue.m_ready[i][j]);
                   }
                 }
-              }
-              else {
+              } else {
                 // returns nullptr if and only if all other queues have a ready
                 // count of 0 also. Otherwise, returns a task from another queue
                 // or `end` if one couldn't be popped
                 task = team_queue.attempt_to_steal_task();
-                #if 0
+#if 0
                 if(task != no_more_tasks_sentinel && task != end) {
                   std::printf("task stolen on rank %d\n", team_exec.league_rank());
                 }
-                #endif
+#endif
               }
 
               // If still tasks are still executing
               // and no task could be acquired
               // then continue this leader loop
-              if(task == end) {
+              if (task == end) {
                 // this means that the ready task count was not zero, but we
                 // couldn't pop a task (because, for instance, someone else
                 // got there before us
                 leader_loop = true;
-              }
-              else if ( ( task != no_more_tasks_sentinel ) &&
-                ( task_base_type::TaskSingle == task->m_task_type ) ) {
-
+              } else if ((task != no_more_tasks_sentinel) &&
+                         (task_base_type::TaskSingle == task->m_task_type)) {
                 // if a single thread task then execute now
 
                 (*task->m_apply)(task, &single_exec);
 
                 leader_loop = true;
-              }
-              else {
+              } else {
                 leader_loop = false;
               }
-            } while ( leader_loop );
+            } while (leader_loop);
           }
 
           // Team lead either found 0 == m_ready_count or a team task
           // Team lead broadcast acquired task:
 
-          team_exec.team_broadcast( task , 0);
+          team_exec.team_broadcast(task, 0);
 
-          if ( task != no_more_tasks_sentinel ) { // Thread Team Task
+          if (task != no_more_tasks_sentinel) {  // Thread Team Task
 
-            (*task->m_apply)( task , & team_exec );
+            (*task->m_apply)(task, &team_exec);
 
             // The m_apply function performs a barrier
           }
-        } while( task != no_more_tasks_sentinel );
+        } while (task != no_more_tasks_sentinel);
       }
       self.disband_team();
-    } // end pragma omp parallel
+    }  // end pragma omp parallel
   }
 
-  template< typename TaskType >
-  static void
-  get_function_pointer(
-    typename TaskType::function_type& ptr,
-    typename TaskType::destroy_type& dtor
-  ) { 
-    ptr = TaskType::apply;
+  template <typename TaskType>
+  static void get_function_pointer(typename TaskType::function_type& ptr,
+                                   typename TaskType::destroy_type& dtor) {
+    ptr  = TaskType::apply;
     dtor = TaskType::destroy;
   }
 };
 
-extern template class TaskQueue< Kokkos::OpenMP, typename Kokkos::OpenMP::memory_space > ;
+extern template class TaskQueue<Kokkos::OpenMP,
+                                typename Kokkos::OpenMP::memory_space>;
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_OPENMP_TASK_HPP */
-
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Team.hpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Team.hpp
index 38b062bdc02c24fb4701402f448061f0f1492c05..39fd5ae0337c232820cb4df9c59aa1625a554d1f 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Team.hpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_Team.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,350 +46,381 @@
 #define KOKKOS_OPENMP_TEAM_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_OPENMP )
+#if defined(KOKKOS_ENABLE_OPENMP)
 
 #include <OpenMP/Kokkos_OpenMP_Exec.hpp>
 
-namespace Kokkos { namespace Impl {
-
-template< class ... Properties >
-class TeamPolicyInternal< Kokkos::OpenMP, Properties ... >: public PolicyTraits<Properties ...>
-{
-public:
+namespace Kokkos {
+namespace Impl {
 
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
+    : public PolicyTraits<Properties...> {
+ public:
   //! Tag this class as a kokkos execution policy
-  typedef TeamPolicyInternal      execution_policy ;
+  typedef TeamPolicyInternal execution_policy;
 
-  typedef PolicyTraits<Properties ... > traits;
+  typedef PolicyTraits<Properties...> traits;
 
-  TeamPolicyInternal& operator = (const TeamPolicyInternal& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_team_alloc = p.m_team_alloc;
-    m_team_iter = p.m_team_iter;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  TeamPolicyInternal& operator=(const TeamPolicyInternal& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_team_alloc             = p.m_team_alloc;
+    m_team_iter              = p.m_team_iter;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
     return *this;
   }
 
-  template<class ExecSpace, class ... OtherProperties >
+  template <class ExecSpace, class... OtherProperties>
   friend class TeamPolicyInternal;
 
-  template< class ... OtherProperties >
-  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::OpenMP,OtherProperties...>& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_team_alloc = p.m_team_alloc;
-    m_team_iter = p.m_team_iter;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  template <class... OtherProperties>
+  TeamPolicyInternal(
+      const TeamPolicyInternal<Kokkos::OpenMP, OtherProperties...>& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_team_alloc             = p.m_team_alloc;
+    m_team_iter              = p.m_team_iter;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
   }
   //----------------------------------------
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  template< class FunctorType >
-  inline static
-  int team_size_max( const FunctorType & ) {
-    int pool_size = traits::execution_space::thread_pool_size(1);
-    int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-    return pool_size<max_host_team_size?pool_size:max_host_team_size;
+  template <class FunctorType>
+  inline static int team_size_max(const FunctorType&) {
+    int pool_size          = traits::execution_space::thread_pool_size(1);
+    int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
 
-  template< class FunctorType >
-  inline static
-  int team_size_recommended( const FunctorType & )
-  {
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&) {
     return traits::execution_space::thread_pool_size(2);
   }
 
-  template< class FunctorType >
-  inline static
-  int team_size_recommended( const FunctorType &, const int& )
-  {
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&, const int&) {
     return traits::execution_space::thread_pool_size(2);
   }
 #endif
 
-  template<class FunctorType>
-  int team_size_max( const FunctorType&, const ParallelForTag& ) const {
+  template <class FunctorType>
+  int team_size_max(const FunctorType&, const ParallelForTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     int pool_size = traits::execution_space::thread_pool_size(1);
 #else
     int pool_size = traits::execution_space::impl_thread_pool_size(1);
 #endif
-    int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-    return pool_size<max_host_team_size?pool_size:max_host_team_size;
+    int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
-  template<class FunctorType>
-  int team_size_max( const FunctorType&, const ParallelReduceTag& ) const {
+  template <class FunctorType>
+  int team_size_max(const FunctorType&, const ParallelReduceTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     int pool_size = traits::execution_space::thread_pool_size(1);
 #else
     int pool_size = traits::execution_space::impl_thread_pool_size(1);
 #endif
-    int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-    return pool_size<max_host_team_size?pool_size:max_host_team_size;
+    int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType&, const ParallelForTag& ) const {
+  template <class FunctorType, class ReducerType>
+  inline int team_size_max(const FunctorType& f, const ReducerType&,
+                           const ParallelReduceTag& t) const {
+    return team_size_max(f, t);
+  }
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType&, const ParallelForTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     return traits::execution_space::thread_pool_size(2);
 #else
     return traits::execution_space::impl_thread_pool_size(2);
 #endif
   }
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType&, const ParallelReduceTag& ) const {
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType&,
+                            const ParallelReduceTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     return traits::execution_space::thread_pool_size(2);
 #else
     return traits::execution_space::impl_thread_pool_size(2);
 #endif
   }
+  template <class FunctorType, class ReducerType>
+  inline int team_size_recommended(const FunctorType& f, const ReducerType&,
+                                   const ParallelReduceTag& t) const {
+    return team_size_recommended(f, t);
+  }
 
+  inline static int vector_length_max() {
+    return 1024;
+  }  // Use arbitrary large number, is meant as a vectorizable length
 
-  inline static
-  int vector_length_max()
-    { return 1024; } // Use arbitrary large number, is meant as a vectorizable length
-
-  inline static
-  int scratch_size_max(int level)
-    { return (level==0?
-        1024*32: // Roughly L1 size
-        20*1024*1024); // Limit to keep compatibility with CUDA
-    }
+  inline static int scratch_size_max(int level) {
+    return (level == 0 ? 1024 * 32 :  // Roughly L1 size
+                20 * 1024 * 1024);    // Limit to keep compatibility with CUDA
+  }
 
   //----------------------------------------
 
-private:
-
-  int m_league_size ;
-  int m_team_size ;
-  int m_team_alloc ;
-  int m_team_iter ;
+ private:
+  int m_league_size;
+  int m_team_size;
+  int m_team_alloc;
+  int m_team_iter;
 
   size_t m_team_scratch_size[2];
   size_t m_thread_scratch_size[2];
 
   int m_chunk_size;
 
-  inline void init( const int league_size_request
-                  , const int team_size_request )
-    {
+  inline void init(const int league_size_request, const int team_size_request) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int pool_size  = traits::execution_space::thread_pool_size(0);
-      const int team_grain = traits::execution_space::thread_pool_size(2);
+    const int pool_size  = traits::execution_space::thread_pool_size(0);
+    const int team_grain = traits::execution_space::thread_pool_size(2);
 #else
-      const int pool_size  = traits::execution_space::impl_thread_pool_size(0);
-      const int team_grain = traits::execution_space::impl_thread_pool_size(2);
+    const int pool_size  = traits::execution_space::impl_thread_pool_size(0);
+    const int team_grain = traits::execution_space::impl_thread_pool_size(2);
 #endif
-      const int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-      const int team_max   = ((pool_size < max_host_team_size) ? pool_size : max_host_team_size);
+    const int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    const int team_max =
+        ((pool_size < max_host_team_size) ? pool_size : max_host_team_size);
 
-      m_league_size = league_size_request ;
+    m_league_size = league_size_request;
 
-      #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-      if(team_size_request > team_max) Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
-      #endif
-      m_team_size = team_size_request < team_max ?
-                    team_size_request : team_max ;
-
-      // Round team size up to a multiple of 'team_gain'
-      const int team_size_grain = team_grain * ( ( m_team_size + team_grain - 1 ) / team_grain );
-      const int team_count      = pool_size / team_size_grain ;
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE
+    if (team_size_request > team_max)
+      Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
+#endif
+    m_team_size = team_size_request < team_max ? team_size_request : team_max;
 
-      // Constraint : pool_size = m_team_alloc * team_count
-      m_team_alloc = pool_size / team_count ;
+    // Round team size up to a multiple of 'team_gain'
+    const int team_size_grain =
+        team_grain * ((m_team_size + team_grain - 1) / team_grain);
+    const int team_count = pool_size / team_size_grain;
 
-      // Maxumum number of iterations each team will take:
-      m_team_iter  = ( m_league_size + team_count - 1 ) / team_count ;
+    // Constraint : pool_size = m_team_alloc * team_count
+    m_team_alloc = pool_size / team_count;
 
-      set_auto_chunk_size();
-    }
+    // Maxumum number of iterations each team will take:
+    m_team_iter = (m_league_size + team_count - 1) / team_count;
 
-public:
+    set_auto_chunk_size();
+  }
 
-  inline int team_size()   const { return m_team_size ; }
-  inline int league_size() const { return m_league_size ; }
+ public:
+  inline int team_size() const { return m_team_size; }
+  inline int league_size() const { return m_league_size; }
 
   inline size_t scratch_size(const int& level, int team_size_ = -1) const {
-    if(team_size_ < 0) team_size_ = m_team_size;
-    return m_team_scratch_size[level] + team_size_*m_thread_scratch_size[level] ;
+    if (team_size_ < 0) team_size_ = m_team_size;
+    return m_team_scratch_size[level] +
+           team_size_ * m_thread_scratch_size[level];
   }
 
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal( const typename traits::execution_space &
-            , int league_size_request
-            , int team_size_request
-            , int /* vector_length_request */ = 1 )
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
-    { init( league_size_request , team_size_request ); }
-
-  TeamPolicyInternal( const typename traits::execution_space &
-            , int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int /* vector_length_request */ = 1)
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request, int team_size_request,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+  }
+
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    { init( league_size_request , traits::execution_space::thread_pool_size(2) ); }
+  {
+    init(league_size_request, traits::execution_space::thread_pool_size(2));
+  }
 #else
-    { init( league_size_request , traits::execution_space::impl_thread_pool_size(2) ); }
+  {
+    init(league_size_request,
+         traits::execution_space::impl_thread_pool_size(2));
+  }
 #endif
 
-  TeamPolicyInternal( int league_size_request
-            , int team_size_request
-            , int /* vector_length_request */ = 1 )
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
-    { init( league_size_request , team_size_request ); }
-
-  TeamPolicyInternal( int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int /* vector_length_request */ = 1 )
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
-  {
-    init( league_size_request ,
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+  }
+
+  TeamPolicyInternal(int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request,
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-        traits::execution_space::thread_pool_size(2)
+         traits::execution_space::thread_pool_size(2)
 #else
-        traits::execution_space::impl_thread_pool_size(2)
+         traits::execution_space::impl_thread_pool_size(2)
 #endif
-        );
+    );
   }
 
-  inline int team_alloc() const { return m_team_alloc ; }
-  inline int team_iter()  const { return m_team_iter ; }
+  inline int team_alloc() const { return m_team_alloc; }
+  inline int team_iter() const { return m_team_iter; }
 
-  inline int chunk_size() const { return m_chunk_size ; }
+  inline int chunk_size() const { return m_chunk_size; }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal set_chunk_size(typename traits::index_type chunk_size_) const {
+  inline TeamPolicyInternal set_chunk_size(
+      typename traits::index_type chunk_size_) const {
     TeamPolicyInternal p = *this;
-    p.m_chunk_size = chunk_size_;
+    p.m_chunk_size       = chunk_size_;
     return p;
   }
 
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team) const {
-    TeamPolicyInternal p = *this;
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team) const {
+    TeamPolicyInternal p         = *this;
     p.m_team_scratch_size[level] = per_team.value;
     return p;
   }
 
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
-    p.m_team_scratch_size[level] = per_team.value;
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
+    p.m_team_scratch_size[level]   = per_team.value;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 #else
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal& set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal& set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(const int& level,
+                                              const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
     m_team_scratch_size[level] = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-protected:
+ protected:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal internal_set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal internal_set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-private:
+ private:
   /** \brief finalize chunk_size if it was set to AUTO*/
   inline void set_auto_chunk_size() {
-
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    int concurrency = traits::execution_space::thread_pool_size(0)/m_team_alloc;
+    int concurrency =
+        traits::execution_space::thread_pool_size(0) / m_team_alloc;
 #else
-    int concurrency = traits::execution_space::impl_thread_pool_size(0)/m_team_alloc;
+    int concurrency =
+        traits::execution_space::impl_thread_pool_size(0) / m_team_alloc;
 #endif
-    if( concurrency==0 ) concurrency=1;
+    if (concurrency == 0) concurrency = 1;
 
-    if(m_chunk_size > 0) {
-      if(!Impl::is_integral_power_of_two( m_chunk_size ))
-        Kokkos::abort("TeamPolicy blocking granularity must be power of two" );
+    if (m_chunk_size > 0) {
+      if (!Impl::is_integral_power_of_two(m_chunk_size))
+        Kokkos::abort("TeamPolicy blocking granularity must be power of two");
     }
 
     int new_chunk_size = 1;
-    while(new_chunk_size*100*concurrency < m_league_size)
+    while (new_chunk_size * 100 * concurrency < m_league_size)
       new_chunk_size *= 2;
-    if(new_chunk_size < 128) {
+    if (new_chunk_size < 128) {
       new_chunk_size = 1;
-      while( (new_chunk_size*40*concurrency < m_league_size ) && (new_chunk_size<128) )
-        new_chunk_size*=2;
+      while ((new_chunk_size * 40 * concurrency < m_league_size) &&
+             (new_chunk_size < 128))
+        new_chunk_size *= 2;
     }
     m_chunk_size = new_chunk_size;
   }
 
-public:
-  typedef Impl::HostThreadTeamMember< Kokkos::OpenMP > member_type ;
+ public:
+  typedef Impl::HostThreadTeamMember<Kokkos::OpenMP> member_type;
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
 #endif /* KOKKOS_OPENMP_TEAM_HPP */
-
-
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIAvail.hpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIAvail.hpp
index 2663b99dfbbfe1ffac46dd7afb7691d7fb3e5305..7bcd515f4cf102d063dd9d03b81548d758899f0c 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIAvail.hpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIAvail.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::OpenMP
 
-#include<eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIDecl.hpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIDecl.hpp
index 960fb138f4aef30442b379ffd1a617d371a2bfe2..b5254e1275fe6b5e4f71ddc8df0c49547a408083 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIDecl.hpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_ViewCopyETIDecl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::OpenMP
 
-#include<eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp
index 0742575cb8ce0346c662ae1e270da463d0349178..4ff1486c682a4d8fe6686e9e306f91477bd1c4bd 100644
--- a/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp
+++ b/lib/kokkos/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,63 +48,54 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType ,
-                   Kokkos::WorkGraphPolicy< Traits ... > ,
-                   Kokkos::OpenMP
-                 >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
+                  Kokkos::OpenMP> {
+ private:
+  typedef Kokkos::WorkGraphPolicy<Traits...> Policy;
 
-  typedef Kokkos::WorkGraphPolicy< Traits ... > Policy ;
+  Policy m_policy;
+  FunctorType m_functor;
 
-  Policy       m_policy ;
-  FunctorType  m_functor ;
-
-  template< class TagType >
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { m_functor( w ); }
-
-  template< class TagType >
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { const TagType t{} ; m_functor( t , w ); }
+  template <class TagType>
+  typename std::enable_if<std::is_same<TagType, void>::value>::type exec_one(
+      const std::int32_t w) const noexcept {
+    m_functor(w);
+  }
 
-public:
+  template <class TagType>
+  typename std::enable_if<!std::is_same<TagType, void>::value>::type exec_one(
+      const std::int32_t w) const noexcept {
+    const TagType t{};
+    m_functor(t, w);
+  }
 
-  inline
-  void execute()
-  {
+ public:
+  inline void execute() {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    #pragma omp parallel num_threads(OpenMP::thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::thread_pool_size())
 #else
-    #pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
+#pragma omp parallel num_threads(OpenMP::impl_thread_pool_size())
 #endif
     {
       // Spin until COMPLETED_TOKEN.
       // END_TOKEN indicates no work is currently available.
 
-      for ( std::int32_t w = Policy::END_TOKEN ;
-            Policy::COMPLETED_TOKEN != ( w = m_policy.pop_work() ) ; ) {
-        if ( Policy::END_TOKEN != w ) {
-          exec_one< typename Policy::work_tag >( w );
+      for (std::int32_t w = Policy::END_TOKEN;
+           Policy::COMPLETED_TOKEN != (w = m_policy.pop_work());) {
+        if (Policy::END_TOKEN != w) {
+          exec_one<typename Policy::work_tag>(w);
           m_policy.completed_work(w);
         }
       }
     }
   }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_policy( arg_policy )
-    , m_functor( arg_functor )
-  {}
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_policy(arg_policy), m_functor(arg_functor) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #define KOKKOS_OPENMP_WORKGRAPHPOLICY_HPP */
-
diff --git a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
index c7d4defad2c56961cc468655d6a1f217f4f33720..2dd038dce72359546565a938967a5bf71d3330be 100644
--- a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
+++ b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -62,36 +63,30 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
 namespace Kokkos {
 namespace Experimental {
 /* Default allocation mechanism */
-OpenMPTargetSpace::OpenMPTargetSpace()
-{}
+OpenMPTargetSpace::OpenMPTargetSpace() {}
+
+void *OpenMPTargetSpace::allocate(const size_t arg_alloc_size) const {
+  static_assert(sizeof(void *) == sizeof(uintptr_t),
+                "Error sizeof(void*) != sizeof(uintptr_t)");
 
-void * OpenMPTargetSpace::allocate( const size_t arg_alloc_size ) const
-{
-  static_assert( sizeof(void*) == sizeof(uintptr_t)
-               , "Error sizeof(void*) != sizeof(uintptr_t)" );
+  void *ptr;
 
-  void * ptr;
-  
-  ptr = omp_target_alloc( arg_alloc_size, omp_get_default_device());
+  ptr = omp_target_alloc(arg_alloc_size, omp_get_default_device());
 
   return ptr;
 }
 
-
-void OpenMPTargetSpace::deallocate( void * const arg_alloc_ptr , const size_t arg_alloc_size ) const
-{
-  if ( arg_alloc_ptr ) {
-
-      omp_target_free( arg_alloc_ptr , omp_get_default_device() );
-
+void OpenMPTargetSpace::deallocate(void *const arg_alloc_ptr,
+                                   const size_t arg_alloc_size) const {
+  if (arg_alloc_ptr) {
+    omp_target_free(arg_alloc_ptr, omp_get_default_device());
   }
 }
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -100,146 +95,145 @@ namespace Kokkos {
 namespace Impl {
 
 #ifdef KOKKOS_DEBUG
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void> SharedAllocationRecord<
+    Kokkos::Experimental::OpenMPTargetSpace, void>::s_root_record;
 #endif
 
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-~SharedAllocationRecord()
-{
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
+SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
+                       void>::~SharedAllocationRecord() {
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
 }
 
-//TODO: Implement deep copy back see CudaSpace 
-std::string
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::get_label() const {
+// TODO: Implement deep copy back see CudaSpace
+std::string SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
+                                   void>::get_label() const {
   return std::string("OpenMPTargetAllocation");
 }
 
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >* 
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-allocate( const Kokkos::Experimental::OpenMPTargetSpace & arg_space,
-          const std::string               & arg_label ,
-          const size_t                      arg_alloc_size) {
-  return new SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >(arg_space,arg_label,arg_alloc_size);
+SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void> *
+SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>::allocate(
+    const Kokkos::Experimental::OpenMPTargetSpace &arg_space,
+    const std::string &arg_label, const size_t arg_alloc_size) {
+  return new SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
+                                    void>(arg_space, arg_label, arg_alloc_size);
 }
 
-void
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-deallocate( SharedAllocationRecord<void, void> * arg_rec )
-{
-  delete static_cast<SharedAllocationRecord*>(arg_rec);
+void SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
+                            void>::deallocate(SharedAllocationRecord<void, void>
+                                                  *arg_rec) {
+  delete static_cast<SharedAllocationRecord *>(arg_rec);
 }
 
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-SharedAllocationRecord( const Kokkos::Experimental::OpenMPTargetSpace & arg_space
-                      , const std::string       & arg_label
-                      , const size_t              arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>::
+    SharedAllocationRecord(
+        const Kokkos::Experimental::OpenMPTargetSpace &arg_space,
+        const std::string &arg_label, const size_t arg_alloc_size,
+        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-        & SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
+                                  void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_space( arg_space )
-{
+          reinterpret_cast<SharedAllocationHeader *>(arg_space.allocate(
+              sizeof(SharedAllocationHeader) + arg_alloc_size)),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_space(arg_space) {
   SharedAllocationHeader header;
 
-  header.m_record = static_cast< SharedAllocationRecord< void , void > * >( this );
+  header.m_record = static_cast<SharedAllocationRecord<void, void> *>(this);
 
-  strncpy( header.m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(header.m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
   // Set last element zero, in case c_str is too long
-  header.m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0; 
-  //TODO DeepCopy
+  header.m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
+  // TODO DeepCopy
   // DeepCopy
-
 }
 
 //----------------------------------------------------------------------------
 
-void * SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-allocate_tracked( const Kokkos::Experimental::OpenMPTargetSpace & arg_space
-                , const std::string & arg_alloc_label 
-                , const size_t arg_alloc_size )
-{
-  if ( ! arg_alloc_size ) return (void *) 0 ;
+void *SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>::
+    allocate_tracked(const Kokkos::Experimental::OpenMPTargetSpace &arg_space,
+                     const std::string &arg_alloc_label,
+                     const size_t arg_alloc_size) {
+  if (!arg_alloc_size) return (void *)0;
 
-  SharedAllocationRecord * const r =
-    allocate( arg_space , arg_alloc_label , arg_alloc_size );
+  SharedAllocationRecord *const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
 
-  RecordBase::increment( r );
+  RecordBase::increment(r);
 
   return r->data();
 }
 
-void SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-deallocate_tracked( void * const arg_alloc_ptr )
-{
-  if ( arg_alloc_ptr != 0 ) {
-    SharedAllocationRecord * const r = get_record( arg_alloc_ptr );
+void SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
+                            void>::deallocate_tracked(void *const
+                                                          arg_alloc_ptr) {
+  if (arg_alloc_ptr != 0) {
+    SharedAllocationRecord *const r = get_record(arg_alloc_ptr);
 
-    RecordBase::decrement( r );
+    RecordBase::decrement(r);
   }
 }
 
-void * SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-reallocate_tracked( void * const arg_alloc_ptr
-                  , const size_t arg_alloc_size )
-{
-  SharedAllocationRecord * const r_old = get_record( arg_alloc_ptr );
-  SharedAllocationRecord * const r_new = allocate( r_old->m_space , r_old->get_label() , arg_alloc_size );
+void *SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>::
+    reallocate_tracked(void *const arg_alloc_ptr, const size_t arg_alloc_size) {
+  SharedAllocationRecord *const r_old = get_record(arg_alloc_ptr);
+  SharedAllocationRecord *const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
 
-  //Kokkos::Impl::DeepCopy<OpenMPTargetSpace,OpenMPTargetSpace>( r_new->data() , r_old->data()
-  //                                           , std::min( r_old->size() , r_new->size() ) );
+  // Kokkos::Impl::DeepCopy<OpenMPTargetSpace,OpenMPTargetSpace>( r_new->data()
+  // , r_old->data()
+  //                                           , std::min( r_old->size() ,
+  //                                           r_new->size() ) );
 
-  RecordBase::increment( r_new );
-  RecordBase::decrement( r_old );
+  RecordBase::increment(r_new);
+  RecordBase::decrement(r_old);
 
   return r_new->data();
 }
 
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void > *
-SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::get_record( void * alloc_ptr )
-{
-  typedef SharedAllocationHeader  Header ;
-  typedef SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >  RecordHost ;
-
-  SharedAllocationHeader const * const head   = alloc_ptr ? Header::get_header( alloc_ptr ) : (SharedAllocationHeader *)0 ;
-  RecordHost                   * const record = head ? static_cast< RecordHost * >( head->m_record ) : (RecordHost *) 0 ;
-
-  if ( ! alloc_ptr || record->m_alloc_ptr != head ) {
-    Kokkos::Impl::throw_runtime_exception( std::string("Kokkos::Experimental::Impl::SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::get_record ERROR" ) );
+SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>
+    *SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
+                            void>::get_record(void *alloc_ptr) {
+  typedef SharedAllocationHeader Header;
+  typedef SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>
+      RecordHost;
+
+  SharedAllocationHeader const *const head =
+      alloc_ptr ? Header::get_header(alloc_ptr) : (SharedAllocationHeader *)0;
+  RecordHost *const record =
+      head ? static_cast<RecordHost *>(head->m_record) : (RecordHost *)0;
+
+  if (!alloc_ptr || record->m_alloc_ptr != head) {
+    Kokkos::Impl::throw_runtime_exception(std::string(
+        "Kokkos::Experimental::Impl::SharedAllocationRecord< "
+        "Kokkos::Experimental::OpenMPTargetSpace , void >::get_record ERROR"));
   }
 
-  return record ;
+  return record;
 }
 
 // Iterate records to print orphaned memory ...
-void SharedAllocationRecord< Kokkos::Experimental::OpenMPTargetSpace , void >::
-print_records( std::ostream & s , const Kokkos::Experimental::OpenMPTargetSpace & space , bool detail )
-{
+void SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>::
+    print_records(std::ostream &s,
+                  const Kokkos::Experimental::OpenMPTargetSpace &space,
+                  bool detail) {
 #ifdef KOKKOS_DEBUG
-  SharedAllocationRecord< void , void >::print_host_accessible_records( s , "OpenMPTargetSpace" , & s_root_record , detail );
+  SharedAllocationRecord<void, void>::print_host_accessible_records(
+      s, "OpenMPTargetSpace", &s_root_record, detail);
 #else
-  throw_runtime_exception("SharedAllocationRecord<OpenMPTargetSpace>::print_records"
+  throw_runtime_exception(
+      "SharedAllocationRecord<OpenMPTargetSpace>::print_records"
       " only works with KOKKOS_DEBUG enabled");
 #endif
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -247,41 +241,35 @@ print_records( std::ostream & s , const Kokkos::Experimental::OpenMPTargetSpace
 namespace Kokkos {
 namespace Impl {
 
-template< class >
-struct ViewOperatorBoundsErrorAbort ;
-
-template<>
-struct ViewOperatorBoundsErrorAbort< Kokkos::Experimental::OpenMPTargetSpace > {
- static void apply( const size_t rank
-                  , const size_t n0 , const size_t n1
-                  , const size_t n2 , const size_t n3
-                  , const size_t n4 , const size_t n5
-                  , const size_t n6 , const size_t n7
-                  , const size_t i0 , const size_t i1
-                  , const size_t i2 , const size_t i3
-                  , const size_t i4 , const size_t i5
-                  , const size_t i6 , const size_t i7 );
+template <class>
+struct ViewOperatorBoundsErrorAbort;
+
+template <>
+struct ViewOperatorBoundsErrorAbort<Kokkos::Experimental::OpenMPTargetSpace> {
+  static void apply(const size_t rank, const size_t n0, const size_t n1,
+                    const size_t n2, const size_t n3, const size_t n4,
+                    const size_t n5, const size_t n6, const size_t n7,
+                    const size_t i0, const size_t i1, const size_t i2,
+                    const size_t i3, const size_t i4, const size_t i5,
+                    const size_t i6, const size_t i7);
 };
 
-void ViewOperatorBoundsErrorAbort< Kokkos::Experimental::OpenMPTargetSpace >::
-apply( const size_t rank
-     , const size_t n0 , const size_t n1
-     , const size_t n2 , const size_t n3
-     , const size_t n4 , const size_t n5
-     , const size_t n6 , const size_t n7
-     , const size_t i0 , const size_t i1
-     , const size_t i2 , const size_t i3
-     , const size_t i4 , const size_t i5
-     , const size_t i6 , const size_t i7 )
-{
-  printf( "View operator bounds error : rank(%lu) dim(%lu,%lu,%lu,%lu,%lu,%lu,%lu,%lu) index(%lu,%lu,%lu,%lu,%lu,%lu,%lu,%lu)"
-          , rank , n0 , n1 , n2 , n3 , n4 , n5 , n6 , n7
-                 , i0 , i1 , i2 , i3 , i4 , i5 , i6 , i7 );
-  //Kokkos::Impl::throw_runtime_exception( buffer );
+void ViewOperatorBoundsErrorAbort<Kokkos::Experimental::OpenMPTargetSpace>::
+    apply(const size_t rank, const size_t n0, const size_t n1, const size_t n2,
+          const size_t n3, const size_t n4, const size_t n5, const size_t n6,
+          const size_t n7, const size_t i0, const size_t i1, const size_t i2,
+          const size_t i3, const size_t i4, const size_t i5, const size_t i6,
+          const size_t i7) {
+  printf(
+      "View operator bounds error : rank(%lu) "
+      "dim(%lu,%lu,%lu,%lu,%lu,%lu,%lu,%lu) "
+      "index(%lu,%lu,%lu,%lu,%lu,%lu,%lu,%lu)",
+      rank, n0, n1, n2, n3, n4, n5, n6, n7, i0, i1, i2, i3, i4, i5, i6, i7);
+  // Kokkos::Impl::throw_runtime_exception( buffer );
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -303,14 +291,14 @@ void init_lock_array_host_space() {
 
 bool lock_address_host_space(void* ptr) {
   return 0 == atomic_compare_exchange( &HOST_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^ HOST_SPACE_ATOMIC_XOR_MASK] ,
-                                  0 , 1);
+      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^
+HOST_SPACE_ATOMIC_XOR_MASK] , 0 , 1);
 }
 
 void unlock_address_host_space(void* ptr) {
    atomic_exchange( &HOST_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^ HOST_SPACE_ATOMIC_XOR_MASK] ,
-                    0);
+      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^
+HOST_SPACE_ATOMIC_XOR_MASK] , 0);
 }
 
 }
diff --git a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
index 2fa2f1382cae6576f910cea00817a4f77cea0746..140a4cb88ec2a767a483da03b7df6d6ddebc4fbd 100644
--- a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
+++ b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -60,13 +61,13 @@ namespace {
 KOKKOS_INLINE_FUNCTION
 int kokkos_omp_in_parallel();
 
-int kokkos_omp_in_critical_region = ( Kokkos::HostSpace::register_in_parallel( kokkos_omp_in_parallel ) , 0 );
+int kokkos_omp_in_critical_region =
+    (Kokkos::HostSpace::register_in_parallel(kokkos_omp_in_parallel), 0);
 
 KOKKOS_INLINE_FUNCTION
-int kokkos_omp_in_parallel()
-{
+int kokkos_omp_in_parallel() {
 #ifndef __CUDA_ARCH__
-  return omp_in_parallel() && ! kokkos_omp_in_critical_region ;
+  return omp_in_parallel() && !kokkos_omp_in_critical_region;
 #else
   return 0;
 #endif
@@ -74,84 +75,81 @@ int kokkos_omp_in_parallel()
 
 bool s_using_hwloc = false;
 
-} // namespace
-} // namespace Impl
-} // namespace Kokkos
-
+}  // namespace
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Experimental {
 bool OpenMPTarget::m_is_initialized = false;
 }
-}
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 
+// int OpenMPTargetExec::m_map_rank[ OpenMPTargetExec::MAX_THREAD_COUNT ] = { 0
+// };
 
-//int OpenMPTargetExec::m_map_rank[ OpenMPTargetExec::MAX_THREAD_COUNT ] = { 0 };
-
-//int OpenMPTargetExec::m_pool_topo[ 4 ] = { 0 };
+// int OpenMPTargetExec::m_pool_topo[ 4 ] = { 0 };
 
-//OpenMPTargetExec * OpenMPTargetExec::m_pool[ OpenMPTargetExec::MAX_THREAD_COUNT ] = { 0 };
+// OpenMPTargetExec * OpenMPTargetExec::m_pool[
+// OpenMPTargetExec::MAX_THREAD_COUNT ] = { 0 };
 
-void OpenMPTargetExec::verify_is_process( const char * const label )
-{
-  if ( omp_in_parallel() ) {
-    std::string msg( label );
-    msg.append( " ERROR: in parallel" );
-    Kokkos::Impl::throw_runtime_exception( msg );
+void OpenMPTargetExec::verify_is_process(const char* const label) {
+  if (omp_in_parallel()) {
+    std::string msg(label);
+    msg.append(" ERROR: in parallel");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
 }
 
-void OpenMPTargetExec::verify_initialized( const char * const label )
-{
-  if ( 0 == Kokkos::Experimental::OpenMPTarget::is_initialized() ) {
-    std::string msg( label );
-    msg.append( " ERROR: not initialized" );
-    Kokkos::Impl::throw_runtime_exception( msg );
+void OpenMPTargetExec::verify_initialized(const char* const label) {
+  if (0 == Kokkos::Experimental::OpenMPTarget::is_initialized()) {
+    std::string msg(label);
+    msg.append(" ERROR: not initialized");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
 
-  if ( omp_get_max_threads() != Kokkos::Experimental::OpenMPTarget::thread_pool_size(0) ) {
-    std::string msg( label );
-    msg.append( " ERROR: Initialized but threads modified inappropriately" );
-    Kokkos::Impl::throw_runtime_exception( msg );
+  if (omp_get_max_threads() !=
+      Kokkos::Experimental::OpenMPTarget::thread_pool_size(0)) {
+    std::string msg(label);
+    msg.append(" ERROR: Initialized but threads modified inappropriately");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
-
 }
 
-void*    OpenMPTargetExec::m_scratch_ptr  = NULL;
+void* OpenMPTargetExec::m_scratch_ptr    = NULL;
 int64_t OpenMPTargetExec::m_scratch_size = 0;
 
-void OpenMPTargetExec::clear_scratch()
-{
+void OpenMPTargetExec::clear_scratch() {
   Kokkos::Experimental::OpenMPTargetSpace space;
-  space.deallocate(m_scratch_ptr,m_scratch_size);
-  m_scratch_ptr = NULL;
+  space.deallocate(m_scratch_ptr, m_scratch_size);
+  m_scratch_ptr  = NULL;
   m_scratch_size = NULL;
 }
 
 void* OpenMPTargetExec::get_scratch_ptr() { return m_scratch_ptr; }
 
-void OpenMPTargetExec::resize_scratch( int64_t reduce_bytes , 
-                                       int64_t team_reduce_bytes, 
-                                       int64_t team_shared_bytes, int64_t thread_local_bytes) 
-{
+void OpenMPTargetExec::resize_scratch(int64_t reduce_bytes,
+                                      int64_t team_reduce_bytes,
+                                      int64_t team_shared_bytes,
+                                      int64_t thread_local_bytes) {
   Kokkos::Experimental::OpenMPTargetSpace space;
-  uint64_t total_size = MAX_ACTIVE_TEAMS * reduce_bytes +            // Inter Team Reduction  
-                        MAX_ACTIVE_TEAMS * team_reduce_bytes  +    // Intra Team Reduction
-                        MAX_ACTIVE_TEAMS * team_shared_bytes +       // Team Local Scratch
-                        MAX_ACTIVE_THREADS * thread_local_bytes;     // Thread Private Scratch
-
-  if( total_size > m_scratch_size ) {
-    space.deallocate(m_scratch_ptr,m_scratch_size);
+  uint64_t total_size =
+      MAX_ACTIVE_TEAMS * reduce_bytes +         // Inter Team Reduction
+      MAX_ACTIVE_TEAMS * team_reduce_bytes +    // Intra Team Reduction
+      MAX_ACTIVE_TEAMS * team_shared_bytes +    // Team Local Scratch
+      MAX_ACTIVE_THREADS * thread_local_bytes;  // Thread Private Scratch
+
+  if (total_size > m_scratch_size) {
+    space.deallocate(m_scratch_ptr, m_scratch_size);
     m_scratch_size = total_size;
-    m_scratch_ptr = space.allocate(total_size);
+    m_scratch_ptr  = space.allocate(total_size);
   }
-
 }
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -160,114 +158,115 @@ namespace Kokkos {
 namespace Experimental {
 //----------------------------------------------------------------------------
 
-int OpenMPTarget::is_initialized()
-{ return m_is_initialized; }// != Impl::OpenMPTargetExec::m_pool[0]; }
+int OpenMPTarget::is_initialized() {
+  return m_is_initialized;
+}  // != Impl::OpenMPTargetExec::m_pool[0]; }
 
-void OpenMPTarget::initialize( unsigned thread_count ,
-                         unsigned use_numa_count ,
-                         unsigned use_cores_per_numa )
-{
+void OpenMPTarget::initialize(unsigned thread_count, unsigned use_numa_count,
+                              unsigned use_cores_per_numa) {
   // Before any other call to OMP query the maximum number of threads
   // and save the value for re-initialization unit testing.
 
-
   // Init the array for used for arbitrarily sized atomics
   Kokkos::Impl::init_lock_array_host_space();
 
-  #ifdef KOKKOS_ENABLE_PROFILING
-    Kokkos::Profiling::initialize();
-  #endif
+#ifdef KOKKOS_ENABLE_PROFILING
+  Kokkos::Profiling::initialize();
+#endif
   m_is_initialized = true;
 }
 
 //----------------------------------------------------------------------------
 
-void OpenMPTarget::finalize()
-{
-  Kokkos::Impl::OpenMPTargetExec::verify_initialized( "OpenMPTarget::finalize" );
-  Kokkos::Impl::OpenMPTargetExec::verify_is_process( "OpenMPTarget::finalize" );
+void OpenMPTarget::finalize() {
+  Kokkos::Impl::OpenMPTargetExec::verify_initialized("OpenMPTarget::finalize");
+  Kokkos::Impl::OpenMPTargetExec::verify_is_process("OpenMPTarget::finalize");
 
   m_is_initialized = false;
 
   omp_set_num_threads(1);
 
-  if ( Kokkos::Impl::s_using_hwloc && Kokkos::hwloc::can_bind_threads() ) {
+  if (Kokkos::Impl::s_using_hwloc && Kokkos::hwloc::can_bind_threads()) {
     hwloc::unbind_this_thread();
   }
 
-  #ifdef KOKKOS_ENABLE_PROFILING
-    Kokkos::Profiling::finalize();
-  #endif
+#ifdef KOKKOS_ENABLE_PROFILING
+  Kokkos::Profiling::finalize();
+#endif
 }
 
 //----------------------------------------------------------------------------
 
-void OpenMPTarget::print_configuration( std::ostream & s , const bool detail )
-{
-  Kokkos::Impl::OpenMPTargetExec::verify_is_process( "OpenMPTarget::print_configuration" );
-/*
-  s << "Kokkos::Experimental::OpenMPTarget" ;
+void OpenMPTarget::print_configuration(std::ostream& s, const bool detail) {
+  Kokkos::Impl::OpenMPTargetExec::verify_is_process(
+      "OpenMPTarget::print_configuration");
+  /*
+    s << "Kokkos::Experimental::OpenMPTarget" ;
 
-#if defined( KOKKOS_ENABLE_OPENMPTARGET )
-  s << " KOKKOS_ENABLE_OPENMPTARGET" ;
-#endif
-#if defined( KOKKOS_ENABLE_HWLOC )
+  #if defined( KOKKOS_ENABLE_OPENMPTARGET )
+    s << " KOKKOS_ENABLE_OPENMPTARGET" ;
+  #endif
+  #if defined( KOKKOS_ENABLE_HWLOC )
 
-  const unsigned numa_count_       = Kokkos::hwloc::get_available_numa_count();
-  const unsigned cores_per_numa   = Kokkos::hwloc::get_available_cores_per_numa();
-  const unsigned threads_per_core = Kokkos::hwloc::get_available_threads_per_core();
+    const unsigned numa_count_       =
+  Kokkos::hwloc::get_available_numa_count(); const unsigned cores_per_numa   =
+  Kokkos::hwloc::get_available_cores_per_numa(); const unsigned threads_per_core
+  = Kokkos::hwloc::get_available_threads_per_core();
 
-  s << " hwloc[" << numa_count_ << "x" << cores_per_numa << "x" << threads_per_core << "]"
-    << " hwloc_binding_" << ( Impl::s_using_hwloc ? "enabled" : "disabled" )
-    ;
-#endif
+    s << " hwloc[" << numa_count_ << "x" << cores_per_numa << "x" <<
+  threads_per_core << "]"
+      << " hwloc_binding_" << ( Impl::s_using_hwloc ? "enabled" : "disabled" )
+      ;
+  #endif
 
-  const bool is_initialized = 0 != Impl::OpenMPTargetExec::m_pool[0] ;
+    const bool is_initialized = 0 != Impl::OpenMPTargetExec::m_pool[0] ;
 
-  if ( is_initialized ) {
-    const int numa_count      = Kokkos::Impl::OpenMPTargetExec::m_pool_topo[0] / Kokkos::Impl::OpenMPTargetExec::m_pool_topo[1] ;
-    const int core_per_numa   = Kokkos::Impl::OpenMPTargetExec::m_pool_topo[1] / Kokkos::Impl::OpenMPTargetExec::m_pool_topo[2] ;
-    const int thread_per_core = Kokkos::Impl::OpenMPTargetExec::m_pool_topo[2] ;
+    if ( is_initialized ) {
+      const int numa_count      = Kokkos::Impl::OpenMPTargetExec::m_pool_topo[0]
+  / Kokkos::Impl::OpenMPTargetExec::m_pool_topo[1] ; const int core_per_numa   =
+  Kokkos::Impl::OpenMPTargetExec::m_pool_topo[1] /
+  Kokkos::Impl::OpenMPTargetExec::m_pool_topo[2] ; const int thread_per_core =
+  Kokkos::Impl::OpenMPTargetExec::m_pool_topo[2] ;
 
-    s << " thread_pool_topology[ " << numa_count
-      << " x " << core_per_numa
-      << " x " << thread_per_core
-      << " ]"
-      << std::endl ;
+      s << " thread_pool_topology[ " << numa_count
+        << " x " << core_per_numa
+        << " x " << thread_per_core
+        << " ]"
+        << std::endl ;
 
-    if ( detail ) {
-      std::vector< std::pair<unsigned,unsigned> > coord( Kokkos::Impl::OpenMPTargetExec::m_pool_topo[0] );
+      if ( detail ) {
+        std::vector< std::pair<unsigned,unsigned> > coord(
+  Kokkos::Impl::OpenMPTargetExec::m_pool_topo[0] );
 
-#pragma omp parallel
-      {
-#pragma omp critical
+  #pragma omp parallel
         {
-          coord[ omp_get_thread_num() ] = hwloc::get_this_thread_coordinate();
+  #pragma omp critical
+          {
+            coord[ omp_get_thread_num() ] = hwloc::get_this_thread_coordinate();
+          }
+  // END #pragma omp critical
+        }
+  // END #pragma omp parallel
+
+        for ( unsigned i = 0 ; i < coord.size() ; ++i ) {
+          s << "  thread omp_rank[" << i << "]"
+            << " kokkos_rank[" << Impl::OpenMPTargetExec::m_map_rank[ i ] << "]"
+            << " hwloc_coord[" << coord[i].first << "." << coord[i].second <<
+  "]"
+            << std::endl ;
         }
-// END #pragma omp critical 
-      }
-// END #pragma omp parallel 
-
-      for ( unsigned i = 0 ; i < coord.size() ; ++i ) {
-        s << "  thread omp_rank[" << i << "]"
-          << " kokkos_rank[" << Impl::OpenMPTargetExec::m_map_rank[ i ] << "]"
-          << " hwloc_coord[" << coord[i].first << "." << coord[i].second << "]"
-          << std::endl ;
       }
     }
-  }
-  else {
-    s << " not initialized" << std::endl ;
-  }
-*/
+    else {
+      s << " not initialized" << std::endl ;
+    }
+  */
 }
 
-int OpenMPTarget::concurrency() {
-  return thread_pool_size(0);
-}
+int OpenMPTarget::concurrency() { return thread_pool_size(0); }
 
 const char* OpenMPTarget::name() { return "OpenMPTarget"; }
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
-#endif //KOKKOS_ENABLE_OPENMPTARGET
+#endif  // KOKKOS_ENABLE_OPENMPTARGET
diff --git a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp
index d57ddbcc5cc3f4817b512480166441fc01395fd2..c9d8543eab0662baccbd030572c0124b30a9e53f 100644
--- a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp
+++ b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,29 +58,30 @@ namespace Impl {
 //----------------------------------------------------------------------------
 /** \brief  Data for OpenMPTarget thread execution */
 
-
 class OpenMPTargetExec {
-public:
-  enum { MAX_ACTIVE_THREADS = 256*8*56*4 };
-  enum { MAX_ACTIVE_TEAMS = MAX_ACTIVE_THREADS/32 };
+ public:
+  enum { MAX_ACTIVE_THREADS = 256 * 8 * 56 * 4 };
+  enum { MAX_ACTIVE_TEAMS = MAX_ACTIVE_THREADS / 32 };
 
-private:
+ private:
   static void* scratch_ptr;
 
-public:
-  static void verify_is_process( const char * const );
-  static void verify_initialized( const char * const );
+ public:
+  static void verify_is_process(const char* const);
+  static void verify_initialized(const char* const);
 
   static void* get_scratch_ptr();
   static void clear_scratch();
-  static void resize_scratch( int64_t reduce_bytes , int64_t team_reduce_bytes, int64_t team_shared_bytes, int64_t thread_local_bytes );
+  static void resize_scratch(int64_t reduce_bytes, int64_t team_reduce_bytes,
+                             int64_t team_shared_bytes,
+                             int64_t thread_local_bytes);
 
   static void* m_scratch_ptr;
   static int64_t m_scratch_size;
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -88,25 +90,24 @@ namespace Kokkos {
 namespace Impl {
 
 class OpenMPTargetExecTeamMember {
-public:
-
+ public:
   enum { TEAM_REDUCE_SIZE = 512 };
 
   /** \brief  Thread states for team synchronization */
-  enum { Active = 0 , Rendezvous = 1 };
+  enum { Active = 0, Rendezvous = 1 };
 
-  typedef Kokkos::Experimental::OpenMPTarget                         execution_space ;
-  typedef execution_space::scratch_memory_space  scratch_memory_space ;
+  typedef Kokkos::Experimental::OpenMPTarget execution_space;
+  typedef execution_space::scratch_memory_space scratch_memory_space;
 
-  scratch_memory_space  m_team_shared ;
-  int                   m_team_scratch_size[2] ;
-  int                   m_team_rank ;
-  int                   m_team_size ;
-  int                   m_league_rank ;
-  int                   m_league_size ;
-  int                   m_vector_length ;
-  int                   m_vector_lane ;
-  void* 		m_glb_scratch ;
+  scratch_memory_space m_team_shared;
+  int m_team_scratch_size[2];
+  int m_team_rank;
+  int m_team_size;
+  int m_league_rank;
+  int m_league_size;
+  int m_vector_length;
+  int m_vector_lane;
+  void* m_glb_scratch;
 
   /*
   // Fan-in team threads, root of the fan-in which does not block returns true
@@ -114,7 +115,8 @@ public:
   bool team_fan_in() const
     {
       memory_fence();
-      for ( int n = 1 , j ; ( ( j = m_team_rank_rev + n ) < m_team_size ) && ! ( m_team_rank_rev & n ) ; n <<= 1 ) {
+      for ( int n = 1 , j ; ( ( j = m_team_rank_rev + n ) < m_team_size ) && ! (
+  m_team_rank_rev & n ) ; n <<= 1 ) {
 
         m_exec.pool_rev( m_team_base_rev + j )->state_wait( Active );
       }
@@ -132,92 +134,91 @@ public:
   void team_fan_out() const
     {
       memory_fence();
-      for ( int n = 1 , j ; ( ( j = m_team_rank_rev + n ) < m_team_size ) && ! ( m_team_rank_rev & n ) ; n <<= 1 ) {
-        m_exec.pool_rev( m_team_base_rev + j )->state_set( Active );
-        memory_fence();
+      for ( int n = 1 , j ; ( ( j = m_team_rank_rev + n ) < m_team_size ) && ! (
+  m_team_rank_rev & n ) ; n <<= 1 ) { m_exec.pool_rev( m_team_base_rev + j
+  )->state_set( Active ); memory_fence();
       }
     }
   */
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space& team_shmem() const
-    { return m_team_shared.set_team_thread_mode(0,1,0) ; }
+  const execution_space::scratch_memory_space& team_shmem() const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space& team_scratch(int) const
-    { return m_team_shared.set_team_thread_mode(0,1,0) ; }
+  const execution_space::scratch_memory_space& team_scratch(int) const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space& thread_scratch(int) const
-    { return m_team_shared.set_team_thread_mode(0,team_size(),team_rank()) ; }
-
-  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank ; }
-  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size ; }
-  KOKKOS_INLINE_FUNCTION int team_rank() const { return m_team_rank ; }
-  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size ; }
+  const execution_space::scratch_memory_space& thread_scratch(int) const {
+    return m_team_shared.set_team_thread_mode(0, team_size(), team_rank());
+  }
 
-  KOKKOS_INLINE_FUNCTION void team_barrier() const
-    {
-      #pragma omp barrier
-    }
+  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank; }
+  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
+  KOKKOS_INLINE_FUNCTION int team_rank() const { return m_team_rank; }
+  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
 
-  template<class ValueType>
-  KOKKOS_INLINE_FUNCTION
-  void team_broadcast(ValueType& value, const int& thread_id) const
-  {
-/*#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    { }
-#else
-    // Make sure there is enough scratch space:
-    typedef typename if_c< sizeof(ValueType) < TEAM_REDUCE_SIZE
-                         , ValueType , void >::type type ;
-
-    type * const local_value = ((type*) m_exec.scratch_thread());
-    if(team_rank() == thread_id)
-      *local_value = value;
-    memory_fence();
-    team_barrier();
-    value = *local_value;
-#endif*/
+  KOKKOS_INLINE_FUNCTION void team_barrier() const {
+#pragma omp barrier
   }
 
-  template< class ValueType, class JoinOp >
-  KOKKOS_INLINE_FUNCTION ValueType
-    team_reduce( const ValueType & value
-               , const JoinOp & op_in ) const {
-
-      #pragma omp barrier
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(ValueType& value,
+                                             const int& thread_id) const {
+    /*#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+        { }
+    #else
+        // Make sure there is enough scratch space:
+        typedef typename if_c< sizeof(ValueType) < TEAM_REDUCE_SIZE
+                             , ValueType , void >::type type ;
+
+        type * const local_value = ((type*) m_exec.scratch_thread());
+        if(team_rank() == thread_id)
+          *local_value = value;
+        memory_fence();
+        team_barrier();
+        value = *local_value;
+    #endif*/
+  }
 
-      typedef ValueType value_type;
-      const JoinLambdaAdapter<value_type,JoinOp> op(op_in);
+  template <class ValueType, class JoinOp>
+  KOKKOS_INLINE_FUNCTION ValueType team_reduce(const ValueType& value,
+                                               const JoinOp& op_in) const {
+#pragma omp barrier
 
-      // Make sure there is enough scratch space:
-      typedef typename if_c< sizeof(value_type) < TEAM_REDUCE_SIZE
-                           , value_type , void >::type type ;
+    typedef ValueType value_type;
+    const JoinLambdaAdapter<value_type, JoinOp> op(op_in);
 
-      const int n_values = TEAM_REDUCE_SIZE/sizeof(value_type);
-      type * team_scratch = (type*) ((char*)m_glb_scratch + TEAM_REDUCE_SIZE*omp_get_team_num());
-      for(int i = m_team_rank; i < n_values; i+= m_team_size) {
-        team_scratch[i] = value_type();
-      }
+    // Make sure there is enough scratch space:
+    typedef typename if_c<sizeof(value_type) < TEAM_REDUCE_SIZE, value_type,
+                          void>::type type;
+
+    const int n_values = TEAM_REDUCE_SIZE / sizeof(value_type);
+    type* team_scratch =
+        (type*)((char*)m_glb_scratch + TEAM_REDUCE_SIZE * omp_get_team_num());
+    for (int i = m_team_rank; i < n_values; i += m_team_size) {
+      team_scratch[i] = value_type();
+    }
 
-      #pragma omp barrier
+#pragma omp barrier
 
-      for(int k=0; k<m_team_size; k+=n_values) {
-        if((k <= m_team_rank) && (k+n_values > m_team_rank))
-          team_scratch[m_team_rank%n_values]+=value;
-        #pragma omp barrier
-      }
+    for (int k = 0; k < m_team_size; k += n_values) {
+      if ((k <= m_team_rank) && (k + n_values > m_team_rank))
+        team_scratch[m_team_rank % n_values] += value;
+#pragma omp barrier
+    }
 
-      for(int d = 1; d<n_values;d*=2) {
-        if((m_team_rank+d<n_values) && (m_team_rank%(2*d)==0)) {
-          team_scratch[m_team_rank] += team_scratch[m_team_rank+d];
-        }
-        #pragma omp barrier
+    for (int d = 1; d < n_values; d *= 2) {
+      if ((m_team_rank + d < n_values) && (m_team_rank % (2 * d) == 0)) {
+        team_scratch[m_team_rank] += team_scratch[m_team_rank + d];
       }
-      return team_scratch[0];
+#pragma omp barrier
     }
+    return team_scratch[0];
+  }
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
    *          with intra-team non-deterministic ordering accumulation.
    *
@@ -227,11 +228,12 @@ public:
    *  As such the base value for each team's scan operation is similarly
    *  non-deterministic.
    */
-  template< typename ArgType >
-  KOKKOS_INLINE_FUNCTION ArgType team_scan( const ArgType & value , ArgType * const global_accum ) const
-    {
+  template <typename ArgType>
+  KOKKOS_INLINE_FUNCTION ArgType team_scan(const ArgType& value,
+                                           ArgType* const global_accum) const {
     /*  // Make sure there is enough scratch space:
-      typedef typename if_c< sizeof(ArgType) < TEAM_REDUCE_SIZE , ArgType , void >::type type ;
+      typedef typename if_c< sizeof(ArgType) < TEAM_REDUCE_SIZE , ArgType , void
+      >::type type ;
 
       volatile type * const work_value  = ((type*) m_exec.scratch_thread());
 
@@ -240,7 +242,8 @@ public:
       memory_fence();
 
       if ( team_fan_in() ) {
-        // The last thread to synchronize returns true, all other threads wait for team_fan_out()
+        // The last thread to synchronize returns true, all other threads wait
+      for team_fan_out()
         // m_team_base[0]                 == highest ranking team member
         // m_team_base[ m_team_size - 1 ] == lowest ranking team member
         //
@@ -251,17 +254,16 @@ public:
 
         if ( global_accum ) {
           for ( int i = m_team_size ; i-- ; ) {
-            type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i )->scratch_thread());
-            accum += val ;
+            type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i
+      )->scratch_thread()); accum += val ;
           }
           accum = atomic_fetch_add( global_accum , accum );
         }
 
         for ( int i = m_team_size ; i-- ; ) {
-          type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i )->scratch_thread());
-          const type offset = accum ;
-          accum += val ;
-          val = offset ;
+          type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i
+      )->scratch_thread()); const type offset = accum ; accum += val ; val =
+      offset ;
         }
 
         memory_fence();
@@ -270,284 +272,301 @@ public:
       team_fan_out();
 
       return *work_value ;*/
-      return ArgType();
-    }
+    return ArgType();
+  }
 
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering.
    *
    *  The highest rank thread can compute the reduction total as
    *    reduction_total = dev.team_scan( value ) + value ;
    */
-  template< typename Type >
-  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value ) const
-    { return this-> template team_scan<Type>( value , 0 ); }
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_scan(const Type& value) const {
+    return this->template team_scan<Type>(value, 0);
+  }
 
   //----------------------------------------
   // Private for the driver
 
-private:
-
-  typedef execution_space::scratch_memory_space space ;
-
-public:
-
-  inline
-  OpenMPTargetExecTeamMember( const int league_rank, const int league_size, const int team_size, const int vector_length //const TeamPolicyInternal< OpenMPTarget, Properties ...> & team
-                      , void* const glb_scratch
-                      , const int shmem_size_L1
-                      , const int shmem_size_L2
-                      )
-    : m_team_shared(0,0)
-    , m_team_scratch_size{ shmem_size_L1 , shmem_size_L2 }
-    , m_team_rank(0)
-    , m_vector_length( vector_length )
-    , m_team_size( team_size )
-    , m_league_rank( league_rank )
-    , m_league_size( league_size )
-    , m_glb_scratch( glb_scratch )
-    {
-      const int omp_tid = omp_get_thread_num();
-      m_league_rank = league_rank;
-      m_team_rank = omp_tid/m_vector_length;
-      m_vector_lane = omp_tid%m_vector_length;
-    }
+ private:
+  typedef execution_space::scratch_memory_space space;
+
+ public:
+  inline OpenMPTargetExecTeamMember(
+      const int league_rank, const int league_size, const int team_size,
+      const int vector_length  // const TeamPolicyInternal< OpenMPTarget,
+                               // Properties ...> & team
+      ,
+      void* const glb_scratch, const int shmem_size_L1, const int shmem_size_L2)
+      : m_team_shared(0, 0),
+        m_team_scratch_size{shmem_size_L1, shmem_size_L2},
+        m_team_rank(0),
+        m_vector_length(vector_length),
+        m_team_size(team_size),
+        m_league_rank(league_rank),
+        m_league_size(league_size),
+        m_glb_scratch(glb_scratch) {
+    const int omp_tid = omp_get_thread_num();
+    m_league_rank     = league_rank;
+    m_team_rank       = omp_tid / m_vector_length;
+    m_vector_lane     = omp_tid % m_vector_length;
+  }
 
-  static inline int team_reduce_size() { return TEAM_REDUCE_SIZE ; }
+  static inline int team_reduce_size() { return TEAM_REDUCE_SIZE; }
 };
 
-
-
-template< class ... Properties >
-class TeamPolicyInternal< Kokkos::Experimental::OpenMPTarget, Properties ... >: public PolicyTraits<Properties ...>
-{
-public:
-
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget, Properties...>
+    : public PolicyTraits<Properties...> {
+ public:
   //! Tag this class as a kokkos execution policy
-  typedef TeamPolicyInternal      execution_policy ;
+  typedef TeamPolicyInternal execution_policy;
 
-  typedef PolicyTraits<Properties ... > traits;
+  typedef PolicyTraits<Properties...> traits;
 
-  TeamPolicyInternal& operator = (const TeamPolicyInternal& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_vector_length = p.m_vector_length;
-    m_team_alloc = p.m_team_alloc;
-    m_team_iter = p.m_team_iter;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  TeamPolicyInternal& operator=(const TeamPolicyInternal& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_vector_length          = p.m_vector_length;
+    m_team_alloc             = p.m_team_alloc;
+    m_team_iter              = p.m_team_iter;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
     return *this;
   }
 
   //----------------------------------------
 
-  template< class FunctorType >
-  inline static
-  int team_size_max( const FunctorType & )
-    { return 1024; }
+  template <class FunctorType>
+  inline static int team_size_max(const FunctorType&) {
+    return 1024;
+  }
 
-  template< class FunctorType >
-  inline static
-  int team_size_recommended( const FunctorType & )
-    { return 256; }
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&) {
+    return 256;
+  }
 
-  template< class FunctorType >
-  inline static
-  int team_size_recommended( const FunctorType &, const int& vector_length)
-    { return 256/vector_length; }
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&,
+                                          const int& vector_length) {
+    return 256 / vector_length;
+  }
 
   //----------------------------------------
 
-private:
-
-  int m_league_size ;
-  int m_team_size ;
+ private:
+  int m_league_size;
+  int m_team_size;
   int m_vector_length;
-  int m_team_alloc ;
-  int m_team_iter ;
+  int m_team_alloc;
+  int m_team_iter;
 
   size_t m_team_scratch_size[2];
   size_t m_thread_scratch_size[2];
 
   int m_chunk_size;
 
-  inline void init( const int league_size_request
-                  , const int team_size_request
-                  , const int vector_length_request )
-    {
-      m_league_size = league_size_request ;
+  inline void init(const int league_size_request, const int team_size_request,
+                   const int vector_length_request) {
+    m_league_size = league_size_request;
 
-      m_team_size = team_size_request;
+    m_team_size = team_size_request;
 
-      m_vector_length = vector_length_request;
-
-      set_auto_chunk_size();
-    }
+    m_vector_length = vector_length_request;
 
-public:
+    set_auto_chunk_size();
+  }
 
-  inline int vector_length() const { return m_vector_length ; }
-  inline int team_size()   const { return m_team_size ; }
-  inline int league_size() const { return m_league_size ; }
+ public:
+  inline int vector_length() const { return m_vector_length; }
+  inline int team_size() const { return m_team_size; }
+  inline int league_size() const { return m_league_size; }
   inline size_t scratch_size(const int& level, int team_size_ = -1) const {
-    if(team_size_ < 0)
-      team_size_ = m_team_size;
-    return m_team_scratch_size[level] + team_size_*m_thread_scratch_size[level] ;
+    if (team_size_ < 0) team_size_ = m_team_size;
+    return m_team_scratch_size[level] +
+           team_size_ * m_thread_scratch_size[level];
   }
 
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal( typename traits::execution_space &
-            , int league_size_request
-            , int team_size_request
-            , int vector_length_request = 1 )
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
-    { init( league_size_request , team_size_request , vector_length_request); }
-
-  TeamPolicyInternal( typename traits::execution_space &
-            , int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int vector_length_request = 1)
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
-    { init( league_size_request , 256/vector_length_request , vector_length_request ); }
-
-  TeamPolicyInternal( int league_size_request
-            , int team_size_request
-            , int vector_length_request = 1 )
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
-    { init( league_size_request , team_size_request , vector_length_request); }
-
-  TeamPolicyInternal( int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int vector_length_request = 1 )
-            : m_team_scratch_size { 0 , 0 }
-            , m_thread_scratch_size { 0 , 0 }
-            , m_chunk_size(0)
-    { init( league_size_request , 256/vector_length_request , vector_length_request ); }
-
-  inline int team_alloc() const { return m_team_alloc ; }
-  inline int team_iter()  const { return m_team_iter ; }
-
-  inline int chunk_size() const { return m_chunk_size ; }
+  TeamPolicyInternal(typename traits::execution_space&, int league_size_request,
+                     int team_size_request, int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request, vector_length_request);
+  }
+
+  TeamPolicyInternal(typename traits::execution_space&, int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, 256 / vector_length_request,
+         vector_length_request);
+  }
+
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request, vector_length_request);
+  }
+
+  TeamPolicyInternal(int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, 256 / vector_length_request,
+         vector_length_request);
+  }
+
+  inline int team_alloc() const { return m_team_alloc; }
+  inline int team_iter() const { return m_team_iter; }
+
+  inline int chunk_size() const { return m_chunk_size; }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal set_chunk_size(typename traits::index_type chunk_size_) const {
+  inline TeamPolicyInternal set_chunk_size(
+      typename traits::index_type chunk_size_) const {
     TeamPolicyInternal p = *this;
-    p.m_chunk_size = chunk_size_;
+    p.m_chunk_size       = chunk_size_;
     return p;
   }
 
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team) const {
-    TeamPolicyInternal p = *this;
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team) const {
+    TeamPolicyInternal p         = *this;
     p.m_team_scratch_size[level] = per_team.value;
     return p;
   }
 
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
-    p.m_team_scratch_size[level] = per_team.value;
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
+    p.m_team_scratch_size[level]   = per_team.value;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 #else
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal& set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal& set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(const int& level,
+                                              const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-protected:
+ protected:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal internal_set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal internal_set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-private:
+ private:
   /** \brief finalize chunk_size if it was set to AUTO*/
   inline void set_auto_chunk_size() {
+    int concurrency =
+        traits::execution_space::thread_pool_size(0) / m_team_alloc;
+    if (concurrency == 0) concurrency = 1;
 
-    int concurrency = traits::execution_space::thread_pool_size(0)/m_team_alloc;
-    if( concurrency==0 ) concurrency=1;
-
-    if(m_chunk_size > 0) {
-      if(!Impl::is_integral_power_of_two( m_chunk_size ))
-        Kokkos::abort("TeamPolicy blocking granularity must be power of two" );
+    if (m_chunk_size > 0) {
+      if (!Impl::is_integral_power_of_two(m_chunk_size))
+        Kokkos::abort("TeamPolicy blocking granularity must be power of two");
     }
 
     int new_chunk_size = 1;
-    while(new_chunk_size*100*concurrency < m_league_size)
+    while (new_chunk_size * 100 * concurrency < m_league_size)
       new_chunk_size *= 2;
-    if(new_chunk_size < 128) {
+    if (new_chunk_size < 128) {
       new_chunk_size = 1;
-      while( (new_chunk_size*40*concurrency < m_league_size ) && (new_chunk_size<128) )
-        new_chunk_size*=2;
+      while ((new_chunk_size * 40 * concurrency < m_league_size) &&
+             (new_chunk_size < 128))
+        new_chunk_size *= 2;
     }
     m_chunk_size = new_chunk_size;
   }
 
-public:
-  typedef Impl::OpenMPTargetExecTeamMember member_type ;
+ public:
+  typedef Impl::OpenMPTargetExecTeamMember member_type;
 };
-} // namespace Impl
-
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -555,235 +574,268 @@ public:
 namespace Kokkos {
 namespace Experimental {
 
-inline
-int OpenMPTarget::thread_pool_size( int depth )
-{
-  //return Impl::OpenMPTargetExec::pool_size(depth);
+inline int OpenMPTarget::thread_pool_size(int depth) {
+  // return Impl::OpenMPTargetExec::pool_size(depth);
   return omp_get_max_threads();
 }
 
 KOKKOS_INLINE_FUNCTION
-int OpenMPTarget::thread_pool_rank()
-{
-  return omp_get_thread_num();
-}
-
-} // namespace Experimental
-} // namespace Kokkos
+int OpenMPTarget::thread_pool_rank() { return omp_get_thread_num(); }
 
+}  // namespace Experimental
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>
-  TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread, const iType& count) {
-  return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>(thread,count);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                const iType& count) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>
-  TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread, const iType& begin, const iType& end) {
-  return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>(thread,begin,end);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                const iType& begin, const iType& end) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, begin, end);
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >
-  ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread, const iType& count) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >(thread,count);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                  const iType& count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >
-  ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread, const iType& arg_begin, const iType& arg_end) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >(thread,arg_begin,arg_end);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                  const iType& arg_begin, const iType& arg_end) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, arg_begin, arg_end);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember> PerTeam(const Impl::OpenMPTargetExecTeamMember& thread) {
+Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember> PerTeam(
+    const Impl::OpenMPTargetExecTeamMember& thread) {
   return Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>(thread);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember> PerThread(const Impl::OpenMPTargetExecTeamMember& thread) {
+Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember> PerThread(
+    const Impl::OpenMPTargetExecTeamMember& thread) {
   return Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>(thread);
 }
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-  /** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each i=0..N-1.
-   *
-   * The range i=0..N-1 is mapped to all threads of the the calling thread team.
-   * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>& loop_boundaries, const Lambda& lambda) {
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team.
+ * This functionality requires C++11 support.*/
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                     const Lambda & lambda, ValueType& result) {
-
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
   result = ValueType();
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    result+=tmp;
+    lambda(i, tmp);
+    result += tmp;
   }
 
-  //result = loop_boundaries.thread.team_reduce(result,Impl::JoinAdd<ValueType>());
+  // result =
+  // loop_boundaries.thread.team_reduce(result,Impl::JoinAdd<ValueType>());
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a reduction of
- * val is performed using JoinType(ValueType& val, const ValueType& update) and put into init_result.
- * The input value of init_result is used as initializer for temporary variables of ValueType. Therefore
- * the input value should be the neutral element with respect to the join operation (e.g. '0 for +-' or
- * '1 for *'). This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                     const Lambda & lambda, const JoinType& join, ValueType& init_result) {
-
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *'). This functionality requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
   ValueType result = init_result;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    join(result,tmp);
+    lambda(i, tmp);
+    join(result, tmp);
   }
 
-  //init_result = loop_boundaries.thread.team_reduce(result,join);
+  // init_result = loop_boundaries.thread.team_reduce(result,join);
 }
 
-} //namespace Kokkos
-
+}  // namespace Kokkos
 
 namespace Kokkos {
-/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
  * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >&
-    loop_boundaries, const Lambda& lambda) {
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >&
-      loop_boundaries, const Lambda & lambda, ValueType& result) {
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
   result = ValueType();
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    result+=tmp;
+    lambda(i, tmp);
+    result += tmp;
   }
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a reduction of
- * val is performed using JoinType(ValueType& val, const ValueType& update) and put into init_result.
- * The input value of init_result is used as initializer for temporary variables of ValueType. Therefore
- * the input value should be the neutral element with respect to the join operation (e.g. '0 for +-' or
- * '1 for *'). This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >&
-      loop_boundaries, const Lambda & lambda, const JoinType& join, ValueType& init_result) {
-
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *'). This functionality requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
   ValueType result = init_result;
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    join(result,tmp);
+    lambda(i, tmp);
+    join(result, tmp);
   }
   init_result = result;
 }
 
-/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes lambda(iType i, ValueType & val, bool final)
- *          for each i=0..N-1.
+/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
+ * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan operation is performed.
- * Depending on the target execution space the operator might be called twice: once with final=false
- * and once with final=true. When final==true val contains the prefix sum value. The contribution of this
- * "i" needs to be added to val no matter whether final==true or not. In a serial execution
- * (i.e. team_size==1) the operator is only called once with final==true. Scan_val will be set
- * to the final sum value over all vector lanes.
- * This functionality requires C++11 support.*/
-template< typename iType, class FunctorType >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >&
-      loop_boundaries, const FunctorType & lambda) {
-
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
-  typedef typename ValueTraits::value_type value_type ;
+ * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
+ * operation is performed. Depending on the target execution space the operator
+ * might be called twice: once with final=false and once with final=true. When
+ * final==true val contains the prefix sum value. The contribution of this "i"
+ * needs to be added to val no matter whether final==true or not. In a serial
+ * execution (i.e. team_size==1) the operator is only called once with
+ * final==true. Scan_val will be set to the final sum value over all vector
+ * lanes. This functionality requires C++11 support.*/
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const FunctorType& lambda) {
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename ValueTraits::value_type value_type;
 
   value_type scan_val = value_type();
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,scan_val,true);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, scan_val, true);
   }
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>& single_struct, const FunctorType& lambda) {
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+        single_struct,
+    const FunctorType& lambda) {
   lambda();
 }
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>& single_struct, const FunctorType& lambda) {
-  if(single_struct.team_member.team_rank()==0) lambda();
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+        single_struct,
+    const FunctorType& lambda) {
+  if (single_struct.team_member.team_rank() == 0) lambda();
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>& single_struct, const FunctorType& lambda, ValueType& val) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+        single_struct,
+    const FunctorType& lambda, ValueType& val) {
   lambda(val);
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>& single_struct, const FunctorType& lambda, ValueType& val) {
-  if(single_struct.team_member.team_rank()==0) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+        single_struct,
+    const FunctorType& lambda, ValueType& val) {
+  if (single_struct.team_member.team_rank() == 0) {
     lambda(val);
   }
-  single_struct.team_member.team_broadcast(val,0);
-}
+  single_struct.team_member.team_broadcast(val, 0);
 }
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_OPENMPTARGETEXEC_HPP */
-
diff --git a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
index c93a88606da4630cbca920064834e9eb4361f41d..2252cf0372fcbf54ba596c31723718f2b77b709d 100644
--- a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
+++ b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -56,70 +57,57 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::RangePolicy< Traits ... >
-                 , Kokkos::Experimental::OpenMPTarget 
-                 >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ...  > Policy ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
-
-  const FunctorType m_functor ;
-  const Policy      m_policy ;
-
-
-public:
-
-  inline void execute() const {
-    execute_impl<WorkTag>();
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                  Kokkos::Experimental::OpenMPTarget> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+ public:
+  inline void execute() const { execute_impl<WorkTag>(); }
+
+  template <class TagType>
+  inline typename std::enable_if<std::is_same<TagType, void>::value>::type
+  execute_impl() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const typename Policy::member_type begin = m_policy.begin();
+    const typename Policy::member_type end   = m_policy.end();
+
+#pragma omp target teams distribute parallel for map(to : this->m_functor)
+    for (int i = begin; i < end; i++) m_functor(i);
   }
 
-  template< class TagType >
-  inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  execute_impl() const
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const typename Policy::member_type begin = m_policy.begin();
-      const typename Policy::member_type end = m_policy.end();
-      
-      #pragma omp target teams distribute parallel for map(to:this->m_functor)
-      for(int i=begin; i<end; i++)
-        m_functor(i);
-    }
-
-
-  template< class TagType >
-  inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  execute_impl() const
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const typename Policy::member_type begin = m_policy.begin();
-      const typename Policy::member_type end = m_policy.end();
-
-      #pragma omp target teams distribute parallel for num_threads(128) map(to:this->m_functor)
-      for(int i=begin; i<end; i++)
-        m_functor(TagType(),i);
-    }
+  template <class TagType>
+  inline typename std::enable_if<!std::is_same<TagType, void>::value>::type
+  execute_impl() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const typename Policy::member_type begin = m_policy.begin();
+    const typename Policy::member_type end   = m_policy.end();
+
+#pragma omp target teams distribute parallel for num_threads(128) \
+    map(to                                                        \
+        : this->m_functor)
+    for (int i = begin; i < end; i++) m_functor(TagType(), i);
+  }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , Policy arg_policy )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -127,78 +115,88 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template<class FunctorType, class PolicyType, class ReducerType, class PointerType, class ValueType, int FunctorHasJoin, int UseReducerType>
+template <class FunctorType, class PolicyType, class ReducerType,
+          class PointerType, class ValueType, int FunctorHasJoin,
+          int UseReducerType>
 struct ParallelReduceSpecialize {
-  static inline void execute(const FunctorType& f, const PolicyType& p , PointerType result_ptr) {
-    printf("Error: Invalid Specialization %i %i\n",FunctorHasJoin,UseReducerType);
+  static inline void execute(const FunctorType& f, const PolicyType& p,
+                             PointerType result_ptr) {
+    printf("Error: Invalid Specialization %i %i\n", FunctorHasJoin,
+           UseReducerType);
   }
 };
 
-template<class FunctorType, class ReducerType, class PointerType, class ValueType, class ... PolicyArgs>
-struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>, ReducerType, PointerType, ValueType, 0,0> {
+template <class FunctorType, class ReducerType, class PointerType,
+          class ValueType, class... PolicyArgs>
+struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
+                                ReducerType, PointerType, ValueType, 0, 0> {
   typedef Kokkos::RangePolicy<PolicyArgs...> PolicyType;
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  execute_impl(const FunctorType& f, const PolicyType& p, PointerType result_ptr)
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const typename PolicyType::member_type begin = p.begin();
-      const typename PolicyType::member_type end = p.end();
-      
-      ValueType result = ValueType();
-      #pragma omp target teams distribute parallel for num_teams(512) map(to:f) map(tofrom:result) reduction(+: result)
-      for(int i=begin; i<end; i++)
-        f(i,result);
-
-      *result_ptr=result;
-    }
-
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      execute_impl(const FunctorType& f, const PolicyType& p,
+                   PointerType result_ptr) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const typename PolicyType::member_type begin = p.begin();
+    const typename PolicyType::member_type end   = p.end();
+
+    ValueType result = ValueType();
+#pragma omp target teams distribute parallel for num_teams(512) map(to:f) map(tofrom:result) reduction(+: result)
+    for (int i = begin; i < end; i++) f(i, result);
+
+    *result_ptr = result;
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  execute_impl(const FunctorType& f, const PolicyType& p, PointerType result_ptr)
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const typename PolicyType::member_type begin = p.begin();
-      const typename PolicyType::member_type end = p.end();
-
-      ValueType result = ValueType();
-      #pragma omp target teams distribute parallel for num_teams(512) map(to:f) map(tofrom: result) reduction(+: result)
-      for(int i=begin; i<end; i++)
-        f(TagType(),i,result);
-      
-      *result_ptr=result;
-    }
-
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      execute_impl(const FunctorType& f, const PolicyType& p,
+                   PointerType result_ptr) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const typename PolicyType::member_type begin = p.begin();
+    const typename PolicyType::member_type end   = p.end();
+
+    ValueType result = ValueType();
+#pragma omp target teams distribute parallel for num_teams(512) map(to:f) map(tofrom: result) reduction(+: result)
+    for (int i = begin; i < end; i++) f(TagType(), i, result);
+
+    *result_ptr = result;
+  }
 
-    inline static
-    void execute(const FunctorType& f, const PolicyType& p, PointerType ptr) {
-      execute_impl<typename PolicyType::work_tag>(f,p,ptr);
-    }
+  inline static void execute(const FunctorType& f, const PolicyType& p,
+                             PointerType ptr) {
+    execute_impl<typename PolicyType::work_tag>(f, p, ptr);
+  }
 };
 /*
-template<class FunctorType, class PolicyType, class ReducerType, class PointerType, class ValueType>
-struct ParallelReduceSpecialize<FunctorType, PolicyType, ReducerType, PointerType, ValueType, 0,1> {
+template<class FunctorType, class PolicyType, class ReducerType, class
+PointerType, class ValueType> struct ParallelReduceSpecialize<FunctorType,
+PolicyType, ReducerType, PointerType, ValueType, 0,1> {
 
-  #pragma omp declare reduction(custom: ValueType : ReducerType::join(omp_out, omp_in)) initializer ( ReducerType::init(omp_priv) )
+  #pragma omp declare reduction(custom: ValueType : ReducerType::join(omp_out,
+omp_in)) initializer ( ReducerType::init(omp_priv) )
 
   template< class TagType >
   inline static
   typename std::enable_if< std::is_same< TagType , void >::value >::type
-  execute_impl(const FunctorType& f, const PolicyType& p, PointerType result_ptr)
+  execute_impl(const FunctorType& f, const PolicyType& p, PointerType
+result_ptr)
     {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const typename PolicyType::member_type begin = p.begin();
-      const typename PolicyType::member_type end = p.end();
+      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget
+parallel_for");
+      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget
+parallel_for"); const typename PolicyType::member_type begin = p.begin(); const
+typename PolicyType::member_type end = p.end();
 
       ValueType result = ValueType();
-      #pragma omp target teams distribute parallel for num_teams(512) map(to:f) map(tofrom:result) reduction(custom: result)
-      for(int i=begin; i<end; i++)
+      #pragma omp target teams distribute parallel for num_teams(512) map(to:f)
+map(tofrom:result) reduction(custom: result) for(int i=begin; i<end; i++)
         f(i,result);
 
       *result_ptr=result;
@@ -208,16 +206,18 @@ struct ParallelReduceSpecialize<FunctorType, PolicyType, ReducerType, PointerTyp
   template< class TagType >
   inline static
   typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  execute_impl(const FunctorType& f, const PolicyType& p, PointerType result_ptr)
+  execute_impl(const FunctorType& f, const PolicyType& p, PointerType
+result_ptr)
     {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const typename PolicyType::member_type begin = p.begin();
-      const typename PolicyType::member_type end = p.end();
+      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget
+parallel_for");
+      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget
+parallel_for"); const typename PolicyType::member_type begin = p.begin(); const
+typename PolicyType::member_type end = p.end();
 
       ValueType result = ValueType();
-      #pragma omp target teams distribute parallel for num_teams(512) map(to:f) map(tofrom: result) reduction(custom: result)
-      for(int i=begin; i<end; i++)
+      #pragma omp target teams distribute parallel for num_teams(512) map(to:f)
+map(tofrom: result) reduction(custom: result) for(int i=begin; i<end; i++)
         f(TagType(),i,result);
 
       *result_ptr=result;
@@ -231,86 +231,84 @@ struct ParallelReduceSpecialize<FunctorType, PolicyType, ReducerType, PointerTyp
 };
 */
 
-template< class FunctorType , class ReducerType, class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::RangePolicy< Traits ...>
-                    , ReducerType
-                    , Kokkos::Experimental::OpenMPTarget
-                    >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+                     Kokkos::Experimental::OpenMPTarget> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
   // Static Assert WorkTag void if ReducerType not InvalidType
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd , WorkTagFwd > ValueJoin ;
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
 
-  enum {HasJoin = ReduceFunctorHasJoin<FunctorType>::value };
-  enum {UseReducer = is_reducer_type<ReducerType>::value };
+  enum { HasJoin = ReduceFunctorHasJoin<FunctorType>::value };
+  enum { UseReducer = is_reducer_type<ReducerType>::value };
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  
-  typedef ParallelReduceSpecialize<FunctorType,Policy,ReducerType,pointer_type,typename ValueTraits::value_type,HasJoin,UseReducer> ParForSpecialize;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
+  typedef ParallelReduceSpecialize<
+      FunctorType, Policy, ReducerType, pointer_type,
+      typename ValueTraits::value_type, HasJoin, UseReducer>
+      ParForSpecialize;
 
-public: 
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+
+ public:
   inline void execute() const {
-    ParForSpecialize::execute(m_functor,m_policy,m_result_ptr);    
+    ParForSpecialize::execute(m_functor, m_policy, m_result_ptr);
   }
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ViewType    & arg_result_view
-                , typename std::enable_if<
-                           Kokkos::is_view< ViewType >::value &&
-                           !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr(  arg_result_view.data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::Experimental::OpenMPTarget must be a Kokkos::View in HostSpace" );*/
-    }
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ReducerType& reducer )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.result_view().data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::Experimental::OpenMPTarget must be a Kokkos::View in HostSpace" );*/
-    }
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType& arg_functor, Policy arg_policy,
+      const ViewType& arg_result_view,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result_view.data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::Experimental::OpenMPTarget must be a
+      Kokkos::View in HostSpace" );*/
+  }
 
+  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                        const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.result_view().data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::Experimental::OpenMPTarget must be a
+      Kokkos::View in HostSpace" );*/
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -318,136 +316,129 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelScan< FunctorType
-                  , Kokkos::RangePolicy< Traits ... >
-                  , Kokkos::Experimental::OpenMPTarget
-                  >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Experimental::OpenMPTarget> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, WorkTag > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   FunctorType, WorkTag > ValueJoin ;
-  typedef Kokkos::Impl::FunctorValueOps<    FunctorType, WorkTag > ValueOps ;
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, WorkTag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<FunctorType, WorkTag> ValueJoin;
+  typedef Kokkos::Impl::FunctorValueOps<FunctorType, WorkTag> ValueOps;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-/*
-  template< class TagType >
-  inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      #ifdef KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
-      #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-      #pragma ivdep
-      #endif
-      #endif
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( iwork , update , final );
-      }
-    }
-
-  template< class TagType >
-  inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      const TagType t{} ;
-      #ifdef KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
-      #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-      #pragma ivdep
-      #endif
-      #endif
-      for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
-        functor( t , iwork , update , final );
+  const FunctorType m_functor;
+  const Policy m_policy;
+  /*
+    template< class TagType >
+    inline static
+    typename std::enable_if< std::is_same< TagType , void >::value >::type
+    exec_range( const FunctorType & functor
+              , const Member ibeg , const Member iend
+              , reference_type update , const bool final )
+      {
+        #ifdef KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
+        #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+        #pragma ivdep
+        #endif
+        #endif
+        for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
+          functor( iwork , update , final );
+        }
       }
-    }
-*/
-public:
 
-  inline
-  void execute() const
-    {
-/*      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_scan");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_scan");
-
-      OpenMPTargetExec::resize_scratch( 2 * ValueTraits::value_size( m_functor ) , 0 );
-
-#pragma omp parallel
+    template< class TagType >
+    inline static
+    typename std::enable_if< ! std::is_same< TagType , void >::value >::type
+    exec_range( const FunctorType & functor
+              , const Member ibeg , const Member iend
+              , reference_type update , const bool final )
       {
-        OpenMPTargetExec & exec = * OpenMPTargetExec::get_thread_omp();
-        const WorkRange range( m_policy, exec.pool_rank(), exec.pool_size() );
-        const pointer_type ptr =
-          pointer_type( exec.scratch_reduce() ) +
-          ValueTraits::value_count( m_functor );
-        ParallelScan::template exec_range< WorkTag >
-          ( m_functor , range.begin() , range.end()
-          , ValueInit::init( m_functor , ptr ) , false );
+        const TagType t{} ;
+        #ifdef KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
+        #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+        #pragma ivdep
+        #endif
+        #endif
+        for ( Member iwork = ibeg ; iwork < iend ; ++iwork ) {
+          functor( t , iwork , update , final );
+        }
       }
+  */
+ public:
+  inline void execute() const {
+    /*      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget
+    parallel_scan");
+          OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget
+    parallel_scan");
+
+          OpenMPTargetExec::resize_scratch( 2 * ValueTraits::value_size(
+    m_functor ) , 0 );
+
+    #pragma omp parallel
+          {
+            OpenMPTargetExec & exec = * OpenMPTargetExec::get_thread_omp();
+            const WorkRange range( m_policy, exec.pool_rank(), exec.pool_size()
+    ); const pointer_type ptr = pointer_type( exec.scratch_reduce() ) +
+              ValueTraits::value_count( m_functor );
+            ParallelScan::template exec_range< WorkTag >
+              ( m_functor , range.begin() , range.end()
+              , ValueInit::init( m_functor , ptr ) , false );
+          }
 
-      {
-        const unsigned thread_count = OpenMPTargetExec::pool_size();
-        const unsigned value_count  = ValueTraits::value_count( m_functor );
+          {
+            const unsigned thread_count = OpenMPTargetExec::pool_size();
+            const unsigned value_count  = ValueTraits::value_count( m_functor );
 
-        pointer_type ptr_prev = 0 ;
+            pointer_type ptr_prev = 0 ;
 
-        for ( unsigned rank_rev = thread_count ; rank_rev-- ; ) {
+            for ( unsigned rank_rev = thread_count ; rank_rev-- ; ) {
 
-          pointer_type ptr = pointer_type( OpenMPTargetExec::pool_rev(rank_rev)->scratch_reduce() );
+              pointer_type ptr = pointer_type(
+    OpenMPTargetExec::pool_rev(rank_rev)->scratch_reduce() );
 
-          if ( ptr_prev ) {
-            for ( unsigned i = 0 ; i < value_count ; ++i ) { ptr[i] = ptr_prev[ i + value_count ] ; }
-            ValueJoin::join( m_functor , ptr + value_count , ptr );
-          }
-          else {
-            ValueInit::init( m_functor , ptr );
-          }
+              if ( ptr_prev ) {
+                for ( unsigned i = 0 ; i < value_count ; ++i ) { ptr[i] =
+    ptr_prev[ i + value_count ] ; } ValueJoin::join( m_functor , ptr +
+    value_count , ptr );
+              }
+              else {
+                ValueInit::init( m_functor , ptr );
+              }
 
-          ptr_prev = ptr ;
-        }
-      }
+              ptr_prev = ptr ;
+            }
+          }
 
-#pragma omp parallel
-      {
-        OpenMPTargetExec & exec = * OpenMPTargetExec::get_thread_omp();
-        const WorkRange range( m_policy, exec.pool_rank(), exec.pool_size() );
-        const pointer_type ptr = pointer_type( exec.scratch_reduce() );
-        ParallelScan::template exec_range< WorkTag >
-          ( m_functor , range.begin() , range.end()
-          , ValueOps::reference( ptr ) , true );
-      }
-*/
-    }
+    #pragma omp parallel
+          {
+            OpenMPTargetExec & exec = * OpenMPTargetExec::get_thread_omp();
+            const WorkRange range( m_policy, exec.pool_rank(), exec.pool_size()
+    ); const pointer_type ptr = pointer_type( exec.scratch_reduce() );
+            ParallelScan::template exec_range< WorkTag >
+              ( m_functor , range.begin() , range.end()
+              , ValueOps::reference( ptr ) , true );
+          }
+    */
+  }
 
   //----------------------------------------
 
-  inline
-  ParallelScan( const FunctorType & arg_functor
-              , const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-  {}
+  inline ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 
   //----------------------------------------
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -455,315 +446,340 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Properties >
-class ParallelFor< FunctorType
-                 , Kokkos::TeamPolicy< Properties ... >
-                 , Kokkos::Experimental::OpenMPTarget
-                 >
-{
-private:
-
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::Experimental::OpenMPTarget, Properties ... > Policy ;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::member_type  Member ;
-
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  const int          m_shmem_size ;
-
-public:
-
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::Experimental::OpenMPTarget> {
+ private:
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget,
+                                           Properties...>
+      Policy;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const int m_shmem_size;
+
+ public:
   inline void execute() const {
-    OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
     execute_impl<WorkTag>();
   }
 
-private:
-  template< class TagType >
-  inline
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  execute_impl() const
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const int league_size = m_policy.league_size();
-      const int team_size = m_policy.team_size();
-      const int vector_length = m_policy.vector_length();
-      const int nteams = OpenMPTargetExec::MAX_ACTIVE_TEAMS<league_size?OpenMPTargetExec::MAX_ACTIVE_TEAMS:league_size;
-
-      OpenMPTargetExec::resize_scratch(0,Policy::member_type::TEAM_REDUCE_SIZE,0,0);
-      void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
-
-      #pragma omp target teams distribute parallel for num_teams(league_size) num_threads(team_size*vector_length) schedule(static,1) \
-          map(to:this->m_functor,scratch_ptr) 
-      for(int i=0 ; i<league_size*team_size*vector_length ; i++) {
-        typename Policy::member_type team(i/(team_size*vector_length),league_size,team_size,vector_length, scratch_ptr, 0,0);
-        m_functor(team);
-      }
+ private:
+  template <class TagType>
+  inline typename std::enable_if<std::is_same<TagType, void>::value>::type
+  execute_impl() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const int league_size   = m_policy.league_size();
+    const int team_size     = m_policy.team_size();
+    const int vector_length = m_policy.vector_length();
+    const int nteams        = OpenMPTargetExec::MAX_ACTIVE_TEAMS < league_size
+                           ? OpenMPTargetExec::MAX_ACTIVE_TEAMS
+                           : league_size;
+
+    OpenMPTargetExec::resize_scratch(0, Policy::member_type::TEAM_REDUCE_SIZE,
+                                     0, 0);
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+
+#pragma omp target teams distribute parallel for num_teams(league_size) \
+    num_threads(team_size* vector_length) schedule(static, 1)           \
+        map(to                                                          \
+            : this->m_functor, scratch_ptr)
+    for (int i = 0; i < league_size * team_size * vector_length; i++) {
+      typename Policy::member_type team(i / (team_size * vector_length),
+                                        league_size, team_size, vector_length,
+                                        scratch_ptr, 0, 0);
+      m_functor(team);
     }
+  }
 
-
-  template< class TagType >
-  inline
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  execute_impl() const
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      const int league_size = m_policy.league_size();
-      const int team_size = m_policy.team_size();
-      const int vector_length = m_policy.vector_length();
-      const int nteams = OpenMPTargetExec::MAX_ACTIVE_TEAMS<league_size?OpenMPTargetExec::MAX_ACTIVE_TEAMS:league_size;
-
-      OpenMPTargetExec::resize_scratch(0,Policy::member_type::TEAM_REDUCE_SIZE,0,0);
-      void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
-      #pragma omp target teams distribute parallel for num_teams(league_size) num_threads(team_size*vector_length) schedule(static,1) \
-         map(to:this->m_functor,scratch_ptr)
-      for(int i=0 ; i<league_size ; i++) {
-        typename Policy::member_type team(i/(team_size*vector_length),league_size,team_size,vector_length, scratch_ptr, 0,0);
-        m_functor(TagType(), team);
-      }
+  template <class TagType>
+  inline typename std::enable_if<!std::is_same<TagType, void>::value>::type
+  execute_impl() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const int league_size   = m_policy.league_size();
+    const int team_size     = m_policy.team_size();
+    const int vector_length = m_policy.vector_length();
+    const int nteams        = OpenMPTargetExec::MAX_ACTIVE_TEAMS < league_size
+                           ? OpenMPTargetExec::MAX_ACTIVE_TEAMS
+                           : league_size;
+
+    OpenMPTargetExec::resize_scratch(0, Policy::member_type::TEAM_REDUCE_SIZE,
+                                     0, 0);
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+#pragma omp target teams distribute parallel for num_teams(league_size) \
+    num_threads(team_size* vector_length) schedule(static, 1)           \
+        map(to                                                          \
+            : this->m_functor, scratch_ptr)
+    for (int i = 0; i < league_size; i++) {
+      typename Policy::member_type team(i / (team_size * vector_length),
+                                        league_size, team_size, vector_length,
+                                        scratch_ptr, 0, 0);
+      m_functor(TagType(), team);
     }
+  }
 
-public:
-
-  inline
-  ParallelFor( const FunctorType & arg_functor ,
-               const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_shmem_size( arg_policy.scratch_size(0) + arg_policy.scratch_size(1) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , arg_policy.team_size() ) )
-    {}
+ public:
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                     FunctorTeamShmemSize<FunctorType>::value(
+                         arg_functor, arg_policy.team_size())) {}
 };
 
-template<class FunctorType, class ReducerType, class PointerType, class ValueType, class ... PolicyArgs>
-struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>, ReducerType, PointerType, ValueType, 0,0> {
+template <class FunctorType, class ReducerType, class PointerType,
+          class ValueType, class... PolicyArgs>
+struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
+                                ReducerType, PointerType, ValueType, 0, 0> {
   typedef TeamPolicyInternal<PolicyArgs...> PolicyType;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  execute_impl(const FunctorType& f, const PolicyType& p, PointerType result_ptr)
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-      
-      const int league_size = p.league_size();
-      const int team_size = p.team_size();
-      const int vector_length = p.vector_length();
-      const int nteams = OpenMPTargetExec::MAX_ACTIVE_TEAMS<league_size?OpenMPTargetExec::MAX_ACTIVE_TEAMS:league_size;
-      
-      OpenMPTargetExec::resize_scratch(0,PolicyType::member_type::TEAM_REDUCE_SIZE,0,0);
-      void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr(); 
-
-      ValueType result = ValueType();
-      #pragma omp target teams distribute parallel for num_teams(nteams) num_threads(team_size*vector_length) \
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      execute_impl(const FunctorType& f, const PolicyType& p,
+                   PointerType result_ptr) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+
+    const int league_size   = p.league_size();
+    const int team_size     = p.team_size();
+    const int vector_length = p.vector_length();
+    const int nteams        = OpenMPTargetExec::MAX_ACTIVE_TEAMS < league_size
+                           ? OpenMPTargetExec::MAX_ACTIVE_TEAMS
+                           : league_size;
+
+    OpenMPTargetExec::resize_scratch(
+        0, PolicyType::member_type::TEAM_REDUCE_SIZE, 0, 0);
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+
+    ValueType result = ValueType();
+#pragma omp target teams distribute parallel for num_teams(nteams) num_threads(team_size*vector_length) \
          map(to:f,scratch_ptr) map(tofrom:result) reduction(+: result) schedule(static,1)
-      for(int i=0 ; i<league_size*team_size*vector_length ; i++) {
-        typename PolicyType::member_type team(i/(team_size*vector_length),league_size,team_size,vector_length, scratch_ptr, 0,0);
-        f(team,result);
-        if(team.m_vector_lane!=0) result = 0;
-      }
-
-      *result_ptr=result;
+    for (int i = 0; i < league_size * team_size * vector_length; i++) {
+      typename PolicyType::member_type team(i / (team_size * vector_length),
+                                            league_size, team_size,
+                                            vector_length, scratch_ptr, 0, 0);
+      f(team, result);
+      if (team.m_vector_lane != 0) result = 0;
     }
 
+    *result_ptr = result;
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  execute_impl(const FunctorType& f, const PolicyType& p, PointerType result_ptr)
-    {
-      OpenMPTargetExec::verify_is_process("Kokkos::Experimental::OpenMPTarget parallel_for");
-      OpenMPTargetExec::verify_initialized("Kokkos::Experimental::OpenMPTarget parallel_for");
-
-      const int league_size = p.league_size();
-      const int team_size = p.team_size();
-      const int vector_length = p.vector_length();
-      const int nteams = OpenMPTargetExec::MAX_ACTIVE_TEAMS<league_size?OpenMPTargetExec::MAX_ACTIVE_TEAMS:league_size;
-
-      OpenMPTargetExec::resize_scratch(0,PolicyType::member_type::TEAM_REDUCE_SIZE,0,0);
-      void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
-
-      ValueType result = ValueType();
-      #pragma omp target teams distribute parallel for num_teams(nteams) num_threads(team_size*vector_length) \
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      execute_impl(const FunctorType& f, const PolicyType& p,
+                   PointerType result_ptr) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+
+    const int league_size   = p.league_size();
+    const int team_size     = p.team_size();
+    const int vector_length = p.vector_length();
+    const int nteams        = OpenMPTargetExec::MAX_ACTIVE_TEAMS < league_size
+                           ? OpenMPTargetExec::MAX_ACTIVE_TEAMS
+                           : league_size;
+
+    OpenMPTargetExec::resize_scratch(
+        0, PolicyType::member_type::TEAM_REDUCE_SIZE, 0, 0);
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+
+    ValueType result = ValueType();
+#pragma omp target teams distribute parallel for num_teams(nteams) num_threads(team_size*vector_length) \
          map(to:f,scratch_ptr) map(tofrom:result) reduction(+: result) schedule(static,1)
-      for(int i=0 ; i<league_size*team_size*vector_length ; i++) {
-        typename PolicyType::member_type team(i/(team_size*vector_length),league_size,team_size,vector_length, scratch_ptr, 0,0);
-        f(TagType(),team,result);
-        if(team.vector_lane!=0) result = 0;
-      }
-      *result_ptr=result;
+    for (int i = 0; i < league_size * team_size * vector_length; i++) {
+      typename PolicyType::member_type team(i / (team_size * vector_length),
+                                            league_size, team_size,
+                                            vector_length, scratch_ptr, 0, 0);
+      f(TagType(), team, result);
+      if (team.vector_lane != 0) result = 0;
     }
+    *result_ptr = result;
+  }
 
-
-    inline static
-    void execute(const FunctorType& f, const PolicyType& p, PointerType ptr) {
-      execute_impl<typename PolicyType::work_tag>(f,p,ptr);
-    }
+  inline static void execute(const FunctorType& f, const PolicyType& p,
+                             PointerType ptr) {
+    execute_impl<typename PolicyType::work_tag>(f, p, ptr);
+  }
 };
 
+template <class FunctorType, class ReducerType, class... Properties>
+class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                     ReducerType, Kokkos::Experimental::OpenMPTarget> {
+ private:
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget,
+                                           Properties...>
+      Policy;
 
-template< class FunctorType , class ReducerType, class ... Properties >
-class ParallelReduce< FunctorType
-                    , Kokkos::TeamPolicy< Properties ... >
-                    , ReducerType
-                    , Kokkos::Experimental::OpenMPTarget
-                    >
-{
-private:
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::Experimental::OpenMPTarget, Properties ... >         Policy ;
-
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::member_type  Member ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
-
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , WorkTagFwd >  ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd >  ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd , WorkTagFwd >  ValueJoin ;
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef typename ValueTraits::value_type      value_type ;
-
-  enum {HasJoin = ReduceFunctorHasJoin<FunctorType>::value };
-  enum {UseReducer = is_reducer_type<ReducerType>::value };
-
-  typedef ParallelReduceSpecialize<FunctorType,Policy,ReducerType,pointer_type,typename ValueTraits::value_type,HasJoin,UseReducer> ParForSpecialize;
-
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  const ReducerType  m_reducer ;
-  const pointer_type m_result_ptr ;
-  const int          m_shmem_size ;
-
-public:
-
-  inline
-  void execute() const {
-    ParForSpecialize::execute(m_functor,m_policy,m_result_ptr);   
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
+
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef typename ValueTraits::value_type value_type;
+
+  enum { HasJoin = ReduceFunctorHasJoin<FunctorType>::value };
+  enum { UseReducer = is_reducer_type<ReducerType>::value };
+
+  typedef ParallelReduceSpecialize<
+      FunctorType, Policy, ReducerType, pointer_type,
+      typename ValueTraits::value_type, HasJoin, UseReducer>
+      ParForSpecialize;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+  const int m_shmem_size;
+
+ public:
+  inline void execute() const {
+    ParForSpecialize::execute(m_functor, m_policy, m_result_ptr);
   }
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType  & arg_functor ,
-                  const Policy       & arg_policy ,
-                  const ViewType     & arg_result ,
-                  typename std::enable_if<
-                    Kokkos::is_view< ViewType >::value &&
-                    !Kokkos::is_reducer_type<ReducerType>::value
-                    ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result.ptr_on_device() )
-    , m_shmem_size( arg_policy.scratch_size(0) + arg_policy.scratch_size(1) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , arg_policy.team_size() ) )
-    {}
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-    , Policy       arg_policy
-    , const ReducerType& reducer )
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr(  reducer.result_view().data() )
-  , m_shmem_size( arg_policy.scratch_size(0) + arg_policy.scratch_size(1) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , arg_policy.team_size() ) )
-  {
-  /*static_assert( std::is_same< typename ViewType::memory_space
-                          , Kokkos::HostSpace >::value
-  , "Reduction result on Kokkos::Experimental::OpenMPTarget must be a Kokkos::View in HostSpace" );*/
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType& arg_functor, const Policy& arg_policy,
+      const ViewType& arg_result,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.ptr_on_device()),
+        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                     FunctorTeamShmemSize<FunctorType>::value(
+                         arg_functor, arg_policy.team_size())) {}
+
+  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                        const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.result_view().data()),
+        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                     FunctorTeamShmemSize<FunctorType>::value(
+                         arg_functor, arg_policy.team_size())) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                            , Kokkos::HostSpace >::value
+    , "Reduction result on Kokkos::Experimental::OpenMPTarget must be a
+    Kokkos::View in HostSpace" );*/
   }
-
 };
 
-} // namespace Impl
-} // namespace Kokkos
-
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 
-  template<typename iType>
-  struct TeamThreadRangeBoundariesStruct<iType,OpenMPTargetExecTeamMember> {
-    typedef iType index_type;
-    const iType start;
-    const iType end;
-    const iType increment;
-
-    inline
-    TeamThreadRangeBoundariesStruct (const OpenMPTargetExecTeamMember& thread_, iType count):
-      start( thread_.team_rank() ),
-      end( count ),
-      increment( thread_.team_size() )
-    {}
-    inline
-    TeamThreadRangeBoundariesStruct (const OpenMPTargetExecTeamMember& thread_, iType begin_, iType end_):
-      start( begin_+thread_.team_rank() ),
-      end( end_ ),
-      increment( thread_.team_size() )
-    {}
-  };
-
-  template<typename iType>
-  struct ThreadVectorRangeBoundariesStruct<iType,OpenMPTargetExecTeamMember> {
-    typedef iType index_type;
-    const index_type start;
-    const index_type end;
-    const index_type increment;
-
-    inline
-    ThreadVectorRangeBoundariesStruct (const OpenMPTargetExecTeamMember& thread_, index_type count):
-      start( thread_.m_vector_lane ),
-      end( count ),
-      increment( thread_.m_vector_length )
-    {}
-    inline
-    ThreadVectorRangeBoundariesStruct (const OpenMPTargetExecTeamMember& thread_, index_type begin_, index_type end_):
-      start( begin_+thread_.m_vector_lane ),
-      end( end_ ),
-      increment( thread_.m_vector_length )
-    {}
-  };
-
-  template<typename iType>
-  KOKKOS_INLINE_FUNCTION
-  Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>
-    TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread, iType count) {
-    return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>(thread,count);
-  }
-  
-  template<typename iType>
-  KOKKOS_INLINE_FUNCTION
-  Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>
-    TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread, iType begin, iType end) {
-    return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>(thread,begin,end);
-  }
+template <typename iType>
+struct TeamThreadRangeBoundariesStruct<iType, OpenMPTargetExecTeamMember> {
+  typedef iType index_type;
+  const iType start;
+  const iType end;
+  const iType increment;
+
+  inline TeamThreadRangeBoundariesStruct(
+      const OpenMPTargetExecTeamMember& thread_, iType count)
+      : start(thread_.team_rank()),
+        end(count),
+        increment(thread_.team_size()) {}
+  inline TeamThreadRangeBoundariesStruct(
+      const OpenMPTargetExecTeamMember& thread_, iType begin_, iType end_)
+      : start(begin_ + thread_.team_rank()),
+        end(end_),
+        increment(thread_.team_size()) {}
+};
 
-  template<typename iType>
-  KOKKOS_INLINE_FUNCTION
-  Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >
-    ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread, iType count) {
-    return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember >(thread,count);
-  }
+template <typename iType>
+struct ThreadVectorRangeBoundariesStruct<iType, OpenMPTargetExecTeamMember> {
+  typedef iType index_type;
+  const index_type start;
+  const index_type end;
+  const index_type increment;
+
+  inline ThreadVectorRangeBoundariesStruct(
+      const OpenMPTargetExecTeamMember& thread_, index_type count)
+      : start(thread_.m_vector_lane),
+        end(count),
+        increment(thread_.m_vector_length) {}
+  inline ThreadVectorRangeBoundariesStruct(
+      const OpenMPTargetExecTeamMember& thread_, index_type begin_,
+      index_type end_)
+      : start(begin_ + thread_.m_vector_lane),
+        end(end_),
+        increment(thread_.m_vector_length) {}
+};
 
-  template<typename iType>
-  KOKKOS_INLINE_FUNCTION
-  Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>
-    ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread, iType begin, iType end) {
-    return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::OpenMPTargetExecTeamMember>(thread,begin,end);
-  }
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread, iType count) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
+}
 
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread, iType begin,
+                iType end) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, begin, end);
 }
 
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread, iType count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
 }
+
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread, iType begin,
+                  iType end) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, begin, end);
+}
+
+}  // namespace Impl
+
+}  // namespace Kokkos
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* KOKKOS_OPENMPTARGET_PARALLEL_HPP */
-
diff --git a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.cpp b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.cpp
index dfd45486ef268c170fbb29a49dc6ac226424c832..be924ffa61c1f8cf696b3b84cb44765536fde4f9 100644
--- a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.cpp
+++ b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,14 +37,14 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
 #include <Kokkos_Core.hpp>
 
-#if defined( KOKKOS_ENABLE_OPENMPTARGET ) && defined( KOKKOS_ENABLE_TASKPOLICY )
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ENABLE_TASKPOLICY)
 
 #include <impl/Kokkos_TaskQueue_impl.hpp>
 
@@ -53,56 +54,51 @@
 namespace Kokkos {
 namespace Impl {
 
-template class TaskQueue< Kokkos::Experimental::OpenMPTarget > ;
+template class TaskQueue<Kokkos::Experimental::OpenMPTarget>;
 
 //----------------------------------------------------------------------------
 
-TaskExec< Kokkos::Experimental::OpenMPTarget >::
-TaskExec()
-  : m_self_exec( 0 )
-  , m_team_exec( 0 )
-  , m_sync_mask( 0 )
-  , m_sync_value( 0 )
-  , m_sync_step( 0 )
-  , m_group_rank( 0 )
-  , m_team_rank( 0 )
-  , m_team_size( 1 )
-{
-}
-
-TaskExec< Kokkos::Experimental::OpenMPTarget >::
-TaskExec( Kokkos::Impl::OpenMPTargetExec & arg_exec , int const arg_team_size )
-  : m_self_exec( & arg_exec )
-  , m_team_exec( arg_exec.pool_rev(arg_exec.pool_rank_rev() / arg_team_size) )
-  , m_sync_mask( 0 )
-  , m_sync_value( 0 )
-  , m_sync_step( 0 )
-  , m_group_rank( arg_exec.pool_rank_rev() / arg_team_size )
-  , m_team_rank(  arg_exec.pool_rank_rev() % arg_team_size )
-  , m_team_size(  arg_team_size )
-{
+TaskExec<Kokkos::Experimental::OpenMPTarget>::TaskExec()
+    : m_self_exec(0),
+      m_team_exec(0),
+      m_sync_mask(0),
+      m_sync_value(0),
+      m_sync_step(0),
+      m_group_rank(0),
+      m_team_rank(0),
+      m_team_size(1) {}
+
+TaskExec<Kokkos::Experimental::OpenMPTarget>::TaskExec(
+    Kokkos::Impl::OpenMPTargetExec &arg_exec, int const arg_team_size)
+    : m_self_exec(&arg_exec),
+      m_team_exec(arg_exec.pool_rev(arg_exec.pool_rank_rev() / arg_team_size)),
+      m_sync_mask(0),
+      m_sync_value(0),
+      m_sync_step(0),
+      m_group_rank(arg_exec.pool_rank_rev() / arg_team_size),
+      m_team_rank(arg_exec.pool_rank_rev() % arg_team_size),
+      m_team_size(arg_team_size) {
   // This team spans
   //    m_self_exec->pool_rev( team_size * group_rank )
   //    m_self_exec->pool_rev( team_size * ( group_rank + 1 ) - 1 )
 
-  int64_t volatile * const sync = (int64_t *) m_self_exec->scratch_reduce();
+  int64_t volatile *const sync = (int64_t *)m_self_exec->scratch_reduce();
 
-  sync[0] = int64_t(0) ;
-  sync[1] = int64_t(0) ;
+  sync[0] = int64_t(0);
+  sync[1] = int64_t(0);
 
-  for ( int i = 0 ; i < m_team_size ; ++i ) {
-    m_sync_value |= int64_t(1) << (8*i);
-    m_sync_mask  |= int64_t(3) << (8*i);
+  for (int i = 0; i < m_team_size; ++i) {
+    m_sync_value |= int64_t(1) << (8 * i);
+    m_sync_mask |= int64_t(3) << (8 * i);
   }
 
   Kokkos::memory_fence();
 }
 
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
 
-void TaskExec< Kokkos::Experimental::OpenMPTarget >::team_barrier_impl() const
-{
-  if ( m_team_exec->scratch_reduce_size() < int(2 * sizeof(int64_t)) ) {
+void TaskExec<Kokkos::Experimental::OpenMPTarget>::team_barrier_impl() const {
+  if (m_team_exec->scratch_reduce_size() < int(2 * sizeof(int64_t))) {
     Kokkos::abort("TaskQueue<OpenMPTarget> scratch_reduce memory too small");
   }
 
@@ -110,12 +106,11 @@ void TaskExec< Kokkos::Experimental::OpenMPTarget >::team_barrier_impl() const
   // Alternate memory locations between barriers to avoid a sequence
   // of barriers overtaking one another.
 
-  int64_t volatile * const sync =
-    ((int64_t *) m_team_exec->scratch_reduce()) + ( m_sync_step & 0x01 );
+  int64_t volatile *const sync =
+      ((int64_t *)m_team_exec->scratch_reduce()) + (m_sync_step & 0x01);
 
   // This team member sets one byte within the sync variable
-  int8_t volatile * const sync_self =
-   ((int8_t *) sync) + m_team_rank ;
+  int8_t volatile *const sync_self = ((int8_t *)sync) + m_team_rank;
 
 #if 0
 fprintf( stdout
@@ -129,9 +124,10 @@ fprintf( stdout
 fflush(stdout);
 #endif
 
-  *sync_self = int8_t( m_sync_value & 0x03 ); // signal arrival
+  *sync_self = int8_t(m_sync_value & 0x03);  // signal arrival
 
-  while ( m_sync_value != *sync ); // wait for team to arrive
+  while (m_sync_value != *sync)
+    ;  // wait for team to arrive
 
 #if 0
 fprintf( stdout
@@ -145,11 +141,11 @@ fprintf( stdout
 fflush(stdout);
 #endif
 
-  ++m_sync_step ;
+  ++m_sync_step;
 
-  if ( 0 == ( 0x01 & m_sync_step ) ) { // Every other step
-    m_sync_value ^= m_sync_mask ;
-    if ( 1000 < m_sync_step ) m_sync_step = 0 ;
+  if (0 == (0x01 & m_sync_step)) {  // Every other step
+    m_sync_value ^= m_sync_mask;
+    if (1000 < m_sync_step) m_sync_step = 0;
   }
 }
 
@@ -157,36 +153,35 @@ fflush(stdout);
 
 //----------------------------------------------------------------------------
 
-void TaskQueueSpecialization< Kokkos::Experimental::OpenMPTarget >::execute
-  ( TaskQueue< Kokkos::Experimental::OpenMPTarget > * const queue )
-{
-  using execution_space = Kokkos::Experimental::OpenMPTarget ;
-  using queue_type      = TaskQueue< execution_space > ;
-  using task_root_type  = TaskBase< execution_space , void , void > ;
-  using PoolExec        = Kokkos::Impl::OpenMPTargetExec ;
-  using Member          = TaskExec< execution_space > ;
+void TaskQueueSpecialization<Kokkos::Experimental::OpenMPTarget>::execute(
+    TaskQueue<Kokkos::Experimental::OpenMPTarget> *const queue) {
+  using execution_space = Kokkos::Experimental::OpenMPTarget;
+  using queue_type      = TaskQueue<execution_space>;
+  using task_root_type  = TaskBase<execution_space, void, void>;
+  using PoolExec        = Kokkos::Impl::OpenMPTargetExec;
+  using Member          = TaskExec<execution_space>;
 
-  task_root_type * const end = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const end = (task_root_type *)task_root_type::EndTag;
 
   // Required:  team_size <= 8
 
-  const int team_size = PoolExec::pool_size(2); // Threads per core
+  const int team_size = PoolExec::pool_size(2);  // Threads per core
   // const int team_size = PoolExec::pool_size(1); // Threads per NUMA
 
-  if ( 8 < team_size ) {
+  if (8 < team_size) {
     Kokkos::abort("TaskQueue<OpenMPTarget> unsupported team size");
   }
 
 #pragma omp parallel
   {
-    PoolExec & self = *PoolExec::get_thread_omp();
+    PoolExec &self = *PoolExec::get_thread_omp();
 
-    Member single_exec ;
-    Member team_exec( self , team_size );
+    Member single_exec;
+    Member team_exec(self, team_size);
 
     // Team shared memory
-    task_root_type * volatile * const task_shared =
-      (task_root_type **) team_exec.m_team_exec->scratch_thread();
+    task_root_type *volatile *const task_shared =
+        (task_root_type **)team_exec.m_team_exec->scratch_thread();
 
 // Barrier across entire OpenMPTarget thread pool to insure initialization
 #pragma omp barrier
@@ -194,29 +189,26 @@ void TaskQueueSpecialization< Kokkos::Experimental::OpenMPTarget >::execute
     // Loop until all queues are empty and no tasks in flight
 
     do {
-
-      task_root_type * task = 0 ;
+      task_root_type *task = 0;
 
       // Each team lead attempts to acquire either a thread team task
       // or a single thread task for the team.
 
-      if ( 0 == team_exec.team_rank() ) {
-
-        task = 0 < *((volatile int *) & queue->m_ready_count) ? end : 0 ;
+      if (0 == team_exec.team_rank()) {
+        task = 0 < *((volatile int *)&queue->m_ready_count) ? end : 0;
 
         // Loop by priority and then type
-        for ( int i = 0 ; i < queue_type::NumQueue && end == task ; ++i ) {
-          for ( int j = 0 ; j < 2 && end == task ; ++j ) {
-            task = queue_type::pop_task( & queue->m_ready[i][j] );
+        for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+          for (int j = 0; j < 2 && end == task; ++j) {
+            task = queue_type::pop_task(&queue->m_ready[i][j]);
           }
         }
       }
 
       // Team lead broadcast acquired task to team members:
 
-      if ( 1 < team_exec.team_size() ) {
-
-        if ( 0 == team_exec.team_rank() ) *task_shared = task ;
+      if (1 < team_exec.team_size()) {
+        if (0 == team_exec.team_rank()) *task_shared = task;
 
         // Fence to be sure task_shared is stored before the barrier
         Kokkos::memory_fence();
@@ -227,7 +219,7 @@ void TaskQueueSpecialization< Kokkos::Experimental::OpenMPTarget >::execute
         // Fence to be sure task_shared is stored
         Kokkos::memory_fence();
 
-        task = *task_shared ;
+        task = *task_shared;
       }
 
 #if 0
@@ -241,33 +233,30 @@ fprintf( stdout
 fflush(stdout);
 #endif
 
-      if ( 0 == task ) break ; // 0 == m_ready_count
+      if (0 == task) break;  // 0 == m_ready_count
 
-      if ( end == task ) {
+      if (end == task) {
         // All team members wait for whole team to reach this statement.
         // Is necessary to prevent task_shared from being updated
         // before it is read by all threads.
         team_exec.team_barrier();
-      }
-      else if ( task_root_type::TaskTeam == task->m_task_type ) {
+      } else if (task_root_type::TaskTeam == task->m_task_type) {
         // Thread Team Task
-        (*task->m_apply)( task , & team_exec );
+        (*task->m_apply)(task, &team_exec);
 
         // The m_apply function performs a barrier
 
-        if ( 0 == team_exec.team_rank() ) {
+        if (0 == team_exec.team_rank()) {
           // team member #0 completes the task, which may delete the task
-          queue->complete( task ); 
+          queue->complete(task);
         }
-      }
-      else {
+      } else {
         // Single Thread Task
 
-        if ( 0 == team_exec.team_rank() ) {
+        if (0 == team_exec.team_rank()) {
+          (*task->m_apply)(task, &single_exec);
 
-          (*task->m_apply)( task , & single_exec );
-
-          queue->complete( task ); 
+          queue->complete(task);
         }
 
         // All team members wait for whole team to reach this statement.
@@ -276,54 +265,50 @@ fflush(stdout);
         // before it is read by all threads.
         team_exec.team_barrier();
       }
-    } while(1);
+    } while (1);
   }
-// END #pragma omp parallel
-
+  // END #pragma omp parallel
 }
 
-void TaskQueueSpecialization< Kokkos::Experimental::OpenMPTarget >::
-  iff_single_thread_recursive_execute
-    ( TaskQueue< Kokkos::Experimental::OpenMPTarget > * const queue )
-{
-  using execution_space = Kokkos::Experimental::OpenMPTarget ;
-  using queue_type      = TaskQueue< execution_space > ;
-  using task_root_type  = TaskBase< execution_space , void , void > ;
-  using Member          = TaskExec< execution_space > ;
+void TaskQueueSpecialization<Kokkos::Experimental::OpenMPTarget>::
+    iff_single_thread_recursive_execute(
+        TaskQueue<Kokkos::Experimental::OpenMPTarget> *const queue) {
+  using execution_space = Kokkos::Experimental::OpenMPTarget;
+  using queue_type      = TaskQueue<execution_space>;
+  using task_root_type  = TaskBase<execution_space, void, void>;
+  using Member          = TaskExec<execution_space>;
 
-  if ( 1 == omp_get_num_threads() ) {
+  if (1 == omp_get_num_threads()) {
+    task_root_type *const end = (task_root_type *)task_root_type::EndTag;
 
-    task_root_type * const end = (task_root_type *) task_root_type::EndTag ;
+    Member single_exec;
 
-    Member single_exec ;
-
-    task_root_type * task = end ;
+    task_root_type *task = end;
 
     do {
-
-      task = end ;
+      task = end;
 
       // Loop by priority and then type
-      for ( int i = 0 ; i < queue_type::NumQueue && end == task ; ++i ) {
-        for ( int j = 0 ; j < 2 && end == task ; ++j ) {
-          task = queue_type::pop_task( & queue->m_ready[i][j] );
+      for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+        for (int j = 0; j < 2 && end == task; ++j) {
+          task = queue_type::pop_task(&queue->m_ready[i][j]);
         }
       }
 
-      if ( end == task ) break ;
+      if (end == task) break;
 
-      (*task->m_apply)( task , & single_exec );
+      (*task->m_apply)(task, &single_exec);
 
-      queue->complete( task ); 
+      queue->complete(task);
 
-    } while(1);
+    } while (1);
   }
 }
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
-#endif /* #if defined( KOKKOS_ENABLE_OPENMPTARGET ) && defined( KOKKOS_ENABLE_TASKPOLICY ) */
-
-
+#endif /* #if defined( KOKKOS_ENABLE_OPENMPTARGET ) && defined( \
+          KOKKOS_ENABLE_TASKPOLICY ) */
diff --git a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.hpp b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.hpp
index fe9ac4abb4a8521b2d02e6a943aaf2fa05353cc5..a40ec19e798a31dfec081a33d0bc4a8d9b2ce51c 100644
--- a/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.hpp
+++ b/lib/kokkos/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Task.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -44,7 +45,7 @@
 #ifndef KOKKOS_IMPL_OPENMP_TASK_HPP
 #define KOKKOS_IMPL_OPENMP_TASK_HPP
 
-#if defined( KOKKOS_ENABLE_TASKPOLICY )
+#if defined(KOKKOS_ENABLE_TASKPOLICY)
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -52,161 +53,156 @@
 namespace Kokkos {
 namespace Impl {
 
-template<>
-class TaskQueueSpecialization< Kokkos::Experimental::OpenMPTarget >
-{
-public:
-
-  using execution_space = Kokkos::Experimental::OpenMPTarget ;
-  using queue_type      = Kokkos::Impl::TaskQueue< execution_space > ;
-  using task_base_type  = Kokkos::Impl::TaskBase< execution_space , void , void > ;
+template <>
+class TaskQueueSpecialization<Kokkos::Experimental::OpenMPTarget> {
+ public:
+  using execution_space = Kokkos::Experimental::OpenMPTarget;
+  using queue_type      = Kokkos::Impl::TaskQueue<execution_space>;
+  using task_base_type  = Kokkos::Impl::TaskBase<execution_space, void, void>;
 
   // Must specify memory space
-  using memory_space = Kokkos::HostSpace ;
+  using memory_space = Kokkos::HostSpace;
 
-  static
-  void iff_single_thread_recursive_execute( queue_type * const );
+  static void iff_single_thread_recursive_execute(queue_type* const);
 
   // Must provide task queue execution function
-  static void execute( queue_type * const );
+  static void execute(queue_type* const);
 
   // Must provide mechanism to set function pointer in
   // execution space from the host process.
-  template< typename FunctorType >
-  static
-  void proc_set_apply( task_base_type::function_type * ptr )
-    {
-      using TaskType = TaskBase< Kokkos::Experimental::OpenMPTarget
-                               , typename FunctorType::value_type
-                               , FunctorType
-                               > ;
-       *ptr = TaskType::apply ;
-    }
+  template <typename FunctorType>
+  static void proc_set_apply(task_base_type::function_type* ptr) {
+    using TaskType = TaskBase<Kokkos::Experimental::OpenMPTarget,
+                              typename FunctorType::value_type, FunctorType>;
+    *ptr           = TaskType::apply;
+  }
 };
 
-extern template class TaskQueue< Kokkos::Experimental::OpenMPTarget > ;
+extern template class TaskQueue<Kokkos::Experimental::OpenMPTarget>;
 
 //----------------------------------------------------------------------------
 
-template<>
-class TaskExec< Kokkos::Experimental::OpenMPTarget >
-{
-private:
-
-  TaskExec( TaskExec && ) = delete ;
-  TaskExec( TaskExec const & ) = delete ;
-  TaskExec & operator = ( TaskExec && ) = delete ;
-  TaskExec & operator = ( TaskExec const & ) = delete ;
-
-
-  using PoolExec = Kokkos::Impl::OpenMPTargetExec ;
-
-  friend class Kokkos::Impl::TaskQueue< Kokkos::Experimental::OpenMPTarget > ;
-  friend class Kokkos::Impl::TaskQueueSpecialization< Kokkos::Experimental::OpenMPTarget > ;
-
-  PoolExec * const m_self_exec ;  ///< This thread's thread pool data structure 
-  PoolExec * const m_team_exec ;  ///< Team thread's thread pool data structure
-  int64_t          m_sync_mask ;
-  int64_t mutable  m_sync_value ;
-  int     mutable  m_sync_step ;
-  int              m_group_rank ; ///< Which "team" subset of thread pool
-  int              m_team_rank ;  ///< Which thread within a team
-  int              m_team_size ;
+template <>
+class TaskExec<Kokkos::Experimental::OpenMPTarget> {
+ private:
+  TaskExec(TaskExec&&)      = delete;
+  TaskExec(TaskExec const&) = delete;
+  TaskExec& operator=(TaskExec&&) = delete;
+  TaskExec& operator=(TaskExec const&) = delete;
+
+  using PoolExec = Kokkos::Impl::OpenMPTargetExec;
+
+  friend class Kokkos::Impl::TaskQueue<Kokkos::Experimental::OpenMPTarget>;
+  friend class Kokkos::Impl::TaskQueueSpecialization<
+      Kokkos::Experimental::OpenMPTarget>;
+
+  PoolExec* const m_self_exec;  ///< This thread's thread pool data structure
+  PoolExec* const m_team_exec;  ///< Team thread's thread pool data structure
+  int64_t m_sync_mask;
+  int64_t mutable m_sync_value;
+  int mutable m_sync_step;
+  int m_group_rank;  ///< Which "team" subset of thread pool
+  int m_team_rank;   ///< Which thread within a team
+  int m_team_size;
 
   TaskExec();
-  TaskExec( PoolExec & arg_exec , int arg_team_size );
-
-  void team_barrier_impl() const ;
+  TaskExec(PoolExec& arg_exec, int arg_team_size);
 
-public:
+  void team_barrier_impl() const;
 
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  void * team_shared() const
-    { return m_team_exec ? m_team_exec->scratch_thread() : (void*) 0 ; }
+ public:
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  void* team_shared() const {
+    return m_team_exec ? m_team_exec->scratch_thread() : (void*)0;
+  }
 
-  int team_shared_size() const
-    { return m_team_exec ? m_team_exec->scratch_thread_size() : 0 ; }
+  int team_shared_size() const {
+    return m_team_exec ? m_team_exec->scratch_thread_size() : 0;
+  }
 
   /**\brief  Whole team enters this function call
    *         before any teeam member returns from
    *         this function call.
    */
-  void team_barrier() const { if ( 1 < m_team_size ) team_barrier_impl(); }
+  void team_barrier() const {
+    if (1 < m_team_size) team_barrier_impl();
+  }
 #else
   KOKKOS_INLINE_FUNCTION void team_barrier() const {}
-  KOKKOS_INLINE_FUNCTION void * team_shared() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION int team_shared_size() const { return 0 ; }
+  KOKKOS_INLINE_FUNCTION void* team_shared() const { return 0; }
+  KOKKOS_INLINE_FUNCTION int team_shared_size() const { return 0; }
 #endif
 
   KOKKOS_INLINE_FUNCTION
-  int team_rank() const { return m_team_rank ; }
+  int team_rank() const { return m_team_rank; }
 
   KOKKOS_INLINE_FUNCTION
-  int team_size() const { return m_team_size ; }
+  int team_size() const { return m_team_size; }
 };
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > >
-TeamThreadRange
-  ( Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > & thread
-  , const iType & count )
-{
-  return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > >(thread,count);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >
+TeamThreadRange(Impl::TaskExec<Kokkos::Experimental::OpenMPTarget>& thread,
+                const iType& count) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >(thread,
+                                                                  count);
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType,Impl:: TaskExec< Kokkos::Experimental::OpenMPTarget > >
-TeamThreadRange
-  ( Impl:: TaskExec< Kokkos::Experimental::OpenMPTarget > & thread
-  , const iType & start
-  , const iType & end )
-{
-  return Impl::TeamThreadRangeBoundariesStruct<iType,Impl:: TaskExec< Kokkos::Experimental::OpenMPTarget > >(thread,start,end);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >
+TeamThreadRange(Impl::TaskExec<Kokkos::Experimental::OpenMPTarget>& thread,
+                const iType& start, const iType& end) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >(thread, start,
+                                                                  end);
 }
 
-/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all threads of the the calling thread team.
  * This functionality requires C++11 support.
-*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl:: TaskExec< Kokkos::Experimental::OpenMPTarget > >& loop_boundaries
-  , const Lambda& lambda
-  )
-{
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+ */
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >&
+        loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i);
   }
 }
 
-template<typename iType, class Lambda, typename ValueType>
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl:: TaskExec< Kokkos::Experimental::OpenMPTarget > >& loop_boundaries
-  , const Lambda& lambda
-  , ValueType& initialized_result)
-{
-  int team_rank = loop_boundaries.thread.team_rank(); // member num within the team
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >&
+        loop_boundaries,
+    const Lambda& lambda, ValueType& initialized_result) {
+  int team_rank =
+      loop_boundaries.thread.team_rank();  // member num within the team
   ValueType result = initialized_result;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i, result);
   }
 
-  if ( 1 < loop_boundaries.thread.team_size() ) {
-
-    ValueType *shared = (ValueType*) loop_boundaries.thread.team_shared();
+  if (1 < loop_boundaries.thread.team_size()) {
+    ValueType* shared = (ValueType*)loop_boundaries.thread.team_shared();
 
     loop_boundaries.thread.team_barrier();
     shared[team_rank] = result;
@@ -224,29 +220,28 @@ void parallel_reduce
 
     // broadcast result
     initialized_result = shared[0];
-  }
-  else {
-    initialized_result = result ;
+  } else {
+    initialized_result = result;
   }
 }
 
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > >& loop_boundaries,
-   const Lambda & lambda,
-   const JoinType & join,
-   ValueType& initialized_result)
-{
-  int team_rank = loop_boundaries.thread.team_rank(); // member num within the team
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >&
+        loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& initialized_result) {
+  int team_rank =
+      loop_boundaries.thread.team_rank();  // member num within the team
   ValueType result = initialized_result;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i, result);
   }
 
-  if ( 1 < loop_boundaries.thread.team_size() ) {
-    ValueType *shared = (ValueType*) loop_boundaries.thread.team_shared();
+  if (1 < loop_boundaries.thread.team_size()) {
+    ValueType* shared = (ValueType*)loop_boundaries.thread.team_shared();
 
     loop_boundaries.thread.team_barrier();
     shared[team_rank] = result;
@@ -264,51 +259,48 @@ void parallel_reduce
 
     // broadcast result
     initialized_result = shared[0];
-  }
-  else {
-    initialized_result = result ;
+  } else {
+    initialized_result = result;
   }
 }
 
 // placeholder for future function
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > >& loop_boundaries,
-   const Lambda & lambda,
-   ValueType& initialized_result)
-{
-}
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >&
+        loop_boundaries,
+    const Lambda& lambda, ValueType& initialized_result) {}
 
 // placeholder for future function
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > >& loop_boundaries,
-   const Lambda & lambda,
-   const JoinType & join,
-   ValueType& initialized_result)
-{
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >&
+        loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& initialized_result) {
 }
 
-template< typename ValueType, typename iType, class Lambda >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > >& loop_boundaries,
-   const Lambda & lambda)
-{
-  ValueType accum = 0 ;
+template <typename ValueType, typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >&
+        loop_boundaries,
+    const Lambda& lambda) {
+  ValueType accum = 0;
   ValueType val, local_total;
-  ValueType *shared = (ValueType*) loop_boundaries.thread.team_shared();
-  int team_size = loop_boundaries.thread.team_size();
-  int team_rank = loop_boundaries.thread.team_rank(); // member num within the team
+  ValueType* shared = (ValueType*)loop_boundaries.thread.team_shared();
+  int team_size     = loop_boundaries.thread.team_size();
+  int team_rank =
+      loop_boundaries.thread.team_rank();  // member num within the team
 
   // Intra-member scan
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     local_total = 0;
-    lambda(i,local_total,false);
+    lambda(i, local_total, false);
     val = accum;
-    lambda(i,val,true);
+    lambda(i, val, true);
     accum += local_total;
   }
 
@@ -317,34 +309,35 @@ void parallel_scan
 
   // Member 0 do scan on accumulated totals
   if (team_rank == 0) {
-    for( iType i = 1; i < team_size; i+=1) {
-      shared[i] += shared[i-1];
+    for (iType i = 1; i < team_size; i += 1) {
+      shared[i] += shared[i - 1];
     }
-    accum = 0; // Member 0 set accum to 0 in preparation for inter-member scan
+    accum = 0;  // Member 0 set accum to 0 in preparation for inter-member scan
   }
 
   loop_boundaries.thread.team_barrier();
 
   // Inter-member scan adding in accumulated totals
-  if (team_rank != 0) { accum = shared[team_rank-1]; }
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  if (team_rank != 0) {
+    accum = shared[team_rank - 1];
+  }
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     local_total = 0;
-    lambda(i,local_total,false);
+    lambda(i, local_total, false);
     val = accum;
-    lambda(i,val,true);
+    lambda(i, val, true);
     accum += local_total;
   }
 }
 
 // placeholder for future function
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::OpenMPTarget > >& loop_boundaries,
-   const Lambda & lambda)
-{
-}
-
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::OpenMPTarget> >&
+        loop_boundaries,
+    const Lambda& lambda) {}
 
 } /* namespace Kokkos */
 
@@ -353,4 +346,3 @@ void parallel_scan
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKPOLICY ) */
 #endif /* #ifndef KOKKOS_IMPL_OPENMP_TASK_HPP */
-
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.cpp b/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.cpp
index b37a4c63b93b7bf2ee45679c609ae0637f898e1d..4372f3ce807fd8424f22c451205facd0c6503bdf 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.cpp
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS )
+#if defined(KOKKOS_ENABLE_QTHREADS)
 
 #include <Kokkos_Core_fwd.hpp>
 
@@ -76,92 +77,88 @@ enum { MAXIMUM_QTHREADS_WORKERS = 1024 };
  *  for faster fan-in / fan-out lookups
  *  [ n - 1, n - 2, ..., 0 ]
  */
-QthreadsExec * s_exec[ MAXIMUM_QTHREADS_WORKERS ];
+QthreadsExec *s_exec[MAXIMUM_QTHREADS_WORKERS];
 
-int  s_number_shepherds            = 0;
-int  s_number_workers_per_shepherd = 0;
-int  s_number_workers              = 0;
+int s_number_shepherds            = 0;
+int s_number_workers_per_shepherd = 0;
+int s_number_workers              = 0;
 
-inline
-QthreadsExec ** worker_exec()
-{
-  return s_exec + s_number_workers - ( qthread_shep() * s_number_workers_per_shepherd + qthread_worker_local( NULL ) + 1 );
+inline QthreadsExec **worker_exec() {
+  return s_exec + s_number_workers -
+         (qthread_shep() * s_number_workers_per_shepherd +
+          qthread_worker_local(NULL) + 1);
 }
 
-const int s_base_size = QthreadsExec::align_alloc( sizeof(QthreadsExec) );
+const int s_base_size = QthreadsExec::align_alloc(sizeof(QthreadsExec));
 
 int s_worker_reduce_end   = 0;  // End of worker reduction memory.
 int s_worker_shared_end   = 0;  // Total of worker scratch memory.
 int s_worker_shared_begin = 0;  // Beginning of worker shared memory.
 
-QthreadsExecFunctionPointer volatile s_active_function     = 0;
-const void                * volatile s_active_function_arg = 0;
+QthreadsExecFunctionPointer volatile s_active_function = 0;
+const void *volatile s_active_function_arg             = 0;
 
-} // namespace
+}  // namespace
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-int Qthreads::is_initialized()
-{
-  return Impl::s_number_workers != 0;
-}
+int Qthreads::is_initialized() { return Impl::s_number_workers != 0; }
 
-int Qthreads::concurrency()
-{
-  return Impl::s_number_workers_per_shepherd;
-}
+int Qthreads::concurrency() { return Impl::s_number_workers_per_shepherd; }
 
-int Qthreads::in_parallel()
-{
-  return Impl::s_active_function != 0;
-}
+int Qthreads::in_parallel() { return Impl::s_active_function != 0; }
 
-void Qthreads::initialize( int thread_count )
-{
+void Qthreads::initialize(int thread_count) {
   // Environment variable: QTHREAD_NUM_SHEPHERDS
   // Environment variable: QTHREAD_NUM_WORKERS_PER_SHEP
   // Environment variable: QTHREAD_HWPAR
 
   {
     char buffer[256];
-    snprintf( buffer, sizeof(buffer), "QTHREAD_HWPAR=%d", thread_count );
-    putenv( buffer );
+    snprintf(buffer, sizeof(buffer), "QTHREAD_HWPAR=%d", thread_count);
+    putenv(buffer);
   }
 
-  const bool ok_init = ( QTHREAD_SUCCESS == qthread_initialize() ) &&
-                       ( thread_count    == qthread_num_shepherds() * qthread_num_workers_local( NO_SHEPHERD ) ) &&
-                       ( thread_count    == qthread_num_workers() );
+  const bool ok_init =
+      (QTHREAD_SUCCESS == qthread_initialize()) &&
+      (thread_count ==
+       qthread_num_shepherds() * qthread_num_workers_local(NO_SHEPHERD)) &&
+      (thread_count == qthread_num_workers());
 
   bool ok_symmetry = true;
 
-  if ( ok_init ) {
-    Impl::s_number_shepherds            = qthread_num_shepherds();
-    Impl::s_number_workers_per_shepherd = qthread_num_workers_local( NO_SHEPHERD );
-    Impl::s_number_workers              = Impl::s_number_shepherds * Impl::s_number_workers_per_shepherd;
+  if (ok_init) {
+    Impl::s_number_shepherds = qthread_num_shepherds();
+    Impl::s_number_workers_per_shepherd =
+        qthread_num_workers_local(NO_SHEPHERD);
+    Impl::s_number_workers =
+        Impl::s_number_shepherds * Impl::s_number_workers_per_shepherd;
 
-    for ( int i = 0; ok_symmetry && i < Impl::s_number_shepherds; ++i ) {
-      ok_symmetry = ( Impl::s_number_workers_per_shepherd == qthread_num_workers_local( i ) );
+    for (int i = 0; ok_symmetry && i < Impl::s_number_shepherds; ++i) {
+      ok_symmetry =
+          (Impl::s_number_workers_per_shepherd == qthread_num_workers_local(i));
     }
   }
 
-  if ( ! ok_init || ! ok_symmetry ) {
+  if (!ok_init || !ok_symmetry) {
     std::ostringstream msg;
 
     msg << "Kokkos::Qthreads::initialize(" << thread_count << ") FAILED";
     msg << " : qthread_num_shepherds = " << qthread_num_shepherds();
-    msg << " : qthread_num_workers_per_shepherd = " << qthread_num_workers_local( NO_SHEPHERD );
+    msg << " : qthread_num_workers_per_shepherd = "
+        << qthread_num_workers_local(NO_SHEPHERD);
     msg << " : qthread_num_workers = " << qthread_num_workers();
 
-    if ( ! ok_symmetry ) {
+    if (!ok_symmetry) {
       msg << " : qthread_num_workers_local = {";
-      for ( int i = 0; i < Impl::s_number_shepherds; ++i ) {
-        msg << " " << qthread_num_workers_local( i );
+      for (int i = 0; i < Impl::s_number_shepherds; ++i) {
+        msg << " " << qthread_num_workers_local(i);
       }
       msg << " }";
     }
@@ -170,23 +167,23 @@ void Qthreads::initialize( int thread_count )
     Impl::s_number_shepherds            = 0;
     Impl::s_number_workers_per_shepherd = 0;
 
-    if ( ok_init ) { qthread_finalize(); }
+    if (ok_init) {
+      qthread_finalize();
+    }
 
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
-  Impl::QthreadsExec::resize_worker_scratch( 256, 256 );
+  Impl::QthreadsExec::resize_worker_scratch(256, 256);
 
   // Init the array for used for arbitrarily sized atomics.
   Impl::init_lock_array_host_space();
-
 }
 
-void Qthreads::finalize()
-{
+void Qthreads::finalize() {
   Impl::QthreadsExec::clear_workers();
 
-  if ( Impl::s_number_workers ) {
+  if (Impl::s_number_workers) {
     qthread_finalize();
   }
 
@@ -195,30 +192,29 @@ void Qthreads::finalize()
   Impl::s_number_workers_per_shepherd = 0;
 }
 
-void Qthreads::print_configuration( std::ostream & s, const bool detail )
-{
+void Qthreads::print_configuration(std::ostream &s, const bool detail) {
   s << "Kokkos::Qthreads {"
     << " num_shepherds(" << Impl::s_number_shepherds << ")"
-    << " num_workers_per_shepherd(" << Impl::s_number_workers_per_shepherd << ")"
+    << " num_workers_per_shepherd(" << Impl::s_number_workers_per_shepherd
+    << ")"
     << " }" << std::endl;
 }
 
-Qthreads & Qthreads::instance( int )
-{
+Qthreads &Qthreads::instance(int) {
   static Qthreads q;
   return q;
 }
 
-void Qthreads::fence()
-{
-}
+void Qthreads::fence() {}
 
 int Qthreads::shepherd_size() const { return Impl::s_number_shepherds; }
-int Qthreads::shepherd_worker_size() const { return Impl::s_number_workers_per_shepherd; }
+int Qthreads::shepherd_worker_size() const {
+  return Impl::s_number_workers_per_shepherd;
+}
 
-const char* Qthreads::name() { return "Qthreads"; }
+const char *Qthreads::name() { return "Qthreads"; }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -228,108 +224,110 @@ namespace Impl {
 
 namespace {
 
-aligned_t driver_exec_all( void * arg )
-{
-  QthreadsExec & exec = **worker_exec();
+aligned_t driver_exec_all(void *arg) {
+  QthreadsExec &exec = **worker_exec();
 
-  (*s_active_function)( exec, s_active_function_arg );
+  (*s_active_function)(exec, s_active_function_arg);
 
-/*
-  fprintf( stdout
-         , "QthreadsExec driver worker(%d:%d) shepherd(%d:%d) shepherd_worker(%d:%d) done\n"
-         , exec.worker_rank()
-         , exec.worker_size()
-         , exec.shepherd_rank()
-         , exec.shepherd_size()
-         , exec.shepherd_worker_rank()
-         , exec.shepherd_worker_size()
-         );
-  fflush(stdout);
-*/
+  /*
+    fprintf( stdout
+           , "QthreadsExec driver worker(%d:%d) shepherd(%d:%d)
+    shepherd_worker(%d:%d) done\n" , exec.worker_rank() , exec.worker_size() ,
+    exec.shepherd_rank() , exec.shepherd_size() , exec.shepherd_worker_rank() ,
+    exec.shepherd_worker_size()
+           );
+    fflush(stdout);
+  */
 
   return 0;
 }
 
-aligned_t driver_resize_worker_scratch( void * arg )
-{
+aligned_t driver_resize_worker_scratch(void *arg) {
   static volatile int lock_begin = 0;
   static volatile int lock_end   = 0;
 
-  QthreadsExec ** const exec = worker_exec();
+  QthreadsExec **const exec = worker_exec();
 
   //----------------------------------------
   // Serialize allocation for thread safety.
 
-  while ( ! atomic_compare_exchange_strong( & lock_begin, 0, 1 ) ); // Spin wait to claim lock.
+  while (!atomic_compare_exchange_strong(&lock_begin, 0, 1))
+    ;  // Spin wait to claim lock.
 
   const bool ok = 0 == *exec;
 
-  if ( ok ) { *exec = (QthreadsExec *) malloc( s_base_size + s_worker_shared_end ); }
+  if (ok) {
+    *exec = (QthreadsExec *)malloc(s_base_size + s_worker_shared_end);
+  }
 
-  lock_begin = 0; // Release lock.
+  lock_begin = 0;  // Release lock.
 
-  if ( ok ) { new( *exec ) QthreadsExec(); }
+  if (ok) {
+    new (*exec) QthreadsExec();
+  }
 
   //----------------------------------------
   // Wait for all calls to complete to insure that each worker has executed.
 
-  if ( s_number_workers == 1 + atomic_fetch_add( & lock_end, 1 ) ) { lock_end = 0; }
+  if (s_number_workers == 1 + atomic_fetch_add(&lock_end, 1)) {
+    lock_end = 0;
+  }
 
-  while ( lock_end );
+  while (lock_end)
+    ;
 
-/*
-  fprintf( stdout
-         , "QthreadsExec resize worker(%d:%d) shepherd(%d:%d) shepherd_worker(%d:%d) done\n"
-         , (**exec).worker_rank()
-         , (**exec).worker_size()
-         , (**exec).shepherd_rank()
-         , (**exec).shepherd_size()
-         , (**exec).shepherd_worker_rank()
-         , (**exec).shepherd_worker_size()
-         );
-  fflush(stdout);
-*/
+  /*
+    fprintf( stdout
+           , "QthreadsExec resize worker(%d:%d) shepherd(%d:%d)
+    shepherd_worker(%d:%d) done\n" , (**exec).worker_rank() ,
+    (**exec).worker_size() , (**exec).shepherd_rank() , (**exec).shepherd_size()
+           , (**exec).shepherd_worker_rank()
+           , (**exec).shepherd_worker_size()
+           );
+    fflush(stdout);
+  */
 
   //----------------------------------------
 
-  if ( ! ok ) {
-    fprintf( stderr, "Kokkos::QthreadsExec resize failed\n" );
-    fflush( stderr );
+  if (!ok) {
+    fprintf(stderr, "Kokkos::QthreadsExec resize failed\n");
+    fflush(stderr);
   }
 
   return 0;
 }
 
-void verify_is_process( const char * const label, bool not_active = false )
-{
-  const bool not_process = 0 != qthread_shep() || 0 != qthread_worker_local( NULL );
-  const bool is_active   = not_active && ( s_active_function || s_active_function_arg );
-
-  if ( not_process || is_active ) {
-    std::string msg( label );
-    msg.append( " : FAILED" );
-    if ( not_process ) msg.append(" : not called by main process");
-    if ( is_active )   msg.append(" : parallel execution in progress");
-    Kokkos::Impl::throw_runtime_exception( msg );
+void verify_is_process(const char *const label, bool not_active = false) {
+  const bool not_process =
+      0 != qthread_shep() || 0 != qthread_worker_local(NULL);
+  const bool is_active =
+      not_active && (s_active_function || s_active_function_arg);
+
+  if (not_process || is_active) {
+    std::string msg(label);
+    msg.append(" : FAILED");
+    if (not_process) msg.append(" : not called by main process");
+    if (is_active) msg.append(" : parallel execution in progress");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
 }
 
-} // namespace
+}  // namespace
 
-int QthreadsExec::worker_per_shepherd()
-{
+int QthreadsExec::worker_per_shepherd() {
   return s_number_workers_per_shepherd;
 }
 
-QthreadsExec::QthreadsExec()
-{
+QthreadsExec::QthreadsExec() {
   const int shepherd_rank        = qthread_shep();
-  const int shepherd_worker_rank = qthread_worker_local( NULL );
-  const int worker_rank          = shepherd_rank * s_number_workers_per_shepherd + shepherd_worker_rank;
-
-  m_worker_base          = s_exec;
-  m_shepherd_base        = s_exec + s_number_workers_per_shepherd * ( ( s_number_shepherds - ( shepherd_rank + 1 ) ) );
-  m_scratch_alloc        = ( (unsigned char *) this ) + s_base_size;
+  const int shepherd_worker_rank = qthread_worker_local(NULL);
+  const int worker_rank =
+      shepherd_rank * s_number_workers_per_shepherd + shepherd_worker_rank;
+
+  m_worker_base   = s_exec;
+  m_shepherd_base = s_exec + s_number_workers_per_shepherd *
+                                 ((s_number_shepherds - (shepherd_rank + 1)));
+  m_scratch_alloc        = ((unsigned char *)this) + s_base_size;
   m_reduce_end           = s_worker_reduce_end;
   m_shepherd_rank        = shepherd_rank;
   m_shepherd_size        = s_number_shepherds;
@@ -340,37 +338,34 @@ QthreadsExec::QthreadsExec()
   m_worker_state         = QthreadsExec::Active;
 }
 
-void QthreadsExec::clear_workers()
-{
-  for ( int iwork = 0; iwork < s_number_workers; ++iwork ) {
-    QthreadsExec * const exec = s_exec[iwork];
-    s_exec[iwork] = 0;
-    free( exec );
+void QthreadsExec::clear_workers() {
+  for (int iwork = 0; iwork < s_number_workers; ++iwork) {
+    QthreadsExec *const exec = s_exec[iwork];
+    s_exec[iwork]            = 0;
+    free(exec);
   }
 }
 
-void QthreadsExec::shared_reset( Qthreads::scratch_memory_space & space )
-{
-  new( & space )
-    Qthreads::scratch_memory_space(
-      ((unsigned char *) (**m_shepherd_base).m_scratch_alloc ) + s_worker_shared_begin,
-      s_worker_shared_end - s_worker_shared_begin
-    );
+void QthreadsExec::shared_reset(Qthreads::scratch_memory_space &space) {
+  new (&space) Qthreads::scratch_memory_space(
+      ((unsigned char *)(**m_shepherd_base).m_scratch_alloc) +
+          s_worker_shared_begin,
+      s_worker_shared_end - s_worker_shared_begin);
 }
 
-void QthreadsExec::resize_worker_scratch( const int reduce_size, const int shared_size )
-{
-  const int exec_all_reduce_alloc = align_alloc( reduce_size );
-  const int shepherd_scan_alloc   = align_alloc( 8 );
-  const int shepherd_shared_end   = exec_all_reduce_alloc + shepherd_scan_alloc + align_alloc( shared_size );
+void QthreadsExec::resize_worker_scratch(const int reduce_size,
+                                         const int shared_size) {
+  const int exec_all_reduce_alloc = align_alloc(reduce_size);
+  const int shepherd_scan_alloc   = align_alloc(8);
+  const int shepherd_shared_end =
+      exec_all_reduce_alloc + shepherd_scan_alloc + align_alloc(shared_size);
 
-  if ( s_worker_reduce_end < exec_all_reduce_alloc ||
-       s_worker_shared_end < shepherd_shared_end ) {
-
-/*
-  fprintf( stdout, "QthreadsExec::resize\n");
-  fflush(stdout);
-*/
+  if (s_worker_reduce_end < exec_all_reduce_alloc ||
+      s_worker_shared_end < shepherd_shared_end) {
+    /*
+      fprintf( stdout, "QthreadsExec::resize\n");
+      fflush(stdout);
+    */
 
     // Clear current worker memory before allocating new worker memory.
     clear_workers();
@@ -393,51 +388,62 @@ void QthreadsExec::resize_worker_scratch( const int reduce_size, const int share
     }
 #else
     // If this function is used before the 'qthreads.task_policy' unit test,
-    // the 'qthreads.task_policy' unit test fails with a seg-fault within libqthread.so.
-    for ( int jshep = 0; jshep < s_number_shepherds; ++jshep ) {
-      const int num_clone = jshep != main_shep ? s_number_workers_per_shepherd : s_number_workers_per_shepherd - 1;
-
-      if ( num_clone ) {
-        const int ret = qthread_fork_clones_to_local_priority
-          ( driver_resize_worker_scratch   // Function
-          , NULL                           // Function data block
-          , NULL                           // Pointer to return value feb
-          , jshep                          // Shepherd number
-          , num_clone - 1                  // Number of instances - 1
-          );
-
-        assert( ret == QTHREAD_SUCCESS );
+    // the 'qthreads.task_policy' unit test fails with a seg-fault within
+    // libqthread.so.
+    for (int jshep = 0; jshep < s_number_shepherds; ++jshep) {
+      const int num_clone = jshep != main_shep
+                                ? s_number_workers_per_shepherd
+                                : s_number_workers_per_shepherd - 1;
+
+      if (num_clone) {
+        const int ret = qthread_fork_clones_to_local_priority(
+            driver_resize_worker_scratch  // Function
+            ,
+            NULL  // Function data block
+            ,
+            NULL  // Pointer to return value feb
+            ,
+            jshep  // Shepherd number
+            ,
+            num_clone - 1  // Number of instances - 1
+        );
+
+        assert(ret == QTHREAD_SUCCESS);
       }
     }
 #endif
 
-    driver_resize_worker_scratch( NULL );
+    driver_resize_worker_scratch(NULL);
 
     // Verify all workers allocated.
 
     bool ok = true;
-    for ( int iwork = 0; ok && iwork < s_number_workers; ++iwork ) { ok = 0 != s_exec[iwork]; }
+    for (int iwork = 0; ok && iwork < s_number_workers; ++iwork) {
+      ok = 0 != s_exec[iwork];
+    }
 
-    if ( ! ok ) {
+    if (!ok) {
       std::ostringstream msg;
       msg << "Kokkos::Impl::QthreadsExec::resize : FAILED for workers {";
-      for ( int iwork = 0; iwork < s_number_workers; ++iwork ) {
-         if ( 0 == s_exec[iwork] ) { msg << " " << ( s_number_workers - ( iwork + 1 ) ); }
+      for (int iwork = 0; iwork < s_number_workers; ++iwork) {
+        if (0 == s_exec[iwork]) {
+          msg << " " << (s_number_workers - (iwork + 1));
+        }
       }
       msg << " }";
-      Kokkos::Impl::throw_runtime_exception( msg.str() );
+      Kokkos::Impl::throw_runtime_exception(msg.str());
     }
   }
 }
 
-void QthreadsExec::exec_all( Qthreads &, QthreadsExecFunctionPointer func, const void * arg )
-{
-  verify_is_process("QthreadsExec::exec_all(...)",true);
+void QthreadsExec::exec_all(Qthreads &, QthreadsExecFunctionPointer func,
+                            const void *arg) {
+  verify_is_process("QthreadsExec::exec_all(...)", true);
 
-/*
-  fprintf( stdout, "QthreadsExec::exec_all\n");
-  fflush(stdout);
-*/
+  /*
+    fprintf( stdout, "QthreadsExec::exec_all\n");
+    fflush(stdout);
+  */
 
   s_active_function     = func;
   s_active_function_arg = arg;
@@ -454,72 +460,76 @@ void QthreadsExec::exec_all( Qthreads &, QthreadsExecFunctionPointer func, const
   }
 #else
   // If this function is used before the 'qthreads.task_policy' unit test,
-  // the 'qthreads.task_policy' unit test fails with a seg-fault within libqthread.so.
-  for ( int jshep = 0; jshep < s_number_shepherds; ++jshep ) {
-    const int num_clone = jshep != main_shep ? s_number_workers_per_shepherd : s_number_workers_per_shepherd - 1;
-
-    if ( num_clone ) {
-      const int ret = qthread_fork_clones_to_local_priority
-        ( driver_exec_all   // Function
-        , NULL              // Function data block
-        , NULL              // Pointer to return value feb
-        , jshep             // Shepherd number
-        , num_clone - 1     // Number of instances - 1
-        );
+  // the 'qthreads.task_policy' unit test fails with a seg-fault within
+  // libqthread.so.
+  for (int jshep = 0; jshep < s_number_shepherds; ++jshep) {
+    const int num_clone = jshep != main_shep
+                              ? s_number_workers_per_shepherd
+                              : s_number_workers_per_shepherd - 1;
+
+    if (num_clone) {
+      const int ret = qthread_fork_clones_to_local_priority(
+          driver_exec_all  // Function
+          ,
+          NULL  // Function data block
+          ,
+          NULL  // Pointer to return value feb
+          ,
+          jshep  // Shepherd number
+          ,
+          num_clone - 1  // Number of instances - 1
+      );
 
       assert(ret == QTHREAD_SUCCESS);
     }
   }
 #endif
 
-  driver_exec_all( NULL );
+  driver_exec_all(NULL);
 
   s_active_function     = 0;
   s_active_function_arg = 0;
 }
 
-void * QthreadsExec::exec_all_reduce_result()
-{
+void *QthreadsExec::exec_all_reduce_result() {
   return s_exec[0]->m_scratch_alloc;
 }
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
 namespace Impl {
 
 QthreadsTeamPolicyMember::QthreadsTeamPolicyMember()
-  : m_exec( **worker_exec() )
-  , m_team_shared( 0, 0 )
-  , m_team_size( 1 )
-  , m_team_rank( 0 )
-  , m_league_size( 1 )
-  , m_league_end( 1 )
-  , m_league_rank( 0 )
-{
-  m_exec.shared_reset( m_team_shared );
+    : m_exec(**worker_exec()),
+      m_team_shared(0, 0),
+      m_team_size(1),
+      m_team_rank(0),
+      m_league_size(1),
+      m_league_end(1),
+      m_league_rank(0) {
+  m_exec.shared_reset(m_team_shared);
 }
 
-QthreadsTeamPolicyMember::QthreadsTeamPolicyMember( const QthreadsTeamPolicyMember::TaskTeam & )
-  : m_exec( **worker_exec() )
-  , m_team_shared( 0, 0 )
-  , m_team_size( s_number_workers_per_shepherd )
-  , m_team_rank( m_exec.shepherd_worker_rank() )
-  , m_league_size( 1 )
-  , m_league_end( 1 )
-  , m_league_rank( 0 )
-{
-  m_exec.shared_reset( m_team_shared );
+QthreadsTeamPolicyMember::QthreadsTeamPolicyMember(
+    const QthreadsTeamPolicyMember::TaskTeam &)
+    : m_exec(**worker_exec()),
+      m_team_shared(0, 0),
+      m_team_size(s_number_workers_per_shepherd),
+      m_team_rank(m_exec.shepherd_worker_rank()),
+      m_league_size(1),
+      m_league_end(1),
+      m_league_rank(0) {
+  m_exec.shared_reset(m_team_shared);
 }
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #else
 void KOKKOS_SRC_QTHREADS_EXEC_PREVENT_LINK_ERROR() {}
-#endif // #if defined( KOKKOS_ENABLE_QTHREADS )
-
+#endif  // #if defined( KOKKOS_ENABLE_QTHREADS )
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.hpp b/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.hpp
index b2a3ebe4149909301ce5c5759d5c0676f333b413..aa0fd73a4abced088cefd24b036d11b30dadcbef 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.hpp
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_QthreadsExec.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_QTHREADSEXEC_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS )
+#if defined(KOKKOS_ENABLE_QTHREADS)
 
 #include <impl/Kokkos_Spinwait.hpp>
 
@@ -57,299 +58,308 @@ namespace Impl {
 
 class QthreadsExec;
 
-typedef void (*QthreadsExecFunctionPointer)( QthreadsExec &, const void * );
+typedef void (*QthreadsExecFunctionPointer)(QthreadsExec &, const void *);
 
 class QthreadsExec {
-private:
+ private:
   enum { Inactive = 0, Active = 1 };
 
-  const QthreadsExec * const * m_worker_base;
-  const QthreadsExec * const * m_shepherd_base;
+  const QthreadsExec *const *m_worker_base;
+  const QthreadsExec *const *m_shepherd_base;
 
-  void  * m_scratch_alloc;  ///< Scratch memory [ reduce, team, shared ]
-  int     m_reduce_end;     ///< End of scratch reduction memory
+  void *m_scratch_alloc;  ///< Scratch memory [ reduce, team, shared ]
+  int m_reduce_end;       ///< End of scratch reduction memory
 
-  int     m_shepherd_rank;
-  int     m_shepherd_size;
+  int m_shepherd_rank;
+  int m_shepherd_size;
 
-  int     m_shepherd_worker_rank;
-  int     m_shepherd_worker_size;
+  int m_shepherd_worker_rank;
+  int m_shepherd_worker_size;
 
   /*
-   *  m_worker_rank = m_shepherd_rank * m_shepherd_worker_size + m_shepherd_worker_rank
-   *  m_worker_size = m_shepherd_size * m_shepherd_worker_size
+   *  m_worker_rank = m_shepherd_rank * m_shepherd_worker_size +
+   * m_shepherd_worker_rank m_worker_size = m_shepherd_size *
+   * m_shepherd_worker_size
    */
-  int     m_worker_rank;
-  int     m_worker_size;
+  int m_worker_rank;
+  int m_worker_size;
 
   int mutable volatile m_worker_state;
 
   friend class Kokkos::Qthreads;
 
   ~QthreadsExec();
-  QthreadsExec( const QthreadsExec & );
-  QthreadsExec & operator = ( const QthreadsExec & );
+  QthreadsExec(const QthreadsExec &);
+  QthreadsExec &operator=(const QthreadsExec &);
 
-public:
+ public:
   QthreadsExec();
 
   /** Execute the input function on all available Qthreads workers. */
-  static void exec_all( Qthreads &, QthreadsExecFunctionPointer, const void * );
+  static void exec_all(Qthreads &, QthreadsExecFunctionPointer, const void *);
 
   /** Barrier across all workers participating in the 'exec_all'. */
-  void exec_all_barrier() const
-  {
-    const int rev_rank = m_worker_size - ( m_worker_rank + 1 );
+  void exec_all_barrier() const {
+    const int rev_rank = m_worker_size - (m_worker_rank + 1);
 
     int n, j;
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < m_worker_size ); n <<= 1 ) {
-      Impl::spinwait_while_equal( m_worker_base[j]->m_worker_state, QthreadsExec::Active );
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < m_worker_size);
+         n <<= 1) {
+      Impl::spinwait_while_equal(m_worker_base[j]->m_worker_state,
+                                 QthreadsExec::Active);
     }
 
-    if ( rev_rank ) {
+    if (rev_rank) {
       m_worker_state = QthreadsExec::Inactive;
-      Impl::spinwait_while_equal( m_worker_state, QthreadsExec::Inactive );
+      Impl::spinwait_while_equal(m_worker_state, QthreadsExec::Inactive);
     }
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < m_worker_size ); n <<= 1 ) {
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < m_worker_size);
+         n <<= 1) {
       m_worker_base[j]->m_worker_state = QthreadsExec::Active;
     }
   }
 
   /** Barrier across workers within the shepherd with rank < team_rank. */
-  void shepherd_barrier( const int team_size ) const
-  {
-    if ( m_shepherd_worker_rank < team_size ) {
-
-      const int rev_rank = team_size - ( m_shepherd_worker_rank + 1 );
+  void shepherd_barrier(const int team_size) const {
+    if (m_shepherd_worker_rank < team_size) {
+      const int rev_rank = team_size - (m_shepherd_worker_rank + 1);
 
       int n, j;
 
-      for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
-        Impl::spinwait_while_equal( m_shepherd_base[j]->m_worker_state, QthreadsExec::Active );
+      for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+           n <<= 1) {
+        Impl::spinwait_while_equal(m_shepherd_base[j]->m_worker_state,
+                                   QthreadsExec::Active);
       }
 
-      if ( rev_rank ) {
+      if (rev_rank) {
         m_worker_state = QthreadsExec::Inactive;
-        Impl::spinwait_while_equal( m_worker_state, QthreadsExec::Inactive );
+        Impl::spinwait_while_equal(m_worker_state, QthreadsExec::Inactive);
       }
 
-      for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
+      for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+           n <<= 1) {
         m_shepherd_base[j]->m_worker_state = QthreadsExec::Active;
       }
     }
   }
 
   /** Reduce across all workers participating in the 'exec_all'. */
-  template< class FunctorType, class ReducerType, class ArgTag >
-  inline
-  void exec_all_reduce( const FunctorType & func, const ReducerType & reduce ) const
-  {
-    typedef Kokkos::Impl::if_c< std::is_same<InvalidType, ReducerType>::value, FunctorType, ReducerType > ReducerConditional;
+  template <class FunctorType, class ReducerType, class ArgTag>
+  inline void exec_all_reduce(const FunctorType &func,
+                              const ReducerType &reduce) const {
+    typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                               FunctorType, ReducerType>
+        ReducerConditional;
     typedef typename ReducerConditional::type ReducerTypeFwd;
-    typedef Kokkos::Impl::FunctorValueJoin< ReducerTypeFwd, ArgTag > ValueJoin;
+    typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, ArgTag> ValueJoin;
 
-    const int rev_rank = m_worker_size - ( m_worker_rank + 1 );
+    const int rev_rank = m_worker_size - (m_worker_rank + 1);
 
     int n, j;
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < m_worker_size ); n <<= 1 ) {
-      const QthreadsExec & fan = *m_worker_base[j];
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < m_worker_size);
+         n <<= 1) {
+      const QthreadsExec &fan = *m_worker_base[j];
 
-      Impl::spinwait_while_equal( fan.m_worker_state, QthreadsExec::Active );
+      Impl::spinwait_while_equal(fan.m_worker_state, QthreadsExec::Active);
 
-      ValueJoin::join( ReducerConditional::select( func, reduce ), m_scratch_alloc, fan.m_scratch_alloc );
+      ValueJoin::join(ReducerConditional::select(func, reduce), m_scratch_alloc,
+                      fan.m_scratch_alloc);
     }
 
-    if ( rev_rank ) {
+    if (rev_rank) {
       m_worker_state = QthreadsExec::Inactive;
-      Impl::spinwait_while_equal( m_worker_state, QthreadsExec::Inactive );
+      Impl::spinwait_while_equal(m_worker_state, QthreadsExec::Inactive);
     }
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < m_worker_size ); n <<= 1 ) {
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < m_worker_size);
+         n <<= 1) {
       m_worker_base[j]->m_worker_state = QthreadsExec::Active;
     }
   }
 
   /** Scan across all workers participating in the 'exec_all'. */
-  template< class FunctorType, class ArgTag >
-  inline
-  void exec_all_scan( const FunctorType & func ) const
-  {
-    typedef Kokkos::Impl::FunctorValueInit< FunctorType, ArgTag > ValueInit;
-    typedef Kokkos::Impl::FunctorValueJoin< FunctorType, ArgTag > ValueJoin;
-    typedef Kokkos::Impl::FunctorValueOps<  FunctorType, ArgTag > ValueOps;
+  template <class FunctorType, class ArgTag>
+  inline void exec_all_scan(const FunctorType &func) const {
+    typedef Kokkos::Impl::FunctorValueInit<FunctorType, ArgTag> ValueInit;
+    typedef Kokkos::Impl::FunctorValueJoin<FunctorType, ArgTag> ValueJoin;
+    typedef Kokkos::Impl::FunctorValueOps<FunctorType, ArgTag> ValueOps;
 
-    const int rev_rank = m_worker_size - ( m_worker_rank + 1 );
+    const int rev_rank = m_worker_size - (m_worker_rank + 1);
 
     int n, j;
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < m_worker_size ); n <<= 1 ) {
-      Impl::spinwait_while_equal( m_worker_base[j]->m_worker_state, QthreadsExec::Active );
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < m_worker_size);
+         n <<= 1) {
+      Impl::spinwait_while_equal(m_worker_base[j]->m_worker_state,
+                                 QthreadsExec::Active);
     }
 
-    if ( rev_rank ) {
+    if (rev_rank) {
       m_worker_state = QthreadsExec::Inactive;
-      Impl::spinwait_while_equal( m_worker_state, QthreadsExec::Inactive );
-    }
-    else {
+      Impl::spinwait_while_equal(m_worker_state, QthreadsExec::Inactive);
+    } else {
       // Root thread scans across values before releasing threads.
       // Worker data is in reverse order, so m_worker_base[0] is the
       // highest ranking thread.
 
       // Copy from lower ranking to higher ranking worker.
-      for ( int i = 1; i < m_worker_size; ++i ) {
-        ValueOps::copy( func
-                      , m_worker_base[i-1]->m_scratch_alloc
-                      , m_worker_base[i]->m_scratch_alloc
-                      );
+      for (int i = 1; i < m_worker_size; ++i) {
+        ValueOps::copy(func, m_worker_base[i - 1]->m_scratch_alloc,
+                       m_worker_base[i]->m_scratch_alloc);
       }
 
-      ValueInit::init( func, m_worker_base[m_worker_size-1]->m_scratch_alloc );
+      ValueInit::init(func, m_worker_base[m_worker_size - 1]->m_scratch_alloc);
 
       // Join from lower ranking to higher ranking worker.
-      // Value at m_worker_base[n-1] is zero so skip adding it to m_worker_base[n-2].
-      for ( int i = m_worker_size - 1; --i > 0; ) {
-        ValueJoin::join( func, m_worker_base[i-1]->m_scratch_alloc, m_worker_base[i]->m_scratch_alloc );
+      // Value at m_worker_base[n-1] is zero so skip adding it to
+      // m_worker_base[n-2].
+      for (int i = m_worker_size - 1; --i > 0;) {
+        ValueJoin::join(func, m_worker_base[i - 1]->m_scratch_alloc,
+                        m_worker_base[i]->m_scratch_alloc);
       }
     }
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < m_worker_size ); n <<= 1 ) {
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < m_worker_size);
+         n <<= 1) {
       m_worker_base[j]->m_worker_state = QthreadsExec::Active;
     }
   }
 
   //----------------------------------------
 
-  template< class Type >
-  inline
-  volatile Type * shepherd_team_scratch_value() const
-  { return (volatile Type*)( ( (unsigned char *) m_scratch_alloc ) + m_reduce_end ); }
+  template <class Type>
+  inline volatile Type *shepherd_team_scratch_value() const {
+    return (volatile Type *)(((unsigned char *)m_scratch_alloc) + m_reduce_end);
+  }
 
-  template< class Type >
-  inline
-  void shepherd_broadcast( Type & value, const int team_size, const int team_rank ) const
-  {
-    if ( m_shepherd_base ) {
-      Type * const shared_value = m_shepherd_base[0]->shepherd_team_scratch_value<Type>();
-      if ( m_shepherd_worker_rank == team_rank ) { *shared_value = value; }
+  template <class Type>
+  inline void shepherd_broadcast(Type &value, const int team_size,
+                                 const int team_rank) const {
+    if (m_shepherd_base) {
+      Type *const shared_value =
+          m_shepherd_base[0]->shepherd_team_scratch_value<Type>();
+      if (m_shepherd_worker_rank == team_rank) {
+        *shared_value = value;
+      }
       memory_fence();
-      shepherd_barrier( team_size );
+      shepherd_barrier(team_size);
       value = *shared_value;
     }
   }
 
-  template< class Type >
-  inline
-  Type shepherd_reduce( const int team_size, const Type & value ) const
-  {
-    volatile Type * const shared_value = shepherd_team_scratch_value<Type>();
-    *shared_value = value;
-//    *shepherd_team_scratch_value<Type>() = value;
+  template <class Type>
+  inline Type shepherd_reduce(const int team_size, const Type &value) const {
+    volatile Type *const shared_value = shepherd_team_scratch_value<Type>();
+    *shared_value                     = value;
+    //    *shepherd_team_scratch_value<Type>() = value;
 
     memory_fence();
 
-    const int rev_rank = team_size - ( m_shepherd_worker_rank + 1 );
+    const int rev_rank = team_size - (m_shepherd_worker_rank + 1);
 
     int n, j;
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
-      Impl::spinwait_while_equal( m_shepherd_base[j]->m_worker_state, QthreadsExec::Active );
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+         n <<= 1) {
+      Impl::spinwait_while_equal(m_shepherd_base[j]->m_worker_state,
+                                 QthreadsExec::Active);
     }
 
-    if ( rev_rank ) {
+    if (rev_rank) {
       m_worker_state = QthreadsExec::Inactive;
-      Impl::spinwait_while_equal( m_worker_state, QthreadsExec::Inactive );
-    }
-    else {
-      Type & accum = *m_shepherd_base[0]->shepherd_team_scratch_value<Type>();
-      for ( int i = 1; i < n; ++i ) {
+      Impl::spinwait_while_equal(m_worker_state, QthreadsExec::Inactive);
+    } else {
+      Type &accum = *m_shepherd_base[0]->shepherd_team_scratch_value<Type>();
+      for (int i = 1; i < n; ++i) {
         accum += *m_shepherd_base[i]->shepherd_team_scratch_value<Type>();
       }
-      for ( int i = 1; i < n; ++i ) {
+      for (int i = 1; i < n; ++i) {
         *m_shepherd_base[i]->shepherd_team_scratch_value<Type>() = accum;
       }
 
       memory_fence();
     }
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+         n <<= 1) {
       m_shepherd_base[j]->m_worker_state = QthreadsExec::Active;
     }
 
     return *shepherd_team_scratch_value<Type>();
   }
 
-  template< class JoinOp >
-  inline
-  typename JoinOp::value_type
-  shepherd_reduce( const int team_size
-                 , const typename JoinOp::value_type & value
-                 , const JoinOp & op ) const
-  {
+  template <class JoinOp>
+  inline typename JoinOp::value_type shepherd_reduce(
+      const int team_size, const typename JoinOp::value_type &value,
+      const JoinOp &op) const {
     typedef typename JoinOp::value_type Type;
 
-    volatile Type * const shared_value = shepherd_team_scratch_value<Type>();
-    *shared_value = value;
-//    *shepherd_team_scratch_value<Type>() = value;
+    volatile Type *const shared_value = shepherd_team_scratch_value<Type>();
+    *shared_value                     = value;
+    //    *shepherd_team_scratch_value<Type>() = value;
 
     memory_fence();
 
-    const int rev_rank = team_size - ( m_shepherd_worker_rank + 1 );
+    const int rev_rank = team_size - (m_shepherd_worker_rank + 1);
 
     int n, j;
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
-      Impl::spinwait_while_equal( m_shepherd_base[j]->m_worker_state, QthreadsExec::Active );
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+         n <<= 1) {
+      Impl::spinwait_while_equal(m_shepherd_base[j]->m_worker_state,
+                                 QthreadsExec::Active);
     }
 
-    if ( rev_rank ) {
+    if (rev_rank) {
       m_worker_state = QthreadsExec::Inactive;
-      Impl::spinwait_while_equal( m_worker_state, QthreadsExec::Inactive );
-    }
-    else {
-      volatile Type & accum = *m_shepherd_base[0]->shepherd_team_scratch_value<Type>();
-      for ( int i = 1; i < team_size; ++i ) {
-        op.join( accum, *m_shepherd_base[i]->shepherd_team_scratch_value<Type>() );
+      Impl::spinwait_while_equal(m_worker_state, QthreadsExec::Inactive);
+    } else {
+      volatile Type &accum =
+          *m_shepherd_base[0]->shepherd_team_scratch_value<Type>();
+      for (int i = 1; i < team_size; ++i) {
+        op.join(accum,
+                *m_shepherd_base[i]->shepherd_team_scratch_value<Type>());
       }
-      for ( int i = 1; i < team_size; ++i ) {
+      for (int i = 1; i < team_size; ++i) {
         *m_shepherd_base[i]->shepherd_team_scratch_value<Type>() = accum;
       }
 
       memory_fence();
     }
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+         n <<= 1) {
       m_shepherd_base[j]->m_worker_state = QthreadsExec::Active;
     }
 
     return *shepherd_team_scratch_value<Type>();
   }
 
-  template< class Type >
-  inline
-  Type shepherd_scan( const int team_size
-                    , const Type & value
-                    ,       Type * const global_value = 0 ) const
-  {
+  template <class Type>
+  inline Type shepherd_scan(const int team_size, const Type &value,
+                            Type *const global_value = 0) const {
     *shepherd_team_scratch_value<Type>() = value;
 
     memory_fence();
 
-    const int rev_rank = team_size - ( m_shepherd_worker_rank + 1 );
+    const int rev_rank = team_size - (m_shepherd_worker_rank + 1);
 
     int n, j;
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
-      Impl::spinwait_while_equal( m_shepherd_base[j]->m_worker_state, QthreadsExec::Active );
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+         n <<= 1) {
+      Impl::spinwait_while_equal(m_shepherd_base[j]->m_worker_state,
+                                 QthreadsExec::Active);
     }
 
-    if ( rev_rank ) {
+    if (rev_rank) {
       m_worker_state = QthreadsExec::Inactive;
-      Impl::spinwait_while_equal( m_worker_state, QthreadsExec::Inactive );
-    }
-    else {
+      Impl::spinwait_while_equal(m_worker_state, QthreadsExec::Inactive);
+    } else {
       // Root thread scans across values before releasing threads.
       // Worker data is in reverse order, so m_shepherd_base[0] is the
       // highest ranking thread.
@@ -357,24 +367,27 @@ public:
       // Copy from lower ranking to higher ranking worker.
 
       Type accum = *m_shepherd_base[0]->shepherd_team_scratch_value<Type>();
-      for ( int i = 1; i < team_size; ++i ) {
-        const Type tmp = *m_shepherd_base[i]->shepherd_team_scratch_value<Type>();
+      for (int i = 1; i < team_size; ++i) {
+        const Type tmp =
+            *m_shepherd_base[i]->shepherd_team_scratch_value<Type>();
         accum += tmp;
-        *m_shepherd_base[i-1]->shepherd_team_scratch_value<Type>() = tmp;
+        *m_shepherd_base[i - 1]->shepherd_team_scratch_value<Type>() = tmp;
       }
 
-      *m_shepherd_base[team_size-1]->shepherd_team_scratch_value<Type>() =
-        global_value ? atomic_fetch_add( global_value, accum ) : 0;
+      *m_shepherd_base[team_size - 1]->shepherd_team_scratch_value<Type>() =
+          global_value ? atomic_fetch_add(global_value, accum) : 0;
 
       // Join from lower ranking to higher ranking worker.
-      for ( int i = team_size; --i; ) {
-        *m_shepherd_base[i-1]->shepherd_team_scratch_value<Type>() += *m_shepherd_base[i]->shepherd_team_scratch_value<Type>();
+      for (int i = team_size; --i;) {
+        *m_shepherd_base[i - 1]->shepherd_team_scratch_value<Type>() +=
+            *m_shepherd_base[i]->shepherd_team_scratch_value<Type>();
       }
 
       memory_fence();
     }
 
-    for ( n = 1; ( ! ( rev_rank & n ) ) && ( ( j = rev_rank + n ) < team_size ); n <<= 1 ) {
+    for (n = 1; (!(rev_rank & n)) && ((j = rev_rank + n) < team_size);
+         n <<= 1) {
       m_shepherd_base[j]->m_worker_state = QthreadsExec::Active;
     }
 
@@ -383,21 +396,20 @@ public:
 
   //----------------------------------------
 
-  static inline
-  int align_alloc( int size )
-  {
+  static inline int align_alloc(int size) {
     enum { ALLOC_GRAIN = 1 << 6 /* power of two, 64bytes */ };
     enum { ALLOC_GRAIN_MASK = ALLOC_GRAIN - 1 };
-    return ( size + ALLOC_GRAIN_MASK ) & ~ALLOC_GRAIN_MASK;
+    return (size + ALLOC_GRAIN_MASK) & ~ALLOC_GRAIN_MASK;
   }
 
-  void shared_reset( Qthreads::scratch_memory_space & );
+  void shared_reset(Qthreads::scratch_memory_space &);
 
-  void * exec_all_reduce_value() const { return m_scratch_alloc; }
+  void *exec_all_reduce_value() const { return m_scratch_alloc; }
 
-  static void * exec_all_reduce_result();
+  static void *exec_all_reduce_result();
 
-  static void resize_worker_scratch( const int reduce_size, const int shared_size );
+  static void resize_worker_scratch(const int reduce_size,
+                                    const int shared_size);
   static void clear_workers();
 
   //----------------------------------------
@@ -412,9 +424,9 @@ public:
   static int worker_per_shepherd();
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
@@ -423,21 +435,21 @@ namespace Kokkos {
 namespace Impl {
 
 class QthreadsTeamPolicyMember {
-private:
-  typedef Kokkos::Qthreads                       execution_space;
-  typedef execution_space::scratch_memory_space  scratch_memory_space;
-
-  Impl::QthreadsExec   & m_exec;
-  scratch_memory_space   m_team_shared;
-  const int              m_team_size;
-  const int              m_team_rank;
-  const int              m_league_size;
-  const int              m_league_end;
-        int              m_league_rank;
-
-public:
+ private:
+  typedef Kokkos::Qthreads execution_space;
+  typedef execution_space::scratch_memory_space scratch_memory_space;
+
+  Impl::QthreadsExec &m_exec;
+  scratch_memory_space m_team_shared;
+  const int m_team_size;
+  const int m_team_rank;
+  const int m_league_size;
+  const int m_league_end;
+  int m_league_rank;
+
+ public:
   KOKKOS_INLINE_FUNCTION
-  const scratch_memory_space & team_shmem() const { return m_team_shared; }
+  const scratch_memory_space &team_shmem() const { return m_team_shared; }
 
   KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank; }
   KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
@@ -445,36 +457,50 @@ public:
   KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
 
   KOKKOS_INLINE_FUNCTION void team_barrier() const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  {}
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+  }
 #else
-  { m_exec.shepherd_barrier( m_team_size ); }
+  {
+    m_exec.shepherd_barrier(m_team_size);
+  }
 #endif
 
-  template< typename Type >
-  KOKKOS_INLINE_FUNCTION Type team_broadcast( const Type & value, int rank ) const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  { return Type(); }
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_broadcast(const Type &value, int rank) const
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    return Type();
+  }
 #else
-  { return m_exec.template shepherd_broadcast<Type>( value, m_team_size, rank ); }
+  {
+    return m_exec.template shepherd_broadcast<Type>(value, m_team_size, rank);
+  }
 #endif
 
-  template< typename Type >
-  KOKKOS_INLINE_FUNCTION Type team_reduce( const Type & value ) const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  { return Type(); }
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_reduce(const Type &value) const
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    return Type();
+  }
 #else
-  { return m_exec.template shepherd_reduce<Type>( m_team_size, value ); }
+  {
+    return m_exec.template shepherd_reduce<Type>(m_team_size, value);
+  }
 #endif
 
-  template< typename JoinOp >
-  KOKKOS_INLINE_FUNCTION typename JoinOp::value_type
-  team_reduce( const typename JoinOp::value_type & value
-             , const JoinOp & op ) const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  { return typename JoinOp::value_type(); }
+  template <typename JoinOp>
+  KOKKOS_INLINE_FUNCTION typename JoinOp::value_type team_reduce(
+      const typename JoinOp::value_type &value, const JoinOp &op) const
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    return typename JoinOp::value_type();
+  }
 #else
-  { return m_exec.template shepherd_reduce<JoinOp>( m_team_size, value, op ); }
+  {
+    return m_exec.template shepherd_reduce<JoinOp>(m_team_size, value, op);
+  }
 #endif
 
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering.
@@ -482,12 +508,16 @@ public:
    *  The highest rank thread can compute the reduction total as
    *    reduction_total = dev.team_scan( value ) + value;
    */
-  template< typename Type >
-  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value ) const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  { return Type(); }
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_scan(const Type &value) const
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    return Type();
+  }
 #else
-  { return m_exec.template shepherd_scan<Type>( m_team_size, value ); }
+  {
+    return m_exec.template shepherd_scan<Type>(m_team_size, value);
+  }
 #endif
 
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
@@ -498,12 +528,18 @@ public:
    *  the league's teams is non-deterministic.  As such the base value for each
    *  team's scan operation is similarly non-deterministic.
    */
-  template< typename Type >
-  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value, Type * const global_accum ) const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  { return Type(); }
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_scan(const Type &value,
+                                        Type *const global_accum) const
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    return Type();
+  }
 #else
-  { return m_exec.template shepherd_scan<Type>( m_team_size, value, global_accum ); }
+  {
+    return m_exec.template shepherd_scan<Type>(m_team_size, value,
+                                               global_accum);
+  }
 #endif
 
   //----------------------------------------
@@ -512,120 +548,127 @@ public:
   struct TaskTeam {};
 
   QthreadsTeamPolicyMember();
-  explicit QthreadsTeamPolicyMember( const TaskTeam & );
+  explicit QthreadsTeamPolicyMember(const TaskTeam &);
 
   //----------------------------------------
-  // Private for the driver ( for ( member_type i( exec, team ); i; i.next_team() ) { ... }
+  // Private for the driver ( for ( member_type i( exec, team ); i;
+  // i.next_team() ) { ... }
 
   // Initialize.
-  template< class ... Properties >
-  QthreadsTeamPolicyMember( Impl::QthreadsExec & exec
-                          , const Kokkos::Impl::TeamPolicyInternal< Qthreads, Properties... > & team )
-    : m_exec( exec )
-    , m_team_shared( 0, 0 )
-    , m_team_size( team.m_team_size )
-    , m_team_rank( exec.shepherd_worker_rank() )
-    , m_league_size( team.m_league_size )
-    , m_league_end( team.m_league_size - team.m_shepherd_iter * ( exec.shepherd_size() - ( exec.shepherd_rank() + 1 ) ) )
-    , m_league_rank( m_league_end > team.m_shepherd_iter ? m_league_end - team.m_shepherd_iter : 0 )
-  {
-    m_exec.shared_reset( m_team_shared );
+  template <class... Properties>
+  QthreadsTeamPolicyMember(
+      Impl::QthreadsExec &exec,
+      const Kokkos::Impl::TeamPolicyInternal<Qthreads, Properties...> &team)
+      : m_exec(exec),
+        m_team_shared(0, 0),
+        m_team_size(team.m_team_size),
+        m_team_rank(exec.shepherd_worker_rank()),
+        m_league_size(team.m_league_size),
+        m_league_end(team.m_league_size -
+                     team.m_shepherd_iter *
+                         (exec.shepherd_size() - (exec.shepherd_rank() + 1))),
+        m_league_rank(m_league_end > team.m_shepherd_iter
+                          ? m_league_end - team.m_shepherd_iter
+                          : 0) {
+    m_exec.shared_reset(m_team_shared);
   }
 
   // Continue.
-  operator bool () const { return m_league_rank < m_league_end; }
+  operator bool() const { return m_league_rank < m_league_end; }
 
   // Iterate.
-  void next_team() { ++m_league_rank; m_exec.shared_reset( m_team_shared ); }
+  void next_team() {
+    ++m_league_rank;
+    m_exec.shared_reset(m_team_shared);
+  }
 };
 
-template< class ... Properties >
-class TeamPolicyInternal< Kokkos::Qthreads, Properties ... >
-  : public PolicyTraits< Properties... >
-{
-private:
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Qthreads, Properties...>
+    : public PolicyTraits<Properties...> {
+ private:
   const int m_league_size;
   const int m_team_size;
   const int m_shepherd_iter;
 
-public:
+ public:
   //! Tag this class as a kokkos execution policy.
-  typedef TeamPolicyInternal              execution_policy;
-  typedef Qthreads                        execution_space;
-  typedef PolicyTraits< Properties ... >  traits;
+  typedef TeamPolicyInternal execution_policy;
+  typedef Qthreads execution_space;
+  typedef PolicyTraits<Properties...> traits;
 
   //----------------------------------------
 
-  template< class FunctorType >
-  inline static
-  int team_size_max( const FunctorType & )
-  { return Qthreads::instance().shepherd_worker_size(); }
+  template <class FunctorType>
+  inline static int team_size_max(const FunctorType &) {
+    return Qthreads::instance().shepherd_worker_size();
+  }
 
-  template< class FunctorType >
-  static int team_size_recommended( const FunctorType & f )
-  { return team_size_max( f ); }
+  template <class FunctorType>
+  static int team_size_recommended(const FunctorType &f) {
+    return team_size_max(f);
+  }
 
-  template< class FunctorType >
-  inline static
-  int team_size_recommended( const FunctorType & f, const int& )
-  { return team_size_max( f ); }
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType &f, const int &) {
+    return team_size_max(f);
+  }
 
   //----------------------------------------
 
-  inline int team_size()   const { return m_team_size; }
+  inline int team_size() const { return m_team_size; }
   inline int league_size() const { return m_league_size; }
 
   // One active team per shepherd.
-  TeamPolicyInternal( Kokkos::Qthreads & q
-                    , const int league_size
-                    , const int team_size
-                    , const int /* vector_length */ = 0
-                    )
-    : m_league_size( league_size )
-    , m_team_size( team_size < q.shepherd_worker_size()
-                 ? team_size : q.shepherd_worker_size() )
-    , m_shepherd_iter( ( league_size + q.shepherd_size() - 1 ) / q.shepherd_size() )
-  {}
+  TeamPolicyInternal(Kokkos::Qthreads &q, const int league_size,
+                     const int team_size, const int /* vector_length */ = 0)
+      : m_league_size(league_size),
+        m_team_size(team_size < q.shepherd_worker_size()
+                        ? team_size
+                        : q.shepherd_worker_size()),
+        m_shepherd_iter((league_size + q.shepherd_size() - 1) /
+                        q.shepherd_size()) {}
 
   // TODO: Make sure this is correct.
   // One active team per shepherd.
-  TeamPolicyInternal( Kokkos::Qthreads & q
-                    , const int league_size
-                    , const Kokkos::AUTO_t & /* team_size_request */
-                    , const int /* vector_length */ = 0
-                    )
-    : m_league_size( league_size )
-    , m_team_size( q.shepherd_worker_size() )
-    , m_shepherd_iter( ( league_size + q.shepherd_size() - 1 ) / q.shepherd_size() )
-  {}
+  TeamPolicyInternal(Kokkos::Qthreads &q, const int league_size,
+                     const Kokkos::AUTO_t & /* team_size_request */
+                     ,
+                     const int /* vector_length */ = 0)
+      : m_league_size(league_size),
+        m_team_size(q.shepherd_worker_size()),
+        m_shepherd_iter((league_size + q.shepherd_size() - 1) /
+                        q.shepherd_size()) {}
 
   // One active team per shepherd.
-  TeamPolicyInternal( const int league_size
-                    , const int team_size
-                    , const int /* vector_length */ = 0
-                    )
-    : m_league_size( league_size )
-    , m_team_size( team_size < Qthreads::instance().shepherd_worker_size()
-                 ? team_size : Qthreads::instance().shepherd_worker_size() )
-    , m_shepherd_iter( ( league_size + Qthreads::instance().shepherd_size() - 1 ) / Qthreads::instance().shepherd_size() )
-  {}
+  TeamPolicyInternal(const int league_size, const int team_size,
+                     const int /* vector_length */ = 0)
+      : m_league_size(league_size),
+        m_team_size(team_size < Qthreads::instance().shepherd_worker_size()
+                        ? team_size
+                        : Qthreads::instance().shepherd_worker_size()),
+        m_shepherd_iter(
+            (league_size + Qthreads::instance().shepherd_size() - 1) /
+            Qthreads::instance().shepherd_size()) {}
 
   // TODO: Make sure this is correct.
   // One active team per shepherd.
-  TeamPolicyInternal( const int league_size
-                    , const Kokkos::AUTO_t & /* team_size_request */
-                    , const int /* vector_length */ = 0
-                    )
-    : m_league_size( league_size )
-    , m_team_size( Qthreads::instance().shepherd_worker_size() )
-    , m_shepherd_iter( ( league_size + Qthreads::instance().shepherd_size() - 1 ) / Qthreads::instance().shepherd_size() )
-  {}
+  TeamPolicyInternal(const int league_size,
+                     const Kokkos::AUTO_t & /* team_size_request */
+                     ,
+                     const int /* vector_length */ = 0)
+      : m_league_size(league_size),
+        m_team_size(Qthreads::instance().shepherd_worker_size()),
+        m_shepherd_iter(
+            (league_size + Qthreads::instance().shepherd_size() - 1) /
+            Qthreads::instance().shepherd_size()) {}
 
   // TODO: Doesn't do anything yet.  Fix this.
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal set_chunk_size(typename traits::index_type chunk_size_) const {
+  inline TeamPolicyInternal set_chunk_size(
+      typename traits::index_type chunk_size_) const {
     TeamPolicyInternal p = *this;
-//    p.m_chunk_size = chunk_size_;
+    //    p.m_chunk_size = chunk_size_;
     return p;
   }
 
@@ -634,12 +677,11 @@ public:
   friend class Impl::QthreadsTeamPolicyMember;
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 #endif
-#endif // #define KOKKOS_QTHREADSEXEC_HPP
-
+#endif  // #define KOKKOS_QTHREADSEXEC_HPP
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Parallel.hpp b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Parallel.hpp
index 7b1b63befeb9290b44ca82144507ae2e179b7080..8611818e27cbd385b21aa7c96f8c121fbc91a251 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Parallel.hpp
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Parallel.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_QTHREADS_PARALLEL_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS )
+#if defined(KOKKOS_ENABLE_QTHREADS)
 
 #include <vector>
 
@@ -62,679 +63,691 @@ namespace Impl {
 
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::RangePolicy< Traits ... >
-                 , Kokkos::Qthreads
-                 >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                  Kokkos::Qthreads> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef Kokkos::RangePolicy< Traits ... >  Policy ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::WorkRange WorkRange;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::WorkRange    WorkRange ;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor , const Member ibeg , const Member iend )
-    {
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( i );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend) {
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor , const Member ibeg , const Member iend )
-    {
-      const TagType t{} ;
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( t , i );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend) {
+    const TagType t{};
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i);
     }
+  }
 
   // Function is called once by every concurrent thread.
-  static void exec( QthreadsExec & exec , const void * arg )
-  {
-    const ParallelFor & self = * ((const ParallelFor *) arg );
+  static void exec(QthreadsExec& exec, const void* arg) {
+    const ParallelFor& self = *((const ParallelFor*)arg);
 
-    const WorkRange range( self.m_policy, exec.worker_rank(), exec.worker_size() );
+    const WorkRange range(self.m_policy, exec.worker_rank(),
+                          exec.worker_size());
 
-    ParallelFor::template exec_range< WorkTag > ( self.m_functor , range.begin() , range.end() );
+    ParallelFor::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                              range.end());
 
     // All threads wait for completion.
     exec.exec_all_barrier();
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      Impl::QthreadsExec::exec_all( Qthreads::instance() , & ParallelFor::exec , this );
-
-    }
+ public:
+  inline void execute() const {
+    Impl::QthreadsExec::exec_all(Qthreads::instance(), &ParallelFor::exec,
+                                 this);
+  }
 
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy
-             )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    { }
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ReducerType , class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::RangePolicy< Traits ... >
-                    , ReducerType
-                    , Kokkos::Qthreads
-                    >
-{
-private:
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+                     Kokkos::Qthreads> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef Kokkos::RangePolicy< Traits ... >  Policy ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType, ReducerType>::value, FunctorType, ReducerType > ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType, ReducerType>::value, WorkTag, void >::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
   // Static Assert WorkTag void if ReducerType not InvalidType
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd > ValueInit ;
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  const FunctorType   m_functor ;
-  const Policy        m_policy ;
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update )
-    {
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( i , update );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update) {
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update )
-    {
-      const TagType t{} ;
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( t , i , update );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update) {
+    const TagType t{};
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update);
     }
-
-  static void exec( QthreadsExec & exec , const void * arg )
-  {
-    const ParallelReduce & self = * ((const ParallelReduce *) arg );
-
-    const WorkRange range( self.m_policy, exec.worker_rank(), exec.worker_size() );
-
-    ParallelReduce::template exec_range< WorkTag >(
-      self.m_functor, range.begin(), range.end(),
-      ValueInit::init( ReducerConditional::select(self.m_functor , self.m_reducer)
-                     , exec.exec_all_reduce_value() ) );
-
-    exec.template exec_all_reduce< FunctorType, ReducerType, WorkTag >( self.m_functor, self.m_reducer );
   }
 
-public:
+  static void exec(QthreadsExec& exec, const void* arg) {
+    const ParallelReduce& self = *((const ParallelReduce*)arg);
 
-  inline
-  void execute() const
-    {
-      QthreadsExec::resize_worker_scratch( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) , 0 );
-      Impl::QthreadsExec::exec_all( Qthreads::instance() , & ParallelReduce::exec , this );
+    const WorkRange range(self.m_policy, exec.worker_rank(),
+                          exec.worker_size());
 
-      const pointer_type data = (pointer_type) QthreadsExec::exec_all_reduce_result();
+    ParallelReduce::template exec_range<WorkTag>(
+        self.m_functor, range.begin(), range.end(),
+        ValueInit::init(
+            ReducerConditional::select(self.m_functor, self.m_reducer),
+            exec.exec_all_reduce_value()));
 
-      Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , data );
+    exec.template exec_all_reduce<FunctorType, ReducerType, WorkTag>(
+        self.m_functor, self.m_reducer);
+  }
 
-      if ( m_result_ptr ) {
-        const unsigned n = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer) );
-        for ( unsigned i = 0 ; i < n ; ++i ) { m_result_ptr[i] = data[i]; }
+ public:
+  inline void execute() const {
+    QthreadsExec::resize_worker_scratch(
+        ValueTraits::value_size(
+            ReducerConditional::select(m_functor, m_reducer)),
+        0);
+    Impl::QthreadsExec::exec_all(Qthreads::instance(), &ParallelReduce::exec,
+                                 this);
+
+    const pointer_type data =
+        (pointer_type)QthreadsExec::exec_all_reduce_result();
+
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), data);
+
+    if (m_result_ptr) {
+      const unsigned n = ValueTraits::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
+      for (unsigned i = 0; i < n; ++i) {
+        m_result_ptr[i] = data[i];
       }
     }
+  }
 
-  template< class ViewType >
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ViewType & arg_result_view
-                , typename std::enable_if<Kokkos::is_view< ViewType >::value &&
-                                          !Kokkos::is_reducer_type< ReducerType >::value
-                                          , void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result_view.data() )
-    { }
-
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ReducerType& reducer )
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    , m_reducer( reducer )
-    , m_result_ptr( reducer.result_view().data() )
-    { }
+  template <class ViewType>
+  ParallelReduce(
+      const FunctorType& arg_functor, const Policy& arg_policy,
+      const ViewType& arg_result_view,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result_view.data()) {}
+
+  ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                 const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.result_view().data()) {}
 };
 
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ... Properties >
-class ParallelFor< FunctorType
-                 , TeamPolicy< Properties ... >
-                 , Kokkos::Qthreads >
-{
-private:
-
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::Qthreads , Properties ... > Policy ;
-  typedef typename Policy::member_type  Member ;
-  typedef typename Policy::work_tag     WorkTag ;
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, TeamPolicy<Properties...>, Kokkos::Qthreads> {
+ private:
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::Qthreads, Properties...>
+      Policy;
+  typedef typename Policy::member_type Member;
+  typedef typename Policy::work_tag WorkTag;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_team( const FunctorType & functor , Member member )
-    {
-      while ( member ) {
-        functor( member );
-        member.team_barrier();
-        member.next_team();
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_team(const FunctorType& functor, Member member) {
+    while (member) {
+      functor(member);
+      member.team_barrier();
+      member.next_team();
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_team( const FunctorType & functor , Member member )
-    {
-      const TagType t{} ;
-      while ( member ) {
-        functor( t , member );
-        member.team_barrier();
-        member.next_team();
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_team(const FunctorType& functor, Member member) {
+    const TagType t{};
+    while (member) {
+      functor(t, member);
+      member.team_barrier();
+      member.next_team();
     }
+  }
 
-  static void exec( QthreadsExec & exec , const void * arg )
-  {
-    const ParallelFor & self = * ((const ParallelFor *) arg );
+  static void exec(QthreadsExec& exec, const void* arg) {
+    const ParallelFor& self = *((const ParallelFor*)arg);
 
-    ParallelFor::template exec_team< WorkTag >
-      ( self.m_functor , Member( exec , self.m_policy ) );
+    ParallelFor::template exec_team<WorkTag>(self.m_functor,
+                                             Member(exec, self.m_policy));
 
     exec.exec_all_barrier();
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      QthreadsExec::resize_worker_scratch
-        ( /* reduction   memory */ 0
-        , /* team shared memory */ FunctorTeamShmemSize< FunctorType >::value( m_functor , m_policy.team_size() ) );
-      Impl::QthreadsExec::exec_all( Qthreads::instance() , & ParallelFor::exec , this );
-    }
+ public:
+  inline void execute() const {
+    QthreadsExec::resize_worker_scratch(
+        /* reduction   memory */ 0,
+        /* team shared memory */ FunctorTeamShmemSize<FunctorType>::value(
+            m_functor, m_policy.team_size()));
+    Impl::QthreadsExec::exec_all(Qthreads::instance(), &ParallelFor::exec,
+                                 this);
+  }
 
-  ParallelFor( const FunctorType & arg_functor ,
-               const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    { }
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ReducerType , class ... Properties >
-class ParallelReduce< FunctorType
-                    , TeamPolicy< Properties... >
-                    , ReducerType
-                    , Kokkos::Qthreads
-                    >
-{
-private:
-
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::Qthreads , Properties ... > Policy ;
+template <class FunctorType, class ReducerType, class... Properties>
+class ParallelReduce<FunctorType, TeamPolicy<Properties...>, ReducerType,
+                     Kokkos::Qthreads> {
+ private:
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::Qthreads, Properties...>
+      Policy;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::member_type  Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType, ReducerType>::value, WorkTag, void >::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , WorkTagFwd >  ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd >  ValueInit ;
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  const ReducerType  m_reducer ;
-  const pointer_type m_result_ptr ;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_team( const FunctorType & functor , Member member , reference_type update )
-    {
-      while ( member ) {
-        functor( member , update );
-        member.team_barrier();
-        member.next_team();
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_team(const FunctorType& functor, Member member,
+                reference_type update) {
+    while (member) {
+      functor(member, update);
+      member.team_barrier();
+      member.next_team();
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_team( const FunctorType & functor , Member member , reference_type update )
-    {
-      const TagType t{} ;
-      while ( member ) {
-        functor( t , member , update );
-        member.team_barrier();
-        member.next_team();
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_team(const FunctorType& functor, Member member,
+                reference_type update) {
+    const TagType t{};
+    while (member) {
+      functor(t, member, update);
+      member.team_barrier();
+      member.next_team();
     }
+  }
 
-  static void exec( QthreadsExec & exec , const void * arg )
-  {
-    const ParallelReduce & self = * ((const ParallelReduce *) arg );
+  static void exec(QthreadsExec& exec, const void* arg) {
+    const ParallelReduce& self = *((const ParallelReduce*)arg);
 
-    ParallelReduce::template exec_team< WorkTag >
-      ( self.m_functor
-      , Member( exec , self.m_policy )
-      , ValueInit::init( ReducerConditional::select( self.m_functor , self.m_reducer )
-                       , exec.exec_all_reduce_value() ) );
+    ParallelReduce::template exec_team<WorkTag>(
+        self.m_functor, Member(exec, self.m_policy),
+        ValueInit::init(
+            ReducerConditional::select(self.m_functor, self.m_reducer),
+            exec.exec_all_reduce_value()));
 
-    exec.template exec_all_reduce< FunctorType, ReducerType, WorkTag >( self.m_functor, self.m_reducer );
+    exec.template exec_all_reduce<FunctorType, ReducerType, WorkTag>(
+        self.m_functor, self.m_reducer);
   }
 
-public:
+ public:
+  inline void execute() const {
+    QthreadsExec::resize_worker_scratch(
+        /* reduction   memory */ ValueTraits::value_size(
+            ReducerConditional::select(m_functor, m_reducer)),
+        /* team shared memory */ FunctorTeamShmemSize<FunctorType>::value(
+            m_functor, m_policy.team_size()));
 
-  inline
-  void execute() const
-    {
-      QthreadsExec::resize_worker_scratch
-        ( /* reduction   memory */ ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) )
-        , /* team shared memory */ FunctorTeamShmemSize< FunctorType >::value( m_functor , m_policy.team_size() ) );
+    Impl::QthreadsExec::exec_all(Qthreads::instance(), &ParallelReduce::exec,
+                                 this);
 
-      Impl::QthreadsExec::exec_all( Qthreads::instance() , & ParallelReduce::exec , this );
+    const pointer_type data =
+        (pointer_type)QthreadsExec::exec_all_reduce_result();
 
-      const pointer_type data = (pointer_type) QthreadsExec::exec_all_reduce_result();
+    Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+        ReducerConditional::select(m_functor, m_reducer), data);
 
-      Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer), data );
-
-      if ( m_result_ptr ) {
-        const unsigned n = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer) );
-        for ( unsigned i = 0 ; i < n ; ++i ) { m_result_ptr[i] = data[i]; }
+    if (m_result_ptr) {
+      const unsigned n = ValueTraits::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
+      for (unsigned i = 0; i < n; ++i) {
+        m_result_ptr[i] = data[i];
       }
     }
+  }
 
-  template< class ViewType >
-  ParallelReduce( const FunctorType & arg_functor
-                , const Policy      & arg_policy
-                , const ViewType    & arg_result
-                , typename std::enable_if<Kokkos::is_view< ViewType >::value &&
-                                          !Kokkos::is_reducer_type< ReducerType >::value
-                                          , void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result.ptr_on_device() )
-    { }
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ReducerType& reducer )
-  : m_functor( arg_functor )
-  , m_policy( arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr( reducer.result_view().data() )
-  { }
+  template <class ViewType>
+  ParallelReduce(
+      const FunctorType& arg_functor, const Policy& arg_policy,
+      const ViewType& arg_result,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.ptr_on_device()) {}
+
+  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
+                        const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.result_view().data()) {}
 };
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ... Traits >
-class ParallelScan< FunctorType
-                  , Kokkos::RangePolicy< Traits ... >
-                  , Kokkos::Qthreads
-                  >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Qthreads> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef Kokkos::RangePolicy< Traits ... >  Policy ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::WorkRange    WorkRange ;
-  typedef typename Policy::member_type  Member ;
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, WorkTag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
 
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, WorkTag > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( i , update , final );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update, const bool final) {
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update, final);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend
-            , reference_type update , const bool final )
-    {
-      const TagType t{} ;
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( t , i , update , final );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType& functor, const Member ibeg,
+                 const Member iend, reference_type update, const bool final) {
+    const TagType t{};
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update, final);
     }
+  }
 
-  static void exec( QthreadsExec & exec , const void * arg )
-  {
-    const ParallelScan & self = * ((const ParallelScan *) arg );
+  static void exec(QthreadsExec& exec, const void* arg) {
+    const ParallelScan& self = *((const ParallelScan*)arg);
 
-    const WorkRange range( self.m_policy , exec.worker_rank() , exec.worker_size() );
+    const WorkRange range(self.m_policy, exec.worker_rank(),
+                          exec.worker_size());
 
     // Initialize thread-local value
-    reference_type update = ValueInit::init( self.m_functor , exec.exec_all_reduce_value() );
+    reference_type update =
+        ValueInit::init(self.m_functor, exec.exec_all_reduce_value());
 
-    ParallelScan::template exec_range< WorkTag >( self.m_functor, range.begin() , range.end() , update , false );
+    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                               range.end(), update, false);
 
-    exec.template exec_all_scan< FunctorType , typename Policy::work_tag >( self.m_functor );
+    exec.template exec_all_scan<FunctorType, typename Policy::work_tag>(
+        self.m_functor);
 
-    ParallelScan::template exec_range< WorkTag >( self.m_functor , range.begin() , range.end() , update , true );
+    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                               range.end(), update, true);
 
     exec.exec_all_barrier();
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      QthreadsExec::resize_worker_scratch( ValueTraits::value_size( m_functor ) , 0 );
-      Impl::QthreadsExec::exec_all( Qthreads::instance() , & ParallelScan::exec , this );
-    }
+ public:
+  inline void execute() const {
+    QthreadsExec::resize_worker_scratch(ValueTraits::value_size(m_functor), 0);
+    Impl::QthreadsExec::exec_all(Qthreads::instance(), &ParallelScan::exec,
+                                 this);
+  }
 
-  ParallelScan( const FunctorType & arg_functor
-              , const Policy      & arg_policy
-              )
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    {
-    }
+  ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-template< typename iType >
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< iType, Impl::QthreadsTeamPolicyMember >
-TeamThreadRange( const Impl::QthreadsTeamPolicyMember& thread, const iType& count )
-{
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::QthreadsTeamPolicyMember >( thread, count );
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::QthreadsTeamPolicyMember>
+    TeamThreadRange(const Impl::QthreadsTeamPolicyMember& thread,
+                    const iType& count) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType,
+                                               Impl::QthreadsTeamPolicyMember>(
+      thread, count);
 }
 
-template< typename iType1, typename iType2 >
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< typename std::common_type< iType1, iType2 >::type,
-                                       Impl::QthreadsTeamPolicyMember >
-TeamThreadRange( const Impl::QthreadsTeamPolicyMember& thread, const iType1 & begin, const iType2 & end )
-{
-  typedef typename std::common_type< iType1, iType2 >::type iType;
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::QthreadsTeamPolicyMember >( thread, iType(begin), iType(end) );
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type,
+    Impl::QthreadsTeamPolicyMember>
+TeamThreadRange(const Impl::QthreadsTeamPolicyMember& thread,
+                const iType1& begin, const iType2& end) {
+  typedef typename std::common_type<iType1, iType2>::type iType;
+  return Impl::TeamThreadRangeBoundariesStruct<iType,
+                                               Impl::QthreadsTeamPolicyMember>(
+      thread, iType(begin), iType(end));
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >
-  ThreadVectorRange(const Impl::QthreadsTeamPolicyMember& thread, const iType& count) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >(thread,count);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::QthreadsTeamPolicyMember>
+ThreadVectorRange(const Impl::QthreadsTeamPolicyMember& thread,
+                  const iType& count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::QthreadsTeamPolicyMember>(thread, count);
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >
-  ThreadVectorRange(const Impl::QthreadsTeamPolicyMember& thread, const iType& arg_begin, const iType& arg_end) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >(thread,arg_begin,arg_end);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::QthreadsTeamPolicyMember>
+ThreadVectorRange(const Impl::QthreadsTeamPolicyMember& thread,
+                  const iType& arg_begin, const iType& arg_end) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::QthreadsTeamPolicyMember>(thread, arg_begin, arg_end);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::QthreadsTeamPolicyMember> PerTeam(const Impl::QthreadsTeamPolicyMember& thread) {
+Impl::ThreadSingleStruct<Impl::QthreadsTeamPolicyMember> PerTeam(
+    const Impl::QthreadsTeamPolicyMember& thread) {
   return Impl::ThreadSingleStruct<Impl::QthreadsTeamPolicyMember>(thread);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::QthreadsTeamPolicyMember> PerThread(const Impl::QthreadsTeamPolicyMember& thread) {
+Impl::VectorSingleStruct<Impl::QthreadsTeamPolicyMember> PerThread(
+    const Impl::QthreadsTeamPolicyMember& thread) {
   return Impl::VectorSingleStruct<Impl::QthreadsTeamPolicyMember>(thread);
 }
 
-/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all threads of the the calling thread team.
  * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember>& loop_boundaries, const Lambda& lambda) {
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::QthreadsTeamPolicyMember>& loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember>& loop_boundaries,
-                     const Lambda & lambda, ValueType& result) {
-
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::QthreadsTeamPolicyMember>& loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
   result = ValueType();
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    result+=tmp;
+    lambda(i, tmp);
+    result += tmp;
   }
 
-  result = loop_boundaries.thread.team_reduce(result,Impl::JoinAdd<ValueType>());
+  result =
+      loop_boundaries.thread.team_reduce(result, Impl::JoinAdd<ValueType>());
 }
 
-
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a reduction of
- * val is performed using JoinType(ValueType& val, const ValueType& update) and put into init_result.
- * The input value of init_result is used as initializer for temporary variables of ValueType. Therefore
- * the input value should be the neutral element with respect to the join operation (e.g. '0 for +-' or
- * '1 for *'). This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember>& loop_boundaries,
-                     const Lambda & lambda, const JoinType& join, ValueType& init_result) {
-
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *'). This functionality requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::QthreadsTeamPolicyMember>& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
   ValueType result = init_result;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    join(result,tmp);
+    lambda(i, tmp);
+    join(result, tmp);
   }
 
-  init_result = loop_boundaries.thread.team_reduce(result,Impl::JoinLambdaAdapter<ValueType,JoinType>(join));
+  init_result = loop_boundaries.thread.team_reduce(
+      result, Impl::JoinLambdaAdapter<ValueType, JoinType>(join));
 }
 
-/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
  * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >&
-    loop_boundaries, const Lambda& lambda) {
-  #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-  #pragma ivdep
-  #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::QthreadsTeamPolicyMember>& loop_boundaries,
+    const Lambda& lambda) {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >&
-      loop_boundaries, const Lambda & lambda, ValueType& result) {
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::QthreadsTeamPolicyMember>& loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
   result = ValueType();
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    result+=tmp;
+    lambda(i, tmp);
+    result += tmp;
   }
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a reduction of
- * val is performed using JoinType(ValueType& val, const ValueType& update) and put into init_result.
- * The input value of init_result is used as initializer for temporary variables of ValueType. Therefore
- * the input value should be the neutral element with respect to the join operation (e.g. '0 for +-' or
- * '1 for *'). This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >&
-      loop_boundaries, const Lambda & lambda, const JoinType& join, ValueType& init_result) {
-
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *'). This functionality requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::QthreadsTeamPolicyMember>& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
   ValueType result = init_result;
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    join(result,tmp);
+    lambda(i, tmp);
+    join(result, tmp);
   }
   init_result = result;
 }
 
-/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes lambda(iType i, ValueType & val, bool final)
- *          for each i=0..N-1.
+/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
+ * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan operation is performed.
- * Depending on the target execution space the operator might be called twice: once with final=false
- * and once with final=true. When final==true val contains the prefix sum value. The contribution of this
- * "i" needs to be added to val no matter whether final==true or not. In a serial execution
- * (i.e. team_size==1) the operator is only called once with final==true. Scan_val will be set
- * to the final sum value over all vector lanes.
- * This functionality requires C++11 support.*/
-template< typename iType, class FunctorType >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::QthreadsTeamPolicyMember >&
-      loop_boundaries, const FunctorType & lambda) {
-
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
-  typedef typename ValueTraits::value_type value_type ;
+ * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
+ * operation is performed. Depending on the target execution space the operator
+ * might be called twice: once with final=false and once with final=true. When
+ * final==true val contains the prefix sum value. The contribution of this "i"
+ * needs to be added to val no matter whether final==true or not. In a serial
+ * execution (i.e. team_size==1) the operator is only called once with
+ * final==true. Scan_val will be set to the final sum value over all vector
+ * lanes. This functionality requires C++11 support.*/
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::QthreadsTeamPolicyMember>& loop_boundaries,
+    const FunctorType& lambda) {
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename ValueTraits::value_type value_type;
 
   value_type scan_val = value_type();
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,scan_val,true);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, scan_val, true);
   }
 }
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::QthreadsTeamPolicyMember>& single_struct, const FunctorType& lambda) {
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::QthreadsTeamPolicyMember>&
+        single_struct,
+    const FunctorType& lambda) {
   lambda();
 }
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::QthreadsTeamPolicyMember>& single_struct, const FunctorType& lambda) {
-  if(single_struct.team_member.team_rank()==0) lambda();
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::QthreadsTeamPolicyMember>&
+        single_struct,
+    const FunctorType& lambda) {
+  if (single_struct.team_member.team_rank() == 0) lambda();
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::QthreadsTeamPolicyMember>& single_struct, const FunctorType& lambda, ValueType& val) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::QthreadsTeamPolicyMember>&
+        single_struct,
+    const FunctorType& lambda, ValueType& val) {
   lambda(val);
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::QthreadsTeamPolicyMember>& single_struct, const FunctorType& lambda, ValueType& val) {
-  if(single_struct.team_member.team_rank()==0) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::QthreadsTeamPolicyMember>&
+        single_struct,
+    const FunctorType& lambda, ValueType& val) {
+  if (single_struct.team_member.team_rank() == 0) {
     lambda(val);
   }
-  single_struct.team_member.team_broadcast(val,0);
+  single_struct.team_member.team_broadcast(val, 0);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif
 #endif /* #define KOKKOS_QTHREADS_PARALLEL_HPP */
-
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.cpp b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.cpp
index 52f57f5e45a205f80fd1effb21c5033b15bc08f0..b3a903494a60e85115e97acf748170dd67b99ca4 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.cpp
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS ) && defined( KOKKOS_ENABLE_TASKPOLICY )
+#if defined(KOKKOS_ENABLE_QTHREADS) && defined(KOKKOS_ENABLE_TASKPOLICY)
 
 #include <Kokkos_Core.hpp>
 #include <impl/Kokkos_TaskQueue_impl.hpp>
@@ -53,56 +54,52 @@
 namespace Kokkos {
 namespace Impl {
 
-template class TaskQueue< Kokkos::Qthreads > ;
+template class TaskQueue<Kokkos::Qthreads>;
 
 //----------------------------------------------------------------------------
 
-TaskExec< Kokkos::Qthreads >::TaskExec()
-  : m_self_exec( 0 ),
-    m_team_exec( 0 ),
-    m_sync_mask( 0 ),
-    m_sync_value( 0 ),
-    m_sync_step( 0 ),
-    m_group_rank( 0 ),
-    m_team_rank( 0 ),
-    m_team_size( 1 )
-{}
-
-TaskExec< Kokkos::Qthreads >::
-TaskExec( Kokkos::Impl::QthreadsExec & arg_exec, int const arg_team_size )
-  : m_self_exec( & arg_exec ),
-    m_team_exec( arg_exec.pool_rev(arg_exec.pool_rank_rev() / arg_team_size) ),
-    m_sync_mask( 0 ),
-    m_sync_value( 0 ),
-    m_sync_step( 0 ),
-    m_group_rank( arg_exec.pool_rank_rev() / arg_team_size ),
-    m_team_rank( arg_exec.pool_rank_rev() % arg_team_size ),
-    m_team_size( arg_team_size )
-{
+TaskExec<Kokkos::Qthreads>::TaskExec()
+    : m_self_exec(0),
+      m_team_exec(0),
+      m_sync_mask(0),
+      m_sync_value(0),
+      m_sync_step(0),
+      m_group_rank(0),
+      m_team_rank(0),
+      m_team_size(1) {}
+
+TaskExec<Kokkos::Qthreads>::TaskExec(Kokkos::Impl::QthreadsExec &arg_exec,
+                                     int const arg_team_size)
+    : m_self_exec(&arg_exec),
+      m_team_exec(arg_exec.pool_rev(arg_exec.pool_rank_rev() / arg_team_size)),
+      m_sync_mask(0),
+      m_sync_value(0),
+      m_sync_step(0),
+      m_group_rank(arg_exec.pool_rank_rev() / arg_team_size),
+      m_team_rank(arg_exec.pool_rank_rev() % arg_team_size),
+      m_team_size(arg_team_size) {
   // This team spans
   //    m_self_exec->pool_rev( team_size * group_rank )
   //    m_self_exec->pool_rev( team_size * ( group_rank + 1 ) - 1 )
 
-  int64_t volatile * const sync = (int64_t *) m_self_exec->scratch_reduce();
+  int64_t volatile *const sync = (int64_t *)m_self_exec->scratch_reduce();
 
-  sync[0] = int64_t(0) ;
-  sync[1] = int64_t(0) ;
+  sync[0] = int64_t(0);
+  sync[1] = int64_t(0);
 
-  for ( int i = 0 ; i < m_team_size ; ++i ) {
-    m_sync_value |= int64_t(1) << (8*i);
-    m_sync_mask  |= int64_t(3) << (8*i);
+  for (int i = 0; i < m_team_size; ++i) {
+    m_sync_value |= int64_t(1) << (8 * i);
+    m_sync_mask |= int64_t(3) << (8 * i);
   }
 
   Kokkos::memory_fence();
 }
 
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
 
-void TaskExec< Kokkos::Qthreads >::team_barrier() const
-{
-  if ( 1 < m_team_size ) {
-
-    if ( m_team_exec->scratch_reduce_size() < int(2 * sizeof(int64_t)) ) {
+void TaskExec<Kokkos::Qthreads>::team_barrier() const {
+  if (1 < m_team_size) {
+    if (m_team_exec->scratch_reduce_size() < int(2 * sizeof(int64_t))) {
       Kokkos::abort("TaskQueue<Qthreads> scratch_reduce memory too small");
     }
 
@@ -110,12 +107,11 @@ void TaskExec< Kokkos::Qthreads >::team_barrier() const
     // Alternate memory locations between barriers to avoid a sequence
     // of barriers overtaking one another.
 
-    int64_t volatile * const sync =
-      ((int64_t *) m_team_exec->scratch_reduce()) + ( m_sync_step & 0x01 );
+    int64_t volatile *const sync =
+        ((int64_t *)m_team_exec->scratch_reduce()) + (m_sync_step & 0x01);
 
     // This team member sets one byte within the sync variable
-    int8_t volatile * const sync_self =
-     ((int8_t *) sync) + m_team_rank ;
+    int8_t volatile *const sync_self = ((int8_t *)sync) + m_team_rank;
 
 #if 0
 fprintf( stdout,
@@ -129,9 +125,10 @@ fprintf( stdout,
 fflush(stdout);
 #endif
 
-    *sync_self = int8_t( m_sync_value & 0x03 ); // signal arrival
+    *sync_self = int8_t(m_sync_value & 0x03);  // signal arrival
 
-    while ( m_sync_value != *sync ); // wait for team to arrive
+    while (m_sync_value != *sync)
+      ;  // wait for team to arrive
 
 #if 0
 fprintf( stdout,
@@ -145,11 +142,11 @@ fprintf( stdout,
 fflush(stdout);
 #endif
 
-    ++m_sync_step ;
+    ++m_sync_step;
 
-    if ( 0 == ( 0x01 & m_sync_step ) ) { // Every other step
-      m_sync_value ^= m_sync_mask ;
-      if ( 1000 < m_sync_step ) m_sync_step = 0 ;
+    if (0 == (0x01 & m_sync_step)) {  // Every other step
+      m_sync_value ^= m_sync_mask;
+      if (1000 < m_sync_step) m_sync_step = 0;
     }
   }
 }
@@ -158,36 +155,35 @@ fflush(stdout);
 
 //----------------------------------------------------------------------------
 
-void TaskQueueSpecialization< Kokkos::Qthreads >::execute
-  ( TaskQueue< Kokkos::Qthreads > * const queue )
-{
-  using execution_space = Kokkos::Qthreads ;
-  using queue_type      = TaskQueue< execution_space > ;
-  using task_root_type  = TaskBase< execution_space, void, void > ;
-  using PoolExec        = Kokkos::Impl::QthreadsExec ;
-  using Member          = TaskExec< execution_space > ;
+void TaskQueueSpecialization<Kokkos::Qthreads>::execute(
+    TaskQueue<Kokkos::Qthreads> *const queue) {
+  using execution_space = Kokkos::Qthreads;
+  using queue_type      = TaskQueue<execution_space>;
+  using task_root_type  = TaskBase<execution_space, void, void>;
+  using PoolExec        = Kokkos::Impl::QthreadsExec;
+  using Member          = TaskExec<execution_space>;
 
-  task_root_type * const end = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const end = (task_root_type *)task_root_type::EndTag;
 
   // Required:  team_size <= 8
 
-  const int team_size = PoolExec::pool_size(2); // Threads per core
+  const int team_size = PoolExec::pool_size(2);  // Threads per core
   // const int team_size = PoolExec::pool_size(1); // Threads per NUMA
 
-  if ( 8 < team_size ) {
+  if (8 < team_size) {
     Kokkos::abort("TaskQueue<Qthreads> unsupported team size");
   }
 
 #pragma omp parallel
   {
-    PoolExec & self = *PoolExec::get_thread_omp();
+    PoolExec &self = *PoolExec::get_thread_omp();
 
-    Member single_exec ;
-    Member team_exec( self, team_size );
+    Member single_exec;
+    Member team_exec(self, team_size);
 
     // Team shared memory
-    task_root_type * volatile * const task_shared =
-      (task_root_type **) team_exec.m_team_exec->scratch_thread();
+    task_root_type *volatile *const task_shared =
+        (task_root_type **)team_exec.m_team_exec->scratch_thread();
 
 // Barrier across entire Qthreads thread pool to insure initialization
 #pragma omp barrier
@@ -195,23 +191,21 @@ void TaskQueueSpecialization< Kokkos::Qthreads >::execute
     // Loop until all queues are empty and no tasks in flight
 
     do {
-
       // Each team lead attempts to acquire either a thread team task
       // or collection of single thread tasks for the team.
 
-      if ( 0 == team_exec.team_rank() ) {
-
-        task_root_type * tmp =
-          0 < *((volatile int *) & queue->m_ready_count) ? end : 0 ;
+      if (0 == team_exec.team_rank()) {
+        task_root_type *tmp =
+            0 < *((volatile int *)&queue->m_ready_count) ? end : 0;
 
         // Loop by priority and then type
-        for ( int i = 0 ; i < queue_type::NumQueue && end == tmp ; ++i ) {
-          for ( int j = 0 ; j < 2 && end == tmp ; ++j ) {
-            tmp = queue_type::pop_task( & queue->m_ready[i][j] );
+        for (int i = 0; i < queue_type::NumQueue && end == tmp; ++i) {
+          for (int j = 0; j < 2 && end == tmp; ++j) {
+            tmp = queue_type::pop_task(&queue->m_ready[i][j]);
           }
         }
 
-        *task_shared = tmp ;
+        *task_shared = tmp;
 
         // Fence to be sure shared_task_array is stored
         Kokkos::memory_fence();
@@ -222,7 +216,7 @@ void TaskQueueSpecialization< Kokkos::Qthreads >::execute
 
       Kokkos::memory_fence();
 
-      task_root_type * const task = *task_shared ;
+      task_root_type *const task = *task_shared;
 
 #if 0
 fprintf( stdout,
@@ -235,30 +229,27 @@ fprintf( stdout,
 fflush(stdout);
 #endif
 
-      if ( 0 == task ) break ; // 0 == m_ready_count
+      if (0 == task) break;  // 0 == m_ready_count
 
-      if ( end == task ) {
+      if (end == task) {
         team_exec.team_barrier();
-      }
-      else if ( task_root_type::TaskTeam == task->m_task_type ) {
+      } else if (task_root_type::TaskTeam == task->m_task_type) {
         // Thread Team Task
-        (*task->m_apply)( task, & team_exec );
+        (*task->m_apply)(task, &team_exec);
 
         // The m_apply function performs a barrier
 
-        if ( 0 == team_exec.team_rank() ) {
+        if (0 == team_exec.team_rank()) {
           // team member #0 completes the task, which may delete the task
-          queue->complete( task );
+          queue->complete(task);
         }
-      }
-      else {
+      } else {
         // Single Thread Task
 
-        if ( 0 == team_exec.team_rank() ) {
+        if (0 == team_exec.team_rank()) {
+          (*task->m_apply)(task, &single_exec);
 
-          (*task->m_apply)( task, & single_exec );
-
-          queue->complete( task );
+          queue->complete(task);
         }
 
         // All team members wait for whole team to reach this statement.
@@ -267,54 +258,51 @@ fflush(stdout);
         // before it is read by all threads.
         team_exec.team_barrier();
       }
-    } while(1);
+    } while (1);
   }
-// END #pragma omp parallel
-
+  // END #pragma omp parallel
 }
 
-void TaskQueueSpecialization< Kokkos::Qthreads >::
-  iff_single_thread_recursive_execute
-    ( TaskQueue< Kokkos::Qthreads > * const queue )
-{
-  using execution_space = Kokkos::Qthreads ;
-  using queue_type      = TaskQueue< execution_space > ;
-  using task_root_type  = TaskBase< execution_space, void, void > ;
-  using Member          = TaskExec< execution_space > ;
-
-  if ( 1 == omp_get_num_threads() ) {
+void TaskQueueSpecialization<Kokkos::Qthreads>::
+    iff_single_thread_recursive_execute(
+        TaskQueue<Kokkos::Qthreads> *const queue) {
+  using execution_space = Kokkos::Qthreads;
+  using queue_type      = TaskQueue<execution_space>;
+  using task_root_type  = TaskBase<execution_space, void, void>;
+  using Member          = TaskExec<execution_space>;
 
-    task_root_type * const end = (task_root_type *) task_root_type::EndTag ;
+  if (1 == omp_get_num_threads()) {
+    task_root_type *const end = (task_root_type *)task_root_type::EndTag;
 
-    Member single_exec ;
+    Member single_exec;
 
-    task_root_type * task = end ;
+    task_root_type *task = end;
 
     do {
-
-      task = end ;
+      task = end;
 
       // Loop by priority and then type
-      for ( int i = 0 ; i < queue_type::NumQueue && end == task ; ++i ) {
-        for ( int j = 0 ; j < 2 && end == task ; ++j ) {
-          task = queue_type::pop_task( & queue->m_ready[i][j] );
+      for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+        for (int j = 0; j < 2 && end == task; ++j) {
+          task = queue_type::pop_task(&queue->m_ready[i][j]);
         }
       }
 
-      if ( end == task ) break ;
+      if (end == task) break;
 
-      (*task->m_apply)( task, & single_exec );
+      (*task->m_apply)(task, &single_exec);
 
-      queue->complete( task );
+      queue->complete(task);
 
-    } while(1);
+    } while (1);
   }
 }
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 #else
 void KOKKOS_SRC_QTHREADS_TASK_PREVENT_LINK_ERROR() {}
-#endif /* #if defined( KOKKOS_ENABLE_QTHREADS ) && defined( KOKKOS_ENABLE_TASKPOLICY ) */
-
+#endif /* #if defined( KOKKOS_ENABLE_QTHREADS ) && defined( \
+          KOKKOS_ENABLE_TASKPOLICY ) */
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.hpp b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.hpp
index 35fc6599779b134e5a8844ac8295f7dd8f7d2a25..1b2c3d3855e19d0a79af18257d2641eaf42239b5 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.hpp
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_Task.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_IMPL_QTHREADS_TASK_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS ) && defined( KOKKOS_ENABLE_TASKPOLICY )
+#if defined(KOKKOS_ENABLE_QTHREADS) && defined(KOKKOS_ENABLE_TASKPOLICY)
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -53,98 +54,90 @@
 namespace Kokkos {
 namespace Impl {
 
-template<>
-class TaskQueueSpecialization< Kokkos::Qthreads >
-{
-public:
-
-  using execution_space = Kokkos::Qthreads ;
-  using queue_type      = Kokkos::Impl::TaskQueue< execution_space > ;
-  using task_base_type  = Kokkos::Impl::TaskBase< execution_space, void, void > ;
+template <>
+class TaskQueueSpecialization<Kokkos::Qthreads> {
+ public:
+  using execution_space = Kokkos::Qthreads;
+  using queue_type      = Kokkos::Impl::TaskQueue<execution_space>;
+  using task_base_type  = Kokkos::Impl::TaskBase<execution_space, void, void>;
 
   // Must specify memory space
-  using memory_space = Kokkos::HostSpace ;
+  using memory_space = Kokkos::HostSpace;
 
-  static
-  void iff_single_thread_recursive_execute( queue_type * const );
+  static void iff_single_thread_recursive_execute(queue_type* const);
 
   // Must provide task queue execution function
-  static void execute( queue_type * const );
+  static void execute(queue_type* const);
 
   // Must provide mechanism to set function pointer in
   // execution space from the host process.
-  template< typename FunctorType >
-  static
-  void proc_set_apply( task_base_type::function_type * ptr )
-    {
-      using TaskType = TaskBase< execution_space,
-                                 typename FunctorType::value_type,
-                                 FunctorType
-                               > ;
-       *ptr = TaskType::apply ;
-    }
+  template <typename FunctorType>
+  static void proc_set_apply(task_base_type::function_type* ptr) {
+    using TaskType = TaskBase<execution_space, typename FunctorType::value_type,
+                              FunctorType>;
+    *ptr           = TaskType::apply;
+  }
 };
 
-extern template class TaskQueue< Kokkos::Qthreads > ;
+extern template class TaskQueue<Kokkos::Qthreads>;
 
 //----------------------------------------------------------------------------
 
-template<>
-class TaskExec< Kokkos::Qthreads >
-{
-private:
-
-  TaskExec( TaskExec && ) = delete ;
-  TaskExec( TaskExec const & ) = delete ;
-  TaskExec & operator = ( TaskExec && ) = delete ;
-  TaskExec & operator = ( TaskExec const & ) = delete ;
-
+template <>
+class TaskExec<Kokkos::Qthreads> {
+ private:
+  TaskExec(TaskExec&&)      = delete;
+  TaskExec(TaskExec const&) = delete;
+  TaskExec& operator=(TaskExec&&) = delete;
+  TaskExec& operator=(TaskExec const&) = delete;
 
-  using PoolExec = Kokkos::Impl::QthreadsExec ;
+  using PoolExec = Kokkos::Impl::QthreadsExec;
 
-  friend class Kokkos::Impl::TaskQueue< Kokkos::Qthreads > ;
-  friend class Kokkos::Impl::TaskQueueSpecialization< Kokkos::Qthreads > ;
+  friend class Kokkos::Impl::TaskQueue<Kokkos::Qthreads>;
+  friend class Kokkos::Impl::TaskQueueSpecialization<Kokkos::Qthreads>;
 
-  PoolExec * const m_self_exec ;  ///< This thread's thread pool data structure
-  PoolExec * const m_team_exec ;  ///< Team thread's thread pool data structure
-  int64_t          m_sync_mask ;
-  int64_t mutable  m_sync_value ;
-  int     mutable  m_sync_step ;
-  int              m_group_rank ; ///< Which "team" subset of thread pool
-  int              m_team_rank ;  ///< Which thread within a team
-  int              m_team_size ;
+  PoolExec* const m_self_exec;  ///< This thread's thread pool data structure
+  PoolExec* const m_team_exec;  ///< Team thread's thread pool data structure
+  int64_t m_sync_mask;
+  int64_t mutable m_sync_value;
+  int mutable m_sync_step;
+  int m_group_rank;  ///< Which "team" subset of thread pool
+  int m_team_rank;   ///< Which thread within a team
+  int m_team_size;
 
   TaskExec();
-  TaskExec( PoolExec & arg_exec, int arg_team_size );
+  TaskExec(PoolExec& arg_exec, int arg_team_size);
 
-public:
+ public:
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  void* team_shared() const {
+    return m_team_exec ? m_team_exec->scratch_thread() : (void*)0;
+  }
 
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  void * team_shared() const
-    { return m_team_exec ? m_team_exec->scratch_thread() : (void*) 0 ; }
-
-  int team_shared_size() const
-    { return m_team_exec ? m_team_exec->scratch_thread_size() : 0 ; }
+  int team_shared_size() const {
+    return m_team_exec ? m_team_exec->scratch_thread_size() : 0;
+  }
 
   /**\brief  Whole team enters this function call
    *         before any teeam member returns from
    *         this function call.
    */
-  void team_barrier() const ;
+  void team_barrier() const;
 #else
   KOKKOS_INLINE_FUNCTION void team_barrier() const {}
-  KOKKOS_INLINE_FUNCTION void * team_shared() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION int team_shared_size() const { return 0 ; }
+  KOKKOS_INLINE_FUNCTION void* team_shared() const { return 0; }
+  KOKKOS_INLINE_FUNCTION int team_shared_size() const { return 0; }
 #endif
 
   KOKKOS_INLINE_FUNCTION
-  int team_rank() const { return m_team_rank ; }
+  int team_rank() const { return m_team_rank; }
 
   KOKKOS_INLINE_FUNCTION
-  int team_size() const { return m_team_size ; }
+  int team_size() const { return m_team_size; }
 };
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -154,4 +147,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKPOLICY ) */
 #endif /* #ifndef KOKKOS_IMPL_QTHREADS_TASK_HPP */
-
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskPolicy.hpp.old b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskPolicy.hpp.old
index f18b3bba8dec7713d9ee1d3b1428fc4c380f3a11..adb6859763d39fbded63fdf476a6b04f639241cf 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskPolicy.hpp.old
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskPolicy.hpp.old
@@ -174,7 +174,7 @@ public:
     }
 
   //----------------------------------------
-  /*  Inheritance Requirements on task types:
+  /*  Inheritence Requirements on task types:
    *    typedef  FunctorType::value_type  value_type ;
    *    class DerivedTaskType
    *      : public TaskMember< Qthreads , value_type , FunctorType >
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue.hpp b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue.hpp
index 96d88af79f3f9404ca16d50f53feeb980cf1e978..b9b6dd86e41eaa750cb5c3fae4d5d732aac94d89 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue.hpp
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_QTHREADS_TASKQUEUE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS ) && defined( KOKKOS_ENABLE_TASKPOLICY )
+#if defined(KOKKOS_ENABLE_QTHREADS) && defined(KOKKOS_ENABLE_TASKPOLICY)
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -57,56 +58,54 @@ namespace Impl {
  *
  *  Task execution is handled here directly for the Qthread implementation.
  */
-template<>
-class TaskQueue< Kokkos::Qthread > {
-private:
+template <>
+class TaskQueue<Kokkos::Qthread> {
+ private:
+  using execution_space = Kokkos::Qthread;
+  using memory_space    = Kokkos::HostSpace using device_type =
+      Kokkos::Device<execution_space, memory_space>;
+  using memory_pool    = Kokkos::MemoryPool<device_type>;
+  using task_root_type = Kokkos::Impl::TaskBase<execution_space, void, void>;
 
-  using execution_space = Kokkos::Qthread ;
-  using memory_space    = Kokkos::HostSpace
-  using device_type     = Kokkos::Device< execution_space, memory_space > ;
-  using memory_pool     = Kokkos::MemoryPool< device_type > ;
-  using task_root_type  = Kokkos::Impl::TaskBase< execution_space, void, void > ;
-
-  friend class Kokkos::TaskScheduler< execution_space > ;
+  friend class Kokkos::TaskScheduler<execution_space>;
 
   struct Destroy {
-    TaskQueue * m_queue ;
+    TaskQueue* m_queue;
     void destroy_shared_allocation();
   };
 
   //----------------------------------------
 
-  enum : int { TASK_STATE_NULL         =  0,  ///<  Does not exist
-               TASK_STATE_CONSTRUCTING =  1,  ///<  Is under construction
-               TASK_STATE_WAITING      =  2,  ///<  Is waiting for execution
-               TASK_STATE_EXECUTING    =  4,  ///<  Is executing
-               TASK_STATE_RESPAWN      =  8,  ///<  Requested respawn
-               TASK_STATE_COMPLETE     = 16   ///<  Execution is complete
-             };
+  enum : int {
+    TASK_STATE_NULL         = 0,  ///<  Does not exist
+    TASK_STATE_CONSTRUCTING = 1,  ///<  Is under construction
+    TASK_STATE_WAITING      = 2,  ///<  Is waiting for execution
+    TASK_STATE_EXECUTING    = 4,  ///<  Is executing
+    TASK_STATE_RESPAWN      = 8,  ///<  Requested respawn
+    TASK_STATE_COMPLETE     = 16  ///<  Execution is complete
+  };
 
   // Queue is organized as [ priority ][ type ]
 
-  memory_pool  m_memory ;
-  unsigned     m_team_size ;   // Number of threads in a team
-  long         m_accum_alloc ; // Accumulated number of allocations
-  int          m_count_alloc ; // Current number of allocations
-  int          m_max_alloc ;   // Maximum number of allocations
-  int          m_ready_count ; // Number of ready or executing
+  memory_pool m_memory;
+  unsigned m_team_size;  // Number of threads in a team
+  long m_accum_alloc;    // Accumulated number of allocations
+  int m_count_alloc;     // Current number of allocations
+  int m_max_alloc;       // Maximum number of allocations
+  int m_ready_count;     // Number of ready or executing
 
   //----------------------------------------
 
   ~TaskQueue();
-  TaskQueue() = delete ;
-  TaskQueue( TaskQueue && ) = delete ;
-  TaskQueue( TaskQueue const & ) = delete ;
-  TaskQueue & operator = ( TaskQueue && ) = delete ;
-  TaskQueue & operator = ( TaskQueue const & ) = delete ;
-
-  TaskQueue
-    ( const memory_space & arg_space,
-      unsigned const arg_memory_pool_capacity,
-      unsigned const arg_memory_pool_superblock_capacity_log2
-    );
+  TaskQueue()                 = delete;
+  TaskQueue(TaskQueue&&)      = delete;
+  TaskQueue(TaskQueue const&) = delete;
+  TaskQueue& operator=(TaskQueue&&) = delete;
+  TaskQueue& operator=(TaskQueue const&) = delete;
+
+  TaskQueue(const memory_space& arg_space,
+            unsigned const arg_memory_pool_capacity,
+            unsigned const arg_memory_pool_superblock_capacity_log2);
 
   // Schedule a task
   //   Precondition:
@@ -115,7 +114,7 @@ private:
   //   Postcondition:
   //     task->m_next is linked list membership
   KOKKOS_FUNCTION
-  void schedule( task_root_type * const );
+  void schedule(task_root_type* const);
 
   // Reschedule a task
   //   Precondition:
@@ -125,7 +124,7 @@ private:
   //     task is in Executing-Respawn state
   //     task->m_next == 0 (no dependence)
   KOKKOS_FUNCTION
-  void reschedule( task_root_type * );
+  void reschedule(task_root_type*);
 
   // Complete a task
   //   Precondition:
@@ -136,35 +135,31 @@ private:
   //     task->m_wait == LockTag  =>  task is complete
   //     task->m_wait != LockTag  =>  task is waiting
   KOKKOS_FUNCTION
-  void complete( task_root_type * );
-
-public:
+  void complete(task_root_type*);
 
+ public:
   // If and only if the execution space is a single thread
   // then execute ready tasks.
   KOKKOS_INLINE_FUNCTION
-  void iff_single_thread_recursive_execute()
-    {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      specialization::iff_single_thread_recursive_execute( this );
+  void iff_single_thread_recursive_execute() {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    specialization::iff_single_thread_recursive_execute(this);
 #endif
-    }
+  }
 
-  void execute() { specialization::execute( this ); }
+  void execute() { specialization::execute(this); }
 
-  template< typename FunctorType >
-  void proc_set_apply( typename task_root_type::function_type * ptr )
-    {
-      specialization::template proc_set_apply< FunctorType >( ptr );
-    }
+  template <typename FunctorType>
+  void proc_set_apply(typename task_root_type::function_type* ptr) {
+    specialization::template proc_set_apply<FunctorType>(ptr);
+  }
 
   // Assign task pointer with reference counting of assigned tasks
-  template< typename LV, typename RV >
-  KOKKOS_FUNCTION static
-  void assign( TaskBase< execution_space, LV, void > ** const lhs,
-               TaskBase< execution_space, RV, void > *  const rhs )
-    {
-      using task_lhs = TaskBase< execution_space, LV, void > ;
+  template <typename LV, typename RV>
+  KOKKOS_FUNCTION static void assign(
+      TaskBase<execution_space, LV, void>** const lhs,
+      TaskBase<execution_space, RV, void>* const rhs) {
+    using task_lhs = TaskBase<execution_space, LV, void>;
 #if 0
   {
     printf( "assign( 0x%lx { 0x%lx %d %d }, 0x%lx { 0x%lx %d %d } )\n",
@@ -181,39 +176,40 @@ public:
   }
 #endif
 
-      if ( *lhs )
-      {
-        const int count = Kokkos::atomic_fetch_add( &((*lhs)->m_ref_count), -1 );
-
-        if ( ( 1 == count ) && ( (*lhs)->m_state == TASK_STATE_COMPLETE ) ) {
-          // Reference count is zero and task is complete, deallocate.
-          (*lhs)->m_queue->deallocate( *lhs, (*lhs)->m_alloc_size );
-        }
-        else if ( count <= 1 ) {
-          Kokkos::abort("TaskScheduler task has negative reference count or is incomplete" );
-        }
+    if (*lhs) {
+      const int count = Kokkos::atomic_fetch_add(&((*lhs)->m_ref_count), -1);
 
-        // GEM: Should I check that there are no dependences here?  Can the state
-        //      be set to complete while there are still dependences?
+      if ((1 == count) && ((*lhs)->m_state == TASK_STATE_COMPLETE)) {
+        // Reference count is zero and task is complete, deallocate.
+        (*lhs)->m_queue->deallocate(*lhs, (*lhs)->m_alloc_size);
+      } else if (count <= 1) {
+        Kokkos::abort(
+            "TaskScheduler task has negative reference count or is incomplete");
       }
 
-      if ( rhs ) { Kokkos::atomic_fetch_add( &(rhs->m_ref_count), 1 ); }
+      // GEM: Should I check that there are no dependences here?  Can the state
+      //      be set to complete while there are still dependences?
+    }
 
-      // Force write of *lhs
+    if (rhs) {
+      Kokkos::atomic_fetch_add(&(rhs->m_ref_count), 1);
+    }
 
-      *static_cast< task_lhs * volatile * >(lhs) = rhs ;
+    // Force write of *lhs
 
-      Kokkos::memory_fence();
-    }
+    *static_cast<task_lhs* volatile*>(lhs) = rhs;
+
+    Kokkos::memory_fence();
+  }
 
   KOKKOS_FUNCTION
-  size_t allocate_block_size( size_t n ); ///< Actual block size allocated
+  size_t allocate_block_size(size_t n);  ///< Actual block size allocated
 
   KOKKOS_FUNCTION
-  void * allocate( size_t n ); ///< Allocate from the memory pool
+  void* allocate(size_t n);  ///< Allocate from the memory pool
 
   KOKKOS_FUNCTION
-  void deallocate( void * p, size_t n ); ///< Deallocate to the memory pool
+  void deallocate(void* p, size_t n);  ///< Deallocate to the memory pool
 };
 
 } /* namespace Impl */
@@ -225,90 +221,91 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template<>
-class TaskBase< Kokkos::Qthread, void, void >
-{
-public:
-
-  enum : int16_t   { TaskTeam   = TaskBase< void, void, void >::TaskTeam,
-                     TaskSingle = TaskBase< void, void, void >::TaskSingle,
-                     Aggregate  = TaskBase< void, void, void >::Aggregate };
+template <>
+class TaskBase<Kokkos::Qthread, void, void> {
+ public:
+  enum : int16_t {
+    TaskTeam   = TaskBase<void, void, void>::TaskTeam,
+    TaskSingle = TaskBase<void, void, void>::TaskSingle,
+    Aggregate  = TaskBase<void, void, void>::Aggregate
+  };
 
-  enum : uintptr_t { LockTag = TaskBase< void, void, void >::LockTag,
-                     EndTag  = TaskBase< void, void, void >::EndTag };
+  enum : uintptr_t {
+    LockTag = TaskBase<void, void, void>::LockTag,
+    EndTag  = TaskBase<void, void, void>::EndTag
+  };
 
-  using execution_space = Kokkos::Qthread ;
-  using queue_type      = TaskQueue< execution_space > ;
+  using execution_space = Kokkos::Qthread;
+  using queue_type      = TaskQueue<execution_space>;
 
-  template< typename > friend class Kokkos::TaskScheduler ;
+  template <typename>
+  friend class Kokkos::TaskScheduler;
 
-  typedef void (* function_type) ( TaskBase *, void * );
+  typedef void (*function_type)(TaskBase*, void*);
 
   // sizeof(TaskBase) == 48
 
-  function_type  m_apply ;       ///< Apply function pointer
-  queue_type   * m_queue ;       ///< Queue in which this task resides
-  TaskBase     * m_dep ;         ///< Dependence
-  int32_t        m_ref_count ;   ///< Reference count
-  int32_t        m_alloc_size ;  ///< Allocation size
-  int32_t        m_dep_count ;   ///< Aggregate's number of dependences
-  int16_t        m_task_type ;   ///< Type of task
-  int16_t        m_priority ;    ///< Priority of runnable task
-  aligned_t      m_qfeb ;        ///< Qthread full/empty bit
-  int            m_state ;       ///< State of the task
+  function_type m_apply;  ///< Apply function pointer
+  queue_type* m_queue;    ///< Queue in which this task resides
+  TaskBase* m_dep;        ///< Dependence
+  int32_t m_ref_count;    ///< Reference count
+  int32_t m_alloc_size;   ///< Allocation size
+  int32_t m_dep_count;    ///< Aggregate's number of dependences
+  int16_t m_task_type;    ///< Type of task
+  int16_t m_priority;     ///< Priority of runnable task
+  aligned_t m_qfeb;       ///< Qthread full/empty bit
+  int m_state;            ///< State of the task
 
-  TaskBase( TaskBase && ) = delete ;
-  TaskBase( const TaskBase & ) = delete ;
-  TaskBase & operator = ( TaskBase && ) = delete ;
-  TaskBase & operator = ( const TaskBase & ) = delete ;
+  TaskBase(TaskBase&&)      = delete;
+  TaskBase(const TaskBase&) = delete;
+  TaskBase& operator=(TaskBase&&) = delete;
+  TaskBase& operator=(const TaskBase&) = delete;
 
-  KOKKOS_INLINE_FUNCTION ~TaskBase() = default ;
+  KOKKOS_INLINE_FUNCTION ~TaskBase() = default;
 
   KOKKOS_INLINE_FUNCTION
   constexpr TaskBase() noexcept
-    : m_apply(0),
-      m_queue(0),
-      m_dep(0),
-      m_ref_count(0),
-      m_alloc_size(0),
-      m_dep_count(0),
-      m_task_type( TaskSingle ),
-      m_priority( 1 /* TaskRegularPriority */ ),
-      m_qfeb(0),
-      m_state( queue_type::TASK_STATE_CONSTRUCTING )
-    {
-      qthread_empty( & m_qfeb ); // Set to full when complete
-    }
+      : m_apply(0),
+        m_queue(0),
+        m_dep(0),
+        m_ref_count(0),
+        m_alloc_size(0),
+        m_dep_count(0),
+        m_task_type(TaskSingle),
+        m_priority(1 /* TaskRegularPriority */),
+        m_qfeb(0),
+        m_state(queue_type::TASK_STATE_CONSTRUCTING) {
+    qthread_empty(&m_qfeb);  // Set to full when complete
+  }
 
   //----------------------------------------
 
-  static aligned_t qthread_func( void * arg );
+  static aligned_t qthread_func(void* arg);
 
   KOKKOS_INLINE_FUNCTION
-  TaskBase ** aggregate_dependences()
-    { return reinterpret_cast<TaskBase**>( this + 1 ); }
+  TaskBase** aggregate_dependences() {
+    return reinterpret_cast<TaskBase**>(this + 1);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void requested_respawn()
-    { return m_state == queue_type::TASK_STATE_RESPAWN; }
+  void requested_respawn() { return m_state == queue_type::TASK_STATE_RESPAWN; }
 
   KOKKOS_INLINE_FUNCTION
-  void add_dependence( TaskBase* dep )
-    {
-      // Assign dependence to m_dep.  It will be processed in the subsequent
-      // call to schedule.  Error if the dependence is reset.
-      if ( 0 != Kokkos::atomic_exchange( & m_dep, dep ) ) {
-        Kokkos::abort("TaskScheduler ERROR: resetting task dependence");
-      }
+  void add_dependence(TaskBase* dep) {
+    // Assign dependence to m_dep.  It will be processed in the subsequent
+    // call to schedule.  Error if the dependence is reset.
+    if (0 != Kokkos::atomic_exchange(&m_dep, dep)) {
+      Kokkos::abort("TaskScheduler ERROR: resetting task dependence");
+    }
 
-      if ( 0 != dep ) {
-        // The future may be destroyed upon returning from this call
-        // so increment reference count to track this assignment.
-        Kokkos::atomic_fetch_add( &(dep->m_ref_count), 1 );
-      }
+    if (0 != dep) {
+      // The future may be destroyed upon returning from this call
+      // so increment reference count to track this assignment.
+      Kokkos::atomic_fetch_add(&(dep->m_ref_count), 1);
     }
+  }
 
-  using get_return_type = void ;
+  using get_return_type = void;
 
   KOKKOS_INLINE_FUNCTION
   get_return_type get() const {}
@@ -320,6 +317,5 @@ public:
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-#endif /* #if defined( KOKKOS_ENABLE_TASKPOLICY ) */
-#endif // KOKKOS_QTHREADS_TASKQUEUE_HPP
-
+#endif  /* #if defined( KOKKOS_ENABLE_TASKPOLICY ) */
+#endif  // KOKKOS_QTHREADS_TASKQUEUE_HPP
diff --git a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue_impl.hpp b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue_impl.hpp
index c79332f653d27ab9c5ab550bb00d3ef262aab9c9..7a91103ae77a25916282ae8437bb2337f6da3a7b 100644
--- a/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue_impl.hpp
+++ b/lib/kokkos/core/src/Qthreads/Kokkos_Qthreads_TaskQueue_impl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,91 +46,79 @@
 #define KOKKOS_QTHREADS_TASKQUEUE_IMPL_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_QTHREADS ) && defined( KOKKOS_ENABLE_TASKPOLICY )
+#if defined(KOKKOS_ENABLE_QTHREADS) && defined(KOKKOS_ENABLE_TASKPOLICY)
 
 namespace Kokkos {
 namespace Impl {
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-void TaskQueue< ExecSpace >::Destroy::destroy_shared_allocation()
-{
+template <typename ExecSpace>
+void TaskQueue<ExecSpace>::Destroy::destroy_shared_allocation() {
   m_queue->~TaskQueue();
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-TaskQueue< ExecSpace >::TaskQueue
-  ( const TaskQueue< ExecSpace >::memory_space & arg_space,
+template <typename ExecSpace>
+TaskQueue<ExecSpace>::TaskQueue(
+    const TaskQueue<ExecSpace>::memory_space &arg_space,
     unsigned const arg_memory_pool_capacity,
-    unsigned const arg_memory_pool_superblock_capacity_log2 )
-  : m_memory( arg_space,
-              arg_memory_pool_capacity,
-              arg_memory_pool_superblock_capacity_log2 )
-    m_team_size( unsigned( qthread_num_workers_local(NO_SHEPHERD) ) ),
-    m_accum_alloc(0),
-    m_count_alloc(0),
-    m_max_alloc(0),
-    m_ready_count(0)
-{}
+    unsigned const arg_memory_pool_superblock_capacity_log2)
+    : m_memory(arg_space, arg_memory_pool_capacity,
+               arg_memory_pool_superblock_capacity_log2)
+          m_team_size(unsigned(qthread_num_workers_local(NO_SHEPHERD))),
+      m_accum_alloc(0),
+      m_count_alloc(0),
+      m_max_alloc(0),
+      m_ready_count(0) {}
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-TaskQueue< ExecSpace >::~TaskQueue()
-{
+template <typename ExecSpace>
+TaskQueue<ExecSpace>::~TaskQueue() {
   // Verify that ready count is zero.
-  if ( 0 != m_ready_count ) {
+  if (0 != m_ready_count) {
     Kokkos::abort("TaskQueue::~TaskQueue ERROR: has ready or executing tasks");
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-KOKKOS_FUNCTION
-size_t TaskQueue< ExecSpace >::allocate_block_size( size_t n )
-{
-  return m_memory.allocate_block_size( n );
+template <typename ExecSpace>
+KOKKOS_FUNCTION size_t TaskQueue<ExecSpace>::allocate_block_size(size_t n) {
+  return m_memory.allocate_block_size(n);
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-KOKKOS_FUNCTION
-void * TaskQueue< ExecSpace >::allocate( size_t n )
-{
-  void * const p = m_memory.allocate(n);
+template <typename ExecSpace>
+KOKKOS_FUNCTION void *TaskQueue<ExecSpace>::allocate(size_t n) {
+  void *const p = m_memory.allocate(n);
 
-  if ( p ) {
-    Kokkos::atomic_increment( & m_accum_alloc );
-    Kokkos::atomic_increment( & m_count_alloc );
+  if (p) {
+    Kokkos::atomic_increment(&m_accum_alloc);
+    Kokkos::atomic_increment(&m_count_alloc);
 
-    if ( m_max_alloc < m_count_alloc ) m_max_alloc = m_count_alloc ;
+    if (m_max_alloc < m_count_alloc) m_max_alloc = m_count_alloc;
   }
 
-  return p ;
+  return p;
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace >::deallocate( void * p, size_t n )
-{
-  m_memory.deallocate( p, n );
-  Kokkos::atomic_decrement( & m_count_alloc );
+template <typename ExecSpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace>::deallocate(void *p, size_t n) {
+  m_memory.deallocate(p, n);
+  Kokkos::atomic_decrement(&m_count_alloc);
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace >::schedule
-  ( TaskQueue< ExecSpace >::task_root_type * const task )
-{
+template <typename ExecSpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace>::schedule(
+    TaskQueue<ExecSpace>::task_root_type *const task) {
 #if 0
   printf( "schedule( 0x%lx { %d %d %d }\n",
           uintptr_t(task),
@@ -139,22 +128,23 @@ void TaskQueue< ExecSpace >::schedule
 #endif
 
   // The task has been constructed and is waiting to be executed.
-  task->m_state = TASK_STATE_WAITING ;
+  task->m_state = TASK_STATE_WAITING;
 
-  if ( task->m_task_type != task_root_type::Aggregate ) {
+  if (task->m_task_type != task_root_type::Aggregate) {
     // Scheduling a single or team task.
 
     // Increment active task count before spawning.
-    Kokkos::atomic_increment( m_ready_count );
+    Kokkos::atomic_increment(m_ready_count);
 
-    if ( task->m_dep == 0 ) {
+    if (task->m_dep == 0) {
       // Schedule a task with no dependences.
 
-      if ( task_root_type::TaskTeam == task->m_task_type && m_team_size > 1 ) {
-        // If more than one shepherd spawn on a shepherd other than this shepherd
+      if (task_root_type::TaskTeam == task->m_task_type && m_team_size > 1) {
+        // If more than one shepherd spawn on a shepherd other than this
+        // shepherd
         const int num_shepherd  = qthread_num_shepherds();
         const int this_shepherd = qthread_shep();
-        int spawn_shepherd      = ( this_shepherd + 1 ) % num_shepherd ;
+        int spawn_shepherd      = (this_shepherd + 1) % num_shepherd;
 
 #if 0
         fprintf( stdout,
@@ -169,46 +159,37 @@ void TaskQueue< ExecSpace >::schedule
 #endif
 
         qthread_spawn_cloneable(
-          & task_root_type::qthread_func,
-          task,
-          0,
-          NULL,
-          0, // no depenedences
-          0, // dependences array
-          spawn_shepherd,
-          unsigned( QTHREAD_SPAWN_SIMPLE | QTHREAD_SPAWN_LOCAL_PRIORITY ),
-          m_team_size - 1
-        );
-      }
-      else {
+            &task_root_type::qthread_func, task, 0, NULL,
+            0,  // no depenedences
+            0,  // dependences array
+            spawn_shepherd,
+            unsigned(QTHREAD_SPAWN_SIMPLE | QTHREAD_SPAWN_LOCAL_PRIORITY),
+            m_team_size - 1);
+      } else {
         qthread_spawn(
-          & task_root_type::qthread_func,
-          task,
-          0,
-          NULL,
-          0, // no depenedences
-          0, // dependences array
-          NO_SHEPHERD,
-          QTHREAD_SPAWN_SIMPLE /* allows optimization for non-blocking task */
+            &task_root_type::qthread_func, task, 0, NULL,
+            0,  // no depenedences
+            0,  // dependences array
+            NO_SHEPHERD,
+            QTHREAD_SPAWN_SIMPLE /* allows optimization for non-blocking task */
         );
       }
-    }
-    else if ( task->m_dep->m_task_type != task_root_type::Aggregate )
-    // Malloc the precondition array to pass to qthread_spawn().  For
-    // non-aggregate tasks, it is a single pointer since there are no
-    // dependences.  Qthreads will eventually free this allocation so memory will
-    // not be leaked. Is malloc thread-safe?  Should this call be guarded?  The
-    // memory can't be allocated from the pool allocator because Qthreads frees
-    // it using free().
-    aligned_t ** qprecon = (aligned_t **) malloc( sizeof(aligned_t *) );
-
-    *qprecon = reinterpret_cast<aligned_t *>( uintptr_t(m_dep_size) );
-
-    if ( task->m_task_type == task_root_type::TaskTeam && m_team_size > 1) {
+    } else if (task->m_dep->m_task_type != task_root_type::Aggregate)
+      // Malloc the precondition array to pass to qthread_spawn().  For
+      // non-aggregate tasks, it is a single pointer since there are no
+      // dependences.  Qthreads will eventually free this allocation so memory
+      // will not be leaked. Is malloc thread-safe?  Should this call be
+      // guarded?  The memory can't be allocated from the pool allocator because
+      // Qthreads frees it using free().
+      aligned_t **qprecon = (aligned_t **)malloc(sizeof(aligned_t *));
+
+    *qprecon = reinterpret_cast<aligned_t *>(uintptr_t(m_dep_size));
+
+    if (task->m_task_type == task_root_type::TaskTeam && m_team_size > 1) {
       // If more than one shepherd spawn on a shepherd other than this shepherd
       const int num_shepherd  = qthread_num_shepherds();
       const int this_shepherd = qthread_shep();
-      int spawn_shepherd      = ( this_shepherd + 1 ) % num_shepherd ;
+      int spawn_shepherd      = (this_shepherd + 1) % num_shepherd;
 
 #if 0
   fprintf( stdout,
@@ -223,41 +204,29 @@ void TaskQueue< ExecSpace >::schedule
 #endif
 
       qthread_spawn_cloneable(
-        & Task::qthread_func,
-        this,
-        0,
-        NULL,
-        m_dep_size,
-        qprecon, /* dependences */
-        spawn_shepherd,
-        unsigned( QTHREAD_SPAWN_SIMPLE | QTHREAD_SPAWN_LOCAL_PRIORITY ),
-        m_team_size - 1
-      );
-    }
-    else {
+          &Task::qthread_func, this, 0, NULL, m_dep_size,
+          qprecon, /* dependences */
+          spawn_shepherd,
+          unsigned(QTHREAD_SPAWN_SIMPLE | QTHREAD_SPAWN_LOCAL_PRIORITY),
+          m_team_size - 1);
+    } else {
       qthread_spawn(
-        & Task::qthread_func, /* function */
-        this,                 /* function argument */
-        0,
-        NULL,
-        m_dep_size,
-        qprecon, /* dependences */
-        NO_SHEPHERD,
-        QTHREAD_SPAWN_SIMPLE /* allows optimization for non-blocking task */
+          &Task::qthread_func,          /* function */
+          this,                         /* function argument */
+          0, NULL, m_dep_size, qprecon, /* dependences */
+          NO_SHEPHERD,
+          QTHREAD_SPAWN_SIMPLE /* allows optimization for non-blocking task */
       );
     }
-  }
-  else {
+  } else {
     // GEM: How do I handle an aggregate (when_all) task?
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace >::reschedule( task_root_type * task )
-{
+template <typename ExecSpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace>::reschedule(task_root_type *task) {
   // Precondition:
   //   task is in Executing state
   //   task->m_next == LockTag
@@ -266,27 +235,25 @@ void TaskQueue< ExecSpace >::reschedule( task_root_type * task )
   //   task is in Executing-Respawn state
   //   task->m_next == 0 (no dependence)
 
-  task_root_type * const zero = (task_root_type *) 0 ;
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
+  task_root_type *const zero = (task_root_type *)0;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
 
-  if ( lock != Kokkos::atomic_exchange( & task->m_next, zero ) ) {
+  if (lock != Kokkos::atomic_exchange(&task->m_next, zero)) {
     Kokkos::abort("TaskScheduler::respawn ERROR: already respawned");
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace >
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace >::complete
-  ( TaskQueue< ExecSpace >::task_root_type * task )
-{
+template <typename ExecSpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace>::complete(
+    TaskQueue<ExecSpace>::task_root_type *task) {
   // Complete a runnable task that has finished executing
   // or a when_all task when all of its dependeneces are complete.
 
-  task_root_type * const zero = (task_root_type *) 0 ;
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
-  task_root_type * const end  = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const zero = (task_root_type *)0;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
+  task_root_type *const end  = (task_root_type *)task_root_type::EndTag;
 
 #if 0
   printf( "complete( 0x%lx { 0x%lx 0x%lx %d %d %d }\n",
@@ -300,15 +267,15 @@ void TaskQueue< ExecSpace >::complete
   fflush( stdout );
 #endif
 
-  const bool runnable = task_root_type::Aggregate != task->m_task_type ;
+  const bool runnable = task_root_type::Aggregate != task->m_task_type;
 
   //----------------------------------------
 
-  if ( runnable && lock != task->m_next ) {
+  if (runnable && lock != task->m_next) {
     // Is a runnable task has finished executing and requested respawn.
     // Schedule the task for subsequent execution.
 
-    schedule( task );
+    schedule(task);
   }
   //----------------------------------------
   else {
@@ -318,78 +285,72 @@ void TaskQueue< ExecSpace >::complete
     // If 'task' is an aggregate then any of the runnable tasks that
     // it depends upon may be attempting to complete this 'task'.
     // Must only transition a task once to complete status.
-    // This is controlled by atomically locking the wait queue.
+    // This is controled by atomically locking the wait queue.
 
     // Stop other tasks from adding themselves to this task's wait queue
     // by locking the head of this task's wait queue.
 
-    task_root_type * x = Kokkos::atomic_exchange( & task->m_wait, lock );
-
-    if ( x != (task_root_type *) lock ) {
+    task_root_type *x = Kokkos::atomic_exchange(&task->m_wait, lock);
 
+    if (x != (task_root_type *)lock) {
       // This thread has transitioned this 'task' to complete.
       // 'task' is no longer in a queue and is not executing
       // so decrement the reference count from 'task's creation.
       // If no other references to this 'task' then it will be deleted.
 
-      TaskQueue::assign( & task, zero );
+      TaskQueue::assign(&task, zero);
 
       // This thread has exclusive access to the wait list so
       // the concurrency-safe pop_task function is not needed.
       // Schedule the tasks that have been waiting on the input 'task',
       // which may have been deleted.
 
-      while ( x != end ) {
-
+      while (x != end) {
         // Set x->m_next = zero  <=  no dependence
 
-        task_root_type * const next =
-          (task_root_type *) Kokkos::atomic_exchange( & x->m_next, zero );
+        task_root_type *const next =
+            (task_root_type *)Kokkos::atomic_exchange(&x->m_next, zero);
 
-        schedule( x );
+        schedule(x);
 
-        x = next ;
+        x = next;
       }
     }
   }
 
-  if ( runnable ) {
+  if (runnable) {
     // A runnable task was popped from a ready queue and executed.
     // If respawned into a ready queue then the ready count was incremented
     // so decrement whether respawned or not.
-    Kokkos::atomic_decrement( & m_ready_count );
+    Kokkos::atomic_decrement(&m_ready_count);
   }
 }
 
 //----------------------------------------------------------------------------
 
-template<>
-aligned_t
-TaskBase< Kokkos::Qthreads, void, void >::qthread_func( void * arg )
-{
-  using execution_space = Kokkos::Qthreads ;
-  using task_root_type  = TaskBase< execution_space , void , void > ;
+template <>
+aligned_t TaskBase<Kokkos::Qthreads, void, void>::qthread_func(void *arg) {
+  using execution_space = Kokkos::Qthreads;
+  using task_root_type  = TaskBase<execution_space, void, void>;
   using Member          = Kokkos::Impl::QthreadsTeamPolicyMember;
 
-  task_root_type * const task = reinterpret_cast< task_root_type * >( arg );
+  task_root_type *const task = reinterpret_cast<task_root_type *>(arg);
 
   // First member of the team change state to executing.
   // Use compare-exchange to avoid race condition with a respawn.
-  Kokkos::atomic_compare_exchange_strong( & task->m_state,
-                                          queue_type::TASK_STATE_WAITING,
-                                          queue_type::TASK_STATE_EXECUTING
-                                        );
-
-  if ( task_root_type::TaskTeam == task->m_task_type )
-  {
-    if ( 1 < task->m_queue->m_team_size ) {
+  Kokkos::atomic_compare_exchange_strong(&task->m_state,
+                                         queue_type::TASK_STATE_WAITING,
+                                         queue_type::TASK_STATE_EXECUTING);
+
+  if (task_root_type::TaskTeam == task->m_task_type) {
+    if (1 < task->m_queue->m_team_size) {
       // Team task with team size of more than 1.
-      Member::TaskTeam task_team_tag ;
+      Member::TaskTeam task_team_tag;
 
       // Initialize team size and rank with shephered info
-      Member member( task_team_tag );
+      Member member(task_team_tag);
 
-      (*task->m_apply)( task , & member );
+      (*task->m_apply)(task, &member);
 
 #if 0
       fprintf( stdout,
@@ -404,18 +365,16 @@ TaskBase< Kokkos::Qthreads, void, void >::qthread_func( void * arg )
 #endif
 
       member.team_barrier();
-      if ( member.team_rank() == 0 ) task->closeout();
+      if (member.team_rank() == 0) task->closeout();
       member.team_barrier();
-    }
-    else {
+    } else {
       // Team task with team size of 1.
-      Member member ;
-      (*task->m_apply)( task , & member );
+      Member member;
+      (*task->m_apply)(task, &member);
       task->closeout();
     }
-  }
-  else {
-    (*task->m_apply)( task );
+  } else {
+    (*task->m_apply)(task);
     task->closeout();
   }
 
@@ -429,13 +388,11 @@ fprintf( stdout
 fflush(stdout);
 #endif
 
-  return 0 ;
+  return 0;
 }
 
 } /* namespace Impl */
 } /* namespace Kokkos */
 
-
-#endif /* #if defined( KOKKOS_ENABLE_TASKPOLICY ) */
-#endif // KOKKOS_QTHREADS_TASKQUEUE_IMPL_HPP
-
+#endif  /* #if defined( KOKKOS_ENABLE_TASKPOLICY ) */
+#endif  // KOKKOS_QTHREADS_TASKQUEUE_IMPL_HPP
diff --git a/lib/kokkos/core/src/ROCm/KokkosExp_ROCm_IterateTile_Refactor.hpp b/lib/kokkos/core/src/ROCm/KokkosExp_ROCm_IterateTile_Refactor.hpp
index 0d66d016cb62eacba74cc409b91201ba32b82783..608c2ea9f74ee9182247f0a37c725c7e21d664b6 100644
--- a/lib/kokkos/core/src/ROCm/KokkosExp_ROCm_IterateTile_Refactor.hpp
+++ b/lib/kokkos/core/src/ROCm/KokkosExp_ROCm_IterateTile_Refactor.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_ROCM_EXP_ITERATE_TILE_REFACTOR_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( __HCC__ ) && defined( KOKKOS_ENABLE_ROCM )
+#if defined(__HCC__) && defined(KOKKOS_ENABLE_ROCM)
 
 #include <iostream>
 #include <algorithm>
@@ -55,67 +56,69 @@
 
 // #include<ROCm/Kokkos_ROCmExec.hpp>
 // Including the file above leads to following type of errors:
-// /home/ndellin/kokkos/core/src/ROCm/Kokkos_ROCmExec.hpp(84): error: incomplete type is not allowed
-// use existing Kokkos functionality, e.g. max blocks, once resolved
+// /home/ndellin/kokkos/core/src/ROCm/Kokkos_ROCmExec.hpp(84): error: incomplete
+// type is not allowed use existing Kokkos functionality, e.g. max blocks, once
+// resolved
 
 #if defined(KOKKOS_ENABLE_PROFILING)
 #include <impl/Kokkos_Profiling_Interface.hpp>
 #include <typeinfo>
 #endif
 
-
 #define threadIdx_x (hc_get_workitem_id(0))
 #define threadIdx_y (hc_get_workitem_id(1))
 #define threadIdx_z (hc_get_workitem_id(2))
 
-#define blockIdx_x  (hc_get_group_id(0))
-#define blockIdx_y  (hc_get_group_id(1))
-#define blockIdx_z  (hc_get_group_id(2))
-
-#define blockDim_x  (hc_get_group_size(0))
-#define blockDim_y  (hc_get_group_size(1))
-#define blockDim_z  (hc_get_group_size(2))
+#define blockIdx_x (hc_get_group_id(0))
+#define blockIdx_y (hc_get_group_id(1))
+#define blockIdx_z (hc_get_group_id(2))
 
-#define gridDim_x   (hc_get_num_groups(0))
-#define gridDim_y   (hc_get_num_groups(1))
-#define gridDim_z   (hc_get_num_groups(2))
+#define blockDim_x (hc_get_group_size(0))
+#define blockDim_y (hc_get_group_size(1))
+#define blockDim_z (hc_get_group_size(2))
 
+#define gridDim_x (hc_get_num_groups(0))
+#define gridDim_y (hc_get_num_groups(1))
+#define gridDim_z (hc_get_num_groups(2))
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 namespace Refactor {
 
 // ------------------------------------------------------------------ //
 // ParallelFor iteration pattern
-template< int N , typename RP , typename Functor , typename Tag >
+template <int N, typename RP, typename Functor, typename Tag>
 struct DeviceIterateTile;
 
-//Rank 2
+// Rank 2
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<2,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<2, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
+  void exec_range() const {
     // LL
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-        const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-        if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-
-          for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-            const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-            if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-              m_func(offset_0 , offset_1);
+      for (index_type tile_id1 = (index_type)blockIdx_y;
+           tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+        const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                    (index_type)threadIdx_y +
+                                    (index_type)m_rp.m_lower[1];
+        if (offset_1 < m_rp.m_upper[1] &&
+            (index_type)threadIdx_y < m_rp.m_tile[1]) {
+          for (index_type tile_id0 = (index_type)blockIdx_x;
+               tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+            const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                        (index_type)threadIdx_x +
+                                        (index_type)m_rp.m_lower[0];
+            if (offset_0 < m_rp.m_upper[0] &&
+                (index_type)threadIdx_x < m_rp.m_tile[0]) {
+              m_func(offset_0, offset_1);
             }
           }
         }
@@ -123,108 +126,127 @@ struct DeviceIterateTile<2,RP,Functor,void >
     }
     // LR
     else {
-      for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-              m_func(offset_0 , offset_1);
+      for (index_type tile_id0 = (index_type)blockIdx_x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx_x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx_x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx_y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx_y < m_rp.m_tile[1]) {
+              m_func(offset_0, offset_1);
             }
           }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<2,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<2, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_) : m_rp(rp_), m_func(f_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
+  void exec_range() const {
     if (RP::inner_direction == RP::Left) {
       // Loop over size maxnumblocks until full range covered
-      for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-        const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-        if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-
-          for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-            const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-            if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-              m_func(Tag(), offset_0 , offset_1);
+      for (index_type tile_id1 = (index_type)blockIdx_y;
+           tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+        const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                    (index_type)threadIdx_y +
+                                    (index_type)m_rp.m_lower[1];
+        if (offset_1 < m_rp.m_upper[1] &&
+            (index_type)threadIdx_y < m_rp.m_tile[1]) {
+          for (index_type tile_id0 = (index_type)blockIdx_x;
+               tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+            const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                        (index_type)threadIdx_x +
+                                        (index_type)m_rp.m_lower[0];
+            if (offset_0 < m_rp.m_upper[0] &&
+                (index_type)threadIdx_x < m_rp.m_tile[0]) {
+              m_func(Tag(), offset_0, offset_1);
             }
           }
         }
       }
-    }
-    else {
-      for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-              m_func(Tag(), offset_0 , offset_1);
+    } else {
+      for (index_type tile_id0 = (index_type)blockIdx_x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx_x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx_x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx_y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx_y < m_rp.m_tile[1]) {
+              m_func(Tag(), offset_0, offset_1);
             }
           }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 3
+// Rank 3
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<3,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<3, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
+  void exec_range() const {
     // LL
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id2 = (index_type)blockIdx_z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z ) {
-        const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[2];
-        if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_z < m_rp.m_tile[2] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-                const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-                if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-                  m_func(offset_0 , offset_1 , offset_2);
+      for (index_type tile_id2 = (index_type)blockIdx_z;
+           tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z) {
+        const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                    (index_type)threadIdx_z +
+                                    (index_type)m_rp.m_lower[2];
+        if (offset_2 < m_rp.m_upper[2] &&
+            (index_type)threadIdx_z < m_rp.m_tile[2]) {
+          for (index_type tile_id1 = (index_type)blockIdx_y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx_y < m_rp.m_tile[1]) {
+              for (index_type tile_id0 = (index_type)blockIdx_x;
+                   tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+                const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                            (index_type)threadIdx_x +
+                                            (index_type)m_rp.m_lower[0];
+                if (offset_0 < m_rp.m_upper[0] &&
+                    (index_type)threadIdx_x < m_rp.m_tile[0]) {
+                  m_func(offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -234,18 +256,28 @@ struct DeviceIterateTile<3,RP,Functor,void >
     }
     // LR
     else {
-      for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx_z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_z < m_rp.m_tile[2] ) {
-                  m_func(offset_0 , offset_1 , offset_2);
+      for (index_type tile_id0 = (index_type)blockIdx_x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx_x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx_x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx_y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx_y < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx_z;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx_z +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx_z < m_rp.m_tile[2]) {
+                  m_func(offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -253,61 +285,75 @@ struct DeviceIterateTile<3,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<3,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<3, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_) : m_rp(rp_), m_func(f_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
+  void exec_range() const {
     if (RP::inner_direction == RP::Left) {
-      for ( index_type tile_id2 = (index_type)blockIdx_z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z ) {
-        const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[2];
-        if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_z < m_rp.m_tile[2] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-                const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-                if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-                  m_func(Tag(), offset_0 , offset_1 , offset_2);
+      for (index_type tile_id2 = (index_type)blockIdx_z;
+           tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z) {
+        const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                    (index_type)threadIdx_z +
+                                    (index_type)m_rp.m_lower[2];
+        if (offset_2 < m_rp.m_upper[2] &&
+            (index_type)threadIdx_z < m_rp.m_tile[2]) {
+          for (index_type tile_id1 = (index_type)blockIdx_y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx_y < m_rp.m_tile[1]) {
+              for (index_type tile_id0 = (index_type)blockIdx_x;
+                   tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+                const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                            (index_type)threadIdx_x +
+                                            (index_type)m_rp.m_lower[0];
+                if (offset_0 < m_rp.m_upper[0] &&
+                    (index_type)threadIdx_x < m_rp.m_tile[0]) {
+                  m_func(Tag(), offset_0, offset_1, offset_2);
                 }
               }
             }
           }
         }
       }
-    }
-    else {
-      for ( index_type tile_id0 = (index_type)blockIdx_x; tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x ) {
-        const index_type offset_0 = tile_id0*m_rp.m_tile[0] + (index_type)threadIdx_x + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && (index_type)threadIdx_x < m_rp.m_tile[0] ) {
-
-          for ( index_type tile_id1 = (index_type)blockIdx_y; tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && (index_type)threadIdx_y < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx_z; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_z < m_rp.m_tile[2] ) {
-                  m_func(Tag(), offset_0 , offset_1 , offset_2);
+    } else {
+      for (index_type tile_id0 = (index_type)blockIdx_x;
+           tile_id0 < m_rp.m_tile_end[0]; tile_id0 += gridDim_x) {
+        const index_type offset_0 = tile_id0 * m_rp.m_tile[0] +
+                                    (index_type)threadIdx_x +
+                                    (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] &&
+            (index_type)threadIdx_x < m_rp.m_tile[0]) {
+          for (index_type tile_id1 = (index_type)blockIdx_y;
+               tile_id1 < m_rp.m_tile_end[1]; tile_id1 += gridDim_y) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] &&
+                (index_type)threadIdx_y < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx_z;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_z) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx_z +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx_z < m_rp.m_tile[2]) {
+                  m_func(Tag(), offset_0, offset_1, offset_2);
                 }
               }
             }
@@ -315,64 +361,73 @@ struct DeviceIterateTile<3,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 4
+// Rank 4
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<4,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<4, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx_x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx_x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx_x / m_rp.m_tile[0];
-
-      for ( index_type tile_id3 = (index_type)blockIdx_z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z ) {
-        const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[3];
-        if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx_z < m_rp.m_tile[3] ) {
-
-          for ( index_type tile_id2 = (index_type)blockIdx_y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y ) {
-            const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[2];
-            if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_y < m_rp.m_tile[2] ) {
-
-              for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                  for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                    const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                    if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                      m_func(offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx_x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx_x / m_rp.m_tile[0];
+
+      for (index_type tile_id3 = (index_type)blockIdx_z;
+           tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z) {
+        const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                    (index_type)threadIdx_z +
+                                    (index_type)m_rp.m_lower[3];
+        if (offset_3 < m_rp.m_upper[3] &&
+            (index_type)threadIdx_z < m_rp.m_tile[3]) {
+          for (index_type tile_id2 = (index_type)blockIdx_y;
+               tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y) {
+            const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[2];
+            if (offset_2 < m_rp.m_upper[2] &&
+                (index_type)threadIdx_y < m_rp.m_tile[2]) {
+              for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                   j += numbl1) {
+                const index_type offset_1 =
+                    j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+                if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+                  for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                       i += numbl0) {
+                    const index_type offset_0 = i * m_rp.m_tile[0] + thr_id0 +
+                                                (index_type)m_rp.m_lower[0];
+                    if (offset_0 < m_rp.m_upper[0] &&
+                        thr_id0 < m_rp.m_tile[0]) {
+                      m_func(offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -384,33 +439,42 @@ struct DeviceIterateTile<4,RP,Functor,void >
     }
     // LR
     else {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx_x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx_x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx_x % m_rp.m_tile[1];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx_y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_y < m_rp.m_tile[2] ) {
-
-                  for ( index_type tile_id3 = (index_type)blockIdx_z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z ) {
-                    const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx_z < m_rp.m_tile[3] ) {
-                      m_func(offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx_x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx_x % m_rp.m_tile[1];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx_y;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx_y +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx_y < m_rp.m_tile[2]) {
+                  for (index_type tile_id3 = (index_type)blockIdx_z;
+                       tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z) {
+                    const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                                (index_type)threadIdx_z +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        (index_type)threadIdx_z < m_rp.m_tile[3]) {
+                      m_func(offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -420,61 +484,71 @@ struct DeviceIterateTile<4,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<4,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<4, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_) : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
     if (RP::inner_direction == RP::Left) {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx_x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx_x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx_x / m_rp.m_tile[0];
-
-      for ( index_type tile_id3 = (index_type)blockIdx_z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z ) {
-        const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[3];
-        if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx_z < m_rp.m_tile[3] ) {
-
-          for ( index_type tile_id2 = (index_type)blockIdx_y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y ) {
-            const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[2];
-            if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_y < m_rp.m_tile[2] ) {
-
-              for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                  for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                    const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                    if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                      m_func(Tag(), offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx_x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx_x / m_rp.m_tile[0];
+
+      for (index_type tile_id3 = (index_type)blockIdx_z;
+           tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z) {
+        const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                    (index_type)threadIdx_z +
+                                    (index_type)m_rp.m_lower[3];
+        if (offset_3 < m_rp.m_upper[3] &&
+            (index_type)threadIdx_z < m_rp.m_tile[3]) {
+          for (index_type tile_id2 = (index_type)blockIdx_y;
+               tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y) {
+            const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                        (index_type)threadIdx_y +
+                                        (index_type)m_rp.m_lower[2];
+            if (offset_2 < m_rp.m_upper[2] &&
+                (index_type)threadIdx_y < m_rp.m_tile[2]) {
+              for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                   j += numbl1) {
+                const index_type offset_1 =
+                    j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+                if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+                  for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                       i += numbl0) {
+                    const index_type offset_0 = i * m_rp.m_tile[0] + thr_id0 +
+                                                (index_type)m_rp.m_lower[0];
+                    if (offset_0 < m_rp.m_upper[0] &&
+                        thr_id0 < m_rp.m_tile[0]) {
+                      m_func(Tag(), offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -483,35 +557,43 @@ struct DeviceIterateTile<4,RP,Functor,Tag>
           }
         }
       }
-    }
-    else {
-      const index_type temp0  =  m_rp.m_tile_end[0];
-      const index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+    } else {
+      const index_type temp0  = m_rp.m_tile_end[0];
+      const index_type temp1  = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx_x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx_x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx_x % m_rp.m_tile[1];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = tile_id1*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type tile_id2 = (index_type)blockIdx_y; tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y ) {
-                const index_type offset_2 = tile_id2*m_rp.m_tile[2] + (index_type)threadIdx_y + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && (index_type)threadIdx_y < m_rp.m_tile[2] ) {
-
-                  for ( index_type tile_id3 = (index_type)blockIdx_z; tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z ) {
-                    const index_type offset_3 = tile_id3*m_rp.m_tile[3] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && (index_type)threadIdx_z < m_rp.m_tile[3] ) {
-                      m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3);
+      const index_type thr_id0  = (index_type)threadIdx_x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx_x % m_rp.m_tile[1];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 = tile_id1 * m_rp.m_tile[1] + thr_id1 +
+                                        (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type tile_id2 = (index_type)blockIdx_y;
+                   tile_id2 < m_rp.m_tile_end[2]; tile_id2 += gridDim_y) {
+                const index_type offset_2 = tile_id2 * m_rp.m_tile[2] +
+                                            (index_type)threadIdx_y +
+                                            (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] &&
+                    (index_type)threadIdx_y < m_rp.m_tile[2]) {
+                  for (index_type tile_id3 = (index_type)blockIdx_z;
+                       tile_id3 < m_rp.m_tile_end[3]; tile_id3 += gridDim_z) {
+                    const index_type offset_3 = tile_id3 * m_rp.m_tile[3] +
+                                                (index_type)threadIdx_z +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        (index_type)threadIdx_z < m_rp.m_tile[3]) {
+                      m_func(Tag(), offset_0, offset_1, offset_2, offset_3);
                     }
                   }
                 }
@@ -521,81 +603,91 @@ struct DeviceIterateTile<4,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 5
+// Rank 5
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<5,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<5, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx_x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx_x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx_x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx_x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx_x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx_y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx_y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx_y / m_rp.m_tile[2];
-
-      for ( index_type tile_id4 = (index_type)blockIdx_z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim_z ) {
-        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[4];
-        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx_z < m_rp.m_tile[4] ) {
-
-          for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-            const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-            if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                    const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                    if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                      for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                          m_func(offset_0 , offset_1 , offset_2 , offset_3, offset_4);
+      const index_type thr_id2  = (index_type)threadIdx_y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx_y / m_rp.m_tile[2];
+
+      for (index_type tile_id4 = (index_type)blockIdx_z;
+           tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim_z) {
+        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                    (index_type)threadIdx_z +
+                                    (index_type)m_rp.m_lower[4];
+        if (offset_4 < m_rp.m_upper[4] &&
+            (index_type)threadIdx_z < m_rp.m_tile[4]) {
+          for (index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3) {
+            const index_type offset_3 =
+                l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+            if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                       j += numbl1) {
+                    const index_type offset_1 = j * m_rp.m_tile[1] + thr_id1 +
+                                                (index_type)m_rp.m_lower[1];
+                    if (offset_1 < m_rp.m_upper[1] &&
+                        thr_id1 < m_rp.m_tile[1]) {
+                      for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                           i += numbl0) {
+                        const index_type offset_0 = i * m_rp.m_tile[0] +
+                                                    thr_id0 +
+                                                    (index_type)m_rp.m_lower[0];
+                        if (offset_0 < m_rp.m_upper[0] &&
+                            thr_id0 < m_rp.m_tile[0]) {
+                          m_func(offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -609,48 +701,61 @@ struct DeviceIterateTile<5,RP,Functor,void >
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx_x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx_x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx_x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx_x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx_x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx_y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx_y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx_y % m_rp.m_tile[3];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type tile_id4 = (index_type)blockIdx_z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim_z ) {
-                        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx_z < m_rp.m_tile[4] ) {
-                          m_func(offset_0 , offset_1 , offset_2 , offset_3 , offset_4);
+      const index_type thr_id2  = (index_type)threadIdx_y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx_y % m_rp.m_tile[3];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type tile_id4 = (index_type)blockIdx_z;
+                           tile_id4 < m_rp.m_tile_end[4];
+                           tile_id4 += gridDim_z) {
+                        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                                    (index_type)threadIdx_z +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            (index_type)threadIdx_z < m_rp.m_tile[4]) {
+                          m_func(offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -662,77 +767,90 @@ struct DeviceIterateTile<5,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<5,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<5, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_) : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx_x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx_x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx_x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx_x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx_x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx_y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx_y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx_y / m_rp.m_tile[2];
-
-      for ( index_type tile_id4 = (index_type)blockIdx_z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim_z ) {
-        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[4];
-        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx_z < m_rp.m_tile[4] ) {
-
-          for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-            const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-            if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                    const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                    if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                      for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                          m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3, offset_4);
+      const index_type thr_id2  = (index_type)threadIdx_y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx_y / m_rp.m_tile[2];
+
+      for (index_type tile_id4 = (index_type)blockIdx_z;
+           tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim_z) {
+        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                    (index_type)threadIdx_z +
+                                    (index_type)m_rp.m_lower[4];
+        if (offset_4 < m_rp.m_upper[4] &&
+            (index_type)threadIdx_z < m_rp.m_tile[4]) {
+          for (index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3) {
+            const index_type offset_3 =
+                l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+            if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                       j += numbl1) {
+                    const index_type offset_1 = j * m_rp.m_tile[1] + thr_id1 +
+                                                (index_type)m_rp.m_lower[1];
+                    if (offset_1 < m_rp.m_upper[1] &&
+                        thr_id1 < m_rp.m_tile[1]) {
+                      for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                           i += numbl0) {
+                        const index_type offset_0 = i * m_rp.m_tile[0] +
+                                                    thr_id0 +
+                                                    (index_type)m_rp.m_lower[0];
+                        if (offset_0 < m_rp.m_upper[0] &&
+                            thr_id0 < m_rp.m_tile[0]) {
+                          m_func(Tag(), offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -746,48 +864,61 @@ struct DeviceIterateTile<5,RP,Functor,Tag>
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx_x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx_x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx_x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx_x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx_x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx_y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx_y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx_y % m_rp.m_tile[3];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type tile_id4 = (index_type)blockIdx_z; tile_id4 < m_rp.m_tile_end[4]; tile_id4 += gridDim_z ) {
-                        const index_type offset_4 = tile_id4*m_rp.m_tile[4] + (index_type)threadIdx_z + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && (index_type)threadIdx_z < m_rp.m_tile[4] ) {
-                          m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3 , offset_4);
+      const index_type thr_id2  = (index_type)threadIdx_y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx_y % m_rp.m_tile[3];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type tile_id4 = (index_type)blockIdx_z;
+                           tile_id4 < m_rp.m_tile_end[4];
+                           tile_id4 += gridDim_z) {
+                        const index_type offset_4 = tile_id4 * m_rp.m_tile[4] +
+                                                    (index_type)threadIdx_z +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            (index_type)threadIdx_z < m_rp.m_tile[4]) {
+                          m_func(Tag(), offset_0, offset_1, offset_2, offset_3,
+                                 offset_4);
                         }
                       }
                     }
@@ -799,94 +930,108 @@ struct DeviceIterateTile<5,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-
-//Rank 6
+// Rank 6
 // Specializations for void tag type
-template< typename RP , typename Functor >
-struct DeviceIterateTile<6,RP,Functor,void >
-{
+template <typename RP, typename Functor>
+struct DeviceIterateTile<6, RP, Functor, void> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_)
+      : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx_x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx_x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx_x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx_x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx_x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx_y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx_y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx_y / m_rp.m_tile[2];
+      const index_type thr_id2  = (index_type)threadIdx_y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx_y / m_rp.m_tile[2];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl4 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl5 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl4 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl4 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl5 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl4)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx_z % numbl4;
       const index_type tile_id5 = (index_type)blockIdx_z / numbl4;
-      const index_type thr_id4 = (index_type)threadIdx_z % m_rp.m_tile[4];
-      const index_type thr_id5 = (index_type)threadIdx_z / m_rp.m_tile[4];
-
-      for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-        const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-        if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-
-          for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-            const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-            if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-              for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                  for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                    const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                    if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                      for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                        const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                        if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                          for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                            const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                            if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                              m_func(offset_0 , offset_1 , offset_2 , offset_3, offset_4, offset_5);
+      const index_type thr_id4  = (index_type)threadIdx_z % m_rp.m_tile[4];
+      const index_type thr_id5  = (index_type)threadIdx_z / m_rp.m_tile[4];
+
+      for (index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5) {
+        const index_type offset_5 =
+            n * m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
+        if (offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5]) {
+          for (index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4) {
+            const index_type offset_4 =
+                m * m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
+            if (offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4]) {
+              for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                   l += numbl3) {
+                const index_type offset_3 =
+                    l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+                if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+                  for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                       k += numbl2) {
+                    const index_type offset_2 = k * m_rp.m_tile[2] + thr_id2 +
+                                                (index_type)m_rp.m_lower[2];
+                    if (offset_2 < m_rp.m_upper[2] &&
+                        thr_id2 < m_rp.m_tile[2]) {
+                      for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                           j += numbl1) {
+                        const index_type offset_1 = j * m_rp.m_tile[1] +
+                                                    thr_id1 +
+                                                    (index_type)m_rp.m_lower[1];
+                        if (offset_1 < m_rp.m_upper[1] &&
+                            thr_id1 < m_rp.m_tile[1]) {
+                          for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                               i += numbl0) {
+                            const index_type offset_0 =
+                                i * m_rp.m_tile[0] + thr_id0 +
+                                (index_type)m_rp.m_lower[0];
+                            if (offset_0 < m_rp.m_upper[0] &&
+                                thr_id0 < m_rp.m_tile[0]) {
+                              m_func(offset_0, offset_1, offset_2, offset_3,
+                                     offset_4, offset_5);
                             }
                           }
                         }
@@ -902,63 +1047,80 @@ struct DeviceIterateTile<6,RP,Functor,void >
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx_x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx_x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx_x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx_x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx_x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx_y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx_y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx_y % m_rp.m_tile[3];
+      const index_type thr_id2  = (index_type)threadIdx_y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx_y % m_rp.m_tile[3];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl5 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl4 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl5 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl5 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl4 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl5)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx_z / numbl5;
       const index_type tile_id5 = (index_type)blockIdx_z % numbl5;
-      const index_type thr_id4 = (index_type)threadIdx_z / m_rp.m_tile[5];
-      const index_type thr_id5 = (index_type)threadIdx_z % m_rp.m_tile[5];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-                        const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-                          for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-                            const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-                            if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-                              m_func(offset_0 , offset_1 , offset_2 , offset_3 , offset_4 , offset_5);
+      const index_type thr_id4  = (index_type)threadIdx_z / m_rp.m_tile[5];
+      const index_type thr_id5  = (index_type)threadIdx_z % m_rp.m_tile[5];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type m = tile_id4; m < m_rp.m_tile_end[4];
+                           m += numbl4) {
+                        const index_type offset_4 = m * m_rp.m_tile[4] +
+                                                    thr_id4 +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            thr_id4 < m_rp.m_tile[4]) {
+                          for (index_type n = tile_id5; n < m_rp.m_tile_end[5];
+                               n += numbl5) {
+                            const index_type offset_5 =
+                                n * m_rp.m_tile[5] + thr_id5 +
+                                (index_type)m_rp.m_lower[5];
+                            if (offset_5 < m_rp.m_upper[5] &&
+                                thr_id5 < m_rp.m_tile[5]) {
+                              m_func(offset_0, offset_1, offset_2, offset_3,
+                                     offset_4, offset_5);
                             }
                           }
                         }
@@ -972,92 +1134,107 @@ struct DeviceIterateTile<6,RP,Functor,void >
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag >
-struct DeviceIterateTile<6,RP,Functor,Tag>
-{
+template <typename RP, typename Functor, typename Tag>
+struct DeviceIterateTile<6, RP, Functor, Tag> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ )
-  : m_rp(rp_)
-  , m_func(f_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_) : m_rp(rp_), m_func(f_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
     // LL
     if (RP::inner_direction == RP::Left) {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl0 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl1 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl0 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl0 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl1 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl0)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x % numbl0;
       const index_type tile_id1 = (index_type)blockIdx_x / numbl0;
-      const index_type thr_id0 = (index_type)threadIdx_x % m_rp.m_tile[0];
-      const index_type thr_id1 = (index_type)threadIdx_x / m_rp.m_tile[0];
+      const index_type thr_id0  = (index_type)threadIdx_x % m_rp.m_tile[0];
+      const index_type thr_id1  = (index_type)threadIdx_x / m_rp.m_tile[0];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl2 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl3 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl2 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl2 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl3 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl2)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y % numbl2;
       const index_type tile_id3 = (index_type)blockIdx_y / numbl2;
-      const index_type thr_id2 = (index_type)threadIdx_y % m_rp.m_tile[2];
-      const index_type thr_id3 = (index_type)threadIdx_y / m_rp.m_tile[2];
+      const index_type thr_id2  = (index_type)threadIdx_y % m_rp.m_tile[2];
+      const index_type thr_id3  = (index_type)threadIdx_y / m_rp.m_tile[2];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl4 = ( temp0 <= max_blocks ? temp0 : max_blocks ) ;
-      const index_type numbl5 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl4 ) :
-          (  temp1 <= max_blocks ? temp1 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl4 = (temp0 <= max_blocks ? temp0 : max_blocks);
+      const index_type numbl5 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl4)
+               : (temp1 <= max_blocks ? temp1 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx_z % numbl4;
       const index_type tile_id5 = (index_type)blockIdx_z / numbl4;
-      const index_type thr_id4 = (index_type)threadIdx_z % m_rp.m_tile[4];
-      const index_type thr_id5 = (index_type)threadIdx_z / m_rp.m_tile[4];
-
-      for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-        const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-        if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-
-          for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-            const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-            if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-              for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                  for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                    const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                    if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                      for ( index_type j = tile_id1 ; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-                        const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-                        if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-                          for ( index_type i = tile_id0 ; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-                            const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-                            if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-                              m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3, offset_4, offset_5);
+      const index_type thr_id4  = (index_type)threadIdx_z % m_rp.m_tile[4];
+      const index_type thr_id5  = (index_type)threadIdx_z / m_rp.m_tile[4];
+
+      for (index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5) {
+        const index_type offset_5 =
+            n * m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
+        if (offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5]) {
+          for (index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4) {
+            const index_type offset_4 =
+                m * m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
+            if (offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4]) {
+              for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                   l += numbl3) {
+                const index_type offset_3 =
+                    l * m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
+                if (offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3]) {
+                  for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                       k += numbl2) {
+                    const index_type offset_2 = k * m_rp.m_tile[2] + thr_id2 +
+                                                (index_type)m_rp.m_lower[2];
+                    if (offset_2 < m_rp.m_upper[2] &&
+                        thr_id2 < m_rp.m_tile[2]) {
+                      for (index_type j = tile_id1; j < m_rp.m_tile_end[1];
+                           j += numbl1) {
+                        const index_type offset_1 = j * m_rp.m_tile[1] +
+                                                    thr_id1 +
+                                                    (index_type)m_rp.m_lower[1];
+                        if (offset_1 < m_rp.m_upper[1] &&
+                            thr_id1 < m_rp.m_tile[1]) {
+                          for (index_type i = tile_id0; i < m_rp.m_tile_end[0];
+                               i += numbl0) {
+                            const index_type offset_0 =
+                                i * m_rp.m_tile[0] + thr_id0 +
+                                (index_type)m_rp.m_lower[0];
+                            if (offset_0 < m_rp.m_upper[0] &&
+                                thr_id0 < m_rp.m_tile[0]) {
+                              m_func(Tag(), offset_0, offset_1, offset_2,
+                                     offset_3, offset_4, offset_5);
                             }
                           }
                         }
@@ -1073,63 +1250,80 @@ struct DeviceIterateTile<6,RP,Functor,Tag>
     }
     // LR
     else {
-      index_type temp0  =  m_rp.m_tile_end[0];
-      index_type temp1  =  m_rp.m_tile_end[1];
-      const index_type numbl1 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl0 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl1 ) :
-          ( temp0 <= max_blocks ? temp0 : max_blocks ) );
+      index_type temp0        = m_rp.m_tile_end[0];
+      index_type temp1        = m_rp.m_tile_end[1];
+      const index_type numbl1 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl0 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl1)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id0 = (index_type)blockIdx_x / numbl1;
       const index_type tile_id1 = (index_type)blockIdx_x % numbl1;
-      const index_type thr_id0 = (index_type)threadIdx_x / m_rp.m_tile[1];
-      const index_type thr_id1 = (index_type)threadIdx_x % m_rp.m_tile[1];
+      const index_type thr_id0  = (index_type)threadIdx_x / m_rp.m_tile[1];
+      const index_type thr_id1  = (index_type)threadIdx_x % m_rp.m_tile[1];
 
-      temp0  =  m_rp.m_tile_end[2];
-      temp1  =  m_rp.m_tile_end[3];
-      const index_type numbl3 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl2 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl3 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[2];
+      temp1                   = m_rp.m_tile_end[3];
+      const index_type numbl3 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl2 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl3)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id2 = (index_type)blockIdx_y / numbl3;
       const index_type tile_id3 = (index_type)blockIdx_y % numbl3;
-      const index_type thr_id2 = (index_type)threadIdx_y / m_rp.m_tile[3];
-      const index_type thr_id3 = (index_type)threadIdx_y % m_rp.m_tile[3];
+      const index_type thr_id2  = (index_type)threadIdx_y / m_rp.m_tile[3];
+      const index_type thr_id3  = (index_type)threadIdx_y % m_rp.m_tile[3];
 
-      temp0  =  m_rp.m_tile_end[4];
-      temp1  =  m_rp.m_tile_end[5];
-      const index_type numbl5 = ( temp1 <= max_blocks ? temp1 : max_blocks ) ;
-      const index_type numbl4 = ( temp0*temp1 > max_blocks ? index_type( max_blocks / numbl5 ) :
-          (  temp0 <= max_blocks ? temp0 : max_blocks ) );
+      temp0                   = m_rp.m_tile_end[4];
+      temp1                   = m_rp.m_tile_end[5];
+      const index_type numbl5 = (temp1 <= max_blocks ? temp1 : max_blocks);
+      const index_type numbl4 =
+          (temp0 * temp1 > max_blocks
+               ? index_type(max_blocks / numbl5)
+               : (temp0 <= max_blocks ? temp0 : max_blocks));
 
       const index_type tile_id4 = (index_type)blockIdx_z / numbl5;
       const index_type tile_id5 = (index_type)blockIdx_z % numbl5;
-      const index_type thr_id4 = (index_type)threadIdx_z / m_rp.m_tile[5];
-      const index_type thr_id5 = (index_type)threadIdx_z % m_rp.m_tile[5];
-
-      for ( index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0 ) {
-        const index_type offset_0 = i*m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
-        if ( offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0] ) {
-
-          for ( index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1 ) {
-            const index_type offset_1 = j*m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
-            if ( offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1] ) {
-
-              for ( index_type k = tile_id2; k < m_rp.m_tile_end[2]; k += numbl2 ) {
-                const index_type offset_2 = k*m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
-                if ( offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2] ) {
-
-                  for ( index_type l = tile_id3; l < m_rp.m_tile_end[3]; l += numbl3 ) {
-                    const index_type offset_3 = l*m_rp.m_tile[3] + thr_id3 + (index_type)m_rp.m_lower[3];
-                    if ( offset_3 < m_rp.m_upper[3] && thr_id3 < m_rp.m_tile[3] ) {
-
-                      for ( index_type m = tile_id4; m < m_rp.m_tile_end[4]; m += numbl4 ) {
-                        const index_type offset_4 = m*m_rp.m_tile[4] + thr_id4 + (index_type)m_rp.m_lower[4];
-                        if ( offset_4 < m_rp.m_upper[4] && thr_id4 < m_rp.m_tile[4] ) {
-
-                          for ( index_type n = tile_id5; n < m_rp.m_tile_end[5]; n += numbl5 ) {
-                            const index_type offset_5 = n*m_rp.m_tile[5] + thr_id5 + (index_type)m_rp.m_lower[5];
-                            if ( offset_5 < m_rp.m_upper[5] && thr_id5 < m_rp.m_tile[5] ) {
-                              m_func(Tag() , offset_0 , offset_1 , offset_2 , offset_3 , offset_4 , offset_5);
+      const index_type thr_id4  = (index_type)threadIdx_z / m_rp.m_tile[5];
+      const index_type thr_id5  = (index_type)threadIdx_z % m_rp.m_tile[5];
+
+      for (index_type i = tile_id0; i < m_rp.m_tile_end[0]; i += numbl0) {
+        const index_type offset_0 =
+            i * m_rp.m_tile[0] + thr_id0 + (index_type)m_rp.m_lower[0];
+        if (offset_0 < m_rp.m_upper[0] && thr_id0 < m_rp.m_tile[0]) {
+          for (index_type j = tile_id1; j < m_rp.m_tile_end[1]; j += numbl1) {
+            const index_type offset_1 =
+                j * m_rp.m_tile[1] + thr_id1 + (index_type)m_rp.m_lower[1];
+            if (offset_1 < m_rp.m_upper[1] && thr_id1 < m_rp.m_tile[1]) {
+              for (index_type k = tile_id2; k < m_rp.m_tile_end[2];
+                   k += numbl2) {
+                const index_type offset_2 =
+                    k * m_rp.m_tile[2] + thr_id2 + (index_type)m_rp.m_lower[2];
+                if (offset_2 < m_rp.m_upper[2] && thr_id2 < m_rp.m_tile[2]) {
+                  for (index_type l = tile_id3; l < m_rp.m_tile_end[3];
+                       l += numbl3) {
+                    const index_type offset_3 = l * m_rp.m_tile[3] + thr_id3 +
+                                                (index_type)m_rp.m_lower[3];
+                    if (offset_3 < m_rp.m_upper[3] &&
+                        thr_id3 < m_rp.m_tile[3]) {
+                      for (index_type m = tile_id4; m < m_rp.m_tile_end[4];
+                           m += numbl4) {
+                        const index_type offset_4 = m * m_rp.m_tile[4] +
+                                                    thr_id4 +
+                                                    (index_type)m_rp.m_lower[4];
+                        if (offset_4 < m_rp.m_upper[4] &&
+                            thr_id4 < m_rp.m_tile[4]) {
+                          for (index_type n = tile_id5; n < m_rp.m_tile_end[5];
+                               n += numbl5) {
+                            const index_type offset_5 =
+                                n * m_rp.m_tile[5] + thr_id5 +
+                                (index_type)m_rp.m_lower[5];
+                            if (offset_5 < m_rp.m_upper[5] &&
+                                thr_id5 < m_rp.m_tile[5]) {
+                              m_func(Tag(), offset_0, offset_1, offset_2,
+                                     offset_3, offset_4, offset_5);
                             }
                           }
                         }
@@ -1143,168 +1337,177 @@ struct DeviceIterateTile<6,RP,Functor,Tag>
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
 };
 
-} // Refactor
+}  // namespace Refactor
 
 // ----------------------------------------------------------------------------------
 
 namespace Reduce {
 
-template < typename T >
-using is_void = std::is_same< T, void >;
+template <typename T>
+using is_void = std::is_same<T, void>;
 
-template < typename T >
-struct is_array_type : std::false_type
-{
+template <typename T>
+struct is_array_type : std::false_type {
   using value_type = T;
 };
 
-template < typename T >
-struct is_array_type< T* > : std::true_type
-{
+template <typename T>
+struct is_array_type<T*> : std::true_type {
   using value_type = T;
 };
 
-template < typename T >
-struct is_array_type< T[] > : std::true_type
-{
+template <typename T>
+struct is_array_type<T[]> : std::true_type {
   using value_type = T;
 };
 
 // ------------------------------------------------------------------ //
-template< int N , typename RP , typename Functor , typename Tag , typename ValueType , typename Enable = void >
+template <int N, typename RP, typename Functor, typename Tag,
+          typename ValueType, typename Enable = void>
 struct DeviceIterateTile;
 
 // ParallelReduce iteration pattern
 // Scalar reductions
 
-// num_blocks = min( num_tiles, max_num_blocks ); //i.e. determined by number of tiles and reduction algorithm constraints
-// extract n-dim tile offsets (i.e. tile's global starting mulit-index) from the tileid = blockid using tile dimensions
-// local indices within a tile extracted from (index_type)threadIdx_x using tile dims, constrained by blocksize
-// combine tile and local id info for multi-dim global ids
+// num_blocks = min( num_tiles, max_num_blocks ); //i.e. determined by number of
+// tiles and reduction algorithm constraints extract n-dim tile offsets (i.e.
+// tile's global starting mulit-index) from the tileid = blockid using tile
+// dimensions local indices within a tile extracted from (index_type)threadIdx_x
+// using tile dims, constrained by blocksize combine tile and local id info for
+// multi-dim global ids
 
 // Pattern:
-// Each block+thread is responsible for a tile+local_id combo (additional when striding by num_blocks)
+// Each block+thread is responsible for a tile+local_id combo (additional when
+// striding by num_blocks)
 // 1. create offset arrays
-// 2. loop over number of tiles, striding by griddim (equal to num tiles, or max num blocks)
+// 2. loop over number of tiles, striding by griddim (equal to num tiles, or max
+// num blocks)
 // 3. temps set for tile_idx and thrd_idx, which will be modified
 // 4. if LL vs LR:
 //      determine tile starting point offsets (multidim)
 //      determine local index offsets (multidim)
 //      concatentate tile offset + local offset for global multi-dim index
-//    if offset withinin range bounds AND local offset within tile bounds, call functor
+//    if offset withinin range bounds AND local offset within tile bounds, call
+//    functor
 
 // ValueType = T
-//Rank 2
+// Rank 2
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,void,ValueType, typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
+          for (int i = 0; i < RP::rank; ++i) {
             // Deduce this blocks tile_id
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]);
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          {
-            m_func( m_offset[0], m_offset[1], m_v );
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
           }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]);
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
+          }
         }
       }
     }
 
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1312,72 +1515,79 @@ struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< !
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 3
+// Rank 3
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1385,71 +1595,80 @@ struct DeviceIterateTile<3,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1457,77 +1676,87 @@ struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< !
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 4
+// Rank 4
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1535,17 +1764,20 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1553,58 +1785,65 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1612,17 +1851,21 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1630,59 +1873,65 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 5
+// Rank 5
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1690,17 +1939,21 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1708,58 +1961,65 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1767,17 +2027,21 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1785,59 +2049,65 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
-//Rank 6
+// Rank 6
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if< !is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, void, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1845,17 +2115,21 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1863,58 +2137,65 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< !is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , ValueType & v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, ValueType& v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1922,17 +2203,21 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -1940,130 +2225,140 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< !i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
-  ValueType & m_v;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
+  ValueType& m_v;
 };
 
-
 // ValueType = T[], T*
-//Rank 2
+// Rank 2
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,void,ValueType, typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
-  [[hc]]
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  [[hc]] DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]);
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          {
-            m_func( m_offset[0], m_offset[1], m_v );
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
           }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    2, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2071,17 +2366,20 @@ struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2089,128 +2387,142 @@ struct DeviceIterateTile<2,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_v);
+          }
         }
-      } //end for loop over num_tiles - product of tiles in each direction
+      }  // end for loop over num_tiles - product of tiles in each direction
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 3
+// Rank 3
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
-            m_local_offset[i] = (thrd_idx % m_rp.m_tile[i]); // Move this to first computation, add to m_offset right away
+            m_local_offset[i] =
+                (thrd_idx % m_rp.m_tile[i]);  // Move this to first computation,
+                                              // add to m_offset right away
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    3, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2218,17 +2530,20 @@ struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2236,60 +2551,66 @@ struct DeviceIterateTile<3,RP,Functor,Tag, ValueType, typename std::enable_if< i
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 4
+// Rank 4
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2297,17 +2618,20 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2315,59 +2639,66 @@ struct DeviceIterateTile<4,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for void tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    4, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2375,17 +2706,21 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2393,60 +2728,67 @@ struct DeviceIterateTile<4,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 5
+// Rank 5
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2454,17 +2796,21 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2472,59 +2818,67 @@ struct DeviceIterateTile<5,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    5, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2532,17 +2886,21 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2550,60 +2908,67 @@ struct DeviceIterateTile<5,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
-//Rank 6
+// Rank 6
 // Specializations for void tag type
-template< typename RP , typename Functor , typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if< is_array_type<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, void, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2611,17 +2976,21 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2629,59 +2998,67 @@ struct DeviceIterateTile<6,RP,Functor,void,ValueType , typename std::enable_if<
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-
 // Specializations for tag type
-template< typename RP , typename Functor , typename Tag, typename ValueType >
-struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< is_array_type<ValueType>::value && !is_void< Tag >::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct DeviceIterateTile<
+    6, RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_array_type<ValueType>::value &&
+                            !is_void<Tag>::value>::type> {
   using index_type = typename RP::index_type;
-  using value_type = typename is_array_type< ValueType >::value_type;
+  using value_type = typename is_array_type<ValueType>::value_type;
 
   KOKKOS_INLINE_FUNCTION
-  DeviceIterateTile( const RP & rp_ , const Functor & f_ , value_type* v_)
-  : m_rp(rp_)
-  , m_func(f_)
-  , m_v(v_)
-  {}
+  DeviceIterateTile(const RP& rp_, const Functor& f_, value_type* v_)
+      : m_rp(rp_), m_func(f_), m_v(v_) {}
 
   static constexpr index_type max_blocks = 65535;
-  //static constexpr index_type max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
+  // static constexpr index_type max_blocks =
+  // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount);
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range() const
-  {
-    //enum { max_blocks = static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
-    //const index_type max_blocks = static_cast<index_type>( Kokkos::Impl::rocm_internal_maximum_grid_count() );
-    if ( (index_type)blockIdx_x < m_rp.m_num_tiles && (index_type)threadIdx_y < m_rp.m_prod_tile_dims ) {
-      index_type m_offset[RP::rank]; // tile starting global id offset
-      index_type m_local_offset[RP::rank]; // tile starting global id offset
-
-      for ( index_type tileidx = (index_type)blockIdx_x; tileidx < m_rp.m_num_tiles; tileidx += gridDim_x ) {
-        index_type tile_idx = tileidx; // temp because tile_idx will be modified while determining tile starting point offsets
+  void exec_range() const {
+    // enum { max_blocks =
+    // static_cast<index_type>(Kokkos::Impl::ROCmTraits::UpperBoundGridCount) };
+    // const index_type max_blocks = static_cast<index_type>(
+    // Kokkos::Impl::rocm_internal_maximum_grid_count() );
+    if ((index_type)blockIdx_x < m_rp.m_num_tiles &&
+        (index_type)threadIdx_y < m_rp.m_prod_tile_dims) {
+      index_type m_offset[RP::rank];        // tile starting global id offset
+      index_type m_local_offset[RP::rank];  // tile starting global id offset
+
+      for (index_type tileidx = (index_type)blockIdx_x;
+           tileidx < m_rp.m_num_tiles; tileidx += gridDim_x) {
+        index_type tile_idx =
+            tileidx;  // temp because tile_idx will be modified while
+                      // determining tile starting point offsets
         index_type thrd_idx = (index_type)threadIdx_y;
-        bool in_bounds = true;
+        bool in_bounds      = true;
 
         // LL
         if (RP::inner_direction == RP::Left) {
-          for (int i=0; i<RP::rank; ++i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = 0; i < RP::rank; ++i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2689,17 +3066,21 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
         // LR
         else {
-          for (int i=RP::rank-1; i>=0; --i) {
-            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+          for (int i = RP::rank - 1; i >= 0; --i) {
+            m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] +
+                          m_rp.m_lower[i];
             tile_idx /= m_rp.m_tile_end[i];
 
             // tile-local indices identified with (index_type)threadIdx_y
@@ -2707,28 +3088,32 @@ struct DeviceIterateTile<6,RP,Functor,Tag,ValueType, typename std::enable_if< is
             thrd_idx /= m_rp.m_tile[i];
 
             m_offset[i] += m_local_offset[i];
-            if ( !(m_offset[i] < m_rp.m_upper[i] && m_local_offset[i] < m_rp.m_tile[i]) ) {
+            if (!(m_offset[i] < m_rp.m_upper[i] &&
+                  m_local_offset[i] < m_rp.m_tile[i])) {
               in_bounds &= false;
             }
           }
-          if ( in_bounds )
-          { m_func( Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3], m_offset[4], m_offset[5], m_v ); }
+          if (in_bounds) {
+            m_func(Tag(), m_offset[0], m_offset[1], m_offset[2], m_offset[3],
+                   m_offset[4], m_offset[5], m_v);
+          }
         }
       }
     }
-  } //end exec_range
+  }  // end exec_range
 
-private:
-  const RP & m_rp;
-  const Functor & m_func;
+ private:
+  const RP& m_rp;
+  const Functor& m_func;
   value_type* m_v;
 };
 
-} // Reduce
+}  // namespace Reduce
 
 // ----------------------------------------------------------------------------------
 
-} } //end namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 #undef threadIdx_x
 #undef threadIdx_y
 #undef threadIdx_z
@@ -2745,6 +3130,5 @@ private:
 #undef gridDim_y
 #undef gridDim_z
 
-
 #endif
 #endif
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Atomic.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Atomic.hpp
index db7527701dfc40d60334262d9bf7fd09285945f9..484269f21fdf8b481d3722f5e565f4ffffa13644 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Atomic.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Atomic.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,449 +47,488 @@
 
 #ifdef KOKKOS_ENABLE_ROCM_ATOMICS
 namespace Kokkos {
-  //ROCm can do:
-  //Types int/unsigned int
-  //variants: atomic_exchange/compare_exchange/fetch_add/fetch_sub/fetch_max/fetch_min/fetch_and/fetch_or/fetch_xor/fetch_inc/fetch_dec 
-
-
-  KOKKOS_INLINE_FUNCTION
-  int atomic_exchange(int* dest, const int& val) {
-    return hc::atomic_exchange_int(dest, val);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  unsigned int atomic_exchange(unsigned int* dest, const unsigned int& val) {
-    return hc::atomic_exchange_unsigned(dest, val);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  int64_t atomic_exchange(int64_t* dest, const int64_t& val) {
-    return (int64_t)hc::atomic_exchange_uint64((uint64_t*)dest, (const uint64_t&)val);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  uint64_t atomic_exchange(uint64_t* dest, const uint64_t& val) {
-    return hc::atomic_exchange_uint64(dest, val);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  long long atomic_exchange(long long* dest, const long long& val) {
-    return (long long)hc::atomic_exchange_uint64((uint64_t*)dest, (const uint64_t&)val);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  unsigned long long atomic_exchange(unsigned long long* dest, const unsigned long long& val) {
-    return (unsigned long long)hc::atomic_exchange_uint64((uint64_t*)dest, (const uint64_t&)val);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  float atomic_exchange(float* dest, const float& val) {
-    union U {
-      int i ;
-      float f ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } idest,ival;
-    idest.f = *dest;
-    ival.f = val;
-    idest.i = hc::atomic_exchange_int((int*)dest, ival.i);
-    return idest.f;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  double atomic_exchange(double* dest, const double& val) {
-    union U {
-      uint64_t i ;
-      double d ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } idest,ival;
-    idest.d = *dest;
-    ival.d = val;
-    idest.i = hc::atomic_exchange_uint64((uint64_t*)dest, ival.i);
-    return idest.d;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  int atomic_compare_exchange(int* dest, int compare, const int& val);
+// ROCm can do:
+// Types int/unsigned int
+// variants:
+// atomic_exchange/compare_exchange/fetch_add/fetch_sub/fetch_max/fetch_min/fetch_and/fetch_or/fetch_xor/fetch_inc/fetch_dec
+
+KOKKOS_INLINE_FUNCTION
+int atomic_exchange(int* dest, const int& val) {
+  return hc::atomic_exchange_int(dest, val);
+}
 
-  KOKKOS_INLINE_FUNCTION
-  int64_t atomic_compare_exchange(int64_t* dest, int64_t compare, const int64_t& val);
+KOKKOS_INLINE_FUNCTION
+unsigned int atomic_exchange(unsigned int* dest, const unsigned int& val) {
+  return hc::atomic_exchange_unsigned(dest, val);
+}
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_exchange(T* dest, typename std::enable_if<sizeof(T) == sizeof(int), const T&>::type val) {
-    union U {
-      int i ;
-      T t ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } assume , oldval , newval ;
+KOKKOS_INLINE_FUNCTION
+int64_t atomic_exchange(int64_t* dest, const int64_t& val) {
+  return (int64_t)hc::atomic_exchange_uint64((uint64_t*)dest,
+                                             (const uint64_t&)val);
+}
 
-    oldval.t = *dest ;
-    assume.i = oldval.i ;
-    newval.t = val ;
-    atomic_compare_exchange( (int*)(dest) , assume.i, newval.i );
+KOKKOS_INLINE_FUNCTION
+uint64_t atomic_exchange(uint64_t* dest, const uint64_t& val) {
+  return hc::atomic_exchange_uint64(dest, val);
+}
 
-    return oldval.t ;    
-  }
+KOKKOS_INLINE_FUNCTION
+long long atomic_exchange(long long* dest, const long long& val) {
+  return (long long)hc::atomic_exchange_uint64((uint64_t*)dest,
+                                               (const uint64_t&)val);
+}
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_exchange(T* dest, typename std::enable_if<sizeof(T) != sizeof(int) && sizeof(T) == sizeof(int64_t), const T&>::type val) {
-    union U {
-      uint64_t i ;
-      T t ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } assume , oldval , newval ;
+KOKKOS_INLINE_FUNCTION
+unsigned long long atomic_exchange(unsigned long long* dest,
+                                   const unsigned long long& val) {
+  return (unsigned long long)hc::atomic_exchange_uint64((uint64_t*)dest,
+                                                        (const uint64_t&)val);
+}
 
-    oldval.t = *dest ;
+KOKKOS_INLINE_FUNCTION
+float atomic_exchange(float* dest, const float& val) {
+  union U {
+    int i;
+    float f;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } idest, ival;
+  idest.f = *dest;
+  ival.f  = val;
+  idest.i = hc::atomic_exchange_int((int*)dest, ival.i);
+  return idest.f;
+}
 
-    assume.i = oldval.i ;
-    newval.t = val ;
-    atomic_compare_exchange( (int64_t*)(dest) , assume.i, newval.i );
+KOKKOS_INLINE_FUNCTION
+double atomic_exchange(double* dest, const double& val) {
+  union U {
+    uint64_t i;
+    double d;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } idest, ival;
+  idest.d = *dest;
+  ival.d  = val;
+  idest.i = hc::atomic_exchange_uint64((uint64_t*)dest, ival.i);
+  return idest.d;
+}
 
-    return oldval.t ;    
-  }
- 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_exchange(T* dest, typename std::enable_if<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(int64_t), const T&>::type val) {
-    return val;
-  }
+KOKKOS_INLINE_FUNCTION
+int atomic_compare_exchange(int* dest, int compare, const int& val);
+
+KOKKOS_INLINE_FUNCTION
+int64_t atomic_compare_exchange(int64_t* dest, int64_t compare,
+                                const int64_t& val);
+
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_exchange(
+    T* dest,
+    typename std::enable_if<sizeof(T) == sizeof(int), const T&>::type val) {
+  union U {
+    int i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } assume, oldval, newval;
+
+  oldval.t = *dest;
+  assume.i = oldval.i;
+  newval.t = val;
+  atomic_compare_exchange((int*)(dest), assume.i, newval.i);
+
+  return oldval.t;
+}
 
-  KOKKOS_INLINE_FUNCTION
-  int atomic_compare_exchange(int* dest, int compare, const int& val) {
-    return hc::atomic_compare_exchange_int(dest, compare, val);
-  }
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_exchange(
+    T* dest, typename std::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) == sizeof(int64_t),
+                                     const T&>::type val) {
+  union U {
+    uint64_t i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } assume, oldval, newval;
 
-  KOKKOS_INLINE_FUNCTION
-  unsigned int atomic_compare_exchange(unsigned int* dest, unsigned int compare, const unsigned int& val) {
-    return hc::atomic_compare_exchange_unsigned(dest, compare, val);
-  }
+  oldval.t = *dest;
 
-  KOKKOS_INLINE_FUNCTION
-  int64_t atomic_compare_exchange(int64_t* dest, int64_t compare, const int64_t& val) {
-    return (int64_t) hc::atomic_compare_exchange_uint64((uint64_t*)dest, (uint64_t)compare, (const uint64_t&)val);
-  }
+  assume.i = oldval.i;
+  newval.t = val;
+  atomic_compare_exchange((int64_t*)(dest), assume.i, newval.i);
 
-  KOKKOS_INLINE_FUNCTION
-  uint64_t atomic_compare_exchange(uint64_t* dest, uint64_t compare, const uint64_t& val) {
-    return hc::atomic_compare_exchange_uint64(dest, compare, val);
-  }
+  return oldval.t;
+}
 
-  KOKKOS_INLINE_FUNCTION
-  long long atomic_compare_exchange(long long* dest, long long compare, const long long& val) {
-    return (long long)hc::atomic_compare_exchange_uint64((uint64_t*)(dest), (uint64_t)(compare), (const uint64_t&)(val));
-  }
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_exchange(
+    T* dest, typename std::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) != sizeof(int64_t),
+                                     const T&>::type val) {
+  return val;
+}
 
-  KOKKOS_INLINE_FUNCTION
-  float atomic_compare_exchange(float* dest, float compare, const float& val) {
-    union U {
-      int i ;
-      float f ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } idest,icompare,ival;
-    idest.f = *dest;
-    icompare.f = compare;
-    ival.f = val;
-    idest.i = hc::atomic_compare_exchange_int(reinterpret_cast<int*>(dest), icompare.i, ival.i);
-    return idest.f;
-  }
+KOKKOS_INLINE_FUNCTION
+int atomic_compare_exchange(int* dest, int compare, const int& val) {
+  return hc::atomic_compare_exchange_int(dest, compare, val);
+}
 
-  KOKKOS_INLINE_FUNCTION
-  double atomic_compare_exchange(double* dest, double compare, const double& val) {
-    union U {
-      uint64_t i ;
-      double d ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } idest,icompare,ival;
-    idest.d = *dest;
-    icompare.d = compare;
-    ival.d = val;
-    idest.i = hc::atomic_compare_exchange_uint64(reinterpret_cast<uint64_t*>(dest), icompare.i, ival.i);
-    return idest.d;
-  }
+KOKKOS_INLINE_FUNCTION
+unsigned int atomic_compare_exchange(unsigned int* dest, unsigned int compare,
+                                     const unsigned int& val) {
+  return hc::atomic_compare_exchange_unsigned(dest, compare, val);
+}
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_compare_exchange(volatile T* dest, T compare, typename std::enable_if<sizeof(T) == sizeof(int), const T&>::type val) {
-    union U {
-      int i ;
-      T f ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } idest,icompare,ival;
-    idest.f = *dest;
-    icompare.f = compare;
-    ival.f = val;
-    idest.i = hc::atomic_compare_exchange_int((int*)(dest), icompare.i, ival.i);
-    return idest.f;
-  }
+KOKKOS_INLINE_FUNCTION
+int64_t atomic_compare_exchange(int64_t* dest, int64_t compare,
+                                const int64_t& val) {
+  return (int64_t)hc::atomic_compare_exchange_uint64(
+      (uint64_t*)dest, (uint64_t)compare, (const uint64_t&)val);
+}
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_compare_exchange(volatile T* dest, T compare, typename std::enable_if<sizeof(T) == sizeof(int64_t), const T&>::type val) {
-    union U {
-      uint64_t i ;
-      T f ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } idest,icompare,ival;
-    idest.f = *dest;
-    icompare.f = compare;
-    ival.f = val;
-    idest.i = hc::atomic_compare_exchange_uint64((uint64_t*)(dest), icompare.i, ival.i);
-    return idest.f;
-  }
+KOKKOS_INLINE_FUNCTION
+uint64_t atomic_compare_exchange(uint64_t* dest, uint64_t compare,
+                                 const uint64_t& val) {
+  return hc::atomic_compare_exchange_uint64(dest, compare, val);
+}
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_compare_exchange(volatile T* dest, T compare, typename std::enable_if<(sizeof(T) != sizeof(int32_t)) && (sizeof(T) != sizeof(int64_t)), const T&>::type val) {
-    return val;
-  }
+KOKKOS_INLINE_FUNCTION
+long long atomic_compare_exchange(long long* dest, long long compare,
+                                  const long long& val) {
+  return (long long)hc::atomic_compare_exchange_uint64(
+      (uint64_t*)(dest), (uint64_t)(compare), (const uint64_t&)(val));
+}
 
-  KOKKOS_INLINE_FUNCTION
-  int atomic_fetch_add (volatile int * dest, const int& val) {
-    return hc::atomic_fetch_add((int *)dest, val);
-  }
-  
-  KOKKOS_INLINE_FUNCTION
-  unsigned int atomic_fetch_add(unsigned int* dest, const unsigned int& val) {
-    return hc::atomic_fetch_add(dest, val);
-  }
+KOKKOS_INLINE_FUNCTION
+float atomic_compare_exchange(float* dest, float compare, const float& val) {
+  union U {
+    int i;
+    float f;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } idest, icompare, ival;
+  idest.f    = *dest;
+  icompare.f = compare;
+  ival.f     = val;
+  idest.i    = hc::atomic_compare_exchange_int(reinterpret_cast<int*>(dest),
+                                            icompare.i, ival.i);
+  return idest.f;
+}
 
-  KOKKOS_INLINE_FUNCTION
-  unsigned long atomic_fetch_add(volatile unsigned long* dest, const unsigned long& val) {
-    return (unsigned long)hc::atomic_fetch_add((uint64_t *)dest, (const uint64_t)val);
-  }
+KOKKOS_INLINE_FUNCTION
+double atomic_compare_exchange(double* dest, double compare,
+                               const double& val) {
+  union U {
+    uint64_t i;
+    double d;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } idest, icompare, ival;
+  idest.d    = *dest;
+  icompare.d = compare;
+  ival.d     = val;
+  idest.i    = hc::atomic_compare_exchange_uint64(
+      reinterpret_cast<uint64_t*>(dest), icompare.i, ival.i);
+  return idest.d;
+}
 
-  KOKKOS_INLINE_FUNCTION
-  int64_t atomic_fetch_add(volatile int64_t* dest, const int64_t& val) {
-    return (int64_t)hc::atomic_fetch_add((uint64_t *)dest, (const uint64_t&)val);
-  }
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(
+    volatile T* dest, T compare,
+    typename std::enable_if<sizeof(T) == sizeof(int), const T&>::type val) {
+  union U {
+    int i;
+    T f;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } idest, icompare, ival;
+  idest.f    = *dest;
+  icompare.f = compare;
+  ival.f     = val;
+  idest.i = hc::atomic_compare_exchange_int((int*)(dest), icompare.i, ival.i);
+  return idest.f;
+}
 
-  KOKKOS_INLINE_FUNCTION
-  char atomic_fetch_add(volatile char * dest, const char& val) {
-    unsigned int oldval,newval,assume;
-    oldval = *(int *)dest ;
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(
+    volatile T* dest, T compare,
+    typename std::enable_if<sizeof(T) == sizeof(int64_t), const T&>::type val) {
+  union U {
+    uint64_t i;
+    T f;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } idest, icompare, ival;
+  idest.f    = *dest;
+  icompare.f = compare;
+  ival.f     = val;
+  idest.i =
+      hc::atomic_compare_exchange_uint64((uint64_t*)(dest), icompare.i, ival.i);
+  return idest.f;
+}
 
-    do {
-      assume = oldval ;
-      newval = assume&0x7fffff00 + ((assume&0xff)+val)&0xff ;
-      oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,newval);
-    } while ( assume != oldval );
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(
+    volatile T* dest, T compare,
+    typename std::enable_if<(sizeof(T) != sizeof(int32_t)) &&
+                                (sizeof(T) != sizeof(int64_t)),
+                            const T&>::type val) {
+  return val;
+}
 
-    return oldval ;    
-  }
+KOKKOS_INLINE_FUNCTION
+int atomic_fetch_add(volatile int* dest, const int& val) {
+  return hc::atomic_fetch_add((int*)dest, val);
+}
 
+KOKKOS_INLINE_FUNCTION
+unsigned int atomic_fetch_add(unsigned int* dest, const unsigned int& val) {
+  return hc::atomic_fetch_add(dest, val);
+}
 
-  KOKKOS_INLINE_FUNCTION
-  short atomic_fetch_add(volatile short * dest, const short& val) {
-    unsigned int oldval,newval,assume;
-    oldval = *(int *)dest ;
+KOKKOS_INLINE_FUNCTION
+unsigned long atomic_fetch_add(volatile unsigned long* dest,
+                               const unsigned long& val) {
+  return (unsigned long)hc::atomic_fetch_add((uint64_t*)dest,
+                                             (const uint64_t)val);
+}
 
-    do {
-      assume = oldval ;
-      newval = assume&0x7fff0000 + ((assume&0xffff)+val)&0xffff ;
-      oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,newval);
-    } while ( assume != oldval );
+KOKKOS_INLINE_FUNCTION
+int64_t atomic_fetch_add(volatile int64_t* dest, const int64_t& val) {
+  return (int64_t)hc::atomic_fetch_add((uint64_t*)dest, (const uint64_t&)val);
+}
 
-    return oldval ;    
-  }
+KOKKOS_INLINE_FUNCTION
+char atomic_fetch_add(volatile char* dest, const char& val) {
+  unsigned int oldval, newval, assume;
+  oldval = *(int*)dest;
 
-  KOKKOS_INLINE_FUNCTION
-  long long atomic_fetch_add(volatile long long * dest, const long long& val) {
-    return (long long)hc::atomic_fetch_add((uint64_t*)dest, (const uint64_t&)val);
-  }
+  do {
+    assume = oldval;
+    newval = assume & 0x7fffff00 + ((assume & 0xff) + val) & 0xff;
+    oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,
+                                                  newval);
+  } while (assume != oldval);
 
+  return oldval;
+}
 
+KOKKOS_INLINE_FUNCTION
+short atomic_fetch_add(volatile short* dest, const short& val) {
+  unsigned int oldval, newval, assume;
+  oldval = *(int*)dest;
 
-  KOKKOS_INLINE_FUNCTION
-  int atomic_fetch_sub (volatile int * dest, const int& val) {
-    return hc::atomic_fetch_sub((int *)dest, val);
-  }
-  
-  KOKKOS_INLINE_FUNCTION
-  unsigned int atomic_fetch_sub(volatile unsigned int* dest, const unsigned int& val) {
-    return hc::atomic_fetch_sub((unsigned int *)dest, val);
-  }
+  do {
+    assume = oldval;
+    newval = assume & 0x7fff0000 + ((assume & 0xffff) + val) & 0xffff;
+    oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,
+                                                  newval);
+  } while (assume != oldval);
 
-  KOKKOS_INLINE_FUNCTION
-  int64_t atomic_fetch_sub(int64_t* dest, const int64_t& val) {
-    return (int64_t)hc::atomic_fetch_add((uint64_t *)dest, -(const uint64_t&)val);
-//    return (int64_t)hc::atomic_fetch_sub_uint64((uint64_t*)dest, (const uint64_t&)val);
-  }
-  
-  KOKKOS_INLINE_FUNCTION
-  char atomic_fetch_sub(volatile char * dest, const char& val) {
-    unsigned int oldval,newval,assume;
-    oldval = *(int *)dest ;
-
-    do {
-      assume = oldval ;
-      newval = assume&0x7fffff00 + ((assume&0xff)-val)&0xff ;
-      oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,newval);
-    } while ( assume != oldval );
-
-    return oldval ;    
-  }
+  return oldval;
+}
 
-  KOKKOS_INLINE_FUNCTION
-  short atomic_fetch_sub(volatile short * dest, const short& val) {
-    unsigned int oldval,newval,assume;
-    oldval = *(int *)dest ;
+KOKKOS_INLINE_FUNCTION
+long long atomic_fetch_add(volatile long long* dest, const long long& val) {
+  return (long long)hc::atomic_fetch_add((uint64_t*)dest, (const uint64_t&)val);
+}
 
-    do {
-      assume = oldval ;
-      newval = assume&0x7fff0000 + ((assume&0xffff)-val)&0xffff;
-      oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,newval);
-    } while ( assume != oldval );
+KOKKOS_INLINE_FUNCTION
+int atomic_fetch_sub(volatile int* dest, const int& val) {
+  return hc::atomic_fetch_sub((int*)dest, val);
+}
 
-    return oldval ;    
-  }
+KOKKOS_INLINE_FUNCTION
+unsigned int atomic_fetch_sub(volatile unsigned int* dest,
+                              const unsigned int& val) {
+  return hc::atomic_fetch_sub((unsigned int*)dest, val);
+}
 
-  KOKKOS_INLINE_FUNCTION
-  long long atomic_fetch_sub(volatile long long * dest, const long long& val) {
-    return (long long)hc::atomic_fetch_add((uint64_t*)dest, -(const uint64_t&)val);
-  }
+KOKKOS_INLINE_FUNCTION
+int64_t atomic_fetch_sub(int64_t* dest, const int64_t& val) {
+  return (int64_t)hc::atomic_fetch_add((uint64_t*)dest, -(const uint64_t&)val);
+  //    return (int64_t)hc::atomic_fetch_sub_uint64((uint64_t*)dest, (const
+  //    uint64_t&)val);
+}
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_fetch_add(volatile T* dest, typename std::enable_if<sizeof(T) == sizeof(int), const T&>::type val) {
-    union U {
-      unsigned int i ;
-      T t ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } assume , oldval , newval ;
+KOKKOS_INLINE_FUNCTION
+char atomic_fetch_sub(volatile char* dest, const char& val) {
+  unsigned int oldval, newval, assume;
+  oldval = *(int*)dest;
 
-    oldval.t = *dest ;
+  do {
+    assume = oldval;
+    newval = assume & 0x7fffff00 + ((assume & 0xff) - val) & 0xff;
+    oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,
+                                                  newval);
+  } while (assume != oldval);
 
-    do {
-      assume.i = oldval.i ;
-      newval.t = assume.t + val ;
-      oldval.i = atomic_compare_exchange( (unsigned int*)(dest) , assume.i , newval.i );
-    } while ( assume.i != oldval.i );
+  return oldval;
+}
 
-    return oldval.t ;    
-  }
+KOKKOS_INLINE_FUNCTION
+short atomic_fetch_sub(volatile short* dest, const short& val) {
+  unsigned int oldval, newval, assume;
+  oldval = *(int*)dest;
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_fetch_add(volatile T* dest, typename std::enable_if<sizeof(T) != sizeof(int) && sizeof(T) == sizeof(int64_t), const T&>::type val) {
-    union U {
-      uint64_t i ;
-      T t ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } assume , oldval , newval ;
+  do {
+    assume = oldval;
+    newval = assume & 0x7fff0000 + ((assume & 0xffff) - val) & 0xffff;
+    oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,
+                                                  newval);
+  } while (assume != oldval);
 
-    oldval.t = *dest ;
+  return oldval;
+}
 
-    do {
-      assume.i = oldval.i ;
-      newval.t = assume.t + val ;
-      oldval.i = atomic_compare_exchange( (uint64_t*)dest , assume.i , newval.i );
-    } while ( assume.i != oldval.i );
+KOKKOS_INLINE_FUNCTION
+long long atomic_fetch_sub(volatile long long* dest, const long long& val) {
+  return (long long)hc::atomic_fetch_add((uint64_t*)dest,
+                                         -(const uint64_t&)val);
+}
 
-    return oldval.t ;    
-  }
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_add(
+    volatile T* dest,
+    typename std::enable_if<sizeof(T) == sizeof(int), const T&>::type val) {
+  union U {
+    unsigned int i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } assume, oldval, newval;
+
+  oldval.t = *dest;
+
+  do {
+    assume.i = oldval.i;
+    newval.t = assume.t + val;
+    oldval.i =
+        atomic_compare_exchange((unsigned int*)(dest), assume.i, newval.i);
+  } while (assume.i != oldval.i);
+
+  return oldval.t;
+}
 
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_add(
+    volatile T* dest, typename std::enable_if<sizeof(T) != sizeof(int) &&
+                                                  sizeof(T) == sizeof(int64_t),
+                                              const T&>::type val) {
+  union U {
+    uint64_t i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } assume, oldval, newval;
+
+  oldval.t = *dest;
+
+  do {
+    assume.i = oldval.i;
+    newval.t = assume.t + val;
+    oldval.i = atomic_compare_exchange((uint64_t*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
+
+  return oldval.t;
+}
 
-  //WORKAROUND
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_fetch_add(volatile T* dest, typename std::enable_if<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(int64_t), const T&>::type val) {
-    T return_val;
-    // Do we need to (like in CUDA) handle potential wavefront branching?
-    int done = 0;
-    //unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
-    //unsigned int done_active = 0;
-    //while (active!=done_active) {
-    if(!done) {
-      bool locked = ::Kokkos::Impl::lock_address_rocm_space( (void*) dest );
-      if( locked ) {
-        return_val = *dest;
-        *dest = return_val + val;
-        ::Kokkos::Impl::unlock_address_rocm_space( (void*) dest );
-        done = 1;
-      }
+// WORKAROUND
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_add(
+    volatile T* dest, typename std::enable_if<sizeof(T) != sizeof(int) &&
+                                                  sizeof(T) != sizeof(int64_t),
+                                              const T&>::type val) {
+  T return_val;
+  // Do we need to (like in CUDA) handle potential wavefront branching?
+  int done = 0;
+  // unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
+  // unsigned int done_active = 0;
+  // while (active!=done_active) {
+  if (!done) {
+    bool locked = ::Kokkos::Impl::lock_address_rocm_space((void*)dest);
+    if (locked) {
+      return_val = *dest;
+      *dest      = return_val + val;
+      ::Kokkos::Impl::unlock_address_rocm_space((void*)dest);
+      done = 1;
     }
-    //done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
-  //}
-    return return_val;
-  }
-
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_fetch_sub(volatile T* dest, typename std::enable_if<sizeof(T) == sizeof(int),T>::type val) {
-    union U {
-      int i ;
-      T t ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } assume , oldval , newval ;
-
-    oldval.t = *dest ;
-
-    do {
-      assume.i = oldval.i ;
-      newval.t = assume.t - val ;
-      oldval.i = Kokkos::atomic_compare_exchange( (int*)dest , assume.i , newval.i );
-    } while ( assume.i != oldval.i );
-
-    return oldval.t ;
   }
+  // done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
+  //}
+  return return_val;
+}
 
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_fetch_sub(volatile T* dest, typename std::enable_if<sizeof(T) != sizeof(int) && sizeof(T) == sizeof(int64_t), const T&>::type val) {
-    union U {
-      int64_t i ;
-      T t ;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } assume , oldval , newval ;
-
-    oldval.t = *dest ;
-
-    do {
-      assume.i = oldval.i ;
-      newval.t = assume.t - val ;
-      oldval.i = atomic_compare_exchange( (int64_t*)dest , assume.i , newval.i );
-    } while ( assume.i != oldval.i );
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_sub(
+    volatile T* dest,
+    typename std::enable_if<sizeof(T) == sizeof(int), T>::type val) {
+  union U {
+    int i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } assume, oldval, newval;
+
+  oldval.t = *dest;
+
+  do {
+    assume.i = oldval.i;
+    newval.t = assume.t - val;
+    oldval.i = Kokkos::atomic_compare_exchange((int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
+
+  return oldval.t;
+}
 
-    return oldval.t ;    
-  }
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_sub(
+    volatile T* dest, typename std::enable_if<sizeof(T) != sizeof(int) &&
+                                                  sizeof(T) == sizeof(int64_t),
+                                              const T&>::type val) {
+  union U {
+    int64_t i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } assume, oldval, newval;
+
+  oldval.t = *dest;
+
+  do {
+    assume.i = oldval.i;
+    newval.t = assume.t - val;
+    oldval.i = atomic_compare_exchange((int64_t*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
+
+  return oldval.t;
+}
 //  KOKKOS_INLINE_FUNCTION
 //  char atomic_fetch_sub(volatile char * dest, const char& val) {
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_fetch_sub(volatile T* dest, typename std::enable_if<sizeof(T) == sizeof(char),T>::type val) {
-
-    unsigned int oldval,newval,assume;
-    oldval = *(int *)dest ;
-
-    do {
-      assume = oldval ;
-      newval = assume&0x7fffff00 + ((assume&0xff)-val)&0xff ;
-      oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,newval);
-    } while ( assume != oldval );
-
-    return (T) oldval&0xff ;
-  }
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_sub(
+    volatile T* dest,
+    typename std::enable_if<sizeof(T) == sizeof(char), T>::type val) {
+  unsigned int oldval, newval, assume;
+  oldval = *(int*)dest;
+
+  do {
+    assume = oldval;
+    newval = assume & 0x7fffff00 + ((assume & 0xff) - val) & 0xff;
+    oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,
+                                                  newval);
+  } while (assume != oldval);
+
+  return (T)oldval & 0xff;
+}
 
 //  KOKKOS_INLINE_FUNCTION
 //  short atomic_fetch_sub(volatile short * dest, const short& val) {
-  template<class T>
-  KOKKOS_INLINE_FUNCTION
-  T atomic_fetch_sub(volatile T* dest, typename std::enable_if<sizeof(T) == sizeof(short),T>::type val) {
-
-    unsigned int oldval,newval,assume;
-    oldval = *(int *)dest ;
-
-    do {
-      assume = oldval ;
-      newval = assume&0x7fff0000 + ((assume&0xffff)-val)&0xffff;
-      oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,newval);
-    } while ( assume != oldval );
-
-    return (T) oldval&0xffff ;
-  }
-
-
-
+template <class T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_sub(
+    volatile T* dest,
+    typename std::enable_if<sizeof(T) == sizeof(short), T>::type val) {
+  unsigned int oldval, newval, assume;
+  oldval = *(int*)dest;
+
+  do {
+    assume = oldval;
+    newval = assume & 0x7fff0000 + ((assume & 0xffff) - val) & 0xffff;
+    oldval = hc::atomic_compare_exchange_unsigned((unsigned int*)dest, assume,
+                                                  newval);
+  } while (assume != oldval);
+
+  return (T)oldval & 0xffff;
 }
+
+}  // namespace Kokkos
 #endif
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Config.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Config.hpp
index 87840bb37be3b4a63f613c68a86846f7a381710d..422e425cfef84d7be051a8d78a8778f95eeba513 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Config.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Config.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.cpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.cpp
index b4be18d03be763bea6aa0c54148bbd07b572e675..4c500521b1a5984988bcea5b1c09c3066bf1623d 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.cpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,56 +50,51 @@
 //#include <ROCm/Kokkos_ROCmExec.hpp>
 #include <hc.hpp>
 
-#define ROCM_SPACE_ATOMIC_MASK      0x1FFFF
-#define ROCM_SPACE_ATOMIC_XOR_MASK  0x15A39
+#define ROCM_SPACE_ATOMIC_MASK 0x1FFFF
+#define ROCM_SPACE_ATOMIC_XOR_MASK 0x15A39
 #define ROCM_CONCURRENCY 20480
 //#define ROCM_CONCURRENCY 81920  # for fiji
 
 namespace Kokkos {
-  static int rocm_space_atomic_locks[ROCM_SPACE_ATOMIC_MASK+1];
-  static int rocm_space_scratch_locks[ROCM_CONCURRENCY];
-  static int rocm_space_threadid_locks[ROCM_CONCURRENCY];
+static int rocm_space_atomic_locks[ROCM_SPACE_ATOMIC_MASK + 1];
+static int rocm_space_scratch_locks[ROCM_CONCURRENCY];
+static int rocm_space_threadid_locks[ROCM_CONCURRENCY];
 namespace Impl {
 // TODO: mimic cuda implemtation, add dgpu capability
 
-  void init_rocm_atomic_lock_array() {
-    static int is_initialized = 0;
-    if(!is_initialized)
-    {
-      for(int i = 0; i < ROCM_SPACE_ATOMIC_MASK+1; i++)
-        rocm_space_atomic_locks[i] = 0;
-      is_initialized = 1;
-    }
+void init_rocm_atomic_lock_array() {
+  static int is_initialized = 0;
+  if (!is_initialized) {
+    for (int i = 0; i < ROCM_SPACE_ATOMIC_MASK + 1; i++)
+      rocm_space_atomic_locks[i] = 0;
+    is_initialized = 1;
   }
+}
 
-  void init_rocm_scratch_lock_array() {
-    static int is_initialized = 0;
-    if(!is_initialized)
-    {
-      for(int i = 0; i < ROCM_CONCURRENCY; i++)
-        rocm_space_scratch_locks[i] = 0;
-      is_initialized = 1;
-    }
+void init_rocm_scratch_lock_array() {
+  static int is_initialized = 0;
+  if (!is_initialized) {
+    for (int i = 0; i < ROCM_CONCURRENCY; i++) rocm_space_scratch_locks[i] = 0;
+    is_initialized = 1;
   }
+}
 
-  void init_rocm_threadid_lock_array() {
-    static int is_initialized = 0;
-    if(!is_initialized)
-    {
-      for(int i = 0; i < ROCM_CONCURRENCY; i++)
-        rocm_space_threadid_locks[i] = 0;
-      is_initialized = 1;
-    }
+void init_rocm_threadid_lock_array() {
+  static int is_initialized = 0;
+  if (!is_initialized) {
+    for (int i = 0; i < ROCM_CONCURRENCY; i++) rocm_space_threadid_locks[i] = 0;
+    is_initialized = 1;
   }
+}
 
-  void init_lock_arrays_rocm_space() {
-     init_rocm_atomic_lock_array();
-//     init_rocm_scratch_lock_array();
-//     init_rocm_threadid_lock_array();
-  }
+void init_lock_arrays_rocm_space() {
+  init_rocm_atomic_lock_array();
+  //     init_rocm_scratch_lock_array();
+  //     init_rocm_threadid_lock_array();
 }
+}  // namespace Impl
 
-} // namespace Kokkos
+}  // namespace Kokkos
 #if 0
 namespace Kokkos {
 namespace Impl {
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.hpp
index 3e81883278dd39958b9b39ab537f254830ce4327..5f527a19b33fbf2d1853d80430e787815474d82d 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Exec.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -54,17 +55,17 @@ namespace Kokkos {
 namespace Impl {
 
 struct ROCmTraits {
-// TODO: determine if needed
-  enum { WavefrontSize       = 64  /* 64  */ };
-  enum { WorkgroupSize       = 256 /* 256  */ };
-  enum { WavefrontIndexMask  = 0x003f  /* Mask for wavefrontindex */ };
-  enum { WavefrontIndexShift = 6   /* WavefrontSize == 1 << WavefrontShift */ };
+  // TODO: determine if needed
+  enum { WavefrontSize = 64 /* 64  */ };
+  enum { WorkgroupSize = 256 /* 256  */ };
+  enum { WavefrontIndexMask = 0x003f /* Mask for wavefrontindex */ };
+  enum { WavefrontIndexShift = 6 /* WavefrontSize == 1 << WavefrontShift */ };
 
-  enum { SharedMemoryBanks    = 64      /* GCN */ };
+  enum { SharedMemoryBanks = 64 /* GCN */ };
   enum { SharedMemoryCapacity = 0x10000 /* 64k shared / 16k L1 Cache */ };
-  enum { SharedMemoryUsage    = 0x04000 /* 64k shared / 16k L1 Cache */ };
+  enum { SharedMemoryUsage = 0x04000 /* 64k shared / 16k L1 Cache */ };
 
-  enum { UpperBoundExtentCount    = 4294967295 /* Hard upper bound */ };
+  enum { UpperBoundExtentCount = 4294967295 /* Hard upper bound */ };
 #if 0
   KOKKOS_INLINE_FUNCTION static
   ROCmSpace::size_type wavefront_count( ROCmSpace::size_type i )
@@ -81,69 +82,68 @@ struct ROCmTraits {
 size_t rocm_internal_cu_count();
 size_t rocm_internal_maximum_workgroup_count();
 
-size_t * rocm_internal_scratch_flags( const size_t size );
-size_t * rocm_internal_scratch_space( const size_t size );
+size_t *rocm_internal_scratch_flags(const size_t size);
+size_t *rocm_internal_scratch_space(const size_t size);
 
 // This pointer is the start of dynamic shared memory (LDS).
 // Dynamic is at the end of LDS and it's size must be specified
 // in a tile_block specification at kernel launch time.
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-T * kokkos_impl_rocm_shared_memory()
+template <typename T>
+KOKKOS_INLINE_FUNCTION T *kokkos_impl_rocm_shared_memory()
 //{ return (T*) hc::get_group_segment_base_pointer() ; }
-{ return (T*) hc::get_dynamic_group_segment_base_pointer() ; }
-
-
+{
+  return (T *)hc::get_dynamic_group_segment_base_pointer();
 }
-} // namespace Kokkos
-#define ROCM_SPACE_ATOMIC_MASK      0x1FFFF
-#define ROCM_SPACE_ATOMIC_XOR_MASK  0x15A39
-//int rocm_space_atomic_locks[ROCM_SPACE_ATOMIC_MASK+1];
-extern int
-   *rocm_space_atomic_locks;
+
+}  // namespace Impl
+}  // namespace Kokkos
+#define ROCM_SPACE_ATOMIC_MASK 0x1FFFF
+#define ROCM_SPACE_ATOMIC_XOR_MASK 0x15A39
+// int rocm_space_atomic_locks[ROCM_SPACE_ATOMIC_MASK+1];
+extern int *rocm_space_atomic_locks;
 
 namespace Kokkos {
 namespace Impl {
-  void init_lock_arrays_rocm_space();
+void init_lock_arrays_rocm_space();
 
-  void* rocm_resize_scratch_space(size_t bytes, bool force_shrink = false);
+void *rocm_resize_scratch_space(size_t bytes, bool force_shrink = false);
 
 // TODO: determine if needed
 KOKKOS_INLINE_FUNCTION
-bool lock_address_rocm_space(void* ptr) {
+bool lock_address_rocm_space(void *ptr) {
 #if 0
 return(Kokkos::Impl::lock_address_host_space(ptr));
 #else
   size_t offset = size_t(ptr);
-  offset = offset >> 2;
-  offset = offset & ROCM_SPACE_ATOMIC_MASK;
-  return (0 == hc::atomic_compare_exchange(&rocm_space_atomic_locks[offset],0,1));
+  offset        = offset >> 2;
+  offset        = offset & ROCM_SPACE_ATOMIC_MASK;
+  return (0 ==
+          hc::atomic_compare_exchange(&rocm_space_atomic_locks[offset], 0, 1));
 #endif
 }
 KOKKOS_INLINE_FUNCTION
-void unlock_address_rocm_space(void* ptr) {
+void unlock_address_rocm_space(void *ptr) {
 #if 0
 Kokkos::Impl::unlock_address_host_space(ptr) ;
 #else
   size_t offset = size_t(ptr);
-  offset = offset >> 2;
-  offset = offset & ROCM_SPACE_ATOMIC_MASK;
-  hc::atomic_exchange( &rocm_space_atomic_locks[ offset ], 0);
+  offset        = offset >> 2;
+  offset        = offset & ROCM_SPACE_ATOMIC_MASK;
+  hc::atomic_exchange(&rocm_space_atomic_locks[offset], 0);
 #endif
 }
 
-}
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
-//extern 
-//KOKKOS_INLINE_FUNCTION
-//void init_lock_arrays_rocm_space(); 
-
+// extern
+// KOKKOS_INLINE_FUNCTION
+// void init_lock_arrays_rocm_space();
 
 }
-} // namespace Kokkos
+}  // namespace Kokkos
 //#if defined(__HCC_ACCELERATOR__)
 namespace Kokkos {
 namespace Impl {
@@ -184,92 +184,82 @@ static void rocm_parallel_launch_local_memory( const DriverType driver )
   driver();
 }
 */
-template < class DriverType
-         , class LaunchBounds = Kokkos::LaunchBounds<> >
-struct ROCmParallelLaunch ;
-
-template < class DriverType
-         , unsigned int MaxThreadsPerBlock
-         , unsigned int MinBlocksPerSM >
-struct ROCmParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds< MaxThreadsPerBlock
-                                               , MinBlocksPerSM >>
-{
-  inline
-  ROCmParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int      shmem )
-  {
-    if ( grid.x && ( block.x * block.y * block.z ) ) {
-      if ( ROCmTraits::SharedMemoryCapacity < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("ROCmParallelLaunch FAILED: shared memory request is too large") );
+template <class DriverType, class LaunchBounds = Kokkos::LaunchBounds<>>
+struct ROCmParallelLaunch;
+
+template <class DriverType, unsigned int MaxThreadsPerBlock,
+          unsigned int MinBlocksPerSM>
+struct ROCmParallelLaunch<
+    DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>> {
+  inline ROCmParallelLaunch(const DriverType &driver, const dim3 &grid,
+                            const dim3 &block, const int shmem) {
+    if (grid.x && (block.x * block.y * block.z)) {
+      if (ROCmTraits::SharedMemoryCapacity < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "ROCmParallelLaunch FAILED: shared memory request is too large"));
       }
-      DriverType * rocm_memory_buffer = (DriverType *)
-                                     rocm_device_allocate(sizeof(DriverType));
+      DriverType *rocm_memory_buffer =
+          (DriverType *)rocm_device_allocate(sizeof(DriverType));
       // Copy functor to constant memory on the device
-      Kokkos::Impl::DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace>
-              ( rocm_memory_buffer , (void *)&driver , sizeof(DriverType) );
+      Kokkos::Impl::DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace>(
+          rocm_memory_buffer, (void *)&driver, sizeof(DriverType));
 
-//      KOKKOS_ENSURE_ROCM_LOCK_ARRAYS_ON_DEVICE();
+      //      KOKKOS_ENSURE_ROCM_LOCK_ARRAYS_ON_DEVICE();
 
       // Invoke the driver function on the device
-      auto ext = hc::extent<3>(grid.z,grid.y,grid.x);
-      size_t bx = (grid.x > block.x)? block.x : grid.x;
-      size_t by = (grid.y > block.y)? block.y : grid.y;
-      size_t bz = (grid.z > block.z)? block.z : grid.z;
+      auto ext  = hc::extent<3>(grid.z, grid.y, grid.x);
+      size_t bx = (grid.x > block.x) ? block.x : grid.x;
+      size_t by = (grid.y > block.y) ? block.y : grid.y;
+      size_t bz = (grid.z > block.z) ? block.z : grid.z;
 
-      hc::parallel_for_each(ext.tile_with_dynamic(bz,by,bx,shmem), [=](const hc::index<3> & idx) [[hc]]
- 
-      { rocm_memory_buffer->operator()();
-      }).wait();
+      hc::parallel_for_each(
+          ext.tile_with_dynamic(bz, by, bx, shmem), [=](const hc::index<3> &idx)
+                                                        [[hc]]
+
+          { rocm_memory_buffer->operator()(); })
+          .wait();
       rocm_device_free(rocm_memory_buffer);
 
-//#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-//      ROCM_SAFE_CALL( rocmGetLastError() );
-//      Kokkos::ROCm().fence();
-//#endif
+      //#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
+      //      ROCM_SAFE_CALL( rocmGetLastError() );
+      //      Kokkos::ROCm().fence();
+      //#endif
     }
   }
 };
-template < class DriverType >
-struct ROCmParallelLaunch< DriverType
-                         , Kokkos::LaunchBounds<>>
-{
-  inline
-  ROCmParallelLaunch( const DriverType & driver
-                    , const dim3       & grid
-                    , const dim3       & block
-                    , const int          shmem )
-  {
-    if ( grid.x && ( block.x * block.y * block.z ) ) {
-      if ( ROCmTraits::SharedMemoryCapacity < shmem ) {
-        Kokkos::Impl::throw_runtime_exception( std::string("ROCmParallelLaunch FAILED: shared memory request is too large") );
+template <class DriverType>
+struct ROCmParallelLaunch<DriverType, Kokkos::LaunchBounds<>> {
+  inline ROCmParallelLaunch(const DriverType &driver, const dim3 &grid,
+                            const dim3 &block, const int shmem) {
+    if (grid.x && (block.x * block.y * block.z)) {
+      if (ROCmTraits::SharedMemoryCapacity < shmem) {
+        Kokkos::Impl::throw_runtime_exception(std::string(
+            "ROCmParallelLaunch FAILED: shared memory request is too large"));
       }
 
-      DriverType * rocm_memory_buffer = (DriverType *)
-                                     rocm_device_allocate(sizeof(DriverType));
+      DriverType *rocm_memory_buffer =
+          (DriverType *)rocm_device_allocate(sizeof(DriverType));
       // Copy functor to constant memory on the device
-      Kokkos::Impl::DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace>
-              ( rocm_memory_buffer , (void *)&driver , sizeof(DriverType) );
+      Kokkos::Impl::DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace>(
+          rocm_memory_buffer, (void *)&driver, sizeof(DriverType));
 
-//      KOKKOS_ENSURE_ROCM_LOCK_ARRAYS_ON_DEVICE();
+      //      KOKKOS_ENSURE_ROCM_LOCK_ARRAYS_ON_DEVICE();
       // Invoke the driver function on the device
-      auto ext = hc::extent<3>(grid.z,grid.y,grid.x);
-      size_t bx = (grid.x > block.x)? block.x : grid.x;
-      size_t by = (grid.y > block.y)? block.y : grid.y;
-      size_t bz = (grid.z > block.z)? block.z : grid.z;
-      hc::parallel_for_each(ext.tile_with_dynamic(bz,by,bx,shmem), [=](const hc::index<3> & idx) [[hc]]
- 
- 
-      { rocm_memory_buffer->operator()();
-      }).wait();
+      auto ext  = hc::extent<3>(grid.z, grid.y, grid.x);
+      size_t bx = (grid.x > block.x) ? block.x : grid.x;
+      size_t by = (grid.y > block.y) ? block.y : grid.y;
+      size_t bz = (grid.z > block.z) ? block.z : grid.z;
+      hc::parallel_for_each(
+          ext.tile_with_dynamic(bz, by, bx, shmem), [=](const hc::index<3> &idx)
+                                                        [[hc]]
+
+          { rocm_memory_buffer->operator()(); })
+          .wait();
       rocm_device_free(rocm_memory_buffer);
     }
   }
 };
-} // namespace Impl
-} // namespace Kokkos
-
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_ROCMEXEC_HPP */
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Impl.cpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Impl.cpp
index 236042ccc20ad62b85ea72fb64eb062067263999..aedde5b80a8238935224999edfd6457f28aefb02 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Impl.cpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Impl.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -64,12 +65,9 @@
 #include <sstream>
 #include <string>
 
-
-
-//KOKKOS_INLINE_FUNCTION
+// KOKKOS_INLINE_FUNCTION
 // Kokkos::Impl::ROCmLockArraysStruct kokkos_impl_rocm_lock_arrays ;
 
-
 /*--------------------------------------------------------------------------*/
 namespace Kokkos {
 namespace Impl {
@@ -79,7 +77,7 @@ namespace {
 __global__
 void query_rocm_kernel_arch( int * d_arch )
 {
-#if defined( __HCC_ACCELERATOR__ )
+#if defined(__HCC_ACCELERATOR__)
   *d_arch = OCM_ARCH__ ;
 #else
   *d_arch = 0 ;
@@ -110,41 +108,34 @@ bool rocm_launch_blocking()
 #endif
 
 // true device memory allocation, not visible from host
-void * rocm_device_allocate(int size)
-{
-  void * ptr;
+void* rocm_device_allocate(int size) {
+  void* ptr;
   hc::accelerator acc;
-  ptr = hc::am_alloc(size,acc,0);
+  ptr = hc::am_alloc(size, acc, 0);
   return ptr;
 }
 
 // host pinned allocation
 // flag = 1, non-coherent, host resident, but with gpu address space pointer
 // flag = 2, coherent, host resident, but with host address space pointer
-void * rocm_hostpinned_allocate(int size)
-{
-  void * ptr;
+void* rocm_hostpinned_allocate(int size) {
+  void* ptr;
   hc::accelerator acc;
-  ptr = hc::am_alloc(size,acc,2);
+  ptr = hc::am_alloc(size, acc, 2);
   return ptr;
 }
 // same free used by all rocm memory allocations
-void rocm_device_free(void * ptr)
-{
-  hc::am_free(ptr);
-}
-
+void rocm_device_free(void* ptr) { hc::am_free(ptr); }
 
 KOKKOS_INLINE_FUNCTION
-void rocm_device_synchronize()
-{
-   hc::accelerator_view av = hc::accelerator().get_default_view();
-   hc::completion_future fut = av.create_marker();
-   fut.wait();
+void rocm_device_synchronize() {
+  hc::accelerator_view av   = hc::accelerator().get_default_view();
+  hc::completion_future fut = av.create_marker();
+  fut.wait();
 }
 
-void rocm_internal_error_throw( const char * name, const char * file, const int line )
-{
+void rocm_internal_error_throw(const char* name, const char* file,
+                               const int line) {
 #if 0
   std::ostringstream out ;
   out << name << " error( " << rocmGetErrorName(e) << "): " << rocmGetErrorString(e);
@@ -182,310 +173,299 @@ void rocm_internal_error_throw( const char * name, const char * file, const int
 // bool get_supports_cpu_shared_memory()
 // size_t get_max_tile_static_size()
 // unsigned int get_cu_count()
-// bool has_cpu_accessible_am() 
+// bool has_cpu_accessible_am()
 struct rocmDeviceProp {
-   char name[256];
-   char description[256];
-   unsigned int version;
-   int device_type;
-   int device_ordinal;
-   int major;
-   int minor;
-   size_t totalGlobalMem;
-   size_t sharedMemPerWavefront;
-   int WavefrontSize;
-   int WorkgroupSize;
-   int MaxTileCount;
-   int maxThreadsPerWorkgroup;
-   int multiProcessorCount;
-   int canMapHostMemory;
-   bool APU;
+  char name[256];
+  char description[256];
+  unsigned int version;
+  int device_type;
+  int device_ordinal;
+  int major;
+  int minor;
+  size_t totalGlobalMem;
+  size_t sharedMemPerWavefront;
+  int WavefrontSize;
+  int WorkgroupSize;
+  int MaxTileCount;
+  int maxThreadsPerWorkgroup;
+  int multiProcessorCount;
+  int canMapHostMemory;
+  bool APU;
 };
 
+void rocmGetDeviceProperties(struct rocmDeviceProp* devProp, int device) {
+  std::wstring s;
+  int i, n;
+  hc::accelerator acc;
+  std::vector<hc::accelerator> accv = acc.get_all();
+
+  hc::accelerator a = accv[device];
+
+  s = a.get_device_path();
+  i = 0;
+  for (wchar_t c : s)
+    if ((n = std::wctomb(&devProp->name[i], c)) > 0) i += n;
+
+  /* assume a CPU */
+  devProp->version = a.get_version();
+  devProp->major   = a.get_version() >> 16;  // for CPU, these are meaningless
+  devProp->minor   = a.get_version() & 0xff;
+  devProp->device_ordinal = 0;
+
+  /* is this an AMD graphics card */
+  if ((devProp->name[0] == 'g') && (devProp->name[1] == 'f') &&
+      (devProp->name[2] == 'x')) {
+    /* for AMD cards, the name has the format gfxMmmO */
+
+    devProp->device_type = ((devProp->name[3] - 0x30) << 16) +
+                           ((devProp->name[4] - 0x30) << 8) +
+                           (devProp->name[5] - 0x30);
+    devProp->device_ordinal = devProp->name[6] - 0x30;
+    devProp->major          = devProp->name[3] - 0x30;
+    devProp->minor          = devProp->name[5] - 0x30;
+  }
 
-
-void rocmGetDeviceProperties(struct rocmDeviceProp* devProp, int device)
-{
-   std::wstring s;
-   int i,n;
-   hc::accelerator acc;
-   std::vector<hc::accelerator> accv = acc.get_all() ;
-
-   hc::accelerator a = accv[device];
-
-   s=a.get_device_path();
-   i = 0;
-   for(wchar_t c: s)
-      if((n=std::wctomb(&devProp->name[i],c))>0)
-         i+=n;
-
-   /* assume a CPU */
-   devProp->version = a.get_version();
-   devProp->major = a.get_version()>>16; // for CPU, these are meaningless 
-   devProp->minor = a.get_version()&0xff;
-   devProp->device_ordinal = 0;
-
-   /* is this an AMD graphics card */
-   if((devProp->name[0]=='g') && (devProp->name[1]=='f') 
-                              && (devProp->name[2]=='x')) {
-   /* for AMD cards, the name has the format gfxMmmO */
-     
-      devProp->device_type    = ((devProp->name[3]-0x30)<<16)
-                              + ((devProp->name[4]-0x30)<<8)
-                              +  (devProp->name[5]-0x30);
-      devProp->device_ordinal = devProp->name[6]-0x30;
-      devProp->major = devProp->name[3]-0x30;
-      devProp->minor = devProp->name[5]-0x30;
-   }
-
-   s=a.get_description();
-   i = 0;
-   for(wchar_t c: s)
-      if((n=std::wctomb(&devProp->description[i],c))>0)
-         i+=n;
-   devProp->totalGlobalMem = a.get_dedicated_memory();
-   devProp->sharedMemPerWavefront = a.get_max_tile_static_size();
-   devProp->WavefrontSize = 64;
-   devProp->WorkgroupSize = 256; // preferred
-   devProp->MaxTileCount  = 409600; // as defined in /opt/rocm/hcc-lc/include/hsa_new.h
-   devProp->maxThreadsPerWorkgroup = 1024;
-   devProp->multiProcessorCount = a.get_cu_count();
-   devProp->canMapHostMemory = a.get_supports_cpu_shared_memory();
-// Kaveri has 64KB L2 per CU, 16KB L1, 64KB Vector Regs/SIMD, or 128 regs/thread
-// GCN has 64KB LDS per CU
-
-//Kaveri APU is 7:0:0
-//Carrizo APU is 8:0:1
-   devProp->APU = (((devProp->major==7)&&(devProp->minor==0))|
-                   ((devProp->major==8)&&(devProp->minor==1)))?true:false;
+  s = a.get_description();
+  i = 0;
+  for (wchar_t c : s)
+    if ((n = std::wctomb(&devProp->description[i], c)) > 0) i += n;
+  devProp->totalGlobalMem        = a.get_dedicated_memory();
+  devProp->sharedMemPerWavefront = a.get_max_tile_static_size();
+  devProp->WavefrontSize         = 64;
+  devProp->WorkgroupSize         = 256;  // preferred
+  devProp->MaxTileCount =
+      409600;  // as defined in /opt/rocm/hcc-lc/include/hsa_new.h
+  devProp->maxThreadsPerWorkgroup = 1024;
+  devProp->multiProcessorCount    = a.get_cu_count();
+  devProp->canMapHostMemory       = a.get_supports_cpu_shared_memory();
+  // Kaveri has 64KB L2 per CU, 16KB L1, 64KB Vector Regs/SIMD, or 128
+  // regs/thread GCN has 64KB LDS per CU
+
+  // Kaveri APU is 7:0:0
+  // Carrizo APU is 8:0:1
+  devProp->APU = (((devProp->major == 7) && (devProp->minor == 0)) |
+                  ((devProp->major == 8) && (devProp->minor == 1)))
+                     ? true
+                     : false;
 }
 
 namespace {
 
-
-
 class ROCmInternalDevices {
-public:
+ public:
   enum { MAXIMUM_DEVICE_COUNT = 64 };
-  struct rocmDeviceProp  m_rocmProp[ MAXIMUM_DEVICE_COUNT ] ;
-  int                    m_rocmDevCount ;
+  struct rocmDeviceProp m_rocmProp[MAXIMUM_DEVICE_COUNT];
+  int m_rocmDevCount;
 
   ROCmInternalDevices();
 
-  static const ROCmInternalDevices & singleton();
+  static const ROCmInternalDevices& singleton();
 };
 
-ROCmInternalDevices::ROCmInternalDevices()
-{
-   hc::accelerator acc;
-   std::vector<hc::accelerator> accv = acc.get_all() ;
-   m_rocmDevCount = accv.size();
+ROCmInternalDevices::ROCmInternalDevices() {
+  hc::accelerator acc;
+  std::vector<hc::accelerator> accv = acc.get_all();
+  m_rocmDevCount                    = accv.size();
 
-  if(m_rocmDevCount > MAXIMUM_DEVICE_COUNT) {
-    Kokkos::abort("Sorry, you have more GPUs per node than we thought anybody would ever have. Please report this to github.com/kokkos/kokkos.");
+  if (m_rocmDevCount > MAXIMUM_DEVICE_COUNT) {
+    Kokkos::abort(
+        "Sorry, you have more GPUs per node than we thought anybody would ever "
+        "have. Please report this to github.com/kokkos/kokkos.");
   }
-  for ( int i = 0 ; i < m_rocmDevCount ; ++i ) {
-    rocmGetDeviceProperties( m_rocmProp + i , i );
+  for (int i = 0; i < m_rocmDevCount; ++i) {
+    rocmGetDeviceProperties(m_rocmProp + i, i);
   }
 }
 
-const ROCmInternalDevices & ROCmInternalDevices::singleton()
-{
+const ROCmInternalDevices& ROCmInternalDevices::singleton() {
   static ROCmInternalDevices* self = nullptr;
   if (!self) {
     self = new ROCmInternalDevices();
   }
   return *self;
-
 }
 
-}
+}  // namespace
 
 //----------------------------------------------------------------------------
 
 class ROCmInternal {
-private:
-
-  ROCmInternal( const ROCmInternal & );
-  ROCmInternal & operator = ( const ROCmInternal & );
-
-
-public:
-
-  typedef Kokkos::Experimental::ROCm::size_type size_type ;
-
-  int         m_rocmDev ;
-  int         m_rocmArch ;
-  unsigned    m_multiProcCount ;
-  unsigned    m_maxWorkgroup ;
-  unsigned    m_maxSharedWords ;
-  size_type   m_scratchSpaceCount ;
-  size_type   m_scratchFlagsCount ;
-  size_type * m_scratchSpace ;
-  size_type * m_scratchFlags ;
+ private:
+  ROCmInternal(const ROCmInternal&);
+  ROCmInternal& operator=(const ROCmInternal&);
+
+ public:
+  typedef Kokkos::Experimental::ROCm::size_type size_type;
+
+  int m_rocmDev;
+  int m_rocmArch;
+  unsigned m_multiProcCount;
+  unsigned m_maxWorkgroup;
+  unsigned m_maxSharedWords;
+  size_type m_scratchSpaceCount;
+  size_type m_scratchFlagsCount;
+  size_type* m_scratchSpace;
+  size_type* m_scratchFlags;
 
   static int was_finalized;
 
-  static ROCmInternal & singleton();
+  static ROCmInternal& singleton();
 
-  int verify_is_initialized( const char * const label ) const ;
+  int verify_is_initialized(const char* const label) const;
 
-  int is_initialized() const
-    { return 0 != m_scratchSpace && 0 != m_scratchFlags ; }
+  int is_initialized() const {
+    return 0 != m_scratchSpace && 0 != m_scratchFlags;
+  }
 
-  void initialize( int rocm_device_id );
+  void initialize(int rocm_device_id);
   void finalize();
 
-  void print_configuration( std::ostream & ) const ;
-
+  void print_configuration(std::ostream&) const;
 
   ~ROCmInternal();
 
   ROCmInternal()
-    : m_rocmDev( -1 )
-    , m_rocmArch( -1 )
-    , m_multiProcCount( 0 )
-    , m_maxWorkgroup( 0 )
-    , m_maxSharedWords( 0 )
-    , m_scratchSpaceCount( 0 )
-    , m_scratchFlagsCount( 0 )
-    , m_scratchSpace( 0 )
-    , m_scratchFlags( 0 )
-    {}
-
-  size_type * scratch_space( const size_type size );
-  size_type * scratch_flags( const size_type size );
+      : m_rocmDev(-1),
+        m_rocmArch(-1),
+        m_multiProcCount(0),
+        m_maxWorkgroup(0),
+        m_maxSharedWords(0),
+        m_scratchSpaceCount(0),
+        m_scratchFlagsCount(0),
+        m_scratchSpace(0),
+        m_scratchFlags(0) {}
+
+  size_type* scratch_space(const size_type size);
+  size_type* scratch_flags(const size_type size);
 };
 
 int ROCmInternal::was_finalized = 0;
 //----------------------------------------------------------------------------
 
+void ROCmInternal::print_configuration(std::ostream& s) const {
+  const ROCmInternalDevices& dev_info = ROCmInternalDevices::singleton();
 
-void ROCmInternal::print_configuration( std::ostream & s ) const
-{
-  const ROCmInternalDevices & dev_info = ROCmInternalDevices::singleton();
-
-#if defined( KOKKOS_ENABLE_ROCM )
-    s << "macro  KOKKOS_ENABLE_ROCM      : defined" << std::endl ;
+#if defined(KOKKOS_ENABLE_ROCM)
+  s << "macro  KOKKOS_ENABLE_ROCM      : defined" << std::endl;
 #endif
-#if defined( __hcc_version__ )
-    s << "macro  __hcc_version__          = " << __hcc_version__
-      << std::endl ;
+#if defined(__hcc_version__)
+  s << "macro  __hcc_version__          = " << __hcc_version__ << std::endl;
 #endif
 
-  for ( int i = 0 ; i < dev_info.m_rocmDevCount ; ++i ) {
+  for (int i = 0; i < dev_info.m_rocmDevCount; ++i) {
     s << "Kokkos::Experimental::ROCm[ " << i << " ] "
-      << dev_info.m_rocmProp[i].name
-      << " version " << (dev_info.m_rocmProp[i].major) << "." << dev_info.m_rocmProp[i].minor
-      << ", Total Global Memory: " << human_memory_size(dev_info.m_rocmProp[i].totalGlobalMem)
-      << ", Shared Memory per Wavefront: " << human_memory_size(dev_info.m_rocmProp[i].sharedMemPerWavefront);
-    if ( m_rocmDev == i ) s << " : Selected" ;
-    s << std::endl ;
+      << dev_info.m_rocmProp[i].name << " version "
+      << (dev_info.m_rocmProp[i].major) << "." << dev_info.m_rocmProp[i].minor
+      << ", Total Global Memory: "
+      << human_memory_size(dev_info.m_rocmProp[i].totalGlobalMem)
+      << ", Shared Memory per Wavefront: "
+      << human_memory_size(dev_info.m_rocmProp[i].sharedMemPerWavefront);
+    if (m_rocmDev == i) s << " : Selected";
+    s << std::endl;
   }
 }
 
 //----------------------------------------------------------------------------
 
-ROCmInternal::~ROCmInternal()
-{
-  if ( m_scratchSpace ||
-       m_scratchFlags ) {
-    std::cerr << "Kokkos::Experimental::ROCm ERROR: Failed to call Kokkos::Experimental::ROCm::finalize()"
-              << std::endl ;
+ROCmInternal::~ROCmInternal() {
+  if (m_scratchSpace || m_scratchFlags) {
+    std::cerr << "Kokkos::Experimental::ROCm ERROR: Failed to call "
+                 "Kokkos::Experimental::ROCm::finalize()"
+              << std::endl;
     std::cerr.flush();
   }
 
-  m_rocmDev                 = -1 ;
-  m_rocmArch                = -1 ;
-  m_multiProcCount          = 0 ;
-  m_maxWorkgroup            = 0 ;
-  m_maxSharedWords          = 0 ;
-  m_scratchSpaceCount       = 0 ;
-  m_scratchFlagsCount       = 0 ;
-  m_scratchSpace            = 0 ;
-  m_scratchFlags            = 0 ;
+  m_rocmDev           = -1;
+  m_rocmArch          = -1;
+  m_multiProcCount    = 0;
+  m_maxWorkgroup      = 0;
+  m_maxSharedWords    = 0;
+  m_scratchSpaceCount = 0;
+  m_scratchFlagsCount = 0;
+  m_scratchSpace      = 0;
+  m_scratchFlags      = 0;
 }
 
-int ROCmInternal::verify_is_initialized( const char * const label ) const
-{
-  if ( m_rocmDev < 0 ) {
-    std::cerr << "Kokkos::Experimental::ROCm::" << label << " : ERROR device not initialized" << std::endl ;
+int ROCmInternal::verify_is_initialized(const char* const label) const {
+  if (m_rocmDev < 0) {
+    std::cerr << "Kokkos::Experimental::ROCm::" << label
+              << " : ERROR device not initialized" << std::endl;
   }
-  return 0 <= m_rocmDev ;
+  return 0 <= m_rocmDev;
 }
 
-ROCmInternal & ROCmInternal::singleton()
-{
-  static ROCmInternal* self = nullptr ;
+ROCmInternal& ROCmInternal::singleton() {
+  static ROCmInternal* self = nullptr;
   if (!self) {
     self = new ROCmInternal();
   }
-  return *self ;
-
+  return *self;
 }
 
-void ROCmInternal::initialize( int rocm_device_id  )
-{
-  if ( was_finalized ) Kokkos::abort("Calling ROCm::initialize after ROCm::finalize is illegal\n");
+void ROCmInternal::initialize(int rocm_device_id) {
+  if (was_finalized)
+    Kokkos::abort("Calling ROCm::initialize after ROCm::finalize is illegal\n");
 
-  if ( is_initialized() ) return;
+  if (is_initialized()) return;
 
   enum { WordSize = sizeof(size_type) };
 
-  if ( ! HostSpace::execution_space::is_initialized() ) {
-    const std::string msg("ROCm::initialize ERROR : HostSpace::execution_space is not initialized");
-    throw_runtime_exception( msg );
+  if (!HostSpace::execution_space::is_initialized()) {
+    const std::string msg(
+        "ROCm::initialize ERROR : HostSpace::execution_space is not "
+        "initialized");
+    throw_runtime_exception(msg);
   }
 
-  const ROCmInternalDevices & dev_info = ROCmInternalDevices::singleton();
+  const ROCmInternalDevices& dev_info = ROCmInternalDevices::singleton();
 
-  const bool ok_init = 0 == m_scratchSpace || 0 == m_scratchFlags ;
+  const bool ok_init = 0 == m_scratchSpace || 0 == m_scratchFlags;
 
-  const bool ok_id   = 1 <= rocm_device_id &&
-                            rocm_device_id < dev_info.m_rocmDevCount ;
+  const bool ok_id =
+      1 <= rocm_device_id && rocm_device_id < dev_info.m_rocmDevCount;
 
   // Need at least a GPU device
 
-  const bool ok_dev = ok_id &&
-    ( 1 <= dev_info.m_rocmProp[ rocm_device_id ].major &&
-      0 <= dev_info.m_rocmProp[ rocm_device_id ].minor );
-  if ( ok_init && ok_dev ) {
-
-    const struct rocmDeviceProp & rocmProp =
-      dev_info.m_rocmProp[ rocm_device_id ];
+  const bool ok_dev =
+      ok_id && (1 <= dev_info.m_rocmProp[rocm_device_id].major &&
+                0 <= dev_info.m_rocmProp[rocm_device_id].minor);
+  if (ok_init && ok_dev) {
+    const struct rocmDeviceProp& rocmProp = dev_info.m_rocmProp[rocm_device_id];
 
-    m_rocmDev = rocm_device_id ;
+    m_rocmDev = rocm_device_id;
 
-//  rocmSetDevice( m_rocmDev ) );
+    //  rocmSetDevice( m_rocmDev ) );
     Kokkos::Impl::rocm_device_synchronize();
 
-/*
-    // Query what compute capability architecture a kernel executes:
-    m_rocmArch = rocm_kernel_arch();
-    if ( m_rocmArch != rocmProp.major * 100 + rocmProp.minor * 10 ) {
-      std::cerr << "Kokkos::Experimental::ROCm::initialize WARNING: running kernels compiled for compute capability "
-                << ( m_rocmArch / 100 ) << "." << ( ( m_rocmArch % 100 ) / 10 )
-                << " on device with compute capability "
-                << rocmProp.major << "." << rocmProp.minor
-                << " , this will likely reduce potential performance."
-                << std::endl ;
-    }
-*/
+    /*
+        // Query what compute capability architecture a kernel executes:
+        m_rocmArch = rocm_kernel_arch();
+        if ( m_rocmArch != rocmProp.major * 100 + rocmProp.minor * 10 ) {
+          std::cerr << "Kokkos::Experimental::ROCm::initialize WARNING: running
+       kernels compiled for compute capability "
+                    << ( m_rocmArch / 100 ) << "." << ( ( m_rocmArch % 100 ) /
+       10 )
+                    << " on device with compute capability "
+                    << rocmProp.major << "." << rocmProp.minor
+                    << " , this will likely reduce potential performance."
+                    << std::endl ;
+        }
+    */
     // number of multiprocessors
 
-    m_multiProcCount = rocmProp.multiProcessorCount ;
+    m_multiProcCount = rocmProp.multiProcessorCount;
 
     //----------------------------------
     // Maximum number of wavefronts,
     // at most one workgroup per thread in a workgroup for reduction.
 
-
-    m_maxSharedWords = rocmProp.sharedMemPerWavefront/ WordSize ;
+    m_maxSharedWords = rocmProp.sharedMemPerWavefront / WordSize;
 
     //----------------------------------
     // Maximum number of Workgroups:
 
-    m_maxWorkgroup = 5*rocmProp.multiProcessorCount;  //TODO: confirm usage and value
+    m_maxWorkgroup =
+        5 * rocmProp.multiProcessorCount;  // TODO: confirm usage and value
 
     //----------------------------------
     // Multiblock reduction uses scratch flags for counters
@@ -493,186 +473,195 @@ void ROCmInternal::initialize( int rocm_device_id  )
     // Allocate some initial space.  This will grow as needed.
 
     {
-      const unsigned reduce_block_count = m_maxWorkgroup * Impl::ROCmTraits::WorkgroupSize ;
+      const unsigned reduce_block_count =
+          m_maxWorkgroup * Impl::ROCmTraits::WorkgroupSize;
 
-      (void) scratch_flags( reduce_block_count * 2  * sizeof(size_type) );
-      (void) scratch_space( reduce_block_count * 16 * sizeof(size_type) );
+      (void)scratch_flags(reduce_block_count * 2 * sizeof(size_type));
+      (void)scratch_space(reduce_block_count * 16 * sizeof(size_type));
     }
     //----------------------------------
 
-  }
-  else {
+  } else {
+    std::ostringstream msg;
+    msg << "Kokkos::Experimental::ROCm::initialize(" << rocm_device_id
+        << ") FAILED";
 
-    std::ostringstream msg ;
-    msg << "Kokkos::Experimental::ROCm::initialize(" << rocm_device_id << ") FAILED" ;
-
-    if ( ! ok_init ) {
-      msg << " : Already initialized" ;
+    if (!ok_init) {
+      msg << " : Already initialized";
     }
-    if ( ! ok_id ) {
+    if (!ok_id) {
       msg << " : Device identifier out of range "
-          << "[0.." << (dev_info.m_rocmDevCount-1) << "]" ;
-    }
-    else if ( ! ok_dev ) {
-      msg << " : Device " ;
-      msg << dev_info.m_rocmProp[ rocm_device_id ].major ;
-      msg << "." ;
-      msg << dev_info.m_rocmProp[ rocm_device_id ].minor ;
-      msg << " Need at least a GPU" ;
+          << "[0.." << (dev_info.m_rocmDevCount - 1) << "]";
+    } else if (!ok_dev) {
+      msg << " : Device ";
+      msg << dev_info.m_rocmProp[rocm_device_id].major;
+      msg << ".";
+      msg << dev_info.m_rocmProp[rocm_device_id].minor;
+      msg << " Need at least a GPU";
       msg << std::endl;
     }
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
-
   // Init the array for used for arbitrarily sized atomics
   Kokkos::Impl::init_lock_arrays_rocm_space();
 
-//  Kokkos::Impl::ROCmLockArraysStruct locks;
-//  locks.atomic = atomic_lock_array_rocm_space_ptr(false);
-//  locks.scratch = scratch_lock_array_rocm_space_ptr(false);
-//  locks.threadid = threadid_lock_array_rocm_space_ptr(false);
-//  rocmMemcpyToSymbol( kokkos_impl_rocm_lock_arrays , & locks , sizeof(ROCmLockArraysStruct) );
+  //  Kokkos::Impl::ROCmLockArraysStruct locks;
+  //  locks.atomic = atomic_lock_array_rocm_space_ptr(false);
+  //  locks.scratch = scratch_lock_array_rocm_space_ptr(false);
+  //  locks.threadid = threadid_lock_array_rocm_space_ptr(false);
+  //  rocmMemcpyToSymbol( kokkos_impl_rocm_lock_arrays , & locks ,
+  //  sizeof(ROCmLockArraysStruct) );
 }
 
 //----------------------------------------------------------------------------
 
-typedef Kokkos::Experimental::ROCm::size_type ScratchGrain[ Impl::ROCmTraits::WorkgroupSize ] ;
+typedef Kokkos::Experimental::ROCm::size_type
+    ScratchGrain[Impl::ROCmTraits::WorkgroupSize];
 enum { sizeScratchGrain = sizeof(ScratchGrain) };
 
-void rocmMemset(  Kokkos::Experimental::ROCm::size_type * ptr ,  Kokkos::Experimental::ROCm::size_type value , Kokkos::Experimental::ROCm::size_type size)
-{
-char * mptr = (char * ) ptr;
-/*   parallel_for_each(hc::extent<1>(size),
-                    [=, &ptr]
-                    (hc::index<1> idx) __HC__
-   {
-      int i = idx[0];
-      ptr[i] = value;
-   }).wait();*/
-}
-
-Kokkos::Experimental::ROCm::size_type *
-ROCmInternal::scratch_flags( const Kokkos::Experimental::ROCm::size_type size )
-{
-  if ( verify_is_initialized("scratch_flags") && m_scratchFlagsCount * sizeScratchGrain < size ) {
-
+void rocmMemset(Kokkos::Experimental::ROCm::size_type* ptr,
+                Kokkos::Experimental::ROCm::size_type value,
+                Kokkos::Experimental::ROCm::size_type size) {
+  char* mptr = (char*)ptr;
+  /*   parallel_for_each(hc::extent<1>(size),
+                      [=, &ptr]
+                      (hc::index<1> idx) __HC__
+     {
+        int i = idx[0];
+        ptr[i] = value;
+     }).wait();*/
+}
 
-    m_scratchFlagsCount = ( size + sizeScratchGrain - 1 ) / sizeScratchGrain ;
+Kokkos::Experimental::ROCm::size_type* ROCmInternal::scratch_flags(
+    const Kokkos::Experimental::ROCm::size_type size) {
+  if (verify_is_initialized("scratch_flags") &&
+      m_scratchFlagsCount * sizeScratchGrain < size) {
+    m_scratchFlagsCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
 
-    typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void > Record ;
+    typedef Kokkos::Impl::SharedAllocationRecord<
+        Kokkos::Experimental::ROCmSpace, void>
+        Record;
 
-    Record * const r = Record::allocate( Kokkos::Experimental::ROCmSpace()
-                                       , "InternalScratchFlags"
-                                       , ( sizeScratchGrain  * m_scratchFlagsCount ) );
+    Record* const r = Record::allocate(
+        Kokkos::Experimental::ROCmSpace(), "InternalScratchFlags",
+        (sizeScratchGrain * m_scratchFlagsCount));
 
-    Record::increment( r );
+    Record::increment(r);
 
-    m_scratchFlags = reinterpret_cast<size_type *>( r->data() );
+    m_scratchFlags = reinterpret_cast<size_type*>(r->data());
 
-    rocmMemset( m_scratchFlags , 0 , m_scratchFlagsCount * sizeScratchGrain );
+    rocmMemset(m_scratchFlags, 0, m_scratchFlagsCount * sizeScratchGrain);
   }
 
-  return m_scratchFlags ;
+  return m_scratchFlags;
 }
 
-Kokkos::Experimental::ROCm::size_type *
-ROCmInternal::scratch_space( const Kokkos::Experimental::ROCm::size_type size )
-{
-  if ( verify_is_initialized("scratch_space") && m_scratchSpaceCount * sizeScratchGrain < size ) {
-
-    m_scratchSpaceCount = ( size + sizeScratchGrain - 1 ) / sizeScratchGrain ;
+Kokkos::Experimental::ROCm::size_type* ROCmInternal::scratch_space(
+    const Kokkos::Experimental::ROCm::size_type size) {
+  if (verify_is_initialized("scratch_space") &&
+      m_scratchSpaceCount * sizeScratchGrain < size) {
+    m_scratchSpaceCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
 
-     typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void > Record ;
+    typedef Kokkos::Impl::SharedAllocationRecord<
+        Kokkos::Experimental::ROCmSpace, void>
+        Record;
 
-     static Record * const r = Record::allocate( Kokkos::Experimental::ROCmSpace()
-                                        , "InternalScratchSpace"
-                                        , ( sizeScratchGrain  * m_scratchSpaceCount ) );
+    static Record* const r = Record::allocate(
+        Kokkos::Experimental::ROCmSpace(), "InternalScratchSpace",
+        (sizeScratchGrain * m_scratchSpaceCount));
 
-     Record::increment( r );
+    Record::increment(r);
 
-     m_scratchSpace = reinterpret_cast<size_type *>( r->data() );
+    m_scratchSpace = reinterpret_cast<size_type*>(r->data());
   }
 
-  return m_scratchSpace ;
+  return m_scratchSpace;
 }
 
 //----------------------------------------------------------------------------
 
-void ROCmInternal::finalize()
-{
+void ROCmInternal::finalize() {
   Kokkos::Impl::rocm_device_synchronize();
   was_finalized = 1;
-  if ( 0 != m_scratchSpace || 0 != m_scratchFlags ) {
-
-//    atomic_lock_array_rocm_space_ptr(false);
-//    scratch_lock_array_rocm_space_ptr(false);
-//    threadid_lock_array_rocm_space_ptr(false);
-
-    typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::ROCmSpace > RecordROCm ;
-    typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace > RecordHost ;
-
-    RecordROCm::decrement( RecordROCm::get_record( m_scratchFlags ) );
-    RecordROCm::decrement( RecordROCm::get_record( m_scratchSpace ) );
-
-    m_rocmDev             = -1 ;
-    m_multiProcCount      = 0 ;
-    m_maxWorkgroup        = 0 ;
-    m_maxSharedWords      = 0 ;
-    m_scratchSpaceCount   = 0 ;
-    m_scratchFlagsCount   = 0 ;
-    m_scratchSpace        = 0 ;
-    m_scratchFlags        = 0 ;
+  if (0 != m_scratchSpace || 0 != m_scratchFlags) {
+    //    atomic_lock_array_rocm_space_ptr(false);
+    //    scratch_lock_array_rocm_space_ptr(false);
+    //    threadid_lock_array_rocm_space_ptr(false);
+
+    typedef Kokkos::Impl::SharedAllocationRecord<
+        Kokkos::Experimental::ROCmSpace>
+        RecordROCm;
+    typedef Kokkos::Impl::SharedAllocationRecord<
+        Kokkos::Experimental::ROCmHostPinnedSpace>
+        RecordHost;
+
+    RecordROCm::decrement(RecordROCm::get_record(m_scratchFlags));
+    RecordROCm::decrement(RecordROCm::get_record(m_scratchSpace));
+
+    m_rocmDev           = -1;
+    m_multiProcCount    = 0;
+    m_maxWorkgroup      = 0;
+    m_maxSharedWords    = 0;
+    m_scratchSpaceCount = 0;
+    m_scratchFlagsCount = 0;
+    m_scratchSpace      = 0;
+    m_scratchFlags      = 0;
   }
 }
 
 //----------------------------------------------------------------------------
 
-Kokkos::Experimental::ROCm::size_type rocm_internal_cu_count()
-{ return ROCmInternal::singleton().m_multiProcCount ; }
-
-Kokkos::Experimental::ROCm::size_type rocm_internal_maximum_extent_size()
-{ return ROCmInternal::singleton().m_maxWorkgroup ; }
-
-Kokkos::Experimental::ROCm::size_type rocm_internal_maximum_shared_words()
-{ return ROCmInternal::singleton().m_maxSharedWords ; }
+Kokkos::Experimental::ROCm::size_type rocm_internal_cu_count() {
+  return ROCmInternal::singleton().m_multiProcCount;
+}
 
-Kokkos::Experimental::ROCm::size_type * rocm_internal_scratch_space( const Kokkos::Experimental::ROCm::size_type size )
-{ return ROCmInternal::singleton().scratch_space( size ); }
+Kokkos::Experimental::ROCm::size_type rocm_internal_maximum_extent_size() {
+  return ROCmInternal::singleton().m_maxWorkgroup;
+}
 
-Kokkos::Experimental::ROCm::size_type * rocm_internal_scratch_flags( const Kokkos::Experimental::ROCm::size_type size )
-{ return ROCmInternal::singleton().scratch_flags( size ); }
+Kokkos::Experimental::ROCm::size_type rocm_internal_maximum_shared_words() {
+  return ROCmInternal::singleton().m_maxSharedWords;
+}
 
+Kokkos::Experimental::ROCm::size_type* rocm_internal_scratch_space(
+    const Kokkos::Experimental::ROCm::size_type size) {
+  return ROCmInternal::singleton().scratch_space(size);
+}
 
+Kokkos::Experimental::ROCm::size_type* rocm_internal_scratch_flags(
+    const Kokkos::Experimental::ROCm::size_type size) {
+  return ROCmInternal::singleton().scratch_flags(size);
+}
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Experimental {
 
-//ROCm::size_type ROCm::detect_device_count()
+// ROCm::size_type ROCm::detect_device_count()
 //{ return Impl::ROCmInternalDevices::singleton().m_rocmDevCount ; }
 
 int ROCm::concurrency() {
-#if defined(KOKKOS_ARCH_KAVERI) 
-  return 8*64*40;  // 20480 kaveri
+#if defined(KOKKOS_ARCH_KAVERI)
+  return 8 * 64 * 40;  // 20480 kaveri
 #else
-  return 32*8*40;  // 81920 fiji and hawaii
+  return 32 * 8 * 40;  // 81920 fiji and hawaii
 #endif
 }
-int ROCm::is_initialized()
-{ return Kokkos::Impl::ROCmInternal::singleton().is_initialized(); }
+int ROCm::is_initialized() {
+  return Kokkos::Impl::ROCmInternal::singleton().is_initialized();
+}
 
-void ROCm::initialize( const ROCm::SelectDevice config )
-{
-  Kokkos::Impl::ROCmInternal::singleton().initialize( config.rocm_device_id );
+void ROCm::initialize(const ROCm::SelectDevice config) {
+  Kokkos::Impl::ROCmInternal::singleton().initialize(config.rocm_device_id);
 
-  #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::initialize();
-  #endif
+#if defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::initialize();
+#endif
 }
 
 #if 0
@@ -696,52 +685,45 @@ ROCm::size_type ROCm::device_arch()
 }
 #endif
 
-void ROCm::finalize()
-{
+void ROCm::finalize() {
   Kokkos::Impl::ROCmInternal::singleton().finalize();
 
-  #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::finalize();
-  #endif
+#if defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::finalize();
+#endif
 }
 
-ROCm::ROCm()
-  : m_device( Kokkos::Impl::ROCmInternal::singleton().m_rocmDev )
-{
-  Kokkos::Impl::ROCmInternal::singleton().verify_is_initialized( "ROCm instance constructor" );
+ROCm::ROCm() : m_device(Kokkos::Impl::ROCmInternal::singleton().m_rocmDev) {
+  Kokkos::Impl::ROCmInternal::singleton().verify_is_initialized(
+      "ROCm instance constructor");
 }
 
 bool ROCm::isAPU(int device) {
-  const Kokkos::Impl::ROCmInternalDevices & dev_info = 
-              Kokkos::Impl::ROCmInternalDevices::singleton();
-  return (dev_info.m_rocmProp[device].APU);  
+  const Kokkos::Impl::ROCmInternalDevices& dev_info =
+      Kokkos::Impl::ROCmInternalDevices::singleton();
+  return (dev_info.m_rocmProp[device].APU);
 }
 
-bool ROCm::isAPU() {
-  return ROCm::isAPU(rocm_device());  
-}
+bool ROCm::isAPU() { return ROCm::isAPU(rocm_device()); }
 
-//ROCm::ROCm( const int instance_id )
+// ROCm::ROCm( const int instance_id )
 //  : m_device( Impl::ROCmInternal::singleton().m_rocmDev )
 //{}
 
-void ROCm::print_configuration( std::ostream & s , const bool )
-{ Kokkos::Impl::ROCmInternal::singleton().print_configuration( s ); }
+void ROCm::print_configuration(std::ostream& s, const bool) {
+  Kokkos::Impl::ROCmInternal::singleton().print_configuration(s);
+}
 
-bool ROCm::sleep() { return false ; }
+bool ROCm::sleep() { return false; }
 
-bool ROCm::wake() { return true ; }
+bool ROCm::wake() { return true; }
 
-void ROCm::fence()
-{
-  Kokkos::Impl::rocm_device_synchronize();
-}
+void ROCm::fence() { Kokkos::Impl::rocm_device_synchronize(); }
 
 const char* ROCm::name() { return "ROCm"; }
 
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
-#endif // KOKKOS_ENABLE_ROCM
+#endif  // KOKKOS_ENABLE_ROCM
 //----------------------------------------------------------------------------
-
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Invoke.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Invoke.hpp
index b18e5f61f17f8cc62610b6eff11e35e8a460960d..989a4aec90513ac817273594544aa4ed99949219 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Invoke.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Invoke.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,95 +45,82 @@
 #include <type_traits>
 #include <Kokkos_Macros.hpp>
 
-#if !defined( KOKKOS_ROCM_INVOKE_H )
+#if !defined(KOKKOS_ROCM_INVOKE_H)
 #define KOKKOS_ROCM_INVOKE_H
 
 namespace Kokkos {
 namespace Impl {
 
-template<class Tag, class F, class... Ts, typename std::enable_if<(!std::is_void<Tag>()), int>::type = 0>
-KOKKOS_INLINE_FUNCTION void rocm_invoke(F&& f, Ts&&... xs)
-{
+template <class Tag, class F, class... Ts,
+          typename std::enable_if<(!std::is_void<Tag>()), int>::type = 0>
+KOKKOS_INLINE_FUNCTION void rocm_invoke(F&& f, Ts&&... xs) {
   f(Tag(), static_cast<Ts&&>(xs)...);
 }
 
-template<class Tag, class F, class... Ts, typename std::enable_if<(std::is_void<Tag>()), int>::type = 0>
-KOKKOS_INLINE_FUNCTION void rocm_invoke(F&& f, Ts&&... xs)
-{
+template <class Tag, class F, class... Ts,
+          typename std::enable_if<(std::is_void<Tag>()), int>::type = 0>
+KOKKOS_INLINE_FUNCTION void rocm_invoke(F&& f, Ts&&... xs) {
   f(static_cast<Ts&&>(xs)...);
 }
 
+template <class F, class Tag = void>
+struct rocm_invoke_fn {
+  F* f;
+  rocm_invoke_fn(F& f_) : f(&f_) {}
 
-template<class F, class Tag=void>
-struct rocm_invoke_fn
-{
-    F* f;
-    rocm_invoke_fn(F& f_) : f(&f_)
-    {}
-
-    template<class... Ts>
-    KOKKOS_INLINE_FUNCTION void operator()(Ts&&... xs) const
-    {
-        rocm_invoke<Tag>(*f, static_cast<Ts&&>(xs)...);
-    }
+  template <class... Ts>
+  KOKKOS_INLINE_FUNCTION void operator()(Ts&&... xs) const {
+    rocm_invoke<Tag>(*f, static_cast<Ts&&>(xs)...);
+  }
 };
 
-template<class Tag, class F>
-KOKKOS_INLINE_FUNCTION rocm_invoke_fn<F, Tag> make_rocm_invoke_fn(F& f)
-{
-    return {f};
+template <class Tag, class F>
+KOKKOS_INLINE_FUNCTION rocm_invoke_fn<F, Tag> make_rocm_invoke_fn(F& f) {
+  return {f};
 }
 
-template<class T>
-KOKKOS_INLINE_FUNCTION T& rocm_unwrap(T& x)
-{
-    return x;
+template <class T>
+KOKKOS_INLINE_FUNCTION T& rocm_unwrap(T& x) {
+  return x;
 }
 
-template<class T>
-KOKKOS_INLINE_FUNCTION T& rocm_unwrap(std::reference_wrapper<T> x)
-{
-    return x;
+template <class T>
+KOKKOS_INLINE_FUNCTION T& rocm_unwrap(std::reference_wrapper<T> x) {
+  return x;
 }
 
-template<class F, class T>
-struct rocm_capture_fn
-{
-    F f;
-    T data;
-
-    KOKKOS_INLINE_FUNCTION rocm_capture_fn(F f_, T x) 
-    : f(f_), data(x)
-    {}
-
-    template<class... Ts>
-    KOKKOS_INLINE_FUNCTION void operator()(Ts&&... xs) const
-    {
-        f(rocm_unwrap(data), static_cast<Ts&&>(xs)...);
-    }
+template <class F, class T>
+struct rocm_capture_fn {
+  F f;
+  T data;
+
+  KOKKOS_INLINE_FUNCTION rocm_capture_fn(F f_, T x) : f(f_), data(x) {}
+
+  template <class... Ts>
+  KOKKOS_INLINE_FUNCTION void operator()(Ts&&... xs) const {
+    f(rocm_unwrap(data), static_cast<Ts&&>(xs)...);
+  }
 };
 
-template<class F, class T>
-KOKKOS_INLINE_FUNCTION rocm_capture_fn<F, T> rocm_capture(F f, T x)
-{
-    return {f, x};
+template <class F, class T>
+KOKKOS_INLINE_FUNCTION rocm_capture_fn<F, T> rocm_capture(F f, T x) {
+  return {f, x};
 }
 
-template<class F, class T, class U, class... Ts>
-KOKKOS_INLINE_FUNCTION auto rocm_capture(F f, T x, U y, Ts... xs) -> decltype(rocm_capture(rocm_capture(f, x), y, xs...))
-{
-    return rocm_capture(rocm_capture(f, x), y, xs...);
+template <class F, class T, class U, class... Ts>
+KOKKOS_INLINE_FUNCTION auto rocm_capture(F f, T x, U y, Ts... xs)
+    -> decltype(rocm_capture(rocm_capture(f, x), y, xs...)) {
+  return rocm_capture(rocm_capture(f, x), y, xs...);
 }
 
-struct rocm_apply_op
-{
-    template<class F, class... Ts>
-    KOKKOS_INLINE_FUNCTION void operator()(F&& f, Ts&&... xs) const
-    {
-        f(static_cast<Ts&&>(xs)...);
-    }
+struct rocm_apply_op {
+  template <class F, class... Ts>
+  KOKKOS_INLINE_FUNCTION void operator()(F&& f, Ts&&... xs) const {
+    f(static_cast<Ts&&>(xs)...);
+  }
 };
 
-}}
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Join.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Join.hpp
index eccba5119a2aec0917d12d8d94234993b480f19c..8968663c12a2db0ad4142d70754f17c8435edc18 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Join.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Join.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,32 +42,29 @@
 //@HEADER
 */
 
-#if !defined( KOKKOS_ROCM_JOIN_H )
+#if !defined(KOKKOS_ROCM_JOIN_H)
 #define KOKKOS_ROCM_JOIN_H
 
 namespace Kokkos {
 namespace Impl {
 
-
 // Adaptor to use ValueJoin with standard algorithms
-template<class Joiner, class F>
-struct join_operator
-{
+template <class Joiner, class F>
+struct join_operator {
   const F* fp;
-  template<class T, class U>
-  T operator()(T x, const U& y) const
-  {
+  template <class T, class U>
+  T operator()(T x, const U& y) const {
     Joiner::join(*fp, &x, &y);
     return x;
   }
 };
 
-template<class Joiner, class F>
-join_operator<Joiner, F> make_join_operator(const F& f)
-{
+template <class Joiner, class F>
+join_operator<Joiner, F> make_join_operator(const F& f) {
   return join_operator<Joiner, F>{&f};
 }
 
-}}
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Parallel.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Parallel.hpp
index 48654555b23fb8bb78d907fe6bef7cea126c004f..4ebcdc6f95892bbbef28853865a66a3678c18b75 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Parallel.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Parallel.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,232 +52,256 @@
 
 #include <KokkosExp_MDRangePolicy.hpp>
 
-
 namespace Kokkos {
 namespace Impl {
 
-struct ROCmTeamMember ;
-
-template< class ... Properties >
-class TeamPolicyInternal< Kokkos::Experimental::ROCm, Properties ... >: public PolicyTraits<Properties ...> {
-private:
-  int m_league_size ;
-  int m_team_size ;
-  int m_vector_length ;
-  int m_team_scratch_size[2] ;
-  int m_thread_scratch_size[2] ;
-  int m_chunk_size ;
-
-
-public:
-
-  using execution_policy = TeamPolicyInternal ;
-  using execution_space  = Kokkos::Experimental::ROCm ;
-  typedef PolicyTraits<Properties ... > traits;
-
-  TeamPolicyInternal& operator = (const TeamPolicyInternal& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_vector_length = p.m_vector_length;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+struct ROCmTeamMember;
+
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Experimental::ROCm, Properties...>
+    : public PolicyTraits<Properties...> {
+ private:
+  int m_league_size;
+  int m_team_size;
+  int m_vector_length;
+  int m_team_scratch_size[2];
+  int m_thread_scratch_size[2];
+  int m_chunk_size;
+
+ public:
+  using execution_policy = TeamPolicyInternal;
+  using execution_space  = Kokkos::Experimental::ROCm;
+  typedef PolicyTraits<Properties...> traits;
+
+  TeamPolicyInternal& operator=(const TeamPolicyInternal& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_vector_length          = p.m_vector_length;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
     return *this;
   }
 
-  template<class ExecSpace, class ... OtherProperties >
+  template <class ExecSpace, class... OtherProperties>
   friend class TeamPolicyInternal;
 
-  template< class ... OtherProperties >
-  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::Experimental::ROCm,OtherProperties...>& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_vector_length = p.m_vector_length;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+  template <class... OtherProperties>
+  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::Experimental::ROCm,
+                                              OtherProperties...>& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_vector_length          = p.m_vector_length;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
   }
 
   TeamPolicyInternal()
-    : m_league_size( 0 )
-    , m_team_size( 0 )
-    , m_vector_length( 0 )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 64 )
-   {}
-
-  TeamPolicyInternal( const int arg_league_size
-            , const int arg_team_size )
-    : m_league_size( arg_league_size ),
-      m_team_size( arg_team_size )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 64 )
-    {}
-
-  TeamPolicyInternal( const int arg_league_size
-            , const int arg_team_size
-            , const int vector_length_request=1)
-    : m_league_size( arg_league_size ),
-      m_team_size( arg_team_size ),
-      m_vector_length (vector_length_request)
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 64 )
-    {}
-
-  TeamPolicyInternal( const int arg_league_size
-            , const Kokkos::AUTO_t )
-    : m_league_size( arg_league_size ), m_team_size( -1 )
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 64 )
-    {}
-
-  TeamPolicyInternal( const int arg_league_size
-            , const Kokkos::AUTO_t
-            , const int vector_length_request)
-    : m_league_size( arg_league_size ),
-      m_team_size( -1 ),
-      m_vector_length (vector_length_request)
-    , m_team_scratch_size {0,0}
-    , m_thread_scratch_size {0,0}
-    , m_chunk_size ( 64 )
-    {}
-
-  inline int chunk_size() const { return m_chunk_size ; }
+      : m_league_size(0),
+        m_team_size(0),
+        m_vector_length(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(64) {}
+
+  TeamPolicyInternal(const int arg_league_size, const int arg_team_size)
+      : m_league_size(arg_league_size),
+        m_team_size(arg_team_size),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(64) {}
+
+  TeamPolicyInternal(const int arg_league_size, const int arg_team_size,
+                     const int vector_length_request = 1)
+      : m_league_size(arg_league_size),
+        m_team_size(arg_team_size),
+        m_vector_length(vector_length_request),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(64) {}
+
+  TeamPolicyInternal(const int arg_league_size, const Kokkos::AUTO_t)
+      : m_league_size(arg_league_size),
+        m_team_size(-1),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(64) {}
+
+  TeamPolicyInternal(const int arg_league_size, const Kokkos::AUTO_t,
+                     const int vector_length_request)
+      : m_league_size(arg_league_size),
+        m_team_size(-1),
+        m_vector_length(vector_length_request),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(64) {}
+
+  inline int chunk_size() const { return m_chunk_size; }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  KOKKOS_INLINE_FUNCTION TeamPolicyInternal set_chunk_size(typename traits::index_type chunk_size_) const {
+  KOKKOS_INLINE_FUNCTION TeamPolicyInternal
+  set_chunk_size(typename traits::index_type chunk_size_) const {
     TeamPolicyInternal p = *this;
-    p.m_chunk_size = chunk_size_;
+    p.m_chunk_size       = chunk_size_;
     return p;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team) const {
+    TeamPolicyInternal p         = *this;
     p.m_team_scratch_size[level] = per_team.value;
     return p;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
-    p.m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
+    p.m_team_scratch_size[level]   = per_team.value;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 #else
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal& set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal& set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(const int& level,
+                                              const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-protected:
+ protected:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal internal_set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal internal_set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-public:
-// TODO:  evaluate proper team_size_max requirements
-  template< class Functor_Type>
-  KOKKOS_INLINE_FUNCTION static
-  int team_size_max( const Functor_Type & functor)
-  {
-    typedef typename Kokkos::Impl::FunctorValueTraits<Functor_Type, typename traits::work_tag>::value_type value_type;
+ public:
+  // TODO:  evaluate proper team_size_max requirements
+  template <class Functor_Type>
+  KOKKOS_INLINE_FUNCTION static int team_size_max(const Functor_Type& functor) {
+    typedef typename Kokkos::Impl::FunctorValueTraits<
+        Functor_Type, typename traits::work_tag>::value_type value_type;
     return team_size_recommended(functor);
-    // return std::min(Kokkos::Impl::get_max_tile_size() / sizeof(value_type), Kokkos::Impl::get_max_tile_thread());
+    // return std::min(Kokkos::Impl::get_max_tile_size() / sizeof(value_type),
+    // Kokkos::Impl::get_max_tile_thread());
   }
 
-  template< class Functor_Type>
-  KOKKOS_INLINE_FUNCTION static int team_size_recommended(const Functor_Type & functor)
-  { return Kokkos::Impl::get_tile_size<typename Kokkos::Impl::FunctorValueTraits<Functor_Type, typename traits::work_tag>::value_type>(); }
-
-  template< class Functor_Type >
-  KOKKOS_INLINE_FUNCTION static int team_size_recommended(const Functor_Type &functor, const int vector_length)
- {
-   int max = team_size_recommended( functor )/vector_length;
-   if(max < 1) max = 1;
-   return(max);
- }
-
-  template< class FunctorType , class PatternTypeTag>
-  int team_size_max( const FunctorType& functor, PatternTypeTag) {
-    return 256/vector_length();
+  template <class Functor_Type>
+  KOKKOS_INLINE_FUNCTION static int team_size_recommended(
+      const Functor_Type& functor) {
+    return Kokkos::Impl::get_tile_size<
+        typename Kokkos::Impl::FunctorValueTraits<
+            Functor_Type, typename traits::work_tag>::value_type>();
   }
-  template< class FunctorType , class PatternTypeTag>
-  int team_size_recommended( const FunctorType& functor, PatternTypeTag) {
-    return 128/vector_length();
+
+  template <class Functor_Type>
+  KOKKOS_INLINE_FUNCTION static int team_size_recommended(
+      const Functor_Type& functor, const int vector_length) {
+    int max = team_size_recommended(functor) / vector_length;
+    if (max < 1) max = 1;
+    return (max);
   }
 
-  template<class F>
-  KOKKOS_INLINE_FUNCTION int team_size(const F& f) const { return (m_team_size > 0) ? m_team_size : team_size_recommended(f); }
-  KOKKOS_INLINE_FUNCTION int team_size() const { return (m_team_size > 0) ? m_team_size : Impl::get_max_tile_thread(); ; }
-  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size ; }
+  template <class FunctorType, class PatternTypeTag>
+  int team_size_max(const FunctorType& functor, PatternTypeTag) {
+    return 256 / vector_length();
+  }
+  template <class FunctorType, class PatternTypeTag>
+  int team_size_recommended(const FunctorType& functor, PatternTypeTag) {
+    return 128 / vector_length();
+  }
 
+  template <class F>
+  KOKKOS_INLINE_FUNCTION int team_size(const F& f) const {
+    return (m_team_size > 0) ? m_team_size : team_size_recommended(f);
+  }
+  KOKKOS_INLINE_FUNCTION int team_size() const {
+    return (m_team_size > 0) ? m_team_size : Impl::get_max_tile_thread();
+    ;
+  }
+  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
 
-  inline int vector_length()   const { return m_vector_length ; }
+  inline int vector_length() const { return m_vector_length; }
   inline int scratch_size(int level, int team_size_ = -1) const {
-    if(team_size_<0) team_size_ = m_team_size;
-    return m_team_scratch_size[level] + team_size_*m_thread_scratch_size[level];
+    if (team_size_ < 0) team_size_ = m_team_size;
+    return m_team_scratch_size[level] +
+           team_size_ * m_thread_scratch_size[level];
   }
   inline size_t team_scratch_size(int level) const {
     return m_team_scratch_size[level];
@@ -286,330 +311,299 @@ public:
   }
 
   static int scratch_size_max(int level) {
-    return level==0 ? 
-      1024*40 : 1024*1204*20;
+    return level == 0 ? 1024 * 40 : 1024 * 1204 * 20;
   }
 
   typedef Impl::ROCmTeamMember member_type;
 };
 
-  struct ROCmTeamMember {
-    typedef Kokkos::Experimental::ROCm                             execution_space ;
-    typedef Kokkos::ScratchMemorySpace<Kokkos::Experimental::ROCm> scratch_memory_space ;
-
-    KOKKOS_INLINE_FUNCTION
-    const scratch_memory_space & team_shmem() const 
-      { return m_team_shared.set_team_thread_mode(0,1,0); }
-    KOKKOS_INLINE_FUNCTION
-    const execution_space::scratch_memory_space & team_scratch(const int& level) const
-      { return m_team_shared.set_team_thread_mode(level,1,0) ; }
-    KOKKOS_INLINE_FUNCTION
-    const execution_space::scratch_memory_space & thread_scratch(const int& level) const
-      { return m_team_shared.set_team_thread_mode(level,
-                                             team_size(),
-                                             team_rank()) ; }
-
-
-    /* Rank of this team within the league of teams */
-    KOKKOS_INLINE_FUNCTION int league_rank() const { return m_idx.tile[0]; }
-    /* Number of teams in the league */
-    KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
-    /* Rank of this thread within this team */
-    KOKKOS_INLINE_FUNCTION int team_rank() const { return m_idx.local[0] / m_vector_length; }
-    /* Rank of this thread within this thread */
-    KOKKOS_INLINE_FUNCTION int vector_rank() const { return m_idx.local[0] % m_vector_length; }
-    KOKKOS_INLINE_FUNCTION int lindex() const { return m_idx.local[0]; }
-    KOKKOS_INLINE_FUNCTION int gindex() const { return m_idx.global[0]; }
-    KOKKOS_INLINE_FUNCTION int tindex() const { return m_idx.tile[0]; }
-    KOKKOS_INLINE_FUNCTION int tile_dim() const { return m_idx.tile_dim[0]; }
-    KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
-    KOKKOS_INLINE_FUNCTION int vector_length() const { return m_vector_length; }
-
-
-    KOKKOS_INLINE_FUNCTION
-    ROCmTeamMember( const hc::tiled_index< 1 > & arg_idx, int league_size_,int team_size_ )
-      : m_league_size( league_size_ )
-      , m_team_size( team_size_ )
-      , m_team_shared( nullptr, 0 )
-      , m_vector_length( 1 )
-      , m_idx( arg_idx )
-      {}
-
-    KOKKOS_INLINE_FUNCTION
-    ROCmTeamMember( const hc::tiled_index< 1 > & arg_idx, int league_size_,int team_size_, char * shared,  std::size_t shsize, std::size_t scratch_size0, char * scratch_ptr, std::size_t scratch_size1, std::size_t vector_length)
-      : m_league_size( league_size_ )
-      , m_team_size( team_size_ )
-      , m_team_shared( shared +  
-                          arg_idx.tile[0]*(shsize+scratch_size0), 
-                       (shsize+scratch_size0)*league_size_, 
-                       scratch_ptr + arg_idx.tile[0]*scratch_size1, 
-                       scratch_size1*league_size_)
-      , m_vector_length( vector_length )
-      , m_idx( arg_idx )
-      {}
-
-    KOKKOS_INLINE_FUNCTION
-    void team_barrier() const {
-      m_idx.barrier.wait();
-    }
+struct ROCmTeamMember {
+  typedef Kokkos::Experimental::ROCm execution_space;
+  typedef Kokkos::ScratchMemorySpace<Kokkos::Experimental::ROCm>
+      scratch_memory_space;
 
-    template<class ValueType>
-    KOKKOS_INLINE_FUNCTION
-    void team_broadcast(const ValueType& value, const int& thread_id ) const 
-    {
-      static_assert(std::is_trivially_default_constructible<ValueType>(), "Only trivial constructible types can be broadcasted");
-      tile_static ValueType local_value;
-      zero_init(local_value);
-      if (this->team_rank() == thread_id) {
-        local_value = value;
-      }
-      this->team_barrier();
-      value = local_value;
-    }
-// Reduce across a team of threads.
-//
-// Each thread has vector_length elements.
-// This reduction is for TeamThreadRange operations, where the range
-// is spread across threads.  Effectively, there are vector_length
-// independent reduction operations.
-// This is different from a reduction across the elements of a thread,
-// which reduces every vector element.
-
-    template< class ValueType, class JoinOp >
-    KOKKOS_INLINE_FUNCTION
-    ValueType team_reduce( const ValueType & value , const JoinOp & op_in) const
-    {
-      typedef JoinLambdaAdapter<ValueType,JoinOp> JoinOpFunctor ;
-      const JoinOpFunctor op(op_in);
+  KOKKOS_INLINE_FUNCTION
+  const scratch_memory_space& team_shmem() const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
+  KOKKOS_INLINE_FUNCTION
+  const execution_space::scratch_memory_space& team_scratch(
+      const int& level) const {
+    return m_team_shared.set_team_thread_mode(level, 1, 0);
+  }
+  KOKKOS_INLINE_FUNCTION
+  const execution_space::scratch_memory_space& thread_scratch(
+      const int& level) const {
+    return m_team_shared.set_team_thread_mode(level, team_size(), team_rank());
+  }
 
-      tile_static ValueType buffer[512];
-      const auto local = lindex();
-      const auto team  = team_rank();
-      auto vector_rank = local%m_vector_length;
-      auto thread_base = team*m_vector_length;
+  /* Rank of this team within the league of teams */
+  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_idx.tile[0]; }
+  /* Number of teams in the league */
+  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
+  /* Rank of this thread within this team */
+  KOKKOS_INLINE_FUNCTION int team_rank() const {
+    return m_idx.local[0] / m_vector_length;
+  }
+  /* Rank of this thread within this thread */
+  KOKKOS_INLINE_FUNCTION int vector_rank() const {
+    return m_idx.local[0] % m_vector_length;
+  }
+  KOKKOS_INLINE_FUNCTION int lindex() const { return m_idx.local[0]; }
+  KOKKOS_INLINE_FUNCTION int gindex() const { return m_idx.global[0]; }
+  KOKKOS_INLINE_FUNCTION int tindex() const { return m_idx.tile[0]; }
+  KOKKOS_INLINE_FUNCTION int tile_dim() const { return m_idx.tile_dim[0]; }
+  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
+  KOKKOS_INLINE_FUNCTION int vector_length() const { return m_vector_length; }
 
-      const std::size_t size = next_pow_2(m_team_size+1)/2;
+  KOKKOS_INLINE_FUNCTION
+  ROCmTeamMember(const hc::tiled_index<1>& arg_idx, int league_size_,
+                 int team_size_)
+      : m_league_size(league_size_),
+        m_team_size(team_size_),
+        m_team_shared(nullptr, 0),
+        m_vector_length(1),
+        m_idx(arg_idx) {}
+
+  KOKKOS_INLINE_FUNCTION
+  ROCmTeamMember(const hc::tiled_index<1>& arg_idx, int league_size_,
+                 int team_size_, char* shared, std::size_t shsize,
+                 std::size_t scratch_size0, char* scratch_ptr,
+                 std::size_t scratch_size1, std::size_t vector_length)
+      : m_league_size(league_size_),
+        m_team_size(team_size_),
+        m_team_shared(shared + arg_idx.tile[0] * (shsize + scratch_size0),
+                      (shsize + scratch_size0) * league_size_,
+                      scratch_ptr + arg_idx.tile[0] * scratch_size1,
+                      scratch_size1 * league_size_),
+        m_vector_length(vector_length),
+        m_idx(arg_idx) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void team_barrier() const { m_idx.barrier.wait(); }
+
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(const ValueType& value,
+                                             const int& thread_id) const {
+    static_assert(std::is_trivially_default_constructible<ValueType>(),
+                  "Only trivial constructible types can be broadcasted");
+    tile_static ValueType local_value;
+    zero_init(local_value);
+    if (this->team_rank() == thread_id) {
+      local_value = value;
+    }
+    this->team_barrier();
+    value = local_value;
+  }
+  // Reduce across a team of threads.
+  //
+  // Each thread has vector_length elements.
+  // This reduction is for TeamThreadRange operations, where the range
+  // is spread across threads.  Effectively, there are vector_length
+  // independent reduction operations.
+  // This is different from a reduction across the elements of a thread,
+  // which reduces every vector element.
+
+  template <class ValueType, class JoinOp>
+  KOKKOS_INLINE_FUNCTION ValueType team_reduce(const ValueType& value,
+                                               const JoinOp& op_in) const {
+    typedef JoinLambdaAdapter<ValueType, JoinOp> JoinOpFunctor;
+    const JoinOpFunctor op(op_in);
+
+    tile_static ValueType buffer[512];
+    const auto local = lindex();
+    const auto team  = team_rank();
+    auto vector_rank = local % m_vector_length;
+    auto thread_base = team * m_vector_length;
+
+    const std::size_t size = next_pow_2(m_team_size + 1) / 2;
 #if defined(ROCM15)
-      buffer[local] = value;
+    buffer[local] = value;
 #else
-        // ROCM 1.5 handles address spaces better, previous version didn't
-      lds_for(buffer[local], [&](ValueType& x)
-      {
-          x = value;
-      });
+    // ROCM 1.5 handles address spaces better, previous version didn't
+    lds_for(buffer[local], [&](ValueType& x) { x = value; });
 #endif
-      m_idx.barrier.wait();
+    m_idx.barrier.wait();
 
-      for(std::size_t s = 1; s < size; s *= 2)
-      {
-          const std::size_t index = 2 * s * team;
-          if (index < size)
-          {
+    for (std::size_t s = 1; s < size; s *= 2) {
+      const std::size_t index = 2 * s * team;
+      if (index < size) {
 #if defined(ROCM15)
-                op.join(buffer[vector_rank+index*m_vector_length],
-                        buffer[vector_rank+(index+s)*m_vector_length]);
+        op.join(buffer[vector_rank + index * m_vector_length],
+                buffer[vector_rank + (index + s) * m_vector_length]);
 #else
-              lds_for(buffer[vector_rank+index*m_vector_length], [&](ValueType& x)
-              {
-                  lds_for(buffer[vector_rank+(index+s)*m_vector_length],
-                                [&](ValueType& y)
-                  {
-                      op.join(x, y);
-                  });
-              });
+        lds_for(buffer[vector_rank + index * m_vector_length],
+                [&](ValueType& x) {
+                  lds_for(buffer[vector_rank + (index + s) * m_vector_length],
+                          [&](ValueType& y) { op.join(x, y); });
+                });
 #endif
-          }
-          m_idx.barrier.wait();
       }
+      m_idx.barrier.wait();
+    }
 
-      if (local == 0)
-      {
-          for(int i=size*m_vector_length; i<m_team_size*m_vector_length; i+=m_vector_length)
+    if (local == 0) {
+      for (int i = size * m_vector_length; i < m_team_size * m_vector_length;
+           i += m_vector_length)
 #if defined(ROCM15)
-              op.join(buffer[vector_rank], buffer[vector_rank+i]);
+        op.join(buffer[vector_rank], buffer[vector_rank + i]);
 #else
-              lds_for(buffer[vector_rank], [&](ValueType& x)
-              {
-                  lds_for(buffer[vector_rank+i],
-                                [&](ValueType& y)
-                  {
-                      op.join(x, y);
-                  });
-              });
+        lds_for(buffer[vector_rank], [&](ValueType& x) {
+          lds_for(buffer[vector_rank + i],
+                  [&](ValueType& y) { op.join(x, y); });
+        });
 #endif
-      }
-      m_idx.barrier.wait();
-
-      return buffer[0];
     }
+    m_idx.barrier.wait();
 
-// Reduce across a team of threads, with a reducer data type
-//
-// Each thread has vector_length elements.
-// This reduction is for TeamThreadRange operations, where the range
-// is spread across threads.  Effectively, there are vector_length
-// independent reduction operations.
-// This is different from a reduction across the elements of a thread,
-// which reduces every vector element.
-
-    template< class ReducerType >
-    KOKKOS_INLINE_FUNCTION
-    typename std::enable_if< is_reducer< ReducerType >::value >::type
-    team_reduce( const ReducerType & reducer) const
-    {
-      typedef typename ReducerType::value_type value_type ;
+    return buffer[0];
+  }
+
+  // Reduce across a team of threads, with a reducer data type
+  //
+  // Each thread has vector_length elements.
+  // This reduction is for TeamThreadRange operations, where the range
+  // is spread across threads.  Effectively, there are vector_length
+  // independent reduction operations.
+  // This is different from a reduction across the elements of a thread,
+  // which reduces every vector element.
 
-      tile_static value_type buffer[512];
-      const auto local = lindex();
-      const auto team  = team_rank();
-      auto vector_rank = local%m_vector_length;
-      auto thread_base = team*m_vector_length;
+  template <class ReducerType>
+  KOKKOS_INLINE_FUNCTION
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      team_reduce(const ReducerType& reducer) const {
+    typedef typename ReducerType::value_type value_type;
+
+    tile_static value_type buffer[512];
+    const auto local = lindex();
+    const auto team  = team_rank();
+    auto vector_rank = local % m_vector_length;
+    auto thread_base = team * m_vector_length;
 
-      const std::size_t size = next_pow_2(m_team_size+1)/2;
+    const std::size_t size = next_pow_2(m_team_size + 1) / 2;
 #if defined(ROCM15)
-      buffer[local] = reducer.reference();
+    buffer[local] = reducer.reference();
 #else
-        // ROCM 1.5 handles address spaces better, previous version didn't
-      lds_for(buffer[local], [&](ValueType& x)
-      {
-          x = value;
-      });
+    // ROCM 1.5 handles address spaces better, previous version didn't
+    lds_for(buffer[local], [&](ValueType& x) { x = value; });
 #endif
-      m_idx.barrier.wait();
+    m_idx.barrier.wait();
 
-      for(std::size_t s = 1; s < size; s *= 2)
-      {
-          const std::size_t index = 2 * s * team;
-          if (index < size)
-          {
+    for (std::size_t s = 1; s < size; s *= 2) {
+      const std::size_t index = 2 * s * team;
+      if (index < size) {
 #if defined(ROCM15)
-                reducer.join(buffer[vector_rank+index*m_vector_length],
-                        buffer[vector_rank+(index+s)*m_vector_length]);
+        reducer.join(buffer[vector_rank + index * m_vector_length],
+                     buffer[vector_rank + (index + s) * m_vector_length]);
 #else
-              lds_for(buffer[vector_rank+index*m_vector_length], [&](ValueType& x)
-              {
-                  lds_for(buffer[vector_rank+(index+s)*m_vector_length],
-                                [&](ValueType& y)
-                  {
-                      reducer.join(x, y);
-                  });
-              });
+        lds_for(buffer[vector_rank + index * m_vector_length],
+                [&](ValueType& x) {
+                  lds_for(buffer[vector_rank + (index + s) * m_vector_length],
+                          [&](ValueType& y) { reducer.join(x, y); });
+                });
 #endif
-          }
-          m_idx.barrier.wait();
       }
+      m_idx.barrier.wait();
+    }
 
-      if (local == 0)
-      {
-          for(int i=size*m_vector_length; i<m_team_size*m_vector_length; i+=m_vector_length)
+    if (local == 0) {
+      for (int i = size * m_vector_length; i < m_team_size * m_vector_length;
+           i += m_vector_length)
 #if defined(ROCM15)
-              reducer.join(buffer[vector_rank], buffer[vector_rank+i]);
+        reducer.join(buffer[vector_rank], buffer[vector_rank + i]);
 #else
-              lds_for(buffer[vector_rank], [&](ValueType& x)
-              {
-                  lds_for(buffer[vector_rank+i],
-                                [&](ValueType& y)
-                  {
-                      reducer.join(x, y);
-                  });
-              });
+        lds_for(buffer[vector_rank], [&](ValueType& x) {
+          lds_for(buffer[vector_rank + i],
+                  [&](ValueType& y) { reducer.join(x, y); });
+        });
 #endif
-      }
-      m_idx.barrier.wait();
-      reducer.reference() = buffer[0];
     }
+    m_idx.barrier.wait();
+    reducer.reference() = buffer[0];
+  }
 
-    /** \brief  Intra-team vector reduce 
-     *          with intra-team non-deterministic ordering accumulation.
-     *
-     *  The intra-team accumulation value will, at the end of the
-     *  league's parallel execution, be the reduction's total.
-     *  Parallel execution ordering of the league's teams is non-deterministic.
-     *  As such the base value for each team's vector reduce operation is
-     *  similarly non-deterministic.
-     */
-    template< class ValueType, class JoinOp >
-    KOKKOS_INLINE_FUNCTION
-    ValueType thread_reduce( const ValueType & value , const JoinOp & op_in) const
-    {
-      typedef JoinLambdaAdapter<ValueType,JoinOp> JoinOpFunctor ;
-      const JoinOpFunctor op(op_in);
-
-      const auto local = m_idx.local[0];
-      tile_static ValueType buffer[512];
-      const std::size_t size = m_vector_length; //vector length must be power of 2
-      auto vector_rank = local%m_vector_length;
-      auto thread_base = team_rank()*m_vector_length;
-      lds_for(buffer[local], [&](ValueType& x)
-      {
-          x = value;
-      });
-      m_idx.barrier.wait();
-      for(std::size_t s = 1; s < size; s *= 2)
-      {
-          const std::size_t index = 2 * s * vector_rank;
-          if (index < size)
-          {
+  /** \brief  Intra-team vector reduce
+   *          with intra-team non-deterministic ordering accumulation.
+   *
+   *  The intra-team accumulation value will, at the end of the
+   *  league's parallel execution, be the reduction's total.
+   *  Parallel execution ordering of the league's teams is non-deterministic.
+   *  As such the base value for each team's vector reduce operation is
+   *  similarly non-deterministic.
+   */
+  template <class ValueType, class JoinOp>
+  KOKKOS_INLINE_FUNCTION ValueType thread_reduce(const ValueType& value,
+                                                 const JoinOp& op_in) const {
+    typedef JoinLambdaAdapter<ValueType, JoinOp> JoinOpFunctor;
+    const JoinOpFunctor op(op_in);
+
+    const auto local = m_idx.local[0];
+    tile_static ValueType buffer[512];
+    const std::size_t size =
+        m_vector_length;  // vector length must be power of 2
+    auto vector_rank = local % m_vector_length;
+    auto thread_base = team_rank() * m_vector_length;
+    lds_for(buffer[local], [&](ValueType& x) { x = value; });
+    m_idx.barrier.wait();
+    for (std::size_t s = 1; s < size; s *= 2) {
+      const std::size_t index = 2 * s * vector_rank;
+      if (index < size) {
 #if defined(ROCM15)
-              op.join(buffer[thread_base+index], buffer[thread_base+index+s]);
+        op.join(buffer[thread_base + index], buffer[thread_base + index + s]);
 #else
 
-              lds_for(buffer[thread_base+index], [&](ValueType& x)
-              {
-                  lds_for(buffer[thread_base+index+s], [&](ValueType& y)
-                  {
-                      op.join(x, y);
-                  });
-              });
+        lds_for(buffer[thread_base + index], [&](ValueType& x) {
+          lds_for(buffer[thread_base + index + s],
+                  [&](ValueType& y) { op.join(x, y); });
+        });
 #endif
-          }
-          m_idx.barrier.wait();
       }
-
       m_idx.barrier.wait();
-      return buffer[thread_base];
     }
 
-  template< typename ReducerType >
-  KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< is_reducer< ReducerType >::value >::type
-  vector_reduce( ReducerType const & reducer ) const
-    {
-      #ifdef __HCC_ACCELERATOR__
-      if(m_vector_length == 1) return;
-
-      // Intra vector lane shuffle reduction:
-      typename ReducerType::value_type tmp ( reducer.reference() );
+    m_idx.barrier.wait();
+    return buffer[thread_base];
+  }
 
-      for ( int i = m_vector_length ; ( i >>= 1 ) ; ) {
-        reducer.reference() = shfl_down( tmp , i , m_vector_length );
-        if ( (int)vector_rank() < i ) { reducer.join( tmp , reducer.reference() ); }
+  template <typename ReducerType>
+  KOKKOS_INLINE_FUNCTION
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      vector_reduce(ReducerType const& reducer) const {
+#ifdef __HCC_ACCELERATOR__
+    if (m_vector_length == 1) return;
+
+    // Intra vector lane shuffle reduction:
+    typename ReducerType::value_type tmp(reducer.reference());
+
+    for (int i = m_vector_length; (i >>= 1);) {
+      reducer.reference() = shfl_down(tmp, i, m_vector_length);
+      if ((int)vector_rank() < i) {
+        reducer.join(tmp, reducer.reference());
       }
-
-      // Broadcast from root lane to all other lanes.
-      // Cannot use "butterfly" algorithm to avoid the broadcast
-      // because floating point summation is not associative
-      // and thus different threads could have different results.
-
-      reducer.reference() = shfl( tmp , 0 , m_vector_length );
-      #endif
     }
 
+    // Broadcast from root lane to all other lanes.
+    // Cannot use "butterfly" algorithm to avoid the broadcast
+    // because floating point summation is not associative
+    // and thus different threads could have different results.
 
+    reducer.reference() = shfl(tmp, 0, m_vector_length);
+#endif
+  }
 
-    /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
-     *          with intra-team non-deterministic ordering accumulation.
-     *
-     *  The global inter-team accumulation value will, at the end of the
-     *  league's parallel execution, be the scan's total.
-     *  Parallel execution ordering of the league's teams is non-deterministic.
-     *  As such the base value for each team's scan operation is similarly
-     *  non-deterministic.
-     */
-    template< typename Type >
-    KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value , Type * const global_accum = nullptr ) const
-    {
-  #if 0
+  /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
+   *          with intra-team non-deterministic ordering accumulation.
+   *
+   *  The global inter-team accumulation value will, at the end of the
+   *  league's parallel execution, be the scan's total.
+   *  Parallel execution ordering of the league's teams is non-deterministic.
+   *  As such the base value for each team's scan operation is similarly
+   *  non-deterministic.
+   */
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type
+  team_scan(const Type& value, Type* const global_accum = nullptr) const {
+#if 0
       const auto local = m_idx.local[0];
       const auto last = m_team_size - 1;
       const auto init = 0;
@@ -638,63 +632,57 @@ public:
       m_idx.barrier.wait();
       return buffer[local];
 #else
-      tile_static Type sarray[2][256+1];
-      int lid = m_idx.local[0];
-      int lp1 = lid+1;
+    tile_static Type sarray[2][256 + 1];
+    int lid = m_idx.local[0];
+    int lp1 = lid + 1;
 
-      int toggle = 1;
-      int _toggle = 0;
-      m_idx.barrier.wait();
+    int toggle  = 1;
+    int _toggle = 0;
+    m_idx.barrier.wait();
 
-      if(lid == 0) 
-      {
-         sarray[1][0] = 0;
-         sarray[0][0] = 0;
+    if (lid == 0) {
+      sarray[1][0] = 0;
+      sarray[0][0] = 0;
+    }
+    sarray[1][lp1] = value;
+
+    m_idx.barrier.wait();
+    for (int stride = 1; stride < m_team_size; stride *= 2) {
+      if (lid >= stride) {
+        sarray[_toggle][lp1] =
+            sarray[toggle][lp1] + sarray[toggle][lp1 - stride];
+      } else {
+        sarray[_toggle][lp1] = sarray[toggle][lp1];
       }
-      sarray[1][lp1] = value;
-
+      toggle  = _toggle;
+      _toggle = 1 - toggle;
       m_idx.barrier.wait();
-      for(int stride = 1; stride < m_team_size; stride*=2)
-      {
-         if(lid >= stride)
-         {
-            sarray[_toggle][lp1] =
-                          sarray[toggle][lp1]+sarray[toggle][lp1-stride];
-         }
-         else
-         {
-            sarray[_toggle][lp1] = sarray[toggle][lp1];
-         }
-         toggle = _toggle;
-         _toggle = 1-toggle;
-         m_idx.barrier.wait();
-      }
+    }
 
-      if ( global_accum )
-      { 
-         if(m_team_size == lp1)
-         {
-            sarray[toggle][m_team_size] = atomic_fetch_add(global_accum,sarray[toggle][m_team_size]);
-         }
-         m_idx.barrier.wait();
-         sarray[toggle][lid] += sarray[toggle][m_team_size];
+    if (global_accum) {
+      if (m_team_size == lp1) {
+        sarray[toggle][m_team_size] =
+            atomic_fetch_add(global_accum, sarray[toggle][m_team_size]);
       }
       m_idx.barrier.wait();
-      return sarray[toggle][lid];
-#endif
+      sarray[toggle][lid] += sarray[toggle][m_team_size];
     }
+    m_idx.barrier.wait();
+    return sarray[toggle][lid];
+#endif
+  }
 
-  private:
-    int m_league_size ;
-    int m_team_size ;
-    const scratch_memory_space  m_team_shared;
+ private:
+  int m_league_size;
+  int m_team_size;
+  const scratch_memory_space m_team_shared;
 
-  public:
-    int m_vector_length;
-    hc::tiled_index<1> m_idx;
-  };
-}
-} // namespace Kokkos
+ public:
+  int m_vector_length;
+  hc::tiled_index<1> m_idx;
+};
+}  // namespace Impl
+}  // namespace Kokkos
 #include <ROCm/Kokkos_ROCm_ReduceScan.hpp>
 
 namespace Kokkos {
@@ -702,624 +690,582 @@ namespace Impl {
 
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::RangePolicy< Traits... >, Kokkos::Experimental::ROCm >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits... > Policy ;
-
-public:
-
-  inline
-  ParallelFor( const FunctorType & f
-             , const Policy      & policy )
-    {
-
-
-      const auto len = policy.end()-policy.begin();
-      const auto offset = policy.begin();
-      if(len == 0) return;
-// define a lambda to work around a compiler issue.  The compiler does not
-// properly dereference f inside the pfe.
-auto foo = [=](size_t i){rocm_invoke<typename Policy::work_tag>(f, i);};
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                  Kokkos::Experimental::ROCm> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+
+ public:
+  inline ParallelFor(const FunctorType& f, const Policy& policy) {
+    const auto len    = policy.end() - policy.begin();
+    const auto offset = policy.begin();
+    if (len == 0) return;
+    // define a lambda to work around a compiler issue.  The compiler does not
+    // properly dereference f inside the pfe.
+    auto foo = [=](size_t i) { rocm_invoke<typename Policy::work_tag>(f, i); };
 
 #if __hcc_workweek__ > 16600
-      hc::parallel_for_each(hc::extent<1>(len) , [=](const hc::index<1> & idx) [[hc]]  [[hc_max_workgroup_dim(1024,1,1)]]
+    hc::parallel_for_each(
+        hc::extent<1>(len),
+        [=](const hc::index<1>& idx) [[hc]] [[hc_max_workgroup_dim(1024, 1, 1)]]
 #else
-      hc::parallel_for_each(hc::extent<1>(len).tile(256) , [=](const hc::index<1> & idx) [[hc]]
+    hc::parallel_for_each(
+        hc::extent<1>(len).tile(256),
+        [=](const hc::index<1>& idx) [[hc]]
 #endif
-      {
-        if(idx[0]<len)  // workaround for Carrizo (and Fiji?)
-          foo(idx[0] + offset);
-      }).wait();
-
-    }
+        {
+          if (idx[0] < len)  // workaround for Carrizo (and Fiji?)
+            foo(idx[0] + offset);
+        })
+        .wait();
+  }
 
   KOKKOS_INLINE_FUNCTION
   void execute() const {}
-
 };
 
 // MDRangePolicy impl
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::MDRangePolicy< Traits ... >
-                 , Kokkos::Experimental::ROCm
-                 >
-{
-private:
-  typedef Kokkos::MDRangePolicy< Traits ...  > Policy ;
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::Experimental::ROCm> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> Policy;
   using RP = Policy;
   typedef typename Policy::array_index_type array_index_type;
   typedef typename Policy::index_type index_type;
   typedef typename Policy::launch_bounds LaunchBounds;
 
+  const FunctorType m_functor;
+  const Policy m_rp;
 
-  const FunctorType m_functor ;
-  const Policy      m_rp ;
-
-public:
-
-  KOKKOS_INLINE_FUNCTION 
-  void operator()(void) const
-    {
-       Kokkos::Impl::Refactor::DeviceIterateTile<Policy::rank,Policy,FunctorType,typename Policy::work_tag>(m_rp,m_functor).exec_range();
-    }
-
+ public:
+  KOKKOS_INLINE_FUNCTION
+  void operator()(void) const {
+    Kokkos::Impl::Refactor::DeviceIterateTile<Policy::rank, Policy, FunctorType,
+                                              typename Policy::work_tag>(
+        m_rp, m_functor)
+        .exec_range();
+  }
 
-  inline
-  void execute() const
-  {
-    const array_index_type maxblocks = static_cast<array_index_type>(Kokkos::Impl::ROCmTraits::UpperBoundExtentCount);
-    if ( RP::rank == 2 )
-    {
-      const dim3 block( m_rp.m_tile[0] , m_rp.m_tile[1] , 1);
-      const dim3 grid(
-            std::min( m_rp.m_upper[0] - m_rp.m_lower[0] , maxblocks )
-          , std::min( m_rp.m_upper[1] - m_rp.m_lower[1] , maxblocks )
-          , 1 );
-      ROCmParallelLaunch< ParallelFor, LaunchBounds >( *this, grid, block, 0);
-    }
-    else if ( RP::rank == 3 )
-    {
-      const dim3 block( m_rp.m_tile[0] , m_rp.m_tile[1] , m_rp.m_tile[2] );
-      const dim3 grid(
-            std::min( m_rp.m_upper[0] - m_rp.m_lower[0] , maxblocks )
-          , std::min( m_rp.m_upper[1] - m_rp.m_lower[1] , maxblocks )
-          , std::min( m_rp.m_upper[2] - m_rp.m_lower[2] , maxblocks ));
-      ROCmParallelLaunch< ParallelFor, LaunchBounds >( *this, grid, block, 0);
-    }
-    else if ( RP::rank == 4 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2] , m_rp.m_tile[3] );
-      const dim3 grid(
-          std::min(  m_rp.m_tile_end[0] * m_rp.m_tile_end[1] *
-              m_rp.m_tile[0] * m_rp.m_tile[1] , maxblocks )
-        , std::min( m_rp.m_upper[2] - m_rp.m_lower[2] , maxblocks )
-        , std::min( m_rp.m_upper[3] - m_rp.m_lower[3] , maxblocks ));
-      ROCmParallelLaunch< ParallelFor, LaunchBounds >( *this, grid, block, 0);
-    }
-    else if ( RP::rank == 5 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2]*m_rp.m_tile[3] , m_rp.m_tile[4] );
-      const dim3 grid(
-          std::min(  m_rp.m_tile_end[0] * m_rp.m_tile_end[1] *
-              m_rp.m_tile[0] * m_rp.m_tile[1] , maxblocks )
-        , std::min(  m_rp.m_tile_end[2] * m_rp.m_tile_end[3] *
-              m_rp.m_tile[2] * m_rp.m_tile[3] , maxblocks )
-        , std::min(  m_rp.m_upper[4] - m_rp.m_lower[4] , maxblocks ));
-      ROCmParallelLaunch< ParallelFor, LaunchBounds >( *this, grid, block, 0);
-    }
-    else if ( RP::rank == 6 )
-    {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4,id5 to threadIdx.z
-      const dim3 block( m_rp.m_tile[0]*m_rp.m_tile[1] , m_rp.m_tile[2]*m_rp.m_tile[3] , m_rp.m_tile[4]*m_rp.m_tile[5] );
-      const dim3 grid(
-          std::min(  m_rp.m_tile_end[0] * m_rp.m_tile_end[1] *
-              m_rp.m_tile[0] * m_rp.m_tile[1] , maxblocks )
-        , std::min(  m_rp.m_tile_end[2] * m_rp.m_tile_end[3] *
-              m_rp.m_tile[2] * m_rp.m_tile[3] , maxblocks )
-        , std::min(  m_rp.m_tile_end[4] * m_rp.m_tile_end[5] *
-              m_rp.m_tile[4] * m_rp.m_tile[5] , maxblocks ));
-      ROCmParallelLaunch< ParallelFor, LaunchBounds >( *this, grid, block, 0);
-    }
-    else
-    {
+  inline void execute() const {
+    const array_index_type maxblocks = static_cast<array_index_type>(
+        Kokkos::Impl::ROCmTraits::UpperBoundExtentCount);
+    if (RP::rank == 2) {
+      const dim3 block(m_rp.m_tile[0], m_rp.m_tile[1], 1);
+      const dim3 grid(std::min(m_rp.m_upper[0] - m_rp.m_lower[0], maxblocks),
+                      std::min(m_rp.m_upper[1] - m_rp.m_lower[1], maxblocks),
+                      1);
+      ROCmParallelLaunch<ParallelFor, LaunchBounds>(*this, grid, block, 0);
+    } else if (RP::rank == 3) {
+      const dim3 block(m_rp.m_tile[0], m_rp.m_tile[1], m_rp.m_tile[2]);
+      const dim3 grid(std::min(m_rp.m_upper[0] - m_rp.m_lower[0], maxblocks),
+                      std::min(m_rp.m_upper[1] - m_rp.m_lower[1], maxblocks),
+                      std::min(m_rp.m_upper[2] - m_rp.m_lower[2], maxblocks));
+      ROCmParallelLaunch<ParallelFor, LaunchBounds>(*this, grid, block, 0);
+    } else if (RP::rank == 4) {
+      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1], m_rp.m_tile[2],
+                       m_rp.m_tile[3]);
+      const dim3 grid(std::min(m_rp.m_tile_end[0] * m_rp.m_tile_end[1] *
+                                   m_rp.m_tile[0] * m_rp.m_tile[1],
+                               maxblocks),
+                      std::min(m_rp.m_upper[2] - m_rp.m_lower[2], maxblocks),
+                      std::min(m_rp.m_upper[3] - m_rp.m_lower[3], maxblocks));
+      ROCmParallelLaunch<ParallelFor, LaunchBounds>(*this, grid, block, 0);
+    } else if (RP::rank == 5) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1],
+                       m_rp.m_tile[2] * m_rp.m_tile[3], m_rp.m_tile[4]);
+      const dim3 grid(std::min(m_rp.m_tile_end[0] * m_rp.m_tile_end[1] *
+                                   m_rp.m_tile[0] * m_rp.m_tile[1],
+                               maxblocks),
+                      std::min(m_rp.m_tile_end[2] * m_rp.m_tile_end[3] *
+                                   m_rp.m_tile[2] * m_rp.m_tile[3],
+                               maxblocks),
+                      std::min(m_rp.m_upper[4] - m_rp.m_lower[4], maxblocks));
+      ROCmParallelLaunch<ParallelFor, LaunchBounds>(*this, grid, block, 0);
+    } else if (RP::rank == 6) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4,id5 to
+      // threadIdx.z
+      const dim3 block(m_rp.m_tile[0] * m_rp.m_tile[1],
+                       m_rp.m_tile[2] * m_rp.m_tile[3],
+                       m_rp.m_tile[4] * m_rp.m_tile[5]);
+      const dim3 grid(std::min(m_rp.m_tile_end[0] * m_rp.m_tile_end[1] *
+                                   m_rp.m_tile[0] * m_rp.m_tile[1],
+                               maxblocks),
+                      std::min(m_rp.m_tile_end[2] * m_rp.m_tile_end[3] *
+                                   m_rp.m_tile[2] * m_rp.m_tile[3],
+                               maxblocks),
+                      std::min(m_rp.m_tile_end[4] * m_rp.m_tile_end[5] *
+                                   m_rp.m_tile[4] * m_rp.m_tile[5],
+                               maxblocks));
+      ROCmParallelLaunch<ParallelFor, LaunchBounds>(*this, grid, block, 0);
+    } else {
       printf("Kokkos::MDRange Error: Exceeded rank bounds with ROCm\n");
       Kokkos::abort("Aborting");
     }
 
-  } //end execute
+  }  // end execute
 
-//  inline
-  ParallelFor( const FunctorType & arg_functor
-             , Policy arg_policy )
-    : m_functor( arg_functor )
-    , m_rp(  arg_policy )
-    {
-}
+  //  inline
+  ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
+      : m_functor(arg_functor), m_rp(arg_policy) {}
 };
 
 //----------------------------------------------------------------------------
 
-template< class F , class... Traits >
-class ParallelFor< F
-                 , Kokkos::TeamPolicy< Traits... >
-                 , Kokkos::Experimental::ROCm >
-{
-  using Policy = Kokkos::Impl::TeamPolicyInternal< Kokkos::Experimental::ROCm, Traits... >;
-  typedef Kokkos::Impl::FunctorValueTraits<F, typename Policy::work_tag> ValueTraits;
-
-public:
-  inline
-  ParallelFor( const F & f
-             , const Policy      & policy )
-    {
-      const auto league_size  = policy.league_size();
-      const auto team_size    = policy.team_size();
-      const int vector_length = policy.vector_length();
-      const auto total_size   = league_size * team_size * vector_length;
-      const int scratch_size0 = policy.scratch_size(0,team_size);
-      const int scratch_size1 = policy.scratch_size(1,team_size);
-
-      if(total_size == 0) return;
-
-      const auto shared_size = FunctorTeamShmemSize< F >::value( f , team_size );
-      char * scratch = NULL;
-      char * shared = (char *)rocm_device_allocate(shared_size * league_size +
-                                                   scratch_size0*league_size);
-      if(0<scratch_size1)
-        scratch = (char *)rocm_device_allocate(scratch_size1*league_size);
-
-      hc::extent< 1 > flat_extent( total_size );
-
-      hc::tiled_extent< 1 > team_extent = flat_extent.tile(vector_length*team_size);
-      hc::parallel_for_each( team_extent , [=](hc::tiled_index<1> idx) [[hc]]
-      {
-        rocm_invoke<typename Policy::work_tag>(f, typename Policy::member_type(idx, league_size, team_size, shared, shared_size, scratch_size0, scratch, scratch_size1,vector_length));
-      }).wait();
-
-      if(0<scratch_size1)
-        rocm_device_free(scratch);
-      rocm_device_free(shared);
-    }
+template <class F, class... Traits>
+class ParallelFor<F, Kokkos::TeamPolicy<Traits...>,
+                  Kokkos::Experimental::ROCm> {
+  using Policy =
+      Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::ROCm, Traits...>;
+  typedef Kokkos::Impl::FunctorValueTraits<F, typename Policy::work_tag>
+      ValueTraits;
+
+ public:
+  inline ParallelFor(const F& f, const Policy& policy) {
+    const auto league_size  = policy.league_size();
+    const auto team_size    = policy.team_size();
+    const int vector_length = policy.vector_length();
+    const auto total_size   = league_size * team_size * vector_length;
+    const int scratch_size0 = policy.scratch_size(0, team_size);
+    const int scratch_size1 = policy.scratch_size(1, team_size);
+
+    if (total_size == 0) return;
+
+    const auto shared_size = FunctorTeamShmemSize<F>::value(f, team_size);
+    char* scratch          = NULL;
+    char* shared = (char*)rocm_device_allocate(shared_size * league_size +
+                                               scratch_size0 * league_size);
+    if (0 < scratch_size1)
+      scratch = (char*)rocm_device_allocate(scratch_size1 * league_size);
+
+    hc::extent<1> flat_extent(total_size);
+
+    hc::tiled_extent<1> team_extent =
+        flat_extent.tile(vector_length * team_size);
+    hc::parallel_for_each(
+        team_extent,
+        [=](hc::tiled_index<1> idx) [[hc]] {
+          rocm_invoke<typename Policy::work_tag>(
+              f, typename Policy::member_type(
+                     idx, league_size, team_size, shared, shared_size,
+                     scratch_size0, scratch, scratch_size1, vector_length));
+        })
+        .wait();
+
+    if (0 < scratch_size1) rocm_device_free(scratch);
+    rocm_device_free(shared);
+  }
 
   KOKKOS_INLINE_FUNCTION
   void execute() const {}
-
 };
 
-
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ReducerType, class... Traits >
-class ParallelReduce<
-  FunctorType , Kokkos::RangePolicy< Traits... >, ReducerType, Kokkos::Experimental::ROCm >
-{
-public:
-
-  typedef Kokkos::RangePolicy< Traits... > Policy ;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+                     Kokkos::Experimental::ROCm> {
+ public:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
   // TODO: Use generic lambdas instead
-  struct invoke_fn
-  {
-    template<class F, class... Ts>
-    KOKKOS_INLINE_FUNCTION void operator()(std::size_t size, F&& f, hc::tiled_index<1> idx, tile_desc td, Ts&&... xs) const
-    {
+  struct invoke_fn {
+    template <class F, class... Ts>
+    KOKKOS_INLINE_FUNCTION void operator()(std::size_t size, F&& f,
+                                           hc::tiled_index<1> idx, tile_desc td,
+                                           Ts&&... xs) const {
       auto global = idx.global[0];
       if (global < size) f(idx.global[0], static_cast<Ts&&>(xs)...);
     }
   };
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType  & f,
-                  const Policy       & policy,
-                  const ViewType & result_view,
-                  typename std::enable_if<
-                               Kokkos::is_view< ViewType >::value &&
-                              !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    {
-      typedef typename Policy::work_tag Tag;
-      typedef Kokkos::Impl::FunctorValueTraits< FunctorType , Tag > ValueTraits;
-      typedef Kokkos::Impl::FunctorValueInit< FunctorType , Tag > ValueInit;
-      typedef typename ValueTraits::reference_type reference_type;
-
-      const auto total_size = policy.end() - policy.begin();
-
-      if(total_size==0) {
-        if (result_view.data()) {
-           ValueInit::init( f , result_view.data() );
-        }
-        return;
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType& f, const Policy& policy, const ViewType& result_view,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL) {
+    typedef typename Policy::work_tag Tag;
+    typedef Kokkos::Impl::FunctorValueTraits<FunctorType, Tag> ValueTraits;
+    typedef Kokkos::Impl::FunctorValueInit<FunctorType, Tag> ValueInit;
+    typedef typename ValueTraits::reference_type reference_type;
+
+    const auto total_size = policy.end() - policy.begin();
+
+    if (total_size == 0) {
+      if (result_view.data()) {
+        ValueInit::init(f, result_view.data());
       }
-
-      Kokkos::Impl::reduce_enqueue< Tag >
-        ( total_size 
-        , f
-        , InvalidType{}
-        , rocm_capture(invoke_fn{}, total_size)
-        , result_view.data()
-        , result_view.extent(0)
-        );
+      return;
     }
 
-  inline
-  ParallelReduce( const FunctorType & f,
-                  Policy       policy,
-                  const ReducerType& reducer )
-  {
-      typedef typename Policy::work_tag Tag;
+    Kokkos::Impl::reduce_enqueue<Tag>(
+        total_size, f, InvalidType{}, rocm_capture(invoke_fn{}, total_size),
+        result_view.data(), result_view.extent(0));
+  }
+
+  inline ParallelReduce(const FunctorType& f, Policy policy,
+                        const ReducerType& reducer) {
+    typedef typename Policy::work_tag Tag;
 
-      typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value,                                   FunctorType, ReducerType> ReducerConditional;
-      typedef typename ReducerConditional::type ReducerTypeFwd;
-      typedef Kokkos::Impl::FunctorValueTraits< FunctorType , Tag > ValueTraits;
-      typedef Kokkos::Impl::FunctorValueInit< ReducerType, Tag > ValueInit ;
+    typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                               FunctorType, ReducerType>
+        ReducerConditional;
+    typedef typename ReducerConditional::type ReducerTypeFwd;
+    typedef Kokkos::Impl::FunctorValueTraits<FunctorType, Tag> ValueTraits;
+    typedef Kokkos::Impl::FunctorValueInit<ReducerType, Tag> ValueInit;
 
-      typedef typename ValueTraits::reference_type reference_type;
+    typedef typename ValueTraits::reference_type reference_type;
 
-      const auto total_size = policy.end() - policy.begin();
+    const auto total_size = policy.end() - policy.begin();
 
-      if(total_size==0) {
-        if (reducer.view().data()) {
-           ValueInit::init( ReducerConditional::select(f,reducer), 
-                            reducer.view().data() );
-        }
-        return;
+    if (total_size == 0) {
+      if (reducer.view().data()) {
+        ValueInit::init(ReducerConditional::select(f, reducer),
+                        reducer.view().data());
       }
+      return;
+    }
 
-      Kokkos::Impl::reduce_enqueue< Tag >
-        ( total_size 
-        , f
-        , reducer
-        , rocm_capture(invoke_fn{}, total_size)
-        , reducer.view().data()
-        , reducer.view().extent(0)
-        );
+    Kokkos::Impl::reduce_enqueue<Tag>(
+        total_size, f, reducer, rocm_capture(invoke_fn{}, total_size),
+        reducer.view().data(), reducer.view().extent(0));
   }
 
   KOKKOS_INLINE_FUNCTION
   void execute() const {}
-
 };
 
 //----------------------------------------------------------------------------
 
-template< class FunctorType , class ReducerType, class... Traits >
-class ParallelReduce<
-  FunctorType , Kokkos::MDRangePolicy< Traits... >, ReducerType, Kokkos::Experimental::ROCm >
-{
-private:
-  typedef Kokkos::MDRangePolicy< Traits ...  > Policy ;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
+                     Kokkos::Experimental::ROCm> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> Policy;
   using RP = Policy;
   typedef typename Policy::array_index_type array_index_type;
   typedef typename Policy::index_type index_type;
-  typedef typename Policy::work_tag     WorkTag ;
-  typedef typename Policy::member_type  Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
   typedef typename Policy::launch_bounds LaunchBounds;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
-
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd, WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd, WorkTagFwd > ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin<   ReducerTypeFwd, WorkTagFwd > ValueJoin ;
-
-
-public:
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::value_type      value_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef FunctorType                           functor_type ;
-  typedef Kokkos::Experimental::ROCm::size_type size_type ;
-
-  // Algorithmic constraints: blockSize is a power of two AND blockDim.y == blockDim.z == 1
-
-  const FunctorType   m_functor ;
-  const Policy        m_policy ; // used for workrange and nwork
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
-  value_type *         m_scratch_space ;
-  size_type *         m_scratch_flags ;
-
-  typedef typename Kokkos::Impl::Reduce::DeviceIterateTile<Policy::rank, Policy, FunctorType, typename Policy::work_tag, reference_type> DeviceIteratePattern;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, WorkTagFwd> ValueJoin;
+
+ public:
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::value_type value_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef FunctorType functor_type;
+  typedef Kokkos::Experimental::ROCm::size_type size_type;
+
+  // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
+  // blockDim.z == 1
+
+  const FunctorType m_functor;
+  const Policy m_policy;  // used for workrange and nwork
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+  value_type* m_scratch_space;
+  size_type* m_scratch_flags;
+
+  typedef typename Kokkos::Impl::Reduce::DeviceIterateTile<
+      Policy::rank, Policy, FunctorType, typename Policy::work_tag,
+      reference_type>
+      DeviceIteratePattern;
 
   KOKKOS_INLINE_FUNCTION
-  void exec_range( reference_type update ) const
-  {
-    Kokkos::Impl::Reduce::DeviceIterateTile<Policy::rank,Policy,FunctorType,typename Policy::work_tag, reference_type>(m_policy, m_functor, update).exec_range();
+  void exec_range(reference_type update) const {
+    Kokkos::Impl::Reduce::DeviceIterateTile<Policy::rank, Policy, FunctorType,
+                                            typename Policy::work_tag,
+                                            reference_type>(m_policy, m_functor,
+                                                            update)
+        .exec_range();
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void operator()(void) const
-    {
-       run();
-    }
+  void operator()(void) const { run(); }
 
   KOKKOS_INLINE_FUNCTION
-  void run( ) const
-  {
-    const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(value_type) >
-      word_count( (ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) )) / sizeof(value_type) );
-      // pointer to shared data accounts for the reserved space at the start
-      value_type * const shared = kokkos_impl_rocm_shared_memory<value_type>()
-                                 + 2*sizeof(uint64_t); 
+  void run() const {
+    const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                   sizeof(value_type)>
+        word_count((ValueTraits::value_size(
+                       ReducerConditional::select(m_functor, m_reducer))) /
+                   sizeof(value_type));
+    // pointer to shared data accounts for the reserved space at the start
+    value_type* const shared =
+        kokkos_impl_rocm_shared_memory<value_type>() + 2 * sizeof(uint64_t);
 
     {
       reference_type value =
-        ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , shared + threadIdx_y * word_count.value );
-      // Number of blocks is bounded so that the reduction can be limited to two passes.
-      // Each thread block is given an approximately equal amount of work to perform.
-      // Accumulate the values for this block.
-      // The accumulation ordering does not match the final pass, but is arithmatically equivalent.
-
-      this-> exec_range( value );
+          ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                          shared + threadIdx_y * word_count.value);
+      // Number of blocks is bounded so that the reduction can be limited to two
+      // passes. Each thread block is given an approximately equal amount of
+      // work to perform. Accumulate the values for this block. The accumulation
+      // ordering does not match the final pass, but is arithmatically
+      // equivalent.
+
+      this->exec_range(value);
     }
 
     // Reduce with final value at blockDim.y - 1 location.
     // Problem: non power-of-two blockDim
 
-    if ( rocm_single_inter_block_reduce_scan<false,ReducerTypeFwd,WorkTagFwd>(
-           ReducerConditional::select(m_functor , m_reducer) , blockIdx_x ,
-           gridDim_x , shared , m_scratch_space , m_scratch_flags ) ) {
-
-      // This is the final block with the final result at the final threads' location
-      value_type * const tshared = shared + ( blockDim_y - 1 ) * word_count.value ;
-      value_type * const global =  m_scratch_space ;
-
-      if ( threadIdx_y == 0 ) {
-        Kokkos::Impl::FunctorFinal< ReducerTypeFwd , WorkTagFwd >::final( ReducerConditional::select(m_functor , m_reducer) , tshared );
-//        for ( unsigned i = 0 ; i < word_count.value ; i+=blockDim_y ) { global[i] = tshared[i]; }
-        for ( unsigned i = 0 ; i < word_count.value ; i++ ) { global[i] = tshared[i]; }
+    if (rocm_single_inter_block_reduce_scan<false, ReducerTypeFwd, WorkTagFwd>(
+            ReducerConditional::select(m_functor, m_reducer), blockIdx_x,
+            gridDim_x, shared, m_scratch_space, m_scratch_flags)) {
+      // This is the final block with the final result at the final threads'
+      // location
+      value_type* const tshared = shared + (blockDim_y - 1) * word_count.value;
+      value_type* const global  = m_scratch_space;
+
+      if (threadIdx_y == 0) {
+        Kokkos::Impl::FunctorFinal<ReducerTypeFwd, WorkTagFwd>::final(
+            ReducerConditional::select(m_functor, m_reducer), tshared);
+        //        for ( unsigned i = 0 ; i < word_count.value ; i+=blockDim_y )
+        //        { global[i] = tshared[i]; }
+        for (unsigned i = 0; i < word_count.value; i++) {
+          global[i] = tshared[i];
+        }
       }
     }
   }
 
-
-
   // Determine block size constrained by shared memory:
-  static inline
-  unsigned local_block_size( const FunctorType & f )
-    {
-      unsigned n = ROCmTraits::WavefrontSize * 8 ;
-      while ( n && ROCmTraits::SharedMemoryCapacity < rocm_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( f , n ) ) { n >>= 1 ; }
-      return n ;
+  static inline unsigned local_block_size(const FunctorType& f) {
+    unsigned n = ROCmTraits::WavefrontSize * 8;
+    while (n &&
+           ROCmTraits::SharedMemoryCapacity <
+               rocm_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                         WorkTag>(f, n)) {
+      n >>= 1;
     }
+    return n;
+  }
 
-  inline
-  void execute()
-    {
-      const int nwork = m_policy.m_num_tiles;
-      if ( nwork ) {
-        int block_size = m_policy.m_prod_tile_dims;
-        // CONSTRAINT: Algorithm requires block_size >= product of tile dimensions
-        // Nearest power of two
-        int exponent_pow_two = std::ceil( std::log2((float)block_size) );
-        block_size = 1<<(exponent_pow_two);
-
-        m_scratch_space = (value_type*)rocm_internal_scratch_space( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) * block_size*nwork /* block_size == max block_count */ );
-        m_scratch_flags = rocm_internal_scratch_flags( sizeof(size_type) );
-        const dim3 block( 1 , block_size , 1 );
-        // Required grid.x <= block.y
-        const dim3 grid( nwork, block_size ,  1 );
-      const int shmem = rocm_single_inter_block_reduce_scan_shmem<false,FunctorType,WorkTag>( m_functor , block.y );
-
-      ROCmParallelLaunch< ParallelReduce, LaunchBounds >( *this, grid, block, shmem ); // copy to device and execute
+  inline void execute() {
+    const int nwork = m_policy.m_num_tiles;
+    if (nwork) {
+      int block_size = m_policy.m_prod_tile_dims;
+      // CONSTRAINT: Algorithm requires block_size >= product of tile dimensions
+      // Nearest power of two
+      int exponent_pow_two = std::ceil(std::log2((float)block_size));
+      block_size           = 1 << (exponent_pow_two);
+
+      m_scratch_space = (value_type*)rocm_internal_scratch_space(
+          ValueTraits::value_size(
+              ReducerConditional::select(m_functor, m_reducer)) *
+          block_size * nwork /* block_size == max block_count */);
+      m_scratch_flags = rocm_internal_scratch_flags(sizeof(size_type));
+      const dim3 block(1, block_size, 1);
+      // Required grid.x <= block.y
+      const dim3 grid(nwork, block_size, 1);
+      const int shmem =
+          rocm_single_inter_block_reduce_scan_shmem<false, FunctorType,
+                                                    WorkTag>(m_functor,
+                                                             block.y);
+
+      ROCmParallelLaunch<ParallelReduce, LaunchBounds>(
+          *this, grid, block, shmem);  // copy to device and execute
 
       ROCM().fence();
 
-      if ( m_result_ptr ) {
-          const int size = ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer)  );
-          DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace>( m_result_ptr , m_scratch_space , size );
+      if (m_result_ptr) {
+        const int size = ValueTraits::value_size(
+            ReducerConditional::select(m_functor, m_reducer));
+        DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace>(
+            m_result_ptr, m_scratch_space, size);
       }
-    }
-    else {
+    } else {
       if (m_result_ptr) {
-        ValueInit::init( ReducerConditional::select(m_functor , m_reducer) , m_result_ptr );
+        ValueInit::init(ReducerConditional::select(m_functor, m_reducer),
+                        m_result_ptr);
       }
     }
   }
 
-
-  template< class HostViewType >
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const HostViewType & arg_result
-                , typename std::enable_if<
-                   Kokkos::is_view< HostViewType >::value
-                ,void*>::type = NULL)
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( InvalidType() )
-  , m_result_ptr( arg_result.data() )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  {}
-
-  ParallelReduce( const FunctorType  & arg_functor
-                , const Policy       & arg_policy
-                , const ReducerType & reducer)
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr( reducer.view().data() )
-  , m_scratch_space( 0 )
-  , m_scratch_flags( 0 )
-  {}
-
+  template <class HostViewType>
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const HostViewType& arg_result,
+                 typename std::enable_if<Kokkos::is_view<HostViewType>::value,
+                                         void*>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.data()),
+        m_scratch_space(0),
+        m_scratch_flags(0) {}
+
+  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
+                 const ReducerType& reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
+        m_scratch_space(0),
+        m_scratch_flags(0) {}
 };
 //----------------------------------------------------------------------------
 
-template< class FunctorType, class ReducerType, class... Traits >
-class ParallelReduce<
-   FunctorType , Kokkos::TeamPolicy< Traits... >, ReducerType, Kokkos::Experimental::ROCm >
-{
-  using Policy = Kokkos::Impl::TeamPolicyInternal< Kokkos::Experimental::ROCm, Traits... >;
-  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, typename Policy::work_tag> ValueTraits;
-
-public:
-
-  struct invoke_fn
-  {
-    template<class Create, class F, class... Ts>
-    KOKKOS_INLINE_FUNCTION void operator()(Create&& create, F&& f, hc::tiled_index<1> idx, tile_desc td, Ts&&... xs) const
-    {
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Traits...>, ReducerType,
+                     Kokkos::Experimental::ROCm> {
+  using Policy =
+      Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::ROCm, Traits...>;
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType,
+                                           typename Policy::work_tag>
+      ValueTraits;
+
+ public:
+  struct invoke_fn {
+    template <class Create, class F, class... Ts>
+    KOKKOS_INLINE_FUNCTION void operator()(Create&& create, F&& f,
+                                           hc::tiled_index<1> idx, tile_desc td,
+                                           Ts&&... xs) const {
       f(create(idx, td), static_cast<Ts&&>(xs)...);
     }
   };
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType  & f,
-                  const Policy       & policy,
-                  const ViewType     & result_view,
-                typename std::enable_if<
-                  Kokkos::is_view< ViewType >::value &&
-                  !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    {
-      const int league_size = policy.league_size();
-      const int team_size = policy.team_size(f);
-      const int vector_length = policy.vector_length();
-      const int scratch_size0 = policy.scratch_size(0,team_size);
-      const int scratch_size1 = policy.scratch_size(1,team_size);
-      const int total_size = league_size * team_size ;
-      
-      typedef Kokkos::Impl::FunctorValueInit< FunctorType, typename Policy::work_tag > ValueInit ;
-      if(total_size==0) {
-        if (result_view.data()) {
-           ValueInit::init( f , result_view.data() );
-        }
-        return;
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType& f, const Policy& policy, const ViewType& result_view,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void*>::type = NULL) {
+    const int league_size   = policy.league_size();
+    const int team_size     = policy.team_size(f);
+    const int vector_length = policy.vector_length();
+    const int scratch_size0 = policy.scratch_size(0, team_size);
+    const int scratch_size1 = policy.scratch_size(1, team_size);
+    const int total_size    = league_size * team_size;
+
+    typedef Kokkos::Impl::FunctorValueInit<FunctorType,
+                                           typename Policy::work_tag>
+        ValueInit;
+    if (total_size == 0) {
+      if (result_view.data()) {
+        ValueInit::init(f, result_view.data());
       }
+      return;
+    }
 
-      const int reduce_size = ValueTraits::value_size( f );
-      const int shared_size = FunctorTeamShmemSize< FunctorType >::value( f , team_size );
-
-      char * shared;
-      char * scratch = NULL;
+    const int reduce_size = ValueTraits::value_size(f);
+    const int shared_size =
+        FunctorTeamShmemSize<FunctorType>::value(f, team_size);
 
-      shared = (char *)rocm_device_allocate(league_size *
-                             (shared_size + scratch_size0));
-      if(0<scratch_size1)
-        scratch = (char *)rocm_device_allocate(scratch_size1 * league_size);
+    char* shared;
+    char* scratch = NULL;
 
-      auto create_team_member = [=](hc::tiled_index<1> idx, tile_desc td) 
-      { 
+    shared = (char*)rocm_device_allocate(league_size *
+                                         (shared_size + scratch_size0));
+    if (0 < scratch_size1)
+      scratch = (char*)rocm_device_allocate(scratch_size1 * league_size);
 
-        return typename Policy::member_type(idx, league_size, td.team_size, 
-                                          shared, shared_size, scratch_size0,
-                                          scratch, scratch_size1, 
-                                          vector_length); 
-      };
-
-      Kokkos::Impl::reduce_enqueue< typename Policy::work_tag >
-      ( total_size*vector_length
-        , f
-        , InvalidType{}
-        , rocm_capture(invoke_fn{}, create_team_member)
-        , result_view.ptr_on_device()
-        , result_view.dimension_0()
-        , team_size 
-        , vector_length 
-        , shared_size
-      );
-
-      if(0<scratch_size1)
-        rocm_device_free(scratch);
-      rocm_device_free(shared);
-    }
+    auto create_team_member = [=](hc::tiled_index<1> idx, tile_desc td) {
+      return typename Policy::member_type(
+          idx, league_size, td.team_size, shared, shared_size, scratch_size0,
+          scratch, scratch_size1, vector_length);
+    };
 
-  inline
-  ParallelReduce( const FunctorType & f,
-                  Policy       policy,
-                  const ReducerType& reducer )
-  {
-    const int league_size = policy.league_size();
-      const int team_size = policy.team_size(f);
-      const int vector_length = policy.vector_length();
-      const int total_size = league_size * team_size;
-
-      typedef Kokkos::Impl::FunctorValueInit< ReducerType, typename Policy::work_tag > ValueInit ;
-      typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value,
-                                   FunctorType, ReducerType> ReducerConditional;
-      if(total_size==0) {
-        if (reducer.view().data()) {
-           ValueInit::init( ReducerConditional::select(f,reducer), 
-                            reducer.view().data() );
-        }
-        return;
-      }
+    Kokkos::Impl::reduce_enqueue<typename Policy::work_tag>(
+        total_size * vector_length, f, InvalidType{},
+        rocm_capture(invoke_fn{}, create_team_member),
+        result_view.ptr_on_device(), result_view.dimension_0(), team_size,
+        vector_length, shared_size);
 
-      const int reduce_size = ValueTraits::value_size( f );
-      const int shared_size = FunctorTeamShmemSize< FunctorType >::value( f , team_size );
-      const int scratch_size0 = policy.scratch_size(0,team_size);
-      const int scratch_size1 = policy.scratch_size(1,team_size);
+    if (0 < scratch_size1) rocm_device_free(scratch);
+    rocm_device_free(shared);
+  }
 
-      char * shared;
-      char * scratch = NULL;
-      shared = (char *)rocm_device_allocate((shared_size + scratch_size0) *
-                                            league_size);
-      if(0<scratch_size1)
-        scratch = (char *)rocm_device_allocate(scratch_size1 * league_size);
+  inline ParallelReduce(const FunctorType& f, Policy policy,
+                        const ReducerType& reducer) {
+    const int league_size   = policy.league_size();
+    const int team_size     = policy.team_size(f);
+    const int vector_length = policy.vector_length();
+    const int total_size    = league_size * team_size;
+
+    typedef Kokkos::Impl::FunctorValueInit<ReducerType,
+                                           typename Policy::work_tag>
+        ValueInit;
+    typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                               FunctorType, ReducerType>
+        ReducerConditional;
+    if (total_size == 0) {
+      if (reducer.view().data()) {
+        ValueInit::init(ReducerConditional::select(f, reducer),
+                        reducer.view().data());
+      }
+      return;
+    }
 
-      auto create_team_member = [=](hc::tiled_index<1> idx, tile_desc td) 
-      { 
-        return typename Policy::member_type(idx, league_size, td.tile_size, shared, shared_size, scratch_size0, scratch, scratch_size1, vector_length); 
-      };
-
-      Kokkos::Impl::reduce_enqueue< typename Policy::work_tag >
-      ( league_size
-        , f
-        , reducer
-        , rocm_capture(invoke_fn{}, create_team_member)
-        , reducer.view().data()
-        , reducer.view().extent(0),team_size,vector_length
-        , shared_size
-     );
-
-      if(0<scratch_size1)
-        rocm_device_free(scratch);
-      rocm_device_free(shared);
+    const int reduce_size = ValueTraits::value_size(f);
+    const int shared_size =
+        FunctorTeamShmemSize<FunctorType>::value(f, team_size);
+    const int scratch_size0 = policy.scratch_size(0, team_size);
+    const int scratch_size1 = policy.scratch_size(1, team_size);
+
+    char* shared;
+    char* scratch = NULL;
+    shared        = (char*)rocm_device_allocate((shared_size + scratch_size0) *
+                                         league_size);
+    if (0 < scratch_size1)
+      scratch = (char*)rocm_device_allocate(scratch_size1 * league_size);
+
+    auto create_team_member = [=](hc::tiled_index<1> idx, tile_desc td) {
+      return typename Policy::member_type(
+          idx, league_size, td.tile_size, shared, shared_size, scratch_size0,
+          scratch, scratch_size1, vector_length);
+    };
+
+    Kokkos::Impl::reduce_enqueue<typename Policy::work_tag>(
+        league_size, f, reducer, rocm_capture(invoke_fn{}, create_team_member),
+        reducer.view().data(), reducer.view().extent(0), team_size,
+        vector_length, shared_size);
+
+    if (0 < scratch_size1) rocm_device_free(scratch);
+    rocm_device_free(shared);
   }
 
   KOKKOS_INLINE_FUNCTION
   void execute() const {}
-
 };
 
-
-template< class FunctorType , class... Traits >
-class ParallelScan< FunctorType , Kokkos::RangePolicy< Traits... >, Kokkos::Experimental::ROCm >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits... > Policy;
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Experimental::ROCm> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
   typedef typename Policy::work_tag Tag;
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, Tag>  ValueTraits;
-
-public:
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, Tag> ValueTraits;
 
+ public:
   //----------------------------------------
 
-  inline
-  ParallelScan( const FunctorType & f
-              , const Policy      & policy )
-  {
-    const auto len = policy.end()-policy.begin();
+  inline ParallelScan(const FunctorType& f, const Policy& policy) {
+    const auto len = policy.end() - policy.begin();
 
+    if (len == 0) return;
 
-    if(len==0) return;
-
-    scan_enqueue<Tag>(len, f, [](hc::tiled_index<1> idx, int, int) { return idx.global[0]; });
+    scan_enqueue<Tag>(
+        len, f, [](hc::tiled_index<1> idx, int, int) { return idx.global[0]; });
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -1328,31 +1274,26 @@ public:
   //----------------------------------------
 };
 
-template< class FunctorType , class ReturnType , class... Traits >
-class ParallelScanWithTotal< FunctorType , Kokkos::RangePolicy< Traits... >,
-                             ReturnType, Kokkos::Experimental::ROCm >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits... > Policy;
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::Experimental::ROCm> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
   typedef typename Policy::work_tag Tag;
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, Tag>  ValueTraits;
-
-public:
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, Tag> ValueTraits;
 
+ public:
   //----------------------------------------
 
-  inline
-  ParallelScanWithTotal( const FunctorType & f
-              , const Policy      & policy 
-              , ReturnType        & arg_returnvalue)
-  {
-    const auto len = policy.end()-policy.begin();
-
+  inline ParallelScanWithTotal(const FunctorType& f, const Policy& policy,
+                               ReturnType& arg_returnvalue) {
+    const auto len = policy.end() - policy.begin();
 
-    if(len==0) return;
+    if (len == 0) return;
 
-    scan_enqueue<Tag,ReturnType>(len, f, arg_returnvalue, [](hc::tiled_index<1> idx, int, int) { return idx.global[0]; });
+    scan_enqueue<Tag, ReturnType>(
+        len, f, arg_returnvalue,
+        [](hc::tiled_index<1> idx, int, int) { return idx.global[0]; });
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -1361,30 +1302,29 @@ public:
   //----------------------------------------
 };
 
-template< class FunctorType , class... Traits>
-class ParallelScan< FunctorType , Kokkos::TeamPolicy< Traits... >, Kokkos::Experimental::ROCm >
-{
-private:
-
-  using Policy = Kokkos::Impl::TeamPolicyInternal< Kokkos::Experimental::ROCm, Traits... >;
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::TeamPolicy<Traits...>,
+                   Kokkos::Experimental::ROCm> {
+ private:
+  using Policy =
+      Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::ROCm, Traits...>;
   typedef typename Policy::work_tag Tag;
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, Tag>  ValueTraits;
-
-public:
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, Tag> ValueTraits;
 
+ public:
   //----------------------------------------
 
-  inline
-  ParallelScan( const FunctorType & f
-              , const Policy      & policy )
-  {
+  inline ParallelScan(const FunctorType& f, const Policy& policy) {
     const auto league_size = policy.league_size();
-    const auto team_size = policy.team_size(f);
-    const auto len  = league_size * team_size;
-      
-    if(len == 0) return;
+    const auto team_size   = policy.team_size(f);
+    const auto len         = league_size * team_size;
 
-    scan_enqueue<Tag>(len, f, [&](hc::tiled_index<1> idx, int n_teams, int n_leagues) { return typename Policy::member_type(idx,n_leagues,n_teams); });
+    if (len == 0) return;
+
+    scan_enqueue<Tag>(
+        len, f, [&](hc::tiled_index<1> idx, int n_teams, int n_leagues) {
+          return typename Policy::member_type(idx, n_leagues, n_teams);
+        });
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -1393,76 +1333,71 @@ public:
   //----------------------------------------
 };
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
-  template<typename iType>
-  struct TeamThreadRangeBoundariesStruct<iType,ROCmTeamMember> {
-    typedef iType index_type;
-    const iType start;
-    const iType end;
-    const iType increment;
-    const ROCmTeamMember& thread;
-
-#if defined( __HCC_ACCELERATOR__ )
-    KOKKOS_INLINE_FUNCTION
-    TeamThreadRangeBoundariesStruct (const ROCmTeamMember& thread_, const iType& count):
-      start( thread_.team_rank() ),
-      end( count ),
-      increment( thread_.team_size() ),
-      thread(thread_)
-    {}
-    KOKKOS_INLINE_FUNCTION
-    TeamThreadRangeBoundariesStruct (const ROCmTeamMember& thread_,  const iType& begin_, const iType& end_):
-      start( begin_ + thread_.team_rank() ),
-      end( end_ ),
-      increment( thread_.team_size() ),
-      thread(thread_)
-    {}
+template <typename iType>
+struct TeamThreadRangeBoundariesStruct<iType, ROCmTeamMember> {
+  typedef iType index_type;
+  const iType start;
+  const iType end;
+  const iType increment;
+  const ROCmTeamMember& thread;
+
+#if defined(__HCC_ACCELERATOR__)
+  KOKKOS_INLINE_FUNCTION
+  TeamThreadRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                  const iType& count)
+      : start(thread_.team_rank()),
+        end(count),
+        increment(thread_.team_size()),
+        thread(thread_) {}
+  KOKKOS_INLINE_FUNCTION
+  TeamThreadRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                  const iType& begin_, const iType& end_)
+      : start(begin_ + thread_.team_rank()),
+        end(end_),
+        increment(thread_.team_size()),
+        thread(thread_) {}
 #else
-    KOKKOS_INLINE_FUNCTION
-    TeamThreadRangeBoundariesStruct (const ROCmTeamMember& thread_, const iType& count):
-      start( 0 ),
-      end( count ),
-      increment( 1 ),
-      thread(thread_)
-    {}
-    KOKKOS_INLINE_FUNCTION
-    TeamThreadRangeBoundariesStruct (const ROCmTeamMember& thread_,  const iType& begin_, const iType& end_):
-      start( begin_ ),
-      end( end_ ),
-      increment( 1 ),
-      thread(thread_)
-    {}
+  KOKKOS_INLINE_FUNCTION
+  TeamThreadRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                  const iType& count)
+      : start(0), end(count), increment(1), thread(thread_) {}
+  KOKKOS_INLINE_FUNCTION
+  TeamThreadRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                  const iType& begin_, const iType& end_)
+      : start(begin_), end(end_), increment(1), thread(thread_) {}
 #endif
-  };
+};
+
+template <typename iType>
+struct ThreadVectorRangeBoundariesStruct<iType, ROCmTeamMember> {
+  typedef iType index_type;
+  const index_type start;
+  const index_type end;
+  const index_type increment;
+  const ROCmTeamMember& thread;
+
+#if defined(__HCC_ACCELERATOR__)
+  KOKKOS_INLINE_FUNCTION
+  ThreadVectorRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                    const index_type& count)
+      : start(thread_.lindex() % thread_.vector_length()),
+        end(count),
+        increment(thread_.vector_length()),
+        thread(thread_) {}
 
-  template<typename iType>
-  struct ThreadVectorRangeBoundariesStruct<iType,ROCmTeamMember> {
-    typedef iType index_type;
-    const index_type start;
-    const index_type end;
-    const index_type increment;
-    const ROCmTeamMember& thread;
-
-#if defined( __HCC_ACCELERATOR__ )
-    KOKKOS_INLINE_FUNCTION
-    ThreadVectorRangeBoundariesStruct (const ROCmTeamMember& thread_, const index_type& count):
-      start( thread_.lindex()%thread_.vector_length() ),
-      end( count ),
-      increment( thread_.vector_length() ),
-      thread(thread_)
-    {}
-
-    KOKKOS_INLINE_FUNCTION
-    ThreadVectorRangeBoundariesStruct (const ROCmTeamMember& thread_, const index_type& arg_begin, const index_type& arg_end):
-      start( arg_begin + thread_.lindex()%thread_.vector_length() ),
-      end( arg_end ),
-      increment( thread_.vector_length() ),
-      thread(thread_)
-    {}
+  KOKKOS_INLINE_FUNCTION
+  ThreadVectorRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                    const index_type& arg_begin,
+                                    const index_type& arg_end)
+      : start(arg_begin + thread_.lindex() % thread_.vector_length()),
+        end(arg_end),
+        increment(thread_.vector_length()),
+        thread(thread_) {}
 
 //    KOKKOS_INLINE_FUNCTION
 //    ThreadVectorRangeBoundariesStruct (const index_type& count):
@@ -1471,319 +1406,362 @@ namespace Impl {
 //      increment( 1 )
 //    {}
 #else
-    KOKKOS_INLINE_FUNCTION
-    ThreadVectorRangeBoundariesStruct (const ROCmTeamMember& thread_, const index_type& count):
-      start( static_cast<index_type>(0) ),
-      end( count ),
-      increment( static_cast<index_type>(1) ),
-      thread(thread_)
-    {}
-    KOKKOS_INLINE_FUNCTION
-    ThreadVectorRangeBoundariesStruct (const index_type& count):
-      start( static_cast<index_type>(0) ),
-      end( count ),
-      increment( static_cast<index_type>(1) )
-    {}
-
-    KOKKOS_INLINE_FUNCTION
-    ThreadVectorRangeBoundariesStruct (const ROCmTeamMember& thread_, const index_type& arg_begin, const index_type& arg_end):
-      start( arg_begin ),
-      end( arg_end ),
-      increment( static_cast<index_type>(1) ),
-      thread(thread_)
-    {}
-    KOKKOS_INLINE_FUNCTION
-    ThreadVectorRangeBoundariesStruct (const index_type& arg_begin, const index_type& arg_end):
-      start( arg_begin ),
-      end( arg_end ),
-      increment( static_cast<index_type>(1) )
-    {}
+  KOKKOS_INLINE_FUNCTION
+  ThreadVectorRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                    const index_type& count)
+      : start(static_cast<index_type>(0)),
+        end(count),
+        increment(static_cast<index_type>(1)),
+        thread(thread_) {}
+  KOKKOS_INLINE_FUNCTION
+  ThreadVectorRangeBoundariesStruct(const index_type& count)
+      : start(static_cast<index_type>(0)),
+        end(count),
+        increment(static_cast<index_type>(1)) {}
+
+  KOKKOS_INLINE_FUNCTION
+  ThreadVectorRangeBoundariesStruct(const ROCmTeamMember& thread_,
+                                    const index_type& arg_begin,
+                                    const index_type& arg_end)
+      : start(arg_begin),
+        end(arg_end),
+        increment(static_cast<index_type>(1)),
+        thread(thread_) {}
+  KOKKOS_INLINE_FUNCTION
+  ThreadVectorRangeBoundariesStruct(const index_type& arg_begin,
+                                    const index_type& arg_end)
+      : start(arg_begin), end(arg_end), increment(static_cast<index_type>(1)) {}
 #endif
-  };
+};
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ROCmTeamMember>
-  TeamThreadRange(const Impl::ROCmTeamMember& thread, iType count) {
-  return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ROCmTeamMember>(thread,count);
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::ROCmTeamMember>
+    TeamThreadRange(const Impl::ROCmTeamMember& thread, iType count) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::ROCmTeamMember>(
+      thread, count);
 }
 
-template<typename iType1,typename iType2>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<typename std::common_type< iType1, iType2 >::type,Impl::ROCmTeamMember>
-  TeamThreadRange(const Impl::ROCmTeamMember& thread, iType1 begin, iType2 end) {
-  typedef typename std::common_type< iType1, iType2 >::type iType;
-  return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ROCmTeamMember>(thread,begin,end);
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type, Impl::ROCmTeamMember>
+TeamThreadRange(const Impl::ROCmTeamMember& thread, iType1 begin, iType2 end) {
+  typedef typename std::common_type<iType1, iType2>::type iType;
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::ROCmTeamMember>(
+      thread, begin, end);
 }
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >
-  ThreadVectorRange(const Impl::ROCmTeamMember& thread, iType count) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >(thread,count);
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>
+    ThreadVectorRange(const Impl::ROCmTeamMember& thread, iType count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>(
+      thread, count);
 }
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >
-  ThreadVectorRange(const Impl::ROCmTeamMember& thread, iType arg_begin, iType arg_end) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >(thread,arg_begin,arg_end);
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>
+    ThreadVectorRange(const Impl::ROCmTeamMember& thread, iType arg_begin,
+                      iType arg_end) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>(
+      thread, arg_begin, arg_end);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::ROCmTeamMember> PerTeam(const Impl::ROCmTeamMember& thread) {
+Impl::ThreadSingleStruct<Impl::ROCmTeamMember> PerTeam(
+    const Impl::ROCmTeamMember& thread) {
   return Impl::ThreadSingleStruct<Impl::ROCmTeamMember>(thread);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::ROCmTeamMember> PerThread(const Impl::ROCmTeamMember& thread) {
+Impl::VectorSingleStruct<Impl::ROCmTeamMember> PerThread(
+    const Impl::ROCmTeamMember& thread) {
   return Impl::VectorSingleStruct<Impl::ROCmTeamMember>(thread);
 }
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::ROCmTeamMember>& single_struct, const FunctorType& lambda) {
-  if(single_struct.team_member.vector_rank()==0) lambda();
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::ROCmTeamMember>& single_struct,
+    const FunctorType& lambda) {
+  if (single_struct.team_member.vector_rank() == 0) lambda();
 }
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::ROCmTeamMember>& single_struct, const FunctorType& lambda) {
-  if((single_struct.team_member.lindex()==0)) lambda();
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::ROCmTeamMember>& single_struct,
+    const FunctorType& lambda) {
+  if ((single_struct.team_member.lindex() == 0)) lambda();
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::ROCmTeamMember>& single_struct, const FunctorType& lambda, ValueType& val) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::ROCmTeamMember>& single_struct,
+    const FunctorType& lambda, ValueType& val) {
 #if defined(ROCM15)
   // 1.5 needs this more proper restriction on which work units run
-  if( single_struct.team_member.vector_rank()==0) lambda(val);
-  val = shfl(val,0,single_struct.team_member.vector_length());
+  if (single_struct.team_member.vector_rank() == 0) lambda(val);
+  val = shfl(val, 0, single_struct.team_member.vector_length());
 #else
-  // but older compilers are fine with this (TestTeamVector::Test< Kokkos::Experimental::ROCm >(4))
+  // but older compilers are fine with this (TestTeamVector::Test<
+  // Kokkos::Experimental::ROCm >(4))
   lambda(val);
 #endif
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::ROCmTeamMember>& single_struct, const FunctorType& lambda, ValueType& val) {
-  if(single_struct.team_member.lindex()==0) lambda(val);
-  single_struct.team_member.team_broadcast(val,0);
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::ROCmTeamMember>& single_struct,
+    const FunctorType& lambda, ValueType& val) {
+  if (single_struct.team_member.lindex() == 0) lambda(val);
+  single_struct.team_member.team_broadcast(val, 0);
 }
 
-}
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-  /** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each i=0..N-1.
-   *
-   * The range i=0..N-1 is mapped to all threads of the the calling thread team.
-   * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ROCmTeamMember>& loop_boundaries, const Lambda& lambda) {
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team.
+ * This functionality requires C++11 support.*/
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::ROCmTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Inter-thread thread range parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Inter-thread thread range parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< ! Kokkos::is_reducer< ValueType >::value >::type
-parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ROCmTeamMember>& loop_boundaries,
-                     const Lambda & lambda, ValueType& result) {
-
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                        iType, Impl::ROCmTeamMember>& loop_boundaries,
+                    const Lambda& lambda, ValueType& result) {
   Kokkos::Sum<ValueType> reducer(result);
-  reducer.init( reducer.reference() );
+  reducer.init(reducer.reference());
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,reducer.reference());
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
   }
   loop_boundaries.thread.team_reduce(reducer);
 }
 
-/** \brief  Inter-thread thread range parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Inter-thread thread range parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ReducerType >
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ReducerType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< Kokkos::is_reducer< ReducerType >::value >::type
-parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ROCmTeamMember>& loop_boundaries,
-                     const Lambda & lambda, ReducerType const & reducer) {
-  reducer.init( reducer.reference() );
-
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,reducer.reference());
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                        iType, Impl::ROCmTeamMember>& loop_boundaries,
+                    const Lambda& lambda, ReducerType const& reducer) {
+  reducer.init(reducer.reference());
+
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
   }
   loop_boundaries.thread.team_reduce(reducer);
 }
 
-/** \brief  Intra-thread thread range parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread thread range parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a reduction of
- * val is performed using JoinType(ValueType& val, const ValueType& update) and put into init_result.
- * The input value of init_result is used as initializer for temporary variables of ValueType. Therefore
- * the input value should be the neutral element with respect to the join operation (e.g. '0 for +-' or
- * '1 for *'). This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ROCmTeamMember>& loop_boundaries,
-                     const Lambda & lambda, const JoinType& join, ValueType& result) {
-
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *'). This functionality requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::ROCmTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& result) {
 #if defined(ROCM15)
   ValueType tmp = result;
   //  Simpler code works with ROCM1.5
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,tmp);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, tmp);
   }
-  result = loop_boundaries.thread.team_reduce(tmp,join);
+  result = loop_boundaries.thread.team_reduce(tmp, join);
 #else
   // this workaround freezes up with ROCM1.5, but needed for earlier compilers
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    join(result,tmp);
+    lambda(i, tmp);
+    join(result, tmp);
   }
-  result = loop_boundaries.thread.team_reduce(result,join);
+  result = loop_boundaries.thread.team_reduce(result, join);
 #endif
-//  Impl::rocm_intra_workgroup_reduction( loop_boundaries.thread, result,join);
-//  Impl::rocm_inter_workgroup_reduction( loop_boundaries.thread, result,join);
+  //  Impl::rocm_intra_workgroup_reduction( loop_boundaries.thread,
+  //  result,join); Impl::rocm_inter_workgroup_reduction(
+  //  loop_boundaries.thread, result,join);
 }
 
-} //namespace Kokkos
-
+}  // namespace Kokkos
 
 namespace Kokkos {
-/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
  * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >&
-    loop_boundaries, const Lambda& lambda) {
-
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< !Kokkos::is_reducer< ValueType >::value >::type 
-parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >&
-      loop_boundaries, const Lambda & lambda, ValueType& result) {
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                        iType, Impl::ROCmTeamMember>& loop_boundaries,
+                    const Lambda& lambda, ValueType& result) {
   result = ValueType();
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    result+=tmp;
+    lambda(i, tmp);
+    result += tmp;
   }
-  result = loop_boundaries.thread.thread_reduce(result,Impl::JoinAdd<ValueType>());
+  result =
+      loop_boundaries.thread.thread_reduce(result, Impl::JoinAdd<ValueType>());
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a reduction of
- * val is performed using JoinType(ValueType& val, const ValueType& update) and put into init_result.
- * The input value of init_result is used as initializer for temporary variables of ValueType. Therefore
- * the input value should be the neutral element with respect to the join operation (e.g. '0 for +-' or
- * '1 for *'). This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >&
-      loop_boundaries, const Lambda & lambda, const JoinType& join, ValueType& result) {
-
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);  
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *'). This functionality requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& result) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
     loop_boundaries.thread.team_barrier();
   }
-  result = loop_boundaries.thread.thread_reduce(result,join);
+  result = loop_boundaries.thread.thread_reduce(result, join);
 }
 
-
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ReducerType >
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ReducerType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< Kokkos::is_reducer< ReducerType >::value >::type
-parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >&
-      loop_boundaries, const Lambda & lambda, ReducerType const & reducer) {
-  reducer.init( reducer.reference() );
-
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,reducer.reference());
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                        iType, Impl::ROCmTeamMember>& loop_boundaries,
+                    const Lambda& lambda, ReducerType const& reducer) {
+  reducer.init(reducer.reference());
+
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
   }
   loop_boundaries.thread.vector_reduce(reducer);
 }
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a reduction of
- * val is performed using JoinType(ValueType& val, const ValueType& update) and put into init_result.
- * The input value of init_result is used as initializer for temporary variables of ValueType. Therefore
- * the input value should be the neutral element with respect to the join operation (e.g. '0 for +-' or
- * '1 for *'). This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ReducerType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >&
-      loop_boundaries, const Lambda & lambda, const JoinType& join, ReducerType const & reducer) {
-
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,reducer.reference());  
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *'). This functionality requires C++11 support.*/
+template <typename iType, class Lambda, typename ReducerType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ReducerType const& reducer) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
     loop_boundaries.thread.team_barrier();
   }
-  reducer.reference() = loop_boundaries.thread.thread_reduce(reducer.reference(),join);
+  reducer.reference() =
+      loop_boundaries.thread.thread_reduce(reducer.reference(), join);
 }
 
-/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes lambda(iType i, ValueType & val, bool final)
- *          for each i=0..N-1.
+/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
+ * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan operation is performed.
- * Depending on the target execution space the operator might be called twice: once with final=false
- * and once with final=true. When final==true val contains the prefix sum value. The contribution of this
- * "i" needs to be added to val no matter whether final==true or not. In a serial execution
- * (i.e. team_size==1) the operator is only called once with final==true. Scan_val will be set
- * to the final sum value over all vector lanes.
- * This functionality requires C++11 support.*/
-template< typename iType, class FunctorType >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROCmTeamMember >&
-      loop_boundaries, const FunctorType & lambda) {
-
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
-  typedef typename ValueTraits::value_type value_type ;
-
-  value_type val = value_type();
+ * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
+ * operation is performed. Depending on the target execution space the operator
+ * might be called twice: once with final=false and once with final=true. When
+ * final==true val contains the prefix sum value. The contribution of this "i"
+ * needs to be added to val no matter whether final==true or not. In a serial
+ * execution (i.e. team_size==1) the operator is only called once with
+ * final==true. Scan_val will be set to the final sum value over all vector
+ * lanes. This functionality requires C++11 support.*/
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ROCmTeamMember>&
+        loop_boundaries,
+    const FunctorType& lambda) {
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename ValueTraits::value_type value_type;
+
+  value_type val          = value_type();
   const int vector_length = loop_boundaries.thread.vector_length();
-  const int vector_rank = loop_boundaries.thread.vector_rank();
+  const int vector_rank   = loop_boundaries.thread.vector_rank();
 
-  iType end = ((loop_boundaries.end+vector_length-1)/vector_length) * vector_length;
+  iType end = ((loop_boundaries.end + vector_length - 1) / vector_length) *
+              vector_length;
   value_type accum = value_type();
 
-  for ( int i = vector_rank ; i < end ; i += vector_length ) {
-
-    value_type val = 0 ;
+  for (int i = vector_rank; i < end; i += vector_length) {
+    value_type val = 0;
 
     // First acquire per-lane contributions:
-    if ( i < loop_boundaries.end ) lambda( i , val , false );
+    if (i < loop_boundaries.end) lambda(i, val, false);
 
-    value_type sval = val ;
+    value_type sval = val;
 
     // Bottom up inclusive scan in triangular pattern
     // where each thread is the root of a reduction tree
@@ -1793,23 +1771,24 @@ void parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ROC
     //  [t] += [t-4] if t >= 4
     //  ...
 
-    for ( int j = 1 ; j < vector_length ; j <<= 1 ) {
-      value_type tmp = 0 ;
-      tmp = shfl_up(sval , j , vector_length );
-      if ( j <= vector_rank ) { sval += tmp ; }
+    for (int j = 1; j < vector_length; j <<= 1) {
+      value_type tmp = 0;
+      tmp            = shfl_up(sval, j, vector_length);
+      if (j <= vector_rank) {
+        sval += tmp;
+      }
     }
 
     // Include accumulation and remove value for exclusive scan:
-    val = accum + sval - val ;
+    val = accum + sval - val;
 
     // Provide exclusive scan value:
-    if ( i < loop_boundaries.end ) lambda( i , val , true );
+    if (i < loop_boundaries.end) lambda(i, val, true);
 
     // Accumulate the last value in the inclusive scan:
-    sval = shfl( sval , vector_length-1 , vector_length);
-    accum += sval ;
+    sval = shfl(sval, vector_length - 1, vector_length);
+    accum += sval;
   }
 }
 
-} // namespace Kokkos
-
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Reduce.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Reduce.hpp
index 0321f3d53f733a34ff082785f1aa01fc6ce1cd14..59a6a0433c0427e0f8ea28d24924e877278b3dfa 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Reduce.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Reduce.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 // AMP REDUCE
 //////////////////////////////////////////////////////////////////////////////
 
-#if !defined( KOKKOS_ROCM_AMP_REDUCE_INL )
+#if !defined(KOKKOS_ROCM_AMP_REDUCE_INL)
 #define KOKKOS_ROCM_AMP_REDUCE_INL
 
 #include <iostream>
@@ -62,127 +63,122 @@
 namespace Kokkos {
 namespace Impl {
 
-template<class T>
-T* reduce_value(T* x, std::true_type) [[hc]]
-{
+template <class T>
+T* reduce_value(T* x, std::true_type) [[hc]] {
   return x;
 }
 
-template<class T>
-T& reduce_value(T* x, std::false_type) [[hc]]
-{
+template <class T>
+T& reduce_value(T* x, std::false_type) [[hc]] {
   return *x;
 }
 
 #ifdef KOKKOS_IMPL_ROCM_CLANG_WORKAROUND
-struct always_true
-{
-    template<class... Ts>
-    bool operator()(Ts&&...) const
-    {
-        return true;
-    }
+struct always_true {
+  template <class... Ts>
+  bool operator()(Ts&&...) const {
+    return true;
+  }
 };
 #endif
 
-template< class Tag, class F, class ReducerType, class Invoker, class T >
-void reduce_enqueue(
-  const int szElements,  // size of the extent
-  const F & f,
-  const ReducerType& reducer,
-  Invoker invoke,
-  T * const output_result,
-  int const output_length,
-  const int team_size=64,
-  const int vector_size=1,
-  int const shared_size=0)
-{
-  using namespace hc ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, F, ReducerType> ReducerConditional;
+template <class Tag, class F, class ReducerType, class Invoker, class T>
+void reduce_enqueue(const int szElements,  // size of the extent
+                    const F& f, const ReducerType& reducer, Invoker invoke,
+                    T* const output_result, int const output_length,
+                    const int team_size = 64, const int vector_size = 1,
+                    int const shared_size = 0) {
+  using namespace hc;
+
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value, F,
+                             ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType, ReducerType>::value, Tag, void >::type TagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  Tag, void>::type TagFwd;
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , TagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit< ReducerTypeFwd , TagFwd >   ValueInit ;
-  typedef Kokkos::Impl::FunctorValueJoin< ReducerTypeFwd , TagFwd >   ValueJoin ;
-  typedef Kokkos::Impl::FunctorFinal< ReducerTypeFwd , TagFwd >       ValueFinal ;
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, TagFwd> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, TagFwd> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<ReducerTypeFwd, TagFwd> ValueJoin;
+  typedef Kokkos::Impl::FunctorFinal<ReducerTypeFwd, TagFwd> ValueFinal;
 
-  typedef typename ValueTraits::pointer_type   pointer_type ;
-  typedef typename ValueTraits::reference_type reference_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
   if (output_length < 1) return;
 
-  const auto td = get_tile_desc<T>(szElements,output_length,team_size,vector_size, shared_size);
+  const auto td = get_tile_desc<T>(szElements, output_length, team_size,
+                                   vector_size, shared_size);
 
   // allocate host and device memory for the results from each team
-  std::vector<T> result_cpu(td.num_tiles*output_length);
-  hc::array<T> result(td.num_tiles*output_length);
+  std::vector<T> result_cpu(td.num_tiles * output_length);
+  hc::array<T> result(td.num_tiles * output_length);
 
-  auto fut = tile_for<T[]>(td, [=,&result](hc::tiled_index<1> t_idx, tile_buffer<T[]> buffer) [[hc]] 
-  {
-      const auto local = t_idx.local[0];
-      const auto global = t_idx.global[0];
-      const auto tile = t_idx.tile[0];
+  auto fut = tile_for<T[]>(
+      td,
+      [ =, &result ](hc::tiled_index<1> t_idx, tile_buffer<T[]> buffer) [[hc]] {
+        const auto local  = t_idx.local[0];
+        const auto global = t_idx.global[0];
+        const auto tile   = t_idx.tile[0];
 
-      buffer.action_at(local, [&](T* state)
-      {
+        buffer.action_at(local, [&](T* state) {
           ValueInit::init(ReducerConditional::select(f, reducer), state);
-          invoke(make_rocm_invoke_fn<Tag>(f), t_idx, td, reduce_value(state, std::is_pointer<reference_type>()));
-      });
-      t_idx.barrier.wait();
+          invoke(make_rocm_invoke_fn<Tag>(f), t_idx, td,
+                 reduce_value(state, std::is_pointer<reference_type>()));
+        });
+        t_idx.barrier.wait();
 
-      for(std::size_t s = 1; s < buffer.size(); s *= 2)
-      {
+        for (std::size_t s = 1; s < buffer.size(); s *= 2) {
           const std::size_t index = 2 * s * local;
-          if (index < buffer.size())
-          {
-              buffer.action_at(index, index + s, [&](T* x, T* y)
-              {
-                  ValueJoin::join(ReducerConditional::select(f, reducer), x, y);
-              });
+          if (index < buffer.size()) {
+            buffer.action_at(index, index + s, [&](T* x, T* y) {
+              ValueJoin::join(ReducerConditional::select(f, reducer), x, y);
+            });
           }
           t_idx.barrier.wait();
-      }
+        }
 
-      // Store the tile result in the global memory.
-      if (local == 0)
-      {
+        // Store the tile result in the global memory.
+        if (local == 0) {
 #ifdef KOKKOS_IMPL_ROCM_CLANG_WORKAROUND
           // Workaround for assigning from LDS memory: std::copy should work
           // directly
-          buffer.action_at(0, [&](T* x)
-          {
+          buffer.action_at(0, [&](T* x) {
 #if ROCM15
-// new ROCM 15 address space changes aren't implemented in std algorithms yet
-              auto * src = reinterpret_cast<char *>(x);
-              auto * dest = reinterpret_cast<char *>(result.data()+tile*output_length);
-              for(int i=0; i<sizeof(T)*output_length;i++) dest[i] = src[i];
+            // new ROCM 15 address space changes aren't implemented in std
+            // algorithms yet
+            auto* src = reinterpret_cast<char*>(x);
+            auto* dest =
+                reinterpret_cast<char*>(result.data() + tile * output_length);
+            for (int i = 0; i < sizeof(T) * output_length; i++)
+              dest[i] = src[i];
 #else
               // Workaround: copy_if used to avoid memmove
               std::copy_if(x, x+output_length, result.data()+tile*output_length, always_true{} );
 #endif
           });
 #else
-          std::copy(buffer, buffer+output_length, result.data()+tile*output_length);
+          std::copy(buffer, buffer + output_length,
+                    result.data() + tile * output_length);
 
 #endif
-      }
-  });
+        }
+      });
   if (output_result != nullptr)
-     ValueInit::init(ReducerConditional::select(f, reducer), output_result);
+    ValueInit::init(ReducerConditional::select(f, reducer), output_result);
   fut.wait();
-  copy(result,result_cpu.data());
+  copy(result, result_cpu.data());
   if (output_result != nullptr) {
-    for(std::size_t i=0;i<td.num_tiles;i++)
-       ValueJoin::join(ReducerConditional::select(f, reducer), output_result, result_cpu.data()+i*output_length);
+    for (std::size_t i = 0; i < td.num_tiles; i++)
+      ValueJoin::join(ReducerConditional::select(f, reducer), output_result,
+                      result_cpu.data() + i * output_length);
 
-    ValueFinal::final( ReducerConditional::select(f, reducer) , output_result );
+    ValueFinal::final(ReducerConditional::select(f, reducer), output_result);
   }
-
 }
 
-}} //end of namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #if !defined( KOKKOS_ROCM_AMP_REDUCE_INL ) */
-
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ReduceScan.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ReduceScan.hpp
index 33efa0d6f057c94601b85144b0d7709f40e02d9f..29694a012ce9a2197993683b1f64bca5f33b142b 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ReduceScan.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ReduceScan.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -47,7 +48,7 @@
 #include <Kokkos_Macros.hpp>
 
 /* only compile this file if ROCM is enabled for Kokkos */
-#if defined( __HCC__ ) && defined( KOKKOS_ENABLE_ROCM )
+#if defined(__HCC__) && defined(KOKKOS_ENABLE_ROCM)
 
 //#include <utility>
 
@@ -64,149 +65,138 @@ namespace Impl {
 
 //#if __KALMAR_ACCELERATOR__ == 1
 KOKKOS_INLINE_FUNCTION
-void __syncthreads() [[hc]]
-{
-   amp_barrier(CLK_LOCAL_MEM_FENCE);
-}
-
-#define LT0 ((threadIdx_x+threadIdx_y+threadIdx_z)?0:1)
+void __syncthreads() [[hc]] { amp_barrier(CLK_LOCAL_MEM_FENCE); }
 
+#define LT0 ((threadIdx_x + threadIdx_y + threadIdx_z) ? 0 : 1)
 
 // returns non-zero if and only if predicate is non-zero for all threads
 // note that syncthreads_or uses the first 64 bits of dynamic group memory.
-// this reserved memory must be accounted for everwhere 
+// this reserved memory must be accounted for everwhere
 // that get_dynamic_group_segment_base_pointer is called.
 KOKKOS_INLINE_FUNCTION
-uint64_t __syncthreads_or(uint64_t  pred) 
-{
-  uint64_t *shared_var = (uint64_t *)hc::get_dynamic_group_segment_base_pointer();
-  if(LT0) *shared_var = 0;
+uint64_t __syncthreads_or(uint64_t pred) {
+  uint64_t *shared_var =
+      (uint64_t *)hc::get_dynamic_group_segment_base_pointer();
+  if (LT0) *shared_var = 0;
   amp_barrier(CLK_LOCAL_MEM_FENCE);
 #if __KALMAR_ACCELERATOR__ == 1
-  if (pred) hc::atomic_or_uint64(shared_var,1);
+  if (pred) hc::atomic_or_uint64(shared_var, 1);
 #endif
   amp_barrier(CLK_LOCAL_MEM_FENCE);
   return (*shared_var);
 }
 
 KOKKOS_INLINE_FUNCTION
-void __threadfence() 
-{
-   amp_barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE);
+void __threadfence() {
+  amp_barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE);
 }
 
 KOKKOS_INLINE_FUNCTION
-void __threadfence_block() 
-{
-   amp_barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE);
+void __threadfence_block() {
+  amp_barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE);
 }
 //#endif
 struct ROCm_atomic_CAS {
-    template<class OP>
-    KOKKOS_INLINE_FUNCTION
-    unsigned long operator () (volatile unsigned long * dest, OP &&op){
-       unsigned long read,compare,val;
-       compare = *dest;
-       read = compare;
-       do {
-         compare = read;
-         val = op(compare);
+  template <class OP>
+  KOKKOS_INLINE_FUNCTION unsigned long operator()(volatile unsigned long *dest,
+                                                  OP &&op) {
+    unsigned long read, compare, val;
+    compare = *dest;
+    read    = compare;
+    do {
+      compare = read;
+      val     = op(compare);
 #if __KALMAR_ACCELERATOR__ == 1
-         hc::atomic_compare_exchange((uint64_t *)dest,&read,val);
+      hc::atomic_compare_exchange((uint64_t *)dest, &read, val);
 #endif
-       } while (read != compare);
-       return val;
-    }
-};
-
-  template<class OP>
-  KOKKOS_INLINE_FUNCTION
-  unsigned long atomic_cas_op (volatile unsigned long * dest, OP &&op) {
-    ROCm_atomic_CAS cas_op;
-    return cas_op(dest, std::forward<OP>(op));
+    } while (read != compare);
+    return val;
   }
+};
 
-  KOKKOS_INLINE_FUNCTION
-  unsigned long atomicInc (volatile unsigned long * dest, const unsigned long& val) {
-    return atomic_cas_op(dest, [=](unsigned long old){return ((old>=val)?0:(old+1));});
-  }
+template <class OP>
+KOKKOS_INLINE_FUNCTION unsigned long atomic_cas_op(volatile unsigned long *dest,
+                                                   OP &&op) {
+  ROCm_atomic_CAS cas_op;
+  return cas_op(dest, std::forward<OP>(op));
+}
 
+KOKKOS_INLINE_FUNCTION
+unsigned long atomicInc(volatile unsigned long *dest,
+                        const unsigned long &val) {
+  return atomic_cas_op(
+      dest, [=](unsigned long old) { return ((old >= val) ? 0 : (old + 1)); });
+}
 
 //----------------------------------------------------------------------------
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-void rocm_shfl( T & out , T const & in , int lane ,
-  typename std::enable_if< sizeof(int) == sizeof(T) , int >::type width )
-{
-  *reinterpret_cast<int*>(&out) =
-    __shfl( *reinterpret_cast<int const *>(&in) , lane , width );
+template <typename T>
+KOKKOS_INLINE_FUNCTION void rocm_shfl(
+    T &out, T const &in, int lane,
+    typename std::enable_if<sizeof(int) == sizeof(T), int>::type width) {
+  *reinterpret_cast<int *>(&out) =
+      __shfl(*reinterpret_cast<int const *>(&in), lane, width);
 }
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-void rocm_shfl( T & out , T const & in , int lane ,
-  typename std::enable_if
-    < ( sizeof(int) < sizeof(T) ) && ( 0 == ( sizeof(T) % sizeof(int) ) )
-    , int >::type width )
-{
+template <typename T>
+KOKKOS_INLINE_FUNCTION void rocm_shfl(
+    T &out, T const &in, int lane,
+    typename std::enable_if<(sizeof(int) < sizeof(T)) &&
+                                (0 == (sizeof(T) % sizeof(int))),
+                            int>::type width) {
   enum : int { N = sizeof(T) / sizeof(int) };
 
-  for ( int i = 0 ; i < N ; ++i ) {
-    reinterpret_cast<int*>(&out)[i] =
-      __shfl( reinterpret_cast<int const *>(&in)[i] , lane , width );
+  for (int i = 0; i < N; ++i) {
+    reinterpret_cast<int *>(&out)[i] =
+        __shfl(reinterpret_cast<int const *>(&in)[i], lane, width);
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-void rocm_shfl_down( T & out , T const & in , int delta ,
-  typename std::enable_if< sizeof(int) == sizeof(T) , int >::type width )
-{
-  *reinterpret_cast<int*>(&out) =
-    __shfl_down( *reinterpret_cast<int const *>(&in) , delta , width );
+template <typename T>
+KOKKOS_INLINE_FUNCTION void rocm_shfl_down(
+    T &out, T const &in, int delta,
+    typename std::enable_if<sizeof(int) == sizeof(T), int>::type width) {
+  *reinterpret_cast<int *>(&out) =
+      __shfl_down(*reinterpret_cast<int const *>(&in), delta, width);
 }
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-void rocm_shfl_down( T & out , T const & in , int delta ,
-  typename std::enable_if
-    < ( sizeof(int) < sizeof(T) ) && ( 0 == ( sizeof(T) % sizeof(int) ) )
-    , int >::type width )
-{
+template <typename T>
+KOKKOS_INLINE_FUNCTION void rocm_shfl_down(
+    T &out, T const &in, int delta,
+    typename std::enable_if<(sizeof(int) < sizeof(T)) &&
+                                (0 == (sizeof(T) % sizeof(int))),
+                            int>::type width) {
   enum : int { N = sizeof(T) / sizeof(int) };
 
-  for ( int i = 0 ; i < N ; ++i ) {
-    reinterpret_cast<int*>(&out)[i] =
-      __shfl_down( reinterpret_cast<int const *>(&in)[i] , delta , width );
+  for (int i = 0; i < N; ++i) {
+    reinterpret_cast<int *>(&out)[i] =
+        __shfl_down(reinterpret_cast<int const *>(&in)[i], delta, width);
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-void rocm_shfl_up( T & out , T const & in , int delta ,
-  typename std::enable_if< sizeof(int) == sizeof(T) , int >::type width )
-{
-  *reinterpret_cast<int*>(&out) =
-    __shfl_up( *reinterpret_cast<int const *>(&in) , delta , width );
+template <typename T>
+KOKKOS_INLINE_FUNCTION void rocm_shfl_up(
+    T &out, T const &in, int delta,
+    typename std::enable_if<sizeof(int) == sizeof(T), int>::type width) {
+  *reinterpret_cast<int *>(&out) =
+      __shfl_up(*reinterpret_cast<int const *>(&in), delta, width);
 }
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-void rocm_shfl_up( T & out , T const & in , int delta ,
-  typename std::enable_if
-    < ( sizeof(int) < sizeof(T) ) && ( 0 == ( sizeof(T) % sizeof(int) ) )
-    , int >::type width )
-{
+template <typename T>
+KOKKOS_INLINE_FUNCTION void rocm_shfl_up(
+    T &out, T const &in, int delta,
+    typename std::enable_if<(sizeof(int) < sizeof(T)) &&
+                                (0 == (sizeof(T) % sizeof(int))),
+                            int>::type width) {
   enum : int { N = sizeof(T) / sizeof(int) };
 
-  for ( int i = 0 ; i < N ; ++i ) {
-    reinterpret_cast<int*>(&out)[i] =
-      __shfl_up( reinterpret_cast<int const *>(&in)[i] , delta , width );
+  for (int i = 0; i < N; ++i) {
+    reinterpret_cast<int *>(&out)[i] =
+        __shfl_up(reinterpret_cast<int const *>(&in)[i], delta, width);
   }
 }
 #if 0
@@ -290,58 +280,51 @@ void rocm_intra_workgroup_vector_inclusive_scan( ValueType & local )
  *   (c) blockDim.z == 1
  */
 
-template< class ValueType , class JoinOp>
-KOKKOS_INLINE_FUNCTION
-void rocm_intra_workgroup_reduction( const ROCmTeamMember& team, 
-                                       ValueType& result,
-                                       const JoinOp& join) {
-
-  unsigned int shift = 1;
+template <class ValueType, class JoinOp>
+KOKKOS_INLINE_FUNCTION void rocm_intra_workgroup_reduction(
+    const ROCmTeamMember &team, ValueType &result, const JoinOp &join) {
+  unsigned int shift    = 1;
   int max_active_thread = team.team_size();
 
-  //Reduce over values from threads with different team.team_rank()
-  while(team.vector_length() * shift < 32 ) {
-    const ValueType tmp = shfl_down(result, team.vector_length()*shift,32u);
-    //Only join if upper thread is active (this allows non power of two for team.team_size()
-    if(team.team_rank() + shift < max_active_thread)
-      join(result , tmp);
-    shift*=2;
+  // Reduce over values from threads with different team.team_rank()
+  while (team.vector_length() * shift < 32) {
+    const ValueType tmp = shfl_down(result, team.vector_length() * shift, 32u);
+    // Only join if upper thread is active (this allows non power of two for
+    // team.team_size()
+    if (team.team_rank() + shift < max_active_thread) join(result, tmp);
+    shift *= 2;
   }
 
-  result = shfl(result,0,32);
+  result = shfl(result, 0, 32);
 }
 
-template< class ValueType , class JoinOp>
-KOKKOS_INLINE_FUNCTION
-void rocm_inter_workgroup_reduction( const ROCmTeamMember& team,
-                                       ValueType& value,
-                                       const JoinOp& join) {
+template <class ValueType, class JoinOp>
+KOKKOS_INLINE_FUNCTION void rocm_inter_workgroup_reduction(
+    const ROCmTeamMember &team, ValueType &value, const JoinOp &join) {
+#define STEP_WIDTH 4
 
-  #define STEP_WIDTH 4
-  
   tile_static ValueType sh_result[256];
   int max_active_thread = team.team_size();
-  ValueType* result = (ValueType*) & sh_result;
-  const unsigned step = 256 / team.vector_length();
-  unsigned shift = STEP_WIDTH;
-  const int id = team.team_rank()%step==0?team.team_rank()/step:65000;
-  if(id < STEP_WIDTH ) {
+  ValueType *result     = (ValueType *)&sh_result;
+  const unsigned step   = 256 / team.vector_length();
+  unsigned shift        = STEP_WIDTH;
+  const int id = team.team_rank() % step == 0 ? team.team_rank() / step : 65000;
+  if (id < STEP_WIDTH) {
     result[id] = value;
   }
   team.team_barrier();
 
-  while (shift<=max_active_thread/step) {
-    if(shift<=id && shift+STEP_WIDTH>id && team.vector_rank()==0) {
-      join(result[id%STEP_WIDTH],value);
+  while (shift <= max_active_thread / step) {
+    if (shift <= id && shift + STEP_WIDTH > id && team.vector_rank() == 0) {
+      join(result[id % STEP_WIDTH], value);
     }
     team.team_barrier();
-    shift+=STEP_WIDTH;
+    shift += STEP_WIDTH;
   }
 
-
   value = result[0];
-  for(int i = 1; (i*step<max_active_thread) && i<STEP_WIDTH; i++)
-    join(value,result[i]);
+  for (int i = 1; (i * step < max_active_thread) && i < STEP_WIDTH; i++)
+    join(value, result[i]);
 }
 
 #if 0
@@ -454,55 +437,64 @@ bool rocm_inter_block_reduction( ROCmTeamMember& team,
  *   (c) team.vector_length() == blockDim.z == 1
  */
 
-template< bool DoScan , class FunctorType , class ArgTag >
-KOKKOS_INLINE_FUNCTION
-void rocm_intra_block_reduce_scan( const FunctorType & functor ,
-                                   const typename FunctorValueTraits< FunctorType , ArgTag >::pointer_type base_data )
-{
-  typedef FunctorValueTraits< FunctorType , ArgTag >  ValueTraits ;
-  typedef FunctorValueJoin<   FunctorType , ArgTag >  ValueJoin ;
+template <bool DoScan, class FunctorType, class ArgTag>
+KOKKOS_INLINE_FUNCTION void rocm_intra_block_reduce_scan(
+    const FunctorType &functor,
+    const typename FunctorValueTraits<FunctorType, ArgTag>::pointer_type
+        base_data) {
+  typedef FunctorValueTraits<FunctorType, ArgTag> ValueTraits;
+  typedef FunctorValueJoin<FunctorType, ArgTag> ValueJoin;
 
-  typedef typename ValueTraits::pointer_type  pointer_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
 
-  const unsigned value_count   = ValueTraits::value_count( functor );
-  const unsigned BlockSizeMask = blockDim_y  - 1 ;
+  const unsigned value_count   = ValueTraits::value_count(functor);
+  const unsigned BlockSizeMask = blockDim_y - 1;
 
   // Must have power of two thread count
 
-  if ( BlockSizeMask & blockDim_y ) { Kokkos::abort("ROCm::rocm_intra_block_scan requires power-of-two blockDim"); }
+  if (BlockSizeMask & blockDim_y) {
+    Kokkos::abort("ROCm::rocm_intra_block_scan requires power-of-two blockDim");
+  }
 
-#define BLOCK_REDUCE_STEP( R , TD , S )  \
-  if ( ! (( R & ((1<<(S+1))-1) )|(blockDim_y<(1<<(S+1)))) ) { ValueJoin::join( functor , TD , (TD - (value_count<<S)) ); }
+#define BLOCK_REDUCE_STEP(R, TD, S)                                    \
+  if (!((R & ((1 << (S + 1)) - 1)) | (blockDim_y < (1 << (S + 1))))) { \
+    ValueJoin::join(functor, TD, (TD - (value_count << S)));           \
+  }
 
-#define BLOCK_SCAN_STEP( TD , N , S )  \
-  if ( N == (1<<S) ) { ValueJoin::join( functor , TD , (TD - (value_count<<S))); }
+#define BLOCK_SCAN_STEP(TD, N, S)                            \
+  if (N == (1 << S)) {                                       \
+    ValueJoin::join(functor, TD, (TD - (value_count << S))); \
+  }
 #define KOKKOS_IMPL_ROCM_SYNCWF __threadfence_block()
 
-  const unsigned     rtid_intra = threadIdx_y ^ BlockSizeMask ;
-  const pointer_type tdata_intra = base_data + value_count * threadIdx_y ;
+  const unsigned rtid_intra      = threadIdx_y ^ BlockSizeMask;
+  const pointer_type tdata_intra = base_data + value_count * threadIdx_y;
 
-  { // Intra-workgroup reduction: min blocksize of 64
+  {  // Intra-workgroup reduction: min blocksize of 64
     KOKKOS_IMPL_ROCM_SYNCWF;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,0)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 0)
     KOKKOS_IMPL_ROCM_SYNCWF;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,1)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 1)
     KOKKOS_IMPL_ROCM_SYNCWF;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,2)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 2)
     KOKKOS_IMPL_ROCM_SYNCWF;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,3)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 3)
     KOKKOS_IMPL_ROCM_SYNCWF;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,4)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 4)
     KOKKOS_IMPL_ROCM_SYNCWF;
-    BLOCK_REDUCE_STEP(rtid_intra,tdata_intra,5)
+    BLOCK_REDUCE_STEP(rtid_intra, tdata_intra, 5)
     KOKKOS_IMPL_ROCM_SYNCWF;
   }
 
-  __syncthreads(); // Wait for all workgroups to reduce
+  __syncthreads();  // Wait for all workgroups to reduce
 
-  { // Inter-workgroup reduce-scan by a single workgroup to avoid extra synchronizations
-    if(threadIdx_y < value_count) {
-      for(int i=blockDim_y-65; i>0; i-= 64)
-        ValueJoin::join( functor , base_data + (blockDim_y-1)*value_count + threadIdx_y ,  base_data + i*value_count + threadIdx_y );
+  {  // Inter-workgroup reduce-scan by a single workgroup to avoid extra
+     // synchronizations
+    if (threadIdx_y < value_count) {
+      for (int i = blockDim_y - 65; i > 0; i -= 64)
+        ValueJoin::join(
+            functor, base_data + (blockDim_y - 1) * value_count + threadIdx_y,
+            base_data + i * value_count + threadIdx_y);
     }
     __syncthreads();
 #if 0
@@ -541,24 +533,29 @@ void rocm_intra_block_reduce_scan( const FunctorType & functor ,
 #endif
   }
 
-  __syncthreads(); // Wait for inter-workgroup reduce-scan to complete
-
-  if ( DoScan ) {
-    int n = ( rtid_intra &  1 ) ?  1 : (
-            ( rtid_intra &  2 ) ?  2 : (
-            ( rtid_intra &  4 ) ?  4 : (
-            ( rtid_intra &  8 ) ?  8 : (
-            ( rtid_intra & 16 ) ? 16 : (
-            ( rtid_intra & 32 ) ? 32 : 0 )))));
-
-    if ( ! ( rtid_intra + n < blockDim_y ) ) n = 0 ;
-
-//    BLOCK_SCAN_STEP(tdata_intra,n,5) __threadfence_block();
-//    BLOCK_SCAN_STEP(tdata_intra,n,4) __threadfence_block();
-    BLOCK_SCAN_STEP(tdata_intra,n,3) __threadfence_block();
-    BLOCK_SCAN_STEP(tdata_intra,n,2) __threadfence_block();
-    BLOCK_SCAN_STEP(tdata_intra,n,1) __threadfence_block();
-    BLOCK_SCAN_STEP(tdata_intra,n,0) __threadfence_block();
+  __syncthreads();  // Wait for inter-workgroup reduce-scan to complete
+
+  if (DoScan) {
+    int n = (rtid_intra & 1)
+                ? 1
+                : ((rtid_intra & 2)
+                       ? 2
+                       : ((rtid_intra & 4)
+                              ? 4
+                              : ((rtid_intra & 8)
+                                     ? 8
+                                     : ((rtid_intra & 16)
+                                            ? 16
+                                            : ((rtid_intra & 32) ? 32 : 0)))));
+
+    if (!(rtid_intra + n < blockDim_y)) n = 0;
+
+    //    BLOCK_SCAN_STEP(tdata_intra,n,5) __threadfence_block();
+    //    BLOCK_SCAN_STEP(tdata_intra,n,4) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 3) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 2) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 1) __threadfence_block();
+    BLOCK_SCAN_STEP(tdata_intra, n, 0) __threadfence_block();
   }
 
 #undef BLOCK_SCAN_STEP
@@ -574,104 +571,120 @@ void rocm_intra_block_reduce_scan( const FunctorType & functor ,
  *
  *  Global reduce result is in the last threads' 'shared_data' location.
  */
-using ROCM  = Kokkos::Experimental::ROCm ;
-
-template< bool DoScan , class FunctorType , class ArgTag >
-KOKKOS_INLINE_FUNCTION
-bool rocm_single_inter_block_reduce_scan( const FunctorType     & functor ,
-                                          const ROCM::size_type   block_id ,
-                                          const ROCM::size_type   block_count ,
-                                          typename FunctorValueTraits<FunctorType, ArgTag>::value_type * const shared_data ,
-                                          typename FunctorValueTraits<FunctorType, ArgTag>::value_type * const global_data ,
-                                          ROCM::size_type * const global_flags )
-{
-  typedef ROCM::size_type                  size_type ;
-  typedef FunctorValueTraits< FunctorType , ArgTag >  ValueTraits ;
-  typedef FunctorValueJoin<   FunctorType , ArgTag >  ValueJoin ;
-  typedef FunctorValueInit<   FunctorType , ArgTag >  ValueInit ;
-  typedef FunctorValueOps<    FunctorType , ArgTag >  ValueOps ;
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-  typedef typename ValueTraits::value_type      value_type ;
+using ROCM = Kokkos::Experimental::ROCm;
+
+template <bool DoScan, class FunctorType, class ArgTag>
+KOKKOS_INLINE_FUNCTION bool rocm_single_inter_block_reduce_scan(
+    const FunctorType &functor, const ROCM::size_type block_id,
+    const ROCM::size_type block_count,
+    typename FunctorValueTraits<FunctorType, ArgTag>::value_type
+        *const shared_data,
+    typename FunctorValueTraits<FunctorType, ArgTag>::value_type
+        *const global_data,
+    ROCM::size_type *const global_flags) {
+  typedef ROCM::size_type size_type;
+  typedef FunctorValueTraits<FunctorType, ArgTag> ValueTraits;
+  typedef FunctorValueJoin<FunctorType, ArgTag> ValueJoin;
+  typedef FunctorValueInit<FunctorType, ArgTag> ValueInit;
+  typedef FunctorValueOps<FunctorType, ArgTag> ValueOps;
+
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+  typedef typename ValueTraits::value_type value_type;
 
   // '__ffs' = position of the least significant bit set to 1.
   // blockDim_y is guaranteed to be a power of two so this
   // is the integral shift value that can replace an integral divide.
   //  const unsigned long BlockSizeShift = __ffs( blockDim_y ) - 1 ;
-  const unsigned long BlockSizeShift = __lastbit_u32_u32( blockDim_y )  ;
-  const unsigned long BlockSizeMask  = blockDim_y - 1 ;
+  const unsigned long BlockSizeShift = __lastbit_u32_u32(blockDim_y);
+  const unsigned long BlockSizeMask  = blockDim_y - 1;
 
   // Must have power of two thread count
-  if ( BlockSizeMask & blockDim_y ) { Kokkos::abort("ROCm::rocm_single_inter_block_reduce_scan requires power-of-two blockDim"); }
+  if (BlockSizeMask & blockDim_y) {
+    Kokkos::abort(
+        "ROCm::rocm_single_inter_block_reduce_scan requires power-of-two "
+        "blockDim");
+  }
 
-  const integral_nonzero_constant< size_type , ValueTraits::StaticValueSize / sizeof(value_type) >
-    word_count( ValueTraits::value_size( functor )/ sizeof(value_type) );
+  const integral_nonzero_constant<size_type, ValueTraits::StaticValueSize /
+                                                 sizeof(value_type)>
+      word_count(ValueTraits::value_size(functor) / sizeof(value_type));
 
   // Reduce the accumulation for the entire block.
-  rocm_intra_block_reduce_scan<false,FunctorType,ArgTag>( functor , pointer_type(shared_data) );
+  rocm_intra_block_reduce_scan<false, FunctorType, ArgTag>(
+      functor, pointer_type(shared_data));
 
   {
     // Write accumulation total to global scratch space.
     // Accumulation total is the last thread's data.
-    value_type * const shared = shared_data +  
-                                   word_count.value * BlockSizeMask ;
-    value_type * const global = global_data + word_count.value * block_id ;
+    value_type *const shared = shared_data + word_count.value * BlockSizeMask;
+    value_type *const global = global_data + word_count.value * block_id;
 
-    for ( int i = int(threadIdx_y) ; i < word_count.value ; i += blockDim_y ) { global[i] = shared[i] ; }
+    for (int i = int(threadIdx_y); i < word_count.value; i += blockDim_y) {
+      global[i] = shared[i];
+    }
   }
 
-  // Contributing blocks note that their contribution has been completed via an atomic-increment flag
-  // If this block is not the last block to contribute to this group then the block is done.
-    
-  const bool is_last_block =
-    !  __syncthreads_or( threadIdx_y ? 0 : ( 1 + atomicInc( global_flags , block_count - 1 ) < block_count ) );
-  if ( is_last_block ) {
+  // Contributing blocks note that their contribution has been completed via an
+  // atomic-increment flag If this block is not the last block to contribute to
+  // this group then the block is done.
 
-    const size_type b = ( long(block_count) * long(threadIdx_y )) >> BlockSizeShift ;
-    const size_type e = ( long(block_count) * long(threadIdx_y + 1 ) ) >> BlockSizeShift ;
+  const bool is_last_block = !__syncthreads_or(
+      threadIdx_y
+          ? 0
+          : (1 + atomicInc(global_flags, block_count - 1) < block_count));
+  if (is_last_block) {
+    const size_type b =
+        (long(block_count) * long(threadIdx_y)) >> BlockSizeShift;
+    const size_type e =
+        (long(block_count) * long(threadIdx_y + 1)) >> BlockSizeShift;
 
     {
-      value_type * const shared_ptr = shared_data + word_count.value * threadIdx_y ;
-      ValueInit::init( functor , shared_ptr );
-
+      value_type *const shared_ptr =
+          shared_data + word_count.value * threadIdx_y;
+      ValueInit::init(functor, shared_ptr);
 
-      for ( size_type i = b ; i < e ; ++i ) {
-        ValueJoin::join( functor , shared_ptr , global_data + word_count.value * i );
+      for (size_type i = b; i < e; ++i) {
+        ValueJoin::join(functor, shared_ptr,
+                        global_data + word_count.value * i);
       }
     }
-    rocm_intra_block_reduce_scan<DoScan,FunctorType,ArgTag>( functor , pointer_type(shared_data) );
+    rocm_intra_block_reduce_scan<DoScan, FunctorType, ArgTag>(
+        functor, pointer_type(shared_data));
 
-    if ( DoScan ) {
-      value_type * const shared_value = shared_data + word_count.value * ( threadIdx_y ? threadIdx_y - 1 : blockDim_y );
+    if (DoScan) {
+      value_type *const shared_value =
+          shared_data +
+          word_count.value * (threadIdx_y ? threadIdx_y - 1 : blockDim_y);
 
-      if ( ! threadIdx_y ) { ValueInit::init( functor , shared_value ); }
+      if (!threadIdx_y) {
+        ValueInit::init(functor, shared_value);
+      }
 
       // Join previous inclusive scan value to each member
-      for ( size_type i = b ; i < e ; ++i ) {
-        value_type * const global_value = global_data + word_count.value * i ;
-        ValueJoin::join( functor , shared_value , global_value );
-        ValueOps ::copy( functor , global_value , shared_value );
+      for (size_type i = b; i < e; ++i) {
+        value_type *const global_value = global_data + word_count.value * i;
+        ValueJoin::join(functor, shared_value, global_value);
+        ValueOps ::copy(functor, global_value, shared_value);
       }
     }
   }
-  return is_last_block ;
+  return is_last_block;
 }
 
 // Size in bytes required for inter block reduce or scan
-template< bool DoScan , class FunctorType , class ArgTag >
-inline
-unsigned rocm_single_inter_block_reduce_scan_shmem( const FunctorType & functor , const unsigned BlockSize )
-{
-  return ( BlockSize + 2 ) * Impl::FunctorValueTraits< FunctorType , ArgTag >::value_size( functor );
+template <bool DoScan, class FunctorType, class ArgTag>
+inline unsigned rocm_single_inter_block_reduce_scan_shmem(
+    const FunctorType &functor, const unsigned BlockSize) {
+  return (BlockSize + 2) *
+         Impl::FunctorValueTraits<FunctorType, ArgTag>::value_size(functor);
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( __ROCMCC__ ) */
 #endif /* KOKKOS_ROCM_REDUCESCAN_HPP */
-
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Scan.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Scan.hpp
index f24db42cee09adefbbf7604a263a165b9a2d3f1e..337550b9f84a69298e3658b8081e4b7bb40fa231 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Scan.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Scan.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,209 +48,203 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class Tag, class F, class TransformIndex>
-void scan_enqueue(
-  const int len,
-  const F & f,
-  TransformIndex transform_index)
-{
-    typedef Kokkos::Impl::FunctorValueTraits< F, Tag>  ValueTraits;
-    typedef Kokkos::Impl::FunctorValueInit<   F, Tag>  ValueInit;
-    typedef Kokkos::Impl::FunctorValueJoin<   F, Tag>  ValueJoin;
-    typedef Kokkos::Impl::FunctorValueOps<    F, Tag>  ValueOps;
-
-    typedef typename ValueTraits::value_type    value_type;
-    typedef typename ValueTraits::pointer_type    pointer_type;
-    typedef typename ValueTraits::reference_type  reference_type;
-
-    const auto td = get_tile_desc<value_type>(len);
-    std::vector<value_type> result_cpu(td.num_tiles);
-    hc::array<value_type> result(td.num_tiles);
-    hc::array<value_type> scratch(len);
-
-    tile_for<value_type>(td, [&,f,len,td](hc::tiled_index<1> t_idx, tile_buffer<value_type> buffer) [[hc]] 
-    {
-        const auto local = t_idx.local[0];
+template <class Tag, class F, class TransformIndex>
+void scan_enqueue(const int len, const F& f, TransformIndex transform_index) {
+  typedef Kokkos::Impl::FunctorValueTraits<F, Tag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<F, Tag> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<F, Tag> ValueJoin;
+  typedef Kokkos::Impl::FunctorValueOps<F, Tag> ValueOps;
+
+  typedef typename ValueTraits::value_type value_type;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+
+  const auto td = get_tile_desc<value_type>(len);
+  std::vector<value_type> result_cpu(td.num_tiles);
+  hc::array<value_type> result(td.num_tiles);
+  hc::array<value_type> scratch(len);
+
+  tile_for<value_type>(
+      td, [&, f, len, td ](hc::tiled_index<1> t_idx,
+                           tile_buffer<value_type> buffer) [[hc]] {
+        const auto local  = t_idx.local[0];
         const auto global = t_idx.global[0];
-        const auto tile = t_idx.tile[0];
+        const auto tile   = t_idx.tile[0];
 
         // Join tile buffer elements
-        const auto join = [&](std::size_t i, std::size_t j)
-        {
-            buffer.action_at(i, j, [&](value_type& x, const value_type& y)
-            {
-                ValueJoin::join(f, &x, &y);
-            });
+        const auto join = [&](std::size_t i, std::size_t j) {
+          buffer.action_at(i, j, [&](value_type& x, const value_type& y) {
+            ValueJoin::join(f, &x, &y);
+          });
         };
 
         // Copy into tile
-        buffer.action_at(local, [&](value_type& state)
-        {
-            ValueInit::init(f, &state);
-            if (global < len) rocm_invoke<Tag>(f, transform_index(t_idx, td.tile_size, td.num_tiles), state, false);
+        buffer.action_at(local, [&](value_type& state) {
+          ValueInit::init(f, &state);
+          if (global < len)
+            rocm_invoke<Tag>(f,
+                             transform_index(t_idx, td.tile_size, td.num_tiles),
+                             state, false);
         });
         t_idx.barrier.wait();
         // Up sweep phase
-        for(std::size_t d=1;d<buffer.size();d*=2)
-        {
-            auto d2 = 2*d;
-            auto i = local*d2;
-            if(i<len)
-            {
-               auto j = i + d - 1;
-               auto k = i + d2 - 1;
-
-               ValueJoin::join(f, &buffer[k], &buffer[j]);
-            }
+        for (std::size_t d = 1; d < buffer.size(); d *= 2) {
+          auto d2 = 2 * d;
+          auto i  = local * d2;
+          if (i < len) {
+            auto j = i + d - 1;
+            auto k = i + d2 - 1;
+
+            ValueJoin::join(f, &buffer[k], &buffer[j]);
+          }
         }
         t_idx.barrier.wait();
 
-        result[tile] = buffer[buffer.size()-1];
-        buffer[buffer.size()-1] = 0;
+        result[tile]              = buffer[buffer.size() - 1];
+        buffer[buffer.size() - 1] = 0;
         // Down sweep phase
-        for(std::size_t d=buffer.size()/2;d>0;d/=2)
-        {
-            auto d2 = 2*d;
-            auto i = local*d2;
-            if(i<len)
-            {
-               auto j = i + d - 1;
-               auto k = i + d2 - 1;
-               auto t = buffer[k];
-
-               ValueJoin::join(f, &buffer[k], &buffer[j]);
-               buffer[j] = t;
-            }
-            t_idx.barrier.wait();
+        for (std::size_t d = buffer.size() / 2; d > 0; d /= 2) {
+          auto d2 = 2 * d;
+          auto i  = local * d2;
+          if (i < len) {
+            auto j = i + d - 1;
+            auto k = i + d2 - 1;
+            auto t = buffer[k];
+
+            ValueJoin::join(f, &buffer[k], &buffer[j]);
+            buffer[j] = t;
+          }
+          t_idx.barrier.wait();
         }
         // Copy tiles into global memory
         if (global < len) scratch[global] = buffer[local];
-    }).wait();
-    copy(result,result_cpu.data());
-
-   for(int i=1; i<td.num_tiles; i++)
-      ValueJoin::join(f, &result_cpu[i], &result_cpu[i-1]);
-
-    copy(result_cpu.data(),result);
-    size_t launch_len = (((len - 1) / td.tile_size) + 1) * td.tile_size;
-    hc::parallel_for_each(hc::extent<1>(launch_len).tile(td.tile_size), [&,f,len,td](hc::tiled_index<1> t_idx) [[hc]] 
-    {
+      })
+      .wait();
+  copy(result, result_cpu.data());
+
+  for (int i = 1; i < td.num_tiles; i++)
+    ValueJoin::join(f, &result_cpu[i], &result_cpu[i - 1]);
+
+  copy(result_cpu.data(), result);
+  size_t launch_len = (((len - 1) / td.tile_size) + 1) * td.tile_size;
+  hc::parallel_for_each(
+      hc::extent<1>(launch_len).tile(td.tile_size),
+      [&, f, len, td ](hc::tiled_index<1> t_idx) [[hc]] {
         const auto global = t_idx.global[0];
-        const auto tile = t_idx.tile[0];
+        const auto tile   = t_idx.tile[0];
 
-        if (global < len) 
-        {
-            auto final_state = scratch[global];
+        if (global < len) {
+          auto final_state = scratch[global];
 
-            if (tile != 0) ValueJoin::join(f, &final_state, &result[tile-1]);
-            rocm_invoke<Tag>(f, transform_index(t_idx, td.tile_size, td.num_tiles), final_state, true);
+          if (tile != 0) ValueJoin::join(f, &final_state, &result[tile - 1]);
+          rocm_invoke<Tag>(f,
+                           transform_index(t_idx, td.tile_size, td.num_tiles),
+                           final_state, true);
         }
-    }).wait();
+      })
+      .wait();
 }
 
-template< class Tag, class ReturnType, class F, class TransformIndex>
-void scan_enqueue(
-  const int len,
-  const F & f,
-  ReturnType & return_val,
-  TransformIndex transform_index)
-{
-    typedef Kokkos::Impl::FunctorValueTraits< F, Tag>  ValueTraits;
-    typedef Kokkos::Impl::FunctorValueInit<   F, Tag>  ValueInit;
-    typedef Kokkos::Impl::FunctorValueJoin<   F, Tag>  ValueJoin;
-    typedef Kokkos::Impl::FunctorValueOps<    F, Tag>  ValueOps;
-
-    typedef typename ValueTraits::value_type    value_type;
-    typedef typename ValueTraits::pointer_type    pointer_type;
-    typedef typename ValueTraits::reference_type  reference_type;
-
-    const auto td = get_tile_desc<value_type>(len);
-    std::vector<value_type> result_cpu(td.num_tiles);
-    hc::array<value_type> result(td.num_tiles);
-    hc::array<value_type> scratch(len);
-    std::vector<ReturnType> total_cpu(1);
-    hc::array<ReturnType> total(1);
-
-    tile_for<value_type>(td, [&,f,len,td](hc::tiled_index<1> t_idx, tile_buffer<value_type> buffer) [[hc]] 
-    {
-        const auto local = t_idx.local[0];
+template <class Tag, class ReturnType, class F, class TransformIndex>
+void scan_enqueue(const int len, const F& f, ReturnType& return_val,
+                  TransformIndex transform_index) {
+  typedef Kokkos::Impl::FunctorValueTraits<F, Tag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<F, Tag> ValueInit;
+  typedef Kokkos::Impl::FunctorValueJoin<F, Tag> ValueJoin;
+  typedef Kokkos::Impl::FunctorValueOps<F, Tag> ValueOps;
+
+  typedef typename ValueTraits::value_type value_type;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+
+  const auto td = get_tile_desc<value_type>(len);
+  std::vector<value_type> result_cpu(td.num_tiles);
+  hc::array<value_type> result(td.num_tiles);
+  hc::array<value_type> scratch(len);
+  std::vector<ReturnType> total_cpu(1);
+  hc::array<ReturnType> total(1);
+
+  tile_for<value_type>(
+      td, [&, f, len, td ](hc::tiled_index<1> t_idx,
+                           tile_buffer<value_type> buffer) [[hc]] {
+        const auto local  = t_idx.local[0];
         const auto global = t_idx.global[0];
-        const auto tile = t_idx.tile[0];
+        const auto tile   = t_idx.tile[0];
 
         // Join tile buffer elements
-        const auto join = [&](std::size_t i, std::size_t j)
-        {
-            buffer.action_at(i, j, [&](value_type& x, const value_type& y)
-            {
-                ValueJoin::join(f, &x, &y);
-            });
+        const auto join = [&](std::size_t i, std::size_t j) {
+          buffer.action_at(i, j, [&](value_type& x, const value_type& y) {
+            ValueJoin::join(f, &x, &y);
+          });
         };
 
         // Copy into tile
-        buffer.action_at(local, [&](value_type& state)
-        {
-            ValueInit::init(f, &state);
-            if (global < len) rocm_invoke<Tag>(f, transform_index(t_idx, td.tile_size, td.num_tiles), state, false);
+        buffer.action_at(local, [&](value_type& state) {
+          ValueInit::init(f, &state);
+          if (global < len)
+            rocm_invoke<Tag>(f,
+                             transform_index(t_idx, td.tile_size, td.num_tiles),
+                             state, false);
         });
         t_idx.barrier.wait();
         // Up sweep phase
-        for(std::size_t d=1;d<buffer.size();d*=2)
-        {
-            auto d2 = 2*d;
-            auto i = local*d2;
-            if(i<len)
-            {
-               auto j = i + d - 1;
-               auto k = i + d2 - 1;
-               ValueJoin::join(f, &buffer[k], &buffer[j]);
-            }
+        for (std::size_t d = 1; d < buffer.size(); d *= 2) {
+          auto d2 = 2 * d;
+          auto i  = local * d2;
+          if (i < len) {
+            auto j = i + d - 1;
+            auto k = i + d2 - 1;
+            ValueJoin::join(f, &buffer[k], &buffer[j]);
+          }
         }
         t_idx.barrier.wait();
 
-        result[tile] = buffer[buffer.size()-1];
-        buffer[buffer.size()-1] = 0;
+        result[tile]              = buffer[buffer.size() - 1];
+        buffer[buffer.size() - 1] = 0;
         // Down sweep phase
-        for(std::size_t d=buffer.size()/2;d>0;d/=2)
-        {
-            auto d2 = 2*d;
-            auto i = local*d2;
-            if(i<len)
-            {
-               auto j = i + d - 1;
-               auto k = i + d2 - 1;
-               auto t = buffer[k];
-               ValueJoin::join(f, &buffer[k], &buffer[j]);
-               buffer[j] = t;
-            }
-            t_idx.barrier.wait();
+        for (std::size_t d = buffer.size() / 2; d > 0; d /= 2) {
+          auto d2 = 2 * d;
+          auto i  = local * d2;
+          if (i < len) {
+            auto j = i + d - 1;
+            auto k = i + d2 - 1;
+            auto t = buffer[k];
+            ValueJoin::join(f, &buffer[k], &buffer[j]);
+            buffer[j] = t;
+          }
+          t_idx.barrier.wait();
         }
         // Copy tiles into global memory
         if (global < len) scratch[global] = buffer[local];
-    }).wait();
-    copy(result,result_cpu.data());
-
-   for(int i=1; i<td.num_tiles; i++)
-      ValueJoin::join(f, &result_cpu[i], &result_cpu[i-1]);
-
-    copy(result_cpu.data(),result);
-    size_t launch_len = (((len - 1) / td.tile_size) + 1) * td.tile_size;
-    hc::parallel_for_each(hc::extent<1>(launch_len).tile(td.tile_size), [&,f,len,td](hc::tiled_index<1> t_idx) [[hc]] 
-    {
+      })
+      .wait();
+  copy(result, result_cpu.data());
+
+  for (int i = 1; i < td.num_tiles; i++)
+    ValueJoin::join(f, &result_cpu[i], &result_cpu[i - 1]);
+
+  copy(result_cpu.data(), result);
+  size_t launch_len = (((len - 1) / td.tile_size) + 1) * td.tile_size;
+  hc::parallel_for_each(
+      hc::extent<1>(launch_len).tile(td.tile_size),
+      [&, f, len, td ](hc::tiled_index<1> t_idx) [[hc]] {
         const auto global = t_idx.global[0];
-        const auto tile = t_idx.tile[0];
+        const auto tile   = t_idx.tile[0];
 
-        if (global < len) 
-        {
-            auto final_state = scratch[global];
+        if (global < len) {
+          auto final_state = scratch[global];
 
-            if (tile != 0) ValueJoin::join(f, &final_state, &result[tile-1]);
-            rocm_invoke<Tag>(f, transform_index(t_idx, td.tile_size, td.num_tiles), final_state, true);
-            if(global==(len-1))  total[0] = final_state;
+          if (tile != 0) ValueJoin::join(f, &final_state, &result[tile - 1]);
+          rocm_invoke<Tag>(f,
+                           transform_index(t_idx, td.tile_size, td.num_tiles),
+                           final_state, true);
+          if (global == (len - 1)) total[0] = final_state;
         }
-    }).wait();
-    copy(total,total_cpu.data());
-    return_val = total_cpu[0];
+      })
+      .wait();
+  copy(total, total_cpu.data());
+  return_val = total_cpu[0];
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Space.cpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Space.cpp
index 2fe0c4192d6b530fded431557c7f54f58225ec1c..501567406ddf0ab67748044d1454ebabb7fc7df7 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Space.cpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Space.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -62,7 +63,6 @@
 #include <impl/Kokkos_Profiling_Interface.hpp>
 #endif
 
-
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 #define ROCM_SAFE_CALL
@@ -70,123 +70,145 @@ namespace Kokkos {
 namespace Impl {
 using namespace hc;
 
-DeepCopy<Kokkos::Experimental::ROCmSpace,Kokkos::Experimental::ROCmSpace,Kokkos::Experimental::ROCm>::DeepCopy( void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-
-DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace,Kokkos::Experimental::ROCm>::DeepCopy( void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<Kokkos::Experimental::ROCmSpace,HostSpace,Kokkos::Experimental::ROCm>::DeepCopy( void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<Kokkos::Experimental::ROCmSpace,Kokkos::Experimental::ROCmSpace,Kokkos::Experimental::ROCm>::DeepCopy( const Kokkos::Experimental::ROCm & instance , void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace,Kokkos::Experimental::ROCm>::DeepCopy( const Kokkos::Experimental::ROCm & instance , void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<Kokkos::Experimental::ROCmSpace,HostSpace,Kokkos::Experimental::ROCm>::DeepCopy( const Kokkos::Experimental::ROCm & instance , void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-
-
-DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,Kokkos::Experimental::ROCmHostPinnedSpace,Kokkos::Experimental::ROCm>::DeepCopy( void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-
-DeepCopy<HostSpace,Kokkos::Experimental::ROCmHostPinnedSpace,Kokkos::Experimental::ROCm>::DeepCopy( void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,HostSpace,Kokkos::Experimental::ROCm>::DeepCopy( void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,Kokkos::Experimental::ROCmHostPinnedSpace,Kokkos::Experimental::ROCm>::DeepCopy( const Kokkos::Experimental::ROCm & instance , void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<HostSpace,Kokkos::Experimental::ROCmHostPinnedSpace,Kokkos::Experimental::ROCm>::DeepCopy( const Kokkos::Experimental::ROCm & instance , void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,HostSpace,Kokkos::Experimental::ROCm>::DeepCopy( const Kokkos::Experimental::ROCm & instance , void * dst , const void * src , size_t n )
-{
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   av.copy( src , dst , n);
-}
-
-
-hc::completion_future DeepCopyAsyncROCm( void * dst , const void * src , size_t n) {
-   hc::accelerator acc;
-   hc::accelerator_view av = acc.get_default_view();
-   return(av.copy_async( src , dst , n));
-}
-
-} // namespace Impl
-} // namespace Kokkos
+DeepCopy<Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCmSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCmSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(const Kokkos::Experimental::ROCm&
+                                                   instance,
+                                               void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(const Kokkos::Experimental::ROCm&
+                                                   instance,
+                                               void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(const Kokkos::Experimental::ROCm&
+                                                   instance,
+                                               void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,
+         Kokkos::Experimental::ROCmHostPinnedSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace, HostSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace,
+         Kokkos::Experimental::ROCmHostPinnedSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(const Kokkos::Experimental::ROCm&
+                                                   instance,
+                                               void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(const Kokkos::Experimental::ROCm&
+                                                   instance,
+                                               void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+DeepCopy<Kokkos::Experimental::ROCmHostPinnedSpace, HostSpace,
+         Kokkos::Experimental::ROCm>::DeepCopy(const Kokkos::Experimental::ROCm&
+                                                   instance,
+                                               void* dst, const void* src,
+                                               size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  av.copy(src, dst, n);
+}
+
+hc::completion_future DeepCopyAsyncROCm(void* dst, const void* src, size_t n) {
+  hc::accelerator acc;
+  hc::accelerator_view av = acc.get_default_view();
+  return (av.copy_async(src, dst, n));
+}
+
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
-
 namespace Kokkos {
 
-void Experimental::ROCmSpace::access_error()
-{
-  const std::string msg("Kokkos::Experimental::ROCmSpace::access_error attempt to execute Experimental::ROCm function from non-ROCm space" );
-  Kokkos::Impl::throw_runtime_exception( msg );
+void Experimental::ROCmSpace::access_error() {
+  const std::string msg(
+      "Kokkos::Experimental::ROCmSpace::access_error attempt to execute "
+      "Experimental::ROCm function from non-ROCm space");
+  Kokkos::Impl::throw_runtime_exception(msg);
 }
 
-void Experimental::ROCmSpace::access_error( const void * const )
-{
-  const std::string msg("Kokkos::Experimental::ROCmSpace::access_error attempt to execute Experimental::ROCm function from non-ROCm space" );
-  Kokkos::Impl::throw_runtime_exception( msg );
+void Experimental::ROCmSpace::access_error(const void* const) {
+  const std::string msg(
+      "Kokkos::Experimental::ROCmSpace::access_error attempt to execute "
+      "Experimental::ROCm function from non-ROCm space");
+  Kokkos::Impl::throw_runtime_exception(msg);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -194,39 +216,33 @@ void Experimental::ROCmSpace::access_error( const void * const )
 namespace Kokkos {
 namespace Experimental {
 
-ROCmSpace::ROCmSpace()
-  : m_device( ROCm().rocm_device() )
-{
-}
+ROCmSpace::ROCmSpace() : m_device(ROCm().rocm_device()) {}
 
-ROCmHostPinnedSpace::ROCmHostPinnedSpace()
-{
-}
+ROCmHostPinnedSpace::ROCmHostPinnedSpace() {}
 
-void * ROCmSpace::allocate( const size_t arg_alloc_size ) const
-{
-  void * ptr =  Kokkos::Impl::rocm_device_allocate( arg_alloc_size );
-  return ptr ;
+void* ROCmSpace::allocate(const size_t arg_alloc_size) const {
+  void* ptr = Kokkos::Impl::rocm_device_allocate(arg_alloc_size);
+  return ptr;
 }
 
-void * Experimental::ROCmHostPinnedSpace::allocate( const size_t arg_alloc_size ) const
-{
-  void * ptr =  Kokkos::Impl::rocm_hostpinned_allocate( arg_alloc_size );
-  return ptr ;
+void* Experimental::ROCmHostPinnedSpace::allocate(
+    const size_t arg_alloc_size) const {
+  void* ptr = Kokkos::Impl::rocm_hostpinned_allocate(arg_alloc_size);
+  return ptr;
 }
 
-void ROCmSpace::deallocate( void * const arg_alloc_ptr , const size_t /* arg_alloc_size */ ) const
-{
+void ROCmSpace::deallocate(void* const arg_alloc_ptr,
+                           const size_t /* arg_alloc_size */) const {
   Kokkos::Impl::rocm_device_free(arg_alloc_ptr);
 }
 
-void Experimental::ROCmHostPinnedSpace::deallocate( void * const arg_alloc_ptr , const size_t /* arg_alloc_size */ ) const
-{
+void Experimental::ROCmHostPinnedSpace::deallocate(
+    void* const arg_alloc_ptr, const size_t /* arg_alloc_size */) const {
   Kokkos::Impl::rocm_device_free(arg_alloc_ptr);
 }
 
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -235,215 +251,196 @@ namespace Kokkos {
 namespace Impl {
 
 #ifdef KOKKOS_DEBUG
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void> SharedAllocationRecord<
+    Kokkos::Experimental::ROCmSpace, void>::s_root_record;
 
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void> SharedAllocationRecord<
+    Kokkos::Experimental::ROCmHostPinnedSpace, void>::s_root_record;
 #endif
 
-std::string
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::get_label() const
-{
-  SharedAllocationHeader header ;
+std::string SharedAllocationRecord<Kokkos::Experimental::ROCmSpace,
+                                   void>::get_label() const {
+  SharedAllocationHeader header;
 
-  Kokkos::Impl::DeepCopy< Kokkos::HostSpace , Kokkos::Experimental::ROCmSpace >( & header , RecordBase::head() , sizeof(SharedAllocationHeader) );
+  Kokkos::Impl::DeepCopy<Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace>(
+      &header, RecordBase::head(), sizeof(SharedAllocationHeader));
 
-  return std::string( header.m_label );
+  return std::string(header.m_label);
 }
 
-std::string
-SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::get_label() const
-{
-  return std::string( RecordBase::head()->m_label );
+std::string SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace,
+                                   void>::get_label() const {
+  return std::string(RecordBase::head()->m_label);
 }
 
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void > *
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-allocate( const Kokkos::Experimental::ROCmSpace &  arg_space
-        , const std::string       &  arg_label
-        , const size_t               arg_alloc_size
-        )
-{
-  return new SharedAllocationRecord( arg_space , arg_label , arg_alloc_size );
+SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>*
+SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>::allocate(
+    const Kokkos::Experimental::ROCmSpace& arg_space,
+    const std::string& arg_label, const size_t arg_alloc_size) {
+  return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void > *
-SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::
-allocate( const Kokkos::Experimental::ROCmHostPinnedSpace &  arg_space
-        , const std::string                 &  arg_label
-        , const size_t                         arg_alloc_size
-        )
-{
-  return new SharedAllocationRecord( arg_space , arg_label , arg_alloc_size );
+SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace, void>*
+SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace, void>::
+    allocate(const Kokkos::Experimental::ROCmHostPinnedSpace& arg_space,
+             const std::string& arg_label, const size_t arg_alloc_size) {
+  return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
 }
 
-void
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-deallocate( SharedAllocationRecord< void , void > * arg_rec )
-{
+void SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>::deallocate(
+    SharedAllocationRecord<void, void>* arg_rec) {
   delete static_cast<SharedAllocationRecord*>(arg_rec);
 }
 
-void
-SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::
-deallocate( SharedAllocationRecord< void , void > * arg_rec )
-{
+void SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace, void>::
+    deallocate(SharedAllocationRecord<void, void>* arg_rec) {
   delete static_cast<SharedAllocationRecord*>(arg_rec);
 }
 
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-~SharedAllocationRecord()
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-
-    SharedAllocationHeader header ;
-    Kokkos::Impl::DeepCopy<Kokkos::Experimental::ROCmSpace,HostSpace>( & header , RecordBase::m_alloc_ptr , sizeof(SharedAllocationHeader) );
+SharedAllocationRecord<Kokkos::Experimental::ROCmSpace,
+                       void>::~SharedAllocationRecord() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    SharedAllocationHeader header;
+    Kokkos::Impl::DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace>(
+        &header, RecordBase::m_alloc_ptr, sizeof(SharedAllocationHeader));
 
     Kokkos::Profiling::deallocateData(
-      Kokkos::Profiling::SpaceHandle(Kokkos::Experimental::ROCmSpace::name()),header.m_label,
-      data(),size());
+        Kokkos::Profiling::SpaceHandle(Kokkos::Experimental::ROCmSpace::name()),
+        header.m_label, data(), size());
   }
-  #endif
+#endif
 
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::
-~SharedAllocationRecord()
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace,
+                       void>::~SharedAllocationRecord() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::deallocateData(
-      Kokkos::Profiling::SpaceHandle(Kokkos::Experimental::ROCmHostPinnedSpace::name()),RecordBase::m_alloc_ptr->m_label,
-      data(),size());
+        Kokkos::Profiling::SpaceHandle(
+            Kokkos::Experimental::ROCmHostPinnedSpace::name()),
+        RecordBase::m_alloc_ptr->m_label, data(), size());
   }
-  #endif
-
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
-}
-
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-SharedAllocationRecord( const Kokkos::Experimental::ROCmSpace & arg_space
-                      , const std::string       & arg_label
-                      , const size_t              arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+#endif
+
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
+}
+
+SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>::
+    SharedAllocationRecord(
+        const Kokkos::Experimental::ROCmSpace& arg_space,
+        const std::string& arg_label, const size_t arg_alloc_size,
+        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-        & SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::Experimental::ROCmSpace,
+                                  void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_space( arg_space )
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Profiling::allocateData(Kokkos::Profiling::SpaceHandle(arg_space.name()),arg_label,data(),arg_alloc_size);
+          reinterpret_cast<SharedAllocationHeader*>(arg_space.allocate(
+              sizeof(SharedAllocationHeader) + arg_alloc_size)),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_space(arg_space) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::allocateData(
+        Kokkos::Profiling::SpaceHandle(arg_space.name()), arg_label, data(),
+        arg_alloc_size);
   }
-  #endif
+#endif
 
-  SharedAllocationHeader header ;
+  SharedAllocationHeader header;
 
   // Fill in the Header information
-  header.m_record = static_cast< SharedAllocationRecord< void , void > * >( this );
+  header.m_record = static_cast<SharedAllocationRecord<void, void>*>(this);
 
-  strncpy( header.m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(header.m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
   // Set last element zero, in case c_str is too long
-  header.m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0;
+  header.m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
 
   // Copy to device memory
-  Kokkos::Impl::DeepCopy<Kokkos::Experimental::ROCmSpace,HostSpace>( RecordBase::m_alloc_ptr , & header , sizeof(SharedAllocationHeader) );
-}
-
-SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::
-SharedAllocationRecord( const Kokkos::Experimental::ROCmHostPinnedSpace & arg_space
-                      , const std::string                 & arg_label
-                      , const size_t                        arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+  Kokkos::Impl::DeepCopy<Kokkos::Experimental::ROCmSpace, HostSpace>(
+      RecordBase::m_alloc_ptr, &header, sizeof(SharedAllocationHeader));
+}
+
+SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace, void>::
+    SharedAllocationRecord(
+        const Kokkos::Experimental::ROCmHostPinnedSpace& arg_space,
+        const std::string& arg_label, const size_t arg_alloc_size,
+        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-        & SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::Experimental::ROCmHostPinnedSpace,
+                                  void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_space( arg_space )
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Profiling::allocateData(Kokkos::Profiling::SpaceHandle(arg_space.name()),arg_label,data(),arg_alloc_size);
+          reinterpret_cast<SharedAllocationHeader*>(arg_space.allocate(
+              sizeof(SharedAllocationHeader) + arg_alloc_size)),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_space(arg_space) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::allocateData(
+        Kokkos::Profiling::SpaceHandle(arg_space.name()), arg_label, data(),
+        arg_alloc_size);
   }
-  #endif
+#endif
   // Fill in the Header information, directly accessible via host pinned memory
 
-  RecordBase::m_alloc_ptr->m_record = this ;
+  RecordBase::m_alloc_ptr->m_record = this;
 
-  strncpy( RecordBase::m_alloc_ptr->m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(RecordBase::m_alloc_ptr->m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
   // Set last element zero, in case c_str is too long
-  RecordBase::m_alloc_ptr->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0;
+  RecordBase::m_alloc_ptr
+      ->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
 }
 
 //----------------------------------------------------------------------------
 
-void * SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-allocate_tracked( const Kokkos::Experimental::ROCmSpace & arg_space
-                , const std::string & arg_alloc_label
-                , const size_t arg_alloc_size )
-{
-  if ( ! arg_alloc_size ) return (void *) 0 ;
+void* SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>::
+    allocate_tracked(const Kokkos::Experimental::ROCmSpace& arg_space,
+                     const std::string& arg_alloc_label,
+                     const size_t arg_alloc_size) {
+  if (!arg_alloc_size) return (void*)0;
 
-  SharedAllocationRecord * const r =
-    allocate( arg_space , arg_alloc_label , arg_alloc_size );
+  SharedAllocationRecord* const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
 
-  RecordBase::increment( r );
+  RecordBase::increment(r);
 
   return r->data();
 }
 
-void SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-deallocate_tracked( void * const arg_alloc_ptr )
-{
-  if ( arg_alloc_ptr != 0 ) {
-    SharedAllocationRecord * const r = get_record( arg_alloc_ptr );
+void SharedAllocationRecord<Kokkos::Experimental::ROCmSpace,
+                            void>::deallocate_tracked(void* const
+                                                          arg_alloc_ptr) {
+  if (arg_alloc_ptr != 0) {
+    SharedAllocationRecord* const r = get_record(arg_alloc_ptr);
 
-    RecordBase::decrement( r );
+    RecordBase::decrement(r);
   }
 }
 
-void * SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-reallocate_tracked( void * const arg_alloc_ptr
-                  , const size_t arg_alloc_size )
-{
-  SharedAllocationRecord * const r_old = get_record( arg_alloc_ptr );
-  SharedAllocationRecord * const r_new = allocate( r_old->m_space , r_old->get_label() , arg_alloc_size );
+void* SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>::
+    reallocate_tracked(void* const arg_alloc_ptr, const size_t arg_alloc_size) {
+  SharedAllocationRecord* const r_old = get_record(arg_alloc_ptr);
+  SharedAllocationRecord* const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
 
-  Kokkos::Impl::DeepCopy<Kokkos::Experimental::ROCmSpace,Kokkos::Experimental::ROCmSpace>( r_new->data() , r_old->data()
-                                             , std::min( r_old->size() , r_new->size() ) );
+  Kokkos::Impl::DeepCopy<Kokkos::Experimental::ROCmSpace,
+                         Kokkos::Experimental::ROCmSpace>(
+      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
 
-  RecordBase::increment( r_new );
-  RecordBase::decrement( r_old );
+  RecordBase::increment(r_new);
+  RecordBase::decrement(r_old);
 
   return r_new->data();
 }
@@ -493,32 +490,38 @@ reallocate_tracked( void * const arg_alloc_ptr
 
 //----------------------------------------------------------------------------
 
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void > *
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::get_record( void * alloc_ptr )
-{
-  using Header     = SharedAllocationHeader ;
-  using RecordBase = SharedAllocationRecord< void , void > ;
-  using RecordROCm = SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void > ;
+SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>*
+SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>::get_record(
+    void* alloc_ptr) {
+  using Header     = SharedAllocationHeader;
+  using RecordBase = SharedAllocationRecord<void, void>;
+  using RecordROCm =
+      SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>;
 
   // Copy the header from the allocation
-  Header head ;
+  Header head;
 
-  Header const * const head_rocm = alloc_ptr ? Header::get_header( alloc_ptr ) : (Header*) 0 ;
+  Header const* const head_rocm =
+      alloc_ptr ? Header::get_header(alloc_ptr) : (Header*)0;
 
-  if ( alloc_ptr ) {
-    Kokkos::Impl::DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace>( & head , head_rocm , sizeof(SharedAllocationHeader) );
+  if (alloc_ptr) {
+    Kokkos::Impl::DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace>(
+        &head, head_rocm, sizeof(SharedAllocationHeader));
   }
 
-  RecordROCm * const record = alloc_ptr ? static_cast< RecordROCm * >( head.m_record ) : (RecordROCm *) 0 ;
+  RecordROCm* const record =
+      alloc_ptr ? static_cast<RecordROCm*>(head.m_record) : (RecordROCm*)0;
 
-  if ( ! alloc_ptr || record->m_alloc_ptr != head_rocm ) {
-    Kokkos::Impl::throw_runtime_exception( std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::get_record ERROR" ) );
+  if (!alloc_ptr || record->m_alloc_ptr != head_rocm) {
+    Kokkos::Impl::throw_runtime_exception(std::string(
+        "Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::ROCmSpace "
+        ", void >::get_record ERROR"));
   }
 
-  return record ;
+  return record;
 }
 
-#if  0
+#if 0
 SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void > *
 SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::get_record( void * alloc_ptr )
 {
@@ -533,92 +536,84 @@ SharedAllocationRecord< Kokkos::Experimental::ROCmHostPinnedSpace , void >::get_
 
   return static_cast< RecordROCm * >( h->m_record );
 }
-#endif 
+#endif
 
 // Iterate records to print orphaned memory ...
-void
-SharedAllocationRecord< Kokkos::Experimental::ROCmSpace , void >::
-print_records( std::ostream & s , const Kokkos::Experimental::ROCmSpace & space , bool detail )
-{
+void SharedAllocationRecord<Kokkos::Experimental::ROCmSpace, void>::
+    print_records(std::ostream& s, const Kokkos::Experimental::ROCmSpace& space,
+                  bool detail) {
 #ifdef KOKKOS_DEBUG
-  SharedAllocationRecord< void , void > * r = & s_root_record ;
+  SharedAllocationRecord<void, void>* r = &s_root_record;
 
-  char buffer[256] ;
+  char buffer[256];
 
-  SharedAllocationHeader head ;
+  SharedAllocationHeader head;
 
-  if ( detail ) {
+  if (detail) {
     do {
-      if ( r->m_alloc_ptr ) {
-        Kokkos::Impl::DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace>( & head , r->m_alloc_ptr , sizeof(SharedAllocationHeader) );
+      if (r->m_alloc_ptr) {
+        Kokkos::Impl::DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace>(
+            &head, r->m_alloc_ptr, sizeof(SharedAllocationHeader));
+      } else {
+        head.m_label[0] = 0;
       }
-      else {
-        head.m_label[0] = 0 ;
-      }
-
-      //Formatting dependent on sizeof(uintptr_t)
-      const char * format_string;
 
-      if (sizeof(uintptr_t) == sizeof(unsigned long)) { 
-        format_string = "ROCm addr( 0x%.12lx ) list( 0x%.12lx 0x%.12lx ) extent[ 0x%.12lx + %.8ld ] count(%d) dealloc(0x%.12lx) %s\n";
-      }
-      else if (sizeof(uintptr_t) == sizeof(unsigned long long)) { 
-        format_string = "ROCm addr( 0x%.12llx ) list( 0x%.12llx 0x%.12llx ) extent[ 0x%.12llx + %.8ld ] count(%d) dealloc(0x%.12llx) %s\n";
+      // Formatting dependent on sizeof(uintptr_t)
+      const char* format_string;
+
+      if (sizeof(uintptr_t) == sizeof(unsigned long)) {
+        format_string =
+            "ROCm addr( 0x%.12lx ) list( 0x%.12lx 0x%.12lx ) extent[ 0x%.12lx "
+            "+ %.8ld ] count(%d) dealloc(0x%.12lx) %s\n";
+      } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
+        format_string =
+            "ROCm addr( 0x%.12llx ) list( 0x%.12llx 0x%.12llx ) extent[ "
+            "0x%.12llx + %.8ld ] count(%d) dealloc(0x%.12llx) %s\n";
       }
 
-      snprintf( buffer , 256 
-              , format_string
-              , reinterpret_cast<uintptr_t>( r )
-              , reinterpret_cast<uintptr_t>( r->m_prev )
-              , reinterpret_cast<uintptr_t>( r->m_next )
-              , reinterpret_cast<uintptr_t>( r->m_alloc_ptr )
-              , r->m_alloc_size
-              , r->m_count
-              , reinterpret_cast<uintptr_t>( r->m_dealloc )
-              , head.m_label
-              );
-      std::cout << buffer ;
-      r = r->m_next ;
-    } while ( r != & s_root_record );
-  }
-  else {
+      snprintf(buffer, 256, format_string, reinterpret_cast<uintptr_t>(r),
+               reinterpret_cast<uintptr_t>(r->m_prev),
+               reinterpret_cast<uintptr_t>(r->m_next),
+               reinterpret_cast<uintptr_t>(r->m_alloc_ptr), r->m_alloc_size,
+               r->m_count, reinterpret_cast<uintptr_t>(r->m_dealloc),
+               head.m_label);
+      std::cout << buffer;
+      r = r->m_next;
+    } while (r != &s_root_record);
+  } else {
     do {
-      if ( r->m_alloc_ptr ) {
-
-        Kokkos::Impl::DeepCopy<HostSpace,Kokkos::Experimental::ROCmSpace>( & head , r->m_alloc_ptr , sizeof(SharedAllocationHeader) );
+      if (r->m_alloc_ptr) {
+        Kokkos::Impl::DeepCopy<HostSpace, Kokkos::Experimental::ROCmSpace>(
+            &head, r->m_alloc_ptr, sizeof(SharedAllocationHeader));
 
-        //Formatting dependent on sizeof(uintptr_t)
-        const char * format_string;
+        // Formatting dependent on sizeof(uintptr_t)
+        const char* format_string;
 
-        if (sizeof(uintptr_t) == sizeof(unsigned long)) { 
+        if (sizeof(uintptr_t) == sizeof(unsigned long)) {
           format_string = "ROCm [ 0x%.12lx + %ld ] %s\n";
-        }
-        else if (sizeof(uintptr_t) == sizeof(unsigned long long)) { 
+        } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
           format_string = "ROCm [ 0x%.12llx + %ld ] %s\n";
         }
 
-        snprintf( buffer , 256 
-                , format_string
-                , reinterpret_cast< uintptr_t >( r->data() )
-                , r->size()
-                , head.m_label
-                );
-      }
-      else {
-        snprintf( buffer , 256 , "ROCm [ 0 + 0 ]\n" );
+        snprintf(buffer, 256, format_string,
+                 reinterpret_cast<uintptr_t>(r->data()), r->size(),
+                 head.m_label);
+      } else {
+        snprintf(buffer, 256, "ROCm [ 0 + 0 ]\n");
       }
-      std::cout << buffer ;
-      r = r->m_next ;
-    } while ( r != & s_root_record );
+      std::cout << buffer;
+      r = r->m_next;
+    } while (r != &s_root_record);
   }
 #else
-  throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord<ROCmSpace>::print_records"
+  throw_runtime_exception(
+      "Kokkos::Impl::SharedAllocationRecord<ROCmSpace>::print_records"
       " only works with KOKKOS_DEBUG enabled");
 #endif
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -626,26 +621,28 @@ namespace Kokkos {
 namespace {
 
 void* rocm_resize_scratch_space(size_t bytes, bool force_shrink) {
-  static void* ptr = NULL;
+  static void* ptr           = NULL;
   static size_t current_size = 0;
-  if(current_size == 0) {
+  if (current_size == 0) {
     current_size = bytes;
-    ptr = Kokkos::kokkos_malloc<Kokkos::Experimental::ROCmSpace>("ROCmSpace::ScratchMemory",current_size);
+    ptr          = Kokkos::kokkos_malloc<Kokkos::Experimental::ROCmSpace>(
+        "ROCmSpace::ScratchMemory", current_size);
   }
-  if(bytes > current_size) {
+  if (bytes > current_size) {
     current_size = bytes;
-    ptr = Kokkos::kokkos_realloc<Kokkos::Experimental::ROCmSpace>(ptr,current_size);
+    ptr          = Kokkos::kokkos_realloc<Kokkos::Experimental::ROCmSpace>(ptr,
+                                                                  current_size);
   }
-  if((bytes < current_size) && (force_shrink)) {
+  if ((bytes < current_size) && (force_shrink)) {
     current_size = bytes;
     Kokkos::kokkos_free<Kokkos::Experimental::ROCmSpace>(ptr);
-    ptr = Kokkos::kokkos_malloc<Kokkos::Experimental::ROCmSpace>("ROCmSpace::ScratchMemory",current_size);
+    ptr = Kokkos::kokkos_malloc<Kokkos::Experimental::ROCmSpace>(
+        "ROCmSpace::ScratchMemory", current_size);
   }
   return ptr;
 }
 
-}
-}
-
-#endif // KOKKOS_ENABLE_ROCM
+}  // namespace
+}  // namespace Kokkos
 
+#endif  // KOKKOS_ENABLE_ROCM
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.cpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.cpp
index 894d3248341aa69e0dcaebab1e7711044fb8e6c7..53966ca93483a28848715346c0f33324b69ca75f 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.cpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,14 +37,14 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
 #include <Kokkos_Core.hpp>
 
-#if defined( KOKKOS_ENABLE_ROCM ) && defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_ROCM) && defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <impl/Kokkos_TaskQueue_impl.hpp>
 
@@ -53,46 +54,44 @@
 namespace Kokkos {
 namespace Impl {
 
-template class TaskQueue< Kokkos::Experimental::ROCm > ;
-
+template class TaskQueue<Kokkos::Experimental::ROCm>;
 
 //----------------------------------------------------------------------------
 KOKKOS_INLINE_FUNCTION
-void TaskQueueSpecialization< Kokkos::Experimental::ROCm >::driver
-  ( TaskQueueSpecialization< Kokkos::Experimental::ROCm >::queue_type * const queue,
-    hc::tiled_index<3> threadIdx )
-{
-  using Member = TaskExec< Kokkos::Experimental::ROCm > ;
-  using Queue  = TaskQueue< Kokkos::Experimental::ROCm > ;
-  using task_root_type = TaskBase< void , void , void > ;
+void TaskQueueSpecialization<Kokkos::Experimental::ROCm>::driver(
+    TaskQueueSpecialization<Kokkos::Experimental::ROCm>::queue_type
+        *const queue,
+    hc::tiled_index<3> threadIdx) {
+  using Member         = TaskExec<Kokkos::Experimental::ROCm>;
+  using Queue          = TaskQueue<Kokkos::Experimental::ROCm>;
+  using task_root_type = TaskBase<void, void, void>;
 
-  task_root_type * const end = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const end = (task_root_type *)task_root_type::EndTag;
 
-  Member single_exec( 1, threadIdx );
-  Member team_exec( threadIdx.tile_dim[0], threadIdx );
+  Member single_exec(1, threadIdx);
+  Member team_exec(threadIdx.tile_dim[0], threadIdx);
 
-  const int wavefront_lane = threadIdx.local[0] + threadIdx.local[1]* threadIdx.tile_dim[0] ;
+  const int wavefront_lane =
+      threadIdx.local[0] + threadIdx.local[1] * threadIdx.tile_dim[0];
 
   union {
-    task_root_type * ptr ;
-    int              raw[2] ;
-  } task ;
+    task_root_type *ptr;
+    int raw[2];
+  } task;
 
   // Loop until all queues are empty and no tasks in flight
 
   do {
-
     // Each team lead attempts to acquire either a thread team task
     // or collection of single thread tasks for the team.
 
-    if ( 0 == wavefront_lane ) {
-
-      task.ptr = 0 < *((volatile int *) & queue->m_ready_count) ? end : 0 ;
+    if (0 == wavefront_lane) {
+      task.ptr = 0 < *((volatile int *)&queue->m_ready_count) ? end : 0;
 
       // Loop by priority and then type
-      for ( int i = 0 ; i < Queue::NumQueue && end == task.ptr ; ++i ) {
-        for ( int j = 0 ; j < 2 && end == task.ptr ; ++j ) {
-          task.ptr = Queue::pop_ready_task( & queue->m_ready[i][j] );
+      for (int i = 0; i < Queue::NumQueue && end == task.ptr; ++i) {
+        for (int j = 0; j < 2 && end == task.ptr; ++j) {
+          task.ptr = Queue::pop_ready_task(&queue->m_ready[i][j]);
         }
       }
 
@@ -100,31 +99,29 @@ void TaskQueueSpecialization< Kokkos::Experimental::ROCm >::driver
 printf("TaskQueue<ROCm>::driver(%d,%d) task(%lx)\n",threadIdx.z,blockIdx.x
       , uintptr_t(task.ptr));
 #endif
-
     }
 
     // shuffle broadcast
 
-    task.raw[0] = hc::__shfl( task.raw[0] , 0 );
-    task.raw[1] = hc::__shfl( task.raw[1] , 0 );
+    task.raw[0] = hc::__shfl(task.raw[0], 0);
+    task.raw[1] = hc::__shfl(task.raw[1], 0);
 
-    if ( 0 == task.ptr ) break ; // 0 == queue->m_ready_count
+    if (0 == task.ptr) break;  // 0 == queue->m_ready_count
 
-    if ( end != task.ptr ) {
-      if ( task_root_type::TaskTeam == task.ptr->m_task_type ) {
+    if (end != task.ptr) {
+      if (task_root_type::TaskTeam == task.ptr->m_task_type) {
         // Thread Team Task
-        (*task.ptr->m_apply)( task.ptr , & team_exec );
-      }
-      else if ( 0 == threadIdx.local[1] ) {
+        (*task.ptr->m_apply)(task.ptr, &team_exec);
+      } else if (0 == threadIdx.local[1]) {
         // Single Thread Task
-        (*task.ptr->m_apply)( task.ptr , & single_exec );
+        (*task.ptr->m_apply)(task.ptr, &single_exec);
       }
 
-      if ( 0 == wavefront_lane ) {
-        queue->complete( task.ptr );
+      if (0 == wavefront_lane) {
+        queue->complete(task.ptr);
       }
     }
-  } while(1);
+  } while (1);
 }
 #if 0
 namespace {
@@ -135,21 +132,19 @@ void rocm_task_queue_execute( TaskQueue< Kokkos::Experimental::ROCm > * queue,
 
 }
 #endif
-void TaskQueueSpecialization< Kokkos::Experimental::ROCm >::execute
-  ( TaskQueue< Kokkos::Experimental::ROCm > * const queue )
-{
-  const int workgroups_per_wavefront = 4 ;
-  const int wavefront_size = Kokkos::Impl::ROCmTraits::WavefrontSize ;
-  const int cu_count = Kokkos::Impl::rocm_internal_cu_count();
-//  const dim3 grid( Kokkos::Impl::rocm_internal_cu_count() , 1 , 1 );
-//  const dim3 block( 1 , Kokkos::Impl::ROCmTraits::WorkGroupSize , workgroups_per_wavefront );
-
-
+void TaskQueueSpecialization<Kokkos::Experimental::ROCm>::execute(
+    TaskQueue<Kokkos::Experimental::ROCm> *const queue) {
+  const int workgroups_per_wavefront = 4;
+  const int wavefront_size           = Kokkos::Impl::ROCmTraits::WavefrontSize;
+  const int cu_count                 = Kokkos::Impl::rocm_internal_cu_count();
+  //  const dim3 grid( Kokkos::Impl::rocm_internal_cu_count() , 1 , 1 );
+  //  const dim3 block( 1 , Kokkos::Impl::ROCmTraits::WorkGroupSize ,
+  //  workgroups_per_wavefront );
 
   // Query the stack size, in bytes:
   // If not large enough then set the stack size, in bytes:
 
-// adapted from the cuda code.  TODO: Not at all sure that this is the proper 
+// adapted from the cuda code.  TODO: Not at all sure that this is the proper
 // to map the cuda grid/blocks/3D tiling to HCC
 #if 0
   hc::extent< 3 > flat_extent(  cu_count,
@@ -164,11 +159,10 @@ void TaskQueueSpecialization< Kokkos::Experimental::ROCm >::execute
 #endif
 }
 
-
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
-#endif /* #if defined( KOKKOS_ENABLE_ROCM ) && defined( KOKKOS_ENABLE_TASKDAG ) */
-
-
+#endif /* #if defined( KOKKOS_ENABLE_ROCM ) && defined( KOKKOS_ENABLE_TASKDAG \
+          ) */
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.hpp
index 37c61c691a9d44d7b3a33e7b5612031fe8649f2d..5b04e955132f3649f6a7c4ebe2a4b35a70b70dc0 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Task.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -44,7 +45,7 @@
 #ifndef KOKKOS_IMPL_ROCM_TASK_HPP
 #define KOKKOS_IMPL_ROCM_TASK_HPP
 
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <ROCm/Kokkos_ROCm_Vectorization.hpp>
 
@@ -54,59 +55,53 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class > class TaskExec ; 
-
-template<>
-class TaskQueueSpecialization< Kokkos::Experimental::ROCm >
-{
-public:
+template <class>
+class TaskExec;
 
-  using execution_space = Kokkos::Experimental::ROCm ;
-  using queue_type      = Kokkos::Impl::TaskQueue< execution_space > ;
-  using task_base_type  = Kokkos::Impl::TaskBase< execution_space , void , void > ;
-  using member_type     = TaskExec< execution_space > ;
+template <>
+class TaskQueueSpecialization<Kokkos::Experimental::ROCm> {
+ public:
+  using execution_space = Kokkos::Experimental::ROCm;
+  using queue_type      = Kokkos::Impl::TaskQueue<execution_space>;
+  using task_base_type  = Kokkos::Impl::TaskBase<execution_space, void, void>;
+  using member_type     = TaskExec<execution_space>;
 
   // Must specify memory space
-  using memory_space = Kokkos::HostSpace ;
+  using memory_space = Kokkos::HostSpace;
 
-  static
-  void iff_single_thread_recursive_execute( queue_type * const ) {}
+  static void iff_single_thread_recursive_execute(queue_type* const) {}
 
   KOKKOS_INLINE_FUNCTION
-  static void driver( queue_type * const, hc::tiled_index<3> );
+  static void driver(queue_type* const, hc::tiled_index<3>);
 
   // Must provide task queue execution function
-  static void execute( queue_type * const );
+  static void execute(queue_type* const);
 
   // Must provide mechanism to set function pointer in
   // execution space from the host process.
-  template< typename FunctorType >
-  static
-  void proc_set_apply( typename TaskBase< Kokkos::Experimental::ROCm
-                               , typename FunctorType::value_type
-                               , FunctorType
-                               >::function_type * ptr )
-    {
-      using TaskType = TaskBase< Kokkos::Experimental::ROCm
-                               , typename FunctorType::value_type
-                               , FunctorType
-                               > ;
-      hc::extent< 1 > flat_extent( 1 );
-      hc::tiled_extent< 1 > team_extent = flat_extent.tile( 1);
-
-      hc::parallel_for_each( team_extent , [&](hc::tiled_index<1> idx) [[hc]]
-      {
-         *ptr = TaskType::apply ;
-      }).wait();
-    }
+  template <typename FunctorType>
+  static void proc_set_apply(
+      typename TaskBase<Kokkos::Experimental::ROCm,
+                        typename FunctorType::value_type,
+                        FunctorType>::function_type* ptr) {
+    using TaskType = TaskBase<Kokkos::Experimental::ROCm,
+                              typename FunctorType::value_type, FunctorType>;
+    hc::extent<1> flat_extent(1);
+    hc::tiled_extent<1> team_extent = flat_extent.tile(1);
+
+    hc::parallel_for_each(
+        team_extent, [&](hc::tiled_index<1> idx)
+                         [[hc]] { *ptr = TaskType::apply; })
+        .wait();
+  }
 };
 
 /*template<>
-KOKKOS_FUNCTION 
-void TaskQueue<Kokkos::Experimental::ROCm>::decrement( typename TaskQueue<Kokkos::Experimental::ROCm>::task_root_type *
-) {}
+KOKKOS_FUNCTION
+void TaskQueue<Kokkos::Experimental::ROCm>::decrement( typename
+TaskQueue<Kokkos::Experimental::ROCm>::task_root_type * ) {}
 */
-extern template class TaskQueue< Kokkos::Experimental::ROCm > ;
+extern template class TaskQueue<Kokkos::Experimental::ROCm>;
 
 //----------------------------------------------------------------------------
 /**\brief  Impl::TaskExec<ROCm> is the TaskScheduler<ROCm>::member_type
@@ -123,347 +118,331 @@ extern template class TaskQueue< Kokkos::Experimental::ROCm > ;
  *  A single thread task is called by warp lane #0 and the remaining
  *  lanes of the warp are idle.
  */
-template<>
-class TaskExec< Kokkos::Experimental::ROCm >
-{
-private:
-
-  TaskExec( TaskExec && ) = delete ;
-  TaskExec( TaskExec const & ) = delete ;
-  TaskExec & operator = ( TaskExec && ) = delete ;
-  TaskExec & operator = ( TaskExec const & ) = delete ;
-
+template <>
+class TaskExec<Kokkos::Experimental::ROCm> {
+ private:
+  TaskExec(TaskExec&&)      = delete;
+  TaskExec(TaskExec const&) = delete;
+  TaskExec& operator=(TaskExec&&) = delete;
+  TaskExec& operator=(TaskExec const&) = delete;
 
-  friend class Kokkos::Impl::TaskQueue< Kokkos::Experimental::ROCm > ;
-  friend class Kokkos::Impl::TaskQueueSpecialization< Kokkos::Experimental::ROCm > ;
+  friend class Kokkos::Impl::TaskQueue<Kokkos::Experimental::ROCm>;
+  friend class Kokkos::Impl::TaskQueueSpecialization<
+      Kokkos::Experimental::ROCm>;
 
-  int              m_team_size ;
-  hc::tiled_index<3>      m_idx;
+  int m_team_size;
+  hc::tiled_index<3> m_idx;
 
-//  KOKKOS_INLINE_FUNCTION TaskExec( int arg_team_size )  //TODO: tile_dim[0]
-//    : m_team_size( arg_team_size ) {}
+  //  KOKKOS_INLINE_FUNCTION TaskExec( int arg_team_size )  //TODO: tile_dim[0]
+  //    : m_team_size( arg_team_size ) {}
 
-  KOKKOS_INLINE_FUNCTION TaskExec( int arg_team_size,
-                                   hc::tiled_index<3> tidx)  
-    : m_team_size( arg_team_size),
-      m_idx( tidx ) {}
+  KOKKOS_INLINE_FUNCTION TaskExec(int arg_team_size, hc::tiled_index<3> tidx)
+      : m_team_size(arg_team_size), m_idx(tidx) {}
 
-public:
-//      const auto local = t_idx.local[0];
-//      const auto global = t_idx.global[0];
-//     const auto tile = t_idx.tile[0];
+ public:
+  //      const auto local = t_idx.local[0];
+  //      const auto global = t_idx.global[0];
+  //     const auto tile = t_idx.tile[0];
 
-  hc::tiled_index<3> idx() const { return m_idx;}
+  hc::tiled_index<3> idx() const { return m_idx; }
 
-#if defined( __HCC_ACCELERATOR__ )
-  KOKKOS_INLINE_FUNCTION void team_barrier() { /* __threadfence_block(); */ }
-  KOKKOS_INLINE_FUNCTION int  team_rank() const { return m_idx.local[1] ; } // t_idx.tile[0];
-  KOKKOS_INLINE_FUNCTION int  team_size() const { return m_team_size ; }
+#if defined(__HCC_ACCELERATOR__)
+  KOKKOS_INLINE_FUNCTION void team_barrier() { /* __threadfence_block(); */
+  }
+  KOKKOS_INLINE_FUNCTION int team_rank() const {
+    return m_idx.local[1];
+  }  // t_idx.tile[0];
+  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
 #else
   KOKKOS_INLINE_FUNCTION void team_barrier() {}
-  KOKKOS_INLINE_FUNCTION int  team_rank() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION int  team_size() const { return 0 ; }
+  KOKKOS_INLINE_FUNCTION int team_rank() const { return 0; }
+  KOKKOS_INLINE_FUNCTION int team_size() const { return 0; }
 #endif
 };
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 namespace Kokkos {
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >
-TeamThreadRange
-  ( Impl::TaskExec< Kokkos::Experimental::ROCm > & thread, const iType & count )
-{
-  return Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >(thread,count);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >
+TeamThreadRange(Impl::TaskExec<Kokkos::Experimental::ROCm>& thread,
+                const iType& count) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >(thread, count);
 }
 
-template<typename iType1, typename iType2>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< typename std::common_type< iType1, iType2 >::type,
-                                       Impl::TaskExec< Kokkos::Experimental::ROCm > >
-TeamThreadRange
-  ( Impl:: TaskExec< Kokkos::Experimental::ROCm > & thread, const iType1 & begin, const iType2 & end )
-{
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type,
+    Impl::TaskExec<Kokkos::Experimental::ROCm> >
+TeamThreadRange(Impl::TaskExec<Kokkos::Experimental::ROCm>& thread,
+                const iType1& begin, const iType2& end) {
   typedef typename std::common_type<iType1, iType2>::type iType;
-  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::TaskExec< Kokkos::Experimental::ROCm > >(thread, begin, end);
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >(thread, begin, end);
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >
-ThreadVectorRange
-  ( Impl::TaskExec< Kokkos::Experimental::ROCm > & thread
-  , const iType & count )
-{
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >(thread,count);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >
+ThreadVectorRange(Impl::TaskExec<Kokkos::Experimental::ROCm>& thread,
+                  const iType& count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >(thread, count);
 }
 
-template<typename iType>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >
-ThreadVectorRange
-  ( Impl::TaskExec< Kokkos::Experimental::ROCm > & thread
-  , const iType & arg_begin
-  , const iType & arg_end)
-{
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >(thread,arg_begin,arg_end);
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >
+ThreadVectorRange(Impl::TaskExec<Kokkos::Experimental::ROCm>& thread,
+                  const iType& arg_begin, const iType& arg_end) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >(thread, arg_begin,
+                                                          arg_end);
 }
 
-/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all threads of the the calling thread team.
  * This functionality requires C++11 support.
-*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl:: TaskExec< Kokkos::Experimental::ROCm > >& loop_boundaries
-  , const Lambda& lambda
-  )
-{
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+ */
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >& loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i);
   }
 }
 
 // reduce across corresponding lanes between team members within workgroup
 // assume stride*team_size == workgroup_size
-template< typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void strided_shfl_workgroup_reduction
-  (const ValueType& f(),
-   ValueType& val,
-   int team_size,
-   int stride)
-{
-  for (int lane_delta=(team_size*stride)>>1; lane_delta>=stride; lane_delta>>=1) {
-    f(val, Kokkos::shfl_down(val, lane_delta, team_size*stride));
+template <typename ValueType>
+KOKKOS_INLINE_FUNCTION void strided_shfl_workgroup_reduction(
+    const ValueType& f(), ValueType& val, int team_size, int stride) {
+  for (int lane_delta = (team_size * stride) >> 1; lane_delta >= stride;
+       lane_delta >>= 1) {
+    f(val, Kokkos::shfl_down(val, lane_delta, team_size * stride));
   }
 }
 
-template< typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void strided_shfl_workgroup_reduction
-  (const JoinType& join,
-   ValueType& val,
-   int team_size,
-   int stride)
-{
-  for (int lane_delta=(team_size*stride)>>1; lane_delta>=stride; lane_delta>>=1) {
-    join(val, shfl_down(val, lane_delta, team_size*stride));
+template <typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void strided_shfl_workgroup_reduction(
+    const JoinType& join, ValueType& val, int team_size, int stride) {
+  for (int lane_delta = (team_size * stride) >> 1; lane_delta >= stride;
+       lane_delta >>= 1) {
+    join(val, shfl_down(val, lane_delta, team_size * stride));
   }
 }
 
 // multiple within-workgroup non-strided reductions
-template< typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void multi_shfl_workgroup_reduction
-  (const JoinType& join,
-   ValueType& val,
-   int vec_length)
-{
-  for (int lane_delta=vec_length>>1; lane_delta; lane_delta>>=1) {
+template <typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void multi_shfl_workgroup_reduction(const JoinType& join,
+                                                           ValueType& val,
+                                                           int vec_length) {
+  for (int lane_delta = vec_length >> 1; lane_delta; lane_delta >>= 1) {
     join(val, shfl_down(val, lane_delta, vec_length));
   }
 }
 
 // broadcast within workgroup
-template< class ValueType >
-KOKKOS_INLINE_FUNCTION
-ValueType shfl_workgroup_broadcast
-  (ValueType& val,
-   int src_lane,
-   int width)
-{
+template <class ValueType>
+KOKKOS_INLINE_FUNCTION ValueType shfl_workgroup_broadcast(ValueType& val,
+                                                          int src_lane,
+                                                          int width) {
   return shfl(val, src_lane, width);
 }
 
-// all-reduce across corresponding vector lanes between team members within workgroup
-// assume vec_length*team_size == workgroup_size
-// blockDim.x == vec_length == stride
-// blockDim.y == team_size
-// threadIdx.x == position in vec
+// all-reduce across corresponding vector lanes between team members within
+// workgroup assume vec_length*team_size == workgroup_size blockDim.x ==
+// vec_length == stride blockDim.y == team_size threadIdx.x == position in vec
 // threadIdx.y == member number
 
-template<typename iType, class Lambda, typename ValueType>
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  ( const Impl::TeamThreadRangeBoundariesStruct<iType,Impl:: TaskExec< Kokkos::Experimental::ROCm > >& loop_boundaries
-  , const Lambda& lambda
-  , ValueType& initialized_result)
-{
-  int team_rank = loop_boundaries.thread.team_rank(); // member num within the team
-  ValueType result = initialized_result;
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >& loop_boundaries,
+    const Lambda& lambda, ValueType& initialized_result) {
+  int team_rank =
+      loop_boundaries.thread.team_rank();  // member num within the team
+  ValueType result       = initialized_result;
   hc::tiled_index<3> idx = loop_boundaries.thread.idx();
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i, result);
   }
   initialized_result = result;
 
   strided_shfl_workgroup_reduction(
-                          [&] (ValueType& val1, const ValueType& val2) { val1 += val2; },
-                          initialized_result,
-                          loop_boundaries.thread.team_size(),
-                          idx.tile_dim[0]);
-  initialized_result = shfl_workgroup_broadcast<ValueType>( initialized_result, idx.local[0], Impl::ROCmTraits::WavefrontSize );
-
+      [&](ValueType& val1, const ValueType& val2) { val1 += val2; },
+      initialized_result, loop_boundaries.thread.team_size(), idx.tile_dim[0]);
+  initialized_result = shfl_workgroup_broadcast<ValueType>(
+      initialized_result, idx.local[0], Impl::ROCmTraits::WavefrontSize);
 }
 
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >& loop_boundaries,
-   const Lambda & lambda,
-   const JoinType & join,
-   ValueType& initialized_result)
-{
-   hc::tiled_index<3> idx = loop_boundaries.thread.idx();
-  int team_rank = loop_boundaries.thread.team_rank(); // member num within the team
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& initialized_result) {
+  hc::tiled_index<3> idx = loop_boundaries.thread.idx();
+  int team_rank =
+      loop_boundaries.thread.team_rank();  // member num within the team
   ValueType result = initialized_result;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     lambda(i, result);
   }
 
   strided_shfl_workgroup_reduction<ValueType, JoinType>(
-                          join,
-                          initialized_result,
-                          loop_boundaries.thread.team_size(),
-                          idx.tile_dim[0]);
-  initialized_result = shfl_workgroup_broadcast<ValueType>( initialized_result, idx.local[0], Impl::ROCmTraits::WavefrontSize );
+      join, initialized_result, loop_boundaries.thread.team_size(),
+      idx.tile_dim[0]);
+  initialized_result = shfl_workgroup_broadcast<ValueType>(
+      initialized_result, idx.local[0], Impl::ROCmTraits::WavefrontSize);
 }
 
 // placeholder for future function
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >& loop_boundaries,
-   const Lambda & lambda,
-   ValueType& initialized_result)
-{
-  ValueType result = initialized_result;
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >& loop_boundaries,
+    const Lambda& lambda, ValueType& initialized_result) {
+  ValueType result       = initialized_result;
   hc::tiled_index<3> idx = loop_boundaries.thread.idx();
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
 
   initialized_result = result;
 
-  //initialized_result = multi_shfl_workgroup_reduction(
+  // initialized_result = multi_shfl_workgroup_reduction(
   multi_shfl_workgroup_reduction(
-                          [&] (ValueType& val1, const ValueType& val2) { val1 += val2; },
-                          initialized_result,
-                          idx.tile_dim[0]);
-  initialized_result = shfl_workgroup_broadcast<ValueType>( initialized_result, 0, idx.tile_dim[0] );
+      [&](ValueType& val1, const ValueType& val2) { val1 += val2; },
+      initialized_result, idx.tile_dim[0]);
+  initialized_result = shfl_workgroup_broadcast<ValueType>(initialized_result,
+                                                           0, idx.tile_dim[0]);
 }
 
 // placeholder for future function
-template< typename iType, class Lambda, typename ValueType, class JoinType >
-KOKKOS_INLINE_FUNCTION
-void parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >& loop_boundaries,
-   const Lambda & lambda,
-   const JoinType & join,
-   ValueType& initialized_result)
-{
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& initialized_result) {
   hc::tiled_index<3> idx = loop_boundaries.thread.idx();
-  ValueType result = initialized_result;
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  ValueType result       = initialized_result;
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
   initialized_result = result;
 
-  multi_shfl_workgroup_reduction<ValueType, JoinType>(join, initialized_result, idx.tile_dim[0]);
-  initialized_result = shfl_workgroup_broadcast<ValueType>( initialized_result, 0, idx.tile_dim[0] );
+  multi_shfl_workgroup_reduction<ValueType, JoinType>(join, initialized_result,
+                                                      idx.tile_dim[0]);
+  initialized_result = shfl_workgroup_broadcast<ValueType>(initialized_result,
+                                                           0, idx.tile_dim[0]);
 }
 
-template< typename ValueType, typename iType, class Lambda >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan
-  (const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >& loop_boundaries,
-   const Lambda & lambda)
-{
+template <typename ValueType, typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >& loop_boundaries,
+    const Lambda& lambda) {
   hc::tiled_index<3> idx = loop_boundaries.thread.idx();
-  ValueType accum = 0 ;
+  ValueType accum        = 0;
   ValueType val, y, local_total;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     val = 0;
-    lambda(i,val,false);
+    lambda(i, val, false);
 
     // intra-idx.tile_dim[0] exclusive scan on 'val'
     // accum = accumulated, sum in total for this iteration
 
     // INCLUSIVE scan
-    for( int offset = idx.tile_dim[0] ; offset < Impl::ROCmTraits::WavefrontSize ; offset <<= 1 ) {
+    for (int offset = idx.tile_dim[0]; offset < Impl::ROCmTraits::WavefrontSize;
+         offset <<= 1) {
       y = shfl_up(val, offset, Impl::ROCmTraits::WavefrontSize);
-      if(idx.local[1]*idx.tile_dim[0] >= offset) { val += y; }
+      if (idx.local[1] * idx.tile_dim[0] >= offset) {
+        val += y;
+      }
     }
 
     // pass accum to all threads
-    local_total = shfl_workgroup_broadcast<ValueType>(val,
-                                            idx.local[0]+Impl::ROCmTraits::WavefrontSize-idx.tile_dim[0],
-                                            Impl::ROCmTraits::WavefrontSize);
+    local_total = shfl_workgroup_broadcast<ValueType>(
+        val, idx.local[0] + Impl::ROCmTraits::WavefrontSize - idx.tile_dim[0],
+        Impl::ROCmTraits::WavefrontSize);
 
     // make EXCLUSIVE scan by shifting values over one
     val = shfl_up(val, idx.tile_dim[0], Impl::ROCmTraits::WavefrontSize);
-    if ( idx.local[1] == 0 ) { val = 0 ; }
+    if (idx.local[1] == 0) {
+      val = 0;
+    }
 
     val += accum;
-    lambda(i,val,true);
+    lambda(i, val, true);
     accum += local_total;
   }
 }
 
 // placeholder for future function
-template< typename iType, class Lambda, typename ValueType >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::TaskExec< Kokkos::Experimental::ROCm > >& loop_boundaries,
-   const Lambda & lambda)
-{
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::TaskExec<Kokkos::Experimental::ROCm> >& loop_boundaries,
+    const Lambda& lambda) {
   hc::tiled_index<3> idx = loop_boundaries.thread.idx();
-  ValueType accum = 0 ;
+  ValueType accum        = 0;
   ValueType val, y, local_total;
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     val = 0;
-    lambda(i,val,false);
+    lambda(i, val, false);
 
     // intra-idx.tile_dim[0] exclusive scan on 'val'
     // accum = accumulated, sum in total for this iteration
 
     // INCLUSIVE scan
-    for( int offset = 1 ; offset < idx.tile_dim[0] ; offset <<= 1 ) {
+    for (int offset = 1; offset < idx.tile_dim[0]; offset <<= 1) {
       y = shfl_up(val, offset, idx.tile_dim[0]);
-      if(idx.local[0] >= offset) { val += y; }
+      if (idx.local[0] >= offset) {
+        val += y;
+      }
     }
 
     // pass accum to all threads
-    local_total = shfl_workgroup_broadcast<ValueType>(val, idx.tile_dim[0]-1, 
-                                                 idx.tile_dim[0]);
+    local_total = shfl_workgroup_broadcast<ValueType>(val, idx.tile_dim[0] - 1,
+                                                      idx.tile_dim[0]);
 
     // make EXCLUSIVE scan by shifting values over one
     val = shfl_up(val, 1, idx.tile_dim[0]);
-    if ( idx.local[0] == 0 ) { val = 0 ; }
+    if (idx.local[0] == 0) {
+      val = 0;
+    }
 
     val += accum;
-    lambda(i,val,true);
+    lambda(i, val, true);
     accum += local_total;
   }
 }
 
-
 } /* namespace Kokkos */
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_ROCM_TASK_HPP */
-
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Tile.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Tile.hpp
index b4436ae156c2821e51fa307dfa6ce2b5dbf2cbb6..da95064eea8bd3691ccd9c8d1cdc39e080e1fbfc 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Tile.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Tile.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,14 +48,17 @@
 #include <memory>
 #include <ROCm/Kokkos_ROCm_Config.hpp>
 
-#if !defined( KOKKOS_ROCM_TILE_H )
+#if !defined(KOKKOS_ROCM_TILE_H)
 #define KOKKOS_ROCM_TILE_H
 
 // Macro to abstract out the enable_if craziness
-#define KOKKOS_ROCM_REQUIRES(...) \
-    bool KokkosROCmRequiresBool ## __LINE__ = true, typename std::enable_if<KokkosROCmRequiresBool ## __LINE__ && (__VA_ARGS__), int>::type = 0
+#define KOKKOS_ROCM_REQUIRES(...)                                    \
+  bool KokkosROCmRequiresBool##__LINE__ = true,                      \
+       typename std::enable_if < KokkosROCmRequiresBool##__LINE__ && \
+           (__VA_ARGS__),                                            \
+       int > ::type = 0
 
-// This number uniquely identifies the 1.5 release build.  
+// This number uniquely identifies the 1.5 release build.
 #if __hcc_workweek__ > 17160
 #define ROCM15 1
 #endif
@@ -62,7 +66,7 @@
 namespace Kokkos {
 namespace Impl {
 
-template<class T>
+template <class T>
 
 #if defined(ROCM15)
 using lds_t = T;
@@ -77,55 +81,46 @@ using lds_t = __attribute__((address_space(3))) T;
 // that will operate on address space 3 types
 
 #if defined(ROCM15)
-// 1.5 can't use std::copy et al for LDS access, so we define our own 
+// 1.5 can't use std::copy et al for LDS access, so we define our own
 // set of routines
-template<class I, class O>
-void rcopy(I first, I last, O out) [[hc]]
-{
-    while (first != last) *out++ = *first++;
+template <class I, class O>
+void rcopy(I first, I last, O out) [[hc]] {
+  while (first != last) *out++ = *first++;
 }
-template<class I,class F>
-void rfor_each(I first, I last, F f) [[hc]]
-{
-  for(;first!=last;++first) f(*first);
+template <class I, class F>
+void rfor_each(I first, I last, F f) [[hc]] {
+  for (; first != last; ++first) f(*first);
 }
 
-template<class I,class O,class F>
-void rtransform(I first, I last, O out, F f) [[hc]]
-{
-  while(first!=last) *out++ = f(*first++);
+template <class I, class O, class F>
+void rtransform(I first, I last, O out, F f) [[hc]] {
+  while (first != last) *out++ = f(*first++);
 }
 #endif
 
-
-inline std::size_t get_max_tile_size() KOKKOS_ROCM_TILE_RESTRIC_CPU
-{
-    return hc::accelerator().get_max_tile_static_size() - 1024;
+inline std::size_t get_max_tile_size() KOKKOS_ROCM_TILE_RESTRIC_CPU {
+  return hc::accelerator().get_max_tile_static_size() - 1024;
 }
 
-inline std::size_t get_max_tile_thread() KOKKOS_ROCM_TILE_RESTRIC_CPU
-{
-    return 64;
+inline std::size_t get_max_tile_thread() KOKKOS_ROCM_TILE_RESTRIC_CPU {
+  return 64;
 }
 
-inline int next_pow_2(int x) restrict(cpu, amp)
-{ 
-    --x;
-    x |= x >> 1;
-    x |= x >> 2;
-    x |= x >> 4;
-    x |= x >> 8;
-    x |= x >> 16;
-    return x+1;
+inline int next_pow_2(int x) restrict(cpu, amp) {
+  --x;
+  x |= x >> 1;
+  x |= x >> 2;
+  x |= x >> 4;
+  x |= x >> 8;
+  x |= x >> 16;
+  return x + 1;
 }
 
-template<class T>
-inline std::size_t get_tile_size(std::size_t n = 1,
-                                 std::size_t team = 64, 
-                                 std::size_t vector = 1) 
-                                 KOKKOS_ROCM_TILE_RESTRIC_CPU
-{
-  return team*vector;
+template <class T>
+inline std::size_t get_tile_size(std::size_t n = 1, std::size_t team = 64,
+                                 std::size_t vector = 1)
+    KOKKOS_ROCM_TILE_RESTRIC_CPU {
+  return team * vector;
   /*
     const auto size = sizeof(T) * n;
     const auto group_size = get_max_tile_size();
@@ -140,380 +135,317 @@ inline std::size_t get_tile_size(std::size_t n = 1,
   */
 }
 
-template<class T>
-struct array_view
-{
-    T* x;
-    std::size_t n;
-
-    array_view(T* xp, std::size_t np) [[hc]] [[cpu]] 
-    : x(xp), n(np)
-    {}
-
-    array_view(T* xp, T* yp) [[hc]] [[cpu]] 
-    : x(xp), n(yp-xp)
-    {}
-
-    T& operator[](std::size_t i) const [[hc]] [[cpu]]
-    {
-        return x[i];
-    }
-
-    std::size_t size() const [[hc]] [[cpu]]
-    {
-        return this->n;
-    }
-
-    T* data() const [[hc]] [[cpu]]
-    {
-        return x;
-    }
-
-    T* begin() const [[hc]] [[cpu]]
-    {
-        return x;
-    }
-
-    T* end() const [[hc]] [[cpu]]
-    {
-        return x+this->size();
-    }
+template <class T>
+struct array_view {
+  T* x;
+  std::size_t n;
+
+  array_view(T* xp, std::size_t np) [[hc]] [[cpu]] : x(xp), n(np) {}
+
+  array_view(T* xp, T* yp) [[hc]] [[cpu]] : x(xp), n(yp - xp) {}
+
+  T& operator[](std::size_t i) const [[hc]] [[cpu]] { return x[i]; }
+
+  std::size_t size() const [[hc]] [[cpu]] { return this->n; }
+
+  T* data() const [[hc]] [[cpu]] { return x; }
+
+  T* begin() const [[hc]] [[cpu]] { return x; }
+
+  T* end() const [[hc]] [[cpu]] { return x + this->size(); }
 };
 
-template<class T>
-struct rocm_char
-{ using type=char; };
+template <class T>
+struct rocm_char {
+  using type = char;
+};
 
-template<class T>
-struct rocm_char<const T>
-: std::add_const<typename rocm_char<T>::type>
-{};
+template <class T>
+struct rocm_char<const T> : std::add_const<typename rocm_char<T>::type> {};
 #if !defined(ROCM15)
 // earlier compilers required explicit address space decorations
-template<class T>
-struct rocm_char<__attribute__((address_space(3))) T>
-{ using type = __attribute__((address_space(3))) typename rocm_char<T>::type; };
+template <class T>
+struct rocm_char<__attribute__((address_space(3))) T> {
+  using type = __attribute__((address_space(3))) typename rocm_char<T>::type;
+};
 
-template<class T>
-struct rocm_char<const __attribute__((address_space(3))) T>
-{ using type = const __attribute__((address_space(3))) typename rocm_char<T>::type; };
+template <class T>
+struct rocm_char<const __attribute__((address_space(3))) T> {
+  using type =
+      const __attribute__((address_space(3))) typename rocm_char<T>::type;
+};
 #endif
 
-template<class T, class Char=typename rocm_char<T>::type>
-Char* rocm_byte_cast(T& x) restrict(cpu, amp)
-{
-    return reinterpret_cast<Char*>(&x);
+template <class T, class Char = typename rocm_char<T>::type>
+Char* rocm_byte_cast(T& x) restrict(cpu, amp) {
+  return reinterpret_cast<Char*>(&x);
 }
 
-template<class T, class U>
-void rocm_raw_assign(T& x, const U& y) restrict(cpu, amp)
-{
-    auto * src = rocm_byte_cast(y);
-    auto * dest = rocm_byte_cast(x);
-#if defined (ROCM15)
-    rcopy(src, src+sizeof(T), dest);
+template <class T, class U>
+void rocm_raw_assign(T& x, const U& y) restrict(cpu, amp) {
+  auto* src  = rocm_byte_cast(y);
+  auto* dest = rocm_byte_cast(x);
+#if defined(ROCM15)
+  rcopy(src, src + sizeof(T), dest);
 #else
-    std::copy(src, src+sizeof(T), dest);
+  std::copy(src, src + sizeof(T), dest);
 #endif
 }
 
-template<class T, class U>
-void rocm_assign_impl(T& x, const U& y, std::true_type) restrict(cpu, amp)
-{
-    rocm_raw_assign(x, y);
+template <class T, class U>
+void rocm_assign_impl(T& x, const U& y, std::true_type) restrict(cpu, amp) {
+  rocm_raw_assign(x, y);
 }
 
-template<class T, class U>
-void rocm_assign_impl(T& x, const U& y, std::false_type) restrict(cpu, amp)
-{
-    x = y;
+template <class T, class U>
+void rocm_assign_impl(T& x, const U& y, std::false_type) restrict(cpu, amp) {
+  x = y;
 }
 
 // Workaround for assigning in and out of LDS memory
-template<class T, class U>
-void rocm_assign(T& x, const U& y) restrict(cpu, amp)
-{
-    rocm_assign_impl(x, y, std::integral_constant<bool, (
-        sizeof(T) == sizeof(U)
-    )>());
+template <class T, class U>
+void rocm_assign(T& x, const U& y) restrict(cpu, amp) {
+  rocm_assign_impl(x, y,
+                   std::integral_constant<bool, (sizeof(T) == sizeof(U))>());
 }
 
 // Compute the address space of tile
-template<class T>
-struct tile_type
-{
-#if defined (ROCM15)
-    typedef T type;
+template <class T>
+struct tile_type {
+#if defined(ROCM15)
+  typedef T type;
 #else
-    typedef __attribute__((address_space(3))) T type;
+  typedef __attribute__((address_space(3))) T type;
 #endif
 };
 
-#if !defined (ROCM15)
-template<class T, class Body>
-void lds_for(__attribute__((address_space(3))) T& value, Body b) [[hc]]
-{
-    T state = value;
-    b(state);
-    value = state;
+#if !defined(ROCM15)
+template <class T, class Body>
+void lds_for(__attribute__((address_space(3))) T& value, Body b) [[hc]] {
+  T state = value;
+  b(state);
+  value = state;
 }
 #endif
 
-template<class T, class Body>
-void lds_for(T& value, Body b) [[hc]]
-{
-    b(value);
+template <class T, class Body>
+void lds_for(T& value, Body b) [[hc]] {
+  b(value);
 }
 
+constexpr std::size_t get_max_tile_array_size() { return 24; }
 
-constexpr std::size_t get_max_tile_array_size()
-{
-    return 24;
-}
-
-template<class Derived, class T>
-struct single_action
-{
-    template<class Action>
-    void action_at(std::size_t i, Action a) [[hc]]
-    {
-        auto& value = static_cast<Derived&>(*this)[i];
+template <class Derived, class T>
+struct single_action {
+  template <class Action>
+  void action_at(std::size_t i, Action a) [[hc]] {
+    auto& value = static_cast<Derived&>(*this)[i];
 #ifdef KOKKOS_IMPL_ROCM_CLANG_WORKAROUND
-        T state = value;
-        a(state);
-        value = state;
+    T state = value;
+    a(state);
+    value = state;
 #else
-        a(value);
+    a(value);
 #endif
-    }
-
-    template<class Action>
-    void action_at(std::size_t i, std::size_t j, Action a) [[hc]]
-    {
-        static_cast<Derived&>(*this).action_at(i, [&](T& x)
-        {
-            static_cast<Derived&>(*this).action_at(j, [&](T& y)
-            {
-                a(x, y);
-            });
-        });
-    }
+  }
+
+  template <class Action>
+  void action_at(std::size_t i, std::size_t j, Action a) [[hc]] {
+    static_cast<Derived&>(*this).action_at(i, [&](T& x) {
+      static_cast<Derived&>(*this).action_at(j, [&](T& y) { a(x, y); });
+    });
+  }
 };
 
-template<class T>
-struct tile_buffer
-: array_view<typename tile_type<T>::type>, single_action<tile_buffer<T>, T>
-{
-    typedef typename tile_type<T>::type element_type;
-    typedef array_view<element_type> base;
+template <class T>
+struct tile_buffer : array_view<typename tile_type<T>::type>,
+                     single_action<tile_buffer<T>, T> {
+  typedef typename tile_type<T>::type element_type;
+  typedef array_view<element_type> base;
 
-    using base::base;
+  using base::base;
 
-    tile_buffer(element_type* xp, std::size_t np, std::size_t) [[hc]] [[cpu]] 
-    : base(xp, np)
-    {}
+  tile_buffer(element_type* xp, std::size_t np, std::size_t) [[hc]] [[cpu]]
+  : base(xp, np) {}
 
-    tile_buffer(T* xp, T* yp, std::size_t) [[hc]] [[cpu]] 
-    : base(xp, yp)
-    {}
+  tile_buffer(T* xp, T* yp, std::size_t) [[hc]] [[cpu]] : base(xp, yp) {}
 };
 
-template<class T>
-struct tile_buffer<T[]>
-{
-    typedef typename tile_type<T>::type element_type;
-    typedef typename tile_type<char>::type tchar_type;
-    element_type* element_data;
-    std::size_t n, m;
-
-    tile_buffer(element_type* xp, std::size_t np, std::size_t mp) [[hc]] [[cpu]] 
-    : element_data(xp), n(np), m(mp)
-    {}
-
-    tile_buffer(element_type* xp, element_type* yp, std::size_t mp) [[hc]] [[cpu]] 
-    : element_data(xp), n(yp-xp), m(mp)
-    {}
-
-    element_type* operator[](std::size_t i) const [[hc]] [[cpu]]
-    {
-        return element_data+i*m;
-    }
-
-    template<class Action, class Q = T>
-    typename Impl::enable_if< (sizeof(Q) <= 8) , void >::type
-    action_at(std::size_t i, Action a) [[hc]]
-    {
-        element_type* value = (*this)[i];
-#if defined (ROCM15)
-        a(value);
+template <class T>
+struct tile_buffer<T[]> {
+  typedef typename tile_type<T>::type element_type;
+  typedef typename tile_type<char>::type tchar_type;
+  element_type* element_data;
+  std::size_t n, m;
+
+  tile_buffer(element_type* xp, std::size_t np, std::size_t mp) [[hc]] [[cpu]]
+  : element_data(xp),
+    n(np),
+    m(mp) {}
+
+  tile_buffer(element_type* xp, element_type* yp, std::size_t mp) [[hc]] [[cpu]]
+  : element_data(xp),
+    n(yp - xp),
+    m(mp) {}
+
+  element_type* operator[](std::size_t i) const [[hc]] [[cpu]] {
+    return element_data + i * m;
+  }
+
+  template <class Action, class Q = T>
+  typename Impl::enable_if<(sizeof(Q) <= 8), void>::type action_at(
+      std::size_t i, Action a) [[hc]] {
+    element_type* value = (*this)[i];
+#if defined(ROCM15)
+    a(value);
 #else
 #ifdef KOKKOS_IMPL_ROCM_CLANG_WORKAROUND
-        if (m > get_max_tile_array_size()) return;
-        T state[get_max_tile_array_size()];
-        // std::copy(value, value+m, state);
-        // Workaround for assigning from LDS memory
-        std::transform(value, value+m, state, [](element_type& x)
-        {
-          T result;
-          rocm_assign(result, x);
-          return result;
-        });
-        a(state);
-        std::copy(state, state+m, value);
+    if (m > get_max_tile_array_size()) return;
+    T state[get_max_tile_array_size()];
+    // std::copy(value, value+m, state);
+    // Workaround for assigning from LDS memory
+    std::transform(value, value + m, state, [](element_type& x) {
+      T result;
+      rocm_assign(result, x);
+      return result;
+    });
+    a(state);
+    std::copy(state, state + m, value);
 #endif
 #endif
-    }
-
-    template<class Action, class Q = T>
-    typename Impl::enable_if< !(sizeof(Q) <= 8) , void >::type
-    action_at(std::size_t i, Action a) [[hc]]
-    {
-        element_type* value = (*this)[i];
-#if defined (ROCM15)
-        a(value);
+  }
+
+  template <class Action, class Q = T>
+  typename Impl::enable_if<!(sizeof(Q) <= 8), void>::type action_at(
+      std::size_t i, Action a) [[hc]] {
+    element_type* value = (*this)[i];
+#if defined(ROCM15)
+    a(value);
 #else
-        if (m > get_max_tile_array_size()) return;
-        T state[get_max_tile_array_size()];
-        // std::copy(value, value+m, state);
-        // Workaround for assigning from LDS memory
-        std::transform(value, value+m, state, [](element_type& x)
-        {
-          T result;
-          rocm_assign(result, x);
-          return result;
-        });
-        a(state);
-        // this workaround required when T is greater than 8 bytes
-        tile_static char tv[64*sizeof(T)];
-        size_t sT = sizeof(T);
-        for (int j = 0; j<sT; j++) tv[i*sT+j] = ((char *)state)[j];
-        for (int j = 0; j<sT; j++) ((tchar_type *)value)[j] = tv[i*sT+j];
+    if (m > get_max_tile_array_size()) return;
+    T state[get_max_tile_array_size()];
+    // std::copy(value, value+m, state);
+    // Workaround for assigning from LDS memory
+    std::transform(value, value + m, state, [](element_type& x) {
+      T result;
+      rocm_assign(result, x);
+      return result;
+    });
+    a(state);
+    // this workaround required when T is greater than 8 bytes
+    tile_static char tv[64 * sizeof(T)];
+    size_t sT = sizeof(T);
+    for (int j = 0; j < sT; j++) tv[i * sT + j] = ((char*)state)[j];
+    for (int j = 0; j < sT; j++) ((tchar_type*)value)[j] = tv[i * sT + j];
 #endif
-    }
-
-    template<class Action>
-    void action_at(std::size_t i, std::size_t j, Action a) [[hc]]
-    {
-        this->action_at(i, [&](T* x)
-        {
-            this->action_at(j, [&](T* y)
-            {
-                a(x, y);
-            });
-        });
-    }
-
-    std::size_t size() const [[hc]] [[cpu]]
-    {
-        return this->n;
-    }
-
-    element_type* data() const [[hc]] [[cpu]]
-    {
-        return element_data;
-    }
+  }
+
+  template <class Action>
+  void action_at(std::size_t i, std::size_t j, Action a) [[hc]] {
+    this->action_at(i,
+                    [&](T* x) { this->action_at(j, [&](T* y) { a(x, y); }); });
+  }
+
+  std::size_t size() const [[hc]] [[cpu]] { return this->n; }
+
+  element_type* data() const [[hc]] [[cpu]] { return element_data; }
 };
 
 // Zero initialize LDS memory
-struct zero_init_f
-{
-    template<class T>
-#if defined (ROCM15)
-    void operator()(T& x, std::size_t=1) const [[hc]]
-    {
-        auto * start = reinterpret_cast<char*>(&x);
-        for(int i=0; i<sizeof(T);i++) start[i] = 0;
-        rocm_raw_assign(x, T());
-    }
+struct zero_init_f {
+  template <class T>
+#if defined(ROCM15)
+  void operator()(T& x, std::size_t = 1) const [[hc]] {
+    auto* start = reinterpret_cast<char*>(&x);
+    for (int i = 0; i < sizeof(T); i++) start[i] = 0;
+    rocm_raw_assign(x, T());
+  }
 #else
-    void operator()(__attribute__((address_space(3))) T& x, std::size_t=1) const [[hc]]
-    {
-        auto * start = reinterpret_cast<__attribute__((address_space(3))) char*>(&x);
-        std::fill(start, start+sizeof(T), 0);
-        rocm_raw_assign(x, T());
-    }
+  void operator()(__attribute__((address_space(3))) T& x, std::size_t = 1) const
+      [[hc]] {
+    auto* start = reinterpret_cast<__attribute__((address_space(3))) char*>(&x);
+    std::fill(start, start + sizeof(T), 0);
+    rocm_raw_assign(x, T());
+  }
 #endif
 
-    template<class T>
-#if defined (ROCM15)
-    void operator()(T* x, std::size_t size) const [[hc]]
-    {
-        rfor_each(x, x+size, *this);
-    }
+  template <class T>
+#if defined(ROCM15)
+  void operator()(T* x, std::size_t size) const [[hc]] {
+    rfor_each(x, x + size, *this);
+  }
 #else
-    void operator()(__attribute__((address_space(3))) T* x, std::size_t size) const [[hc]]
-    {
-        std::for_each(x, x+size, *this);
-    }
+  void operator()(__attribute__((address_space(3))) T* x,
+                  std::size_t size) const [[hc]] {
+    std::for_each(x, x + size, *this);
+  }
 #endif
 };
 
 static constexpr zero_init_f zero_init = {};
 
-struct tile_desc
-{
-    // Number of work items, or size of extent
-    std::size_t elements;
-    // number of threads in team 
-    std::size_t team_size;
-    // vector length of team
-    std::size_t vector_length;
-    // Size of tile
-    std::size_t tile_size;
-    // Size of array
-    std::size_t array_size;
-    // Number of tiles
-    std::size_t num_tiles;
-    // Per team reserved LDS memory, used for reduction
-    std::size_t reduce_size;
-    // Per team shared memory in LDS, this in addition to reduce shared mem
-    std::size_t shared_size;
-    std::size_t size;
+struct tile_desc {
+  // Number of work items, or size of extent
+  std::size_t elements;
+  // number of threads in team
+  std::size_t team_size;
+  // vector length of team
+  std::size_t vector_length;
+  // Size of tile
+  std::size_t tile_size;
+  // Size of array
+  std::size_t array_size;
+  // Number of tiles
+  std::size_t num_tiles;
+  // Per team reserved LDS memory, used for reduction
+  std::size_t reduce_size;
+  // Per team shared memory in LDS, this in addition to reduce shared mem
+  std::size_t shared_size;
+  std::size_t size;
 };
 
-template<class T>
-tile_desc get_tile_desc(std::size_t size, 
-                        std::size_t array_size=1,
-                        std::size_t team_size=64,
-                        std::size_t vector_size=1,
-                        std::size_t shared_size=0)
-{
-    tile_desc result;
-    result.elements = size;
-    result.array_size = array_size;
-    result.vector_length = vector_size;
-    result.team_size = team_size;
-    result.tile_size = get_tile_size<T>(array_size,team_size,vector_size);
-    result.num_tiles = std::ceil(1.0 * size / result.tile_size);
-    result.reduce_size = result.tile_size * sizeof(T) * array_size;
-    result.shared_size = shared_size;
-    result.size = result.tile_size * result.num_tiles;
-
-    return result;
+template <class T>
+tile_desc get_tile_desc(std::size_t size, std::size_t array_size = 1,
+                        std::size_t team_size = 64, std::size_t vector_size = 1,
+                        std::size_t shared_size = 0) {
+  tile_desc result;
+  result.elements      = size;
+  result.array_size    = array_size;
+  result.vector_length = vector_size;
+  result.team_size     = team_size;
+  result.tile_size     = get_tile_size<T>(array_size, team_size, vector_size);
+  result.num_tiles     = std::ceil(1.0 * size / result.tile_size);
+  result.reduce_size   = result.tile_size * sizeof(T) * array_size;
+  result.shared_size   = shared_size;
+  result.size          = result.tile_size * result.num_tiles;
+
+  return result;
 }
 
-template<class U, class F, class T=typename std::remove_extent<U>::type>
-hc::completion_future tile_for(tile_desc td, F f) 
-{
-    assert(td.array_size <= get_max_tile_array_size() && "Exceed max array size");
-    assert(((td.size % td.tile_size) == 0) && "Tile size must be divisible by extent");
-    auto grid = hc::extent<1>(td.size).tile_with_dynamic(
-                          td.tile_size, td.reduce_size + td.shared_size);
-    // grid.set_dynamic_group_segment_size(td.reduce_size + td.shared_size);
-    return parallel_for_each(grid, [=](hc::tiled_index<1> t_idx) [[hc]] 
-    {
-#if defined (ROCM15)
+template <class U, class F, class T = typename std::remove_extent<U>::type>
+hc::completion_future tile_for(tile_desc td, F f) {
+  assert(td.array_size <= get_max_tile_array_size() && "Exceed max array size");
+  assert(((td.size % td.tile_size) == 0) &&
+         "Tile size must be divisible by extent");
+  auto grid = hc::extent<1>(td.size).tile_with_dynamic(
+      td.tile_size, td.reduce_size + td.shared_size);
+  // grid.set_dynamic_group_segment_size(td.reduce_size + td.shared_size);
+  return parallel_for_each(
+      grid, [=](hc::tiled_index<1> t_idx) [[hc]] {
+#if defined(ROCM15)
         typedef T group_t;
 #else
         typedef __attribute__((address_space(3))) T group_t;
 #endif
-        group_t * buffer = (group_t *)hc::get_dynamic_group_segment_base_pointer();
+        group_t* buffer =
+            (group_t*)hc::get_dynamic_group_segment_base_pointer();
         tile_buffer<U> tb(buffer, td.tile_size, td.array_size);
         zero_init(tb[t_idx.local[0]], td.array_size);
         f(t_idx, tb);
-    });
+      });
 }
 
-}}
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Vectorization.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Vectorization.hpp
index 36f886109c495564ce2e7b57f73df896a2adc598..157c15695b0a0985c8487033f1536d62934b8ae8 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Vectorization.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_Vectorization.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -62,285 +63,288 @@ using namespace hc;
 // and it controls whether shfl_down() gets called.)
 namespace Impl {
 
-  template< typename Scalar >
-  struct shfl_union {
-    enum {n = sizeof(Scalar)/4};
-    float fval[n];
-    KOKKOS_INLINE_FUNCTION
-    Scalar value() {
-      return *(Scalar*) fval;
-    }
-    KOKKOS_INLINE_FUNCTION
-    void operator= (Scalar& value_) {
-      float* const val_ptr = (float*) &value_;
-      for(int i=0; i<n ; i++) {
-        fval[i] = val_ptr[i];
-      }
+template <typename Scalar>
+struct shfl_union {
+  enum { n = sizeof(Scalar) / 4 };
+  float fval[n];
+  KOKKOS_INLINE_FUNCTION
+  Scalar value() { return *(Scalar*)fval; }
+  KOKKOS_INLINE_FUNCTION
+  void operator=(Scalar& value_) {
+    float* const val_ptr = (float*)&value_;
+    for (int i = 0; i < n; i++) {
+      fval[i] = val_ptr[i];
     }
-    KOKKOS_INLINE_FUNCTION
-    void operator= (const Scalar& value_) {
-      float* const val_ptr = (float*) &value_;
-      for(int i=0; i<n ; i++) {
-        fval[i] = val_ptr[i];
-      }
+  }
+  KOKKOS_INLINE_FUNCTION
+  void operator=(const Scalar& value_) {
+    float* const val_ptr = (float*)&value_;
+    for (int i = 0; i < n; i++) {
+      fval[i] = val_ptr[i];
     }
-
-  };
-}
+  }
+};
+}  // namespace Impl
 
 #ifdef __HCC_ACCELERATOR__
 
-    KOKKOS_INLINE_FUNCTION
-    int __long2loint(const long val ) {
-    union {
-      long l;
-      int i[2];
-    } u;
-      u.l = val;
-      return u.i[0];
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    int __long2hiint(const long val ) {
-    union {
-      long l;
-      int i[2];
-    } u;
-      u.l = val;
-      return u.i[1];
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    int __double2loint(const double val ) {
-    union {
-      double d;
-      int i[2];
-    } u;
-      u.d = val;
-      return u.i[0];
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    int __double2hiint(const double val ) {
-    union {
-      double d;
-      int i[2];
-    } u;
-      u.d = val;
-      return u.i[1];
-    }
+KOKKOS_INLINE_FUNCTION
+int __long2loint(const long val) {
+  union {
+    long l;
+    int i[2];
+  } u;
+  u.l = val;
+  return u.i[0];
+}
 
-    KOKKOS_INLINE_FUNCTION
-    long __hiloint2long(const int hi, const int lo ) {
-    union {
-      long l;
-      int i[2];
-    } u;
-      u.i[0] = lo;
-      u.i[1] = hi;
-      return u.l;
-    }
+KOKKOS_INLINE_FUNCTION
+int __long2hiint(const long val) {
+  union {
+    long l;
+    int i[2];
+  } u;
+  u.l = val;
+  return u.i[1];
+}
 
-    KOKKOS_INLINE_FUNCTION
-    double __hiloint2double(const int hi, const int lo ) {
-    union {
-      double d;
-      int i[2];
-    } u;
-      u.i[0] = lo;
-      u.i[1] = hi;
-      return u.d;
-    }
+KOKKOS_INLINE_FUNCTION
+int __double2loint(const double val) {
+  union {
+    double d;
+    int i[2];
+  } u;
+  u.d = val;
+  return u.i[0];
+}
 
-    KOKKOS_INLINE_FUNCTION
-    int shfl(const int &val, const int& srcLane, const int& width ) {
-      return __shfl(val,srcLane,width);
-    }
+KOKKOS_INLINE_FUNCTION
+int __double2hiint(const double val) {
+  union {
+    double d;
+    int i[2];
+  } u;
+  u.d = val;
+  return u.i[1];
+}
 
-    KOKKOS_INLINE_FUNCTION
-    float shfl(const float &val, const int& srcLane, const int& width ) {
-      return __shfl(val,srcLane,width);
-    }
+KOKKOS_INLINE_FUNCTION
+long __hiloint2long(const int hi, const int lo) {
+  union {
+    long l;
+    int i[2];
+  } u;
+  u.i[0] = lo;
+  u.i[1] = hi;
+  return u.l;
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const typename Impl::enable_if< (sizeof(Scalar) == 4) , int >::type& width
-        ) {
-      Scalar tmp1 = val;
-      float tmp = *reinterpret_cast<float*>(&tmp1);
-      tmp = __shfl(tmp,srcLane,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
+KOKKOS_INLINE_FUNCTION
+double __hiloint2double(const int hi, const int lo) {
+  union {
+    double d;
+    int i[2];
+  } u;
+  u.i[0] = lo;
+  u.i[1] = hi;
+  return u.d;
+}
 
-    KOKKOS_INLINE_FUNCTION
-    double shfl(const double &val, const int& srcLane, const int& width) {
-      int lo = __double2loint(val);
-      int hi = __double2hiint(val);
-      lo = __shfl(lo,srcLane,width);
-      hi = __shfl(hi,srcLane,width);
-      return __hiloint2double(hi,lo);
-    }
+KOKKOS_INLINE_FUNCTION
+int shfl(const int& val, const int& srcLane, const int& width) {
+  return __shfl(val, srcLane, width);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const typename Impl::enable_if< (sizeof(Scalar) == 8) ,int>::type& width) {
-      int lo = __double2loint(*reinterpret_cast<const double*>(&val));
-      int hi = __double2hiint(*reinterpret_cast<const double*>(&val));
-      lo = __shfl(lo,srcLane,width);
-      hi = __shfl(hi,srcLane,width);
-      const double tmp = __hiloint2double(hi,lo);
-      return *(reinterpret_cast<const Scalar*>(&tmp));
-    }
+KOKKOS_INLINE_FUNCTION
+float shfl(const float& val, const int& srcLane, const int& width) {
+  return __shfl(val, srcLane, width);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl(const Scalar &val, const int& srcLane, const typename Impl::enable_if< (sizeof(Scalar) > 8) ,int>::type& width) {
-      Impl::shfl_union<Scalar> s_val;
-      Impl::shfl_union<Scalar> r_val;
-      s_val = val;
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar
+shfl(const Scalar& val, const int& srcLane,
+     const typename Impl::enable_if<(sizeof(Scalar) == 4), int>::type& width) {
+  Scalar tmp1 = val;
+  float tmp   = *reinterpret_cast<float*>(&tmp1);
+  tmp         = __shfl(tmp, srcLane, width);
+  return *reinterpret_cast<Scalar*>(&tmp);
+}
 
-      for(int i = 0; i<s_val.n; i++)
-        r_val.fval[i] = __shfl(s_val.fval[i],srcLane,width);
-      return r_val.value();
-    }
+KOKKOS_INLINE_FUNCTION
+double shfl(const double& val, const int& srcLane, const int& width) {
+  int lo = __double2loint(val);
+  int hi = __double2hiint(val);
+  lo     = __shfl(lo, srcLane, width);
+  hi     = __shfl(hi, srcLane, width);
+  return __hiloint2double(hi, lo);
+}
 
-    KOKKOS_INLINE_FUNCTION
-    int shfl_down(const int &val, const int& delta, const int& width) {
-      return __shfl_down(val,delta,width);
-    }
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar
+shfl(const Scalar& val, const int& srcLane,
+     const typename Impl::enable_if<(sizeof(Scalar) == 8), int>::type& width) {
+  int lo           = __double2loint(*reinterpret_cast<const double*>(&val));
+  int hi           = __double2hiint(*reinterpret_cast<const double*>(&val));
+  lo               = __shfl(lo, srcLane, width);
+  hi               = __shfl(hi, srcLane, width);
+  const double tmp = __hiloint2double(hi, lo);
+  return *(reinterpret_cast<const Scalar*>(&tmp));
+}
 
-    KOKKOS_INLINE_FUNCTION
-    float shfl_down(const float &val, const int& delta, const int& width) {
-      return __shfl_down(val,delta,width);
-    }
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar
+shfl(const Scalar& val, const int& srcLane,
+     const typename Impl::enable_if<(sizeof(Scalar) > 8), int>::type& width) {
+  Impl::shfl_union<Scalar> s_val;
+  Impl::shfl_union<Scalar> r_val;
+  s_val = val;
+
+  for (int i = 0; i < s_val.n; i++)
+    r_val.fval[i] = __shfl(s_val.fval[i], srcLane, width);
+  return r_val.value();
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 4) , int >::type & width) {
-      Scalar tmp1 = val;
-      float tmp = *reinterpret_cast<float*>(&tmp1);
-      tmp = __shfl_down(tmp,delta,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
+KOKKOS_INLINE_FUNCTION
+int shfl_down(const int& val, const int& delta, const int& width) {
+  return __shfl_down(val, delta, width);
+}
 
-    KOKKOS_INLINE_FUNCTION
-    long shfl_down(const long &val, const int& delta, const int& width) {
-      int lo = __long2loint(val);
-      int hi = __long2hiint(val);
-      lo = __shfl_down(lo,delta,width);
-      hi = __shfl_down(hi,delta,width);
-      return __hiloint2long(hi,lo);
-    }
+KOKKOS_INLINE_FUNCTION
+float shfl_down(const float& val, const int& delta, const int& width) {
+  return __shfl_down(val, delta, width);
+}
 
-    KOKKOS_INLINE_FUNCTION
-    double shfl_down(const double &val, const int& delta, const int& width) {
-      int lo = __double2loint(val);
-      int hi = __double2hiint(val);
-      lo = __shfl_down(lo,delta,width);
-      hi = __shfl_down(hi,delta,width);
-      return __hiloint2double(hi,lo);
-    }
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar shfl_down(
+    const Scalar& val, const int& delta,
+    const typename Impl::enable_if<(sizeof(Scalar) == 4), int>::type& width) {
+  Scalar tmp1 = val;
+  float tmp   = *reinterpret_cast<float*>(&tmp1);
+  tmp         = __shfl_down(tmp, delta, width);
+  return *reinterpret_cast<Scalar*>(&tmp);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 8) , int >::type & width) {
-      int lo = __double2loint(*reinterpret_cast<const double*>(&val));
-      int hi = __double2hiint(*reinterpret_cast<const double*>(&val));
-      lo = __shfl_down(lo,delta,width);
-      hi = __shfl_down(hi,delta,width);
-      const double tmp = __hiloint2double(hi,lo);
-      return *(reinterpret_cast<const Scalar*>(&tmp));
-    }
+KOKKOS_INLINE_FUNCTION
+long shfl_down(const long& val, const int& delta, const int& width) {
+  int lo = __long2loint(val);
+  int hi = __long2hiint(val);
+  lo     = __shfl_down(lo, delta, width);
+  hi     = __shfl_down(hi, delta, width);
+  return __hiloint2long(hi, lo);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_down(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) > 8) , int >::type & width) {
-      Impl::shfl_union<Scalar> s_val;
-      Impl::shfl_union<Scalar> r_val;
-      s_val = val;
+KOKKOS_INLINE_FUNCTION
+double shfl_down(const double& val, const int& delta, const int& width) {
+  int lo = __double2loint(val);
+  int hi = __double2hiint(val);
+  lo     = __shfl_down(lo, delta, width);
+  hi     = __shfl_down(hi, delta, width);
+  return __hiloint2double(hi, lo);
+}
 
-      for(int i = 0; i<s_val.n; i++)
-        r_val.fval[i] = __shfl_down(s_val.fval[i],delta,width);
-      return r_val.value();
-    }
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar shfl_down(
+    const Scalar& val, const int& delta,
+    const typename Impl::enable_if<(sizeof(Scalar) == 8), int>::type& width) {
+  int lo           = __double2loint(*reinterpret_cast<const double*>(&val));
+  int hi           = __double2hiint(*reinterpret_cast<const double*>(&val));
+  lo               = __shfl_down(lo, delta, width);
+  hi               = __shfl_down(hi, delta, width);
+  const double tmp = __hiloint2double(hi, lo);
+  return *(reinterpret_cast<const Scalar*>(&tmp));
+}
 
-    KOKKOS_INLINE_FUNCTION
-    int shfl_up(const int &val, const int& delta, const int& width ) {
-      return __shfl_up(val,delta,width);
-    }
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar shfl_down(
+    const Scalar& val, const int& delta,
+    const typename Impl::enable_if<(sizeof(Scalar) > 8), int>::type& width) {
+  Impl::shfl_union<Scalar> s_val;
+  Impl::shfl_union<Scalar> r_val;
+  s_val = val;
+
+  for (int i = 0; i < s_val.n; i++)
+    r_val.fval[i] = __shfl_down(s_val.fval[i], delta, width);
+  return r_val.value();
+}
 
-    KOKKOS_INLINE_FUNCTION
-    float shfl_up(const float &val, const int& delta, const int& width ) {
-      return __shfl_up(val,delta,width);
-    }
+KOKKOS_INLINE_FUNCTION
+int shfl_up(const int& val, const int& delta, const int& width) {
+  return __shfl_up(val, delta, width);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 4) , int >::type & width) {
-      Scalar tmp1 = val;
-      float tmp = *reinterpret_cast<float*>(&tmp1);
-      tmp = __shfl_up(tmp,delta,width);
-      return *reinterpret_cast<Scalar*>(&tmp);
-    }
+KOKKOS_INLINE_FUNCTION
+float shfl_up(const float& val, const int& delta, const int& width) {
+  return __shfl_up(val, delta, width);
+}
 
-    KOKKOS_INLINE_FUNCTION
-    double shfl_up(const double &val, const int& delta, const int& width ) {
-      int lo = __double2loint(val);
-      int hi = __double2hiint(val);
-      lo = __shfl_up(lo,delta,width);
-      hi = __shfl_up(hi,delta,width);
-      return __hiloint2double(hi,lo);
-    }
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar shfl_up(
+    const Scalar& val, const int& delta,
+    const typename Impl::enable_if<(sizeof(Scalar) == 4), int>::type& width) {
+  Scalar tmp1 = val;
+  float tmp   = *reinterpret_cast<float*>(&tmp1);
+  tmp         = __shfl_up(tmp, delta, width);
+  return *reinterpret_cast<Scalar*>(&tmp);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) == 8) , int >::type & width) {
-      int lo = __double2loint(*reinterpret_cast<const double*>(&val));
-      int hi = __double2hiint(*reinterpret_cast<const double*>(&val));
-      lo = __shfl_up(lo,delta,width);
-      hi = __shfl_up(hi,delta,width);
-      const double tmp = __hiloint2double(hi,lo);
-      return *(reinterpret_cast<const Scalar*>(&tmp));
-    }
+KOKKOS_INLINE_FUNCTION
+double shfl_up(const double& val, const int& delta, const int& width) {
+  int lo = __double2loint(val);
+  int hi = __double2hiint(val);
+  lo     = __shfl_up(lo, delta, width);
+  hi     = __shfl_up(hi, delta, width);
+  return __hiloint2double(hi, lo);
+}
 
-    template<typename Scalar>
-    KOKKOS_INLINE_FUNCTION
-    Scalar shfl_up(const Scalar &val, const int& delta, const typename Impl::enable_if< (sizeof(Scalar) > 8) , int >::type & width) {
-      Impl::shfl_union<Scalar> s_val;
-      Impl::shfl_union<Scalar> r_val;
-      s_val = val;
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar shfl_up(
+    const Scalar& val, const int& delta,
+    const typename Impl::enable_if<(sizeof(Scalar) == 8), int>::type& width) {
+  int lo           = __double2loint(*reinterpret_cast<const double*>(&val));
+  int hi           = __double2hiint(*reinterpret_cast<const double*>(&val));
+  lo               = __shfl_up(lo, delta, width);
+  hi               = __shfl_up(hi, delta, width);
+  const double tmp = __hiloint2double(hi, lo);
+  return *(reinterpret_cast<const Scalar*>(&tmp));
+}
 
-      for(int i = 0; i<s_val.n; i++)
-        r_val.fval[i] = __shfl_up(s_val.fval[i],delta,width);
-      return r_val.value();
-    }
+template <typename Scalar>
+KOKKOS_INLINE_FUNCTION Scalar shfl_up(
+    const Scalar& val, const int& delta,
+    const typename Impl::enable_if<(sizeof(Scalar) > 8), int>::type& width) {
+  Impl::shfl_union<Scalar> s_val;
+  Impl::shfl_union<Scalar> r_val;
+  s_val = val;
+
+  for (int i = 0; i < s_val.n; i++)
+    r_val.fval[i] = __shfl_up(s_val.fval[i], delta, width);
+  return r_val.value();
+}
 
 #else
-    template<typename Scalar>
-    inline
-    Scalar shfl(const Scalar &val, const int& srcLane, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl from a device with CC<8.0.");
-      return val;
-    }
+template <typename Scalar>
+inline Scalar shfl(const Scalar& val, const int& srcLane, const int& width) {
+  if (width > 1)
+    Kokkos::abort("Error: calling shfl from a device with CC<8.0.");
+  return val;
+}
 
-    template<typename Scalar>
-    inline
-    Scalar shfl_down(const Scalar &val, const int& delta, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl_down from a device with CC<8.0.");
-      return val;
-    }
+template <typename Scalar>
+inline Scalar shfl_down(const Scalar& val, const int& delta, const int& width) {
+  if (width > 1)
+    Kokkos::abort("Error: calling shfl_down from a device with CC<8.0.");
+  return val;
+}
 
-    template<typename Scalar>
-    inline
-    Scalar shfl_up(const Scalar &val, const int& delta, const int& width) {
-      if(width > 1) Kokkos::abort("Error: calling shfl_down from a device with CC<8.0.");
-      return val;
-    }
+template <typename Scalar>
+inline Scalar shfl_up(const Scalar& val, const int& delta, const int& width) {
+  if (width > 1)
+    Kokkos::abort("Error: calling shfl_down from a device with CC<8.0.");
+  return val;
+}
 #endif
 
+}  // namespace Kokkos
 
-
-}
-
-#endif // KOKKOS_ENABLE_ROCM
+#endif  // KOKKOS_ENABLE_ROCM
 #endif
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIAvail.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIAvail.hpp
index 0f7f399a57885be00193a6d971d09ec79cf21e1b..018151b3092bfce729d995173c6bc255ba55c751 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIAvail.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIAvail.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::ROCm
 
-#include<eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIDecl.hpp b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIDecl.hpp
index f7ed4cea8ecb30b25cb3721f2f8bad4bc7920702..db02a49c8a45eefd8c31b436acfc1cb4bbd634de 100644
--- a/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIDecl.hpp
+++ b/lib/kokkos/core/src/ROCm/Kokkos_ROCm_ViewCopyETIDecl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::ROCm
 
-#include<eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/ROCm/hc_math_std.hpp b/lib/kokkos/core/src/ROCm/hc_math_std.hpp
index 56c2e634e45b7e7e6ae9af8e244a017217e21850..b637507130be6d6b5f8bc148cc169c3b045b6ba5 100644
--- a/lib/kokkos/core/src/ROCm/hc_math_std.hpp
+++ b/lib/kokkos/core/src/ROCm/hc_math_std.hpp
@@ -9,225 +9,230 @@
 
 #ifdef __KALMAR_ACCELERATOR__
 
-#define HC_MATH_WRAPPER_1(function, arg1) \
-template<typename T> \
-inline T function(T arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1); \
-}
+#define HC_MATH_WRAPPER_1(function, arg1)              \
+  template <typename T>                                \
+  inline T function(T arg1) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1);           \
+  }
 
 #define KALMAR_MATH_WRAPPER_1(function, arg1) HC_MATH_WRAPPER_1(function, arg1)
 
-#define HC_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1) \
-template<typename T> \
-inline \
-typename std::enable_if<std::is_integral<T>::value,HC_IMPLICIT_FLOAT_CONV>::type \
- function(T arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1)); \
-} \
-template<typename T> \
-inline \
-typename std::enable_if<std::is_floating_point <T>::value,T>::type \
- function(T arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1); \
-}
-
-#define KALMAR_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1) HC_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1) 
-
-#define HC_MATH_WRAPPER_2(function, arg1, arg2) \
-template<typename T> \
-inline T function(T arg1, T arg2) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1, arg2); \
-}
-
-#define HC_MATH_ALIAS_2(alias, function, arg1, arg2) \
-template<typename T> \
-inline T alias(T arg1, T arg2) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1, arg2); \
-}
-
-#define HC_MATH_WRAPPER_3(function, arg1, arg2, arg3) \
-template<typename T> \
-inline T function(T arg1, T arg2, T arg3) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1, arg2, arg3); \
-}
-
-#define HC_MATH_WRAPPER_TQ(function, arg1) \
-template<typename T, typename Q> \
-inline T function(Q arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1); \
-}
-
-#define HC_MATH_WRAPPER_FP_OVERLOAD_TQ(function, T, arg1) \
-template<typename Q> \
-inline \
-typename std::enable_if<std::is_integral<Q>::value,T>::type \
-function(Q arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1)); \
-}\
-template<typename Q> \
-inline \
-typename std::enable_if<std::is_floating_point<Q>::value,T>::type \
-function(Q arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1); \
-}
-
-#define HC_MATH_WRAPPER_TTQ(function, arg1, arg2) \
-template<typename T, typename Q> \
-inline T function(T arg1, Q arg2) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1, arg2); \
-}
-
-#define HC_MATH_WRAPPER_FP_OVERLOAD_TTQ(function, arg1, arg2) \
-template<typename T, typename Q> \
-inline \
-typename std::enable_if<std::is_integral<T>::value||std::is_integral<Q>::value,HC_IMPLICIT_FLOAT_CONV>::type \
-function(T arg1, Q arg2) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1),static_cast<HC_IMPLICIT_FLOAT_CONV>(arg2)); \
-}\
-template<typename T, typename Q> \
-inline \
-typename std::enable_if<std::is_floating_point<T>::value&&std::is_floating_point<Q>::value,T>::type \
-function(T arg1, Q arg2) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1,arg2); \
-}
-
-#define HC_MATH_WRAPPER_TTTQ(function, arg1, arg2, arg3) \
-template<typename T, typename Q> \
-inline T function(T arg1, T arg2, Q arg3) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1, arg2, arg3); \
-}
-
-#define HC_MATH_WRAPPER_VTQQ(function, arg1, arg2, arg3) \
-template<typename T, typename Q> \
-inline void function(T arg1, Q arg2, Q arg3) __attribute__((hc,cpu)) { \
-  hc::precise_math::function(arg1, arg2, arg3); \
-}
+#define HC_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1)                       \
+  template <typename T>                                                     \
+  inline typename std::enable_if<std::is_integral<T>::value,                \
+                                 HC_IMPLICIT_FLOAT_CONV>::type              \
+  function(T arg1) __attribute__((hc, cpu)) {                               \
+    return hc::precise_math::function(                                      \
+        static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1));                         \
+  }                                                                         \
+  template <typename T>                                                     \
+  inline typename std::enable_if<std::is_floating_point<T>::value, T>::type \
+  function(T arg1) __attribute__((hc, cpu)) {                               \
+    return hc::precise_math::function(arg1);                                \
+  }
 
-#else
+#define KALMAR_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1) \
+  HC_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1)
+
+#define HC_MATH_WRAPPER_2(function, arg1, arg2)                \
+  template <typename T>                                        \
+  inline T function(T arg1, T arg2) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1, arg2);             \
+  }
+
+#define HC_MATH_ALIAS_2(alias, function, arg1, arg2)        \
+  template <typename T>                                     \
+  inline T alias(T arg1, T arg2) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1, arg2);          \
+  }
+
+#define HC_MATH_WRAPPER_3(function, arg1, arg2, arg3)                  \
+  template <typename T>                                                \
+  inline T function(T arg1, T arg2, T arg3) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1, arg2, arg3);               \
+  }
+
+#define HC_MATH_WRAPPER_TQ(function, arg1)             \
+  template <typename T, typename Q>                    \
+  inline T function(Q arg1) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1);           \
+  }
+
+#define HC_MATH_WRAPPER_FP_OVERLOAD_TQ(function, T, arg1)                   \
+  template <typename Q>                                                     \
+  inline typename std::enable_if<std::is_integral<Q>::value, T>::type       \
+  function(Q arg1) __attribute__((hc, cpu)) {                               \
+    return hc::precise_math::function(                                      \
+        static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1));                         \
+  }                                                                         \
+  template <typename Q>                                                     \
+  inline typename std::enable_if<std::is_floating_point<Q>::value, T>::type \
+  function(Q arg1) __attribute__((hc, cpu)) {                               \
+    return hc::precise_math::function(arg1);                                \
+  }
+
+#define HC_MATH_WRAPPER_TTQ(function, arg1, arg2)              \
+  template <typename T, typename Q>                            \
+  inline T function(T arg1, Q arg2) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1, arg2);             \
+  }
+
+#define HC_MATH_WRAPPER_FP_OVERLOAD_TTQ(function, arg1, arg2)          \
+  template <typename T, typename Q>                                    \
+  inline typename std::enable_if<std::is_integral<T>::value ||         \
+                                     std::is_integral<Q>::value,       \
+                                 HC_IMPLICIT_FLOAT_CONV>::type         \
+  function(T arg1, Q arg2) __attribute__((hc, cpu)) {                  \
+    return hc::precise_math::function(                                 \
+        static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1),                     \
+        static_cast<HC_IMPLICIT_FLOAT_CONV>(arg2));                    \
+  }                                                                    \
+  template <typename T, typename Q>                                    \
+  inline typename std::enable_if<std::is_floating_point<T>::value &&   \
+                                     std::is_floating_point<Q>::value, \
+                                 T>::type                              \
+  function(T arg1, Q arg2) __attribute__((hc, cpu)) {                  \
+    return hc::precise_math::function(arg1, arg2);                     \
+  }
+
+#define HC_MATH_WRAPPER_TTTQ(function, arg1, arg2, arg3)               \
+  template <typename T, typename Q>                                    \
+  inline T function(T arg1, T arg2, Q arg3) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1, arg2, arg3);               \
+  }
+
+#define HC_MATH_WRAPPER_VTQQ(function, arg1, arg2, arg3)                  \
+  template <typename T, typename Q>                                       \
+  inline void function(T arg1, Q arg2, Q arg3) __attribute__((hc, cpu)) { \
+    hc::precise_math::function(arg1, arg2, arg3);                         \
+  }
 
-#define HC_MATH_WRAPPER_1(function, arg1) \
-template<typename T> \
-inline T function(T arg1) __attribute__((hc,cpu)) { \
-  return std::function(arg1); \
-}
-
-#define KALMAR_MATH_WRAPPER_1(function, arg1) \
-template<typename T> \
-inline T function(T arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1); \
-}
-
-#define HC_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1) \
-template<typename T> \
-inline \
-typename std::enable_if<std::is_integral<T>::value,HC_IMPLICIT_FLOAT_CONV>::type \
- function(T arg1) __attribute__((hc,cpu)) { \
-  return ::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1)); \
-} \
-template<typename T> \
-inline \
-typename std::enable_if<std::is_floating_point <T>::value,T>::type \
- function(T arg1) __attribute__((hc,cpu)) { \
-  return std::function(arg1); \
-} 
+#else
 
-#define KALMAR_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1) \
-template<typename T> \
-inline \
-typename std::enable_if<std::is_integral<T>::value,HC_IMPLICIT_FLOAT_CONV>::type \
- function(T arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1)); \
-} \
-template<typename T> \
-inline \
-typename std::enable_if<std::is_floating_point <T>::value,T>::type \
- function(T arg1) __attribute__((hc,cpu)) { \
-  return hc::precise_math::function(arg1); \
-}
-
-#define HC_MATH_WRAPPER_2(function, arg1, arg2) \
-template<typename T> \
-inline T function(T arg1, T arg2) __attribute__((hc,cpu)) { \
-  return std::function(arg1, arg2); \
-}
-
-#define HC_MATH_ALIAS_2(alias, function, arg1, arg2) \
-template<typename T> \
-inline T alias(T arg1, T arg2) __attribute__((hc,cpu)) { \
-  return std::function(arg1, arg2); \
-}
-
-#define HC_MATH_WRAPPER_3(function, arg1, arg2, arg3) \
-template<typename T> \
-inline T function(T arg1, T arg2, T arg3) __attribute__((hc,cpu)) { \
-  return std::function(arg1, arg2, arg3); \
-}
-
-#define HC_MATH_WRAPPER_TQ(function, arg1) \
-template<typename T, typename Q> \
-inline T function(Q arg1) __attribute__((hc,cpu)) { \
-  return std::function(arg1); \
-}
-
-#define HC_MATH_WRAPPER_FP_OVERLOAD_TQ(function, T, arg1) \
-template<typename Q> \
-inline \
-typename std::enable_if<std::is_integral<Q>::value,T>::type \
-function(Q arg1) __attribute__((hc)) { \
-  return std::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1)); \
-}\
-template<typename Q> \
-inline \
-typename std::enable_if<std::is_floating_point<Q>::value,T>::type \
-function(Q arg1) __attribute__((hc)) { \
-  return std::function(arg1); \
-}
-
-#define HC_MATH_WRAPPER_TTQ(function, arg1, arg2) \
-template<typename T, typename Q> \
-inline T function(T arg1, Q arg2) __attribute__((hc,cpu)) { \
-  return std::function(arg1, arg2); \
-}
-
-#define HC_MATH_WRAPPER_FP_OVERLOAD_TTQ(function, arg1, arg2) \
-template<typename T, typename Q> \
-inline \
-typename std::enable_if<std::is_integral<T>::value||std::is_integral<Q>::value,HC_IMPLICIT_FLOAT_CONV>::type \
-function(T arg1, Q arg2) __attribute__((hc,cpu)) { \
-  return std::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1),static_cast<HC_IMPLICIT_FLOAT_CONV>(arg2)); \
-}\
-template<typename T, typename Q> \
-inline \
-typename std::enable_if<std::is_floating_point<T>::value&&std::is_floating_point<Q>::value,T>::type \
-function(T arg1, Q arg2) __attribute__((hc,cpu)) { \
-  return std::function(arg1,arg2); \
-}
-
-#define HC_MATH_WRAPPER_TTTQ(function, arg1, arg2, arg3) \
-template<typename T, typename Q> \
-inline T function(T arg1, T arg2, Q arg3) __attribute__((hc,cpu)) { \
-  return std::function(arg1, arg2, arg3); \
-}
-
-#define HC_MATH_WRAPPER_VTQQ(function, arg1, arg2, arg3) \
-template<typename T, typename Q> \
-inline void function(T arg1, Q arg2, Q arg3) __attribute__((hc,cpu)) { \
-  std::function(arg1, arg2, arg3); \
-}
+#define HC_MATH_WRAPPER_1(function, arg1)              \
+  template <typename T>                                \
+  inline T function(T arg1) __attribute__((hc, cpu)) { \
+    return std::function(arg1);                        \
+  }
+
+#define KALMAR_MATH_WRAPPER_1(function, arg1)          \
+  template <typename T>                                \
+  inline T function(T arg1) __attribute__((hc, cpu)) { \
+    return hc::precise_math::function(arg1);           \
+  }
+
+#define HC_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1)                       \
+  template <typename T>                                                     \
+  inline typename std::enable_if<std::is_integral<T>::value,                \
+                                 HC_IMPLICIT_FLOAT_CONV>::type              \
+  function(T arg1) __attribute__((hc, cpu)) {                               \
+    return ::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1));           \
+  }                                                                         \
+  template <typename T>                                                     \
+  inline typename std::enable_if<std::is_floating_point<T>::value, T>::type \
+  function(T arg1) __attribute__((hc, cpu)) {                               \
+    return std::function(arg1);                                             \
+  }
+
+#define KALMAR_MATH_WRAPPER_FP_OVERLOAD_1(function, arg1)                   \
+  template <typename T>                                                     \
+  inline typename std::enable_if<std::is_integral<T>::value,                \
+                                 HC_IMPLICIT_FLOAT_CONV>::type              \
+  function(T arg1) __attribute__((hc, cpu)) {                               \
+    return hc::precise_math::function(                                      \
+        static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1));                         \
+  }                                                                         \
+  template <typename T>                                                     \
+  inline typename std::enable_if<std::is_floating_point<T>::value, T>::type \
+  function(T arg1) __attribute__((hc, cpu)) {                               \
+    return hc::precise_math::function(arg1);                                \
+  }
+
+#define HC_MATH_WRAPPER_2(function, arg1, arg2)                \
+  template <typename T>                                        \
+  inline T function(T arg1, T arg2) __attribute__((hc, cpu)) { \
+    return std::function(arg1, arg2);                          \
+  }
+
+#define HC_MATH_ALIAS_2(alias, function, arg1, arg2)        \
+  template <typename T>                                     \
+  inline T alias(T arg1, T arg2) __attribute__((hc, cpu)) { \
+    return std::function(arg1, arg2);                       \
+  }
+
+#define HC_MATH_WRAPPER_3(function, arg1, arg2, arg3)                  \
+  template <typename T>                                                \
+  inline T function(T arg1, T arg2, T arg3) __attribute__((hc, cpu)) { \
+    return std::function(arg1, arg2, arg3);                            \
+  }
+
+#define HC_MATH_WRAPPER_TQ(function, arg1)             \
+  template <typename T, typename Q>                    \
+  inline T function(Q arg1) __attribute__((hc, cpu)) { \
+    return std::function(arg1);                        \
+  }
+
+#define HC_MATH_WRAPPER_FP_OVERLOAD_TQ(function, T, arg1)                   \
+  template <typename Q>                                                     \
+  inline typename std::enable_if<std::is_integral<Q>::value, T>::type       \
+  function(Q arg1) __attribute__((hc)) {                                    \
+    return std::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1));        \
+  }                                                                         \
+  template <typename Q>                                                     \
+  inline typename std::enable_if<std::is_floating_point<Q>::value, T>::type \
+  function(Q arg1) __attribute__((hc)) {                                    \
+    return std::function(arg1);                                             \
+  }
+
+#define HC_MATH_WRAPPER_TTQ(function, arg1, arg2)              \
+  template <typename T, typename Q>                            \
+  inline T function(T arg1, Q arg2) __attribute__((hc, cpu)) { \
+    return std::function(arg1, arg2);                          \
+  }
+
+#define HC_MATH_WRAPPER_FP_OVERLOAD_TTQ(function, arg1, arg2)          \
+  template <typename T, typename Q>                                    \
+  inline typename std::enable_if<std::is_integral<T>::value ||         \
+                                     std::is_integral<Q>::value,       \
+                                 HC_IMPLICIT_FLOAT_CONV>::type         \
+  function(T arg1, Q arg2) __attribute__((hc, cpu)) {                  \
+    return std::function(static_cast<HC_IMPLICIT_FLOAT_CONV>(arg1),    \
+                         static_cast<HC_IMPLICIT_FLOAT_CONV>(arg2));   \
+  }                                                                    \
+  template <typename T, typename Q>                                    \
+  inline typename std::enable_if<std::is_floating_point<T>::value &&   \
+                                     std::is_floating_point<Q>::value, \
+                                 T>::type                              \
+  function(T arg1, Q arg2) __attribute__((hc, cpu)) {                  \
+    return std::function(arg1, arg2);                                  \
+  }
+
+#define HC_MATH_WRAPPER_TTTQ(function, arg1, arg2, arg3)               \
+  template <typename T, typename Q>                                    \
+  inline T function(T arg1, T arg2, Q arg3) __attribute__((hc, cpu)) { \
+    return std::function(arg1, arg2, arg3);                            \
+  }
+
+#define HC_MATH_WRAPPER_VTQQ(function, arg1, arg2, arg3)                  \
+  template <typename T, typename Q>                                       \
+  inline void function(T arg1, Q arg2, Q arg3) __attribute__((hc, cpu)) { \
+    std::function(arg1, arg2, arg3);                                      \
+  }
 
 #endif
 
-
 // override global math functions
 namespace std {
 
-// following math functions are NOT available because they don't have a GPU implementation
+// following math functions are NOT available because they don't have a GPU
+// implementation
 //
 // erfinv
 // erfcinv
 // fpclassify
-// 
-// following math functions are NOT available because they don't have a CPU implementation
+//
+// following math functions are NOT available because they don't have a CPU
+// implementation
 //
 // cospif
 // cospi
@@ -246,7 +251,7 @@ HC_MATH_WRAPPER_FP_OVERLOAD_TQ(isnan, bool, x)
 HC_MATH_WRAPPER_FP_OVERLOAD_TQ(isnormal, bool, x)
 HC_MATH_WRAPPER_TQ(nanf, tagp)
 HC_MATH_WRAPPER_TQ(nan, tagp)
-//HC_MATH_WRAPPER_TQ(signbitf, x)
+// HC_MATH_WRAPPER_TQ(signbitf, x)
 HC_MATH_WRAPPER_TQ(signbit, x)
 HC_MATH_WRAPPER_TTQ(frexpf, x, exp)
 HC_MATH_WRAPPER_TTQ(frexp, x, exp)
@@ -332,9 +337,9 @@ HC_MATH_WRAPPER_FP_OVERLOAD_1(nearbyint, x)
 HC_MATH_WRAPPER_2(nextafterf, x, y)
 HC_MATH_WRAPPER_2(nextafter, x, y)
 HC_MATH_WRAPPER_2(powf, x, y)
-HC_MATH_WRAPPER_FP_OVERLOAD_TTQ(pow,x,y)
-//HC_MATH_WRAPPER_1(rcbrtf, x)
-//HC_MATH_WRAPPER_1(rcbrt, x)
+HC_MATH_WRAPPER_FP_OVERLOAD_TTQ(pow, x, y)
+// HC_MATH_WRAPPER_1(rcbrtf, x)
+// HC_MATH_WRAPPER_1(rcbrt, x)
 HC_MATH_WRAPPER_2(remainderf, x, y)
 HC_MATH_WRAPPER_2(remainder, x, y)
 HC_MATH_WRAPPER_1(roundf, x)
@@ -360,8 +365,7 @@ HC_MATH_WRAPPER_FP_OVERLOAD_1(tanh, x)
 HC_MATH_WRAPPER_1(truncf, x)
 HC_MATH_WRAPPER_FP_OVERLOAD_1(trunc, x)
 
-//HC_MATH_ALIAS_2(min, fmin, x, y)
-//HC_MATH_ALIAS_2(max, fmax, x, y)
-
-} // namespace
+// HC_MATH_ALIAS_2(min, fmin, x, y)
+// HC_MATH_ALIAS_2(max, fmax, x, y)
 
+}  // namespace std
diff --git a/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIAvail.hpp b/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIAvail.hpp
index 86b71b99c852afcdfb2d91e4ba789869f1b0b86c..f7d18854dc307a220b2905538dd3f7c437428081 100644
--- a/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIAvail.hpp
+++ b/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIAvail.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Serial
 
-#include<eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIDecl.hpp b/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIDecl.hpp
index f0322e65c2e3d22a7391e075b0dcfb08c826c7d6..1410a7eeacd4b2776e8cb311a447217abf4b3c3b 100644
--- a/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIDecl.hpp
+++ b/lib/kokkos/core/src/Serial/Kokkos_Serial_ViewCopyETIDecl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Serial
 
-#include<eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.cpp b/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.cpp
index 1a9a837af7286ee44a486faeeb11853789fa1971..d106abf6881fb75c7cc3bfe8de5eec081ec1c240 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.cpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,9 +42,8 @@
 //@HEADER
 */
 
-
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 
 #include <cstdint>
 #include <limits>
@@ -57,7 +57,6 @@
 #include <impl/Kokkos_CPUDiscovery.hpp>
 #include <impl/Kokkos_Profiling_Interface.hpp>
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
@@ -65,50 +64,46 @@ namespace Kokkos {
 namespace Impl {
 namespace {
 
-ThreadsExec                  s_threads_process ;
-ThreadsExec                * s_threads_exec[  ThreadsExec::MAX_THREAD_COUNT ] = { 0 };
-pthread_t                    s_threads_pid[   ThreadsExec::MAX_THREAD_COUNT ] = { 0 };
-std::pair<unsigned,unsigned> s_threads_coord[ ThreadsExec::MAX_THREAD_COUNT ];
+ThreadsExec s_threads_process;
+ThreadsExec *s_threads_exec[ThreadsExec::MAX_THREAD_COUNT] = {0};
+pthread_t s_threads_pid[ThreadsExec::MAX_THREAD_COUNT]     = {0};
+std::pair<unsigned, unsigned> s_threads_coord[ThreadsExec::MAX_THREAD_COUNT];
 
-int s_thread_pool_size[3] = { 0 , 0 , 0 };
+int s_thread_pool_size[3] = {0, 0, 0};
 
-unsigned s_current_reduce_size = 0 ;
-unsigned s_current_shared_size = 0 ;
+unsigned s_current_reduce_size = 0;
+unsigned s_current_shared_size = 0;
 
-void (* volatile s_current_function)( ThreadsExec & , const void * );
-const void * volatile s_current_function_arg = 0 ;
+void (*volatile s_current_function)(ThreadsExec &, const void *);
+const void *volatile s_current_function_arg = 0;
 
 struct Sentinel {
-  Sentinel()
-  {}
-
-  ~Sentinel()
-  {
-    if ( s_thread_pool_size[0] ||
-         s_thread_pool_size[1] ||
-         s_thread_pool_size[2] ||
-         s_current_reduce_size ||
-         s_current_shared_size ||
-         s_current_function ||
-         s_current_function_arg ||
-         s_threads_exec[0] ) {
-      std::cerr << "ERROR : Process exiting while Kokkos::Threads is still initialized" << std::endl ;
+  Sentinel() {}
+
+  ~Sentinel() {
+    if (s_thread_pool_size[0] || s_thread_pool_size[1] ||
+        s_thread_pool_size[2] || s_current_reduce_size ||
+        s_current_shared_size || s_current_function || s_current_function_arg ||
+        s_threads_exec[0]) {
+      std::cerr << "ERROR : Process exiting while Kokkos::Threads is still "
+                   "initialized"
+                << std::endl;
     }
   }
 };
 
-inline
-unsigned fan_size( const unsigned rank , const unsigned size )
-{
-  const unsigned rank_rev = size - ( rank + 1 );
-  unsigned count = 0 ;
-  for ( unsigned n = 1 ; ( rank_rev + n < size ) && ! ( rank_rev & n ) ; n <<= 1 ) { ++count ; }
-  return count ;
+inline unsigned fan_size(const unsigned rank, const unsigned size) {
+  const unsigned rank_rev = size - (rank + 1);
+  unsigned count          = 0;
+  for (unsigned n = 1; (rank_rev + n < size) && !(rank_rev & n); n <<= 1) {
+    ++count;
+  }
+  return count;
 }
 
-} // namespace
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -116,205 +111,196 @@ unsigned fan_size( const unsigned rank , const unsigned size )
 namespace Kokkos {
 namespace Impl {
 
-void execute_function_noop( ThreadsExec & , const void * ) {}
+void execute_function_noop(ThreadsExec &, const void *) {}
 
-void ThreadsExec::driver(void)
-{
-  SharedAllocationRecord< void, void >::tracking_enable();
-
-  ThreadsExec this_thread ;
+void ThreadsExec::driver(void) {
+  SharedAllocationRecord<void, void>::tracking_enable();
 
-  while ( ThreadsExec::Active == this_thread.m_pool_state ) {
+  ThreadsExec this_thread;
 
-    (*s_current_function)( this_thread , s_current_function_arg );
+  while (ThreadsExec::Active == this_thread.m_pool_state) {
+    (*s_current_function)(this_thread, s_current_function_arg);
 
     // Deactivate thread and wait for reactivation
-    this_thread.m_pool_state = ThreadsExec::Inactive ;
+    this_thread.m_pool_state = ThreadsExec::Inactive;
 
-    wait_yield( this_thread.m_pool_state , ThreadsExec::Inactive );
+    wait_yield(this_thread.m_pool_state, ThreadsExec::Inactive);
   }
 }
 
 ThreadsExec::ThreadsExec()
-  : m_pool_base(0)
-  , m_scratch(0)
-  , m_scratch_reduce_end(0)
-  , m_scratch_thread_end(0)
-  , m_numa_rank(0)
-  , m_numa_core_rank(0)
-  , m_pool_rank(0)
-  , m_pool_size(0)
-  , m_pool_fan_size(0)
-  , m_pool_state( ThreadsExec::Terminating )
-{
-  if ( & s_threads_process != this ) {
-
+    : m_pool_base(0),
+      m_scratch(0),
+      m_scratch_reduce_end(0),
+      m_scratch_thread_end(0),
+      m_numa_rank(0),
+      m_numa_core_rank(0),
+      m_pool_rank(0),
+      m_pool_size(0),
+      m_pool_fan_size(0),
+      m_pool_state(ThreadsExec::Terminating) {
+  if (&s_threads_process != this) {
     // A spawned thread
 
-    ThreadsExec * const nil = 0 ;
+    ThreadsExec *const nil = 0;
 
     // Which entry in 's_threads_exec', possibly determined from hwloc binding
-    const int entry = ((size_t)s_current_function_arg) < size_t(s_thread_pool_size[0])
-                    ? ((size_t)s_current_function_arg)
-                    : size_t(Kokkos::hwloc::bind_this_thread( s_thread_pool_size[0] , s_threads_coord ));
+    const int entry =
+        ((size_t)s_current_function_arg) < size_t(s_thread_pool_size[0])
+            ? ((size_t)s_current_function_arg)
+            : size_t(Kokkos::hwloc::bind_this_thread(s_thread_pool_size[0],
+                                                     s_threads_coord));
 
     // Given a good entry set this thread in the 's_threads_exec' array
-    if ( entry < s_thread_pool_size[0] &&
-         nil == atomic_compare_exchange( s_threads_exec + entry , nil , this ) ) {
-
-      const std::pair<unsigned,unsigned> coord = Kokkos::hwloc::get_this_thread_coordinate();
-
-      m_numa_rank       = coord.first ;
-      m_numa_core_rank  = coord.second ;
-      m_pool_base       = s_threads_exec ;
-      m_pool_rank       = s_thread_pool_size[0] - ( entry + 1 );
-      m_pool_rank_rev   = s_thread_pool_size[0] - ( pool_rank() + 1 );
-      m_pool_size       = s_thread_pool_size[0] ;
-      m_pool_fan_size   = fan_size( m_pool_rank , m_pool_size );
-      m_pool_state      = ThreadsExec::Active ;
-
-      s_threads_pid[ m_pool_rank ] = pthread_self();
+    if (entry < s_thread_pool_size[0] &&
+        nil == atomic_compare_exchange(s_threads_exec + entry, nil, this)) {
+      const std::pair<unsigned, unsigned> coord =
+          Kokkos::hwloc::get_this_thread_coordinate();
+
+      m_numa_rank      = coord.first;
+      m_numa_core_rank = coord.second;
+      m_pool_base      = s_threads_exec;
+      m_pool_rank      = s_thread_pool_size[0] - (entry + 1);
+      m_pool_rank_rev  = s_thread_pool_size[0] - (pool_rank() + 1);
+      m_pool_size      = s_thread_pool_size[0];
+      m_pool_fan_size  = fan_size(m_pool_rank, m_pool_size);
+      m_pool_state     = ThreadsExec::Active;
+
+      s_threads_pid[m_pool_rank] = pthread_self();
 
       // Inform spawning process that the threads_exec entry has been set.
-      s_threads_process.m_pool_state = ThreadsExec::Active ;
-    }
-    else {
+      s_threads_process.m_pool_state = ThreadsExec::Active;
+    } else {
       // Inform spawning process that the threads_exec entry could not be set.
-      s_threads_process.m_pool_state = ThreadsExec::Terminating ;
+      s_threads_process.m_pool_state = ThreadsExec::Terminating;
     }
-  }
-  else {
+  } else {
     // Enables 'parallel_for' to execute on unitialized Threads device
-    m_pool_rank  = 0 ;
-    m_pool_size  = 1 ;
-    m_pool_state = ThreadsExec::Inactive ;
+    m_pool_rank  = 0;
+    m_pool_size  = 1;
+    m_pool_state = ThreadsExec::Inactive;
 
-    s_threads_pid[ m_pool_rank ] = pthread_self();
+    s_threads_pid[m_pool_rank] = pthread_self();
   }
 }
 
-ThreadsExec::~ThreadsExec()
-{
-  const unsigned entry = m_pool_size - ( m_pool_rank + 1 );
+ThreadsExec::~ThreadsExec() {
+  const unsigned entry = m_pool_size - (m_pool_rank + 1);
 
-  typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::HostSpace , void > Record ;
+  typedef Kokkos::Impl::SharedAllocationRecord<Kokkos::HostSpace, void> Record;
 
-  if ( m_scratch ) {
-    Record * const r = Record::get_record( m_scratch );
+  if (m_scratch) {
+    Record *const r = Record::get_record(m_scratch);
 
-    m_scratch = 0 ;
+    m_scratch = 0;
 
-    Record::decrement( r );
+    Record::decrement(r);
   }
 
-  m_pool_base   = 0 ;
-  m_scratch_reduce_end = 0 ;
-  m_scratch_thread_end = 0 ;
-  m_numa_rank      = 0 ;
-  m_numa_core_rank = 0 ;
-  m_pool_rank      = 0 ;
-  m_pool_size      = 0 ;
-  m_pool_fan_size  = 0 ;
+  m_pool_base          = 0;
+  m_scratch_reduce_end = 0;
+  m_scratch_thread_end = 0;
+  m_numa_rank          = 0;
+  m_numa_core_rank     = 0;
+  m_pool_rank          = 0;
+  m_pool_size          = 0;
+  m_pool_fan_size      = 0;
 
-  m_pool_state  = ThreadsExec::Terminating ;
+  m_pool_state = ThreadsExec::Terminating;
 
-  if ( & s_threads_process != this && entry < MAX_THREAD_COUNT ) {
-    ThreadsExec * const nil = 0 ;
+  if (&s_threads_process != this && entry < MAX_THREAD_COUNT) {
+    ThreadsExec *const nil = 0;
 
-    atomic_compare_exchange( s_threads_exec + entry , this , nil );
+    atomic_compare_exchange(s_threads_exec + entry, this, nil);
 
-    s_threads_process.m_pool_state = ThreadsExec::Terminating ;
+    s_threads_process.m_pool_state = ThreadsExec::Terminating;
   }
 }
 
+int ThreadsExec::get_thread_count() { return s_thread_pool_size[0]; }
 
-int ThreadsExec::get_thread_count()
-{
-  return s_thread_pool_size[0] ;
-}
-
-ThreadsExec * ThreadsExec::get_thread( const int init_thread_rank )
-{
-  ThreadsExec * const th =
-    init_thread_rank < s_thread_pool_size[0]
-    ? s_threads_exec[ s_thread_pool_size[0] - ( init_thread_rank + 1 ) ] : 0 ;
+ThreadsExec *ThreadsExec::get_thread(const int init_thread_rank) {
+  ThreadsExec *const th =
+      init_thread_rank < s_thread_pool_size[0]
+          ? s_threads_exec[s_thread_pool_size[0] - (init_thread_rank + 1)]
+          : 0;
 
-  if ( 0 == th || th->m_pool_rank != init_thread_rank ) {
-    std::ostringstream msg ;
+  if (0 == th || th->m_pool_rank != init_thread_rank) {
+    std::ostringstream msg;
     msg << "Kokkos::Impl::ThreadsExec::get_thread ERROR : "
-        << "thread " << init_thread_rank << " of " << s_thread_pool_size[0] ;
-    if ( 0 == th ) {
-      msg << " does not exist" ;
+        << "thread " << init_thread_rank << " of " << s_thread_pool_size[0];
+    if (0 == th) {
+      msg << " does not exist";
+    } else {
+      msg << " has wrong thread_rank " << th->m_pool_rank;
     }
-    else {
-      msg << " has wrong thread_rank " << th->m_pool_rank ;
-    }
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
-  return th ;
+  return th;
 }
 
 //----------------------------------------------------------------------------
 
-void ThreadsExec::execute_sleep( ThreadsExec & exec , const void * )
-{
+void ThreadsExec::execute_sleep(ThreadsExec &exec, const void *) {
   ThreadsExec::global_lock();
   ThreadsExec::global_unlock();
 
-  const int n = exec.m_pool_fan_size ;
-  const int rank_rev = exec.m_pool_size - ( exec.m_pool_rank + 1 );
+  const int n        = exec.m_pool_fan_size;
+  const int rank_rev = exec.m_pool_size - (exec.m_pool_rank + 1);
 
-  for ( int i = 0 ; i < n ; ++i ) {
-    Impl::spinwait_while_equal<int>( exec.m_pool_base[ rank_rev + (1<<i) ]->m_pool_state , ThreadsExec::Active );
+  for (int i = 0; i < n; ++i) {
+    Impl::spinwait_while_equal<int>(
+        exec.m_pool_base[rank_rev + (1 << i)]->m_pool_state,
+        ThreadsExec::Active);
   }
 
-  exec.m_pool_state = ThreadsExec::Inactive ;
+  exec.m_pool_state = ThreadsExec::Inactive;
 }
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-void ThreadsExec::verify_is_process( const std::string & name , const bool initialized )
-{
-  if ( ! is_process() ) {
-    std::string msg( name );
-    msg.append( " FAILED : Called by a worker thread, can only be called by the master process." );
-    Kokkos::Impl::throw_runtime_exception( msg );
+void ThreadsExec::verify_is_process(const std::string &name,
+                                    const bool initialized) {
+  if (!is_process()) {
+    std::string msg(name);
+    msg.append(
+        " FAILED : Called by a worker thread, can only be called by the master "
+        "process.");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
 
-  if ( initialized && 0 == s_thread_pool_size[0] ) {
-    std::string msg( name );
-    msg.append( " FAILED : Threads not initialized." );
-    Kokkos::Impl::throw_runtime_exception( msg );
+  if (initialized && 0 == s_thread_pool_size[0]) {
+    std::string msg(name);
+    msg.append(" FAILED : Threads not initialized.");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
 }
 
-int ThreadsExec::in_parallel()
-{
+int ThreadsExec::in_parallel() {
   // A thread function is in execution and
   // the function argument is not the special threads process argument and
   // the master process is a worker or is not the master process.
-  return s_current_function &&
-         ( & s_threads_process != s_current_function_arg ) &&
-         ( s_threads_process.m_pool_base || ! is_process() );
+  return s_current_function && (&s_threads_process != s_current_function_arg) &&
+         (s_threads_process.m_pool_base || !is_process());
 }
 
 // Wait for root thread to become inactive
-void ThreadsExec::fence()
-{
-  if ( s_thread_pool_size[0] ) {
+void ThreadsExec::fence() {
+  if (s_thread_pool_size[0]) {
     // Wait for the root thread to complete:
-    Impl::spinwait_while_equal<int>( s_threads_exec[0]->m_pool_state , ThreadsExec::Active );
+    Impl::spinwait_while_equal<int>(s_threads_exec[0]->m_pool_state,
+                                    ThreadsExec::Active);
   }
 
-  s_current_function     = 0 ;
-  s_current_function_arg = 0 ;
+  s_current_function     = 0;
+  s_current_function_arg = 0;
 
   // Make sure function and arguments are cleared before
   // potentially re-activating threads with a subsequent launch.
@@ -322,100 +308,98 @@ void ThreadsExec::fence()
 }
 
 /** \brief  Begin execution of the asynchronous functor */
-void ThreadsExec::start( void (*func)( ThreadsExec & , const void * ) , const void * arg )
-{
-  verify_is_process("ThreadsExec::start" , true );
+void ThreadsExec::start(void (*func)(ThreadsExec &, const void *),
+                        const void *arg) {
+  verify_is_process("ThreadsExec::start", true);
 
-  if ( s_current_function || s_current_function_arg ) {
-    Kokkos::Impl::throw_runtime_exception( std::string( "ThreadsExec::start() FAILED : already executing" ) );
+  if (s_current_function || s_current_function_arg) {
+    Kokkos::Impl::throw_runtime_exception(
+        std::string("ThreadsExec::start() FAILED : already executing"));
   }
 
-  s_current_function     = func ;
-  s_current_function_arg = arg ;
+  s_current_function     = func;
+  s_current_function_arg = arg;
 
   // Make sure function and arguments are written before activating threads.
   memory_fence();
 
   // Activate threads:
-  for ( int i = s_thread_pool_size[0] ; 0 < i-- ; ) {
-    s_threads_exec[i]->m_pool_state = ThreadsExec::Active ;
+  for (int i = s_thread_pool_size[0]; 0 < i--;) {
+    s_threads_exec[i]->m_pool_state = ThreadsExec::Active;
   }
 
-  if ( s_threads_process.m_pool_size ) {
+  if (s_threads_process.m_pool_size) {
     // Master process is the root thread, run it:
-    (*func)( s_threads_process , arg );
-    s_threads_process.m_pool_state = ThreadsExec::Inactive ;
+    (*func)(s_threads_process, arg);
+    s_threads_process.m_pool_state = ThreadsExec::Inactive;
   }
 }
 
 //----------------------------------------------------------------------------
 
-bool ThreadsExec::sleep()
-{
-  verify_is_process("ThreadsExec::sleep", true );
+bool ThreadsExec::sleep() {
+  verify_is_process("ThreadsExec::sleep", true);
 
-  if ( & execute_sleep == s_current_function ) return false ;
+  if (&execute_sleep == s_current_function) return false;
 
   fence();
 
   ThreadsExec::global_lock();
 
-  s_current_function = & execute_sleep ;
+  s_current_function = &execute_sleep;
 
   // Activate threads:
-  for ( unsigned i = s_thread_pool_size[0] ; 0 < i ; ) {
-    s_threads_exec[--i]->m_pool_state = ThreadsExec::Active ;
+  for (unsigned i = s_thread_pool_size[0]; 0 < i;) {
+    s_threads_exec[--i]->m_pool_state = ThreadsExec::Active;
   }
 
-  return true ;
+  return true;
 }
 
-bool ThreadsExec::wake()
-{
-  verify_is_process("ThreadsExec::wake", true );
+bool ThreadsExec::wake() {
+  verify_is_process("ThreadsExec::wake", true);
 
-  if ( & execute_sleep != s_current_function ) return false ;
+  if (&execute_sleep != s_current_function) return false;
 
   ThreadsExec::global_unlock();
 
-  if ( s_threads_process.m_pool_base ) {
-    execute_sleep( s_threads_process , 0 );
-    s_threads_process.m_pool_state = ThreadsExec::Inactive ;
+  if (s_threads_process.m_pool_base) {
+    execute_sleep(s_threads_process, 0);
+    s_threads_process.m_pool_state = ThreadsExec::Inactive;
   }
 
   fence();
 
-  return true ;
+  return true;
 }
 
 //----------------------------------------------------------------------------
 
-void ThreadsExec::execute_serial( void (*func)( ThreadsExec & , const void * ) )
-{
-  s_current_function = func ;
-  s_current_function_arg = & s_threads_process ;
+void ThreadsExec::execute_serial(void (*func)(ThreadsExec &, const void *)) {
+  s_current_function     = func;
+  s_current_function_arg = &s_threads_process;
 
   // Make sure function and arguments are written before activating threads.
   memory_fence();
 
-  const unsigned begin = s_threads_process.m_pool_base ? 1 : 0 ;
+  const unsigned begin = s_threads_process.m_pool_base ? 1 : 0;
 
-  for ( unsigned i = s_thread_pool_size[0] ; begin < i ; ) {
-    ThreadsExec & th = * s_threads_exec[ --i ];
+  for (unsigned i = s_thread_pool_size[0]; begin < i;) {
+    ThreadsExec &th = *s_threads_exec[--i];
 
-    th.m_pool_state = ThreadsExec::Active ;
+    th.m_pool_state = ThreadsExec::Active;
 
-    wait_yield( th.m_pool_state , ThreadsExec::Active );
+    wait_yield(th.m_pool_state, ThreadsExec::Active);
   }
 
-  if ( s_threads_process.m_pool_base ) {
-    s_threads_process.m_pool_state = ThreadsExec::Active ;
-    (*func)( s_threads_process , 0 );
-    s_threads_process.m_pool_state = ThreadsExec::Inactive ;
+  if (s_threads_process.m_pool_base) {
+    s_threads_process.m_pool_state = ThreadsExec::Active;
+    (*func)(s_threads_process, 0);
+    s_threads_process.m_pool_state = ThreadsExec::Inactive;
   }
 
-  s_current_function_arg = 0 ;
-  s_current_function = 0 ;
+  s_current_function_arg = 0;
+  s_current_function     = 0;
 
   // Make sure function and arguments are cleared before proceeding.
   memory_fence();
@@ -423,214 +407,203 @@ void ThreadsExec::execute_serial( void (*func)( ThreadsExec & , const void * ) )
 
 //----------------------------------------------------------------------------
 
-void * ThreadsExec::root_reduce_scratch()
-{
+void *ThreadsExec::root_reduce_scratch() {
   return s_threads_process.reduce_memory();
 }
 
-void ThreadsExec::execute_resize_scratch( ThreadsExec & exec , const void * )
-{
-  typedef Kokkos::Impl::SharedAllocationRecord< Kokkos::HostSpace , void > Record ;
+void ThreadsExec::execute_resize_scratch(ThreadsExec &exec, const void *) {
+  typedef Kokkos::Impl::SharedAllocationRecord<Kokkos::HostSpace, void> Record;
 
-  if ( exec.m_scratch ) {
-    Record * const r = Record::get_record( exec.m_scratch );
+  if (exec.m_scratch) {
+    Record *const r = Record::get_record(exec.m_scratch);
 
-    exec.m_scratch = 0 ;
+    exec.m_scratch = 0;
 
-    Record::decrement( r );
+    Record::decrement(r);
   }
 
-  exec.m_scratch_reduce_end = s_threads_process.m_scratch_reduce_end ;
-  exec.m_scratch_thread_end = s_threads_process.m_scratch_thread_end ;
-
-  if ( s_threads_process.m_scratch_thread_end ) {
+  exec.m_scratch_reduce_end = s_threads_process.m_scratch_reduce_end;
+  exec.m_scratch_thread_end = s_threads_process.m_scratch_thread_end;
 
+  if (s_threads_process.m_scratch_thread_end) {
     // Allocate tracked memory:
     {
-      Record * const r = Record::allocate( Kokkos::HostSpace() , "thread_scratch" , s_threads_process.m_scratch_thread_end );
+      Record *const r =
+          Record::allocate(Kokkos::HostSpace(), "thread_scratch",
+                           s_threads_process.m_scratch_thread_end);
 
-      Record::increment( r );
+      Record::increment(r);
 
       exec.m_scratch = r->data();
     }
 
-    unsigned * ptr = reinterpret_cast<unsigned *>( exec.m_scratch );
+    unsigned *ptr = reinterpret_cast<unsigned *>(exec.m_scratch);
 
-    unsigned * const end = ptr + s_threads_process.m_scratch_thread_end / sizeof(unsigned);
+    unsigned *const end =
+        ptr + s_threads_process.m_scratch_thread_end / sizeof(unsigned);
 
     // touch on this thread
-    while ( ptr < end ) *ptr++ = 0 ;
+    while (ptr < end) *ptr++ = 0;
   }
 }
 
-void * ThreadsExec::resize_scratch( size_t reduce_size , size_t thread_size )
-{
+void *ThreadsExec::resize_scratch(size_t reduce_size, size_t thread_size) {
   enum { ALIGN_MASK = Kokkos::Impl::MEMORY_ALIGNMENT - 1 };
 
   fence();
 
-  const size_t old_reduce_size = s_threads_process.m_scratch_reduce_end ;
-  const size_t old_thread_size = s_threads_process.m_scratch_thread_end - s_threads_process.m_scratch_reduce_end ;
+  const size_t old_reduce_size = s_threads_process.m_scratch_reduce_end;
+  const size_t old_thread_size = s_threads_process.m_scratch_thread_end -
+                                 s_threads_process.m_scratch_reduce_end;
 
-  reduce_size = ( reduce_size + ALIGN_MASK ) & ~ALIGN_MASK ;
-  thread_size = ( thread_size + ALIGN_MASK ) & ~ALIGN_MASK ;
+  reduce_size = (reduce_size + ALIGN_MASK) & ~ALIGN_MASK;
+  thread_size = (thread_size + ALIGN_MASK) & ~ALIGN_MASK;
 
   // Increase size or deallocate completely.
 
-  if ( ( old_reduce_size < reduce_size ) ||
-       ( old_thread_size < thread_size ) ||
-       ( ( reduce_size == 0 && thread_size == 0 ) &&
-         ( old_reduce_size != 0 || old_thread_size != 0 ) ) ) {
-
-    verify_is_process( "ThreadsExec::resize_scratch" , true );
+  if ((old_reduce_size < reduce_size) || (old_thread_size < thread_size) ||
+      ((reduce_size == 0 && thread_size == 0) &&
+       (old_reduce_size != 0 || old_thread_size != 0))) {
+    verify_is_process("ThreadsExec::resize_scratch", true);
 
-    s_threads_process.m_scratch_reduce_end = reduce_size ;
-    s_threads_process.m_scratch_thread_end = reduce_size + thread_size ;
+    s_threads_process.m_scratch_reduce_end = reduce_size;
+    s_threads_process.m_scratch_thread_end = reduce_size + thread_size;
 
-    execute_serial( & execute_resize_scratch );
+    execute_serial(&execute_resize_scratch);
 
-    s_threads_process.m_scratch = s_threads_exec[0]->m_scratch ;
+    s_threads_process.m_scratch = s_threads_exec[0]->m_scratch;
   }
 
-  return s_threads_process.m_scratch ;
+  return s_threads_process.m_scratch;
 }
 
 //----------------------------------------------------------------------------
 
-void ThreadsExec::print_configuration( std::ostream & s , const bool detail )
-{
-  verify_is_process("ThreadsExec::print_configuration",false);
+void ThreadsExec::print_configuration(std::ostream &s, const bool detail) {
+  verify_is_process("ThreadsExec::print_configuration", false);
 
   fence();
 
-  const unsigned numa_count       = Kokkos::hwloc::get_available_numa_count();
-  const unsigned cores_per_numa   = Kokkos::hwloc::get_available_cores_per_numa();
-  const unsigned threads_per_core = Kokkos::hwloc::get_available_threads_per_core();
+  const unsigned numa_count     = Kokkos::hwloc::get_available_numa_count();
+  const unsigned cores_per_numa = Kokkos::hwloc::get_available_cores_per_numa();
+  const unsigned threads_per_core =
+      Kokkos::hwloc::get_available_threads_per_core();
 
   // Forestall compiler warnings for unused variables.
-  (void) numa_count;
-  (void) cores_per_numa;
-  (void) threads_per_core;
+  (void)numa_count;
+  (void)cores_per_numa;
+  (void)threads_per_core;
 
-  s << "Kokkos::Threads" ;
+  s << "Kokkos::Threads";
 
-#if defined( KOKKOS_ENABLE_THREADS )
-  s << " KOKKOS_ENABLE_THREADS" ;
+#if defined(KOKKOS_ENABLE_THREADS)
+  s << " KOKKOS_ENABLE_THREADS";
 #endif
-#if defined( KOKKOS_ENABLE_HWLOC )
-  s << " hwloc[" << numa_count << "x" << cores_per_numa << "x" << threads_per_core << "]" ;
+#if defined(KOKKOS_ENABLE_HWLOC)
+  s << " hwloc[" << numa_count << "x" << cores_per_numa << "x"
+    << threads_per_core << "]";
 #endif
 
-  if ( s_thread_pool_size[0] ) {
+  if (s_thread_pool_size[0]) {
     s << " threads[" << s_thread_pool_size[0] << "]"
       << " threads_per_numa[" << s_thread_pool_size[1] << "]"
-      << " threads_per_core[" << s_thread_pool_size[2] << "]"
-      ;
-    if ( 0 == s_threads_process.m_pool_base ) { s << " Asynchronous" ; }
+      << " threads_per_core[" << s_thread_pool_size[2] << "]";
+    if (0 == s_threads_process.m_pool_base) {
+      s << " Asynchronous";
+    }
     s << " ReduceScratch[" << s_current_reduce_size << "]"
-      << " SharedScratch[" << s_current_shared_size << "]" ;
-    s << std::endl ;
-
-    if ( detail ) {
-
-      for ( int i = 0 ; i < s_thread_pool_size[0] ; ++i ) {
+      << " SharedScratch[" << s_current_shared_size << "]";
+    s << std::endl;
 
-        ThreadsExec * const th = s_threads_exec[i] ;
+    if (detail) {
+      for (int i = 0; i < s_thread_pool_size[0]; ++i) {
+        ThreadsExec *const th = s_threads_exec[i];
 
-        if ( th ) {
+        if (th) {
+          const int rank_rev = th->m_pool_size - (th->m_pool_rank + 1);
 
-          const int rank_rev = th->m_pool_size - ( th->m_pool_rank + 1 );
+          s << " Thread[ " << th->m_pool_rank << " : " << th->m_numa_rank << "."
+            << th->m_numa_core_rank << " ]";
 
-          s << " Thread[ " << th->m_pool_rank << " : "
-            << th->m_numa_rank << "." << th->m_numa_core_rank << " ]" ;
-
-          s << " Fan{" ;
-          for ( int j = 0 ; j < th->m_pool_fan_size ; ++j ) {
-            ThreadsExec * const thfan = th->m_pool_base[rank_rev+(1<<j)] ;
-            s << " [ " << thfan->m_pool_rank << " : "
-              << thfan->m_numa_rank << "." << thfan->m_numa_core_rank << " ]" ;
+          s << " Fan{";
+          for (int j = 0; j < th->m_pool_fan_size; ++j) {
+            ThreadsExec *const thfan = th->m_pool_base[rank_rev + (1 << j)];
+            s << " [ " << thfan->m_pool_rank << " : " << thfan->m_numa_rank
+              << "." << thfan->m_numa_core_rank << " ]";
           }
-          s << " }" ;
+          s << " }";
 
-          if ( th == & s_threads_process ) {
-            s << " is_process" ;
+          if (th == &s_threads_process) {
+            s << " is_process";
           }
         }
-        s << std::endl ;
+        s << std::endl;
       }
     }
-  }
-  else {
-    s << " not initialized" << std::endl ;
+  } else {
+    s << " not initialized" << std::endl;
   }
 }
 
 //----------------------------------------------------------------------------
 
-int ThreadsExec::is_initialized()
-{ return 0 != s_threads_exec[0] ; }
+int ThreadsExec::is_initialized() { return 0 != s_threads_exec[0]; }
 
-void ThreadsExec::initialize
-( unsigned thread_count ,
-  unsigned use_numa_count ,
-  unsigned use_cores_per_numa ,
-  bool allow_asynchronous_threadpool )
-{
-  static const Sentinel sentinel ;
+void ThreadsExec::initialize(unsigned thread_count, unsigned use_numa_count,
+                             unsigned use_cores_per_numa,
+                             bool allow_asynchronous_threadpool) {
+  static const Sentinel sentinel;
 
-  const bool is_initialized = 0 != s_thread_pool_size[0] ;
+  const bool is_initialized = 0 != s_thread_pool_size[0];
 
-  unsigned thread_spawn_failed = 0 ;
+  unsigned thread_spawn_failed = 0;
 
-  for ( int i = 0; i < ThreadsExec::MAX_THREAD_COUNT ; i++)
+  for (int i = 0; i < ThreadsExec::MAX_THREAD_COUNT; i++)
     s_threads_exec[i] = NULL;
 
-  if ( ! is_initialized ) {
-
+  if (!is_initialized) {
     // If thread_count, use_numa_count, or use_cores_per_numa are zero
     // then they will be given default values based upon hwloc detection
     // and allowed asynchronous execution.
 
     const bool hwloc_avail = Kokkos::hwloc::available();
-    const bool hwloc_can_bind = hwloc_avail && Kokkos::hwloc::can_bind_threads();
+    const bool hwloc_can_bind =
+        hwloc_avail && Kokkos::hwloc::can_bind_threads();
 
-    if ( thread_count == 0 ) {
+    if (thread_count == 0) {
       thread_count = hwloc_avail
-      ? Kokkos::hwloc::get_available_numa_count() *
-        Kokkos::hwloc::get_available_cores_per_numa() *
-        Kokkos::hwloc::get_available_threads_per_core()
-      : 1 ;
+                         ? Kokkos::hwloc::get_available_numa_count() *
+                               Kokkos::hwloc::get_available_cores_per_numa() *
+                               Kokkos::hwloc::get_available_threads_per_core()
+                         : 1;
     }
 
-    const unsigned thread_spawn_begin =
-      hwloc::thread_mapping( "Kokkos::Threads::initialize" ,
-                             allow_asynchronous_threadpool ,
-                             thread_count ,
-                             use_numa_count ,
-                             use_cores_per_numa ,
-                             s_threads_coord );
+    const unsigned thread_spawn_begin = hwloc::thread_mapping(
+        "Kokkos::Threads::initialize", allow_asynchronous_threadpool,
+        thread_count, use_numa_count, use_cores_per_numa, s_threads_coord);
 
-    const std::pair<unsigned,unsigned> proc_coord = s_threads_coord[0] ;
+    const std::pair<unsigned, unsigned> proc_coord = s_threads_coord[0];
 
-    if ( thread_spawn_begin ) {
+    if (thread_spawn_begin) {
       // Synchronous with s_threads_coord[0] as the process core
       // Claim entry #0 for binding the process core.
-      s_threads_coord[0] = std::pair<unsigned,unsigned>(~0u,~0u);
+      s_threads_coord[0] = std::pair<unsigned, unsigned>(~0u, ~0u);
     }
 
-    s_thread_pool_size[0] = thread_count ;
-    s_thread_pool_size[1] = s_thread_pool_size[0] / use_numa_count ;
-    s_thread_pool_size[2] = s_thread_pool_size[1] / use_cores_per_numa ;
-    s_current_function = & execute_function_noop ; // Initialization work function
-
-    for ( unsigned ith = thread_spawn_begin ; ith < thread_count ; ++ith ) {
+    s_thread_pool_size[0] = thread_count;
+    s_thread_pool_size[1] = s_thread_pool_size[0] / use_numa_count;
+    s_thread_pool_size[2] = s_thread_pool_size[1] / use_cores_per_numa;
+    s_current_function =
+        &execute_function_noop;  // Initialization work function
 
-      s_threads_process.m_pool_state = ThreadsExec::Inactive ;
+    for (unsigned ith = thread_spawn_begin; ith < thread_count; ++ith) {
+      s_threads_process.m_pool_state = ThreadsExec::Inactive;
 
       // If hwloc available then spawned thread will
       // choose its own entry in 's_threads_coord'
       // otherwise specify the entry.
-      s_current_function_arg = (void*)static_cast<uintptr_t>( hwloc_can_bind ? ~0u : ith );
+      s_current_function_arg =
+          (void *)static_cast<uintptr_t>(hwloc_can_bind ? ~0u : ith);
 
       // Make sure all outstanding memory writes are complete
       // before spawning the new thread.
@@ -638,153 +611,158 @@ void ThreadsExec::initialize
 
       // Spawn thread executing the 'driver()' function.
       // Wait until spawned thread has attempted to initialize.
-      // If spawning and initialization are successful then
+      // If spawning and initialization is successful then
       // an entry in 's_threads_exec' will be assigned.
-      if ( ThreadsExec::spawn() ) {
-        wait_yield( s_threads_process.m_pool_state , ThreadsExec::Inactive );
+      if (ThreadsExec::spawn()) {
+        wait_yield(s_threads_process.m_pool_state, ThreadsExec::Inactive);
       }
-      if ( s_threads_process.m_pool_state == ThreadsExec::Terminating ) break ;
+      if (s_threads_process.m_pool_state == ThreadsExec::Terminating) break;
     }
 
     // Wait for all spawned threads to deactivate before zeroing the function.
 
-    for ( unsigned ith = thread_spawn_begin ; ith < thread_count ; ++ith ) {
+    for (unsigned ith = thread_spawn_begin; ith < thread_count; ++ith) {
       // Try to protect against cache coherency failure by casting to volatile.
-      ThreadsExec * const th = ((ThreadsExec * volatile *)s_threads_exec)[ith] ;
-      if ( th ) {
-        wait_yield( th->m_pool_state , ThreadsExec::Active );
-      }
-      else {
-        ++thread_spawn_failed ;
+      ThreadsExec *const th = ((ThreadsExec * volatile *)s_threads_exec)[ith];
+      if (th) {
+        wait_yield(th->m_pool_state, ThreadsExec::Active);
+      } else {
+        ++thread_spawn_failed;
       }
     }
 
-    s_current_function     = 0 ;
-    s_current_function_arg = 0 ;
-    s_threads_process.m_pool_state = ThreadsExec::Inactive ;
+    s_current_function             = 0;
+    s_current_function_arg         = 0;
+    s_threads_process.m_pool_state = ThreadsExec::Inactive;
 
     memory_fence();
 
-    if ( ! thread_spawn_failed ) {
-      // Bind process to the core on which it was located before spawning occurred
+    if (!thread_spawn_failed) {
+      // Bind process to the core on which it was located before spawning
+      // occurred
       if (hwloc_can_bind) {
-        Kokkos::hwloc::bind_this_thread( proc_coord );
+        Kokkos::hwloc::bind_this_thread(proc_coord);
       }
 
-      if ( thread_spawn_begin ) { // Include process in pool.
-        const std::pair<unsigned,unsigned> coord = Kokkos::hwloc::get_this_thread_coordinate();
-
-        s_threads_exec[0]                   = & s_threads_process ;
-        s_threads_process.m_numa_rank       = coord.first ;
-        s_threads_process.m_numa_core_rank  = coord.second ;
-        s_threads_process.m_pool_base       = s_threads_exec ;
-        s_threads_process.m_pool_rank       = thread_count - 1 ; // Reversed for scan-compatible reductions
-        s_threads_process.m_pool_size       = thread_count ;
-        s_threads_process.m_pool_fan_size   = fan_size( s_threads_process.m_pool_rank , s_threads_process.m_pool_size );
-        s_threads_pid[ s_threads_process.m_pool_rank ] = pthread_self();
-      }
-      else {
-        s_threads_process.m_pool_base = 0 ;
-        s_threads_process.m_pool_rank = 0 ;
-        s_threads_process.m_pool_size = 0 ;
-        s_threads_process.m_pool_fan_size = 0 ;
+      if (thread_spawn_begin) {  // Include process in pool.
+        const std::pair<unsigned, unsigned> coord =
+            Kokkos::hwloc::get_this_thread_coordinate();
+
+        s_threads_exec[0]                  = &s_threads_process;
+        s_threads_process.m_numa_rank      = coord.first;
+        s_threads_process.m_numa_core_rank = coord.second;
+        s_threads_process.m_pool_base      = s_threads_exec;
+        s_threads_process.m_pool_rank =
+            thread_count - 1;  // Reversed for scan-compatible reductions
+        s_threads_process.m_pool_size     = thread_count;
+        s_threads_process.m_pool_fan_size = fan_size(
+            s_threads_process.m_pool_rank, s_threads_process.m_pool_size);
+        s_threads_pid[s_threads_process.m_pool_rank] = pthread_self();
+      } else {
+        s_threads_process.m_pool_base     = 0;
+        s_threads_process.m_pool_rank     = 0;
+        s_threads_process.m_pool_size     = 0;
+        s_threads_process.m_pool_fan_size = 0;
       }
 
       // Initial allocations:
-      ThreadsExec::resize_scratch( 1024 , 1024 );
-    }
-    else {
-      s_thread_pool_size[0] = 0 ;
-      s_thread_pool_size[1] = 0 ;
-      s_thread_pool_size[2] = 0 ;
+      ThreadsExec::resize_scratch(1024, 1024);
+    } else {
+      s_thread_pool_size[0] = 0;
+      s_thread_pool_size[1] = 0;
+      s_thread_pool_size[2] = 0;
     }
   }
 
-  if ( is_initialized || thread_spawn_failed ) {
-
-    std::ostringstream msg ;
+  if (is_initialized || thread_spawn_failed) {
+    std::ostringstream msg;
 
-    msg << "Kokkos::Threads::initialize ERROR" ;
+    msg << "Kokkos::Threads::initialize ERROR";
 
-    if ( is_initialized ) {
-      msg << " : already initialized" ;
+    if (is_initialized) {
+      msg << " : already initialized";
     }
-    if ( thread_spawn_failed ) {
-      msg << " : failed to spawn " << thread_spawn_failed << " threads" ;
+    if (thread_spawn_failed) {
+      msg << " : failed to spawn " << thread_spawn_failed << " threads";
     }
 
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
   // Check for over-subscription
-  if( Kokkos::show_warnings() && (Impl::mpi_ranks_per_node() * long(thread_count) > Impl::processors_per_node()) ) {
-    std::cerr << "Kokkos::Threads::initialize WARNING: You are likely oversubscribing your CPU cores." << std::endl;
-    std::cerr << "                                    Detected: " << Impl::processors_per_node() << " cores per node." << std::endl;
-    std::cerr << "                                    Detected: " << Impl::mpi_ranks_per_node() << " MPI_ranks per node." << std::endl;
-    std::cerr << "                                    Requested: " << thread_count << " threads per process." << std::endl;
+  if (Kokkos::show_warnings() &&
+      (Impl::mpi_ranks_per_node() * long(thread_count) >
+       Impl::processors_per_node())) {
+    std::cerr << "Kokkos::Threads::initialize WARNING: You are likely "
+                 "oversubscribing your CPU cores."
+              << std::endl;
+    std::cerr << "                                    Detected: "
+              << Impl::processors_per_node() << " cores per node." << std::endl;
+    std::cerr << "                                    Detected: "
+              << Impl::mpi_ranks_per_node() << " MPI_ranks per node."
+              << std::endl;
+    std::cerr << "                                    Requested: "
+              << thread_count << " threads per process." << std::endl;
   }
 
   // Init the array for used for arbitrarily sized atomics
   Impl::init_lock_array_host_space();
 
-  Impl::SharedAllocationRecord< void, void >::tracking_enable();
+  Impl::SharedAllocationRecord<void, void>::tracking_enable();
 
-  #if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::initialize();
-  #endif
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::initialize();
+#endif
 }
 
 //----------------------------------------------------------------------------
 
-void ThreadsExec::finalize()
-{
-  verify_is_process("ThreadsExec::finalize",false);
+void ThreadsExec::finalize() {
+  verify_is_process("ThreadsExec::finalize", false);
 
   fence();
 
-  resize_scratch(0,0);
-
-  const unsigned begin = s_threads_process.m_pool_base ? 1 : 0 ;
-
-  for ( unsigned i = s_thread_pool_size[0] ; begin < i-- ; ) {
+  resize_scratch(0, 0);
 
-    if ( s_threads_exec[i] ) {
+  const unsigned begin = s_threads_process.m_pool_base ? 1 : 0;
 
-      s_threads_exec[i]->m_pool_state = ThreadsExec::Terminating ;
+  for (unsigned i = s_thread_pool_size[0]; begin < i--;) {
+    if (s_threads_exec[i]) {
+      s_threads_exec[i]->m_pool_state = ThreadsExec::Terminating;
 
-      wait_yield( s_threads_process.m_pool_state , ThreadsExec::Inactive );
+      wait_yield(s_threads_process.m_pool_state, ThreadsExec::Inactive);
 
-      s_threads_process.m_pool_state = ThreadsExec::Inactive ;
+      s_threads_process.m_pool_state = ThreadsExec::Inactive;
     }
 
-    s_threads_pid[i] = 0 ;
+    s_threads_pid[i] = 0;
   }
 
-  if ( s_threads_process.m_pool_base ) {
-    ( & s_threads_process )->~ThreadsExec();
-    s_threads_exec[0] = 0 ;
+  if (s_threads_process.m_pool_base) {
+    (&s_threads_process)->~ThreadsExec();
+    s_threads_exec[0] = 0;
   }
 
-  if (Kokkos::hwloc::can_bind_threads() ) {
+  if (Kokkos::hwloc::can_bind_threads()) {
     Kokkos::hwloc::unbind_this_thread();
   }
 
-  s_thread_pool_size[0] = 0 ;
-  s_thread_pool_size[1] = 0 ;
-  s_thread_pool_size[2] = 0 ;
+  s_thread_pool_size[0] = 0;
+  s_thread_pool_size[1] = 0;
+  s_thread_pool_size[2] = 0;
 
   // Reset master thread to run solo.
-  s_threads_process.m_numa_rank       = 0 ;
-  s_threads_process.m_numa_core_rank  = 0 ;
-  s_threads_process.m_pool_base       = 0 ;
-  s_threads_process.m_pool_rank       = 0 ;
-  s_threads_process.m_pool_size       = 1 ;
-  s_threads_process.m_pool_fan_size   = 0 ;
-  s_threads_process.m_pool_state = ThreadsExec::Inactive ;
-
-  #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::finalize();
-  #endif
+  s_threads_process.m_numa_rank      = 0;
+  s_threads_process.m_numa_core_rank = 0;
+  s_threads_process.m_pool_base      = 0;
+  s_threads_process.m_pool_rank      = 0;
+  s_threads_process.m_pool_size      = 1;
+  s_threads_process.m_pool_fan_size  = 0;
+  s_threads_process.m_pool_state     = ThreadsExec::Inactive;
+
+#if defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::finalize();
+#endif
 }
 
 //----------------------------------------------------------------------------
@@ -805,30 +783,29 @@ int Threads::concurrency() {
 #endif
 }
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-void Threads::fence() const
-{ Impl::ThreadsExec::fence() ; }
+void Threads::fence() const { Impl::ThreadsExec::fence(); }
 #endif
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-Threads & Threads::instance(int)
+Threads &Threads::instance(int)
 #else
-Threads & Threads::impl_instance(int)
+Threads &Threads::impl_instance(int)
 #endif
 {
-  static Threads t ;
-  return t ;
+  static Threads t;
+  return t;
 }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-int Threads::thread_pool_size( int depth )
+int Threads::thread_pool_size(int depth)
 #else
-int Threads::impl_thread_pool_size( int depth )
+int Threads::impl_thread_pool_size(int depth)
 #endif
 {
   return Impl::s_thread_pool_size[depth];
 }
 
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
 int Threads::thread_pool_rank()
 #else
@@ -836,13 +813,15 @@ int Threads::impl_thread_pool_rank()
 #endif
 {
   const pthread_t pid = pthread_self();
-  int i = 0;
-  while ( ( i < Impl::s_thread_pool_size[0] ) && ( pid != Impl::s_threads_pid[i] ) ) { ++i ; }
-  return i ;
+  int i               = 0;
+  while ((i < Impl::s_thread_pool_size[0]) && (pid != Impl::s_threads_pid[i])) {
+    ++i;
+  }
+  return i;
 }
 #endif
 
-const char* Threads::name() { return "Threads"; }
+const char *Threads::name() { return "Threads"; }
 } /* namespace Kokkos */
 
 //----------------------------------------------------------------------------
@@ -850,4 +829,3 @@ const char* Threads::name() { return "Threads"; }
 #else
 void KOKKOS_CORE_SRC_THREADS_EXEC_PREVENT_LINK_ERROR() {}
 #endif /* #if defined( KOKKOS_ENABLE_THREADS ) */
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.hpp b/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.hpp
index 7af9d9e065246c402fb205363e5438cf1198bcb0..1b11f45b728152363f599f6998c40caa1b309589 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.hpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_THREADSEXEC_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 
 #include <cstdio>
 
@@ -62,52 +63,55 @@ namespace Kokkos {
 namespace Impl {
 
 class ThreadsExec {
-public:
-
+ public:
   // Fan array has log_2(NT) reduction threads plus 2 scan threads
   // Currently limited to 16k threads.
-  enum { MAX_FAN_COUNT    = 16 };
-  enum { MAX_THREAD_COUNT = 1 << ( MAX_FAN_COUNT - 2 ) };
-  enum { VECTOR_LENGTH    = 8 };
+  enum { MAX_FAN_COUNT = 16 };
+  enum { MAX_THREAD_COUNT = 1 << (MAX_FAN_COUNT - 2) };
+  enum { VECTOR_LENGTH = 8 };
 
   /** \brief States of a worker thread */
-  enum { Terminating ///<  Termination in progress
-       , Inactive    ///<  Exists, waiting for work
-       , Active      ///<  Exists, performing work
-       , Rendezvous  ///<  Exists, waiting in a barrier or reduce
-
-       , ScanCompleted
-       , ScanAvailable
-       , ReductionAvailable
-       };
-
-private:
-
-  friend class Kokkos::Threads ;
+  enum {
+    Terminating  ///<  Termination in progress
+    ,
+    Inactive  ///<  Exists, waiting for work
+    ,
+    Active  ///<  Exists, performing work
+    ,
+    Rendezvous  ///<  Exists, waiting in a barrier or reduce
+
+    ,
+    ScanCompleted,
+    ScanAvailable,
+    ReductionAvailable
+  };
+
+ private:
+  friend class Kokkos::Threads;
 
   // Fan-in operations' root is the highest ranking thread
   // to place the 'scan' reduction intermediate values on
   // the threads that need them.
   // For a simple reduction the thread location is arbitrary.
 
-  ThreadsExec * const * m_pool_base ; ///< Base for pool fan-in
+  ThreadsExec *const *m_pool_base;  ///< Base for pool fan-in
 
-  void *        m_scratch ;
-  int           m_scratch_reduce_end ;
-  int           m_scratch_thread_end ;
-  int           m_numa_rank ;
-  int           m_numa_core_rank ;
-  int           m_pool_rank ;
-  int           m_pool_rank_rev ;
-  int           m_pool_size ;
-  int           m_pool_fan_size ;
-  int volatile  m_pool_state ;  ///< State for global synchronizations
+  void *m_scratch;
+  int m_scratch_reduce_end;
+  int m_scratch_thread_end;
+  int m_numa_rank;
+  int m_numa_core_rank;
+  int m_pool_rank;
+  int m_pool_rank_rev;
+  int m_pool_size;
+  int m_pool_fan_size;
+  int volatile m_pool_state;  ///< State for global synchronizations
 
   // Members for dynamic scheduling
   // Which thread am I stealing from currently
   int m_current_steal_target;
   // This thread's owned work_range
-  Kokkos::pair<long,long> m_work_range __attribute__((aligned(16))) ;
+  Kokkos::pair<long, long> m_work_range __attribute__((aligned(16)));
   // Team Offset if one thread determines work_range for others
   long m_team_work_index;
 
@@ -118,471 +122,477 @@ private:
   static void global_unlock();
   static bool spawn();
 
-  static void execute_resize_scratch( ThreadsExec & , const void * );
-  static void execute_sleep(          ThreadsExec & , const void * );
+  static void execute_resize_scratch(ThreadsExec &, const void *);
+  static void execute_sleep(ThreadsExec &, const void *);
 
-  ThreadsExec( const ThreadsExec & );
-  ThreadsExec & operator = ( const ThreadsExec & );
+  ThreadsExec(const ThreadsExec &);
+  ThreadsExec &operator=(const ThreadsExec &);
 
-  static void execute_serial( void (*)( ThreadsExec & , const void * ) );
+  static void execute_serial(void (*)(ThreadsExec &, const void *));
 
-public:
-
-  KOKKOS_INLINE_FUNCTION int pool_size() const { return m_pool_size ; }
-  KOKKOS_INLINE_FUNCTION int pool_rank() const { return m_pool_rank ; }
-  KOKKOS_INLINE_FUNCTION int numa_rank() const { return m_numa_rank ; }
-  KOKKOS_INLINE_FUNCTION int numa_core_rank() const { return m_numa_core_rank ; }
-  inline long team_work_index() const { return m_team_work_index ; }
+ public:
+  KOKKOS_INLINE_FUNCTION int pool_size() const { return m_pool_size; }
+  KOKKOS_INLINE_FUNCTION int pool_rank() const { return m_pool_rank; }
+  KOKKOS_INLINE_FUNCTION int numa_rank() const { return m_numa_rank; }
+  KOKKOS_INLINE_FUNCTION int numa_core_rank() const { return m_numa_core_rank; }
+  inline long team_work_index() const { return m_team_work_index; }
 
   static int get_thread_count();
-  static ThreadsExec * get_thread( const int init_thread_rank );
+  static ThreadsExec *get_thread(const int init_thread_rank);
 
-  inline void * reduce_memory() const { return m_scratch ; }
-  KOKKOS_INLINE_FUNCTION  void * scratch_memory() const
-    { return reinterpret_cast<unsigned char *>(m_scratch) + m_scratch_reduce_end ; }
+  inline void *reduce_memory() const { return m_scratch; }
+  KOKKOS_INLINE_FUNCTION void *scratch_memory() const {
+    return reinterpret_cast<unsigned char *>(m_scratch) + m_scratch_reduce_end;
+  }
 
-  KOKKOS_INLINE_FUNCTION  int volatile & state() { return m_pool_state ; }
-  KOKKOS_INLINE_FUNCTION  ThreadsExec * const * pool_base() const { return m_pool_base ; }
+  KOKKOS_INLINE_FUNCTION int volatile &state() { return m_pool_state; }
+  KOKKOS_INLINE_FUNCTION ThreadsExec *const *pool_base() const {
+    return m_pool_base;
+  }
 
   static void driver(void);
 
   ~ThreadsExec();
   ThreadsExec();
 
-  static void * resize_scratch( size_t reduce_size , size_t thread_size );
+  static void *resize_scratch(size_t reduce_size, size_t thread_size);
 
-  static void * root_reduce_scratch();
+  static void *root_reduce_scratch();
 
   static bool is_process();
 
-  static void verify_is_process( const std::string & , const bool initialized );
+  static void verify_is_process(const std::string &, const bool initialized);
 
   static int is_initialized();
 
-  static void initialize( unsigned thread_count ,
-                          unsigned use_numa_count ,
-                          unsigned use_cores_per_numa ,
-                          bool allow_asynchronous_threadpool );
+  static void initialize(unsigned thread_count, unsigned use_numa_count,
+                         unsigned use_cores_per_numa,
+                         bool allow_asynchronous_threadpool);
 
   static void finalize();
 
   /* Given a requested team size, return valid team size */
-  static unsigned team_size_valid( unsigned );
+  static unsigned team_size_valid(unsigned);
 
-  static void print_configuration( std::ostream & , const bool detail = false );
+  static void print_configuration(std::ostream &, const bool detail = false);
 
   //------------------------------------
 
-  static void wait_yield( volatile int & , const int );
+  static void wait_yield(volatile int &, const int);
 
   //------------------------------------
   // All-thread functions:
 
-  inline
-  int all_reduce( const int value )
-    {
-      // Make sure there is enough scratch space:
-      const int rev_rank = m_pool_size - ( m_pool_rank + 1 );
+  inline int all_reduce(const int value) {
+    // Make sure there is enough scratch space:
+    const int rev_rank = m_pool_size - (m_pool_rank + 1);
 
-      *((volatile int*) reduce_memory()) = value ;
+    *((volatile int *)reduce_memory()) = value;
 
-      memory_fence();
+    memory_fence();
 
-      // Fan-in reduction with highest ranking thread as the root
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        // Wait: Active -> Rendezvous
-        Impl::spinwait_while_equal<int>( m_pool_base[ rev_rank + (1<<i) ]->m_pool_state , ThreadsExec::Active );
-      }
+    // Fan-in reduction with highest ranking thread as the root
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      // Wait: Active -> Rendezvous
+      Impl::spinwait_while_equal<int>(
+          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
+    }
 
-      if ( rev_rank ) {
-        m_pool_state = ThreadsExec::Rendezvous ;
-        // Wait: Rendezvous -> Active
-        Impl::spinwait_while_equal<int>( m_pool_state , ThreadsExec::Rendezvous );
-      }
-      else {
-        // Root thread does the reduction and broadcast
+    if (rev_rank) {
+      m_pool_state = ThreadsExec::Rendezvous;
+      // Wait: Rendezvous -> Active
+      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::Rendezvous);
+    } else {
+      // Root thread does the reduction and broadcast
 
-        int accum = 0 ;
+      int accum = 0;
 
-        for ( int rank = 0 ; rank < m_pool_size ; ++rank ) {
-          accum += *((volatile int *) get_thread( rank )->reduce_memory());
-        }
+      for (int rank = 0; rank < m_pool_size; ++rank) {
+        accum += *((volatile int *)get_thread(rank)->reduce_memory());
+      }
 
-        for ( int rank = 0 ; rank < m_pool_size ; ++rank ) {
-          *((volatile int *) get_thread( rank )->reduce_memory()) = accum ;
-        }
+      for (int rank = 0; rank < m_pool_size; ++rank) {
+        *((volatile int *)get_thread(rank)->reduce_memory()) = accum;
+      }
 
-        memory_fence();
+      memory_fence();
 
-        for ( int rank = 0 ; rank < m_pool_size ; ++rank ) {
-          get_thread( rank )->m_pool_state = ThreadsExec::Active ;
-        }
+      for (int rank = 0; rank < m_pool_size; ++rank) {
+        get_thread(rank)->m_pool_state = ThreadsExec::Active;
       }
-
-      return *((volatile int*) reduce_memory());
     }
 
-  inline
-  void barrier( )
-    {
-      // Make sure there is enough scratch space:
-      const int rev_rank = m_pool_size - ( m_pool_rank + 1 );
+    return *((volatile int *)reduce_memory());
+  }
 
-      memory_fence();
+  inline void barrier() {
+    // Make sure there is enough scratch space:
+    const int rev_rank = m_pool_size - (m_pool_rank + 1);
 
-      // Fan-in reduction with highest ranking thread as the root
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        // Wait: Active -> Rendezvous
-        Impl::spinwait_while_equal<int>( m_pool_base[ rev_rank + (1<<i) ]->m_pool_state , ThreadsExec::Active );
-      }
+    memory_fence();
 
-      if ( rev_rank ) {
-        m_pool_state = ThreadsExec::Rendezvous ;
-        // Wait: Rendezvous -> Active
-        Impl::spinwait_while_equal<int>( m_pool_state , ThreadsExec::Rendezvous );
-      }
-      else {
-        // Root thread does the reduction and broadcast
+    // Fan-in reduction with highest ranking thread as the root
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      // Wait: Active -> Rendezvous
+      Impl::spinwait_while_equal<int>(
+          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
+    }
 
-        memory_fence();
+    if (rev_rank) {
+      m_pool_state = ThreadsExec::Rendezvous;
+      // Wait: Rendezvous -> Active
+      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::Rendezvous);
+    } else {
+      // Root thread does the reduction and broadcast
 
-        for ( int rank = 0 ; rank < m_pool_size ; ++rank ) {
-          get_thread( rank )->m_pool_state = ThreadsExec::Active ;
-        }
+      memory_fence();
+
+      for (int rank = 0; rank < m_pool_size; ++rank) {
+        get_thread(rank)->m_pool_state = ThreadsExec::Active;
       }
     }
+  }
 
   //------------------------------------
   // All-thread functions:
 
-  template< class FunctorType , class ArgTag >
-  inline
-  void fan_in_reduce( const FunctorType & f ) const
-    {
-      typedef Kokkos::Impl::FunctorValueJoin< FunctorType , ArgTag > Join ;
-      typedef Kokkos::Impl::FunctorFinal<     FunctorType , ArgTag > Final ;
-
-      const int rev_rank  = m_pool_size - ( m_pool_rank + 1 );
+  template <class FunctorType, class ArgTag>
+  inline void fan_in_reduce(const FunctorType &f) const {
+    typedef Kokkos::Impl::FunctorValueJoin<FunctorType, ArgTag> Join;
+    typedef Kokkos::Impl::FunctorFinal<FunctorType, ArgTag> Final;
 
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
+    const int rev_rank = m_pool_size - (m_pool_rank + 1);
 
-        ThreadsExec & fan = *m_pool_base[ rev_rank + ( 1 << i ) ] ;
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      ThreadsExec &fan = *m_pool_base[rev_rank + (1 << i)];
 
-        Impl::spinwait_while_equal<int>( fan.m_pool_state , ThreadsExec::Active );
+      Impl::spinwait_while_equal<int>(fan.m_pool_state, ThreadsExec::Active);
 
-        Join::join( f , reduce_memory() , fan.reduce_memory() );
-      }
+      Join::join(f, reduce_memory(), fan.reduce_memory());
+    }
 
-      if ( ! rev_rank ) {
-        Final::final( f , reduce_memory() );
-      }
+    if (!rev_rank) {
+      Final::final(f, reduce_memory());
+    }
 
-      //  This thread has updated 'reduce_memory()' and upon returning
-      //  from this function will set 'm_pool_state' to inactive.
-      //  If this is a non-root thread then setting 'm_pool_state'
-      //  to inactive triggers another thread to exit a spinwait
-      //  and read the 'reduce_memory'.
-      //  Must 'memory_fence()' to guarantee that storing the update to
-      //  'reduce_memory()' will complete before storing the the update to
-      //  'm_pool_state'.
+    //  This thread has updated 'reduce_memory()' and upon returning
+    //  from this function will set 'm_pool_state' to inactive.
+    //  If this is a non-root thread then setting 'm_pool_state'
+    //  to inactive triggers another thread to exit a spinwait
+    //  and read the 'reduce_memory'.
+    //  Must 'memory_fence()' to guarantee that storing the update to
+    //  'reduce_memory()' will complete before storing the the update to
+    //  'm_pool_state'.
 
-      memory_fence();
-    }
+    memory_fence();
+  }
 
-  inline
-  void fan_in() const
-    {
-      const int rev_rank = m_pool_size - ( m_pool_rank + 1 );
+  inline void fan_in() const {
+    const int rev_rank = m_pool_size - (m_pool_rank + 1);
 
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        Impl::spinwait_while_equal<int>( m_pool_base[rev_rank+(1<<i)]->m_pool_state , ThreadsExec::Active );
-      }
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      Impl::spinwait_while_equal<int>(
+          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
     }
+  }
 
-  template< class FunctorType , class ArgTag >
-  inline
-  void scan_large( const FunctorType & f )
-    {
-      // Sequence of states:
-      //  0) Active             : entry and exit state
-      //  1) ReductionAvailable : reduction value available
-      //  2) ScanAvailable      : inclusive scan value available
-      //  3) Rendezvous         : All threads inclusive scan value are available
-      //  4) ScanCompleted      : exclusive scan value copied
-
-      typedef Kokkos::Impl::FunctorValueTraits< FunctorType , ArgTag > Traits ;
-      typedef Kokkos::Impl::FunctorValueJoin<   FunctorType , ArgTag > Join ;
-      typedef Kokkos::Impl::FunctorValueInit<   FunctorType , ArgTag > Init ;
-
-      typedef typename Traits::value_type scalar_type ;
-
-      const int      rev_rank = m_pool_size - ( m_pool_rank + 1 );
-      const unsigned count    = Traits::value_count( f );
-
-      scalar_type * const work_value = (scalar_type *) reduce_memory();
-
-      //--------------------------------
-      // Fan-in reduction with highest ranking thread as the root
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        ThreadsExec & fan = *m_pool_base[ rev_rank + (1<<i) ];
-
-        // Wait: Active -> ReductionAvailable (or ScanAvailable)
-        Impl::spinwait_while_equal<int>( fan.m_pool_state , ThreadsExec::Active );
-        Join::join( f , work_value , fan.reduce_memory() );
-      }
+  template <class FunctorType, class ArgTag>
+  inline void scan_large(const FunctorType &f) {
+    // Sequence of states:
+    //  0) Active             : entry and exit state
+    //  1) ReductionAvailable : reduction value available
+    //  2) ScanAvailable      : inclusive scan value available
+    //  3) Rendezvous         : All threads inclusive scan value are available
+    //  4) ScanCompleted      : exclusive scan value copied
 
-      // Copy reduction value to scan value before releasing from this phase.
-      for ( unsigned i = 0 ; i < count ; ++i ) { work_value[i+count] = work_value[i] ; }
+    typedef Kokkos::Impl::FunctorValueTraits<FunctorType, ArgTag> Traits;
+    typedef Kokkos::Impl::FunctorValueJoin<FunctorType, ArgTag> Join;
+    typedef Kokkos::Impl::FunctorValueInit<FunctorType, ArgTag> Init;
 
-      if ( rev_rank ) {
+    typedef typename Traits::value_type scalar_type;
 
-        // Set: Active -> ReductionAvailable
-        m_pool_state = ThreadsExec::ReductionAvailable ;
+    const int rev_rank   = m_pool_size - (m_pool_rank + 1);
+    const unsigned count = Traits::value_count(f);
 
-        // Wait for contributing threads' scan value to be available.
-        if ( ( 1 << m_pool_fan_size ) < ( m_pool_rank + 1 ) ) {
-          ThreadsExec & th = *m_pool_base[ rev_rank + ( 1 << m_pool_fan_size ) ] ;
+    scalar_type *const work_value = (scalar_type *)reduce_memory();
 
-          // Wait: Active             -> ReductionAvailable
-          // Wait: ReductionAvailable -> ScanAvailable
-          Impl::spinwait_while_equal<int>( th.m_pool_state , ThreadsExec::Active );
-          Impl::spinwait_while_equal<int>( th.m_pool_state , ThreadsExec::ReductionAvailable );
+    //--------------------------------
+    // Fan-in reduction with highest ranking thread as the root
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      ThreadsExec &fan = *m_pool_base[rev_rank + (1 << i)];
 
-          Join::join( f , work_value + count , ((scalar_type *)th.reduce_memory()) + count );
-        }
+      // Wait: Active -> ReductionAvailable (or ScanAvailable)
+      Impl::spinwait_while_equal<int>(fan.m_pool_state, ThreadsExec::Active);
+      Join::join(f, work_value, fan.reduce_memory());
+    }
 
-        // This thread has completed inclusive scan
-        // Set: ReductionAvailable -> ScanAvailable
-        m_pool_state = ThreadsExec::ScanAvailable ;
+    // Copy reduction value to scan value before releasing from this phase.
+    for (unsigned i = 0; i < count; ++i) {
+      work_value[i + count] = work_value[i];
+    }
 
-        // Wait for all threads to complete inclusive scan
-        // Wait: ScanAvailable -> Rendezvous
-        Impl::spinwait_while_equal<int>( m_pool_state , ThreadsExec::ScanAvailable );
-      }
+    if (rev_rank) {
+      // Set: Active -> ReductionAvailable
+      m_pool_state = ThreadsExec::ReductionAvailable;
 
-      //--------------------------------
+      // Wait for contributing threads' scan value to be available.
+      if ((1 << m_pool_fan_size) < (m_pool_rank + 1)) {
+        ThreadsExec &th = *m_pool_base[rev_rank + (1 << m_pool_fan_size)];
 
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        ThreadsExec & fan = *m_pool_base[ rev_rank + (1<<i) ];
+        // Wait: Active             -> ReductionAvailable
         // Wait: ReductionAvailable -> ScanAvailable
-        Impl::spinwait_while_equal<int>( fan.m_pool_state , ThreadsExec::ReductionAvailable );
-        // Set: ScanAvailable -> Rendezvous
-        fan.m_pool_state = ThreadsExec::Rendezvous ;
+        Impl::spinwait_while_equal<int>(th.m_pool_state, ThreadsExec::Active);
+        Impl::spinwait_while_equal<int>(th.m_pool_state,
+                                        ThreadsExec::ReductionAvailable);
+
+        Join::join(f, work_value + count,
+                   ((scalar_type *)th.reduce_memory()) + count);
       }
 
-      // All threads have completed the inclusive scan.
-      // All non-root threads are in the Rendezvous state.
-      // Threads are free to overwrite their reduction value.
-      //--------------------------------
+      // This thread has completed inclusive scan
+      // Set: ReductionAvailable -> ScanAvailable
+      m_pool_state = ThreadsExec::ScanAvailable;
 
-      if ( ( rev_rank + 1 ) < m_pool_size ) {
-        // Exclusive scan: copy the previous thread's inclusive scan value
+      // Wait for all threads to complete inclusive scan
+      // Wait: ScanAvailable -> Rendezvous
+      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::ScanAvailable);
+    }
 
-        ThreadsExec & th = *m_pool_base[ rev_rank + 1 ] ; // Not the root thread
+    //--------------------------------
 
-        const scalar_type * const src_value = ((scalar_type *)th.reduce_memory()) + count ;
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      ThreadsExec &fan = *m_pool_base[rev_rank + (1 << i)];
+      // Wait: ReductionAvailable -> ScanAvailable
+      Impl::spinwait_while_equal<int>(fan.m_pool_state,
+                                      ThreadsExec::ReductionAvailable);
+      // Set: ScanAvailable -> Rendezvous
+      fan.m_pool_state = ThreadsExec::Rendezvous;
+    }
 
-        for ( unsigned j = 0 ; j < count ; ++j ) { work_value[j] = src_value[j]; }
-      }
-      else {
-        (void) Init::init( f , work_value );
-      }
+    // All threads have completed the inclusive scan.
+    // All non-root threads are in the Rendezvous state.
+    // Threads are free to overwrite their reduction value.
+    //--------------------------------
 
-      //--------------------------------
-      // Wait for all threads to copy previous thread's inclusive scan value
-      // Wait for all threads: Rendezvous -> ScanCompleted
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        Impl::spinwait_while_equal<int>( m_pool_base[ rev_rank + (1<<i) ]->m_pool_state , ThreadsExec::Rendezvous );
-      }
-      if ( rev_rank ) {
-        // Set: ScanAvailable -> ScanCompleted
-        m_pool_state = ThreadsExec::ScanCompleted ;
-        // Wait: ScanCompleted -> Active
-        Impl::spinwait_while_equal<int>( m_pool_state , ThreadsExec::ScanCompleted );
-      }
-      // Set: ScanCompleted -> Active
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        m_pool_base[ rev_rank + (1<<i) ]->m_pool_state = ThreadsExec::Active ;
+    if ((rev_rank + 1) < m_pool_size) {
+      // Exclusive scan: copy the previous thread's inclusive scan value
+
+      ThreadsExec &th = *m_pool_base[rev_rank + 1];  // Not the root thread
+
+      const scalar_type *const src_value =
+          ((scalar_type *)th.reduce_memory()) + count;
+
+      for (unsigned j = 0; j < count; ++j) {
+        work_value[j] = src_value[j];
       }
+    } else {
+      (void)Init::init(f, work_value);
     }
 
-  template< class FunctorType , class ArgTag >
-  inline
-  void scan_small( const FunctorType & f )
-    {
-      typedef Kokkos::Impl::FunctorValueTraits< FunctorType , ArgTag > Traits ;
-      typedef Kokkos::Impl::FunctorValueJoin<   FunctorType , ArgTag > Join ;
-      typedef Kokkos::Impl::FunctorValueInit<   FunctorType , ArgTag > Init ;
-
-      typedef typename Traits::value_type scalar_type ;
+    //--------------------------------
+    // Wait for all threads to copy previous thread's inclusive scan value
+    // Wait for all threads: Rendezvous -> ScanCompleted
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      Impl::spinwait_while_equal<int>(
+          m_pool_base[rev_rank + (1 << i)]->m_pool_state,
+          ThreadsExec::Rendezvous);
+    }
+    if (rev_rank) {
+      // Set: ScanAvailable -> ScanCompleted
+      m_pool_state = ThreadsExec::ScanCompleted;
+      // Wait: ScanCompleted -> Active
+      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::ScanCompleted);
+    }
+    // Set: ScanCompleted -> Active
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      m_pool_base[rev_rank + (1 << i)]->m_pool_state = ThreadsExec::Active;
+    }
+  }
 
-      const int      rev_rank = m_pool_size - ( m_pool_rank + 1 );
-      const unsigned count    = Traits::value_count( f );
+  template <class FunctorType, class ArgTag>
+  inline void scan_small(const FunctorType &f) {
+    typedef Kokkos::Impl::FunctorValueTraits<FunctorType, ArgTag> Traits;
+    typedef Kokkos::Impl::FunctorValueJoin<FunctorType, ArgTag> Join;
+    typedef Kokkos::Impl::FunctorValueInit<FunctorType, ArgTag> Init;
 
-      scalar_type * const work_value = (scalar_type *) reduce_memory();
+    typedef typename Traits::value_type scalar_type;
 
-      //--------------------------------
-      // Fan-in reduction with highest ranking thread as the root
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        // Wait: Active -> Rendezvous
-        Impl::spinwait_while_equal<int>( m_pool_base[ rev_rank + (1<<i) ]->m_pool_state , ThreadsExec::Active );
-      }
+    const int rev_rank   = m_pool_size - (m_pool_rank + 1);
+    const unsigned count = Traits::value_count(f);
 
-      for ( unsigned i = 0 ; i < count ; ++i ) { work_value[i+count] = work_value[i]; }
+    scalar_type *const work_value = (scalar_type *)reduce_memory();
 
-      if ( rev_rank ) {
-        m_pool_state = ThreadsExec::Rendezvous ;
-        // Wait: Rendezvous -> Active
-        Impl::spinwait_while_equal<int>( m_pool_state , ThreadsExec::Rendezvous );
-      }
-      else {
-        // Root thread does the thread-scan before releasing threads
+    //--------------------------------
+    // Fan-in reduction with highest ranking thread as the root
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      // Wait: Active -> Rendezvous
+      Impl::spinwait_while_equal<int>(
+          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
+    }
 
-        scalar_type * ptr_prev = 0 ;
+    for (unsigned i = 0; i < count; ++i) {
+      work_value[i + count] = work_value[i];
+    }
 
-        for ( int rank = 0 ; rank < m_pool_size ; ++rank ) {
-          scalar_type * const ptr = (scalar_type *) get_thread( rank )->reduce_memory();
-          if ( rank ) {
-            for ( unsigned i = 0 ; i < count ; ++i ) { ptr[i] = ptr_prev[ i + count ]; }
-            Join::join( f , ptr + count , ptr );
+    if (rev_rank) {
+      m_pool_state = ThreadsExec::Rendezvous;
+      // Wait: Rendezvous -> Active
+      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::Rendezvous);
+    } else {
+      // Root thread does the thread-scan before releasing threads
+
+      scalar_type *ptr_prev = 0;
+
+      for (int rank = 0; rank < m_pool_size; ++rank) {
+        scalar_type *const ptr =
+            (scalar_type *)get_thread(rank)->reduce_memory();
+        if (rank) {
+          for (unsigned i = 0; i < count; ++i) {
+            ptr[i] = ptr_prev[i + count];
           }
-          else {
-            (void) Init::init( f , ptr );
-          }
-          ptr_prev = ptr ;
+          Join::join(f, ptr + count, ptr);
+        } else {
+          (void)Init::init(f, ptr);
         }
+        ptr_prev = ptr;
       }
+    }
 
-      for ( int i = 0 ; i < m_pool_fan_size ; ++i ) {
-        m_pool_base[ rev_rank + (1<<i) ]->m_pool_state = ThreadsExec::Active ;
-      }
+    for (int i = 0; i < m_pool_fan_size; ++i) {
+      m_pool_base[rev_rank + (1 << i)]->m_pool_state = ThreadsExec::Active;
     }
+  }
 
   //------------------------------------
   /** \brief  Wait for previous asynchronous functor to
    *          complete and release the Threads device.
    *          Acquire the Threads device and start this functor.
    */
-  static void start( void (*)( ThreadsExec & , const void * ) , const void * );
+  static void start(void (*)(ThreadsExec &, const void *), const void *);
 
-  static int  in_parallel();
+  static int in_parallel();
   static void fence();
   static bool sleep();
   static bool wake();
 
   /* Dynamic Scheduling related functionality */
   // Initialize the work range for this thread
-  inline void set_work_range(const long& begin, const long& end, const long& chunk_size) {
-    m_work_range.first = (begin+chunk_size-1)/chunk_size;
-    m_work_range.second = end>0?(end+chunk_size-1)/chunk_size:m_work_range.first;
+  inline void set_work_range(const long &begin, const long &end,
+                             const long &chunk_size) {
+    m_work_range.first = (begin + chunk_size - 1) / chunk_size;
+    m_work_range.second =
+        end > 0 ? (end + chunk_size - 1) / chunk_size : m_work_range.first;
   }
 
   // Claim and index from this thread's range from the beginning
-  inline long get_work_index_begin () {
-    Kokkos::pair<long,long> work_range_new = m_work_range;
-    Kokkos::pair<long,long> work_range_old = work_range_new;
-    if(work_range_old.first>=work_range_old.second)
-      return -1;
+  inline long get_work_index_begin() {
+    Kokkos::pair<long, long> work_range_new = m_work_range;
+    Kokkos::pair<long, long> work_range_old = work_range_new;
+    if (work_range_old.first >= work_range_old.second) return -1;
 
-    work_range_new.first+=1;
+    work_range_new.first += 1;
 
     bool success = false;
-    while(!success) {
-      work_range_new = Kokkos::atomic_compare_exchange(&m_work_range,work_range_old,work_range_new);
-      success = ( (work_range_new == work_range_old) ||
-                  (work_range_new.first>=work_range_new.second));
+    while (!success) {
+      work_range_new = Kokkos::atomic_compare_exchange(
+          &m_work_range, work_range_old, work_range_new);
+      success        = ((work_range_new == work_range_old) ||
+                 (work_range_new.first >= work_range_new.second));
       work_range_old = work_range_new;
-      work_range_new.first+=1;
+      work_range_new.first += 1;
     }
-    if(work_range_old.first<work_range_old.second)
+    if (work_range_old.first < work_range_old.second)
       return work_range_old.first;
     else
       return -1;
   }
 
   // Claim and index from this thread's range from the end
-  inline long get_work_index_end () {
-    Kokkos::pair<long,long> work_range_new = m_work_range;
-    Kokkos::pair<long,long> work_range_old = work_range_new;
-    if(work_range_old.first>=work_range_old.second)
-      return -1;
-    work_range_new.second-=1;
+  inline long get_work_index_end() {
+    Kokkos::pair<long, long> work_range_new = m_work_range;
+    Kokkos::pair<long, long> work_range_old = work_range_new;
+    if (work_range_old.first >= work_range_old.second) return -1;
+    work_range_new.second -= 1;
     bool success = false;
-    while(!success) {
-      work_range_new = Kokkos::atomic_compare_exchange(&m_work_range,work_range_old,work_range_new);
-      success = ( (work_range_new == work_range_old) ||
-                  (work_range_new.first>=work_range_new.second) );
+    while (!success) {
+      work_range_new = Kokkos::atomic_compare_exchange(
+          &m_work_range, work_range_old, work_range_new);
+      success        = ((work_range_new == work_range_old) ||
+                 (work_range_new.first >= work_range_new.second));
       work_range_old = work_range_new;
-      work_range_new.second-=1;
+      work_range_new.second -= 1;
     }
-    if(work_range_old.first<work_range_old.second)
-      return work_range_old.second-1;
+    if (work_range_old.first < work_range_old.second)
+      return work_range_old.second - 1;
     else
       return -1;
   }
 
   // Reset the steal target
   inline void reset_steal_target() {
-    m_current_steal_target = (m_pool_rank+1)%pool_size();
-    m_stealing = false;
+    m_current_steal_target = (m_pool_rank + 1) % pool_size();
+    m_stealing             = false;
   }
 
   // Reset the steal target
   inline void reset_steal_target(int team_size) {
-    m_current_steal_target = (m_pool_rank_rev+team_size);
-    if(m_current_steal_target>=pool_size())
-      m_current_steal_target = 0;//pool_size()-1;
+    m_current_steal_target = (m_pool_rank_rev + team_size);
+    if (m_current_steal_target >= pool_size())
+      m_current_steal_target = 0;  // pool_size()-1;
     m_stealing = false;
   }
 
-  // Get a steal target; start with my-rank + 1 and go round robin, until arriving at this threads rank
-  // Returns -1 fi no active steal target available
+  // Get a steal target; start with my-rank + 1 and go round robin, until
+  // arriving at this threads rank Returns -1 fi no active steal target
+  // available
   inline int get_steal_target() {
-    while(( m_pool_base[m_current_steal_target]->m_work_range.second <=
-            m_pool_base[m_current_steal_target]->m_work_range.first  ) &&
-          (m_current_steal_target!=m_pool_rank) ) {
-      m_current_steal_target = (m_current_steal_target+1)%pool_size();
+    while ((m_pool_base[m_current_steal_target]->m_work_range.second <=
+            m_pool_base[m_current_steal_target]->m_work_range.first) &&
+           (m_current_steal_target != m_pool_rank)) {
+      m_current_steal_target = (m_current_steal_target + 1) % pool_size();
     }
-    if(m_current_steal_target == m_pool_rank)
+    if (m_current_steal_target == m_pool_rank)
       return -1;
     else
       return m_current_steal_target;
   }
 
   inline int get_steal_target(int team_size) {
-
-    while(( m_pool_base[m_current_steal_target]->m_work_range.second <=
-            m_pool_base[m_current_steal_target]->m_work_range.first  ) &&
-          (m_current_steal_target!=m_pool_rank_rev) ) {
-      if(m_current_steal_target + team_size < pool_size())
-        m_current_steal_target = (m_current_steal_target+team_size);
+    while ((m_pool_base[m_current_steal_target]->m_work_range.second <=
+            m_pool_base[m_current_steal_target]->m_work_range.first) &&
+           (m_current_steal_target != m_pool_rank_rev)) {
+      if (m_current_steal_target + team_size < pool_size())
+        m_current_steal_target = (m_current_steal_target + team_size);
       else
         m_current_steal_target = 0;
     }
 
-    if(m_current_steal_target == m_pool_rank_rev)
+    if (m_current_steal_target == m_pool_rank_rev)
       return -1;
     else
       return m_current_steal_target;
   }
 
-  inline long steal_work_index (int team_size = 0) {
+  inline long steal_work_index(int team_size = 0) {
     long index = -1;
-    int steal_target = team_size>0?get_steal_target(team_size):get_steal_target();
-    while ( (steal_target != -1) && (index == -1)) {
+    int steal_target =
+        team_size > 0 ? get_steal_target(team_size) : get_steal_target();
+    while ((steal_target != -1) && (index == -1)) {
       index = m_pool_base[steal_target]->get_work_index_end();
-      if(index == -1)
-        steal_target = team_size>0?get_steal_target(team_size):get_steal_target();
+      if (index == -1)
+        steal_target =
+            team_size > 0 ? get_steal_target(team_size) : get_steal_target();
     }
     return index;
   }
 
-  // Get a work index. Claim from owned range until its exhausted, then steal from other thread
-  inline long get_work_index (int team_size = 0) {
+  // Get a work index. Claim from owned range until its exhausted, then steal
+  // from other thread
+  inline long get_work_index(int team_size = 0) {
     long work_index = -1;
-    if(!m_stealing) work_index = get_work_index_begin();
+    if (!m_stealing) work_index = get_work_index_begin();
 
-    if( work_index == -1) {
+    if (work_index == -1) {
       memory_fence();
       m_stealing = true;
       work_index = steal_work_index(team_size);
@@ -592,7 +602,6 @@ public:
     memory_fence();
     return work_index;
   }
-
 };
 
 } /* namespace Impl */
@@ -603,15 +612,16 @@ public:
 
 namespace Kokkos {
 
-inline int Threads::in_parallel()
-{ return Impl::ThreadsExec::in_parallel(); }
+inline int Threads::in_parallel() { return Impl::ThreadsExec::in_parallel(); }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-inline int Threads::is_initialized()
-{ return Impl::ThreadsExec::is_initialized(); }
+inline int Threads::is_initialized() {
+  return Impl::ThreadsExec::is_initialized();
+}
 #else
-inline int Threads::impl_is_initialized()
-{ return Impl::ThreadsExec::is_initialized(); }
+inline int Threads::impl_is_initialized() {
+  return Impl::ThreadsExec::is_initialized();
+}
 #endif
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
@@ -619,12 +629,11 @@ inline void Threads::initialize(
 #else
 inline void Threads::impl_initialize(
 #endif
-  unsigned threads_count ,
-  unsigned use_numa_count ,
-  unsigned use_cores_per_numa ,
-  bool allow_asynchronous_threadpool )
-{
-  Impl::ThreadsExec::initialize( threads_count , use_numa_count , use_cores_per_numa , allow_asynchronous_threadpool );
+    unsigned threads_count, unsigned use_numa_count,
+    unsigned use_cores_per_numa, bool allow_asynchronous_threadpool) {
+  Impl::ThreadsExec::initialize(threads_count, use_numa_count,
+                                use_cores_per_numa,
+                                allow_asynchronous_threadpool);
 }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
@@ -636,24 +645,19 @@ inline void Threads::impl_finalize()
   Impl::ThreadsExec::finalize();
 }
 
-inline void Threads::print_configuration( std::ostream & s , const bool detail )
-{
-  Impl::ThreadsExec::print_configuration( s , detail );
+inline void Threads::print_configuration(std::ostream &s, const bool detail) {
+  Impl::ThreadsExec::print_configuration(s, detail);
 }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-inline bool Threads::sleep()
-{ return Impl::ThreadsExec::sleep() ; }
+inline bool Threads::sleep() { return Impl::ThreadsExec::sleep(); }
 
-inline bool Threads::wake()
-{ return Impl::ThreadsExec::wake() ; }
+inline bool Threads::wake() { return Impl::ThreadsExec::wake(); }
 #endif
 
-inline void Threads::impl_static_fence()
-{ Impl::ThreadsExec::fence() ; }
+inline void Threads::impl_static_fence() { Impl::ThreadsExec::fence(); }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-inline void Threads::fence()
-{ Impl::ThreadsExec::fence() ; }
+inline void Threads::fence() { Impl::ThreadsExec::fence(); }
 #endif
 
 } /* namespace Kokkos */
@@ -661,76 +665,97 @@ inline void Threads::fence()
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-namespace Kokkos { namespace Experimental {
+namespace Kokkos {
+namespace Experimental {
 
-template<>
-class UniqueToken< Threads, UniqueTokenScope::Instance>
-{
-public:
+template <>
+class UniqueToken<Threads, UniqueTokenScope::Instance> {
+ public:
   using execution_space = Threads;
   using size_type       = int;
 
   /// \brief create object size for concurrency on the given instance
   ///
   /// This object should not be shared between instances
-  UniqueToken( execution_space const& = execution_space() ) noexcept {}
+  UniqueToken(execution_space const & = execution_space()) noexcept {}
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  int size() const noexcept { return Threads::thread_pool_size(); }
+      int
+      size() const noexcept {
+    return Threads::thread_pool_size();
+  }
 #else
-  int size() const noexcept { return Threads::impl_thread_pool_size(); }
+      int
+      size() const noexcept {
+    return Threads::impl_thread_pool_size();
+  }
 #endif
 
   /// \brief acquire value such that 0 <= value < size()
   inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  int acquire() const  noexcept { return Threads::thread_pool_rank(); }
+      int
+      acquire() const noexcept {
+    return Threads::thread_pool_rank();
+  }
 #else
-  int acquire() const  noexcept { return Threads::impl_thread_pool_rank(); }
+      int
+      acquire() const noexcept {
+    return Threads::impl_thread_pool_rank();
+  }
 #endif
 
   /// \brief release a value acquired by generate
-  inline
-  void release( int ) const noexcept {}
+  inline void release(int) const noexcept {}
 };
 
-template<>
-class UniqueToken< Threads, UniqueTokenScope::Global>
-{
-public:
+template <>
+class UniqueToken<Threads, UniqueTokenScope::Global> {
+ public:
   using execution_space = Threads;
   using size_type       = int;
 
   /// \brief create object size for concurrency on the given instance
   ///
   /// This object should not be shared between instances
-  UniqueToken( execution_space const& = execution_space() ) noexcept {}
+  UniqueToken(execution_space const & = execution_space()) noexcept {}
 
   /// \brief upper bound for acquired values, i.e. 0 <= value < size()
   inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  int size() const noexcept { return Threads::thread_pool_size(); }
+      int
+      size() const noexcept {
+    return Threads::thread_pool_size();
+  }
 #else
-  int size() const noexcept { return Threads::impl_thread_pool_size(); }
+      int
+      size() const noexcept {
+    return Threads::impl_thread_pool_size();
+  }
 #endif
 
   /// \brief acquire value such that 0 <= value < size()
   inline
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  int acquire() const  noexcept { return Threads::thread_pool_rank(); }
+      int
+      acquire() const noexcept {
+    return Threads::thread_pool_rank();
+  }
 #else
-  int acquire() const  noexcept { return Threads::impl_thread_pool_rank(); }
+      int
+      acquire() const noexcept {
+    return Threads::impl_thread_pool_rank();
+  }
 #endif
   /// \brief release a value acquired by generate
-  inline
-  void release( int ) const noexcept {}
+  inline void release(int) const noexcept {}
 };
 
-}} // namespace Kokkos::Experimental
+}  // namespace Experimental
+}  // namespace Kokkos
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 #endif
 #endif /* #define KOKKOS_THREADSEXEC_HPP */
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec_base.cpp b/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec_base.cpp
index 487661424566eec40046c294e47b0249e574e1c6..ed7b884a870ad2fb78858e6a41b45d202ac62133 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec_base.cpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_ThreadsExec_base.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,9 +42,8 @@
 //@HEADER
 */
 
-
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 
 #include <Kokkos_Core_fwd.hpp>
 /* Standard 'C' Linux libraries */
@@ -67,90 +67,84 @@ namespace Kokkos {
 namespace Impl {
 namespace {
 
-pthread_mutex_t host_internal_pthread_mutex = PTHREAD_MUTEX_INITIALIZER ;
+pthread_mutex_t host_internal_pthread_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 // Pthreads compatible driver.
 // Recovery from an exception would require constant intra-thread health
 // verification; which would negatively impact runtime.  As such simply
 // abort the process.
 
-void * internal_pthread_driver( void * )
-{
+void* internal_pthread_driver(void*) {
   try {
     ThreadsExec::driver();
-  }
-  catch( const std::exception & x ) {
-    std::cerr << "Exception thrown from worker thread: " << x.what() << std::endl ;
+  } catch (const std::exception& x) {
+    std::cerr << "Exception thrown from worker thread: " << x.what()
+              << std::endl;
     std::cerr.flush();
     std::abort();
-  }
-  catch( ... ) {
-    std::cerr << "Exception thrown from worker thread" << std::endl ;
+  } catch (...) {
+    std::cerr << "Exception thrown from worker thread" << std::endl;
     std::cerr.flush();
     std::abort();
   }
-  return NULL ;
+  return NULL;
 }
 
-} // namespace
+}  // namespace
 
 //----------------------------------------------------------------------------
 // Spawn a thread
 
-bool ThreadsExec::spawn()
-{
-  bool result = false ;
+bool ThreadsExec::spawn() {
+  bool result = false;
 
-  pthread_attr_t attr ;
+  pthread_attr_t attr;
 
-  if ( 0 == pthread_attr_init( & attr ) ||
-       0 == pthread_attr_setscope(       & attr, PTHREAD_SCOPE_SYSTEM ) ||
-       0 == pthread_attr_setdetachstate( & attr, PTHREAD_CREATE_DETACHED ) ) {
+  if (0 == pthread_attr_init(&attr) ||
+      0 == pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) ||
+      0 == pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) {
+    pthread_t pt;
 
-    pthread_t pt ;
-
-    result = 0 == pthread_create( & pt, & attr, internal_pthread_driver, 0 );
+    result = 0 == pthread_create(&pt, &attr, internal_pthread_driver, 0);
   }
 
-  pthread_attr_destroy( & attr );
+  pthread_attr_destroy(&attr);
 
-  return result ;
+  return result;
 }
 
 //----------------------------------------------------------------------------
 
-bool ThreadsExec::is_process()
-{
+bool ThreadsExec::is_process() {
   static const pthread_t master_pid = pthread_self();
 
-  return pthread_equal( master_pid , pthread_self() );
+  return pthread_equal(master_pid, pthread_self());
 }
 
-void ThreadsExec::global_lock()
-{
-  pthread_mutex_lock( & host_internal_pthread_mutex );
+void ThreadsExec::global_lock() {
+  pthread_mutex_lock(&host_internal_pthread_mutex);
 }
 
-void ThreadsExec::global_unlock()
-{
-  pthread_mutex_unlock( & host_internal_pthread_mutex );
+void ThreadsExec::global_unlock() {
+  pthread_mutex_unlock(&host_internal_pthread_mutex);
 }
 
 //----------------------------------------------------------------------------
 
-void ThreadsExec::wait_yield( volatile int & flag , const int value )
-{
-  while ( value == flag ) { sched_yield(); }
+void ThreadsExec::wait_yield(volatile int& flag, const int value) {
+  while (value == flag) {
+    sched_yield();
+  }
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /* end #if defined( KOKKOS_ENABLE_THREADS ) */
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_WINTHREAD )
+#elif defined(KOKKOS_ENABLE_WINTHREAD)
 
 #include <Kokkos_Core_fwd.hpp>
 
@@ -175,43 +169,40 @@ namespace Kokkos {
 namespace Impl {
 namespace {
 
-unsigned WINAPI internal_winthread_driver( void * arg )
-{
+unsigned WINAPI internal_winthread_driver(void* arg) {
   ThreadsExec::driver();
 
-  return 0 ;
+  return 0;
 }
 
 class ThreadLockWindows {
-private:
-  CRITICAL_SECTION  m_handle ;
+ private:
+  CRITICAL_SECTION m_handle;
 
-  ~ThreadLockWindows()
-  { DeleteCriticalSection( & m_handle ); }
+  ~ThreadLockWindows() { DeleteCriticalSection(&m_handle); }
 
   ThreadLockWindows();
-  { InitializeCriticalSection( & m_handle ); }
+  { InitializeCriticalSection(&m_handle); }
 
-  ThreadLockWindows( const ThreadLockWindows & );
-  ThreadLockWindows & operator = ( const ThreadLockWindows & );
+  ThreadLockWindows(const ThreadLockWindows&);
+  ThreadLockWindows& operator=(const ThreadLockWindows&);
 
-public:
+ public:
+  static ThreadLockWindows& singleton();
 
-  static ThreadLockWindows & singleton();
+  void lock() { EnterCriticalSection(&m_handle); }
 
-  void lock()
-  { EnterCriticalSection( & m_handle ); }
-
-  void unlock()
-  { LeaveCriticalSection( & m_handle ); }
+  void unlock() { LeaveCriticalSection(&m_handle); }
 };
 
-ThreadLockWindows & ThreadLockWindows::singleton()
-{ static ThreadLockWindows self ; return self ; }
+ThreadLockWindows& ThreadLockWindows::singleton() {
+  static ThreadLockWindows self;
+  return self;
+}
 
-} // namespace <>
-} // namespace Kokkos
-} // namespace Impl
+}  // namespace
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -221,33 +212,30 @@ namespace Impl {
 
 // Spawn this thread
 
-bool ThreadsExec::spawn()
-{
-  unsigned Win32ThreadID = 0 ;
+bool ThreadsExec::spawn() {
+  unsigned Win32ThreadID = 0;
 
   HANDLE handle =
-    _beginthreadex(0,0,internal_winthread_driver,0,0, & Win32ThreadID );
+      _beginthreadex(0, 0, internal_winthread_driver, 0, 0, &Win32ThreadID);
 
-  return ! handle ;
+  return !handle;
 }
 
-bool ThreadsExec::is_process() { return true ; }
+bool ThreadsExec::is_process() { return true; }
 
-void ThreadsExec::global_lock()
-{ ThreadLockWindows::singleton().lock(); }
+void ThreadsExec::global_lock() { ThreadLockWindows::singleton().lock(); }
 
-void ThreadsExec::global_unlock()
-{ ThreadLockWindows::singleton().unlock(); }
+void ThreadsExec::global_unlock() { ThreadLockWindows::singleton().unlock(); }
 
-void ThreadsExec::wait_yield( volatile int & flag , const int value ) {}
-{
-  while ( value == flag ) { Sleep(0); }
+void ThreadsExec::wait_yield(volatile int& flag, const int value){} {
+  while (value == flag) {
+    Sleep(0);
+  }
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #else
 void KOKKOS_CORE_SRC_THREADS_EXEC_BASE_PREVENT_LINK_ERROR() {}
 #endif /* end #elif defined( KOKKOS_ENABLE_WINTHREAD ) */
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_ThreadsTeam.hpp b/lib/kokkos/core/src/Threads/Kokkos_ThreadsTeam.hpp
index 9d6c0fa8cf249cc6a7cce5902507047f32a439fc..2cd9d73b2a43137f6f6e9b158e8c6619f83eb308 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_ThreadsTeam.hpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_ThreadsTeam.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_THREADSTEAM_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 
 #include <cstdio>
 
@@ -63,114 +64,120 @@ namespace Impl {
 
 //----------------------------------------------------------------------------
 
-template< class > struct ThreadsExecAdapter ;
+template <class>
+struct ThreadsExecAdapter;
 
 //----------------------------------------------------------------------------
 
 class ThreadsExecTeamMember {
-private:
-
+ private:
   enum { TEAM_REDUCE_SIZE = 512 };
 
-public:
-  typedef Kokkos::Threads execution_space ;
-  typedef execution_space::scratch_memory_space scratch_memory_space ;
-
-private:
-  typedef execution_space::scratch_memory_space space ;
-  ThreadsExec * const   m_exec ;
-  ThreadsExec * const * m_team_base ; ///< Base for team fan-in
-  space                 m_team_shared ;
-  int                   m_team_shared_size ;
-  int                   m_team_size ;
-  int                   m_team_rank ;
-  int                   m_team_rank_rev ;
-  int                   m_league_size ;
-  int                   m_league_end ;
-  int                   m_league_rank ;
-
-  int                   m_chunk_size;
-  int                   m_league_chunk_end;
+ public:
+  typedef Kokkos::Threads execution_space;
+  typedef execution_space::scratch_memory_space scratch_memory_space;
+
+ private:
+  typedef execution_space::scratch_memory_space space;
+  ThreadsExec* const m_exec;
+  ThreadsExec* const* m_team_base;  ///< Base for team fan-in
+  space m_team_shared;
+  int m_team_shared_size;
+  int m_team_size;
+  int m_team_rank;
+  int m_team_rank_rev;
+  int m_league_size;
+  int m_league_end;
+  int m_league_rank;
 
-  int                   m_invalid_thread;
-  int                   m_team_alloc;
+  int m_chunk_size;
+  int m_league_chunk_end;
 
-  inline
-  void set_team_shared()
-    { new( & m_team_shared ) space( ((char *) (*m_team_base)->scratch_memory()) + TEAM_REDUCE_SIZE , m_team_shared_size ); }
+  int m_invalid_thread;
+  int m_team_alloc;
 
-public:
+  inline void set_team_shared() {
+    new (&m_team_shared)
+        space(((char*)(*m_team_base)->scratch_memory()) + TEAM_REDUCE_SIZE,
+              m_team_shared_size);
+  }
 
+ public:
   // Fan-in and wait until the matching fan-out is called.
   // The root thread which does not wait will return true.
   // All other threads will return false during the fan-out.
-  KOKKOS_INLINE_FUNCTION bool team_fan_in() const
-    {
-      int n , j ;
-
-      // Wait for fan-in threads
-      for ( n = 1 ; ( ! ( m_team_rank_rev & n ) ) && ( ( j = m_team_rank_rev + n ) < m_team_size ) ; n <<= 1 ) {
-        Impl::spinwait_while_equal<int>( m_team_base[j]->state() , ThreadsExec::Active );
-      }
-
-      // If not root then wait for release
-      if ( m_team_rank_rev ) {
-        m_exec->state() = ThreadsExec::Rendezvous ;
-        Impl::spinwait_while_equal<int>( m_exec->state() , ThreadsExec::Rendezvous );
-      }
-
-      return ! m_team_rank_rev ;
+  KOKKOS_INLINE_FUNCTION bool team_fan_in() const {
+    int n, j;
+
+    // Wait for fan-in threads
+    for (n = 1;
+         (!(m_team_rank_rev & n)) && ((j = m_team_rank_rev + n) < m_team_size);
+         n <<= 1) {
+      Impl::spinwait_while_equal<int>(m_team_base[j]->state(),
+                                      ThreadsExec::Active);
     }
 
-  KOKKOS_INLINE_FUNCTION void team_fan_out() const
-    {
-      int n , j ;
-      for ( n = 1 ; ( ! ( m_team_rank_rev & n ) ) && ( ( j = m_team_rank_rev + n ) < m_team_size ) ; n <<= 1 ) {
-        m_team_base[j]->state() = ThreadsExec::Active ;
-      }
+    // If not root then wait for release
+    if (m_team_rank_rev) {
+      m_exec->state() = ThreadsExec::Rendezvous;
+      Impl::spinwait_while_equal<int>(m_exec->state(), ThreadsExec::Rendezvous);
     }
 
-public:
+    return !m_team_rank_rev;
+  }
 
-  KOKKOS_INLINE_FUNCTION static int team_reduce_size() { return TEAM_REDUCE_SIZE ; }
+  KOKKOS_INLINE_FUNCTION void team_fan_out() const {
+    int n, j;
+    for (n = 1;
+         (!(m_team_rank_rev & n)) && ((j = m_team_rank_rev + n) < m_team_size);
+         n <<= 1) {
+      m_team_base[j]->state() = ThreadsExec::Active;
+    }
+  }
 
-  KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space & team_shmem() const
-    { return m_team_shared.set_team_thread_mode(0,1,0) ; }
+ public:
+  KOKKOS_INLINE_FUNCTION static int team_reduce_size() {
+    return TEAM_REDUCE_SIZE;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space & team_scratch(int) const
-    { return m_team_shared.set_team_thread_mode(0,1,0) ; }
+  const execution_space::scratch_memory_space& team_shmem() const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space & thread_scratch(int) const
-    { return m_team_shared.set_team_thread_mode(0,team_size(),team_rank()) ; }
-
-  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank ; }
-  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size ; }
-  KOKKOS_INLINE_FUNCTION int team_rank() const { return m_team_rank ; }
-  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size ; }
-
-  KOKKOS_INLINE_FUNCTION void team_barrier() const
-    {
-      team_fan_in();
-      team_fan_out();
-    }
+  const execution_space::scratch_memory_space& team_scratch(int) const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
 
-  template<class ValueType>
   KOKKOS_INLINE_FUNCTION
-  void team_broadcast(ValueType& value, const int& thread_id) const
-  {
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    { }
+  const execution_space::scratch_memory_space& thread_scratch(int) const {
+    return m_team_shared.set_team_thread_mode(0, team_size(), team_rank());
+  }
+
+  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank; }
+  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
+  KOKKOS_INLINE_FUNCTION int team_rank() const { return m_team_rank; }
+  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
+
+  KOKKOS_INLINE_FUNCTION void team_barrier() const {
+    team_fan_in();
+    team_fan_out();
+  }
+
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(ValueType& value,
+                                             const int& thread_id) const {
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    {}
 #else
     // Make sure there is enough scratch space:
-    typedef typename if_c< sizeof(ValueType) < TEAM_REDUCE_SIZE
-                         , ValueType , void >::type type ;
+    typedef typename if_c<sizeof(ValueType) < TEAM_REDUCE_SIZE, ValueType,
+                          void>::type type;
 
-    if ( m_team_base ) {
-      type * const local_value = ((type*) m_team_base[0]->scratch_memory());
-      if(team_rank() == thread_id) *local_value = value;
+    if (m_team_base) {
+      type* const local_value = ((type*)m_team_base[0]->scratch_memory());
+      if (team_rank() == thread_id) *local_value = value;
       memory_fence();
       team_barrier();
       value = *local_value;
@@ -178,115 +185,121 @@ public:
 #endif
   }
 
-  template<class Closure, class ValueType>
-  KOKKOS_INLINE_FUNCTION
-  void team_broadcast(Closure const & f, ValueType& value, const int& thread_id) const
-  {
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    { }
+  template <class Closure, class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(Closure const& f, ValueType& value,
+                                             const int& thread_id) const {
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    {}
 #else
     // Make sure there is enough scratch space:
-    typedef typename if_c< sizeof(ValueType) < TEAM_REDUCE_SIZE
-                         , ValueType , void >::type type ;
-    f( value );
-    if ( m_team_base ) {
-      type * const local_value = ((type*) m_team_base[0]->scratch_memory());
-      if(team_rank() == thread_id) *local_value = value;
+    typedef typename if_c<sizeof(ValueType) < TEAM_REDUCE_SIZE, ValueType,
+                          void>::type type;
+    f(value);
+    if (m_team_base) {
+      type* const local_value = ((type*)m_team_base[0]->scratch_memory());
+      if (team_rank() == thread_id) *local_value = value;
       memory_fence();
       team_barrier();
       value = *local_value;
     }
 #endif
   }
-  
-  template< typename Type >
+
+  template <typename Type>
   KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< !Kokkos::is_reducer< Type >::value , Type>::type
-  team_reduce( const Type & value ) const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    { return Type(); }
+      typename std::enable_if<!Kokkos::is_reducer<Type>::value, Type>::type
+      team_reduce(const Type& value) const
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    return Type();
+  }
 #else
-    {
-      // Make sure there is enough scratch space:
-      typedef typename if_c< sizeof(Type) < TEAM_REDUCE_SIZE , Type , void >::type type ;
+  {
+    // Make sure there is enough scratch space:
+    typedef
+        typename if_c<sizeof(Type) < TEAM_REDUCE_SIZE, Type, void>::type type;
 
-      if ( 0 == m_exec ) return value ;
+    if (0 == m_exec) return value;
 
-      *((volatile type*) m_exec->scratch_memory() ) = value ;
+    *((volatile type*)m_exec->scratch_memory()) = value;
 
-      memory_fence();
+    memory_fence();
 
-      type & accum = *((type *) m_team_base[0]->scratch_memory() );
+    type& accum = *((type*)m_team_base[0]->scratch_memory());
 
-      if ( team_fan_in() ) {
-        for ( int i = 1 ; i < m_team_size ; ++i ) {
-          accum += *((type *) m_team_base[i]->scratch_memory() );
-        }
-        memory_fence();
+    if (team_fan_in()) {
+      for (int i = 1; i < m_team_size; ++i) {
+        accum += *((type*)m_team_base[i]->scratch_memory());
       }
+      memory_fence();
+    }
 
-      team_fan_out();
+    team_fan_out();
 
-      return accum ;
-    }
+    return accum;
+  }
 #endif
 
-    template< typename ReducerType >
-    KOKKOS_INLINE_FUNCTION
-    typename std::enable_if< is_reducer< ReducerType >::value >::type
-    team_reduce( ReducerType const & reducer ) const noexcept
-    { team_reduce(reducer,reducer.reference()); }
-
-    template< typename ReducerType >
-    KOKKOS_INLINE_FUNCTION
-    typename std::enable_if< Kokkos::is_reducer< ReducerType >::value >::type
-  #if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    team_reduce( const ReducerType &, const typename ReducerType::value_type ) const
-      {}
-  #else
-    team_reduce( const ReducerType & reducer, const typename ReducerType::value_type contribution  ) const
-    {
-      typedef typename ReducerType::value_type value_type;
-      // Make sure there is enough scratch space:
-      typedef typename if_c< sizeof(value_type) < TEAM_REDUCE_SIZE
-                           , value_type , void >::type type ;
-
-      if ( 0 == m_exec ) return ;
-
-      type * const local_value = ((type*) m_exec->scratch_memory());
-
-      // Set this thread's contribution
-      *local_value = contribution ;
-
-      // Fence to make sure the base team member has access:
-      memory_fence();
+  template <typename ReducerType>
+  KOKKOS_INLINE_FUNCTION
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      team_reduce(ReducerType const& reducer) const noexcept {
+    team_reduce(reducer, reducer.reference());
+  }
+
+  template <typename ReducerType>
+  KOKKOS_INLINE_FUNCTION
+      typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+      team_reduce(const ReducerType&,
+                  const typename ReducerType::value_type) const {
+  }
+#else
+      team_reduce(const ReducerType& reducer,
+                  const typename ReducerType::value_type contribution) const {
+    typedef typename ReducerType::value_type value_type;
+    // Make sure there is enough scratch space:
+    typedef typename if_c<sizeof(value_type) < TEAM_REDUCE_SIZE, value_type,
+                          void>::type type;
 
-      if ( team_fan_in() ) {
-        // The last thread to synchronize returns true, all other threads wait for team_fan_out()
-        type * const team_value = ((type*) m_team_base[0]->scratch_memory());
+    if (0 == m_exec) return;
 
-        // Join to the team value:
-        for ( int i = 1 ; i < m_team_size ; ++i ) {
-          reducer.join( *team_value , *((type*) m_team_base[i]->scratch_memory()) );
-        }
+    type* const local_value = ((type*)m_exec->scratch_memory());
 
-        // Team base thread may "lap" member threads so copy out to their local value.
-        for ( int i = 1 ; i < m_team_size ; ++i ) {
-          *((type*) m_team_base[i]->scratch_memory()) = *team_value ;
-        }
+    // Set this thread's contribution
+    *local_value = contribution;
 
-        // Fence to make sure all team members have access
-        memory_fence();
+    // Fence to make sure the base team member has access:
+    memory_fence();
+
+    if (team_fan_in()) {
+      // The last thread to synchronize returns true, all other threads wait for
+      // team_fan_out()
+      type* const team_value = ((type*)m_team_base[0]->scratch_memory());
+
+      // Join to the team value:
+      for (int i = 1; i < m_team_size; ++i) {
+        reducer.join(*team_value, *((type*)m_team_base[i]->scratch_memory()));
       }
 
-      team_fan_out();
+      // Team base thread may "lap" member threads so copy out to their local
+      // value.
+      for (int i = 1; i < m_team_size; ++i) {
+        *((type*)m_team_base[i]->scratch_memory()) = *team_value;
+      }
 
-      // Value was changed by the team base
-      reducer.reference() = *((type volatile const *) local_value);
+      // Fence to make sure all team members have access
+      memory_fence();
     }
-  #endif
 
-   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
+    team_fan_out();
+
+    // Value was changed by the team base
+    reducer.reference() = *((type volatile const*)local_value);
+  }
+#endif
+
+  /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
    *          with intra-team non-deterministic ordering accumulation.
    *
    *  The global inter-team accumulation value will, at the end of the
@@ -295,55 +308,60 @@ public:
    *  As such the base value for each team's scan operation is similarly
    *  non-deterministic.
    */
-  template< typename ArgType >
-  KOKKOS_INLINE_FUNCTION ArgType team_scan( const ArgType & value , ArgType * const global_accum ) const
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    { return ArgType(); }
+  template <typename ArgType>
+  KOKKOS_INLINE_FUNCTION ArgType team_scan(const ArgType& value,
+                                           ArgType* const global_accum) const
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    return ArgType();
+  }
 #else
-    {
-      // Make sure there is enough scratch space:
-      typedef typename if_c< sizeof(ArgType) < TEAM_REDUCE_SIZE , ArgType , void >::type type ;
+  {
+    // Make sure there is enough scratch space:
+    typedef
+        typename if_c<sizeof(ArgType) < TEAM_REDUCE_SIZE, ArgType, void>::type
+            type;
 
-      if ( 0 == m_exec ) return type(0);
+    if (0 == m_exec) return type(0);
 
-      volatile type * const work_value  = ((type*) m_exec->scratch_memory());
+    volatile type* const work_value = ((type*)m_exec->scratch_memory());
 
-      *work_value = value ;
+    *work_value = value;
 
-      memory_fence();
+    memory_fence();
 
-      if ( team_fan_in() ) {
-        // The last thread to synchronize returns true, all other threads wait for team_fan_out()
-        // m_team_base[0]                 == highest ranking team member
-        // m_team_base[ m_team_size - 1 ] == lowest ranking team member
-        //
-        // 1) copy from lower to higher rank, initialize lowest rank to zero
-        // 2) prefix sum from lowest to highest rank, skipping lowest rank
-
-        type accum = 0 ;
-
-        if ( global_accum ) {
-          for ( int i = m_team_size ; i-- ; ) {
-            type & val = *((type*) m_team_base[i]->scratch_memory());
-            accum += val ;
-          }
-          accum = atomic_fetch_add( global_accum , accum );
-        }
+    if (team_fan_in()) {
+      // The last thread to synchronize returns true, all other threads wait for
+      // team_fan_out() m_team_base[0]                 == highest ranking team
+      // member m_team_base[ m_team_size - 1 ] == lowest ranking team member
+      //
+      // 1) copy from lower to higher rank, initialize lowest rank to zero
+      // 2) prefix sum from lowest to highest rank, skipping lowest rank
 
-        for ( int i = m_team_size ; i-- ; ) {
-          type & val = *((type*) m_team_base[i]->scratch_memory());
-          const type offset = accum ;
-          accum += val ;
-          val = offset ;
-        }
+      type accum = 0;
 
-        memory_fence();
+      if (global_accum) {
+        for (int i = m_team_size; i--;) {
+          type& val = *((type*)m_team_base[i]->scratch_memory());
+          accum += val;
+        }
+        accum = atomic_fetch_add(global_accum, accum);
       }
 
-      team_fan_out();
+      for (int i = m_team_size; i--;) {
+        type& val = *((type*)m_team_base[i]->scratch_memory());
+        const type offset = accum;
+        accum += val;
+        val = offset;
+      }
 
-      return *work_value ;
+      memory_fence();
     }
+
+    team_fan_out();
+
+    return *work_value;
+  }
 #endif
 
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering.
@@ -351,154 +369,160 @@ public:
    *  The highest rank thread can compute the reduction total as
    *    reduction_total = dev.team_scan( value ) + value ;
    */
-  template< typename ArgType >
-  KOKKOS_INLINE_FUNCTION ArgType team_scan( const ArgType & value ) const
-    { return this-> template team_scan<ArgType>( value , 0 ); }
-
+  template <typename ArgType>
+  KOKKOS_INLINE_FUNCTION ArgType team_scan(const ArgType& value) const {
+    return this->template team_scan<ArgType>(value, 0);
+  }
 
   //----------------------------------------
   // Private for the driver
 
-  template< class ... Properties >
-  ThreadsExecTeamMember( Impl::ThreadsExec * exec
-                       , const TeamPolicyInternal< Kokkos::Threads , Properties ... > & team
-                       , const int shared_size )
-    : m_exec( exec )
-    , m_team_base(0)
-    , m_team_shared(0,0)
-    , m_team_shared_size( shared_size )
-    , m_team_size(team.team_size())
-    , m_team_rank(0)
-    , m_team_rank_rev(0)
-    , m_league_size(0)
-    , m_league_end(0)
-    , m_league_rank(0)
-    , m_chunk_size( team.chunk_size() )
-    , m_league_chunk_end(0)
-    , m_team_alloc( team.team_alloc())
-   {
-      if ( team.league_size() ) {
-        // Execution is using device-team interface:
-
-        const int pool_rank_rev = m_exec->pool_size() - ( m_exec->pool_rank() + 1 );
-        const int team_rank_rev = pool_rank_rev % team.team_alloc();
-        const size_t pool_league_size     = m_exec->pool_size() / team.team_alloc() ;
-        const size_t pool_league_rank_rev = pool_rank_rev / team.team_alloc() ;
-        if(pool_league_rank_rev >= pool_league_size) {
-          m_invalid_thread = 1;
-          return;
-        }
-        const size_t pool_league_rank     = pool_league_size - ( pool_league_rank_rev + 1 );
-
-        const int pool_num_teams       = m_exec->pool_size()/team.team_alloc();
-        const int chunk_size           = team.chunk_size()>0?team.chunk_size():team.team_iter();
-        const int chunks_per_team      = ( team.league_size() + chunk_size*pool_num_teams-1 ) / (chunk_size*pool_num_teams);
-              int league_iter_end      = team.league_size() - pool_league_rank_rev * chunks_per_team * chunk_size;
-              int league_iter_begin    = league_iter_end - chunks_per_team * chunk_size;
-        if (league_iter_begin < 0)     league_iter_begin = 0;
-        if (league_iter_end>team.league_size()) league_iter_end = team.league_size();
-
-        if ((team.team_alloc()>m_team_size)?
-            (team_rank_rev >= m_team_size):
-            (m_exec->pool_size() - pool_num_teams*m_team_size > m_exec->pool_rank())
-           )
-          m_invalid_thread = 1;
-        else
-          m_invalid_thread = 0;
-
-        // May be using fewer threads per team than a multiple of threads per core,
-        // some threads will idle.
-
-        if ( team_rank_rev < team.team_size() && !m_invalid_thread) {
-
-          m_team_base        = m_exec->pool_base() + team.team_alloc() * pool_league_rank_rev ;
-          m_team_size        = team.team_size() ;
-          m_team_rank        = team.team_size() - ( team_rank_rev + 1 );
-          m_team_rank_rev    = team_rank_rev ;
-          m_league_size      = team.league_size();
-
-          m_league_rank      = ( team.league_size() *  pool_league_rank    ) / pool_league_size ;
-          m_league_end       = ( team.league_size() * (pool_league_rank+1) ) / pool_league_size ;
-
-          set_team_shared();
-        }
-
-        if ( (m_team_rank_rev == 0) && (m_invalid_thread == 0) ) {
-          m_exec->set_work_range(m_league_rank,m_league_end,m_chunk_size);
-          m_exec->reset_steal_target(m_team_size);
-        }
-        if(std::is_same<typename TeamPolicyInternal<Kokkos::Threads, Properties ...>::schedule_type::type,Kokkos::Dynamic>::value) {
-          m_exec->barrier();
-        }
+  template <class... Properties>
+  ThreadsExecTeamMember(
+      Impl::ThreadsExec* exec,
+      const TeamPolicyInternal<Kokkos::Threads, Properties...>& team,
+      const int shared_size)
+      : m_exec(exec),
+        m_team_base(0),
+        m_team_shared(0, 0),
+        m_team_shared_size(shared_size),
+        m_team_size(team.team_size()),
+        m_team_rank(0),
+        m_team_rank_rev(0),
+        m_league_size(0),
+        m_league_end(0),
+        m_league_rank(0),
+        m_chunk_size(team.chunk_size()),
+        m_league_chunk_end(0),
+        m_team_alloc(team.team_alloc()) {
+    if (team.league_size()) {
+      // Execution is using device-team interface:
+
+      const int pool_rank_rev = m_exec->pool_size() - (m_exec->pool_rank() + 1);
+      const int team_rank_rev = pool_rank_rev % team.team_alloc();
+      const size_t pool_league_size = m_exec->pool_size() / team.team_alloc();
+      const size_t pool_league_rank_rev = pool_rank_rev / team.team_alloc();
+      if (pool_league_rank_rev >= pool_league_size) {
+        m_invalid_thread = 1;
+        return;
       }
+      const size_t pool_league_rank =
+          pool_league_size - (pool_league_rank_rev + 1);
+
+      const int pool_num_teams = m_exec->pool_size() / team.team_alloc();
+      const int chunk_size =
+          team.chunk_size() > 0 ? team.chunk_size() : team.team_iter();
+      const int chunks_per_team =
+          (team.league_size() + chunk_size * pool_num_teams - 1) /
+          (chunk_size * pool_num_teams);
+      int league_iter_end = team.league_size() -
+                            pool_league_rank_rev * chunks_per_team * chunk_size;
+      int league_iter_begin = league_iter_end - chunks_per_team * chunk_size;
+      if (league_iter_begin < 0) league_iter_begin = 0;
+      if (league_iter_end > team.league_size())
+        league_iter_end = team.league_size();
+
+      if ((team.team_alloc() > m_team_size)
+              ? (team_rank_rev >= m_team_size)
+              : (m_exec->pool_size() - pool_num_teams * m_team_size >
+                 m_exec->pool_rank()))
+        m_invalid_thread = 1;
       else
-      { m_invalid_thread = 1; }
-    }
+        m_invalid_thread = 0;
 
-  ThreadsExecTeamMember()
-    : m_exec(0)
-    , m_team_base(0)
-    , m_team_shared(0,0)
-    , m_team_shared_size(0)
-    , m_team_size(1)
-    , m_team_rank(0)
-    , m_team_rank_rev(0)
-    , m_league_size(1)
-    , m_league_end(0)
-    , m_league_rank(0)
-    , m_chunk_size(0)
-    , m_league_chunk_end(0)
-    , m_invalid_thread(0)
-    , m_team_alloc(0)
-    {}
+      // May be using fewer threads per team than a multiple of threads per
+      // core, some threads will idle.
 
-  inline
-  ThreadsExec & threads_exec_team_base() const { return m_team_base ? **m_team_base : *m_exec ; }
+      if (team_rank_rev < team.team_size() && !m_invalid_thread) {
+        m_team_base =
+            m_exec->pool_base() + team.team_alloc() * pool_league_rank_rev;
+        m_team_size     = team.team_size();
+        m_team_rank     = team.team_size() - (team_rank_rev + 1);
+        m_team_rank_rev = team_rank_rev;
+        m_league_size   = team.league_size();
 
-  bool valid_static() const
-    { return m_league_rank < m_league_end ; }
+        m_league_rank =
+            (team.league_size() * pool_league_rank) / pool_league_size;
+        m_league_end =
+            (team.league_size() * (pool_league_rank + 1)) / pool_league_size;
 
-  void next_static()
-    {
-      if ( m_league_rank < m_league_end ) {
-        // Make sure all stores are complete before entering the barrier
-        memory_fence();
-        team_barrier();
         set_team_shared();
       }
-      m_league_rank++;
+
+      if ((m_team_rank_rev == 0) && (m_invalid_thread == 0)) {
+        m_exec->set_work_range(m_league_rank, m_league_end, m_chunk_size);
+        m_exec->reset_steal_target(m_team_size);
+      }
+      if (std::is_same<typename TeamPolicyInternal<
+                           Kokkos::Threads, Properties...>::schedule_type::type,
+                       Kokkos::Dynamic>::value) {
+        m_exec->barrier();
+      }
+    } else {
+      m_invalid_thread = 1;
     }
+  }
 
-  bool valid_dynamic() {
+  ThreadsExecTeamMember()
+      : m_exec(0),
+        m_team_base(0),
+        m_team_shared(0, 0),
+        m_team_shared_size(0),
+        m_team_size(1),
+        m_team_rank(0),
+        m_team_rank_rev(0),
+        m_league_size(1),
+        m_league_end(0),
+        m_league_rank(0),
+        m_chunk_size(0),
+        m_league_chunk_end(0),
+        m_invalid_thread(0),
+        m_team_alloc(0) {}
+
+  inline ThreadsExec& threads_exec_team_base() const {
+    return m_team_base ? **m_team_base : *m_exec;
+  }
+
+  bool valid_static() const { return m_league_rank < m_league_end; }
 
-    if(m_invalid_thread)
-      return false;
-    if ((m_league_rank < m_league_chunk_end) && (m_league_rank < m_league_size)) {
+  void next_static() {
+    if (m_league_rank < m_league_end) {
+      // Make sure all stores are complete before entering the barrier
+      memory_fence();
+      team_barrier();
+      set_team_shared();
+    }
+    m_league_rank++;
+  }
+
+  bool valid_dynamic() {
+    if (m_invalid_thread) return false;
+    if ((m_league_rank < m_league_chunk_end) &&
+        (m_league_rank < m_league_size)) {
       return true;
     }
 
-    if (  m_team_rank_rev == 0 ) {
+    if (m_team_rank_rev == 0) {
       m_team_base[0]->get_work_index(m_team_alloc);
     }
     team_barrier();
 
     long work_index = m_team_base[0]->team_work_index();
 
-    m_league_rank = work_index * m_chunk_size;
-    m_league_chunk_end = (work_index +1 ) * m_chunk_size;
+    m_league_rank      = work_index * m_chunk_size;
+    m_league_chunk_end = (work_index + 1) * m_chunk_size;
 
-    if(m_league_chunk_end > m_league_size) m_league_chunk_end = m_league_size;
+    if (m_league_chunk_end > m_league_size) m_league_chunk_end = m_league_size;
 
-    if((m_league_rank>=0) && (m_league_rank < m_league_chunk_end))
+    if ((m_league_rank >= 0) && (m_league_rank < m_league_chunk_end))
       return true;
     return false;
   }
 
   void next_dynamic() {
-    if(m_invalid_thread)
-      return;
+    if (m_invalid_thread) return;
 
-    if ( m_league_rank < m_league_chunk_end ) {
+    if (m_league_rank < m_league_chunk_end) {
       // Make sure all stores are complete before entering the barrier
       memory_fence();
       team_barrier();
@@ -507,16 +531,13 @@ public:
     m_league_rank++;
   }
 
-  void set_league_shmem( const int arg_league_rank
-                       , const int arg_league_size
-                       , const int arg_shmem_size
-                       )
-    {
-      m_league_rank = arg_league_rank ;
-      m_league_size = arg_league_size ;
-      m_team_shared_size = arg_shmem_size ;
-      set_team_shared();
-    }
+  void set_league_shmem(const int arg_league_rank, const int arg_league_size,
+                        const int arg_shmem_size) {
+    m_league_rank      = arg_league_rank;
+    m_league_size      = arg_league_size;
+    m_team_shared_size = arg_shmem_size;
+    set_team_shared();
+  }
 };
 
 } /* namespace Impl */
@@ -527,586 +548,656 @@ public:
 
 namespace Kokkos {
 namespace Impl {
-template< class ... Properties >
-class TeamPolicyInternal< Kokkos::Threads , Properties ... >: public PolicyTraits<Properties ...>
-{
-private:
-
-  int m_league_size ;
-  int m_team_size ;
-  int m_team_alloc ;
-  int m_team_iter ;
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Threads, Properties...>
+    : public PolicyTraits<Properties...> {
+ private:
+  int m_league_size;
+  int m_team_size;
+  int m_team_alloc;
+  int m_team_iter;
 
   size_t m_team_scratch_size[2];
   size_t m_thread_scratch_size[2];
 
   int m_chunk_size;
 
-  inline
-  void init( const int league_size_request
-           , const int team_size_request )
-   {
+  inline void init(const int league_size_request, const int team_size_request) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int pool_size  = traits::execution_space::thread_pool_size(0);
+    const int pool_size = traits::execution_space::thread_pool_size(0);
 #else
-      const int pool_size  = traits::execution_space::impl_thread_pool_size(0);
+    const int pool_size = traits::execution_space::impl_thread_pool_size(0);
 #endif
-      const int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-      const int team_max   = pool_size<max_host_team_size?pool_size:max_host_team_size;
+    const int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    const int team_max =
+        pool_size < max_host_team_size ? pool_size : max_host_team_size;
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      const int team_grain = traits::execution_space::thread_pool_size(2);
+    const int team_grain = traits::execution_space::thread_pool_size(2);
 #else
-      const int team_grain = traits::execution_space::impl_thread_pool_size(2);
+    const int team_grain = traits::execution_space::impl_thread_pool_size(2);
 #endif
 
-      m_league_size = league_size_request ;
-
-      #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
-      if(team_size_request > team_max) Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
-      #endif
-
-      m_team_size = team_size_request < team_max ?
-                    team_size_request : team_max ;
+    m_league_size = league_size_request;
 
-      // Round team size up to a multiple of 'team_gain'
-      const int team_size_grain = team_grain * ( ( m_team_size + team_grain - 1 ) / team_grain );
-      const int team_count      = pool_size / team_size_grain ;
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE
+    if (team_size_request > team_max)
+      Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
+#endif
 
-      // Constraint : pool_size = m_team_alloc * team_count
-      m_team_alloc = pool_size / team_count ;
+    m_team_size = team_size_request < team_max ? team_size_request : team_max;
 
-      // Maxumum number of iterations each team will take:
-      m_team_iter  = ( m_league_size + team_count - 1 ) / team_count ;
+    // Round team size up to a multiple of 'team_gain'
+    const int team_size_grain =
+        team_grain * ((m_team_size + team_grain - 1) / team_grain);
+    const int team_count = pool_size / team_size_grain;
 
-      set_auto_chunk_size();
-   }
+    // Constraint : pool_size = m_team_alloc * team_count
+    m_team_alloc = pool_size / team_count;
 
+    // Maxumum number of iterations each team will take:
+    m_team_iter = (m_league_size + team_count - 1) / team_count;
 
-public:
+    set_auto_chunk_size();
+  }
 
+ public:
   //! Tag this class as a kokkos execution policy
   //! Tag this class as a kokkos execution policy
-  typedef TeamPolicyInternal      execution_policy ;
+  typedef TeamPolicyInternal execution_policy;
 
-  typedef PolicyTraits<Properties ... > traits;
+  typedef PolicyTraits<Properties...> traits;
 
-  TeamPolicyInternal& operator = (const TeamPolicyInternal& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_team_alloc = p.m_team_alloc;
-    m_team_iter = p.m_team_iter;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  TeamPolicyInternal& operator=(const TeamPolicyInternal& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_team_alloc             = p.m_team_alloc;
+    m_team_iter              = p.m_team_iter;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
     return *this;
   }
 
-  template<class ExecSpace, class ... OtherProperties >
+  template <class ExecSpace, class... OtherProperties>
   friend class TeamPolicyInternal;
 
-  template< class ... OtherProperties >
-  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::Threads,OtherProperties...>& p) {
-    m_league_size = p.m_league_size;
-    m_team_size = p.m_team_size;
-    m_team_alloc = p.m_team_alloc;
-    m_team_iter = p.m_team_iter;
-    m_team_scratch_size[0] = p.m_team_scratch_size[0];
+  template <class... OtherProperties>
+  TeamPolicyInternal(
+      const TeamPolicyInternal<Kokkos::Threads, OtherProperties...>& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_team_alloc             = p.m_team_alloc;
+    m_team_iter              = p.m_team_iter;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
     m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1] = p.m_team_scratch_size[1];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
     m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size = p.m_chunk_size;
+    m_chunk_size             = p.m_chunk_size;
   }
 
   //----------------------------------------
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  template< class FunctorType >
-  inline static
-  int team_size_max( const FunctorType & ) {
-    int pool_size = traits::execution_space::thread_pool_size(1);
-    int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-    return pool_size<max_host_team_size?pool_size:max_host_team_size;
+  template <class FunctorType>
+  inline static int team_size_max(const FunctorType&) {
+    int pool_size          = traits::execution_space::thread_pool_size(1);
+    int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
 
-  template< class FunctorType >
-  inline static
-  int team_size_recommended( const FunctorType & )
-  {
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&) {
     return traits::execution_space::thread_pool_size(2);
   }
 
-  template< class FunctorType >
-  inline static
-  int team_size_recommended( const FunctorType &, const int& )
-  {
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&, const int&) {
     return traits::execution_space::thread_pool_size(2);
   }
 #endif
 
-  template<class FunctorType>
-  int team_size_max( const FunctorType&, const ParallelForTag& ) const {
+  template <class FunctorType>
+  int team_size_max(const FunctorType&, const ParallelForTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     int pool_size = traits::execution_space::thread_pool_size(1);
 #else
     int pool_size = traits::execution_space::impl_thread_pool_size(1);
 #endif
-    int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-    return pool_size<max_host_team_size?pool_size:max_host_team_size;
+    int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
-  template<class FunctorType>
-  int team_size_max( const FunctorType&, const ParallelReduceTag& ) const {
+  template <class FunctorType>
+  int team_size_max(const FunctorType&, const ParallelReduceTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     int pool_size = traits::execution_space::thread_pool_size(1);
 #else
     int pool_size = traits::execution_space::impl_thread_pool_size(1);
 #endif
-    int max_host_team_size =  Impl::HostThreadTeamData::max_team_members;
-    return pool_size<max_host_team_size?pool_size:max_host_team_size;
+    int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
+    return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType&, const ParallelForTag& ) const {
+  template <class FunctorType, class ReducerType>
+  inline int team_size_max(const FunctorType& f, const ReducerType&,
+                           const ParallelReduceTag& t) const {
+    return team_size_max(f, t);
+  }
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType&, const ParallelForTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     return traits::execution_space::thread_pool_size(2);
 #else
     return traits::execution_space::impl_thread_pool_size(2);
 #endif
   }
-  template<class FunctorType>
-  int team_size_recommended( const FunctorType&, const ParallelReduceTag& ) const {
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType&,
+                            const ParallelReduceTag&) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     return traits::execution_space::thread_pool_size(2);
 #else
     return traits::execution_space::impl_thread_pool_size(2);
 #endif
   }
+  template <class FunctorType, class ReducerType>
+  inline int team_size_recommended(const FunctorType& f, const ReducerType&,
+                                   const ParallelReduceTag& t) const {
+    return team_size_recommended(f, t);
+  }
 
+  inline static int vector_length_max() {
+    return 1024;
+  }  // Use arbitrary large number, is meant as a vectorizable length
 
-  inline static
-  int vector_length_max()
-    { return 1024; } // Use arbitrary large number, is meant as a vectorizable length
-
-  inline static
-  int scratch_size_max(int level)
-    { return (level==0?
-        1024*32: // Roughly L1 size
-        20*1024*1024); // Limit to keep compatibility with CUDA
-    }
+  inline static int scratch_size_max(int level) {
+    return (level == 0 ? 1024 * 32 :  // Roughly L1 size
+                20 * 1024 * 1024);    // Limit to keep compatibility with CUDA
+  }
 
   //----------------------------------------
 
-  inline int team_size() const { return m_team_size ; }
-  inline int team_alloc() const { return m_team_alloc ; }
-  inline int league_size() const { return m_league_size ; }
-  inline size_t scratch_size(const int& level, int team_size_ = -1 ) const {
-    if(team_size_ < 0)
-      team_size_ = m_team_size;
-    return m_team_scratch_size[level] + team_size_*m_thread_scratch_size[level] ;
+  inline int team_size() const { return m_team_size; }
+  inline int team_alloc() const { return m_team_alloc; }
+  inline int league_size() const { return m_league_size; }
+  inline size_t scratch_size(const int& level, int team_size_ = -1) const {
+    if (team_size_ < 0) team_size_ = m_team_size;
+    return m_team_scratch_size[level] +
+           team_size_ * m_thread_scratch_size[level];
   }
 
-  inline int team_iter() const { return m_team_iter ; }
+  inline int team_iter() const { return m_team_iter; }
 
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal( const typename traits::execution_space &
-            , int league_size_request
-            , int team_size_request
-            , int vector_length_request = 1 )
-    : m_league_size(0)
-    , m_team_size(0)
-    , m_team_alloc(0)
-    , m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_chunk_size(0)
-    { init(league_size_request,team_size_request); (void) vector_length_request; }
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request, int team_size_request,
+                     int vector_length_request = 1)
+      : m_league_size(0),
+        m_team_size(0),
+        m_team_alloc(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+    (void)vector_length_request;
+  }
 
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal( const typename traits::execution_space &
-            , int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int /* vector_length_request */ = 1 )
-    : m_league_size(0)
-    , m_team_size(0)
-    , m_team_alloc(0)
-    , m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_chunk_size(0)
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_league_size(0),
+        m_team_size(0),
+        m_team_alloc(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    { init(league_size_request,traits::execution_space::thread_pool_size(2)); }
+  {
+    init(league_size_request, traits::execution_space::thread_pool_size(2));
+  }
 #else
-    { init(league_size_request,traits::execution_space::impl_thread_pool_size(2)); }
+  {
+    init(league_size_request,
+         traits::execution_space::impl_thread_pool_size(2));
+  }
 #endif
 
-  TeamPolicyInternal( int league_size_request
-            , int team_size_request
-            , int /* vector_length_request */ = 1 )
-    : m_league_size(0)
-    , m_team_size(0)
-    , m_team_alloc(0)
-    , m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_chunk_size(0)
-    { init(league_size_request,team_size_request); }
-
-  TeamPolicyInternal( int league_size_request
-            , const Kokkos::AUTO_t & /* team_size_request */
-            , int /* vector_length_request */ = 1 )
-    : m_league_size(0)
-    , m_team_size(0)
-    , m_team_alloc(0)
-    , m_team_scratch_size { 0 , 0 }
-    , m_thread_scratch_size { 0 , 0 }
-    , m_chunk_size(0)
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     int /* vector_length_request */ = 1)
+      : m_league_size(0),
+        m_team_size(0),
+        m_team_alloc(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+  }
+
+  TeamPolicyInternal(int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int /* vector_length_request */ = 1)
+      : m_league_size(0),
+        m_team_size(0),
+        m_team_alloc(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    { init(league_size_request,traits::execution_space::thread_pool_size(2)); }
+  {
+    init(league_size_request, traits::execution_space::thread_pool_size(2));
+  }
 #else
-    { init(league_size_request,traits::execution_space::impl_thread_pool_size(2)); }
+  {
+    init(league_size_request,
+         traits::execution_space::impl_thread_pool_size(2));
+  }
 #endif
-  inline int chunk_size() const { return m_chunk_size ; }
+  inline int chunk_size() const { return m_chunk_size; }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal set_chunk_size(typename traits::index_type chunk_size_) const {
+  inline TeamPolicyInternal set_chunk_size(
+      typename traits::index_type chunk_size_) const {
     TeamPolicyInternal p = *this;
-    p.m_chunk_size = chunk_size_;
+    p.m_chunk_size       = chunk_size_;
     return p;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team) const {
+    TeamPolicyInternal p         = *this;
     p.m_team_scratch_size[level] = per_team.value;
     return p;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) const {
-    TeamPolicyInternal p = *this;
-    p.m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) const {
+    TeamPolicyInternal p           = *this;
+    p.m_team_scratch_size[level]   = per_team.value;
     p.m_thread_scratch_size[level] = per_thread.value;
     return p;
   }
 #else
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal& set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal& set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(const int& level,
+                                              const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
     m_team_scratch_size[level] = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-protected:
+ protected:
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal internal_set_chunk_size(typename traits::index_type chunk_size_) {
+  inline TeamPolicyInternal internal_set_chunk_size(
+      typename traits::index_type chunk_size_) {
     m_chunk_size = chunk_size_;
     return *this;
   }
 
-  /** \brief set per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team) {
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team) {
     m_team_scratch_size[level] = per_team.value;
     return *this;
   }
 
-  /** \brief set per thread scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerThreadValue& per_thread) {
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 
-  /** \brief set per thread and per team scratch size for a specific level of the scratch hierarchy */
-  inline TeamPolicyInternal internal_set_scratch_size(const int& level, const PerTeamValue& per_team, const PerThreadValue& per_thread) {
-    m_team_scratch_size[level] = per_team.value;
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal internal_set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
     m_thread_scratch_size[level] = per_thread.value;
     return *this;
   }
 #endif
 
-private:
+ private:
   /** \brief finalize chunk_size if it was set to AUTO*/
   inline void set_auto_chunk_size() {
+    int concurrency = traits::execution_space::concurrency() / m_team_alloc;
+    if (concurrency == 0) concurrency = 1;
 
-    int concurrency = traits::execution_space::concurrency()/m_team_alloc;
-    if( concurrency==0 ) concurrency=1;
-
-    if(m_chunk_size > 0) {
-      if(!Impl::is_integral_power_of_two( m_chunk_size ))
-        Kokkos::abort("TeamPolicy blocking granularity must be power of two" );
+    if (m_chunk_size > 0) {
+      if (!Impl::is_integral_power_of_two(m_chunk_size))
+        Kokkos::abort("TeamPolicy blocking granularity must be power of two");
     }
 
     int new_chunk_size = 1;
-    while(new_chunk_size*100*concurrency < m_league_size)
+    while (new_chunk_size * 100 * concurrency < m_league_size)
       new_chunk_size *= 2;
-    if(new_chunk_size < 128) {
+    if (new_chunk_size < 128) {
       new_chunk_size = 1;
-      while( (new_chunk_size*40*concurrency < m_league_size ) && (new_chunk_size<128) )
-        new_chunk_size*=2;
+      while ((new_chunk_size * 40 * concurrency < m_league_size) &&
+             (new_chunk_size < 128))
+        new_chunk_size *= 2;
     }
     m_chunk_size = new_chunk_size;
   }
 
-public:
+ public:
+  typedef Impl::ThreadsExecTeamMember member_type;
 
-  typedef Impl::ThreadsExecTeamMember member_type ;
-
-  friend class Impl::ThreadsExecTeamMember ;
+  friend class Impl::ThreadsExecTeamMember;
 };
 
 } /*namespace Impl */
 } /* namespace Kokkos */
 
-
 namespace Kokkos {
 
-template< typename iType >
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< iType, Impl::ThreadsExecTeamMember >
-TeamThreadRange( const Impl::ThreadsExecTeamMember& thread, const iType& count )
-{
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::ThreadsExecTeamMember >( thread, count );
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::ThreadsExecTeamMember>
+    TeamThreadRange(const Impl::ThreadsExecTeamMember& thread,
+                    const iType& count) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType,
+                                               Impl::ThreadsExecTeamMember>(
+      thread, count);
 }
 
-template< typename iType1, typename iType2 >
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< typename std::common_type< iType1, iType2 >::type,
-                                       Impl::ThreadsExecTeamMember>
-TeamThreadRange( const Impl::ThreadsExecTeamMember& thread, const iType1 & begin, const iType2 & end )
-{
-  typedef typename std::common_type< iType1, iType2 >::type iType;
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::ThreadsExecTeamMember >( thread, iType(begin), iType(end) );
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type,
+    Impl::ThreadsExecTeamMember>
+TeamThreadRange(const Impl::ThreadsExecTeamMember& thread, const iType1& begin,
+                const iType2& end) {
+  typedef typename std::common_type<iType1, iType2>::type iType;
+  return Impl::TeamThreadRangeBoundariesStruct<iType,
+                                               Impl::ThreadsExecTeamMember>(
+      thread, iType(begin), iType(end));
 }
 
-template< typename iType >
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< iType, Impl::ThreadsExecTeamMember >
-TeamVectorRange( const Impl::ThreadsExecTeamMember& thread, const iType& count )
-{
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::ThreadsExecTeamMember >( thread, count );
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::ThreadsExecTeamMember>
+    TeamVectorRange(const Impl::ThreadsExecTeamMember& thread,
+                    const iType& count) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType,
+                                               Impl::ThreadsExecTeamMember>(
+      thread, count);
 }
 
-template< typename iType1, typename iType2 >
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct< typename std::common_type< iType1, iType2 >::type,
-                                       Impl::ThreadsExecTeamMember>
-TeamVectorRange( const Impl::ThreadsExecTeamMember& thread, const iType1 & begin, const iType2 & end )
-{
-  typedef typename std::common_type< iType1, iType2 >::type iType;
-  return Impl::TeamThreadRangeBoundariesStruct< iType, Impl::ThreadsExecTeamMember >( thread, iType(begin), iType(end) );
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type,
+    Impl::ThreadsExecTeamMember>
+TeamVectorRange(const Impl::ThreadsExecTeamMember& thread, const iType1& begin,
+                const iType2& end) {
+  typedef typename std::common_type<iType1, iType2>::type iType;
+  return Impl::TeamThreadRangeBoundariesStruct<iType,
+                                               Impl::ThreadsExecTeamMember>(
+      thread, iType(begin), iType(end));
 }
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >
-  ThreadVectorRange(const Impl::ThreadsExecTeamMember& thread, const iType& count) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >(thread,count);
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ThreadsExecTeamMember>
+    ThreadVectorRange(const Impl::ThreadsExecTeamMember& thread,
+                      const iType& count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType,
+                                                 Impl::ThreadsExecTeamMember>(
+      thread, count);
 }
 
-template<typename iType>
+template <typename iType>
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >
-  ThreadVectorRange(const Impl::ThreadsExecTeamMember& thread, const iType& arg_begin, const iType& arg_end) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >(thread,arg_begin,arg_end);
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::ThreadsExecTeamMember>
+    ThreadVectorRange(const Impl::ThreadsExecTeamMember& thread,
+                      const iType& arg_begin, const iType& arg_end) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType,
+                                                 Impl::ThreadsExecTeamMember>(
+      thread, arg_begin, arg_end);
 }
 
-
 KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::ThreadsExecTeamMember> PerTeam(const Impl::ThreadsExecTeamMember& thread) {
+Impl::ThreadSingleStruct<Impl::ThreadsExecTeamMember> PerTeam(
+    const Impl::ThreadsExecTeamMember& thread) {
   return Impl::ThreadSingleStruct<Impl::ThreadsExecTeamMember>(thread);
 }
 
 KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::ThreadsExecTeamMember> PerThread(const Impl::ThreadsExecTeamMember& thread) {
+Impl::VectorSingleStruct<Impl::ThreadsExecTeamMember> PerThread(
+    const Impl::ThreadsExecTeamMember& thread) {
   return Impl::VectorSingleStruct<Impl::ThreadsExecTeamMember>(thread);
 }
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-  /** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each i=0..N-1.
-   *
-   * The range i=0..N-1 is mapped to all threads of the the calling thread team.
-   * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember>& loop_boundaries, const Lambda& lambda) {
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team.
+ * This functionality requires C++11 support.*/
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+    const Lambda& lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< !Kokkos::is_reducer< ValueType >::value >::type
-parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember>& loop_boundaries,
-                     const Lambda & lambda, ValueType& result) {
-
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+                    const Lambda& lambda, ValueType& result) {
   ValueType intermediate;
   Sum<ValueType> sum(intermediate);
   sum.init(intermediate);
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
     ValueType tmp = ValueType();
-    lambda(i,tmp);
-    intermediate+=tmp;
+    lambda(i, tmp);
+    intermediate += tmp;
   }
 
-  loop_boundaries.thread.team_reduce(sum,intermediate);
+  loop_boundaries.thread.team_reduce(sum, intermediate);
   result = sum.reference();
 }
 
-template< typename iType, class Lambda, typename ReducerType >
+template <typename iType, class Lambda, typename ReducerType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< Kokkos::is_reducer< ReducerType >::value >::type
-parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember>& loop_boundaries,
-                     const Lambda & lambda, const ReducerType& reducer) {
-
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+                    const Lambda& lambda, const ReducerType& reducer) {
   typename ReducerType::value_type value;
   reducer.init(value);
 
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,value);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, value);
   }
 
-  loop_boundaries.thread.team_reduce(reducer,value);
+  loop_boundaries.thread.team_reduce(reducer, value);
 }
 
-} //namespace Kokkos
-
+}  // namespace Kokkos
 
 namespace Kokkos {
-/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
  *
  * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
  * This functionality requires C++11 support.*/
-template<typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION
-void parallel_for(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >&
-    loop_boundaries, const Lambda& lambda) {
-  #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-  #pragma ivdep
-  #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment)
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+    const Lambda& lambda) {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
     lambda(i);
 }
 
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i, ValueType & val) for each i=0..N-1.
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread and a summation of
- * val is performed and put into result. This functionality requires C++11 support.*/
-template< typename iType, class Lambda, typename ValueType >
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a summation of val is performed and put into result. This functionality
+ * requires C++11 support.*/
+template <typename iType, class Lambda, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< !Kokkos::is_reducer< ValueType >::value >::type
-parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >&
-      loop_boundaries, const Lambda & lambda, ValueType& result) {
+    typename std::enable_if<!Kokkos::is_reducer<ValueType>::value>::type
+    parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+                    const Lambda& lambda, ValueType& result) {
   result = ValueType();
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,result);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
 }
 
-template< typename iType, class Lambda, typename ReducerType >
+template <typename iType, class Lambda, typename ReducerType>
 KOKKOS_INLINE_FUNCTION
-typename std::enable_if< Kokkos::is_reducer< ReducerType >::value >::type
-parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >&
-      loop_boundaries, const Lambda & lambda, const ReducerType& reducer) {
+    typename std::enable_if<Kokkos::is_reducer<ReducerType>::value>::type
+    parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+                    const Lambda& lambda, const ReducerType& reducer) {
   reducer.init(reducer.reference());
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,reducer.reference());
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
   }
 }
 
-
-/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes lambda(iType i, ValueType & val, bool final)
- *          for each i=0..N-1.
+/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
+ * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
  *
- * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan operation is performed.
- * Depending on the target execution space the operator might be called twice: once with final=false
- * and once with final=true. When final==true val contains the prefix sum value. The contribution of this
- * "i" needs to be added to val no matter whether final==true or not. In a serial execution
- * (i.e. team_size==1) the operator is only called once with final==true. Scan_val will be set
- * to the final sum value over all vector lanes.
- * This functionality requires C++11 support.*/
-template< typename iType, class FunctorType >
-KOKKOS_INLINE_FUNCTION
-void parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<iType,Impl::ThreadsExecTeamMember >&
-      loop_boundaries, const FunctorType & lambda) {
-
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
-  typedef typename ValueTraits::value_type value_type ;
+ * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
+ * operation is performed. Depending on the target execution space the operator
+ * might be called twice: once with final=false and once with final=true. When
+ * final==true val contains the prefix sum value. The contribution of this "i"
+ * needs to be added to val no matter whether final==true or not. In a serial
+ * execution (i.e. team_size==1) the operator is only called once with
+ * final==true. Scan_val will be set to the final sum value over all vector
+ * lanes. This functionality requires C++11 support.*/
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+    const FunctorType& lambda) {
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, void> ValueTraits;
+  typedef typename ValueTraits::value_type value_type;
 
   value_type scan_val = value_type();
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
-  for( iType i = loop_boundaries.start; i < loop_boundaries.end; i+=loop_boundaries.increment) {
-    lambda(i,scan_val,true);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, scan_val, true);
   }
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 namespace Kokkos {
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::ThreadsExecTeamMember>& single_struct, const FunctorType& lambda) {
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::ThreadsExecTeamMember>& single_struct,
+    const FunctorType& lambda) {
   lambda();
 }
 
-template<class FunctorType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::ThreadsExecTeamMember>& single_struct, const FunctorType& lambda) {
-  if(single_struct.team_member.team_rank()==0) lambda();
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::ThreadsExecTeamMember>& single_struct,
+    const FunctorType& lambda) {
+  if (single_struct.team_member.team_rank() == 0) lambda();
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::VectorSingleStruct<Impl::ThreadsExecTeamMember>& single_struct, const FunctorType& lambda, ValueType& val) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::ThreadsExecTeamMember>& single_struct,
+    const FunctorType& lambda, ValueType& val) {
   lambda(val);
 }
 
-template<class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION
-void single(const Impl::ThreadSingleStruct<Impl::ThreadsExecTeamMember>& single_struct, const FunctorType& lambda, ValueType& val) {
-  if(single_struct.team_member.team_rank()==0) {
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::ThreadsExecTeamMember>& single_struct,
+    const FunctorType& lambda, ValueType& val) {
+  if (single_struct.team_member.team_rank() == 0) {
     lambda(val);
   }
-  single_struct.team_member.team_broadcast(val,0);
-}
+  single_struct.team_member.team_broadcast(val, 0);
 }
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 #endif
 #endif /* #define KOKKOS_THREADSTEAM_HPP */
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_Threads_Parallel.hpp b/lib/kokkos/core/src/Threads/Kokkos_Threads_Parallel.hpp
index 022a5fc1882b7774d0e0e91e347ace742dc8ef24..f45830cb24c8e8d65157a35273089a869d8312c5 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_Threads_Parallel.hpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_Threads_Parallel.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_THREADS_PARALLEL_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
 
 #include <vector>
 #include <iostream>
@@ -65,760 +66,736 @@ namespace Impl {
 //----------------------------------------------------------------------------
 /* ParallelFor Kokkos::Threads with RangePolicy */
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::RangePolicy< Traits ... >
-                 , Kokkos::Threads
-                 >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                  Kokkos::Threads> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
-  typedef typename Policy::work_tag    WorkTag ;
-  typedef typename Policy::WorkRange   WorkRange ;
-  typedef typename Policy::member_type Member ;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend )
-    {
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( i );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member ibeg,
+                 const Member iend) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member ibeg , const Member iend )
-    {
-      const TagType t{} ;
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( t , i );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member ibeg,
+                 const Member iend) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i);
     }
+  }
 
-  static void exec( ThreadsExec & exec , const void * arg )
-  {
-    exec_schedule<typename Policy::schedule_type::type>(exec,arg);
+  static void exec(ThreadsExec &exec, const void *arg) {
+    exec_schedule<typename Policy::schedule_type::type>(exec, arg);
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Static>::value >::type
-  exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelFor & self = * ((const ParallelFor *) arg );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Static>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
 
-    WorkRange range( self.m_policy , exec.pool_rank() , exec.pool_size() );
+    WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    ParallelFor::template exec_range< WorkTag >
-      ( self.m_functor , range.begin() , range.end() );
+    ParallelFor::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                              range.end());
 
     exec.fan_in();
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Dynamic>::value >::type
-  exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelFor & self = * ((const ParallelFor *) arg );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Dynamic>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
 
-    WorkRange range( self.m_policy , exec.pool_rank() , exec.pool_size() );
+    WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    exec.set_work_range(range.begin()-self.m_policy.begin(),range.end()-self.m_policy.begin(),self.m_policy.chunk_size());
+    exec.set_work_range(range.begin() - self.m_policy.begin(),
+                        range.end() - self.m_policy.begin(),
+                        self.m_policy.chunk_size());
     exec.reset_steal_target();
     exec.barrier();
 
     long work_index = exec.get_work_index();
 
-    while(work_index != -1) {
-      const Member begin = static_cast<Member>(work_index) * self.m_policy.chunk_size()+self.m_policy.begin();
-      const Member end = begin + self.m_policy.chunk_size() < self.m_policy.end()?begin+self.m_policy.chunk_size():self.m_policy.end();
-      ParallelFor::template exec_range< WorkTag >
-        ( self.m_functor , begin , end );
+    while (work_index != -1) {
+      const Member begin =
+          static_cast<Member>(work_index) * self.m_policy.chunk_size() +
+          self.m_policy.begin();
+      const Member end =
+          begin + self.m_policy.chunk_size() < self.m_policy.end()
+              ? begin + self.m_policy.chunk_size()
+              : self.m_policy.end();
+      ParallelFor::template exec_range<WorkTag>(self.m_functor, begin, end);
       work_index = exec.get_work_index();
     }
 
     exec.fan_in();
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      ThreadsExec::start( & ParallelFor::exec , this );
-      ThreadsExec::fence();
-    }
+ public:
+  inline void execute() const {
+    ThreadsExec::start(&ParallelFor::exec, this);
+    ThreadsExec::fence();
+  }
 
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    {}
+  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
-
 // MDRangePolicy impl
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType
-                 , Kokkos::MDRangePolicy< Traits ... >
-                 , Kokkos::Threads
-                 >
-{
-private:
-  typedef Kokkos::MDRangePolicy< Traits ... > MDRangePolicy ;
-  typedef typename MDRangePolicy::impl_range_policy         Policy ;
-
-  typedef typename MDRangePolicy::work_tag                  WorkTag ;
-
-  typedef typename Policy::WorkRange   WorkRange ;
-  typedef typename Policy::member_type Member ;
-
-  typedef typename Kokkos::Impl::HostIterateTile< MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void > iterate_type;
-
-  const FunctorType   m_functor ;
-  const MDRangePolicy m_mdr_policy ;
-  const Policy        m_policy ;  // construct as RangePolicy( 0, num_tiles ).set_chunk_size(1) in ctor
-
-  inline static
-  void
-  exec_range( const MDRangePolicy & mdr_policy 
-            , const FunctorType & functor
-            , const Member ibeg , const Member iend )
-    {
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        iterate_type( mdr_policy, functor )( i );
-      }
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::Threads> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> MDRangePolicy;
+  typedef typename MDRangePolicy::impl_range_policy Policy;
+
+  typedef typename MDRangePolicy::work_tag WorkTag;
+
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
+
+  typedef typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void>
+      iterate_type;
+
+  const FunctorType m_functor;
+  const MDRangePolicy m_mdr_policy;
+  const Policy m_policy;  // construct as RangePolicy( 0, num_tiles
+                          // ).set_chunk_size(1) in ctor
+
+  inline static void exec_range(const MDRangePolicy &mdr_policy,
+                                const FunctorType &functor, const Member ibeg,
+                                const Member iend) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      iterate_type(mdr_policy, functor)(i);
     }
+  }
 
-  static void exec( ThreadsExec & exec , const void * arg )
-  {
-    exec_schedule<typename Policy::schedule_type::type>(exec,arg);
+  static void exec(ThreadsExec &exec, const void *arg) {
+    exec_schedule<typename Policy::schedule_type::type>(exec, arg);
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Static>::value >::type
-  exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelFor & self = * ((const ParallelFor *) arg );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Static>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
 
-    WorkRange range( self.m_policy , exec.pool_rank() , exec.pool_size() );
+    WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    ParallelFor::exec_range
-      ( self.m_mdr_policy, self.m_functor , range.begin() , range.end() );
+    ParallelFor::exec_range(self.m_mdr_policy, self.m_functor, range.begin(),
+                            range.end());
 
     exec.fan_in();
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Dynamic>::value >::type
-  exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelFor & self = * ((const ParallelFor *) arg );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Dynamic>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
 
-    WorkRange range( self.m_policy , exec.pool_rank() , exec.pool_size() );
+    WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    exec.set_work_range(range.begin(),range.end(),self.m_policy.chunk_size());
+    exec.set_work_range(range.begin(), range.end(), self.m_policy.chunk_size());
     exec.reset_steal_target();
     exec.barrier();
 
     long work_index = exec.get_work_index();
 
-    while(work_index != -1) {
-      const Member begin = static_cast<Member>(work_index) * self.m_policy.chunk_size();
-      const Member end = begin + self.m_policy.chunk_size() < self.m_policy.end()?begin+self.m_policy.chunk_size():self.m_policy.end();
+    while (work_index != -1) {
+      const Member begin =
+          static_cast<Member>(work_index) * self.m_policy.chunk_size();
+      const Member end =
+          begin + self.m_policy.chunk_size() < self.m_policy.end()
+              ? begin + self.m_policy.chunk_size()
+              : self.m_policy.end();
 
-      ParallelFor::exec_range
-        ( self.m_mdr_policy, self.m_functor , begin , end );
+      ParallelFor::exec_range(self.m_mdr_policy, self.m_functor, begin, end);
       work_index = exec.get_work_index();
     }
 
     exec.fan_in();
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      ThreadsExec::start( & ParallelFor::exec , this );
-      ThreadsExec::fence();
-    }
+ public:
+  inline void execute() const {
+    ThreadsExec::start(&ParallelFor::exec, this);
+    ThreadsExec::fence();
+  }
 
-  ParallelFor( const FunctorType & arg_functor
-             , const MDRangePolicy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_mdr_policy( arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    {}
+  ParallelFor(const FunctorType &arg_functor, const MDRangePolicy &arg_policy)
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)) {}
 };
 
 //----------------------------------------------------------------------------
 /* ParallelFor Kokkos::Threads with TeamPolicy */
 
-template< class FunctorType , class ... Properties >
-class ParallelFor< FunctorType
-                 , Kokkos::TeamPolicy< Properties ... >
-                 , Kokkos::Threads
-                 >
-{
-private:
-
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::Threads, Properties ... >  Policy ;
-  typedef typename Policy::work_tag                    WorkTag ;
-  typedef typename Policy::member_type                 Member ;
-
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  const int          m_shared ;
-
-  template< class TagType , class Schedule>
-  inline static
-  typename std::enable_if< std::is_same< TagType , void >::value
-  && std::is_same<Schedule,Kokkos::Static>::value >::type
-  exec_team( const FunctorType & functor , Member member )
-    {
-      for ( ; member.valid_static() ; member.next_static() ) {
-        functor( member );
-      }
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::Threads> {
+ private:
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::Threads, Properties...>
+      Policy;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const int m_shared;
+
+  template <class TagType, class Schedule>
+  inline static typename std::enable_if<
+      std::is_same<TagType, void>::value &&
+      std::is_same<Schedule, Kokkos::Static>::value>::type
+  exec_team(const FunctorType &functor, Member member) {
+    for (; member.valid_static(); member.next_static()) {
+      functor(member);
     }
+  }
 
-  template< class TagType , class Schedule>
-  inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value
-  && std::is_same<Schedule,Kokkos::Static>::value >::type
-  exec_team( const FunctorType & functor , Member member )
-    {
-      const TagType t{} ;
-      for ( ; member.valid_static() ; member.next_static() ) {
-        functor( t , member );
-      }
+  template <class TagType, class Schedule>
+  inline static typename std::enable_if<
+      !std::is_same<TagType, void>::value &&
+      std::is_same<Schedule, Kokkos::Static>::value>::type
+  exec_team(const FunctorType &functor, Member member) {
+    const TagType t{};
+    for (; member.valid_static(); member.next_static()) {
+      functor(t, member);
     }
+  }
 
-  template< class TagType , class Schedule>
-  inline static
-  typename std::enable_if< std::is_same< TagType , void >::value
-  && std::is_same<Schedule,Kokkos::Dynamic>::value >::type
-  exec_team( const FunctorType & functor , Member member )
-    {
-
-      for ( ; member.valid_dynamic() ; member.next_dynamic() ) {
-        functor( member );
-      }
+  template <class TagType, class Schedule>
+  inline static typename std::enable_if<
+      std::is_same<TagType, void>::value &&
+      std::is_same<Schedule, Kokkos::Dynamic>::value>::type
+  exec_team(const FunctorType &functor, Member member) {
+    for (; member.valid_dynamic(); member.next_dynamic()) {
+      functor(member);
     }
+  }
 
-  template< class TagType , class Schedule>
-  inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value
-                          && std::is_same<Schedule,Kokkos::Dynamic>::value >::type
-  exec_team( const FunctorType & functor , Member member )
-    {
-      const TagType t{} ;
-      for ( ; member.valid_dynamic() ; member.next_dynamic() ) {
-        functor( t , member );
-      }
+  template <class TagType, class Schedule>
+  inline static typename std::enable_if<
+      !std::is_same<TagType, void>::value &&
+      std::is_same<Schedule, Kokkos::Dynamic>::value>::type
+  exec_team(const FunctorType &functor, Member member) {
+    const TagType t{};
+    for (; member.valid_dynamic(); member.next_dynamic()) {
+      functor(t, member);
     }
+  }
 
-  static void exec( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelFor & self = * ((const ParallelFor *) arg );
+  static void exec(ThreadsExec &exec, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
 
-    ParallelFor::exec_team< WorkTag , typename Policy::schedule_type::type >
-      ( self.m_functor , Member( & exec , self.m_policy , self.m_shared ) );
+    ParallelFor::exec_team<WorkTag, typename Policy::schedule_type::type>(
+        self.m_functor, Member(&exec, self.m_policy, self.m_shared));
 
     exec.barrier();
     exec.fan_in();
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      ThreadsExec::resize_scratch( 0 , Policy::member_type::team_reduce_size() + m_shared );
+ public:
+  inline void execute() const {
+    ThreadsExec::resize_scratch(
+        0, Policy::member_type::team_reduce_size() + m_shared);
 
-      ThreadsExec::start( & ParallelFor::exec , this );
+    ThreadsExec::start(&ParallelFor::exec, this);
 
-      ThreadsExec::fence();
-    }
+    ThreadsExec::fence();
+  }
 
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_shared( arg_policy.scratch_size(0) + arg_policy.scratch_size(1) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , arg_policy.team_size() ) )
-    { }
+  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(
+                     arg_functor, arg_policy.team_size())) {}
 };
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 /* ParallelReduce with Kokkos::Threads and RangePolicy */
 
-template< class FunctorType , class ReducerType, class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::RangePolicy< Traits ... >
-                    , ReducerType
-                    , Kokkos::Threads
-                    >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+                     Kokkos::Threads> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
 
-  typedef typename Policy::work_tag    WorkTag ;
-  typedef typename Policy::WorkRange   WorkRange ;
-  typedef typename Policy::member_type Member ;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
 
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd > ValueInit ;
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  const ReducerType   m_reducer ;
-  const pointer_type m_result_ptr ;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member & ibeg , const Member & iend
-            , reference_type update )
-    {
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( i , update );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member &ibeg,
+                 const Member &iend, reference_type update) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member & ibeg , const Member & iend
-            , reference_type update )
-    {
-      const TagType t{} ;
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( t , i , update );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member &ibeg,
+                 const Member &iend, reference_type update) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update);
     }
+  }
 
-  static void
-  exec( ThreadsExec & exec , const void * arg ) {
+  static void exec(ThreadsExec &exec, const void *arg) {
     exec_schedule<typename Policy::schedule_type::type>(exec, arg);
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Static>::value >::type
-  exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelReduce & self = * ((const ParallelReduce *) arg );
-    const WorkRange range( self.m_policy, exec.pool_rank(), exec.pool_size() );
-
-    ParallelReduce::template exec_range< WorkTag >
-      ( self.m_functor , range.begin() , range.end()
-      , ValueInit::init( ReducerConditional::select(self.m_functor , self.m_reducer) , exec.reduce_memory() ) );
-
-    exec.template fan_in_reduce< ReducerTypeFwd , WorkTagFwd >( ReducerConditional::select(self.m_functor , self.m_reducer) );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Static>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelReduce &self = *((const ParallelReduce *)arg);
+    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
+
+    ParallelReduce::template exec_range<WorkTag>(
+        self.m_functor, range.begin(), range.end(),
+        ValueInit::init(
+            ReducerConditional::select(self.m_functor, self.m_reducer),
+            exec.reduce_memory()));
+
+    exec.template fan_in_reduce<ReducerTypeFwd, WorkTagFwd>(
+        ReducerConditional::select(self.m_functor, self.m_reducer));
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Dynamic>::value >::type
-    exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelReduce & self = * ((const ParallelReduce *) arg );
-    const WorkRange range( self.m_policy, exec.pool_rank(), exec.pool_size() );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Dynamic>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelReduce &self = *((const ParallelReduce *)arg);
+    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    exec.set_work_range(range.begin()-self.m_policy.begin(),range.end()-self.m_policy.begin(),self.m_policy.chunk_size());
+    exec.set_work_range(range.begin() - self.m_policy.begin(),
+                        range.end() - self.m_policy.begin(),
+                        self.m_policy.chunk_size());
     exec.reset_steal_target();
     exec.barrier();
 
-    long work_index = exec.get_work_index();
-    reference_type update = ValueInit::init( ReducerConditional::select(self.m_functor , self.m_reducer) , exec.reduce_memory() );
-    while(work_index != -1) {
-      const Member begin = static_cast<Member>(work_index) * self.m_policy.chunk_size() + self.m_policy.begin();
-      const Member end = begin + self.m_policy.chunk_size() < self.m_policy.end()?begin+self.m_policy.chunk_size():self.m_policy.end();
-      ParallelReduce::template exec_range< WorkTag >
-        ( self.m_functor , begin , end
-        , update );
+    long work_index       = exec.get_work_index();
+    reference_type update = ValueInit::init(
+        ReducerConditional::select(self.m_functor, self.m_reducer),
+        exec.reduce_memory());
+    while (work_index != -1) {
+      const Member begin =
+          static_cast<Member>(work_index) * self.m_policy.chunk_size() +
+          self.m_policy.begin();
+      const Member end =
+          begin + self.m_policy.chunk_size() < self.m_policy.end()
+              ? begin + self.m_policy.chunk_size()
+              : self.m_policy.end();
+      ParallelReduce::template exec_range<WorkTag>(self.m_functor, begin, end,
+                                                   update);
       work_index = exec.get_work_index();
     }
 
-    exec.template fan_in_reduce< ReducerTypeFwd , WorkTagFwd >( ReducerConditional::select(self.m_functor , self.m_reducer) );
+    exec.template fan_in_reduce<ReducerTypeFwd, WorkTagFwd>(
+        ReducerConditional::select(self.m_functor, self.m_reducer));
   }
 
-public:
+ public:
+  inline void execute() const {
+    ThreadsExec::resize_scratch(
+        ValueTraits::value_size(
+            ReducerConditional::select(m_functor, m_reducer)),
+        0);
 
-  inline
-  void execute() const
-    {
-      ThreadsExec::resize_scratch( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) , 0 );
+    ThreadsExec::start(&ParallelReduce::exec, this);
 
-      ThreadsExec::start( & ParallelReduce::exec , this );
+    ThreadsExec::fence();
 
-      ThreadsExec::fence();
+    if (m_result_ptr) {
+      const pointer_type data =
+          (pointer_type)ThreadsExec::root_reduce_scratch();
 
-      if ( m_result_ptr ) {
-
-        const pointer_type data =
-          (pointer_type) ThreadsExec::root_reduce_scratch();
-
-        const unsigned n = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer) );
-        for ( unsigned i = 0 ; i < n ; ++i ) { m_result_ptr[i] = data[i]; }
+      const unsigned n = ValueTraits::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
+      for (unsigned i = 0; i < n; ++i) {
+        m_result_ptr[i] = data[i];
       }
     }
+  }
 
-  template< class HostViewType >
-  ParallelReduce( const FunctorType  & arg_functor ,
-                  const Policy       & arg_policy ,
-                  const HostViewType & arg_result_view ,
-                  typename std::enable_if<
-                               Kokkos::is_view< HostViewType >::value &&
-                              !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result_view.data() )
-    {
-      static_assert( Kokkos::is_view< HostViewType >::value
-        , "Kokkos::Threads reduce result must be a View" );
-
-      static_assert( std::is_same< typename HostViewType::memory_space , HostSpace >::value
-        , "Kokkos::Threads reduce result must be a View in HostSpace" );
-    }
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , Policy       arg_policy
-                , const ReducerType& reducer )
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.view().data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
+  template <class HostViewType>
+  ParallelReduce(
+      const FunctorType &arg_functor, const Policy &arg_policy,
+      const HostViewType &arg_result_view,
+      typename std::enable_if<Kokkos::is_view<HostViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void *>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result_view.data()) {
+    static_assert(Kokkos::is_view<HostViewType>::value,
+                  "Kokkos::Threads reduce result must be a View");
+
+    static_assert(
+        std::is_same<typename HostViewType::memory_space, HostSpace>::value,
+        "Kokkos::Threads reduce result must be a View in HostSpace");
+  }
 
+  inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
+                        const ReducerType &reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 };
 
-
 // MDRangePolicy impl
-template< class FunctorType , class ReducerType, class ... Traits >
-class ParallelReduce< FunctorType
-                    , Kokkos::MDRangePolicy< Traits ... >
-                    , ReducerType
-                    , Kokkos::Threads
-                    >
-{
-private:
-
-  typedef Kokkos::MDRangePolicy< Traits ... > MDRangePolicy ;
-  typedef typename MDRangePolicy::impl_range_policy Policy ;
-
-  typedef typename MDRangePolicy::work_tag    WorkTag ;
-  typedef typename Policy::WorkRange   WorkRange ;
-  typedef typename Policy::member_type Member ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+template <class FunctorType, class ReducerType, class... Traits>
+class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
+                     Kokkos::Threads> {
+ private:
+  typedef Kokkos::MDRangePolicy<Traits...> MDRangePolicy;
+  typedef typename MDRangePolicy::impl_range_policy Policy;
+
+  typedef typename MDRangePolicy::work_tag WorkTag;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::member_type Member;
+
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
-
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd > ValueInit ;
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::value_type      value_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-
-  using iterate_type = typename Kokkos::Impl::HostIterateTile< MDRangePolicy
-                                                                           , FunctorType
-                                                                           , WorkTag
-                                                                           , reference_type
-                                                                           >;
-
-  const FunctorType   m_functor ;
-  const MDRangePolicy m_mdr_policy ;
-  const Policy        m_policy ;  // construct as RangePolicy( 0, num_tiles ).set_chunk_size(1) in ctor
-  const ReducerType   m_reducer ;
-  const pointer_type  m_result_ptr ;
-
-  inline static
-  void
-  exec_range( const MDRangePolicy & mdr_policy
-            , const FunctorType & functor
-            , const Member & ibeg , const Member & iend
-            , reference_type update )
-    {
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        iterate_type( mdr_policy, functor, update )( i );
-      }
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
+
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
+
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::value_type value_type;
+  typedef typename ValueTraits::reference_type reference_type;
+
+  using iterate_type =
+      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
+                                             WorkTag, reference_type>;
+
+  const FunctorType m_functor;
+  const MDRangePolicy m_mdr_policy;
+  const Policy m_policy;  // construct as RangePolicy( 0, num_tiles
+                          // ).set_chunk_size(1) in ctor
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+
+  inline static void exec_range(const MDRangePolicy &mdr_policy,
+                                const FunctorType &functor, const Member &ibeg,
+                                const Member &iend, reference_type update) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      iterate_type(mdr_policy, functor, update)(i);
     }
+  }
 
-  static void
-  exec( ThreadsExec & exec , const void * arg ) {
+  static void exec(ThreadsExec &exec, const void *arg) {
     exec_schedule<typename Policy::schedule_type::type>(exec, arg);
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Static>::value >::type
-  exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelReduce & self = * ((const ParallelReduce *) arg );
-    const WorkRange range( self.m_policy, exec.pool_rank(), exec.pool_size() );
-
-    ParallelReduce::exec_range
-      ( self.m_mdr_policy, self.m_functor , range.begin() , range.end()
-      , ValueInit::init( ReducerConditional::select(self.m_functor , self.m_reducer) , exec.reduce_memory() ) );
-
-    exec.template fan_in_reduce< ReducerTypeFwd , WorkTagFwd >( ReducerConditional::select(self.m_functor , self.m_reducer) );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Static>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelReduce &self = *((const ParallelReduce *)arg);
+    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
+
+    ParallelReduce::exec_range(
+        self.m_mdr_policy, self.m_functor, range.begin(), range.end(),
+        ValueInit::init(
+            ReducerConditional::select(self.m_functor, self.m_reducer),
+            exec.reduce_memory()));
+
+    exec.template fan_in_reduce<ReducerTypeFwd, WorkTagFwd>(
+        ReducerConditional::select(self.m_functor, self.m_reducer));
   }
 
-  template<class Schedule>
-  static
-  typename std::enable_if< std::is_same<Schedule,Kokkos::Dynamic>::value >::type
-    exec_schedule( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelReduce & self = * ((const ParallelReduce *) arg );
-    const WorkRange range( self.m_policy, exec.pool_rank(), exec.pool_size() );
+  template <class Schedule>
+  static typename std::enable_if<
+      std::is_same<Schedule, Kokkos::Dynamic>::value>::type
+  exec_schedule(ThreadsExec &exec, const void *arg) {
+    const ParallelReduce &self = *((const ParallelReduce *)arg);
+    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    exec.set_work_range(range.begin(),range.end(),self.m_policy.chunk_size());
+    exec.set_work_range(range.begin(), range.end(), self.m_policy.chunk_size());
     exec.reset_steal_target();
     exec.barrier();
 
-    long work_index = exec.get_work_index();
-    reference_type update = ValueInit::init( ReducerConditional::select(self.m_functor , self.m_reducer) , exec.reduce_memory() );
-    while(work_index != -1) {
-      const Member begin = static_cast<Member>(work_index) * self.m_policy.chunk_size();
-      const Member end = begin + self.m_policy.chunk_size() < self.m_policy.end()?begin+self.m_policy.chunk_size():self.m_policy.end();
-      ParallelReduce::exec_range
-        ( self.m_mdr_policy, self.m_functor , begin , end
-        , update );
+    long work_index       = exec.get_work_index();
+    reference_type update = ValueInit::init(
+        ReducerConditional::select(self.m_functor, self.m_reducer),
+        exec.reduce_memory());
+    while (work_index != -1) {
+      const Member begin =
+          static_cast<Member>(work_index) * self.m_policy.chunk_size();
+      const Member end =
+          begin + self.m_policy.chunk_size() < self.m_policy.end()
+              ? begin + self.m_policy.chunk_size()
+              : self.m_policy.end();
+      ParallelReduce::exec_range(self.m_mdr_policy, self.m_functor, begin, end,
+                                 update);
       work_index = exec.get_work_index();
     }
 
-    exec.template fan_in_reduce< ReducerTypeFwd , WorkTagFwd >( ReducerConditional::select(self.m_functor , self.m_reducer) );
+    exec.template fan_in_reduce<ReducerTypeFwd, WorkTagFwd>(
+        ReducerConditional::select(self.m_functor, self.m_reducer));
   }
 
-public:
+ public:
+  inline void execute() const {
+    ThreadsExec::resize_scratch(
+        ValueTraits::value_size(
+            ReducerConditional::select(m_functor, m_reducer)),
+        0);
 
-  inline
-  void execute() const
-    {
-      ThreadsExec::resize_scratch( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) , 0 );
+    ThreadsExec::start(&ParallelReduce::exec, this);
 
-      ThreadsExec::start( & ParallelReduce::exec , this );
+    ThreadsExec::fence();
 
-      ThreadsExec::fence();
+    if (m_result_ptr) {
+      const pointer_type data =
+          (pointer_type)ThreadsExec::root_reduce_scratch();
 
-      if ( m_result_ptr ) {
-
-        const pointer_type data =
-          (pointer_type) ThreadsExec::root_reduce_scratch();
-
-        const unsigned n = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer) );
-        for ( unsigned i = 0 ; i < n ; ++i ) { m_result_ptr[i] = data[i]; }
+      const unsigned n = ValueTraits::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
+      for (unsigned i = 0; i < n; ++i) {
+        m_result_ptr[i] = data[i];
       }
     }
+  }
 
-  template< class HostViewType >
-  ParallelReduce( const FunctorType  & arg_functor ,
-                  const MDRangePolicy       & arg_policy ,
-                  const HostViewType & arg_result_view ,
-                  typename std::enable_if<
-                               Kokkos::is_view< HostViewType >::value &&
-                              !Kokkos::is_reducer_type<ReducerType>::value
-                  ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_mdr_policy( arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result_view.data() )
-    {
-      static_assert( Kokkos::is_view< HostViewType >::value
-        , "Kokkos::Threads reduce result must be a View" );
-
-      static_assert( std::is_same< typename HostViewType::memory_space , HostSpace >::value
-        , "Kokkos::Threads reduce result must be a View in HostSpace" );
-    }
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-                , MDRangePolicy       arg_policy
-                , const ReducerType& reducer )
-    : m_functor( arg_functor )
-    , m_mdr_policy(  arg_policy )
-    , m_policy( Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1) )
-    , m_reducer( reducer )
-    , m_result_ptr(  reducer.view().data() )
-    {
-      /*static_assert( std::is_same< typename ViewType::memory_space
-                                      , Kokkos::HostSpace >::value
-        , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
-    }
+  template <class HostViewType>
+  ParallelReduce(
+      const FunctorType &arg_functor, const MDRangePolicy &arg_policy,
+      const HostViewType &arg_result_view,
+      typename std::enable_if<Kokkos::is_view<HostViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void *>::type = NULL)
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result_view.data()) {
+    static_assert(Kokkos::is_view<HostViewType>::value,
+                  "Kokkos::Threads reduce result must be a View");
+
+    static_assert(
+        std::is_same<typename HostViewType::memory_space, HostSpace>::value,
+        "Kokkos::Threads reduce result must be a View in HostSpace");
+  }
 
+  inline ParallelReduce(const FunctorType &arg_functor,
+                        MDRangePolicy arg_policy, const ReducerType &reducer)
+      : m_functor(arg_functor),
+        m_mdr_policy(arg_policy),
+        m_policy(Policy(0, m_mdr_policy.m_num_tiles).set_chunk_size(1)),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                                    , Kokkos::HostSpace >::value
+      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+      );*/
+  }
 };
 
-
 //----------------------------------------------------------------------------
 /* ParallelReduce with Kokkos::Threads and TeamPolicy */
 
-template< class FunctorType , class ReducerType, class ... Properties >
-class ParallelReduce< FunctorType
-                    , Kokkos::TeamPolicy< Properties ... >
-                    , ReducerType
-                    , Kokkos::Threads
-                    >
-{
-private:
-
-  typedef Kokkos::Impl::TeamPolicyInternal< Kokkos::Threads, Properties ... >              Policy ;
-  typedef typename Policy::work_tag                                WorkTag ;
-  typedef typename Policy::member_type                             Member ;
-
-  typedef Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, FunctorType, ReducerType> ReducerConditional;
+template <class FunctorType, class ReducerType, class... Properties>
+class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                     ReducerType, Kokkos::Threads> {
+ private:
+  typedef Kokkos::Impl::TeamPolicyInternal<Kokkos::Threads, Properties...>
+      Policy;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+
+  typedef Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                             FunctorType, ReducerType>
+      ReducerConditional;
   typedef typename ReducerConditional::type ReducerTypeFwd;
-  typedef typename Kokkos::Impl::if_c< std::is_same<InvalidType,ReducerType>::value, WorkTag, void>::type WorkTagFwd;
+  typedef
+      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
+                                  WorkTag, void>::type WorkTagFwd;
 
-  typedef Kokkos::Impl::FunctorValueTraits< ReducerTypeFwd , WorkTagFwd > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   ReducerTypeFwd , WorkTagFwd > ValueInit ;
+  typedef Kokkos::Impl::FunctorValueTraits<ReducerTypeFwd, WorkTagFwd>
+      ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<ReducerTypeFwd, WorkTagFwd> ValueInit;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  const ReducerType  m_reducer ;
-  const pointer_type m_result_ptr ;
-  const int          m_shared ;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const ReducerType m_reducer;
+  const pointer_type m_result_ptr;
+  const int m_shared;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_team( const FunctorType & functor , Member member , reference_type update )
-    {
-      for ( ; member.valid_static() ; member.next_static() ) {
-        functor( member , update );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_team(const FunctorType &functor, Member member,
+                reference_type update) {
+    for (; member.valid_static(); member.next_static()) {
+      functor(member, update);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_team( const FunctorType & functor , Member member , reference_type update )
-    {
-      const TagType t{} ;
-      for ( ; member.valid_static() ; member.next_static() ) {
-        functor( t , member , update );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_team(const FunctorType &functor, Member member,
+                reference_type update) {
+    const TagType t{};
+    for (; member.valid_static(); member.next_static()) {
+      functor(t, member, update);
     }
+  }
 
-  static void exec( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelReduce & self = * ((const ParallelReduce *) arg );
+  static void exec(ThreadsExec &exec, const void *arg) {
+    const ParallelReduce &self = *((const ParallelReduce *)arg);
 
-    ParallelReduce::template exec_team< WorkTag >
-      ( self.m_functor , Member( & exec , self.m_policy , self.m_shared )
-      , ValueInit::init( ReducerConditional::select(self.m_functor , self.m_reducer) , exec.reduce_memory() ) );
+    ParallelReduce::template exec_team<WorkTag>(
+        self.m_functor, Member(&exec, self.m_policy, self.m_shared),
+        ValueInit::init(
+            ReducerConditional::select(self.m_functor, self.m_reducer),
+            exec.reduce_memory()));
 
-    exec.template fan_in_reduce< ReducerTypeFwd , WorkTagFwd >( ReducerConditional::select(self.m_functor , self.m_reducer) );
+    exec.template fan_in_reduce<ReducerTypeFwd, WorkTagFwd>(
+        ReducerConditional::select(self.m_functor, self.m_reducer));
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      ThreadsExec::resize_scratch( ValueTraits::value_size( ReducerConditional::select(m_functor , m_reducer) ) , Policy::member_type::team_reduce_size() + m_shared );
-
-      ThreadsExec::start( & ParallelReduce::exec , this );
+ public:
+  inline void execute() const {
+    ThreadsExec::resize_scratch(
+        ValueTraits::value_size(
+            ReducerConditional::select(m_functor, m_reducer)),
+        Policy::member_type::team_reduce_size() + m_shared);
 
-      ThreadsExec::fence();
+    ThreadsExec::start(&ParallelReduce::exec, this);
 
-      if ( m_result_ptr ) {
+    ThreadsExec::fence();
 
-        const pointer_type data = (pointer_type) ThreadsExec::root_reduce_scratch();
+    if (m_result_ptr) {
+      const pointer_type data =
+          (pointer_type)ThreadsExec::root_reduce_scratch();
 
-        const unsigned n = ValueTraits::value_count( ReducerConditional::select(m_functor , m_reducer) );
-        for ( unsigned i = 0 ; i < n ; ++i ) { m_result_ptr[i] = data[i]; }
+      const unsigned n = ValueTraits::value_count(
+          ReducerConditional::select(m_functor, m_reducer));
+      for (unsigned i = 0; i < n; ++i) {
+        m_result_ptr[i] = data[i];
       }
     }
+  }
 
-  template< class ViewType >
-  inline
-  ParallelReduce( const FunctorType  & arg_functor ,
-                  const Policy       & arg_policy ,
-                  const ViewType     & arg_result ,
-                  typename std::enable_if<
-                    Kokkos::is_view< ViewType >::value &&
-                    !Kokkos::is_reducer_type<ReducerType>::value
-                    ,void*>::type = NULL)
-    : m_functor( arg_functor )
-    , m_policy(  arg_policy )
-    , m_reducer( InvalidType() )
-    , m_result_ptr( arg_result.data() )
-    , m_shared( arg_policy.scratch_size(0) + arg_policy.scratch_size(1) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , arg_policy.team_size() ) )
-    {}
-
-  inline
-  ParallelReduce( const FunctorType & arg_functor
-    , Policy       arg_policy
-    , const ReducerType& reducer )
-  : m_functor( arg_functor )
-  , m_policy(  arg_policy )
-  , m_reducer( reducer )
-  , m_result_ptr(  reducer.view().data() )
-  , m_shared( arg_policy.scratch_size(0) + arg_policy.scratch_size(1) + FunctorTeamShmemSize< FunctorType >::value( arg_functor , arg_policy.team_size() ) )
-  {
-  /*static_assert( std::is_same< typename ViewType::memory_space
-                          , Kokkos::HostSpace >::value
-  , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace" );*/
+  template <class ViewType>
+  inline ParallelReduce(
+      const FunctorType &arg_functor, const Policy &arg_policy,
+      const ViewType &arg_result,
+      typename std::enable_if<Kokkos::is_view<ViewType>::value &&
+                                  !Kokkos::is_reducer_type<ReducerType>::value,
+                              void *>::type = NULL)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(InvalidType()),
+        m_result_ptr(arg_result.data()),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(
+                     arg_functor, arg_policy.team_size())) {}
+
+  inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
+                        const ReducerType &reducer)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_reducer(reducer),
+        m_result_ptr(reducer.view().data()),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(
+                     arg_functor, arg_policy.team_size())) {
+    /*static_assert( std::is_same< typename ViewType::memory_space
+                            , Kokkos::HostSpace >::value
+    , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
+    );*/
   }
 };
 
@@ -826,204 +803,173 @@ public:
 //----------------------------------------------------------------------------
 /* ParallelScan with Kokkos::Threads and RangePolicy */
 
-template< class FunctorType , class ... Traits >
-class ParallelScan< FunctorType
-                  , Kokkos::RangePolicy< Traits ... >
-                  , Kokkos::Threads
-                  >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
-  typedef typename Policy::WorkRange                               WorkRange ;
-  typedef typename Policy::work_tag                                WorkTag ;
-  typedef typename Policy::member_type                             Member ;
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, WorkTag > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Threads> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, WorkTag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
 
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
 
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
+  const FunctorType m_functor;
+  const Policy m_policy;
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member & ibeg , const Member & iend
-            , reference_type update , const bool final )
-    {
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( i , update , final );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member &ibeg,
+                 const Member &iend, reference_type update, const bool final) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update, final);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member & ibeg , const Member & iend
-            , reference_type update , const bool final )
-    {
-      const TagType t{} ;
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( t , i , update , final );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member &ibeg,
+                 const Member &iend, reference_type update, const bool final) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update, final);
     }
+  }
 
-  static void exec( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelScan & self = * ((const ParallelScan *) arg );
+  static void exec(ThreadsExec &exec, const void *arg) {
+    const ParallelScan &self = *((const ParallelScan *)arg);
 
-    const WorkRange range( self.m_policy, exec.pool_rank(), exec.pool_size() );
+    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
     reference_type update =
-      ValueInit::init( self.m_functor , exec.reduce_memory() );
+        ValueInit::init(self.m_functor, exec.reduce_memory());
 
-    ParallelScan::template exec_range< WorkTag >
-      ( self.m_functor , range.begin(), range.end(), update, false );
+    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                               range.end(), update, false);
 
     //  exec.template scan_large<FunctorType,WorkTag>( self.m_functor );
-    exec.template scan_small<FunctorType,WorkTag>( self.m_functor );
+    exec.template scan_small<FunctorType, WorkTag>(self.m_functor);
 
-    ParallelScan::template exec_range< WorkTag >
-      ( self.m_functor , range.begin(), range.end(), update, true );
+    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                               range.end(), update, true);
 
     exec.fan_in();
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      ThreadsExec::resize_scratch( 2 * ValueTraits::value_size( m_functor ) , 0 );
-      ThreadsExec::start( & ParallelScan::exec , this );
-      ThreadsExec::fence();
-    }
+ public:
+  inline void execute() const {
+    ThreadsExec::resize_scratch(2 * ValueTraits::value_size(m_functor), 0);
+    ThreadsExec::start(&ParallelScan::exec, this);
+    ThreadsExec::fence();
+  }
 
-  ParallelScan( const FunctorType & arg_functor
-              , const Policy      & arg_policy )
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    { }
+  ParallelScan(const FunctorType &arg_functor, const Policy &arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
-template< class FunctorType, class ReturnType, class ... Traits >
-class ParallelScanWithTotal< FunctorType
-                           , Kokkos::RangePolicy< Traits ... >
-                           , ReturnType
-                           , Kokkos::Threads
-                           >
-{
-private:
-
-  typedef Kokkos::RangePolicy< Traits ... > Policy ;
-  typedef typename Policy::WorkRange                               WorkRange ;
-  typedef typename Policy::work_tag                                WorkTag ;
-  typedef typename Policy::member_type                             Member ;
-  typedef Kokkos::Impl::FunctorValueTraits< FunctorType, WorkTag > ValueTraits ;
-  typedef Kokkos::Impl::FunctorValueInit<   FunctorType, WorkTag > ValueInit ;
-
-  typedef typename ValueTraits::pointer_type    pointer_type ;
-  typedef typename ValueTraits::reference_type  reference_type ;
-
-  const FunctorType  m_functor ;
-  const Policy       m_policy ;
-  ReturnType       & m_returnvalue;
-
-  template< class TagType >
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::Threads> {
+ private:
+  typedef Kokkos::RangePolicy<Traits...> Policy;
+  typedef typename Policy::WorkRange WorkRange;
+  typedef typename Policy::work_tag WorkTag;
+  typedef typename Policy::member_type Member;
+  typedef Kokkos::Impl::FunctorValueTraits<FunctorType, WorkTag> ValueTraits;
+  typedef Kokkos::Impl::FunctorValueInit<FunctorType, WorkTag> ValueInit;
+
+  typedef typename ValueTraits::pointer_type pointer_type;
+  typedef typename ValueTraits::reference_type reference_type;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  ReturnType &m_returnvalue;
+
+  template <class TagType>
   inline static
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member & ibeg , const Member & iend
-            , reference_type update , const bool final )
-    {
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( i , update , final );
-      }
+      typename std::enable_if<std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member &ibeg,
+                 const Member &iend, reference_type update, const bool final) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update, final);
     }
+  }
 
-  template< class TagType >
+  template <class TagType>
   inline static
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_range( const FunctorType & functor
-            , const Member & ibeg , const Member & iend
-            , reference_type update , const bool final )
-    {
-      const TagType t{} ;
-      #if defined( KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION ) && \
-          defined( KOKKOS_ENABLE_PRAGMA_IVDEP )
-      #pragma ivdep
-      #endif
-      for ( Member i = ibeg ; i < iend ; ++i ) {
-        functor( t , i , update , final );
-      }
+      typename std::enable_if<!std::is_same<TagType, void>::value>::type
+      exec_range(const FunctorType &functor, const Member &ibeg,
+                 const Member &iend, reference_type update, const bool final) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update, final);
     }
+  }
 
-  static void exec( ThreadsExec & exec , const void * arg )
-  {
-    const ParallelScanWithTotal & self = * ((const ParallelScanWithTotal *) arg );
+  static void exec(ThreadsExec &exec, const void *arg) {
+    const ParallelScanWithTotal &self = *((const ParallelScanWithTotal *)arg);
 
-    const WorkRange range( self.m_policy, exec.pool_rank(), exec.pool_size() );
+    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
     reference_type update =
-      ValueInit::init( self.m_functor , exec.reduce_memory() );
+        ValueInit::init(self.m_functor, exec.reduce_memory());
 
-    ParallelScanWithTotal::template exec_range< WorkTag >
-      ( self.m_functor , range.begin(), range.end(), update, false );
+    ParallelScanWithTotal::template exec_range<WorkTag>(
+        self.m_functor, range.begin(), range.end(), update, false);
 
     //  exec.template scan_large<FunctorType,WorkTag>( self.m_functor );
-    exec.template scan_small<FunctorType,WorkTag>( self.m_functor );
+    exec.template scan_small<FunctorType, WorkTag>(self.m_functor);
 
-    ParallelScanWithTotal::template exec_range< WorkTag >
-      ( self.m_functor , range.begin(), range.end(), update, true );
+    ParallelScanWithTotal::template exec_range<WorkTag>(
+        self.m_functor, range.begin(), range.end(), update, true);
 
     exec.fan_in();
 
-    if (exec.pool_rank()==exec.pool_size()-1) {
+    if (exec.pool_rank() == exec.pool_size() - 1) {
       self.m_returnvalue = update;
     }
   }
 
-public:
-
-  inline
-  void execute() const
-    {
-      ThreadsExec::resize_scratch( 2 * ValueTraits::value_size( m_functor ) , 0 );
-      ThreadsExec::start( & ParallelScanWithTotal::exec , this );
-      ThreadsExec::fence();
-    }
+ public:
+  inline void execute() const {
+    ThreadsExec::resize_scratch(2 * ValueTraits::value_size(m_functor), 0);
+    ThreadsExec::start(&ParallelScanWithTotal::exec, this);
+    ThreadsExec::fence();
+  }
 
-  ParallelScanWithTotal( const FunctorType & arg_functor
-                       , const Policy      & arg_policy
-                       , ReturnType        & arg_returnvalue )
-    : m_functor( arg_functor )
-    , m_policy( arg_policy )
-    , m_returnvalue(  arg_returnvalue )
-    { }
+  ParallelScanWithTotal(const FunctorType &arg_functor,
+                        const Policy &arg_policy, ReturnType &arg_returnvalue)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_returnvalue(arg_returnvalue) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif
 #endif /* #define KOKKOS_THREADS_PARALLEL_HPP */
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIAvail.hpp b/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIAvail.hpp
index 051703ebffa5be5b54eaad8f7e7f564ceddbdd8c..c3c416c4cd0810f982e2f1d2771bff07e9fbfd9e 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIAvail.hpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIAvail.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Threads
 
-#include<eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIDecl.hpp b/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIDecl.hpp
index 8f26b28d6a01041aca32cc945e4f273627cf8ea1..eb287c0db7aba2f7cd144385479fd9fd0079d987 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIDecl.hpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_Threads_ViewCopyETIDecl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,10 +49,9 @@ namespace Kokkos {
 namespace Impl {
 #define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE Kokkos::Threads
 
-#include<eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
+#include <eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp>
 
 #undef KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp b/lib/kokkos/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp
index 934d2db2ca83ccbd2dc1062ab71c48c14f1f8542..ec2b1d983fa6e86510a1590df612c3bb002313cf 100644
--- a/lib/kokkos/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp
+++ b/lib/kokkos/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,71 +48,61 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType ,
-                   Kokkos::WorkGraphPolicy< Traits ... > ,
-                   Kokkos::Threads
-                 >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
+                  Kokkos::Threads> {
+ private:
+  typedef Kokkos::WorkGraphPolicy<Traits...> Policy;
 
-  typedef Kokkos::WorkGraphPolicy< Traits ... > Policy ;
+  typedef ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
+                      Kokkos::Threads>
+      Self;
 
-  typedef ParallelFor<FunctorType,
-                      Kokkos::WorkGraphPolicy<Traits ...>,
-                      Kokkos::Threads> Self ;
+  Policy m_policy;
+  FunctorType m_functor;
 
-  Policy       m_policy ;
-  FunctorType  m_functor ;
+  template <class TagType>
+  typename std::enable_if<std::is_same<TagType, void>::value>::type exec_one(
+      const std::int32_t w) const noexcept {
+    m_functor(w);
+  }
 
-  template< class TagType >
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { m_functor( w ); }
+  template <class TagType>
+  typename std::enable_if<!std::is_same<TagType, void>::value>::type exec_one(
+      const std::int32_t w) const noexcept {
+    const TagType t{};
+    m_functor(t, w);
+  }
 
-  template< class TagType >
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { const TagType t{}; m_functor( t , w ); }
+  inline void exec_one_thread() const noexcept {
+    // Spin until COMPLETED_TOKEN.
+    // END_TOKEN indicates no work is currently available.
 
-  inline void exec_one_thread() const noexcept 
-    {
-      // Spin until COMPLETED_TOKEN.
-      // END_TOKEN indicates no work is currently available.
-      
-      for ( std::int32_t w = Policy::END_TOKEN ;
-            Policy::COMPLETED_TOKEN != ( w = m_policy.pop_work() ) ; ) {
-        if ( Policy::END_TOKEN != w ) {
-          exec_one< typename Policy::work_tag >( w );
-          m_policy.completed_work(w);
-        }
+    for (std::int32_t w = Policy::END_TOKEN;
+         Policy::COMPLETED_TOKEN != (w = m_policy.pop_work());) {
+      if (Policy::END_TOKEN != w) {
+        exec_one<typename Policy::work_tag>(w);
+        m_policy.completed_work(w);
       }
     }
+  }
 
-  static inline void thread_main( ThreadsExec&, const void* arg ) noexcept
-    {
-      const Self& self = *(static_cast<const Self*>(arg));
-      self.exec_one_thread();
-    }
-
-public:
+  static inline void thread_main(ThreadsExec&, const void* arg) noexcept {
+    const Self& self = *(static_cast<const Self*>(arg));
+    self.exec_one_thread();
+  }
 
-  inline
-  void execute()
-  {
-    ThreadsExec::start( & Self::thread_main, this );
+ public:
+  inline void execute() {
+    ThreadsExec::start(&Self::thread_main, this);
     ThreadsExec::fence();
   }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_policy( arg_policy )
-    , m_functor( arg_functor )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_policy(arg_policy), m_functor(arg_functor) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #define KOKKOS_THREADS_WORKGRAPHPOLICY_HPP */
diff --git a/lib/kokkos/core/src/dummy.cpp b/lib/kokkos/core/src/dummy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4f5f14e7d323e97a5289d271be98667c59b5cf34
--- /dev/null
+++ b/lib/kokkos/core/src/dummy.cpp
@@ -0,0 +1,10 @@
+
+
+namespace Kokkos {
+namespace AvoidCompilerWarnings {
+int dontComplain() {
+  // keep the compiler from complaining about emptiness
+  return 0;
+}
+}  // namespace AvoidCompilerWarnings
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
index 588de9ff87a1a244a3357402392997c66fabcc39..a72781d8a0dcfe53766c59a68ede210ae5396735 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
index 3ea55b017fc9064c178cb560a4bdb155eefb4be8..86600a2d38fc24abbbf40a9a129f27a05ec41f0c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
index fc8ff3c0f84b161f42cc350383a7723c09d1b1a8..1f4e93ec2b22f60387e369652ada9e8c648848a8 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
index 2577ef6ce53e8663d0db93417a5e8d5eadddb9d6..e6d965eb4811a2dc5b9b23b274be5a1860cb3bf3 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
index 83fece17a58e052c6efb8b309838f1c79d620b64..5bb1ce76e639b8306f8ea4211c3af17ee92dd95b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
index 57fbf84a4fcc048428e0395a20b88f7be7d7e612..cad6e9b671ea7099ddd9d67c3d1f0e12bb78df6d 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
index 983d4758f861f8fcfdd22bd562cf1c0dd1b0306b..5c31da459e0efdb3b048db5d27775f5aa1ea6d9d 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
index 2c4f36b264be47e94c66e28549bffa937c91422f..7ef6acb4b199a6b04207814dced6459af5895af2 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
index 2942ef69ee58234cd4a34c520d180e1008d19698..5680b8581c2b14f743d2300f177ab13b1e03a55b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
index d49c76bf4ff344e685f3a12650af8b75975a4094..bae1ee88270458abc8a5d2a287dbc5a932a4e05a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
index 554e39923e65bff4ed1351c6fb838d6a597dd7cf..9ad5912c0bfd0cbd7c355a209d4bc8c81421820c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
index 48b4f812ab73f4e1b6d19a6f87e9d3e9f7926790..12806d1c5b2c5f36b0a16dc4ee37fd25243156fc 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
index 30b1fa18ca5c04c848d5b2a98d664bbf34783769..0330b205db29cff4ceae306e2ff4d4e0ce9abc3e 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
index bb1bcba7cc6ec782c6dd4107279a2177b38cd84a..10e894125d193ed73d0610c3abcd4cc2869102ae 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
index 9cc20527b595e633cc23bb8748cc68026c2a17de..7cec3526625bedb3a2f50d2b8d85eaebae1bdd02 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
index 60ee27fdc3af78357fd2ad66c8a72103dd5b8318..5bb6913ccefa2a35105bb133064634cdd76bd6fc 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
index ff53cb5c46aef73d9aecc952bd003532ff8e1d48..f138a2049aa68e6ad8adbd4af85817281de152c6 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
index 3009f69d7926507dcb83ca223522993a83bde03c..e1901422d1bcb26860f44fee6bf617cc40125505 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
index 3e4cb08e55c5ed7222085497701df4456b582b3c..c4a52c2dea81980255314d61228b2b14ca414cb7 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
index e3bed2fe3a959bcf74b07fbcaa344c0907cfbc48..dab83bfb18ecfda33d1df8065a17fe4e0ad55dc7 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
index ddcde86c2dc60eaaa586afdcac962469fae52575..522303b4477b30136191745457db8ad64adf7b4c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
index ee83ff2979589169552c3638a1280f2a97c4fa8e..608b4d4c27c1941d053fb88fdfc2ea9aea08953e 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
index 448a33a42c4cb5180f60d570f067195b20d7e0c8..2c33f7facdf4937bf48ed407e0d7485d463f0dd0 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
index 03ee59df501974c59a6d51dfaa5061f421130cf2..3ad16222e454a4b0e4dd7f4ae129d8f8c5366039 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
index 76feae31fc1ff681d904db3d8b4c7777c5a9edd3..47f39d7ae224b091b8c6fa77981359290bf0ba32 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
index 907fef11aead75bc810730fae37bf8f1df19e8ae..bca253b756584321b327d1c343f38823f08bea69 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
index 5a1c9e194113ef62b9504aefa00ac54154084896..20fadbd5d8c1bbc3c48d677eb160f0b59d7e8a39 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
index 53dbf6876aeb1a5469a398fb223c35096280a95c..4d4716510e61330882f5ce888608854f38f94c63 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
index f077fc17bcbe0da99ece0c690d53b892c433f657..42fa2c7b4e3c94a599a097946590e675d11aae76 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
index 2b16913edfbaf4de1d8e3b2d0c228d0f6768fad1..a3cd8cc994b986ab66f0801f3e86561d98e32a6a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
index 9af8d5cad8154b6e84c5b9d9a92430b147a729dd..9efcc720c3c1f73ca4eb4e092a08a03810aa3e54 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
index a8d721ff2aa49d8b7586ba92fc0ad94a36da5604..c34c6a391f2707f97d7f4e17bc1fb389a2e9dd9a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
index 56cc0cc35ff5b9d7a501b02d794cf680643ff754..6d7cf16fa5e5ab6c5dcd370785a005cbfcfd8742 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
index cdba118eaf02abe4f5a2fe42d2987cdad71d7d81..ddd65c01a885e35e81809a02b7be99637c53c580 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
index 9e3ddc21c1255b8d3ff65037e647e5c6a7dbb647..ae41d193957e9daaafde10fa32588ee034eaa512 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
index 88dfa48a92eb0ae780d420fc64c7d9832e2cb042..5d349b69907056e29f26d20b82f5430fb8a689de 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
index ddfbb697aa6f1425fa59dafa80ed7a948ef68c50..c60df3767435356f73ce9bf8efb047cf6907102a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
index 5ab2169892ec2809687a83bdfb42c51860e96caa..cfce1b7916b5fe0aef4f648b9fdb8ed331d34496 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
index 4b1f40078aef250b6e3cfa24341cb851ed65f044..659ef18377d3f992ea205b2d53ba1d18762809d3 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
index e787ea93ebd63f7fb4e11eabc7a6bbbdcf07cc83..84eb9918530738f00e9240b29d79f8b58a186c14 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
index 5a64d8b9d7cb04b022cfbd8aa7e9205fb6d1ba6b..7f98cebd64b92b0e456f165756a5f86adc272645 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
index 172ff0cb026ee37c7e2bbcc7112afa69f4976076..f26ae1e4e1cfca1cb4e2a6f0b8a65fba0e9aebe7 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
index e0eabfd1ee0a62766439802e42c275dd30152cc4..a5167f6fa8488b95ab9efbcee66530d8e96f2120 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
index 9c832f1c76985a615d0b87b6f1fc02ec2e1ce928..60658f0bd7c8ad6773fb98772acb9841d5e11b00 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
index a8ef166b8eb932177aac3ea65e3d3a6fb3851b73..f74d41f90284e727c23396e90924b730a8ea9444 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
index b15610071e4ae417bba8a5741a5a2100e99ed02e..03459667487b25f304db33578e34c0df5b65a700 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
index aeb9ba203917cbda468fd0f1e7ead7005c645097..bfbaaaec7af487d2bb198e3013f3df1004eb508c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
index 5a17f5f3c823f4ca054245e64bba911ed519d5a9..1be20a18fccda2f40622ba745fa5b9d83a3b709a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
index cb24225dc7f1ebd27a8d1ad6aac1b6d6a3f65f45..51394ca352e81353a743ff95f18b36061f5788a4 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
index d0750ee04b978301b876a397a1bc47abceac2243..df4ef48e33d8a3dd8c218fadbf3f5aa17c5ba0fa 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
index 2e7bddc68f47ae7d340618cbe3a52889282cffdc..83671a7caa0d8053f9902b86549b95dbf4d66a05 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
index 0396b9746644c9a5e48a55002c203efdf84790f5..e652e268beffa77e8753b572dc906e3112b82b99 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
index f43d9ced14ddbbe90086f932b25474123e035440..2b6b50a89079d8041856b97bc27941be2315f6a5 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
index dd6268bdb1d62d471fafb306276fdd989b035936..072569f7eca58f284f926f6cad4e8ef6f4cf9b29 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
index b46f21eaaffd251435fc33e4b58dbba79c83629b..b2bb00cb8960bae9327d725a4615187444176c56 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
index 4e4f72de24a08375bb0c2ddee9163db7751b0f8c..39615042ee9ff2e42563501740fa726f2100863a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
index 762be2a5b17abadb29cfe85ffa4798b80881d2bf..a98a7aad2d8a8f41fda7a266c5f74850d352ab3c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
index 7c569e881e8c17807bbaf6fcfe129427022ebb7c..e557600c6c5be04e27e193c36a24544fdc18fbd2 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
index 45e08d82c07b71a3820ffd022a7453a582e84c1b..0e31670af8fd8e6b1a8b3694c16caa8b9078209a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
index 02eb834284d5639594cdbae615b05e2370d60407..873bcb274eb0b3e7ea8399c4fcb44e9955ac1062 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
index df7e14fcac757d013065d2c3e42e836cc6ca5e41..0cb8e8f22fb76ef6e465da6cf81f42a89ada9e9c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
index c55ee267b30235e5ba7173100a802f448c0bac37..120fbd427897f9064f1d74b9ade8e3a589bdf1ba 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
index a151eb3373119b8c32a4021447a06c9071544bd9..181c8df8dfe752bd938ec21b096911661441669f 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
index f63ed4acb0ae799d2aa70d0b27d933f1bb6540a6..0e7254d25b79cfca4ff1abfb438d6ea3f4300f0a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
index 2d469487dc46d8fce05347508e563b02d62b0361..e0a383743a95e441c4b8954dcb7c7520758b1f5c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
index b38a8c5b669d423d1d527966b17a452a515d9bbb..4bcab3263f5b56ba1c3ff5d20f8f9524f0787130 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
index 1c7418bc76da7c1d0a718f79e44f6fba69f44dc2..4fc3ffeac896dd5b9010b4d567fb7e49da26b064 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
index 179c6d0dc3fae16c6e95d88d16f497de3b74bf91..cf63d330b1353bbd478300e92c82c03957b21e73 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
index c3c8600757b4dbd2465005a4a4bfcf2d585d8e2b..e3ec8d7a0e5101f4123498e0ca880a2e63008ce7 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, Cuda, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
index 0db876682787d10fb07b45a95f0765436f10d697..9e8739ba3d7fc3bdb7120de5e1a616a7067a7243 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
index cf7a595d92f4dd1cb80298df00ebaf892f8b069a..30a6e366f3f30f537c04edf5a4922078f9f8d828 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, Cuda, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
index d92069af5542024bc1a069b21545c0c18083839e..1d7eedd9ffd2cfdc61b1d8907c7a8b4b2b41f82a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Cuda,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Cuda,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Cuda,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, Cuda,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Cuda, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
index 648989d4e758daac708b03c316409e6149fa711c..372bc02c3f1f60ddf7f7753b543529a32316a49f 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
index 52e5616179f8ef417dec463a50d9109d9279abcd..9c9328f21d614513123ac5b34f79dc40c36c2ac0 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
index 25893821eacbcfffae2bdd98d2b171866b83682a..86a85d220a7e01b0f1827314d9d172e41cef348e 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
index fb063765beb6102285ebdbecb7ffbf604d3dc6c4..251bf7dd1855a0aa731aaf33776123b6fb6636eb 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
index 7f3d5640a1ea83be9446727cd061bdc4060f915f..f0c0d79391f99229522bd3dee8161f3e7d25f2ff 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
index 944487e6fb40a01736bdd9259b7e6edce1be2fff..1b094259f8fb6ca058076c8048a42895e4ebc37d 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
index ed279b3e5d9d2525020f15b74960f4d1aaf798b8..82b8f87fa499fd3096ffe5fe4bc86de310686a20 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
index 9a8a68cb02875a0dc919a28ad07e954d56e1b7eb..daf8a4d1e7c71b22275fe3bcf7bdb3695331a109 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
index 29be58695cfabcc2732f8de9047ae934391f4a8b..bbdd48bfd56d031df0fe4e283813b8861c3337de 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
index c8049f36be6d862689145e79a5000ca72c65f8aa..093c250d572b9ec1d26c6bd16aee599119110bee 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
index 9ff426d37801c0f7179c516a318e27cb227ded88..c8472757c7098e80ec6d5d92c96e12e3ee222eb3 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
index 54d71faa9831774961b65a2b5e8eabcefbf64539..f8a92911327a9e6a2a3931a2ac286f73975223a9 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
index b5348d789d26a2e363d07f554b6a9734118ef8b4..f47423fc1b408b5ad24c3c60e54c7f8742f8c23c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
index 8f176e035a0eea63da9751f5697fdd7e75c9ea22..f9b8d6dba30e12b76e8cdd5325b4ec2577732f03 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
index f3b11f3be3bc5b2beddcdcd0ae7705ec7b8a77c4..8dd503b5a80ccc577c1e11f28d563762ee014dd2 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
index bc75c59aa00a448fd263b4abd38778280be7e7e3..f9317134555f525cf85ff89ba858c6f30709ca6b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
index ef4ab09758790c281ba0d15717694e4756d68d5b..9105b908b3697b14ad620831d0bc7ddb2ec7d58b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
index 6b3e5b4f50f8c4e86645165306b8d5085fc00075..6f92bf8f50fa4a63ddef52bbc8a7e7e92a806125 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
index 6fa6134d5fba74c779e30811946b4afcaf48ee91..6538490fe3cb017e921e365f5b4104e343008e2a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
index bb868bcd8fe0d1da1e9cf640677e73cd1fcd5c78..c7a793b3d1d2753812fbd3126cc520348fe84c9a 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
index 9073092dd6f1c26b42b185a1620b141d7f0803aa..7e5c7b56f0af0c014500c3ea47e26f3264bb5f63 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
index a863155fee33fe29a365f36a17413f557b543009..dcf70436985c7d2d9239a47e76de954bc9775674 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
index e7dfece441a0202f7c64185779698ba2f86cc097..3bd6920f419a49c8fdca261ebce9d371b2d59274 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
index 29553b1f0ccf1e9037a1b4b4954ea4294ce176b9..d75d3f92410686184e78cb5bc73a2e5dc2a576fc 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
index dc0699b9f18f34f82c9ba597a2761312c9beafbc..640fd04e9656e8ef710140badfb479b4c142fdeb 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
index 6f1b308e51301d36ddad6fa17b58c33a77c9e196..b17601cf0a39940ce72f466d70de2697ad4aad01 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
index 5a80040b894c81031de309e06944a6a3954643fa..a039d13f19af3ea9b1970bf8571d1a81b79886cc 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
index 87721733d4da69144b1a490a0d1f0285f34e6ad7..0f4ac7de1db2047ecca224fc88d256b5054494e3 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
index fd3bb36a889afa1e51f23ce0770caf7970416c79..892f51c218e180a4c44a8d4950c7dc5ad0ad955d 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
index 3fbefed4dbdb81db646fb51e40d59acc9f3d8915..ab96396e6abb56152a385287137ca019c16a2b22 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
index fadb9ac50f0b6ac07e2ceaaacb5989584d580da0..762c1f8f6bd5c416bc6adb980628b2c96de91194 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
index 7847f728078cbb89e5e08a1ddaf5d8e6e37fca24..63c6bdc8a0ba3dc25e655fb90533c154a00af728 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
index 2a24638193f5eb87701e3ec63c4648b95298fc86..5f0dc1f6e2d5f188ec5a20b308c43cefdeb3f192 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
index 4e675eda164487a5b608d5fd84d4f4598a2e73d7..d3eab4fe88a561523bd2d5f2f8527a1f01f6b9aa 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
index 34193e4b1e9c914b8497f583e3260513fc071291..36d34aaff2fe8514ddf8ca157b24920cea96e32e 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
index e21b25cd00fe3adf3d9a6dc3d6efd99e1d9ee2c6..1d9022f380fd77ccd099fe439418741006f34e4d 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
index 37ec7cc896072243969edfcf9c47f9e7a8e94839..89172d0ef27a7ac006cb714c7bd292de8b39b612 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
index 563bac2c1e26a04369b1b7ce0f1228643107299e..c14394738b85badadf7208d7648eb8513fa885c5 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
index 1999f0b66fcc7b378231af9d0b604b39dedbda7c..395dae627a0908e9cf7a4f968fd3492b8a449907 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
index abd11745ce34d71244f5243d858af5acddb4066c..8c192533f5e232f971245810c595d9514a9391a0 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
index c480228d3f6db4d5c4bad1703c39723e42d5b551..22153b115853acf9802a18fdf1854d3de3d4f579 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
index a3c1d0a88359f76a863be400cc246bb6050d73f5..0e5d2768728b252048446d553d6860a01216e94c 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
index 0e314b2725a7538c70691cd9d29d06ba8611d3fe..d8b91a00f5afe01fcb6357b8f8dc5bac234cf571 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
index be5d4747ade198d6e97420a1d9429d0bb83922c0..08798db548f87a8cf01ea50b215279a3d706da42 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
index 4e16c4ef3fdad63a323ed3e2642176937f036c6c..f371b9535dfd426ed19865d6c99b1bf4f8ac72ec 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
index 41fec603a347342fb1a87f0d9b74b4d2fe713a6c..6b29dcd945d7ccf0bb8c2cccfc2d9330088b69fc 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
index b30e046bee058e0a82ae98275a3eb2184dee65ea..8deb69b612e03bf4da3c1213b9f8eb186f6ef4ec 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
index c7178a86f2e2ffb76ce66aa57dd606031d4aa644..fbd4a498c94db4a44cc48da63b1b6c5304c067ad 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
index 4cfac53d82478cc5a668d436ad02fa2a8cba0210..b3c31de32daf820f117b2b9d8cf9e6e8c9cbe60e 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
index 857b32d762e61c31bdb148879b0ee1331b4d2723..6fab29106109ed3e3ab118543d9bd7ebeb4d2501 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
index b443f33474f934bfcbf5ff332ae1dbc2323828c6..7be7b466278b576bff977f53ce5b25ed9fb085a6 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
index c9a2958fe2ee3d021aff07c2658d7f1271bf7070..9f0f83ba2df259cd054383de65f222dd524c790b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
index daca93e505f8542dc739ab76a3fba9c410523436..7fcc5db031ef485a75167aecb46f278ec18cf917 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
index 2bd06640420bd2c93d04a90e0047f0ce8ab8bd6e..1a7b9933ab17851ac46690f161d5a31d977ef283 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
index 90cf69ddea44eed560ead0d347fa19e35ed91dd2..c89e60595ee8e5afbc230f2be252226a0e10959d 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
index b3e7a6b8500ce27c22c1bc524bd2ba0c9bedb7d1..1be8bd0281d61d1873d6a76f343cea54585502d4 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
index cc07a826fd39f884de92a1cb95c40821d4711518..0c61d411bb6ac53838c0dfc65d2567c742ad7480 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
index 9edad89e4a4dc62145fa24ce82c0eeac9424739b..c46bc82680b2974e6b822b4fa9cb219157487f9b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
index b0b934b6b46fd81db568ce10ef064cf54bc84911..3f430147adadfaed80a02802e88df20d851f033b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
index 2c018b8cf094c432f0f690d719562e533c7b895b..482bf3a6c142a3b9950116df3cc208b21eb1ea41 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
index 88d0692285da319f21a3339c7834faf8095355fa..eec32bbc800b3e884a2b82298f8ac3f22b56e719 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
index 3b5f73c9e33652a5e6ffd5055e3b90e8de526e01..9d95e5f9d515a85f7ef7dfd83533f3a72aa5ae15 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
index 85dc163c1879dd9f498338069b61b09f9a2af97f..ca86e10dddca41e177d2eaa1cdba496fa19a7324 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
index 0586654b249f1ede4ef80223a47453deb7e88159..3047e380dac48b7535a5e4b8cc9c7f8e8ebea426 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
index 3a22cc8a9efdad19e329b5b4ded906a4f4c31a4b..3096ab6d3a8cc1457222efd844955578713104cc 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
index 1b7cb634a4dfe2960b1be45722f809de8b8962f6..88eacdfe85ab2ccf88aba7fcfdc09348b348c673 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
index 465f00e6e33c0dc0f64a0b9930499287265b410d..c800698d36a8f7629e388a0c986fb89338d5d178 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
index ce20c681da7468f7ef4ad5c85e5187ccd8c28ac2..b2e2cdad449db2ca7513f7373bc29f48805b0b81 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
index 4534e7dfd8355e9aeb7eb760cc0fdfc842d07641..0dcabb6626b46d2f476aad6e5670f4077af2c8fb 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
index 334224a63331a43519081c8eb21b42e8fa536102..fd2f9e858912908690787a14428c40ffd5a90f3b 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
index 4c1821f07442ee38cea5fe18c2ec8b524bde0138..c7b4b9ff80948186529458afeae862e9c5750b1d 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, Cuda, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
index a7e1fa02629f21fa341d2532fdfb0a6609f037d1..c389a15f728df4586793aa53d475871ea0fa901e 100644
--- a/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Cuda/Kokkos_Cuda_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Cuda,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Cuda,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Cuda,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, Cuda, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, Cuda,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Cuda, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
index 905c97c54e1759d94df14bec1d9f0202d5b8609c..1a9a9bf4f86beb2cc06c09d416bbdc534d29027c 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
index a7632852cec2bb3af415a3756bf2d9c1fcb9b35d..0996ffda1a3e1686c6b8abd5b30427fbeffacb21 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
index cff22240cfcc7adaef7a1bd947678054b823b518..08f2651c4540f8be47fca496c5036636a2beade7 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
index 2b667c674fc1c770399ec26cf798f7d83061f012..8f5ca318507846201d1a2609137e3041bd349779 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
index cd1a445d81b3af6bdad240929d70531189e1f7dc..7e50c2d58b5439cf9b94c9da19b889d0420e5401 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
index 3d805d5134ff7ffdb2ba7604dbb4ba36ab210d08..5caa76cd55be5597e2c1766c1cb35ce25469a585 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
index 3883d581b67ee7af447d91938c0357c74fb46835..5427e9f274948cdc1c5475da804f4e0ac7d10875 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
index 55f3e200a5be7df68884ff1bdd950c5598a1038e..4748550943a940ba024362030f088a76342a368f 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
index ed6d57260bdbdeedf45ba383c219ba317a575e6b..db65f31221eb51e0f1e3625441c67faf2a8d9f96 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
index ed1954e683cef4a7ccacd537060fdaa0fb94899a..da598b4e5504831a7a08ea7b4436ed34d320af48 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
index fb8dadb8d04764c33c08b948c73deedc823d827d..8a60373f4a6c789f7c68afd1bc531f50b6281fab 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
index 16a0ed3e9c188fa4d76e5718402a7661b057bca6..a9531ab8e3a1b87c13c30564cc507124d58bb497 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
index f846f94a9696800b7bed317eb65f3408c708c8fc..66c05061377972011312c6746e95851330fd4356 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
index f4b51a1d785dfcd9df5db937e778bc41341d95ea..885b2cc04d611e0c298889c021eb6792b141171c 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
index 622b3119bd09c5aba2bbbc863b484415c4fbcb7d..90b19bb66e45ceb3aa12793fef53be9e2af2d6cb 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
index de871103dd37a3cf77770020c922c4342865404b..d62dbf0b43789af6b9f04e70e0f0e80ae7f72819 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
index 720e075aeaf1ba8d201c768c4755a9079e28ec78..2b614aabfc65128409dec038ab4a48e9f299d7fd 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
index 4c57c457c2ef76534c7abb17582403a2877def53..7a1db773e95848485d0ed731ee543680f6a736e1 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
index 5a37da22c4508f857f7995565bbda68209560a88..d6a697d60eec74aa507ce8ce5fa095f587e75cbe 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
index 93a96ee5540b639170da77238c8440325ecd3923..4fe8d07b9fc20792c047a0a93e80bd72247eab96 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
index dcfcc8a0e32679e507656e8bb444b3b3a758f6e5..c0d5b19de5aad507fd3c5b19f0819965b70cb4fd 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
index 7082701282d6b059c101f7790f20c7fef6ef9d8e..0c6fbd75bcdf851bae610af437e8188bebf2f800 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
index cbbd7c9ef37328d681056fba9b35709ec019fa96..379e7e6b7742182d9118683393d54074975b3041 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
index 22d6fc53878af6b2fbe987cda5f7b0e556dd367e..6c62abcd70e0262097bac1dcaeffe795f90ae1ac 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
index d44e95e67eb0fbf779ee481066088f81c158413b..e5b3c382344fb420fcdcaa2906c1359b4d2fb1db 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
index ae79919c42a53f14fe7c02c79cf9d050ce0a0b6b..f90485b60db8fcc74a1315f4257ffce69d461942 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
index 0c671ad593ba55d04870ea09268574f125c385d7..7b4ebf21c83362d96cfdc27ad52fc9ab51bed62b 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
index 24dd1c8354cb5c3106b5e461ff7dcdf7e53175c4..35de800a9ba7904e3d4a4006644c91fef5b6561e 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
index 6e2de8a02eadfeb656ac51df77fda81952dda58c..7aa6a05d344f23fbb0363d459d7b26120aa94c50 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
index 38840ac9e666ac214477a4bfbbaf64add24572f7..f1b95bbc0e2832c5a51f37f58864e6a487a21485 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
index bcb105628ba9afd7c242573dea3537b4c703bc2f..884570ac64e19f5e04fafce56d1b800de198f987 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
index 8730f92f205e0eb95e800662f20802b39aedcbc5..ae73c5dd3c4224fc7b75d084481534e7eae9bd78 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
index 785996558ba88a3398c19c6f884040bdc799a950..f529807167db4f30a8b56e260142d022f7fe07dc 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
index 3ae193ca6538cfd34f2d577c0d93ee5b834d6d6a..b3ab97ad7f1d01a0695ce01979de98806effb413 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
index 81f91019d6b7c2bb9648bd95d4ca8463d18e31ee..e5e934e8bf8bbcf89052f365c3a4620d679aaf83 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
index d34a4870b901ebef253d4d41e06c28aeefb09236..aa1f24ce43ebc8883b005f2cfcab0f53430b93a8 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
index 0da5ed177064720ab4badd869410db35a49ee3ea..891aaaa5776f2e5c0d604945433bccce5082b960 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
index 444dad079bc79e880e3428e0b0919430a5a1c9e5..d5fc488231bafb02631be542bd614620d1b36db3 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
index 3f36a1d7142116aa060d05f1bf4f062b0f7d49f1..baa863a40fbd6aa6e2ac74adfe68ab913a3b304a 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
index 51c964b92db3a8e5cde1b99e9593465493f28aa1..b8936f1bcb47e26b2cea71c2b88563df62d6aac9 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
index 1a26522ff5dc6430fb713abfb7d039213e897861..b5c313875964b244d99c8d12873ab8828371d4ed 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
index 9bd9af3fe39081d2a66e77f6b6ba3e75ace98f03..0c12c5b477bb1013246e36b9aed02b425050ba02 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
index dd5a32553543426569d83326d8b6c6cfe8e9ec26..8934c4a6e4fbfbb1e32d41d5cfe2321a9dc711cb 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
index 30a44c0a8016f9ee7c5ea75224f3505f7f26276f..9c3046036716a1ffb352d46d8210b0d2badeb821 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
index 0b73280c6e4add7410f84d1d515fef6f646f100f..ae2b1e609f494752d961b14346dba0eda10b2cd6 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
index 3997d8ca583ec3f62af7b746ab998bf61bb11eb3..6f721ca7892e0f5dd8cf25bb239d0d9d87d05573 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
index 6cbaa59223448b3df19d8647233a4aba88f26075..4cca974fb6fc6f97fe803f04358d35181ac865c8 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
index 351001c8d17fa4821133a14847b079a56176aa67..747250c590193cb5bbeefd63af60cc23df7115da 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
index d37e34af30391dc55c00274d22730db6df35548f..2bcc9dcaa208dcf208076d6889b5f50824c54710 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
index 7609d9478f9010b7e5fffa1dd64cd3ea907431ba..cf424725b332d8d630cf7cfd8d40bb2b24662def 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
index 30f0c1d882a77216fde13264c0f62b682b4efcbc..7c5163c537319df53cf116863dbe647d37e58027 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
index 4c4109e298f76aea84a237af60705d2601875d37..275703c2212b4dc82b1c55a4f17303f102266242 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
index 189245d352e3db7fd8253d160bce2ad957987dca..0b8b6690b69b7974c60645a8b921d53fcef9a5c0 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
index 921a8e88c7b1718827993c4a2bc58b1a736b0a7d..dd7cb725e4baaeaf974ce2f8670d523376dea2a0 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
index 7e492aa25f15d162a382f4cf4cbd27e7bd7b6391..05694106cf0ff84f14e4866646e4222a54312f56 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
index 13b1a78d7c24fbef53dd937508eb6c744ea2bb15..ce5e6a291767d8f0bc5be8ad5a01c93174db5f95 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
index 03fa72c21cfd2a923b679cbec4cf80bf436fa34e..baf95fb1f26df07103c275405c1a0536713a2fe6 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
index 10a46bcd9d9787583f26c27d96f134953974800c..3638c01003b8ae9c83579c00f6aedb607cea1e4d 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
index 4c23c7e796429f775373b73163b96ef5a8cb2ff7..1f964cbddfead28880276c31ec0af702f732d949 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
index 1bc7ab41f784e575e7f4eef67dd709d7844737d9..bc498b3509bca227afbc4585fa962995694bef76 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
index 0206838af6b1ec64f37ccbd9f1bb5c223ae329de..0e97cd97c24535bfc75239fddd2d3db60aeb74e8 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
index 78b67a4a2a682dbc65d26c73e2721a88ec89e409..e21f05bf55b90da0d5785741dbe8f345a422a004 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
index 564f530d9badbe2ac387751d1d93d86533ea5323..1ccdc6a3612067c952d8e399e54599104276a5e0 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
index b5ae4ae52a39d2da5b70f5a14c5e965dbbb8aadc..ef1c1f970fe2d19e93437d03b8a306b434ef2fef 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
index b2c91a1aa12af806ef7ac96f664b63e47c5a6368..2c993914c61bad64a150a090c0c7b9105ece65b0 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
index 18e3f2b9b9b9039b51a314a39bb38340ae1b8209..c4d120b33bf9d5bd67474b6e7a5c3ce8015f942b 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
index e3d08c6e385e1d5de36d59842b7fd5df1cf12aaa..520013db6a8f5c515a9e3db2b097afb1959ce953 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Experimental::HPX,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
index 5001fc278144cfc71b49095dc76fe4c75704638e..663110f4508dc711d4422f4acd5d7352c03b6294 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
index fd45308d150c355f5e6a45be28730af89ca1ad90..ab18fdebdb010cb772bb8df16a3b7ee08e5342ea 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
index d2fca731512938b25a5b64a9a3cf17161dbc5170..232f088e811a6ffd58fb4936e700180167f37ccb 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Experimental::HPX, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
index c7fafd4aec1e4ee14d7f8b267459475d717f0f5c..5a6331b76b1145cc1715929cd951252fc6ee5035 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
index 046aafa6ad2c73d9f4f9be1c692bfc59eb93dcab..c3223ee4dc6a0399c2e46076ad545e93f7910318 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Experimental::HPX,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Experimental::HPX,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Experimental::HPX,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
index 60f78b7a570cb4bd95dbcbbabc51f912a3c4d949..50584929ae3aee751b12214c09eec853d35743df 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
index 304a5afc0d616ef1afd673b99799455f2b4ffdd8..281784c6a7a0765615475109f7f796a12b34ad25 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
index 8aeaf8a1f8258cb77843b95500e9892c360588e4..8a8220baeb0f58b08581640b187f5903168dc691 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
index 26ff7aefede90891d2474789c329fbba299bf5e6..7c5567b049bcf00b6ab3fac9ac97d6a59aad3669 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
index 518d000eeac14f57da8fa613226f5a120970ec20..f2716fef3ee615c98ffc1a63092dad379d84e330 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
index 36b3b4fab8ca31dce0ae50849cb20fc5d37a2af2..db1797304a3f14f105d551e7f7c087697a3d64f2 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
index df5c890a49483237ed3e03216553498cc119d8db..5c4646817001b883c419f0f75f017f8211d96eb7 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
index b120215692e5bc829bdf12e8b7498a6a5488842b..be4e90ccc4e49a8468a2c5c973b1f757d88ad30c 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
index 9b5e4c2e5fa906a9ba8cd4f8c9903fabc771f13a..17200db10bd2899ec02d6e46a4b1d3a6b001cb41 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
index 74ad489303e38c50298e7f8acb6fc02dd20dc730..89794ad1b965fe289dd087352c16c414d2031e59 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
index bc9dbc65c1d09c9e86924da12298dbee44eedeb7..1771edc874a803548c98d57e483a8b66015e2c84 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
index fbd98c8011cdc9e96a155d5c288e0de828eb7960..b118550ac21009314058d530612c7bc69d79ca80 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
index d52c5306d0655716938c7156927e65a9ba8113e7..88792476406b888c05efacc92d554d35736c955f 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
index 5cc29daaca5d0b7d06cdd35532099320f5f631cc..7b078639c749e22375adedef87cd29284c68cc40 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
index 7e63d802365990194184476652d8684a1c84b11a..2dc3d8b7c32197dc2bdfe7c3ff1aa11bc4456bae 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
index 11447c11b5021ef43cac8518bae26da81ef806a0..c3ff0b2127ede4b1e4aec2d158719a9d7b484a01 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
index bafe266044030e224e4099f83593e23ff8f8e76a..737fe0d63470955bd8fba51414b87051ac944879 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
index e4ef20c3707ffbe8f135ba75657395842c1a43d1..176a8a5768d191e447cc34323d96449872ae1280 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
index fb00c3bfd33715fe4e18423057b58108fb44b9fe..e967e8d2b3634625c735e467bce25f5a93b21cb9 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
index 12718353e8a67aade7e3ac394bf66c763591d9da..80323d7aa2f55cb606c5c6d998ee07a5f024e8af 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
index c9ab75062d39cd51812f90c444592c9c17e5aaf0..f68b9720ba94643d9c867238bf1ee4c5f45af574 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
index 71380c21a2d8db7edddd3d05446f3049a80dd57b..2dd7bf78434df7fdc0e9082349f143e6d9099420 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
index 9787086a807c3e6912d796ff3710b3e4983de0ba..c240157692dfe8df7fa75cef3b24e2c4201530b6 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
index 81072d77cb4ceaa588ae989740bacc8901b7e4e0..008eea27c956a82e763482fd648c19781b1f73ce 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
index 363b05baceb7b4c7f4b11b073cac62c277e9a45c..ba10fddcb5c4b546cb657ba70f5ad898caf50b91 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
index ce1bc89e01dab7cfabe328963c068a9f370c2296..0bc5851c11b19bee877c182367130162985335dd 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
index 4af590818c0cbaacf501531824f2757d22565591..14c359c09365b43d3a7130dede3c8c12d0d29087 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
index ad399eff7692b671568125aacc50f2d5479287fc..6672b85ce55c613091ad504db93c72efb65954ba 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
index 661edef66846942afa164445a9b7c2f34b50eb6b..1ec216204805722661aabb67e79089ca548638af 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
index 48cb4a34b10d626efea176fb015b37112bc264f6..1a6f0631b7b3b85612f939e55586901e68e030cb 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
index d2f88bb243acfc6b0a241c81164aa9b40e3dcc90..5b90d4c7a7d582105e2ab8d7d4ba05429285b070 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
index 58ce6f19110e8d5ead4acb9d222bfb8877dd9bf8..3e0e011b0a865b41837122d15a504b92cf1159cc 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
index bc4efab1e444444b3416741c810e7835502af184..912cfe66ff64c15d6265f510df54e212da35d4af 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
index 6225cf97208034d75345996617c865d90dc4158c..a2cc70ffac395d5b72f27acf1b25a2ec6cdf9239 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
index e50472d85090980481b1dfadb0f55371ed1aeb85..58772e42df7240b5097cda581e8f62b09765a0b3 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
index 5ad427acc59e0d31e9848578e72c64a5ef9726a4..ce52b3fcfc6ead8c675c2425a89966a3023997ea 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
index 4ae2437fc8715ceab8e1a07db3d9f4fc14bf7ddd..9baf307d8b256a8d054fe1e7b3be65bc7131a5d5 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
index 02a2b8e1d93de4a7ded9791663ea484a9b0f9ab0..ffc8e2c520a13dfbbb13c2bade3deef8e2ebf9e3 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
index ff693c9b4f66539843243095fee1441584e5fb3c..16aec37096dab1da2f9c92231413cef2056f687a 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
index d96960d4a79c5e09d9ebc9157e365f7cee50e4e6..a2b5e8dff484d76bf7837fa8e28e99d6539cc31e 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
index 05c3ef68ebfb29c5860a610cc06cb0c4819ee929..f5b7347d389c90c4dc6378d044d946f5b2b6b19b 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
index d96f47ece0fd642453f4ef101b2951286994ce15..7646c537229b2fb7f74c3752f6d789f5ae0a59e2 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
index 208933899e6d3506f784c8129eddbf850b048b82..e225e99c56d2b1bb1439ef20d87772f3d89f685b 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
index aa7d9b8f15883ec27ec3148a219b9838302f9e8f..441e8b63ed2662e41d2fbfb86f8d1a133370bc2a 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
index e43a1783fd4b04228a9234551d9fd9d4bbce579c..8e3bdecf1e060b1a301120c53426de9401361570 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
index 67060748197f3a5d4664e9b699558dea9a28ecef..7662c5a390056cd71776d911c5d317731f98d0de 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
index cd7082dcb3a87c06e227339a50631aad11dd754e..db8625bd9fcc7a6a000108f95adbdb7b651eda01 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
index 8735d5860501f08d47916ddf4092a24c589ef8d7..5992b136b08e35c736e5b9df75060a400cf48384 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
index ec371dcba7f93698618042cec625b2f42ab97b3d..f862aa4df93fa29435c1c54d520b4f4e7e5bb0d8 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
index 354da997949538e319b6cc1ce8fd6f62ca104acd..788c411d33959eb4c9e30ded772bb3d4784fad85 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
index bbc32aba039b4a98c9900f30815ca71e0b0caa6d..0646c93ac47567af5b6c6c415f772e5eabad3d34 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
index addbbb291aad2e5b7dbe9de37e88830d3090aaf3..88299a88baf0d2f9320b1c40f0a1f4017e026fc4 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
index dbebda1594b8b93efb279866e7a8955fd1523766..aaec87e40c7761033b373f0758ef37677d01a713 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
index f8a89b4226d10b85e1380d5c592876580c148ffd..f650c7e4a2a6672d387f47d3fd94d4897f0fd120 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Experimental::HPX,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
index 7f0b9fc346b085bb61571565f4f8ca82c8117204..1cf32f3f52b0f6d59aa236170fb2b3f4a092234c 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
index 4a31e60a3a0e3034ae46674d250897eac8f4bc40..a53f5b304bcb1959186b334c1f6a327a3fa7d950 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
index e876da3a6c731264e3c6d54a2aeda51259cba484..a679f816b3cf4152b5fde7ebb87877fa78a0c185 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
index a7ee2c554d3bcfd0cebc03ab476b5feb38b41ae9..dc2efe85261f1b05b1764d78e8741fb6bed62d50 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
index 4769c235bcfacf59e24433d52e2ef3e2ce2d03c7..f532d1917bf06836ae84984f9016ca08888673d2 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
index 3ac618b5dda64937008193e7fff84c30ab851a37..067d7c34150cc79ab30157c7085adb1b72b7e3b5 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
index 825bee722ff20ae3d19de31b87ecdf85f4d6dc1a..fdee4a6f35352ed1cc98cc724fe030a21b1b5cee 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
index 44e24e57f37fe9e73be969df685464bb5420a914..4ee5059611f6cb0d18161ee2005260c3250ca928 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
index 0b18c7e5c027f311b99b23da563b4e2b6eb10b93..280fd0113e7905212c85ee5e19c21a101cd2e20c 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
index 951d770305cff8d2567a9cfd8bf8a561c2a78a59..84525a00438063d07233984c5bfe0420bf6e3c6d 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
index a0e80d764d23f2c0b9f19d9cf856d456b17f7dd5..7ba740043c2d72a14d8a13419afb3384bffb3cba 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
index d8cd0155affe169534c46ebb6d24bbb49f182259..4a475494806759e19d6c9892efa1afd0602ac8cd 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
index c4bd8a043a08c8c140f82ace7ba3e9be9b5bcad2..14773de5dbdce3e188516d526b76bd478c5918e3 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Experimental::HPX,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
index 566eb71e4d22ba85a36946fec6743d4078b2e5dd..0f57ae5cb56bfd2a20d043a858adb7456a16c8d2 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
index 4b99a8fd0c74affa1cfc9cad6a24d7e80a138680..905bb918fce751328d22ab956622bdf4a0440255 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
index 6cf55bb5b42eb257390be9234325372c210aa183..30563fe13a1dde8b7accc6a5344684430bd3b977 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
index 932a322bac0c41121ee011632a23a464d0014a09..ed0c45b36b1f75666af642c3beeca251431e03f0 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
index f46a156a9332d0c33b51f0d35d6b58c0a1b10015..1ff4404c9b7577e8d711bd6ad207887091dd0a17 100644
--- a/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/HPX/Kokkos_HPX_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Experimental::HPX,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Experimental::HPX,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Experimental::HPX,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride,
+                              Experimental::HPX, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Experimental::HPX, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
index fd441ec0b21b678a23b42e3a8178afba651f5126..37d812f9894331eba580fa24f00b4d1f6a02b5e8 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
index 5add9e1a523b3c3b6955bdf3cf52a2e638556132..c4ac098abcf0a96e1252fba47a567da377238c87 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
index 872f7be994d9d9feb7a7063d07d52b2d4068af18..fc7cc305550db6675488d30a3b5f6c39fb8bc6a6 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
index 7ba7d7754bb4ff59fc1f0ee9483fc5f5999d026d..f543baf688e357e073db11775612beff0eaddbdb 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
index 26e79debffddd7976d9835dd33a135aa1734de62..6cff58e36027b91ce234761c14524dd353cbb053 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
index 74ca13c3d5091b9c468408e3e95dfe29e7533c9f..30ae7d650bd9535d766f2094273381ff258f0d71 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
index c5d354a5aa03699ea3244b52682c58468b8e08dd..343c09f22001ae3c2b74decdb4c594882949037b 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
index 6e60cb4778ef7619e5c63d8fe739dd005726582b..ffe2971e59f8f12e99cb6b6da910fe275d589125 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
index f26b9c3215eaedaa7547fe32fe5fdfa566b2de17..0e9a519c15f3b67ea18a3735b4f1c44901ca7dbe 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
index 6da79e6fbd39d1b39162ed220632e7535edd84ae..cca76dac3741980b6f405db5692e25607154a531 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
index 1b59813380092a4f2dce07b782c93902d25c09bf..22a6f0492fe342552ca55c548ffb93f84692364e 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
index dee5e70f5c999c2a7b8b54277af8294ca5a51c5c..32f9b4ec9813724fb15703e4634fcd8ad7e821b5 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
index a70b77317db0617785e2615a5be46fc7a333d750..9753469e5103307b383ae5aeaa2f17540dd96d10 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
index 5672c3bfd4d424c77251e34293d4fb504e625f5b..b0d5a3a7c7098c257c1c2c31fb962dc8794e9e30 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
index a2fbbbfa993069e9616e4620d8a2645553486d92..f1b981eac15b5b689540b5830cc564bc2ab471db 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
index 6c59e0db82d8893b18597562f0754925dfaccbcc..07ebe686a4c64df531b3f846d221486dae5f7bd7 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
index a14620f85337f1d53cb32934daf7c0236cc44ad5..1eefbc9b01772b147a06d2fe8d1def9b2b0663b9 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
index e5f572bfaad1fc34c0a2b6685c9202a7ed36d270..87a81639eb832b0de2245f9d230c116d18a7171b 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
index ee3e556a9c68cc4af9339ea2dff7e6576c589fa8..401069942e741da0d70ac9bcb01744ebd310e864 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
index 10e084638285f618b2a4c5e819f80f61c71253b7..4e774bec23925e7c192a205cd3cb8f085f98e6de 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
index 5d607bd85ef4b4f13036ec8e9a5dd63713d346a2..1b3343dd239a30d70017b40380dec3de72bee9ad 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
index 07f8f5ede263443290ea4bebb668725242021582..ad5421bb5ed3688c884923e843bd9e206541905c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
index b0d148aca40cbf3d6f427b43769aa9cc462600ea..fde46899806beddd42fbb2bd45207b669f1ee404 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
index b49698e1f4d5fff71ec7dbf364dfcd9d6e5b9096..9c1db701cc273000817594b7185f52ffe7f6a57e 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
index 2ea80d7c6e76978ea6d45aee2b9cd2e0059dcf27..2536abbed4e093ee92e5f2bfbeeb706d01daef58 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
index a5b05c16ab73eea1f7bb3b32df186aa6c3fb814a..8ab48a4f7b393a093a14796856d6c5836675eaeb 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
index f1c5ac6bfcb311212c58da2d4d7ec772fb7ce95c..e4f8d4044341a49aeae97e623cf1e0778fd35cd0 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
index 2330d73af00b0fa665d3b1fbaa24a2183dc37381..cd482972a76bd4888e72cb66d0d6d7d20b368d15 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
index 385f83dc38369a079558b5ee0721daaab2770dec..fa7b6211fdf8e94d9141ec86ec080eed8cdbaed3 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
index 037fa3e04d7c2efa282655ef48da4df1ce016416..aeb191e8ca7c0b05d0e6911546c35382e9f5d3d7 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
index 1d826cba49824d63efeb95ec39cc55243da99d18..94ce1eba0a6e8b19f4e976a05c7ddbe8d6bb740a 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
index 15bcc2fa45c445c92ff2c506e6dbfc66b4bbd792..01c96b436fcab997482d9f2e3029c831989ae21d 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
index 459c413c8d27b1cb8d63daf5ca6fa9d39b38e79d..3067883b2d722fcc3b7fe7b13fdc9a59b483455a 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
index 22d8d6608349e9bbdbe31483e7cd89932b998f62..27ecf522ac259114613af69a70213ed3d7d43457 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
index 5a9e00d3688dc69ced0e13e15dadea7ea9eaa774..2925cbe447fa9374f1a34dd2abd79c08523508b7 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
index 5ceea4286679be05bd7f85b29f9a73cd42ac9d35..72672c5bb33fce3db029b487a1f6efb26bb43ca9 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
index 142871e3fd25a79db6236e3d7cc7854808210184..d301592daac39c3b404abfb5d09e21858c45176f 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
index 0f6aaa9dfde59968b8734b827649753126b8f1d9..dca8eeb026e1e7898c9b0935e0c624500ba7220a 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
index 1e04899caa88100c289591bb238f03d8d26add02..832bbc0fef50828a807f8326d1854cc1bfb1c449 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
index a5f5bb24429ff0bc51f760d48abdd014c8963049..45f9c22bc1747fea7b449eaa27028bd88713de2f 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
index 217583995227966df76988f20d4e8134a1b88ad5..7c8c5d80b718900f2ebcd84c8bbffcef3315f6a3 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
index 9c71a7aa7135a12d71ef06ae3680b199a16b02b7..2fae74f591867e690b65cfbd7347f6435c38f809 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
index ac5587302336b016f0f3c77b2ee490d244578a2a..0523a6e286bdd8bd25e4ba62ab413a3905b2cf24 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
index 40761d0ee717e42aa2dc2e72df2058b07d9363f4..24d667d7da5e49637932cc92035253b170d59741 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
index e3d4243f102eee6a4dfb1c43df122baac1533558..599d8fc04d63c0137c5a1891fd2558c12cdfdc8c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
index c2fcc2d5c37f581267e4fad7366e4fe57107827d..2583f8d6e9c83ed556deabbc22c1654355d279cc 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
index 9b9ad45aebabbc220b3f43c612f96b481bea6116..d9e1f774bce194791a2090406337d9195670d2c1 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
index e28d0d9cf5a8e29198642b427e97173985e01cb6..8376f1dd38ff5117009104f3c589382ce7ddc153 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
index c8f48fb8f89fd07066106daf1b3ecb9f788cb7ed..2b21554c0854341aa4f16d116ce9def29d36f4d6 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
index 1c342bdff965b350d0596fbf53c77bd0a571aff5..985e0be47c2f693830c9fe47547c6784bbda9d58 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
index c7522a67988fda7b284f5632e530ff55488f9da7..f1e37a5c415e37b05aed9b1ed02bcf8380f13e14 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
index 5c5edb40290786e395131deea3df859399d4d32d..ea071ac108583717d8e474d6d99588686e7bc3ec 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
index 40668b27726386cdbcdb3fb0cf8893e473b4e905..ea2da28f105494cc22aeafab1ae32454f3ea3ed3 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
index cf68ec98d91ea10c0691577cba18a1993f67ea56..bac3515894bf3c547b31eac241194207f2c57ca8 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
index 8aec36b637ccd3821df30ba0decf213173533434..515812fb99410110460f5ccb97e90f639249a11d 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
index eadaa8fef1c0acf053a0ce1432692e1636ce2c4b..28ebc3505ba3014674ca75230e3450f24bb75948 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
index c2568a8355b0b8e002d0b56ac88c65c1ff4121e1..3bc9254b0e0f4fbd7f0171a3c37347e16df05a14 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
index 7dab740e0efacbf37fa1aef9fc3ec514465f872a..dcba7deea3bf6191b8f70f12a4199d22eeb625e0 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
index 1a7da65dac9beac63d1d8bd2180fb575a3a24d90..9aba49991b2b5a453b0993ef26b0b4cd707e06b0 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
index 9853c143efe72754da592a57cdc8568bae060b86..98d7304444276b45fd90adab5b7dff6698549824 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
index 215e893a7c6d23f21e381a35d2b96aebaa6141bc..2179ba6558ff13ddd4d79bdd1d7976f29a2dc04f 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
index 427ab62f3c7f08ec8460d7ae66952a80bab1ff93..b7eed148d8dd9fb8902adcc9791d195ff7fcb570 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
index e90198ced43129d16e68149f8228ad2accd36ff7..58a27832183fb894b30fef9b7cbc5ec9c3c62986 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
index 0d474d03c20277cfd523c5bff178772bc8e71d75..7ed2bd0bd792693b534c3629e6e0120bf81fa7e6 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
index 4415875ab2af140f0879b07dd13a2e2f7696c165..0ba5edbc7c0525dfe279626e20f8ceae54c59bd9 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
index 75c5030556636a491ff6b1a7ded0401c5f416ad3..acce37b7942b464dc7cf4c5825ef3bdb8088b2f9 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
index 92f5e2d187e9183b43895db476e590038c1ad3e6..83878113da2255c8fb7ab729d2307eab8dffc0b6 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
index f909e7e7decd40df775ea6613d88d533a9cb76ed..fbbd5edd28c5dae53eae6fa08d9ec67d452cd273 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
index 3d981ebd1b55312241de327c5d23687f4c8489d0..f4b2364f64896d9dabcda95849a2c0ccc0de500a 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, OpenMP, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
index 915c66f6791b3f65356177d64871fe7938d22c14..df6db05a880ea3e5d107da162c6b12180f51cf7d 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
index b70f09fb1e8a7fefdf7e8043976e30cb13a37004..14acf8fb2908f2adc1339d3adef6a18208bcf57c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
index 26f3cef1b62b845af300af16edf7b320cb1adf01..1984598a27913dffd213e32c2673a3af6a40f7d7 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  OpenMP,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,OpenMP,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,OpenMP,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, OpenMP,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, OpenMP, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
index 7e6941fb2106e68295b95a3305a7e761b0ce78ad..98798026505ce9c62533acc069b480ab94cb9b35 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
index 827c566ddd66d774467b256419ef3747e2f5dc86..1283f14a6917a7ecbc591ddb1ec413c0b4652253 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
index 5c096e04e8e7b171a01f3d2c19183f00e4010b09..3addc9913f57b9a5f464e88118a4c41d4c9fe274 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
index adc432d50bf8c7bb6072c5217ef4a871402b17d5..25336a754ae5b70c7ba5e45dd4563b40f7cda1d6 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
index 3b1024f4d876b4ea8b7bf4b11cf79fcec68cbbb4..b4cca866206356d17aaf9bdf4b0659cbe98b84fa 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
index d3155f4ec1be448601ae2c2ded3db0e89accf2f5..ffe81fbff76bd782bb1247d5a3f095d646bea4b6 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
index 3280fd5176b1bb5b6c54ca417b6b165ce9175449..7bb38884bcf2c7a7e1b6307b27883c610a426546 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
index 99fde6b9a83afefed01f05eb0b6d2c9c0d305725..f99f79e4fcafbc8f6f2d24cfc61d6b5381a43ddc 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
index 2fe8423e94ec6d5ed6a1368f238cc0de78d6380c..cedc1d90144c88094470e5bd3c60bd7a7be14d68 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
index 8a71683a76f2ad2ee9500d5c527f31e9ca8a3252..2e101591d1fc7884cc8a65dbe7fa1f9b2496ef38 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
index 7d1b1c98528a9ac8faafa94ae2ec620d8723d1fc..6451611b6f70bb02fd0437d9d033a24d0491159d 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
index abe4191dd79f96bd0a02cffdd43fe15ae3a15720..0898be20e1da2c5c8efdf3d06b3e3b9009c9b2fc 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
index 856cfa2970356d664e3639ffa63da218d5968165..5dc7d5cdde8e0ef60a70c6216e85b6a0345a8d82 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
index ccbde7277a175f7014f5843bf3a6960d0c80d140..dc3c00d42f728482afc0e79e4fdb47593be6613b 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
index 02d4b58684766f578370e11aec9ef70215506b7d..52b94e91e4f53fa5e7b25fc4c3de0e912364f4e7 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
index 4d8bd3bf5bb19f22b73b570148784b5fbc8933e9..3d1359bbfadb178ee00202b1d12ba249c2dc9f51 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
index 5725e9e40b2df64b213fc2424f4edd67c33fb3e4..54ac13a7564a95a675f125547169b3e72b993a6b 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
index 0de142dcb99c19de98475313c9eeda310e7ee15a..8a1e5089239492f183ce8909d4df6662d4bdcf3c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
index 6b9bb2c62f6b34c1f08c46a719b3dd3276d3025a..f585a683311546ffcf695346a814d3d59306dddd 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
index e3cf04bdade11f779eb6f72c86ae64845d168a93..f3943c7c6343e97ebe6bcab3f47894deff925736 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
index fa809bb923ef48ac60b31a5d0251347335a1fc83..ab16463a37778087a73083a4247bbfdbfd08708d 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
index c6eb82a2d8fba67d1721d3f43720400a1e2c7b24..3adbfa6aae6e9a68b4b997b3f8ca29dc1daa04d7 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
index ed7a5a0acc076cc083685a77d0fdd80ccd8a945f..32e317e02cd73793bff0a4ed0bf4efe010c9a475 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
index 93bc0f23821f9acb09b504bbbf42dca01acfefec..9a6bf70c926b9b8fa16701637bb020740d0dd4e8 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
index 649b2dfcda199bd5a80bf15f5b32b3c49942e5ee..a081f46d43480076dcbdb354fb3c4648b9a79800 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
index 0cf7acdc74d94995f7ac0975b29e1497bb7112dd..7175be7bf9fb4ad556fc17c8f5be39a5e49d21e0 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
index 8f295b309610c47506dd2657a17b80986d50c90e..6ad85033028892289e96ac583a36661821333254 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
index 1de10ea4183cfe7071b7f051eae2bf0e3bc9dde7..6af17f7c3efae87bb63444d992224ea1f2d753ee 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
index 0836b053eba3b00b786eb3d12d6a7acb23d2390c..269785fa7e7af218a0578acd92e1731cd290f498 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
index e09f777c458bee4de3c3b785a457f12d376f4c34..a3469972de96e28ff07b2ae529c8ff69fee0ac37 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
index d6d00b9ed62152d052daafd37a5fb75b4f95b558..d3064fd97f1b89927ec4077e5d531c7886be2274 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
index f97ec633713802ecb9c898493ca05579737acc93..5ae8d476201dc2d10e18bf80a38143c04048f837 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
index 172918f0eee56ae4721f5fffe95249200c7e1927..f7b3a5db8784a8e182cac2b2f1ac466a0fcea29d 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
index 7f56ad95ce1828658565591e4b04874c3cf83762..d36d2d27c69d587b7d8fbe00097f4e6f8e43a14f 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
index fd389ee1c13c61da7de940d160f9c63dbf8a9257..6a88b0b8eadd0d8aa0fb99dcb693f7d72fb1fa21 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
index c6faf10cab1aecc18adaf8f45e02b2c669e8ce8e..ec459f1bbfd97df317e25bbecb9350b9dbc1edb4 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
index 5e0e09c0a66c7381fc91d715ee568bd1bf02d8c8..6e606008d6151ad28f1e8f88f9ae2ed1af1780c4 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
index 58ea0ff12f3a53ced409fe61976354603614707f..086e1effe10ee6f0cf6661c56619b1b1b3cd8b69 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
index a25cfd77b983c5ba8466843996d2cb805a961240..882477486733f0ae615858081359be01a0412146 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
index 141577851039c0dad090bb1063836eb94c820799..e32f7504fe4424527b73bcdc40760bf01b3d8ad3 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
index a00be2024e3647cf68039bdd30cfc526e39376ec..d36a5c1be5ecd7aa23079ef48c63d175fa5ce13c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
index 14307309e3217d5845ea1e25c3a17bd8e19df56d..3389fed4fa8b30879f8f7e8f0abb7ed3774ef307 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
index 3dae23a8deadd34cb926215e663f06136ab92694..c68d3ed810a5f7cfc0b2627520d920898b67ef31 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
index 03e5627af35d1d15752e4b0c1c92d50ca84e7268..9fc1b47afda8f71ba3facf5bafb5fe769f040270 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
index 471fb8d35afea433474df873a206d3204ceed8f3..ed9ed4d63ebdff0240a062b353b44526112d0523 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
index 8b470b8bde9c8ea391b4a0ef2e3c67e7983dbe15..954f9eff6bda3cdff4aa102f54e5985c5bbd0a65 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
index cf5b0547d06173be10d0155417fe29eef0d0d5c6..46c19786fa0e450078f39d9fb5c5995872395d3d 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
index 5615571eee1df6101225cad76eb429e8a5eb811f..0fc871882ea0bac778a8a8da98eac649195dad1c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
index 64867a702fb2a59ef4a0e596ec660ac664e152f9..13739b99b22e43dae2fbb0e9d9281b83c48181e0 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
index 1cd83e48a0808816320e03599cc1f6c653d0d3cf..9dec2fe8b97cb7f1e46dda5bc1da4a3f27768782 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
index 7d701395a781f9a4a60819b5c2541f708bb367bd..334da5277f572ae1756ee22f1f72784b503cb640 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
index ccebb6ea8c5fc97fa1a7065c8807590b63b9fe8f..05b1921525a5d9ca0e230ececbc9877a02f1b50e 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
index afa9f26a9eae0a7715ee27e7756e61d0c314495c..0e57e83f858c0db273c3575b659dac141dee725e 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
index e17e861ef4c73193e297f3753c306de2d70e0157..89d7c4541465a094ddb58cb4b85e858233453fee 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
index f8c5254d2029cc7a95220a946d1df5043c4fafc3..12ad031ee6d64a77da1e5508411354f19cd91213 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
index bed26e31cca0ce7d4f5494355f4cf79b09240079..1b7286cdcd1ff4ac574a38929f47c25df6f586f7 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
index f65d06df9d2b90d161cfd55273c1a4a55fed175d..319755559317cbc81b5ec178c16cf0032d42983e 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
index e0ee1f83f0a7071318eabacbe7548d0dc0eb71a1..b5f1ddcc5714e56a2d83c571b1f9a89a02bda0ca 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
index 90f379b2fbae2a951fc20a292860e24eae023f29..bb490af704fcc8447700640c997709163cc79e15 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
index 5b01d5d0aa2feca7ad42c79a0bc00fa56e12f244..483d0ce3cfd9fdfecf410dad25db001577d2e48e 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
index 174d35f7d57b3873b0fa9493d2bb5382d9676bce..4f1ae60f42564bcfeb61c570f2f5aee4d52a3acf 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
index 89c9df9360f2141aa65030bcdabaf0c0c7c5fbeb..5420e3a4497fa44052a4d2b08f755ddaf76a57bd 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
index 153a6281798b23e46c5838d2576e75ba8a6b3a15..46269afc229e7758c0b3e2d1aa71cbbdf625ffe5 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
index 685174b367efe3c8d1144cbcf94e7d3c77ff2b88..425220e27f5b349ea77dcd50b07fac352cbaf8c4 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
index a4a3881a5779c09c32c42acef2ae0bfc08dce97c..6bc2ed733df8b4cf1ea8dc2c4dbbb611c4fe446a 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
index f51d133e7af3f58d01dd3eb533655f7e9c6cf825..91cc8c2af2825dec3c28b7f01b6da0a8faafd38b 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
index c3d5027a3815f8b84cb8f25bcfa1c7b905459108..46b97b313367867530a4b10dc9b98aff04889d9c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
index 0e091389ab8365e899c188c9913d7375468e8988..1c6c071e36aee1344fe828c355eee06b0fc051fc 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
index 6355e213aed613741c7d1fa7bbe896dd3745e4ea..adb9f1e947f8843a6d56183710f264b1a1b1f14c 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
index c187cd2e15dd7b313e50cba89689b15db77ada20..5c7fc991795344b3f9335a102970e092cecb28be 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
index b5a6879cec67898eaa0eddd410434003bea44f37..f8605287e2770b2fc85a0ea02b51e323894fbfa1 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, OpenMP, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, OpenMP, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
index 7ed95bb56f0f993a6a03548b57d7a1fa60068c02..b47b23c0df9ec03db106322e95547704fc095f80 100644
--- a/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/OpenMP/Kokkos_OpenMP_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  OpenMP,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,OpenMP,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,OpenMP,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, OpenMP,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, OpenMP, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
index 8a5896ac209f86196b322652abd804176b470fe3..936b24983f2e177571f144fd530c3e5111bd5d9d 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
index 50bf6e438037084d8bdf231d4213999747e65718..7d83d022795731846866c6c4b149733533a1c52b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
index f33bcdbe0856c896fbf9fb0bd84ad84f44cc4b3d..50b160c452d2365567a088831a1142e15bc040c5 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
index 715bb2bfc92ce0ac334ee4d62cacda1de0f1531f..fa4dccf30baaa5e6628df2626d2fd373004dbe3b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
index a914551a22fcd4c757774cc5cc6e9595b55c425d..5ed0812c35f5c8068fbf9f0d29c9498706d81782 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
index 86a4aa7cfbe294b12660a09f44b3e02f7aba02d4..9bc2faefe933f617f513796cf6d1155e0bb43e14 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
index 470d0b42d729dc779b0608eb886453eb811383b9..35a198cb26c0ad42684c8a66b93956cd4e56c268 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
index 9285c3104c249490e4a704de0b450441d6f544e8..a79082c7a646b82794f9a6c731d09c58e8cd3eeb 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
index 782a65728114b5681ec5d5c90370accff83f3ad7..e344f942471748991fa5595851acb46d3f2df5ef 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
index decb4dbc736c382ab977d542f2300eed36253576..92e4281baa6a0309f1b60729e83c797f312fb188 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
index c793f4d18176285fb1be6d5df31d4f70da385729..c25262075a5e3a0af746714494774560d4a00d83 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
index bbb00e33308c330d45afd4eb68c6f3b87cc40b86..c3ce63ccb07ff9e7756fb06adcb1b76f9724013a 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
index 0ae86042be499f1afc0e1f81c5a2ac27833abdee..443aaa1172c87b191335134dafa0a80ca007ee30 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
index 1a1b04196b31013cf3c8aee9672430b046e849e7..65d137d62bcc43a18ee793716339edbd0494afad 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
index e4a1e260d8878a52f0e58bcf95d2a0a165315df8..50c66d9315e71302348181adb7edc64fda1f526e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
index df0c797327b211706bdf21841800a56ec42ab674..78464445e9a3bf16e38a0921b28d01252616a8a3 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
index fa29e7ec749f17e759a797ecc5c466f2bc6ddb85..f1085851dde82d8a5200bc457bb39980e391f149 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
index 65b27694abf13ebd5ae967333038b38fe7a5219b..090e77d63b34612e5c358eaedbd6cbb890130204 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
index d0738d0429337fba52a231a78560018d1cb3cafa..b82e770ee61a208282e84bd7086ed401892c0c0d 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
index f958ac4ae5b402f6b2e9027c6d71c9cb66e6a86a..6fbd24842db474320158766c2d6f675dab645951 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
index e0d708226166d92b2b4e04d36863f7152e7786f3..a434fc069fe130fbc76520ebba81c9166b77afc0 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
index 893af9e9c76e1e4ceec592a96d8f2bb036e050b8..cf7972a445095463d4b97fddd3c6146c1bdafba8 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
index 23782b36393308f803a42318033f7631bafb213d..724fa978be72f5cd6836a3a132c41dc608d8d1c3 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
index da50bacf9379bafab73e600636328df0d3341dff..1910a2024fd3905172b98509ef4c7af74b67a923 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
index 392144d00ed3bc7ea3f79350eeeb79eb5189db41..9e5bf0fa3e8a855c54602ac627c5e9590c6204d7 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
index 5f6ec7c0438fd60f8a3f8cdae9825080efc84fc4..55b67d29992f62a452e0160f5c62facd5f0826ca 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
index e205b3e6f265f18d51d55a2f8c91c8c33a655278..1e7cfd254599b47911ff18e2fd9876416dff342b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
index b6ab570f41165341b3d987c4e0517ee806b52644..d374edbd4acec729f53118647af0c5c06fdbd3d2 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
index 8a850e859d26e3865b29f05fdb81ded35abbc3a8..7eb20ccaba464f2096c0e00c41a68045215cf015 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
index 6fbd0ff8b171eb80e90c55b5a537ac649e93eeff..cd13711178cc46c67da5c44c2d361154ddf26489 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
index c6911e3b7aa941fb4324fafa5b3d7bf5571fe721..f36b5353ac7635fd67d6b495d05b7e1ed29ad003 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
index 214c90b506cb3724a00c5efb34e94b5de56f2ca7..afeeae9b3f0c0053e9cd3deabd5de5a9cf360977 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
index f005e67a589da1ae98e0391f8c60014095445ba4..1786596001e69c8d9462a5cd54454292817a9e78 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
index e692bb0ad0830d1ca63626a443ae1ccc04b458c5..2db4dd794db9f728677e751c02c95e4e53b3d5c6 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
index 1dedd07a1199cf4253371a1065f541ad32325d9a..85ec8fc2d18490f25eb92ebbff145d3bae67c821 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
index 600f3fb1000248866c824e6b357fc87d818fc95c..7b9ef4eedba320df6b8ad9f47797fd392672a80f 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
index 3ee2707f0c68b0ec7e08446bd0f287f0f1ada22c..0e37d90d7bba3d0da3f8d11e792d8b289f12030e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
index d26d3453e9360b59cc784c50616ae001905c3313..aa484fcff038227c83d0f18c0e3e976b60831549 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
index 444eb7ffdd50e5edd84d7867febc3c4bdabd5079..94b5ba47079e6f26883553409dbb687226a60c72 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
index 2f0cc14dacaa97b52f82545aabedfc939386c7f8..f5f88d999ece7766e7f6381ac54b986c7c1abf89 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
index c36bbc590b213b5108bf2b710e9dcd5b5eeee4fc..056fccd673d6d226626c097af0a733f28af6fcdd 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
index 4156f83bf243821f440cddd8ecfac72d71b76911..00dfe959c55013a0f0916de63f5f5b73ffe7c4ce 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
index 401719d45971ddc9ec9d3a090d1f2ac18df5e86b..9d975b184c56b96c63f396d7c974d28e1098427e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
index 020fc44ad361445c73eb8c5ab84316227a65c026..c01f76e9e6222acad5de57d38e94273835b2b55f 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
index bfccbde750f1c52408453c79fbd8108c2fd211a9..5fc0e1cbac2974e4f47718f6e279dcdd08e43ab5 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
index 5f3db5be342c3d4b6c9d640c8571147fe5c793a5..2124318ad88909bee49c6724ce71d7b3ab722157 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
index 6ba3d3ff88193742ac8d14230bf6c56a89ee265d..1dc1ece2cb04962e313e37ec43ce3dad35a3fc7a 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
index 66e8a5650cc727dd7c0f62303cde9491998c871d..2b49fe1931b8d3e25b9e4aca8e29b5bde3121602 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
index d550c89414b4c972ff05fa270ba38b518ba3e7a7..3cc1154673023e29d84319a39b62b7811c7bdf08 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
index 0c39620a3a1f0431825be33847b9f1092e98f42b..56cb22173ef5519c5cc3142b95dd5df3cfba6b20 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
index 6a037cc2ba16c261c9f09513fb01515ee4543880..96b4198e073982b61faca13045e1d2b3ac27a200 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
index e921cec7ce1e3d17b6ecfd4825f20dedfc7fda86..3bf36b1c82a1cb7083ff8d0d5e055f7bf04aae94 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
index 1684bdc5a7592d6ccc49cc32c64ff8d5cded824f..689270a64b7900f3997acc33145f04f58bcce6ca 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
index ed99f40da32d1638c8374bf57eb02e9457548af8..995b4994254e4cbeb5f43eb3080ce9f5abf08198 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
index 4262cbfcd5c0874389b04212b389811f2505db8e..e6f2970a6487c6acbbca45ecdfe65389ef2f913b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Experimental::ROCm,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Experimental::ROCm,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
index 7251fc34a78a79ae9d754b488c94acca191eb454..c4602070ebcd89ff02807933baa790ed8495977f 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Experimental::ROCm,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
index 4c9c2f6e723df8dde293cd20ca4ab730b6a79d77..5a52ee9e869ca0b21207c8d45bbfdb35bb5cd6f9 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
index 6196fc961b9d62a0a7a14eccb9189399419918ac..9fe37b25772be36912d7876e460d670734bb6d05 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
index cc1c6d9ab74590edf248cc6110a12226c9c3f38f..81dd98a95f8e4f9d121a92ff4c188a6be21ef71e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
index 6788bc6bdc5d2d251d0c8c83effdad9cc08481f4..1f487edd27be5d4d315541fd288768b29226b846 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
index ddfea9363330682b6a5ad3ad732f9c73a971985e..0fe78ecbbb7c228cf7d96e56bfa487df156f5083 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Experimental::ROCm,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
index eda5c752baa4d50a1a37879ad5541a5a1db332ed..710bfc182a563c9fbdcd484ef51d83e4a3896998 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
index 67d6df013a94b34db4d4e54972623b0e1fb84bd5..8f4cf975c6dfac0cc40c85591701bff4be69c9b5 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
index 91e67320800d29ab31982021df137c2532182386..fcf444ca88bd377728aecc735c7f9b675f473448 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
index 544f73af825fb5c1e26a6893a93ce4067e9c0874..480c135297e2f9bebd1ce899c7464179f929fbf2 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
index fb79ffdf69ed339b0882cedcdd85f460dd10387e..f09cb89a32e0910c40d39a30a82191708de2db22 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
index 688402656f687410ebfd12018a64d0841b2ffc88..ef36faebd69f07539e0770b41505e6c6f0a5dba7 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
index ee1511bdc706c466e5f9aff5e5a91c2d9c195e91..3e351015058efd922ddfbe11367ca6f4afd62ea8 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
index b2fc38fad8dc55a41c4fa306ad105fadada32011..b12b8bc9fa27cb7cf8a7dc15a48bd50ee795bb23 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Experimental::ROCm, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
index a20ee7ef40cb1ddf372cc09c909495a90e876ac6..1e2e04276332f68e0232072ad70bd5c998c35da1 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
index 2833279865638e4e0634b04e1441076119758ff2..4539a4087148b3390d081ee38ede47806955ca4d 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
index 41c2c27fcab464cd4c5ead4f5fbbbb4e2f1fb035..5af78387da735242a000127e53a0ffc3c358cf1d 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Experimental::ROCm,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Experimental::ROCm,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Experimental::ROCm,
+                              int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
index 9fbb13c5e711cdb890f7e2685bedfdf4e2efc26c..96f54890544c5e2c9549c09df7dcc273bdfb85dc 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
index a1fa3e16367c0de3ec00308ee23b6689de85e02d..957741e776752872b28ed7fb07e1efe1e0f52f8b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
index 256772e9c475ea3ab6c6bc5156b0d371770ee245..d1c2254dac3a577e5846fd94fea1839eedc29220 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
index 0cdc69435e7fb4015f8be2cbd06fa83c6c8966b4..87b95b9434652d02315a2125066292db350c2fe1 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
index 32666461e792636e0e1d0f83c4ccf9264a02ccef..fba1027fc4edb559a68e5a3c768f093fba3833e1 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
index 1a98160dc9ff8c05a7def9aaa94a1aaebb108f0c..bbd762f1d434c98c3a6f33c4b92555e701e37785 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
index f27329f5b8980fd6acbc3ccabee04d01890b2d14..ad31e2c0307173824e42ee38b3c23053ddf04cc0 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
index ffbfd36a339f67259e05f4e1af0493fba7e782cd..bc14bbcee3968b4b5cb87b08ec70589ec814878a 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
index ef2d78d2cf67a248912dc03cd7495d7141c78f80..736781d696a9c1a3564ce569b278d266e540a087 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
index ac0fc982e695af6f591afb73564467013c3f9656..6b16fbe952b3c5f01ef1f511c18d1a129ccc5a9b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
index f35680c08021f7c9a4894673dfe193de0ed5aacf..95ce9c952132be9234205fd2ba313824437c2788 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
index 155e8a9e6626ea6b5b107691ed4b913385296cb8..34888c4e4a6a1bcb7666ed43738751ce6825987c 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
index 57000ac6d64d723825fd2c0de2f6f7ab98c494b4..eba5f4acd27dc398eb189e6942de5513a4e3748c 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
index fa5fd8daeffb8e81b6aaae4e97992b960e744e2a..bc3ed4dcab2bd2acc428e60220020ed5b65f5da9 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
index 4efaabefc1e4dcd38b7a54b551fd35868fb454ed..f7a669c8203ca5a23738f53c14d15a056387681b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
index 30447c85a676d0f9db99d606f85ffa4135c6f740..084a97323bf0bc0c97f33aa567873cc94f738385 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
index 06a0437b9388bf159df70fab97f4b0253136b254..d5e1538ca186a66d5e46358c37d65c424a2b7f87 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
index dd7e9c3b4528281b1b0b61bf9d6a8de3debcaef6..c2ffd740af7fc48eaa862cccb2ce8dca5d3246af 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
index 57f134c1de8818b1d11f01d644a2c3faa2958f65..c7560e2ebab25549c314dcce4e58e7c913d8c9b2 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
index 33fd5597b75d947d183da72f742c329b62e2a102..650e3684696af66ac0186b583e00fabd23a54160 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
index 8e48691d71736414cd88ca782e379b0d7323a9b3..19636e8bf7fe6a6fda4711a9cd4a4ca2244118a3 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
index 493b7e1f75a787d69f98c864ccadc25b35f26232..2d15ad10e8aff6178ffb6aea40d546e6cffedabb 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
index 1d2faee2e0a8dea706a43c96a0bd36006938fccb..477b8e44b7ceb6eb7b5cd9e5955d6ce3ee209eb7 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
index 3bbd3eab30d0ea7dff823a8d8a745cad43df98d8..6f4234e708223c44e6ca1d03244e1b274d68b10b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
index 66ce02ed67fc8a7ea23e974ed0b65520e31c98ae..4697b8285dba3771ee8faac64d712fb855045fe5 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
index f9ae820532b23b40956b3b8675ade75e7b767d8f..4e15f3651298c3bab039cfb795abd1cc2dfdbd3e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
index f203404c755e766d4b655242e1f5893808e89fe4..4336ff9ed323845372bf278e3c051212196b22a6 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
index 31ddaa6f192cf20eef2e5845ded3c4a17f43c1dc..a93494cb0cbc120e828bb41b59e4f244d414f81d 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
index d68baba448f5e297f9f6aeb044edae0b4c55dd52..0d4303e974f5dc49be5563cdd4c04803ac9bdc50 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
index bc82eba995daf5a573dc41b1baf40447926553f2..02b7f479f5ce929f2d2c844284a23c13d3079d4a 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
index 1016443c4e71783277a3e8a6bac50a2ab846efb4..8af29e6d0f01d742154f60a98c196cd02580651e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
index 86298d9db3ba794ba611db7f591ceeaaa87b0af6..49787220cbb1b61feb139055a8e698bf3268c82b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
index 0b47f24fe42bb8d882b9c18ff73acb6683f376c6..a48d561c936ef7aad2d63c534b9dd45274788018 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
index f67f0a0d819454423a790d19a57af7543cbdf2e0..f5414d25e7a54ade26342c86dff57095123c7452 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
index fc6fcaf4354a69f245ed51574b88b1efc5870b58..aa2e44a1c5d9b5931529be97d81e1e8caaad583f 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
index bd557a6b00cdde1b209affcc02e411c03774a84e..02401e5ec0cb78943bd6035e85dda43ccdb3eeef 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
index b33cb48352208337d06d037f319eb3ff13681cc2..dc48d2350ca7ecb46ce8ca603659eaf21dd9e4e0 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
index 2f908123a7140779735da198927d420b83c338c4..28be03b8a707a47d5db9fe7f4f860efcce7b90ad 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
index c9c27a59ac80d59d04e9eb2daa0a7dbac5606bab..2974698b454a6a40665c7e340d6aa00a8be6c1be 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
index 3c417e619c93e59e480c184f5e66c1eb47e8d5ee..bf9678b7d222e8b013e71262beae15a73f0e00c9 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
index 5350bbe8f3be200524db3c5ba672c2d6e04f6bd9..7df511d71d8e69631ee67856ea7b505c7efec765 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
index 557032a06cefd0ce4cac0ac697e5eca7d64b3273..8eec6cae19b96054afccd4b1b0d2e1442e74f2fc 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
index f5b651a543bbb9c3e1253f1cb888d679ab18f03d..5422bacac43fde98ff3c341b46c1d0c89601cd63 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
index f0595f3474bee45077bffbd0d8ab0b0bf561c391..dbb856b8dad93f0a191d26542771e75dc9d8de6d 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
index 8b5b3a5e591e29e141459e92fe1bc0db14c89817..3944a4671d5f2a41afe7288d3fb4d80c354df1cb 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
index e12687088d973ad9528fa10abd150f2e73da6fe8..5f490e1a8ebe1501d532bda0e10520ebb062e35e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
index 033675f5c98169de3a7a7deba4c5ba064bf90e39..5c2cf9d561bbbd6d6d60a5ba5f72a1bf4ffd6590 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
index 00f49c8bd749fd6e5340d906f44df61de506ccfa..6ca32499b13939162d787f42fb3041828977ede4 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
index 4fe878189738a83500e9e5dfbf6f82af8f252f5d..9c5d40e18a798ceff4b5d9e68e99c4e31f035e2a 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
index 2a19666c4a875a66c0e962cacf2d4cc6e06873cc..ae111b312b6ff1873925db53703c9a36d2edd26f 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
index 867152b2cbde1d79d8b56dcad9ab84adcd29ca7a..ce6c8a9fc68715ca28b1530e31a96ce039e239c6 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
index 52661d731b62bacdce285167a58f854382f441b2..d56e9e776eebd31471d1cb9a8ab7be01d8cdbd03 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
index c5484287f6ff96549f514d8d8a36859733941842..e1ab19f5ffe94746dd1d37765afac34428cad96f 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
index 20f399e9a84754c92e552cba1f34c02ed7b360ba..083cecc07491fef84b7d939ef81663ef2b943cb4 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
index 5528e87f97d3d4f58ba4fc94bdabecf2c124b3d8..b345f2ac436403be7b2c10a190574abcf0fedfd3 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Experimental::ROCm,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Experimental::ROCm,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
index f58f20e0d6712c125391770016670b645c2c1064..7370f284cf72f8b3528e4739fc0ef79eeb2b0a1e 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Experimental::ROCm,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
index 2d1e60f24a1225af2f5f2e48886ab6d75c003e3c..e6892ca01a6c721a0ae5b1c20a87cf295c427931 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
index 642fd8995ca515d162a224eacabb7fc532dc0c52..1560af198f013449e3c0283845b6968fe032098b 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
index 03b3f6be04d80e9cdec38e654e318affdf2be38a..a7322631a216a49b650068cb92808dd5cf79f7cf 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
index 5e4724862d5501c7101081de8d71dc1ea7eef929..2b5d8178c4ea89158ec3767340a455adf343328d 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
index b7d79ad994d900dbff1d1b42b993a44616ad58a8..ed476241ff9a2e41d9af656eb3725eef8c52a871 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Experimental::ROCm,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
index d30ff0b10b1655e9d8fa2ebd0a35ba6d0904a5ec..ee2b6739e0da570fc26f9fea0a2a1ba80a8cfa0a 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
index ce977b9808806a78f4c12687301bf5ce30a7975f..a8b7a8ef15072436d4e95f3eb435c64de1ad01e9 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
index 4efb0ce971a42eb872f6abce91cddb2cbcaec58f..e11f9b44333fe52e0e53bd5b6a4b47b167f59afd 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
index 7fb139f08e411bbceaf6ef80976af233ce745b36..0e17bc8c5d4c1db49d60ab392504afee5a99d0e6 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
index 6e3c1938901cea6577d50b9fc11f80a1ca818f29..a7c9b8585df405510095a03e0d6cae77e4ccb5e4 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
index 6eefc1232831f93142efbcd662d1181043a4a5e3..88c9569a9ff47b849110f0ad310ec63d4f291f21 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
index b5f8a83c116ad7a1c944544359848da5803eb6b1..62ec94f718da02a4b6331c8f42d7815c18b62d43 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
index ed38f742b37332c2075248af272e62284348e321..9f86f52008cae8d719f316da8e2c212f04a03c90 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
index c4cf30e7f1e3f6208799bd04c53803d55999dbb6..a0762ad58544a3502c3b04860fb39bc61d007b69 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
index a3b3a348b457e79ec6e2b50d687ee07913dbf261..a3ffd626446fc6f0d74352cc4b6e04960dcfd6a1 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Experimental::ROCm, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
index 7b2183206a3f5cbc103e0b4ef71f3e69bcbed8a2..fbd2fca225106d573b56652cc42e5b612f0c45a9 100644
--- a/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/ROCm/Kokkos_ROCm_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,22 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Experimental::ROCm,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Experimental::ROCm,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride,
+                              Experimental::ROCm, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Experimental::ROCm,
+                              int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
index 48be6a1ece161bad7726e439be989f80ced5396a..a749ec859b9c6c25fad8be7c7a11d77e4a18a338 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
index d383eb051c66aa4b53a63b570f69851711f44292..7a95f39755aad03f9d62334b5107141e9c0f5e8e 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
index db8b11aa398c8498f3bac6bcfcd66cba969982e2..961b788a857484220424f7f8d863b05fb9cc6c70 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
index 85bf1c9deb00c13c02afac6863a4a5b4e2acf81d..57dbaaf95ea34246002031f5e6c6e4c6a483767a 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
index 089141f203f3bae9b0be1528294b6919756b9ed1..33b0b87208e116c512659abc6e5abbc358a575b1 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
index 468798c322ba5ca6ac341432ad2cf427b53c26b9..6ec8b5f294588aae97a08039a9dc37bcd91c6e5e 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
index 311af3515f0425fe3a2d0987dbf1deaa68a16240..e4660ae4dcb487f91de78f8f22ba31a2d66c1662 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
index ccee72a4e989783bd309ef75b03d3c7b465202a8..d77fb3eb132c3baeafc3f3023269bd8f2bbc8820 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
index 671855bcc376ecada1651e36c699859c00b9473f..c7ae12e854dd904851ea6cc326135c242ed81524 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
index 3d4d81ff9beae7e92424fdfc8a175de7931b8a5f..7a6ad9b5789a7ff1cd5ea677a00fb77da6df44ec 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
index 7a6a9054b3b5a67bc64fec82ec65d0c9309dd5bf..bfe375c6b48f3eb6f56bbb04d0c7e3e449870d23 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
index c8adea2d8f32976c34c18f1389c5c8a49e226f55..11c0c4a8136e034132bd82eee62788d6fc2bd2e4 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
index 11d21a605aa84da52fbc9c2208a916157ad2399f..8a7323699542da1bcfec5f8177bfb3471fbecd6d 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
index 6675cf207b81e415964bb85d7dbd1326adc00e5c..e2c48e8bb0f66c5a842b91001125a47ceae96a56 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
index 11bdfac4650ec3ccf528493110ff77e5f0880632..b6a7f488d70ef9209535ff271cee6211c10a0d6c 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
index a8b9e7ee21759cf4e021ca2183d2b4371fa67637..2e3313b6eb0747883da39a550819653c992ac8c9 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
index 2b71fc5564b6faae24a5247780c1c606f651711a..dcb760fbf4e9526076b4e45e69f922445ad0e034 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
index 8e34fd89333c78ec9488bc346e403d765fea41f0..9bd7e80e7e8928a078fa1d47e72e2c56e2b01b4f 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
index 59dfeccbb03794a735050cdc1c3fc51f5139bb67..dedbd50d8ec45411ac488904f25d72c0b1e60e14 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
index 7a4fc05cf2b4cda74a0dcb65b38afdd38dcc6341..441d4774ccf1a15189129f4890b3a2173ad14818 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
index db50dc09fb5a36889ef225033f4f45e430e3bcbd..b9013da90a13c07481d5770fcf7f0d0e20fd0bc4 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
index 91c2257accd41b0c9c065fecde1a37a7455e62cd..0b19e47184fc7809160bbf938d9ba3f403a8112f 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
index 5281d949e5cf2c5b192484b7b4d3abe98dfabbe7..f901648517e06117f2019e24898dc1ac47006161 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
index 603e5750aee4acf1aa0c9724d1c2ea772d7b9e13..b8ad2e78bd56823aae20f1ec91b1994dd15b41dd 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
index c308bb6034e8faa864fc596d0cf2b40229c9c9b5..7bf4b7e77f59e59db2744790e9ff6343a8e5abe3 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
index 2b78dbe16c96824053b016dbeca98938ab7d34da..39e4d3bb6e9cff9de73a0ceb0b76c9f655e46cdf 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
index 46d6a678b9698e75d50e82abb861b0e82ac74745..4d845c8e1ae53502108513158bba6538cc78b5cb 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
index cf4bef6605b07a9b712391beba74016a54e8f20c..b0d8e00fefbb273996239a9fdf381ee8bb7d35aa 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
index 9f93cafc7d9960704d95697426549241a9ea7603..a8972610c96681847fe7de3a2ff5758c3a1d62c8 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
index db4e0f524c732a65631c2f1bde9bf5f08fe9edea..c0db2a928b81e474582dcf7af0478c796adeff52 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
index fcc42ef57d6c74c221ae4a63403460e839f29f2f..44ef5f0bab7fc8a1b0e4ab82b5eb39b19164ce08 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
index f244e89e646eba57fb6dc31914e7769a92689e89..39d0b58af35025ab877a2168d347351be2e2cb8b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
index c51bc06148e44b6a2091b3be4c9a4bf922220dd1..1d6eb2fd34da17cb3a5f3de12e58264b056bf5fd 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
index 7229abc2cf4ca8743c923c85f0196c300196b413..b38d19b999a57fcf33f65f59f1a188cb95dc2923 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
index 37a3a88093eec0f2565dc87ee72b4efaa895263e..360c6b4117dea82167074ae4e07d44dddc7b85d4 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
index ccc817812817709032e60f47b4868e3552bedbb7..f1f1dcde1743b5b16c83bfdcd6baeb283442eefb 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
index 9cb9cb57bbc29f889a1ed04dc99fc99a0d232197..6cfb563e75f7cce3791f1cf29dbb83d76ea6db6a 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
index 71b6798756dc10454c839f65faedad7879b0cd2b..abe7810be86ecc828f32e562c1bf996abff507cd 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
index b44dde3c81829e41efb700f1ffc5f31758d99cb3..1b6b81e8e420a2d14c6e1b00d3bee807b240b9fa 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
index 4e3db8ec6b4f41222cbc3a542340c7308e954612..7e50ce7cbce9ced6c486eb3facc14f4f64cc4b2b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
index c84d55bbe8b6886f21b3d91005c8ad0247bde232..ea944ba15f55eb8818e37327819fe448833db9fa 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
index 4f981d3d8323fd865109ee8356c5cf9495db08cc..d00dd6a3354bba7b92e79fa066d0854a0e33beb9 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
index 868d4fa57e7ae6c7230f5edc23f085649ae11cf4..b7cf7d7fce6b51e67cbb16fa5759a4ab42d230d3 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
index b3b00569bfbf950e87870f71cee73066de4ab89a..343dfc96581c097385b43548068dd1f0d1e042c7 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
index c1659f2268f9f9ff5c5e2c6b8ab2d79919e5e99a..44050f1421a7d5022558bc0acc14cc34d0aa8920 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
index 3a9004912aded8ba08c8480f40a81ca4e82a8624..4ab602bc3b6fe69c7992699e90f3e76f09c2f384 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
index 0686907b8a8469a58096872a3dacf65c584193dc..077314b85e4a0ef7e144c33a7d72810d47c5819c 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
index 14e22b030126cb666d047b56b63c6dd18482a630..009d5afcf64c336c74ee75a15656d723a7df2963 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
index 09996174e3458c1b047c3e70c0c117f1012eb024..24a1e61eb32560c2e7b9d3868adc1e3dfac36867 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
index 0c7d73712088b77e1330f6f547efa30a21d2fca5..bcf66fb1611fdf5ef98e5530206ef82e375c8e8b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
index 80ea3ba6f1d3b6283f5f9b1f25db706e327511c8..65c075948fcab8fc89946a3c5c19dfe45e53cfaa 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
index 5b14ba88d4401676bd570282cee0467d596a73bb..e301766022a1b81dd5e9760d8680ed5eb64cf19f 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
index f1d6b632ceba4760a0e9b6ba1583c2158f8c1675..4ccabe6b3de032b6b22713528cb17d84edfefa36 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
index 083227f7c9260ce8ef14fb62e10e93cd571e6fa7..161cf27c4998fda3b61e539ecb97b242e30e1cd8 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
index d510adaa25a9e829e3045502d463e27f4b9c1dfd..0a0bb54bfdc2e64008dccdcc35166b7a9b0bbe4e 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
index 04b878fb371ce900165359c68605e185a8d3274c..745e67b5bf7511605744305eac94580be61c2bf0 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
index 12c195cf08cedc88cfe2daca80805defe3e7d755..40a9d2fe0f193df7fd41a8c2b259446eb5a52555 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
index 819429dc1bfecae028daeb2cdaf8f9bf90331073..9436c1d9f7b73a3ce93a850139c6ffd6dffd2dae 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
index 564574ab8aa659480e9b3c13879a32cb76ab408a..a52db28973f3fffa2e32f56438bb1ba8037ddedb 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
index be5bca923d8d08ecb19f33873e89dc714a7ce766..66e8b8f332211b55601097345fa685b0a886fce7 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
index a9c1a02f60779dfaff7c14dc37a8596c83d67153..9a32d30e2a7133458a54235f1657452270c32673 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
index fa40d6810053e85d31c6cd22d86a7fb60d3174ba..1ec25b63b5975d992e4281925b2775f0d6783c62 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
index 8a5106c3ea97db9314d379ac57dfaec5143a3fff..0c96adece56623457276b9f9dc820c3d46b25d97 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
index 7953746d44f0bc435932b7b40a437543e058cd83..5771fcf55ee75b15c96f5a713b5010c8ab3dcfe7 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
index 543470776a97f3b9f0e8f695b199d30c0feb99f6..b0b918d782d4cfd3b2b66ac54ee5bf38734fc6ac 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
index 6c2fbd47af48d20caede92713f917b12473644ad..eae13261e9f892b7f5a4f28cc3f50b5a3bf2e505 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
index 5cc5b25cf3789783f7e50c0cf5c916462dbcbebc..7efc50d457a9d830cdb2d88aee28fbae35f42aac 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, Serial, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
index 3fd3c7b45144a48d02c01e1bd00bad17053e9651..f6b63e9896a91cc79da0936065ce9941add3e294 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
index efe8630ceabc3b438eef59a2fd677488450105a1..148ed99027a4843206c09026c310332b37d17602 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, Serial, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
index a933af7f517f07cc52d73f92e3456baca47d9de7..a9b1b6d4090ea25ff88401b82f9032d8faf46db5 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
index 0eec22f7af4445c8ab56b654dc20252c0b700475..30a20055a1d1b920a7cc92fd88c00d160fce74f9 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
index 9dcd492b5f47dfa204b301d1c653ab197fc21931..fa42ed37b1cd96b872ea681e938c9c685dcc2e2d 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Serial,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Serial,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Serial,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, Serial,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Serial, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
index b1f1e2c3b97e1eaae00d1d4e9976bb607118098f..07d809a290dddefd8def4c3ad4395af5c7cf1259 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
index a1504577bfd01e259ed333679bba744de30e6c7d..e03f4f796671f4b64e7cd7a2416676fbceb2a506 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
index 7fe1d49972c5316ff91abad2dce96a6031fde842..92deaa8a3ebeb4bea8a7fa32009aed96cb981297 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
index c0269b9c0b02a4809313991bf14a8ed286b5359b..ec97ca8c53352a62025955ca7559e41bae924c5e 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
index 2b03ff58097595985813e887c0c1e23f8c946e6b..2693928bd8e0f0c473531f8b3abd579d8eb813d3 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
index 360cb28f54f8e1bb18bcf6b41d2ebe471d49997d..968a40079835c0f956fecb9d5dfc4a406ea6c325 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
index 3eaacb197c2c30d7bb3b83e8b45eb6a429da9090..4d7b8bc7243d08edcd92941b8e4995a30d29dd6b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
index b06717d45c4c37c3886051557ce05beae5a1d100..7a97d75c1dbcf88e1390e0e1732058e325741d6c 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
index 2095454ee1905a7412695aff092ab7593d95c11d..25d9ee82b927b91e9048eccd4d85546c0cb3ff2b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
index 4261ed2af2c29f13dcadf7a54eef20d4daca9094..b830d1a0172025d916a3f0ed6bc6b97bd12f7af8 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
index 021576ae315dbc0446fc6237d322c43663d1ba00..40f690b782ea600f9b250fc921e8f757b38d431c 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
index cad50f737f5439d50d0e2d414777c104171db0ed..bf46af97d125ebc75ebca9003e82d2b986822099 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
index 011b1a3c71c9e0ad315b187983d04553648da154..8abd7cc80b36c58e08bd0c378ac2e0b603404d4b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
index 6c5d7b6c2fb7ac9d14c8944d5ee6a4d06e711362..e5472cda7af8f75b8c11197e333690fcf8e93605 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
index d51b22ad7ba76ea6963c218de4121f343fdc5267..a0c1b4efcdef3334c363339945fa1511c97ae66d 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
index 3a6431f581f72c95fdd660d48cdbb45cd8ee5184..a5998458122f74e070323815629d2f7aeb172349 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
index 5246dcd4e84a611600e9561d480d53bc39ac5700..b750ca88caf840dccc391a202e191559cc18cded 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
index f714207bb62c0b4bead076165f3a3725085bc464..c1223916b1e4cc2440cdfd36ac2933ad065e661f 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
index 31577672e86a96e20dc0c7369ec22be1194eacf7..453960b508771f63000200498e18c7078d383fab 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
index 33279ac418defbfb0e06ef6e6b4d6b71154f9b66..a1c599c76511cbc482c6280a8d111ea6efc9fc75 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
index 32adef28b41b649b2c6e6aee688af86efc89c6b1..a8f280cf232e0960ab1055a33f9099ed177a4386 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
index a9a6cf480dcb3b3ea3220c06ffc2d6e1281c0d28..e9a6a979c3bfc8b9c77bf434bfa8f78725f1b7eb 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
index cfe1971332d7a929d781d94a5ae9778714446d7e..0cbac14fb670d58441a1a1f207be6766b4473626 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
index 034ecff526191f81088042995dfa355453180e61..98e182506b9d5d78a213eeb61211272450eb1281 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
index a96199e6cda76d8323787f2b0e624f20eee77fa1..0afd110876ab93b9e6686f3d9148a95d8ee51a69 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
index 512404ab3f381c33f56947e60b5c98a33030f60b..14a80d9a948f017a540bda8cbdb35befb9de0310 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
index 9f51de587a60f4249de4ae245f9ba65aa337bfb1..76516c19270a534ed4fe1e8a42fe6da7b6fad123 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
index a2bb83cc72aecb0038eb9617c41cd4eca2c2f9a3..3769ea0aac8b0e22d3f7c9a45ef65abc310e9d07 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
index 11ccdfdb834ab13b6f98aafdec25019e533d91b4..106f1b9c67f5ef750a0c2f8082863326486f6cf0 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
index 719b07439b5a919efa5ee4f2662e800f0a384650..44a362d82c50510fa0f7968e350c97578c1d4315 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
index 345509e8249ad2e020c191ce0c9d3c384404e066..5184be60701597d7a923eee6cd4408a5f31eb42c 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
index 7cc933aa5e64bb4edd6dd4068c021efec8fe5a80..50117e94bf89b22c1a40ccee11ceb4ef9c7caced 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
index 2ced210d4862ad6ce0f11903efa6b6237cafa351..4ddc4a3e40356e0a3d2f7e89682de064780cf23f 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
index abec17254a24a7437c006f91afd063a8f472e7d3..cf48e0caab62c68a51cc7571d29e8140fdb672b5 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
index 4dc3b61c63c4dec3a4fb341be0f68d076ef93827..b1ab7b66675a697134487df604431c729c77b2de 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
index 9931e0fe77d4615a943815d201336e9d5a2ffb2e..02104cfa3711b439af7813822db2bdc9fd7aefaf 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
index 2e360102f9bd1f570f55491b462159e291f8671e..81eab82b0479f22cbf7825161da87f04aefe961b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
index 41404ee0cbfb5ba3f2200367f54fdcdb51f281e8..d5e45a194d210f40cc08f0320e1a2a5a6f4156ab 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
index e5d219d0409ae1d22dbceabcaf157c6e166599d9..7cc00391ac87a2ca803da038ef094bac54707d08 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
index a6d97c40acf9a5567639a376ce51818c87fa2d29..70df317f3e9c87a22a84f763a1745c8b78e9eca5 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
index 550e8fb66d416dae5a7b91dc2292951fffc9df75..4c6018db781c86941d06a27abf93dd18608edb7a 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
index d3453f3805a5a6cc40f1fbf4c2a1cdfa29770887..4d48bb32cccd42d66b49f6117dd9f58c7282b81a 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
index ea2bc082a92f466bd6916d41b959edf330a5c54c..61b6682ba6d45fbc657fef55ee1be7f035befce0 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
index 81421490386b3e221d34db4abce8eb43ad96b99d..dd80db3e20186c2d6a368620dc4be25e238b7a99 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
index 17eec4e038fb835b0050cae1dd70cf4f34b48a66..bec7b5d9526ed9c4b7e1b37c18966facb21907c2 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
index f36f3c05bef3f522ec8b60e60ff7cee6b68a3c2f..162915fb2b9ceec2b3b26d1e8f45677c14565e3f 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
index 5548438fdfe389b1142dab065f6d3265a1244fda..5fe93924d8b3d59b5fa1b38751697799db3f159d 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
index e869d49e5ea696d9ad6bb3f7e1df1cc59cae7c91..284b7c7c0304deba3c5a37117465b88012a1216c 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
index afc143012d93286dbdafef6cab33d3bc1268ad87..aea75154802466ab072b7368e5ca317817069e25 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
index d146b84f0c617c94a8456e9ec5d32a08e7350a21..310d949ebcc0b4ce824483f788fd328d1d036c0c 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
index 4d445cf4fb95bd179b299dfcf8e97be48146fb99..2caeee72ae080f29ad9e83d62ca842c83d41935b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
index ed0c3a277276695bc4046194bc0be730df0ab4bf..b914f59ed60a31446b5b01af7c812528ee7203a7 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
index 0ae90db1010d6c6e943d79895dbbe4bdaea999dd..601716c99b4bbba992180083af68c1e7eb97494b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
index 7d2a62d0903489a1dc78a5d68284d4dcb1633679..2c101a3552fc58f80497725d188ca2f534741585 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
index cca028b411f2c41ce90a9460351b6f0c22c6b112..b69c4263ed5a1b0e6dbcbe1356de3a8940ec80e9 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
index 2d1c9078de9c02c4ad2d839d38ffea06f44c6ead..ae58660227e2bb7554d5dd552bcc4fa99d7930b7 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
index 4366c3431c01d6157d7ae801ab5ea9f38acbb492..1c66b5844694e83ee62a483937aa6dede0291a4b 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
index 8fc8c53881074de0f542c6daa6e70c236b13d0ad..330dc037d089514e58b06e124259ad8a57e12d09 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
index 45cbc9c93bf5612411537620ffab5ecb361258ab..001a67f146b4542fbf1ecca099f68b2b4dd94e08 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
index 60875bb56084b75f4c1b3d5337ac64928e240d4f..247f5a311664875d93b13c26c285798848771058 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
index edd36851651bb572b9b645db252e8fdefb439ae0..3fffcddae5bcc833a528571d284cb759f57b2c1d 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
index 454443a32d46d32e27ea7604eed7d397e70bb9d7..0df3ae643a45d39e352579abbf587c233b9b942d 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
index eec967657b281c0bd3dd9a9cae355293db0e57c3..64440939ac03d215600740492cbc34afb0c28af3 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
index ad07902efd1b18e0c82ebee45f50b90d6e756a52..9e5ec83642194679e4dc50bf292f698aa6a19b89 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
index a9fa7d3bd71fbd7407ac8149bfb1e6a68a6c6c8c..f5731068c8269c64f5af5b0903f026cbec3309ae 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
index aba595865c7a4dc03caaf67746a5291e618083a3..4f04907c086b783881a084fc02443908d10e421a 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
index 030954cfd0f96808c6ebac7c8e4a80229ef473ca..b0b2b83a335aff683775b3079895522a3a63e878 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
index 58eb0f8f8e602f87767099026831a75dfcebd564..a10911f330dfa1dba8ad4cba6ea91089eff3621e 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
index db698ff0c452a832acb91bf184b3c591c28d5160..566f8e4f9b1218d82f6de98822604abc96492f7d 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
index 0a03729316e86c85646d2c8e8f327b71b7a98636..e299d3ab7a236c7566f6a65a822815817e0627f9 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
index 54fe3bbaeb9f3f39bb909f6c4410f2a15eceed6a..9a191bf546b1c009108adedbde2d567fac127ea4 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, Serial, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, Serial, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
index 188a6ae90e2e2d2c9b8a7d09f7ff11ecae8bad92..d07e1e8d74609e07f645431c01ddc48427e6fab9 100644
--- a/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Serial/Kokkos_Serial_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Serial,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Serial,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Serial,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, Serial,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, Serial,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Serial, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
index ea35f6e75ea69ba9072a9fd6d67e4a8c47cefcd4..7c84605ed9b3b2b6736052455c1a00a2957ee4f7 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
index 2c3352a4e406fcf053479743b53dbd2b620c6ec5..3d7313a54fa2f76157099fd004492d6b4a0b9dba 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
index 78a7dadbf102d483c3b6e90d681417833d794545..72895035bb344819fead22eb8e4686a22a9ccc29 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
index 26654052ac32440da9855367b0b62072a48351c5..69673d51e03ea4bc71789bd3915ff6b04f6ae925 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
index cc2bc74616c4a30905127386ee334d5b4122412d..d1aff7b82f370cd73f0616d1789ade928b3312d2 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
index 547352cbc512c3504b1c487a39bb07fc1a037c50..e617e19b44b29209c39ef971bcda447b63779b51 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
index c6db34afcac13c0416e5e39ddf5bd935132a8ae4..855e99e06b0a8ef9c6769068a8422967ea2b310b 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
index 7e0b8bc5b22bd7e3e678d791f6594757807554f5..b9ffb82a5d051462e15db8e6a73c2bda61a2939a 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
index 225d5f3c5d6a65dd2d7b829233e7fde87a8c4718..85a46839742478c775dd3a5ba6554f99a04b3d44 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
index 603c0035279628ade2ebf5fbcd1ba901d6e80ebd..ba658e7b718a9e57ccd37d6098ed634753de7cf5 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
index 47d1dad83fb32a957c6fabf93732e8739a69fee1..8d413bcb392296f77f8316375f7ceadfb34a2e4b 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
index 29ff44cc7ae7de2d4b7d4d3c38f3538cc329b69e..8a2a06649ffe1ff1477214871190c938d55bb674 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
index 19e55a498829297b86eac652230477e7cc5c0bcc..3a376b91a905c3adf82383de4e489692dafc0d98 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
index 14d96e05b2582940224adac3557763b7fd175d79..7a3ca29f43ed8b6a361bf54639a8d59ca3021a7d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
index 16964ca0de638f602f877d285f408603c06a5629..44bf3df6a60768d4f1d7e62a5541eed878207e64 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
index 76f7312e4277b1261ce419a7a2e58c435c97e4ff..943a00325f8a2025a200a9ea474a0fa4fde6f643 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
index 03e39ec11378c2aacb35243d1dd2d60164950bb1..b12da7c5b926b8c805faef65abdc57af29eec128 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
index f90114c841e58b577788b225f85245e104af47e1..a859379df6a923488513ab535c5cb6401908cdad 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
index 206ecb2030609cd875b209dc5fd1d695e29e1417..b11ec7758d8d00001e06cfa2d105b0711d7d9209 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
index 7f70db58c6cb97c36088fe1e72cb3a4cf50de65d..e7fee1b9e30cf7f815223353aab85510d0898b4e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
index 01b98c50ff959e20e971d53446ded68d41b89eff..f82b4a92bae841ba6f6f1e958775801962054ec1 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
index b57b537878b08865cf327cba599901b5139c3d27..3904c4cb03ca7a77e4743fc22f42a677066f5a91 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
index 058c517fa776c2322ac93c7f4608b751ee516553..77d46acfddda05b2223f5e00c7d0a8e6049ba874 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
index 5603583aee504eb12acb10e2a661dca2ef4e39bf..006fce3cfc7dbf9be8b1b44668344341b82d7bef 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
index 66b72374463534a1281362bedd080419c2ceb575..91256cd69ba3433b1175bb5aeeb02f02fd53cc41 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
index 998f8109afc1979a4646e7a58703f967eb4803a4..d29fbfe795ec7497797af8c967227586cddbb6a8 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
index 2b806028b92313e546fffa1b5494fb034f9434c5..bdf866f3baf050267fd942daecb042d3b386af0c 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
index ab2a92c19a7ede979830ca1eaacca5af5911760b..aaa00a6f6d88ce008a5f584bb57ec7e49abba8d7 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
index 15c1811331130b8c3dc599581e91dbae77ff3845..db2ab88d287f76b6b473e58a1834b743a84e2e8c 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
index e8caa6bf5ed34285636c0027afe89e9cba164651..3024e4e00469d260651e985af42d7247f92567c0 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
index 8d2652d31bf6f0273c69dbaad9877e93597d61c4..e6e66d7bb84f6f85e81ea66e367db3063c8c60b9 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
index 3f24c46337c2b814b7719a4331d0f53cc2655376..28ed80254fbf58930ff444b91075f8fa4ce6c52a 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
index 07abec16de8a0d58031c7c7da8dce226da4f2a73..4863866aa71a55855a09d77bb66b58cee912cf6f 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
index 868b86f4b38f5e70ee8f7aad7d9f10d110501963..e24e9e022a017962d4f09976d22357006c35457c 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
index 93fb522f9220da3136e25140cb45db1f42a6279e..047c078bce56e93a1cc5268d8b89354a73a7fb44 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
index 59e006df81c5b7bfe393f8a92dec07bf358d2b1a..78c7496b7cd76dfc10b28446ecdaa14a30adf377 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
index 461f88b5090347d3d7328ce89a82b9116dd6d612..33ee5008135c8013831549899a3bb96da03ce6d1 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
index 6f728921ed6721edfdae756f2618c3540f8141f4..4c1d4bb58c09f1fe18a5310ae78872ad1bbb23ad 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
index e80f24eba36e4efbbe34090812a99db1cd6a8163..75e4bc4e3e6123cf96d1dd1c11d5e7585526eed1 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
index 1d01f9654ab2379805876f3ebb2917d3d067f396..3007a4db6fe2e8b4cca46a7aa21ef66d62fb1aac 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
index d39754bb4d358bb0c60c1ef65623c17d09d62662..198e54631b53fcf027574950eb8cc3d47440ac90 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
index 8ac534d5fb26a8e8c0d8c71ccbebdb901a1d2f60..c12fa4e7bdd5e7e25f7e5993f9c841bfc28dd343 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
index 51ecca66313a5406d0c3ef5677a94c29fe420162..82f782ce575401071d9733137c922f95fc8177eb 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
index 04ff78c52f0d8359897af314e0e832f882ec61af..d11bf3dd27bd3059ee65fa2a63e0a1ae480e8d02 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
index 2ab12f26809ef61cebe33542d12ec97429305fbf..53bd8056d03d4cc856fe8f2b279d91352c524908 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
index 8a9c681d8e3a8813eb12dc685f492fb8b89ccca7..44e78041be4696375eb6885565cae184e325d4e7 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
index d70fcd3e7569f5d383f843d69a405b0c65755278..6f54702d24fca0ae6d263014081ec19d5d2a3b41 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
index ad26488045a504c1801c65d37c7241b40be60381..141b79110e43a6288f3e2a846a4df8e0720eedb2 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
index 737a43339eecdf9dc7ff0bcc7c5c4b67a36b666f..e23e6092eb91474f187568ea9af8536307dec3b1 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
index a3ca1138e6f3b428fdc4d669c116f44c3a0618ea..f5db8f744ed45bcdf6335d1709747afff526b6a0 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
index 2e7ffe0e82d8dd131a519e22cb2df56262cd432d..44ce223183001b754ecef781fd9a8ef72d8ffd25 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
index c42ef596062671d164da8ba02ee53a120dae98f9..55fca111839c4bcf4ffeca40cb4b4a84a5fee81e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
index 483475012671294a07a6a39715461e25232907c3..31b952913e0d982b61dc899246bdb139fbbb7228 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
index b5b40bb67c1bf107ecb08bf5903428cfdc060a32..887bfb4c094322817cf6d54061b2e319f35d1f80 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
index b3dddb6bd284877042ea28c2f1f94ba98d9e613a..71625e0d8178b3d5b96864cc0ebabed4d07b2887 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
index 722de5233968cbdf31d6dc6781ab2720c4b9fd4e..cd045703ff15330e18808b4fce493f425345d050 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
index b0871ddcce68e802912adc44b7f6d617dfabe57c..abbd0f8429f8b3749325c9d67e86800ea3aa1325 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
index 53aea25bded4412bf3380efb07490929133abcaa..5ac12d8648bd07d309bdb584f8770f6c234c979e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
index d64523e05d74bfde78ffbfa12afd600c2dd5c770..50ed4f48c381176751cbfcffcc76494a2ec29581 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
index 1017176577ae681717115f061db7269b92e12204..f83f5faa20f42822055c56e0a2bc6db99cfc58cd 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
index ff400f883b268f25b59db56da7a3e0611ff078ba..c99684ef901cc61e7c28430b07b6fdbaacf355d5 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, Threads, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
index 686cffe8025dfa1a1056fbd976902bc4f6dc5e50..c0c1bb9c813353852715e8ae67ca56c3d63fd349 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
index b352f9f52bfd911fc74a68c004b21f11850b890e..cfef96b18a1641e6f7a331d21ae33d68200c1337 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
index ea0da13ec70de2c00189a3ac5b5445faca124ff6..c16e1893522e19d629be0a1c3412a0ef99aeddad 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
index 5420b76cd9f664500af7e88d873c23463de8b5da..3b404d2411fa743a572ccd833afa0b437a78729b 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
index 04dc1694c9ec7fca27dbc6a1cb2a9b904de92caf..21148463c70aa3f2aa4befb97bde62800c5a54fb 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
index 40abc5c94a5f37b5a231ca7ba37ef9cedae3b8b1..8d5eed4f8e0233381c8626279c1fdc9419d06034 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
index 2394bae511cf1d06fdb5a137e23d9b57b7357eb8..7a590129d56d013ddfc8a11d035667572e3e9155 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, Threads, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
index 6e358f8aff176fea52816c25f095adf1bdedba9e..7ad5bfa4dcd12e2197696a07fb0d142b7ba8850e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
index 3546134132047ddc94956da495bee112e166a6c4..be7a7cb21cc667f687f9f425f20b8c5c95a5a81d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
index 89d8b2e029f49603b4f8f7f526deca2edd140a9f..df2d4b176776d03d1d17e65fa0b906720d414d7b 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
index d42c63b4354b7f8f688b51dcb5c8b7f3bf9c77a4..29b3cc8ee978e09128e97fb28f2eb3ae2d9ecaca 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int64_t_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Threads,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Threads,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Threads,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, Threads,
+                              int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Threads, int64_t)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
index 05b9f222c18a5c4d33f4d49446296f700e9d50d4..1bbc8c414c6bed2df5e75f8e6126d373302f16c7 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
index ab7415cb66efa0a7d29401732da9fcd32bef6533..e04cee2c2a26e34b4f81b3c5b1a72086f62f6998 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
index c95759513c4c81226e7fb05ee6a0e95095c6f8fd..0849086c3a7155852b8d9b37654a6e2fa043e45a 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
index 63c8ce607549dc5312c4f680effe3065395ec86a..6b50b7ca7db14d12bef8bfdb2b8d59d79a6295e7 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
index 95baeff94f221fda014e4b36b5f1cd67811c292f..a3592cabaca5e85e61d8d09c956067e1500713e6 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
index 741244a4dc726560fc7ee1e1d4e9bb7573435d45..ce16f2a705040f01ac48ed8c87b420bfba72353e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
index fb2cc8bfb36c69238aaa4b3a03b10a53ed581a69..29c6670a874ab164d060b63d3589ea4138212bc3 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
index 87e494b67803b7568f1dd7c2f5952af39a7c0105..aa343fcb8d83e4289021f9546258845d98a4ce3e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
index 5e8c405f4691f941f0d331d3c2aa4a3cb85e7a77..1043a55fd6a1f4ef53e9057efda70e76d6c1b835 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
index 48fb2ac5d00bd8e7f49a15c693560f0a56c8ba7b..9f2d095653c5e66e3e8ce19a9689ef8e8152ffbc 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
index 3c198408759bde717e70330a1020fda3701af72a..02b4d108743911dd4f003cee8e1fe38ca1f1e701 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
index 08d49b4dc0af35e857fa6b285878da0cc09736a4..c83fe0bfb9db2b5687bb2a9b4c00ab927ca9fd0a 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutRight, LayoutStride,
+                              Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
index 27fca5f6ea93bf870cf801a0660f4cf09da7f9db..d97cb633f90042be94a020bc1adceb7537cb93ce 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*, LayoutStride, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
index 6a0098358246b301f4b8aa7a09409da404c660e6..988dd30917faa18bf8bec0ad9cbd612df0e982ef 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double**,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double**, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double**, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
index 8a892efd740a5228f2db645b57c146768bd445f5..b537f31ec235997684f7a2ba90575e947d6fef7d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double***,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double***, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double***, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
index 0c8f2be52bad5a57b34efd52ce59e1402db1e414..4163489a3124e43f19a68e0f58cf70cc0159bce0 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double****, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
index ba31d9786439615ffacdb1431b4a1079922f77a1..e954a0b03725bd4220c7f91cdb490557e7459087 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double*****, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double*****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
index 3477c02d678efee114c9a50875970d3efa9577db..7f56eb8d210a926cf17829da2e5d8b3811eafdcc 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_double_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(double********,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutRight,
+                              Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(double********, LayoutStride, LayoutStride,
+                              Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(double********, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
index 947e6a174879be4fa504ea69563d93b0424d232c..be9a665fb960f761477c14c2cc137e376e239309 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
index f27415d3bb49d792335c0536abda793719bef180..c82e8d12a2855a7cc4fb17527df8c57038235f2f 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
index eafc108eb3ed78248387bb629b3f91f4f28d2ec3..0789ace2e2d63b5e3e36f0f353564600565d39ed 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
index 8b16ebaaa77df6cea11a3ffd8a241546441ebdfe..1b9f8a61597cbfc72cb90353492cdaf079777e41 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
index c3c9c6dd20b5755507866784f906cbf1a738dd9e..92ae8f9a98d7ef91d75ce76fe9a0f59edc658616 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
index e5b2f9ac9c097827fca706051781d7fbebae689a..1cf105fe536f0b9b75d7109314ff78ccb222a8ae 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
index 37fbf8c49df89917a8200a199e88fffd146d07ad..24dc52eef4c48a32ccd457aaedb2651c5e726489 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
index 287fa9b5b08afaced523e271c6297514d8e17908..7e66193302b4c31ed6f928d839b30c3bd4f32fd6 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
index 6741cd57ef8d5d3fc195d6927153b459bed0a551..c347f77004b5eb63fcf43b3b6f4853306a5e291e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
index e91e990dc3e90982cbbd6bfb77b606d3406f32de..607eeed51c9960d1b3e442102b8dfa24c2d072d5 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
index d8e3c15c08f8df310a2bf245053e3b6a7fe4f970..86ce1f81ad23db21d613741e11ee090e2718a734 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
index 8f66eca6a70a8d59752713f2b4e4fdbdf1ebae36..38edea565bc6a22dc6b7e84d14280e8eb299403d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
index c345677a04902df904c9498d65a7f23ec46d7f0e..c11ba480b61ec46087c5a9ee4a416f4685a1e868 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*, LayoutStride, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
index 2a0dbbe6399a6b81cc3544f8786245c27af86ca1..12973de44d561586e6e72e3bfb9065dadb2ef1e0 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float**,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float**, LayoutStride, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float**, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
index 67cafdc50e6ab7bdbf3285649152d2c2d25dbbd2..57f00f62bfe3d17ae63448e15ac2122950985f39 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float***,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float***, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float***, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
index 7f12f7d1ccadda4152d6891b4ac84176237016d3..5a73ab7e96625f0a0691171556bc3d00258b86d6 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float****, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
index 1ef8215ae32fb3bc8084cfa71349f65a9b2eaf8f..1b928f18f405d2df712ee7deea80f8a5196ce106 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float*****, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float*****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
index 45508096ff5d26255741951deb3eed688ea80b23..c3b3949d82bfc8b5611f7463761a9bfcd2520270 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_float_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(float********,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(float********, LayoutStride, LayoutStride,
+                              Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(float********, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
index 46d2ab76481fb891cc9801761d588f0487ba7b8f..c9736ad22a2ddf3bd68dccfc18aa068066553cc8 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
index 2312aedb36d59068e08fb624612feb6937ea5ab9..93d7a16c98ef3b280a913dfb8d8f59706a546327 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
index 41efbde987f3c05e6144bc8e33f5fc5ad8bd5807..ad9546fa6743a190882eb627a4f8ccf1a69c86c9 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
index 905c50ed1c20f2a23a1a55d89f4bcbcdec2a682e..a62946d97aeb2301da109df97ed548b30fdd3e8f 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
index a4a1f1498c21f64838689274eacf687f6f8fe2fd..20826a0378bdf4d646da3912e49691cf3a7275c5 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
index fe0851893a894995e625eb75ae378ecf1bec3588..9d629f9ff643059adde068d88ada9a1c66ad440e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutLeft, LayoutStride,
+                              Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
index 98ac56661270d0a8abcd013f63259d954f68c126..39a7dbef812e1d800e42c8dc045c82e8f2543c1e 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
index 1a105251c31e8af403dc7f5864d584ad413057be..33bb9f577cf6bbfb714ad14aa6f679b69337879d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
index 6d10eba0a965b15e107c8f6425d57ce6b12b7e68..1d052babb47013378213d347e6707281dd311026 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
index 89fa00d436a9151cd1f69df284fda64e501b5b70..6533f33f56ece8c3b72a1c610982d3038fcc1370 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
index 048d0da381d056ff63d0950f18dd006acf948dfb..a8b7a9615ca61b7fb434b99fd1a8e30569fd3c6b 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
index bb1f381b08444d975b0043c1c4d0f02bd9e88174..33517ed85c3e59b7ae1a4811a3e4ed7a2d5d93cc 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutRight,
+                              Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutRight, LayoutStride,
+                              Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
index ce59eef8e270dbe9a28b1df8eb22a46f34b419c1..2bd62e5607f81c2a391ecfa941bc6bac437184a0 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
index ad0179a0e1ac88024bc7eb7bae34dccb9afffbf3..fd1bb8862fd2035706be5e1eed27d85f1e32ded6 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t**, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t**, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
index 6980bc56eb20fdcc7102d438fbf5c247ab9b6932..33a23913e6b19862664f8688ac8294b67f577fce 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t***, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t***, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
index 44b6c378a9448342f5e0f1ae21c1c5303f70015f..1bcab4c1305524165b10b520b10faf8cace116ed 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t****, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
index 0f4c948dd87f1ce84fa5cb1a672457179a09047a..0a8d0676d48ce110f448b99517e6dced2f224e8d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t*****, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t*****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
index 2686b35addbc56ac4642bbe7bff825884c74c9c6..47ccf94a8a04b4a8b7f8a39ec9c70219392ea92b 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int64_t_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutRight,
+                              Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutLeft,
+                              Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int64_t********, LayoutStride, LayoutStride,
+                              Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int64_t********, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
index c65e732fc3f7fa941d76ced7b9d8f1cf55a8543a..acc4187d91f08cb37ab254226382ee206f2f6cf8 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
index d7a0dc0eedbdcca3959be84d80ed5cc9bc11bbd7..01a0fd28e4da10dc3a41aa0d71627c27662a70d6 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
index 1266e8e0202c9888c77bb5fc17d963ffd43ee52a..b31813ca3dfd5dc61ab705b8107931782a6b058b 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
index 383ad88cff45058e8b3f4f520de65d83c2e6616d..bf52b9f938f564d0850572e2e8a18ff3ba1ac79d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
index 48c2223334324945fe1e07e9821c546615f16cb9..61e5dc06a641d730ed7693d1a813c360c7e68c44 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutLeft, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
index a508aba68f18a61738f5d2ae0a313901273586d7..cb6906991ed958e75ca191374b141bf6d9f5c874 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutLeft_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,20 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutLeft,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutLeft,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutLeft, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutLeft, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
index 56d57e61da4994e076c66bee12bd0456129a04ab..b3afb8f5a4014fd39054dd553e27a96c7be4baa7 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
index 88b5d5585c305ad0d6ae0a35e79c9d05512198d5..f742ae330b0933888e8c5dd99b487570ce2bfc26 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
index b5c9dd119f96d737de2676c31c1e8cc43e8aba90..44b77241865966567bdb1cf8473eae6e6e0eafd8 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
index 19c92e1c164319b7cecb9a8fedd3a85af84bd6ae..2a08a72d8af813d66b075c9ad83a56d7d8741d43 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
index 84cc37d2688dcebf6b47075812d3a26beae4b407..5e9bd50d162b461120a8c8fa844aca566b51055d 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutRight, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
index ec08b187621100f22fce0afe0a0edb0aa3aa2cd2..9d3ebb948af7a7c48e721cd6a810b72e538b66b6 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutRight_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutRight,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutRight,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutRight, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutRight, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
index cf77e86f648aa5e7e3c6687f385ab46118b8f4ad..f77e685c77908706fe6905a5de9f1c26f5a32006 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank1.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*, LayoutStride, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
index 4fd37b5577bf75c2ae08995829e0291631578479..57ae0a1fd5a112db7da97ea7f76dcc42f187e204 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank2.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int**,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int**, LayoutStride, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int**, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
index c30658ad764bbc6d9906828bdd5ab1ea3307ae34..d86407b2c686aab362def8a3d88147a251cdeba5 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank3.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int***,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int***, LayoutStride, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int***, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
index b0b644770f7a22d7d1bf251236f0e5464f21f9f1..0abf26b47804406c5363843112bbfd910cac5826 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank4.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int****, LayoutStride, LayoutStride, Threads, int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
index 0a16c7a1283266b558f3905c2c7d0288692e9ddc..6e8cd9f288a3e8b524c3fccb906cb69c36a306f1 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank5.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,19 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutRight, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutLeft, Threads, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int*****, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int*****, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
index e4fe9e96527a310792dc98cbeff1ac90c4c23497..ff91ded36f604481aed613465278094ffb01a1cf 100644
--- a/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
+++ b/lib/kokkos/core/src/eti/Threads/Kokkos_Threads_ViewCopyETIInst_int_int_LayoutStride_Rank8.cpp
@@ -1,14 +1,15 @@
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Kokkos is licensed under 3-clause BSD terms of use:
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -37,18 +38,21 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 
 #define KOKKOS_IMPL_COMPILING_LIBRARY true
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutRight, Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutLeft,  Threads,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********,LayoutStride,LayoutStride,Threads,int)
-KOKKOS_IMPL_VIEWFILL_ETI_INST(int********,LayoutStride,Threads,int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutRight, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutLeft, Threads,
+                              int)
+KOKKOS_IMPL_VIEWCOPY_ETI_INST(int********, LayoutStride, LayoutStride, Threads,
+                              int)
+KOKKOS_IMPL_VIEWFILL_ETI_INST(int********, LayoutStride, Threads, int)
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp b/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp
index 60f1968e6e40eb921756846643b519c7a5f94f18..6196dbf35591c08d6f48ba3be14c82d50a0908e3 100644
--- a/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp
+++ b/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIAvail_Macros.hpp
@@ -1,576 +1,1440 @@
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********,LayoutLeft, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********,LayoutStride, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(int64_t********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(int64_t********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(float********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(float********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutLeft, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutLeft, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutLeft, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutRight, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutRight, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutRight, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double**, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double**, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double***, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double***, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double*****, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double*****, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutStride, LayoutRight,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutStride, LayoutLeft,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(double********, LayoutStride, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(double********, LayoutStride,
+                               KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,
+                               int64_t)
diff --git a/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp b/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp
index 6bf5a77204c3d9dfa78d3348aebea07bad05d296..98d9791eebb55dc6d9864a564099c0d61c1b6b59 100644
--- a/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp
+++ b/lib/kokkos/core/src/eti/common/Kokkos_ViewFillCopyETIDecl_Macros.hpp
@@ -1,576 +1,1152 @@
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutLeft,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutLeft,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutLeft,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********,LayoutLeft,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutRight,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutRight,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutRight,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********,LayoutRight,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutStride,LayoutRight, KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutStride,LayoutLeft,  KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********,LayoutStride,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
-KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********,LayoutStride,KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE,int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(int64_t********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(int64_t********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(float********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(float********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutLeft, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutLeft, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutLeft, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutRight, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutRight, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutRight, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double**, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double**, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double***, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double***, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double*****, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double*****, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutStride, LayoutRight,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutStride, LayoutLeft,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWCOPY_ETI_DECL(double********, LayoutStride, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
+KOKKOS_IMPL_VIEWFILL_ETI_DECL(double********, LayoutStride,
+                              KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL_EXECSPACE, int64_t)
diff --git a/lib/kokkos/core/src/impl/CMakeLists.txt b/lib/kokkos/core/src/impl/CMakeLists.txt
index c543194de3993015f6940506c0ff51da157f2084..2f6d8e78a3c0e7e283fd7473a0872ea46b5126bf 100644
--- a/lib/kokkos/core/src/impl/CMakeLists.txt
+++ b/lib/kokkos/core/src/impl/CMakeLists.txt
@@ -1,18 +1,18 @@
-
-SET(HEADERS "")
-SET(SOURCES "")
-
-FILE(GLOB HEADERS *.hpp)
-FILE(GLOB SOURCES *.cpp)
-
-TRIBITS_ADD_LIBRARY(
-    kokkoscore_impl
-    NOINSTALLHEADERS ${HEADERS}
-    SOURCES ${SOURCES}
-    DEPLIBS 
-    )
-
-SET(TRILINOS_INCDIR ${CMAKE_INSTALL_PREFIX}/${${PROJECT_NAME}_INSTALL_INCLUDE_DIR})
-
-INSTALL(FILES ${HEADERS} DESTINATION ${TRILINOS_INCDIR}/impl/)
-
+
+SET(HEADERS "")
+SET(SOURCES "")
+
+FILE(GLOB HEADERS *.hpp)
+FILE(GLOB SOURCES *.cpp)
+
+TRIBITS_ADD_LIBRARY(
+    kokkoscore_impl
+    NOINSTALLHEADERS ${HEADERS}
+    SOURCES ${SOURCES}
+    DEPLIBS 
+    )
+
+SET(TRILINOS_INCDIR ${CMAKE_INSTALL_PREFIX}/${${PROJECT_NAME}_INSTALL_INCLUDE_DIR})
+
+INSTALL(FILES ${HEADERS} DESTINATION ${TRILINOS_INCDIR}/impl/)
+
diff --git a/lib/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp b/lib/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp
index f67d378572ff1ff0bb6895d032917e650dc0cb57..09ed79a5fd7f6d7e35d8a0419b53cf47a55cec04 100644
--- a/lib/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp
+++ b/lib/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,91 +46,83 @@
 #define KOKKOS_HOST_EXP_ITERATE_TILE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && defined(KOKKOS_ENABLE_PRAGMA_IVDEP) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP) && !defined(__CUDA_ARCH__)
 #define KOKKOS_MDRANGE_IVDEP
 #endif
 
 #ifdef KOKKOS_MDRANGE_IVDEP
- #define KOKKOS_ENABLE_IVDEP_MDRANGE _Pragma("ivdep")
+#define KOKKOS_ENABLE_IVDEP_MDRANGE _Pragma("ivdep")
 #else
- #define KOKKOS_ENABLE_IVDEP_MDRANGE
+#define KOKKOS_ENABLE_IVDEP_MDRANGE
 #endif
 
 #include <iostream>
 #include <algorithm>
 #include <cstdio>
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 // Temporary, for testing new loop macros
 #define KOKKOS_ENABLE_NEW_LOOP_MACROS 1
 
-
-#define LOOP_1L(type, tile) \
+#define LOOP_1L(type, tile)   \
   KOKKOS_ENABLE_IVDEP_MDRANGE \
-  for( type i0=0; i0<static_cast<type>(tile[0]); ++i0)
+  for (type i0 = 0; i0 < static_cast<type>(tile[0]); ++i0)
 
 #define LOOP_2L(type, tile) \
-  for( type i1=0; i1<static_cast<type>(tile[1]); ++i1) \
-  LOOP_1L(type, tile)
+  for (type i1 = 0; i1 < static_cast<type>(tile[1]); ++i1) LOOP_1L(type, tile)
 
 #define LOOP_3L(type, tile) \
-  for( type i2=0; i2<static_cast<type>(tile[2]); ++i2) \
-  LOOP_2L(type, tile)
+  for (type i2 = 0; i2 < static_cast<type>(tile[2]); ++i2) LOOP_2L(type, tile)
 
 #define LOOP_4L(type, tile) \
-  for( type i3=0; i3<static_cast<type>(tile[3]); ++i3) \
-  LOOP_3L(type, tile)
+  for (type i3 = 0; i3 < static_cast<type>(tile[3]); ++i3) LOOP_3L(type, tile)
 
 #define LOOP_5L(type, tile) \
-  for( type i4=0; i4<static_cast<type>(tile[4]); ++i4) \
-  LOOP_4L(type, tile)
+  for (type i4 = 0; i4 < static_cast<type>(tile[4]); ++i4) LOOP_4L(type, tile)
 
 #define LOOP_6L(type, tile) \
-  for( type i5=0; i5<static_cast<type>(tile[5]); ++i5) \
-  LOOP_5L(type, tile)
+  for (type i5 = 0; i5 < static_cast<type>(tile[5]); ++i5) LOOP_5L(type, tile)
 
 #define LOOP_7L(type, tile) \
-  for( type i6=0; i6<static_cast<type>(tile[6]); ++i6) \
-  LOOP_6L(type, tile)
+  for (type i6 = 0; i6 < static_cast<type>(tile[6]); ++i6) LOOP_6L(type, tile)
 
 #define LOOP_8L(type, tile) \
-  for( type i7=0; i7<static_cast<type>(tile[7]); ++i7) \
-  LOOP_7L(type, tile)
-
+  for (type i7 = 0; i7 < static_cast<type>(tile[7]); ++i7) LOOP_7L(type, tile)
 
-#define LOOP_1R(type, tile) \
+#define LOOP_1R(type, tile)   \
   KOKKOS_ENABLE_IVDEP_MDRANGE \
-  for ( type i0=0; i0<static_cast<type>(tile[0]); ++i0 )
+  for (type i0 = 0; i0 < static_cast<type>(tile[0]); ++i0)
 
 #define LOOP_2R(type, tile) \
-  LOOP_1R(type, tile) \
-  for ( type i1=0; i1<static_cast<type>(tile[1]); ++i1 )
+  LOOP_1R(type, tile)       \
+  for (type i1 = 0; i1 < static_cast<type>(tile[1]); ++i1)
 
 #define LOOP_3R(type, tile) \
-  LOOP_2R(type, tile) \
-  for ( type i2=0; i2<static_cast<type>(tile[2]); ++i2 )
+  LOOP_2R(type, tile)       \
+  for (type i2 = 0; i2 < static_cast<type>(tile[2]); ++i2)
 
 #define LOOP_4R(type, tile) \
-  LOOP_3R(type, tile) \
-  for ( type i3=0; i3<static_cast<type>(tile[3]); ++i3 )
+  LOOP_3R(type, tile)       \
+  for (type i3 = 0; i3 < static_cast<type>(tile[3]); ++i3)
 
 #define LOOP_5R(type, tile) \
-  LOOP_4R(type, tile) \
-  for ( type i4=0; i4<static_cast<type>(tile[4]); ++i4 )
+  LOOP_4R(type, tile)       \
+  for (type i4 = 0; i4 < static_cast<type>(tile[4]); ++i4)
 
 #define LOOP_6R(type, tile) \
-  LOOP_5R(type, tile) \
-  for ( type i5=0; i5<static_cast<type>(tile[5]); ++i5 )
+  LOOP_5R(type, tile)       \
+  for (type i5 = 0; i5 < static_cast<type>(tile[5]); ++i5)
 
 #define LOOP_7R(type, tile) \
-  LOOP_6R(type, tile) \
-  for ( type i6=0; i6<static_cast<type>(tile[6]); ++i6 )
+  LOOP_6R(type, tile)       \
+  for (type i6 = 0; i6 < static_cast<type>(tile[6]); ++i6)
 
 #define LOOP_8R(type, tile) \
-  LOOP_7R(type, tile) \
-  for ( type i7=0; i7<static_cast<type>(tile[7]); ++i7 )
-
+  LOOP_7R(type, tile)       \
+  for (type i7 = 0; i7 < static_cast<type>(tile[7]); ++i7)
 
 #define LOOP_ARGS_1 i0 + m_offset[0]
 #define LOOP_ARGS_2 LOOP_ARGS_1, i1 + m_offset[1]
@@ -140,2609 +133,2664 @@ namespace Kokkos { namespace Impl {
 #define LOOP_ARGS_7 LOOP_ARGS_6, i6 + m_offset[6]
 #define LOOP_ARGS_8 LOOP_ARGS_7, i7 + m_offset[7]
 
-
 // New Loop Macros...
 // parallel_for, non-tagged
-#define APPLY( func, ... ) \
-  func( __VA_ARGS__ );
+#define APPLY(func, ...) func(__VA_ARGS__);
 
 // LayoutRight
 // d = 0 to start
-#define LOOP_R_1( func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY( func, __VA_ARGS__, i0 + m_offset[d] )              \
+#define LOOP_R_1(func, type, m_offset, extent, d, ...)               \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
+    APPLY(func, __VA_ARGS__, i0 + m_offset[d])                       \
   }
 
-#define LOOP_R_2( func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    LOOP_R_1( func, type, m_offset, extent, d+1 , __VA_ARGS__, i1 + m_offset[d] ) \
+#define LOOP_R_2(func, type, m_offset, extent, d, ...)               \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) { \
+    LOOP_R_1(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
+             i1 + m_offset[d])                                       \
   }
 
-#define LOOP_R_3( func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    LOOP_R_2( func, type, m_offset, extent, d+1 , __VA_ARGS__, i2 + m_offset[d] ) \
+#define LOOP_R_3(func, type, m_offset, extent, d, ...)               \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) { \
+    LOOP_R_2(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
+             i2 + m_offset[d])                                       \
   }
 
-#define LOOP_R_4( func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    LOOP_R_3( func, type, m_offset, extent, d+1 , __VA_ARGS__, i3 + m_offset[d] ) \
+#define LOOP_R_4(func, type, m_offset, extent, d, ...)               \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) { \
+    LOOP_R_3(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
+             i3 + m_offset[d])                                       \
   }
 
-#define LOOP_R_5( func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    LOOP_R_4( func, type, m_offset, extent, d+1 , __VA_ARGS__, i4 + m_offset[d] ) \
+#define LOOP_R_5(func, type, m_offset, extent, d, ...)               \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) { \
+    LOOP_R_4(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
+             i4 + m_offset[d])                                       \
   }
 
-#define LOOP_R_6( func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    LOOP_R_5( func, type, m_offset, extent, d+1 , __VA_ARGS__, i5 + m_offset[d] ) \
+#define LOOP_R_6(func, type, m_offset, extent, d, ...)               \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) { \
+    LOOP_R_5(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
+             i5 + m_offset[d])                                       \
   }
 
-#define LOOP_R_7( func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    LOOP_R_6( func, type, m_offset, extent, d+1 , __VA_ARGS__, i6 + m_offset[d] ) \
+#define LOOP_R_7(func, type, m_offset, extent, d, ...)               \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) { \
+    LOOP_R_6(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
+             i6 + m_offset[d])                                       \
   }
 
-#define LOOP_R_8( func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    LOOP_R_7( func, type, m_offset, extent, d+1 , __VA_ARGS__, i7 + m_offset[d] ) \
+#define LOOP_R_8(func, type, m_offset, extent, d, ...)               \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) { \
+    LOOP_R_7(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
+             i7 + m_offset[d])                                       \
   }
 
-//LayoutLeft
+// LayoutLeft
 // d = rank-1 to start
-#define LOOP_L_1( func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY( func, i0 + m_offset[d] , __VA_ARGS__ )              \
+#define LOOP_L_1(func, type, m_offset, extent, d, ...)               \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
+    APPLY(func, i0 + m_offset[d], __VA_ARGS__)                       \
   }
 
-#define LOOP_L_2( func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    LOOP_L_1( func, type, m_offset, extent, d-1, i1 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_2(func, type, m_offset, extent, d, ...)               \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) { \
+    LOOP_L_1(func, type, m_offset, extent, d - 1, i1 + m_offset[d],  \
+             __VA_ARGS__)                                            \
   }
 
-#define LOOP_L_3( func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    LOOP_L_2( func, type, m_offset, extent, d-1, i2 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_3(func, type, m_offset, extent, d, ...)               \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) { \
+    LOOP_L_2(func, type, m_offset, extent, d - 1, i2 + m_offset[d],  \
+             __VA_ARGS__)                                            \
   }
 
-#define LOOP_L_4( func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    LOOP_L_3( func, type, m_offset, extent, d-1, i3 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_4(func, type, m_offset, extent, d, ...)               \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) { \
+    LOOP_L_3(func, type, m_offset, extent, d - 1, i3 + m_offset[d],  \
+             __VA_ARGS__)                                            \
   }
 
-#define LOOP_L_5( func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    LOOP_L_4( func, type, m_offset, extent, d-1, i4 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_5(func, type, m_offset, extent, d, ...)               \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) { \
+    LOOP_L_4(func, type, m_offset, extent, d - 1, i4 + m_offset[d],  \
+             __VA_ARGS__)                                            \
   }
 
-#define LOOP_L_6( func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    LOOP_L_5( func, type, m_offset, extent, d-1, i5 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_6(func, type, m_offset, extent, d, ...)               \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) { \
+    LOOP_L_5(func, type, m_offset, extent, d - 1, i5 + m_offset[d],  \
+             __VA_ARGS__)                                            \
   }
 
-#define LOOP_L_7( func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    LOOP_L_6( func, type, m_offset, extent, d-1, i6 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_7(func, type, m_offset, extent, d, ...)               \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) { \
+    LOOP_L_6(func, type, m_offset, extent, d - 1, i6 + m_offset[d],  \
+             __VA_ARGS__)                                            \
   }
 
-#define LOOP_L_8( func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    LOOP_L_7( func, type, m_offset, extent, d-1, i7 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_8(func, type, m_offset, extent, d, ...)               \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) { \
+    LOOP_L_7(func, type, m_offset, extent, d - 1, i7 + m_offset[d],  \
+             __VA_ARGS__)                                            \
   }
 
 // Left vs Right
 // TODO: rank not necessary to pass through, can hardcode the values
-#define LOOP_LAYOUT_1( func, type, is_left, m_offset, extent, rank )  \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) { \
-    APPLY( func, i0 + m_offset[0] )              \
-  }
-
-#define LOOP_LAYOUT_2( func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[rank-1]); ++i1) {   \
-      LOOP_L_1( func, type, m_offset, extent, rank-2, i1 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) { \
-      LOOP_R_1( func, type, m_offset, extent, 1 , i1 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_3( func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[rank-1]); ++i2) {   \
-      LOOP_L_2( func, type, m_offset, extent, rank-2, i2 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) { \
-      LOOP_R_2( func, type, m_offset, extent, 1 , i2 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_4( func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[rank-1]); ++i3) {   \
-      LOOP_L_3( func, type, m_offset, extent, rank-2, i3 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) { \
-      LOOP_R_3( func, type, m_offset, extent, 1 , i3 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_5( func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[rank-1]); ++i4) {   \
-      LOOP_L_4( func, type, m_offset, extent, rank-2, i4 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) { \
-      LOOP_R_4( func, type, m_offset, extent, 1 , i4 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_6( func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[rank-1]); ++i5) {   \
-      LOOP_L_5( func, type, m_offset, extent, rank-2, i5 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) { \
-      LOOP_R_5( func, type, m_offset, extent, 1 , i5 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_7( func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[rank-1]); ++i6) {   \
-      LOOP_L_6( func, type, m_offset, extent, rank-2, i6 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) { \
-      LOOP_R_6( func, type, m_offset, extent, 1 , i6 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_8( func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[rank-1]); ++i7) {   \
-      LOOP_L_7( func, type, m_offset, extent, rank-2, i7 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) { \
-      LOOP_R_7( func, type, m_offset, extent, 1 , i7 + m_offset[0] )   \
-    } \
+#define LOOP_LAYOUT_1(func, type, is_left, m_offset, extent, rank)   \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) { \
+    APPLY(func, i0 + m_offset[0])                                    \
+  }
+
+#define LOOP_LAYOUT_2(func, type, is_left, m_offset, extent, rank)            \
+  if (is_left) {                                                              \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) { \
+      LOOP_L_1(func, type, m_offset, extent, rank - 2,                        \
+               i1 + m_offset[rank - 1])                                       \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {        \
+      LOOP_R_1(func, type, m_offset, extent, 1, i1 + m_offset[0])             \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_3(func, type, is_left, m_offset, extent, rank)            \
+  if (is_left) {                                                              \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) { \
+      LOOP_L_2(func, type, m_offset, extent, rank - 2,                        \
+               i2 + m_offset[rank - 1])                                       \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {        \
+      LOOP_R_2(func, type, m_offset, extent, 1, i2 + m_offset[0])             \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_4(func, type, is_left, m_offset, extent, rank)            \
+  if (is_left) {                                                              \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) { \
+      LOOP_L_3(func, type, m_offset, extent, rank - 2,                        \
+               i3 + m_offset[rank - 1])                                       \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {        \
+      LOOP_R_3(func, type, m_offset, extent, 1, i3 + m_offset[0])             \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_5(func, type, is_left, m_offset, extent, rank)            \
+  if (is_left) {                                                              \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) { \
+      LOOP_L_4(func, type, m_offset, extent, rank - 2,                        \
+               i4 + m_offset[rank - 1])                                       \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {        \
+      LOOP_R_4(func, type, m_offset, extent, 1, i4 + m_offset[0])             \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_6(func, type, is_left, m_offset, extent, rank)            \
+  if (is_left) {                                                              \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) { \
+      LOOP_L_5(func, type, m_offset, extent, rank - 2,                        \
+               i5 + m_offset[rank - 1])                                       \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {        \
+      LOOP_R_5(func, type, m_offset, extent, 1, i5 + m_offset[0])             \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_7(func, type, is_left, m_offset, extent, rank)            \
+  if (is_left) {                                                              \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) { \
+      LOOP_L_6(func, type, m_offset, extent, rank - 2,                        \
+               i6 + m_offset[rank - 1])                                       \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {        \
+      LOOP_R_6(func, type, m_offset, extent, 1, i6 + m_offset[0])             \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_8(func, type, is_left, m_offset, extent, rank)            \
+  if (is_left) {                                                              \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) { \
+      LOOP_L_7(func, type, m_offset, extent, rank - 2,                        \
+               i7 + m_offset[rank - 1])                                       \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {        \
+      LOOP_R_7(func, type, m_offset, extent, 1, i7 + m_offset[0])             \
+    }                                                                         \
   }
 
 // Partial vs Full Tile
-#define TILE_LOOP_1( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_1( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_1( func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_2( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_2( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_2( func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_1(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_1(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_1(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
-#define TILE_LOOP_3( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_3( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_3( func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_2(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_2(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_2(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
-#define TILE_LOOP_4( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_4( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_4( func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_3(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_3(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_3(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
-#define TILE_LOOP_5( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_5( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_5( func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_4(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_4(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_4(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
-#define TILE_LOOP_6( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_6( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_6( func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_5(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_5(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_5(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
-#define TILE_LOOP_7( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_7( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_7( func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_6(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_6(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_6(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
-#define TILE_LOOP_8( func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_8( func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_8( func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_7(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_7(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_7(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
+#define TILE_LOOP_8(func, type, is_left, cond, m_offset, extent_full,  \
+                    extent_partial, rank)                              \
+  if (cond) {                                                          \
+    LOOP_LAYOUT_8(func, type, is_left, m_offset, extent_full, rank)    \
+  } else {                                                             \
+    LOOP_LAYOUT_8(func, type, is_left, m_offset, extent_partial, rank) \
+  }
 
 // parallel_reduce, non-tagged
 // Reduction version
-#define APPLY_REDUX( val, func, ... ) \
-  func( __VA_ARGS__, val );
+#define APPLY_REDUX(val, func, ...) func(__VA_ARGS__, val);
 
 // LayoutRight
 // d = 0 to start
-#define LOOP_R_1_REDUX( val, func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY_REDUX( val, func, __VA_ARGS__, i0 + m_offset[d] )              \
+#define LOOP_R_1_REDUX(val, func, type, m_offset, extent, d, ...)    \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
+    APPLY_REDUX(val, func, __VA_ARGS__, i0 + m_offset[d])            \
   }
 
-#define LOOP_R_2_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    LOOP_R_1_REDUX( val, func, type, m_offset, extent, d+1 , __VA_ARGS__, i1 + m_offset[d] ) \
+#define LOOP_R_2_REDUX(val, func, type, m_offset, extent, d, ...)         \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {      \
+    LOOP_R_1_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                   i1 + m_offset[d])                                      \
   }
 
-#define LOOP_R_3_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    LOOP_R_2_REDUX( val, func, type, m_offset, extent, d+1 , __VA_ARGS__, i2 + m_offset[d] ) \
+#define LOOP_R_3_REDUX(val, func, type, m_offset, extent, d, ...)         \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {      \
+    LOOP_R_2_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                   i2 + m_offset[d])                                      \
   }
 
-#define LOOP_R_4_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    LOOP_R_3_REDUX( val, func, type, m_offset, extent, d+1 , __VA_ARGS__, i3 + m_offset[d] ) \
+#define LOOP_R_4_REDUX(val, func, type, m_offset, extent, d, ...)         \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {      \
+    LOOP_R_3_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                   i3 + m_offset[d])                                      \
   }
 
-#define LOOP_R_5_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    LOOP_R_4_REDUX( val, func, type, m_offset, extent, d+1 , __VA_ARGS__, i4 + m_offset[d] ) \
+#define LOOP_R_5_REDUX(val, func, type, m_offset, extent, d, ...)         \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {      \
+    LOOP_R_4_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                   i4 + m_offset[d])                                      \
   }
 
-#define LOOP_R_6_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    LOOP_R_5_REDUX( val, func, type, m_offset, extent, d+1 , __VA_ARGS__, i5 + m_offset[d] ) \
+#define LOOP_R_6_REDUX(val, func, type, m_offset, extent, d, ...)         \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {      \
+    LOOP_R_5_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                   i5 + m_offset[d])                                      \
   }
 
-#define LOOP_R_7_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    LOOP_R_6_REDUX( val, func, type, m_offset, extent, d+1 , __VA_ARGS__, i6 + m_offset[d] ) \
+#define LOOP_R_7_REDUX(val, func, type, m_offset, extent, d, ...)         \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {      \
+    LOOP_R_6_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                   i6 + m_offset[d])                                      \
   }
 
-#define LOOP_R_8_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    LOOP_R_7_REDUX( val, func, type, m_offset, extent, d+1 , __VA_ARGS__, i7 + m_offset[d] ) \
+#define LOOP_R_8_REDUX(val, func, type, m_offset, extent, d, ...)         \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {      \
+    LOOP_R_7_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                   i7 + m_offset[d])                                      \
   }
 
-//LayoutLeft
+// LayoutLeft
 // d = rank-1 to start
-#define LOOP_L_1_REDUX( val, func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY_REDUX( val, func, i0 + m_offset[d] , __VA_ARGS__ )              \
+#define LOOP_L_1_REDUX(val, func, type, m_offset, extent, d, ...)    \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
+    APPLY_REDUX(val, func, i0 + m_offset[d], __VA_ARGS__)            \
   }
 
-#define LOOP_L_2_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    LOOP_L_1_REDUX( val, func, type, m_offset, extent, d-1, i1 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_2_REDUX(val, func, type, m_offset, extent, d, ...)              \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {           \
+    LOOP_L_1_REDUX(val, func, type, m_offset, extent, d - 1, i1 + m_offset[d], \
+                   __VA_ARGS__)                                                \
   }
 
-#define LOOP_L_3_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    LOOP_L_2_REDUX( val, func, type, m_offset, extent, d-1, i2 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_3_REDUX(val, func, type, m_offset, extent, d, ...)              \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {           \
+    LOOP_L_2_REDUX(val, func, type, m_offset, extent, d - 1, i2 + m_offset[d], \
+                   __VA_ARGS__)                                                \
   }
 
-#define LOOP_L_4_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    LOOP_L_3_REDUX( val, func, type, m_offset, extent, d-1, i3 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_4_REDUX(val, func, type, m_offset, extent, d, ...)              \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {           \
+    LOOP_L_3_REDUX(val, func, type, m_offset, extent, d - 1, i3 + m_offset[d], \
+                   __VA_ARGS__)                                                \
   }
 
-#define LOOP_L_5_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    LOOP_L_4_REDUX( val, func, type, m_offset, extent, d-1, i4 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_5_REDUX(val, func, type, m_offset, extent, d, ...)              \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {           \
+    LOOP_L_4_REDUX(val, func, type, m_offset, extent, d - 1, i4 + m_offset[d], \
+                   __VA_ARGS__)                                                \
   }
 
-#define LOOP_L_6_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    LOOP_L_5_REDUX( val, func, type, m_offset, extent, d-1, i5 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_6_REDUX(val, func, type, m_offset, extent, d, ...)              \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {           \
+    LOOP_L_5_REDUX(val, func, type, m_offset, extent, d - 1, i5 + m_offset[d], \
+                   __VA_ARGS__)                                                \
   }
 
-#define LOOP_L_7_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    LOOP_L_6_REDUX( val, func, type, m_offset, extent, d-1, i6 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_7_REDUX(val, func, type, m_offset, extent, d, ...)              \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {           \
+    LOOP_L_6_REDUX(val, func, type, m_offset, extent, d - 1, i6 + m_offset[d], \
+                   __VA_ARGS__)                                                \
   }
 
-#define LOOP_L_8_REDUX( val, func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    LOOP_L_7_REDUX( val, func, type, m_offset, extent, d-1, i7 + m_offset[d] , __VA_ARGS__ ) \
+#define LOOP_L_8_REDUX(val, func, type, m_offset, extent, d, ...)              \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {           \
+    LOOP_L_7_REDUX(val, func, type, m_offset, extent, d - 1, i7 + m_offset[d], \
+                   __VA_ARGS__)                                                \
   }
 
 // Left vs Right
-#define LOOP_LAYOUT_1_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) { \
-    APPLY_REDUX( val, func, i0 + m_offset[0] )              \
-  }
-
-#define LOOP_LAYOUT_2_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[rank-1]); ++i1) {   \
-      LOOP_L_1_REDUX( val, func, type, m_offset, extent, rank-2, i1 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) { \
-      LOOP_R_1_REDUX( val, func, type, m_offset, extent, 1 , i1 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_3_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[rank-1]); ++i2) {   \
-      LOOP_L_2_REDUX( val, func, type, m_offset, extent, rank-2, i2 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) { \
-      LOOP_R_2_REDUX( val, func, type, m_offset, extent, 1 , i2 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_4_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[rank-1]); ++i3) {   \
-      LOOP_L_3_REDUX( val, func, type, m_offset, extent, rank-2, i3 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) { \
-      LOOP_R_3_REDUX( val, func, type, m_offset, extent, 1 , i3 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_5_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[rank-1]); ++i4) {   \
-      LOOP_L_4_REDUX( val, func, type, m_offset, extent, rank-2, i4 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) { \
-      LOOP_R_4_REDUX( val, func, type, m_offset, extent, 1 , i4 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_6_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[rank-1]); ++i5) {   \
-      LOOP_L_5_REDUX( val, func, type, m_offset, extent, rank-2, i5 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) { \
-      LOOP_R_5_REDUX( val, func, type, m_offset, extent, 1 , i5 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_7_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[rank-1]); ++i6) {   \
-      LOOP_L_6_REDUX( val, func, type, m_offset, extent, rank-2, i6 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) { \
-      LOOP_R_6_REDUX( val, func, type, m_offset, extent, 1 , i6 + m_offset[0] )   \
-    } \
-  }
-
-#define LOOP_LAYOUT_8_REDUX( val, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[rank-1]); ++i7) {   \
-      LOOP_L_7_REDUX( val, func, type, m_offset, extent, rank-2, i7 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) { \
-      LOOP_R_7_REDUX( val, func, type, m_offset, extent, 1 , i7 + m_offset[0] )   \
-    } \
+#define LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {          \
+    APPLY_REDUX(val, func, i0 + m_offset[0])                                  \
+  }
+
+#define LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                              \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) { \
+      LOOP_L_1_REDUX(val, func, type, m_offset, extent, rank - 2,             \
+                     i1 + m_offset[rank - 1])                                 \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {        \
+      LOOP_R_1_REDUX(val, func, type, m_offset, extent, 1, i1 + m_offset[0])  \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                              \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) { \
+      LOOP_L_2_REDUX(val, func, type, m_offset, extent, rank - 2,             \
+                     i2 + m_offset[rank - 1])                                 \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {        \
+      LOOP_R_2_REDUX(val, func, type, m_offset, extent, 1, i2 + m_offset[0])  \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                              \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) { \
+      LOOP_L_3_REDUX(val, func, type, m_offset, extent, rank - 2,             \
+                     i3 + m_offset[rank - 1])                                 \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {        \
+      LOOP_R_3_REDUX(val, func, type, m_offset, extent, 1, i3 + m_offset[0])  \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                              \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) { \
+      LOOP_L_4_REDUX(val, func, type, m_offset, extent, rank - 2,             \
+                     i4 + m_offset[rank - 1])                                 \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {        \
+      LOOP_R_4_REDUX(val, func, type, m_offset, extent, 1, i4 + m_offset[0])  \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                              \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) { \
+      LOOP_L_5_REDUX(val, func, type, m_offset, extent, rank - 2,             \
+                     i5 + m_offset[rank - 1])                                 \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {        \
+      LOOP_R_5_REDUX(val, func, type, m_offset, extent, 1, i5 + m_offset[0])  \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                              \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) { \
+      LOOP_L_6_REDUX(val, func, type, m_offset, extent, rank - 2,             \
+                     i6 + m_offset[rank - 1])                                 \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {        \
+      LOOP_R_6_REDUX(val, func, type, m_offset, extent, 1, i6 + m_offset[0])  \
+    }                                                                         \
+  }
+
+#define LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                              \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) { \
+      LOOP_L_7_REDUX(val, func, type, m_offset, extent, rank - 2,             \
+                     i7 + m_offset[rank - 1])                                 \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {        \
+      LOOP_R_7_REDUX(val, func, type, m_offset, extent, 1, i7 + m_offset[0])  \
+    }                                                                         \
   }
 
 // Partial vs Full Tile
-#define TILE_LOOP_1_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_1_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_1_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_2_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_2_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_2_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_3_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_3_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_3_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_4_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_4_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_4_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_5_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_5_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_5_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_6_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_6_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_6_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_7_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_7_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_7_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TILE_LOOP_8_REDUX( val, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { LOOP_LAYOUT_8_REDUX( val, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { LOOP_LAYOUT_8_REDUX( val, func, type, is_left, m_offset, extent_partial, rank ) }
+#define TILE_LOOP_1_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
+
+#define TILE_LOOP_2_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
+
+#define TILE_LOOP_3_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
+
+#define TILE_LOOP_4_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
+
+#define TILE_LOOP_5_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
+
+#define TILE_LOOP_6_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
+
+#define TILE_LOOP_7_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
+
+#define TILE_LOOP_8_REDUX(val, func, type, is_left, cond, m_offset,            \
+                          extent_full, extent_partial, rank)                   \
+  if (cond) {                                                                  \
+    LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
+  } else {                                                                     \
+    LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
+                        rank)                                                  \
+  }
 // end New Loop Macros
 
-
 // tagged macros
-#define TAGGED_APPLY( tag, func, ... ) \
-  func( tag, __VA_ARGS__ );
+#define TAGGED_APPLY(tag, func, ...) func(tag, __VA_ARGS__);
 
 // LayoutRight
 // d = 0 to start
-#define TAGGED_LOOP_R_1( tag, func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    TAGGED_APPLY( tag, func, __VA_ARGS__, i0 + m_offset[d] )              \
+#define TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, d, ...)   \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
+    TAGGED_APPLY(tag, func, __VA_ARGS__, i0 + m_offset[d])           \
   }
 
-#define TAGGED_LOOP_R_2( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    TAGGED_LOOP_R_1( tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i1 + m_offset[d] ) \
+#define TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, d, ...)         \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {       \
+    TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                    i1 + m_offset[d])                                      \
   }
 
-#define TAGGED_LOOP_R_3( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    TAGGED_LOOP_R_2( tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i2 + m_offset[d] ) \
+#define TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, d, ...)         \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {       \
+    TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                    i2 + m_offset[d])                                      \
   }
 
-#define TAGGED_LOOP_R_4( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    TAGGED_LOOP_R_3( tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i3 + m_offset[d] ) \
+#define TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, d, ...)         \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {       \
+    TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                    i3 + m_offset[d])                                      \
   }
 
-#define TAGGED_LOOP_R_5( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    TAGGED_LOOP_R_4( tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i4 + m_offset[d] ) \
+#define TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, d, ...)         \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {       \
+    TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                    i4 + m_offset[d])                                      \
   }
 
-#define TAGGED_LOOP_R_6( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    TAGGED_LOOP_R_5( tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i5 + m_offset[d] ) \
+#define TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, d, ...)         \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {       \
+    TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                    i5 + m_offset[d])                                      \
   }
 
-#define TAGGED_LOOP_R_7( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    TAGGED_LOOP_R_6( tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i6 + m_offset[d] ) \
+#define TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, d, ...)         \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {       \
+    TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                    i6 + m_offset[d])                                      \
   }
 
-#define TAGGED_LOOP_R_8( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    TAGGED_LOOP_R_7( tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i7 + m_offset[d] ) \
+#define TAGGED_LOOP_R_8(tag, func, type, m_offset, extent, d, ...)         \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {       \
+    TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                    i7 + m_offset[d])                                      \
   }
 
-//LayoutLeft
+// LayoutLeft
 // d = rank-1 to start
-#define TAGGED_LOOP_L_1( tag, func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    TAGGED_APPLY( tag, func, i0 + m_offset[d] , __VA_ARGS__ )              \
+#define TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, d, ...)   \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
+    TAGGED_APPLY(tag, func, i0 + m_offset[d], __VA_ARGS__)           \
   }
 
-#define TAGGED_LOOP_L_2( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    TAGGED_LOOP_L_1( tag, func, type, m_offset, extent, d-1, i1 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, d, ...)   \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) { \
+    TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, d - 1,        \
+                    i1 + m_offset[d], __VA_ARGS__)                   \
   }
 
-#define TAGGED_LOOP_L_3( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    TAGGED_LOOP_L_2( tag, func, type, m_offset, extent, d-1, i2 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, d, ...)   \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) { \
+    TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, d - 1,        \
+                    i2 + m_offset[d], __VA_ARGS__)                   \
   }
 
-#define TAGGED_LOOP_L_4( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    TAGGED_LOOP_L_3( tag, func, type, m_offset, extent, d-1, i3 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, d, ...)   \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) { \
+    TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, d - 1,        \
+                    i3 + m_offset[d], __VA_ARGS__)                   \
   }
 
-#define TAGGED_LOOP_L_5( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    TAGGED_LOOP_L_4( tag, func, type, m_offset, extent, d-1, i4 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, d, ...)   \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) { \
+    TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, d - 1,        \
+                    i4 + m_offset[d], __VA_ARGS__)                   \
   }
 
-#define TAGGED_LOOP_L_6( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    TAGGED_LOOP_L_5( tag, func, type, m_offset, extent, d-1, i5 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, d, ...)   \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) { \
+    TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, d - 1,        \
+                    i5 + m_offset[d], __VA_ARGS__)                   \
   }
 
-#define TAGGED_LOOP_L_7( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    TAGGED_LOOP_L_6( tag, func, type, m_offset, extent, d-1, i6 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, d, ...)   \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) { \
+    TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, d - 1,        \
+                    i6 + m_offset[d], __VA_ARGS__)                   \
   }
 
-#define TAGGED_LOOP_L_8( tag, func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    TAGGED_LOOP_L_7( tag, func, type, m_offset, extent, d-1, i7 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_8(tag, func, type, m_offset, extent, d, ...)   \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) { \
+    TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, d - 1,        \
+                    i7 + m_offset[d], __VA_ARGS__)                   \
   }
 
 // Left vs Right
 // TODO: rank not necessary to pass through, can hardcode the values
-#define TAGGED_LOOP_LAYOUT_1( tag, func, type, is_left, m_offset, extent, rank )  \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) { \
-    TAGGED_APPLY( tag, func, i0 + m_offset[0] )              \
-  }
-
-#define TAGGED_LOOP_LAYOUT_2( tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[rank-1]); ++i1) {   \
-      TAGGED_LOOP_L_1( tag, func, type, m_offset, extent, rank-2, i1 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) { \
-      TAGGED_LOOP_R_1( tag, func, type, m_offset, extent, 1 , i1 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_3( tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[rank-1]); ++i2) {   \
-      TAGGED_LOOP_L_2( tag, func, type, m_offset, extent, rank-2, i2 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) { \
-      TAGGED_LOOP_R_2( tag, func, type, m_offset, extent, 1 , i2 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_4( tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[rank-1]); ++i3) {   \
-      TAGGED_LOOP_L_3( tag, func, type, m_offset, extent, rank-2, i3 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) { \
-      TAGGED_LOOP_R_3( tag, func, type, m_offset, extent, 1 , i3 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_5( tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[rank-1]); ++i4) {   \
-      TAGGED_LOOP_L_4( tag, func, type, m_offset, extent, rank-2, i4 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) { \
-      TAGGED_LOOP_R_4( tag, func, type, m_offset, extent, 1 , i4 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_6( tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[rank-1]); ++i5) {   \
-      TAGGED_LOOP_L_5( tag, func, type, m_offset, extent, rank-2, i5 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) { \
-      TAGGED_LOOP_R_5( tag, func, type, m_offset, extent, 1 , i5 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_7( tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[rank-1]); ++i6) {   \
-      TAGGED_LOOP_L_6( tag, func, type, m_offset, extent, rank-2, i6 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) { \
-      TAGGED_LOOP_R_6( tag, func, type, m_offset, extent, 1 , i6 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_8( tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[rank-1]); ++i7) {   \
-      TAGGED_LOOP_L_7( tag, func, type, m_offset, extent, rank-2, i7 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) { \
-      TAGGED_LOOP_R_7( tag, func, type, m_offset, extent, 1 , i7 + m_offset[0] )   \
-    } \
+#define TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset, extent, rank) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                  \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {           \
+    TAGGED_APPLY(tag, func, i0 + m_offset[0])                                  \
+  }
+
+#define TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) {  \
+      TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, rank - 2,             \
+                      i1 + m_offset[rank - 1])                                 \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {         \
+      TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, 1, i1 + m_offset[0])  \
+    }                                                                          \
+  }
+
+#define TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) {  \
+      TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, rank - 2,             \
+                      i2 + m_offset[rank - 1])                                 \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {         \
+      TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, 1, i2 + m_offset[0])  \
+    }                                                                          \
+  }
+
+#define TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) {  \
+      TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, rank - 2,             \
+                      i3 + m_offset[rank - 1])                                 \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {         \
+      TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, 1, i3 + m_offset[0])  \
+    }                                                                          \
+  }
+
+#define TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) {  \
+      TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, rank - 2,             \
+                      i4 + m_offset[rank - 1])                                 \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {         \
+      TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, 1, i4 + m_offset[0])  \
+    }                                                                          \
+  }
+
+#define TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) {  \
+      TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, rank - 2,             \
+                      i5 + m_offset[rank - 1])                                 \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {         \
+      TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, 1, i5 + m_offset[0])  \
+    }                                                                          \
+  }
+
+#define TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) {  \
+      TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, rank - 2,             \
+                      i6 + m_offset[rank - 1])                                 \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {         \
+      TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, 1, i6 + m_offset[0])  \
+    }                                                                          \
+  }
+
+#define TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) {  \
+      TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, rank - 2,             \
+                      i7 + m_offset[rank - 1])                                 \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {         \
+      TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, 1, i7 + m_offset[0])  \
+    }                                                                          \
   }
 
 // Partial vs Full Tile
-#define TAGGED_TILE_LOOP_1( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_1( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_1( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_2( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_2( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_2( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_3( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_3( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_3( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_4( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_4( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_4( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_5( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_5( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_5( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_6( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_6( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_6( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_7( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_7( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_7( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_8( tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_8( tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_8( tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
+#define TAGGED_TILE_LOOP_1(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
+
+#define TAGGED_TILE_LOOP_2(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
+
+#define TAGGED_TILE_LOOP_3(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
+
+#define TAGGED_TILE_LOOP_4(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
+
+#define TAGGED_TILE_LOOP_5(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
+
+#define TAGGED_TILE_LOOP_6(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
+
+#define TAGGED_TILE_LOOP_7(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
+
+#define TAGGED_TILE_LOOP_8(tag, func, type, is_left, cond, m_offset,         \
+                           extent_full, extent_partial, rank)                \
+  if (cond) {                                                                \
+    TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset, extent_full,    \
+                         rank)                                               \
+  } else {                                                                   \
+    TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset, extent_partial, \
+                         rank)                                               \
+  }
 
 // parallel_reduce, tagged
 // Reduction version
-#define TAGGED_APPLY_REDUX( val, tag, func, ... ) \
-  func( tag, __VA_ARGS__, val );
+#define TAGGED_APPLY_REDUX(val, tag, func, ...) func(tag, __VA_ARGS__, val);
 
 // LayoutRight
 // d = 0 to start
-#define TAGGED_LOOP_R_1_REDUX( val, tag, func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    TAGGED_APPLY_REDUX( val, tag, func, __VA_ARGS__, i0 + m_offset[d] )              \
+#define TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {          \
+    TAGGED_APPLY_REDUX(val, tag, func, __VA_ARGS__, i0 + m_offset[d])         \
   }
 
-#define TAGGED_LOOP_R_2_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    TAGGED_LOOP_R_1_REDUX( val, tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i1 + m_offset[d] ) \
+#define TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
+    TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
+                          __VA_ARGS__, i1 + m_offset[d])                      \
   }
 
-#define TAGGED_LOOP_R_3_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    TAGGED_LOOP_R_2_REDUX( val, tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i2 + m_offset[d] ) \
+#define TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
+    TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
+                          __VA_ARGS__, i2 + m_offset[d])                      \
   }
 
-#define TAGGED_LOOP_R_4_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    TAGGED_LOOP_R_3_REDUX( val, tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i3 + m_offset[d] ) \
+#define TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
+    TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
+                          __VA_ARGS__, i3 + m_offset[d])                      \
   }
 
-#define TAGGED_LOOP_R_5_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    TAGGED_LOOP_R_4_REDUX( val, tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i4 + m_offset[d] ) \
+#define TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
+    TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
+                          __VA_ARGS__, i4 + m_offset[d])                      \
   }
 
-#define TAGGED_LOOP_R_6_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    TAGGED_LOOP_R_5_REDUX( val, tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i5 + m_offset[d] ) \
+#define TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
+    TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
+                          __VA_ARGS__, i5 + m_offset[d])                      \
   }
 
-#define TAGGED_LOOP_R_7_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    TAGGED_LOOP_R_6_REDUX( val, tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i6 + m_offset[d] ) \
+#define TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
+    TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
+                          __VA_ARGS__, i6 + m_offset[d])                      \
   }
 
-#define TAGGED_LOOP_R_8_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    TAGGED_LOOP_R_7_REDUX( val, tag, func, type, m_offset, extent, d+1 , __VA_ARGS__, i7 + m_offset[d] ) \
+#define TAGGED_LOOP_R_8_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
+    TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
+                          __VA_ARGS__, i7 + m_offset[d])                      \
   }
 
-//LayoutLeft
+// LayoutLeft
 // d = rank-1 to start
-#define TAGGED_LOOP_L_1_REDUX( val, tag, func, type, m_offset, extent, d, ... )    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    TAGGED_APPLY_REDUX( val, tag, func, i0 + m_offset[d] , __VA_ARGS__ )              \
+#define TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {          \
+    TAGGED_APPLY_REDUX(val, tag, func, i0 + m_offset[d], __VA_ARGS__)         \
   }
 
-#define TAGGED_LOOP_L_2_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    TAGGED_LOOP_L_1_REDUX( val, tag, func, type, m_offset, extent, d-1, i1 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
+    TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
+                          i1 + m_offset[d], __VA_ARGS__)                      \
   }
 
-#define TAGGED_LOOP_L_3_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    TAGGED_LOOP_L_2_REDUX( val, tag, func, type, m_offset, extent, d-1, i2 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
+    TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
+                          i2 + m_offset[d], __VA_ARGS__)                      \
   }
 
-#define TAGGED_LOOP_L_4_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    TAGGED_LOOP_L_3_REDUX( val, tag, func, type, m_offset, extent, d-1, i3 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
+    TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
+                          i3 + m_offset[d], __VA_ARGS__)                      \
   }
 
-#define TAGGED_LOOP_L_5_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    TAGGED_LOOP_L_4_REDUX( val, tag, func, type, m_offset, extent, d-1, i4 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
+    TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
+                          i4 + m_offset[d], __VA_ARGS__)                      \
   }
 
-#define TAGGED_LOOP_L_6_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    TAGGED_LOOP_L_5_REDUX( val, tag, func, type, m_offset, extent, d-1, i5 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
+    TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
+                          i5 + m_offset[d], __VA_ARGS__)                      \
   }
 
-#define TAGGED_LOOP_L_7_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    TAGGED_LOOP_L_6_REDUX( val, tag, func, type, m_offset, extent, d-1, i6 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
+    TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
+                          i6 + m_offset[d], __VA_ARGS__)                      \
   }
 
-#define TAGGED_LOOP_L_8_REDUX( val, tag, func, type, m_offset, extent, d, ... )             \
-  for( type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    TAGGED_LOOP_L_7_REDUX( val, tag, func, type, m_offset, extent, d-1, i7 + m_offset[d] , __VA_ARGS__ ) \
+#define TAGGED_LOOP_L_8_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
+    TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
+                          i7 + m_offset[d], __VA_ARGS__)                      \
   }
 
 // Left vs Right
-#define TAGGED_LOOP_LAYOUT_1_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                            \
-  for( type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) { \
-    TAGGED_APPLY_REDUX( val, tag, func, i0 + m_offset[0] )              \
-  }
-
-#define TAGGED_LOOP_LAYOUT_2_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[rank-1]); ++i1) {   \
-      TAGGED_LOOP_L_1_REDUX( val, tag, func, type, m_offset, extent, rank-2, i1 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) { \
-      TAGGED_LOOP_R_1_REDUX( val, tag, func, type, m_offset, extent, 1 , i1 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_3_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[rank-1]); ++i2) {   \
-      TAGGED_LOOP_L_2_REDUX( val, tag, func, type, m_offset, extent, rank-2, i2 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) { \
-      TAGGED_LOOP_R_2_REDUX( val, tag, func, type, m_offset, extent, 1 , i2 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_4_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[rank-1]); ++i3) {   \
-      TAGGED_LOOP_L_3_REDUX( val, tag, func, type, m_offset, extent, rank-2, i3 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) { \
-      TAGGED_LOOP_R_3_REDUX( val, tag, func, type, m_offset, extent, 1 , i3 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_5_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[rank-1]); ++i4) {   \
-      TAGGED_LOOP_L_4_REDUX( val, tag, func, type, m_offset, extent, rank-2, i4 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) { \
-      TAGGED_LOOP_R_4_REDUX( val, tag, func, type, m_offset, extent, 1 , i4 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_6_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[rank-1]); ++i5) {   \
-      TAGGED_LOOP_L_5_REDUX( val, tag, func, type, m_offset, extent, rank-2, i5 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) { \
-      TAGGED_LOOP_R_5_REDUX( val, tag, func, type, m_offset, extent, 1 , i5 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_7_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[rank-1]); ++i6) {   \
-      TAGGED_LOOP_L_6_REDUX( val, tag, func, type, m_offset, extent, rank-2, i6 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) { \
-      TAGGED_LOOP_R_6_REDUX( val, tag, func, type, m_offset, extent, 1 , i6 + m_offset[0] )   \
-    } \
-  }
-
-#define TAGGED_LOOP_LAYOUT_8_REDUX( val, tag, func, type, is_left, m_offset, extent, rank )  \
-  if (is_left) { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[rank-1]); ++i7) {   \
-      TAGGED_LOOP_L_7_REDUX( val, tag, func, type, m_offset, extent, rank-2, i7 + m_offset[rank-1] ) \
-    } \
-  } \
-  else         { \
-    for( type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) { \
-      TAGGED_LOOP_R_7_REDUX( val, tag, func, type, m_offset, extent, 1 , i7 + m_offset[0] )   \
-    } \
+#define TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left, m_offset, \
+                                   extent, rank)                            \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                               \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {        \
+    TAGGED_APPLY_REDUX(val, tag, func, i0 + m_offset[0])                    \
+  }
+
+#define TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left, m_offset,   \
+                                   extent, rank)                              \
+  if (is_left) {                                                              \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) { \
+      TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
+                            i1 + m_offset[rank - 1])                          \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {        \
+      TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, extent, 1,        \
+                            i1 + m_offset[0])                                 \
+    }                                                                         \
+  }
+
+#define TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left, m_offset,   \
+                                   extent, rank)                              \
+  if (is_left) {                                                              \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) { \
+      TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
+                            i2 + m_offset[rank - 1])                          \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {        \
+      TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset, extent, 1,        \
+                            i2 + m_offset[0])                                 \
+    }                                                                         \
+  }
+
+#define TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left, m_offset,   \
+                                   extent, rank)                              \
+  if (is_left) {                                                              \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) { \
+      TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
+                            i3 + m_offset[rank - 1])                          \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {        \
+      TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset, extent, 1,        \
+                            i3 + m_offset[0])                                 \
+    }                                                                         \
+  }
+
+#define TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left, m_offset,   \
+                                   extent, rank)                              \
+  if (is_left) {                                                              \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) { \
+      TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
+                            i4 + m_offset[rank - 1])                          \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {        \
+      TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset, extent, 1,        \
+                            i4 + m_offset[0])                                 \
+    }                                                                         \
+  }
+
+#define TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left, m_offset,   \
+                                   extent, rank)                              \
+  if (is_left) {                                                              \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) { \
+      TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
+                            i5 + m_offset[rank - 1])                          \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {        \
+      TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset, extent, 1,        \
+                            i5 + m_offset[0])                                 \
+    }                                                                         \
+  }
+
+#define TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left, m_offset,   \
+                                   extent, rank)                              \
+  if (is_left) {                                                              \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) { \
+      TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
+                            i6 + m_offset[rank - 1])                          \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {        \
+      TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset, extent, 1,        \
+                            i6 + m_offset[0])                                 \
+    }                                                                         \
+  }
+
+#define TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left, m_offset,   \
+                                   extent, rank)                              \
+  if (is_left) {                                                              \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) { \
+      TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
+                            i7 + m_offset[rank - 1])                          \
+    }                                                                         \
+  } else {                                                                    \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {        \
+      TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset, extent, 1,        \
+                            i7 + m_offset[0])                                 \
+    }                                                                         \
   }
 
 // Partial vs Full Tile
-#define TAGGED_TILE_LOOP_1_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_1_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_1_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_2_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_2_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_2_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_3_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_3_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_3_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_4_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_4_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_4_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_5_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_5_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_5_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_6_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_6_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_6_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_7_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_7_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_7_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
-
-#define TAGGED_TILE_LOOP_8_REDUX( val, tag, func, type, is_left, cond, m_offset, extent_full, extent_partial, rank ) \
-  if (cond) { TAGGED_LOOP_LAYOUT_8_REDUX( val, tag, func, type, is_left, m_offset, extent_full, rank ) } \
-  else      { TAGGED_LOOP_LAYOUT_8_REDUX( val, tag, func, type, is_left, m_offset, extent_partial, rank ) }
+#define TAGGED_TILE_LOOP_1_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
+
+#define TAGGED_TILE_LOOP_2_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
+
+#define TAGGED_TILE_LOOP_3_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
+
+#define TAGGED_TILE_LOOP_4_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
+
+#define TAGGED_TILE_LOOP_5_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
+
+#define TAGGED_TILE_LOOP_6_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
+
+#define TAGGED_TILE_LOOP_7_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
+
+#define TAGGED_TILE_LOOP_8_REDUX(val, tag, func, type, is_left, cond,         \
+                                 m_offset, extent_full, extent_partial, rank) \
+  if (cond) {                                                                 \
+    TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_full, rank)                             \
+  } else {                                                                    \
+    TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left, m_offset,       \
+                               extent_partial, rank)                          \
+  }
 
 // end tagged macros
 
-
 // Structs for calling loops
-template < int Rank, bool IsLeft, typename IType, typename Tagged, typename Enable = void >
+template <int Rank, bool IsLeft, typename IType, typename Tagged,
+          typename Enable = void>
 struct Tile_Loop_Type;
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<1, IsLeft, IType, void, void >
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_1( func, IType, IsLeft, cond, offset, a, b, 1 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<1, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_1(func, IType, IsLeft, cond, offset, a, b, 1);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_1_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 1 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_1_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 1);
   }
 };
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<2, IsLeft, IType, void, void>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_2( func, IType, IsLeft, cond, offset, a, b, 2 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<2, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_2(func, IType, IsLeft, cond, offset, a, b, 2);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_2_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 2 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_2_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 2);
   }
 };
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<3, IsLeft, IType, void, void>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_3( func, IType, IsLeft, cond, offset, a, b, 3 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<3, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_3(func, IType, IsLeft, cond, offset, a, b, 3);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_3_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 3 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_3_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 3);
   }
 };
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<4, IsLeft, IType, void, void>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_4( func, IType, IsLeft, cond, offset, a, b, 4 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<4, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_4(func, IType, IsLeft, cond, offset, a, b, 4);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_4_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 4 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_4_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 4);
   }
 };
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<5, IsLeft, IType, void, void>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_5( func, IType, IsLeft, cond, offset, a, b, 5 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<5, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_5(func, IType, IsLeft, cond, offset, a, b, 5);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_5_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 5 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_5_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 5);
   }
 };
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<6, IsLeft, IType, void, void>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_6( func, IType, IsLeft, cond, offset, a, b, 6 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<6, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_6(func, IType, IsLeft, cond, offset, a, b, 6);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_6_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 6 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_6_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 6);
   }
 };
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<7, IsLeft, IType, void, void>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_7( func, IType, IsLeft, cond, offset, a, b, 7 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<7, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_7(func, IType, IsLeft, cond, offset, a, b, 7);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_7_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 7 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_7_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 7);
   }
 };
 
-template < bool IsLeft, typename IType >
-struct Tile_Loop_Type<8, IsLeft, IType, void, void>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_8( func, IType, IsLeft, cond, offset, a, b, 8 );
+template <bool IsLeft, typename IType>
+struct Tile_Loop_Type<8, IsLeft, IType, void, void> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_8(func, IType, IsLeft, cond, offset, a, b, 8);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TILE_LOOP_8_REDUX( value, func, IType, IsLeft, cond, offset, a, b, 8 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TILE_LOOP_8_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 8);
   }
 };
 
 // tagged versions
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<1, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type >
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_1( Tagged(), func, IType, IsLeft, cond, offset, a, b, 1 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    1, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_1(Tagged(), func, IType, IsLeft, cond, offset, a, b, 1);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_1_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 1 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_1_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 1);
   }
 };
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<2, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_2( Tagged(), func, IType, IsLeft, cond, offset, a, b, 2 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    2, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_2(Tagged(), func, IType, IsLeft, cond, offset, a, b, 2);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_2_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 2 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_2_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 2);
   }
 };
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<3, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_3( Tagged(), func, IType, IsLeft, cond, offset, a, b, 3 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    3, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_3(Tagged(), func, IType, IsLeft, cond, offset, a, b, 3);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_3_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 3 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_3_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 3);
   }
 };
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<4, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_4( Tagged(), func, IType, IsLeft, cond, offset, a, b, 4 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    4, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_4(Tagged(), func, IType, IsLeft, cond, offset, a, b, 4);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_4_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 4 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_4_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 4);
   }
 };
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<5, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_5( Tagged(), func, IType, IsLeft, cond, offset, a, b, 5 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    5, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_5(Tagged(), func, IType, IsLeft, cond, offset, a, b, 5);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_5_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 5 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_5_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 5);
   }
 };
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<6, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_6( Tagged(), func, IType, IsLeft, cond, offset, a, b, 6 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    6, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_6(Tagged(), func, IType, IsLeft, cond, offset, a, b, 6);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_6_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 6 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_6_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 6);
   }
 };
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<7, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_7( Tagged(), func, IType, IsLeft, cond, offset, a, b, 7 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    7, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_7(Tagged(), func, IType, IsLeft, cond, offset, a, b, 7);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_7_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 7 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_7_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 7);
   }
 };
 
-template < bool IsLeft, typename IType, typename Tagged >
-struct Tile_Loop_Type<8, IsLeft, IType, Tagged, typename std::enable_if< !std::is_same<Tagged,void>::value>::type>
-{
-  template < typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_8( Tagged(), func, IType, IsLeft, cond, offset, a, b, 8 );
+template <bool IsLeft, typename IType, typename Tagged>
+struct Tile_Loop_Type<
+    8, IsLeft, IType, Tagged,
+    typename std::enable_if<!std::is_same<Tagged, void>::value>::type> {
+  template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
+  static void apply(Func const& func, bool cond, Offset const& offset,
+                    ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_8(Tagged(), func, IType, IsLeft, cond, offset, a, b, 8);
   }
 
-  template < typename ValType, typename Func, typename Offset, typename ExtentA, typename ExtentB >
-  static void apply(ValType &value, Func const& func, bool cond, Offset const& offset, ExtentA const& a, ExtentB const& b)
-  {
-    TAGGED_TILE_LOOP_8_REDUX( value, Tagged(), func, IType, IsLeft, cond, offset, a, b, 8 );
+  template <typename ValType, typename Func, typename Offset, typename ExtentA,
+            typename ExtentB>
+  static void apply(ValType& value, Func const& func, bool cond,
+                    Offset const& offset, ExtentA const& a, ExtentB const& b) {
+    TAGGED_TILE_LOOP_8_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
+                             a, b, 8);
   }
 };
 // end Structs for calling loops
 
-
 template <typename T>
-using is_void_type = std::is_same< T , void >;
+using is_void_type = std::is_same<T, void>;
 
 template <typename T>
-struct is_type_array : std::false_type 
-{
+struct is_type_array : std::false_type {
   using value_type = T;
 };
 
 template <typename T>
-struct is_type_array< T[] > : std::true_type
-{
+struct is_type_array<T[]> : std::true_type {
   using value_type = T;
 };
 
-
-template < typename RP
-         , typename Functor
-         , typename Tag = void
-         , typename ValueType = void
-         , typename Enable = void
-         >
+template <typename RP, typename Functor, typename Tag = void,
+          typename ValueType = void, typename Enable = void>
 struct HostIterateTile;
 
-//For ParallelFor
-template < typename RP
-         , typename Functor
-         , typename Tag
-         , typename ValueType
-         >
-struct HostIterateTile < RP , Functor , Tag , ValueType , typename std::enable_if< is_void_type<ValueType >::value >::type >
-{
+// For ParallelFor
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct HostIterateTile<
+    RP, Functor, Tag, ValueType,
+    typename std::enable_if<is_void_type<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
   using point_type = typename RP::point_type;
 
   using value_type = ValueType;
 
-  inline
-  HostIterateTile( RP const& rp, Functor const& func )
-    : m_rp(rp)
-    , m_func(func)
-  {
-  }
+  inline HostIterateTile(RP const& rp, Functor const& func)
+      : m_rp(rp), m_func(func) {}
 
-  inline
-  bool check_iteration_bounds( point_type& partial_tile , point_type& offset ) const {
+  inline bool check_iteration_bounds(point_type& partial_tile,
+                                     point_type& offset) const {
     bool is_full_tile = true;
 
-      for ( int i = 0; i < RP::rank; ++i ) {
-        if ((offset[i] + m_rp.m_tile[i]) <= m_rp.m_upper[i]) {
-            partial_tile[i] = m_rp.m_tile[i] ;
-        }
-        else {
-          is_full_tile = false ;
-            partial_tile[i] = (m_rp.m_upper[i] - 1 - offset[i]) == 0 ? 1
-                            : (m_rp.m_upper[i] - m_rp.m_tile[i]) > 0 ? (m_rp.m_upper[i] - offset[i])
-                            : (m_rp.m_upper[i] - m_rp.m_lower[i]) ; // when single tile encloses range
-        }
+    for (int i = 0; i < RP::rank; ++i) {
+      if ((offset[i] + m_rp.m_tile[i]) <= m_rp.m_upper[i]) {
+        partial_tile[i] = m_rp.m_tile[i];
+      } else {
+        is_full_tile = false;
+        partial_tile[i] =
+            (m_rp.m_upper[i] - 1 - offset[i]) == 0
+                ? 1
+                : (m_rp.m_upper[i] - m_rp.m_tile[i]) > 0
+                      ? (m_rp.m_upper[i] - offset[i])
+                      : (m_rp.m_upper[i] -
+                         m_rp.m_lower[i]);  // when single tile encloses range
       }
+    }
 
-    return is_full_tile ;
-  } // end check bounds
-
+    return is_full_tile;
+  }  // end check bounds
 
   template <int Rank>
-  struct RankTag
-  {
+  struct RankTag {
     typedef RankTag type;
     enum { value = (int)Rank };
   };
 
 #if KOKKOS_ENABLE_NEW_LOOP_MACROS
   template <typename IType>
-  inline
-  void
-  operator()(IType tile_idx) const
-  {
+  inline void operator()(IType tile_idx) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
-
-    Tile_Loop_Type< RP::rank, (RP::inner_direction == RP::Left), index_type, Tag >::apply( m_func, full_tile, m_offset, m_rp.m_tile, m_tiledims );
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
+    Tile_Loop_Type<RP::rank, (RP::inner_direction == RP::Left), index_type,
+                   Tag>::apply(m_func, full_tile, m_offset, m_rp.m_tile,
+                               m_tiledims);
   }
 
 #else
   template <typename IType>
-  inline
-  void
-  operator()(IType tile_idx) const
-  { operator_impl( tile_idx , RankTag<RP::rank>() ); }
-  // added due to compiler error when using sfinae to choose operator based on rank w/ cuda+serial
+  inline void operator()(IType tile_idx) const {
+    operator_impl(tile_idx, RankTag<RP::rank>());
+  }
+  // added due to compiler error when using sfinae to choose operator based on
+  // rank w/ cuda+serial
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<2> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<2>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_2L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
-//      #pragma simd
-        LOOP_2L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+        //      #pragma simd
+        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_2R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
-//      #pragma simd
-        LOOP_2R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+        //      #pragma simd
+        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 2
+    }  // end RP::Right
 
+  }  // end op() rank == 2
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<3> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<3>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_3L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
-//      #pragma simd
-        LOOP_3L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+        //      #pragma simd
+        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_3R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
-//      #pragma simd
-        LOOP_3R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+        //      #pragma simd
+        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 3
+    }  // end RP::Right
 
+  }  // end op() rank == 3
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<4> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<4>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_4L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
-//      #pragma simd
-        LOOP_4L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+        //      #pragma simd
+        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_4R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
-//      #pragma simd
-        LOOP_4R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+        //      #pragma simd
+        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 4
+    }  // end RP::Right
 
+  }  // end op() rank == 4
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<5> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<5>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_5L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
-//      #pragma simd
-        LOOP_5L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+        //      #pragma simd
+        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_5R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
-//      #pragma simd
-        LOOP_5R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+        //      #pragma simd
+        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 5
+    }  // end RP::Right
 
+  }  // end op() rank == 5
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<6> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<6>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_6L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
-//      #pragma simd
-        LOOP_6L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+        //      #pragma simd
+        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_6R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
-//      #pragma simd
-        LOOP_6R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+        //      #pragma simd
+        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 6
+    }  // end RP::Right
 
+  }  // end op() rank == 6
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<7> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<7>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_7L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
-//      #pragma simd
-        LOOP_7L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+        //      #pragma simd
+        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_7R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
-//      #pragma simd
-        LOOP_7R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+        //      #pragma simd
+        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 7
+    }  // end RP::Right
 
+  }  // end op() rank == 7
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<8> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<8>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_8L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
-//      #pragma simd
-        LOOP_8L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+        //      #pragma simd
+        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_8R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
-//      #pragma simd
-        LOOP_8R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+        //      #pragma simd
+        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
-    } // end RP::Right
+    }  // end RP::Right
 
-  } //end op() rank == 8
+  }  // end op() rank == 8
 #endif
 
+  template <typename... Args>
+  typename std::enable_if<(sizeof...(Args) == RP::rank &&
+                           std::is_same<Tag, void>::value),
+                          void>::type
+  apply(Args&&... args) const {
+    m_func(args...);
+  }
 
-    template <typename... Args>
-    typename std::enable_if<( sizeof...(Args) == RP::rank && std::is_same<Tag,void>::value), void>::type
-    apply(Args &&... args) const
-    {
-      m_func(args...);
-    }
-
-    template <typename... Args>
-    typename std::enable_if<( sizeof...(Args) == RP::rank && !std::is_same<Tag,void>::value), void>::type
-    apply(Args &&... args) const
-    {
-      m_func( m_tag, args...);
-    }
-
+  template <typename... Args>
+  typename std::enable_if<(sizeof...(Args) == RP::rank &&
+                           !std::is_same<Tag, void>::value),
+                          void>::type
+  apply(Args&&... args) const {
+    m_func(m_tag, args...);
+  }
 
-  RP         const& m_rp;
-  Functor    const& m_func;
-  typename std::conditional< std::is_same<Tag,void>::value,int,Tag>::type m_tag;
+  RP const& m_rp;
+  Functor const& m_func;
+  typename std::conditional<std::is_same<Tag, void>::value, int, Tag>::type
+      m_tag;
 };
 
-
 // For ParallelReduce
 // ValueType - scalar: For reductions
-template < typename RP
-         , typename Functor
-         , typename Tag
-         , typename ValueType
-         >
-struct HostIterateTile < RP , Functor , Tag , ValueType , typename std::enable_if< !is_void_type<ValueType >::value && !is_type_array<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct HostIterateTile<
+    RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_void_type<ValueType>::value &&
+                            !is_type_array<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
   using point_type = typename RP::point_type;
 
   using value_type = ValueType;
 
-  inline
-  HostIterateTile( RP const& rp, Functor const& func, value_type & v )
-    : m_rp(rp) //Cuda 7.0 does not like braces...
-    , m_func(func)
-    , m_v(v) // use with non-void ValueType struct
+  inline HostIterateTile(RP const& rp, Functor const& func, value_type& v)
+      : m_rp(rp)  // Cuda 7.0 does not like braces...
+        ,
+        m_func(func),
+        m_v(v)  // use with non-void ValueType struct
   {
-// Errors due to braces rather than parenthesis for init (with cuda 7.0)
-//      /home/ndellin/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp:1216:98: error: too many braces around initializer for ‘int’ [-fpermissive]
-//      /home/ndellin/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp:1216:98: error: aggregate value used where an integer was expected
+    // Errors due to braces rather than parenthesis for init (with cuda 7.0)
+    //      /home/ndellin/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp:1216:98:
+    //      error: too many braces around initializer for ‘int’ [-fpermissive]
+    //      /home/ndellin/kokkos/core/src/impl/KokkosExp_Host_IterateTile.hpp:1216:98:
+    //      error: aggregate value used where an integer was expected
   }
 
-  inline
-  bool check_iteration_bounds( point_type& partial_tile , point_type& offset ) const {
+  inline bool check_iteration_bounds(point_type& partial_tile,
+                                     point_type& offset) const {
     bool is_full_tile = true;
 
-      for ( int i = 0; i < RP::rank; ++i ) {
-        if ((offset[i] + m_rp.m_tile[i]) <= m_rp.m_upper[i]) {
-            partial_tile[i] = m_rp.m_tile[i] ;
-        }
-        else {
-          is_full_tile = false ;
-            partial_tile[i] = (m_rp.m_upper[i] - 1 - offset[i]) == 0 ? 1
-                            : (m_rp.m_upper[i] - m_rp.m_tile[i]) > 0 ? (m_rp.m_upper[i] - offset[i])
-                            : (m_rp.m_upper[i] - m_rp.m_lower[i]) ; // when single tile encloses range
-        }
+    for (int i = 0; i < RP::rank; ++i) {
+      if ((offset[i] + m_rp.m_tile[i]) <= m_rp.m_upper[i]) {
+        partial_tile[i] = m_rp.m_tile[i];
+      } else {
+        is_full_tile = false;
+        partial_tile[i] =
+            (m_rp.m_upper[i] - 1 - offset[i]) == 0
+                ? 1
+                : (m_rp.m_upper[i] - m_rp.m_tile[i]) > 0
+                      ? (m_rp.m_upper[i] - offset[i])
+                      : (m_rp.m_upper[i] -
+                         m_rp.m_lower[i]);  // when single tile encloses range
       }
+    }
 
-    return is_full_tile ;
-  } // end check bounds
-
+    return is_full_tile;
+  }  // end check bounds
 
   template <int Rank>
-  struct RankTag
-  {
+  struct RankTag {
     typedef RankTag type;
     enum { value = (int)Rank };
   };
 
-
 #if KOKKOS_ENABLE_NEW_LOOP_MACROS
   template <typename IType>
-  inline
-  void
-  operator()(IType tile_idx) const
-  {
+  inline void operator()(IType tile_idx) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
-
-    Tile_Loop_Type< RP::rank, (RP::inner_direction == RP::Left), index_type, Tag >::apply( m_v, m_func, full_tile, m_offset, m_rp.m_tile, m_tiledims );
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
+    Tile_Loop_Type<RP::rank, (RP::inner_direction == RP::Left), index_type,
+                   Tag>::apply(m_v, m_func, full_tile, m_offset, m_rp.m_tile,
+                               m_tiledims);
   }
 
 #else
   template <typename IType>
-  inline
-  void
-  operator()(IType tile_idx) const
-  { operator_impl( tile_idx , RankTag<RP::rank>() ); }
-  // added due to compiler error when using sfinae to choose operator based on rank
-
+  inline void operator()(IType tile_idx) const {
+    operator_impl(tile_idx, RankTag<RP::rank>());
+  }
+  // added due to compiler error when using sfinae to choose operator based on
+  // rank
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<2> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<2>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_2L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
-//      #pragma simd
-        LOOP_2L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+        //      #pragma simd
+        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_2R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
-//      #pragma simd
-        LOOP_2R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+        //      #pragma simd
+        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 2
+    }  // end RP::Right
 
+  }  // end op() rank == 2
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<3> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<3>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_3L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
-//      #pragma simd
-        LOOP_3L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+        //      #pragma simd
+        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_3R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
-//      #pragma simd
-        LOOP_3R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+        //      #pragma simd
+        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 3
+    }  // end RP::Right
 
+  }  // end op() rank == 3
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<4> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<4>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_4L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
-//      #pragma simd
-        LOOP_4L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+        //      #pragma simd
+        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_4R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
-//      #pragma simd
-        LOOP_4R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+        //      #pragma simd
+        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 4
+    }  // end RP::Right
 
+  }  // end op() rank == 4
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<5> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<5>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_5L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
-//      #pragma simd
-        LOOP_5L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+        //      #pragma simd
+        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_5R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
-//      #pragma simd
-        LOOP_5R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+        //      #pragma simd
+        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 5
+    }  // end RP::Right
 
+  }  // end op() rank == 5
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<6> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<6>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_6L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
-//      #pragma simd
-        LOOP_6L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+        //      #pragma simd
+        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_6R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
-//      #pragma simd
-        LOOP_6R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+        //      #pragma simd
+        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 6
+    }  // end RP::Right
 
+  }  // end op() rank == 6
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<7> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<7>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_7L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
-//      #pragma simd
-        LOOP_7L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+        //      #pragma simd
+        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_7R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
-//      #pragma simd
-        LOOP_7R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+        //      #pragma simd
+        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 7
+    }  // end RP::Right
 
+  }  // end op() rank == 7
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<8> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<8>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_8L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
-//      #pragma simd
-        LOOP_8L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+        //      #pragma simd
+        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_8R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
-//      #pragma simd
-        LOOP_8R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+        //      #pragma simd
+        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
-    } // end RP::Right
+    }  // end RP::Right
 
-  } //end op() rank == 8
+  }  // end op() rank == 8
 #endif
 
+  template <typename... Args>
+  typename std::enable_if<(sizeof...(Args) == RP::rank &&
+                           std::is_same<Tag, void>::value),
+                          void>::type
+  apply(Args&&... args) const {
+    m_func(args..., m_v);
+  }
 
-    template <typename... Args>
-    typename std::enable_if<( sizeof...(Args) == RP::rank && std::is_same<Tag,void>::value), void>::type
-    apply(Args &&... args) const
-    {
-      m_func(args... , m_v);
-    }
-
-    template <typename... Args>
-    typename std::enable_if<( sizeof...(Args) == RP::rank && !std::is_same<Tag,void>::value), void>::type
-    apply(Args &&... args) const
-    {
-      m_func( m_tag, args... , m_v);
-    }
-
-
-  RP         const& m_rp;
-  Functor    const& m_func;
-  value_type  & m_v;
-  typename std::conditional< std::is_same<Tag,void>::value,int,Tag>::type m_tag;
+  template <typename... Args>
+  typename std::enable_if<(sizeof...(Args) == RP::rank &&
+                           !std::is_same<Tag, void>::value),
+                          void>::type
+  apply(Args&&... args) const {
+    m_func(m_tag, args..., m_v);
+  }
 
+  RP const& m_rp;
+  Functor const& m_func;
+  value_type& m_v;
+  typename std::conditional<std::is_same<Tag, void>::value, int, Tag>::type
+      m_tag;
 };
 
-
 // For ParallelReduce
 // Extra specialization for array reductions
 // ValueType[]: For array reductions
-template < typename RP
-         , typename Functor
-         , typename Tag
-         , typename ValueType
-         >
-struct HostIterateTile < RP , Functor , Tag , ValueType , typename std::enable_if< !is_void_type<ValueType >::value && is_type_array<ValueType>::value >::type >
-{
+template <typename RP, typename Functor, typename Tag, typename ValueType>
+struct HostIterateTile<
+    RP, Functor, Tag, ValueType,
+    typename std::enable_if<!is_void_type<ValueType>::value &&
+                            is_type_array<ValueType>::value>::type> {
   using index_type = typename RP::index_type;
   using point_type = typename RP::point_type;
 
-  using value_type = typename is_type_array<ValueType>::value_type; // strip away the 'array-ness' [], only underlying type remains
-
-  inline
-  HostIterateTile( RP const& rp, Functor const& func, value_type *v ) // v should be an array; treat as pointer for compatibility since size is not known nor needed here
-    : m_rp(rp) //Cuda 7.0 does not like braces...
-    , m_func(func)
-    , m_v(v) // use with non-void ValueType struct
+  using value_type =
+      typename is_type_array<ValueType>::value_type;  // strip away the
+                                                      // 'array-ness' [], only
+                                                      // underlying type remains
+
+  inline HostIterateTile(
+      RP const& rp, Functor const& func,
+      value_type* v)  // v should be an array; treat as pointer for
+                      // compatibility since size is not known nor needed here
+      : m_rp(rp)      // Cuda 7.0 does not like braces...
+        ,
+        m_func(func),
+        m_v(v)  // use with non-void ValueType struct
   {}
 
-  inline
-  bool check_iteration_bounds( point_type& partial_tile , point_type& offset ) const {
+  inline bool check_iteration_bounds(point_type& partial_tile,
+                                     point_type& offset) const {
     bool is_full_tile = true;
 
-      for ( int i = 0; i < RP::rank; ++i ) {
-        if ((offset[i] + m_rp.m_tile[i]) <= m_rp.m_upper[i]) {
-            partial_tile[i] = m_rp.m_tile[i] ;
-        }
-        else {
-          is_full_tile = false ;
-            partial_tile[i] = (m_rp.m_upper[i] - 1 - offset[i]) == 0 ? 1
-                            : (m_rp.m_upper[i] - m_rp.m_tile[i]) > 0 ? (m_rp.m_upper[i] - offset[i])
-                            : (m_rp.m_upper[i] - m_rp.m_lower[i]) ; // when single tile encloses range
-        }
+    for (int i = 0; i < RP::rank; ++i) {
+      if ((offset[i] + m_rp.m_tile[i]) <= m_rp.m_upper[i]) {
+        partial_tile[i] = m_rp.m_tile[i];
+      } else {
+        is_full_tile = false;
+        partial_tile[i] =
+            (m_rp.m_upper[i] - 1 - offset[i]) == 0
+                ? 1
+                : (m_rp.m_upper[i] - m_rp.m_tile[i]) > 0
+                      ? (m_rp.m_upper[i] - offset[i])
+                      : (m_rp.m_upper[i] -
+                         m_rp.m_lower[i]);  // when single tile encloses range
       }
+    }
 
-    return is_full_tile ;
-  } // end check bounds
-
+    return is_full_tile;
+  }  // end check bounds
 
   template <int Rank>
-  struct RankTag
-  {
+  struct RankTag {
     typedef RankTag type;
     enum { value = (int)Rank };
   };
 
-
 #if KOKKOS_ENABLE_NEW_LOOP_MACROS
   template <typename IType>
-  inline
-  void
-  operator()(IType tile_idx) const
-  {
+  inline void operator()(IType tile_idx) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
-
-    Tile_Loop_Type< RP::rank, (RP::inner_direction == RP::Left), index_type, Tag >::apply( m_v, m_func, full_tile, m_offset, m_rp.m_tile, m_tiledims );
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
+    Tile_Loop_Type<RP::rank, (RP::inner_direction == RP::Left), index_type,
+                   Tag>::apply(m_v, m_func, full_tile, m_offset, m_rp.m_tile,
+                               m_tiledims);
   }
 
 #else
   template <typename IType>
-  inline
-  void
-  operator()(IType tile_idx) const
-  { operator_impl( tile_idx , RankTag<RP::rank>() ); }
-  // added due to compiler error when using sfinae to choose operator based on rank
-
+  inline void operator()(IType tile_idx) const {
+    operator_impl(tile_idx, RankTag<RP::rank>());
+  }
+  // added due to compiler error when using sfinae to choose operator based on
+  // rank
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<2> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<2>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_2L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
-//      #pragma simd
-        LOOP_2L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+        //      #pragma simd
+        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_2R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
-//      #pragma simd
-        LOOP_2R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_2 );
-        }
+        //      #pragma simd
+        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 2
+    }  // end RP::Right
 
+  }  // end op() rank == 2
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<3> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<3>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_3L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
-//      #pragma simd
-        LOOP_3L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+        //      #pragma simd
+        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_3R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
-//      #pragma simd
-        LOOP_3R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_3 );
-        }
+        //      #pragma simd
+        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 3
+    }  // end RP::Right
 
+  }  // end op() rank == 3
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<4> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<4>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_4L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
-//      #pragma simd
-        LOOP_4L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+        //      #pragma simd
+        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_4R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
-//      #pragma simd
-        LOOP_4R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_4 );
-        }
+        //      #pragma simd
+        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 4
+    }  // end RP::Right
 
+  }  // end op() rank == 4
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<5> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<5>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_5L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
-//      #pragma simd
-        LOOP_5L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+        //      #pragma simd
+        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_5R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
-//      #pragma simd
-        LOOP_5R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_5 );
-        }
+        //      #pragma simd
+        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 5
+    }  // end RP::Right
 
+  }  // end op() rank == 5
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<6> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<6>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_6L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
-//      #pragma simd
-        LOOP_6L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+        //      #pragma simd
+        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_6R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
-//      #pragma simd
-        LOOP_6R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_6 );
-        }
+        //      #pragma simd
+        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 6
+    }  // end RP::Right
 
+  }  // end op() rank == 6
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<7> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<7>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_7L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
-//      #pragma simd
-        LOOP_7L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+        //      #pragma simd
+        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_7R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
-//      #pragma simd
-        LOOP_7R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_7 );
-        }
+        //      #pragma simd
+        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
-    } // end RP::Right
-
-  } //end op() rank == 7
+    }  // end RP::Right
 
+  }  // end op() rank == 7
 
   template <typename IType>
-  inline
-  void operator_impl( IType tile_idx , const RankTag<8> ) const
-  {
+  inline void operator_impl(IType tile_idx, const RankTag<8>) const {
     point_type m_offset;
     point_type m_tiledims;
 
     if (RP::outer_direction == RP::Left) {
-      for (int i=0; i<RP::rank; ++i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+      for (int i = 0; i < RP::rank; ++i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
-    }
-    else {
-      for (int i=RP::rank-1; i>=0; --i) {
-        m_offset[i] = (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i] ;
+    } else {
+      for (int i = RP::rank - 1; i >= 0; --i) {
+        m_offset[i] =
+            (tile_idx % m_rp.m_tile_end[i]) * m_rp.m_tile[i] + m_rp.m_lower[i];
         tile_idx /= m_rp.m_tile_end[i];
       }
     }
 
-    //Check if offset+tiledim in bounds - if not, replace tile dims with the partial tile dims
-    const bool full_tile = check_iteration_bounds(m_tiledims , m_offset) ;
+    // Check if offset+tiledim in bounds - if not, replace tile dims with the
+    // partial tile dims
+    const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     if (RP::inner_direction == RP::Left) {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_8L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
-//      #pragma simd
-        LOOP_8L(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+        //      #pragma simd
+        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
-    } // end RP::Left
+    }  // end RP::Left
     else {
-     if ( full_tile ) {
-//      #pragma simd
-        LOOP_8R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+      if (full_tile) {
+        //      #pragma simd
+        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
-//      #pragma simd
-        LOOP_8R(index_type, m_tiledims) {
-          apply( LOOP_ARGS_8 );
-        }
+        //      #pragma simd
+        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
-    } // end RP::Right
+    }  // end RP::Right
 
-  } //end op() rank == 8
+  }  // end op() rank == 8
 #endif
 
+  template <typename... Args>
+  typename std::enable_if<(sizeof...(Args) == RP::rank &&
+                           std::is_same<Tag, void>::value),
+                          void>::type
+  apply(Args&&... args) const {
+    m_func(args..., m_v);
+  }
 
-    template <typename... Args>
-    typename std::enable_if<( sizeof...(Args) == RP::rank && std::is_same<Tag,void>::value), void>::type
-    apply(Args &&... args) const
-    {
-      m_func(args... , m_v);
-    }
-
-    template <typename... Args>
-    typename std::enable_if<( sizeof...(Args) == RP::rank && !std::is_same<Tag,void>::value), void>::type
-    apply(Args &&... args) const
-    {
-      m_func( m_tag, args... , m_v);
-    }
-
-
-  RP         const& m_rp;
-  Functor    const& m_func;
-  value_type * m_v;
-  typename std::conditional< std::is_same<Tag,void>::value,int,Tag>::type m_tag;
+  template <typename... Args>
+  typename std::enable_if<(sizeof...(Args) == RP::rank &&
+                           !std::is_same<Tag, void>::value),
+                          void>::type
+  apply(Args&&... args) const {
+    m_func(m_tag, args..., m_v);
+  }
 
+  RP const& m_rp;
+  Functor const& m_func;
+  value_type* m_v;
+  typename std::conditional<std::is_same<Tag, void>::value, int, Tag>::type
+      m_tag;
 };
 
-
 // ------------------------------------------------------------------ //
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
@@ -2751,138 +2799,96 @@ struct HostIterateTile < RP , Functor , Tag , ValueType , typename std::enable_i
 // Cuda uses DeviceIterateTile directly within md_parallel_for
 // TODO Once md_parallel_{for,reduce} removed, this can be removed
 
-namespace Experimental { 
+namespace Experimental {
 
 // ParallelReduce - scalar reductions
-template < typename MDRange, typename Functor, typename ValueType = void >
-struct MDFunctor
-{
+template <typename MDRange, typename Functor, typename ValueType = void>
+struct MDFunctor {
   using range_policy = MDRange;
   using functor_type = Functor;
   using value_type   = ValueType;
   using work_tag     = typename range_policy::work_tag;
   using index_type   = typename range_policy::index_type;
-  using iterate_type = typename Kokkos::Impl::HostIterateTile< MDRange
-                                                             , Functor
-                                                             , work_tag
-                                                             , value_type
-                                                             >;
-
+  using iterate_type =
+      typename Kokkos::Impl::HostIterateTile<MDRange, Functor, work_tag,
+                                             value_type>;
 
-  inline
-  MDFunctor( MDRange const& range, Functor const& f )
-    : m_range( range )
-    , m_func( f )
-  {}
+  inline MDFunctor(MDRange const& range, Functor const& f)
+      : m_range(range), m_func(f) {}
 
-  inline
-  MDFunctor( MDFunctor const& ) = default;
+  inline MDFunctor(MDFunctor const&) = default;
 
-  inline
-  MDFunctor& operator=( MDFunctor const& ) = default;
+  inline MDFunctor& operator=(MDFunctor const&) = default;
 
-  inline
-  MDFunctor( MDFunctor && ) = default;
+  inline MDFunctor(MDFunctor&&) = default;
 
-  inline
-  MDFunctor& operator=( MDFunctor && ) = default;
+  inline MDFunctor& operator=(MDFunctor&&) = default;
 
-  inline
-  void operator()(index_type t, value_type & v) const
-  {
+  inline void operator()(index_type t, value_type& v) const {
     iterate_type(m_range, m_func, v)(t);
   }
 
-  MDRange   m_range;
-  Functor   m_func;
+  MDRange m_range;
+  Functor m_func;
 };
 
-
-// ParallelReduce - array reductions 
-template < typename MDRange, typename Functor, typename ValueType >
-struct MDFunctor< MDRange, Functor, ValueType[] >
-{
+// ParallelReduce - array reductions
+template <typename MDRange, typename Functor, typename ValueType>
+struct MDFunctor<MDRange, Functor, ValueType[]> {
   using range_policy = MDRange;
   using functor_type = Functor;
   using value_type   = ValueType[];
   using work_tag     = typename range_policy::work_tag;
   using index_type   = typename range_policy::index_type;
-  using iterate_type = typename Kokkos::Impl::HostIterateTile< MDRange
-                                                             , Functor
-                                                             , work_tag
-                                                             , value_type
-                                                             >;
-
-
-  inline
-  MDFunctor( MDRange const& range, Functor const& f )
-    : m_range( range )
-    , m_func( f )
-    , value_count( f.value_count )
-  {}
+  using iterate_type =
+      typename Kokkos::Impl::HostIterateTile<MDRange, Functor, work_tag,
+                                             value_type>;
 
-  inline
-  MDFunctor( MDFunctor const& ) = default;
+  inline MDFunctor(MDRange const& range, Functor const& f)
+      : m_range(range), m_func(f), value_count(f.value_count) {}
 
-  inline
-  MDFunctor& operator=( MDFunctor const& ) = default;
+  inline MDFunctor(MDFunctor const&) = default;
 
-  inline
-  MDFunctor( MDFunctor && ) = default;
+  inline MDFunctor& operator=(MDFunctor const&) = default;
 
-  inline
-  MDFunctor& operator=( MDFunctor && ) = default;
+  inline MDFunctor(MDFunctor&&) = default;
 
-  // FIXME Init and Join, as defined in m_func, are not working through the MDFunctor
-  // Best path forward is to eliminate need for MDFunctor, directly use MDRangePolicy within Parallel{For,Reduce} ??
-  inline
-  void operator()(index_type t, value_type v) const
-  {
+  inline MDFunctor& operator=(MDFunctor&&) = default;
+
+  // FIXME Init and Join, as defined in m_func, are not working through the
+  // MDFunctor Best path forward is to eliminate need for MDFunctor, directly
+  // use MDRangePolicy within Parallel{For,Reduce} ??
+  inline void operator()(index_type t, value_type v) const {
     iterate_type(m_range, m_func, v)(t);
   }
 
-  MDRange   m_range;
-  Functor   m_func;
-  size_t    value_count;
+  MDRange m_range;
+  Functor m_func;
+  size_t value_count;
 };
 
-
 // ParallelFor
-template < typename MDRange, typename Functor >
-struct MDFunctor< MDRange, Functor, void >
-{
+template <typename MDRange, typename Functor>
+struct MDFunctor<MDRange, Functor, void> {
   using range_policy = MDRange;
   using functor_type = Functor;
   using work_tag     = typename range_policy::work_tag;
   using index_type   = typename range_policy::index_type;
-  using iterate_type = typename Kokkos::Impl::HostIterateTile< MDRange
-                                                             , Functor
-                                                             , work_tag
-                                                             , void
-                                                             >;
+  using iterate_type =
+      typename Kokkos::Impl::HostIterateTile<MDRange, Functor, work_tag, void>;
 
+  inline MDFunctor(MDRange const& range, Functor const& f)
+      : m_range(range), m_func(f) {}
 
-  inline
-  MDFunctor( MDRange const& range, Functor const& f )
-    : m_range( range )
-    , m_func( f )
-  {}
-
-  inline
-  MDFunctor( MDFunctor const& ) = default;
+  inline MDFunctor(MDFunctor const&) = default;
 
-  inline
-  MDFunctor& operator=( MDFunctor const& ) = default;
+  inline MDFunctor& operator=(MDFunctor const&) = default;
 
-  inline
-  MDFunctor( MDFunctor && ) = default;
+  inline MDFunctor(MDFunctor&&) = default;
 
-  inline
-  MDFunctor& operator=( MDFunctor && ) = default;
+  inline MDFunctor& operator=(MDFunctor&&) = default;
 
-  inline
-  void operator()(index_type t) const
-  {
+  inline void operator()(index_type t) const {
     iterate_type(m_range, m_func)(t);
   }
 
@@ -2890,10 +2896,11 @@ struct MDFunctor< MDRange, Functor, void >
   Functor m_func;
 };
 
-} // end namespace Experimental
+}  // end namespace Experimental
 #endif
 #undef KOKKOS_ENABLE_NEW_LOOP_MACROS
 
-} } //end namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/impl/KokkosExp_ViewMapping.hpp b/lib/kokkos/core/src/impl/KokkosExp_ViewMapping.hpp
index 0bfc5841dfb0487419c20c9849cb00f68db3cef9..a41ffb1e8a0572b4b1a06be8c27bfab0126c9500 100644
--- a/lib/kokkos/core/src/impl/KokkosExp_ViewMapping.hpp
+++ b/lib/kokkos/core/src/impl/KokkosExp_ViewMapping.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
diff --git a/lib/kokkos/core/src/impl/Kokkos_AnalyzePolicy.hpp b/lib/kokkos/core/src/impl/Kokkos_AnalyzePolicy.hpp
index 50af5ec82e41104fb8129d42f4467dd16a14d282..ac8665143347554acb3fa5a4184f3573c55030c4 100644
--- a/lib/kokkos/core/src/impl/Kokkos_AnalyzePolicy.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_AnalyzePolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,207 +49,185 @@
 #include <Kokkos_Concepts.hpp>
 #include <impl/Kokkos_Tags.hpp>
 
-namespace Kokkos { namespace Impl {
-
-template < typename ExecutionSpace   = void
-         , typename Schedule         = void
-         , typename WorkTag          = void
-         , typename IndexType        = void
-         , typename IterationPattern = void
-         , typename LaunchBounds     = void
-         , typename MyWorkItemProperty = Kokkos::Experimental::WorkItemProperty::None_t
-         >
-struct PolicyTraitsBase
-{
-  using type = PolicyTraitsBase< ExecutionSpace, Schedule, WorkTag, IndexType, 
-               IterationPattern, LaunchBounds, MyWorkItemProperty>;
-
-  using execution_space   = ExecutionSpace;
-  using schedule_type     = Schedule;
-  using work_tag          = WorkTag;
-  using index_type        = IndexType;
-  using iteration_pattern = IterationPattern;
-  using launch_bounds     = LaunchBounds;
+namespace Kokkos {
+namespace Impl {
+
+template <typename ExecutionSpace = void, typename Schedule = void,
+          typename WorkTag = void, typename IndexType = void,
+          typename IterationPattern = void, typename LaunchBounds = void,
+          typename MyWorkItemProperty =
+              Kokkos::Experimental::WorkItemProperty::None_t>
+struct PolicyTraitsBase {
+  using type =
+      PolicyTraitsBase<ExecutionSpace, Schedule, WorkTag, IndexType,
+                       IterationPattern, LaunchBounds, MyWorkItemProperty>;
+
+  using execution_space    = ExecutionSpace;
+  using schedule_type      = Schedule;
+  using work_tag           = WorkTag;
+  using index_type         = IndexType;
+  using iteration_pattern  = IterationPattern;
+  using launch_bounds      = LaunchBounds;
   using work_item_property = MyWorkItemProperty;
 };
 
 template <typename PolicyBase, typename Property>
-struct SetWorkItemProperty
-{
-  static_assert( std::is_same<typename PolicyBase::work_item_property,Kokkos::Experimental::WorkItemProperty::None_t>::value
-               , "Kokkos Error: More than one work item property given" );
-  using type = PolicyTraitsBase< typename PolicyBase::execution_space
-                               , typename PolicyBase::schedule_type
-                               , typename PolicyBase::work_tag
-                               , typename PolicyBase::index_type
-                               , typename PolicyBase::iteration_pattern
-                               , typename PolicyBase::launch_bounds
-                               , Property
-                               >;
+struct SetWorkItemProperty {
+  static_assert(
+      std::is_same<typename PolicyBase::work_item_property,
+                   Kokkos::Experimental::WorkItemProperty::None_t>::value,
+      "Kokkos Error: More than one work item property given");
+  using type = PolicyTraitsBase<
+      typename PolicyBase::execution_space, typename PolicyBase::schedule_type,
+      typename PolicyBase::work_tag, typename PolicyBase::index_type,
+      typename PolicyBase::iteration_pattern,
+      typename PolicyBase::launch_bounds, Property>;
 };
 
 template <typename PolicyBase, typename ExecutionSpace>
-struct SetExecutionSpace
-{
-  static_assert( is_void<typename PolicyBase::execution_space>::value
-               , "Kokkos Error: More than one execution space given" );
-  using type = PolicyTraitsBase< ExecutionSpace
-                               , typename PolicyBase::schedule_type
-                               , typename PolicyBase::work_tag
-                               , typename PolicyBase::index_type
-                               , typename PolicyBase::iteration_pattern
-                               , typename PolicyBase::launch_bounds
-                               , typename PolicyBase::work_item_property
-                               >;
+struct SetExecutionSpace {
+  static_assert(is_void<typename PolicyBase::execution_space>::value,
+                "Kokkos Error: More than one execution space given");
+  using type =
+      PolicyTraitsBase<ExecutionSpace, typename PolicyBase::schedule_type,
+                       typename PolicyBase::work_tag,
+                       typename PolicyBase::index_type,
+                       typename PolicyBase::iteration_pattern,
+                       typename PolicyBase::launch_bounds,
+                       typename PolicyBase::work_item_property>;
 };
 
 template <typename PolicyBase, typename Schedule>
-struct SetSchedule
-{
-  static_assert( is_void<typename PolicyBase::schedule_type>::value
-               , "Kokkos Error: More than one schedule type given" );
-  using type = PolicyTraitsBase< typename PolicyBase::execution_space
-                               , Schedule
-                               , typename PolicyBase::work_tag
-                               , typename PolicyBase::index_type
-                               , typename PolicyBase::iteration_pattern
-                               , typename PolicyBase::launch_bounds
-                               , typename PolicyBase::work_item_property
-                               >;
+struct SetSchedule {
+  static_assert(is_void<typename PolicyBase::schedule_type>::value,
+                "Kokkos Error: More than one schedule type given");
+  using type = PolicyTraitsBase<typename PolicyBase::execution_space, Schedule,
+                                typename PolicyBase::work_tag,
+                                typename PolicyBase::index_type,
+                                typename PolicyBase::iteration_pattern,
+                                typename PolicyBase::launch_bounds,
+                                typename PolicyBase::work_item_property>;
 };
 
 template <typename PolicyBase, typename WorkTag>
-struct SetWorkTag
-{
-  static_assert( is_void<typename PolicyBase::work_tag>::value
-               , "Kokkos Error: More than one work tag given" );
-  using type = PolicyTraitsBase< typename PolicyBase::execution_space
-                               , typename PolicyBase::schedule_type
-                               , WorkTag
-                               , typename PolicyBase::index_type
-                               , typename PolicyBase::iteration_pattern
-                               , typename PolicyBase::launch_bounds
-                               , typename PolicyBase::work_item_property
-                               >;
+struct SetWorkTag {
+  static_assert(is_void<typename PolicyBase::work_tag>::value,
+                "Kokkos Error: More than one work tag given");
+  using type = PolicyTraitsBase<typename PolicyBase::execution_space,
+                                typename PolicyBase::schedule_type, WorkTag,
+                                typename PolicyBase::index_type,
+                                typename PolicyBase::iteration_pattern,
+                                typename PolicyBase::launch_bounds,
+                                typename PolicyBase::work_item_property>;
 };
 
 template <typename PolicyBase, typename IndexType>
-struct SetIndexType
-{
-  static_assert( is_void<typename PolicyBase::index_type>::value
-               , "Kokkos Error: More than one index type given" );
-  using type = PolicyTraitsBase< typename PolicyBase::execution_space
-                               , typename PolicyBase::schedule_type
-                               , typename PolicyBase::work_tag
-                               , IndexType
-                               , typename PolicyBase::iteration_pattern
-                               , typename PolicyBase::launch_bounds
-                               , typename PolicyBase::work_item_property
-                               >;
+struct SetIndexType {
+  static_assert(is_void<typename PolicyBase::index_type>::value,
+                "Kokkos Error: More than one index type given");
+  using type = PolicyTraitsBase<typename PolicyBase::execution_space,
+                                typename PolicyBase::schedule_type,
+                                typename PolicyBase::work_tag, IndexType,
+                                typename PolicyBase::iteration_pattern,
+                                typename PolicyBase::launch_bounds,
+                                typename PolicyBase::work_item_property>;
 };
 
-
 template <typename PolicyBase, typename IterationPattern>
-struct SetIterationPattern
-{
-  static_assert( is_void<typename PolicyBase::iteration_pattern>::value
-               , "Kokkos Error: More than one iteration_pattern given" );
-  using type = PolicyTraitsBase< typename PolicyBase::execution_space
-                               , typename PolicyBase::schedule_type
-                               , typename PolicyBase::work_tag
-                               , typename PolicyBase::index_type
-                               , IterationPattern
-                               , typename PolicyBase::launch_bounds
-                               , typename PolicyBase::work_item_property
-                               >;
+struct SetIterationPattern {
+  static_assert(is_void<typename PolicyBase::iteration_pattern>::value,
+                "Kokkos Error: More than one iteration_pattern given");
+  using type = PolicyTraitsBase<
+      typename PolicyBase::execution_space, typename PolicyBase::schedule_type,
+      typename PolicyBase::work_tag, typename PolicyBase::index_type,
+      IterationPattern, typename PolicyBase::launch_bounds,
+      typename PolicyBase::work_item_property>;
 };
 
-
 template <typename PolicyBase, typename LaunchBounds>
-struct SetLaunchBounds
-{
-  static_assert( is_void<typename PolicyBase::launch_bounds>::value
-               , "Kokkos Error: More than one launch_bounds given" );
-  using type = PolicyTraitsBase< typename PolicyBase::execution_space
-                               , typename PolicyBase::schedule_type
-                               , typename PolicyBase::work_tag
-                               , typename PolicyBase::index_type
-                               , typename PolicyBase::iteration_pattern
-                               , LaunchBounds
-                               , typename PolicyBase::work_item_property
-                               >;
+struct SetLaunchBounds {
+  static_assert(is_void<typename PolicyBase::launch_bounds>::value,
+                "Kokkos Error: More than one launch_bounds given");
+  using type = PolicyTraitsBase<
+      typename PolicyBase::execution_space, typename PolicyBase::schedule_type,
+      typename PolicyBase::work_tag, typename PolicyBase::index_type,
+      typename PolicyBase::iteration_pattern, LaunchBounds,
+      typename PolicyBase::work_item_property>;
 };
 
-
 template <typename Base, typename... Traits>
 struct AnalyzePolicy;
 
 template <typename Base, typename T, typename... Traits>
-struct AnalyzePolicy<Base, T, Traits...> : public
-  AnalyzePolicy<
-      typename std::conditional< is_execution_space<T>::value  , SetExecutionSpace<Base,T>
-    , typename std::conditional< is_schedule_type<T>::value    , SetSchedule<Base,T>
-    , typename std::conditional< is_index_type<T>::value       , SetIndexType<Base,T>
-    , typename std::conditional< std::is_integral<T>::value    , SetIndexType<Base, IndexType<T> >
-    , typename std::conditional< is_iteration_pattern<T>::value, SetIterationPattern<Base,T>
-    , typename std::conditional< is_launch_bounds<T>::value    , SetLaunchBounds<Base,T>
-    , typename std::conditional< Experimental::is_work_item_property<T>::value, SetWorkItemProperty<Base,T>
-    , SetWorkTag<Base,T>
-    >::type >::type >::type >::type >::type>::type>::type::type
-  , Traits...
-  >
-{};
+struct AnalyzePolicy<Base, T, Traits...>
+    : public AnalyzePolicy<
+          typename std::conditional<
+              is_execution_space<T>::value, SetExecutionSpace<Base, T>,
+              typename std::conditional<
+                  is_schedule_type<T>::value, SetSchedule<Base, T>,
+                  typename std::conditional<
+                      is_index_type<T>::value, SetIndexType<Base, T>,
+                      typename std::conditional<
+                          std::is_integral<T>::value,
+                          SetIndexType<Base, IndexType<T> >,
+                          typename std::conditional<
+                              is_iteration_pattern<T>::value,
+                              SetIterationPattern<Base, T>,
+                              typename std::conditional<
+                                  is_launch_bounds<T>::value,
+                                  SetLaunchBounds<Base, T>,
+                                  typename std::conditional<
+                                      Experimental::is_work_item_property<
+                                          T>::value,
+                                      SetWorkItemProperty<Base, T>,
+                                      SetWorkTag<Base, T> >::type>::type>::
+                              type>::type>::type>::type>::type::type,
+          Traits...> {};
 
 template <typename Base>
-struct AnalyzePolicy<Base>
-{
-  using execution_space = typename std::conditional< is_void< typename Base::execution_space >::value
-                                                   , DefaultExecutionSpace
-                                                   , typename Base::execution_space
-                                                   >::type;
-
-  using schedule_type = typename std::conditional< is_void< typename Base::schedule_type >::value
-                                                 , Schedule< Static >
-                                                 , typename Base::schedule_type
-                                                 >::type;
+struct AnalyzePolicy<Base> {
+  using execution_space =
+      typename std::conditional<is_void<typename Base::execution_space>::value,
+                                DefaultExecutionSpace,
+                                typename Base::execution_space>::type;
+
+  using schedule_type =
+      typename std::conditional<is_void<typename Base::schedule_type>::value,
+                                Schedule<Static>,
+                                typename Base::schedule_type>::type;
 
   using work_tag = typename Base::work_tag;
 
-  using index_type = typename std::conditional< is_void< typename Base::index_type >::value
-                                              , IndexType< typename execution_space::size_type >
-                                              , typename Base::index_type
-                                              >::type
-                                               ::type // nasty hack to make index_type into an integral_type
-                                              ;       // instead of the wrapped IndexType<T> for backwards compatibility
+  using index_type =
+      typename std::conditional<is_void<typename Base::index_type>::value,
+                                IndexType<typename execution_space::size_type>,
+                                typename Base::index_type>::type ::
+          type  // nasty hack to make index_type into an integral_type
+      ;  // instead of the wrapped IndexType<T> for backwards compatibility
 
-  using iteration_pattern = typename std::conditional< is_void< typename Base::iteration_pattern >::value
-                                                     , void // TODO set default iteration pattern
-                                                     , typename Base::iteration_pattern
-                                                     >::type;
+  using iteration_pattern = typename std::conditional<
+      is_void<typename Base::iteration_pattern>::value,
+      void  // TODO set default iteration pattern
+      ,
+      typename Base::iteration_pattern>::type;
 
-  using launch_bounds = typename std::conditional< is_void< typename Base::launch_bounds >::value
-                                                     , LaunchBounds<>
-                                                     , typename Base::launch_bounds
-                                                     >::type;
+  using launch_bounds =
+      typename std::conditional<is_void<typename Base::launch_bounds>::value,
+                                LaunchBounds<>,
+                                typename Base::launch_bounds>::type;
 
   using work_item_property = typename Base::work_item_property;
 
-  using type = PolicyTraitsBase< execution_space
-                               , schedule_type
-                               , work_tag
-                               , index_type
-                               , iteration_pattern
-                               , launch_bounds
-                               , work_item_property>;
+  using type =
+      PolicyTraitsBase<execution_space, schedule_type, work_tag, index_type,
+                       iteration_pattern, launch_bounds, work_item_property>;
 };
 
 template <typename... Traits>
 struct PolicyTraits
-  : public AnalyzePolicy< PolicyTraitsBase<>, Traits... >::type
-{};
-
-}} // namespace Kokkos::Impl
-
+    : public AnalyzePolicy<PolicyTraitsBase<>, Traits...>::type {};
 
-#endif //KOKKOS_IMPL_ANALYZE_POLICY_HPP
+}  // namespace Impl
+}  // namespace Kokkos
 
+#endif  // KOKKOS_IMPL_ANALYZE_POLICY_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Assembly.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Assembly.hpp
index c94309162219adf1250e84f00aa38d3e600d8866..786ffc902f641bef5961d2d871908db8d6a9dcc7 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Assembly.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Assembly.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,74 +43,62 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_ASSEMBLY_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_ASSEMBLY_HPP)
 #define KOKKOS_ATOMIC_ASSEMBLY_HPP
 namespace Kokkos {
 
 namespace Impl {
-  struct cas128_t
-  {
-    uint64_t lower;
-    uint64_t upper;
+struct cas128_t {
+  uint64_t lower;
+  uint64_t upper;
 
-    KOKKOS_INLINE_FUNCTION
-    cas128_t () {
-      lower = 0;
-      upper = 0;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    cas128_t (const cas128_t& a) {
-      lower = a.lower;
-      upper = a.upper;
-    }
-    KOKKOS_INLINE_FUNCTION
-    cas128_t (volatile cas128_t* a) {
-      lower = a->lower;
-      upper = a->upper;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    bool operator != (const cas128_t& a) const {
-      return (lower != a.lower) || upper!=a.upper;
-    }
+  KOKKOS_INLINE_FUNCTION
+  cas128_t() {
+    lower = 0;
+    upper = 0;
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void operator = (const cas128_t& a) {
-      lower = a.lower;
-      upper = a.upper;
-    }
-    KOKKOS_INLINE_FUNCTION
-    void operator = (const cas128_t& a) volatile {
-      lower = a.lower;
-      upper = a.upper;
-    }
+  KOKKOS_INLINE_FUNCTION
+  cas128_t(const cas128_t& a) {
+    lower = a.lower;
+    upper = a.upper;
+  }
+  KOKKOS_INLINE_FUNCTION
+  cas128_t(volatile cas128_t* a) {
+    lower = a->lower;
+    upper = a->upper;
   }
-  __attribute__ (( __aligned__( 16 ) ));
 
+  KOKKOS_INLINE_FUNCTION
+  bool operator!=(const cas128_t& a) const {
+    return (lower != a.lower) || upper != a.upper;
+  }
 
-  #if defined( KOKKOS_ENABLE_ASM ) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-  inline cas128_t cas128( volatile cas128_t * ptr, cas128_t cmp,  cas128_t swap )
-  {
-      bool swapped = false;
-      __asm__ __volatile__
-      (
-       "lock cmpxchg16b %1\n\t"
-       "setz %0"
-       : "=q" ( swapped )
-       , "+m" ( *ptr )
-       , "+d" ( cmp.upper )
-       , "+a" ( cmp.lower )
-       : "c" ( swap.upper )
-       , "b" ( swap.lower )
-       , "q" ( swapped )
-     );
-      return cmp;
+  KOKKOS_INLINE_FUNCTION
+  void operator=(const cas128_t& a) {
+    lower = a.lower;
+    upper = a.upper;
   }
-  #endif
+  KOKKOS_INLINE_FUNCTION
+  void operator=(const cas128_t& a) volatile {
+    lower = a.lower;
+    upper = a.upper;
+  }
+} __attribute__((__aligned__(16)));
 
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+inline cas128_t cas128(volatile cas128_t* ptr, cas128_t cmp, cas128_t swap) {
+  bool swapped = false;
+  __asm__ __volatile__(
+      "lock cmpxchg16b %1\n\t"
+      "setz %0"
+      : "=q"(swapped), "+m"(*ptr), "+d"(cmp.upper), "+a"(cmp.lower)
+      : "c"(swap.upper), "b"(swap.lower), "q"(swapped));
+  return cmp;
 }
-}
-
 #endif
 
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp
index 63067c137ace503e4e8360e89b5e4bb34eaa6f37..4fe72ad1426b358c8dd42973f0e928728c6f6843 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,16 +42,17 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_COMPARE_EXCHANGE_STRONG_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && \
+    !defined(KOKKOS_ATOMIC_COMPARE_EXCHANGE_STRONG_HPP)
 #define KOKKOS_ATOMIC_COMPARE_EXCHANGE_STRONG_HPP
 
 #if defined(KOKKOS_ENABLE_CUDA)
-#include<Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
+#include <Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
 #endif
 
 #include <impl/Kokkos_Atomic_Memory_Order.hpp>
@@ -63,76 +65,76 @@
 namespace Kokkos {
 
 //----------------------------------------------------------------------------
-// Cuda native CAS supports int, unsigned int, and unsigned long long int (non-standard type).
-// Must cast-away 'volatile' for the CAS call.
+// Cuda native CAS supports int, unsigned int, and unsigned long long int
+// (non-standard type). Must cast-away 'volatile' for the CAS call.
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 
 #if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-__inline__ __device__
-int atomic_compare_exchange( volatile int * const dest, const int compare, const int val)
-{ return atomicCAS((int*)dest,compare,val); }
-
-__inline__ __device__
-unsigned int atomic_compare_exchange( volatile unsigned int * const dest, const unsigned int compare, const unsigned int val)
-{ return atomicCAS((unsigned int*)dest,compare,val); }
-
-__inline__ __device__
-unsigned long long int atomic_compare_exchange( volatile unsigned long long int * const dest ,
-                                                const unsigned long long int compare ,
-                                                const unsigned long long int val )
-{ return atomicCAS((unsigned long long int*)dest,compare,val); }
-
-template < typename T >
-__inline__ __device__
-T atomic_compare_exchange( volatile T * const dest , const T & compare ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T & >::type val )
-{
-  const int tmp = atomicCAS( (int*) dest , *((int*)&compare) , *((int*)&val) );
-  return *((T*)&tmp);
+__inline__ __device__ int atomic_compare_exchange(volatile int* const dest,
+                                                  const int compare,
+                                                  const int val) {
+  return atomicCAS((int*)dest, compare, val);
+}
+
+__inline__ __device__ unsigned int atomic_compare_exchange(
+    volatile unsigned int* const dest, const unsigned int compare,
+    const unsigned int val) {
+  return atomicCAS((unsigned int*)dest, compare, val);
 }
 
-template < typename T >
-__inline__ __device__
-T atomic_compare_exchange( volatile T * const dest , const T & compare ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(unsigned long long int) , const T & >::type val )
-{
-  typedef unsigned long long int type ;
-  const type tmp = atomicCAS( (type*) dest , *((type*)&compare) , *((type*)&val) );
+__inline__ __device__ unsigned long long int atomic_compare_exchange(
+    volatile unsigned long long int* const dest,
+    const unsigned long long int compare, const unsigned long long int val) {
+  return atomicCAS((unsigned long long int*)dest, compare, val);
+}
+
+template <typename T>
+__inline__ __device__ T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T&>::type
+        val) {
+  const int tmp = atomicCAS((int*)dest, *((int*)&compare), *((int*)&val));
   return *((T*)&tmp);
 }
 
-template < typename T >
-__inline__ __device__
-T atomic_compare_exchange( volatile T * const dest , const T & compare ,
+template <typename T>
+__inline__ __device__ T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
     typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-             , const T >::type& val )
-{
+        sizeof(T) != sizeof(int) && sizeof(T) == sizeof(unsigned long long int),
+        const T&>::type val) {
+  typedef unsigned long long int type;
+  const type tmp = atomicCAS((type*)dest, *((type*)&compare), *((type*)&val));
+  return *((T*)&tmp);
+}
+
+template <typename T>
+__inline__ __device__ T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8),
+                                     const T>::type& val) {
   T return_val;
   // This is a way to (hopefully) avoid dead lock in a warp
   int done = 0;
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+  unsigned int mask   = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
   unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
   unsigned int done_active = 0;
-  while (active!=done_active) {
-    if(!done) {
-      if( Impl::lock_address_cuda_space( (void*) dest ) ) {
+  while (active != done_active) {
+    if (!done) {
+      if (Impl::lock_address_cuda_space((void*)dest)) {
         return_val = *dest;
-        if( return_val == compare )
-          *dest = val;
-        Impl::unlock_address_cuda_space( (void*) dest );
+        if (return_val == compare) *dest = val;
+        Impl::unlock_address_cuda_space((void*)dest);
         done = 1;
       }
     }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,done);
+    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, done);
 #else
     done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
 #endif
@@ -149,163 +151,162 @@ T atomic_compare_exchange( volatile T * const dest , const T & compare ,
 #if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
 
-inline
-int atomic_compare_exchange( volatile int * const dest, const int compare, const int val)
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline int atomic_compare_exchange(volatile int* const dest, const int compare,
+                                   const int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_val_compare_and_swap(dest,compare,val);
+  return __sync_val_compare_and_swap(dest, compare, val);
 }
 
-inline
-long atomic_compare_exchange( volatile long * const dest, const long compare, const long val )
-{ 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline long atomic_compare_exchange(volatile long* const dest,
+                                    const long compare, const long val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_val_compare_and_swap(dest,compare,val);
+  return __sync_val_compare_and_swap(dest, compare, val);
 }
 
-#if defined( KOKKOS_ENABLE_GNU_ATOMICS )
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
 
 // GCC supports unsigned
 
-inline
-unsigned int atomic_compare_exchange( volatile unsigned int * const dest, const unsigned int compare, const unsigned int val )
-{ return __sync_val_compare_and_swap(dest,compare,val); }
+inline unsigned int atomic_compare_exchange(volatile unsigned int* const dest,
+                                            const unsigned int compare,
+                                            const unsigned int val) {
+  return __sync_val_compare_and_swap(dest, compare, val);
+}
 
-inline
-unsigned long atomic_compare_exchange( volatile unsigned long * const dest ,
-                                       const unsigned long compare ,
-                                       const unsigned long val )
-{ return __sync_val_compare_and_swap(dest,compare,val); }
+inline unsigned long atomic_compare_exchange(volatile unsigned long* const dest,
+                                             const unsigned long compare,
+                                             const unsigned long val) {
+  return __sync_val_compare_and_swap(dest, compare, val);
+}
 
 #endif
 
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest, const T & compare,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T & >::type val )
-{
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T&>::type
+        val) {
   union U {
-    int i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U() {};
-  } tmp ;
+    int i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  tmp.i = __sync_val_compare_and_swap( (int*) dest , *((int*)&compare) , *((int*)&val) );
-  return tmp.t ;
+  tmp.i =
+      __sync_val_compare_and_swap((int*)dest, *((int*)&compare), *((int*)&val));
+  return tmp.t;
 }
 
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest, const T & compare,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(long) , const T & >::type val )
-{
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) == sizeof(long),
+                                     const T&>::type val) {
   union U {
-    long i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U() {};
-  } tmp ;
+    long i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  tmp.i = __sync_val_compare_and_swap( (long*) dest , *((long*)&compare) , *((long*)&val) );
-  return tmp.t ;
+  tmp.i = __sync_val_compare_and_swap((long*)dest, *((long*)&compare),
+                                      *((long*)&val));
+  return tmp.t;
 }
 
-#if defined( KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest, const T & compare,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) != sizeof(long) &&
-                                    sizeof(T) == sizeof(Impl::cas128_t), const T & >::type val )
-{
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) != sizeof(long) &&
+                                         sizeof(T) == sizeof(Impl::cas128_t),
+                                     const T&>::type val) {
   union U {
-    Impl::cas128_t i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U() {};
-  } tmp ;
+    Impl::cas128_t i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  tmp.i = Impl::cas128( (Impl::cas128_t*) dest , *((Impl::cas128_t*)&compare) , *((Impl::cas128_t*)&val) );
-  return tmp.t ;
+  tmp.i = Impl::cas128((Impl::cas128_t*)dest, *((Impl::cas128_t*)&compare),
+                       *((Impl::cas128_t*)&val));
+  return tmp.t;
 }
 #endif
 
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest , const T compare ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-            #if defined(KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-               && ( sizeof(T) != 16 )
-            #endif
-             , const T >::type& val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T compare,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8)
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+                                         && (sizeof(T) != 16)
+#endif
+                                         ,
+                                     const T>::type& val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   T return_val = *dest;
-  if( return_val == compare ) {
+  if (return_val == compare) {
     // Don't use the following line of code here:
     //
-    //const T tmp = *dest = val;
+    // const T tmp = *dest = val;
     //
     // Instead, put each assignment in its own statement.  This is
     // because the overload of T::operator= for volatile *this should
     // return void, not volatile T&.  See Kokkos #177:
     //
     // https://github.com/kokkos/kokkos/issues/177
-    *dest = val;
+    *dest       = val;
     const T tmp = *dest;
-    #ifndef KOKKOS_COMPILER_CLANG
-    (void) tmp;
-    #endif
+#ifndef KOKKOS_COMPILER_CLANG
+    (void)tmp;
+#endif
   }
-  Impl::unlock_address_host_space( (void*) dest );
+  Impl::unlock_address_host_space((void*)dest);
   return return_val;
 }
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_compare_exchange( volatile T * const dest, const T compare, const T val )
-{
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest,
+                                                 const T compare, const T val) {
   T retval;
 #pragma omp critical
   {
     retval = dest[0];
-    if ( retval == compare )
-        dest[0] = val;
+    if (retval == compare) dest[0] = val;
   }
   return retval;
 }
 
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_compare_exchange( volatile T * const dest_v, const T compare, const T val )
-{
-  T* dest = const_cast<T*>(dest_v);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest_v,
+                                                 const T compare, const T val) {
+  T* dest  = const_cast<T*>(dest_v);
   T retval = *dest;
   if (retval == compare) *dest = val;
   return retval;
@@ -313,22 +314,21 @@ T atomic_compare_exchange( volatile T * const dest_v, const T compare, const T v
 
 #endif
 #endif
-#endif // !defined ROCM_ATOMICS
+#endif  // !defined ROCM_ATOMICS
 
 // dummy for non-CUDA Kokkos headers being processed by NVCC
 #if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
 template <typename T>
-__inline__ __device__
-T atomic_compare_exchange(volatile T * const, const Kokkos::Impl::identity_t<T>, const Kokkos::Impl::identity_t<T>)
-{
+__inline__ __device__ T
+atomic_compare_exchange(volatile T* const, const Kokkos::Impl::identity_t<T>,
+                        const Kokkos::Impl::identity_t<T>) {
   return T();
 }
 #endif
 
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-bool atomic_compare_exchange_strong(volatile T* const dest, const T compare, const T val)
-{
+KOKKOS_INLINE_FUNCTION bool atomic_compare_exchange_strong(
+    volatile T* const dest, const T compare, const T val) {
   return compare == atomic_compare_exchange(dest, compare, val);
 }
 //----------------------------------------------------------------------------
@@ -337,161 +337,109 @@ namespace Impl {
 // memory-ordered versions are in the Impl namespace
 
 template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION
-bool _atomic_compare_exchange_strong_fallback(
-  T* dest, T compare, T val, memory_order_seq_cst_t, MemoryOrderFailure
-)
-{
+KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
+    T* dest, T compare, T val, memory_order_seq_cst_t, MemoryOrderFailure) {
   Kokkos::memory_fence();
-  auto rv = Kokkos::atomic_compare_exchange_strong(
-    dest, compare, val
-  );
+  auto rv = Kokkos::atomic_compare_exchange_strong(dest, compare, val);
   Kokkos::memory_fence();
   return rv;
 }
 
 template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION
-bool _atomic_compare_exchange_strong_fallback(
-  T* dest, T compare, T val, memory_order_acquire_t, MemoryOrderFailure
-)
-{
-  auto rv = Kokkos::atomic_compare_exchange_strong(
-    dest, compare, val
-  );
+KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
+    T* dest, T compare, T val, memory_order_acquire_t, MemoryOrderFailure) {
+  auto rv = Kokkos::atomic_compare_exchange_strong(dest, compare, val);
   Kokkos::memory_fence();
   return rv;
 }
 
 template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION
-bool _atomic_compare_exchange_strong_fallback(
-  T* dest, T compare, T val, memory_order_release_t, MemoryOrderFailure
-)
-{
+KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
+    T* dest, T compare, T val, memory_order_release_t, MemoryOrderFailure) {
   Kokkos::memory_fence();
-  return Kokkos::atomic_compare_exchange_strong(
-    dest, compare, val
-  );
+  return Kokkos::atomic_compare_exchange_strong(dest, compare, val);
 }
 
 template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION
-bool _atomic_compare_exchange_strong_fallback(
-  T* dest, T compare, T val, memory_order_relaxed_t, MemoryOrderFailure
-)
-{
-  return Kokkos::atomic_compare_exchange_strong(
-    dest, compare, val
-  );
+KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
+    T* dest, T compare, T val, memory_order_relaxed_t, MemoryOrderFailure) {
+  return Kokkos::atomic_compare_exchange_strong(dest, compare, val);
 }
 
-#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) \
-    || (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) ||   \
+    (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
 
 #if defined(__CUDA_ARCH__)
-  #define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
+#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
 #else
-  #define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
+#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
 #endif
 
 template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-bool _atomic_compare_exchange_strong(
-  T* dest, T compare, T val,
-  MemoryOrderSuccess,
-  MemoryOrderFailure,
-  typename std::enable_if<
-    (
-      sizeof(T) == 1
-      || sizeof(T) == 2
-      || sizeof(T) == 4
-      || sizeof(T) == 8
-    )
-    && std::is_same<
-      typename MemoryOrderSuccess::memory_order,
-      typename std::remove_cv<MemoryOrderSuccess>::type
-    >::value
-    && std::is_same<
-      typename MemoryOrderFailure::memory_order,
-      typename std::remove_cv<MemoryOrderFailure>::type
-    >::value,
-    void const**
-  >::type = nullptr
-) {
-  return __atomic_compare_exchange_n(
-    dest, &compare, val, /* weak = */ false,
-    MemoryOrderSuccess::gnu_constant,
-    MemoryOrderFailure::gnu_constant
-  );
+KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH bool _atomic_compare_exchange_strong(
+    T* dest, T compare, T val, MemoryOrderSuccess, MemoryOrderFailure,
+    typename std::enable_if<
+        (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+         sizeof(T) == 8) &&
+            std::is_same<
+                typename MemoryOrderSuccess::memory_order,
+                typename std::remove_cv<MemoryOrderSuccess>::type>::value &&
+            std::is_same<
+                typename MemoryOrderFailure::memory_order,
+                typename std::remove_cv<MemoryOrderFailure>::type>::value,
+        void const**>::type = nullptr) {
+  return __atomic_compare_exchange_n(dest, &compare, val, /* weak = */ false,
+                                     MemoryOrderSuccess::gnu_constant,
+                                     MemoryOrderFailure::gnu_constant);
 }
 
 template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-bool _atomic_compare_exchange_strong(
-  T* dest, T compare, T val,
-  MemoryOrderSuccess order_success,
-  MemoryOrderFailure order_failure,
-  typename std::enable_if<
-    !(
-      sizeof(T) == 1
-      || sizeof(T) == 2
-      || sizeof(T) == 4
-      || sizeof(T) == 8
-    )
-    && std::is_same<
-      typename MemoryOrderSuccess::memory_order,
-      typename std::remove_cv<MemoryOrderSuccess>::type
-    >::value
-    && std::is_same<
-      typename MemoryOrderFailure::memory_order,
-      typename std::remove_cv<MemoryOrderFailure>::type
-    >::value,
-    void const**
-  >::type = nullptr
-) {
-  return _atomic_compare_exchange_fallback(
-    dest, compare, val,
-    order_success, order_failure
-  );
+KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH bool _atomic_compare_exchange_strong(
+    T* dest, T compare, T val, MemoryOrderSuccess order_success,
+    MemoryOrderFailure order_failure,
+    typename std::enable_if<
+        !(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+          sizeof(T) == 8) &&
+            std::is_same<
+                typename MemoryOrderSuccess::memory_order,
+                typename std::remove_cv<MemoryOrderSuccess>::type>::value &&
+            std::is_same<
+                typename MemoryOrderFailure::memory_order,
+                typename std::remove_cv<MemoryOrderFailure>::type>::value,
+        void const**>::type = nullptr) {
+  return _atomic_compare_exchange_fallback(dest, compare, val, order_success,
+                                           order_failure);
 }
 
 #else
 
 template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION
-bool _atomic_compare_exchange_strong(
-  T* dest, T compare, T val,
-  MemoryOrderSuccess order_success,
-  MemoryOrderFailure order_failure
-) {
-  return _atomic_compare_exchange_strong_fallback(
-    dest, compare, val, order_success, order_failure
-  );
+KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong(
+    T* dest, T compare, T val, MemoryOrderSuccess order_success,
+    MemoryOrderFailure order_failure) {
+  return _atomic_compare_exchange_strong_fallback(dest, compare, val,
+                                                  order_success, order_failure);
 }
 
 #endif
 
-// TODO static asserts in overloads that don't make sense (as listed in https://gcc.gnu.org/onlinedocs/gcc-5.2.0/gcc/_005f_005fatomic-Builtins.html)
+// TODO static asserts in overloads that don't make sense (as listed in
+// https://gcc.gnu.org/onlinedocs/gcc-5.2.0/gcc/_005f_005fatomic-Builtins.html)
 template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_FORCEINLINE_FUNCTION
-bool atomic_compare_exchange_strong(
-  T* dest, T compare, T val,
-  MemoryOrderSuccess order_success,
-  MemoryOrderFailure order_failure
-) {
-  return _atomic_compare_exchange_strong(dest, compare, val, order_success, order_failure);
+KOKKOS_FORCEINLINE_FUNCTION bool atomic_compare_exchange_strong(
+    T* dest, T compare, T val, MemoryOrderSuccess order_success,
+    MemoryOrderFailure order_failure) {
+  return _atomic_compare_exchange_strong(dest, compare, val, order_success,
+                                         order_failure);
 }
 
+}  // end namespace Impl
 
-} // end namespace Impl
-
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #if defined(KOKKOS_ENABLE_CUDA)
 #include <Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp>
 #endif
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Weak.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Weak.hpp
index 3abc8ed4b7c77137069c0356045e3e0363fdc4e6..c2aad61975fd5aa64428937f8981ada117315ac1 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Weak.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Compare_Exchange_Weak.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,7 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
@@ -51,7 +52,7 @@
 #define KOKKOS_ATOMIC_COMPARE_EXCHANGE_WEAK_HPP
 
 #if defined(KOKKOS_ENABLE_CUDA)
-#include<Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
+#include <Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
 #endif
 
 namespace Kokkos {
@@ -60,42 +61,49 @@ namespace Kokkos {
 //----------------------------------------------------------------------------
 // Cuda sm_70 or greater supports C++-like semantics directly
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 
 #if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 
-
 #if __CUDA_ARCH__ >= 700
 // See: https://github.com/ogiroux/freestanding
-#  define kokkos_cuda_internal_cas_release_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.release.sys.b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#  define kokkos_cuda_internal_cas_acquire_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.acquire.sys.b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#  define kokkos_cuda_internal_cas_acq_rel_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.acq_rel.sys.b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#  define kokkos_cuda_internal_cas_relaxed_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.relaxed.sys.b32 %0, [%1], %2, %3;" : "=r"(old) : "l"(ptr), "r"(expected), "r"(desired) : "memory")
-#  define kokkos_cuda_internal_fence_seq_cst() asm volatile("fence.sc.sys;" : : : "memory")
-#  define kokkos_cuda_internal_fence_acq_rel() asm volatile("fence.acq_rel.sys;" : : : "memory")
+#define kokkos_cuda_internal_cas_release_32(ptr, old, expected, desired) \
+  asm volatile("atom.cas.release.sys.b32 %0, [%1], %2, %3;"              \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define kokkos_cuda_internal_cas_acquire_32(ptr, old, expected, desired) \
+  asm volatile("atom.cas.acquire.sys.b32 %0, [%1], %2, %3;"              \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define kokkos_cuda_internal_cas_acq_rel_32(ptr, old, expected, desired) \
+  asm volatile("atom.cas.acq_rel.sys.b32 %0, [%1], %2, %3;"              \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define kokkos_cuda_internal_cas_relaxed_32(ptr, old, expected, desired) \
+  asm volatile("atom.cas.relaxed.sys.b32 %0, [%1], %2, %3;"              \
+               : "=r"(old)                                               \
+               : "l"(ptr), "r"(expected), "r"(desired)                   \
+               : "memory")
+#define kokkos_cuda_internal_fence_seq_cst() \
+  asm volatile("fence.sc.sys;" : : : "memory")
+#define kokkos_cuda_internal_fence_acq_rel() \
+  asm volatile("fence.acq_rel.sys;" : : : "memory")
 #else
-#  define kokkos_cuda_internal_fence_acq_rel() asm volatile("membar.sys;" : : : "memory")
-#  define kokkos_cuda_internal_fence_seq_cst() asm volatile("membar.sys;" : : : "memory")
+#define kokkos_cuda_internal_fence_acq_rel() \
+  asm volatile("membar.sys;" : : : "memory")
+#define kokkos_cuda_internal_fence_seq_cst() \
+  asm volatile("membar.sys;" : : : "memory")
 #endif
 
-
 // 32-bit version
-template <class T,
-  typename std::enable_if<sizeof(T) == 4, int>::type = 0
->
-__inline__ __device__
-bool
-atomic_compare_exchange_weak(
-  T volatile* const dest,
-  T* const expected,
-  T const desired,
-  std::memory_order success_order = std::memory_order_seq_cst,
-  std::memory_order failure_order = std::memory_order_seq_cst
-) {
+template <class T, typename std::enable_if<sizeof(T) == 4, int>::type = 0>
+__inline__ __device__ bool atomic_compare_exchange_weak(
+    T volatile* const dest, T* const expected, T const desired,
+    std::memory_order success_order = std::memory_order_seq_cst,
+    std::memory_order failure_order = std::memory_order_seq_cst) {
   // TODO assert that success_order >= failure_order
   // See: https://github.com/ogiroux/freestanding
   int32_t tmp = 0;
@@ -104,7 +112,7 @@ atomic_compare_exchange_weak(
   memcpy(&old, expected, sizeof(T));
   int32_t old_tmp = old;
 #if __CUDA_ARCH__ >= 700
-  switch(success_order) {
+  switch (success_order) {
     case std::memory_order_seq_cst:
       // sequentially consistent is just an acquire with a seq_cst fence
       kokkos_cuda_internal_fence_seq_cst();
@@ -129,42 +137,32 @@ atomic_compare_exchange_weak(
   };
 #else
   // All of the orders that require a fence before the relaxed atomic operation:
-  if(
-    success_order == std::memory_order_release
-    || success_order == std::memory_order_acq_rel
-  ) {
+  if (success_order == std::memory_order_release ||
+      success_order == std::memory_order_acq_rel) {
     kokkos_cuda_internal_fence_acq_rel();
-  }
-  else if(success_order == std::memory_order_seq_cst) {
+  } else if (success_order == std::memory_order_seq_cst) {
     kokkos_cuda_internal_fence_seq_cst();
   }
-  // This is relaxed: 
+  // This is relaxed:
   // Cuda API requires casting away volatile
   atomicCAS((T*)dest, old_tmp, tmp);
 #endif
   bool const rv = (old == old_tmp);
 #if __CUDA_ARCH__ < 700
-  if(rv) {
-    if(
-      success_order == std::memory_order_acquire
-      || success_order == std::memory_order_consume
-      || success_order == std::memory_order_acq_rel
-    ) {
+  if (rv) {
+    if (success_order == std::memory_order_acquire ||
+        success_order == std::memory_order_consume ||
+        success_order == std::memory_order_acq_rel) {
       kokkos_cuda_internal_fence_acq_rel();
-    }
-    else if(success_order == std::memory_order_seq_cst) {
+    } else if (success_order == std::memory_order_seq_cst) {
       kokkos_cuda_internal_fence_seq_cst();
     }
-  }
-  else {
-    if(
-      failure_order == std::memory_order_acquire
-      || failure_order == std::memory_order_consume
-      || failure_order == std::memory_order_acq_rel
-    ) {
+  } else {
+    if (failure_order == std::memory_order_acquire ||
+        failure_order == std::memory_order_consume ||
+        failure_order == std::memory_order_acq_rel) {
       kokkos_cuda_internal_fence_acq_rel();
-    }
-    else if(failure_order == std::memory_order_seq_cst) {
+    } else if (failure_order == std::memory_order_seq_cst) {
       kokkos_cuda_internal_fence_seq_cst();
     }
   }
@@ -174,17 +172,11 @@ atomic_compare_exchange_weak(
 }
 
 // 64-bit version
-template <class T,
-  typename std::enable_if<sizeof(T) == 8, int>::type = 0
->
-bool
-atomic_compare_exchange_weak(
-  T volatile* const dest,
-  T* const expected,
-  T const desired,
-  std::memory_order success_order = std::memory_order_seq_cst,
-  std::memory_order failure_order = std::memory_order_seq_cst
-) {
+template <class T, typename std::enable_if<sizeof(T) == 8, int>::type = 0>
+bool atomic_compare_exchange_weak(
+    T volatile* const dest, T* const expected, T const desired,
+    std::memory_order success_order = std::memory_order_seq_cst,
+    std::memory_order failure_order = std::memory_order_seq_cst) {
   // TODO assert that success_order >= failure_order
   // See: https://github.com/ogiroux/freestanding
   int64_t tmp = 0;
@@ -193,7 +185,7 @@ atomic_compare_exchange_weak(
   memcpy(&old, expected, sizeof(T));
   int64_t old_tmp = old;
 #if __CUDA_ARCH__ >= 700
-  switch(success_order) {
+  switch (success_order) {
     case std::memory_order_seq_cst:
       // sequentially consistent is just an acquire with a seq_cst fence
       kokkos_cuda_internal_fence_seq_cst();
@@ -225,9 +217,9 @@ atomic_compare_exchange_weak(
   return rv;
 }
 
-#endif // defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
+#endif  // defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 
-#endif // defined( KOKKOS_ENABLE_CUDA )
+#endif  // defined( KOKKOS_ENABLE_CUDA )
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -238,163 +230,162 @@ atomic_compare_exchange_weak(
 #if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
 
-inline
-int atomic_compare_exchange( volatile int * const dest, const int compare, const int val)
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline int atomic_compare_exchange(volatile int* const dest, const int compare,
+                                   const int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_val_compare_and_swap(dest,compare,val);
+  return __sync_val_compare_and_swap(dest, compare, val);
 }
 
-inline
-long atomic_compare_exchange( volatile long * const dest, const long compare, const long val )
-{ 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline long atomic_compare_exchange(volatile long* const dest,
+                                    const long compare, const long val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_val_compare_and_swap(dest,compare,val);
+  return __sync_val_compare_and_swap(dest, compare, val);
 }
 
-#if defined( KOKKOS_ENABLE_GNU_ATOMICS )
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
 
 // GCC supports unsigned
 
-inline
-unsigned int atomic_compare_exchange( volatile unsigned int * const dest, const unsigned int compare, const unsigned int val )
-{ return __sync_val_compare_and_swap(dest,compare,val); }
+inline unsigned int atomic_compare_exchange(volatile unsigned int* const dest,
+                                            const unsigned int compare,
+                                            const unsigned int val) {
+  return __sync_val_compare_and_swap(dest, compare, val);
+}
 
-inline
-unsigned long atomic_compare_exchange( volatile unsigned long * const dest ,
-                                       const unsigned long compare ,
-                                       const unsigned long val )
-{ return __sync_val_compare_and_swap(dest,compare,val); }
+inline unsigned long atomic_compare_exchange(volatile unsigned long* const dest,
+                                             const unsigned long compare,
+                                             const unsigned long val) {
+  return __sync_val_compare_and_swap(dest, compare, val);
+}
 
 #endif
 
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest, const T & compare,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T & >::type val )
-{
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T&>::type
+        val) {
   union U {
-    int i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U() {};
-  } tmp ;
+    int i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  tmp.i = __sync_val_compare_and_swap( (int*) dest , *((int*)&compare) , *((int*)&val) );
-  return tmp.t ;
+  tmp.i =
+      __sync_val_compare_and_swap((int*)dest, *((int*)&compare), *((int*)&val));
+  return tmp.t;
 }
 
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest, const T & compare,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(long) , const T & >::type val )
-{
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) == sizeof(long),
+                                     const T&>::type val) {
   union U {
-    long i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U() {};
-  } tmp ;
+    long i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  tmp.i = __sync_val_compare_and_swap( (long*) dest , *((long*)&compare) , *((long*)&val) );
-  return tmp.t ;
+  tmp.i = __sync_val_compare_and_swap((long*)dest, *((long*)&compare),
+                                      *((long*)&val));
+  return tmp.t;
 }
 
-#if defined( KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest, const T & compare,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) != sizeof(long) &&
-                                    sizeof(T) == sizeof(Impl::cas128_t), const T & >::type val )
-{
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) != sizeof(long) &&
+                                         sizeof(T) == sizeof(Impl::cas128_t),
+                                     const T&>::type val) {
   union U {
-    Impl::cas128_t i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U() {};
-  } tmp ;
+    Impl::cas128_t i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  tmp.i = Impl::cas128( (Impl::cas128_t*) dest , *((Impl::cas128_t*)&compare) , *((Impl::cas128_t*)&val) );
-  return tmp.t ;
+  tmp.i = Impl::cas128((Impl::cas128_t*)dest, *((Impl::cas128_t*)&compare),
+                       *((Impl::cas128_t*)&val));
+  return tmp.t;
 }
 #endif
 
-template < typename T >
-inline
-T atomic_compare_exchange( volatile T * const dest , const T compare ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-            #if defined(KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-               && ( sizeof(T) != 16 )
-            #endif
-             , const T >::type& val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+template <typename T>
+inline T atomic_compare_exchange(
+    volatile T* const dest, const T compare,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8)
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+                                         && (sizeof(T) != 16)
+#endif
+                                         ,
+                                     const T>::type& val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   T return_val = *dest;
-  if( return_val == compare ) {
+  if (return_val == compare) {
     // Don't use the following line of code here:
     //
-    //const T tmp = *dest = val;
+    // const T tmp = *dest = val;
     //
     // Instead, put each assignment in its own statement.  This is
     // because the overload of T::operator= for volatile *this should
     // return void, not volatile T&.  See Kokkos #177:
     //
     // https://github.com/kokkos/kokkos/issues/177
-    *dest = val;
+    *dest       = val;
     const T tmp = *dest;
-    #ifndef KOKKOS_COMPILER_CLANG
-    (void) tmp;
-    #endif
+#ifndef KOKKOS_COMPILER_CLANG
+    (void)tmp;
+#endif
   }
-  Impl::unlock_address_host_space( (void*) dest );
+  Impl::unlock_address_host_space((void*)dest);
   return return_val;
 }
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_compare_exchange( volatile T * const dest, const T compare, const T val )
-{
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest,
+                                                 const T compare, const T val) {
   T retval;
 #pragma omp critical
   {
     retval = dest[0];
-    if ( retval == compare )
-        dest[0] = val;
+    if (retval == compare) dest[0] = val;
   }
   return retval;
 }
 
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template< typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_compare_exchange( volatile T * const dest_v, const T compare, const T val )
-{
-  T* dest = const_cast<T*>(dest_v);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest_v,
+                                                 const T compare, const T val) {
+  T* dest  = const_cast<T*>(dest_v);
   T retval = *dest;
   if (retval == compare) *dest = val;
   return retval;
@@ -402,17 +393,15 @@ T atomic_compare_exchange( volatile T * const dest_v, const T compare, const T v
 
 #endif
 #endif
-#endif // !defined ROCM_ATOMICS
+#endif  // !defined ROCM_ATOMICS
 
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-bool atomic_compare_exchange_strong(volatile T* const dest, const T compare, const T val)
-{
+KOKKOS_INLINE_FUNCTION bool atomic_compare_exchange_strong(
+    volatile T* const dest, const T compare, const T val) {
   return compare == atomic_compare_exchange(dest, compare, val);
 }
 //----------------------------------------------------------------------------
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Decrement.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Decrement.hpp
index 0f3dc52fcec33ab994c301b21f5906bc2a832b15..992ae3c0052b72e89ef661d62e6b66ebe6be27f9 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Decrement.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Decrement.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,12 +42,12 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP) && ! defined( KOKKOS_ATOMIC_DECREMENT_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_DECREMENT_HPP)
 #define KOKKOS_ATOMIC_DECREMENT_HPP
 
 #include "impl/Kokkos_Atomic_Fetch_Sub.hpp"
@@ -54,20 +55,18 @@
 namespace Kokkos {
 
 // Atomic increment
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_decrement<char>(volatile char* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_decrement<char>(volatile char* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock decb %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock decb %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   char* a_nv = const_cast<char*>(a);
   --(*a_nv);
 #else
@@ -75,20 +74,18 @@ void atomic_decrement<char>(volatile char* a) {
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_decrement<short>(volatile short* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_decrement<short>(volatile short* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock decw %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock decw %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   short* a_nv = const_cast<short*>(a);
   --(*a_nv);
 #else
@@ -96,20 +93,18 @@ void atomic_decrement<short>(volatile short* a) {
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_decrement<int>(volatile int* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_decrement<int>(volatile int* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock decl %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock decl %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   int* a_nv = const_cast<int*>(a);
   --(*a_nv);
 #else
@@ -117,20 +112,19 @@ void atomic_decrement<int>(volatile int* a) {
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_decrement<long long int>(volatile long long int* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_decrement<long long int>(
+    volatile long long int* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock decq %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock decq %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   long long int* a_nv = const_cast<long long int*>(a);
   --(*a_nv);
 #else
@@ -139,10 +133,9 @@ void atomic_decrement<long long int>(volatile long long int* a) {
 #endif
 }
 
-template<typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_decrement(volatile T* a) {
-#if defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+template <typename T>
+KOKKOS_INLINE_FUNCTION void atomic_decrement(volatile T* a) {
+#if defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   T* a_nv = const_cast<T*>(a);
   --(*a_nv);
 #else
@@ -150,6 +143,5 @@ void atomic_decrement(volatile T* a) {
 #endif
 }
 
-} // End of namespace Kokkos
+}  // End of namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Exchange.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Exchange.hpp
index 6ccf35816b40a5753f04d536b5a0fe83d3257658..37aebf9a3d38bab019e92136fa392e76b51ba2dd 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Exchange.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Exchange.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,113 +42,106 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_EXCHANGE_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_EXCHANGE_HPP)
 #define KOKKOS_ATOMIC_EXCHANGE_HPP
 
 #if defined(KOKKOS_ENABLE_CUDA)
-#include<Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
+#include <Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
 #endif
 
 namespace Kokkos {
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 #if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 
-__inline__ __device__
-int atomic_exchange( volatile int * const dest , const int val )
-{
+__inline__ __device__ int atomic_exchange(volatile int* const dest,
+                                          const int val) {
   // return __iAtomicExch( (int*) dest , val );
-  return atomicExch( (int*) dest , val );
+  return atomicExch((int*)dest, val);
 }
 
-__inline__ __device__
-unsigned int atomic_exchange( volatile unsigned int * const dest , const unsigned int val )
-{
+__inline__ __device__ unsigned int atomic_exchange(
+    volatile unsigned int* const dest, const unsigned int val) {
   // return __uAtomicExch( (unsigned int*) dest , val );
-  return atomicExch( (unsigned int*) dest , val );
+  return atomicExch((unsigned int*)dest, val);
 }
 
-__inline__ __device__
-unsigned long long int atomic_exchange( volatile unsigned long long int * const dest , const unsigned long long int val )
-{
+__inline__ __device__ unsigned long long int atomic_exchange(
+    volatile unsigned long long int* const dest,
+    const unsigned long long int val) {
   // return __ullAtomicExch( (unsigned long long*) dest , val );
-  return atomicExch( (unsigned long long*) dest , val );
+  return atomicExch((unsigned long long*)dest, val);
 }
 
 /** \brief  Atomic exchange for any type with compatible size */
-template< typename T >
-__inline__ __device__
-T atomic_exchange(
-  volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T & >::type val )
-{
+template <typename T>
+__inline__ __device__ T atomic_exchange(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T&>::type
+        val) {
   // int tmp = __ullAtomicExch( (int*) dest , *((int*)&val) );
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  int tmp = atomicExch( ((int*)dest) , *((int*)&val) );
+  int tmp = atomicExch(((int*)dest), *((int*)&val));
   return *((T*)&tmp);
 }
 
-template< typename T >
-__inline__ __device__
-T atomic_exchange(
-  volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(unsigned long long int) , const T & >::type val )
-{
-  typedef unsigned long long int type ;
-
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+template <typename T>
+__inline__ __device__ T atomic_exchange(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<
+        sizeof(T) != sizeof(int) && sizeof(T) == sizeof(unsigned long long int),
+        const T&>::type val) {
+  typedef unsigned long long int type;
+
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
   // type tmp = __ullAtomicExch( (type*) dest , *((type*)&val) );
-  type tmp = atomicExch( ((type*)dest) , *((type*)&val) );
+  type tmp = atomicExch(((type*)dest), *((type*)&val));
   return *((T*)&tmp);
 }
 
-template < typename T >
-__inline__ __device__
-T atomic_exchange( volatile T * const dest ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-             , const T >::type& val )
-{
+template <typename T>
+__inline__ __device__ T atomic_exchange(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8),
+                                     const T>::type& val) {
   T return_val;
   // This is a way to (hopefully) avoid dead lock in a warp
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
   int done = 0;
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+  unsigned int mask   = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
   unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
   unsigned int done_active = 0;
-  while (active!=done_active) {
-    if(!done) {
-      if( Impl::lock_address_cuda_space( (void*) dest ) ) {
+  while (active != done_active) {
+    if (!done) {
+      if (Impl::lock_address_cuda_space((void*)dest)) {
         return_val = *dest;
-        *dest = val;
-        Impl::unlock_address_cuda_space( (void*) dest );
+        *dest      = val;
+        Impl::unlock_address_cuda_space((void*)dest);
         done = 1;
       }
     }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,done);
+    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, done);
 #else
     done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
 #endif
@@ -155,37 +149,33 @@ T atomic_exchange( volatile T * const dest ,
   return return_val;
 }
 /** \brief  Atomic exchange for any type with compatible size */
-template< typename T >
-__inline__ __device__
-void atomic_assign(
-  volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T & >::type val )
-{
+template <typename T>
+__inline__ __device__ void atomic_assign(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T&>::type
+        val) {
   // (void) __ullAtomicExch( (int*) dest , *((int*)&val) );
-  (void) atomicExch( ((int*)dest) , *((int*)&val) );
+  (void)atomicExch(((int*)dest), *((int*)&val));
 }
 
-template< typename T >
-__inline__ __device__
-void atomic_assign(
-  volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(unsigned long long int) , const T & >::type val )
-{
-  typedef unsigned long long int type ;
+template <typename T>
+__inline__ __device__ void atomic_assign(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<
+        sizeof(T) != sizeof(int) && sizeof(T) == sizeof(unsigned long long int),
+        const T&>::type val) {
+  typedef unsigned long long int type;
   // (void) __ullAtomicExch( (type*) dest , *((type*)&val) );
-  (void) atomicExch( ((type*)dest) , *((type*)&val) );
+  (void)atomicExch(((type*)dest), *((type*)&val));
 }
 
-template< typename T >
-__inline__ __device__
-void atomic_assign(
-  volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) != sizeof(unsigned long long int)
-                                  , const T & >::type val )
-{
-  (void) atomic_exchange(dest,val);
+template <typename T>
+__inline__ __device__ void atomic_assign(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<
+        sizeof(T) != sizeof(int) && sizeof(T) != sizeof(unsigned long long int),
+        const T&>::type val) {
+  (void)atomic_exchange(dest, val);
 }
 
 #endif
@@ -196,167 +186,167 @@ void atomic_assign(
 #if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
 
-template< typename T >
-inline
-T atomic_exchange( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) || sizeof(T) == sizeof(long)
-                                  , const T & >::type val )
-{
-  typedef typename Kokkos::Impl::if_c< sizeof(T) == sizeof(int) , int , long >::type type ;
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+template <typename T>
+inline T atomic_exchange(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int) ||
+                                         sizeof(T) == sizeof(long),
+                                     const T&>::type val) {
+  typedef typename Kokkos::Impl::if_c<sizeof(T) == sizeof(int), int, long>::type
+      type;
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  const type v = *((type*)&val); // Extract to be sure the value doesn't change
+  const type v = *((type*)&val);  // Extract to be sure the value doesn't change
 
-  type assumed ;
+  type assumed;
 
   union U {
-    T val_T ;
-    type val_type ;
-    inline U() {};
-  } old ;
+    T val_T;
+    type val_type;
+    inline U(){};
+  } old;
 
-  old.val_T = *dest ;
+  old.val_T = *dest;
 
   do {
-    assumed = old.val_type ;
-    old.val_type = __sync_val_compare_and_swap( (volatile type *) dest , assumed , v );
-  } while ( assumed != old.val_type );
+    assumed = old.val_type;
+    old.val_type =
+        __sync_val_compare_and_swap((volatile type*)dest, assumed, v);
+  } while (assumed != old.val_type);
 
-  return old.val_T ;
+  return old.val_T;
 }
 
-#if defined(KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-template< typename T >
-inline
-T atomic_exchange( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(Impl::cas128_t)
-                                  , const T & >::type val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+template <typename T>
+inline T atomic_exchange(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(Impl::cas128_t),
+                                     const T&>::type val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
   union U {
-    Impl::cas128_t i ;
-    T t ;
-    inline U() {};
-  } assume , oldval , newval ;
+    Impl::cas128_t i;
+    T t;
+    inline U(){};
+  } assume, oldval, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
   newval.t = val;
 
   do {
-    assume.i = oldval.i ;
-    oldval.i = Impl::cas128( (volatile Impl::cas128_t*) dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    oldval.i = Impl::cas128((volatile Impl::cas128_t*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 #endif
 
 //----------------------------------------------------------------------------
 
-template < typename T >
-inline
-T atomic_exchange( volatile T * const dest ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-              #if defined(KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-               && ( sizeof(T) != 16 )
-              #endif
-                 , const T >::type& val )
-{
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+template <typename T>
+inline T atomic_exchange(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8)
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+                                         && (sizeof(T) != 16)
+#endif
+                                         ,
+                                     const T>::type& val) {
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   T return_val = *dest;
   // Don't use the following line of code here:
   //
-  //const T tmp = *dest = val;
+  // const T tmp = *dest = val;
   //
   // Instead, put each assignment in its own statement.  This is
   // because the overload of T::operator= for volatile *this should
   // return void, not volatile T&.  See Kokkos #177:
   //
   // https://github.com/kokkos/kokkos/issues/177
-  *dest = val;
+  *dest       = val;
   const T tmp = *dest;
-  #ifndef KOKKOS_COMPILER_CLANG
-  (void) tmp;
-  #endif
-  Impl::unlock_address_host_space( (void*) dest );
+#ifndef KOKKOS_COMPILER_CLANG
+  (void)tmp;
+#endif
+  Impl::unlock_address_host_space((void*)dest);
   return return_val;
 }
 
-template< typename T >
-inline
-void atomic_assign( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) || sizeof(T) == sizeof(long)
-                                  , const T & >::type val )
-{
-  typedef typename Kokkos::Impl::if_c< sizeof(T) == sizeof(int) , int , long >::type type ;
-
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+template <typename T>
+inline void atomic_assign(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int) ||
+                                         sizeof(T) == sizeof(long),
+                                     const T&>::type val) {
+  typedef typename Kokkos::Impl::if_c<sizeof(T) == sizeof(int), int, long>::type
+      type;
+
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  const type v = *((type*)&val); // Extract to be sure the value doesn't change
+  const type v = *((type*)&val);  // Extract to be sure the value doesn't change
 
-  type assumed ;
+  type assumed;
 
   union U {
-    T val_T ;
-    type val_type ;
-    inline U() {};
-  } old ;
+    T val_T;
+    type val_type;
+    inline U(){};
+  } old;
 
-  old.val_T = *dest ;
+  old.val_T = *dest;
 
   do {
-    assumed = old.val_type ;
-    old.val_type = __sync_val_compare_and_swap( (volatile type *) dest , assumed , v );
-  } while ( assumed != old.val_type );
+    assumed = old.val_type;
+    old.val_type =
+        __sync_val_compare_and_swap((volatile type*)dest, assumed, v);
+  } while (assumed != old.val_type);
 }
 
-#if defined( KOKKOS_ENABLE_ASM ) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-template< typename T >
-inline
-void atomic_assign( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(Impl::cas128_t)
-                                  , const T & >::type val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+template <typename T>
+inline void atomic_assign(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(Impl::cas128_t),
+                                     const T&>::type val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
   union U {
-    Impl::cas128_t i ;
-    T t ;
-    inline U() {};
-  } assume , oldval , newval ;
+    Impl::cas128_t i;
+    T t;
+    inline U(){};
+  } assume, oldval, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
   newval.t = val;
   do {
-    assume.i = oldval.i ;
-    oldval.i = Impl::cas128( (volatile Impl::cas128_t*) dest , assume.i , newval.i);
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    oldval.i = Impl::cas128((volatile Impl::cas128_t*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 }
 #endif
 
-template < typename T >
-inline
-void atomic_assign( volatile T * const dest ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-              #if defined(KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-               && ( sizeof(T) != 16 )
-              #endif
-                 , const T >::type& val )
-{
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+template <typename T>
+inline void atomic_assign(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8)
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+                                         && (sizeof(T) != 16)
+#endif
+                                         ,
+                                     const T>::type& val) {
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   // This is likely an aggregate type with a defined
   // 'volatile T & operator = ( const T & ) volatile'
   // member.  The volatile return value implicitly defines a
@@ -365,55 +355,45 @@ void atomic_assign( volatile T * const dest ,
   //(void)( *dest = val );
   *dest = val;
 
-  Impl::unlock_address_host_space( (void*) dest );
+  Impl::unlock_address_host_space((void*)dest);
 }
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
-template < typename T >
-inline
-T atomic_exchange( volatile T * const dest , const T val )
-{
+template <typename T>
+inline T atomic_exchange(volatile T* const dest, const T val) {
   T retval;
-//#pragma omp atomic capture
-  #pragma omp critical
+  //#pragma omp atomic capture
+#pragma omp critical
   {
-    retval = dest[0];
+    retval  = dest[0];
     dest[0] = val;
   }
   return retval;
 }
 
-template < typename T >
-inline
-void atomic_assign( volatile T * const dest , const T val )
-{
-//#pragma omp atomic
-  #pragma omp critical
-  {
-    dest[0] = val;
-  }
+template <typename T>
+inline void atomic_assign(volatile T* const dest, const T val) {
+  //#pragma omp atomic
+#pragma omp critical
+  { dest[0] = val; }
 }
 
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template < typename T >
-inline
-T atomic_exchange( volatile T * const dest_v , const T val )
-{
-  T* dest = const_cast<T*>(dest_v);
+template <typename T>
+inline T atomic_exchange(volatile T* const dest_v, const T val) {
+  T* dest  = const_cast<T*>(dest_v);
   T retval = *dest;
-  *dest = val;
+  *dest    = val;
   return retval;
 }
 
-template < typename T >
-inline
-void atomic_assign( volatile T * const dest_v , const T val )
-{
+template <typename T>
+inline void atomic_assign(volatile T* const dest_v, const T val) {
   T* dest = const_cast<T*>(dest_v);
-  *dest = val;
+  *dest   = val;
 }
 
 #endif
@@ -422,20 +402,16 @@ void atomic_assign( volatile T * const dest_v , const T val )
 // dummy for non-CUDA Kokkos headers being processed by NVCC
 #if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
 template <typename T>
-__inline__ __device__
-T atomic_exchange(volatile T * const, const Kokkos::Impl::identity_t<T>)
-{
+__inline__ __device__ T atomic_exchange(volatile T* const,
+                                        const Kokkos::Impl::identity_t<T>) {
   return T();
 }
 
-template < typename T >
-__inline__ __device__
-void atomic_assign(volatile T * const, const Kokkos::Impl::identity_t<T>)
-{
-}
+template <typename T>
+__inline__ __device__ void atomic_assign(volatile T* const,
+                                         const Kokkos::Impl::identity_t<T>) {}
 #endif
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Add.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Add.hpp
index 495fd48477a872c1e8fac5b52b8a8dd079fb7787..58277740da1e2de7803f9dbbc711a9089bae0d60 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Add.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Add.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,132 +42,134 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_FETCH_ADD_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_ADD_HPP)
 #define KOKKOS_ATOMIC_FETCH_ADD_HPP
 
 #if defined(KOKKOS_ENABLE_CUDA)
-#include<Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
+#include <Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
 #endif
 
 namespace Kokkos {
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 #if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 
 // Support for int, unsigned int, unsigned long long int, and float
 
-__inline__ __device__
-int atomic_fetch_add( volatile int * const dest , const int val )
-{ return atomicAdd((int*)dest,val); }
+__inline__ __device__ int atomic_fetch_add(volatile int* const dest,
+                                           const int val) {
+  return atomicAdd((int*)dest, val);
+}
 
-__inline__ __device__
-unsigned int atomic_fetch_add( volatile unsigned int * const dest , const unsigned int val )
-{ return atomicAdd((unsigned int*)dest,val); }
+__inline__ __device__ unsigned int atomic_fetch_add(
+    volatile unsigned int* const dest, const unsigned int val) {
+  return atomicAdd((unsigned int*)dest, val);
+}
 
-__inline__ __device__
-unsigned long long int atomic_fetch_add( volatile unsigned long long int * const dest ,
-                                         const unsigned long long int val )
-{ return atomicAdd((unsigned long long int*)dest,val); }
+__inline__ __device__ unsigned long long int atomic_fetch_add(
+    volatile unsigned long long int* const dest,
+    const unsigned long long int val) {
+  return atomicAdd((unsigned long long int*)dest, val);
+}
 
-__inline__ __device__
-float atomic_fetch_add( volatile float * const dest , const float val )
-{ return atomicAdd((float*)dest,val); }
+__inline__ __device__ float atomic_fetch_add(volatile float* const dest,
+                                             const float val) {
+  return atomicAdd((float*)dest, val);
+}
 
-#if ( 600 <= __CUDA_ARCH__ )
-__inline__ __device__
-double atomic_fetch_add( volatile double * const dest , const double val )
-{ return atomicAdd((double*)dest,val); }
+#if (600 <= __CUDA_ARCH__)
+__inline__ __device__ double atomic_fetch_add(volatile double* const dest,
+                                              const double val) {
+  return atomicAdd((double*)dest, val);
+}
 #endif
 
-template < typename T >
-__inline__ __device__
-T atomic_fetch_add( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T >::type val )
-{
+template <typename T>
+__inline__ __device__ T atomic_fetch_add(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T>::type
+        val) {
   // to work around a bug in the clang cuda compiler, the name here needs to be
   // different from the one internal to the other overloads
   union U1 {
-    int i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U1() {};
-  } assume , oldval , newval ;
+    int i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U1(){};
+  } assume, oldval, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t + val ;
-    oldval.i = atomicCAS( (int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t + val;
+    oldval.i = atomicCAS((int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-template < typename T >
-__inline__ __device__
-T atomic_fetch_add( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(unsigned long long int) , const T >::type val )
-{
+template <typename T>
+__inline__ __device__ T atomic_fetch_add(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<
+        sizeof(T) != sizeof(int) && sizeof(T) == sizeof(unsigned long long int),
+        const T>::type val) {
   // to work around a bug in the clang cuda compiler, the name here needs to be
   // different from the one internal to the other overloads
   union U2 {
-    unsigned long long int i ;
-    T t ;
-    KOKKOS_INLINE_FUNCTION U2() {};
-  } assume , oldval , newval ;
+    unsigned long long int i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U2(){};
+  } assume, oldval, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t + val ;
-    oldval.i = atomicCAS( (unsigned long long int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t + val;
+    oldval.i = atomicCAS((unsigned long long int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
 //----------------------------------------------------------------------------
 
-template < typename T >
-__inline__ __device__
-T atomic_fetch_add( volatile T * const dest ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-             , const T >::type& val )
-{
+template <typename T>
+__inline__ __device__ T atomic_fetch_add(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8),
+                                     const T>::type& val) {
   T return_val;
   // This is a way to (hopefully) avoid dead lock in a warp
   int done = 0;
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+  unsigned int mask   = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
   unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
   unsigned int done_active = 0;
-  while (active!=done_active) {
-    if(!done) {
-      bool locked = Impl::lock_address_cuda_space( (void*) dest );
-      if( locked ) {
+  while (active != done_active) {
+    if (!done) {
+      bool locked = Impl::lock_address_cuda_space((void*)dest);
+      if (locked) {
         return_val = *dest;
-        *dest = return_val + val;
-        Impl::unlock_address_cuda_space( (void*) dest );
+        *dest      = return_val + val;
+        Impl::unlock_address_cuda_space((void*)dest);
         done = 1;
       }
     }
 
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,done);
+    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, done);
 #else
     done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
 #endif
@@ -180,189 +183,179 @@ T atomic_fetch_add( volatile T * const dest ,
 #if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
 
-#if defined( KOKKOS_ENABLE_ASM ) && (defined(KOKKOS_ENABLE_ISA_X86_64) || defined(KOKKOS_KNL_USE_ASM_WORKAROUND))
-inline
-int atomic_fetch_add( volatile int * dest , const int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH ) 
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_ASM) && (defined(KOKKOS_ENABLE_ISA_X86_64) || \
+                                   defined(KOKKOS_KNL_USE_ASM_WORKAROUND))
+inline int atomic_fetch_add(volatile int* dest, const int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
   int original = val;
 
-  __asm__ __volatile__(
-  	"lock xadd %1, %0"
-        : "+m" (*dest), "+r" (original)
-        : "m" (*dest), "r" (original)
-        : "memory"
-        );
+  __asm__ __volatile__("lock xadd %1, %0"
+                       : "+m"(*dest), "+r"(original)
+                       : "m"(*dest), "r"(original)
+                       : "memory");
 
   return original;
 }
 #else
-inline
-int atomic_fetch_add( volatile int * const dest , const int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline int atomic_fetch_add(volatile int* const dest, const int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
   return __sync_fetch_and_add(dest, val);
 }
 #endif
 
-inline
-long int atomic_fetch_add( volatile long int * const dest , const long int val )
-{ 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline long int atomic_fetch_add(volatile long int* const dest,
+                                 const long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_add(dest,val);
+  return __sync_fetch_and_add(dest, val);
 }
 
-#if defined( KOKKOS_ENABLE_GNU_ATOMICS )
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
 
-inline
-unsigned int atomic_fetch_add( volatile unsigned int * const dest , const unsigned int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned int atomic_fetch_add(volatile unsigned int* const dest,
+                                     const unsigned int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_add(dest,val);
+  return __sync_fetch_and_add(dest, val);
 }
 
-inline
-unsigned long int atomic_fetch_add( volatile unsigned long int * const dest , const unsigned long int val )
-{ 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned long int atomic_fetch_add(
+    volatile unsigned long int* const dest, const unsigned long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_add(dest,val);
+  return __sync_fetch_and_add(dest, val);
 }
 
 #endif
 
-template < typename T >
-inline
-T atomic_fetch_add( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T >::type val )
-{
+template <typename T>
+inline T atomic_fetch_add(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T>::type
+        val) {
   union U {
-    int i ;
-    T t ;
-    inline U() {};
-  } assume , oldval , newval ;
+    int i;
+    T t;
+    inline U(){};
+  } assume, oldval, newval;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t + val ;
-    oldval.i = __sync_val_compare_and_swap( (int*) dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t + val;
+    oldval.i = __sync_val_compare_and_swap((int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-template < typename T >
-inline
-T atomic_fetch_add( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(long) , const T >::type val )
-{
+template <typename T>
+inline T atomic_fetch_add(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) == sizeof(long),
+                                     const T>::type val) {
   union U {
-    long i ;
-    T t ;
-    inline U() {};
-  } assume , oldval , newval ;
+    long i;
+    T t;
+    inline U(){};
+  } assume, oldval, newval;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t + val ;
-    oldval.i = __sync_val_compare_and_swap( (long*) dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t + val;
+    oldval.i = __sync_val_compare_and_swap((long*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-#if defined( KOKKOS_ENABLE_ASM ) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-template < typename T >
-inline
-T atomic_fetch_add( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) != sizeof(long) &&
-                                    sizeof(T) == sizeof(Impl::cas128_t) , const T >::type val )
-{
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+template <typename T>
+inline T atomic_fetch_add(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) != sizeof(long) &&
+                                         sizeof(T) == sizeof(Impl::cas128_t),
+                                     const T>::type val) {
   union U {
-    Impl::cas128_t i ;
-    T t ;
-    inline U() {};
-  } assume , oldval , newval ;
+    Impl::cas128_t i;
+    T t;
+    inline U(){};
+  } assume, oldval, newval;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t + val ;
-    oldval.i = Impl::cas128( (volatile Impl::cas128_t*) dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t + val;
+    oldval.i = Impl::cas128((volatile Impl::cas128_t*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 #endif
 
 //----------------------------------------------------------------------------
 
-template < typename T >
-inline
-T atomic_fetch_add( volatile T * const dest ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-              #if defined(KOKKOS_ENABLE_ASM) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
-               && ( sizeof(T) != 16 )
-              #endif
-                 , const T >::type& val )
-{
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+template <typename T>
+inline T atomic_fetch_add(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8)
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+                                         && (sizeof(T) != 16)
+#endif
+                                         ,
+                                     const T>::type& val) {
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   T return_val = *dest;
 
   // Don't use the following line of code here:
   //
-  //const T tmp = *dest = return_val + val;
+  // const T tmp = *dest = return_val + val;
   //
   // Instead, put each assignment in its own statement.  This is
   // because the overload of T::operator= for volatile *this should
   // return void, not volatile T&.  See Kokkos #177:
   //
   // https://github.com/kokkos/kokkos/issues/177
-  *dest = return_val + val;
+  *dest       = return_val + val;
   const T tmp = *dest;
-  (void) tmp;
-  Impl::unlock_address_host_space( (void*) dest );
+  (void)tmp;
+  Impl::unlock_address_host_space((void*)dest);
 
   return return_val;
 }
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
-template< typename T >
-T atomic_fetch_add( volatile T * const dest , const T val )
-{
+template <typename T>
+T atomic_fetch_add(volatile T* const dest, const T val) {
   T retval;
 #pragma omp atomic capture
   {
@@ -372,12 +365,12 @@ T atomic_fetch_add( volatile T * const dest , const T val )
   return retval;
 }
 
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template< typename T >
-T atomic_fetch_add( volatile T * const dest_v , typename std::add_const<T>::type val )
-{
-  T* dest = const_cast<T*>(dest_v);
+template <typename T>
+T atomic_fetch_add(volatile T* const dest_v,
+                   typename std::add_const<T>::type val) {
+  T* dest  = const_cast<T*>(dest_v);
   T retval = *dest;
   *dest += val;
   return retval;
@@ -385,25 +378,23 @@ T atomic_fetch_add( volatile T * const dest_v , typename std::add_const<T>::type
 
 #endif
 #endif
-#endif // !defined ROCM_ATOMICS
+#endif  // !defined ROCM_ATOMICS
 //----------------------------------------------------------------------------
 
 // dummy for non-CUDA Kokkos headers being processed by NVCC
 #if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template< typename T >
-__inline__ __device__
-T atomic_fetch_add(volatile T* const, Kokkos::Impl::identity_t<T>) {
+template <typename T>
+__inline__ __device__ T atomic_fetch_add(volatile T* const,
+                                         Kokkos::Impl::identity_t<T>) {
   return T();
 }
 #endif
 
 // Simpler version of atomic_fetch_add without the fetch
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_add(volatile T * const dest, const T src) {
-  atomic_fetch_add(dest,src);
+KOKKOS_INLINE_FUNCTION void atomic_add(volatile T* const dest, const T src) {
+  atomic_fetch_add(dest, src);
 }
 
-}
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_And.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_And.hpp
index db0d97ca19ebde9b30e5030b43b7338ed6388739..1ad54ed3f1b251bdb6b5a252ab245e2971a33e95 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_And.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_And.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,36 +42,39 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_FETCH_AND_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_AND_HPP)
 #define KOKKOS_ATOMIC_FETCH_AND_HPP
 
 namespace Kokkos {
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 #if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 
 // Support for int, unsigned int, unsigned long long int, and float
 
-__inline__ __device__
-int atomic_fetch_and( volatile int * const dest , const int val )
-{ return atomicAnd((int*)dest,val); }
+__inline__ __device__ int atomic_fetch_and(volatile int* const dest,
+                                           const int val) {
+  return atomicAnd((int*)dest, val);
+}
 
-__inline__ __device__
-unsigned int atomic_fetch_and( volatile unsigned int * const dest , const unsigned int val )
-{ return atomicAnd((unsigned int*)dest,val); }
+__inline__ __device__ unsigned int atomic_fetch_and(
+    volatile unsigned int* const dest, const unsigned int val) {
+  return atomicAnd((unsigned int*)dest, val);
+}
 
-#if defined( __CUDA_ARCH__ ) && ( 350 <= __CUDA_ARCH__ )
-__inline__ __device__
-unsigned long long int atomic_fetch_and( volatile unsigned long long int * const dest ,
-                                         const unsigned long long int val )
-{ return atomicAnd((unsigned long long int*)dest,val); }
+#if defined(__CUDA_ARCH__) && (350 <= __CUDA_ARCH__)
+__inline__ __device__ unsigned long long int atomic_fetch_and(
+    volatile unsigned long long int* const dest,
+    const unsigned long long int val) {
+  return atomicAnd((unsigned long long int*)dest, val);
+}
 #endif
 #endif
 #endif
@@ -78,53 +82,47 @@ unsigned long long int atomic_fetch_and( volatile unsigned long long int * const
 #if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
 
-inline
-int atomic_fetch_and( volatile int * const dest , const int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline int atomic_fetch_and(volatile int* const dest, const int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_and(dest,val);
+  return __sync_fetch_and_and(dest, val);
 }
 
-inline
-long int atomic_fetch_and( volatile long int * const dest , const long int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline long int atomic_fetch_and(volatile long int* const dest,
+                                 const long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_and(dest,val);
+  return __sync_fetch_and_and(dest, val);
 }
 
-#if defined( KOKKOS_ENABLE_GNU_ATOMICS )
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
 
-inline
-unsigned int atomic_fetch_and( volatile unsigned int * const dest , const unsigned int val )
-{ 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned int atomic_fetch_and(volatile unsigned int* const dest,
+                                     const unsigned int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_and(dest,val);
+  return __sync_fetch_and_and(dest, val);
 }
 
-inline
-unsigned long int atomic_fetch_and( volatile unsigned long int * const dest , const unsigned long int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned long int atomic_fetch_and(
+    volatile unsigned long int* const dest, const unsigned long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_and(dest,val);
+  return __sync_fetch_and_and(dest, val);
 }
 
 #endif
 
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
-template< typename T >
-T atomic_fetch_and( volatile T * const dest , const T val )
-{
+template <typename T>
+T atomic_fetch_and(volatile T* const dest, const T val) {
   T retval;
 #pragma omp atomic capture
   {
@@ -134,12 +132,11 @@ T atomic_fetch_and( volatile T * const dest , const T val )
   return retval;
 }
 
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template< typename T >
-T atomic_fetch_and( volatile T * const dest_v , const T val )
-{
-  T* dest = const_cast<T*>(dest_v);
+template <typename T>
+T atomic_fetch_and(volatile T* const dest_v, const T val) {
+  T* dest  = const_cast<T*>(dest_v);
   T retval = *dest;
   *dest &= val;
   return retval;
@@ -151,21 +148,19 @@ T atomic_fetch_and( volatile T * const dest_v , const T val )
 
 // dummy for non-CUDA Kokkos headers being processed by NVCC
 #if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template< typename T >
-__inline__ __device__
-T atomic_fetch_and(volatile T* const, Kokkos::Impl::identity_t<T>) {
+template <typename T>
+__inline__ __device__ T atomic_fetch_and(volatile T* const,
+                                         Kokkos::Impl::identity_t<T>) {
   return T();
 }
 #endif
 
 // Simpler version of atomic_fetch_and without the fetch
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_and(volatile T * const dest, const T src) {
-  (void)atomic_fetch_and(dest,src);
+KOKKOS_INLINE_FUNCTION void atomic_and(volatile T* const dest, const T src) {
+  (void)atomic_fetch_and(dest, src);
 }
 
-}
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Or.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Or.hpp
index d146ef3148050d904306e92f5fd87604dd9e3ae4..dc567265a73a7d2e10933a462f93d54d31b73004 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Or.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Or.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,36 +42,39 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_FETCH_OR_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_OR_HPP)
 #define KOKKOS_ATOMIC_FETCH_OR_HPP
 
 namespace Kokkos {
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 #if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 
 // Support for int, unsigned int, unsigned long long int, and float
 
-__inline__ __device__
-int atomic_fetch_or( volatile int * const dest , const int val )
-{ return atomicOr((int*)dest,val); }
+__inline__ __device__ int atomic_fetch_or(volatile int* const dest,
+                                          const int val) {
+  return atomicOr((int*)dest, val);
+}
 
-__inline__ __device__
-unsigned int atomic_fetch_or( volatile unsigned int * const dest , const unsigned int val )
-{ return atomicOr((unsigned int*)dest,val); }
+__inline__ __device__ unsigned int atomic_fetch_or(
+    volatile unsigned int* const dest, const unsigned int val) {
+  return atomicOr((unsigned int*)dest, val);
+}
 
-#if defined( __CUDA_ARCH__ ) && ( 350 <= __CUDA_ARCH__ )
-__inline__ __device__
-unsigned long long int atomic_fetch_or( volatile unsigned long long int * const dest ,
-                                         const unsigned long long int val )
-{ return atomicOr((unsigned long long int*)dest,val); }
+#if defined(__CUDA_ARCH__) && (350 <= __CUDA_ARCH__)
+__inline__ __device__ unsigned long long int atomic_fetch_or(
+    volatile unsigned long long int* const dest,
+    const unsigned long long int val) {
+  return atomicOr((unsigned long long int*)dest, val);
+}
 #endif
 #endif
 #endif
@@ -78,53 +82,47 @@ unsigned long long int atomic_fetch_or( volatile unsigned long long int * const
 #if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
 
-inline
-int atomic_fetch_or( volatile int * const dest , const int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline int atomic_fetch_or(volatile int* const dest, const int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_or(dest,val);
+  return __sync_fetch_and_or(dest, val);
 }
 
-inline
-long int atomic_fetch_or( volatile long int * const dest , const long int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline long int atomic_fetch_or(volatile long int* const dest,
+                                const long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_or(dest,val);
+  return __sync_fetch_and_or(dest, val);
 }
 
-#if defined( KOKKOS_ENABLE_GNU_ATOMICS )
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
 
-inline
-unsigned int atomic_fetch_or( volatile unsigned int * const dest , const unsigned int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned int atomic_fetch_or(volatile unsigned int* const dest,
+                                    const unsigned int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_or(dest,val);
+  return __sync_fetch_and_or(dest, val);
 }
 
-inline
-unsigned long int atomic_fetch_or( volatile unsigned long int * const dest , const unsigned long int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned long int atomic_fetch_or(volatile unsigned long int* const dest,
+                                         const unsigned long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_or(dest,val);
+  return __sync_fetch_and_or(dest, val);
 }
 
 #endif
 
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
-template< typename T >
-T atomic_fetch_or( volatile T * const dest , const T val )
-{
+template <typename T>
+T atomic_fetch_or(volatile T* const dest, const T val) {
   T retval;
 #pragma omp atomic capture
   {
@@ -134,12 +132,11 @@ T atomic_fetch_or( volatile T * const dest , const T val )
   return retval;
 }
 
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template< typename T >
-T atomic_fetch_or( volatile T * const dest_v , const T val )
-{
-  T* dest = const_cast<T*>(dest_v);
+template <typename T>
+T atomic_fetch_or(volatile T* const dest_v, const T val) {
+  T* dest  = const_cast<T*>(dest_v);
   T retval = *dest;
   *dest |= val;
   return retval;
@@ -151,21 +148,19 @@ T atomic_fetch_or( volatile T * const dest_v , const T val )
 
 // dummy for non-CUDA Kokkos headers being processed by NVCC
 #if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template< typename T >
-__inline__ __device__
-T atomic_fetch_or(volatile T* const, Kokkos::Impl::identity_t<T>) {
+template <typename T>
+__inline__ __device__ T atomic_fetch_or(volatile T* const,
+                                        Kokkos::Impl::identity_t<T>) {
   return T();
 }
 #endif
 
 // Simpler version of atomic_fetch_or without the fetch
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_or(volatile T * const dest, const T src) {
-  (void)atomic_fetch_or(dest,src);
+KOKKOS_INLINE_FUNCTION void atomic_or(volatile T* const dest, const T src) {
+  (void)atomic_fetch_or(dest, src);
 }
 
-}
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Sub.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Sub.hpp
index 7a4f95cd9960e5643382e34c95d2d4529aeaf0ef..91da9fdcaa40ce5d02e9a1868b3ffdb1bc511be0 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Sub.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Fetch_Sub.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,126 +42,127 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_FETCH_SUB_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_SUB_HPP)
 #define KOKKOS_ATOMIC_FETCH_SUB_HPP
 
 #if defined(KOKKOS_ENABLE_CUDA)
-#include<Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
+#include <Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
 #endif
 
 namespace Kokkos {
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_ENABLE_CUDA )
+#if defined(KOKKOS_ENABLE_CUDA)
 #if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 
 // Support for int, unsigned int, unsigned long long int, and float
 
-__inline__ __device__
-int atomic_fetch_sub( volatile int * const dest , const int val )
-{ return atomicSub((int*)dest,val); }
+__inline__ __device__ int atomic_fetch_sub(volatile int* const dest,
+                                           const int val) {
+  return atomicSub((int*)dest, val);
+}
 
-__inline__ __device__
-unsigned int atomic_fetch_sub( volatile unsigned int * const dest , const unsigned int val )
-{ return atomicSub((unsigned int*)dest,val); }
+__inline__ __device__ unsigned int atomic_fetch_sub(
+    volatile unsigned int* const dest, const unsigned int val) {
+  return atomicSub((unsigned int*)dest, val);
+}
 
-__inline__ __device__
-unsigned int atomic_fetch_sub( volatile int64_t * const dest , const int64_t val )
-{ return atomic_fetch_add(dest,-val); }
+__inline__ __device__ unsigned int atomic_fetch_sub(
+    volatile int64_t* const dest, const int64_t val) {
+  return atomic_fetch_add(dest, -val);
+}
 
-__inline__ __device__
-unsigned int atomic_fetch_sub( volatile float * const dest , const float val )
-{ return atomicAdd((float*)dest,-val); }
+__inline__ __device__ unsigned int atomic_fetch_sub(volatile float* const dest,
+                                                    const float val) {
+  return atomicAdd((float*)dest, -val);
+}
 
-#if ( 600 <= __CUDA_ARCH__ )
-__inline__ __device__
-unsigned int atomic_fetch_sub( volatile double * const dest , const double val )
-{ return atomicAdd((double*)dest,-val); }
+#if (600 <= __CUDA_ARCH__)
+__inline__ __device__ unsigned int atomic_fetch_sub(volatile double* const dest,
+                                                    const double val) {
+  return atomicAdd((double*)dest, -val);
+}
 #endif
 
-template < typename T >
-__inline__ __device__
-T atomic_fetch_sub( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T >::type val )
-{
+template <typename T>
+__inline__ __device__ T atomic_fetch_sub(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T>::type
+        val) {
   union U {
-    int i ;
-    T t ;
+    int i;
+    T t;
     KOKKOS_INLINE_FUNCTION U() {}
-  } oldval , assume , newval ;
+  } oldval, assume, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t - val ;
-    oldval.i = atomicCAS( (int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t - val;
+    oldval.i = atomicCAS((int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-template < typename T >
-__inline__ __device__
-T atomic_fetch_sub( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(unsigned long long int) , const T >::type val )
-{
+template <typename T>
+__inline__ __device__ T atomic_fetch_sub(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<
+        sizeof(T) != sizeof(int) && sizeof(T) == sizeof(unsigned long long int),
+        const T>::type val) {
   union U {
-    unsigned long long int i ;
-    T t ;
+    unsigned long long int i;
+    T t;
     KOKKOS_INLINE_FUNCTION U() {}
-  } oldval , assume , newval ;
+  } oldval, assume, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t - val ;
-    oldval.i = atomicCAS( (unsigned long long int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t - val;
+    oldval.i = atomicCAS((unsigned long long int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-
 //----------------------------------------------------------------------------
 
-template < typename T >
-__inline__ __device__
-T atomic_fetch_sub( volatile T * const dest ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-             , const T >::type& val )
-{
+template <typename T>
+__inline__ __device__ T atomic_fetch_sub(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8),
+                                     const T>::type& val) {
   T return_val;
   // This is a way to (hopefully) avoid dead lock in a warp
   int done = 0;
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+  unsigned int mask   = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
   unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
   unsigned int done_active = 0;
-  while (active!=done_active) {
-    if(!done) {
-      if( Impl::lock_address_cuda_space( (void*) dest ) ) {
+  while (active != done_active) {
+    if (!done) {
+      if (Impl::lock_address_cuda_space((void*)dest)) {
         return_val = *dest;
-        *dest = return_val - val;
-        Impl::unlock_address_cuda_space( (void*) dest );
+        *dest      = return_val - val;
+        Impl::unlock_address_cuda_space((void*)dest);
         done = 1;
       }
     }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,done);
+    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, done);
 #else
     done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
 #endif
@@ -174,128 +176,119 @@ T atomic_fetch_sub( volatile T * const dest ,
 #if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
 
-inline
-int atomic_fetch_sub( volatile int * const dest , const int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline int atomic_fetch_sub(volatile int* const dest, const int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_sub(dest,val);
+  return __sync_fetch_and_sub(dest, val);
 }
 
-inline
-long int atomic_fetch_sub( volatile long int * const dest , const long int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline long int atomic_fetch_sub(volatile long int* const dest,
+                                 const long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_sub(dest,val);
+  return __sync_fetch_and_sub(dest, val);
 }
 
-#if defined( KOKKOS_ENABLE_GNU_ATOMICS )
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
 
-inline
-unsigned int atomic_fetch_sub( volatile unsigned int * const dest , const unsigned int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned int atomic_fetch_sub(volatile unsigned int* const dest,
+                                     const unsigned int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_sub(dest,val);
+  return __sync_fetch_and_sub(dest, val);
 }
 
-inline
-unsigned long int atomic_fetch_sub( volatile unsigned long int * const dest , const unsigned long int val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+inline unsigned long int atomic_fetch_sub(
+    volatile unsigned long int* const dest, const unsigned long int val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
-  return __sync_fetch_and_sub(dest,val);
+  return __sync_fetch_and_sub(dest, val);
 }
 
 #endif
 
-template < typename T >
-inline
-T atomic_fetch_sub( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T >::type val )
-{
+template <typename T>
+inline T atomic_fetch_sub(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T>::type
+        val) {
   union U {
-    int i ;
-    T t ;
+    int i;
+    T t;
     KOKKOS_INLINE_FUNCTION U() {}
-  } oldval , assume , newval ;
+  } oldval, assume, newval;
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t - val ;
-    oldval.i = __sync_val_compare_and_swap( (int*) dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t - val;
+    oldval.i = __sync_val_compare_and_swap((int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-template < typename T >
-inline
-T atomic_fetch_sub( volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(long) , const T >::type val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+template <typename T>
+inline T atomic_fetch_sub(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) != sizeof(int) &&
+                                         sizeof(T) == sizeof(long),
+                                     const T>::type val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
   union U {
-     long i ;
-     T t ;
-     KOKKOS_INLINE_FUNCTION U() {}
-   } oldval , assume , newval ;
+    long i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U() {}
+  } oldval, assume, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = assume.t - val ;
-    oldval.i = __sync_val_compare_and_swap( (long*) dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = assume.t - val;
+    oldval.i = __sync_val_compare_and_swap((long*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-
 //----------------------------------------------------------------------------
 
-template < typename T >
-inline
-T atomic_fetch_sub( volatile T * const dest ,
-    typename Kokkos::Impl::enable_if<
-                  ( sizeof(T) != 4 )
-               && ( sizeof(T) != 8 )
-             , const T >::type& val )
-{
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) dest, _MM_HINT_ET0 );
+template <typename T>
+inline T atomic_fetch_sub(
+    volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8),
+                                     const T>::type& val) {
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
 #endif
 
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   T return_val = *dest;
-  *dest = return_val - val;
-  Impl::unlock_address_host_space( (void*) dest );
+  *dest        = return_val - val;
+  Impl::unlock_address_host_space((void*)dest);
   return return_val;
 }
 
 //----------------------------------------------------------------------------
 
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
-template< typename T >
-T atomic_fetch_sub( volatile T * const dest , const T val )
-{
+template <typename T>
+T atomic_fetch_sub(volatile T* const dest, const T val) {
   T retval;
 #pragma omp atomic capture
   {
@@ -305,12 +298,11 @@ T atomic_fetch_sub( volatile T * const dest , const T val )
   return retval;
 }
 
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template< typename T >
-T atomic_fetch_sub( volatile T * const dest_v , const T val )
-{
-  T* dest = const_cast<T*>(dest_v);
+template <typename T>
+T atomic_fetch_sub(volatile T* const dest_v, const T val) {
+  T* dest  = const_cast<T*>(dest_v);
   T retval = *dest;
   *dest -= val;
   return retval;
@@ -318,26 +310,24 @@ T atomic_fetch_sub( volatile T * const dest_v , const T val )
 
 #endif
 #endif
-#endif // !defined ROCM_ATOMICS
+#endif  // !defined ROCM_ATOMICS
 
 // dummy for non-CUDA Kokkos headers being processed by NVCC
 #if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template< typename T >
-__inline__ __device__
-T atomic_fetch_sub(volatile T* const, Kokkos::Impl::identity_t<T>) {
+template <typename T>
+__inline__ __device__ T atomic_fetch_sub(volatile T* const,
+                                         Kokkos::Impl::identity_t<T>) {
   return T();
 }
 #endif
 
 // Simpler version of atomic_fetch_sub without the fetch
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_sub(volatile T * const dest, const T src) {
-  atomic_fetch_sub(dest,src);
+KOKKOS_INLINE_FUNCTION void atomic_sub(volatile T* const dest, const T src) {
+  atomic_fetch_sub(dest, src);
 }
 
-}
+}  // namespace Kokkos
 
-#include<impl/Kokkos_Atomic_Assembly.hpp>
+#include <impl/Kokkos_Atomic_Assembly.hpp>
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Generic.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Generic.hpp
index c1a7d803642515f321f9cd18f1f61cdee4d88585..160a4e79218a50345fe413bdace7c856ee30d30f 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Generic.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Generic.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,19 +43,20 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_ATOMIC_GENERIC_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_GENERIC_HPP)
 #define KOKKOS_ATOMIC_GENERIC_HPP
 #include <Kokkos_Macros.hpp>
 
 #if defined(KOKKOS_ENABLE_CUDA)
-#include<Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
+#include <Cuda/Kokkos_Cuda_Version_9_8_Compatibility.hpp>
 #endif
 
-// Combination operands to be used in an Compare and Exchange based atomic operation
+// Combination operands to be used in an Compare and Exchange based atomic
+// operation
 namespace Kokkos {
 namespace Impl {
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct MaxOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
@@ -62,7 +64,7 @@ struct MaxOper {
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct MinOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
@@ -70,213 +72,213 @@ struct MinOper {
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct AddOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1+val2;
+    return val1 + val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct SubOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1-val2;
+    return val1 - val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct MulOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1*val2;
+    return val1 * val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct DivOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1/val2;
+    return val1 / val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct ModOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1%val2;
+    return val1 % val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct AndOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1&val2;
+    return val1 & val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct OrOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1|val2;
+    return val1 | val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct XorOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1^val2;
+    return val1 ^ val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct LShiftOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1<<val2;
+    return val1 << val2;
   }
 };
 
-template<class Scalar1, class Scalar2>
+template <class Scalar1, class Scalar2>
 struct RShiftOper {
   KOKKOS_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1>>val2;
+    return val1 >> val2;
   }
 };
 
-template < class Oper, typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_oper( const Oper& op, volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(unsigned long long int) , const T >::type val )
-{
+template <class Oper, typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_oper(
+    const Oper& op, volatile T* const dest,
+    typename Kokkos::Impl::enable_if<
+        sizeof(T) != sizeof(int) && sizeof(T) == sizeof(unsigned long long int),
+        const T>::type val) {
   union U {
-    unsigned long long int i ;
-    T t ;
+    unsigned long long int i;
+    T t;
     KOKKOS_INLINE_FUNCTION U() {}
-  } oldval , assume , newval ;
+  } oldval, assume, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = op.apply(assume.t, val) ;
-    oldval.i = Kokkos::atomic_compare_exchange( (unsigned long long int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = op.apply(assume.t, val);
+    oldval.i = Kokkos::atomic_compare_exchange((unsigned long long int*)dest,
+                                               assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-template < class Oper, typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_oper_fetch( const Oper& op, volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) != sizeof(int) &&
-                                    sizeof(T) == sizeof(unsigned long long int) , const T >::type val )
-{
+template <class Oper, typename T>
+KOKKOS_INLINE_FUNCTION T atomic_oper_fetch(
+    const Oper& op, volatile T* const dest,
+    typename Kokkos::Impl::enable_if<
+        sizeof(T) != sizeof(int) && sizeof(T) == sizeof(unsigned long long int),
+        const T>::type val) {
   union U {
-    unsigned long long int i ;
-    T t ;
+    unsigned long long int i;
+    T t;
     KOKKOS_INLINE_FUNCTION U() {}
-  } oldval , assume , newval ;
+  } oldval, assume, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = Oper::apply(assume.t, val) ;
-    oldval.i = Kokkos::atomic_compare_exchange( (unsigned long long int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = Oper::apply(assume.t, val);
+    oldval.i = Kokkos::atomic_compare_exchange((unsigned long long int*)dest,
+                                               assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return newval.t ;
+  return newval.t;
 }
 
-template < class Oper, typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_oper( const Oper& op, volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int) , const T >::type val )
-{
+template <class Oper, typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_oper(
+    const Oper& op, volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T>::type
+        val) {
   union U {
-    int i ;
-    T t ;
+    int i;
+    T t;
     KOKKOS_INLINE_FUNCTION U() {}
-  } oldval , assume , newval ;
+  } oldval, assume, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = op.apply(assume.t, val) ;
-    oldval.i = Kokkos::atomic_compare_exchange( (int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = op.apply(assume.t, val);
+    oldval.i = Kokkos::atomic_compare_exchange((int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return oldval.t ;
+  return oldval.t;
 }
 
-template < class Oper, typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_oper_fetch( const Oper& op, volatile T * const dest ,
-  typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(int), const T >::type val )
-{
+template <class Oper, typename T>
+KOKKOS_INLINE_FUNCTION T atomic_oper_fetch(
+    const Oper& op, volatile T* const dest,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(int), const T>::type
+        val) {
   union U {
-    int i ;
-    T t ;
+    int i;
+    T t;
     KOKKOS_INLINE_FUNCTION U() {}
-  } oldval , assume , newval ;
+  } oldval, assume, newval;
 
-  oldval.t = *dest ;
+  oldval.t = *dest;
 
   do {
-    assume.i = oldval.i ;
-    newval.t = Oper::apply(assume.t, val) ;
-    oldval.i = Kokkos::atomic_compare_exchange( (int*)dest , assume.i , newval.i );
-  } while ( assume.i != oldval.i );
+    assume.i = oldval.i;
+    newval.t = Oper::apply(assume.t, val);
+    oldval.i = Kokkos::atomic_compare_exchange((int*)dest, assume.i, newval.i);
+  } while (assume.i != oldval.i);
 
-  return newval.t ;
+  return newval.t;
 }
 
-template < class Oper, typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_oper( const Oper& op, volatile T * const dest ,
-  typename Kokkos::Impl::enable_if<
-                ( sizeof(T) != 4 )
-             && ( sizeof(T) != 8 )
-           , const T >::type val )
-{
-
+template <class Oper, typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_oper(
+    const Oper& op, volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8),
+                                     const T>::type val) {
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   T return_val = *dest;
-  *dest = Oper::apply(return_val, val);
-  Impl::unlock_address_host_space( (void*) dest );
+  *dest        = Oper::apply(return_val, val);
+  Impl::unlock_address_host_space((void*)dest);
   return return_val;
 #elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
   // This is a way to (hopefully) avoid dead lock in a warp
   T return_val;
-  int done = 0;
+  int done                 = 0;
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+  unsigned int mask        = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+  unsigned int active      = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
   unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
   unsigned int done_active = 0;
-  while (active!=done_active) {
-    if(!done) {
-      if( Impl::lock_address_cuda_space( (void*) dest ) ) {
+  while (active != done_active) {
+    if (!done) {
+      if (Impl::lock_address_cuda_space((void*)dest)) {
         return_val = *dest;
-        *dest = Oper::apply(return_val, val);;
-        Impl::unlock_address_cuda_space( (void*) dest );
-        done=1;
+        *dest      = Oper::apply(return_val, val);
+        ;
+        Impl::unlock_address_cuda_space((void*)dest);
+        done = 1;
       }
     }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,done);
+    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, done);
 #else
     done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
 #endif
@@ -285,46 +287,46 @@ T atomic_fetch_oper( const Oper& op, volatile T * const dest ,
 #endif
 }
 
-template < class Oper, typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_oper_fetch( const Oper& op, volatile T * const dest ,
-  typename Kokkos::Impl::enable_if<
-                ( sizeof(T) != 4 )
-             && ( sizeof(T) != 8 )
-          #if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
-             && ( sizeof(T) != 16 )
-          #endif
-           , const T >::type& val )
-{
+template <class Oper, typename T>
+KOKKOS_INLINE_FUNCTION T atomic_oper_fetch(
+    const Oper& op, volatile T* const dest,
+    typename Kokkos::Impl::enable_if<(sizeof(T) != 4) && (sizeof(T) != 8)
+#if defined(KOKKOS_ENABLE_ASM) && \
+    defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+                                         && (sizeof(T) != 16)
+#endif
+                                         ,
+                                     const T>::type& val) {
 
 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-  while( !Impl::lock_address_host_space( (void*) dest ) );
+  while (!Impl::lock_address_host_space((void*)dest))
+    ;
   T return_val = Oper::apply(*dest, val);
-  *dest = return_val;
-  Impl::unlock_address_host_space( (void*) dest );
+  *dest        = return_val;
+  Impl::unlock_address_host_space((void*)dest);
   return return_val;
 #elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
   T return_val;
   // This is a way to (hopefully) avoid dead lock in a warp
-  int done = 0;
+  int done                 = 0;
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-  unsigned int mask = KOKKOS_IMPL_CUDA_ACTIVEMASK;
-  unsigned int active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,1);
+  unsigned int mask        = KOKKOS_IMPL_CUDA_ACTIVEMASK;
+  unsigned int active      = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, 1);
 #else
   unsigned int active = KOKKOS_IMPL_CUDA_BALLOT(1);
 #endif
   unsigned int done_active = 0;
-  while (active!=done_active) {
-    if(!done) {
-      if( Impl::lock_address_cuda_space( (void*) dest ) ) {
+  while (active != done_active) {
+    if (!done) {
+      if (Impl::lock_address_cuda_space((void*)dest)) {
         return_val = Oper::apply(*dest, val);
-        *dest = return_val;
-        Impl::unlock_address_cuda_space( (void*) dest );
-        done=1;
+        *dest      = return_val;
+        Impl::unlock_address_cuda_space((void*)dest);
+        done = 1;
       }
     }
 #ifdef KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
-    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask,done);
+    done_active = KOKKOS_IMPL_CUDA_BALLOT_MASK(mask, done);
 #else
     done_active = KOKKOS_IMPL_CUDA_BALLOT(done);
 #endif
@@ -333,138 +335,124 @@ T atomic_oper_fetch( const Oper& op, volatile T * const dest ,
 #endif
 }
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 
 // Fetch_Oper atomics: return value before operation
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_max(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::MaxOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_max(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::MaxOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_min(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::MinOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_min(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::MinOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_mul(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::MulOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_mul(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::MulOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_div(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::DivOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_div(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::DivOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_mod(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::ModOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_mod(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::ModOper<T, const T>(), dest, val);
 }
 
-#if !defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+#if !defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_and(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::AndOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_and(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::AndOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_or(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::OrOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_or(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::OrOper<T, const T>(), dest, val);
 }
 
 #endif
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_xor(volatile T * const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::XorOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_xor(volatile T* const dest, const T val) {
+  return Impl::atomic_fetch_oper(Impl::XorOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_lshift(volatile T * const dest, const unsigned int val) {
-  return Impl::atomic_fetch_oper(Impl::LShiftOper<T,const unsigned int>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_lshift(volatile T* const dest,
+                                             const unsigned int val) {
+  return Impl::atomic_fetch_oper(Impl::LShiftOper<T, const unsigned int>(),
+                                 dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_fetch_rshift(volatile T * const dest, const unsigned int val) {
-  return Impl::atomic_fetch_oper(Impl::RShiftOper<T,const unsigned int>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_fetch_rshift(volatile T* const dest,
+                                             const unsigned int val) {
+  return Impl::atomic_fetch_oper(Impl::RShiftOper<T, const unsigned int>(),
+                                 dest, val);
 }
 
-
 // Oper Fetch atomics: return value after operation
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_max_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::MaxOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_max_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::MaxOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_min_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::MinOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_min_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::MinOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_mul_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::MulOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_mul_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::MulOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_div_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::DivOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_div_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::DivOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_mod_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::ModOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_mod_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::ModOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_and_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::AndOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_and_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::AndOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_or_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::OrOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_or_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::OrOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_xor_fetch(volatile T * const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::XorOper<T,const T>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_xor_fetch(volatile T* const dest, const T val) {
+  return Impl::atomic_oper_fetch(Impl::XorOper<T, const T>(), dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_lshift_fetch(volatile T * const dest, const unsigned int val) {
-  return Impl::atomic_oper_fetch(Impl::LShiftOper<T,const unsigned int>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_lshift_fetch(volatile T* const dest,
+                                             const unsigned int val) {
+  return Impl::atomic_oper_fetch(Impl::LShiftOper<T, const unsigned int>(),
+                                 dest, val);
 }
 
-template < typename T >
-KOKKOS_INLINE_FUNCTION
-T atomic_rshift_fetch(volatile T * const dest, const unsigned int val) {
-  return Impl::atomic_oper_fetch(Impl::RShiftOper<T,const unsigned int>(),dest,val);
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_rshift_fetch(volatile T* const dest,
+                                             const unsigned int val) {
+  return Impl::atomic_oper_fetch(Impl::RShiftOper<T, const unsigned int>(),
+                                 dest, val);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Increment.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Increment.hpp
index a1a8357b61313519865ca04a6c7d0624f26cfaec..f0ffebef9a22683c586136ccafc458961c87bd01 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Increment.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Increment.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,31 +42,29 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
 #include <xmmintrin.h>
 #endif
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP) && ! defined( KOKKOS_ATOMIC_INCREMENT_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_INCREMENT_HPP)
 #define KOKKOS_ATOMIC_INCREMENT_HPP
 
 namespace Kokkos {
 
 // Atomic increment
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_increment<char>(volatile char* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_increment<char>(volatile char* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock incb %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock incb %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   char* a_nv = const_cast<char*>(a);
   ++(*a_nv);
 #else
@@ -73,20 +72,18 @@ void atomic_increment<char>(volatile char* a) {
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_increment<short>(volatile short* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_increment<short>(volatile short* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock incw %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock incw %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   short* a_nv = const_cast<short*>(a);
   ++(*a_nv);
 #else
@@ -94,60 +91,55 @@ void atomic_increment<short>(volatile short* a) {
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_increment<int>(volatile int* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_increment<int>(volatile int* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock incl %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock incl %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   int* a_nv = const_cast<int*>(a);
   ++(*a_nv);
 #else
-  Kokkos::atomic_fetch_add(a,int(1));
+  Kokkos::atomic_fetch_add(a, int(1));
 #endif
 }
 
-template<>
-KOKKOS_INLINE_FUNCTION
-void atomic_increment<long long int>(volatile long long int* a) {
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 ) && ! defined(_WIN32) && ! defined(__CUDA_ARCH__)
-#if defined( KOKKOS_ENABLE_RFO_PREFETCH )
-  _mm_prefetch( (const char*) a, _MM_HINT_ET0 );
+template <>
+KOKKOS_INLINE_FUNCTION void atomic_increment<long long int>(
+    volatile long long int* a) {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
+    !defined(_WIN32) && !defined(__CUDA_ARCH__)
+#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
+  _mm_prefetch((const char*)a, _MM_HINT_ET0);
 #endif
-  __asm__ __volatile__(
-      "lock incq %0"
-      : /* no output registers */
-      : "m" (a[0])
-      : "memory"
-    );
-#elif defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+  __asm__ __volatile__("lock incq %0"
+                       : /* no output registers */
+                       : "m"(a[0])
+                       : "memory");
+#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   long long int* a_nv = const_cast<long long int*>(a);
   ++(*a_nv);
 #else
   using T = long long int;
-  Kokkos::atomic_fetch_add(a,T(1));
+  Kokkos::atomic_fetch_add(a, T(1));
 #endif
 }
 
-template<typename T>
-KOKKOS_INLINE_FUNCTION
-void atomic_increment(volatile T* a) {
-#if defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
+template <typename T>
+KOKKOS_INLINE_FUNCTION void atomic_increment(volatile T* a) {
+#if defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
   T* a_nv = const_cast<T*>(a);
   ++(*a_nv);
 #else
-  Kokkos::atomic_fetch_add(a,T(1));
+  Kokkos::atomic_fetch_add(a, T(1));
 #endif
 }
 
-} // End of namespace Kokkos
+}  // End of namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Load.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Load.hpp
index 2db74b9f1e90519f5000fd947ce254913dd84f89..6b4c82b6203ccf1ba2ad5f7aa3a96b283279917c 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Load.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Load.hpp
@@ -2,10 +2,10 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
+//                        Kokkos v. 3.0
 //              Copyright (2019) Sandia Corporation
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,6 +48,7 @@
 #if defined(KOKKOS_ATOMIC_HPP)
 
 #include <impl/Kokkos_Atomic_Memory_Order.hpp>
+#include <impl/Kokkos_Atomic_Generic.hpp>
 
 #if defined(KOKKOS_ENABLE_CUDA)
 #include <Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp>
@@ -58,56 +59,38 @@ namespace Impl {
 
 // Olivier's implementation helpfully binds to the same builtins as GNU, so
 // we make this code common across multiple options
-#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) \
-    || (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) ||   \
+    (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
 
 #if defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-  #define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
+#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
 #else
-  #define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
+#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
 #endif
 
 template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-T _atomic_load(
-  T* ptr, MemoryOrder,
-  typename std::enable_if<
-    (
-      sizeof(T) == 1
-        || sizeof(T) == 2
-        || sizeof(T) == 4
-        || sizeof(T) == 8
-    )
-    && std::is_same<
-      typename MemoryOrder::memory_order,
-      typename std::remove_cv<MemoryOrder>::type
-    >::value,
-    void const**
-  >::type = nullptr
-) {
+KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH T _atomic_load(
+    T* ptr, MemoryOrder,
+    typename std::enable_if<
+        (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+         sizeof(T) == 8) &&
+            std::is_same<typename MemoryOrder::memory_order,
+                         typename std::remove_cv<MemoryOrder>::type>::value,
+        void const**>::type = nullptr) {
   return __atomic_load_n(ptr, MemoryOrder::gnu_constant);
 }
 
 template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-T _atomic_load(
-  T* ptr, MemoryOrder,
-  typename std::enable_if<
-    !(
-      sizeof(T) == 1
-        || sizeof(T) == 2
-        || sizeof(T) == 4
-        || sizeof(T) == 8
-    )
-    && std::is_default_constructible<T>::value
-    && std::is_same<
-      typename MemoryOrder::memory_order,
-      typename std::remove_cv<MemoryOrder>::type
-    >::value,
-    void const**
-  >::type = nullptr
-) {
+KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH T _atomic_load(
+    T* ptr, MemoryOrder,
+    typename std::enable_if<
+        !(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+          sizeof(T) == 8) &&
+            std::is_default_constructible<T>::value &&
+            std::is_same<typename MemoryOrder::memory_order,
+                         typename std::remove_cv<MemoryOrder>::type>::value,
+        void const**>::type = nullptr) {
   T rv{};
   __atomic_load(ptr, &rv, MemoryOrder::gnu_constant);
   return rv;
@@ -120,51 +103,34 @@ T _atomic_load(
 // Not compiling for Volta or later, or Cuda ASM atomics were manually disabled
 
 template <class T>
-__device__ __inline__
-T _relaxed_atomic_load_impl(
-  T* ptr,
-  typename std::enable_if<
-    (
-      sizeof(T) == 1
-      || sizeof(T) == 2
-      || sizeof(T) == 4
-      || sizeof(T) == 8
-    ),
-    void const**
-  >::type = nullptr
-) {
+__device__ __inline__ T _relaxed_atomic_load_impl(
+    T* ptr, typename std::enable_if<(sizeof(T) == 1 || sizeof(T) == 2 ||
+                                     sizeof(T) == 4 || sizeof(T) == 8),
+                                    void const**>::type = nullptr) {
   return *ptr;
 }
 
 template <class T>
 struct NoOpOper {
-  __device__ __inline__
-  static constexpr T apply(T const&, T const&) noexcept { }
+  __device__ __inline__ static constexpr T apply(T const& t,
+                                                 T const&) noexcept {
+    return t;
+  }
 };
 
 template <class T>
-__device__ __inline__
-T _relaxed_atomic_load_impl(
-  T* ptr,
-  typename std::enable_if<
-    !(
-      sizeof(T) == 1
-      || sizeof(T) == 2
-      || sizeof(T) == 4
-      || sizeof(T) == 8
-    ),
-    void const**
-  >::type = nullptr
-) {
+__device__ __inline__ T _relaxed_atomic_load_impl(
+    T* ptr, typename std::enable_if<!(sizeof(T) == 1 || sizeof(T) == 2 ||
+                                      sizeof(T) == 4 || sizeof(T) == 8),
+                                    void const**>::type = nullptr) {
   T rv{};
   // TODO remove a copy operation here?
-  Kokkos::atomic_oper_fetch(NoOpOper<T>{}, &rv, rv);
+  Kokkos::Impl::atomic_oper_fetch(NoOpOper<T>{}, &rv, rv);
   return rv;
 }
 
 template <class T>
-__device__ __inline__
-T _atomic_load(T* ptr, memory_order_seq_cst_t) {
+__device__ __inline__ T _atomic_load(T* ptr, memory_order_seq_cst_t) {
   Kokkos::memory_fence();
   T rv = Impl::_relaxed_atomic_load_impl(ptr);
   Kokkos::memory_fence();
@@ -172,95 +138,86 @@ T _atomic_load(T* ptr, memory_order_seq_cst_t) {
 }
 
 template <class T>
-__device__ __inline__
-T _atomic_load(T* ptr, memory_order_acquire_t) {
+__device__ __inline__ T _atomic_load(T* ptr, memory_order_acquire_t) {
   T rv = Impl::_relaxed_atomic_load_impl(ptr);
   Kokkos::memory_fence();
   return rv;
 }
 
 template <class T>
-__device__ __inline__
-T _atomic_load(T* ptr, memory_order_relaxed_t) {
+__device__ __inline__ T _atomic_load(T* ptr, memory_order_relaxed_t) {
   return _relaxed_atomic_load_impl(ptr);
 }
 
 #elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
 template <class T, class MemoryOrder>
-inline
-T _atomic_load(T* ptr, MemoryOrder)
-{
-  // AFAICT, all OpenMP atomics are sequentially consistent, so memory order doesn't matter
-  T retval{ };
+inline T _atomic_load(T* ptr, MemoryOrder) {
+  // AFAICT, all OpenMP atomics are sequentially consistent, so memory order
+  // doesn't matter
+  T retval{};
 #pragma omp atomic read
-  {
-    retval = *ptr;
-  }
+  { retval = *ptr; }
   return retval;
 }
 
 #elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
 template <class T, class MemoryOrder>
-inline
-T _atomic_load(T* ptr, MemoryOrder)
-{
+inline T _atomic_load(T* ptr, MemoryOrder) {
   return *ptr;
 }
 
-#endif // end of all atomic implementations
-
+#endif  // end of all atomic implementations
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-T atomic_load(T* ptr, Impl::memory_order_seq_cst_t) {
+KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
+                                          Impl::memory_order_seq_cst_t) {
   return _atomic_load(ptr, Impl::memory_order_seq_cst);
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-T atomic_load(T* ptr, Impl::memory_order_acquire_t) {
+KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
+                                          Impl::memory_order_acquire_t) {
   return _atomic_load(ptr, Impl::memory_order_acquire);
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-T atomic_load(T* ptr, Impl::memory_order_relaxed_t) {
+KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
+                                          Impl::memory_order_relaxed_t) {
   return _atomic_load(ptr, Impl::memory_order_relaxed);
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-T atomic_load(T* ptr, Impl::memory_order_release_t) {
+KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
+                                          Impl::memory_order_release_t) {
   static_assert(
-    sizeof(T) == 0, // just something that will always be false, but only on instantiation
-    "atomic_load with memory order release doesn't make any sense!"
-  );
+      sizeof(T) == 0,  // just something that will always be false, but only on
+                       // instantiation
+      "atomic_load with memory order release doesn't make any sense!");
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-T atomic_load(T* ptr, Impl::memory_order_acq_rel_t) {
+KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
+                                          Impl::memory_order_acq_rel_t) {
   static_assert(
-    sizeof(T) == 0, // just something that will always be false, but only on instantiation
-    "atomic_load with memory order acq_rel doesn't make any sense!"
-  );
+      sizeof(T) == 0,  // just something that will always be false, but only on
+                       // instantiation
+      "atomic_load with memory order acq_rel doesn't make any sense!");
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-T atomic_load(T* ptr) {
+KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr) {
   // relaxed by default!
   return _atomic_load(ptr, Impl::memory_order_relaxed);
 }
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 #if defined(KOKKOS_ENABLE_CUDA)
 #include <Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp>
 #endif
 
-#endif // defined(KOKKOS_ATOMIC_HPP)
-#endif //KOKKOS_IMPL_KOKKOS_ATOMIC_LOAD_HPP
+#endif  // defined(KOKKOS_ATOMIC_HPP)
+#endif  // KOKKOS_IMPL_KOKKOS_ATOMIC_LOAD_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Memory_Order.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Memory_Order.hpp
index 7b9c08551c0fcc460ebfb046ef25ff394b2d406f..72a6dfa9a466e0161b4b98ec8069f99187c748a2 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Memory_Order.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Memory_Order.hpp
@@ -2,10 +2,10 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
+//                        Kokkos v. 3.0
 //              Copyright (2019) Sandia Corporation
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -60,63 +60,62 @@ namespace Impl {
 
 struct memory_order_seq_cst_t {
   using memory_order = memory_order_seq_cst_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) \
-    || defined(KOKKOS_ENABLE_INTEL_ATOMICS) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
+    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
   static constexpr auto gnu_constant = __ATOMIC_SEQ_CST;
 #endif
   static constexpr auto std_constant = std::memory_order_seq_cst;
 };
-constexpr memory_order_seq_cst_t memory_order_seq_cst = { };
+constexpr memory_order_seq_cst_t memory_order_seq_cst = {};
 
 struct memory_order_relaxed_t {
   using memory_order = memory_order_relaxed_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) \
-    || defined(KOKKOS_ENABLE_INTEL_ATOMICS) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
+    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
   static constexpr auto gnu_constant = __ATOMIC_RELAXED;
 #endif
   static constexpr auto std_constant = std::memory_order_relaxed;
 };
-constexpr memory_order_relaxed_t memory_order_relaxed = { };
+constexpr memory_order_relaxed_t memory_order_relaxed = {};
 
 struct memory_order_acquire_t {
   using memory_order = memory_order_acquire_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) \
-    || defined(KOKKOS_ENABLE_INTEL_ATOMICS) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
+    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
   static constexpr auto gnu_constant = __ATOMIC_ACQUIRE;
 #endif
   static constexpr auto std_constant = std::memory_order_acquire;
 };
-constexpr memory_order_acquire_t memory_order_acquire = { };
+constexpr memory_order_acquire_t memory_order_acquire = {};
 
 struct memory_order_release_t {
   using memory_order = memory_order_release_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) \
-    || defined(KOKKOS_ENABLE_INTEL_ATOMICS) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
+    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
   static constexpr auto gnu_constant = __ATOMIC_RELEASE;
 #endif
   static constexpr auto std_constant = std::memory_order_release;
 };
-constexpr memory_order_release_t memory_order_release = { };
+constexpr memory_order_release_t memory_order_release = {};
 
 struct memory_order_acq_rel_t {
   using memory_order = memory_order_acq_rel_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) \
-    || defined(KOKKOS_ENABLE_INTEL_ATOMICS) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
+    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
   static constexpr auto gnu_constant = __ATOMIC_ACQ_REL;
 #endif
   static constexpr auto std_constant = std::memory_order_acq_rel;
 };
-constexpr memory_order_acq_rel_t memory_order_acq_rel = { };
-
+constexpr memory_order_acq_rel_t memory_order_acq_rel = {};
 
 // Intentionally omit consume (for now)
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
-#endif //KOKKOS_KOKKOS_ATOMIC_MEMORY_ORDER_HPP
+#endif  // KOKKOS_KOKKOS_ATOMIC_MEMORY_ORDER_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Store.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Store.hpp
index 066f90480d594b008eb177d9df676367c9a76b3e..6cd246e3ae9476f44532f8c4558edd2a7494398a 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Store.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Store.hpp
@@ -2,10 +2,10 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
+//                        Kokkos v. 3.0
 //              Copyright (2019) Sandia Corporation
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,6 +48,7 @@
 #if defined(KOKKOS_ATOMIC_HPP)
 
 #include <impl/Kokkos_Atomic_Memory_Order.hpp>
+#include <impl/Kokkos_Atomic_Generic.hpp>
 
 #if defined(KOKKOS_ENABLE_CUDA)
 #include <Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp>
@@ -58,56 +59,38 @@ namespace Impl {
 
 // Olivier's implementation helpfully binds to the same builtins as GNU, so
 // we make this code common across multiple options
-#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) \
-    || (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) \
-    || defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
+#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) ||   \
+    (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) || \
+    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
 
 #if defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-  #define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
+#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
 #else
-  #define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
+#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
 #endif
 
 template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-void _atomic_store(
-  T* ptr, T val, MemoryOrder,
-  typename std::enable_if<
-    (
-      sizeof(T) == 1
-        || sizeof(T) == 2
-        || sizeof(T) == 4
-        || sizeof(T) == 8
-    )
-    && std::is_same<
-      typename MemoryOrder::memory_order,
-      typename std::remove_cv<MemoryOrder>::type
-    >::value,
-    void const**
-  >::type = nullptr
-) {
+KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH void _atomic_store(
+    T* ptr, T val, MemoryOrder,
+    typename std::enable_if<
+        (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+         sizeof(T) == 8) &&
+            std::is_same<typename MemoryOrder::memory_order,
+                         typename std::remove_cv<MemoryOrder>::type>::value,
+        void const**>::type = nullptr) {
   __atomic_store_n(ptr, val, MemoryOrder::gnu_constant);
 }
 
 template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-void _atomic_store(
-  T* ptr, T val, MemoryOrder,
-  typename std::enable_if<
-    !(
-      sizeof(T) == 1
-        || sizeof(T) == 2
-        || sizeof(T) == 4
-        || sizeof(T) == 8
-    )
-    && std::is_default_constructible<T>::value
-    && std::is_same<
-      typename MemoryOrder::memory_order,
-      typename std::remove_cv<MemoryOrder>::type
-    >::value,
-    void const**
-  >::type = nullptr
-) {
+KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH void _atomic_store(
+    T* ptr, T val, MemoryOrder,
+    typename std::enable_if<
+        !(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+          sizeof(T) == 8) &&
+            std::is_default_constructible<T>::value &&
+            std::is_same<typename MemoryOrder::memory_order,
+                         typename std::remove_cv<MemoryOrder>::type>::value,
+        void const**>::type = nullptr) {
   __atomic_store(ptr, &val, MemoryOrder::gnu_constant);
 }
 
@@ -118,141 +101,119 @@ void _atomic_store(
 // Not compiling for Volta or later, or Cuda ASM atomics were manually disabled
 
 template <class T>
-__device__ __inline__
-void _relaxed_atomic_store_impl(
-  T* ptr, T val,
-  typename std::enable_if<
-    (
-      sizeof(T) == 1
-      || sizeof(T) == 2
-      || sizeof(T) == 4
-      || sizeof(T) == 8
-    ),
-    void const**
-  >::type = nullptr
-) {
+__device__ __inline__ void _relaxed_atomic_store_impl(
+    T* ptr, T val,
+    typename std::enable_if<(sizeof(T) == 1 || sizeof(T) == 2 ||
+                             sizeof(T) == 4 || sizeof(T) == 8),
+                            void const**>::type = nullptr) {
   *ptr = val;
 }
 
 template <class T>
 struct StoreOper {
-  __device__ __inline__
-  static constexpr T apply(T const&, T const& val) noexcept { return val; }
+  __device__ __inline__ static constexpr T apply(T const&,
+                                                 T const& val) noexcept {
+    return val;
+  }
 };
 
 template <class T>
-__device__ __inline__
-void _relaxed_atomic_store_impl(
-  T* ptr, T val,
-  typename std::enable_if<
-    !(
-      sizeof(T) == 1
-      || sizeof(T) == 2
-      || sizeof(T) == 4
-      || sizeof(T) == 8
-    ),
-    void const**
-  >::type = nullptr
-) {
-  Kokkos::atomic_oper_fetch(StoreOper<T>{}, &rv, (T&&)val);
+__device__ __inline__ void _relaxed_atomic_store_impl(
+    T* ptr, T val,
+    typename std::enable_if<!(sizeof(T) == 1 || sizeof(T) == 2 ||
+                              sizeof(T) == 4 || sizeof(T) == 8),
+                            void const**>::type = nullptr) {
+  Kokkos::Impl::atomic_oper_fetch(StoreOper<T>{}, ptr, (T &&) val);
 }
 
 template <class T>
-__device__ __inline__
-void _atomic_store(T* ptr, T val, memory_order_seq_cst_t) {
+__device__ __inline__ void _atomic_store(T* ptr, T val,
+                                         memory_order_seq_cst_t) {
   Kokkos::memory_fence();
   Impl::_relaxed_atomic_store_impl(ptr, val);
   Kokkos::memory_fence();
-  return rv;
 }
 
 template <class T>
-__device__ __inline__
-void _atomic_store(T* ptr, T val, memory_order_release_t) {
+__device__ __inline__ void _atomic_store(T* ptr, T val,
+                                         memory_order_release_t) {
   Kokkos::memory_fence();
   _relaxed_atomic_store_impl(ptr, val);
 }
 
 template <class T>
-__device__ __inline__
-void _atomic_store(T* ptr, T val, memory_order_relaxed_t) {
+__device__ __inline__ void _atomic_store(T* ptr, T val,
+                                         memory_order_relaxed_t) {
   _relaxed_atomic_store_impl(ptr, val);
 }
 
 #elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
 
 template <class T, class MemoryOrder>
-inline
-void _atomic_store(T* ptr, T val, MemoryOrder)
-{
-  // AFAICT, all OpenMP atomics are sequentially consistent, so memory order doesn't matter
+inline void _atomic_store(T* ptr, T val, MemoryOrder) {
+  // AFAICT, all OpenMP atomics are sequentially consistent, so memory order
+  // doesn't matter
 #pragma omp atomic write
-  {
-    *ptr = val;
-  }
+  { *ptr = val; }
 }
 
 #elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
 
 template <class T, class MemoryOrder>
-inline
-void _atomic_store(T* ptr, T val, MemoryOrder)
-{
+inline void _atomic_store(T* ptr, T val, MemoryOrder) {
   *ptr = val;
 }
 
-#endif // end of all atomic implementations
-
+#endif  // end of all atomic implementations
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-void atomic_store(T* ptr, T val, Impl::memory_order_seq_cst_t) {
+KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
+                                              Impl::memory_order_seq_cst_t) {
   _atomic_store(ptr, val, Impl::memory_order_seq_cst);
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-void atomic_store(T* ptr, T val, Impl::memory_order_release_t) {
+KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
+                                              Impl::memory_order_release_t) {
   _atomic_store(ptr, val, Impl::memory_order_release);
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-void atomic_store(T* ptr, T val, Impl::memory_order_relaxed_t) {
+KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
+                                              Impl::memory_order_relaxed_t) {
   _atomic_store(ptr, val, Impl::memory_order_relaxed);
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-void atomic_store(T* ptr, T val, Impl::memory_order_acquire_t) {
+KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
+                                              Impl::memory_order_acquire_t) {
   static_assert(
-    sizeof(T) == 0, // just something that will always be false, but only on instantiation
-    "atomic_store with memory order acquire doesn't make any sense!"
-  );
+      sizeof(T) == 0,  // just something that will always be false, but only on
+                       // instantiation
+      "atomic_store with memory order acquire doesn't make any sense!");
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-void atomic_store(T* ptr, T val, Impl::memory_order_acq_rel_t) {
+KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
+                                              Impl::memory_order_acq_rel_t) {
   static_assert(
-    sizeof(T) == 0, // just something that will always be false, but only on instantiation
-    "atomic_store with memory order acq_rel doesn't make any sense!"
-  );
+      sizeof(T) == 0,  // just something that will always be false, but only on
+                       // instantiation
+      "atomic_store with memory order acq_rel doesn't make any sense!");
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION
-void atomic_store(T* ptr, T val) {
+KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val) {
   // relaxed by default!
   _atomic_store(ptr, Impl::memory_order_relaxed);
 }
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 #if defined(KOKKOS_ENABLE_CUDA)
 #include <Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp>
 #endif
 
-#endif // defined(KOKKOS_ATOMIC_HPP)
-#endif //KOKKOS_IMPL_KOKKOS_ATOMIC_STORE_HPP
+#endif  // defined(KOKKOS_ATOMIC_HPP)
+#endif  // KOKKOS_IMPL_KOKKOS_ATOMIC_STORE_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_View.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_View.hpp
index 7f63f93060560bf43f94c7f71dde11e998becf48..bfe9bcd0b33fd21d10569ac9e5135c2ae35d2b81 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_View.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_View.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,386 +47,335 @@
 #include <Kokkos_Macros.hpp>
 #include <Kokkos_Atomic.hpp>
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
-//The following tag is used to prevent an implicit call of the constructor when trying
-//to assign a literal 0 int ( = 0 );
+// The following tag is used to prevent an implicit call of the constructor when
+// trying to assign a literal 0 int ( = 0 );
 struct AtomicViewConstTag {};
 
-template<class ViewTraits>
+template <class ViewTraits>
 class AtomicDataElement {
-public:
+ public:
   typedef typename ViewTraits::value_type value_type;
   typedef typename ViewTraits::const_value_type const_value_type;
   typedef typename ViewTraits::non_const_value_type non_const_value_type;
   volatile value_type* const ptr;
 
   KOKKOS_INLINE_FUNCTION
-  AtomicDataElement(value_type* ptr_, AtomicViewConstTag ):ptr(ptr_){}
+  AtomicDataElement(value_type* ptr_, AtomicViewConstTag) : ptr(ptr_) {}
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator = (const_value_type& val) const {
+  const_value_type operator=(const_value_type& val) const {
     *ptr = val;
     return val;
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator = (volatile const_value_type& val) const {
+  const_value_type operator=(volatile const_value_type& val) const {
     *ptr = val;
     return val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void inc() const {
-    Kokkos::atomic_increment(ptr);
-  }
+  void inc() const { Kokkos::atomic_increment(ptr); }
 
   KOKKOS_INLINE_FUNCTION
-  void dec() const {
-    Kokkos::atomic_decrement(ptr);
-  }
+  void dec() const { Kokkos::atomic_decrement(ptr); }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ++ () const {
-    const_value_type tmp = Kokkos::atomic_fetch_add(ptr,non_const_value_type(1));
-    return tmp+1;
+  const_value_type operator++() const {
+    const_value_type tmp =
+        Kokkos::atomic_fetch_add(ptr, non_const_value_type(1));
+    return tmp + 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator -- () const {
-    const_value_type tmp = Kokkos::atomic_fetch_sub(ptr,non_const_value_type(1));
-    return tmp-1;
+  const_value_type operator--() const {
+    const_value_type tmp =
+        Kokkos::atomic_fetch_sub(ptr, non_const_value_type(1));
+    return tmp - 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ++ (int) const {
-    return Kokkos::atomic_fetch_add(ptr,non_const_value_type(1));
+  const_value_type operator++(int) const {
+    return Kokkos::atomic_fetch_add(ptr, non_const_value_type(1));
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator -- (int) const {
-    return Kokkos::atomic_fetch_sub(ptr,non_const_value_type(1));
+  const_value_type operator--(int) const {
+    return Kokkos::atomic_fetch_sub(ptr, non_const_value_type(1));
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator += (const_value_type& val) const {
-    const_value_type tmp = Kokkos::atomic_fetch_add(ptr,val);
-    return tmp+val;
+  const_value_type operator+=(const_value_type& val) const {
+    const_value_type tmp = Kokkos::atomic_fetch_add(ptr, val);
+    return tmp + val;
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator += (volatile const_value_type& val) const {
-    const_value_type tmp = Kokkos::atomic_fetch_add(ptr,val);
-    return tmp+val;
+  const_value_type operator+=(volatile const_value_type& val) const {
+    const_value_type tmp = Kokkos::atomic_fetch_add(ptr, val);
+    return tmp + val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator -= (const_value_type& val) const {
-    const_value_type tmp = Kokkos::atomic_fetch_sub(ptr,val);
-    return tmp-val;
+  const_value_type operator-=(const_value_type& val) const {
+    const_value_type tmp = Kokkos::atomic_fetch_sub(ptr, val);
+    return tmp - val;
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator -= (volatile const_value_type& val) const {
-    const_value_type tmp = Kokkos::atomic_fetch_sub(ptr,val);
-    return tmp-val;
+  const_value_type operator-=(volatile const_value_type& val) const {
+    const_value_type tmp = Kokkos::atomic_fetch_sub(ptr, val);
+    return tmp - val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator *= (const_value_type& val) const {
-    return Kokkos::atomic_mul_fetch(ptr,val);
+  const_value_type operator*=(const_value_type& val) const {
+    return Kokkos::atomic_mul_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator *= (volatile const_value_type& val) const {
-    return Kokkos::atomic_mul_fetch(ptr,val);
+  const_value_type operator*=(volatile const_value_type& val) const {
+    return Kokkos::atomic_mul_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator /= (const_value_type& val) const {
-    return Kokkos::atomic_div_fetch(ptr,val);
+  const_value_type operator/=(const_value_type& val) const {
+    return Kokkos::atomic_div_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator /= (volatile const_value_type& val) const {
-    return Kokkos::atomic_div_fetch(ptr,val);
+  const_value_type operator/=(volatile const_value_type& val) const {
+    return Kokkos::atomic_div_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator %= (const_value_type& val) const {
-    return Kokkos::atomic_mod_fetch(ptr,val);
+  const_value_type operator%=(const_value_type& val) const {
+    return Kokkos::atomic_mod_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator %= (volatile const_value_type& val) const {
-    return Kokkos::atomic_mod_fetch(ptr,val);
+  const_value_type operator%=(volatile const_value_type& val) const {
+    return Kokkos::atomic_mod_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator &= (const_value_type& val) const {
-    return Kokkos::atomic_and_fetch(ptr,val);
+  const_value_type operator&=(const_value_type& val) const {
+    return Kokkos::atomic_and_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator &= (volatile const_value_type& val) const {
-    return Kokkos::atomic_and_fetch(ptr,val);
+  const_value_type operator&=(volatile const_value_type& val) const {
+    return Kokkos::atomic_and_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ^= (const_value_type& val) const {
-    return Kokkos::atomic_xor_fetch(ptr,val);
+  const_value_type operator^=(const_value_type& val) const {
+    return Kokkos::atomic_xor_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ^= (volatile const_value_type& val) const {
-    return Kokkos::atomic_xor_fetch(ptr,val);
+  const_value_type operator^=(volatile const_value_type& val) const {
+    return Kokkos::atomic_xor_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator |= (const_value_type& val) const {
-    return Kokkos::atomic_or_fetch(ptr,val);
+  const_value_type operator|=(const_value_type& val) const {
+    return Kokkos::atomic_or_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator |= (volatile const_value_type& val) const {
-    return Kokkos::atomic_or_fetch(ptr,val);
+  const_value_type operator|=(volatile const_value_type& val) const {
+    return Kokkos::atomic_or_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator <<= (const_value_type& val) const {
-    return Kokkos::atomic_lshift_fetch(ptr,val);
+  const_value_type operator<<=(const_value_type& val) const {
+    return Kokkos::atomic_lshift_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator <<= (volatile const_value_type& val) const {
-    return Kokkos::atomic_lshift_fetch(ptr,val);
+  const_value_type operator<<=(volatile const_value_type& val) const {
+    return Kokkos::atomic_lshift_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator >>= (const_value_type& val) const {
-    return Kokkos::atomic_rshift_fetch(ptr,val);
+  const_value_type operator>>=(const_value_type& val) const {
+    return Kokkos::atomic_rshift_fetch(ptr, val);
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator >>= (volatile const_value_type& val) const {
-    return Kokkos::atomic_rshift_fetch(ptr,val);
+  const_value_type operator>>=(volatile const_value_type& val) const {
+    return Kokkos::atomic_rshift_fetch(ptr, val);
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator + (const_value_type& val) const {
-    return *ptr+val;
-  }
+  const_value_type operator+(const_value_type& val) const { return *ptr + val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator + (volatile const_value_type& val) const {
-    return *ptr+val;
+  const_value_type operator+(volatile const_value_type& val) const {
+    return *ptr + val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator - (const_value_type& val) const {
-    return *ptr-val;
-  }
+  const_value_type operator-(const_value_type& val) const { return *ptr - val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator - (volatile const_value_type& val) const {
-    return *ptr-val;
+  const_value_type operator-(volatile const_value_type& val) const {
+    return *ptr - val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator * (const_value_type& val) const {
-    return *ptr*val;
-  }
+  const_value_type operator*(const_value_type& val) const { return *ptr * val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator * (volatile const_value_type& val) const {
-    return *ptr*val;
+  const_value_type operator*(volatile const_value_type& val) const {
+    return *ptr * val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator / (const_value_type& val) const {
-    return *ptr/val;
-  }
+  const_value_type operator/(const_value_type& val) const { return *ptr / val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator / (volatile const_value_type& val) const {
-    return *ptr/val;
+  const_value_type operator/(volatile const_value_type& val) const {
+    return *ptr / val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator % (const_value_type& val) const {
-    return *ptr^val;
-  }
+  const_value_type operator%(const_value_type& val) const { return *ptr ^ val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator % (volatile const_value_type& val) const {
-    return *ptr^val;
+  const_value_type operator%(volatile const_value_type& val) const {
+    return *ptr ^ val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ! () const {
-    return !*ptr;
-  }
+  const_value_type operator!() const { return !*ptr; }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator && (const_value_type& val) const {
-    return *ptr&&val;
+  const_value_type operator&&(const_value_type& val) const {
+    return *ptr && val;
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator && (volatile const_value_type& val) const {
-    return *ptr&&val;
+  const_value_type operator&&(volatile const_value_type& val) const {
+    return *ptr && val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator || (const_value_type& val) const {
-    return *ptr|val;
+  const_value_type operator||(const_value_type& val) const {
+    return *ptr | val;
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator || (volatile const_value_type& val) const {
-    return *ptr|val;
+  const_value_type operator||(volatile const_value_type& val) const {
+    return *ptr | val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator & (const_value_type& val) const {
-    return *ptr&val;
-  }
+  const_value_type operator&(const_value_type& val) const { return *ptr & val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator & (volatile const_value_type& val) const {
-    return *ptr&val;
+  const_value_type operator&(volatile const_value_type& val) const {
+    return *ptr & val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator | (const_value_type& val) const {
-    return *ptr|val;
-  }
+  const_value_type operator|(const_value_type& val) const { return *ptr | val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator | (volatile const_value_type& val) const {
-    return *ptr|val;
+  const_value_type operator|(volatile const_value_type& val) const {
+    return *ptr | val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ^ (const_value_type& val) const {
-    return *ptr^val;
-  }
+  const_value_type operator^(const_value_type& val) const { return *ptr ^ val; }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ^ (volatile const_value_type& val) const {
-    return *ptr^val;
+  const_value_type operator^(volatile const_value_type& val) const {
+    return *ptr ^ val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator ~ () const {
-    return ~*ptr;
-  }
+  const_value_type operator~() const { return ~*ptr; }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator << (const unsigned int& val) const {
-    return *ptr<<val;
+  const_value_type operator<<(const unsigned int& val) const {
+    return *ptr << val;
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator << (volatile const unsigned int& val) const {
-    return *ptr<<val;
+  const_value_type operator<<(volatile const unsigned int& val) const {
+    return *ptr << val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator >> (const unsigned int& val) const {
-    return *ptr>>val;
+  const_value_type operator>>(const unsigned int& val) const {
+    return *ptr >> val;
   }
   KOKKOS_INLINE_FUNCTION
-  const_value_type operator >> (volatile const unsigned int& val) const {
-    return *ptr>>val;
+  const_value_type operator>>(volatile const unsigned int& val) const {
+    return *ptr >> val;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator == (const_value_type& val) const {
-    return *ptr == val;
-  }
+  bool operator==(const_value_type& val) const { return *ptr == val; }
   KOKKOS_INLINE_FUNCTION
-  bool operator == (volatile const_value_type& val) const {
-    return *ptr == val;
-  }
+  bool operator==(volatile const_value_type& val) const { return *ptr == val; }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator != (const_value_type& val) const {
-    return *ptr != val;
-  }
+  bool operator!=(const_value_type& val) const { return *ptr != val; }
   KOKKOS_INLINE_FUNCTION
-  bool operator != (volatile const_value_type& val) const {
-    return *ptr != val;
-  }
+  bool operator!=(volatile const_value_type& val) const { return *ptr != val; }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator >= (const_value_type& val) const {
-    return *ptr >= val;
-  }
+  bool operator>=(const_value_type& val) const { return *ptr >= val; }
   KOKKOS_INLINE_FUNCTION
-  bool operator >= (volatile const_value_type& val) const {
-    return *ptr >= val;
-  }
+  bool operator>=(volatile const_value_type& val) const { return *ptr >= val; }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator <= (const_value_type& val) const {
-    return *ptr <= val;
-  }
+  bool operator<=(const_value_type& val) const { return *ptr <= val; }
   KOKKOS_INLINE_FUNCTION
-  bool operator <= (volatile const_value_type& val) const {
-    return *ptr <= val;
-  }
+  bool operator<=(volatile const_value_type& val) const { return *ptr <= val; }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator < (const_value_type& val) const {
-    return *ptr < val;
-  }
+  bool operator<(const_value_type& val) const { return *ptr < val; }
   KOKKOS_INLINE_FUNCTION
-  bool operator < (volatile const_value_type& val) const {
-    return *ptr < val;
-  }
+  bool operator<(volatile const_value_type& val) const { return *ptr < val; }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator > (const_value_type& val) const {
-    return *ptr > val;
-  }
+  bool operator>(const_value_type& val) const { return *ptr > val; }
   KOKKOS_INLINE_FUNCTION
-  bool operator > (volatile const_value_type& val) const {
-    return *ptr > val;
-  }
+  bool operator>(volatile const_value_type& val) const { return *ptr > val; }
 
   KOKKOS_INLINE_FUNCTION
-  operator const_value_type () const {
-    //return Kokkos::atomic_load(ptr);
+  operator const_value_type() const {
+    // return Kokkos::atomic_load(ptr);
     return *ptr;
   }
 
   KOKKOS_INLINE_FUNCTION
-  operator volatile non_const_value_type () volatile const {
-    //return Kokkos::atomic_load(ptr);
+  operator volatile non_const_value_type() volatile const {
+    // return Kokkos::atomic_load(ptr);
     return *ptr;
   }
 };
 
-template<class ViewTraits>
+template <class ViewTraits>
 class AtomicViewDataHandle {
-public:
+ public:
   typename ViewTraits::value_type* ptr;
 
   KOKKOS_INLINE_FUNCTION
-  AtomicViewDataHandle()
-    : ptr(NULL)
-  {}
+  AtomicViewDataHandle() : ptr(NULL) {}
 
   KOKKOS_INLINE_FUNCTION
-  AtomicViewDataHandle(typename ViewTraits::value_type* ptr_)
-    :ptr(ptr_)
-  {}
+  AtomicViewDataHandle(typename ViewTraits::value_type* ptr_) : ptr(ptr_) {}
 
-  template<class iType>
-  KOKKOS_INLINE_FUNCTION
-  AtomicDataElement<ViewTraits> operator[] (const iType& i) const {
-    return AtomicDataElement<ViewTraits>(ptr+i,AtomicViewConstTag());
+  template <class iType>
+  KOKKOS_INLINE_FUNCTION AtomicDataElement<ViewTraits> operator[](
+      const iType& i) const {
+    return AtomicDataElement<ViewTraits>(ptr + i, AtomicViewConstTag());
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  operator typename ViewTraits::value_type * () const { return ptr ; }
-
+  operator typename ViewTraits::value_type*() const { return ptr; }
 };
 
-template<unsigned Size>
+template <unsigned Size>
 struct Kokkos_Atomic_is_only_allowed_with_32bit_and_64bit_scalars;
 
-template<>
+template <>
 struct Kokkos_Atomic_is_only_allowed_with_32bit_and_64bit_scalars<4> {
   typedef int type;
 };
 
-template<>
+template <>
 struct Kokkos_Atomic_is_only_allowed_with_32bit_and_64bit_scalars<8> {
   typedef int64_t type;
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Atomic_Windows.hpp b/lib/kokkos/core/src/impl/Kokkos_Atomic_Windows.hpp
index b18134f40ccff9a288e7e8824a7133afecacddd3..25230982ec79aea5e7cdf6d146562d0d8ca5c29a 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Atomic_Windows.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Atomic_Windows.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,190 +53,191 @@
 #include <windows.h>
 
 namespace Kokkos {
-  namespace Impl {
+namespace Impl {
 #ifdef _MSC_VER
-    _declspec(align(16))
+_declspec(align(16))
 #endif
-    struct cas128_t
-    {
-      LONGLONG lower;
-      LONGLONG upper;
-      KOKKOS_INLINE_FUNCTION
-        bool operator != (const cas128_t& a) const {
-        return (lower != a.lower) || upper != a.upper;
-      }
-    }
-#ifdef __GNUC__
-    __attribute__ ((aligned (16)))
-#endif
-    ;
-  }
-
-  template < typename T >
+    struct cas128_t {
+  LONGLONG lower;
+  LONGLONG upper;
   KOKKOS_INLINE_FUNCTION
-    T atomic_compare_exchange(volatile T * const dest, const T & compare,
-    typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(LONG), const T & >::type val)
-  {
-    union U {
-      LONG i;
-      T t;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } tmp;
-
-    tmp.i = _InterlockedCompareExchange((LONG*)dest, *((LONG*)&val), *((LONG*)&compare));
-    return tmp.t;
-  }
-
-  template < typename T >
-  KOKKOS_INLINE_FUNCTION
-    T atomic_compare_exchange(volatile T * const dest, const T & compare,
-    typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(LONGLONG), const T & >::type val)
-  {
-    union U {
-      LONGLONG i;
-      T t;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } tmp;
-
-    tmp.i = _InterlockedCompareExchange64((LONGLONG*)dest, *((LONGLONG*)&val), *((LONGLONG*)&compare));
-    return tmp.t;
+  bool operator!=(const cas128_t& a) const {
+    return (lower != a.lower) || upper != a.upper;
   }
+}
+#ifdef __GNUC__
+__attribute__((aligned(16)))
+#endif
+;
+}  // namespace Impl
+
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(LONG), const T&>::type
+        val) {
+  union U {
+    LONG i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
+
+  tmp.i = _InterlockedCompareExchange((LONG*)dest, *((LONG*)&val),
+                                      *((LONG*)&compare));
+  return tmp.t;
+}
 
-  template < typename T >
-  KOKKOS_INLINE_FUNCTION
-    T atomic_compare_exchange(volatile T * const dest, const T & compare,
-    typename Kokkos::Impl::enable_if< sizeof(T) == sizeof(Impl::cas128_t), const T & >::type val)
-  {
-    union U {
-      Impl::cas128_t i;
-      T t;
-      KOKKOS_INLINE_FUNCTION U() {};
-    } tmp, newval;
-    newval.t = val;
-    _InterlockedCompareExchange128((LONGLONG*)dest, newval.i.upper, newval.i.lower, ((LONGLONG*)&compare));
-    tmp.t = dest;
-    return tmp.t;
-  }
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(LONGLONG),
+                                     const T&>::type val) {
+  union U {
+    LONGLONG i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp;
+
+  tmp.i = _InterlockedCompareExchange64((LONGLONG*)dest, *((LONGLONG*)&val),
+                                        *((LONGLONG*)&compare));
+  return tmp.t;
+}
 
-  template < typename T >
-  KOKKOS_INLINE_FUNCTION
-    T atomic_compare_exchange_strong(volatile T * const dest, const T & compare, const T & val)
-  {
-    return atomic_compare_exchange(dest,compare,val);
-  }
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(
+    volatile T* const dest, const T& compare,
+    typename Kokkos::Impl::enable_if<sizeof(T) == sizeof(Impl::cas128_t),
+                                     const T&>::type val) {
+  union U {
+    Impl::cas128_t i;
+    T t;
+    KOKKOS_INLINE_FUNCTION U(){};
+  } tmp, newval;
+  newval.t = val;
+  _InterlockedCompareExchange128((LONGLONG*)dest, newval.i.upper,
+                                 newval.i.lower, ((LONGLONG*)&compare));
+  tmp.t = dest;
+  return tmp.t;
+}
 
-  template< typename T >
-  T atomic_fetch_or(volatile T * const dest, const T val) {
-    T oldval = *dest;
-    T assume;
-    do {
-      assume = oldval;
-      T newval = val | oldval;
-      oldval = atomic_compare_exchange(dest, assume, newval);
-    } while (assume != oldval);
-
-    return oldval;
-  }
+template <typename T>
+KOKKOS_INLINE_FUNCTION T atomic_compare_exchange_strong(volatile T* const dest,
+                                                        const T& compare,
+                                                        const T& val) {
+  return atomic_compare_exchange(dest, compare, val);
+}
 
-  template< typename T >
-  T atomic_fetch_and(volatile T * const dest, const T val) {
-    T oldval = *dest;
-    T assume;
-    do {
-      assume = oldval;
-      T newval = val & oldval;
-      oldval = atomic_compare_exchange(dest, assume, newval);
-    } while (assume != oldval);
-
-    return oldval;
-  }
+template <typename T>
+T atomic_fetch_or(volatile T* const dest, const T val) {
+  T oldval = *dest;
+  T assume;
+  do {
+    assume   = oldval;
+    T newval = val | oldval;
+    oldval   = atomic_compare_exchange(dest, assume, newval);
+  } while (assume != oldval);
+
+  return oldval;
+}
 
-  template< typename T >
-  T atomic_fetch_add(volatile T * const dest, const T val) {
-    T oldval = *dest;
-    T assume;
-    do {
-      assume = oldval;
-      T newval = val + oldval;
-      oldval = atomic_compare_exchange(dest, assume, newval);
-    } while (assume != oldval);
-
-    return oldval;
-  }
+template <typename T>
+T atomic_fetch_and(volatile T* const dest, const T val) {
+  T oldval = *dest;
+  T assume;
+  do {
+    assume   = oldval;
+    T newval = val & oldval;
+    oldval   = atomic_compare_exchange(dest, assume, newval);
+  } while (assume != oldval);
+
+  return oldval;
+}
 
-  template< typename T >
-  T atomic_fetch_sub(volatile T * const dest, const T val) {
-    T oldval = *dest;
-    T assume;
-    do {
-      assume = oldval;
-      T newval = val - oldval;
-      oldval = atomic_compare_exchange(dest, assume, newval);
-    } while (assume != oldval);
-
-    return oldval;
-  }
+template <typename T>
+T atomic_fetch_add(volatile T* const dest, const T val) {
+  T oldval = *dest;
+  T assume;
+  do {
+    assume   = oldval;
+    T newval = val + oldval;
+    oldval   = atomic_compare_exchange(dest, assume, newval);
+  } while (assume != oldval);
+
+  return oldval;
+}
 
-  template< typename T >
-  T atomic_exchange(volatile T * const dest, const T val) {
-    T oldval = *dest;
-    T assume;
-    do {
-      assume = oldval;
-      oldval = atomic_compare_exchange(dest, assume, val);
-    } while (assume != oldval);
+template <typename T>
+T atomic_fetch_sub(volatile T* const dest, const T val) {
+  T oldval = *dest;
+  T assume;
+  do {
+    assume   = oldval;
+    T newval = val - oldval;
+    oldval   = atomic_compare_exchange(dest, assume, newval);
+  } while (assume != oldval);
+
+  return oldval;
+}
 
-    return oldval;
-  }
+template <typename T>
+T atomic_exchange(volatile T* const dest, const T val) {
+  T oldval = *dest;
+  T assume;
+  do {
+    assume = oldval;
+    oldval = atomic_compare_exchange(dest, assume, val);
+  } while (assume != oldval);
 
-  template< typename T >
-  void atomic_or(volatile T * const dest, const T val) {
-    atomic_fetch_or(dest, val);
-  }
+  return oldval;
+}
 
-  template< typename T >
-  void atomic_and(volatile T * const dest, const T val) {
-    atomic_fetch_and(dest, val);
-  }
+template <typename T>
+void atomic_or(volatile T* const dest, const T val) {
+  atomic_fetch_or(dest, val);
+}
 
-  template< typename T >
-  void atomic_add(volatile T * const dest, const T val) {
-    atomic_fetch_add(dest, val);
-  }
+template <typename T>
+void atomic_and(volatile T* const dest, const T val) {
+  atomic_fetch_and(dest, val);
+}
 
-  template< typename T >
-  void atomic_sub(volatile T * const dest, const T val) {
-    atomic_fetch_sub(dest, val);
-  }
+template <typename T>
+void atomic_add(volatile T* const dest, const T val) {
+  atomic_fetch_add(dest, val);
+}
 
-  template< typename T >
-  void atomic_assign(volatile T * const dest, const T val) {
-    atomic_fetch_exchange(dest, val);
-  }
+template <typename T>
+void atomic_sub(volatile T* const dest, const T val) {
+  atomic_fetch_sub(dest, val);
+}
 
-  template< typename T >
-  T atomic_increment(volatile T * const dest) {
-    T oldval = *dest;
-    T assume;
-    do {
-      assume = oldval;
-      T newval = assume++;
-      oldval = atomic_compare_exchange(dest, assume, newval);
-    } while (assume != oldval);
-  }
+template <typename T>
+void atomic_assign(volatile T* const dest, const T val) {
+  atomic_fetch_exchange(dest, val);
+}
 
-  template< typename T >
-  T atomic_decrement(volatile T * const dest) {
-    T oldval = *dest;
-    T assume;
-    do {
-      assume = oldval;
-      T newval = assume--;
-      oldval = atomic_compare_exchange(dest, assume, newval);
-    } while (assume != oldval);
-  }
+template <typename T>
+T atomic_increment(volatile T* const dest) {
+  T oldval = *dest;
+  T assume;
+  do {
+    assume   = oldval;
+    T newval = assume++;
+    oldval   = atomic_compare_exchange(dest, assume, newval);
+  } while (assume != oldval);
+}
 
+template <typename T>
+T atomic_decrement(volatile T* const dest) {
+  T oldval = *dest;
+  T assume;
+  do {
+    assume   = oldval;
+    T newval = assume--;
+    oldval   = atomic_compare_exchange(dest, assume, newval);
+  } while (assume != oldval);
 }
+
+}  // namespace Kokkos
 #endif
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_BitOps.hpp b/lib/kokkos/core/src/impl/Kokkos_BitOps.hpp
index 1e6714c08c533649606007bb700c1b64038127da..7d2cdf0d4af43fc1b0c2b0f96654cc78bbe1e324 100644
--- a/lib/kokkos/core/src/impl/Kokkos_BitOps.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_BitOps.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,35 +50,35 @@
 #include <climits>
 
 #ifdef KOKKOS_COMPILER_INTEL
-#include<immintrin.h>
+#include <immintrin.h>
 #endif
 
-#if defined( __HCC_ACCELERATOR__ )
+#if defined(__HCC_ACCELERATOR__)
 #include <hc.hpp>
 #endif
 
 namespace Kokkos {
 
 KOKKOS_FORCEINLINE_FUNCTION
-int log2( unsigned i )
-{
+int log2(unsigned i) {
   enum : int { shift = sizeof(unsigned) * CHAR_BIT - 1 };
-#if defined( __CUDA_ARCH__ )
+#if defined(__CUDA_ARCH__)
   return shift - __clz(i);
-#elif defined( __HCC_ACCELERATOR__ )
-  return  (int)hc::__firstbit_u32_u32(i);
-#elif defined( KOKKOS_COMPILER_INTEL )
+#elif defined(__HCC_ACCELERATOR__)
+  return (int)hc::__firstbit_u32_u32(i);
+#elif defined(KOKKOS_COMPILER_INTEL)
   return _bit_scan_reverse(i);
-#elif defined( KOKKOS_COMPILER_IBM )
+#elif defined(KOKKOS_COMPILER_IBM)
   return shift - __cntlz4(i);
-#elif defined( KOKKOS_COMPILER_CRAYC )
-  return i ? shift - _leadz32(i) : 0 ;
-#elif defined( __GNUC__ ) || defined( __GNUG__ )
+#elif defined(KOKKOS_COMPILER_CRAYC)
+  return i ? shift - _leadz32(i) : 0;
+#elif defined(__GNUC__) || defined(__GNUG__)
   return shift - __builtin_clz(i);
 #else
   int offset = 0;
-  if ( i ) {
-    for ( offset = shift ; (i & ( 1 << offset ) ) == 0 ; --offset );
+  if (i) {
+    for (offset = shift; (i & (1 << offset)) == 0; --offset)
+      ;
   }
   return offset;
 #endif
@@ -90,50 +91,50 @@ namespace Impl {
  *  If none then return -1 ;
  */
 KOKKOS_FORCEINLINE_FUNCTION
-int bit_first_zero( unsigned i ) noexcept
-{
+int bit_first_zero(unsigned i) noexcept {
   enum : unsigned { full = ~0u };
 
-#if defined( __CUDA_ARCH__ )
-  return full != i ? __ffs( ~i ) - 1 : -1 ;
-#elif defined( __HCC_ACCELERATOR__ )
-  return full != i ? (int)hc::__firstbit_u32_u32(~i) : -1 ;
-#elif defined( KOKKOS_COMPILER_INTEL )
-  return full != i ? _bit_scan_forward( ~i ) : -1 ;
-#elif defined( KOKKOS_COMPILER_IBM )
-  return full != i ? __cnttz4( ~i ) : -1 ;
-#elif defined( KOKKOS_COMPILER_CRAYC )
-  return full != i ? _popcnt( i ^ (i+1) ) - 1 : -1 ;
-#elif defined( KOKKOS_COMPILER_GNU ) || defined( __GNUC__ ) || defined( __GNUG__ )
-  return full != i ? __builtin_ffs( ~i ) - 1 : -1 ;
+#if defined(__CUDA_ARCH__)
+  return full != i ? __ffs(~i) - 1 : -1;
+#elif defined(__HCC_ACCELERATOR__)
+  return full != i ? (int)hc::__firstbit_u32_u32(~i) : -1;
+#elif defined(KOKKOS_COMPILER_INTEL)
+  return full != i ? _bit_scan_forward(~i) : -1;
+#elif defined(KOKKOS_COMPILER_IBM)
+  return full != i ? __cnttz4(~i) : -1;
+#elif defined(KOKKOS_COMPILER_CRAYC)
+  return full != i ? _popcnt(i ^ (i + 1)) - 1 : -1;
+#elif defined(KOKKOS_COMPILER_GNU) || defined(__GNUC__) || defined(__GNUG__)
+  return full != i ? __builtin_ffs(~i) - 1 : -1;
 #else
-  int offset = -1 ;
-  if ( full != i ) {
-    for ( offset = 0 ; i & ( 1 << offset ) ; ++offset );
+  int offset = -1;
+  if (full != i) {
+    for (offset = 0; i & (1 << offset); ++offset)
+      ;
   }
-  return offset ;
+  return offset;
 #endif
 }
 
 KOKKOS_FORCEINLINE_FUNCTION
-int bit_scan_forward( unsigned i )
-{
-#if defined( __CUDA_ARCH__ )
+int bit_scan_forward(unsigned i) {
+#if defined(__CUDA_ARCH__)
   return __ffs(i) - 1;
-#elif defined( __HCC_ACCELERATOR__ )
-  return  (int)hc::__firstbit_u32_u32(i);
-#elif defined( KOKKOS_COMPILER_INTEL )
+#elif defined(__HCC_ACCELERATOR__)
+  return (int)hc::__firstbit_u32_u32(i);
+#elif defined(KOKKOS_COMPILER_INTEL)
   return _bit_scan_forward(i);
-#elif defined( KOKKOS_COMPILER_IBM )
+#elif defined(KOKKOS_COMPILER_IBM)
   return __cnttz4(i);
-#elif defined( KOKKOS_COMPILER_CRAYC )
-  return i ? _popcnt(~i & (i-1)) : -1;
-#elif defined( KOKKOS_COMPILER_GNU ) || defined( __GNUC__ ) || defined( __GNUG__ )
+#elif defined(KOKKOS_COMPILER_CRAYC)
+  return i ? _popcnt(~i & (i - 1)) : -1;
+#elif defined(KOKKOS_COMPILER_GNU) || defined(__GNUC__) || defined(__GNUG__)
   return __builtin_ffs(i) - 1;
 #else
   int offset = -1;
-  if ( i ) {
-    for ( offset = 0 ; (i & ( 1 << offset ) ) == 0 ; ++offset );
+  if (i) {
+    for (offset = 0; (i & (1 << offset)) == 0; ++offset)
+      ;
   }
   return offset;
 #endif
@@ -141,41 +142,37 @@ int bit_scan_forward( unsigned i )
 
 /// Count the number of bits set.
 KOKKOS_FORCEINLINE_FUNCTION
-int bit_count( unsigned i )
-{
-#if defined( __CUDA_ARCH__ )
+int bit_count(unsigned i) {
+#if defined(__CUDA_ARCH__)
   return __popc(i);
-#elif defined( __HCC_ACCELERATOR__ )
-  return  (int)hc::__popcount_u32_b32(i);
-#elif defined ( __INTEL_COMPILER )
+#elif defined(__HCC_ACCELERATOR__)
+  return (int)hc::__popcount_u32_b32(i);
+#elif defined(__INTEL_COMPILER)
   return _popcnt32(i);
-#elif defined( KOKKOS_COMPILER_IBM )
+#elif defined(KOKKOS_COMPILER_IBM)
   return __popcnt4(i);
-#elif defined( KOKKOS_COMPILER_CRAYC )
+#elif defined(KOKKOS_COMPILER_CRAYC)
   return _popcnt(i);
-#elif defined( __GNUC__ ) || defined( __GNUG__ )
+#elif defined(__GNUC__) || defined(__GNUG__)
   return __builtin_popcount(i);
 #else
   // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetNaive
-  i = i - ( ( i >> 1 ) & ~0u / 3u );                             // temp
-  i = ( i & ~0u / 15u * 3u ) + ( ( i >> 2 ) & ~0u / 15u * 3u );  // temp
-  i = ( i + ( i >> 4 ) ) & ~0u / 255u * 15u;                     // temp
+  i = i - ((i >> 1) & ~0u / 3u);                           // temp
+  i = (i & ~0u / 15u * 3u) + ((i >> 2) & ~0u / 15u * 3u);  // temp
+  i = (i + (i >> 4)) & ~0u / 255u * 15u;                   // temp
 
   // count
-  return (int)( ( i * ( ~0u / 255u ) ) >> ( sizeof(unsigned) - 1 ) * CHAR_BIT );
+  return (int)((i * (~0u / 255u)) >> (sizeof(unsigned) - 1) * CHAR_BIT);
 #endif
 }
 
 KOKKOS_INLINE_FUNCTION
-unsigned integral_power_of_two_that_contains( const unsigned N )
-{
-  const unsigned i = Kokkos::log2( N );
-  return ( (1u << i) < N ) ? i + 1 : i ;
+unsigned integral_power_of_two_that_contains(const unsigned N) {
+  const unsigned i = Kokkos::log2(N);
+  return ((1u << i) < N) ? i + 1 : i;
 }
 
+}  // namespace Impl
+}  // namespace Kokkos
 
-} // namespace Impl
-} // namespace Kokkos
-
-#endif // KOKKOS_BITOPS_HPP
-
+#endif  // KOKKOS_BITOPS_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.cpp b/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.cpp
index 7b16a8a998ac385dd40c93174c7e017a8b855b40..3b003f84eb2cc9b1e51e8bf25a3475178b16c4ec 100644
--- a/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,7 +45,7 @@
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
-#else
+#elif !defined(__APPLE__)
 #include <unistd.h>
 #endif
 #include <cstdio>
@@ -55,33 +56,14 @@
 namespace Kokkos {
 namespace Impl {
 
-//The following function (processors_per_node) is copied from here:
-// https://lists.gnu.org/archive/html/autoconf/2002-08/msg00126.html
-// Philip Willoughby
-
 int processors_per_node() {
-  int nprocs = -1;
-  int nprocs_max = -1;
-#ifdef _WIN32
-#ifndef _SC_NPROCESSORS_ONLN
-SYSTEM_INFO info;
-GetSystemInfo(&info);
-#define sysconf(a) info.dwNumberOfProcessors
-#define _SC_NPROCESSORS_ONLN
-#endif
-#endif
 #ifdef _SC_NPROCESSORS_ONLN
-  nprocs = sysconf(_SC_NPROCESSORS_ONLN);
-  if (nprocs < 1)
-  {
+  int const num_procs     = sysconf(_SC_NPROCESSORS_ONLN);
+  int const num_procs_max = sysconf(_SC_NPROCESSORS_CONF);
+  if ((num_procs < 1) || (num_procs_max < 1)) {
     return -1;
   }
-  nprocs_max = sysconf(_SC_NPROCESSORS_CONF);
-  if (nprocs_max < 1)
-  {
-    return -1;
-  }
-  return nprocs;
+  return num_procs;
 #else
   return -1;
 #endif
@@ -90,25 +72,25 @@ GetSystemInfo(&info);
 int mpi_ranks_per_node() {
   char *str;
   int ppn = 1;
-  //if ((str = getenv("SLURM_TASKS_PER_NODE"))) {
+  // if ((str = getenv("SLURM_TASKS_PER_NODE"))) {
   //  ppn = atoi(str);
   //  if(ppn<=0) ppn = 1;
   //}
   if ((str = getenv("MV2_COMM_WORLD_LOCAL_SIZE"))) {
     ppn = atoi(str);
-    if(ppn<=0) ppn = 1;
+    if (ppn <= 0) ppn = 1;
   }
   if ((str = getenv("OMPI_COMM_WORLD_LOCAL_SIZE"))) {
     ppn = atoi(str);
-    if(ppn<=0) ppn = 1;
+    if (ppn <= 0) ppn = 1;
   }
   return ppn;
 }
 
 int mpi_local_rank_on_node() {
   char *str;
-  int local_rank=0;
-  //if ((str = getenv("SLURM_LOCALID"))) {
+  int local_rank = 0;
+  // if ((str = getenv("SLURM_LOCALID"))) {
   //  local_rank = atoi(str);
   //}
   if ((str = getenv("MV2_COMM_WORLD_LOCAL_RANK"))) {
@@ -120,6 +102,5 @@ int mpi_local_rank_on_node() {
   return local_rank;
 }
 
-}
-}
-
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.hpp b/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.hpp
index 2b200b057dbc2bc65ea3b7c2e6721f9594f73751..6ba14c85b1c8d6bbaf2e8afc97780df1cace4b32 100644
--- a/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_CPUDiscovery.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,5 +48,5 @@ int processors_per_node();
 int mpi_ranks_per_node();
 int mpi_local_rank_on_node();
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_ChaseLev.hpp b/lib/kokkos/core/src/impl/Kokkos_ChaseLev.hpp
index f86e68cb1d52c386c6a7ef1c937a13e9adfbea8c..bff0ed8315aab5f6ac5c19743d3bb71eb08c9c3e 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ChaseLev.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ChaseLev.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,14 +48,15 @@
 #define KOKKOS_IMPL_LOCKFREEDEQUE_HPP
 
 #include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_TASKDAG // Note: implies CUDA_VERSION >= 8000 if using CUDA
+#ifdef KOKKOS_ENABLE_TASKDAG  // Note: implies CUDA_VERSION >= 8000 if using
+                              // CUDA
 
 #include <Kokkos_Core_fwd.hpp>
 
 #include <Kokkos_PointerOwnership.hpp>
 #include <impl/Kokkos_OptionalRef.hpp>
-#include <impl/Kokkos_Error.hpp> // KOKKOS_EXPECTS
-#include <impl/Kokkos_LinkedListNode.hpp> // KOKKOS_EXPECTS
+#include <impl/Kokkos_Error.hpp>           // KOKKOS_EXPECTS
+#include <impl/Kokkos_LinkedListNode.hpp>  // KOKKOS_EXPECTS
 
 #include <Kokkos_Atomic.hpp>  // atomic_compare_exchange, atomic_fence
 #include "Kokkos_LIFO.hpp"
@@ -70,23 +72,21 @@ namespace Impl {
 
 template <class NodeType, size_t CircularBufferSize, class SizeType = size_t>
 struct fixed_size_circular_buffer {
-public:
-
+ public:
   using node_type = NodeType;
   using size_type = SizeType;
 
-private:
-
-  node_type* m_buffer[CircularBufferSize] = { nullptr };
-
-public:
+ private:
+  node_type* m_buffer[CircularBufferSize] = {nullptr};
 
-  fixed_size_circular_buffer() = default;
+ public:
+  fixed_size_circular_buffer()                                  = default;
   fixed_size_circular_buffer(fixed_size_circular_buffer const&) = delete;
-  fixed_size_circular_buffer(fixed_size_circular_buffer&&) = default;
-  fixed_size_circular_buffer& operator=(fixed_size_circular_buffer const&) = delete;
+  fixed_size_circular_buffer(fixed_size_circular_buffer&&)      = default;
+  fixed_size_circular_buffer& operator=(fixed_size_circular_buffer const&) =
+      delete;
   fixed_size_circular_buffer& operator=(fixed_size_circular_buffer&&) = default;
-  ~fixed_size_circular_buffer() = default;
+  ~fixed_size_circular_buffer()                                       = default;
 
   KOKKOS_FORCEINLINE_FUNCTION
   static constexpr size_type size() noexcept {
@@ -106,38 +106,33 @@ public:
 
 template <class NodeType, class SizeType = size_t>
 struct non_owning_variable_size_circular_buffer {
-public:
-
+ public:
   using node_type = NodeType;
   using size_type = SizeType;
 
-private:
-
+ private:
   ObservingRawPtr<node_type*> m_buffer = nullptr;
-  size_type m_size = 0;
-
-public:
+  size_type m_size                     = 0;
 
+ public:
   KOKKOS_INLINE_FUNCTION
-  non_owning_variable_size_circular_buffer(
-    ObservingRawPtr<node_type*> buffer,
-    size_type arg_size
-  ) noexcept
-    : m_buffer(buffer),
-      m_size(arg_size)
-  { }
+  non_owning_variable_size_circular_buffer(ObservingRawPtr<node_type*> buffer,
+                                           size_type arg_size) noexcept
+      : m_buffer(buffer), m_size(arg_size) {}
 
   non_owning_variable_size_circular_buffer() = default;
-  non_owning_variable_size_circular_buffer(non_owning_variable_size_circular_buffer const&) = delete;
-  non_owning_variable_size_circular_buffer(non_owning_variable_size_circular_buffer&&) = default;
-  non_owning_variable_size_circular_buffer& operator=(non_owning_variable_size_circular_buffer const&) = delete;
-  non_owning_variable_size_circular_buffer& operator=(non_owning_variable_size_circular_buffer&&) = default;
-  ~non_owning_variable_size_circular_buffer() = default;
+  non_owning_variable_size_circular_buffer(
+      non_owning_variable_size_circular_buffer const&) = delete;
+  non_owning_variable_size_circular_buffer(
+      non_owning_variable_size_circular_buffer&&)      = default;
+  non_owning_variable_size_circular_buffer& operator   =(
+      non_owning_variable_size_circular_buffer const&) = delete;
+  non_owning_variable_size_circular_buffer& operator   =(
+      non_owning_variable_size_circular_buffer&&) = default;
+  ~non_owning_variable_size_circular_buffer()          = default;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  constexpr size_type size() const noexcept {
-    return m_size;
-  }
+  constexpr size_type size() const noexcept { return m_size; }
 
   KOKKOS_FORCEINLINE_FUNCTION
   node_type* operator[](size_type idx) const noexcept {
@@ -154,42 +149,28 @@ public:
  * PPoPP '13, https://www.di.ens.fr/~zappa/readings/ppopp13.pdf
  *
  */
-template <
-  class T,
-  class CircularBufferT,
-  class SizeType = int32_t
->
+template <class T, class CircularBufferT, class SizeType = int32_t>
 struct ChaseLevDeque {
-public:
-
-  using size_type = SizeType;
+ public:
+  using size_type  = SizeType;
   using value_type = T;
   // Still using intrusive linked list for waiting queue
   using node_type = SimpleSinglyLinkedListNode<>;
 
-private:
-
+ private:
   // TODO @tasking @new_feature DSH variable size circular buffer?
 
   CircularBufferT m_array;
-  size_type m_top = 0;
+  size_type m_top    = 0;
   size_type m_bottom = 0;
 
+ public:
+  template <class _ignore = void,
+            class         = typename std::enable_if<
+                std::is_default_constructible<CircularBufferT>::value>::type>
+  ChaseLevDeque() : m_array() {}
 
-public:
-
-  template <
-    class _ignore=void,
-    class=typename std::enable_if<
-      std::is_default_constructible<CircularBufferT>::value
-    >::type
-  >
-  ChaseLevDeque() : m_array() { }
-
-  explicit
-  ChaseLevDeque(CircularBufferT buffer)
-    : m_array(std::move(buffer))
-  { }
+  explicit ChaseLevDeque(CircularBufferT buffer) : m_array(std::move(buffer)) {}
 
   KOKKOS_INLINE_FUNCTION
   bool empty() const {
@@ -198,75 +179,75 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef<T>
-  pop() {
-    auto b = m_bottom - 1; // atomic load relaxed
-    auto& a = m_array; // atomic load relaxed
-    m_bottom = b; // atomic store relaxed
-    Kokkos::memory_fence(); // memory order seq_cst
-    auto t = m_top; // atomic load relaxed
+  OptionalRef<T> pop() {
+    auto b   = m_bottom - 1;  // atomic load relaxed
+    auto& a  = m_array;       // atomic load relaxed
+    m_bottom = b;             // atomic store relaxed
+    Kokkos::memory_fence();   // memory order seq_cst
+    auto t = m_top;           // atomic load relaxed
     OptionalRef<T> return_value;
-    if(t <= b) {
+    if (t <= b) {
       /* non-empty queue */
-      return_value = *static_cast<T*>(a[b]); // relaxed load
-      if(t == b) {
+      return_value = *static_cast<T*>(a[b]);  // relaxed load
+      if (t == b) {
         /* single last element in the queue. */
-        if(not Impl::atomic_compare_exchange_strong(&m_top, t, t+1, memory_order_seq_cst, memory_order_relaxed)) {
+        if (not Impl::atomic_compare_exchange_strong(
+                &m_top, t, t + 1, memory_order_seq_cst, memory_order_relaxed)) {
           /* failed race, someone else stole it */
           return_value = nullptr;
         }
-        m_bottom = b + 1; // memory order relaxed
+        m_bottom = b + 1;  // memory order relaxed
       }
     } else {
       /* empty queue */
-      m_bottom = b + 1; // memory order relaxed
+      m_bottom = b + 1;  // memory order relaxed
     }
     return return_value;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool push(node_type&& node)
-  {
+  bool push(node_type&& node) {
     // Just forward to the lvalue version
     return push(node);
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool push(node_type& node)
-  {
-    auto b = m_bottom; // memory order relaxed
-    auto t = Impl::atomic_load(&m_top, memory_order_acquire);
+  bool push(node_type& node) {
+    auto b  = m_bottom;  // memory order relaxed
+    auto t  = Impl::atomic_load(&m_top, memory_order_acquire);
     auto& a = m_array;
-    if(b - t > a.size() - 1) {
+    if (b - t > a.size() - 1) {
       /* queue is full, resize */
-      //m_array = a->grow();
-      //a = m_array;
+      // m_array = a->grow();
+      // a = m_array;
       return false;
     }
-    a[b] = &node; // relaxed
+    a[b] = &node;  // relaxed
     Impl::atomic_store(&m_bottom, b + 1, memory_order_release);
     return true;
   }
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef<T>
-  steal() {
-    auto t = m_top; // TODO @tasking @memory_order DSH: atomic load acquire
-    Kokkos::memory_fence(); // seq_cst fence, so why does the above need to be acquire?
+  OptionalRef<T> steal() {
+    auto t = m_top;  // TODO @tasking @memory_order DSH: atomic load acquire
+    Kokkos::memory_fence();  // seq_cst fence, so why does the above need to be
+                             // acquire?
     auto b = Impl::atomic_load(&m_bottom, memory_order_acquire);
     OptionalRef<T> return_value;
-    if(t < b) {
+    if (t < b) {
       /* Non-empty queue */
-      auto& a = m_array; // TODO @tasking @memory_order DSH: technically consume ordered, but acquire should be fine
-      Kokkos::load_fence(); // TODO @tasking @memory_order DSH memory order instead of fence
-      return_value = *static_cast<T*>(a[t]); // relaxed
-      if(not Impl::atomic_compare_exchange_strong(&m_top, t, t+1, memory_order_seq_cst, memory_order_relaxed)) {
+      auto& a = m_array;     // TODO @tasking @memory_order DSH: technically
+                             // consume ordered, but acquire should be fine
+      Kokkos::load_fence();  // TODO @tasking @memory_order DSH memory order
+                             // instead of fence
+      return_value = *static_cast<T*>(a[t]);  // relaxed
+      if (not Impl::atomic_compare_exchange_strong(
+              &m_top, t, t + 1, memory_order_seq_cst, memory_order_relaxed)) {
         return_value = nullptr;
       }
     }
     return return_value;
   }
-
 };
 
 /*
@@ -275,8 +256,10 @@ public:
       // essentially using the memory order in this version as a fence, which
       // may be unnecessary
       auto buffer_ptr = (node_type***)&m_array.buffer;
-      auto a = Impl::atomic_load(buffer_ptr, memory_order_acquire); // technically consume ordered, but acquire should be fine
-      return_value = *static_cast<T*>(a[t % m_array->size]); // relaxed; we'd have to replace the m_array->size if we ever allow growth
+      auto a = Impl::atomic_load(buffer_ptr, memory_order_acquire); //
+   technically consume ordered, but acquire should be fine return_value =
+   *static_cast<T*>(a[t % m_array->size]); // relaxed; we'd have to replace the
+   m_array->size if we ever allow growth
 */
 
 //----------------------------------------------------------------------------
@@ -284,31 +267,27 @@ public:
 
 template <size_t CircularBufferSize>
 struct TaskQueueTraitsChaseLev {
-
   template <class Task>
-  using ready_queue_type = ChaseLevDeque<
-    Task,
-    fixed_size_circular_buffer<SimpleSinglyLinkedListNode<>, CircularBufferSize, int32_t>,
-    int32_t
-  >;
+  using ready_queue_type =
+      ChaseLevDeque<Task,
+                    fixed_size_circular_buffer<SimpleSinglyLinkedListNode<>,
+                                               CircularBufferSize, int32_t>,
+                    int32_t>;
 
   template <class Task>
   using waiting_queue_type = SingleConsumeOperationLIFO<Task>;
 
   template <class Task>
-  using intrusive_task_base_type =
-    typename ready_queue_type<Task>::node_type;
+  using intrusive_task_base_type = typename ready_queue_type<Task>::node_type;
 
   static constexpr auto ready_queue_insertion_may_fail = true;
-
 };
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* defined KOKKOS_ENABLE_TASKDAG */
 #endif /* #ifndef KOKKOS_IMPL_LOCKFREEDEQUE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ClockTic.hpp b/lib/kokkos/core/src/impl/Kokkos_ClockTic.hpp
index 68ca3b48f61723a0f6c05d5036e04d97f2dcb3b7..ad13fb7548df932b11066f73092dd76419a48a78 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ClockTic.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ClockTic.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -64,47 +65,46 @@ namespace Impl {
  *  having different index-seed values.
  */
 KOKKOS_FORCEINLINE_FUNCTION
-uint64_t clock_tic(void) noexcept
-{
-#if defined( __CUDA_ARCH__ )
+uint64_t clock_tic(void) noexcept {
+#if defined(__CUDA_ARCH__)
 
   // Return value of 64-bit hi-res clock register.
 
   return clock64();
 
 #elif defined(__HCC_ACCELERATOR__)
-    // Get clock register
-    return hc::__clock_u64();
+  // Get clock register
+  return hc::__clock_u64();
 
-#elif defined( __i386__ ) || defined( __x86_64 )
+#elif defined(__i386__) || defined(__x86_64)
 
   // Return value of 64-bit hi-res clock register.
 
   unsigned a = 0, d = 0;
 
-  __asm__ volatile( "rdtsc" : "=a" (a), "=d" (d) );
+  __asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
 
-  return ( (uint64_t) a ) | ( ( (uint64_t) d ) << 32 );
+  return ((uint64_t)a) | (((uint64_t)d) << 32);
 
-#elif defined( __powerpc )     || defined( __powerpc__ ) || \
-      defined( __powerpc64__ ) || defined( __POWERPC__ ) || \
-      defined( __ppc__ )       || defined( __ppc64__ )
+#elif defined(__powerpc) || defined(__powerpc__) || defined(__powerpc64__) || \
+    defined(__POWERPC__) || defined(__ppc__) || defined(__ppc64__)
 
   unsigned int cycles = 0;
 
-  asm volatile( "mftb %0" : "=r" (cycles) );
+  asm volatile("mftb %0" : "=r"(cycles));
 
-  return (uint64_t) cycles;
+  return (uint64_t)cycles;
 
 #else
 
-  return (uint64_t)
-    std::chrono::high_resolution_clock::now().time_since_epoch().count();
+  return (uint64_t)std::chrono::high_resolution_clock::now()
+      .time_since_epoch()
+      .count();
 
 #endif
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
-#endif // KOKKOS_CLOCKTIC_HPP
+#endif  // KOKKOS_CLOCKTIC_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_ConcurrentBitset.hpp b/lib/kokkos/core/src/impl/Kokkos_ConcurrentBitset.hpp
index ca76c2ff72023a8112b1cfb9812fe977b857912d..4f10fb141e18a40f6210126ad53d602ba72212ce 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ConcurrentBitset.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ConcurrentBitset.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,12 +54,11 @@ namespace Kokkos {
 namespace Impl {
 
 struct concurrent_bitset {
-public:
-
+ public:
   // 32 bits per integer value
 
-  enum : uint32_t { bits_per_int_lg2  = 5 };
-  enum : uint32_t { bits_per_int_mask = ( 1 << bits_per_int_lg2 ) - 1 };
+  enum : uint32_t { bits_per_int_lg2 = 5 };
+  enum : uint32_t { bits_per_int_mask = (1 << bits_per_int_lg2) - 1 };
 
   // Buffer is uint32_t[ buffer_bound ]
   //   [ uint32_t { state_header | used_count } , uint32_t bits[*] ]
@@ -74,29 +74,28 @@ public:
   //    before risking an overflow race condition on a full bitset.
 
   enum : uint32_t { max_bit_count_lg2 = 25 };
-  enum : uint32_t { max_bit_count     = 1u << max_bit_count_lg2 };
+  enum : uint32_t { max_bit_count = 1u << max_bit_count_lg2 };
   enum : uint32_t { state_shift = 26 };
-  enum : uint32_t { state_used_mask   = ( 1 << state_shift ) - 1 };
+  enum : uint32_t { state_used_mask = (1 << state_shift) - 1 };
   enum : uint32_t { state_header_mask = uint32_t(0x001f) << state_shift };
 
-  KOKKOS_INLINE_FUNCTION static constexpr
-  uint32_t buffer_bound_lg2( uint32_t const bit_bound_lg2 ) noexcept
-    {
-      return bit_bound_lg2 <= max_bit_count_lg2
-           ? 1 + ( 1u << ( bit_bound_lg2 > bits_per_int_lg2
-                         ? bit_bound_lg2 - bits_per_int_lg2 : 0 ) )
-           : 0 ;
-    }
+  KOKKOS_INLINE_FUNCTION static constexpr uint32_t buffer_bound_lg2(
+      uint32_t const bit_bound_lg2) noexcept {
+    return bit_bound_lg2 <= max_bit_count_lg2
+               ? 1 + (1u << (bit_bound_lg2 > bits_per_int_lg2
+                                 ? bit_bound_lg2 - bits_per_int_lg2
+                                 : 0))
+               : 0;
+  }
 
   /**\brief  Initialize bitset buffer */
-  KOKKOS_INLINE_FUNCTION static constexpr
-  uint32_t buffer_bound( uint32_t const bit_bound ) noexcept
-    {
-      return bit_bound <= max_bit_count
-           ? 1 + ( bit_bound >> bits_per_int_lg2 ) +
-             ( bit_bound & bits_per_int_mask ? 1 : 0 )
-           : 0 ;
-    }
+  KOKKOS_INLINE_FUNCTION static constexpr uint32_t buffer_bound(
+      uint32_t const bit_bound) noexcept {
+    return bit_bound <= max_bit_count
+               ? 1 + (bit_bound >> bits_per_int_lg2) +
+                     (bit_bound & bits_per_int_mask ? 1 : 0)
+               : 0;
+  }
 
   /**\brief  Claim any bit within the bitset bound.
    *
@@ -118,77 +117,70 @@ public:
    *  Recommended to have hint
    *    bit = Kokkos::Impl::clock_tic() & ((1u<<bit_bound_lg2) - 1)
    */
-  KOKKOS_INLINE_FUNCTION static
-  Kokkos::pair<int,int>
-  acquire_bounded_lg2( uint32_t volatile * const buffer
-                     , uint32_t const bit_bound_lg2
-                     , uint32_t bit = 0                /* optional hint */
-                     , uint32_t const state_header = 0 /* optional header */
-                     ) noexcept
-    {
-      typedef Kokkos::pair<int,int> type ;
-
-      const uint32_t bit_bound  = 1 << bit_bound_lg2 ;
-      const uint32_t word_count = bit_bound >> bits_per_int_lg2 ;
-
-      if ( ( max_bit_count_lg2 < bit_bound_lg2 ) ||
-           ( state_header & ~state_header_mask ) ||
-           ( bit_bound < bit ) ) {
-        return type(-3,-3);
-      }
-
-      // Use potentially two fetch_add to avoid CAS loop.
-      // Could generate "racing" failure-to-acquire
-      // when is full at the atomic_fetch_add(+1)
-      // then a release occurs before the atomic_fetch_add(-1).
+  KOKKOS_INLINE_FUNCTION static Kokkos::pair<int, int> acquire_bounded_lg2(
+      uint32_t volatile *const buffer, uint32_t const bit_bound_lg2,
+      uint32_t bit = 0 /* optional hint */
+      ,
+      uint32_t const state_header = 0 /* optional header */
+      ) noexcept {
+    typedef Kokkos::pair<int, int> type;
+
+    const uint32_t bit_bound  = 1 << bit_bound_lg2;
+    const uint32_t word_count = bit_bound >> bits_per_int_lg2;
+
+    if ((max_bit_count_lg2 < bit_bound_lg2) ||
+        (state_header & ~state_header_mask) || (bit_bound < bit)) {
+      return type(-3, -3);
+    }
 
-      const uint32_t state = (uint32_t)
-        Kokkos::atomic_fetch_add( (volatile int *) buffer , 1 );
+    // Use potentially two fetch_add to avoid CAS loop.
+    // Could generate "racing" failure-to-acquire
+    // when is full at the atomic_fetch_add(+1)
+    // then a release occurs before the atomic_fetch_add(-1).
 
-      const uint32_t state_error =
-        state_header != ( state & state_header_mask );
+    const uint32_t state =
+        (uint32_t)Kokkos::atomic_fetch_add((volatile int *)buffer, 1);
 
-      const uint32_t state_bit_used = state & state_used_mask ;
+    const uint32_t state_error = state_header != (state & state_header_mask);
 
-      if ( state_error || ( bit_bound <= state_bit_used ) ) {
-        Kokkos::atomic_fetch_add( (volatile int *) buffer , -1 );
-        return state_error ? type(-2,-2) : type(-1,-1);
-      }
+    const uint32_t state_bit_used = state & state_used_mask;
 
-      // Do not update bit until count is visible:
+    if (state_error || (bit_bound <= state_bit_used)) {
+      Kokkos::atomic_fetch_add((volatile int *)buffer, -1);
+      return state_error ? type(-2, -2) : type(-1, -1);
+    }
 
-      Kokkos::memory_fence();
+    // Do not update bit until count is visible:
 
-      // There is a zero bit available somewhere,
-      // now find the (first) available bit and set it.
+    Kokkos::memory_fence();
 
-      while(1) {
+    // There is a zero bit available somewhere,
+    // now find the (first) available bit and set it.
 
-        const uint32_t word = bit >> bits_per_int_lg2 ;
-        const uint32_t mask = 1u << ( bit & bits_per_int_mask );
-        const uint32_t prev = Kokkos::atomic_fetch_or(buffer + word + 1, mask);
+    while (1) {
+      const uint32_t word = bit >> bits_per_int_lg2;
+      const uint32_t mask = 1u << (bit & bits_per_int_mask);
+      const uint32_t prev = Kokkos::atomic_fetch_or(buffer + word + 1, mask);
 
-        if ( ! ( prev & mask ) ) {
-          // Successfully claimed 'result.first' by
-          // atomically setting that bit.
-          return type( bit , state_bit_used + 1 );
-        }
+      if (!(prev & mask)) {
+        // Successfully claimed 'result.first' by
+        // atomically setting that bit.
+        return type(bit, state_bit_used + 1);
+      }
 
-        // Failed race to set the selected bit
-        // Find a new bit to try.
+      // Failed race to set the selected bit
+      // Find a new bit to try.
 
-        const int j = Kokkos::Impl::bit_first_zero( prev );
+      const int j = Kokkos::Impl::bit_first_zero(prev);
 
-        if ( 0 <= j ) {
-          bit = ( word << bits_per_int_lg2 ) | uint32_t(j);
-        }
-        else {
-          bit =
-            ( (word+1) < word_count ? ((word+1) << bits_per_int_lg2) : 0 )
-            | ( bit & bits_per_int_mask );
-        }
+      if (0 <= j) {
+        bit = (word << bits_per_int_lg2) | uint32_t(j);
+      } else {
+        bit = ((word + 1) < word_count ? ((word + 1) << bits_per_int_lg2) : 0) |
+              (bit & bits_per_int_mask);
       }
     }
+  }
 
   /**\brief  Claim any bit within the bitset bound.
    *
@@ -210,77 +202,71 @@ public:
    *  Recommended to have hint
    *    bit = Kokkos::Impl::clock_tic() % bit_bound
    */
-  KOKKOS_INLINE_FUNCTION static
-  Kokkos::pair<int,int>
-  acquire_bounded( uint32_t volatile * const buffer
-                 , uint32_t const bit_bound
-                 , uint32_t bit = 0                /* optional hint */
-                 , uint32_t const state_header = 0 /* optional header */
-                 ) noexcept
-    {
-      typedef Kokkos::pair<int,int> type ;
-
-      if ( ( max_bit_count < bit_bound ) ||
-           ( state_header & ~state_header_mask ) ||
-           ( bit_bound <= bit ) ) {
-        return type(-3,-3);
-      }
+  KOKKOS_INLINE_FUNCTION static Kokkos::pair<int, int> acquire_bounded(
+      uint32_t volatile *const buffer, uint32_t const bit_bound,
+      uint32_t bit = 0 /* optional hint */
+      ,
+      uint32_t const state_header = 0 /* optional header */
+      ) noexcept {
+    typedef Kokkos::pair<int, int> type;
+
+    if ((max_bit_count < bit_bound) || (state_header & ~state_header_mask) ||
+        (bit_bound <= bit)) {
+      return type(-3, -3);
+    }
 
-      const uint32_t word_count = bit_bound >> bits_per_int_lg2 ;
+    const uint32_t word_count = bit_bound >> bits_per_int_lg2;
 
-      // Use potentially two fetch_add to avoid CAS loop.
-      // Could generate "racing" failure-to-acquire
-      // when is full at the atomic_fetch_add(+1)
-      // then a release occurs before the atomic_fetch_add(-1).
+    // Use potentially two fetch_add to avoid CAS loop.
+    // Could generate "racing" failure-to-acquire
+    // when is full at the atomic_fetch_add(+1)
+    // then a release occurs before the atomic_fetch_add(-1).
 
-      const uint32_t state = (uint32_t)
-        Kokkos::atomic_fetch_add( (volatile int *) buffer , 1 );
+    const uint32_t state =
+        (uint32_t)Kokkos::atomic_fetch_add((volatile int *)buffer, 1);
 
-      const uint32_t state_error =
-        state_header != ( state & state_header_mask );
+    const uint32_t state_error = state_header != (state & state_header_mask);
 
-      const uint32_t state_bit_used = state & state_used_mask ;
+    const uint32_t state_bit_used = state & state_used_mask;
 
-      if ( state_error || ( bit_bound <= state_bit_used ) ) {
-        Kokkos::atomic_fetch_add( (volatile int *) buffer , -1 );
-        return state_error ? type(-2,-2) : type(-1,-1);
-      }
-
-      // Do not update bit until count is visible:
+    if (state_error || (bit_bound <= state_bit_used)) {
+      Kokkos::atomic_fetch_add((volatile int *)buffer, -1);
+      return state_error ? type(-2, -2) : type(-1, -1);
+    }
 
-      Kokkos::memory_fence();
+    // Do not update bit until count is visible:
 
-      // There is a zero bit available somewhere,
-      // now find the (first) available bit and set it.
+    Kokkos::memory_fence();
 
-      while(1) {
+    // There is a zero bit available somewhere,
+    // now find the (first) available bit and set it.
 
-        const uint32_t word = bit >> bits_per_int_lg2 ;
-        const uint32_t mask = 1u << ( bit & bits_per_int_mask );
-        const uint32_t prev = Kokkos::atomic_fetch_or(buffer + word + 1, mask);
+    while (1) {
+      const uint32_t word = bit >> bits_per_int_lg2;
+      const uint32_t mask = 1u << (bit & bits_per_int_mask);
+      const uint32_t prev = Kokkos::atomic_fetch_or(buffer + word + 1, mask);
 
-        if ( ! ( prev & mask ) ) {
-          // Successfully claimed 'result.first' by
-          // atomically setting that bit.
-          return type( bit , state_bit_used + 1 );
-        }
+      if (!(prev & mask)) {
+        // Successfully claimed 'result.first' by
+        // atomically setting that bit.
+        return type(bit, state_bit_used + 1);
+      }
 
-        // Failed race to set the selected bit
-        // Find a new bit to try.
+      // Failed race to set the selected bit
+      // Find a new bit to try.
 
-        const int j = Kokkos::Impl::bit_first_zero( prev );
+      const int j = Kokkos::Impl::bit_first_zero(prev);
 
-        if ( 0 <= j ) {
-          bit = (word << bits_per_int_lg2 ) | uint32_t(j);
-        }
+      if (0 <= j) {
+        bit = (word << bits_per_int_lg2) | uint32_t(j);
+      }
 
-        if ( ( j < 0 ) || ( bit_bound <= bit ) ) {
-          bit =
-            ( (word+1) < word_count ? ((word+1) << bits_per_int_lg2) : 0 )
-            | ( bit & bits_per_int_mask );
-        }
+      if ((j < 0) || (bit_bound <= bit)) {
+        bit = ((word + 1) < word_count ? ((word + 1) << bits_per_int_lg2) : 0) |
+              (bit & bits_per_int_mask);
       }
     }
+  }
 
   /**\brief
    *
@@ -291,30 +277,29 @@ public:
    *    -1 bit was already released
    *    -2 state_header error
    */
-  KOKKOS_INLINE_FUNCTION static
-  int release( uint32_t volatile * const buffer
-             , uint32_t const bit
-             , uint32_t const state_header = 0 /* optional header */
-             ) noexcept
-    {
-      if ( state_header != ( state_header_mask & *buffer ) ) { return -2 ; }
+  KOKKOS_INLINE_FUNCTION static int release(
+      uint32_t volatile *const buffer, uint32_t const bit,
+      uint32_t const state_header = 0 /* optional header */
+      ) noexcept {
+    if (state_header != (state_header_mask & *buffer)) {
+      return -2;
+    }
 
-      const uint32_t mask = 1u << ( bit & bits_per_int_mask );
-      const uint32_t prev =
-        Kokkos::atomic_fetch_and( buffer + ( bit >> bits_per_int_lg2 ) + 1
-                                , ~mask
-                                );
+    const uint32_t mask = 1u << (bit & bits_per_int_mask);
+    const uint32_t prev =
+        Kokkos::atomic_fetch_and(buffer + (bit >> bits_per_int_lg2) + 1, ~mask);
 
-      if ( ! ( prev & mask ) ) { return -1 ; }
+    if (!(prev & mask)) {
+      return -1;
+    }
 
-      // Do not update count until bit clear is visible
-      Kokkos::memory_fence();
+    // Do not update count until bit clear is visible
+    Kokkos::memory_fence();
 
-      const int count =
-        Kokkos::atomic_fetch_add( (volatile int *) buffer , -1 );
+    const int count = Kokkos::atomic_fetch_add((volatile int *)buffer, -1);
 
-      return ( count & state_used_mask ) - 1 ;
-    }
+    return (count & state_used_mask) - 1;
+  }
 
   /**\brief
    *
@@ -325,33 +310,32 @@ public:
    *    -1 bit was already released
    *    -2 bit or state_header error
    */
-  KOKKOS_INLINE_FUNCTION static
-  int set( uint32_t volatile * const buffer
-         , uint32_t const bit
-         , uint32_t const state_header = 0 /* optional header */
-         ) noexcept
-    {
-      if ( state_header != ( state_header_mask & *buffer ) ) { return -2 ; }
+  KOKKOS_INLINE_FUNCTION static int set(
+      uint32_t volatile *const buffer, uint32_t const bit,
+      uint32_t const state_header = 0 /* optional header */
+      ) noexcept {
+    if (state_header != (state_header_mask & *buffer)) {
+      return -2;
+    }
 
-      const uint32_t mask = 1u << ( bit & bits_per_int_mask );
-      const uint32_t prev =
-        Kokkos::atomic_fetch_or( buffer + ( bit >> bits_per_int_lg2 ) + 1
-                               , mask
-                               );
+    const uint32_t mask = 1u << (bit & bits_per_int_mask);
+    const uint32_t prev =
+        Kokkos::atomic_fetch_or(buffer + (bit >> bits_per_int_lg2) + 1, mask);
 
-      if ( ! ( prev & mask ) ) { return -1 ; }
+    if (!(prev & mask)) {
+      return -1;
+    }
 
-      // Do not update count until bit clear is visible
-      Kokkos::memory_fence();
+    // Do not update count until bit clear is visible
+    Kokkos::memory_fence();
 
-      const int count =
-        Kokkos::atomic_fetch_add( (volatile int *) buffer , -1 );
+    const int count = Kokkos::atomic_fetch_add((volatile int *)buffer, -1);
 
-      return ( count & state_used_mask ) - 1 ;
-    }
+    return (count & state_used_mask) - 1;
+  }
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_CONCURRENTBITSET_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Core.cpp b/lib/kokkos/core/src/impl/Kokkos_Core.cpp
index 0d472e98bb7d4dc8c7039e7ffc257c3d11cc397c..53f3fd9ce20279a796d42617eed44c1ec6bb2642 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Core.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Core.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,34 +51,35 @@
 #include <cstdlib>
 #include <stack>
 #include <cerrno>
+#include <unistd.h>
 
 //----------------------------------------------------------------------------
 
 namespace {
 bool g_is_initialized = false;
-bool g_show_warnings = true;
+bool g_show_warnings  = true;
 std::stack<std::function<void()> > finalize_hooks;
-}
+}  // namespace
 
-namespace Kokkos { namespace Impl { namespace {
+namespace Kokkos {
+namespace Impl {
+namespace {
 
-bool is_unsigned_int(const char* str)
-{
-  const size_t len = strlen (str);
+bool is_unsigned_int(const char* str) {
+  const size_t len = strlen(str);
   for (size_t i = 0; i < len; ++i) {
-    if (! isdigit (str[i])) {
+    if (!isdigit(str[i])) {
       return false;
     }
   }
   return true;
 }
-void initialize_internal(const InitArguments& args)
-{
+void initialize_internal(const InitArguments& args) {
 // This is an experimental setting
 // For KNL in Flat mode this variable should be set, so that
 // memkind allocates high bandwidth memory correctly.
 #ifdef KOKKOS_ENABLE_HBWSPACE
-setenv("MEMKIND_HBW_NODES", "1", 0);
+  setenv("MEMKIND_HBW_NODES", "1", 0);
 #endif
 
   if (args.disable_warnings) {
@@ -85,102 +87,108 @@ setenv("MEMKIND_HBW_NODES", "1", 0);
   }
 
   // Protect declarations, to prevent "unused variable" warnings.
-#if defined( KOKKOS_ENABLE_OPENMP ) || defined( KOKKOS_ENABLE_THREADS ) ||\
-    defined( KOKKOS_ENABLE_OPENMPTARGET ) || defined ( KOKKOS_ENABLE_HPX )
+#if defined(KOKKOS_ENABLE_OPENMP) || defined(KOKKOS_ENABLE_THREADS) || \
+    defined(KOKKOS_ENABLE_OPENMPTARGET) || defined(KOKKOS_ENABLE_HPX)
   const int num_threads = args.num_threads;
 #endif
-#if defined( KOKKOS_ENABLE_THREADS ) || defined( KOKKOS_ENABLE_OPENMPTARGET )
+#if defined(KOKKOS_ENABLE_THREADS) || defined(KOKKOS_ENABLE_OPENMPTARGET)
   const int use_numa = args.num_numa;
 #endif
-#if defined( KOKKOS_ENABLE_CUDA ) || defined( KOKKOS_ENABLE_ROCM )
-  int use_gpu = args.device_id;
-  const int ndevices = args.ndevices;
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_ROCM)
+  int use_gpu           = args.device_id;
+  const int ndevices    = args.ndevices;
   const int skip_device = args.skip_device;
-  // if the exact device is not set, but ndevices was given, assign round-robin using on-node MPI rank
+  // if the exact device is not set, but ndevices was given, assign round-robin
+  // using on-node MPI rank
   if (use_gpu < 0 && ndevices >= 0) {
-    auto local_rank_str = std::getenv("OMPI_COMM_WORLD_LOCAL_RANK"); //OpenMPI
-    if (!local_rank_str) local_rank_str = std::getenv("MV2_COMM_WORLD_LOCAL_RANK"); //MVAPICH2
-    if (!local_rank_str) local_rank_str = std::getenv("SLURM_LOCALID"); //SLURM
+    auto local_rank_str = std::getenv("OMPI_COMM_WORLD_LOCAL_RANK");  // OpenMPI
+    if (!local_rank_str)
+      local_rank_str = std::getenv("MV2_COMM_WORLD_LOCAL_RANK");  // MVAPICH2
+    if (!local_rank_str)
+      local_rank_str = std::getenv("SLURM_LOCALID");  // SLURM
     if (local_rank_str) {
       auto local_rank = std::atoi(local_rank_str);
-      use_gpu = local_rank % ndevices;
+      use_gpu         = local_rank % ndevices;
     } else {
-      // user only gave us ndevices, but the MPI environment variable wasn't set.
-      // start with GPU 0 at this point
+      // user only gave us ndevices, but the MPI environment variable wasn't
+      // set. start with GPU 0 at this point
       use_gpu = 0;
     }
     // shift assignments over by one so no one is assigned to "skip_device"
     if (use_gpu >= skip_device) ++use_gpu;
   }
-#endif // defined( KOKKOS_ENABLE_CUDA )
+#endif  // defined( KOKKOS_ENABLE_CUDA )
 
-#if defined( KOKKOS_ENABLE_OPENMP )
-  if( std::is_same< Kokkos::OpenMP , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::OpenMP , Kokkos::HostSpace::execution_space >::value ) {
+#if defined(KOKKOS_ENABLE_OPENMP)
+  if (std::is_same<Kokkos::OpenMP, Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::OpenMP, Kokkos::HostSpace::execution_space>::value) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     Kokkos::OpenMP::initialize(num_threads);
 #else
     Kokkos::OpenMP::impl_initialize(num_threads);
 #endif
-  }
-  else {
-    //std::cout << "Kokkos::initialize() fyi: OpenMP enabled but not initialized" << std::endl ;
+  } else {
+    // std::cout << "Kokkos::initialize() fyi: OpenMP enabled but not
+    // initialized" << std::endl ;
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_THREADS )
-  if( std::is_same< Kokkos::Threads , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::Threads , Kokkos::HostSpace::execution_space >::value ) {
+#if defined(KOKKOS_ENABLE_THREADS)
+  if (std::is_same<Kokkos::Threads, Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::Threads,
+                   Kokkos::HostSpace::execution_space>::value) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    if(num_threads>0) {
-      if(use_numa>0) {
-        Kokkos::Threads::initialize(num_threads,use_numa);
-      }
-      else {
+    if (num_threads > 0) {
+      if (use_numa > 0) {
+        Kokkos::Threads::initialize(num_threads, use_numa);
+      } else {
         Kokkos::Threads::initialize(num_threads);
       }
     } else {
       Kokkos::Threads::initialize();
     }
 #else
-    if(num_threads>0) {
-      if(use_numa>0) {
-        Kokkos::Threads::impl_initialize(num_threads,use_numa);
-      }
-      else {
+    if (num_threads > 0) {
+      if (use_numa > 0) {
+        Kokkos::Threads::impl_initialize(num_threads, use_numa);
+      } else {
         Kokkos::Threads::impl_initialize(num_threads);
       }
     } else {
       Kokkos::Threads::impl_initialize();
     }
 #endif
-    //std::cout << "Kokkos::initialize() fyi: Pthread enabled and initialized" << std::endl ;
-  }
-  else {
-    //std::cout << "Kokkos::initialize() fyi: Pthread enabled but not initialized" << std::endl ;
+    // std::cout << "Kokkos::initialize() fyi: Pthread enabled and initialized"
+    // << std::endl ;
+  } else {
+    // std::cout << "Kokkos::initialize() fyi: Pthread enabled but not
+    // initialized" << std::endl ;
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_HPX )
-  if( std::is_same< Kokkos::Experimental::HPX , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::Experimental::HPX , Kokkos::HostSpace::execution_space >::value ) {
-      if(num_threads>0) {
-        Kokkos::Experimental::HPX::impl_initialize(num_threads);
-      } else {
-        Kokkos::Experimental::HPX::impl_initialize();
-      }
-      //std::cout << "Kokkos::initialize() fyi: HPX enabled and initialized" << std::endl ;
-  }
-  else {
-      //std::cout << "Kokkos::initialize() fyi: HPX enabled but not initialized" << std::endl ;
+#if defined(KOKKOS_ENABLE_HPX)
+  if (std::is_same<Kokkos::Experimental::HPX,
+                   Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::Experimental::HPX,
+                   Kokkos::HostSpace::execution_space>::value) {
+    if (num_threads > 0) {
+      Kokkos::Experimental::HPX::impl_initialize(num_threads);
+    } else {
+      Kokkos::Experimental::HPX::impl_initialize();
+    }
+    // std::cout << "Kokkos::initialize() fyi: HPX enabled and initialized" <<
+    // std::endl ;
+  } else {
+    // std::cout << "Kokkos::initialize() fyi: HPX enabled but not initialized"
+    // << std::endl ;
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_SERIAL )
+#if defined(KOKKOS_ENABLE_SERIAL)
   // Prevent "unused variable" warning for 'args' input struct.  If
   // Serial::initialize() ever needs to take arguments from the input
   // struct, you may remove this line of code.
-  (void) args;
+  (void)args;
 
   // Always initialize Serial if it is configure time enabled
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
@@ -190,80 +198,96 @@ setenv("MEMKIND_HBW_NODES", "1", 0);
 #endif
 #endif
 
-#if defined( KOKKOS_ENABLE_OPENMPTARGET )
-  if( Impl::is_same< Kokkos::Experimental::OpenMPTarget , Kokkos::DefaultExecutionSpace >::value ) {
-    if(num_threads>0) {
-      if(use_numa>0) {
-        Kokkos::Experimental::OpenMPTarget::initialize(num_threads,use_numa);
-      }
-      else {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+  if (Impl::is_same<Kokkos::Experimental::OpenMPTarget,
+                    Kokkos::DefaultExecutionSpace>::value) {
+    if (num_threads > 0) {
+      if (use_numa > 0) {
+        Kokkos::Experimental::OpenMPTarget::initialize(num_threads, use_numa);
+      } else {
         Kokkos::Experimental::OpenMPTarget::initialize(num_threads);
       }
     } else {
       Kokkos::Experimental::OpenMPTarget::initialize();
     }
-    //std::cout << "Kokkos::initialize() fyi: OpenMP enabled and initialized" << std::endl ;
-  }
-  else {
-    //std::cout << "Kokkos::initialize() fyi: OpenMP enabled but not initialized" << std::endl ;
+    // std::cout << "Kokkos::initialize() fyi: OpenMP enabled and initialized"
+    // << std::endl ;
+  } else {
+    // std::cout << "Kokkos::initialize() fyi: OpenMP enabled but not
+    // initialized" << std::endl ;
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_CUDA )
-  if( std::is_same< Kokkos::Cuda , Kokkos::DefaultExecutionSpace >::value || 0 < use_gpu ) {
+#if defined(KOKKOS_ENABLE_CUDA)
+  if (std::is_same<Kokkos::Cuda, Kokkos::DefaultExecutionSpace>::value ||
+      0 < use_gpu) {
     if (use_gpu > -1) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      Kokkos::Cuda::initialize( Kokkos::Cuda::SelectDevice( use_gpu ) );
+      Kokkos::Cuda::initialize(Kokkos::Cuda::SelectDevice(use_gpu));
 #else
-      Kokkos::Cuda::impl_initialize( Kokkos::Cuda::SelectDevice( use_gpu ) );
+      Kokkos::Cuda::impl_initialize(Kokkos::Cuda::SelectDevice(use_gpu));
 #endif
-    }
-    else {
+    } else {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
       Kokkos::Cuda::initialize();
 #else
       Kokkos::Cuda::impl_initialize();
 #endif
     }
-    //std::cout << "Kokkos::initialize() fyi: Cuda enabled and initialized" << std::endl ;
+    // std::cout << "Kokkos::initialize() fyi: Cuda enabled and initialized" <<
+    // std::endl ;
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_ROCM )
-  if( std::is_same< Kokkos::Experimental::ROCm , Kokkos::DefaultExecutionSpace >::value || 0 < use_gpu ) {
+#if defined(KOKKOS_ENABLE_ROCM)
+  if (std::is_same<Kokkos::Experimental::ROCm,
+                   Kokkos::DefaultExecutionSpace>::value ||
+      0 < use_gpu) {
     if (use_gpu > -1) {
-      Kokkos::Experimental::ROCm::initialize( Kokkos::Experimental::ROCm::SelectDevice( use_gpu ) );
-    }
-    else {
+      Kokkos::Experimental::ROCm::initialize(
+          Kokkos::Experimental::ROCm::SelectDevice(use_gpu));
+    } else {
       Kokkos::Experimental::ROCm::initialize();
     }
-    std::cout << "Kokkos::initialize() fyi: ROCm enabled and initialized" << std::endl ;
+    std::cout << "Kokkos::initialize() fyi: ROCm enabled and initialized"
+              << std::endl;
   }
 #endif
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::initialize();
+  Kokkos::Profiling::initialize();
+#else
+  if (getenv("KOKKOS_PROFILE_LIBRARY") != nullptr) {
+    std::cerr << "Kokkos::initialize() warning: Requested Kokkos Profiling, "
+                 "but Kokkos was built without Profiling support"
+              << std::endl;
+  }
 #endif
-    g_is_initialized = true;
+  g_is_initialized = true;
 }
 
-void finalize_internal( const bool all_spaces = false )
-{
-
-  typename decltype(finalize_hooks)::size_type  numSuccessfulCalls = 0;
-  while(! finalize_hooks.empty()) {
+void finalize_internal(const bool all_spaces = false) {
+  typename decltype(finalize_hooks)::size_type numSuccessfulCalls = 0;
+  while (!finalize_hooks.empty()) {
     auto f = finalize_hooks.top();
     try {
       f();
-    }
-    catch(...) {
+    } catch (...) {
       std::cerr << "Kokkos::finalize: A finalize hook (set via "
-        "Kokkos::push_finalize_hook) threw an exception that it did not catch."
-        "  Per std::atexit rules, this results in std::terminate.  This is "
-        "finalize hook number " << numSuccessfulCalls << " (1-based indexing) "
-        "out of " << finalize_hooks.size() << " to call.  Remember that "
-        "Kokkos::finalize calls finalize hooks in reverse order from how they "
-        "were pushed." << std::endl;
+                   "Kokkos::push_finalize_hook) threw an exception that it did "
+                   "not catch."
+                   "  Per std::atexit rules, this results in std::terminate.  "
+                   "This is "
+                   "finalize hook number "
+                << numSuccessfulCalls
+                << " (1-based indexing) "
+                   "out of "
+                << finalize_hooks.size()
+                << " to call.  Remember that "
+                   "Kokkos::finalize calls finalize hooks in reverse order "
+                   "from how they "
+                   "were pushed."
+                << std::endl;
       std::terminate();
     }
     finalize_hooks.pop();
@@ -271,128 +295,128 @@ void finalize_internal( const bool all_spaces = false )
   }
 
 #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::finalize();
+  Kokkos::Profiling::finalize();
 #endif
 
-#if defined( KOKKOS_ENABLE_CUDA )
-  if( std::is_same< Kokkos::Cuda , Kokkos::DefaultExecutionSpace >::value || all_spaces ) {
+#if defined(KOKKOS_ENABLE_CUDA)
+  if (std::is_same<Kokkos::Cuda, Kokkos::DefaultExecutionSpace>::value ||
+      all_spaces) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    if(Kokkos::Cuda::is_initialized())
-      Kokkos::Cuda::finalize();
+    if (Kokkos::Cuda::is_initialized()) Kokkos::Cuda::finalize();
 #else
-    if(Kokkos::Cuda::impl_is_initialized())
-      Kokkos::Cuda::impl_finalize();
+    if (Kokkos::Cuda::impl_is_initialized()) Kokkos::Cuda::impl_finalize();
 #endif
   }
 #else
   (void)all_spaces;
 #endif
 
-#if defined( KOKKOS_ENABLE_ROCM )
-  if( std::is_same< Kokkos::Experimental::ROCm , Kokkos::DefaultExecutionSpace >::value || all_spaces ) {
-    if(Kokkos::Experimental::ROCm::is_initialized())
+#if defined(KOKKOS_ENABLE_ROCM)
+  if (std::is_same<Kokkos::Experimental::ROCm,
+                   Kokkos::DefaultExecutionSpace>::value ||
+      all_spaces) {
+    if (Kokkos::Experimental::ROCm::is_initialized())
       Kokkos::Experimental::ROCm::finalize();
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_OPENMPTARGET )
-  if( std::is_same< Kokkos::Experimental::OpenMPTarget , Kokkos::DefaultExecutionSpace >::value || all_spaces ) {
-    if(Kokkos::Experimental::OpenMPTarget::is_initialized())
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+  if (std::is_same<Kokkos::Experimental::OpenMPTarget,
+                   Kokkos::DefaultExecutionSpace>::value ||
+      all_spaces) {
+    if (Kokkos::Experimental::OpenMPTarget::is_initialized())
       Kokkos::Experimental::OpenMPTarget::finalize();
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_OPENMP )
-  if( std::is_same< Kokkos::OpenMP , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::OpenMP , Kokkos::HostSpace::execution_space >::value ||
-      all_spaces ) {
+#if defined(KOKKOS_ENABLE_OPENMP)
+  if (std::is_same<Kokkos::OpenMP, Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::OpenMP, Kokkos::HostSpace::execution_space>::value ||
+      all_spaces) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    if(Kokkos::OpenMP::is_initialized())
-      Kokkos::OpenMP::finalize();
+    if (Kokkos::OpenMP::is_initialized()) Kokkos::OpenMP::finalize();
 #else
-    if(Kokkos::OpenMP::impl_is_initialized())
-      Kokkos::OpenMP::impl_finalize();
+    if (Kokkos::OpenMP::impl_is_initialized()) Kokkos::OpenMP::impl_finalize();
 #endif
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_HPX )
-  if( std::is_same< Kokkos::Experimental::HPX , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::Experimental::HPX , Kokkos::HostSpace::execution_space >::value ||
-      all_spaces ) {
-    if(Kokkos::Experimental::HPX::impl_is_initialized())
+#if defined(KOKKOS_ENABLE_HPX)
+  if (std::is_same<Kokkos::Experimental::HPX,
+                   Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::Experimental::HPX,
+                   Kokkos::HostSpace::execution_space>::value ||
+      all_spaces) {
+    if (Kokkos::Experimental::HPX::impl_is_initialized())
       Kokkos::Experimental::HPX::impl_finalize();
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_THREADS )
-  if( std::is_same< Kokkos::Threads , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::Threads , Kokkos::HostSpace::execution_space >::value ||
-      all_spaces ) {
+#if defined(KOKKOS_ENABLE_THREADS)
+  if (std::is_same<Kokkos::Threads, Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::Threads,
+                   Kokkos::HostSpace::execution_space>::value ||
+      all_spaces) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    if(Kokkos::Threads::is_initialized())
-      Kokkos::Threads::finalize();
+    if (Kokkos::Threads::is_initialized()) Kokkos::Threads::finalize();
 #else
-    if(Kokkos::Threads::impl_is_initialized())
+    if (Kokkos::Threads::impl_is_initialized())
       Kokkos::Threads::impl_finalize();
 #endif
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_SERIAL )
+#if defined(KOKKOS_ENABLE_SERIAL)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  if(Kokkos::Serial::is_initialized())
-    Kokkos::Serial::finalize();
+  if (Kokkos::Serial::is_initialized()) Kokkos::Serial::finalize();
 #else
-  if(Kokkos::Serial::impl_is_initialized())
-    Kokkos::Serial::impl_finalize();
+  if (Kokkos::Serial::impl_is_initialized()) Kokkos::Serial::impl_finalize();
 #endif
 #endif
 
   g_is_initialized = false;
-  g_show_warnings = true;
+  g_show_warnings  = true;
 }
 
-void fence_internal()
-{
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  if( std::is_same< Kokkos::Cuda , Kokkos::DefaultExecutionSpace >::value ) {
+void fence_internal() {
+#if defined(KOKKOS_ENABLE_CUDA)
+  if (std::is_same<Kokkos::Cuda, Kokkos::DefaultExecutionSpace>::value) {
     Kokkos::Cuda::impl_static_fence();
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_ROCM )
-  if( std::is_same< Kokkos::Experimental::ROCm , Kokkos::DefaultExecutionSpace >::value ) {
+#if defined(KOKKOS_ENABLE_ROCM)
+  if (std::is_same<Kokkos::Experimental::ROCm,
+                   Kokkos::DefaultExecutionSpace>::value) {
     Kokkos::Experimental::ROCm().fence();
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_OPENMP )
-  if( std::is_same< Kokkos::OpenMP , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::OpenMP , Kokkos::HostSpace::execution_space >::value ) {
+#if defined(KOKKOS_ENABLE_OPENMP)
+  if (std::is_same<Kokkos::OpenMP, Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::OpenMP, Kokkos::HostSpace::execution_space>::value) {
     Kokkos::OpenMP::impl_static_fence();
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_HPX )
+#if defined(KOKKOS_ENABLE_HPX)
   Kokkos::Experimental::HPX::impl_static_fence();
 #endif
 
-#if defined( KOKKOS_ENABLE_THREADS )
-  if( std::is_same< Kokkos::Threads , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::Threads , Kokkos::HostSpace::execution_space >::value ) {
+#if defined(KOKKOS_ENABLE_THREADS)
+  if (std::is_same<Kokkos::Threads, Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::Threads,
+                   Kokkos::HostSpace::execution_space>::value) {
     Kokkos::Threads::impl_static_fence();
   }
 #endif
 
-#if defined( KOKKOS_ENABLE_SERIAL )
-  if( std::is_same< Kokkos::Serial , Kokkos::DefaultExecutionSpace >::value ||
-      std::is_same< Kokkos::Serial , Kokkos::HostSpace::execution_space >::value ) {
+#if defined(KOKKOS_ENABLE_SERIAL)
+  if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
+      std::is_same<Kokkos::Serial, Kokkos::HostSpace::execution_space>::value) {
     Kokkos::Serial::impl_static_fence();
   }
 #endif
-
 }
 
 bool check_arg(char const* arg, char const* expected) {
@@ -404,7 +428,8 @@ bool check_arg(char const* arg, char const* expected) {
   /* if expected is "--threads", ignore "--threads-for-application"
      by checking this character          ---------^
      to see if it continues to make a longer name */
-  if (std::isalnum(arg[exp_len]) || arg[exp_len] == '-' || arg[exp_len] == '_') {
+  if (std::isalnum(arg[exp_len]) || arg[exp_len] == '-' ||
+      arg[exp_len] == '_') {
     return false;
   }
   return true;
@@ -414,272 +439,398 @@ bool check_int_arg(char const* arg, char const* expected, int* value) {
   if (!check_arg(arg, expected)) return false;
   std::size_t arg_len = std::strlen(arg);
   std::size_t exp_len = std::strlen(expected);
-  bool okay = true;
+  bool okay           = true;
   if (arg_len == exp_len || arg[exp_len] != '=') okay = false;
   char const* number = arg + exp_len + 1;
   if (!Impl::is_unsigned_int(number) || strlen(number) == 0) okay = false;
   *value = std::atoi(number);
   if (!okay) {
     std::ostringstream ss;
-    ss << "Error: expecting an '=INT' after command line argument '" << expected << "'";
+    ss << "Error: expecting an '=INT' after command line argument '" << expected
+       << "'";
     ss << ". Raised by Kokkos::initialize(int narg, char* argc[]).";
-    Impl::throw_runtime_exception( ss.str() );
+    Impl::throw_runtime_exception(ss.str());
   }
   return true;
 }
 
-}
+}  // namespace
 
-}} // namespace Kokkos::Impl::{unnamed}
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-void initialize(int& narg, char* arg[])
-{
-    int num_threads = -1;
-    int numa = -1;
-    int device = -1;
-    int ndevices=-1;
-    int skip_device = 9999;
-    bool disable_warnings = false;
-
-    int kokkos_threads_found = 0;
-    int kokkos_numa_found = 0;
-    int kokkos_device_found = 0;
-    int kokkos_ndevices_found = 0;
-
-    int iarg = 0;
-
-    while (iarg < narg) {
-      if (Impl::check_int_arg(arg[iarg], "--kokkos-threads", &num_threads)) {
-        for(int k=iarg;k<narg-1;k++) {
-          arg[k] = arg[k+1];
-        }
-        kokkos_threads_found=1;
-        narg--;
-      } else if (!kokkos_threads_found && Impl::check_int_arg(arg[iarg], "--threads", &num_threads)) {
-        iarg++;
-      } else if (Impl::check_int_arg(arg[iarg], "--kokkos-numa", &numa)) {
-        for(int k=iarg;k<narg-1;k++) {
-          arg[k] = arg[k+1];
+void initialize(int& narg, char* arg[]) {
+  int num_threads       = -1;
+  int numa              = -1;
+  int device            = -1;
+  int ndevices          = -1;
+  int skip_device       = 9999;
+  bool disable_warnings = false;
+
+  int kokkos_threads_found  = 0;
+  int kokkos_numa_found     = 0;
+  int kokkos_device_found   = 0;
+  int kokkos_ndevices_found = 0;
+
+  int iarg = 0;
+
+  while (iarg < narg) {
+    if (Impl::check_int_arg(arg[iarg], "--kokkos-threads", &num_threads)) {
+      for (int k = iarg; k < narg - 1; k++) {
+        arg[k] = arg[k + 1];
+      }
+      kokkos_threads_found = 1;
+      narg--;
+    } else if (!kokkos_threads_found &&
+               Impl::check_int_arg(arg[iarg], "--threads", &num_threads)) {
+      iarg++;
+    } else if (Impl::check_int_arg(arg[iarg], "--kokkos-numa", &numa)) {
+      for (int k = iarg; k < narg - 1; k++) {
+        arg[k] = arg[k + 1];
+      }
+      kokkos_numa_found = 1;
+      narg--;
+    } else if (!kokkos_numa_found &&
+               Impl::check_int_arg(arg[iarg], "--numa", &numa)) {
+      iarg++;
+    } else if (Impl::check_int_arg(arg[iarg], "--kokkos-device", &device)) {
+      for (int k = iarg; k < narg - 1; k++) {
+        arg[k] = arg[k + 1];
+      }
+      kokkos_device_found = 1;
+      narg--;
+    } else if (!kokkos_device_found &&
+               Impl::check_int_arg(arg[iarg], "--device", &device)) {
+      iarg++;
+    } else if (Impl::check_arg(arg[iarg], "--kokkos-ndevices") ||
+               Impl::check_arg(arg[iarg], "--ndevices")) {
+      // Find the number of device (expecting --device=XX)
+      if (!((strncmp(arg[iarg], "--kokkos-ndevices=", 18) == 0) ||
+            (strncmp(arg[iarg], "--ndevices=", 11) == 0)))
+        Impl::throw_runtime_exception(
+            "Error: expecting an '=INT[,INT]' after command line argument "
+            "'--ndevices/--kokkos-ndevices'. Raised by Kokkos::initialize(int "
+            "narg, char* argc[]).");
+
+      char* num1      = strchr(arg[iarg], '=') + 1;
+      char* num2      = strpbrk(num1, ",");
+      int num1_len    = num2 == NULL ? strlen(num1) : num2 - num1;
+      char* num1_only = new char[num1_len + 1];
+      strncpy(num1_only, num1, num1_len);
+      num1_only[num1_len] = 0;
+
+      if (!Impl::is_unsigned_int(num1_only) || (strlen(num1_only) == 0)) {
+        Impl::throw_runtime_exception(
+            "Error: expecting an integer number after command line argument "
+            "'--kokkos-ndevices'. Raised by Kokkos::initialize(int narg, char* "
+            "argc[]).");
+      }
+      if ((strncmp(arg[iarg], "--kokkos-ndevices", 17) == 0) ||
+          !kokkos_ndevices_found)
+        ndevices = atoi(num1_only);
+      delete[] num1_only;
+
+      if (num2 != NULL) {
+        if ((!Impl::is_unsigned_int(num2 + 1)) || (strlen(num2) == 1))
+          Impl::throw_runtime_exception(
+              "Error: expecting an integer number after command line argument "
+              "'--kokkos-ndevices=XX,'. Raised by Kokkos::initialize(int narg, "
+              "char* argc[]).");
+
+        if ((strncmp(arg[iarg], "--kokkos-ndevices", 17) == 0) ||
+            !kokkos_ndevices_found)
+          skip_device = atoi(num2 + 1);
+      }
+
+      // Remove the --kokkos-ndevices argument from the list but leave
+      // --ndevices
+      if (strncmp(arg[iarg], "--kokkos-ndevices", 17) == 0) {
+        for (int k = iarg; k < narg - 1; k++) {
+          arg[k] = arg[k + 1];
         }
-        kokkos_numa_found=1;
+        kokkos_ndevices_found = 1;
         narg--;
-      } else if (!kokkos_numa_found && Impl::check_int_arg(arg[iarg], "--numa", &numa)) {
+      } else {
         iarg++;
-      } else if (Impl::check_int_arg(arg[iarg], "--kokkos-device", &device)) {
-        for(int k=iarg;k<narg-1;k++) {
-          arg[k] = arg[k+1];
+      }
+    } else if (strcmp(arg[iarg], "--kokkos-disable-warnings") == 0) {
+      disable_warnings = true;
+      for (int k = iarg; k < narg - 1; k++) {
+        arg[k] = arg[k + 1];
+      }
+      narg--;
+    } else if ((strcmp(arg[iarg], "--kokkos-help") == 0) ||
+               (strcmp(arg[iarg], "--help") == 0)) {
+      std::cout << std::endl;
+      std::cout << "-----------------------------------------------------------"
+                   "---------------------"
+                << std::endl;
+      std::cout << "-------------Kokkos command line "
+                   "arguments--------------------------------------"
+                << std::endl;
+      std::cout << "-----------------------------------------------------------"
+                   "---------------------"
+                << std::endl;
+      std::cout << "The following arguments exist also without prefix 'kokkos' "
+                   "(e.g. --help)."
+                << std::endl;
+      std::cout << "The prefixed arguments will be removed from the list by "
+                   "Kokkos::initialize(),"
+                << std::endl;
+      std::cout << "the non-prefixed ones are not removed. Prefixed versions "
+                   "take precedence over "
+                << std::endl;
+      std::cout << "non prefixed ones, and the last occurrence of an argument "
+                   "overwrites prior"
+                << std::endl;
+      std::cout << "settings." << std::endl;
+      std::cout << std::endl;
+      std::cout << "--kokkos-help               : print this message"
+                << std::endl;
+      std::cout
+          << "--kokkos-disable-warnings   : disable kokkos warning messages"
+          << std::endl;
+      std::cout
+          << "--kokkos-threads=INT        : specify total number of threads or"
+          << std::endl;
+      std::cout << "                              number of threads per NUMA "
+                   "region if "
+                << std::endl;
+      std::cout << "                              used in conjunction with "
+                   "'--numa' option. "
+                << std::endl;
+      std::cout << "--kokkos-numa=INT           : specify number of NUMA "
+                   "regions used by process."
+                << std::endl;
+      std::cout << "--kokkos-device=INT         : specify device id to be used "
+                   "by Kokkos. "
+                << std::endl;
+      std::cout << "--kokkos-ndevices=INT[,INT] : used when running MPI jobs. "
+                   "Specify number of"
+                << std::endl;
+      std::cout << "                              devices per node to be used. "
+                   "Process to device"
+                << std::endl;
+      std::cout << "                              mapping happens by obtaining "
+                   "the local MPI rank"
+                << std::endl;
+      std::cout << "                              and assigning devices "
+                   "round-robin. The optional"
+                << std::endl;
+      std::cout << "                              second argument allows for "
+                   "an existing device"
+                << std::endl;
+      std::cout << "                              to be ignored. This is most "
+                   "useful on workstations"
+                << std::endl;
+      std::cout << "                              with multiple GPUs of which "
+                   "one is used to drive"
+                << std::endl;
+      std::cout << "                              screen output." << std::endl;
+      std::cout << std::endl;
+      std::cout << "-----------------------------------------------------------"
+                   "---------------------"
+                << std::endl;
+      std::cout << std::endl;
+
+      // Remove the --kokkos-help argument from the list but leave --ndevices
+      if (strcmp(arg[iarg], "--kokkos-help") == 0) {
+        for (int k = iarg; k < narg - 1; k++) {
+          arg[k] = arg[k + 1];
         }
-        kokkos_device_found=1;
         narg--;
-      } else if (!kokkos_device_found && Impl::check_int_arg(arg[iarg], "--device", &device)) {
+      } else {
         iarg++;
-      } else if (Impl::check_arg(arg[iarg], "--kokkos-ndevices") || Impl::check_arg(arg[iarg], "--ndevices")) {
-
-        //Find the number of device (expecting --device=XX)
-        if (!((strncmp(arg[iarg],"--kokkos-ndevices=",18) == 0) || (strncmp(arg[iarg],"--ndevices=",11) == 0)))
-          Impl::throw_runtime_exception("Error: expecting an '=INT[,INT]' after command line argument '--ndevices/--kokkos-ndevices'. Raised by Kokkos::initialize(int narg, char* argc[]).");
-
-        char* num1 = strchr(arg[iarg],'=')+1;
-        char* num2 = strpbrk(num1,",");
-        int num1_len = num2==NULL?strlen(num1):num2-num1;
-        char* num1_only = new char[num1_len+1];
-        strncpy(num1_only,num1,num1_len);
-        num1_only[num1_len]=0;
-
-        if(!Impl::is_unsigned_int(num1_only) || (strlen(num1_only)==0)) {
-          Impl::throw_runtime_exception("Error: expecting an integer number after command line argument '--kokkos-ndevices'. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        }
-        if((strncmp(arg[iarg],"--kokkos-ndevices",17) == 0) || !kokkos_ndevices_found)
-          ndevices = atoi(num1_only);
-        delete [] num1_only;
-
-        if( num2 != NULL ) {
-          if(( !Impl::is_unsigned_int(num2+1) ) || (strlen(num2)==1) )
-            Impl::throw_runtime_exception("Error: expecting an integer number after command line argument '--kokkos-ndevices=XX,'. Raised by Kokkos::initialize(int narg, char* argc[]).");
-
-          if((strncmp(arg[iarg],"--kokkos-ndevices",17) == 0) || !kokkos_ndevices_found)
-            skip_device = atoi(num2+1);
-        }
-
-        //Remove the --kokkos-ndevices argument from the list but leave --ndevices
-        if(strncmp(arg[iarg],"--kokkos-ndevices",17) == 0) {
-          for(int k=iarg;k<narg-1;k++) {
-            arg[k] = arg[k+1];
-          }
-          kokkos_ndevices_found=1;
-          narg--;
-        } else {
-          iarg++;
-        }
-      } else if ( strcmp(arg[iarg],"--kokkos-disable-warnings") == 0) {
-        disable_warnings = true;
-        for(int k=iarg;k<narg-1;k++) {
-          arg[k] = arg[k+1];
-        }
-        narg--;
-      } else if ((strcmp(arg[iarg],"--kokkos-help") == 0) || (strcmp(arg[iarg],"--help") == 0)) {
-         std::cout << std::endl;
-         std::cout << "--------------------------------------------------------------------------------" << std::endl;
-         std::cout << "-------------Kokkos command line arguments--------------------------------------" << std::endl;
-         std::cout << "--------------------------------------------------------------------------------" << std::endl;
-         std::cout << "The following arguments exist also without prefix 'kokkos' (e.g. --help)." << std::endl;
-         std::cout << "The prefixed arguments will be removed from the list by Kokkos::initialize()," << std::endl;
-         std::cout << "the non-prefixed ones are not removed. Prefixed versions take precedence over " << std::endl;
-         std::cout << "non prefixed ones, and the last occurrence of an argument overwrites prior" << std::endl;
-         std::cout << "settings." << std::endl;
-         std::cout << std::endl;
-         std::cout << "--kokkos-help               : print this message" << std::endl;
-         std::cout << "--kokkos-disable-warnings   : disable kokkos warning messages" << std::endl;
-         std::cout << "--kokkos-threads=INT        : specify total number of threads or" << std::endl;
-         std::cout << "                              number of threads per NUMA region if " << std::endl;
-         std::cout << "                              used in conjunction with '--numa' option. " << std::endl;
-         std::cout << "--kokkos-numa=INT           : specify number of NUMA regions used by process." << std::endl;
-         std::cout << "--kokkos-device=INT         : specify device id to be used by Kokkos. " << std::endl;
-         std::cout << "--kokkos-ndevices=INT[,INT] : used when running MPI jobs. Specify number of" << std::endl;
-         std::cout << "                              devices per node to be used. Process to device" << std::endl;
-         std::cout << "                              mapping happens by obtaining the local MPI rank" << std::endl;
-         std::cout << "                              and assigning devices round-robin. The optional" << std::endl;
-         std::cout << "                              second argument allows for an existing device" << std::endl;
-         std::cout << "                              to be ignored. This is most useful on workstations" << std::endl;
-         std::cout << "                              with multiple GPUs of which one is used to drive" << std::endl;
-         std::cout << "                              screen output." << std::endl;
-         std::cout << std::endl;
-         std::cout << "--------------------------------------------------------------------------------" << std::endl;
-         std::cout << std::endl;
-
-         //Remove the --kokkos-help argument from the list but leave --ndevices
-         if(strcmp(arg[iarg],"--kokkos-help") == 0) {
-           for(int k=iarg;k<narg-1;k++) {
-             arg[k] = arg[k+1];
-           }
-           narg--;
-         } else {
-           iarg++;
-         }
-      } else
+      }
+    } else
       iarg++;
-    }
+  }
 
-    //Read environment variables
-    char * endptr;
-    auto env_num_threads_str = std::getenv("KOKKOS_NUM_THREADS");
-    if (env_num_threads_str!=nullptr) {
-        errno = 0;
-        auto env_num_threads = std::strtol(env_num_threads_str,&endptr,10);
-        if (endptr== env_num_threads_str) 
-            Impl::throw_runtime_exception("Error: cannot convert KOKKOS_NUM_THREADS to an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if (errno == ERANGE)
-            Impl::throw_runtime_exception("Error: KOKKOS_NUM_THREADS out of range of representable values by an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if ((num_threads != -1)&&(env_num_threads!=num_threads))
-            Impl::throw_runtime_exception("Error: expecting a match between --kokkos-threads and KOKKOS_NUM_THREADS if both are set. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        else
-            num_threads = env_num_threads;
+  // Read environment variables
+  char* endptr;
+  auto env_num_threads_str = std::getenv("KOKKOS_NUM_THREADS");
+  if (env_num_threads_str != nullptr) {
+    errno                = 0;
+    auto env_num_threads = std::strtol(env_num_threads_str, &endptr, 10);
+    if (endptr == env_num_threads_str)
+      Impl::throw_runtime_exception(
+          "Error: cannot convert KOKKOS_NUM_THREADS to an integer. Raised by "
+          "Kokkos::initialize(int narg, char* argc[]).");
+    if (errno == ERANGE)
+      Impl::throw_runtime_exception(
+          "Error: KOKKOS_NUM_THREADS out of range of representable values by "
+          "an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
+    if ((num_threads != -1) && (env_num_threads != num_threads))
+      Impl::throw_runtime_exception(
+          "Error: expecting a match between --kokkos-threads and "
+          "KOKKOS_NUM_THREADS if both are set. Raised by "
+          "Kokkos::initialize(int narg, char* argc[]).");
+    else
+      num_threads = env_num_threads;
+  }
+  auto env_numa_str = std::getenv("KOKKOS_NUMA");
+  if (env_numa_str != nullptr) {
+    errno         = 0;
+    auto env_numa = std::strtol(env_numa_str, &endptr, 10);
+    if (endptr == env_numa_str)
+      Impl::throw_runtime_exception(
+          "Error: cannot convert KOKKOS_NUMA to an integer. Raised by "
+          "Kokkos::initialize(int narg, char* argc[]).");
+    if (errno == ERANGE)
+      Impl::throw_runtime_exception(
+          "Error: KOKKOS_NUMA out of range of representable values by an "
+          "integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
+    if ((numa != -1) && (env_numa != numa))
+      Impl::throw_runtime_exception(
+          "Error: expecting a match between --kokkos-numa and KOKKOS_NUMA if "
+          "both are set. Raised by Kokkos::initialize(int narg, char* "
+          "argc[]).");
+    else
+      numa = env_numa;
+  }
+  auto env_device_str = std::getenv("KOKKOS_DEVICE_ID");
+  if (env_device_str != nullptr) {
+    errno           = 0;
+    auto env_device = std::strtol(env_device_str, &endptr, 10);
+    if (endptr == env_device_str)
+      Impl::throw_runtime_exception(
+          "Error: cannot convert KOKKOS_DEVICE_ID to an integer. Raised by "
+          "Kokkos::initialize(int narg, char* argc[]).");
+    if (errno == ERANGE)
+      Impl::throw_runtime_exception(
+          "Error: KOKKOS_DEVICE_ID out of range of representable values by an "
+          "integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
+    if ((device != -1) && (env_device != device))
+      Impl::throw_runtime_exception(
+          "Error: expecting a match between --kokkos-device and "
+          "KOKKOS_DEVICE_ID if both are set. Raised by Kokkos::initialize(int "
+          "narg, char* argc[]).");
+    else
+      device = env_device;
+  }
+  auto env_rdevices_str = std::getenv("KOKKOS_RAND_DEVICES");
+  auto env_ndevices_str = std::getenv("KOKKOS_NUM_DEVICES");
+  if (env_ndevices_str != nullptr || env_rdevices_str != nullptr) {
+    errno = 0;
+    if (env_ndevices_str != nullptr && env_rdevices_str != nullptr) {
+      Impl::throw_runtime_exception(
+          "Error: cannot specify both KOKKOS_NUM_DEVICES and "
+          "KOKKOS_RAND_DEVICES. "
+          "Raised by Kokkos::initialize(int narg, char* argc[]).");
     }
-    auto env_numa_str = std::getenv("KOKKOS_NUMA");
-    if (env_numa_str!=nullptr) {
-        errno = 0;
-        auto env_numa = std::strtol(env_numa_str,&endptr,10);
-        if (endptr== env_numa_str) 
-            Impl::throw_runtime_exception("Error: cannot convert KOKKOS_NUMA to an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if (errno == ERANGE)
-            Impl::throw_runtime_exception("Error: KOKKOS_NUMA out of range of representable values by an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if ((numa != -1)&&(env_numa!=numa))
-            Impl::throw_runtime_exception("Error: expecting a match between --kokkos-numa and KOKKOS_NUMA if both are set. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        else
-            numa = env_numa;
+    int rdevices = -1;
+    if (env_ndevices_str != nullptr) {
+      auto env_ndevices = std::strtol(env_ndevices_str, &endptr, 10);
+      if (endptr == env_ndevices_str)
+        Impl::throw_runtime_exception(
+            "Error: cannot convert KOKKOS_NUM_DEVICES to an integer. Raised by "
+            "Kokkos::initialize(int narg, char* argc[]).");
+      if (errno == ERANGE)
+        Impl::throw_runtime_exception(
+            "Error: KOKKOS_NUM_DEVICES out of range of representable values by "
+            "an integer. Raised by Kokkos::initialize(int narg, char* "
+            "argc[]).");
+      if ((ndevices != -1) && (env_ndevices != ndevices))
+        Impl::throw_runtime_exception(
+            "Error: expecting a match between --kokkos-ndevices and "
+            "KOKKOS_NUM_DEVICES if both are set. Raised by "
+            "Kokkos::initialize(int narg, char* argc[]).");
+      else
+        ndevices = env_ndevices;
+    } else {  // you set KOKKOS_RAND_DEVICES
+      auto env_rdevices = std::strtol(env_rdevices_str, &endptr, 10);
+      if (endptr == env_ndevices_str)
+        Impl::throw_runtime_exception(
+            "Error: cannot convert KOKKOS_RAND_DEVICES to an integer. Raised "
+            "by Kokkos::initialize(int narg, char* argc[]).");
+      if (errno == ERANGE)
+        Impl::throw_runtime_exception(
+            "Error: KOKKOS_RAND_DEVICES out of range of representable values "
+            "by an integer. Raised by Kokkos::initialize(int narg, char* "
+            "argc[]).");
+      else
+        rdevices = env_rdevices;
     }
-    auto env_device_str = std::getenv("KOKKOS_DEVICE_ID");
-    if (env_device_str!=nullptr) {
-        errno = 0;
-        auto env_device = std::strtol(env_device_str,&endptr,10);
-        if (endptr== env_device_str) 
-            Impl::throw_runtime_exception("Error: cannot convert KOKKOS_DEVICE_ID to an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if (errno == ERANGE)
-            Impl::throw_runtime_exception("Error: KOKKOS_DEVICE_ID out of range of representable values by an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if ((device != -1)&&(env_device!=device))
-            Impl::throw_runtime_exception("Error: expecting a match between --kokkos-device and KOKKOS_DEVICE_ID if both are set. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        else
-            device = env_device;
+    // Skip device
+    auto env_skip_device_str = std::getenv("KOKKOS_SKIP_DEVICE");
+    if (env_skip_device_str != nullptr) {
+      errno                = 0;
+      auto env_skip_device = std::strtol(env_skip_device_str, &endptr, 10);
+      if (endptr == env_skip_device_str)
+        Impl::throw_runtime_exception(
+            "Error: cannot convert KOKKOS_SKIP_DEVICE to an integer. Raised by "
+            "Kokkos::initialize(int narg, char* argc[]).");
+      if (errno == ERANGE)
+        Impl::throw_runtime_exception(
+            "Error: KOKKOS_SKIP_DEVICE out of range of representable values by "
+            "an integer. Raised by Kokkos::initialize(int narg, char* "
+            "argc[]).");
+      if ((skip_device != 9999) && (env_skip_device != skip_device))
+        Impl::throw_runtime_exception(
+            "Error: expecting a match between --kokkos-ndevices and "
+            "KOKKOS_SKIP_DEVICE if both are set. Raised by "
+            "Kokkos::initialize(int narg, char* argc[]).");
+      else
+        skip_device = env_skip_device;
     }
-    auto env_ndevices_str = std::getenv("KOKKOS_NUM_DEVICES");
-    if (env_ndevices_str!=nullptr) {
-        errno = 0;
-        auto env_ndevices = std::strtol(env_ndevices_str,&endptr,10);
-        if (endptr== env_ndevices_str) 
-            Impl::throw_runtime_exception("Error: cannot convert KOKKOS_NUM_DEVICES to an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if (errno == ERANGE)
-            Impl::throw_runtime_exception("Error: KOKKOS_NUM_DEVICES out of range of representable values by an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        if ((ndevices != -1)&&(env_ndevices!=ndevices))
-            Impl::throw_runtime_exception("Error: expecting a match between --kokkos-ndevices and KOKKOS_NUM_DEVICES if both are set. Raised by Kokkos::initialize(int narg, char* argc[]).");
-        else
-            ndevices = env_ndevices;
-        //Skip device
-        auto env_skip_device_str = std::getenv("KOKKOS_SKIP_DEVICE");
-        if (env_skip_device_str!=nullptr) {
-            errno = 0;
-            auto env_skip_device = std::strtol(env_skip_device_str,&endptr,10);
-            if (endptr== env_skip_device_str) 
-                Impl::throw_runtime_exception("Error: cannot convert KOKKOS_SKIP_DEVICE to an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-            if (errno == ERANGE)
-                Impl::throw_runtime_exception("Error: KOKKOS_SKIP_DEVICE out of range of representable values by an integer. Raised by Kokkos::initialize(int narg, char* argc[]).");
-            if ((skip_device != 9999)&&(env_skip_device!=skip_device))
-                Impl::throw_runtime_exception("Error: expecting a match between --kokkos-ndevices and KOKKOS_SKIP_DEVICE if both are set. Raised by Kokkos::initialize(int narg, char* argc[]).");
-            else
-                skip_device = env_skip_device;
-        }
+    if (rdevices > 0) {
+      if (skip_device > 0 && rdevices == 1)
+        Impl::throw_runtime_exception(
+            "Error: cannot KOKKOS_SKIP_DEVICE the only KOKKOS_RAND_DEVICE. "
+            "Raised by Kokkos::initialize(int narg, char* argc[]).");
+
+      std::srand(getpid());
+      while (device < 0) {
+        int test_device = std::rand() % rdevices;
+        if (test_device != skip_device) device = test_device;
+      }
     }
-    char * env_disablewarnings_str = std::getenv("KOKKOS_DISABLE_WARNINGS");
-    if (env_disablewarnings_str!=nullptr) {
-        std::string env_str (env_disablewarnings_str); // deep-copies string
-        for (char& c : env_str) { c = toupper (c); }
-        if ((env_str == "TRUE") || (env_str == "ON") || (env_str == "1"))
-            disable_warnings = true;
-        else
-            if (disable_warnings)
-                Impl::throw_runtime_exception("Error: expecting a match between --kokkos-disable-warnings and KOKKOS_DISABLE_WARNINGS if both are set. Raised by Kokkos::initialize(int narg, char* argc[]).");
+  }
+  char* env_disablewarnings_str = std::getenv("KOKKOS_DISABLE_WARNINGS");
+  if (env_disablewarnings_str != nullptr) {
+    std::string env_str(env_disablewarnings_str);  // deep-copies string
+    for (char& c : env_str) {
+      c = toupper(c);
     }
+    if ((env_str == "TRUE") || (env_str == "ON") || (env_str == "1"))
+      disable_warnings = true;
+    else if (disable_warnings)
+      Impl::throw_runtime_exception(
+          "Error: expecting a match between --kokkos-disable-warnings and "
+          "KOKKOS_DISABLE_WARNINGS if both are set. Raised by "
+          "Kokkos::initialize(int narg, char* argc[]).");
+  }
 
-    InitArguments arguments;
-    arguments.num_threads = num_threads;
-    arguments.num_numa = numa;
-    arguments.device_id = device;
-    arguments.ndevices = ndevices;
-    arguments.skip_device = skip_device;
-    arguments.disable_warnings = disable_warnings;
-    Impl::initialize_internal(arguments);
+  InitArguments arguments;
+  arguments.num_threads      = num_threads;
+  arguments.num_numa         = numa;
+  arguments.device_id        = device;
+  arguments.ndevices         = ndevices;
+  arguments.skip_device      = skip_device;
+  arguments.disable_warnings = disable_warnings;
+  Impl::initialize_internal(arguments);
 }
 
 void initialize(const InitArguments& arguments) {
   Impl::initialize_internal(arguments);
 }
 
-void push_finalize_hook(std::function<void()> f)
-{
-  finalize_hooks.push(f);
-}
+void push_finalize_hook(std::function<void()> f) { finalize_hooks.push(f); }
 
-void finalize()
-{
-  Impl::finalize_internal();
-}
+void finalize() { Impl::finalize_internal(); }
 
-void finalize_all()
-{
+void finalize_all() {
   enum { all_spaces = true };
-  Impl::finalize_internal( all_spaces );
+  Impl::finalize_internal(all_spaces);
 }
 
-void fence()
-{
-  Impl::fence_internal();
-}
+void fence() { Impl::fence_internal(); }
 
-void print_configuration( std::ostream & out , const bool detail )
-{
+void print_configuration(std::ostream& out, const bool detail) {
   std::ostringstream msg;
 
   msg << "Compiler:" << std::endl;
@@ -708,7 +859,6 @@ void print_configuration( std::ostream & out , const bool detail )
   msg << "  KOKKOS_COMPILER_PGI: " << KOKKOS_COMPILER_PGI << std::endl;
 #endif
 
-
   msg << "Architecture:" << std::endl;
 #ifdef KOKKOS_ENABLE_ISA_KNC
   msg << "  KOKKOS_ENABLE_ISA_KNC: yes" << std::endl;
@@ -726,7 +876,6 @@ void print_configuration( std::ostream & out , const bool detail )
   msg << "  KOKKOS_ENABLE_ISA_X86_64: no" << std::endl;
 #endif
 
-
   msg << "Devices:" << std::endl;
   msg << "  KOKKOS_ENABLE_CUDA: ";
 #ifdef KOKKOS_ENABLE_CUDA
@@ -765,7 +914,6 @@ void print_configuration( std::ostream & out , const bool detail )
   msg << "no" << std::endl;
 #endif
 
-
   msg << "Default Device:" << std::endl;
   msg << "  KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA: ";
 #ifdef KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA
@@ -798,7 +946,6 @@ void print_configuration( std::ostream & out , const bool detail )
   msg << "no" << std::endl;
 #endif
 
-
   msg << "Atomics:" << std::endl;
   msg << "  KOKKOS_ENABLE_CUDA_ATOMICS: ";
 #ifdef KOKKOS_ENABLE_CUDA_ATOMICS
@@ -889,7 +1036,6 @@ void print_configuration( std::ostream & out , const bool detail )
   msg << "no" << std::endl;
 #endif
 
-
   msg << "Options:" << std::endl;
   msg << "  KOKKOS_ENABLE_ASM: ";
 #ifdef KOKKOS_ENABLE_ASM
@@ -997,7 +1143,7 @@ void print_configuration( std::ostream & out , const bool detail )
 #ifdef KOKKOS_ENABLE_HPX
   Experimental::HPX::print_configuration(msg, detail);
 #endif
-#if defined( KOKKOS_ENABLE_THREADS )
+#if defined(KOKKOS_ENABLE_THREADS)
   Threads::print_configuration(msg, detail);
 #endif
 #ifdef KOKKOS_ENABLE_QTHREADS
@@ -1014,5 +1160,13 @@ bool is_initialized() noexcept { return g_is_initialized; }
 
 bool show_warnings() noexcept { return g_show_warnings; }
 
-} // namespace Kokkos
+#ifdef KOKKOS_COMPILER_PGI
+namespace Impl {
+// Bizzarely, an extra jump instruction forces the PGI compiler to not have a
+// bug related to (probably?) empty base optimization and/or aggregate
+// construction.
+void _kokkos_pgi_compiler_bug_workaround() {}
+}  // end namespace Impl
+#endif
 
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_EBO.hpp b/lib/kokkos/core/src/impl/Kokkos_EBO.hpp
index 69bb74e2c5fcabb3d8c7c4975980c705bad2b6fb..5adf4bd5f16c9665eaf684854358ee8afd0c9c92 100644
--- a/lib/kokkos/core/src/impl/Kokkos_EBO.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_EBO.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,7 +52,6 @@
 #include <Kokkos_Core_fwd.hpp>
 //----------------------------------------------------------------------------
 
-
 #include <utility>
 #include <type_traits>
 
@@ -62,23 +62,23 @@ namespace Kokkos {
 namespace Impl {
 
 template <int I>
-struct NotOnDeviceCtorDisambiguator { };
+struct NotOnDeviceCtorDisambiguator {};
 
 template <class... Args>
-struct NoCtorsNotOnDevice : std::false_type { };
+struct NoCtorsNotOnDevice : std::false_type {};
 
 template <class... Args>
-struct DefaultCtorNotOnDevice : std::false_type { };
+struct DefaultCtorNotOnDevice : std::false_type {};
 
 template <>
-struct DefaultCtorNotOnDevice<> : std::true_type { };
+struct DefaultCtorNotOnDevice<> : std::true_type {};
 
-template <class T, bool Empty, template <class...> class CtorNotOnDevice = NoCtorsNotOnDevice>
+template <class T, bool Empty,
+          template <class...> class CtorNotOnDevice = NoCtorsNotOnDevice>
 struct EBOBaseImpl;
 
 template <class T, template <class...> class CtorNotOnDevice>
 struct EBOBaseImpl<T, true, CtorNotOnDevice> {
-
   /*
    * Workaround for constexpr in C++11: we need to still call T(args...), but we
    * can't do so in the body of a constexpr function (in C++11), and there's no
@@ -86,48 +86,36 @@ struct EBOBaseImpl<T, true, CtorNotOnDevice> {
    * of a delegating constructor...
    */
   // TODO @minor DSH the destructor gets called too early with this workaround
-  struct _constexpr_14_workaround_tag { };
-  struct _constexpr_14_workaround_no_device_tag { };
+  struct _constexpr_14_workaround_tag {};
+  struct _constexpr_14_workaround_no_device_tag {};
   KOKKOS_FORCEINLINE_FUNCTION
-  constexpr EBOBaseImpl(_constexpr_14_workaround_tag, T&&) noexcept { }
-  inline constexpr EBOBaseImpl(_constexpr_14_workaround_no_device_tag, T&&) noexcept { }
+  constexpr EBOBaseImpl(_constexpr_14_workaround_tag, T&&) noexcept {}
+  inline constexpr EBOBaseImpl(_constexpr_14_workaround_no_device_tag,
+                               T&&) noexcept {}
 
   template <
-    class... Args,
-    class _ignored = void,
-    typename std::enable_if<
-      std::is_void<_ignored>::value
-      && std::is_constructible<T, Args...>::value
-      && !CtorNotOnDevice<Args...>::value,
-      int
-    >::type = 0
-  >
-  KOKKOS_FORCEINLINE_FUNCTION
-  constexpr explicit
-  EBOBaseImpl(
-    Args&&... args
-  ) noexcept(noexcept(T(std::forward<Args>(args)...)))
-    // still call the constructor
-    : EBOBaseImpl(_constexpr_14_workaround_tag{}, T(std::forward<Args>(args)...))
-  { }
+      class... Args, class _ignored = void,
+      typename std::enable_if<std::is_void<_ignored>::value &&
+                                  std::is_constructible<T, Args...>::value &&
+                                  !CtorNotOnDevice<Args...>::value,
+                              int>::type = 0>
+  KOKKOS_FORCEINLINE_FUNCTION constexpr explicit EBOBaseImpl(
+      Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
+      // still call the constructor
+      : EBOBaseImpl(_constexpr_14_workaround_tag{},
+                    T(std::forward<Args>(args)...)) {}
 
   template <
-    class... Args,
-    class _ignored=void,
-    typename std::enable_if<
-      std::is_void<_ignored>::value
-      && std::is_constructible<T, Args...>::value
-      && CtorNotOnDevice<Args...>::value,
-      long
-    >::type = 0
-  >
-  inline constexpr explicit
-  EBOBaseImpl(
-    Args&&... args
-  ) noexcept(noexcept(T(std::forward<Args>(args)...)))
-    // still call the constructor
-    : EBOBaseImpl(_constexpr_14_workaround_no_device_tag{}, T(std::forward<Args>(args)...))
-  { }
+      class... Args, class _ignored = void,
+      typename std::enable_if<std::is_void<_ignored>::value &&
+                                  std::is_constructible<T, Args...>::value &&
+                                  CtorNotOnDevice<Args...>::value,
+                              long>::type = 0>
+  inline constexpr explicit EBOBaseImpl(Args&&... args) noexcept(
+      noexcept(T(std::forward<Args>(args)...)))
+      // still call the constructor
+      : EBOBaseImpl(_constexpr_14_workaround_no_device_tag{},
+                    T(std::forward<Args>(args)...)) {}
 
   KOKKOS_FORCEINLINE_FUNCTION
   constexpr EBOBaseImpl(EBOBaseImpl const&) = default;
@@ -148,85 +136,59 @@ struct EBOBaseImpl<T, true, CtorNotOnDevice> {
 
   KOKKOS_INLINE_FUNCTION
   KOKKOS_CONSTEXPR_14
-  T& _ebo_data_member() & {
-    return *reinterpret_cast<T*>(this);
-  }
+  T& _ebo_data_member() & { return *reinterpret_cast<T*>(this); }
 
   KOKKOS_INLINE_FUNCTION
-  constexpr
-  T const& _ebo_data_member() const & {
+  constexpr T const& _ebo_data_member() const& {
     return *reinterpret_cast<T const*>(this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  T volatile& _ebo_data_member() volatile & {
+  T volatile& _ebo_data_member() volatile& {
     return *reinterpret_cast<T volatile*>(this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  T const volatile& _ebo_data_member() const volatile & {
+  T const volatile& _ebo_data_member() const volatile& {
     return *reinterpret_cast<T const volatile*>(this);
   }
 
   KOKKOS_INLINE_FUNCTION
   KOKKOS_CONSTEXPR_14
-  T&& _ebo_data_member() && {
-    return std::move(*reinterpret_cast<T*>(this));
-  }
-
+  T&& _ebo_data_member() && { return std::move(*reinterpret_cast<T*>(this)); }
 };
 
 template <class T, template <class...> class CTorsNotOnDevice>
 struct EBOBaseImpl<T, false, CTorsNotOnDevice> {
-
   T m_ebo_object;
 
   template <
-    class... Args,
-    class _ignored=void,
-    typename std::enable_if<
-      std::is_void<_ignored>::value
-        && !CTorsNotOnDevice<Args...>::value
-        && std::is_constructible<T, Args...>::value,
-      int
-    >::type = 0
-  >
-  KOKKOS_FORCEINLINE_FUNCTION
-  constexpr explicit
-  EBOBaseImpl(
-    Args&&... args
-  ) noexcept(noexcept(T(std::forward<Args>(args)...)))
-    : m_ebo_object(std::forward<Args>(args)...)
-  { }
+      class... Args, class _ignored = void,
+      typename std::enable_if<std::is_void<_ignored>::value &&
+                                  !CTorsNotOnDevice<Args...>::value &&
+                                  std::is_constructible<T, Args...>::value,
+                              int>::type = 0>
+  KOKKOS_FORCEINLINE_FUNCTION constexpr explicit EBOBaseImpl(
+      Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
+      : m_ebo_object(std::forward<Args>(args)...) {}
 
   template <
-    class... Args,
-    class _ignored=void,
-    typename std::enable_if<
-      std::is_void<_ignored>::value
-        && CTorsNotOnDevice<Args...>::value
-        && std::is_constructible<T, Args...>::value,
-      long
-    >::type = 0
-  >
-  inline
-  constexpr explicit
-  EBOBaseImpl(
-    Args&&... args
-  ) noexcept(noexcept(T(std::forward<Args>(args)...)))
-    : m_ebo_object(std::forward<Args>(args)...)
-  { }
-
+      class... Args, class _ignored = void,
+      typename std::enable_if<std::is_void<_ignored>::value &&
+                                  CTorsNotOnDevice<Args...>::value &&
+                                  std::is_constructible<T, Args...>::value,
+                              long>::type = 0>
+  inline constexpr explicit EBOBaseImpl(Args&&... args) noexcept(
+      noexcept(T(std::forward<Args>(args)...)))
+      : m_ebo_object(std::forward<Args>(args)...) {}
 
   // TODO @tasking @minor DSH noexcept in the right places?
 
   KOKKOS_FORCEINLINE_FUNCTION
-  constexpr
-  EBOBaseImpl(EBOBaseImpl const&) = default;
+  constexpr EBOBaseImpl(EBOBaseImpl const&) = default;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  constexpr
-  EBOBaseImpl(EBOBaseImpl&&) noexcept = default;
+  constexpr EBOBaseImpl(EBOBaseImpl&&) noexcept = default;
 
   KOKKOS_FORCEINLINE_FUNCTION
   KOKKOS_CONSTEXPR_14
@@ -240,46 +202,33 @@ struct EBOBaseImpl<T, false, CTorsNotOnDevice> {
   ~EBOBaseImpl() = default;
 
   KOKKOS_INLINE_FUNCTION
-  T& _ebo_data_member() & {
-    return m_ebo_object;
-  }
+  T& _ebo_data_member() & { return m_ebo_object; }
 
   KOKKOS_INLINE_FUNCTION
-  T const& _ebo_data_member() const & {
-    return m_ebo_object;
-  }
+  T const& _ebo_data_member() const& { return m_ebo_object; }
 
   KOKKOS_INLINE_FUNCTION
-  T volatile& _ebo_data_member() volatile & {
-    return m_ebo_object;
-  }
+  T volatile& _ebo_data_member() volatile& { return m_ebo_object; }
 
   KOKKOS_INLINE_FUNCTION
-  T const volatile& _ebo_data_member() const volatile & {
-    return m_ebo_object;
-  }
+  T const volatile& _ebo_data_member() const volatile& { return m_ebo_object; }
 
   KOKKOS_INLINE_FUNCTION
-  T&& _ebo_data_member() && {
-    return m_ebo_object;
-  }
-
+  T&& _ebo_data_member() && { return m_ebo_object; }
 };
 
 /**
  *
  * @tparam T
  */
-template <class T, template <class...> class CtorsNotOnDevice=NoCtorsNotOnDevice>
+template <class T,
+          template <class...> class CtorsNotOnDevice = NoCtorsNotOnDevice>
 struct StandardLayoutNoUniqueAddressMemberEmulation
-  : EBOBaseImpl<T, std::is_empty<T>::value, CtorsNotOnDevice>
-{
-private:
-
+    : EBOBaseImpl<T, std::is_empty<T>::value, CtorsNotOnDevice> {
+ private:
   using ebo_base_t = EBOBaseImpl<T, std::is_empty<T>::value, CtorsNotOnDevice>;
 
-public:
-
+ public:
   using ebo_base_t::ebo_base_t;
 
   KOKKOS_FORCEINLINE_FUNCTION
@@ -289,18 +238,17 @@ public:
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  constexpr
-  T const& no_unique_address_data_member() const & {
+  constexpr T const& no_unique_address_data_member() const& {
     return this->ebo_base_t::_ebo_data_member();
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  T volatile& no_unique_address_data_member() volatile & {
+  T volatile& no_unique_address_data_member() volatile& {
     return this->ebo_base_t::_ebo_data_member();
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  T const volatile& no_unique_address_data_member() const volatile & {
+  T const volatile& no_unique_address_data_member() const volatile& {
     return this->ebo_base_t::_ebo_data_member();
   }
 
@@ -315,29 +263,24 @@ public:
  *
  * @tparam T
  */
-template <class T, template <class...> class CtorsNotOnDevice=NoCtorsNotOnDevice>
+template <class T,
+          template <class...> class CtorsNotOnDevice = NoCtorsNotOnDevice>
 class NoUniqueAddressMemberEmulation
-  : private StandardLayoutNoUniqueAddressMemberEmulation<T, CtorsNotOnDevice>
-{
-private:
-
-  using base_t = StandardLayoutNoUniqueAddressMemberEmulation<T, CtorsNotOnDevice>;
-
-public:
+    : private StandardLayoutNoUniqueAddressMemberEmulation<T,
+                                                           CtorsNotOnDevice> {
+ private:
+  using base_t =
+      StandardLayoutNoUniqueAddressMemberEmulation<T, CtorsNotOnDevice>;
 
+ public:
   using base_t::base_t;
   using base_t::no_unique_address_data_member;
-
 };
 
-
-} // end namespace Impl
-} // end namespace Kokkos
-
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
 #endif /* #ifndef KOKKOS_EBO_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Error.cpp b/lib/kokkos/core/src/impl/Kokkos_Error.cpp
index dea856606c938e4f04594e5ec3b11bd714e925c8..817c9a0581c26595d4ad41e899b128680c8917db 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Error.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Error.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,28 +58,24 @@
 namespace Kokkos {
 namespace Impl {
 
-void host_abort( const char * const message )
-{
-  fwrite(message,1,strlen(message),stderr);
+void host_abort(const char *const message) {
+  fwrite(message, 1, strlen(message), stderr);
   fflush(stderr);
   ::abort();
 }
 
-void throw_runtime_exception( const std::string & msg )
-{
-  std::ostringstream o ;
-  o << msg ;
-  traceback_callstack( o );
-  throw std::runtime_error( o.str() );
+void throw_runtime_exception(const std::string &msg) {
+  std::ostringstream o;
+  o << msg;
+  traceback_callstack(o);
+  throw std::runtime_error(o.str());
 }
 
-
-std::string human_memory_size(size_t arg_bytes)
-{
-  double bytes = arg_bytes;
+std::string human_memory_size(size_t arg_bytes) {
+  double bytes   = arg_bytes;
   const double K = 1024;
-  const double M = K*1024;
-  const double G = M*1024;
+  const double M = K * 1024;
+  const double G = M * 1024;
 
   std::ostringstream out;
   if (bytes < K) {
@@ -96,99 +93,65 @@ std::string human_memory_size(size_t arg_bytes)
   return out.str();
 }
 
-}
-}
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#if defined( __GNUC__ ) && defined( ENABLE_TRACEBACK )
-
-/*  This is only known to work with GNU C++
- *  Must be compiled with '-rdynamic'
- *  Must be linked with   '-ldl'
- */
-
-/* Print call stack into an error stream,
- * so one knows in which function the error occurred.
- *
- * Code copied from:
- *   http://stupefydeveloper.blogspot.com/2008/10/cc-call-stack.html
- *
- * License on this site:
- *   This blog is licensed under a
- *   Creative Commons Attribution-Share Alike 3.0 Unported License.
- *
- *   http://creativecommons.org/licenses/by-sa/3.0/
- *
- * Modified to output to std::ostream.
- */
-#include <signal.h>
-#include <execinfo.h>
-#include <cxxabi.h>
-#include <dlfcn.h>
-
-#include <cstdlib>
-
-namespace Kokkos {
-namespace Impl {
-
-void traceback_callstack( std::ostream & msg )
-{
-  using namespace abi;
-
-  enum { MAX_DEPTH = 32 };
-
-  void *trace[MAX_DEPTH];
-  Dl_info dlinfo;
-
-  int status;
-
-  int trace_size = backtrace(trace, MAX_DEPTH);
-
-  msg << std::endl << "Call stack {" << std::endl ;
-
-  for (int i=1; i<trace_size; ++i)
-  {
-    if(!dladdr(trace[i], &dlinfo))
-        continue;
-
-    const char * symname = dlinfo.dli_sname;
-
-    char * demangled = __cxa_demangle(symname, NULL, 0, &status);
-
-    if ( status == 0 && demangled ) {
-      symname = demangled;
-    }
-
-    if ( symname && *symname != 0 ) {
-      msg << "  object: " << dlinfo.dli_fname
-          << " function: " << symname
-          << std::endl ;
-    }
-
-    if ( demangled ) {
-        free(demangled);
-    }
+}  // namespace Impl
+
+void Experimental::RawMemoryAllocationFailure::print_error_message(
+    std::ostream &o) const {
+  o << "Allocation of size " << Impl::human_memory_size(m_attempted_size);
+  o << " failed";
+  switch (m_failure_mode) {
+    case FailureMode::OutOfMemoryError:
+      o << ", likely due to insufficient memory.";
+      break;
+    case FailureMode::AllocationNotAligned:
+      o << " because the allocation was improperly aligned.";
+      break;
+    case FailureMode::InvalidAllocationSize:
+      o << " because the requested allocation size is not a valid size for the"
+           " requested allocation mechanism (it's probably too large).";
+      break;
+    // TODO move this to the subclass for Cuda-related things
+    case FailureMode::MaximumCudaUVMAllocationsExceeded:
+      o << " because the maximum Cuda UVM allocations was exceeded.";
+      break;
+    case FailureMode::Unknown: o << " because of an unknown error."; break;
+  }
+  o << "  (The allocation mechanism was ";
+  switch (m_mechanism) {
+    case AllocationMechanism::StdMalloc: o << "standard malloc()."; break;
+    case AllocationMechanism::PosixMemAlign: o << "posix_memalign()."; break;
+    case AllocationMechanism::PosixMMap: o << "POSIX mmap()."; break;
+    case AllocationMechanism::IntelMMAlloc:
+      o << "the Intel _mm_malloc() intrinsic.";
+      break;
+    case AllocationMechanism::CudaMalloc: o << "cudaMalloc()."; break;
+    case AllocationMechanism::CudaMallocManaged:
+      o << "cudaMallocManaged().";
+      break;
+    case AllocationMechanism::CudaHostAlloc: o << "cudaHostAlloc()."; break;
   }
-  msg << "}" ;
+  append_additional_error_information(o);
+  o << ")" << std::endl;
 }
 
+std::string Experimental::RawMemoryAllocationFailure::get_error_message()
+    const {
+  std::ostringstream out;
+  print_error_message(out);
+  return out.str();
 }
-}
 
-#else
+}  // namespace Kokkos
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-void traceback_callstack( std::ostream & msg )
-{
-  msg << std::endl << "Traceback functionality not available" << std::endl ;
+void traceback_callstack(std::ostream &msg) {
+  msg << std::endl << "Traceback functionality not available" << std::endl;
 }
 
-}
-}
-
-#endif
-
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_Error.hpp b/lib/kokkos/core/src/impl/Kokkos_Error.hpp
index 3d634fe5d14e7a0ebe7de0e5cc39dddb90d2df72..44f77710426ab100aa3492a10da7583981828494 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Error.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Error.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -52,87 +53,167 @@
 #endif
 
 #ifndef KOKKOS_ABORT_MESSAGE_BUFFER_SIZE
-#  define KOKKOS_ABORT_MESSAGE_BUFFER_SIZE 2048
-#endif // ifndef KOKKOS_ABORT_MESSAGE_BUFFER_SIZE
+#define KOKKOS_ABORT_MESSAGE_BUFFER_SIZE 2048
+#endif  // ifndef KOKKOS_ABORT_MESSAGE_BUFFER_SIZE
 
 namespace Kokkos {
 namespace Impl {
 
-void host_abort( const char * const );
+void host_abort(const char *const);
 
-void throw_runtime_exception( const std::string & );
+void throw_runtime_exception(const std::string &);
 
-void traceback_callstack( std::ostream & );
+void traceback_callstack(std::ostream &);
 
 std::string human_memory_size(size_t arg_bytes);
 
-}
-}
+}  // namespace Impl
+
+namespace Experimental {
+
+class RawMemoryAllocationFailure : public std::bad_alloc {
+ public:
+  enum class FailureMode {
+    OutOfMemoryError,
+    AllocationNotAligned,
+    InvalidAllocationSize,
+    MaximumCudaUVMAllocationsExceeded,
+    Unknown
+  };
+  enum class AllocationMechanism {
+    StdMalloc,
+    PosixMemAlign,
+    PosixMMap,
+    IntelMMAlloc,
+    CudaMalloc,
+    CudaMallocManaged,
+    CudaHostAlloc
+  };
+
+ private:
+  size_t m_attempted_size;
+  size_t m_attempted_alignment;
+  FailureMode m_failure_mode;
+  AllocationMechanism m_mechanism;
+
+ public:
+  RawMemoryAllocationFailure(
+      size_t arg_attempted_size, size_t arg_attempted_alignment,
+      FailureMode arg_failure_mode = FailureMode::OutOfMemoryError,
+      AllocationMechanism arg_mechanism =
+          AllocationMechanism::StdMalloc) noexcept
+      : m_attempted_size(arg_attempted_size),
+        m_attempted_alignment(arg_attempted_alignment),
+        m_failure_mode(arg_failure_mode),
+        m_mechanism(arg_mechanism) {}
+
+  RawMemoryAllocationFailure() noexcept = delete;
+
+  RawMemoryAllocationFailure(RawMemoryAllocationFailure const &) noexcept =
+      default;
+  RawMemoryAllocationFailure(RawMemoryAllocationFailure &&) noexcept = default;
+
+  RawMemoryAllocationFailure &operator             =(
+      RawMemoryAllocationFailure const &) noexcept = default;
+  RawMemoryAllocationFailure &operator             =(
+      RawMemoryAllocationFailure &&) noexcept = default;
+
+  ~RawMemoryAllocationFailure() noexcept override = default;
+
+  KOKKOS_ATTRIBUTE_NODISCARD
+  const char *what() const noexcept override {
+    if (m_failure_mode == FailureMode::OutOfMemoryError) {
+      return "Memory allocation error: out of memory";
+    } else if (m_failure_mode == FailureMode::OutOfMemoryError) {
+      return "Memory allocation error: allocation result was under-aligned";
+    }
+
+    return nullptr;  // unreachable
+  }
+
+  KOKKOS_ATTRIBUTE_NODISCARD
+  size_t attempted_size() const noexcept { return m_attempted_size; }
+
+  KOKKOS_ATTRIBUTE_NODISCARD
+  size_t attempted_alignment() const noexcept { return m_attempted_alignment; }
+
+  KOKKOS_ATTRIBUTE_NODISCARD
+  AllocationMechanism allocation_mechanism() const noexcept {
+    return m_mechanism;
+  }
+
+  KOKKOS_ATTRIBUTE_NODISCARD
+  FailureMode failure_mode() const noexcept { return m_failure_mode; }
+
+  void print_error_message(std::ostream &o) const;
+  KOKKOS_ATTRIBUTE_NODISCARD
+  std::string get_error_message() const;
+
+  virtual void append_additional_error_information(std::ostream &) const {}
+};
+
+}  // end namespace Experimental
+
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
 namespace Kokkos {
 KOKKOS_INLINE_FUNCTION
-void abort( const char * const message ) {
+void abort(const char *const message) {
 #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__)
   Kokkos::Impl::cuda_abort(message);
 #else
-  #if !defined(KOKKOS_ENABLE_OPENMPTARGET) && !defined(__HCC_ACCELERATOR__)
-    Kokkos::Impl::host_abort(message);
-  #endif
+#if !defined(KOKKOS_ENABLE_OPENMPTARGET) && !defined(__HCC_ACCELERATOR__)
+  Kokkos::Impl::host_abort(message);
+#endif
 #endif
 }
 
-}
-
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
-#if !defined(NDEBUG) || defined(KOKKOS_ENFORCE_CONTRACTS) || defined(KOKKOS_DEBUG)
-#  define KOKKOS_EXPECTS(...) \
-  { \
-    if(!bool(__VA_ARGS__)) { \
-      ::Kokkos::abort( \
-        "Kokkos contract violation:\n  " \
-        "  Expected precondition `" #__VA_ARGS__ "` evaluated false." \
-      ); \
-    } \
+#if !defined(NDEBUG) || defined(KOKKOS_ENFORCE_CONTRACTS) || \
+    defined(KOKKOS_DEBUG)
+#define KOKKOS_EXPECTS(...)                                               \
+  {                                                                       \
+    if (!bool(__VA_ARGS__)) {                                             \
+      ::Kokkos::abort(                                                    \
+          "Kokkos contract violation:\n  "                                \
+          "  Expected precondition `" #__VA_ARGS__ "` evaluated false."); \
+    }                                                                     \
   }
-#  define KOKKOS_ENSURES(...) \
-  { \
-    if(!bool(__VA_ARGS__)) { \
-      ::Kokkos::abort( \
-        "Kokkos contract violation:\n  " \
-        "  Ensured postcondition `" #__VA_ARGS__ "` evaluated false." \
-      ); \
-    } \
+#define KOKKOS_ENSURES(...)                                               \
+  {                                                                       \
+    if (!bool(__VA_ARGS__)) {                                             \
+      ::Kokkos::abort(                                                    \
+          "Kokkos contract violation:\n  "                                \
+          "  Ensured postcondition `" #__VA_ARGS__ "` evaluated false."); \
+    }                                                                     \
   }
 // some projects already define this for themselves, so don't mess them up
-#  ifndef KOKKOS_ASSERT
-#    define KOKKOS_ASSERT(...) \
-  { \
-    if(!bool(__VA_ARGS__)) { \
-      ::Kokkos::abort( \
-        "Kokkos contract violation:\n  " \
-        "  Asserted condition `" #__VA_ARGS__ "` evaluated false." \
-      ); \
-    } \
+#ifndef KOKKOS_ASSERT
+#define KOKKOS_ASSERT(...)                                             \
+  {                                                                    \
+    if (!bool(__VA_ARGS__)) {                                          \
+      ::Kokkos::abort(                                                 \
+          "Kokkos contract violation:\n  "                             \
+          "  Asserted condition `" #__VA_ARGS__ "` evaluated false."); \
+    }                                                                  \
   }
-#  endif // ifndef KOKKOS_ASSERT
-#else // not debug mode
-#  define KOKKOS_EXPECTS(...)
-#  define KOKKOS_ENSURES(...)
-#  ifndef KOKKOS_ASSERT
-#    define KOKKOS_ASSERT(...)
-#  endif // ifndef KOKKOS_ASSERT
-#endif // end debug mode ifdefs
+#endif  // ifndef KOKKOS_ASSERT
+#else   // not debug mode
+#define KOKKOS_EXPECTS(...)
+#define KOKKOS_ENSURES(...)
+#ifndef KOKKOS_ASSERT
+#define KOKKOS_ASSERT(...)
+#endif  // ifndef KOKKOS_ASSERT
+#endif  // end debug mode ifdefs
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_IMPL_ERROR_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ExecPolicy.cpp b/lib/kokkos/core/src/impl/Kokkos_ExecPolicy.cpp
index 72ba5156136e6ddc460d36d65af8a27e3317561d..eada15fe9984bf13f24858a2ea875a21856737b9 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ExecPolicy.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ExecPolicy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,20 +45,15 @@
 #include <Kokkos_Core.hpp>
 namespace Kokkos {
 namespace Impl {
-    PerTeamValue::PerTeamValue(int arg):value(arg) {}
+PerTeamValue::PerTeamValue(int arg) : value(arg) {}
 
-    PerThreadValue::PerThreadValue(int arg):value(arg) {}
-}
+PerThreadValue::PerThreadValue(int arg) : value(arg) {}
+}  // namespace Impl
 
-Impl::PerTeamValue PerTeam(const int& arg)
-{
-  return Impl::PerTeamValue(arg);
-}
+Impl::PerTeamValue PerTeam(const int& arg) { return Impl::PerTeamValue(arg); }
 
-Impl::PerThreadValue PerThread(const int& arg)
-{
+Impl::PerThreadValue PerThread(const int& arg) {
   return Impl::PerThreadValue(arg);
 }
 
-}
-
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_FixedBufferMemoryPool.hpp b/lib/kokkos/core/src/impl/Kokkos_FixedBufferMemoryPool.hpp
index 3053d8d9d0d9341a1babde3379270ea063891b55..a304e8eff26ac8d62373d007ffe2c3c31d41310b 100644
--- a/lib/kokkos/core/src/impl/Kokkos_FixedBufferMemoryPool.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_FixedBufferMemoryPool.hpp
@@ -2,10 +2,10 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
+//                        Kokkos v. 3.0
 //              Copyright (2019) Sandia Corporation
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,69 +53,64 @@
 namespace Kokkos {
 namespace Impl {
 
-template <
-  class DeviceType,
-  size_t Size,
-  size_t Align=1,
-  class SizeType = typename DeviceType::execution_space::size_type
->
+template <class DeviceType, size_t Size, size_t Align = 1,
+          class SizeType = typename DeviceType::execution_space::size_type>
 class FixedBlockSizeMemoryPool
-  : private MemorySpaceInstanceStorage<typename DeviceType::memory_space>
-{
-public:
-
+    : private MemorySpaceInstanceStorage<typename DeviceType::memory_space> {
+ public:
   using memory_space = typename DeviceType::memory_space;
-  using size_type = SizeType;
+  using size_type    = SizeType;
 
-private:
-
-  using memory_space_storage_base = MemorySpaceInstanceStorage<typename DeviceType::memory_space>;
+ private:
+  using memory_space_storage_base =
+      MemorySpaceInstanceStorage<typename DeviceType::memory_space>;
   using tracker_type = Kokkos::Impl::SharedAllocationTracker;
-  using record_type = Kokkos::Impl::SharedAllocationRecord<memory_space>;
+  using record_type  = Kokkos::Impl::SharedAllocationRecord<memory_space>;
 
-  struct alignas(Align) Block { union { char ignore; char data[Size]; }; };
+  struct alignas(Align) Block {
+    union {
+      char ignore;
+      char data[Size];
+    };
+  };
 
   static constexpr auto actual_size = sizeof(Block);
 
   // TODO shared allocation tracker
-  // TODO @optimization put the index values on different cache lines (CPU) or pages (GPU)?
-
-  tracker_type m_tracker = { };
-  size_type m_num_blocks = 0;
-  size_type m_first_free_idx = 0;
-  size_type m_last_free_idx = 0;
-  Kokkos::OwningRawPtr<Block> m_first_block = nullptr;
+  // TODO @optimization put the index values on different cache lines (CPU) or
+  // pages (GPU)?
+
+  tracker_type m_tracker                         = {};
+  size_type m_num_blocks                         = 0;
+  size_type m_first_free_idx                     = 0;
+  size_type m_last_free_idx                      = 0;
+  Kokkos::OwningRawPtr<Block> m_first_block      = nullptr;
   Kokkos::OwningRawPtr<size_type> m_free_indices = nullptr;
 
   enum : size_type { IndexInUse = ~size_type(0) };
 
-public:
-
-  FixedBlockSizeMemoryPool(
-    memory_space const& mem_space,
-    size_type num_blocks
-  ) : memory_space_storage_base(mem_space),
-      m_tracker(),
-      m_num_blocks(num_blocks),
-      m_first_free_idx(0),
-      m_last_free_idx(num_blocks)
-  {
+ public:
+  FixedBlockSizeMemoryPool(memory_space const& mem_space, size_type num_blocks)
+      : memory_space_storage_base(mem_space),
+        m_tracker(),
+        m_num_blocks(num_blocks),
+        m_first_free_idx(0),
+        m_last_free_idx(num_blocks) {
     // TODO alignment?
     auto block_record = record_type::allocate(
-      mem_space, "FixedBlockSizeMemPool_blocks", num_blocks * sizeof(Block)
-    );
+        mem_space, "FixedBlockSizeMemPool_blocks", num_blocks * sizeof(Block));
     KOKKOS_ASSERT(intptr_t(block_record->data()) % Align == 0);
     m_tracker.assign_allocated_record_to_uninitialized(block_record);
     m_first_block = (Block*)block_record->data();
 
-    auto idx_record = record_type::allocate(
-      mem_space, "FixedBlockSizeMemPool_blocks", num_blocks * sizeof(size_type)
-    );
+    auto idx_record =
+        record_type::allocate(mem_space, "FixedBlockSizeMemPool_blocks",
+                              num_blocks * sizeof(size_type));
     KOKKOS_ASSERT(intptr_t(idx_record->data()) % alignof(size_type) == 0);
     m_tracker.assign_allocated_record_to_uninitialized(idx_record);
     m_free_indices = (size_type*)idx_record->data();
 
-    for(size_type i = 0; i < num_blocks; ++i) {
+    for (size_type i = 0; i < num_blocks; ++i) {
       m_free_indices[i] = i;
     }
 
@@ -123,59 +118,62 @@ public:
   }
 
   // For compatibility with MemoryPool<>
-  FixedBlockSizeMemoryPool(
-    memory_space const& mem_space,
-    size_t mempool_capacity,
-    unsigned, unsigned, unsigned
-  ) : FixedBlockSizeMemoryPool(mem_space, mempool_capacity / actual_size)
-  { /* forwarding ctor, must be empty */ }
+  FixedBlockSizeMemoryPool(memory_space const& mem_space,
+                           size_t mempool_capacity, unsigned, unsigned,
+                           unsigned)
+      : FixedBlockSizeMemoryPool(
+            mem_space, mempool_capacity /
+                           actual_size) { /* forwarding ctor, must be empty */
+  }
 
   KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool() = default;
-  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool(FixedBlockSizeMemoryPool&&) = default;
-  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool(FixedBlockSizeMemoryPool const&) = default;
-  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool& operator=(FixedBlockSizeMemoryPool&&) = default;
-  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool& operator=(FixedBlockSizeMemoryPool const&) = default;
-
+  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool(FixedBlockSizeMemoryPool&&) =
+      default;
+  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool(
+      FixedBlockSizeMemoryPool const&)                     = default;
+  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool& operator=(
+      FixedBlockSizeMemoryPool&&) = default;
+  KOKKOS_INLINE_FUNCTION FixedBlockSizeMemoryPool& operator=(
+      FixedBlockSizeMemoryPool const&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  void* allocate(size_type alloc_size) const noexcept
-  {
+  void* allocate(size_type alloc_size) const noexcept {
     KOKKOS_EXPECTS(alloc_size <= Size);
-    auto free_idx_counter = Kokkos::atomic_fetch_add((volatile size_type*)&m_first_free_idx, size_type(1));
+    auto free_idx_counter = Kokkos::atomic_fetch_add(
+        (volatile size_type*)&m_first_free_idx, size_type(1));
     auto free_idx_idx = free_idx_counter % m_num_blocks;
 
     // We don't have exclusive access to m_free_indices[free_idx_idx] because
     // the allocate counter might have lapped us since we incremented it
     auto current_free_idx = m_free_indices[free_idx_idx];
-    size_type free_idx = IndexInUse;
-    free_idx =
-      Kokkos::atomic_compare_exchange(&m_free_indices[free_idx_idx], current_free_idx, free_idx);
+    size_type free_idx    = IndexInUse;
+    free_idx = Kokkos::atomic_compare_exchange(&m_free_indices[free_idx_idx],
+                                               current_free_idx, free_idx);
     Kokkos::memory_fence();
 
     // TODO figure out how to decrement here?
 
-    if(free_idx == IndexInUse) {
+    if (free_idx == IndexInUse) {
       return nullptr;
-    }
-    else {
+    } else {
       return (void*)&m_first_block[free_idx];
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void deallocate(void* ptr, size_type alloc_size) const noexcept
-  {
+  void deallocate(void* ptr, size_type alloc_size) const noexcept {
     // figure out which block we are
     auto offset = intptr_t(ptr) - intptr_t(m_first_block);
 
-    KOKKOS_EXPECTS(offset % actual_size == 0 && offset/actual_size < m_num_blocks);
+    KOKKOS_EXPECTS(offset % actual_size == 0 &&
+                   offset / actual_size < m_num_blocks);
 
     Kokkos::memory_fence();
-    auto last_idx_idx = Kokkos::atomic_fetch_add((volatile size_type*)&m_last_free_idx, size_type(1));
+    auto last_idx_idx = Kokkos::atomic_fetch_add(
+        (volatile size_type*)&m_last_free_idx, size_type(1));
     last_idx_idx %= m_num_blocks;
     m_free_indices[last_idx_idx] = offset / actual_size;
   }
-
 };
 
 #if 0
@@ -301,7 +299,7 @@ public:
 };
 #endif
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
-#endif //KOKKOS_IMPL_KOKKOS_FIXEDBUFFERMEMORYPOOL_HPP
+#endif  // KOKKOS_IMPL_KOKKOS_FIXEDBUFFERMEMORYPOOL_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_FunctorAdapter.hpp b/lib/kokkos/core/src/impl/Kokkos_FunctorAdapter.hpp
index ea3480b48bf69419fc138fa6eda72a9dfbffd79b..e981e903664a02d04bdff8a40da27f3108ab6abd 100644
--- a/lib/kokkos/core/src/impl/Kokkos_FunctorAdapter.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_FunctorAdapter.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -55,68 +56,76 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType, class Enable = void>
+template <class FunctorType, class Enable = void>
 struct ReduceFunctorHasInit {
-  enum {value = false};
+  enum { value = false };
 };
 
-template< class FunctorType>
-struct ReduceFunctorHasInit<FunctorType, typename Impl::enable_if< 0 < sizeof( & FunctorType::init ) >::type > {
-  enum {value = true};
+template <class FunctorType>
+struct ReduceFunctorHasInit<
+    FunctorType,
+    typename Impl::enable_if<0 < sizeof(&FunctorType::init)>::type> {
+  enum { value = true };
 };
 
-template< class FunctorType, class Enable = void>
+template <class FunctorType, class Enable = void>
 struct ReduceFunctorHasJoin {
-  enum {value = false};
+  enum { value = false };
 };
 
-template< class FunctorType>
-struct ReduceFunctorHasJoin<FunctorType, typename Impl::enable_if< 0 < sizeof( & FunctorType::join ) >::type > {
-  enum {value = true};
+template <class FunctorType>
+struct ReduceFunctorHasJoin<
+    FunctorType,
+    typename Impl::enable_if<0 < sizeof(&FunctorType::join)>::type> {
+  enum { value = true };
 };
 
-template< class FunctorType, class Enable = void>
+template <class FunctorType, class Enable = void>
 struct ReduceFunctorHasFinal {
-  enum {value = false};
+  enum { value = false };
 };
 
-template< class FunctorType>
-struct ReduceFunctorHasFinal<FunctorType, typename Impl::enable_if< 0 < sizeof( & FunctorType::final ) >::type > {
-  enum {value = true};
+template <class FunctorType>
+struct ReduceFunctorHasFinal<
+    FunctorType,
+    typename Impl::enable_if<0 < sizeof(&FunctorType::final)>::type> {
+  enum { value = true };
 };
 
-template< class FunctorType, class Enable = void>
-  struct ReduceFunctorHasShmemSize {
-  enum {value = false};
+template <class FunctorType, class Enable = void>
+struct ReduceFunctorHasShmemSize {
+  enum { value = false };
 };
 
-template< class FunctorType>
-struct ReduceFunctorHasShmemSize<FunctorType, typename Impl::enable_if< 0 < sizeof( & FunctorType::team_shmem_size ) >::type > {
-  enum {value = true};
+template <class FunctorType>
+struct ReduceFunctorHasShmemSize<
+    FunctorType,
+    typename Impl::enable_if<0 < sizeof(&FunctorType::team_shmem_size)>::type> {
+  enum { value = true };
 };
 
-template< class FunctorType , class ArgTag , class Enable = void >
+template <class FunctorType, class ArgTag, class Enable = void>
 struct FunctorDeclaresValueType : public Impl::false_type {};
 
-template< class FunctorType , class ArgTag >
-struct FunctorDeclaresValueType< FunctorType , ArgTag
-                               , typename Impl::enable_if_type< typename FunctorType::value_type >::type >
-  : public Impl::true_type {};
-
-template< class FunctorType, bool Enable =
-      ( FunctorDeclaresValueType<FunctorType,void>::value) ||
-      ( ReduceFunctorHasInit<FunctorType>::value  ) ||
-      ( ReduceFunctorHasJoin<FunctorType>::value  ) ||
-      ( ReduceFunctorHasFinal<FunctorType>::value ) ||
-      ( ReduceFunctorHasShmemSize<FunctorType>::value )
-      >
+template <class FunctorType, class ArgTag>
+struct FunctorDeclaresValueType<
+    FunctorType, ArgTag,
+    typename Impl::enable_if_type<typename FunctorType::value_type>::type>
+    : public Impl::true_type {};
+
+template <class FunctorType,
+          bool Enable = (FunctorDeclaresValueType<FunctorType, void>::value) ||
+                        (ReduceFunctorHasInit<FunctorType>::value) ||
+                        (ReduceFunctorHasJoin<FunctorType>::value) ||
+                        (ReduceFunctorHasFinal<FunctorType>::value) ||
+                        (ReduceFunctorHasShmemSize<FunctorType>::value)>
 struct IsNonTrivialReduceFunctor {
-  enum {value = false};
+  enum { value = false };
 };
 
-template< class FunctorType>
+template <class FunctorType>
 struct IsNonTrivialReduceFunctor<FunctorType, true> {
-  enum {value = true};
+  enum { value = true };
 };
 
 /** \brief  Query Functor and execution policy argument tag for value type.
@@ -124,30 +133,31 @@ struct IsNonTrivialReduceFunctor<FunctorType, true> {
  *  If C++11 enabled and 'value_type' is not explicitly declared then attempt
  *  to deduce the type from FunctorType::operator().
  */
-template< class FunctorType , class ArgTag , bool Dec = FunctorDeclaresValueType<FunctorType,ArgTag>::value >
-struct FunctorValueTraits
-{
-  typedef void value_type ;
-  typedef void pointer_type ;
-  typedef void reference_type ;
-  typedef void functor_type ;
+template <class FunctorType, class ArgTag,
+          bool Dec = FunctorDeclaresValueType<FunctorType, ArgTag>::value>
+struct FunctorValueTraits {
+  typedef void value_type;
+  typedef void pointer_type;
+  typedef void reference_type;
+  typedef void functor_type;
 
   enum { StaticValueSize = 0 };
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  unsigned value_count( const FunctorType & ) { return 0 ; }
+  KOKKOS_FORCEINLINE_FUNCTION static unsigned value_count(const FunctorType&) {
+    return 0;
+  }
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  unsigned value_size( const FunctorType & ) { return 0 ; }
+  KOKKOS_FORCEINLINE_FUNCTION static unsigned value_size(const FunctorType&) {
+    return 0;
+  }
 };
 
-template<class ArgTag>
-struct FunctorValueTraits<void, ArgTag,false>
-{
-  typedef void value_type ;
-  typedef void pointer_type ;
-  typedef void reference_type ;
-  typedef void functor_type ;
+template <class ArgTag>
+struct FunctorValueTraits<void, ArgTag, false> {
+  typedef void value_type;
+  typedef void pointer_type;
+  typedef void reference_type;
+  typedef void functor_type;
 };
 
 /** \brief  FunctorType::value_type is explicitly declared so use it.
@@ -161,844 +171,1138 @@ struct FunctorValueTraits<void, ArgTag,false>
  *        typedef {pod_type} value_type[] ;
  *        const unsigned     value_count ;
  */
-template< class FunctorType , class ArgTag >
-struct FunctorValueTraits< FunctorType , ArgTag , true /* == exists FunctorType::value_type */ >
-{
-  typedef typename Impl::remove_extent< typename FunctorType::value_type >::type  value_type ;
+template <class FunctorType, class ArgTag>
+struct FunctorValueTraits<FunctorType, ArgTag,
+                          true /* == exists FunctorType::value_type */> {
+  typedef typename Impl::remove_extent<typename FunctorType::value_type>::type
+      value_type;
   typedef FunctorType functor_type;
 
-  static_assert( 0 == ( sizeof(value_type) % sizeof(int) ) ,
-    "Reduction functor's declared value_type requires: 0 == sizeof(value_type) % sizeof(int)" );
+  static_assert(0 == (sizeof(value_type) % sizeof(int)),
+                "Reduction functor's declared value_type requires: 0 == "
+                "sizeof(value_type) % sizeof(int)");
 
   /* this cast to bool is needed for correctness by NVCC */
-  enum : bool { IsArray = static_cast<bool>(Impl::is_array< typename FunctorType::value_type >::value) };
+  enum : bool {
+    IsArray = static_cast<bool>(
+        Impl::is_array<typename FunctorType::value_type>::value)
+  };
 
   // If not an array then what is the sizeof(value_type)
   enum { StaticValueSize = IsArray ? 0 : sizeof(value_type) };
 
-  typedef value_type                 * pointer_type ;
+  typedef value_type* pointer_type;
 
   // The reference_type for an array is 'value_type *'
   // The reference_type for a single value is 'value_type &'
 
-  typedef typename Impl::if_c< IsArray , value_type *
-                                       , value_type & >::type  reference_type ;
+  typedef typename Impl::if_c<IsArray, value_type*, value_type&>::type
+      reference_type;
 
   // Number of values if single value
-  template< class F >
+  template <class F>
   KOKKOS_FORCEINLINE_FUNCTION static
-  typename Impl::enable_if< std::is_same<F,FunctorType>::value && ! IsArray , unsigned >::type
-    value_count( const F & ) { return 1 ; }
-
-  // Number of values if an array, protect via templating because 'f.value_count'
-  // will only exist when the functor declares the value_type to be an array.
-  template< class F >
+      typename Impl::enable_if<std::is_same<F, FunctorType>::value && !IsArray,
+                               unsigned>::type
+      value_count(const F&) {
+    return 1;
+  }
+
+  // Number of values if an array, protect via templating because
+  // 'f.value_count' will only exist when the functor declares the value_type to
+  // be an array.
+  template <class F>
   KOKKOS_FORCEINLINE_FUNCTION static
-  typename Impl::enable_if< std::is_same<F,FunctorType>::value && IsArray , unsigned >::type
-    value_count( const F & f ) { return f.value_count ; }
+      typename Impl::enable_if<std::is_same<F, FunctorType>::value && IsArray,
+                               unsigned>::type
+      value_count(const F& f) {
+    return f.value_count;
+  }
 
   // Total size of the value
-  KOKKOS_INLINE_FUNCTION static
-  unsigned value_size( const FunctorType & f ) { return value_count( f ) * sizeof(value_type) ; }
+  KOKKOS_INLINE_FUNCTION static unsigned value_size(const FunctorType& f) {
+    return value_count(f) * sizeof(value_type);
+  }
 };
 
+template <class FunctorType, class ArgTag>
+struct FunctorValueTraits<FunctorType, ArgTag,
+                          false /* == exists FunctorType::value_type */
+                          > {
+ private:
+  struct VOIDTAG {
+  };  // Allow declaration of non-matching operator() with void argument tag.
+  struct REJECTTAG {
+  };  // Reject tagged operator() when using non-tagged execution policy.
 
-template< class FunctorType , class ArgTag >
-struct FunctorValueTraits< FunctorType
-                         , ArgTag
-                         , false  /* == exists FunctorType::value_type */
-                         >
-{
-private:
-
-  struct VOIDTAG {};   // Allow declaration of non-matching operator() with void argument tag.
-  struct REJECTTAG {}; // Reject tagged operator() when using non-tagged execution policy.
-
-  typedef typename
-    Impl::if_c< std::is_same< ArgTag , void >::value , VOIDTAG , ArgTag >::type tag_type ;
+  typedef typename Impl::if_c<std::is_same<ArgTag, void>::value, VOIDTAG,
+                              ArgTag>::type tag_type;
 
   //----------------------------------------
   // parallel_for operator without a tag:
 
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class TagType , class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember)
+                   const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember)
+                   const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                                     const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                                     const ArgMember&, const ArgMember&,
+                                     const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                                     const ArgMember&, const ArgMember&,
+                                     const ArgMember&, const ArgMember&,
+                                     const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, const ArgMember&,
+                                     const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, const ArgMember&,
+                                     const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class TagType, class ArgMember>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
 
   //----------------------------------------
   // parallel_for operator with a tag:
 
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember ) const ) {}
-
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
-  template< class ArgMember >
-  KOKKOS_INLINE_FUNCTION
-  static VOIDTAG deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & ) const ) {}
-
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember,
+                                      ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, const ArgMember&,
+                                      const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, const ArgMember&,
+                                      const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&) const) {}
+
+  template <class ArgMember>
+  KOKKOS_INLINE_FUNCTION static VOIDTAG deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&) const) {}
 
   //----------------------------------------
   // parallel_reduce operator without a tag:
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(ArgMember, ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember,
+                                     T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                                     const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                                     const ArgMember&, const ArgMember&,
+                                     const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                                     const ArgMember&, const ArgMember&,
+                                     const ArgMember&, const ArgMember&,
+                                     const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, T&) const) {
+  }
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, const ArgMember&,
+                                     const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, ArgMember, ArgMember,
+                                     ArgMember, ArgMember, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, const ArgMember&,
+                                     const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
 
   //----------------------------------------
   // parallel_reduce operator with a tag:
 
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , ArgMember , T & ) const ) {}
-
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , const ArgMember & , T & ) const ) {}
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember,
+                                      ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, ArgMember,
+                                      ArgMember, ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, ArgMember, ArgMember, ArgMember,
+                            ArgMember, ArgMember, ArgMember, ArgMember,
+                            ArgMember, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, const ArgMember&,
+                                      const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, const ArgMember&,
+                                      const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, T&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&,
+                            const ArgMember&, const ArgMember&, T&) const) {}
 
   //----------------------------------------
   // parallel_scan operator without a tag:
 
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , T & , bool ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , T & , bool ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , T & , bool ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , T & , bool ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , T & , bool ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , T & , bool ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( ArgMember , T & , const bool& ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const ArgMember & , T & , const bool& ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , ArgMember , T & , const bool& ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( TagType , const ArgMember & , T & , const bool& ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , ArgMember , T & , const bool& ) const ) {}
-
-  template< class TagType , class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static REJECTTAG deduce_reduce_type( VOIDTAG , void (FunctorType::*)( const TagType & , const ArgMember & , T & , const bool& ) const ) {}
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, T&, bool) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, T&, bool) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, ArgMember, T&, bool) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, const ArgMember&, T&, bool) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(const TagType&, ArgMember, T&, bool) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, const ArgMember&, T&, bool)
+                   const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(ArgMember, T&, const bool&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const ArgMember&, T&, const bool&) const) {
+  }
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG,
+      void (FunctorType::*)(TagType, ArgMember, T&, const bool&) const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(TagType, const ArgMember&, T&, const bool&)
+                   const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, ArgMember, T&, const bool&)
+                   const) {}
+
+  template <class TagType, class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static REJECTTAG deduce_reduce_type(
+      VOIDTAG, void (FunctorType::*)(const TagType&, const ArgMember&, T&,
+                                     const bool&) const) {}
   //----------------------------------------
   // parallel_scan operator with a tag:
 
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , T & , bool ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , T & , bool ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember& , T & , bool ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember& , T & , bool ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , ArgMember , T & , const bool& ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , ArgMember , T & , const bool& ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( tag_type , const ArgMember& , T & , const bool& ) const ) {}
-
-  template< class ArgMember , class T >
-  KOKKOS_INLINE_FUNCTION
-  static T deduce_reduce_type( tag_type , void (FunctorType::*)( const tag_type & , const ArgMember& , T & , const bool& ) const ) {}
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, ArgMember, T&, bool) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(const tag_type&, ArgMember, T&, bool) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, const ArgMember&, T&, bool) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, const ArgMember&, T&,
+                                      bool) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type,
+      void (FunctorType::*)(tag_type, ArgMember, T&, const bool&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, ArgMember, T&,
+                                      const bool&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(tag_type, const ArgMember&, T&,
+                                      const bool&) const) {}
+
+  template <class ArgMember, class T>
+  KOKKOS_INLINE_FUNCTION static T deduce_reduce_type(
+      tag_type, void (FunctorType::*)(const tag_type&, const ArgMember&, T&,
+                                      const bool&) const) {}
   //----------------------------------------
 
-  typedef decltype( deduce_reduce_type( tag_type() , & FunctorType::operator() ) ) ValueType ;
-
-  enum { IS_VOID   = std::is_same<VOIDTAG  ,ValueType>::value };
-  enum { IS_REJECT = std::is_same<REJECTTAG,ValueType>::value };
+  typedef decltype(
+      deduce_reduce_type(tag_type(), &FunctorType::operator())) ValueType;
 
-public:
+  enum { IS_VOID = std::is_same<VOIDTAG, ValueType>::value };
+  enum { IS_REJECT = std::is_same<REJECTTAG, ValueType>::value };
 
-  typedef typename Impl::if_c< IS_VOID || IS_REJECT , void , ValueType   >::type  value_type ;
-  typedef typename Impl::if_c< IS_VOID || IS_REJECT , void , ValueType * >::type  pointer_type ;
-  typedef typename Impl::if_c< IS_VOID || IS_REJECT , void , ValueType & >::type  reference_type ;
+ public:
+  typedef typename Impl::if_c<IS_VOID || IS_REJECT, void, ValueType>::type
+      value_type;
+  typedef typename Impl::if_c<IS_VOID || IS_REJECT, void, ValueType*>::type
+      pointer_type;
+  typedef typename Impl::if_c<IS_VOID || IS_REJECT, void, ValueType&>::type
+      reference_type;
   typedef FunctorType functor_type;
 
-  static_assert( IS_VOID || IS_REJECT || 0 == ( sizeof(ValueType) % sizeof(int) ) ,
-    "Reduction functor's value_type deduced from functor::operator() requires: 0 == sizeof(value_type) % sizeof(int)" );
+  static_assert(
+      IS_VOID || IS_REJECT || 0 == (sizeof(ValueType) % sizeof(int)),
+      "Reduction functor's value_type deduced from functor::operator() "
+      "requires: 0 == sizeof(value_type) % sizeof(int)");
 
   enum { StaticValueSize = IS_VOID || IS_REJECT ? 0 : sizeof(ValueType) };
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  unsigned value_size( const FunctorType & ) { return StaticValueSize ; }
+  KOKKOS_FORCEINLINE_FUNCTION static unsigned value_size(const FunctorType&) {
+    return StaticValueSize;
+  }
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  unsigned value_count( const FunctorType & ) { return IS_VOID || IS_REJECT ? 0 : 1 ; }
+  KOKKOS_FORCEINLINE_FUNCTION static unsigned value_count(const FunctorType&) {
+    return IS_VOID || IS_REJECT ? 0 : 1;
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1009,134 +1313,131 @@ namespace Impl {
 /** Function signatures for FunctorType::init function with a tag.
  *  reference_type is 'value_type &' for scalar and 'value_type *' for array.
  */
-template< class FunctorType , class ArgTag >
+template <class FunctorType, class ArgTag>
 struct FunctorValueInitFunction {
-
-  typedef typename FunctorValueTraits<FunctorType,ArgTag>::reference_type
-    reference_type ;
-
-  KOKKOS_INLINE_FUNCTION static void
-    enable_if( void (FunctorType::*)( ArgTag         , reference_type ) const );
-  KOKKOS_INLINE_FUNCTION static void
-    enable_if( void (FunctorType::*)( ArgTag const & , reference_type ) const );
-  KOKKOS_INLINE_FUNCTION static void
-    enable_if( void (             *)( ArgTag         , reference_type ) );
-  KOKKOS_INLINE_FUNCTION static void
-    enable_if( void (             *)( ArgTag const & , reference_type ) );
-
+  typedef typename FunctorValueTraits<FunctorType, ArgTag>::reference_type
+      reference_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, reference_type) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, reference_type) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag,
+                                                        reference_type));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        reference_type));
 };
 
 /** Function signatures for FunctorType::init function without a tag.
  *  reference_type is 'value_type &' for scalar and 'value_type *' for array.
  */
-template< class FunctorType >
-struct FunctorValueInitFunction< FunctorType , void > {
-
-  typedef typename FunctorValueTraits<FunctorType,void>::reference_type
-    reference_type ;
-
-  KOKKOS_INLINE_FUNCTION static void
-    enable_if( void (FunctorType::*)( reference_type ) const );
-  KOKKOS_INLINE_FUNCTION static void
-    enable_if( void (             *)( reference_type ) );
+template <class FunctorType>
+struct FunctorValueInitFunction<FunctorType, void> {
+  typedef typename FunctorValueTraits<FunctorType, void>::reference_type
+      reference_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(reference_type) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(reference_type));
 };
 
 // Adapter for value initialization function.
 // If a proper FunctorType::init is declared then use it,
 // otherwise use default constructor.
-template< class FunctorType , class ArgTag
-        , class T = typename FunctorValueTraits<FunctorType,ArgTag>::reference_type // FIXME Fix FunctorValueTraits for multi-dim operator
-        , class Enable = void >
-struct FunctorValueInit ;
+template <class FunctorType, class ArgTag,
+          class T = typename FunctorValueTraits<FunctorType, ArgTag>::
+              reference_type  // FIXME Fix FunctorValueTraits for multi-dim
+                              // operator
+          ,
+          class Enable = void>
+struct FunctorValueInit;
 
 /* No 'init' function provided for single value */
-template< class FunctorType , class ArgTag , class T , class Enable >
-struct FunctorValueInit< FunctorType , ArgTag , T & , Enable >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T & init( const FunctorType & , void * p )
-    { return *( new(p) T() ); };
+template <class FunctorType, class ArgTag, class T, class Enable>
+struct FunctorValueInit<FunctorType, ArgTag, T&, Enable> {
+  KOKKOS_FORCEINLINE_FUNCTION static T& init(const FunctorType&, void* p) {
+    return *(new (p) T());
+  };
 };
 
 /* No 'init' function provided for array value */
-template< class FunctorType , class ArgTag , class T , class Enable >
-struct FunctorValueInit< FunctorType , ArgTag , T * , Enable >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T * init( const FunctorType & f , void * p )
-    {
-      const int n = FunctorValueTraits< FunctorType , ArgTag >::value_count(f);
-      for ( int i = 0 ; i < n ; ++i ) { new( ((T*)p) + i ) T(); }
-      return (T*)p ;
+template <class FunctorType, class ArgTag, class T, class Enable>
+struct FunctorValueInit<FunctorType, ArgTag, T*, Enable> {
+  KOKKOS_FORCEINLINE_FUNCTION static T* init(const FunctorType& f, void* p) {
+    const int n = FunctorValueTraits<FunctorType, ArgTag>::value_count(f);
+    for (int i = 0; i < n; ++i) {
+      new (((T*)p) + i) T();
     }
+    return (T*)p;
+  }
 };
 
 /* 'init' function provided for single value */
-template< class FunctorType , class T >
-struct FunctorValueInit
-  < FunctorType
-  , void
-  , T &
+template <class FunctorType, class T>
+struct FunctorValueInit<
+    FunctorType, void,
+    T&
     // First  substitution failure when FunctorType::init does not exist.
     // Second substitution failure when FunctorType::init is not compatible.
-  , decltype( FunctorValueInitFunction< FunctorType , void >::enable_if( & FunctorType::init ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T & init( const FunctorType & f , void * p )
-    { f.init( *((T*)p) ); return *((T*)p) ; }
+    ,
+    decltype(FunctorValueInitFunction<FunctorType, void>::enable_if(
+        &FunctorType::init))> {
+  KOKKOS_FORCEINLINE_FUNCTION static T& init(const FunctorType& f, void* p) {
+    f.init(*((T*)p));
+    return *((T*)p);
+  }
 };
 
 /* 'init' function provided for array value */
-template< class FunctorType , class T >
-struct FunctorValueInit
-  < FunctorType
-  , void
-  , T *
+template <class FunctorType, class T>
+struct FunctorValueInit<
+    FunctorType, void,
+    T*
     // First  substitution failure when FunctorType::init does not exist.
     // Second substitution failure when FunctorType::init is not compatible
-  , decltype( FunctorValueInitFunction< FunctorType , void >::enable_if( & FunctorType::init ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T * init( const FunctorType & f , void * p )
-    { f.init( (T*)p ); return (T*)p ; }
+    ,
+    decltype(FunctorValueInitFunction<FunctorType, void>::enable_if(
+        &FunctorType::init))> {
+  KOKKOS_FORCEINLINE_FUNCTION static T* init(const FunctorType& f, void* p) {
+    f.init((T*)p);
+    return (T*)p;
+  }
 };
 
 /* 'init' function provided for single value */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorValueInit
-  < FunctorType
-  , ArgTag
-  , T &
+template <class FunctorType, class ArgTag, class T>
+struct FunctorValueInit<
+    FunctorType, ArgTag,
+    T&
     // First  substitution failure when FunctorType::init does not exist.
     // Second substitution failure when FunctorType::init is not compatible.
-  , decltype( FunctorValueInitFunction< FunctorType , ArgTag >::enable_if( & FunctorType::init ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T & init( const FunctorType & f , void * p )
-    { f.init( ArgTag() , *((T*)p) ); return *((T*)p) ; }
+    ,
+    decltype(FunctorValueInitFunction<FunctorType, ArgTag>::enable_if(
+        &FunctorType::init))> {
+  KOKKOS_FORCEINLINE_FUNCTION static T& init(const FunctorType& f, void* p) {
+    f.init(ArgTag(), *((T*)p));
+    return *((T*)p);
+  }
 };
 
 /* 'init' function provided for array value */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorValueInit
-  < FunctorType
-  , ArgTag
-  , T *
+template <class FunctorType, class ArgTag, class T>
+struct FunctorValueInit<
+    FunctorType, ArgTag,
+    T*
     // First  substitution failure when FunctorType::init does not exist.
     // Second substitution failure when FunctorType::init is not compatible
-  , decltype( FunctorValueInitFunction< FunctorType , ArgTag >::enable_if( & FunctorType::init ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T * init( const FunctorType & f , void * p )
-    { f.init( ArgTag() , (T*)p ); return (T*)p ; }
+    ,
+    decltype(FunctorValueInitFunction<FunctorType, ArgTag>::enable_if(
+        &FunctorType::init))> {
+  KOKKOS_FORCEINLINE_FUNCTION static T* init(const FunctorType& f, void* p) {
+    f.init(ArgTag(), (T*)p);
+    return (T*)p;
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1145,345 +1446,338 @@ namespace Kokkos {
 namespace Impl {
 
 // Signatures for compatible FunctorType::join with tag and not an array
-template< class FunctorType , class ArgTag , bool IsArray = 0 == FunctorValueTraits<FunctorType,ArgTag>::StaticValueSize >
+template <class FunctorType, class ArgTag,
+          bool IsArray =
+              0 == FunctorValueTraits<FunctorType, ArgTag>::StaticValueSize>
 struct FunctorValueJoinFunction {
-
-  typedef typename FunctorValueTraits<FunctorType,ArgTag>::value_type value_type ;
-
-  typedef       volatile value_type & vref_type ;
-  typedef const volatile value_type & cvref_type ;
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , vref_type , cvref_type ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , vref_type , cvref_type ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , vref_type , cvref_type ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , vref_type , cvref_type ) );
+  typedef
+      typename FunctorValueTraits<FunctorType, ArgTag>::value_type value_type;
+
+  typedef volatile value_type& vref_type;
+  typedef const volatile value_type& cvref_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, vref_type, cvref_type) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, vref_type, cvref_type) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag, vref_type,
+                                                        cvref_type));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        vref_type, cvref_type));
 };
 
 // Signatures for compatible FunctorType::join with tag and is an array
-template< class FunctorType , class ArgTag >
-struct FunctorValueJoinFunction< FunctorType , ArgTag , true > {
-
-  typedef typename FunctorValueTraits<FunctorType,ArgTag>::value_type value_type ;
-
-  typedef       volatile value_type * vptr_type ;
-  typedef const volatile value_type * cvptr_type ;
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , vptr_type , cvptr_type ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , vptr_type , cvptr_type ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , vptr_type , cvptr_type ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , vptr_type , cvptr_type ) );
+template <class FunctorType, class ArgTag>
+struct FunctorValueJoinFunction<FunctorType, ArgTag, true> {
+  typedef
+      typename FunctorValueTraits<FunctorType, ArgTag>::value_type value_type;
+
+  typedef volatile value_type* vptr_type;
+  typedef const volatile value_type* cvptr_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, vptr_type, cvptr_type) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, vptr_type, cvptr_type) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag, vptr_type,
+                                                        cvptr_type));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        vptr_type, cvptr_type));
 };
 
 // Signatures for compatible FunctorType::join without tag and not an array
-template< class FunctorType >
-struct FunctorValueJoinFunction< FunctorType , void , false > {
-
-  typedef typename FunctorValueTraits<FunctorType,void>::value_type value_type ;
+template <class FunctorType>
+struct FunctorValueJoinFunction<FunctorType, void, false> {
+  typedef typename FunctorValueTraits<FunctorType, void>::value_type value_type;
 
-  typedef       volatile value_type & vref_type ;
-  typedef const volatile value_type & cvref_type ;
+  typedef volatile value_type& vref_type;
+  typedef const volatile value_type& cvref_type;
 
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( vref_type , cvref_type ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( vref_type , cvref_type ) );
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (FunctorType::*)(vref_type,
+                                                                     cvref_type)
+                                                   const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(vref_type, cvref_type));
 };
 
 // Signatures for compatible FunctorType::join without tag and is an array
-template< class FunctorType >
-struct FunctorValueJoinFunction< FunctorType , void , true > {
+template <class FunctorType>
+struct FunctorValueJoinFunction<FunctorType, void, true> {
+  typedef typename FunctorValueTraits<FunctorType, void>::value_type value_type;
 
-  typedef typename FunctorValueTraits<FunctorType,void>::value_type value_type ;
+  typedef volatile value_type* vptr_type;
+  typedef const volatile value_type* cvptr_type;
 
-  typedef       volatile value_type * vptr_type ;
-  typedef const volatile value_type * cvptr_type ;
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( vptr_type , cvptr_type ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( vptr_type , cvptr_type ) );
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (FunctorType::*)(vptr_type,
+                                                                     cvptr_type)
+                                                   const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(vptr_type, cvptr_type));
 };
 
-
-template< class FunctorType , class ArgTag
-        , class T = typename FunctorValueTraits<FunctorType,ArgTag>::reference_type
-        , class Enable = void >
-struct FunctorValueJoin ;
+template <class FunctorType, class ArgTag,
+          class T =
+              typename FunctorValueTraits<FunctorType, ArgTag>::reference_type,
+          class Enable = void>
+struct FunctorValueJoin;
 
 /* No 'join' function provided, single value */
-template< class FunctorType , class ArgTag , class T , class Enable >
-struct FunctorValueJoin< FunctorType , ArgTag , T & , Enable >
-{
+template <class FunctorType, class ArgTag, class T, class Enable>
+struct FunctorValueJoin<FunctorType, ArgTag, T&, Enable> {
   KOKKOS_FORCEINLINE_FUNCTION
-  FunctorValueJoin(const FunctorType& ){}
+  FunctorValueJoin(const FunctorType&) {}
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void join( const FunctorType & f , volatile void * const lhs , const volatile void * const rhs )
-    {
-      *((volatile T*)lhs) += *((const volatile T*)rhs);
-    }
+  KOKKOS_FORCEINLINE_FUNCTION static void join(const FunctorType& f,
+                                               volatile void* const lhs,
+                                               const volatile void* const rhs) {
+    *((volatile T*)lhs) += *((const volatile T*)rhs);
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator()( volatile T& lhs , const volatile T& rhs ) const
-    {
-      lhs += rhs;
-    }
+  void operator()(volatile T& lhs, const volatile T& rhs) const { lhs += rhs; }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator() ( T& lhs , const T& rhs ) const
-    {
-      lhs += rhs;
-    }
+  void operator()(T& lhs, const T& rhs) const { lhs += rhs; }
 };
 
 /* No 'join' function provided, array of values */
-template< class FunctorType , class ArgTag , class T , class Enable >
-struct FunctorValueJoin< FunctorType , ArgTag , T * , Enable >
-{
+template <class FunctorType, class ArgTag, class T, class Enable>
+struct FunctorValueJoin<FunctorType, ArgTag, T*, Enable> {
   const FunctorType& f;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  FunctorValueJoin(const FunctorType& f_):f(f_){}
+  FunctorValueJoin(const FunctorType& f_) : f(f_) {}
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void join( const FunctorType & f_ , volatile void * const lhs , const volatile void * const rhs )
-    {
-      const int n = FunctorValueTraits<FunctorType,ArgTag>::value_count(f_);
+  KOKKOS_FORCEINLINE_FUNCTION static void join(const FunctorType& f_,
+                                               volatile void* const lhs,
+                                               const volatile void* const rhs) {
+    const int n = FunctorValueTraits<FunctorType, ArgTag>::value_count(f_);
 
-      for ( int i = 0 ; i < n ; ++i ) { ((volatile T*)lhs)[i] += ((const volatile T*)rhs)[i]; }
+    for (int i = 0; i < n; ++i) {
+      ((volatile T*)lhs)[i] += ((const volatile T*)rhs)[i];
     }
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator()( volatile T* const lhs , const volatile T* const rhs ) const
-    {
-      const int n = FunctorValueTraits<FunctorType,ArgTag>::value_count(f);
+  void operator()(volatile T* const lhs, const volatile T* const rhs) const {
+    const int n = FunctorValueTraits<FunctorType, ArgTag>::value_count(f);
 
-      for ( int i = 0 ; i < n ; ++i ) { lhs[i] += rhs[i]; }
+    for (int i = 0; i < n; ++i) {
+      lhs[i] += rhs[i];
     }
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator() ( T* lhs , const T* rhs ) const
-    {
-      const int n = FunctorValueTraits<FunctorType,ArgTag>::value_count(f);
+  void operator()(T* lhs, const T* rhs) const {
+    const int n = FunctorValueTraits<FunctorType, ArgTag>::value_count(f);
 
-      for ( int i = 0 ; i < n ; ++i ) { lhs[i] += rhs[i]; }
+    for (int i = 0; i < n; ++i) {
+      lhs[i] += rhs[i];
     }
+  }
 };
 
 /* 'join' function provided, single value */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorValueJoin
-  < FunctorType
-  , ArgTag
-  , T &
+template <class FunctorType, class ArgTag, class T>
+struct FunctorValueJoin<
+    FunctorType, ArgTag,
+    T&
     // First  substitution failure when FunctorType::join does not exist.
-    // Second substitution failure when enable_if( & Functor::join ) does not exist
-  , decltype( FunctorValueJoinFunction< FunctorType , ArgTag >::enable_if( & FunctorType::join ) )
-  >
-{
+    // Second substitution failure when enable_if( & Functor::join ) does not
+    // exist
+    ,
+    decltype(FunctorValueJoinFunction<FunctorType, ArgTag>::enable_if(
+        &FunctorType::join))> {
   const FunctorType& f;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  FunctorValueJoin(const FunctorType& f_):f(f_){}
+  FunctorValueJoin(const FunctorType& f_) : f(f_) {}
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void join( const FunctorType & f_ , volatile void * const lhs , const volatile void * const rhs )
-    {
-      f_.join( ArgTag() , *((volatile T *)lhs) , *((const volatile T *)rhs) );
-    }
+  KOKKOS_FORCEINLINE_FUNCTION static void join(const FunctorType& f_,
+                                               volatile void* const lhs,
+                                               const volatile void* const rhs) {
+    f_.join(ArgTag(), *((volatile T*)lhs), *((const volatile T*)rhs));
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator()( volatile T& lhs , const volatile T& rhs ) const
-    {
-      f.join( ArgTag() , lhs , rhs );
-    }
+  void operator()(volatile T& lhs, const volatile T& rhs) const {
+    f.join(ArgTag(), lhs, rhs);
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator() ( T& lhs , const T& rhs ) const
-    {
-      f.join( ArgTag(), lhs , rhs );
-    }
+  void operator()(T& lhs, const T& rhs) const { f.join(ArgTag(), lhs, rhs); }
 };
 
 /* 'join' function provided, no tag, single value */
-template< class FunctorType , class T >
-struct FunctorValueJoin
-  < FunctorType
-  , void
-  , T &
+template <class FunctorType, class T>
+struct FunctorValueJoin<
+    FunctorType, void,
+    T&
     // First  substitution failure when FunctorType::join does not exist.
-    // Second substitution failure when enable_if( & Functor::join ) does not exist
-  , decltype( FunctorValueJoinFunction< FunctorType , void >::enable_if( & FunctorType::join ) )
-  >
-{
+    // Second substitution failure when enable_if( & Functor::join ) does not
+    // exist
+    ,
+    decltype(FunctorValueJoinFunction<FunctorType, void>::enable_if(
+        &FunctorType::join))> {
   const FunctorType& f;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  FunctorValueJoin(const FunctorType& f_):f(f_){}
+  FunctorValueJoin(const FunctorType& f_) : f(f_) {}
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void join( const FunctorType & f_ , volatile void * const lhs , const volatile void * const rhs )
-    {
-      f_.join( *((volatile T *)lhs) , *((const volatile T *)rhs) );
-    }
+  KOKKOS_FORCEINLINE_FUNCTION static void join(const FunctorType& f_,
+                                               volatile void* const lhs,
+                                               const volatile void* const rhs) {
+    f_.join(*((volatile T*)lhs), *((const volatile T*)rhs));
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator()( volatile T& lhs , const volatile T& rhs ) const
-    {
-      f.join( lhs , rhs );
-    }
+  void operator()(volatile T& lhs, const volatile T& rhs) const {
+    f.join(lhs, rhs);
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator() ( T& lhs , const T& rhs ) const
-    {
-      f.join( lhs , rhs );
-    }
+  void operator()(T& lhs, const T& rhs) const { f.join(lhs, rhs); }
 };
 
 /* 'join' function provided for array value */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorValueJoin
-  < FunctorType
-  , ArgTag
-  , T *
+template <class FunctorType, class ArgTag, class T>
+struct FunctorValueJoin<
+    FunctorType, ArgTag,
+    T*
     // First  substitution failure when FunctorType::join does not exist.
-    // Second substitution failure when enable_if( & Functor::join ) does not exist
-  , decltype( FunctorValueJoinFunction< FunctorType , ArgTag >::enable_if( & FunctorType::join ) )
-  >
-{
+    // Second substitution failure when enable_if( & Functor::join ) does not
+    // exist
+    ,
+    decltype(FunctorValueJoinFunction<FunctorType, ArgTag>::enable_if(
+        &FunctorType::join))> {
   const FunctorType& f;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  FunctorValueJoin(const FunctorType& f_):f(f_){}
+  FunctorValueJoin(const FunctorType& f_) : f(f_) {}
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void join( const FunctorType & f_ , volatile void * const lhs , const volatile void * const rhs )
-    {
-      f_.join( ArgTag() , (volatile T *)lhs , (const volatile T *)rhs );
-    }
+  KOKKOS_FORCEINLINE_FUNCTION static void join(const FunctorType& f_,
+                                               volatile void* const lhs,
+                                               const volatile void* const rhs) {
+    f_.join(ArgTag(), (volatile T*)lhs, (const volatile T*)rhs);
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator()( volatile T* const lhs , const volatile T* const rhs ) const
-    {
-      f.join( ArgTag() , lhs , rhs );
-    }
+  void operator()(volatile T* const lhs, const volatile T* const rhs) const {
+    f.join(ArgTag(), lhs, rhs);
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator() ( T* lhs , const T* rhs ) const
-    {
-      f.join( ArgTag(), lhs , rhs );
-    }
+  void operator()(T* lhs, const T* rhs) const { f.join(ArgTag(), lhs, rhs); }
 };
 
 /* 'join' function provided, no tag, array value */
-template< class FunctorType , class T >
-struct FunctorValueJoin
-  < FunctorType
-  , void
-  , T *
+template <class FunctorType, class T>
+struct FunctorValueJoin<
+    FunctorType, void,
+    T*
     // First  substitution failure when FunctorType::join does not exist.
-    // Second substitution failure when enable_if( & Functor::join ) does not exist
-  , decltype( FunctorValueJoinFunction< FunctorType , void >::enable_if( & FunctorType::join ) )
-  >
-{
+    // Second substitution failure when enable_if( & Functor::join ) does not
+    // exist
+    ,
+    decltype(FunctorValueJoinFunction<FunctorType, void>::enable_if(
+        &FunctorType::join))> {
   const FunctorType& f;
 
   KOKKOS_FORCEINLINE_FUNCTION
-  FunctorValueJoin(const FunctorType& f_):f(f_){}
+  FunctorValueJoin(const FunctorType& f_) : f(f_) {}
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void join( const FunctorType & f_ , volatile void * const lhs , const volatile void * const rhs )
-    {
-      f_.join( (volatile T *)lhs , (const volatile T *)rhs );
-    }
+  KOKKOS_FORCEINLINE_FUNCTION static void join(const FunctorType& f_,
+                                               volatile void* const lhs,
+                                               const volatile void* const rhs) {
+    f_.join((volatile T*)lhs, (const volatile T*)rhs);
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator() ( volatile T* const lhs , const volatile T* const rhs ) const
-    {
-      f.join( lhs , rhs );
-    }
+  void operator()(volatile T* const lhs, const volatile T* const rhs) const {
+    f.join(lhs, rhs);
+  }
   KOKKOS_FORCEINLINE_FUNCTION
-  void operator() ( T* lhs , const T* rhs ) const
-    {
-      f.join( lhs , rhs );
-    }
+  void operator()(T* lhs, const T* rhs) const { f.join(lhs, rhs); }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 
 namespace Impl {
 
-  template<typename ValueType, class JoinOp, class Enable = void>
-  struct JoinLambdaAdapter {
-    typedef ValueType value_type;
-    const JoinOp& lambda;
-    KOKKOS_INLINE_FUNCTION
-    JoinLambdaAdapter(const JoinOp& lambda_):lambda(lambda_) {}
+template <typename ValueType, class JoinOp, class Enable = void>
+struct JoinLambdaAdapter {
+  typedef ValueType value_type;
+  const JoinOp& lambda;
+  KOKKOS_INLINE_FUNCTION
+  JoinLambdaAdapter(const JoinOp& lambda_) : lambda(lambda_) {}
 
-    KOKKOS_INLINE_FUNCTION
-    void join(volatile value_type& dst, const volatile value_type& src) const {
-      lambda(dst,src);
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(volatile value_type& dst, const volatile value_type& src) const {
+    lambda(dst, src);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void join(value_type& dst, const value_type& src) const {
-      lambda(dst,src);
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(value_type& dst, const value_type& src) const { lambda(dst, src); }
 
-    KOKKOS_INLINE_FUNCTION
-    void operator() (volatile value_type& dst, const volatile value_type& src) const {
-      lambda(dst,src);
-    }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(volatile value_type& dst,
+                  const volatile value_type& src) const {
+    lambda(dst, src);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void operator() (value_type& dst, const value_type& src) const {
-      lambda(dst,src);
-    }
-  };
+  KOKKOS_INLINE_FUNCTION
+  void operator()(value_type& dst, const value_type& src) const {
+    lambda(dst, src);
+  }
+};
 
-  template<typename ValueType, class JoinOp>
-  struct JoinLambdaAdapter<ValueType, JoinOp, decltype( FunctorValueJoinFunction< JoinOp , void >::enable_if( & JoinOp::join ) )> {
-    typedef ValueType value_type;
-    static_assert(
-        std::is_same<ValueType,typename JoinOp::value_type>::value,
-        "JoinLambdaAdapter static_assert Fail: ValueType != JoinOp::value_type");
+template <typename ValueType, class JoinOp>
+struct JoinLambdaAdapter<ValueType, JoinOp,
+                         decltype(FunctorValueJoinFunction<
+                                  JoinOp, void>::enable_if(&JoinOp::join))> {
+  typedef ValueType value_type;
+  static_assert(
+      std::is_same<ValueType, typename JoinOp::value_type>::value,
+      "JoinLambdaAdapter static_assert Fail: ValueType != JoinOp::value_type");
 
-    const JoinOp& lambda;
-    KOKKOS_INLINE_FUNCTION
-    JoinLambdaAdapter(const JoinOp& lambda_):lambda(lambda_) {}
+  const JoinOp& lambda;
+  KOKKOS_INLINE_FUNCTION
+  JoinLambdaAdapter(const JoinOp& lambda_) : lambda(lambda_) {}
 
-    KOKKOS_INLINE_FUNCTION
-    void join(volatile value_type& dst, const volatile value_type& src) const {
-      lambda.join(dst,src);
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(volatile value_type& dst, const volatile value_type& src) const {
+    lambda.join(dst, src);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void join(value_type& dst, const value_type& src) const {
-      lambda.join(dst,src);
-    }
+  KOKKOS_INLINE_FUNCTION
+  void join(value_type& dst, const value_type& src) const {
+    lambda.join(dst, src);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void operator() (volatile value_type& dst, const volatile value_type& src) const {
-      lambda.join(dst,src);
-    }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(volatile value_type& dst,
+                  const volatile value_type& src) const {
+    lambda.join(dst, src);
+  }
 
-    KOKKOS_INLINE_FUNCTION
-    void operator() (value_type& dst, const value_type& src) const {
-      lambda.join(dst,src);
-    }
-  };
+  KOKKOS_INLINE_FUNCTION
+  void operator()(value_type& dst, const value_type& src) const {
+    lambda.join(dst, src);
+  }
+};
 
-  template<typename ValueType>
-  struct JoinAdd {
-    typedef ValueType value_type;
+template <typename ValueType>
+struct JoinAdd {
+  typedef ValueType value_type;
 
-    KOKKOS_INLINE_FUNCTION
-    JoinAdd() {}
+  KOKKOS_INLINE_FUNCTION
+  JoinAdd() {}
 
-    KOKKOS_INLINE_FUNCTION
-    void join(volatile value_type& dst, const volatile value_type& src) const {
-      dst+=src;
-    }
-    KOKKOS_INLINE_FUNCTION
-    void operator() (value_type& dst, const value_type& src) const {
-      dst+=src;
-    }
-    KOKKOS_INLINE_FUNCTION
-    void operator() (volatile value_type& dst, const volatile value_type& src) const {
-      dst+=src;
-    }
-  };
+  KOKKOS_INLINE_FUNCTION
+  void join(volatile value_type& dst, const volatile value_type& src) const {
+    dst += src;
+  }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(value_type& dst, const value_type& src) const { dst += src; }
+  KOKKOS_INLINE_FUNCTION
+  void operator()(volatile value_type& dst,
+                  const volatile value_type& src) const {
+    dst += src;
+  }
+};
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1491,44 +1785,43 @@ namespace Impl {
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ArgTag
-        , class T = typename FunctorValueTraits<FunctorType,ArgTag>::reference_type >
-struct FunctorValueOps ;
+template <class FunctorType, class ArgTag,
+          class T =
+              typename FunctorValueTraits<FunctorType, ArgTag>::reference_type>
+struct FunctorValueOps;
 
-template< class FunctorType , class ArgTag , class T >
-struct FunctorValueOps< FunctorType , ArgTag , T & >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T * pointer( T & r ) { return & r ; }
+template <class FunctorType, class ArgTag, class T>
+struct FunctorValueOps<FunctorType, ArgTag, T&> {
+  KOKKOS_FORCEINLINE_FUNCTION static T* pointer(T& r) { return &r; }
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T & reference( void * p ) { return *((T*)p); }
+  KOKKOS_FORCEINLINE_FUNCTION static T& reference(void* p) { return *((T*)p); }
 
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void copy( const FunctorType & , void * const lhs , const void * const rhs )
-    { *((T*)lhs) = *((const T*)rhs); }
+  KOKKOS_FORCEINLINE_FUNCTION static void copy(const FunctorType&,
+                                               void* const lhs,
+                                               const void* const rhs) {
+    *((T*)lhs) = *((const T*)rhs);
+  }
 };
 
 /* No 'join' function provided, array of values */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorValueOps< FunctorType , ArgTag , T * >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T * pointer( T * p ) { return p ; }
-
-  KOKKOS_FORCEINLINE_FUNCTION static
-  T * reference( void * p ) { return ((T*)p); }
-
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void copy( const FunctorType & f , void * const lhs , const void * const rhs )
-    {
-      const int n = FunctorValueTraits<FunctorType,ArgTag>::value_count(f);
-      for ( int i = 0 ; i < n ; ++i ) { ((T*)lhs)[i] = ((const T*)rhs)[i]; }
+template <class FunctorType, class ArgTag, class T>
+struct FunctorValueOps<FunctorType, ArgTag, T*> {
+  KOKKOS_FORCEINLINE_FUNCTION static T* pointer(T* p) { return p; }
+
+  KOKKOS_FORCEINLINE_FUNCTION static T* reference(void* p) { return ((T*)p); }
+
+  KOKKOS_FORCEINLINE_FUNCTION static void copy(const FunctorType& f,
+                                               void* const lhs,
+                                               const void* const rhs) {
+    const int n = FunctorValueTraits<FunctorType, ArgTag>::value_count(f);
+    for (int i = 0; i < n; ++i) {
+      ((T*)lhs)[i] = ((const T*)rhs)[i];
     }
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1537,151 +1830,200 @@ namespace Kokkos {
 namespace Impl {
 
 // Compatible functions for 'final' function and value_type not an array
-template< class FunctorType , class ArgTag , bool IsArray = 0 == FunctorValueTraits<FunctorType,ArgTag>::StaticValueSize >
+template <class FunctorType, class ArgTag,
+          bool IsArray =
+              0 == FunctorValueTraits<FunctorType, ArgTag>::StaticValueSize>
 struct FunctorFinalFunction {
-
-  typedef typename FunctorValueTraits<FunctorType,ArgTag>::value_type value_type ;
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type & ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type & ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type & ) );
-
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type volatile & ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type volatile & ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type volatile & ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type volatile & ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type volatile & ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type volatile & ) );
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const & ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const & ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type const & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type const & ) );
-
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const volatile & ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const volatile & ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const volatile & ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const volatile & ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type const volatile & ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type const volatile & ) );
+  typedef
+      typename FunctorValueTraits<FunctorType, ArgTag>::value_type value_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type&) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type&) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag, value_type&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        value_type&));
+
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // , value_type volatile & ) const ); KOKKOS_INLINE_FUNCTION static void
+  // enable_if( void (FunctorType::*)( ArgTag const & , value_type volatile & )
+  // const ); KOKKOS_INLINE_FUNCTION static void enable_if( void
+  // (FunctorType::*)( ArgTag         , value_type volatile & ) );
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // const & , value_type volatile & ) ); KOKKOS_INLINE_FUNCTION static void
+  // enable_if( void (             *)( ArgTag         , value_type volatile & )
+  // ); KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)(
+  // ArgTag const & , value_type volatile & ) );
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type const&) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type const&) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type const&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type const&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag,
+                                                        value_type const&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        value_type const&));
+
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // , value_type const volatile & ) const ); KOKKOS_INLINE_FUNCTION static void
+  // enable_if( void (FunctorType::*)( ArgTag const & , value_type const
+  // volatile & ) const ); KOKKOS_INLINE_FUNCTION static void enable_if( void
+  // (FunctorType::*)( ArgTag         , value_type const volatile & ) );
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // const & , value_type const volatile & ) ); KOKKOS_INLINE_FUNCTION static
+  // void enable_if( void (             *)( ArgTag         , value_type const
+  // volatile & ) ); KOKKOS_INLINE_FUNCTION static void enable_if( void ( *)(
+  // ArgTag const & , value_type const volatile & ) );
 };
 
 // Compatible functions for 'final' function and value_type is an array
-template< class FunctorType , class ArgTag >
-struct FunctorFinalFunction< FunctorType , ArgTag , true > {
-
-  typedef typename FunctorValueTraits<FunctorType,ArgTag>::value_type value_type ;
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type * ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type * ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type * ) );
-
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type volatile * ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type volatile * ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type volatile * ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type volatile * ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type volatile * ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type volatile * ) );
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const * ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const * ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type const * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type const * ) );
-
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const volatile * ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const volatile * ) const );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , value_type const volatile * ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , value_type const volatile * ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , value_type const volatile * ) );
-  // KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , value_type const volatile * ) );
+template <class FunctorType, class ArgTag>
+struct FunctorFinalFunction<FunctorType, ArgTag, true> {
+  typedef
+      typename FunctorValueTraits<FunctorType, ArgTag>::value_type value_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type*) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type*) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag, value_type*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        value_type*));
+
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // , value_type volatile * ) const ); KOKKOS_INLINE_FUNCTION static void
+  // enable_if( void (FunctorType::*)( ArgTag const & , value_type volatile * )
+  // const ); KOKKOS_INLINE_FUNCTION static void enable_if( void
+  // (FunctorType::*)( ArgTag         , value_type volatile * ) );
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // const & , value_type volatile * ) ); KOKKOS_INLINE_FUNCTION static void
+  // enable_if( void (             *)( ArgTag         , value_type volatile * )
+  // ); KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)(
+  // ArgTag const & , value_type volatile * ) );
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type const*) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type const*) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, value_type const*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, value_type const*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag,
+                                                        value_type const*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        value_type const*));
+
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // , value_type const volatile * ) const ); KOKKOS_INLINE_FUNCTION static void
+  // enable_if( void (FunctorType::*)( ArgTag const & , value_type const
+  // volatile * ) const ); KOKKOS_INLINE_FUNCTION static void enable_if( void
+  // (FunctorType::*)( ArgTag         , value_type const volatile * ) );
+  // KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag
+  // const & , value_type const volatile * ) ); KOKKOS_INLINE_FUNCTION static
+  // void enable_if( void (             *)( ArgTag         , value_type const
+  // volatile * ) ); KOKKOS_INLINE_FUNCTION static void enable_if( void ( *)(
+  // ArgTag const & , value_type const volatile * ) );
 };
 
-template< class FunctorType >
-struct FunctorFinalFunction< FunctorType , void , false > {
-
-  typedef typename FunctorValueTraits<FunctorType,void>::value_type value_type ;
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( value_type & ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( value_type & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( value_type & ) );
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( const value_type & ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( const value_type & ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( const value_type & ) );
+template <class FunctorType>
+struct FunctorFinalFunction<FunctorType, void, false> {
+  typedef typename FunctorValueTraits<FunctorType, void>::value_type value_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(value_type&) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(value_type&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(value_type&));
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(const value_type&) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(const value_type&));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(const value_type&));
 };
 
-template< class FunctorType >
-struct FunctorFinalFunction< FunctorType , void , true > {
-
-  typedef typename FunctorValueTraits<FunctorType,void>::value_type value_type ;
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( value_type * ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( value_type * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( value_type * ) );
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( const value_type * ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( const value_type * ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( const value_type * ) );
+template <class FunctorType>
+struct FunctorFinalFunction<FunctorType, void, true> {
+  typedef typename FunctorValueTraits<FunctorType, void>::value_type value_type;
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(value_type*) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(value_type*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(value_type*));
+
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(const value_type*) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(const value_type*));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(const value_type*));
 };
 
 /* No 'final' function provided */
-template< class FunctorType , class ArgTag
-        , class ResultType = typename FunctorValueTraits<FunctorType,ArgTag>::reference_type
-        , class Enable = void >
-struct FunctorFinal
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void final( const FunctorType & , void * ) {}
+template <class FunctorType, class ArgTag,
+          class ResultType =
+              typename FunctorValueTraits<FunctorType, ArgTag>::reference_type,
+          class Enable = void>
+struct FunctorFinal {
+  KOKKOS_FORCEINLINE_FUNCTION static void final(const FunctorType&, void*) {}
 };
 
 /* 'final' function provided */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorFinal
-  < FunctorType
-  , ArgTag
-  , T &
-    // First  substitution failure when FunctorType::final does not exist.
-    // Second substitution failure when enable_if( & Functor::final ) does not exist
-  , decltype( FunctorFinalFunction< FunctorType , ArgTag >::enable_if( & FunctorType::final ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void final( const FunctorType & f , void * p ) { f.final( *((T*)p) ); }
-
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void final( FunctorType & f , void * p ) { f.final( *((T*)p) ); }
+template <class FunctorType, class ArgTag, class T>
+struct FunctorFinal<FunctorType, ArgTag,
+                    T&
+                    // First  substitution failure when FunctorType::final does
+                    // not exist. Second substitution failure when enable_if( &
+                    // Functor::final ) does not exist
+                    ,
+                    decltype(
+                        FunctorFinalFunction<FunctorType, ArgTag>::enable_if(
+                            &FunctorType::final))> {
+  KOKKOS_FORCEINLINE_FUNCTION static void final(const FunctorType& f, void* p) {
+    f.final(*((T*)p));
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION static void final(FunctorType& f, void* p) {
+    f.final(*((T*)p));
+  }
 };
 
 /* 'final' function provided for array value */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorFinal
-  < FunctorType
-  , ArgTag
-  , T *
-    // First  substitution failure when FunctorType::final does not exist.
-    // Second substitution failure when enable_if( & Functor::final ) does not exist
-  , decltype( FunctorFinalFunction< FunctorType , ArgTag >::enable_if( & FunctorType::final ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void final( const FunctorType & f , void * p ) { f.final( (T*)p ); }
-
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void final( FunctorType & f , void * p ) { f.final( (T*)p ); }
+template <class FunctorType, class ArgTag, class T>
+struct FunctorFinal<FunctorType, ArgTag,
+                    T*
+                    // First  substitution failure when FunctorType::final does
+                    // not exist. Second substitution failure when enable_if( &
+                    // Functor::final ) does not exist
+                    ,
+                    decltype(
+                        FunctorFinalFunction<FunctorType, ArgTag>::enable_if(
+                            &FunctorType::final))> {
+  KOKKOS_FORCEINLINE_FUNCTION static void final(const FunctorType& f, void* p) {
+    f.final((T*)p);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION static void final(FunctorType& f, void* p) {
+    f.final((T*)p);
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -1689,82 +2031,86 @@ struct FunctorFinal
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ArgTag
-        , class ReferenceType = typename FunctorValueTraits<FunctorType,ArgTag>::reference_type >
+template <class FunctorType, class ArgTag,
+          class ReferenceType =
+              typename FunctorValueTraits<FunctorType, ArgTag>::reference_type>
 struct FunctorApplyFunction {
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , ReferenceType ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , ReferenceType ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag         , ReferenceType ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ArgTag const & , ReferenceType ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag         , ReferenceType ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ArgTag const & , ReferenceType ) );
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, ReferenceType) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, ReferenceType) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag, ReferenceType));
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ArgTag const&, ReferenceType));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag, ReferenceType));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ArgTag const&,
+                                                        ReferenceType));
 };
 
-template< class FunctorType , class ReferenceType >
-struct FunctorApplyFunction< FunctorType , void , ReferenceType > {
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ReferenceType ) const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)( ReferenceType ) );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (             *)( ReferenceType ) );
+template <class FunctorType, class ReferenceType>
+struct FunctorApplyFunction<FunctorType, void, ReferenceType> {
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ReferenceType) const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(
+      void (FunctorType::*)(ReferenceType));
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ReferenceType));
 };
 
-template< class FunctorType >
-struct FunctorApplyFunction< FunctorType , void , void > {
-
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)() const );
-  KOKKOS_INLINE_FUNCTION static void enable_if( void (FunctorType::*)() );
+template <class FunctorType>
+struct FunctorApplyFunction<FunctorType, void, void> {
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (FunctorType::*)() const);
+  KOKKOS_INLINE_FUNCTION static void enable_if(void (FunctorType::*)());
 };
 
-template< class FunctorType , class ArgTag , class ReferenceType
-        , class Enable = void >
-struct FunctorApply
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void apply( const FunctorType & , void * ) {}
+template <class FunctorType, class ArgTag, class ReferenceType,
+          class Enable = void>
+struct FunctorApply {
+  KOKKOS_FORCEINLINE_FUNCTION static void apply(const FunctorType&, void*) {}
 };
 
 /* 'apply' function provided for void value */
-template< class FunctorType , class ArgTag >
-struct FunctorApply
-  < FunctorType
-  , ArgTag
-  , void
+template <class FunctorType, class ArgTag>
+struct FunctorApply<
+    FunctorType, ArgTag,
+    void
     // First  substitution failure when FunctorType::apply does not exist.
-    // Second substitution failure when enable_if( & Functor::apply ) does not exist
-  , decltype( FunctorApplyFunction< FunctorType , ArgTag , void >::enable_if( & FunctorType::apply ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void apply( FunctorType & f ) { f.apply(); }
-
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void apply( const FunctorType & f ) { f.apply(); }
+    // Second substitution failure when enable_if( & Functor::apply ) does not
+    // exist
+    ,
+    decltype(FunctorApplyFunction<FunctorType, ArgTag, void>::enable_if(
+        &FunctorType::apply))> {
+  KOKKOS_FORCEINLINE_FUNCTION static void apply(FunctorType& f) { f.apply(); }
+
+  KOKKOS_FORCEINLINE_FUNCTION static void apply(const FunctorType& f) {
+    f.apply();
+  }
 };
 
 /* 'apply' function provided for single value */
-template< class FunctorType , class ArgTag , class T >
-struct FunctorApply
-  < FunctorType
-  , ArgTag
-  , T &
-    // First  substitution failure when FunctorType::apply does not exist.
-    // Second substitution failure when enable_if( & Functor::apply ) does not exist
-  , decltype( FunctorApplyFunction< FunctorType , ArgTag >::enable_if( & FunctorType::apply ) )
-  >
-{
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void apply( const FunctorType & f , void * p ) { f.apply( *((T*)p) ); }
-
-  KOKKOS_FORCEINLINE_FUNCTION static
-  void apply( FunctorType & f , void * p ) { f.apply( *((T*)p) ); }
+template <class FunctorType, class ArgTag, class T>
+struct FunctorApply<FunctorType, ArgTag,
+                    T&
+                    // First  substitution failure when FunctorType::apply does
+                    // not exist. Second substitution failure when enable_if( &
+                    // Functor::apply ) does not exist
+                    ,
+                    decltype(
+                        FunctorApplyFunction<FunctorType, ArgTag>::enable_if(
+                            &FunctorType::apply))> {
+  KOKKOS_FORCEINLINE_FUNCTION static void apply(const FunctorType& f, void* p) {
+    f.apply(*((T*)p));
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION static void apply(FunctorType& f, void* p) {
+    f.apply(*((T*)p));
+  }
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* KOKKOS_FUNCTORADAPTER_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_FunctorAnalysis.hpp b/lib/kokkos/core/src/impl/Kokkos_FunctorAnalysis.hpp
index cc4b2af1a20a7b73650093cacbb00300f9ff4a86..a8f3b5042ac3b3328b2b4b2d78b7e8b168cc6e4b 100644
--- a/lib/kokkos/core/src/impl/Kokkos_FunctorAnalysis.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_FunctorAnalysis.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -70,75 +71,74 @@ struct FunctorPatternInterface {
  *  For the REDUCE pattern generate a Reducer and finalization function
  *  derived from what is available within the functor.
  */
-template< typename PatternInterface , class Policy , class Functor >
+template <typename PatternInterface, class Policy, class Functor>
 struct FunctorAnalysis {
-private:
-
-  using FOR    = FunctorPatternInterface::FOR ;
-  using REDUCE = FunctorPatternInterface::REDUCE ;
-  using SCAN   = FunctorPatternInterface::SCAN ;
+ private:
+  using FOR    = FunctorPatternInterface::FOR;
+  using REDUCE = FunctorPatternInterface::REDUCE;
+  using SCAN   = FunctorPatternInterface::SCAN;
 
   //----------------------------------------
 
   struct VOID {};
 
-  template< typename P = Policy , typename = std::false_type >
-  struct has_work_tag
-    {
-      using type = void ;
-      using wtag = VOID ;
-    };
+  template <typename P = Policy, typename = std::false_type>
+  struct has_work_tag {
+    using type = void;
+    using wtag = VOID;
+  };
 
-  template< typename P >
-  struct has_work_tag
-    < P , typename std::is_same< typename P::work_tag , void >::type >
-    {
-      using type = typename P::work_tag ;
-      using wtag = typename P::work_tag ;
-    };
+  template <typename P>
+  struct has_work_tag<P,
+                      typename std::is_same<typename P::work_tag, void>::type> {
+    using type = typename P::work_tag;
+    using wtag = typename P::work_tag;
+  };
 
-  using Tag  = typename has_work_tag<>::type ;
-  using WTag = typename has_work_tag<>::wtag ;
+  using Tag  = typename has_work_tag<>::type;
+  using WTag = typename has_work_tag<>::wtag;
 
   //----------------------------------------
   // Check for T::execution_space
 
-  template< typename T , typename = std::false_type >
-  struct has_execution_space { using type = void ; enum { value = false }; };
+  template <typename T, typename = std::false_type>
+  struct has_execution_space {
+    using type = void;
+    enum { value = false };
+  };
 
-  template< typename T >
-  struct has_execution_space
-    < T , typename std::is_same< typename T::execution_space , void >::type >
-  {
-    using type = typename T::execution_space ;
+  template <typename T>
+  struct has_execution_space<
+      T, typename std::is_same<typename T::execution_space, void>::type> {
+    using type = typename T::execution_space;
     enum { value = true };
   };
 
-  using policy_has_space  = has_execution_space< Policy > ;
-  using functor_has_space = has_execution_space< Functor > ;
+  using policy_has_space  = has_execution_space<Policy>;
+  using functor_has_space = has_execution_space<Functor>;
 
-  static_assert( ! policy_has_space::value ||
-                 ! functor_has_space::value ||
-                 std::is_same< typename policy_has_space::type
-                             , typename functor_has_space::type >::value
-               , "Execution Policy and Functor execution space must match" );
+  static_assert(!policy_has_space::value || !functor_has_space::value ||
+                    std::is_same<typename policy_has_space::type,
+                                 typename functor_has_space::type>::value,
+                "Execution Policy and Functor execution space must match");
 
   //----------------------------------------
   // Check for Functor::value_type, which is either a simple type T or T[]
 
-  template< typename F , typename = std::false_type >
-  struct has_value_type { using type = void ; };
+  template <typename F, typename = std::false_type>
+  struct has_value_type {
+    using type = void;
+  };
 
-  template< typename F >
-  struct has_value_type
-    < F , typename std::is_same< typename F::value_type , void >::type >
-  {
-    using type = typename F::value_type ;
+  template <typename F>
+  struct has_value_type<
+      F, typename std::is_same<typename F::value_type, void>::type> {
+    using type = typename F::value_type;
 
-    static_assert( ! std::is_reference< type >::value &&
-                   std::rank< type >::value <= 1 &&
-                   std::extent< type >::value == 0
-                 , "Kokkos Functor::value_type is T or T[]" );
+    static_assert(!std::is_reference<type>::value &&
+                      std::rank<type>::value <= 1 &&
+                      std::extent<type>::value == 0,
+                  "Kokkos Functor::value_type is T or T[]");
   };
 
   //----------------------------------------
@@ -146,691 +146,666 @@ private:
   // depending upon the pattern and whether the policy has a work tag,
   // to determine the reduction or scan value_type.
 
-  template< typename F
-          , typename P = PatternInterface
-          , typename V = typename has_value_type<F>::type
-          , bool     T = std::is_same< Tag , void >::value
-          >
-  struct deduce_value_type { using type = V ; };
+  template <typename F, typename P = PatternInterface,
+            typename V = typename has_value_type<F>::type,
+            bool T     = std::is_same<Tag, void>::value>
+  struct deduce_value_type {
+    using type = V;
+  };
+
+  template <typename F>
+  struct deduce_value_type<F, REDUCE, void, true> {
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, A&) const);
 
-  template< typename F >
-  struct deduce_value_type< F , REDUCE , void , true > {
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, M, A&) const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , A & ) const );
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, M, M, A&)
+                                               const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , M , A & ) const );
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, M, M, M, A&)
+                                               const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , M , M , A & ) const );
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, M, M, M, M, A&)
+                                               const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , M , M , M , A & ) const );
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, M, M, M, M, M,
+                                                             A&) const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , M , M , M , M , A & ) const );
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, M, M, M, M, M,
+                                                             M, A&) const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , M , M , M , M , M , A & ) const );
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, M, M, M, M, M,
+                                                             M, M, A&) const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , M , M , M , M , M , M , A & ) const );
+    using type = decltype(deduce(&F::operator()));
+  };
+
+  template <typename F>
+  struct deduce_value_type<F, REDUCE, void, false> {
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, M, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, M, M, M,
+                                                             A&) const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, M, M, M,
+                                                             M, A&) const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, M, M, M,
+                                                             M, M, A&) const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, M, M, M,
+                                                             M, M, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, M, M, M,
+                                                             M, M, M, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, M,
+                                                             A&) const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, M,
+                                                             M, A&) const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, M,
+                                                             M, M, A&) const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, M,
+                                                             M, M, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, M,
+                                                             M, M, M, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, M,
+                                                             M, M, M, M, M, A&)
+                                               const);
+
+    template <typename M, typename A>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, M,
+                                                             M, M, M, M, M, M,
+                                                             A&) const);
+
+    using type = decltype(deduce(&F::operator()));
+  };
+
+  template <typename F>
+  struct deduce_value_type<F, SCAN, void, true> {
+    template <typename M, typename A, typename I>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(M, A&, I) const);
+
+    using type = decltype(deduce(&F::operator()));
+  };
+
+  template <typename F>
+  struct deduce_value_type<F, SCAN, void, false> {
+    template <typename M, typename A, typename I>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag, M, A&, I)
+                                               const);
+
+    template <typename M, typename A, typename I>
+    KOKKOS_INLINE_FUNCTION static A deduce(void (Functor::*)(WTag const&, M, A&,
+                                                             I) const);
+
+    using type = decltype(deduce(&F::operator()));
+  };
+
+  //----------------------------------------
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , M , M , M , M , M , M , M , A & ) const );
+  using candidate_type = typename deduce_value_type<Functor>::type;
 
-    using type = decltype( deduce( & F::operator() ) );
+  enum {
+    candidate_is_void  = std::is_same<candidate_type, void>::value,
+    candidate_is_array = std::rank<candidate_type>::value == 1
   };
 
-  template< typename F >
-  struct deduce_value_type< F , REDUCE , void , false > {
+  //----------------------------------------
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , A & ) const );
+ public:
+  using execution_space = typename std::conditional<
+      functor_has_space::value, typename functor_has_space::type,
+      typename std::conditional<policy_has_space::value,
+                                typename policy_has_space::type,
+                                Kokkos::DefaultExecutionSpace>::type>::type;
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , M , A & ) const );
+  using value_type = typename std::remove_extent<candidate_type>::type;
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , M , M , A & ) const );
+  static_assert(!std::is_const<value_type>::value,
+                "Kokkos functor operator reduce argument cannot be const");
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , M , M , M , A & ) const );
+ private:
+  // Stub to avoid defining a type 'void &'
+  using ValueType =
+      typename std::conditional<candidate_is_void, VOID, value_type>::type;
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , M , M , M , M , A & ) const );
+ public:
+  using pointer_type =
+      typename std::conditional<candidate_is_void, void, ValueType*>::type;
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , M , M , M , M , M , A & ) const );
+  using reference_type = typename std::conditional<
+      candidate_is_array, ValueType*,
+      typename std::conditional<!candidate_is_void, ValueType&,
+                                void>::type>::type;
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , M , M , M , M , M , M , A & ) const );
+ private:
+  template <bool IsArray, class FF>
+  KOKKOS_INLINE_FUNCTION static constexpr
+      typename std::enable_if<IsArray, unsigned>::type
+      get_length(FF const& f) {
+    return f.value_count;
+  }
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , M , M , M , M , M , M , M , A & ) const );
+  template <bool IsArray, class FF>
+  KOKKOS_INLINE_FUNCTION static constexpr
+      typename std::enable_if<!IsArray, unsigned>::type
+      get_length(FF const&) {
+    return candidate_is_void ? 0 : 1;
+  }
+
+ public:
+  enum {
+    StaticValueSize =
+        !candidate_is_void && !candidate_is_array ? sizeof(ValueType) : 0
+  };
 
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_count(
+      const Functor& f) {
+    return FunctorAnalysis::template get_length<candidate_is_array>(f);
+  }
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , A & ) const );
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_size(
+      const Functor& f) {
+    return FunctorAnalysis::template get_length<candidate_is_array>(f) *
+           sizeof(ValueType);
+  }
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , M , A & ) const );
+  //----------------------------------------
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , M , M , A & ) const );
+  template <class Unknown>
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_count(
+      const Unknown&) {
+    return candidate_is_void ? 0 : 1;
+  }
+
+  template <class Unknown>
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_size(
+      const Unknown&) {
+    return candidate_is_void ? 0 : sizeof(ValueType);
+  }
+
+ private:
+  enum INTERFACE : int {
+    DISABLE           = 0,
+    NO_TAG_NOT_ARRAY  = 1,
+    NO_TAG_IS_ARRAY   = 2,
+    HAS_TAG_NOT_ARRAY = 3,
+    HAS_TAG_IS_ARRAY  = 4,
+    DEDUCED =
+        !std::is_same<PatternInterface, REDUCE>::value
+            ? DISABLE
+            : (std::is_same<Tag, void>::value
+                   ? (candidate_is_array ? NO_TAG_IS_ARRAY : NO_TAG_NOT_ARRAY)
+                   : (candidate_is_array ? HAS_TAG_IS_ARRAY
+                                         : HAS_TAG_NOT_ARRAY))
+  };
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , M , M , M , A & ) const );
+  //----------------------------------------
+  // parallel_reduce join operator
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , M , M , M , M , A & ) const );
+  template <class F, INTERFACE>
+  struct has_join_function;
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , M , M , M , M , M , A & ) const );
+  template <class F>
+  struct has_join_function<F, NO_TAG_NOT_ARRAY> {
+    typedef volatile ValueType& vref_type;
+    typedef volatile const ValueType& cvref_type;
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , M , M , M , M , M , M , A & ) const );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(vref_type,
+                                                             cvref_type) const);
 
-    template< typename M , typename A >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , M , M , M , M , M , M , M , A & ) const );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(vref_type,
+                                                          cvref_type));
 
-    using type = decltype( deduce( & F::operator() ) );
+    KOKKOS_INLINE_FUNCTION static void join(F const* const f,
+                                            ValueType volatile* dst,
+                                            ValueType volatile const* src) {
+      f->join(*dst, *src);
+    }
   };
 
-  template< typename F >
-  struct deduce_value_type< F , SCAN , void , true > {
+  template <class F>
+  struct has_join_function<F, NO_TAG_IS_ARRAY> {
+    typedef volatile ValueType* vref_type;
+    typedef volatile const ValueType* cvref_type;
 
-    template< typename M , typename A , typename I >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( M , A & , I ) const );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(vref_type,
+                                                             cvref_type) const);
 
-    using type = decltype( deduce( & F::operator() ) );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(vref_type,
+                                                          cvref_type));
+
+    KOKKOS_INLINE_FUNCTION static void join(F const* const f,
+                                            ValueType volatile* dst,
+                                            ValueType volatile const* src) {
+      f->join(dst, src);
+    }
   };
 
-  template< typename F >
-  struct deduce_value_type< F , SCAN , void , false > {
+  template <class F>
+  struct has_join_function<F, HAS_TAG_NOT_ARRAY> {
+    typedef volatile ValueType& vref_type;
+    typedef volatile const ValueType& cvref_type;
+
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag, vref_type,
+                                                             cvref_type) const);
+
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag, vref_type,
+                                                          cvref_type));
 
-    template< typename M , typename A , typename I >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag , M , A & , I ) const );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag const&,
+                                                             vref_type,
+                                                             cvref_type) const);
 
-    template< typename M , typename A , typename I >
-    KOKKOS_INLINE_FUNCTION static
-    A deduce( void (Functor::*)( WTag const & , M , A & , I ) const );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag const&,
+                                                          vref_type,
+                                                          cvref_type));
 
-    using type = decltype( deduce( & F::operator() ) );
+    KOKKOS_INLINE_FUNCTION static void join(F const* const f,
+                                            ValueType volatile* dst,
+                                            ValueType volatile const* src) {
+      f->join(WTag(), *dst, *src);
+    }
   };
 
-  //----------------------------------------
+  template <class F>
+  struct has_join_function<F, HAS_TAG_IS_ARRAY> {
+    typedef volatile ValueType* vref_type;
+    typedef volatile const ValueType* cvref_type;
+
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag, vref_type,
+                                                             cvref_type) const);
+
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag, vref_type,
+                                                          cvref_type));
+
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag const&,
+                                                             vref_type,
+                                                             cvref_type) const);
+
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag const&,
+                                                          vref_type,
+                                                          cvref_type));
+
+    KOKKOS_INLINE_FUNCTION static void join(F const* const f,
+                                            ValueType volatile* dst,
+                                            ValueType volatile const* src) {
+      f->join(WTag(), dst, src);
+    }
+  };
+
+  template <class F = Functor, INTERFACE = DEDUCED, typename = void>
+  struct DeduceJoin {
+    enum { value = false };
+
+    KOKKOS_INLINE_FUNCTION static void join(F const* const f,
+                                            ValueType volatile* dst,
+                                            ValueType volatile const* src) {
+      const int n = FunctorAnalysis::value_count(*f);
+      for (int i = 0; i < n; ++i) dst[i] += src[i];
+    }
+  };
+
+  template <class F>
+  struct DeduceJoin<F, DISABLE, void> {
+    enum { value = false };
 
-  using candidate_type = typename deduce_value_type< Functor >::type ;
+    KOKKOS_INLINE_FUNCTION static void join(F const* const, ValueType volatile*,
+                                            ValueType volatile const*) {}
+  };
 
-  enum { candidate_is_void  = std::is_same< candidate_type , void >::value
-       , candidate_is_array = std::rank< candidate_type >::value == 1 };
+  template <class F, INTERFACE I>
+  struct DeduceJoin<F, I,
+                    decltype(has_join_function<F, I>::enable_if(&F::join))>
+      : public has_join_function<F, I> {
+    enum { value = true };
+  };
 
   //----------------------------------------
 
-public:
+  template <class, INTERFACE>
+  struct has_init_function;
 
-  using execution_space = typename std::conditional
-    < functor_has_space::value
-    , typename functor_has_space::type
-    , typename std::conditional
-      < policy_has_space::value
-      , typename policy_has_space::type
-      , Kokkos::DefaultExecutionSpace
-      >::type
-    >::type ;
+  template <class F>
+  struct has_init_function<F, NO_TAG_NOT_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(ValueType&) const);
 
-  using value_type = typename std::remove_extent< candidate_type >::type ;
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ValueType&));
 
-  static_assert( ! std::is_const< value_type >::value
-               , "Kokkos functor operator reduce argument cannot be const" );
+    KOKKOS_INLINE_FUNCTION static void init(F const* const f, ValueType* dst) {
+      f->init(*dst);
+    }
+  };
 
-private:
+  template <class F>
+  struct has_init_function<F, NO_TAG_IS_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(ValueType*) const);
 
-  // Stub to avoid defining a type 'void &'
-  using ValueType = typename
-    std::conditional< candidate_is_void , VOID , value_type >::type ;
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ValueType*));
 
-public:
+    KOKKOS_INLINE_FUNCTION static void init(F const* const f, ValueType* dst) {
+      f->init(dst);
+    }
+  };
 
-  using pointer_type = typename
-    std::conditional< candidate_is_void , void , ValueType * >::type ;
+  template <class F>
+  struct has_init_function<F, HAS_TAG_NOT_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag, ValueType&)
+                                                     const);
 
-  using reference_type = typename
-    std::conditional< candidate_is_array  , ValueType * , typename
-    std::conditional< ! candidate_is_void , ValueType & , void >
-    ::type >::type ;
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag const&,
+                                                             ValueType&) const);
 
-private:
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag, ValueType&));
 
-  template< bool IsArray , class FF >
-  KOKKOS_INLINE_FUNCTION static constexpr
-  typename std::enable_if< IsArray , unsigned >::type
-  get_length( FF const & f ) { return f.value_count ; }
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag const&,
+                                                          ValueType&));
 
-  template< bool IsArray , class FF >
-  KOKKOS_INLINE_FUNCTION static constexpr
-  typename std::enable_if< ! IsArray , unsigned >::type
-  get_length( FF const & ) { return candidate_is_void ? 0 : 1 ; }
+    KOKKOS_INLINE_FUNCTION static void init(F const* const f, ValueType* dst) {
+      f->init(WTag(), *dst);
+    }
+  };
 
-public:
+  template <class F>
+  struct has_init_function<F, HAS_TAG_IS_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag, ValueType*)
+                                                     const);
 
-  enum { StaticValueSize = ! candidate_is_void &&
-                           ! candidate_is_array
-                         ? sizeof(ValueType) : 0 };
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag const&,
+                                                             ValueType*) const);
 
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr
-  unsigned value_count( const Functor & f )
-    { return FunctorAnalysis::template get_length< candidate_is_array >(f); }
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag, ValueType*));
 
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr
-  unsigned value_size( const Functor & f )
-    { return FunctorAnalysis::template get_length< candidate_is_array >(f) * sizeof(ValueType); }
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag const&,
+                                                          ValueType*));
 
-  //----------------------------------------
+    KOKKOS_INLINE_FUNCTION static void init(F const* const f, ValueType* dst) {
+      f->init(WTag(), dst);
+    }
+  };
 
-  template< class Unknown >
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr
-  unsigned value_count( const Unknown & )
-    { return candidate_is_void ? 0 : 1  ; }
-
-  template< class Unknown >
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr
-  unsigned value_size( const Unknown & )
-    { return candidate_is_void ? 0 : sizeof(ValueType); }
-
-private:
-
-  enum INTERFACE : int
-    { DISABLE           = 0
-    , NO_TAG_NOT_ARRAY  = 1
-    , NO_TAG_IS_ARRAY   = 2
-    , HAS_TAG_NOT_ARRAY = 3
-    , HAS_TAG_IS_ARRAY  = 4
-    , DEDUCED =
-       ! std::is_same< PatternInterface , REDUCE >::value ? DISABLE : (
-       std::is_same<Tag,void>::value
-         ? (candidate_is_array ? NO_TAG_IS_ARRAY  : NO_TAG_NOT_ARRAY)
-         : (candidate_is_array ? HAS_TAG_IS_ARRAY : HAS_TAG_NOT_ARRAY) )
-    };
+  template <class F = Functor, INTERFACE = DEDUCED, typename = void>
+  struct DeduceInit {
+    enum { value = false };
 
-  //----------------------------------------
-  // parallel_reduce join operator
+    KOKKOS_INLINE_FUNCTION static void init(F const* const, ValueType* dst) {
+      new (dst) ValueType();
+    }
+  };
 
-  template< class F , INTERFACE >
-  struct has_join_function ;
-
-  template< class F >
-  struct has_join_function< F , NO_TAG_NOT_ARRAY >
-    {
-      typedef volatile       ValueType & vref_type ;
-      typedef volatile const ValueType & cvref_type ;
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( vref_type , cvref_type ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( vref_type , cvref_type ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void join( F const * const f
-               , ValueType volatile * dst
-               , ValueType volatile const * src )
-        { f->join( *dst , *src ); }
-    };
-
-  template< class F >
-  struct has_join_function< F , NO_TAG_IS_ARRAY >
-    {
-      typedef volatile       ValueType * vref_type ;
-      typedef volatile const ValueType * cvref_type ;
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( vref_type , cvref_type ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( vref_type , cvref_type ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void join( F const * const f
-               , ValueType volatile * dst
-               , ValueType volatile const * src )
-        { f->join( dst , src ); }
-    };
-
-  template< class F >
-  struct has_join_function< F , HAS_TAG_NOT_ARRAY >
-    {
-      typedef volatile       ValueType & vref_type ;
-      typedef volatile const ValueType & cvref_type ;
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag , vref_type , cvref_type ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag , vref_type , cvref_type ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag const & , vref_type , cvref_type ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag const & , vref_type , cvref_type ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void join( F const * const f
-               , ValueType volatile * dst
-               , ValueType volatile const * src )
-        { f->join( WTag() , *dst , *src ); }
-    };
-
-  template< class F >
-  struct has_join_function< F , HAS_TAG_IS_ARRAY >
-    {
-      typedef volatile       ValueType * vref_type ;
-      typedef volatile const ValueType * cvref_type ;
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag , vref_type , cvref_type ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag , vref_type , cvref_type ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag const & , vref_type , cvref_type ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag const & , vref_type , cvref_type ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void join( F const * const f
-               , ValueType volatile * dst
-               , ValueType volatile const * src )
-        { f->join( WTag() , dst , src ); }
-    };
-
-
-  template< class F   = Functor
-          , INTERFACE = DEDUCED
-          , typename  = void >
-  struct DeduceJoin
-    {
-      enum { value = false };
-
-      KOKKOS_INLINE_FUNCTION static
-      void join( F const * const f
-               , ValueType volatile * dst
-               , ValueType volatile const * src )
-       {
-         const int n = FunctorAnalysis::value_count( *f );
-         for ( int i = 0 ; i < n ; ++i ) dst[i] += src[i];
-       }
-    };
-
-  template< class F >
-  struct DeduceJoin< F , DISABLE , void >
-    {
-      enum { value = false };
-
-      KOKKOS_INLINE_FUNCTION static
-      void join( F const * const
-               , ValueType volatile *
-               , ValueType volatile const * ) {}
-    };
-
-  template< class F , INTERFACE I >
-  struct DeduceJoin< F , I ,
-    decltype( has_join_function<F,I>::enable_if( & F::join ) ) >
-    : public has_join_function<F,I>
-    { enum { value = true }; };
+  template <class F>
+  struct DeduceInit<F, DISABLE, void> {
+    enum { value = false };
 
-  //----------------------------------------
+    KOKKOS_INLINE_FUNCTION static void init(F const* const, ValueType*) {}
+  };
 
-  template< class , INTERFACE >
-  struct has_init_function ;
-
-  template< class F >
-  struct has_init_function< F , NO_TAG_NOT_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( ValueType & ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( ValueType & ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void init( F const * const f , ValueType * dst )
-        { f->init( *dst ); }
-    };
-
-  template< class F >
-  struct has_init_function< F , NO_TAG_IS_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( ValueType * ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( ValueType * ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void init( F const * const f , ValueType * dst )
-        { f->init( dst ); }
-    };
-
-  template< class F >
-  struct has_init_function< F , HAS_TAG_NOT_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag , ValueType & ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag const & , ValueType & ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag , ValueType & ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag const & , ValueType & ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void init( F const * const f , ValueType * dst )
-        { f->init( WTag(), *dst ); }
-    };
-
-  template< class F >
-  struct has_init_function< F , HAS_TAG_IS_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag , ValueType * ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag const & , ValueType * ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag , ValueType * ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag const & , ValueType * ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void init( F const * const f , ValueType * dst )
-        { f->init( WTag(), dst ); }
-    };
-
-  template< class F   = Functor
-          , INTERFACE = DEDUCED
-          , typename  = void >
-  struct DeduceInit
-    {
-      enum { value = false };
-
-      KOKKOS_INLINE_FUNCTION static
-      void init( F const * const , ValueType * dst ) { new(dst) ValueType(); }
-    };
-
-  template< class F >
-  struct DeduceInit< F , DISABLE , void >
-    {
-      enum { value = false };
-
-      KOKKOS_INLINE_FUNCTION static
-      void init( F const * const , ValueType * ) {}
-    };
-
-  template< class F , INTERFACE I >
-  struct DeduceInit< F , I ,
-    decltype( has_init_function<F,I>::enable_if( & F::init ) ) >
-    : public has_init_function<F,I>
-    { enum { value = true }; };
+  template <class F, INTERFACE I>
+  struct DeduceInit<F, I,
+                    decltype(has_init_function<F, I>::enable_if(&F::init))>
+      : public has_init_function<F, I> {
+    enum { value = true };
+  };
 
   //----------------------------------------
 
-  template< class , INTERFACE >
-  struct has_final_function ;
+  template <class, INTERFACE>
+  struct has_final_function;
 
   // No tag, not array
-  template< class F >
-  struct has_final_function< F , NO_TAG_NOT_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( ValueType & ) const );
+  template <class F>
+  struct has_final_function<F, NO_TAG_NOT_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(ValueType&) const);
 
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( ValueType & ) );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ValueType&));
 
-      KOKKOS_INLINE_FUNCTION static
-      void final( F const * const f , ValueType * dst )
-        { f->final( *dst ); }
-    };
+    KOKKOS_INLINE_FUNCTION static void final(F const* const f, ValueType* dst) {
+      f->final(*dst);
+    }
+  };
 
   // No tag, is array
-  template< class F >
-  struct has_final_function< F , NO_TAG_IS_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( ValueType * ) const );
+  template <class F>
+  struct has_final_function<F, NO_TAG_IS_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(ValueType*) const);
 
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( ValueType * ) );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(ValueType*));
 
-      KOKKOS_INLINE_FUNCTION static
-      void final( F const * const f , ValueType * dst )
-        { f->final( dst ); }
-    };
+    KOKKOS_INLINE_FUNCTION static void final(F const* const f, ValueType* dst) {
+      f->final(dst);
+    }
+  };
 
   // Has tag, not array
-  template< class F >
-  struct has_final_function< F , HAS_TAG_NOT_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag , ValueType & ) const );
+  template <class F>
+  struct has_final_function<F, HAS_TAG_NOT_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag, ValueType&)
+                                                     const);
 
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag const & , ValueType & ) const );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag const&,
+                                                             ValueType&) const);
 
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag , ValueType & ) );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag, ValueType&));
 
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag const & , ValueType & ) );
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag const&,
+                                                          ValueType&));
 
-      KOKKOS_INLINE_FUNCTION static
-      void final( F const * const f , ValueType * dst )
-        { f->final( WTag(), *dst ); }
-    };
+    KOKKOS_INLINE_FUNCTION static void final(F const* const f, ValueType* dst) {
+      f->final(WTag(), *dst);
+    }
+  };
 
   // Has tag, is array
-  template< class F >
-  struct has_final_function< F , HAS_TAG_IS_ARRAY >
-    {
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag , ValueType * ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (F::*)( WTag const & , ValueType * ) const );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag , ValueType * ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void enable_if( void (*)( WTag const & , ValueType * ) );
-
-      KOKKOS_INLINE_FUNCTION static
-      void final( F const * const f , ValueType * dst )
-        { f->final( WTag(), dst ); }
-    };
-
-  template< class F   = Functor
-          , INTERFACE = DEDUCED
-          , typename  = void >
-  struct DeduceFinal
-    {
-      enum { value = false };
-
-      KOKKOS_INLINE_FUNCTION
-      static void final( F const * const , ValueType * ) {}
-    };
-
-  template< class F , INTERFACE I >
-  struct DeduceFinal< F , I ,
-    decltype( has_final_function<F,I>::enable_if( & F::final ) ) >
-    : public has_final_function<F,I>
-    { enum { value = true }; };
+  template <class F>
+  struct has_final_function<F, HAS_TAG_IS_ARRAY> {
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag, ValueType*)
+                                                     const);
 
-  //----------------------------------------
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (F::*)(WTag const&,
+                                                             ValueType*) const);
 
-  template< class F = Functor , typename = void >
-  struct DeduceTeamShmem
-    {
-      enum { value = false };
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag, ValueType*));
 
-      static size_t team_shmem_size( F const & , int ) { return 0 ; }
-    };
+    KOKKOS_INLINE_FUNCTION static void enable_if(void (*)(WTag const&,
+                                                          ValueType*));
 
-  template< class F >
-  struct DeduceTeamShmem< F , typename std::enable_if< 0 < sizeof( & F::team_shmem_size ) >::type >
-    {
-      enum { value = true };
+    KOKKOS_INLINE_FUNCTION static void final(F const* const f, ValueType* dst) {
+      f->final(WTag(), dst);
+    }
+  };
 
-      static size_t team_shmem_size( F const * const f , int team_size )
-        { return f->team_shmem_size( team_size ); }
-    };
+  template <class F = Functor, INTERFACE = DEDUCED, typename = void>
+  struct DeduceFinal {
+    enum { value = false };
 
-  template< class F >
-  struct DeduceTeamShmem< F , typename std::enable_if< 0 < sizeof( & F::shmem_size ) >::type >
-    {
-      enum { value = true };
+    KOKKOS_INLINE_FUNCTION
+    static void final(F const* const, ValueType*) {}
+  };
 
-      static size_t team_shmem_size( F const * const f , int team_size )
-        { return f->shmem_size( team_size ); }
-    };
+  template <class F, INTERFACE I>
+  struct DeduceFinal<F, I,
+                     decltype(has_final_function<F, I>::enable_if(&F::final))>
+      : public has_final_function<F, I> {
+    enum { value = true };
+  };
 
   //----------------------------------------
 
-public:
-
-  inline static
-  size_t team_shmem_size( Functor const & f )
-    { return DeduceTeamShmem<>::team_shmem_size( f ); }
-
-  //----------------------------------------
+  template <class F = Functor, typename = void>
+  struct DeduceTeamShmem {
+    enum { value = false };
 
-  enum { has_join_member_function  = DeduceJoin<>::value };
-  enum { has_init_member_function  = DeduceInit<>::value };
-  enum { has_final_member_function = DeduceFinal<>::value };
+    static size_t team_shmem_size(F const&, int) { return 0; }
+  };
 
+  template <class F>
+  struct DeduceTeamShmem<
+      F, typename std::enable_if<0 < sizeof(&F::team_shmem_size)>::type> {
+    enum { value = true };
 
-  template< class MemorySpace = typename execution_space::memory_space >
-  struct Reducer
-  {
-  private:
+    static size_t team_shmem_size(F const* const f, int team_size) {
+      return f->team_shmem_size(team_size);
+    }
+  };
 
-    Functor const * const m_functor ;
-    ValueType     * const m_result ;
+  template <class F>
+  struct DeduceTeamShmem<
+      F, typename std::enable_if<0 < sizeof(&F::shmem_size)>::type> {
+    enum { value = true };
 
-    template< bool IsArray >
-    KOKKOS_INLINE_FUNCTION constexpr
-    typename std::enable_if< IsArray , FunctorAnalysis::ValueType * >::type
-    ref() const noexcept { return m_result ; }
+    static size_t team_shmem_size(F const* const f, int team_size) {
+      return f->shmem_size(team_size);
+    }
+  };
 
-    template< bool IsArray >
-    KOKKOS_INLINE_FUNCTION constexpr
-    typename std::enable_if< ! IsArray , FunctorAnalysis::ValueType & >::type
-    ref() const noexcept { return *m_result ; }
+  //----------------------------------------
 
-    template< bool IsArray >
-    KOKKOS_INLINE_FUNCTION constexpr
-    typename std::enable_if< IsArray , int >::type
-    len() const noexcept { return m_functor->value_count ; }
+ public:
+  inline static size_t team_shmem_size(Functor const& f) {
+    return DeduceTeamShmem<>::team_shmem_size(f);
+  }
 
-    template< bool IsArray >
-    KOKKOS_INLINE_FUNCTION constexpr
-    typename std::enable_if< ! IsArray , int >::type
-    len() const noexcept { return candidate_is_void ? 0 : 1 ; }
+  //----------------------------------------
 
-  public:
+  enum { has_join_member_function = DeduceJoin<>::value };
+  enum { has_init_member_function = DeduceInit<>::value };
+  enum { has_final_member_function = DeduceFinal<>::value };
 
-    using reducer        = Reducer ;
-    using value_type     = FunctorAnalysis::value_type ;
-    using memory_space   = MemorySpace ;
-    using reference_type = FunctorAnalysis::reference_type ;
-    using functor_type   = Functor ; // Adapts a functor
+  template <class MemorySpace = typename execution_space::memory_space>
+  struct Reducer {
+   private:
+    Functor const* const m_functor;
+    ValueType* const m_result;
 
+    template <bool IsArray>
     KOKKOS_INLINE_FUNCTION constexpr
-    value_type * data() const noexcept { return m_result ; }
+        typename std::enable_if<IsArray, FunctorAnalysis::ValueType*>::type
+        ref() const noexcept {
+      return m_result;
+    }
 
+    template <bool IsArray>
     KOKKOS_INLINE_FUNCTION constexpr
-    reference_type reference() const noexcept
-      { return Reducer::template ref< candidate_is_array >(); }
-
+        typename std::enable_if<!IsArray, FunctorAnalysis::ValueType&>::type
+        ref() const noexcept {
+      return *m_result;
+    }
+
+    template <bool IsArray>
+    KOKKOS_INLINE_FUNCTION constexpr typename std::enable_if<IsArray, int>::type
+    len() const noexcept {
+      return m_functor->value_count;
+    }
+
+    template <bool IsArray>
     KOKKOS_INLINE_FUNCTION constexpr
-    int length() const noexcept
-      { return Reducer::template len< candidate_is_array >(); }
+        typename std::enable_if<!IsArray, int>::type
+        len() const noexcept {
+      return candidate_is_void ? 0 : 1;
+    }
+
+   public:
+    using reducer        = Reducer;
+    using value_type     = FunctorAnalysis::value_type;
+    using memory_space   = MemorySpace;
+    using reference_type = FunctorAnalysis::reference_type;
+    using functor_type   = Functor;  // Adapts a functor
+
+    KOKKOS_INLINE_FUNCTION constexpr value_type* data() const noexcept {
+      return m_result;
+    }
+
+    KOKKOS_INLINE_FUNCTION constexpr reference_type reference() const noexcept {
+      return Reducer::template ref<candidate_is_array>();
+    }
+
+    KOKKOS_INLINE_FUNCTION constexpr int length() const noexcept {
+      return Reducer::template len<candidate_is_array>();
+    }
 
     KOKKOS_INLINE_FUNCTION
-    void copy( ValueType * const dst
-             , ValueType const * const src ) const noexcept
-      { for ( int i = 0 ; i < Reducer::template len< candidate_is_array >() ; ++i ) dst[i] = src[i] ; }
+    void copy(ValueType* const dst, ValueType const* const src) const noexcept {
+      for (int i = 0; i < Reducer::template len<candidate_is_array>(); ++i)
+        dst[i] = src[i];
+    }
 
     KOKKOS_INLINE_FUNCTION
-    void join( ValueType volatile * dst
-             , ValueType volatile const * src ) const noexcept
-      { DeduceJoin<>::join( m_functor , dst , src ); }
+    void join(ValueType volatile* dst, ValueType volatile const* src) const
+        noexcept {
+      DeduceJoin<>::join(m_functor, dst, src);
+    }
 
-    KOKKOS_INLINE_FUNCTION 
-    void init( ValueType * dst ) const noexcept
-      { DeduceInit<>::init( m_functor , dst ); }
+    KOKKOS_INLINE_FUNCTION
+    void init(ValueType* dst) const noexcept {
+      DeduceInit<>::init(m_functor, dst);
+    }
 
     KOKKOS_INLINE_FUNCTION
-    void final( ValueType * dst ) const noexcept
-      { DeduceFinal<>::final( m_functor , dst ); }
+    void final(ValueType* dst) const noexcept {
+      DeduceFinal<>::final(m_functor, dst);
+    }
 
-    Reducer( Reducer const & ) = default ;
-    Reducer( Reducer && ) = default ;
-    Reducer & operator = ( Reducer const & ) = delete ;
-    Reducer & operator = ( Reducer && ) = delete ;
+    Reducer(Reducer const&) = default;
+    Reducer(Reducer&&)      = default;
+    Reducer& operator=(Reducer const&) = delete;
+    Reducer& operator=(Reducer&&) = delete;
 
-    template< class S >
-    using rebind = Reducer< S > ;
+    template <class S>
+    using rebind = Reducer<S>;
 
-    KOKKOS_INLINE_FUNCTION explicit constexpr
-    Reducer( Functor const * arg_functor = 0
-           , ValueType * arg_value = 0 ) noexcept
-      : m_functor(arg_functor), m_result(arg_value) {}
+    KOKKOS_INLINE_FUNCTION explicit constexpr Reducer(
+        Functor const* arg_functor = 0, ValueType* arg_value = 0) noexcept
+        : m_functor(arg_functor), m_result(arg_value) {}
   };
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* KOKKOS_FUNCTORANALYSIS_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_HBWSpace.cpp b/lib/kokkos/core/src/impl/Kokkos_HBWSpace.cpp
index 680e937db447439cc4562c90a4862d24fc42654c..8a83aef4c9fb04ca5c7546d232c79f2a9c810f2c 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HBWSpace.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HBWSpace.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,6 @@
 //@HEADER
 */
 
-
 #include <Kokkos_Macros.hpp>
 
 #include <cstddef>
@@ -56,6 +56,7 @@
 
 #include <Kokkos_HBWSpace.hpp>
 #include <impl/Kokkos_Error.hpp>
+#include <impl/Kokkos_MemorySpace.hpp>
 #include <Kokkos_Atomic.hpp>
 #ifdef KOKKOS_ENABLE_HBWSPACE
 #include <memkind.h>
@@ -68,7 +69,7 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 #ifdef KOKKOS_ENABLE_HBWSPACE
-#define MEMKIND_TYPE MEMKIND_HBW //hbw_get_kind(HBW_PAGESIZE_4KB)
+#define MEMKIND_TYPE MEMKIND_HBW  // hbw_get_kind(HBW_PAGESIZE_4KB)
 
 /*--------------------------------------------------------------------------*/
 
@@ -76,53 +77,47 @@ namespace Kokkos {
 namespace Experimental {
 
 /* Default allocation mechanism */
-HBWSpace::HBWSpace()
-  : m_alloc_mech(
-     HBWSpace::STD_MALLOC
-    )
-{
-printf("Init\n");
-setenv("MEMKIND_HBW_NODES", "1", 0);
+HBWSpace::HBWSpace() : m_alloc_mech(HBWSpace::STD_MALLOC) {
+  printf("Init\n");
+  setenv("MEMKIND_HBW_NODES", "1", 0);
 }
 
 /* Default allocation mechanism */
-HBWSpace::HBWSpace( const HBWSpace::AllocationMechanism & arg_alloc_mech )
-  : m_alloc_mech( HBWSpace::STD_MALLOC )
-{
-printf("Init2\n");
-setenv("MEMKIND_HBW_NODES", "1", 0);
-  if ( arg_alloc_mech == STD_MALLOC ) {
-    m_alloc_mech = HBWSpace::STD_MALLOC ;
+HBWSpace::HBWSpace(const HBWSpace::AllocationMechanism &arg_alloc_mech)
+    : m_alloc_mech(HBWSpace::STD_MALLOC) {
+  printf("Init2\n");
+  setenv("MEMKIND_HBW_NODES", "1", 0);
+  if (arg_alloc_mech == STD_MALLOC) {
+    m_alloc_mech = HBWSpace::STD_MALLOC;
   }
 }
 
-void * HBWSpace::allocate( const size_t arg_alloc_size ) const
-{
-  static_assert( sizeof(void*) == sizeof(uintptr_t)
-               , "Error sizeof(void*) != sizeof(uintptr_t)" );
-
-  static_assert( Kokkos::Impl::power_of_two< Kokkos::Impl::MEMORY_ALIGNMENT >::value
-               , "Memory alignment must be power of two" );
+void *HBWSpace::allocate(const size_t arg_alloc_size) const {
+  static_assert(sizeof(void *) == sizeof(uintptr_t),
+                "Error sizeof(void*) != sizeof(uintptr_t)");
 
-  constexpr uintptr_t alignment = Kokkos::Impl::MEMORY_ALIGNMENT ;
-  constexpr uintptr_t alignment_mask = alignment - 1 ;
+  static_assert(
+      Kokkos::Impl::power_of_two<Kokkos::Impl::MEMORY_ALIGNMENT>::value,
+      "Memory alignment must be power of two");
 
-  void * ptr = 0 ;
+  constexpr uintptr_t alignment      = Kokkos::Impl::MEMORY_ALIGNMENT;
+  constexpr uintptr_t alignment_mask = alignment - 1;
 
-  if ( arg_alloc_size ) {
+  void *ptr = 0;
 
-    if ( m_alloc_mech == STD_MALLOC ) {
+  if (arg_alloc_size) {
+    if (m_alloc_mech == STD_MALLOC) {
       // Over-allocate to and round up to guarantee proper alignment.
-      size_t size_padded = arg_alloc_size + sizeof(void*) + alignment ;
+      size_t size_padded = arg_alloc_size + sizeof(void *) + alignment;
 
-      void * alloc_ptr = memkind_malloc(MEMKIND_TYPE, size_padded );
+      void *alloc_ptr = memkind_malloc(MEMKIND_TYPE, size_padded);
 
       if (alloc_ptr) {
         uintptr_t address = reinterpret_cast<uintptr_t>(alloc_ptr);
 
         // offset enough to record the alloc_ptr
         address += sizeof(void *);
-        uintptr_t rem = address % alignment;
+        uintptr_t rem    = address % alignment;
         uintptr_t offset = rem ? (alignment - rem) : 0u;
         address += offset;
         ptr = reinterpret_cast<void *>(address);
@@ -133,41 +128,41 @@ void * HBWSpace::allocate( const size_t arg_alloc_size ) const
     }
   }
 
-  if ( ( ptr == 0 ) || ( reinterpret_cast<uintptr_t>(ptr) == ~uintptr_t(0) )
-       || ( reinterpret_cast<uintptr_t>(ptr) & alignment_mask ) ) {
-    std::ostringstream msg ;
-    msg << "Kokkos::Experimental::HBWSpace::allocate[ " ;
-    switch( m_alloc_mech ) {
-    case STD_MALLOC: msg << "STD_MALLOC" ; break ;
+  if ((ptr == 0) || (reinterpret_cast<uintptr_t>(ptr) == ~uintptr_t(0)) ||
+      (reinterpret_cast<uintptr_t>(ptr) & alignment_mask)) {
+    std::ostringstream msg;
+    msg << "Kokkos::Experimental::HBWSpace::allocate[ ";
+    switch (m_alloc_mech) {
+      case STD_MALLOC: msg << "STD_MALLOC"; break;
+    }
+    msg << " ]( " << arg_alloc_size << " ) FAILED";
+    if (ptr == NULL) {
+      msg << " NULL";
+    } else {
+      msg << " NOT ALIGNED " << ptr;
     }
-    msg << " ]( " << arg_alloc_size << " ) FAILED" ;
-    if ( ptr == NULL ) { msg << " NULL" ; }
-    else { msg << " NOT ALIGNED " << ptr ; }
 
-    std::cerr << msg.str() << std::endl ;
+    std::cerr << msg.str() << std::endl;
     std::cerr.flush();
 
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
   return ptr;
 }
 
-
-void HBWSpace::deallocate( void * const arg_alloc_ptr , const size_t arg_alloc_size ) const
-{
-  if ( arg_alloc_ptr ) {
-
-    if ( m_alloc_mech == STD_MALLOC ) {
-      void * alloc_ptr = *(reinterpret_cast<void **>(arg_alloc_ptr) -1);
-      memkind_free(MEMKIND_TYPE, alloc_ptr );
+void HBWSpace::deallocate(void *const arg_alloc_ptr,
+                          const size_t arg_alloc_size) const {
+  if (arg_alloc_ptr) {
+    if (m_alloc_mech == STD_MALLOC) {
+      void *alloc_ptr = *(reinterpret_cast<void **>(arg_alloc_ptr) - 1);
+      memkind_free(MEMKIND_TYPE, alloc_ptr);
     }
-
   }
 }
 
-} // namespace Experimental
-} // namespace Kokkos
+}  // namespace Experimental
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -176,142 +171,143 @@ namespace Kokkos {
 namespace Impl {
 
 #ifdef KOKKOS_DEBUG
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void>
+    SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::s_root_record;
 #endif
 
-void
-SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::
-deallocate( SharedAllocationRecord< void , void > * arg_rec )
-{
-  delete static_cast<SharedAllocationRecord*>(arg_rec);
+void SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::deallocate(
+    SharedAllocationRecord<void, void> *arg_rec) {
+  delete static_cast<SharedAllocationRecord *>(arg_rec);
 }
 
-SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::
-~SharedAllocationRecord()
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+SharedAllocationRecord<Kokkos::Experimental::HBWSpace,
+                       void>::~SharedAllocationRecord() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::deallocateData(
-      Kokkos::Profiling::SpaceHandle(Kokkos::Experimental::HBWSpace::name()),RecordBase::m_alloc_ptr->m_label,
-      data(),size());
+        Kokkos::Profiling::SpaceHandle(Kokkos::Experimental::HBWSpace::name()),
+        RecordBase::m_alloc_ptr->m_label, data(), size());
   }
-  #endif
+#endif
 
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::
-SharedAllocationRecord( const Kokkos::Experimental::HBWSpace & arg_space
-                      , const std::string       & arg_label
-                      , const size_t              arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::
+    SharedAllocationRecord(
+        const Kokkos::Experimental::HBWSpace &arg_space,
+        const std::string &arg_label, const size_t arg_alloc_size,
+        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-        & SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::Experimental::HBWSpace,
+                                  void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_space( arg_space )
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Profiling::allocateData(Kokkos::Profiling::SpaceHandle(arg_space.name()),arg_label,data(),arg_alloc_size);
+          Impl::checked_allocation_with_header(arg_space, arg_label,
+                                               arg_alloc_size),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_space(arg_space) {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::allocateData(
+        Kokkos::Profiling::SpaceHandle(arg_space.name()), arg_label, data(),
+        arg_alloc_size);
   }
-  #endif
+#endif
 
   // Fill in the Header information
-  RecordBase::m_alloc_ptr->m_record = static_cast< SharedAllocationRecord< void , void > * >( this );
+  RecordBase::m_alloc_ptr->m_record =
+      static_cast<SharedAllocationRecord<void, void> *>(this);
 
-  strncpy( RecordBase::m_alloc_ptr->m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(RecordBase::m_alloc_ptr->m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
   // Set last element zero, in case c_str is too long
-  RecordBase::m_alloc_ptr->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0;
+  RecordBase::m_alloc_ptr
+      ->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
 }
 
 //----------------------------------------------------------------------------
 
-void * SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::
-allocate_tracked( const Kokkos::Experimental::HBWSpace & arg_space
-                , const std::string & arg_alloc_label
-                , const size_t arg_alloc_size )
-{
-  if ( ! arg_alloc_size ) return (void *) 0 ;
+void *
+SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::allocate_tracked(
+    const Kokkos::Experimental::HBWSpace &arg_space,
+    const std::string &arg_alloc_label, const size_t arg_alloc_size) {
+  if (!arg_alloc_size) return (void *)0;
 
-  SharedAllocationRecord * const r =
-    allocate( arg_space , arg_alloc_label , arg_alloc_size );
+  SharedAllocationRecord *const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
 
-  RecordBase::increment( r );
+  RecordBase::increment(r);
 
   return r->data();
 }
 
-void SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::
-deallocate_tracked( void * const arg_alloc_ptr )
-{
-  if ( arg_alloc_ptr != 0 ) {
-    SharedAllocationRecord * const r = get_record( arg_alloc_ptr );
+void SharedAllocationRecord<Kokkos::Experimental::HBWSpace,
+                            void>::deallocate_tracked(void *const
+                                                          arg_alloc_ptr) {
+  if (arg_alloc_ptr != 0) {
+    SharedAllocationRecord *const r = get_record(arg_alloc_ptr);
 
-    RecordBase::decrement( r );
+    RecordBase::decrement(r);
   }
 }
 
-void * SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::
-reallocate_tracked( void * const arg_alloc_ptr
-                  , const size_t arg_alloc_size )
-{
-  SharedAllocationRecord * const r_old = get_record( arg_alloc_ptr );
-  SharedAllocationRecord * const r_new = allocate( r_old->m_space , r_old->get_label() , arg_alloc_size );
+void *SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::
+    reallocate_tracked(void *const arg_alloc_ptr, const size_t arg_alloc_size) {
+  SharedAllocationRecord *const r_old = get_record(arg_alloc_ptr);
+  SharedAllocationRecord *const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
 
-  Kokkos::Impl::DeepCopy<Kokkos::Experimental::HBWSpace,Kokkos::Experimental::HBWSpace>( r_new->data() , r_old->data()
-                                             , std::min( r_old->size() , r_new->size() ) );
+  Kokkos::Impl::DeepCopy<Kokkos::Experimental::HBWSpace,
+                         Kokkos::Experimental::HBWSpace>(
+      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
 
-  RecordBase::increment( r_new );
-  RecordBase::decrement( r_old );
+  RecordBase::increment(r_new);
+  RecordBase::decrement(r_old);
 
   return r_new->data();
 }
 
-SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void > *
-SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::get_record( void * alloc_ptr )
-{
-  typedef SharedAllocationHeader  Header ;
-  typedef SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >  RecordHost ;
-
-  SharedAllocationHeader const * const head   = alloc_ptr ? Header::get_header( alloc_ptr ) : (SharedAllocationHeader *)0 ;
-  RecordHost                   * const record = head ? static_cast< RecordHost * >( head->m_record ) : (RecordHost *) 0 ;
-
-  if ( ! alloc_ptr || record->m_alloc_ptr != head ) {
-    Kokkos::Impl::throw_runtime_exception( std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::get_record ERROR" ) );
+SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>
+    *SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::get_record(
+        void *alloc_ptr) {
+  typedef SharedAllocationHeader Header;
+  typedef SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>
+      RecordHost;
+
+  SharedAllocationHeader const *const head =
+      alloc_ptr ? Header::get_header(alloc_ptr) : (SharedAllocationHeader *)0;
+  RecordHost *const record =
+      head ? static_cast<RecordHost *>(head->m_record) : (RecordHost *)0;
+
+  if (!alloc_ptr || record->m_alloc_ptr != head) {
+    Kokkos::Impl::throw_runtime_exception(std::string(
+        "Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::HBWSpace "
+        ", void >::get_record ERROR"));
   }
 
-  return record ;
+  return record;
 }
 
 // Iterate records to print orphaned memory ...
-void SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >::
-print_records( std::ostream & s , const Kokkos::Experimental::HBWSpace & space , bool detail )
-{
+void SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::
+    print_records(std::ostream &s, const Kokkos::Experimental::HBWSpace &space,
+                  bool detail) {
 #ifdef KOKKOS_DEBUG
-  SharedAllocationRecord< void , void >::print_host_accessible_records( s , "HBWSpace" , & s_root_record , detail );
+  SharedAllocationRecord<void, void>::print_host_accessible_records(
+      s, "HBWSpace", &s_root_record, detail);
 #else
-  throw_runtime_exception("SharedAllocationRecord<HBWSpace>::print_records"
+  throw_runtime_exception(
+      "SharedAllocationRecord<HBWSpace>::print_records"
       " only works with KOKKOS_DEBUG enabled");
 #endif
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
@@ -319,33 +315,35 @@ print_records( std::ostream & s , const Kokkos::Experimental::HBWSpace & space ,
 namespace Kokkos {
 namespace Experimental {
 namespace {
-  const unsigned HBW_SPACE_ATOMIC_MASK = 0xFFFF;
-  const unsigned HBW_SPACE_ATOMIC_XOR_MASK = 0x5A39;
-  static int HBW_SPACE_ATOMIC_LOCKS[HBW_SPACE_ATOMIC_MASK+1];
-}
+const unsigned HBW_SPACE_ATOMIC_MASK     = 0xFFFF;
+const unsigned HBW_SPACE_ATOMIC_XOR_MASK = 0x5A39;
+static int HBW_SPACE_ATOMIC_LOCKS[HBW_SPACE_ATOMIC_MASK + 1];
+}  // namespace
 
 namespace Impl {
 void init_lock_array_hbw_space() {
   static int is_initialized = 0;
-  if(! is_initialized)
-    for(int i = 0; i < static_cast<int> (HBW_SPACE_ATOMIC_MASK+1); i++)
+  if (!is_initialized)
+    for (int i = 0; i < static_cast<int>(HBW_SPACE_ATOMIC_MASK + 1); i++)
       HBW_SPACE_ATOMIC_LOCKS[i] = 0;
 }
 
-bool lock_address_hbw_space(void* ptr) {
-  return 0 == atomic_compare_exchange( &HBW_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HBW_SPACE_ATOMIC_MASK) ^ HBW_SPACE_ATOMIC_XOR_MASK] ,
-                                  0 , 1);
+bool lock_address_hbw_space(void *ptr) {
+  return 0 == atomic_compare_exchange(
+                  &HBW_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) &
+                                           HBW_SPACE_ATOMIC_MASK) ^
+                                          HBW_SPACE_ATOMIC_XOR_MASK],
+                  0, 1);
 }
 
-void unlock_address_hbw_space(void* ptr) {
-   atomic_exchange( &HBW_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HBW_SPACE_ATOMIC_MASK) ^ HBW_SPACE_ATOMIC_XOR_MASK] ,
-                    0);
+void unlock_address_hbw_space(void *ptr) {
+  atomic_exchange(
+      &HBW_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) & HBW_SPACE_ATOMIC_MASK) ^
+                              HBW_SPACE_ATOMIC_XOR_MASK],
+      0);
 }
 
-}
-}
-}
+}  // namespace Impl
+}  // namespace Experimental
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_HostBarrier.cpp b/lib/kokkos/core/src/impl/Kokkos_HostBarrier.cpp
index 347a8b50ba06fbb913d7ce77f097e2e63f96c89e..0b96add432f859d50a93a7aaae133379266756b4 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HostBarrier.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HostBarrier.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,63 +49,60 @@
 
 #include <impl/Kokkos_HostBarrier.hpp>
 
-#if !defined( _WIN32 )
-  #include <sched.h>
-  #include <time.h>
+#if !defined(_WIN32)
+#include <sched.h>
+#include <time.h>
 #else
-  #include <process.h>
-  #include <winsock2.h>
-  #include <windows.h>
+#include <process.h>
+#include <winsock2.h>
+#include <windows.h>
 #endif
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
-void HostBarrier::impl_backoff_wait_until_equal( int * ptr
-                                               , const int v
-                                               , const bool active_wait
-                                               ) noexcept
-{
-  #if !defined( _WIN32 )
-  timespec req ;
-  req.tv_sec  = 0 ;
+void HostBarrier::impl_backoff_wait_until_equal(
+    int* ptr, const int v, const bool active_wait) noexcept {
+#if !defined(_WIN32)
+  timespec req;
+  req.tv_sec     = 0;
   unsigned count = 0u;
 
-  while (!test_equal( ptr, v )) {
+  while (!test_equal(ptr, v)) {
     const int c = ::Kokkos::log2(++count);
-    if ( !active_wait || c > log2_iterations_till_sleep) {
-      req.tv_nsec = c < 16 ? 256*c : 4096;
-      nanosleep( &req, nullptr );
-    }
-    else if (c > log2_iterations_till_yield) {
+    if (!active_wait || c > log2_iterations_till_sleep) {
+      req.tv_nsec = c < 16 ? 256 * c : 4096;
+      nanosleep(&req, nullptr);
+    } else if (c > log2_iterations_till_yield) {
       sched_yield();
     }
-    #if defined( KOKKOS_ENABLE_ASM )
-    #if   defined( __PPC64__ )
-    for (int j=0; j<num_nops; ++j) {
-      asm volatile( "nop\n" );
+#if defined(KOKKOS_ENABLE_ASM)
+#if defined(__PPC64__)
+    for (int j = 0; j < num_nops; ++j) {
+      asm volatile("nop\n");
     }
-    asm volatile( "or 27, 27, 27" ::: "memory" );
-    #elif defined( __amd64 )  || defined( __amd64__ ) || \
-          defined( __x86_64 ) || defined( __x86_64__ )
-    for (int j=0; j<num_nops; ++j) {
-      asm volatile( "nop\n" );
+    asm volatile("or 27, 27, 27" ::: "memory");
+#elif defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
+    defined(__x86_64__)
+    for (int j = 0; j < num_nops; ++j) {
+      asm volatile("nop\n");
     }
-    asm volatile( "pause\n":::"memory" );
-    #endif
-    #endif
+    asm volatile("pause\n" ::: "memory");
+#endif
+#endif
   }
-  #else // _WIN32
+#else  // _WIN32
   while (!try_wait()) {
-    #if defined( KOKKOS_ENABLE_ASM )
-    for (int j=0; j<num_nops; ++j) {
-      __asm__ __volatile__( "nop\n" );
+#if defined(KOKKOS_ENABLE_ASM)
+    for (int j = 0; j < num_nops; ++j) {
+      __asm__ __volatile__("nop\n");
     }
-    __asm__ __volatile__( "pause\n":::"memory" );
-    #endif
+    __asm__ __volatile__("pause\n" ::: "memory");
+#endif
   }
-  #endif
-  //printf("W: %d\n", count);
+#endif
+  // printf("W: %d\n", count);
 }
 
-}} // namespace Kokkos::Impl
-
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_HostBarrier.hpp b/lib/kokkos/core/src/impl/Kokkos_HostBarrier.hpp
index f7f1c4b50ff1137559b3450c7f291224b19539b5..ce7a1408a3dc742f3e32982aae9fd7e80fda7d29 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HostBarrier.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HostBarrier.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,8 @@
 #include <Kokkos_Macros.hpp>
 #include <Kokkos_Atomic.hpp>
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 // class HostBarrier
 //
@@ -55,8 +57,8 @@ namespace Kokkos { namespace Impl {
 // of execution.
 //
 // *buffer* is a shared resource between the threads of execution
-// *step* should be a stack variable associated with the current thread of execution
-// *size* is the number of threads which share the barrier
+// *step* should be a stack variable associated with the current thread of
+// execution *size* is the number of threads which share the barrier
 //
 // before calling any arrive type function the buffer and step must have been
 // initialized to 0 and one of the following conditions must be true
@@ -70,16 +72,16 @@ namespace Kokkos { namespace Impl {
 // The purporse of the split functions is to allow the last thread to arrive
 // an opportunity to perform some actions before releasing the waiting threads
 //
-// If all threads have arrived (and split_release has been call if using split_arrive)
-// before a wait type call, the wait may return quickly
-class HostBarrier
-{
-public:
-  using buffer_type = int;
-  static constexpr int required_buffer_size   = 128;
-  static constexpr int required_buffer_length = required_buffer_size / sizeof(int);
-
-private:
+// If all threads have arrived (and split_release has been call if using
+// split_arrive) before a wait type call, the wait may return quickly
+class HostBarrier {
+ public:
+  using buffer_type                         = int;
+  static constexpr int required_buffer_size = 128;
+  static constexpr int required_buffer_length =
+      required_buffer_size / sizeof(int);
+
+ private:
   // fit the following 3 atomics within a 128 bytes while
   // keeping the arrive atomic at least 64 bytes away from
   // the wait atomic to reduce contention on the caches
@@ -87,30 +89,25 @@ private:
   static constexpr int master_idx = 64 / sizeof(int);
   static constexpr int wait_idx   = 96 / sizeof(int);
 
-
   static constexpr int num_nops                   = 32;
   static constexpr int iterations_till_backoff    = 64;
   static constexpr int log2_iterations_till_yield = 4;
   static constexpr int log2_iterations_till_sleep = 6;
 
-public:
-
+ public:
   // will return true if call is the last thread to arrive
   KOKKOS_INLINE_FUNCTION
-  static bool split_arrive( int * buffer
-                          , const int size
-                          , int & step
-                          , const bool master_wait = true
-                          ) noexcept
-  {
+  static bool split_arrive(int* buffer, const int size, int& step,
+                           const bool master_wait = true) noexcept {
     if (size <= 1) return true;
 
     ++step;
     Kokkos::memory_fence();
-    const bool result = Kokkos::atomic_fetch_add( buffer + arrive_idx, 1 ) == size-1;
+    const bool result =
+        Kokkos::atomic_fetch_add(buffer + arrive_idx, 1) == size - 1;
 
     if (master_wait && result) {
-      Kokkos::atomic_fetch_add( buffer + master_idx, 1 );
+      Kokkos::atomic_fetch_add(buffer + master_idx, 1);
     }
 
     return result;
@@ -120,37 +117,26 @@ public:
   // only the thread which received a return value of true from split_arrive
   // or the thread which calls split_master_wait may call split_release
   KOKKOS_INLINE_FUNCTION
-  static void split_release( int * buffer
-                           , const int size
-                           , const int /*step*/
-                           ) noexcept
-  {
+  static void split_release(int* buffer, const int size, const int /*step*/
+                            ) noexcept {
     if (size <= 1) return;
     Kokkos::memory_fence();
-    Kokkos::atomic_fetch_sub( buffer + arrive_idx, size );
-    Kokkos::atomic_fetch_add( buffer + wait_idx, 1 );
+    Kokkos::atomic_fetch_sub(buffer + arrive_idx, size);
+    Kokkos::atomic_fetch_add(buffer + wait_idx, 1);
   }
 
-  // should only be called by the master thread, will allow the master thread to resume
-  // after all threads have arrived
+  // should only be called by the master thread, will allow the master thread to
+  // resume after all threads have arrived
   KOKKOS_INLINE_FUNCTION
-  static void split_master_wait( int * buffer
-                               , const int size
-                               , const int step
-                               , const bool active_wait = true
-                               ) noexcept
-  {
+  static void split_master_wait(int* buffer, const int size, const int step,
+                                const bool active_wait = true) noexcept {
     if (size <= 1) return;
-    wait_until_equal( buffer + master_idx, step, active_wait );
+    wait_until_equal(buffer + master_idx, step, active_wait);
   }
 
   // arrive, last thread automatically release waiting threads
   KOKKOS_INLINE_FUNCTION
-  static void arrive( int * buffer
-                    , const int size
-                    , int & step
-                    ) noexcept
-  {
+  static void arrive(int* buffer, const int size, int& step) noexcept {
     if (size <= 1) return;
     if (split_arrive(buffer, size, step)) {
       split_release(buffer, size, step);
@@ -159,84 +145,59 @@ public:
 
   // test if all threads have arrived
   KOKKOS_INLINE_FUNCTION
-  static bool try_wait( int * buffer
-                      , const int size
-                      , const int step
-                      ) noexcept
-  {
+  static bool try_wait(int* buffer, const int size, const int step) noexcept {
     if (size <= 1) return true;
-    return test_equal( buffer + wait_idx, step );
+    return test_equal(buffer + wait_idx, step);
   }
 
   // wait for all threads to arrive
   KOKKOS_INLINE_FUNCTION
-  static void wait( int * buffer
-                  , const int size
-                  , const int step
-                  , bool active_wait = true
-                  ) noexcept
-  {
+  static void wait(int* buffer, const int size, const int step,
+                   bool active_wait = true) noexcept {
     if (size <= 1) return;
-    wait_until_equal( buffer + wait_idx, step, active_wait );
+    wait_until_equal(buffer + wait_idx, step, active_wait);
   }
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  bool split_arrive( const bool master_wait = true ) const noexcept
-  {
-    return split_arrive( m_buffer, m_size, m_step, master_wait );
+  bool split_arrive(const bool master_wait = true) const noexcept {
+    return split_arrive(m_buffer, m_size, m_step, master_wait);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void split_release() const noexcept
-  {
+  void split_release() const noexcept {
     split_release(m_buffer, m_size, m_step);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void split_master_wait( const bool active_wait = true) noexcept
-  {
-    split_master_wait( m_buffer, m_size, m_step,  active_wait );
+  void split_master_wait(const bool active_wait = true) noexcept {
+    split_master_wait(m_buffer, m_size, m_step, active_wait);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void arrive() const noexcept
-  {
-    return arrive( m_buffer, m_size, m_step );
-  }
+  void arrive() const noexcept { return arrive(m_buffer, m_size, m_step); }
 
   KOKKOS_INLINE_FUNCTION
-  bool try_wait() const noexcept
-  {
-    return try_wait( m_buffer, m_size, m_step );
-  }
+  bool try_wait() const noexcept { return try_wait(m_buffer, m_size, m_step); }
 
   KOKKOS_INLINE_FUNCTION
-  void wait() const noexcept
-  {
-    wait( m_buffer, m_size, m_step );
-  }
+  void wait() const noexcept { wait(m_buffer, m_size, m_step); }
 
-  HostBarrier()                             = default;
-  HostBarrier( HostBarrier && )             = default;
-  HostBarrier & operator=( HostBarrier && ) = default;
+  HostBarrier()              = default;
+  HostBarrier(HostBarrier&&) = default;
+  HostBarrier& operator=(HostBarrier&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  HostBarrier( int size, int * buffer )
-    : m_size{size}
-    , m_step{0u}
-    , m_buffer{ buffer }
-  {}
+  HostBarrier(int size, int* buffer)
+      : m_size{size}, m_step{0u}, m_buffer{buffer} {}
 
-  HostBarrier( const HostBarrier &  )             = delete;
-  HostBarrier & operator=( const HostBarrier &  ) = delete;
+  HostBarrier(const HostBarrier&) = delete;
+  HostBarrier& operator=(const HostBarrier&) = delete;
 
-private:
+ private:
   KOKKOS_INLINE_FUNCTION
-  static bool test_equal( int * ptr, int v ) noexcept
-  {
-    const bool result = Kokkos::atomic_fetch_add( ptr, 0 ) == v;
+  static bool test_equal(int* ptr, int v) noexcept {
+    const bool result = Kokkos::atomic_fetch_add(ptr, 0) == v;
     if (result) {
       Kokkos::memory_fence();
     }
@@ -244,55 +205,51 @@ private:
   }
 
   KOKKOS_INLINE_FUNCTION
-  static void wait_until_equal( int * ptr
-                              , const int v
-                              , bool active_wait = true
-                              ) noexcept
-  {
-    #if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
-    bool result = test_equal( ptr, v );
-    for (int i=0; !result && i < iterations_till_backoff; ++i) {
-      #if defined( KOKKOS_ENABLE_ASM )
-      #if   defined( _WIN32 )
-      for (int j=0; j<num_nops; ++j) {
-        __asm__ __volatile__( "nop\n" );
+  static void wait_until_equal(int* ptr, const int v,
+                               bool active_wait = true) noexcept {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    bool result = test_equal(ptr, v);
+    for (int i = 0; !result && i < iterations_till_backoff; ++i) {
+#if defined(KOKKOS_ENABLE_ASM)
+#if defined(_WIN32)
+      for (int j = 0; j < num_nops; ++j) {
+        __asm__ __volatile__("nop\n");
       }
-      __asm__ __volatile__( "pause\n":::"memory" );
-      #elif defined( __PPC64__ )
-      for (int j=0; j<num_nops; ++j) {
-        asm volatile( "nop\n" );
+      __asm__ __volatile__("pause\n" ::: "memory");
+#elif defined(__PPC64__)
+      for (int j = 0; j < num_nops; ++j) {
+        asm volatile("nop\n");
       }
-      asm volatile( "or 27, 27, 27" ::: "memory" );
-      #elif defined( __amd64 ) || defined( __amd64__ ) || \
-            defined( __x86_64 ) || defined( __x86_64__ )
-      for (int j=0; j<num_nops; ++j) {
-        asm volatile( "nop\n" );
+      asm volatile("or 27, 27, 27" ::: "memory");
+#elif defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
+    defined(__x86_64__)
+      for (int j = 0; j < num_nops; ++j) {
+        asm volatile("nop\n");
       }
-      asm volatile( "pause\n":::"memory" );
-      #endif
-      #endif
-      result = test_equal( ptr, v );
+      asm volatile("pause\n" ::: "memory");
+#endif
+#endif
+      result = test_equal(ptr, v);
     }
     if (!result) {
-      impl_backoff_wait_until_equal( ptr, v, active_wait );
+      impl_backoff_wait_until_equal(ptr, v, active_wait);
     }
-    #else
-    while( !test_equal(ptr, v) ) {}
-    #endif
+#else
+    while (!test_equal(ptr, v)) {
+    }
+#endif
   }
 
-  static void impl_backoff_wait_until_equal( int * ptr
-                                           , const int v
-                                           , const bool active_wait
-                                           ) noexcept;
+  static void impl_backoff_wait_until_equal(int* ptr, const int v,
+                                            const bool active_wait) noexcept;
 
-private:
-  int         m_size   {0};
-  mutable int m_step   {0};
-  int *       m_buffer {nullptr};
+ private:
+  int m_size{0};
+  mutable int m_step{0};
+  int* m_buffer{nullptr};
 };
 
-}} // namespace Kokkos::Impl
-
-#endif // KOKKOS_HOST_BARRIER_HPP
+}  // namespace Impl
+}  // namespace Kokkos
 
+#endif  // KOKKOS_HOST_BARRIER_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_HostSpace.cpp b/lib/kokkos/core/src/impl/Kokkos_HostSpace.cpp
index 848746d265946cb8b9d4e362581a7011ccc58ba2..94490b83001b54c0f52eb3f5397aa026e9260fb5 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HostSpace.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HostSpace.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,15 +42,18 @@
 //@HEADER
 */
 
+#include <cstdio>
 #include <algorithm>
 #include <Kokkos_Macros.hpp>
+#include <impl/Kokkos_Error.hpp>
+#include <impl/Kokkos_MemorySpace.hpp>
 #if defined(KOKKOS_ENABLE_PROFILING)
 #include <impl/Kokkos_Profiling_Interface.hpp>
 #endif
 
 /*--------------------------------------------------------------------------*/
 
-#if defined( __INTEL_COMPILER ) && ! defined ( KOKKOS_ENABLE_CUDA )
+#if defined(__INTEL_COMPILER) && !defined(KOKKOS_ENABLE_CUDA)
 
 // Intel specialized allocator does not interoperate with CUDA memory allocation
 
@@ -66,20 +70,21 @@
 
 /* mmap flags for private anonymous memory allocation */
 
-#if defined( MAP_ANONYMOUS ) && defined( MAP_PRIVATE )
-  #define KOKKOS_IMPL_POSIX_MMAP_FLAGS (MAP_PRIVATE | MAP_ANONYMOUS)
-#elif defined( MAP_ANON ) && defined( MAP_PRIVATE )
-  #define KOKKOS_IMPL_POSIX_MMAP_FLAGS (MAP_PRIVATE | MAP_ANON)
+#if defined(MAP_ANONYMOUS) && defined(MAP_PRIVATE)
+#define KOKKOS_IMPL_POSIX_MMAP_FLAGS (MAP_PRIVATE | MAP_ANONYMOUS)
+#elif defined(MAP_ANON) && defined(MAP_PRIVATE)
+#define KOKKOS_IMPL_POSIX_MMAP_FLAGS (MAP_PRIVATE | MAP_ANON)
 #endif
 
 // mmap flags for huge page tables
 // the Cuda driver does not interoperate with MAP_HUGETLB
-#if defined( KOKKOS_IMPL_POSIX_MMAP_FLAGS )
-  #if defined( MAP_HUGETLB ) && ! defined( KOKKOS_ENABLE_CUDA )
-    #define KOKKOS_IMPL_POSIX_MMAP_FLAGS_HUGE (KOKKOS_IMPL_POSIX_MMAP_FLAGS | MAP_HUGETLB )
-  #else
-    #define KOKKOS_IMPL_POSIX_MMAP_FLAGS_HUGE KOKKOS_IMPL_POSIX_MMAP_FLAGS
-  #endif
+#if defined(KOKKOS_IMPL_POSIX_MMAP_FLAGS)
+#if defined(MAP_HUGETLB) && !defined(KOKKOS_ENABLE_CUDA)
+#define KOKKOS_IMPL_POSIX_MMAP_FLAGS_HUGE \
+  (KOKKOS_IMPL_POSIX_MMAP_FLAGS | MAP_HUGETLB)
+#else
+#define KOKKOS_IMPL_POSIX_MMAP_FLAGS_HUGE KOKKOS_IMPL_POSIX_MMAP_FLAGS
+#endif
 #endif
 
 #endif
@@ -99,7 +104,8 @@
 #include <impl/Kokkos_Error.hpp>
 #include <Kokkos_Atomic.hpp>
 
-#if ( defined( KOKKOS_ENABLE_ASM ) || defined ( KOKKOS_ENABLE_TM ) ) && defined ( KOKKOS_ENABLE_ISA_X86_64 )
+#if (defined(KOKKOS_ENABLE_ASM) || defined(KOKKOS_ENABLE_TM)) && \
+    defined(KOKKOS_ENABLE_ISA_X86_64) && !defined(KOKKOS_COMPILER_PGI)
 #include <immintrin.h>
 #endif
 
@@ -110,80 +116,81 @@ namespace Kokkos {
 
 /* Default allocation mechanism */
 HostSpace::HostSpace()
-  : m_alloc_mech(
-#if defined( KOKKOS_ENABLE_INTEL_MM_ALLOC )
-      HostSpace::INTEL_MM_ALLOC
-#elif defined( KOKKOS_IMPL_POSIX_MMAP_FLAGS )
-      HostSpace::POSIX_MMAP
-#elif defined( KOKKOS_ENABLE_POSIX_MEMALIGN )
-      HostSpace::POSIX_MEMALIGN
+    : m_alloc_mech(
+#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
+          HostSpace::INTEL_MM_ALLOC
+#elif defined(KOKKOS_IMPL_POSIX_MMAP_FLAGS)
+          HostSpace::POSIX_MMAP
+#elif defined(KOKKOS_ENABLE_POSIX_MEMALIGN)
+          HostSpace::POSIX_MEMALIGN
 #else
-      HostSpace::STD_MALLOC
+          HostSpace::STD_MALLOC
 #endif
-    )
-{}
+      ) {
+}
 
 /* Default allocation mechanism */
-HostSpace::HostSpace( const HostSpace::AllocationMechanism & arg_alloc_mech )
-  : m_alloc_mech( HostSpace::STD_MALLOC )
-{
-  if ( arg_alloc_mech == STD_MALLOC ) {
-    m_alloc_mech = HostSpace::STD_MALLOC ;
+HostSpace::HostSpace(const HostSpace::AllocationMechanism &arg_alloc_mech)
+    : m_alloc_mech(HostSpace::STD_MALLOC) {
+  if (arg_alloc_mech == STD_MALLOC) {
+    m_alloc_mech = HostSpace::STD_MALLOC;
   }
-#if defined( KOKKOS_ENABLE_INTEL_MM_ALLOC )
-  else if ( arg_alloc_mech == HostSpace::INTEL_MM_ALLOC ) {
-    m_alloc_mech = HostSpace::INTEL_MM_ALLOC ;
+#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
+  else if (arg_alloc_mech == HostSpace::INTEL_MM_ALLOC) {
+    m_alloc_mech = HostSpace::INTEL_MM_ALLOC;
   }
-#elif defined( KOKKOS_ENABLE_POSIX_MEMALIGN )
-  else if ( arg_alloc_mech == HostSpace::POSIX_MEMALIGN ) {
-    m_alloc_mech = HostSpace::POSIX_MEMALIGN ;
+#elif defined(KOKKOS_ENABLE_POSIX_MEMALIGN)
+  else if (arg_alloc_mech == HostSpace::POSIX_MEMALIGN) {
+    m_alloc_mech = HostSpace::POSIX_MEMALIGN;
   }
-#elif defined( KOKKOS_IMPL_POSIX_MMAP_FLAGS )
-  else if ( arg_alloc_mech == HostSpace::POSIX_MMAP ) {
-    m_alloc_mech = HostSpace::POSIX_MMAP ;
+#elif defined(KOKKOS_IMPL_POSIX_MMAP_FLAGS)
+  else if (arg_alloc_mech == HostSpace::POSIX_MMAP) {
+    m_alloc_mech = HostSpace::POSIX_MMAP;
   }
 #endif
   else {
-    const char * const mech =
-      ( arg_alloc_mech == HostSpace::INTEL_MM_ALLOC ) ? "INTEL_MM_ALLOC" : (
-      ( arg_alloc_mech == HostSpace::POSIX_MEMALIGN ) ? "POSIX_MEMALIGN" : (
-      ( arg_alloc_mech == HostSpace::POSIX_MMAP     ) ? "POSIX_MMAP" : "" ));
-
-    std::string msg ;
+    const char *const mech =
+        (arg_alloc_mech == HostSpace::INTEL_MM_ALLOC)
+            ? "INTEL_MM_ALLOC"
+            : ((arg_alloc_mech == HostSpace::POSIX_MEMALIGN)
+                   ? "POSIX_MEMALIGN"
+                   : ((arg_alloc_mech == HostSpace::POSIX_MMAP) ? "POSIX_MMAP"
+                                                                : ""));
+
+    std::string msg;
     msg.append("Kokkos::HostSpace ");
     msg.append(mech);
-    msg.append(" is not available" );
-    Kokkos::Impl::throw_runtime_exception( msg );
+    msg.append(" is not available");
+    Kokkos::Impl::throw_runtime_exception(msg);
   }
 }
 
-void * HostSpace::allocate( const size_t arg_alloc_size ) const
-{
-  static_assert( sizeof(void*) == sizeof(uintptr_t)
-               , "Error sizeof(void*) != sizeof(uintptr_t)" );
-
-  static_assert( Kokkos::Impl::is_integral_power_of_two( Kokkos::Impl::MEMORY_ALIGNMENT )
-               , "Memory alignment must be power of two" );
+void *HostSpace::allocate(const size_t arg_alloc_size) const {
+  static_assert(sizeof(void *) == sizeof(uintptr_t),
+                "Error sizeof(void*) != sizeof(uintptr_t)");
 
-  constexpr uintptr_t alignment = Kokkos::Impl::MEMORY_ALIGNMENT ;
-  constexpr uintptr_t alignment_mask = alignment - 1 ;
+  static_assert(
+      Kokkos::Impl::is_integral_power_of_two(Kokkos::Impl::MEMORY_ALIGNMENT),
+      "Memory alignment must be power of two");
 
-  void * ptr = 0 ;
+  constexpr uintptr_t alignment      = Kokkos::Impl::MEMORY_ALIGNMENT;
+  constexpr uintptr_t alignment_mask = alignment - 1;
 
-  if ( arg_alloc_size ) {
+  void *ptr = nullptr;
 
-    if ( m_alloc_mech == STD_MALLOC ) {
+  if (arg_alloc_size) {
+    if (m_alloc_mech == STD_MALLOC) {
       // Over-allocate to and round up to guarantee proper alignment.
-      size_t size_padded = arg_alloc_size + sizeof(void*) + alignment ;
+      size_t size_padded = arg_alloc_size + sizeof(void *) + alignment;
 
-      void * alloc_ptr = malloc( size_padded );
+      void *alloc_ptr = malloc(size_padded);
 
       if (alloc_ptr) {
-        uintptr_t address = reinterpret_cast<uintptr_t>(alloc_ptr);
+        auto address = reinterpret_cast<uintptr_t>(alloc_ptr);
 
         // offset enough to record the alloc_ptr
         address += sizeof(void *);
-        uintptr_t rem = address % alignment;
+        uintptr_t rem    = address % alignment;
         uintptr_t offset = rem ? (alignment - rem) : 0u;
         address += offset;
         ptr = reinterpret_cast<void *>(address);
@@ -192,104 +199,115 @@ void * HostSpace::allocate( const size_t arg_alloc_size ) const
         *reinterpret_cast<void **>(address) = alloc_ptr;
       }
     }
-
-#if defined( KOKKOS_ENABLE_INTEL_MM_ALLOC )
-    else if ( m_alloc_mech == INTEL_MM_ALLOC ) {
-      ptr = _mm_malloc( arg_alloc_size , alignment );
+#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
+    else if (m_alloc_mech == INTEL_MM_ALLOC) {
+      ptr = _mm_malloc(arg_alloc_size, alignment);
     }
 #endif
 
-#if defined( KOKKOS_ENABLE_POSIX_MEMALIGN )
-    else if ( m_alloc_mech == POSIX_MEMALIGN ) {
-      posix_memalign( & ptr, alignment , arg_alloc_size );
+#if defined(KOKKOS_ENABLE_POSIX_MEMALIGN)
+    else if (m_alloc_mech == POSIX_MEMALIGN) {
+      posix_memalign(&ptr, alignment, arg_alloc_size);
     }
 #endif
 
-#if defined( KOKKOS_IMPL_POSIX_MMAP_FLAGS )
-    else if ( m_alloc_mech == POSIX_MMAP ) {
+#if defined(KOKKOS_IMPL_POSIX_MMAP_FLAGS)
+    else if (m_alloc_mech == POSIX_MMAP) {
       constexpr size_t use_huge_pages = (1u << 27);
-      constexpr int    prot  = PROT_READ | PROT_WRITE ;
-      const int flags = arg_alloc_size < use_huge_pages
-                      ? KOKKOS_IMPL_POSIX_MMAP_FLAGS
-                      : KOKKOS_IMPL_POSIX_MMAP_FLAGS_HUGE ;
+      constexpr int prot              = PROT_READ | PROT_WRITE;
+      const int flags                 = arg_alloc_size < use_huge_pages
+                            ? KOKKOS_IMPL_POSIX_MMAP_FLAGS
+                            : KOKKOS_IMPL_POSIX_MMAP_FLAGS_HUGE;
 
       // read write access to private memory
 
-      ptr = mmap( NULL /* address hint, if NULL OS kernel chooses address */
-                , arg_alloc_size /* size in bytes */
-                , prot           /* memory protection */
-                , flags          /* visibility of updates */
-                , -1             /* file descriptor */
-                ,  0             /* offset */
-                );
-
-/* Associated reallocation:
-       ptr = mremap( old_ptr , old_size , new_size , MREMAP_MAYMOVE );
-*/
+      ptr = mmap(NULL /* address hint, if NULL OS kernel chooses address */
+                 ,
+                 arg_alloc_size /* size in bytes */
+                 ,
+                 prot /* memory protection */
+                 ,
+                 flags /* visibility of updates */
+                 ,
+                 -1 /* file descriptor */
+                 ,
+                 0 /* offset */
+      );
+
+      /* Associated reallocation:
+             ptr = mremap( old_ptr , old_size , new_size , MREMAP_MAYMOVE );
+      */
     }
 #endif
   }
 
-  if ( ( ptr == 0 ) || ( reinterpret_cast<uintptr_t>(ptr) == ~uintptr_t(0) )
-       || ( reinterpret_cast<uintptr_t>(ptr) & alignment_mask ) ) {
-    std::ostringstream msg ;
-    msg << "Kokkos::HostSpace::allocate[ " ;
-    switch( m_alloc_mech ) {
-    case STD_MALLOC: msg << "STD_MALLOC" ; break ;
-    case POSIX_MEMALIGN: msg << "POSIX_MEMALIGN" ; break ;
-    case POSIX_MMAP: msg << "POSIX_MMAP" ; break ;
-    case INTEL_MM_ALLOC: msg << "INTEL_MM_ALLOC" ; break ;
+  if ((ptr == nullptr) || (reinterpret_cast<uintptr_t>(ptr) == ~uintptr_t(0)) ||
+      (reinterpret_cast<uintptr_t>(ptr) & alignment_mask)) {
+    Experimental::RawMemoryAllocationFailure::FailureMode failure_mode =
+        Experimental::RawMemoryAllocationFailure::FailureMode::
+            AllocationNotAligned;
+    if (ptr == nullptr) {
+      failure_mode = Experimental::RawMemoryAllocationFailure::FailureMode::
+          OutOfMemoryError;
     }
-    msg << " ]( " << arg_alloc_size << " ) FAILED" ;
-    if ( ptr == NULL ) { msg << " NULL" ; }
-    else { msg << " NOT ALIGNED " << ptr ; }
 
-    std::cerr << msg.str() << std::endl ;
-    std::cerr.flush();
+    Experimental::RawMemoryAllocationFailure::AllocationMechanism alloc_mec =
+        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
+            StdMalloc;
+    switch (m_alloc_mech) {
+      case STD_MALLOC: break;  // default
+      case POSIX_MEMALIGN:
+        alloc_mec = Experimental::RawMemoryAllocationFailure::
+            AllocationMechanism::PosixMemAlign;
+        break;
+      case POSIX_MMAP:
+        alloc_mec = Experimental::RawMemoryAllocationFailure::
+            AllocationMechanism::PosixMMap;
+        break;
+      case INTEL_MM_ALLOC:
+        alloc_mec = Experimental::RawMemoryAllocationFailure::
+            AllocationMechanism::IntelMMAlloc;
+        break;
+    }
 
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    throw Kokkos::Experimental::RawMemoryAllocationFailure(
+        arg_alloc_size, alignment, failure_mode, alloc_mec);
   }
 
   return ptr;
 }
 
-
-void HostSpace::deallocate( void * const arg_alloc_ptr
-    , const size_t
-#if defined( KOKKOS_IMPL_POSIX_MMAP_FLAGS )
-    arg_alloc_size
+void HostSpace::deallocate(void *const arg_alloc_ptr, const size_t
+#if defined(KOKKOS_IMPL_POSIX_MMAP_FLAGS)
+                                                          arg_alloc_size
 #endif
-    ) const
-{
-  if ( arg_alloc_ptr ) {
-
-    if ( m_alloc_mech == STD_MALLOC ) {
-      void * alloc_ptr = *(reinterpret_cast<void **>(arg_alloc_ptr) -1);
-      free( alloc_ptr );
+                           ) const {
+  if (arg_alloc_ptr) {
+    if (m_alloc_mech == STD_MALLOC) {
+      void *alloc_ptr = *(reinterpret_cast<void **>(arg_alloc_ptr) - 1);
+      free(alloc_ptr);
     }
-
-#if defined( KOKKOS_ENABLE_INTEL_MM_ALLOC )
-    else if ( m_alloc_mech == INTEL_MM_ALLOC ) {
-      _mm_free( arg_alloc_ptr );
+#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
+    else if (m_alloc_mech == INTEL_MM_ALLOC) {
+      _mm_free(arg_alloc_ptr);
     }
 #endif
 
-#if defined( KOKKOS_ENABLE_POSIX_MEMALIGN )
-    else if ( m_alloc_mech == POSIX_MEMALIGN ) {
-      free( arg_alloc_ptr );
+#if defined(KOKKOS_ENABLE_POSIX_MEMALIGN)
+    else if (m_alloc_mech == POSIX_MEMALIGN) {
+      free(arg_alloc_ptr);
     }
 #endif
 
-#if defined( KOKKOS_IMPL_POSIX_MMAP_FLAGS )
-    else if ( m_alloc_mech == POSIX_MMAP ) {
-      munmap( arg_alloc_ptr , arg_alloc_size );
+#if defined(KOKKOS_IMPL_POSIX_MMAP_FLAGS)
+    else if (m_alloc_mech == POSIX_MMAP) {
+      munmap(arg_alloc_ptr, arg_alloc_size);
     }
 #endif
-
   }
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -298,208 +316,229 @@ namespace Kokkos {
 namespace Impl {
 
 #ifdef KOKKOS_DEBUG
-SharedAllocationRecord< void , void >
-SharedAllocationRecord< Kokkos::HostSpace , void >::s_root_record ;
+SharedAllocationRecord<void, void>
+    SharedAllocationRecord<Kokkos::HostSpace, void>::s_root_record;
 #endif
 
-void
-SharedAllocationRecord< Kokkos::HostSpace , void >::
-deallocate( SharedAllocationRecord< void , void > * arg_rec )
-{
-  delete static_cast<SharedAllocationRecord*>(arg_rec);
+void SharedAllocationRecord<Kokkos::HostSpace, void>::deallocate(
+    SharedAllocationRecord<void, void> *arg_rec) {
+  delete static_cast<SharedAllocationRecord *>(arg_rec);
 }
 
-SharedAllocationRecord< Kokkos::HostSpace , void >::
-~SharedAllocationRecord()
-{
-  #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
+SharedAllocationRecord<Kokkos::HostSpace, void>::~SharedAllocationRecord() {
+#if defined(KOKKOS_ENABLE_PROFILING)
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::deallocateData(
-      Kokkos::Profiling::SpaceHandle(Kokkos::HostSpace::name()),RecordBase::m_alloc_ptr->m_label,
-      data(),size());
+        Kokkos::Profiling::SpaceHandle(Kokkos::HostSpace::name()),
+        RecordBase::m_alloc_ptr->m_label, data(), size());
   }
-  #endif
+#endif
 
-  m_space.deallocate( SharedAllocationRecord< void , void >::m_alloc_ptr
-                    , SharedAllocationRecord< void , void >::m_alloc_size
-                    );
+  m_space.deallocate(SharedAllocationRecord<void, void>::m_alloc_ptr,
+                     SharedAllocationRecord<void, void>::m_alloc_size);
 }
 
-SharedAllocationRecord< Kokkos::HostSpace , void >::
-SharedAllocationRecord( const Kokkos::HostSpace & arg_space
-                      , const std::string       & arg_label
-                      , const size_t              arg_alloc_size
-                      , const SharedAllocationRecord< void , void >::function_type arg_dealloc
-                      )
-  // Pass through allocated [ SharedAllocationHeader , user_memory ]
-  // Pass through deallocation function
-  : SharedAllocationRecord< void , void >
-      (
+SharedAllocationHeader *_do_allocation(Kokkos::HostSpace const &space,
+                                       std::string const &label,
+                                       size_t alloc_size) {
+  try {
+    return reinterpret_cast<SharedAllocationHeader *>(
+        space.allocate(alloc_size));
+  } catch (Experimental::RawMemoryAllocationFailure const &failure) {
+    if (failure.failure_mode() == Experimental::RawMemoryAllocationFailure::
+                                      FailureMode::AllocationNotAligned) {
+      // TODO: delete the misaligned memory
+    }
+
+    std::cerr << "Kokkos failed to allocate memory for label \"" << label
+              << "\".  Allocation using MemorySpace named \"" << space.name()
+              << " failed with the following error:  ";
+    failure.print_error_message(std::cerr);
+    std::cerr.flush();
+    Kokkos::Impl::throw_runtime_exception("Memory allocation failure");
+  }
+  return nullptr;  // unreachable
+}
+
+SharedAllocationRecord<Kokkos::HostSpace, void>::SharedAllocationRecord(
+    const Kokkos::HostSpace &arg_space, const std::string &arg_label,
+    const size_t arg_alloc_size,
+    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    // Pass through allocated [ SharedAllocationHeader , user_memory ]
+    // Pass through deallocation function
+    : SharedAllocationRecord<void, void>(
 #ifdef KOKKOS_DEBUG
-      & SharedAllocationRecord< Kokkos::HostSpace , void >::s_root_record,
+          &SharedAllocationRecord<Kokkos::HostSpace, void>::s_root_record,
 #endif
-        reinterpret_cast<SharedAllocationHeader*>( arg_space.allocate( sizeof(SharedAllocationHeader) + arg_alloc_size ) )
-      , sizeof(SharedAllocationHeader) + arg_alloc_size
-      , arg_dealloc
-      )
-  , m_space( arg_space )
-{
+          Impl::checked_allocation_with_header(arg_space, arg_label,
+                                               arg_alloc_size),
+          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc),
+      m_space(arg_space) {
 #if defined(KOKKOS_ENABLE_PROFILING)
-  if(Kokkos::Profiling::profileLibraryLoaded()) {
-    Kokkos::Profiling::allocateData(Kokkos::Profiling::SpaceHandle(arg_space.name()),arg_label,data(),arg_alloc_size);
-   }
+  if (Kokkos::Profiling::profileLibraryLoaded()) {
+    Kokkos::Profiling::allocateData(
+        Kokkos::Profiling::SpaceHandle(arg_space.name()), arg_label, data(),
+        arg_alloc_size);
+  }
 #endif
   // Fill in the Header information
-  RecordBase::m_alloc_ptr->m_record = static_cast< SharedAllocationRecord< void , void > * >( this );
+  RecordBase::m_alloc_ptr->m_record =
+      static_cast<SharedAllocationRecord<void, void> *>(this);
 
-  strncpy( RecordBase::m_alloc_ptr->m_label
-          , arg_label.c_str()
-          , SharedAllocationHeader::maximum_label_length
-          );
+  strncpy(RecordBase::m_alloc_ptr->m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
   // Set last element zero, in case c_str is too long
-  RecordBase::m_alloc_ptr->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char) 0;
+  RecordBase::m_alloc_ptr
+      ->m_label[SharedAllocationHeader::maximum_label_length - 1] = (char)0;
 }
 
 //----------------------------------------------------------------------------
 
-void * SharedAllocationRecord< Kokkos::HostSpace , void >::
-allocate_tracked( const Kokkos::HostSpace & arg_space
-                , const std::string & arg_alloc_label
-                , const size_t arg_alloc_size )
-{
-  if ( ! arg_alloc_size ) return (void *) 0 ;
+void *SharedAllocationRecord<Kokkos::HostSpace, void>::allocate_tracked(
+    const Kokkos::HostSpace &arg_space, const std::string &arg_alloc_label,
+    const size_t arg_alloc_size) {
+  if (!arg_alloc_size) return (void *)nullptr;
 
-  SharedAllocationRecord * const r =
-    allocate( arg_space , arg_alloc_label , arg_alloc_size );
+  SharedAllocationRecord *const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
 
-  RecordBase::increment( r );
+  RecordBase::increment(r);
 
   return r->data();
 }
 
-void SharedAllocationRecord< Kokkos::HostSpace , void >::
-deallocate_tracked( void * const arg_alloc_ptr )
-{
-  if ( arg_alloc_ptr != 0 ) {
-    SharedAllocationRecord * const r = get_record( arg_alloc_ptr );
+void SharedAllocationRecord<Kokkos::HostSpace, void>::deallocate_tracked(
+    void *const arg_alloc_ptr) {
+  if (arg_alloc_ptr != 0) {
+    SharedAllocationRecord *const r = get_record(arg_alloc_ptr);
 
-    RecordBase::decrement( r );
+    RecordBase::decrement(r);
   }
 }
 
-void * SharedAllocationRecord< Kokkos::HostSpace , void >::
-reallocate_tracked( void * const arg_alloc_ptr
-                  , const size_t arg_alloc_size )
-{
-  SharedAllocationRecord * const r_old = get_record( arg_alloc_ptr );
-  SharedAllocationRecord * const r_new = allocate( r_old->m_space , r_old->get_label() , arg_alloc_size );
+void *SharedAllocationRecord<Kokkos::HostSpace, void>::reallocate_tracked(
+    void *const arg_alloc_ptr, const size_t arg_alloc_size) {
+  SharedAllocationRecord *const r_old = get_record(arg_alloc_ptr);
+  SharedAllocationRecord *const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
 
-  Kokkos::Impl::DeepCopy<HostSpace,HostSpace>( r_new->data() , r_old->data()
-                                             , std::min( r_old->size() , r_new->size() ) );
+  Kokkos::Impl::DeepCopy<HostSpace, HostSpace>(
+      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
 
-  RecordBase::increment( r_new );
-  RecordBase::decrement( r_old );
+  RecordBase::increment(r_new);
+  RecordBase::decrement(r_old);
 
   return r_new->data();
 }
 
-SharedAllocationRecord< Kokkos::HostSpace , void > *
-SharedAllocationRecord< Kokkos::HostSpace , void >::get_record( void * alloc_ptr )
-{
-  typedef SharedAllocationHeader  Header ;
-  typedef SharedAllocationRecord< Kokkos::HostSpace , void >  RecordHost ;
+SharedAllocationRecord<Kokkos::HostSpace, void> *
+SharedAllocationRecord<Kokkos::HostSpace, void>::get_record(void *alloc_ptr) {
+  typedef SharedAllocationHeader Header;
+  typedef SharedAllocationRecord<Kokkos::HostSpace, void> RecordHost;
 
-  SharedAllocationHeader const * const head   = alloc_ptr ? Header::get_header( alloc_ptr ) : (SharedAllocationHeader *)0 ;
-  RecordHost                   * const record = head ? static_cast< RecordHost * >( head->m_record ) : (RecordHost *) 0 ;
+  SharedAllocationHeader const *const head =
+      alloc_ptr ? Header::get_header(alloc_ptr) : (SharedAllocationHeader *)0;
+  RecordHost *const record =
+      head ? static_cast<RecordHost *>(head->m_record) : (RecordHost *)0;
 
-  if ( ! alloc_ptr || record->m_alloc_ptr != head ) {
-    Kokkos::Impl::throw_runtime_exception( std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::HostSpace , void >::get_record ERROR" ) );
+  if (!alloc_ptr || record->m_alloc_ptr != head) {
+    Kokkos::Impl::throw_runtime_exception(
+        std::string("Kokkos::Impl::SharedAllocationRecord< Kokkos::HostSpace , "
+                    "void >::get_record ERROR"));
   }
 
-  return record ;
+  return record;
 }
 
 // Iterate records to print orphaned memory ...
 #ifdef KOKKOS_DEBUG
-void SharedAllocationRecord< Kokkos::HostSpace , void >::
-print_records( std::ostream & s , const Kokkos::HostSpace & , bool detail )
-{
-  SharedAllocationRecord< void , void >::print_host_accessible_records( s , "HostSpace" , & s_root_record , detail );
+void SharedAllocationRecord<Kokkos::HostSpace, void>::print_records(
+    std::ostream &s, const Kokkos::HostSpace &, bool detail) {
+  SharedAllocationRecord<void, void>::print_host_accessible_records(
+      s, "HostSpace", &s_root_record, detail);
 }
 #else
-void SharedAllocationRecord< Kokkos::HostSpace , void >::
-print_records( std::ostream & , const Kokkos::HostSpace & , bool )
-{
-  throw_runtime_exception("SharedAllocationRecord<HostSpace>::print_records only works with KOKKOS_DEBUG enabled");
+void SharedAllocationRecord<Kokkos::HostSpace, void>::print_records(
+    std::ostream &, const Kokkos::HostSpace &, bool) {
+  throw_runtime_exception(
+      "SharedAllocationRecord<HostSpace>::print_records only works with "
+      "KOKKOS_DEBUG enabled");
 }
 #endif
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
 namespace Kokkos {
 namespace {
-  const unsigned HOST_SPACE_ATOMIC_MASK = 0xFFFF;
-  const unsigned HOST_SPACE_ATOMIC_XOR_MASK = 0x5A39;
-  static int HOST_SPACE_ATOMIC_LOCKS[HOST_SPACE_ATOMIC_MASK+1];
-}
+const unsigned HOST_SPACE_ATOMIC_MASK     = 0xFFFF;
+const unsigned HOST_SPACE_ATOMIC_XOR_MASK = 0x5A39;
+static int HOST_SPACE_ATOMIC_LOCKS[HOST_SPACE_ATOMIC_MASK + 1];
+}  // namespace
 
 namespace Impl {
 void init_lock_array_host_space() {
   static int is_initialized = 0;
-  if(! is_initialized)
-    for(int i = 0; i < static_cast<int> (HOST_SPACE_ATOMIC_MASK+1); i++)
+  if (!is_initialized)
+    for (int i = 0; i < static_cast<int>(HOST_SPACE_ATOMIC_MASK + 1); i++)
       HOST_SPACE_ATOMIC_LOCKS[i] = 0;
 }
 
-bool lock_address_host_space(void* ptr) {
-#if defined( KOKKOS_ENABLE_ISA_X86_64 ) && defined ( KOKKOS_ENABLE_TM )
+bool lock_address_host_space(void *ptr) {
+#if defined(KOKKOS_ENABLE_ISA_X86_64) && defined(KOKKOS_ENABLE_TM) && \
+    !defined(KOKKOS_COMPILER_PGI)
   const unsigned status = _xbegin();
 
-  if( _XBEGIN_STARTED == status ) {
-	const int val = HOST_SPACE_ATOMIC_LOCKS[(( size_t(ptr) >> 2 ) &
-		HOST_SPACE_ATOMIC_MASK) ^ HOST_SPACE_ATOMIC_XOR_MASK];
+  if (_XBEGIN_STARTED == status) {
+    const int val =
+        HOST_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) & HOST_SPACE_ATOMIC_MASK) ^
+                                HOST_SPACE_ATOMIC_XOR_MASK];
 
-	if( 0 == val ) {
-		HOST_SPACE_ATOMIC_LOCKS[(( size_t(ptr) >> 2 ) &
-                   HOST_SPACE_ATOMIC_MASK) ^ HOST_SPACE_ATOMIC_XOR_MASK] = 1;
-	} else {
-		_xabort( 1 );
-	}
+    if (0 == val) {
+      HOST_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) & HOST_SPACE_ATOMIC_MASK) ^
+                              HOST_SPACE_ATOMIC_XOR_MASK] = 1;
+    } else {
+      _xabort(1);
+    }
 
-	_xend();
+    _xend();
 
-	return 1;
+    return 1;
   } else {
 #endif
-  return 0 == atomic_compare_exchange( &HOST_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^ HOST_SPACE_ATOMIC_XOR_MASK] ,
-                                  0 , 1);
-#if defined( KOKKOS_ENABLE_ISA_X86_64 ) && defined ( KOKKOS_ENABLE_TM )
+    return 0 == atomic_compare_exchange(
+                    &HOST_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) &
+                                              HOST_SPACE_ATOMIC_MASK) ^
+                                             HOST_SPACE_ATOMIC_XOR_MASK],
+                    0, 1);
+#if defined(KOKKOS_ENABLE_ISA_X86_64) && defined(KOKKOS_ENABLE_TM) && \
+    !defined(KOKKOS_COMPILER_PGI)
   }
 #endif
 }
 
-void unlock_address_host_space(void* ptr) {
-#if defined( KOKKOS_ENABLE_ISA_X86_64 ) && defined ( KOKKOS_ENABLE_TM )
+void unlock_address_host_space(void *ptr) {
+#if defined(KOKKOS_ENABLE_ISA_X86_64) && defined(KOKKOS_ENABLE_TM) && \
+    !defined(KOKKOS_COMPILER_PGI)
   const unsigned status = _xbegin();
 
-  if( _XBEGIN_STARTED == status ) {
-	HOST_SPACE_ATOMIC_LOCKS[(( size_t(ptr) >> 2 ) &
-        	HOST_SPACE_ATOMIC_MASK) ^ HOST_SPACE_ATOMIC_XOR_MASK] = 0;
+  if (_XBEGIN_STARTED == status) {
+    HOST_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) & HOST_SPACE_ATOMIC_MASK) ^
+                            HOST_SPACE_ATOMIC_XOR_MASK] = 0;
   } else {
 #endif
-   atomic_exchange( &HOST_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^ HOST_SPACE_ATOMIC_XOR_MASK] ,
-                    0);
-#if defined( KOKKOS_ENABLE_ISA_X86_64 ) && defined ( KOKKOS_ENABLE_TM )
+    atomic_exchange(
+        &HOST_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) & HOST_SPACE_ATOMIC_MASK) ^
+                                 HOST_SPACE_ATOMIC_XOR_MASK],
+        0);
+#if defined(KOKKOS_ENABLE_ISA_X86_64) && defined(KOKKOS_ENABLE_TM) && \
+    !defined(KOKKOS_COMPILER_PGI)
   }
 #endif
 }
 
-}
-}
-
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.cpp b/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
index 21b95f6985fa6d0e302c3ee5d06a57c2cfa693dd..35eee40ab7b95ea28bb5a3817435ae6fb7b2b321 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,86 +50,94 @@ namespace Kokkos {
 namespace Impl {
 
 #ifndef KOKKOS_IMPL_HOST_DEEP_COPY_SERIAL_LIMIT
-#define KOKKOS_IMPL_HOST_DEEP_COPY_SERIAL_LIMIT 10*8192
+#define KOKKOS_IMPL_HOST_DEEP_COPY_SERIAL_LIMIT 10 * 8192
 #endif
 
-void hostspace_parallel_deepcopy(void * dst, const void * src, ptrdiff_t n) {
-  if((n<KOKKOS_IMPL_HOST_DEEP_COPY_SERIAL_LIMIT) || (Kokkos::DefaultHostExecutionSpace().concurrency()==1)) {
-    std::memcpy(dst,src,n);
+void hostspace_parallel_deepcopy(void* dst, const void* src, ptrdiff_t n) {
+  if ((n < KOKKOS_IMPL_HOST_DEEP_COPY_SERIAL_LIMIT) ||
+      (Kokkos::DefaultHostExecutionSpace().concurrency() == 1)) {
+    std::memcpy(dst, src, n);
     return;
   }
 
   typedef Kokkos::RangePolicy<Kokkos::DefaultHostExecutionSpace> policy_t;
 
   // Both src and dst are aligned the same way with respect to 8 byte words
-  if(reinterpret_cast<ptrdiff_t>(src)%8 == reinterpret_cast<ptrdiff_t>(dst)%8) {
-    char* dst_c = reinterpret_cast<char*>(dst);
+  if (reinterpret_cast<ptrdiff_t>(src) % 8 ==
+      reinterpret_cast<ptrdiff_t>(dst) % 8) {
+    char* dst_c       = reinterpret_cast<char*>(dst);
     const char* src_c = reinterpret_cast<const char*>(src);
-    int count = 0;
+    int count         = 0;
     // get initial bytes copied
-    while(reinterpret_cast<ptrdiff_t>(dst_c)%8!=0) {
-      *dst_c=*src_c;
-      dst_c++; src_c++; count++;
+    while (reinterpret_cast<ptrdiff_t>(dst_c) % 8 != 0) {
+      *dst_c = *src_c;
+      dst_c++;
+      src_c++;
+      count++;
     }
 
     // copy the bulk of the data
-    double* dst_p = reinterpret_cast<double*>(dst_c);
+    double* dst_p       = reinterpret_cast<double*>(dst_c);
     const double* src_p = reinterpret_cast<const double*>(src_c);
-    Kokkos::parallel_for("Kokkos::Impl::host_space_deepcopy_double",policy_t(0,(n-count)/8),[=](const ptrdiff_t i) {
-      dst_p[i] = src_p[i];
-    });
+    Kokkos::parallel_for("Kokkos::Impl::host_space_deepcopy_double",
+                         policy_t(0, (n - count) / 8),
+                         [=](const ptrdiff_t i) { dst_p[i] = src_p[i]; });
 
     // get final data copied
-    dst_c += ((n-count)/8) * 8;
-    src_c += ((n-count)/8) * 8;
-    char* dst_end = reinterpret_cast<char*>(dst)+n;
-    while(dst_c != dst_end) {
+    dst_c += ((n - count) / 8) * 8;
+    src_c += ((n - count) / 8) * 8;
+    char* dst_end = reinterpret_cast<char*>(dst) + n;
+    while (dst_c != dst_end) {
       *dst_c = *src_c;
-      dst_c++; src_c++;
+      dst_c++;
+      src_c++;
     }
     return;
   }
 
   // Both src and dst are aligned the same way with respect to 4 byte words
-  if(reinterpret_cast<ptrdiff_t>(src)%4 == reinterpret_cast<ptrdiff_t>(dst)%4) {
-    char* dst_c = reinterpret_cast<char*>(dst);
+  if (reinterpret_cast<ptrdiff_t>(src) % 4 ==
+      reinterpret_cast<ptrdiff_t>(dst) % 4) {
+    char* dst_c       = reinterpret_cast<char*>(dst);
     const char* src_c = reinterpret_cast<const char*>(src);
-    int count = 0;
+    int count         = 0;
     // get initial bytes copied
-    while(reinterpret_cast<ptrdiff_t>(dst_c)%4!=0) {
-      *dst_c=*src_c;
-      dst_c++; src_c++; count++;
+    while (reinterpret_cast<ptrdiff_t>(dst_c) % 4 != 0) {
+      *dst_c = *src_c;
+      dst_c++;
+      src_c++;
+      count++;
     }
 
     // copy the bulk of the data
-    int32_t* dst_p = reinterpret_cast<int32_t*>(dst_c);
+    int32_t* dst_p       = reinterpret_cast<int32_t*>(dst_c);
     const int32_t* src_p = reinterpret_cast<const int32_t*>(src_c);
-    Kokkos::parallel_for("Kokkos::Impl::host_space_deepcopy_int",policy_t(0,(n-count)/4),[=](const ptrdiff_t i) {
-      dst_p[i] = src_p[i];
-    });
+    Kokkos::parallel_for("Kokkos::Impl::host_space_deepcopy_int",
+                         policy_t(0, (n - count) / 4),
+                         [=](const ptrdiff_t i) { dst_p[i] = src_p[i]; });
 
     // get final data copied
-    dst_c += ((n-count)/4) * 4;
-    src_c += ((n-count)/4) * 4;
-    char* dst_end = reinterpret_cast<char*>(dst)+n;
-    while(dst_c != dst_end) {
+    dst_c += ((n - count) / 4) * 4;
+    src_c += ((n - count) / 4) * 4;
+    char* dst_end = reinterpret_cast<char*>(dst) + n;
+    while (dst_c != dst_end) {
       *dst_c = *src_c;
-      dst_c++; src_c++;
+      dst_c++;
+      src_c++;
     }
     return;
   }
 
   // Src and dst are not aligned the same way, we can only to byte wise copy.
   {
-    char* dst_p = reinterpret_cast<char*>(dst);
+    char* dst_p       = reinterpret_cast<char*>(dst);
     const char* src_p = reinterpret_cast<const char*>(src);
-    Kokkos::parallel_for("Kokkos::Impl::host_space_deepcopy_char",policy_t(0,n),[=](const ptrdiff_t i) {
-      dst_p[i] = src_p[i];
-    });
+    Kokkos::parallel_for("Kokkos::Impl::host_space_deepcopy_char",
+                         policy_t(0, n),
+                         [=](const ptrdiff_t i) { dst_p[i] = src_p[i]; });
   }
 }
 
-} // namespace Impl
-
-} // namespace Kokkos
+}  // namespace Impl
 
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.hpp b/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.hpp
index b8aea9536363ad1d9981e68f5c6bfa1043bd8e83..e9e0ef52a0dd6ef5254f82b9bad10d9bc569805d 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HostSpace_deepcopy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -40,15 +41,14 @@
 // ************************************************************************
 //@HEADER
 */
-#include<cstdint>
+#include <cstdint>
 
 namespace Kokkos {
 
 namespace Impl {
 
-void hostspace_parallel_deepcopy(void * dst, const void * src, ptrdiff_t n);
+void hostspace_parallel_deepcopy(void* dst, const void* src, ptrdiff_t n);
 
-} // namespace Impl
-
-} // namespace Kokkos
+}  // namespace Impl
 
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.cpp b/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.cpp
index 383b2ec2dc5a1051ccc94e28045ab8e60fb410ca..92e9aa24b0f02ded1a3115faaec91e3bc0de8a38 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,126 +54,119 @@
 namespace Kokkos {
 namespace Impl {
 
-void HostThreadTeamData::organize_pool
-  ( HostThreadTeamData * members[] , const int size )
-{
-  bool ok = true ;
+void HostThreadTeamData::organize_pool(HostThreadTeamData *members[],
+                                       const int size) {
+  bool ok = true;
 
   memory_fence();
 
   // Verify not already a member of a pool:
-  for ( int rank = 0 ; rank < size && ok ; ++rank ) {
-    ok = ( nullptr != members[rank] ) && ( 0 == members[rank]->m_pool_scratch );
+  for (int rank = 0; rank < size && ok; ++rank) {
+    ok = (nullptr != members[rank]) && (0 == members[rank]->m_pool_scratch);
   }
 
-  if ( ok ) {
+  if (ok) {
+    int64_t *const root_scratch = members[0]->m_scratch;
 
-    int64_t * const root_scratch = members[0]->m_scratch ;
-
-    for ( int i = m_pool_rendezvous ; i < m_pool_reduce ; ++i ) {
-      root_scratch[i] = 0 ;
+    for (int i = m_pool_rendezvous; i < m_pool_reduce; ++i) {
+      root_scratch[i] = 0;
     }
 
     {
-      HostThreadTeamData ** const pool =
-        (HostThreadTeamData **) (root_scratch + m_pool_members);
+      HostThreadTeamData **const pool =
+          (HostThreadTeamData **)(root_scratch + m_pool_members);
 
       // team size == 1, league size == pool_size
 
-      for ( int rank = 0 ; rank < size ; ++rank ) {
-        HostThreadTeamData * const mem = members[ rank ] ;
-        mem->m_pool_scratch = root_scratch ;
-        mem->m_team_scratch = mem->m_scratch ;
-        mem->m_pool_rank    = rank ;
-        mem->m_pool_size    = size ;
-        mem->m_team_base    = rank ;
-        mem->m_team_rank    = 0 ;
-        mem->m_team_size    = 1 ;
-        mem->m_team_alloc   = 1 ;
-        mem->m_league_rank  = rank ;
-        mem->m_league_size  = size ;
-        mem->m_team_rendezvous_step = 0 ;
-        pool[ rank ] = mem ;
+      for (int rank = 0; rank < size; ++rank) {
+        HostThreadTeamData *const mem = members[rank];
+        mem->m_pool_scratch           = root_scratch;
+        mem->m_team_scratch           = mem->m_scratch;
+        mem->m_pool_rank              = rank;
+        mem->m_pool_size              = size;
+        mem->m_team_base              = rank;
+        mem->m_team_rank              = 0;
+        mem->m_team_size              = 1;
+        mem->m_team_alloc             = 1;
+        mem->m_league_rank            = rank;
+        mem->m_league_size            = size;
+        mem->m_team_rendezvous_step   = 0;
+        pool[rank]                    = mem;
       }
     }
 
     Kokkos::memory_fence();
-  }
-  else {
-    Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::HostThreadTeamData::organize_pool ERROR pool already exists");
+  } else {
+    Kokkos::Impl::throw_runtime_exception(
+        "Kokkos::Impl::HostThreadTeamData::organize_pool ERROR pool already "
+        "exists");
   }
 }
 
-void HostThreadTeamData::disband_pool()
-{
-   m_work_range.first  = -1 ;
-   m_work_range.second = -1 ;
-   m_pool_scratch = 0 ;
-   m_team_scratch = 0 ;
-   m_pool_rank    = 0 ;
-   m_pool_size    = 1 ;
-   m_team_base    = 0 ;
-   m_team_rank    = 0 ;
-   m_team_size    = 1 ;
-   m_team_alloc   = 1 ;
-   m_league_rank  = 0 ;
-   m_league_size  = 1 ;
-   m_team_rendezvous_step = 0 ;
+void HostThreadTeamData::disband_pool() {
+  m_work_range.first     = -1;
+  m_work_range.second    = -1;
+  m_pool_scratch         = 0;
+  m_team_scratch         = 0;
+  m_pool_rank            = 0;
+  m_pool_size            = 1;
+  m_team_base            = 0;
+  m_team_rank            = 0;
+  m_team_size            = 1;
+  m_team_alloc           = 1;
+  m_league_rank          = 0;
+  m_league_size          = 1;
+  m_team_rendezvous_step = 0;
 }
 
-int HostThreadTeamData::organize_team( const int team_size )
-{
+int HostThreadTeamData::organize_team(const int team_size) {
   // Pool is initialized
-  const bool ok_pool = 0 != m_pool_scratch ;
+  const bool ok_pool = 0 != m_pool_scratch;
 
   // Team is not set
   const bool ok_team =
-    m_team_scratch == m_scratch &&
-    m_team_base    == m_pool_rank &&
-    m_team_rank    == 0 &&
-    m_team_size    == 1 &&
-    m_team_alloc   == 1 &&
-    m_league_rank  == m_pool_rank &&
-    m_league_size  == m_pool_size ;
-
-  if ( ok_pool && ok_team ) {
+      m_team_scratch == m_scratch && m_team_base == m_pool_rank &&
+      m_team_rank == 0 && m_team_size == 1 && m_team_alloc == 1 &&
+      m_league_rank == m_pool_rank && m_league_size == m_pool_size;
 
-    if ( team_size <= 0 ) return 0 ; // No teams to organize
+  if (ok_pool && ok_team) {
+    if (team_size <= 0) return 0;  // No teams to organize
 
-    if ( team_size == 1 ) return 1 ; // Already organized in teams of one
+    if (team_size == 1) return 1;  // Already organized in teams of one
 
-    HostThreadTeamData * const * const pool =
-      (HostThreadTeamData **) (m_pool_scratch + m_pool_members);
+    HostThreadTeamData *const *const pool =
+        (HostThreadTeamData **)(m_pool_scratch + m_pool_members);
 
     // "league_size" in this context is the number of concurrent teams
     // that the pool can accommodate.  Excess threads are idle.
-    const int league_size     = m_pool_size / team_size ;
-    const int team_alloc_size = m_pool_size / league_size ;
-    const int team_alloc_rank = m_pool_rank % team_alloc_size ;
-    const int league_rank     = m_pool_rank / team_alloc_size ;
-    const int team_base_rank  = league_rank * team_alloc_size ;
-
-    m_team_scratch = pool[ team_base_rank ]->m_scratch ;
-    m_team_base    = team_base_rank ;
+    const int league_size     = m_pool_size / team_size;
+    const int team_alloc_size = m_pool_size / league_size;
+    const int team_alloc_rank = m_pool_rank % team_alloc_size;
+    const int league_rank     = m_pool_rank / team_alloc_size;
+    const int team_base_rank  = league_rank * team_alloc_size;
+
+    m_team_scratch = pool[team_base_rank]->m_scratch;
+    m_team_base    = team_base_rank;
     // This needs to check overflow, if m_pool_size % team_alloc_size !=0
     // there are two corner cases:
     // (i) if team_alloc_size == team_size there might be a non-full
     //     zombi team around (for example m_pool_size = 5 and team_size = 2
     // (ii) if team_alloc > team_size then the last team might have less
     //      threads than the others
-    m_team_rank    = ( team_base_rank + team_size <= m_pool_size ) &&
-                     ( team_alloc_rank < team_size ) ?
-                     team_alloc_rank : -1;
-    m_team_size    = team_size ;
-    m_team_alloc   = team_alloc_size ;
-    m_league_rank  = league_rank ;
-    m_league_size  = league_size ;
-    m_team_rendezvous_step = 0 ;
-
-    if ( team_base_rank == m_pool_rank ) {
+    m_team_rank = (team_base_rank + team_size <= m_pool_size) &&
+                          (team_alloc_rank < team_size)
+                      ? team_alloc_rank
+                      : -1;
+    m_team_size            = team_size;
+    m_team_alloc           = team_alloc_size;
+    m_league_rank          = league_rank;
+    m_league_size          = league_size;
+    m_team_rendezvous_step = 0;
+
+    if (team_base_rank == m_pool_rank) {
       // Initialize team's rendezvous memory
-      for ( int i = m_team_rendezvous ; i < m_pool_reduce ; ++i ) {
-        m_scratch[i] = 0 ;
+      for (int i = m_team_rendezvous; i < m_pool_reduce; ++i) {
+        m_scratch[i] = 0;
       }
       // Make sure team's rendezvous memory initialized
       // is written before proceeding.
@@ -183,131 +177,121 @@ int HostThreadTeamData::organize_team( const int team_size )
     // entire pool to insure proper initialization of the team
     // rendezvous mechanism before a team rendezvous can be performed.
 
-    if ( pool_rendezvous() ) {
+    if (pool_rendezvous()) {
       pool_rendezvous_release();
     }
-  }
-  else {
-    Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::HostThreadTeamData::organize_team ERROR");
+  } else {
+    Kokkos::Impl::throw_runtime_exception(
+        "Kokkos::Impl::HostThreadTeamData::organize_team ERROR");
   }
 
-  return 0 <= m_team_rank ;
+  return 0 <= m_team_rank;
 }
 
-void HostThreadTeamData::disband_team()
-{
-  m_team_scratch = m_scratch ;
-  m_team_base    = m_pool_rank ;
-  m_team_rank    = 0 ;
-  m_team_size    = 1 ;
-  m_team_alloc   = 1 ;
-  m_league_rank  = m_pool_rank ;
-  m_league_size  = m_pool_size ;
-  m_team_rendezvous_step = 0 ;
+void HostThreadTeamData::disband_team() {
+  m_team_scratch         = m_scratch;
+  m_team_base            = m_pool_rank;
+  m_team_rank            = 0;
+  m_team_size            = 1;
+  m_team_alloc           = 1;
+  m_league_rank          = m_pool_rank;
+  m_league_size          = m_pool_size;
+  m_team_rendezvous_step = 0;
 }
 
 //----------------------------------------------------------------------------
 
-int HostThreadTeamData::get_work_stealing() noexcept
-{
-  pair_int_t w( -1 , -1 );
+int HostThreadTeamData::get_work_stealing() noexcept {
+  pair_int_t w(-1, -1);
 
   // TODO DJS 3-17-2018:
   // Discover why the work stealing algorithm only works when called
   // by the master thread of the team.  If we can refactor this section to
   // remove that requirement we should be able to remove the split_master_wait
   // behavior in the team and pool rendezvous algorithms
-  if ( 1 == m_team_size || team_rendezvous() ) {
-
+  if (1 == m_team_size || team_rendezvous()) {
     // Attempt first from beginning of my work range
-    for ( int attempt = m_work_range.first < m_work_range.second ; attempt ; ) {
-
+    for (int attempt = m_work_range.first < m_work_range.second; attempt;) {
       // Query and attempt to update m_work_range
       //   from: [ w.first     , w.second )
       //   to:   [ w.first + 1 , w.second ) = w_new
       //
       // If w is invalid then is just a query.
 
-      const pair_int_t w_new( w.first + 1 , w.second );
+      const pair_int_t w_new(w.first + 1, w.second);
 
-      w = Kokkos::atomic_compare_exchange( & m_work_range, w, w_new );
+      w = Kokkos::atomic_compare_exchange(&m_work_range, w, w_new);
 
-      if ( w.first < w.second ) {
+      if (w.first < w.second) {
         // m_work_range is viable
 
         // If steal is successful then don't repeat attempt to steal
-        attempt = ! ( w_new.first  == w.first + 1 &&
-                      w_new.second == w.second );
-      }
-      else {
+        attempt = !(w_new.first == w.first + 1 && w_new.second == w.second);
+      } else {
         // m_work_range is not viable
-        w.first  = -1 ;
-        w.second = -1 ;
+        w.first  = -1;
+        w.second = -1;
 
-        attempt = 0 ;
+        attempt = 0;
       }
     }
 
-    if ( w.first == -1 && m_steal_rank != m_pool_rank ) {
-
-      HostThreadTeamData * const * const pool =
-        (HostThreadTeamData**)( m_pool_scratch + m_pool_members );
+    if (w.first == -1 && m_steal_rank != m_pool_rank) {
+      HostThreadTeamData *const *const pool =
+          (HostThreadTeamData **)(m_pool_scratch + m_pool_members);
 
       // Attempt from beginning failed, try to steal from end of neighbor
 
-      pair_int_t volatile * steal_range =
-        & ( pool[ m_steal_rank ]->m_work_range );
-
-      for ( int attempt = true ; attempt ; ) {
+      pair_int_t volatile *steal_range = &(pool[m_steal_rank]->m_work_range);
 
+      for (int attempt = true; attempt;) {
         // Query and attempt to update steal_work_range
         //   from: [ w.first , w.second )
         //   to:   [ w.first , w.second - 1 ) = w_new
         //
         // If w is invalid then is just a query.
 
-        const pair_int_t w_new( w.first , w.second - 1 );
+        const pair_int_t w_new(w.first, w.second - 1);
 
-        w = Kokkos::atomic_compare_exchange( steal_range, w, w_new );
+        w = Kokkos::atomic_compare_exchange(steal_range, w, w_new);
 
-        if ( w.first < w.second ) {
+        if (w.first < w.second) {
           // steal_work_range is viable
 
           // If steal is successful then don't repeat attempt to steal
-          attempt = ! ( w_new.first  == w.first &&
-                        w_new.second == w.second - 1 );
-        }
-        else {
+          attempt = !(w_new.first == w.first && w_new.second == w.second - 1);
+        } else {
           // steal_work_range is not viable, move to next member
-          w.first  = -1 ;
-          w.second = -1 ;
+          w.first  = -1;
+          w.second = -1;
 
           // We need to figure out whether the next team is active
-          // m_steal_rank + m_team_alloc could be the next base_rank to steal from
-          // but only if there are another m_team_size threads available so that that
-          // base rank has a full team.
-          m_steal_rank = m_steal_rank + m_team_alloc + m_team_size <= m_pool_size ?
-                         m_steal_rank + m_team_alloc : 0;
+          // m_steal_rank + m_team_alloc could be the next base_rank to steal
+          // from but only if there are another m_team_size threads available so
+          // that that base rank has a full team.
+          m_steal_rank =
+              m_steal_rank + m_team_alloc + m_team_size <= m_pool_size
+                  ? m_steal_rank + m_team_alloc
+                  : 0;
 
-          steal_range = & ( pool[ m_steal_rank ]->m_work_range );
+          steal_range = &(pool[m_steal_rank]->m_work_range);
 
           // If tried all other members then don't repeat attempt to steal
-          attempt = m_steal_rank != m_pool_rank ;
+          attempt = m_steal_rank != m_pool_rank;
         }
       }
 
-      if ( w.first != -1 ) w.first = w.second - 1 ;
+      if (w.first != -1) w.first = w.second - 1;
     }
 
-    if ( 1 < m_team_size ) {
+    if (1 < m_team_size) {
       // Must share the work index
-      *((int volatile *) team_reduce()) = w.first ;
+      *((int volatile *)team_reduce()) = w.first;
 
       team_rendezvous_release();
     }
-  }
-  else if ( 1 < m_team_size ) {
-    w.first = *((int volatile *) team_reduce());
+  } else if (1 < m_team_size) {
+    w.first = *((int volatile *)team_reduce());
   }
 
   // May exit because successfully stole work and w is good.
@@ -319,9 +303,8 @@ fprintf(stdout,"HostThreadTeamData::get_work_stealing() pool(%d of %d) %d\n"
 fflush(stdout);
 #endif
 
-  return w.first ;
+  return w.first;
 }
 
-} // namespace Impl
-} // namespace Kokkos
-
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.hpp b/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.hpp
index f44a13c5740346deb0afbf32f35c9545365337a5..fce665f6b156b0449ec574c3aec2cc90b961d6a8 100644
--- a/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_HostThreadTeam.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,7 +53,7 @@
 #include <impl/Kokkos_FunctorAnalysis.hpp>
 #include <impl/Kokkos_HostBarrier.hpp>
 
-#include <limits> // std::numeric_limits
+#include <limits>  // std::numeric_limits
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -60,25 +61,24 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class HostExecSpace >
-class HostThreadTeamMember ;
+template <class HostExecSpace>
+class HostThreadTeamMember;
 
 class HostThreadTeamData {
-public:
-
-  template< class > friend class HostThreadTeamMember ;
+ public:
+  template <class>
+  friend class HostThreadTeamMember;
 
   // Assume upper bounds on number of threads:
   //   pool size       <= 1024 threads
   //   team size       <= 64 threads
 
-  enum : int { max_pool_members  = 1024 };
-  enum : int { max_team_members  = 64 };
+  enum : int { max_pool_members = 1024 };
+  enum : int { max_team_members = 64 };
   enum : int { max_pool_rendezvous = HostBarrier::required_buffer_size };
   enum : int { max_team_rendezvous = HostBarrier::required_buffer_size };
 
-private:
-
+ private:
   // per-thread scratch memory buffer chunks:
   //
   //   [ pool_members ]     = [ m_pool_members    .. m_pool_rendezvous )
@@ -89,168 +89,124 @@ private:
   //   [ team_shared ]      = [ m_team_shared     .. m_thread_local )
   //   [ thread_local ]     = [ m_thread_local    .. m_scratch_size )
 
-  enum : int { m_pool_members    = 0 };
-  enum : int { m_pool_rendezvous = m_pool_members    + max_pool_members };
+  enum : int { m_pool_members = 0 };
+  enum : int { m_pool_rendezvous = m_pool_members + max_pool_members };
   enum : int { m_team_rendezvous = m_pool_rendezvous + max_pool_rendezvous };
-  enum : int { m_pool_reduce     = m_team_rendezvous + max_team_rendezvous };
-
-  using pair_int_t = Kokkos::pair<int64_t,int64_t> ;
-
-  pair_int_t  m_work_range ;
-  int64_t     m_work_end ;
-  int64_t   * m_scratch ;       // per-thread buffer
-  int64_t   * m_pool_scratch ;  // == pool[0]->m_scratch
-  int64_t   * m_team_scratch ;  // == pool[ 0 + m_team_base ]->m_scratch
-  int         m_pool_rank ;
-  int         m_pool_size ;
-  int         m_team_reduce ;
-  int         m_team_shared ;
-  int         m_thread_local ;
-  int         m_scratch_size ;
-  int         m_team_base ;
-  int         m_team_rank ;
-  int         m_team_size ;
-  int         m_team_alloc ;
-  int         m_league_rank ;
-  int         m_league_size ;
-  int         m_work_chunk ;
-  int         m_steal_rank ; // work stealing rank
-  int mutable m_pool_rendezvous_step ;
-  int mutable m_team_rendezvous_step ;
-
-  HostThreadTeamData * team_member( int r ) const noexcept
-    { return ((HostThreadTeamData**)(m_pool_scratch+m_pool_members))[m_team_base+r]; }
-
-public:
-
-  inline
-  bool team_rendezvous() const noexcept
-  {
-    int * ptr = (int *)(m_team_scratch + m_team_rendezvous);
-    HostBarrier::split_arrive( ptr
-                             , m_team_size
-                             , m_team_rendezvous_step
-                             );
+  enum : int { m_pool_reduce = m_team_rendezvous + max_team_rendezvous };
+
+  using pair_int_t = Kokkos::pair<int64_t, int64_t>;
+
+  pair_int_t m_work_range;
+  int64_t m_work_end;
+  int64_t* m_scratch;       // per-thread buffer
+  int64_t* m_pool_scratch;  // == pool[0]->m_scratch
+  int64_t* m_team_scratch;  // == pool[ 0 + m_team_base ]->m_scratch
+  int m_pool_rank;
+  int m_pool_size;
+  int m_team_reduce;
+  int m_team_shared;
+  int m_thread_local;
+  int m_scratch_size;
+  int m_team_base;
+  int m_team_rank;
+  int m_team_size;
+  int m_team_alloc;
+  int m_league_rank;
+  int m_league_size;
+  int m_work_chunk;
+  int m_steal_rank;  // work stealing rank
+  int mutable m_pool_rendezvous_step;
+  int mutable m_team_rendezvous_step;
+
+  HostThreadTeamData* team_member(int r) const noexcept {
+    return ((HostThreadTeamData**)(m_pool_scratch +
+                                   m_pool_members))[m_team_base + r];
+  }
+
+ public:
+  inline bool team_rendezvous() const noexcept {
+    int* ptr = (int*)(m_team_scratch + m_team_rendezvous);
+    HostBarrier::split_arrive(ptr, m_team_size, m_team_rendezvous_step);
     if (m_team_rank != 0) {
-      HostBarrier::wait( ptr
-                       , m_team_size
-                       , m_team_rendezvous_step
-                       );
-    }
-    else {
-      HostBarrier::split_master_wait( ptr
-                                    , m_team_size
-                                    , m_team_rendezvous_step
-                                    );
+      HostBarrier::wait(ptr, m_team_size, m_team_rendezvous_step);
+    } else {
+      HostBarrier::split_master_wait(ptr, m_team_size, m_team_rendezvous_step);
     }
 
     return m_team_rank == 0;
   }
-  
-  inline
-  bool team_rendezvous(const int source_team_rank) const noexcept
-  {
-    int * ptr = (int *)(m_team_scratch + m_team_rendezvous);
-    HostBarrier::split_arrive( ptr
-                             , m_team_size
-                             , m_team_rendezvous_step
-                             );
+
+  inline bool team_rendezvous(const int source_team_rank) const noexcept {
+    int* ptr = (int*)(m_team_scratch + m_team_rendezvous);
+    HostBarrier::split_arrive(ptr, m_team_size, m_team_rendezvous_step);
     if (m_team_rank != source_team_rank) {
-      HostBarrier::wait( ptr
-                       , m_team_size
-                       , m_team_rendezvous_step
-                       );
-    }
-    else {
-      HostBarrier::split_master_wait( ptr
-                                    , m_team_size
-                                    , m_team_rendezvous_step
-                                    );
+      HostBarrier::wait(ptr, m_team_size, m_team_rendezvous_step);
+    } else {
+      HostBarrier::split_master_wait(ptr, m_team_size, m_team_rendezvous_step);
     }
 
     return (m_team_rank == source_team_rank);
   }
 
-  inline
-  void team_rendezvous_release() const noexcept
-    {
-      HostBarrier::split_release( (int *)(m_team_scratch + m_team_rendezvous)
-                                , m_team_size
-                                , m_team_rendezvous_step
-                                );
-    }
+  inline void team_rendezvous_release() const noexcept {
+    HostBarrier::split_release((int*)(m_team_scratch + m_team_rendezvous),
+                               m_team_size, m_team_rendezvous_step);
+  }
 
-  inline
-  int pool_rendezvous() const noexcept
-  {
-    // not sure if the follow hack is still needed with the new barrier
-    #if 0
+  inline int pool_rendezvous() const noexcept {
+// not sure if the follow hack is still needed with the new barrier
+#if 0
     static constexpr bool active_wait =
-    #if defined( KOKKOS_COMPILER_IBM )
+#if defined(KOKKOS_COMPILER_IBM)
       // If running on IBM POWER architecture the global
       // level rendzvous should immediately yield when
       // waiting for other threads in the pool to arrive.
       false;
-    #else
+#else
       true;
-    #endif
-    #endif
-
-    int * ptr = (int *)(m_pool_scratch + m_pool_rendezvous);
-    HostBarrier::split_arrive( ptr
-        , m_pool_size
-        , m_pool_rendezvous_step
-        );
+#endif
+#endif
+
+    int* ptr = (int*)(m_pool_scratch + m_pool_rendezvous);
+    HostBarrier::split_arrive(ptr, m_pool_size, m_pool_rendezvous_step);
     if (m_pool_rank != 0) {
-      HostBarrier::wait( ptr
-          , m_pool_size
-          , m_pool_rendezvous_step
-          );
-    }
-    else {
-      HostBarrier::split_master_wait( ptr
-          , m_pool_size
-          , m_pool_rendezvous_step
-          );
+      HostBarrier::wait(ptr, m_pool_size, m_pool_rendezvous_step);
+    } else {
+      HostBarrier::split_master_wait(ptr, m_pool_size, m_pool_rendezvous_step);
     }
 
     return m_pool_rank == 0;
   }
 
-  inline
-  void pool_rendezvous_release() const noexcept
-    {
-      HostBarrier::split_release( (int *)(m_pool_scratch + m_pool_rendezvous)
-                                , m_pool_size
-                                , m_pool_rendezvous_step
-                                );
-    }
+  inline void pool_rendezvous_release() const noexcept {
+    HostBarrier::split_release((int*)(m_pool_scratch + m_pool_rendezvous),
+                               m_pool_size, m_pool_rendezvous_step);
+  }
 
   //----------------------------------------
 
   constexpr HostThreadTeamData() noexcept
-    : m_work_range(-1,-1)
-    , m_work_end(0)
-    , m_scratch(0)
-    , m_pool_scratch(0)
-    , m_team_scratch(0)
-    , m_pool_rank(0)
-    , m_pool_size(1)
-    , m_team_reduce(0)
-    , m_team_shared(0)
-    , m_thread_local(0)
-    , m_scratch_size(0)
-    , m_team_base(0)
-    , m_team_rank(0)
-    , m_team_size(1)
-    , m_team_alloc(1)
-    , m_league_rank(0)
-    , m_league_size(1)
-    , m_work_chunk(0)
-    , m_steal_rank(0)
-    , m_pool_rendezvous_step(0)
-    , m_team_rendezvous_step(0)
-    {}
+      : m_work_range(-1, -1),
+        m_work_end(0),
+        m_scratch(0),
+        m_pool_scratch(0),
+        m_team_scratch(0),
+        m_pool_rank(0),
+        m_pool_size(1),
+        m_team_reduce(0),
+        m_team_shared(0),
+        m_thread_local(0),
+        m_scratch_size(0),
+        m_team_base(0),
+        m_team_rank(0),
+        m_team_size(1),
+        m_team_alloc(1),
+        m_league_rank(0),
+        m_league_size(1),
+        m_work_chunk(0),
+        m_steal_rank(0),
+        m_pool_rendezvous_step(0),
+        m_team_rendezvous_step(0) {}
 
   //----------------------------------------
   // Organize array of members into a pool.
@@ -259,8 +215,7 @@ public:
   // Requires: called by one thread.
   // Pool members are ordered as "close" - sorted by NUMA and then CORE
   // Each thread is its own team with team_size == 1.
-  static void organize_pool( HostThreadTeamData * members[]
-                           , const int size );
+  static void organize_pool(HostThreadTeamData* members[], const int size);
 
   // Called by each thread within the pool
   void disband_pool();
@@ -274,7 +229,7 @@ public:
   //
   // Return true  if a valid member of a team.
   // Return false if not a member and thread should be idled.
-  int organize_team( const int team_size );
+  int organize_team(const int team_size);
 
   // Each thread within a pool disbands itself from current team.
   // Each thread becomes its own team with team_size == 1.
@@ -283,61 +238,70 @@ public:
 
   //----------------------------------------
 
-  constexpr int pool_rank() const { return m_pool_rank ; }
-  constexpr int pool_size() const { return m_pool_size ; }
+  constexpr int pool_rank() const { return m_pool_rank; }
+  constexpr int pool_size() const { return m_pool_size; }
 
-  HostThreadTeamData * pool_member( int r ) const noexcept
-    { return ((HostThreadTeamData**)(m_pool_scratch+m_pool_members))[r]; }
+  HostThreadTeamData* pool_member(int r) const noexcept {
+    return ((HostThreadTeamData**)(m_pool_scratch + m_pool_members))[r];
+  }
 
   //----------------------------------------
 
-private:
-
-  enum : int { mask_to_16 = 0x0f }; // align to 16 bytes
-  enum : int { shift_to_8 = 3 };    // size to 8 bytes
+ private:
+  enum : int { mask_to_16 = 0x0f };  // align to 16 bytes
+  enum : int { shift_to_8 = 3 };     // size to 8 bytes
 
-public:
-
-  static constexpr int align_to_int64( int n )
-    { return ( ( n + mask_to_16 ) & ~mask_to_16 ) >> shift_to_8 ; }
+ public:
+  static constexpr int align_to_int64(int n) {
+    return ((n + mask_to_16) & ~mask_to_16) >> shift_to_8;
+  }
 
-  constexpr int pool_reduce_bytes() const
-    { return m_scratch_size ? sizeof(int64_t) * ( m_team_reduce - m_pool_reduce ) : 0 ; }
+  constexpr int pool_reduce_bytes() const {
+    return m_scratch_size ? sizeof(int64_t) * (m_team_reduce - m_pool_reduce)
+                          : 0;
+  }
 
-  constexpr int team_reduce_bytes() const
-    { return sizeof(int64_t) * ( m_team_shared - m_team_reduce ); }
+  constexpr int team_reduce_bytes() const {
+    return sizeof(int64_t) * (m_team_shared - m_team_reduce);
+  }
 
-  constexpr int team_shared_bytes() const
-    { return sizeof(int64_t) * ( m_thread_local - m_team_shared ); }
+  constexpr int team_shared_bytes() const {
+    return sizeof(int64_t) * (m_thread_local - m_team_shared);
+  }
 
-  constexpr int thread_local_bytes() const
-    { return sizeof(int64_t) * ( m_scratch_size - m_thread_local ); }
+  constexpr int thread_local_bytes() const {
+    return sizeof(int64_t) * (m_scratch_size - m_thread_local);
+  }
 
-  constexpr int scratch_bytes() const
-    { return sizeof(int64_t) * m_scratch_size ; }
+  constexpr int scratch_bytes() const {
+    return sizeof(int64_t) * m_scratch_size;
+  }
 
   // Memory chunks:
 
-  int64_t * scratch_buffer() const noexcept
-    { return m_scratch ; }
+  int64_t* scratch_buffer() const noexcept { return m_scratch; }
 
-  int64_t * pool_reduce() const noexcept
-    { return m_pool_scratch + m_pool_reduce ; }
+  int64_t* pool_reduce() const noexcept {
+    return m_pool_scratch + m_pool_reduce;
+  }
 
-  int64_t * pool_reduce_local() const noexcept
-    { return m_scratch + m_pool_reduce ; }
+  int64_t* pool_reduce_local() const noexcept {
+    return m_scratch + m_pool_reduce;
+  }
 
-  int64_t * team_reduce() const noexcept
-    { return m_team_scratch + m_team_reduce ; }
+  int64_t* team_reduce() const noexcept {
+    return m_team_scratch + m_team_reduce;
+  }
 
-  int64_t * team_reduce_local() const noexcept
-    { return m_scratch + m_team_reduce ; }
+  int64_t* team_reduce_local() const noexcept {
+    return m_scratch + m_team_reduce;
+  }
 
-  int64_t * team_shared() const noexcept
-    { return m_team_scratch + m_team_shared ; }
+  int64_t* team_shared() const noexcept {
+    return m_team_scratch + m_team_shared;
+  }
 
-  int64_t * local_scratch() const noexcept
-    { return m_scratch + m_thread_local ; }
+  int64_t* local_scratch() const noexcept { return m_scratch + m_thread_local; }
 
   // Given:
   //   pool_reduce_size  = number bytes for pool reduce
@@ -346,26 +310,20 @@ public:
   //   thread_local_size = number bytes for thread local memory
   // Return:
   //   total number of bytes that must be allocated
-  static
-  size_t scratch_size( int pool_reduce_size
-                     , int team_reduce_size
-                     , int team_shared_size
-                     , int thread_local_size )
-    {
-      pool_reduce_size  = align_to_int64( pool_reduce_size );
-      team_reduce_size  = align_to_int64( team_reduce_size );
-      team_shared_size  = align_to_int64( team_shared_size );
-      thread_local_size = align_to_int64( thread_local_size );
-
-      const size_t total_bytes = (
-        m_pool_reduce +
-        pool_reduce_size +
-        team_reduce_size +
-        team_shared_size +
-        thread_local_size ) * sizeof(int64_t);
-
-      return total_bytes ;
-    }
+  static size_t scratch_size(int pool_reduce_size, int team_reduce_size,
+                             int team_shared_size, int thread_local_size) {
+    pool_reduce_size  = align_to_int64(pool_reduce_size);
+    team_reduce_size  = align_to_int64(team_reduce_size);
+    team_shared_size  = align_to_int64(team_shared_size);
+    thread_local_size = align_to_int64(thread_local_size);
+
+    const size_t total_bytes =
+        (m_pool_reduce + pool_reduce_size + team_reduce_size +
+         team_shared_size + thread_local_size) *
+        sizeof(int64_t);
+
+    return total_bytes;
+  }
 
   // Given:
   //   alloc_ptr         = pointer to allocated memory
@@ -376,23 +334,19 @@ public:
   //   thread_local_size = number bytes for thread-local memory
   // Return:
   //   total number of bytes that must be allocated
-  void scratch_assign( void * const alloc_ptr
-                     , size_t const alloc_size
-                     , int pool_reduce_size
-                     , int team_reduce_size
-                     , int team_shared_size
-                     , int /* thread_local_size */ )
-    {
-      pool_reduce_size  = align_to_int64( pool_reduce_size );
-      team_reduce_size  = align_to_int64( team_reduce_size );
-      team_shared_size  = align_to_int64( team_shared_size );
-      // thread_local_size = align_to_int64( thread_local_size );
-
-      m_scratch      = (int64_t *) alloc_ptr ;
-      m_team_reduce  = m_pool_reduce + pool_reduce_size ;
-      m_team_shared  = m_team_reduce + team_reduce_size ;
-      m_thread_local = m_team_shared + team_shared_size ;
-      m_scratch_size = align_to_int64( alloc_size );
+  void scratch_assign(void* const alloc_ptr, size_t const alloc_size,
+                      int pool_reduce_size, int team_reduce_size,
+                      int team_shared_size, int /* thread_local_size */) {
+    pool_reduce_size = align_to_int64(pool_reduce_size);
+    team_reduce_size = align_to_int64(team_reduce_size);
+    team_shared_size = align_to_int64(team_shared_size);
+    // thread_local_size = align_to_int64( thread_local_size );
+
+    m_scratch      = (int64_t*)alloc_ptr;
+    m_team_reduce  = m_pool_reduce + pool_reduce_size;
+    m_team_shared  = m_team_reduce + team_reduce_size;
+    m_thread_local = m_team_shared + team_shared_size;
+    m_scratch_size = align_to_int64(alloc_size);
 
 #if 0
 fprintf(stdout,"HostThreadTeamData::scratch_assign { %d %d %d %d %d %d %d }\n"
@@ -406,224 +360,222 @@ fprintf(stdout,"HostThreadTeamData::scratch_assign { %d %d %d %d %d %d %d }\n"
        );
 fflush(stdout);
 #endif
-
-    }
+  }
 
   //----------------------------------------
   // Get a work index within the range.
   // First try to steal from beginning of own teams's partition.
   // If that fails then try to steal from end of another teams' partition.
-  int get_work_stealing() noexcept ;
+  int get_work_stealing() noexcept;
 
   //----------------------------------------
   // Set the initial work partitioning of [ 0 .. length ) among the teams
   // with granularity of chunk
 
-  void set_work_partition( int64_t const length
-                         , int     const chunk ) noexcept
-    {
-      // Minimum chunk size to insure that
-      //   m_work_end < std::numeric_limits<int>::max() * m_work_chunk
-
-      int const chunk_min = ( length + std::numeric_limits<int>::max() )
-                            / std::numeric_limits<int>::max();
+  void set_work_partition(int64_t const length, int const chunk) noexcept {
+    // Minimum chunk size to insure that
+    //   m_work_end < std::numeric_limits<int>::max() * m_work_chunk
 
-      m_work_end   = length ;
-      m_work_chunk = std::max( chunk , chunk_min );
+    int const chunk_min = (length + std::numeric_limits<int>::max()) /
+                          std::numeric_limits<int>::max();
 
-      // Number of work chunks and partitioning of that number:
-      int const num  = ( m_work_end + m_work_chunk - 1 ) / m_work_chunk ;
-      int const part = ( num + m_league_size - 1 ) / m_league_size ;
+    m_work_end   = length;
+    m_work_chunk = std::max(chunk, chunk_min);
 
-      m_work_range.first  = part * m_league_rank ;
-      m_work_range.second = m_work_range.first + part ;
+    // Number of work chunks and partitioning of that number:
+    int const num  = (m_work_end + m_work_chunk - 1) / m_work_chunk;
+    int const part = (num + m_league_size - 1) / m_league_size;
 
-      // Steal from next team, round robin
-      // The next team is offset by m_team_alloc if it fits in the pool.
+    m_work_range.first  = part * m_league_rank;
+    m_work_range.second = m_work_range.first + part;
 
-      m_steal_rank = m_team_base + m_team_alloc + m_team_size <= m_pool_size ?
-                     m_team_base + m_team_alloc : 0 ;
-    }
+    // Steal from next team, round robin
+    // The next team is offset by m_team_alloc if it fits in the pool.
 
-  std::pair<int64_t,int64_t> get_work_partition() noexcept
-    {
-      int64_t first = m_work_range.first;
-      int64_t second = m_work_range.second;
-      first *= m_work_chunk;
-      second *= m_work_chunk;
-      return std::pair<int64_t,int64_t>
-        ( first
-        , second < m_work_end ? second : m_work_end );
-    }
+    m_steal_rank = m_team_base + m_team_alloc + m_team_size <= m_pool_size
+                       ? m_team_base + m_team_alloc
+                       : 0;
+  }
 
-  std::pair<int64_t,int64_t> get_work_stealing_chunk() noexcept
-    {
-      std::pair<int64_t,int64_t> x(-1,-1);
+  std::pair<int64_t, int64_t> get_work_partition() noexcept {
+    int64_t first  = m_work_range.first;
+    int64_t second = m_work_range.second;
+    first *= m_work_chunk;
+    second *= m_work_chunk;
+    return std::pair<int64_t, int64_t>(
+        first, second < m_work_end ? second : m_work_end);
+  }
 
-      const int i = get_work_stealing();
+  std::pair<int64_t, int64_t> get_work_stealing_chunk() noexcept {
+    std::pair<int64_t, int64_t> x(-1, -1);
 
-      if ( 0 <= i ) {
-        x.first  = m_work_chunk * i ;
-        x.second = x.first + m_work_chunk < m_work_end
-                 ? x.first + m_work_chunk : m_work_end ;
-      }
+    const int i = get_work_stealing();
 
-      return x ;
+    if (0 <= i) {
+      x.first  = m_work_chunk * i;
+      x.second = x.first + m_work_chunk < m_work_end ? x.first + m_work_chunk
+                                                     : m_work_end;
     }
+
+    return x;
+  }
 };
 
 //----------------------------------------------------------------------------
 
-template< class HostExecSpace >
+template <class HostExecSpace>
 class HostThreadTeamMember {
-public:
-
-  using scratch_memory_space = typename HostExecSpace::scratch_memory_space ;
-  using execution_space = HostExecSpace;
-  using thread_team_member = HostThreadTeamMember;
+ public:
+  using scratch_memory_space    = typename HostExecSpace::scratch_memory_space;
+  using execution_space         = HostExecSpace;
+  using thread_team_member      = HostThreadTeamMember;
   using host_thread_team_member = HostThreadTeamMember;
 
-private:
-
-  scratch_memory_space m_scratch ;
-  HostThreadTeamData & m_data ;
-  int const            m_league_rank ;
-  int const            m_league_size ;
-
-public:
-
-  constexpr HostThreadTeamMember( HostThreadTeamData & arg_data ) noexcept
-    : m_scratch( arg_data.team_shared() , arg_data.team_shared_bytes() )
-    , m_data( arg_data )
-    , m_league_rank(arg_data.m_league_rank)
-    , m_league_size(arg_data.m_league_size)
-    {}
-
-  constexpr HostThreadTeamMember( HostThreadTeamData & arg_data
-                                , int const            arg_league_rank
-                                , int const            arg_league_size
-                                ) noexcept
-    : m_scratch( arg_data.team_shared()
-               , arg_data.team_shared_bytes()
-               , arg_data.team_shared()
-               , arg_data.team_shared_bytes() )
-    , m_data( arg_data )
-    , m_league_rank( arg_league_rank )
-    , m_league_size( arg_league_size )
-    {}
-
-  ~HostThreadTeamMember() = default ;
-  HostThreadTeamMember() = delete ;
-  HostThreadTeamMember( HostThreadTeamMember && ) = default ;
-  HostThreadTeamMember( HostThreadTeamMember const & ) = default ;
-  HostThreadTeamMember & operator = ( HostThreadTeamMember && ) = default ;
-  HostThreadTeamMember & operator = ( HostThreadTeamMember const & ) = default ;
+ private:
+  scratch_memory_space m_scratch;
+  HostThreadTeamData& m_data;
+  int const m_league_rank;
+  int const m_league_size;
+
+ public:
+  constexpr HostThreadTeamMember(HostThreadTeamData& arg_data) noexcept
+      : m_scratch(arg_data.team_shared(), arg_data.team_shared_bytes()),
+        m_data(arg_data),
+        m_league_rank(arg_data.m_league_rank),
+        m_league_size(arg_data.m_league_size) {}
+
+  constexpr HostThreadTeamMember(HostThreadTeamData& arg_data,
+                                 int const arg_league_rank,
+                                 int const arg_league_size) noexcept
+      : m_scratch(arg_data.team_shared(), arg_data.team_shared_bytes(),
+                  arg_data.team_shared(), arg_data.team_shared_bytes()),
+        m_data(arg_data),
+        m_league_rank(arg_league_rank),
+        m_league_size(arg_league_size) {}
+
+  ~HostThreadTeamMember()                           = default;
+  HostThreadTeamMember()                            = delete;
+  HostThreadTeamMember(HostThreadTeamMember&&)      = default;
+  HostThreadTeamMember(HostThreadTeamMember const&) = default;
+  HostThreadTeamMember& operator=(HostThreadTeamMember&&) = default;
+  HostThreadTeamMember& operator=(HostThreadTeamMember const&) = default;
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  int team_rank() const noexcept { return m_data.m_team_rank ; }
+  int team_rank() const noexcept { return m_data.m_team_rank; }
 
   KOKKOS_INLINE_FUNCTION
-  int team_size() const noexcept { return m_data.m_team_size ; }
+  int team_size() const noexcept { return m_data.m_team_size; }
 
   KOKKOS_INLINE_FUNCTION
-  int league_rank() const noexcept { return m_league_rank ; }
+  int league_rank() const noexcept { return m_league_rank; }
 
   KOKKOS_INLINE_FUNCTION
-  int league_size() const noexcept { return m_league_size ; }
+  int league_size() const noexcept { return m_league_size; }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  const scratch_memory_space & team_shmem() const
-    { return m_scratch.set_team_thread_mode(0,1,0); }
+  const scratch_memory_space& team_shmem() const {
+    return m_scratch.set_team_thread_mode(0, 1, 0);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const scratch_memory_space & team_scratch(int) const
-    { return m_scratch.set_team_thread_mode(0,1,0); }
+  const scratch_memory_space& team_scratch(int) const {
+    return m_scratch.set_team_thread_mode(0, 1, 0);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  const scratch_memory_space & thread_scratch(int) const
-    { return m_scratch.set_team_thread_mode(0,m_data.m_team_size,m_data.m_team_rank); }
+  const scratch_memory_space& thread_scratch(int) const {
+    return m_scratch.set_team_thread_mode(0, m_data.m_team_size,
+                                          m_data.m_team_rank);
+  }
 
   //--------------------------------------------------------------------------
   // Team collectives
   //--------------------------------------------------------------------------
 
   KOKKOS_INLINE_FUNCTION void team_barrier() const noexcept
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    {
-      if ( m_data.team_rendezvous() ) { m_data.team_rendezvous_release(); };
-    }
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    if (m_data.team_rendezvous()) {
+      m_data.team_rendezvous_release();
+    };
+  }
 #else
-    {}
+  {
+  }
 #endif
 
   //--------------------------------------------------------------------------
 
-  template< typename T >
-  KOKKOS_INLINE_FUNCTION
-  void team_broadcast( T & value , const int source_team_rank ) const noexcept
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    {
-      if ( 1 < m_data.m_team_size ) {
-        T volatile * const shared_value = (T*) m_data.team_reduce();
-		
-        // Don't overwrite shared memory until all threads arrive
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(T& value,
+                                             const int source_team_rank) const
+      noexcept
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    if (1 < m_data.m_team_size) {
+      T volatile* const shared_value = (T*)m_data.team_reduce();
 
-        if ( m_data.team_rendezvous(source_team_rank) ) {
+      // Don't overwrite shared memory until all threads arrive
 
-          // All threads have entered 'team_rendezvous'
-          // only this thread returned from 'team_rendezvous'
-          // with a return value of 'true'
+      if (m_data.team_rendezvous(source_team_rank)) {
+        // All threads have entered 'team_rendezvous'
+        // only this thread returned from 'team_rendezvous'
+        // with a return value of 'true'
 
-          *shared_value = value;
+        *shared_value = value;
 
-          m_data.team_rendezvous_release();
-          // This thread released all other threads from 'team_rendezvous'
-          // with a return value of 'false'
-        }
-        else {
-          value = *shared_value ;
-        }
+        m_data.team_rendezvous_release();
+        // This thread released all other threads from 'team_rendezvous'
+        // with a return value of 'false'
+      } else {
+        value = *shared_value;
       }
     }
+  }
 #else
-    { Kokkos::abort("HostThreadTeamMember team_broadcast\n"); }
+  {
+    Kokkos::abort("HostThreadTeamMember team_broadcast\n");
+  }
 #endif
 
   //--------------------------------------------------------------------------
 
-  template< class Closure , typename T >
-  KOKKOS_INLINE_FUNCTION
-  void team_broadcast( Closure const & f , T & value , const int source_team_rank) const noexcept
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    {
-      T volatile * const shared_value = (T*) m_data.team_reduce();
-
-      // Don't overwrite shared memory until all threads arrive
-
-      if ( m_data.team_rendezvous(source_team_rank) ) {
+  template <class Closure, typename T>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(Closure const& f, T& value,
+                                             const int source_team_rank) const
+      noexcept
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    T volatile* const shared_value = (T*)m_data.team_reduce();
 
-        // All threads have entered 'team_rendezvous'
-        // only this thread returned from 'team_rendezvous'
-        // with a return value of 'true'
+    // Don't overwrite shared memory until all threads arrive
 
-        f( value );
+    if (m_data.team_rendezvous(source_team_rank)) {
+      // All threads have entered 'team_rendezvous'
+      // only this thread returned from 'team_rendezvous'
+      // with a return value of 'true'
 
-        if ( 1 < m_data.m_team_size ) { *shared_value = value ; }
+      f(value);
 
-        m_data.team_rendezvous_release();
-        // This thread released all other threads from 'team_rendezvous'
-        // with a return value of 'false'
-      }
-      else {
-        value = *shared_value ;
+      if (1 < m_data.m_team_size) {
+        *shared_value = value;
       }
+
+      m_data.team_rendezvous_release();
+      // This thread released all other threads from 'team_rendezvous'
+      // with a return value of 'false'
+    } else {
+      value = *shared_value;
     }
+  }
 #else
-    { Kokkos::abort("HostThreadTeamMember team_broadcast\n"); }
+  {
+    Kokkos::abort("HostThreadTeamMember team_broadcast\n");
+  }
 #endif
 
   //--------------------------------------------------------------------------
@@ -631,63 +583,65 @@ public:
   // team_reduce( Min(result) );
   // team_reduce( Max(result) );
 
-  template< typename ReducerType >
+  template <typename ReducerType>
   KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< is_reducer< ReducerType >::value >::type
-  team_reduce( ReducerType const & reducer ) const noexcept
-  { team_reduce(reducer,reducer.reference()); }
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      team_reduce(ReducerType const& reducer) const noexcept {
+    team_reduce(reducer, reducer.reference());
+  }
 
-  template< typename ReducerType >
+  template <typename ReducerType>
   KOKKOS_INLINE_FUNCTION
-  typename std::enable_if< is_reducer< ReducerType >::value >::type
-  team_reduce( ReducerType const & reducer, typename ReducerType::value_type contribution ) const noexcept
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    {
-      if ( 1 < m_data.m_team_size ) {
+      typename std::enable_if<is_reducer<ReducerType>::value>::type
+      team_reduce(ReducerType const& reducer,
+                  typename ReducerType::value_type contribution) const noexcept
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    if (1 < m_data.m_team_size) {
+      using value_type = typename ReducerType::value_type;
 
-        using value_type = typename ReducerType::value_type ;
+      if (0 != m_data.m_team_rank) {
+        // Non-root copies to their local buffer:
+        /*reducer.copy( (value_type*) m_data.team_reduce_local()
+                    , reducer.data() );*/
+        *((value_type*)m_data.team_reduce_local()) = contribution;
+      }
 
-        if ( 0 != m_data.m_team_rank ) {
-          // Non-root copies to their local buffer:
-          /*reducer.copy( (value_type*) m_data.team_reduce_local()
-                      , reducer.data() );*/
-          *((value_type*) m_data.team_reduce_local()) = contribution;
-        }
+      // Root does not overwrite shared memory until all threads arrive
+      // and copy to their local buffer.
 
-        // Root does not overwrite shared memory until all threads arrive
-        // and copy to their local buffer.
-
-        if ( m_data.team_rendezvous() ) {
-          // All threads have entered 'team_rendezvous'
-          // only this thread returned from 'team_rendezvous'
-          // with a return value of 'true'
-          //
-          // This thread sums contributed values
-          for ( int i = 1 ; i < m_data.m_team_size ; ++i ) {
-            value_type * const src =
-              (value_type*) m_data.team_member(i)->team_reduce_local();
-
-            reducer.join( contribution, *src);
-          }
-
-          // Copy result to root member's buffer:
-          // reducer.copy( (value_type*) m_data.team_reduce() , reducer.data() );
-          *((value_type*) m_data.team_reduce()) = contribution;
-          reducer.reference() = contribution;
-          m_data.team_rendezvous_release();
-          // This thread released all other threads from 'team_rendezvous'
-          // with a return value of 'false'
-        }
-        else {
-          // Copy from root member's buffer:
-          reducer.reference() = *((value_type*) m_data.team_reduce());
+      if (m_data.team_rendezvous()) {
+        // All threads have entered 'team_rendezvous'
+        // only this thread returned from 'team_rendezvous'
+        // with a return value of 'true'
+        //
+        // This thread sums contributed values
+        for (int i = 1; i < m_data.m_team_size; ++i) {
+          value_type* const src =
+              (value_type*)m_data.team_member(i)->team_reduce_local();
+
+          reducer.join(contribution, *src);
         }
+
+        // Copy result to root member's buffer:
+        // reducer.copy( (value_type*) m_data.team_reduce() , reducer.data() );
+        *((value_type*)m_data.team_reduce()) = contribution;
+        reducer.reference()                  = contribution;
+        m_data.team_rendezvous_release();
+        // This thread released all other threads from 'team_rendezvous'
+        // with a return value of 'false'
       } else {
-        reducer.reference() = contribution;
+        // Copy from root member's buffer:
+        reducer.reference() = *((value_type*)m_data.team_reduce());
       }
+    } else {
+      reducer.reference() = contribution;
     }
+  }
 #else
-    { Kokkos::abort("HostThreadTeamMember team_reduce\n"); }
+  {
+    Kokkos::abort("HostThreadTeamMember team_reduce\n");
+  }
 #endif
 
   //--------------------------------------------------------------------------
@@ -738,176 +692,138 @@ public:
     { Kokkos::abort("HostThreadTeamMember team_reduce\n"); return ValueType(); }
 #endif*/
 
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION T team_scan(T const& value, T* const global = 0) const
+      noexcept
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  {
+    if (0 != m_data.m_team_rank) {
+      // Non-root copies to their local buffer:
+      ((T*)m_data.team_reduce_local())[1] = value;
+    }
 
-  template< typename T >
-  KOKKOS_INLINE_FUNCTION
-  T team_scan( T const & value , T * const global = 0 ) const noexcept
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-    {
-      if ( 0 != m_data.m_team_rank ) {
-        // Non-root copies to their local buffer:
-        ((T*) m_data.team_reduce_local())[1] = value ;
-      }
-
-      // Root does not overwrite shared memory until all threads arrive
-      // and copy to their local buffer.
+    // Root does not overwrite shared memory until all threads arrive
+    // and copy to their local buffer.
 
-      if ( m_data.team_rendezvous() ) {
-        // All threads have entered 'team_rendezvous'
-        // only this thread returned from 'team_rendezvous'
-        // with a return value of 'true'
-        //
-        // This thread scans contributed values
+    if (m_data.team_rendezvous()) {
+      // All threads have entered 'team_rendezvous'
+      // only this thread returned from 'team_rendezvous'
+      // with a return value of 'true'
+      //
+      // This thread scans contributed values
 
-        {
-          T * prev = (T*) m_data.team_reduce_local();
+      {
+        T* prev = (T*)m_data.team_reduce_local();
 
-          prev[0] = 0 ;
-          prev[1] = value ;
+        prev[0] = 0;
+        prev[1] = value;
 
-          for ( int i = 1 ; i < m_data.m_team_size ; ++i ) {
-            T * const ptr = (T*) m_data.team_member(i)->team_reduce_local();
+        for (int i = 1; i < m_data.m_team_size; ++i) {
+          T* const ptr = (T*)m_data.team_member(i)->team_reduce_local();
 
-            ptr[0] = prev[0] + prev[1] ;
+          ptr[0] = prev[0] + prev[1];
 
-            prev = ptr ;
-          }
+          prev = ptr;
         }
+      }
 
-        // If adding to global value then atomic_fetch_add to that value
-        // and sum previous value to every entry of the scan.
-        if ( global ) {
-          T * prev = (T*) m_data.team_reduce_local();
-
-          {
-            T * ptr  = (T*) m_data.team_member( m_data.m_team_size - 1 )->team_reduce_local();
-            prev[0] = Kokkos::atomic_fetch_add( global , ptr[0] + ptr[1] );
-          }
+      // If adding to global value then atomic_fetch_add to that value
+      // and sum previous value to every entry of the scan.
+      if (global) {
+        T* prev = (T*)m_data.team_reduce_local();
 
-          for ( int i = 1 ; i < m_data.m_team_size ; ++i ) {
-            T * ptr = (T*) m_data.team_member(i)->team_reduce_local();
-            ptr[0] += prev[0] ;
-          }
+        {
+          T* ptr = (T*)m_data.team_member(m_data.m_team_size - 1)
+                       ->team_reduce_local();
+          prev[0] = Kokkos::atomic_fetch_add(global, ptr[0] + ptr[1]);
         }
 
-        m_data.team_rendezvous_release();
+        for (int i = 1; i < m_data.m_team_size; ++i) {
+          T* ptr = (T*)m_data.team_member(i)->team_reduce_local();
+          ptr[0] += prev[0];
+        }
       }
 
-      return ((T*) m_data.team_reduce_local())[0];
+      m_data.team_rendezvous_release();
     }
+
+    return ((T*)m_data.team_reduce_local())[0];
+  }
 #else
-    { Kokkos::abort("HostThreadTeamMember team_scan\n"); return T(); }
+  {
+    Kokkos::abort("HostThreadTeamMember team_scan\n");
+    return T();
+  }
 #endif
-
 };
 
-
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-template<typename iType, typename Member>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType, Member>
+template <typename iType, typename Member>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<iType, Member>
 TeamThreadRange(
-  Member const & member,
-  iType count,
-  typename std::enable_if<
-    Impl::is_thread_team_member<Member>::value
-  >::type const** = nullptr
-)
-{
-  return
-    Impl::TeamThreadRangeBoundariesStruct
-      <iType, Member>(member,0,count);
+    Member const& member, iType count,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Member>(member, 0, count);
 }
 
-template<typename iType1, typename iType2, typename Member>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<
-  typename std::common_type< iType1, iType2 >::type, Member
->
+template <typename iType1, typename iType2, typename Member>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type, Member>
 TeamThreadRange(
-  Member const & member,
-  iType1 begin,
-  iType2 end,
-  typename std::enable_if<
-    Impl::is_thread_team_member<Member>::value
-  >::type const** = nullptr
-)
-{
-  return
-    Impl::TeamThreadRangeBoundariesStruct
-      < typename std::common_type< iType1, iType2 >::type
-      , Member >( member , begin , end );
+    Member const& member, iType1 begin, iType2 end,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      typename std::common_type<iType1, iType2>::type, Member>(member, begin,
+                                                               end);
 }
 
-template<typename iType, typename Member>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<iType, Member>
+template <typename iType, typename Member>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<iType, Member>
 TeamVectorRange(
-  Member const & member,
-  iType count,
-  typename std::enable_if<
-    Impl::is_thread_team_member<Member>::value
-  >::type const** = nullptr
-)
-{
-  return
-    Impl::TeamThreadRangeBoundariesStruct
-      <iType, Member>(member,0,count);
+    Member const& member, iType count,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Member>(member, 0, count);
 }
 
-template<typename iType1, typename iType2, typename Member>
-KOKKOS_INLINE_FUNCTION
-Impl::TeamThreadRangeBoundariesStruct<
-  typename std::common_type< iType1, iType2 >::type, Member
->
+template <typename iType1, typename iType2, typename Member>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    typename std::common_type<iType1, iType2>::type, Member>
 TeamVectorRange(
-  Member const & member,
-  iType1 begin,
-  iType2 end,
-  typename std::enable_if<
-    Impl::is_thread_team_member<Member>::value
-  >::type const** = nullptr
-)
-{
-  return
-    Impl::TeamThreadRangeBoundariesStruct
-      < typename std::common_type< iType1, iType2 >::type
-      , Member >( member , begin , end );
+    Member const& member, iType1 begin, iType2 end,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      typename std::common_type<iType1, iType2>::type, Member>(member, begin,
+                                                               end);
 }
 
-template<typename iType, typename Member>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType, Member>
+template <typename iType, typename Member>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<iType, Member>
 ThreadVectorRange(
-  Member const & member,
-  iType count,
-  typename std::enable_if<
-    Impl::is_thread_team_member<Member>::value
-  >::type const** = nullptr
-)
-{
-  return Impl::ThreadVectorRangeBoundariesStruct<iType, Member>(member,count);
+    Member const& member, iType count,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Member>(member, count);
 }
 
-template<typename iType, typename Member>
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadVectorRangeBoundariesStruct<iType, Member>
+template <typename iType, typename Member>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<iType, Member>
 ThreadVectorRange(
-  Member const & member,
-  iType arg_begin,
-  iType arg_end,
-  typename std::enable_if<
-    Impl::is_thread_team_member<Member>::value
-  >::type const** = nullptr
-)
-{
-  return Impl::ThreadVectorRangeBoundariesStruct<iType, Member>(member,arg_begin,arg_end);
+    Member const& member, iType arg_begin, iType arg_end,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Member>(
+      member, arg_begin, arg_end);
 }
 
 //----------------------------------------------------------------------------
@@ -916,95 +832,72 @@ ThreadVectorRange(
  * Executes lambda(iType i) for each i=[0..N)
  *
  * The range [0..N) is mapped to all threads of the the calling thread team.
-*/
-template<typename iType, class Closure, class Member>
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( Impl::TeamThreadRangeBoundariesStruct<iType, Member> const & loop_boundaries
-  , Closure const & closure
-  , typename std::enable_if<
-      Impl::is_host_thread_team_member<Member>::value
-    >::type const** = nullptr
-  )
-{
-  for( iType i = loop_boundaries.start
-     ; i <  loop_boundaries.end
-     ; i += loop_boundaries.increment ) {
-    closure (i);
+ */
+template <typename iType, class Closure, class Member>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    Impl::TeamThreadRangeBoundariesStruct<iType, Member> const& loop_boundaries,
+    Closure const& closure,
+    typename std::enable_if<Impl::is_host_thread_team_member<Member>::value>::
+        type const** = nullptr) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    closure(i);
   }
 }
 
-template<typename iType, class Closure, class Member>
-KOKKOS_INLINE_FUNCTION
-void parallel_for
-  ( Impl::ThreadVectorRangeBoundariesStruct<iType, Member> const & loop_boundaries
-  , Closure const & closure
-  , typename std::enable_if<
-      Impl::is_host_thread_team_member<Member>::value
-    >::type const** = nullptr
-  )
-{
-  #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-  #pragma ivdep
-  #endif
-  for( iType i = loop_boundaries.start
-     ; i <  loop_boundaries.end
-     ; i += loop_boundaries.increment ) {
-    closure (i);
+template <typename iType, class Closure, class Member>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Member> const&
+        loop_boundaries,
+    Closure const& closure,
+    typename std::enable_if<Impl::is_host_thread_team_member<Member>::value>::
+        type const** = nullptr) {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    closure(i);
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename iType, class Closure, class Reducer, class Member >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Kokkos::is_reducer< Reducer >::value
-  && Impl::is_host_thread_team_member<Member>::value
->::type
-parallel_reduce
-  ( Impl::TeamThreadRangeBoundariesStruct<iType, Member>
-             const & loop_boundaries
-  , Closure  const & closure
-  , Reducer  const & reducer
-  )
-{
+template <typename iType, class Closure, class Reducer, class Member>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Kokkos::is_reducer<Reducer>::value &&
+    Impl::is_host_thread_team_member<Member>::value>::type
+parallel_reduce(
+    Impl::TeamThreadRangeBoundariesStruct<iType, Member> const& loop_boundaries,
+    Closure const& closure, Reducer const& reducer) {
   typename Reducer::value_type value;
-  reducer.init( value );
+  reducer.init(value);
 
-  for( iType i = loop_boundaries.start
-     ; i <  loop_boundaries.end
-     ; i += loop_boundaries.increment ) {
-    closure( i , value );
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    closure(i, value);
   }
-  
-  loop_boundaries.thread.team_reduce( reducer, value );
+
+  loop_boundaries.thread.team_reduce(reducer, value);
 }
 
-template< typename iType, typename Closure, typename ValueType, typename Member >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  ! Kokkos::is_reducer<ValueType>::value
-  && Impl::is_host_thread_team_member<Member>::value
->::type
-parallel_reduce
-  ( Impl::TeamThreadRangeBoundariesStruct<iType, Member >
-             const & loop_boundaries
-  , Closure  const & closure
-  , ValueType      & result
-  )
-{
+template <typename iType, typename Closure, typename ValueType, typename Member>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    !Kokkos::is_reducer<ValueType>::value &&
+    Impl::is_host_thread_team_member<Member>::value>::type
+parallel_reduce(
+    Impl::TeamThreadRangeBoundariesStruct<iType, Member> const& loop_boundaries,
+    Closure const& closure, ValueType& result) {
   ValueType val;
-  Sum<ValueType> reducer( val );
-  reducer.init( val );
+  Sum<ValueType> reducer(val);
+  reducer.init(val);
 
-  for( iType i = loop_boundaries.start
-     ; i <  loop_boundaries.end
-     ; i += loop_boundaries.increment ) {
-    closure( i , reducer.reference() );
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    closure(i, reducer.reference());
   }
 
-  loop_boundaries.thread.team_reduce( reducer );
+  loop_boundaries.thread.team_reduce(reducer);
   result = reducer.reference();
 }
 
@@ -1012,7 +905,8 @@ parallel_reduce
          , class Closure, class Joiner , typename ValueType >
 KOKKOS_INLINE_FUNCTION
 void parallel_reduce
-  ( Impl::TeamThreadRangeBoundariesStruct<iType,Impl::HostThreadTeamMember<Space> >
+  (
+Impl::TeamThreadRangeBoundariesStruct<iType,Impl::HostThreadTeamMember<Space> >
              const & loop_boundaries
   , Closure  const & closure
   , Joiner   const & joiner
@@ -1041,174 +935,131 @@ void parallel_reduce
  *  calling thread team and a summation of  val is
  *  performed and put into result.
  */
-template< typename iType, class Lambda, typename ValueType, typename Member >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  ! Kokkos::is_reducer<ValueType>::value
-  && Impl::is_host_thread_team_member<Member>::value
->::type
-parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType, Member>& loop_boundaries,
-   const Lambda & lambda,
-   ValueType& result)
-{
+template <typename iType, class Lambda, typename ValueType, typename Member>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    !Kokkos::is_reducer<ValueType>::value &&
+    Impl::is_host_thread_team_member<Member>::value>::type
+parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType, Member>&
+                    loop_boundaries,
+                const Lambda& lambda, ValueType& result) {
   result = ValueType();
-  for( iType i =  loop_boundaries.start ;
-             i <  loop_boundaries.end ;
-             i += loop_boundaries.increment) {
-    lambda(i,result);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
   }
 }
 
-template< typename iType, class Lambda, typename ReducerType, typename Member >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Kokkos::is_reducer< ReducerType >::value
-  && Impl::is_host_thread_team_member<Member>::value
->::type
-parallel_reduce
-  (const Impl::ThreadVectorRangeBoundariesStruct<iType, Member>& loop_boundaries,
-   const Lambda & lambda,
-   const ReducerType& reducer)
-{
+template <typename iType, class Lambda, typename ReducerType, typename Member>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Kokkos::is_reducer<ReducerType>::value &&
+    Impl::is_host_thread_team_member<Member>::value>::type
+parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<iType, Member>&
+                    loop_boundaries,
+                const Lambda& lambda, const ReducerType& reducer) {
   reducer.init(reducer.reference());
-  for( iType i =  loop_boundaries.start ;
-             i <  loop_boundaries.end ;
-             i += loop_boundaries.increment) {
-    lambda(i,reducer.reference());
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename iType, class Closure, class Member >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Impl::is_host_thread_team_member<Member>::value
->::type
-parallel_scan
-  ( Impl::TeamThreadRangeBoundariesStruct<iType, Member> const & loop_boundaries
-  , Closure const & closure
-  )
-{
+template <typename iType, class Closure, class Member>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Impl::is_host_thread_team_member<Member>::value>::type
+parallel_scan(
+    Impl::TeamThreadRangeBoundariesStruct<iType, Member> const& loop_boundaries,
+    Closure const& closure) {
   // Extract ValueType from the closure
 
-  using value_type =
-    typename Kokkos::Impl::FunctorAnalysis
-      < Kokkos::Impl::FunctorPatternInterface::SCAN
-      , void
-      , Closure >::value_type ;
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
 
-  value_type accum = 0 ;
+  value_type accum = 0;
 
   // Intra-member scan
-  for ( iType i = loop_boundaries.start
-      ; i <  loop_boundaries.end
-      ; i += loop_boundaries.increment ) {
-    closure(i,accum,false);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    closure(i, accum, false);
   }
 
   // 'accum' output is the exclusive prefix sum
   accum = loop_boundaries.thread.team_scan(accum);
 
-  for ( iType i = loop_boundaries.start
-      ; i <  loop_boundaries.end
-      ; i += loop_boundaries.increment ) {
-    closure(i,accum,true);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    closure(i, accum, true);
   }
 }
 
-
-template< typename iType, class ClosureType, class Member >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Impl::is_host_thread_team_member<Member>::value
->::type
-parallel_scan
-  ( Impl::ThreadVectorRangeBoundariesStruct<iType, Member > const & loop_boundaries
-  , ClosureType const & closure
-  )
-{
-  using value_type = typename
-    Kokkos::Impl::FunctorAnalysis
-      < Impl::FunctorPatternInterface::SCAN
-      , void
-      , ClosureType >::value_type ;
+template <typename iType, class ClosureType, class Member>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Impl::is_host_thread_team_member<Member>::value>::type
+parallel_scan(Impl::ThreadVectorRangeBoundariesStruct<iType, Member> const&
+                  loop_boundaries,
+              ClosureType const& closure) {
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Impl::FunctorPatternInterface::SCAN, void, ClosureType>::value_type;
 
   value_type scan_val = value_type();
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
-  for ( iType i = loop_boundaries.start
-      ; i <  loop_boundaries.end
-      ; i += loop_boundaries.increment ) {
-    closure(i,scan_val,true);
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    closure(i, scan_val, true);
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< class Member >
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Member>
-PerTeam(
-  Member const& member,
-  typename std::enable_if<Impl::is_thread_team_member<Member>::value>::type const** = nullptr
-)
-{
+template <class Member>
+KOKKOS_INLINE_FUNCTION Impl::ThreadSingleStruct<Member> PerTeam(
+    Member const& member,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
   return Impl::ThreadSingleStruct<Member>(member);
 }
 
-template< class Member >
-KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Member>
-PerThread(
-  Member const& member,
-  typename std::enable_if<Impl::is_thread_team_member<Member>::value>::type const** = nullptr
-)
-{
+template <class Member>
+KOKKOS_INLINE_FUNCTION Impl::VectorSingleStruct<Member> PerThread(
+    Member const& member,
+    typename std::enable_if<
+        Impl::is_thread_team_member<Member>::value>::type const** = nullptr) {
   return Impl::VectorSingleStruct<Member>(member);
 }
 
-template< class Member , class FunctorType >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Impl::is_host_thread_team_member<Member>::value
->::type
-single( const Impl::ThreadSingleStruct<Member> & single , const FunctorType & functor )
-{
+template <class Member, class FunctorType>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Impl::is_host_thread_team_member<Member>::value>::type
+single(const Impl::ThreadSingleStruct<Member>& single,
+       const FunctorType& functor) {
   // 'single' does not perform a barrier.
-  if ( single.team_member.team_rank() == 0 ) functor();
+  if (single.team_member.team_rank() == 0) functor();
 }
 
-template< class Member, class FunctorType , typename ValueType >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Impl::is_host_thread_team_member<Member>::value
->::type
-single( const Impl::ThreadSingleStruct<Member> & single , const FunctorType & functor , ValueType & val )
-{
-  single.team_member.team_broadcast( functor , val , 0 );
+template <class Member, class FunctorType, typename ValueType>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Impl::is_host_thread_team_member<Member>::value>::type
+single(const Impl::ThreadSingleStruct<Member>& single,
+       const FunctorType& functor, ValueType& val) {
+  single.team_member.team_broadcast(functor, val, 0);
 }
 
-template< class Member, class FunctorType >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Impl::is_host_thread_team_member<Member>::value
->::type
-single( const Impl::VectorSingleStruct<Member> & , const FunctorType & functor )
-{
+template <class Member, class FunctorType>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Impl::is_host_thread_team_member<Member>::value>::type
+single(const Impl::VectorSingleStruct<Member>&, const FunctorType& functor) {
   functor();
 }
 
-template< class Member, class FunctorType , typename ValueType >
-KOKKOS_INLINE_FUNCTION
-typename std::enable_if<
-  Impl::is_host_thread_team_member<Member>::value
->::type
-single( const Impl::VectorSingleStruct<Member> & , const FunctorType & functor , ValueType & val )
-{
+template <class Member, class FunctorType, typename ValueType>
+KOKKOS_INLINE_FUNCTION typename std::enable_if<
+    Impl::is_host_thread_team_member<Member>::value>::type
+single(const Impl::VectorSingleStruct<Member>&, const FunctorType& functor,
+       ValueType& val) {
   functor(val);
 }
 
@@ -1218,4 +1069,3 @@ single( const Impl::VectorSingleStruct<Member> & , const FunctorType & functor ,
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_IMPL_HOSTTHREADTEAM_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_LIFO.hpp b/lib/kokkos/core/src/impl/Kokkos_LIFO.hpp
index 43e9783beb39d785ad78022f440527ac2eb2ff84..67e9af5c402b963bd2db7dd9ca69e3f4d0c3630e 100644
--- a/lib/kokkos/core/src/impl/Kokkos_LIFO.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_LIFO.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,13 +48,14 @@
 #define KOKKOS_IMPL_LIFO_HPP
 
 #include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_TASKDAG // Note: implies CUDA_VERSION >= 8000 if using CUDA
+#ifdef KOKKOS_ENABLE_TASKDAG  // Note: implies CUDA_VERSION >= 8000 if using
+                              // CUDA
 
 #include <Kokkos_Core_fwd.hpp>
 
 #include <Kokkos_PointerOwnership.hpp>
 #include <impl/Kokkos_OptionalRef.hpp>
-#include <impl/Kokkos_Error.hpp> // KOKKOS_EXPECTS
+#include <impl/Kokkos_Error.hpp>  // KOKKOS_EXPECTS
 #include <impl/Kokkos_LinkedListNode.hpp>
 
 #include <Kokkos_Atomic.hpp>  // atomic_compare_exchange, atomic_fence
@@ -68,32 +70,29 @@ namespace Impl {
 //----------------------------------------------------------------------------
 
 template <class T>
-struct LockBasedLIFOCommon
-{
-
+struct LockBasedLIFOCommon {
   using value_type = T;
 
   using node_type = SimpleSinglyLinkedListNode<>;
 
   static constexpr uintptr_t LockTag = ~uintptr_t(0);
-  static constexpr uintptr_t EndTag = ~uintptr_t(1);
+  static constexpr uintptr_t EndTag  = ~uintptr_t(1);
 
   OwningRawPtr<node_type> m_head = (node_type*)EndTag;
 
   KOKKOS_INLINE_FUNCTION
   bool _try_push_node(node_type& node) {
-
     KOKKOS_EXPECTS(!node.is_enqueued());
 
-    auto* volatile & next = LinkedListNodeAccess::next_ptr(node);
+    auto* volatile& next = LinkedListNodeAccess::next_ptr(node);
 
     // store the head of the queue in a local variable
     auto* old_head = m_head;
 
     // retry until someone locks the queue or we successfully compare exchange
     while (old_head != (node_type*)LockTag) {
-
-      // TODO @tasking @memory_order DSH this should have a memory order and not a memory fence
+      // TODO @tasking @memory_order DSH this should have a memory order and not
+      // a memory fence
 
       // set task->next to the head of the queue
       next = old_head;
@@ -114,13 +113,14 @@ struct LockBasedLIFOCommon
       //   old_head = m_head;
       old_head = ::Kokkos::atomic_compare_exchange(&m_head, old_head, &node);
 
-      if(old_head_tmp == old_head) return true;
+      if (old_head_tmp == old_head) return true;
     }
 
     // Failed, replace 'task->m_next' value since 'task' remains
     // not a member of a queue.
 
-    // TODO @tasking @memory_order DSH this should have a memory order and not a memory fence
+    // TODO @tasking @memory_order DSH this should have a memory order and not a
+    // memory fence
     LinkedListNodeAccess::mark_as_not_enqueued(node);
 
     // fence to emulate acquire semantics on next
@@ -131,55 +131,45 @@ struct LockBasedLIFOCommon
   }
 
   bool _is_empty() const noexcept {
-    // TODO @tasking @memory_order DSH make this an atomic load with memory order
+    // TODO @tasking @memory_order DSH make this an atomic load with memory
+    // order
     return (volatile node_type*)this->m_head == (node_type*)EndTag;
   }
-
 };
 
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------------------
 
 template <class T>
-class LockBasedLIFO
-  : private LockBasedLIFOCommon<T>
-{
-
-private:
-
-  using base_t = LockBasedLIFOCommon<T>;
+class LockBasedLIFO : private LockBasedLIFOCommon<T> {
+ private:
+  using base_t    = LockBasedLIFOCommon<T>;
   using node_type = typename base_t::node_type;
 
-public:
-
-  using value_type = typename base_t::value_type; // = T
+ public:
+  using value_type               = typename base_t::value_type;  // = T
   using intrusive_node_base_type = SimpleSinglyLinkedListNode<>;
 
-public:
-
-
-  LockBasedLIFO() = default;
+ public:
+  LockBasedLIFO()                     = default;
   LockBasedLIFO(LockBasedLIFO const&) = delete;
-  LockBasedLIFO(LockBasedLIFO&&) = delete;
+  LockBasedLIFO(LockBasedLIFO&&)      = delete;
   LockBasedLIFO& operator=(LockBasedLIFO const&) = delete;
   LockBasedLIFO& operator=(LockBasedLIFO&&) = delete;
 
   ~LockBasedLIFO() = default;
 
-
   bool empty() const noexcept {
     // TODO @tasking @memory_order DSH memory order
     return this->_is_empty();
   }
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef<T> pop(bool abort_on_locked = false)
-  {
+  OptionalRef<T> pop(bool abort_on_locked = false) {
     // Put this in here to avoid requiring value_type to be complete until now.
-    static_assert(
-      std::is_base_of<intrusive_node_base_type, value_type>::value,
-      "Intrusive linked-list value_type must be derived from intrusive_node_base_type"
-    );
+    static_assert(std::is_base_of<intrusive_node_base_type, value_type>::value,
+                  "Intrusive linked-list value_type must be derived from "
+                  "intrusive_node_base_type");
 
     // We can't use the static constexpr LockTag directly because
     // atomic_compare_exchange needs to bind a reference to that, and you
@@ -191,8 +181,7 @@ public:
     auto* rv = this->m_head;
 
     // Retry until the lock is acquired or the queue is empty.
-    while(rv != (node_type*)base_t::EndTag) {
-
+    while (rv != (node_type*)base_t::EndTag) {
       // The only possible values for the queue are
       // (1) lock, (2) end, or (3) a valid task.
       // Thus zero will never appear in the queue.
@@ -200,22 +189,23 @@ public:
       // If queue is locked then just read by guaranteeing the CAS will fail.
       KOKKOS_ASSERT(rv != nullptr);
 
-      if(rv == lock_tag) {
-        // TODO @tasking @memory_order DSH this should just be an atomic load followed by a continue
-        // just set rv to nullptr for now, effectively turning the
-        // atomic_compare_exchange below into a load
+      if (rv == lock_tag) {
+        // TODO @tasking @memory_order DSH this should just be an atomic load
+        // followed by a continue just set rv to nullptr for now, effectively
+        // turning the atomic_compare_exchange below into a load
         rv = nullptr;
-        if(abort_on_locked) {
+        if (abort_on_locked) {
           break;
         }
       }
 
       auto* const old_rv = rv;
 
-      // TODO @tasking @memory_order DSH this should be a weak compare exchange in a loop
+      // TODO @tasking @memory_order DSH this should be a weak compare exchange
+      // in a loop
       rv = Kokkos::atomic_compare_exchange(&(this->m_head), old_rv, lock_tag);
 
-      if(rv == old_rv) {
+      if (rv == old_rv) {
         // CAS succeeded and queue is locked
         //
         // This thread has locked the queue and removed 'rv' from the queue.
@@ -229,14 +219,16 @@ public:
         // This thread has exclusive access to
         // the queue and the popped task's m_next.
 
-        // TODO @tasking @memory_order DSH check whether the volatile is needed here
-        auto* volatile& next = LinkedListNodeAccess::next_ptr(*rv); //->m_next;
+        // TODO @tasking @memory_order DSH check whether the volatile is needed
+        // here
+        auto* volatile& next = LinkedListNodeAccess::next_ptr(*rv);  //->m_next;
 
         // This algorithm is not lockfree because a adversarial scheduler could
         // context switch this thread at this point and the rest of the threads
         // calling this method would never make forward progress
 
-        // TODO @tasking @memory_order DSH I think this needs to be a atomic store release (and the memory fence needs to be removed)
+        // TODO @tasking @memory_order DSH I think this needs to be a atomic
+        // store release (and the memory fence needs to be removed)
         // TODO @tasking DSH prove that this doesn't need to be a volatile store
         // Lock is released here
         this->m_head = next;
@@ -246,7 +238,7 @@ public:
 
         Kokkos::memory_fence();
 
-        return OptionalRef<T>{ *static_cast<T*>(rv) };
+        return OptionalRef<T>{*static_cast<T*>(rv)};
       }
 
       // Otherwise, the CAS got a value that didn't match (either because
@@ -256,36 +248,32 @@ public:
     }
 
     // Return an empty OptionalRef by calling the default constructor
-    return { };
+    return {};
   }
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef<T>
-  steal()
-  {
+  OptionalRef<T> steal() {
     // TODO @tasking @optimization DSH do this with fewer retries
     return pop(/* abort_on_locked = */ true);
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool push(node_type& node)
-  {
-    while(!this->_try_push_node(node)) { /* retry until success */ }
+  bool push(node_type& node) {
+    while (!this->_try_push_node(node)) { /* retry until success */
+    }
     // for consistency with push interface on other queue types:
     return true;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool push(node_type&& node)
-  {
+  bool push(node_type&& node) {
     // Just forward to the lvalue version
     return push(node);
   }
-
 };
 
-
-/** @brief A Multiple Producer, Single Consumer Queue with some special semantics
+/** @brief A Multiple Producer, Single Consumer Queue with some special
+ * semantics
  *
  * This multi-producer, single consumer queue has the following semantics:
  *
@@ -306,27 +294,24 @@ public:
  *
  */
 template <class T>
-class SingleConsumeOperationLIFO
-  : private LockBasedLIFOCommon<T>
-{
-private:
-
-  using base_t = LockBasedLIFOCommon<T>;
+class SingleConsumeOperationLIFO : private LockBasedLIFOCommon<T> {
+ private:
+  using base_t    = LockBasedLIFOCommon<T>;
   using node_type = typename base_t::node_type;
 
   // Allows us to reuse the existing infrastructure for
   static constexpr auto ConsumedTag = base_t::LockTag;
 
-public:
-
-  using value_type = typename base_t::value_type; // = T
+ public:
+  using value_type = typename base_t::value_type;  // = T
 
   KOKKOS_INLINE_FUNCTION
   SingleConsumeOperationLIFO() noexcept = default;
 
   SingleConsumeOperationLIFO(SingleConsumeOperationLIFO const&) = delete;
-  SingleConsumeOperationLIFO(SingleConsumeOperationLIFO&&) = delete;
-  SingleConsumeOperationLIFO& operator=(SingleConsumeOperationLIFO const&) = delete;
+  SingleConsumeOperationLIFO(SingleConsumeOperationLIFO&&)      = delete;
+  SingleConsumeOperationLIFO& operator=(SingleConsumeOperationLIFO const&) =
+      delete;
   SingleConsumeOperationLIFO& operator=(SingleConsumeOperationLIFO&&) = delete;
 
   KOKKOS_INLINE_FUNCTION
@@ -345,21 +330,20 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool try_push(node_type& node)
-  {
+  bool try_push(node_type& node) {
     return this->_try_push_node(node);
     // Ensures: (return value is true) || (node.is_enqueued() == false);
   }
 
   template <class Function>
-  KOKKOS_INLINE_FUNCTION
-  void consume(Function&& f) {
+  KOKKOS_INLINE_FUNCTION void consume(Function&& f) {
     auto* const consumed_tag = (node_type*)ConsumedTag;
 
     // Swap the Consumed tag into the head of the queue:
 
     // (local variable used for assertion only)
-    // TODO @tasking @memory_order DSH this should have memory order release, I think
+    // TODO @tasking @memory_order DSH this should have memory order release, I
+    // think
     Kokkos::memory_fence();
     auto old_head = Kokkos::atomic_exchange(&(this->m_head), consumed_tag);
 
@@ -370,8 +354,7 @@ public:
 
     // We now have exclusive access to the queue; loop over it and call
     // the user function
-    while(old_head != (node_type*)base_t::EndTag) {
-
+    while (old_head != (node_type*)base_t::EndTag) {
       // get the Node to make the call with
       auto* call_arg = old_head;
 
@@ -384,15 +367,12 @@ public:
       // Call the user function
       auto& arg = *static_cast<T*>(call_arg);
       f(std::move(arg));
-
     }
-
   }
-
 };
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -400,9 +380,7 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-struct TaskQueueTraitsLockBased
-{
-
+struct TaskQueueTraitsLockBased {
   // TODO @tasking @documentation DSH document what concepts these match
 
   template <class Task>
@@ -413,19 +391,16 @@ struct TaskQueueTraitsLockBased
 
   template <class Task>
   using intrusive_task_base_type =
-    typename ready_queue_type<Task>::intrusive_node_base_type;
+      typename ready_queue_type<Task>::intrusive_node_base_type;
 
   static constexpr auto ready_queue_insertion_may_fail = false;
-
 };
 
-
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* defined KOKKOS_ENABLE_TASKDAG */
 #endif /* #ifndef KOKKOS_IMPL_LIFO_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_LinkedListNode.hpp b/lib/kokkos/core/src/impl/Kokkos_LinkedListNode.hpp
index 78a6faca907069b3a8cfe202d481ff80ea9ba5a8..1b7918ed78895d718e13a1cab73079dadb21d616 100644
--- a/lib/kokkos/core/src/impl/Kokkos_LinkedListNode.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_LinkedListNode.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,13 +48,14 @@
 #define KOKKOS_IMPL_LINKEDLISTNODE_HPP
 
 #include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_TASKDAG // Note: implies CUDA_VERSION >= 8000 if using CUDA
+#ifdef KOKKOS_ENABLE_TASKDAG  // Note: implies CUDA_VERSION >= 8000 if using
+                              // CUDA
 
 #include <Kokkos_Core_fwd.hpp>
 
 #include <Kokkos_PointerOwnership.hpp>
 #include <impl/Kokkos_OptionalRef.hpp>
-#include <impl/Kokkos_Error.hpp> // KOKKOS_EXPECTS
+#include <impl/Kokkos_Error.hpp>  // KOKKOS_EXPECTS
 
 #include <Kokkos_Atomic.hpp>  // atomic_compare_exchange, atomic_fence
 
@@ -65,16 +67,12 @@ namespace Impl {
 
 struct LinkedListNodeAccess;
 
-template <
-  uintptr_t NotEnqueuedValue = 0,
-  template <class> class PointerTemplate = std::add_pointer
->
-struct SimpleSinglyLinkedListNode
-{
-
-private:
-
-  using pointer_type = typename PointerTemplate<SimpleSinglyLinkedListNode>::type;
+template <uintptr_t NotEnqueuedValue             = 0,
+          template <class> class PointerTemplate = std::add_pointer>
+struct SimpleSinglyLinkedListNode {
+ private:
+  using pointer_type =
+      typename PointerTemplate<SimpleSinglyLinkedListNode>::type;
 
   pointer_type m_next = reinterpret_cast<pointer_type>(NotEnqueuedValue);
 
@@ -84,31 +82,27 @@ private:
 
   KOKKOS_INLINE_FUNCTION
   void mark_as_not_enqueued() noexcept {
-    // TODO @tasking @memory_order DSH make this an atomic store with memory order
+    // TODO @tasking @memory_order DSH make this an atomic store with memory
+    // order
     m_next = (pointer_type)NotEnqueuedValue;
   }
 
   KOKKOS_INLINE_FUNCTION
   void mark_as_not_enqueued() volatile noexcept {
-    // TODO @tasking @memory_order DSH make this an atomic store with memory order
+    // TODO @tasking @memory_order DSH make this an atomic store with memory
+    // order
     m_next = (pointer_type)NotEnqueuedValue;
   }
 
   KOKKOS_INLINE_FUNCTION
-  pointer_type& _next_ptr() noexcept {
-    return m_next;
-  }
+  pointer_type& _next_ptr() noexcept { return m_next; }
 
   KOKKOS_INLINE_FUNCTION
-  pointer_type volatile& _next_ptr() volatile noexcept {
-    return m_next;
-  }
+  pointer_type volatile& _next_ptr() volatile noexcept { return m_next; }
 
   KOKKOS_INLINE_FUNCTION
-  pointer_type const& _next_ptr() const noexcept {
-    return m_next;
-  }
-  
+  pointer_type const& _next_ptr() const noexcept { return m_next; }
+
   KOKKOS_INLINE_FUNCTION
   pointer_type const volatile& _next_ptr() const volatile noexcept {
     return m_next;
@@ -116,91 +110,76 @@ private:
 
   friend struct LinkedListNodeAccess;
 
-public:
-
+ public:
   // KOKKOS_CONSTEXPR_14
   KOKKOS_INLINE_FUNCTION
   bool is_enqueued() const noexcept {
-    // TODO @tasking @memory_order DSH make this an atomic load with memory order
+    // TODO @tasking @memory_order DSH make this an atomic load with memory
+    // order
     return m_next != reinterpret_cast<pointer_type>(NotEnqueuedValue);
   }
 
   // KOKKOS_CONSTEXPR_14
   KOKKOS_INLINE_FUNCTION
   bool is_enqueued() const volatile noexcept {
-    // TODO @tasking @memory_order DSH make this an atomic load with memory order
+    // TODO @tasking @memory_order DSH make this an atomic load with memory
+    // order
     return m_next != reinterpret_cast<pointer_type>(NotEnqueuedValue);
   }
-
 };
 
 /// Attorney for LinkedListNode, since user types inherit from it
-struct LinkedListNodeAccess
-{
-
+struct LinkedListNodeAccess {
   template <class Node>
-  KOKKOS_INLINE_FUNCTION
-  static void mark_as_not_enqueued(Node& node) noexcept {
+  KOKKOS_INLINE_FUNCTION static void mark_as_not_enqueued(Node& node) noexcept {
     node.mark_as_not_enqueued();
   }
 
   template <class Node>
-  KOKKOS_INLINE_FUNCTION
-  static void mark_as_not_enqueued(Node volatile& node) noexcept {
+  KOKKOS_INLINE_FUNCTION static void mark_as_not_enqueued(
+      Node volatile& node) noexcept {
     node.mark_as_not_enqueued();
   }
 
   template <class Node>
-  KOKKOS_INLINE_FUNCTION
-  static
-  typename Node::pointer_type&
-  next_ptr(Node& node) noexcept {
+  KOKKOS_INLINE_FUNCTION static typename Node::pointer_type& next_ptr(
+      Node& node) noexcept {
     return node._next_ptr();
   }
 
   template <class Node>
-  KOKKOS_INLINE_FUNCTION
-  static
-  typename Node::pointer_type&
-  next_ptr(Node volatile& node) noexcept {
+  KOKKOS_INLINE_FUNCTION static typename Node::pointer_type& next_ptr(
+      Node volatile& node) noexcept {
     return node._next_ptr();
   }
 
   template <class Node>
-  KOKKOS_INLINE_FUNCTION
-  static
-  typename Node::pointer_type&
-  next_ptr(Node const& node) noexcept {
+  KOKKOS_INLINE_FUNCTION static typename Node::pointer_type& next_ptr(
+      Node const& node) noexcept {
     return node._next_ptr();
   }
 
   template <class Node>
-  KOKKOS_INLINE_FUNCTION
-  static
-  typename Node::pointer_type&
-  prev_ptr(Node& node) noexcept {
+  KOKKOS_INLINE_FUNCTION static typename Node::pointer_type& prev_ptr(
+      Node& node) noexcept {
     return node._prev_ptr();
   }
 
   template <class Node>
-  KOKKOS_INLINE_FUNCTION
-  static
-  typename Node::pointer_type&
-  prev_ptr(Node const& node) noexcept {
+  KOKKOS_INLINE_FUNCTION static typename Node::pointer_type& prev_ptr(
+      Node const& node) noexcept {
     return node._prev_ptr();
   }
-
 };
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* defined KOKKOS_ENABLE_TASKDAG */
 #endif /* #ifndef KOKKOS_IMPL_LINKEDLISTNODE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_MemoryPool.cpp b/lib/kokkos/core/src/impl/Kokkos_MemoryPool.cpp
index 0394ccb5ad2c4dbbc28361002f0076fa91ca65f1..d48368f761b5f24de595f9048bedbb9e88d99390 100644
--- a/lib/kokkos/core/src/impl/Kokkos_MemoryPool.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_MemoryPool.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,73 +54,57 @@ namespace Impl {
 
 /* Verify size constraints:
  *   min_block_alloc_size <= max_block_alloc_size
- *   max_block_alloc_size <= min_superblock_size 
+ *   max_block_alloc_size <= min_superblock_size
  *   min_superblock_size  <= max_superblock_size
  *   min_superblock_size  <= min_total_alloc_size
- *   min_superblock_size  <= min_block_alloc_size * 
+ *   min_superblock_size  <= min_block_alloc_size *
  *                           max_block_per_superblock
  */
-void memory_pool_bounds_verification
-  ( size_t min_block_alloc_size
-  , size_t max_block_alloc_size
-  , size_t min_superblock_size
-  , size_t max_superblock_size
-  , size_t max_block_per_superblock
-  , size_t min_total_alloc_size
-  )
-{
-  const size_t max_superblock =
-    min_block_alloc_size * max_block_per_superblock ;
+void memory_pool_bounds_verification(size_t min_block_alloc_size,
+                                     size_t max_block_alloc_size,
+                                     size_t min_superblock_size,
+                                     size_t max_superblock_size,
+                                     size_t max_block_per_superblock,
+                                     size_t min_total_alloc_size) {
+  const size_t max_superblock = min_block_alloc_size * max_block_per_superblock;
 
-  if ( ( size_t(max_superblock_size) < min_superblock_size ) ||
-       ( min_total_alloc_size < min_superblock_size ) ||
-       ( max_superblock       < min_superblock_size ) ||
-       ( min_superblock_size  < max_block_alloc_size ) ||
-       ( max_block_alloc_size < min_block_alloc_size ) ) {
+  if ((size_t(max_superblock_size) < min_superblock_size) ||
+      (min_total_alloc_size < min_superblock_size) ||
+      (max_superblock < min_superblock_size) ||
+      (min_superblock_size < max_block_alloc_size) ||
+      (max_block_alloc_size < min_block_alloc_size)) {
+    std::ostringstream msg;
 
-    std::ostringstream msg ;
+    msg << "Kokkos::MemoryPool size constraint violation";
 
-    msg << "Kokkos::MemoryPool size constraint violation" ;
-
-    if ( size_t(max_superblock_size) < min_superblock_size ) {
-      msg << " : max_superblock_size("
-          << max_superblock_size
-          << ") < min_superblock_size("
-          << min_superblock_size << ")" ;
+    if (size_t(max_superblock_size) < min_superblock_size) {
+      msg << " : max_superblock_size(" << max_superblock_size
+          << ") < min_superblock_size(" << min_superblock_size << ")";
     }
 
-    if ( min_total_alloc_size < min_superblock_size ) {
-      msg << " : min_total_alloc_size("
-          << min_total_alloc_size
-          << ") < min_superblock_size("
-          << min_superblock_size << ")" ;
+    if (min_total_alloc_size < min_superblock_size) {
+      msg << " : min_total_alloc_size(" << min_total_alloc_size
+          << ") < min_superblock_size(" << min_superblock_size << ")";
     }
 
-    if ( max_superblock < min_superblock_size ) {
-      msg << " : max_superblock("
-          << max_superblock
-          << ") < min_superblock_size("
-          << min_superblock_size << ")" ;
+    if (max_superblock < min_superblock_size) {
+      msg << " : max_superblock(" << max_superblock
+          << ") < min_superblock_size(" << min_superblock_size << ")";
     }
 
-    if ( min_superblock_size < max_block_alloc_size ) {
-      msg << " : min_superblock_size("
-          << min_superblock_size
-          << ") < max_block_alloc_size("
-          << max_block_alloc_size << ")" ;
+    if (min_superblock_size < max_block_alloc_size) {
+      msg << " : min_superblock_size(" << min_superblock_size
+          << ") < max_block_alloc_size(" << max_block_alloc_size << ")";
     }
 
-    if ( max_block_alloc_size < min_block_alloc_size ) {
-      msg << " : max_block_alloc_size("
-          << max_block_alloc_size
-          << ") < min_block_alloc_size("
-          << min_block_alloc_size << ")" ;
+    if (max_block_alloc_size < min_block_alloc_size) {
+      msg << " : max_block_alloc_size(" << max_block_alloc_size
+          << ") < min_block_alloc_size(" << min_block_alloc_size << ")";
     }
 
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 }
 
-}
-}
-
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_MemoryPoolAllocator.hpp b/lib/kokkos/core/src/impl/Kokkos_MemoryPoolAllocator.hpp
index b4629df5b0a4260013ebe9d993fff885f81513be..54f91eb68d09a308b3a19b5b9835ea0ba1ae04ae 100644
--- a/lib/kokkos/core/src/impl/Kokkos_MemoryPoolAllocator.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_MemoryPoolAllocator.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,16 +58,13 @@ namespace Impl {
 
 template <class MemoryPool, class T>
 class MemoryPoolAllocator {
-public:
-
+ public:
   using memory_pool = MemoryPool;
 
-private:
-
+ private:
   memory_pool m_pool;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
   MemoryPoolAllocator() = default;
   KOKKOS_INLINE_FUNCTION
@@ -81,15 +79,16 @@ public:
   ~MemoryPoolAllocator() = default;
 
   KOKKOS_INLINE_FUNCTION
-  explicit MemoryPoolAllocator(memory_pool const& arg_pool) : m_pool(arg_pool) { }
+  explicit MemoryPoolAllocator(memory_pool const& arg_pool)
+      : m_pool(arg_pool) {}
   KOKKOS_INLINE_FUNCTION
-  explicit MemoryPoolAllocator(memory_pool&& arg_pool) : m_pool(std::move(arg_pool)) { }
+  explicit MemoryPoolAllocator(memory_pool&& arg_pool)
+      : m_pool(std::move(arg_pool)) {}
 
-public:
-
-  using value_type = T;
-  using pointer = T*;
-  using size_type = typename MemoryPool::memory_space::size_type;
+ public:
+  using value_type      = T;
+  using pointer         = T*;
+  using size_type       = typename MemoryPool::memory_space::size_type;
   using difference_type = typename std::make_signed<size_type>::type;
 
   template <class U>
@@ -100,21 +99,17 @@ public:
   KOKKOS_INLINE_FUNCTION
   pointer allocate(size_t n) {
     void* rv = m_pool.allocate(n * sizeof(T));
-    if(rv == nullptr) {
+    if (rv == nullptr) {
       Kokkos::abort("Kokkos MemoryPool allocator failed to allocate memory");
     }
     return reinterpret_cast<T*>(rv);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void deallocate(T* ptr, size_t n) {
-    m_pool.deallocate(ptr, n * sizeof(T));
-  }
+  void deallocate(T* ptr, size_t n) { m_pool.deallocate(ptr, n * sizeof(T)); }
 
   KOKKOS_INLINE_FUNCTION
-  size_type max_size() const {
-    return m_pool.max_block_size();
-  }
+  size_type max_size() const { return m_pool.max_block_size(); }
 
   KOKKOS_INLINE_FUNCTION
   bool operator==(MemoryPoolAllocator const& other) const {
@@ -125,16 +120,12 @@ public:
   bool operator!=(MemoryPoolAllocator const& other) const {
     return !(*this == other);
   }
-
 };
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
-
 #endif /* #ifndef KOKKOS_IMPL_MEMORYPOOLALLOCATOR_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_MemorySpace.hpp b/lib/kokkos/core/src/impl/Kokkos_MemorySpace.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..650cf8a70cab81e043b97b7fcafa3c5db8816a5d
--- /dev/null
+++ b/lib/kokkos/core/src/impl/Kokkos_MemorySpace.hpp
@@ -0,0 +1,110 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+/** @file Kokkos_MemorySpace.hpp
+ *
+ *  Operations common to memory space instances, or at least default
+ *  implementations thereof.
+ */
+
+#ifndef KOKKOS_IMPL_MEMORYSPACE_HPP
+#define KOKKOS_IMPL_MEMORYSPACE_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <impl/Kokkos_SharedAlloc.hpp>
+#include <impl/Kokkos_Error.hpp>
+
+#include <string>
+#include <iostream>
+#include <sstream>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class MemorySpace>
+SharedAllocationHeader *checked_allocation_with_header(MemorySpace const &space,
+                                                       std::string const &label,
+                                                       size_t alloc_size) {
+  try {
+    return reinterpret_cast<SharedAllocationHeader *>(
+        space.allocate(alloc_size + sizeof(SharedAllocationHeader)));
+  } catch (Kokkos::Experimental::RawMemoryAllocationFailure const &failure) {
+    auto generate_failure_message = [&](std::ostream &o) {
+      o << "Kokkos failed to allocate memory for label \"" << label
+        << "\".  Allocation using MemorySpace named \"" << space.name()
+        << "\" failed with the following error:  ";
+      failure.print_error_message(o);
+      if (failure.failure_mode() ==
+          Kokkos::Experimental::RawMemoryAllocationFailure::FailureMode::
+              AllocationNotAligned) {
+        // TODO: delete the misaligned memory?
+        o << "Warning: Allocation failed due to misalignment; memory may "
+             "be leaked."
+          << std::endl;
+      }
+      o.flush();
+    };
+    try {
+      std::ostringstream sstr;
+      generate_failure_message(sstr);
+      Kokkos::Impl::throw_runtime_exception(sstr.str());
+    } catch (std::bad_alloc const &) {
+      // Probably failed to allocate the string because we're so close to out
+      // of memory. Try printing to std::cerr instead
+      try {
+        generate_failure_message(std::cerr);
+      } catch (std::bad_alloc const &) {
+        // oh well, we tried...
+      }
+      Kokkos::Impl::throw_runtime_exception(
+          "Kokkos encountered an allocation failure, then another allocation "
+          "failure while trying to create the error message.");
+    }
+  }
+  return nullptr;  // unreachable
+}
+
+}  // end namespace Impl
+}  // end namespace Kokkos
+
+#endif  // KOKKOS_IMPL_MEMORYSPACE_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_Memory_Fence.hpp b/lib/kokkos/core/src/impl/Kokkos_Memory_Fence.hpp
index ac5948669ad4a321c7604876bfb4400d99deae2f..f8bef72b77f405997b9d9416f375e0028d9a2fb0 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Memory_Fence.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Memory_Fence.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,49 +43,44 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_MEMORY_FENCE_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_MEMORY_FENCE_HPP)
 #define KOKKOS_MEMORY_FENCE_HPP
 namespace Kokkos {
 
 //----------------------------------------------------------------------------
 
 KOKKOS_FORCEINLINE_FUNCTION
-void memory_fence()
-{
-#if defined( __CUDA_ARCH__ )
+void memory_fence() {
+#if defined(__CUDA_ARCH__)
   __threadfence();
-#elif defined( KOKKOS_ENABLE_ROCM_ATOMICS )
+#elif defined(KOKKOS_ENABLE_ROCM_ATOMICS)
   amp_barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE);
-#elif defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 )
-  asm volatile (
-	  "mfence" ::: "memory"
-  );
-#elif defined( KOKKOS_ENABLE_GNU_ATOMICS ) || \
-      ( defined( KOKKOS_COMPILER_NVCC ) && defined( KOKKOS_ENABLE_INTEL_ATOMICS ) )
+#elif defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+  asm volatile("mfence" ::: "memory");
+#elif defined(KOKKOS_ENABLE_GNU_ATOMICS) || \
+    (defined(KOKKOS_COMPILER_NVCC) && defined(KOKKOS_ENABLE_INTEL_ATOMICS))
   __sync_synchronize();
-#elif defined( KOKKOS_ENABLE_INTEL_ATOMICS )
+#elif defined(KOKKOS_ENABLE_INTEL_ATOMICS)
   _mm_mfence();
-#elif defined( KOKKOS_ENABLE_OPENMP_ATOMICS )
-  #pragma omp flush
-#elif defined( KOKKOS_ENABLE_WINDOWS_ATOMICS )
+#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
+#pragma omp flush
+#elif defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
   MemoryBarrier();
-#elif !defined( KOKKOS_ENABLE_SERIAL_ATOMICS )
- #error "Error: memory_fence() not defined"
+#elif !defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
+#error "Error: memory_fence() not defined"
 #endif
 }
 
 //////////////////////////////////////////////////////
 // store_fence()
 //
-// If possible use a store fence on the architecture, if not run a full memory fence
+// If possible use a store fence on the architecture, if not run a full memory
+// fence
 
 KOKKOS_FORCEINLINE_FUNCTION
-void store_fence()
-{
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 )
-  asm volatile (
-	  "sfence" ::: "memory"
-  );
+void store_fence() {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+  asm volatile("sfence" ::: "memory");
 #else
   memory_fence();
 #endif
@@ -93,21 +89,18 @@ void store_fence()
 //////////////////////////////////////////////////////
 // load_fence()
 //
-// If possible use a load fence on the architecture, if not run a full memory fence
+// If possible use a load fence on the architecture, if not run a full memory
+// fence
 
 KOKKOS_FORCEINLINE_FUNCTION
-void load_fence()
-{
-#if defined( KOKKOS_ENABLE_ASM ) && defined( KOKKOS_ENABLE_ISA_X86_64 )
-  asm volatile (
-	  "lfence" ::: "memory"
-  );
+void load_fence() {
+#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
+  asm volatile("lfence" ::: "memory");
 #else
   memory_fence();
 #endif
 }
 
-} // namespace kokkos
+}  // namespace Kokkos
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_MultipleTaskQueue.hpp b/lib/kokkos/core/src/impl/Kokkos_MultipleTaskQueue.hpp
index ed8d2be5aea514e9cb61e0221e6c2d916a4a0cdc..675547ba5e86dd58beb28f6179b25be69f5f1bec 100644
--- a/lib/kokkos/core/src/impl/Kokkos_MultipleTaskQueue.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_MultipleTaskQueue.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_IMPL_MULTIPLETASKQUEUE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -66,7 +67,6 @@
 #include <typeinfo>
 #include <stdexcept>
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
@@ -86,35 +86,29 @@ struct FailedQueueInsertionLinkedListSchedulingInfo {
   task_base_type* next = nullptr;
 };
 
-struct EmptyTaskSchedulingInfo { };
+struct EmptyTaskSchedulingInfo {};
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template <
-  class ExecSpace,
-  class MemorySpace,
-  class TaskQueueTraits,
-  class MemoryPool
->
+template <class ExecSpace, class MemorySpace, class TaskQueueTraits,
+          class MemoryPool>
 class MultipleTaskQueue;
 
 template <class TaskQueueTraits>
 struct MultipleTaskQueueTeamEntry {
-public:
-
-  using task_base_type = TaskNode<TaskQueueTraits>;
+ public:
+  using task_base_type          = TaskNode<TaskQueueTraits>;
   using runnable_task_base_type = RunnableTaskBase<TaskQueueTraits>;
-  using ready_queue_type = typename TaskQueueTraits::template ready_queue_type<task_base_type>;
-  using task_queue_traits = TaskQueueTraits;
+  using ready_queue_type =
+      typename TaskQueueTraits::template ready_queue_type<task_base_type>;
+  using task_queue_traits         = TaskQueueTraits;
   using task_scheduling_info_type = typename std::conditional<
-    TaskQueueTraits::ready_queue_insertion_may_fail,
-    FailedQueueInsertionLinkedListSchedulingInfo<TaskQueueTraits>,
-    EmptyTaskSchedulingInfo
-  >::type;
-
-private:
+      TaskQueueTraits::ready_queue_insertion_may_fail,
+      FailedQueueInsertionLinkedListSchedulingInfo<TaskQueueTraits>,
+      EmptyTaskSchedulingInfo>::type;
 
+ private:
   // Number of allowed priorities
   static constexpr int NumPriorities = 3;
 
@@ -123,277 +117,223 @@ private:
   task_base_type* m_failed_heads[NumPriorities][2];
 
   KOKKOS_INLINE_FUNCTION
-  task_base_type*&
-  failed_head_for(runnable_task_base_type const& task)
-  {
+  task_base_type*& failed_head_for(runnable_task_base_type const& task) {
     return m_failed_heads[int(task.get_priority())][int(task.get_task_type())];
   }
 
-  template <class _always_void=void>
-  KOKKOS_INLINE_FUNCTION
-  OptionalRef<task_base_type>
-  _pop_failed_insertion(
-    int priority, TaskType type,
-    typename std::enable_if<
-      task_queue_traits::ready_queue_insertion_may_fail
-        and std::is_void<_always_void>::value,
-      void*
-    >::type = nullptr
-  ) {
+  template <class _always_void = void>
+  KOKKOS_INLINE_FUNCTION OptionalRef<task_base_type> _pop_failed_insertion(
+      int priority, TaskType type,
+      typename std::enable_if<
+          task_queue_traits::ready_queue_insertion_may_fail and
+              std::is_void<_always_void>::value,
+          void*>::type = nullptr) {
     auto* rv_ptr = m_failed_heads[priority][(int)type];
-    if(rv_ptr) {
+    if (rv_ptr) {
       m_failed_heads[priority][(int)type] =
-        rv_ptr->as_runnable_task()
-          .template scheduling_info_as<task_scheduling_info_type>()
-            .next;
-      return OptionalRef<task_base_type>{ *rv_ptr };
-    }
-    else {
-      return OptionalRef<task_base_type>{ nullptr };
+          rv_ptr->as_runnable_task()
+              .template scheduling_info_as<task_scheduling_info_type>()
+              .next;
+      return OptionalRef<task_base_type>{*rv_ptr};
+    } else {
+      return OptionalRef<task_base_type>{nullptr};
     }
   }
 
-  template <class _always_void=void>
-  KOKKOS_INLINE_FUNCTION
-  OptionalRef<task_base_type>
-  _pop_failed_insertion(
-    int priority, TaskType type,
-    typename std::enable_if<
-      not task_queue_traits::ready_queue_insertion_may_fail
-        and std::is_void<_always_void>::value,
-      void*
-    >::type = nullptr
-  ) {
-    return OptionalRef<task_base_type>{ nullptr };
+  template <class _always_void = void>
+  KOKKOS_INLINE_FUNCTION OptionalRef<task_base_type> _pop_failed_insertion(
+      int priority, TaskType type,
+      typename std::enable_if<
+          not task_queue_traits::ready_queue_insertion_may_fail and
+              std::is_void<_always_void>::value,
+          void*>::type = nullptr) {
+    return OptionalRef<task_base_type>{nullptr};
   }
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
   MultipleTaskQueueTeamEntry() {
-    for(int iPriority = 0; iPriority < NumPriorities; ++iPriority) {
-      for(int iType = 0; iType < 2; ++iType) {
+    for (int iPriority = 0; iPriority < NumPriorities; ++iPriority) {
+      for (int iType = 0; iType < 2; ++iType) {
         m_failed_heads[iPriority][iType] = nullptr;
       }
     }
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  OptionalRef<task_base_type>
-  try_to_steal_ready_task()
-  {
+  OptionalRef<task_base_type> try_to_steal_ready_task() {
     auto return_value = OptionalRef<task_base_type>{};
     // prefer lower priority tasks when stealing
-    for(int i_priority = NumPriorities-1; i_priority >= 0; --i_priority) {
+    for (int i_priority = NumPriorities - 1; i_priority >= 0; --i_priority) {
       // Check for a single task with this priority
       return_value = m_ready_queues[i_priority][TaskSingle].steal();
-      if(return_value) return return_value;
+      if (return_value) return return_value;
 
       // Check for a team task with this priority
       return_value = m_ready_queues[i_priority][TaskTeam].steal();
-      if(return_value) return return_value;
-
+      if (return_value) return return_value;
     }
     return return_value;
   }
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef<task_base_type>
-  pop_ready_task()
-  {
+  OptionalRef<task_base_type> pop_ready_task() {
     auto return_value = OptionalRef<task_base_type>{};
-    for(int i_priority = 0; i_priority < NumPriorities; ++i_priority) {
+    for (int i_priority = 0; i_priority < NumPriorities; ++i_priority) {
       return_value = _pop_failed_insertion(i_priority, TaskTeam);
-      if(not return_value) return_value = m_ready_queues[i_priority][TaskTeam].pop();
-      if(return_value) return return_value;
+      if (not return_value)
+        return_value = m_ready_queues[i_priority][TaskTeam].pop();
+      if (return_value) return return_value;
 
       // Check for a single task with this priority
       return_value = _pop_failed_insertion(i_priority, TaskSingle);
-      if(not return_value) return_value = m_ready_queues[i_priority][TaskSingle].pop();
-      if(return_value) return return_value;
+      if (not return_value)
+        return_value = m_ready_queues[i_priority][TaskSingle].pop();
+      if (return_value) return return_value;
     }
     return return_value;
   }
 
   KOKKOS_INLINE_FUNCTION
-  ready_queue_type&
-  team_queue_for(runnable_task_base_type const& task)
-  {
+  ready_queue_type& team_queue_for(runnable_task_base_type const& task) {
     return m_ready_queues[int(task.get_priority())][int(task.get_task_type())];
   }
 
-
-  template <class _always_void=void>
-  KOKKOS_INLINE_FUNCTION
-  void do_handle_failed_insertion(
-    runnable_task_base_type&& task,
-    typename std::enable_if<
-      task_queue_traits::ready_queue_insertion_may_fail
-        and std::is_void<_always_void>::value,
-      void*
-    >::type = nullptr
-  )
-  {
+  template <class _always_void = void>
+  KOKKOS_INLINE_FUNCTION void do_handle_failed_insertion(
+      runnable_task_base_type&& task,
+      typename std::enable_if<
+          task_queue_traits::ready_queue_insertion_may_fail and
+              std::is_void<_always_void>::value,
+          void*>::type = nullptr) {
     // failed insertions, if they happen, must be from the only thread that
-    // is allowed to push to m_ready_queues, so this linked-list insertion is not
-    // concurrent
-    auto& node = task.template scheduling_info_as<task_scheduling_info_type>();
+    // is allowed to push to m_ready_queues, so this linked-list insertion is
+    // not concurrent
+    auto& node  = task.template scheduling_info_as<task_scheduling_info_type>();
     auto*& head = failed_head_for(task);
-    node.next = head;
-    head = &task;
+    node.next   = head;
+    head        = &task;
   }
 
-  template <class _always_void=void>
-  KOKKOS_INLINE_FUNCTION
-  void do_handle_failed_insertion(
-    runnable_task_base_type&& task,
-    typename std::enable_if<
-      not task_queue_traits::ready_queue_insertion_may_fail
-        and std::is_void<_always_void>::value,
-      void*
-    >::type = nullptr
-  )
-  {
+  template <class _always_void = void>
+  KOKKOS_INLINE_FUNCTION void do_handle_failed_insertion(
+      runnable_task_base_type&& task,
+      typename std::enable_if<
+          not task_queue_traits::ready_queue_insertion_may_fail and
+              std::is_void<_always_void>::value,
+          void*>::type = nullptr) {
     Kokkos::abort("should be unreachable!");
   }
 
-
-  template <class _always_void=void>
-  KOKKOS_INLINE_FUNCTION
-  void
-  flush_failed_insertions(
-    int priority,
-    int task_type,
-    typename std::enable_if<
-      task_queue_traits::ready_queue_insertion_may_fail
-        and std::is_void<_always_void>::value, // just to make this dependent on template parameter
-      int
-    >::type = 0
-  ) {
-    // TODO @tasking @minor DSH this somethimes gets some things out of LIFO order, which may be undesirable (but not a bug)
-
+  template <class _always_void = void>
+  KOKKOS_INLINE_FUNCTION void flush_failed_insertions(
+      int priority, int task_type,
+      typename std::enable_if<
+          task_queue_traits::ready_queue_insertion_may_fail and
+              std::is_void<_always_void>::value,  // just to make this dependent
+                                                  // on template parameter
+          int>::type = 0) {
+    // TODO @tasking @minor DSH this somethimes gets some things out of LIFO
+    // order, which may be undesirable (but not a bug)
 
     auto*& failed_head = m_failed_heads[priority][task_type];
-    auto& team_queue = m_ready_queues[priority][task_type];
+    auto& team_queue   = m_ready_queues[priority][task_type];
 
-    while(failed_head != nullptr) {
+    while (failed_head != nullptr) {
       bool success = team_queue.push(*failed_head);
-      if(success) {
+      if (success) {
         // Step to the next linked list element
-        failed_head = failed_head->as_runnable_task()
-          .template scheduling_info_as<task_scheduling_info_type>().next;
-      }
-      else {
+        failed_head =
+            failed_head->as_runnable_task()
+                .template scheduling_info_as<task_scheduling_info_type>()
+                .next;
+      } else {
         // no more room, stop traversing and leave the head where it is
         break;
       }
     }
   }
 
-
-  template <class _always_void=void>
-  KOKKOS_INLINE_FUNCTION
-  void
-  flush_failed_insertions(
-    int, int,
-    typename std::enable_if<
-      not task_queue_traits::ready_queue_insertion_may_fail
-        and std::is_void<_always_void>::value, // just to make this dependent on template parameter
-      int
-    >::type = 0
-  ) { }
-
+  template <class _always_void = void>
+  KOKKOS_INLINE_FUNCTION void flush_failed_insertions(
+      int, int,
+      typename std::enable_if<
+          not task_queue_traits::ready_queue_insertion_may_fail and
+              std::is_void<_always_void>::value,  // just to make this dependent
+                                                  // on template parameter
+          int>::type = 0) {}
 
   KOKKOS_INLINE_FUNCTION
-  void
-  flush_all_failed_insertions() {
-    for(int iPriority = 0; iPriority < NumPriorities; ++iPriority) {
+  void flush_all_failed_insertions() {
+    for (int iPriority = 0; iPriority < NumPriorities; ++iPriority) {
       flush_failed_insertions(iPriority, (int)TaskType::TaskTeam);
       flush_failed_insertions(iPriority, (int)TaskType::TaskSingle);
     }
   }
 
-
-  template <class TeamSchedulerInfo, class ExecutionSpace, class MemorySpace, class MemoryPool>
-  KOKKOS_INLINE_FUNCTION
-  void
-  do_schedule_runnable(
-    MultipleTaskQueue<ExecutionSpace, MemorySpace, TaskQueueTraits, MemoryPool>& queue,
-    RunnableTaskBase<TaskQueueTraits>&& task,
-    TeamSchedulerInfo const& info
+  template <class TeamSchedulerInfo, class ExecutionSpace, class MemorySpace,
+            class MemoryPool>
+  KOKKOS_INLINE_FUNCTION void do_schedule_runnable(
+      MultipleTaskQueue<ExecutionSpace, MemorySpace, TaskQueueTraits,
+                        MemoryPool>& queue,
+      RunnableTaskBase<TaskQueueTraits>&& task, TeamSchedulerInfo const& info
 
   ) {
     // Push on any nodes that failed to enqueue
     auto& team_queue = team_queue_for(task);
-    auto priority = task.get_priority();
-    auto task_type = task.get_task_type();
+    auto priority    = task.get_priority();
+    auto task_type   = task.get_task_type();
 
     // First schedule the task
-    queue.schedule_runnable_to_queue(
-      std::move(task),
-      team_queue,
-      info
-    );
+    queue.schedule_runnable_to_queue(std::move(task), team_queue, info);
 
     // Task may be enqueued and may be run at any point; don't touch it (hence
     // the use of move semantics)
     flush_failed_insertions((int)priority, (int)task_type);
   }
-
-
-
 };
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template <
-  class ExecSpace,
-  class MemorySpace,
-  class TaskQueueTraits,
-  class MemoryPool
->
+template <class ExecSpace, class MemorySpace, class TaskQueueTraits,
+          class MemoryPool>
 class MultipleTaskQueue final
-  : public TaskQueueMemoryManager<ExecSpace, MemorySpace, MemoryPool>,
-    public TaskQueueCommonMixin<MultipleTaskQueue<ExecSpace, MemorySpace, TaskQueueTraits, MemoryPool>>,
-    private ObjectWithVLAEmulation<
-      MultipleTaskQueue<ExecSpace, MemorySpace, TaskQueueTraits, MemoryPool>,
-      MultipleTaskQueueTeamEntry<TaskQueueTraits>
-    >
-{
-public:
-
-  using task_queue_type = MultipleTaskQueue; // mark as task_queue concept
+    : public TaskQueueMemoryManager<ExecSpace, MemorySpace, MemoryPool>,
+      public TaskQueueCommonMixin<MultipleTaskQueue<
+          ExecSpace, MemorySpace, TaskQueueTraits, MemoryPool>>,
+      private ObjectWithVLAEmulation<
+          MultipleTaskQueue<ExecSpace, MemorySpace, TaskQueueTraits,
+                            MemoryPool>,
+          MultipleTaskQueueTeamEntry<TaskQueueTraits>> {
+ public:
+  using task_queue_type   = MultipleTaskQueue;  // mark as task_queue concept
   using task_queue_traits = TaskQueueTraits;
-  using task_base_type = TaskNode<TaskQueueTraits>;
-  using ready_queue_type = typename TaskQueueTraits::template ready_queue_type<task_base_type>;
-
-private:
+  using task_base_type    = TaskNode<TaskQueueTraits>;
+  using ready_queue_type =
+      typename TaskQueueTraits::template ready_queue_type<task_base_type>;
 
+ private:
   using base_t = TaskQueueMemoryManager<ExecSpace, MemorySpace, MemoryPool>;
-  using common_mixin_t = TaskQueueCommonMixin<MultipleTaskQueue>;
+  using common_mixin_t       = TaskQueueCommonMixin<MultipleTaskQueue>;
   using vla_emulation_base_t = ObjectWithVLAEmulation<
-    MultipleTaskQueue<ExecSpace, MemorySpace, TaskQueueTraits, MemoryPool>,
-    MultipleTaskQueueTeamEntry<TaskQueueTraits>
-  >;
+      MultipleTaskQueue<ExecSpace, MemorySpace, TaskQueueTraits, MemoryPool>,
+      MultipleTaskQueueTeamEntry<TaskQueueTraits>>;
 
   // Allow private inheritance from ObjectWithVLAEmulation
   friend struct VLAEmulationAccess;
 
-public:
-
+ public:
   struct SchedulerInfo {
-    using team_queue_id_t = int32_t;
+    using team_queue_id_t                             = int32_t;
     static constexpr team_queue_id_t NoAssociatedTeam = -1;
-    team_queue_id_t team_association = NoAssociatedTeam;
+    team_queue_id_t team_association                  = NoAssociatedTeam;
 
     using scheduler_info_type = SchedulerInfo;
 
     KOKKOS_INLINE_FUNCTION
     constexpr explicit SchedulerInfo(team_queue_id_t association) noexcept
-      : team_association(association)
-    { }
+        : team_association(association) {}
 
     KOKKOS_INLINE_FUNCTION
     SchedulerInfo() = default;
@@ -412,106 +352,101 @@ public:
 
     KOKKOS_INLINE_FUNCTION
     ~SchedulerInfo() = default;
-
   };
 
   using task_scheduling_info_type = typename std::conditional<
-    TaskQueueTraits::ready_queue_insertion_may_fail,
-    FailedQueueInsertionLinkedListSchedulingInfo<TaskQueueTraits>,
-    EmptyTaskSchedulingInfo
-  >::type;
+      TaskQueueTraits::ready_queue_insertion_may_fail,
+      FailedQueueInsertionLinkedListSchedulingInfo<TaskQueueTraits>,
+      EmptyTaskSchedulingInfo>::type;
   using team_scheduler_info_type = SchedulerInfo;
 
   using runnable_task_base_type = RunnableTaskBase<TaskQueueTraits>;
 
   template <class Functor, class Scheduler>
-    // requires TaskScheduler<Scheduler> && TaskFunctor<Functor>
-  using runnable_task_type = RunnableTask<
-    task_queue_traits, Scheduler, typename Functor::value_type, Functor
-  >;
+  // requires TaskScheduler<Scheduler> && TaskFunctor<Functor>
+  using runnable_task_type =
+      RunnableTask<task_queue_traits, Scheduler, typename Functor::value_type,
+                   Functor>;
 
-  using aggregate_task_type = AggregateTask<task_queue_traits, task_scheduling_info_type>;
+  using aggregate_task_type =
+      AggregateTask<task_queue_traits, task_scheduling_info_type>;
 
   // Number of allowed priorities
   static constexpr int NumPriorities = 3;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr typename vla_emulation_base_t::vla_entry_count_type
-  n_queues() const noexcept { return this->n_vla_entries(); }
-
-public:
+  constexpr typename vla_emulation_base_t::vla_entry_count_type n_queues() const
+      noexcept {
+    return this->n_vla_entries();
+  }
 
+ public:
   //----------------------------------------------------------------------------
   // <editor-fold desc="Constructors, destructors, and assignment"> {{{2
 
-  MultipleTaskQueue() = delete;
+  MultipleTaskQueue()                         = delete;
   MultipleTaskQueue(MultipleTaskQueue const&) = delete;
-  MultipleTaskQueue(MultipleTaskQueue&&) = delete;
+  MultipleTaskQueue(MultipleTaskQueue&&)      = delete;
   MultipleTaskQueue& operator=(MultipleTaskQueue const&) = delete;
   MultipleTaskQueue& operator=(MultipleTaskQueue&&) = delete;
 
-  MultipleTaskQueue(
-    typename base_t::execution_space const& arg_execution_space,
-    typename base_t::memory_space const&,
-    typename base_t::memory_pool const& arg_memory_pool
-  ) : base_t(arg_memory_pool),
-      vla_emulation_base_t(
-        Impl::TaskQueueSpecialization<
-          // TODO @tasking @generalization DSH avoid referencing SimpleTaskScheduler directly?
-          SimpleTaskScheduler<typename base_t::execution_space, MultipleTaskQueue>
-        >::get_max_team_count(arg_execution_space)
-      )
-  { }
+  MultipleTaskQueue(typename base_t::execution_space const& arg_execution_space,
+                    typename base_t::memory_space const&,
+                    typename base_t::memory_pool const& arg_memory_pool)
+      : base_t(arg_memory_pool),
+        vla_emulation_base_t(
+            Impl::TaskQueueSpecialization<
+                // TODO @tasking @generalization DSH avoid referencing
+                // SimpleTaskScheduler directly?
+                SimpleTaskScheduler<typename base_t::execution_space,
+                                    MultipleTaskQueue>>::
+                get_max_team_count(arg_execution_space)) {}
 
   // </editor-fold> end Constructors, destructors, and assignment }}}2
   //----------------------------------------------------------------------------
 
   KOKKOS_FUNCTION
-  void
-  schedule_runnable(
-    runnable_task_base_type&& task,
-    team_scheduler_info_type const& info
-  ) {
+  void schedule_runnable(runnable_task_base_type&& task,
+                         team_scheduler_info_type const& info) {
     auto team_association = info.team_association;
     // Should only not be assigned if this is a host spawn...
-    if(team_association == team_scheduler_info_type::NoAssociatedTeam) {
+    if (team_association == team_scheduler_info_type::NoAssociatedTeam) {
       team_association = 0;
     }
-    this->vla_value_at(team_association).do_schedule_runnable(*this, std::move(task), info);
+    this->vla_value_at(team_association)
+        .do_schedule_runnable(*this, std::move(task), info);
     // Task may be enqueued and may be run at any point; don't touch it (hence
     // the use of move semantics)
   }
 
   KOKKOS_FUNCTION
-  OptionalRef<task_base_type>
-  pop_ready_task(
-    team_scheduler_info_type const& info
-  )
-  {
-    KOKKOS_EXPECTS(info.team_association != team_scheduler_info_type::NoAssociatedTeam);
+  OptionalRef<task_base_type> pop_ready_task(
+      team_scheduler_info_type const& info) {
+    KOKKOS_EXPECTS(info.team_association !=
+                   team_scheduler_info_type::NoAssociatedTeam);
 
-    auto return_value = OptionalRef<task_base_type>{};
+    auto return_value     = OptionalRef<task_base_type>{};
     auto team_association = info.team_association;
 
-    // always loop in order of priority first, then prefer team tasks over single tasks
+    // always loop in order of priority first, then prefer team tasks over
+    // single tasks
     auto& team_queue_info = this->vla_value_at(team_association);
 
-    if(task_queue_traits::ready_queue_insertion_may_fail) {
+    if (task_queue_traits::ready_queue_insertion_may_fail) {
       team_queue_info.flush_all_failed_insertions();
     }
 
     return_value = team_queue_info.pop_ready_task();
 
-    if(not return_value) {
-
+    if (not return_value) {
       // loop through the rest of the teams and try to steal
-      for(
-        auto isteal = (team_association + 1) % this->n_queues();
-        isteal != team_association;
-        isteal = (isteal + 1) % this->n_queues()
-      ) {
+      for (auto isteal = (team_association + 1) % this->n_queues();
+           isteal != team_association;
+           isteal = (isteal + 1) % this->n_queues()) {
         return_value = this->vla_value_at(isteal).try_to_steal_ready_task();
-        if(return_value) { break; }
+        if (return_value) {
+          break;
+        }
       }
 
       // Note that this is where we'd update the task's scheduling info
@@ -520,91 +455,76 @@ public:
     return return_value;
   }
 
-
-  // TODO @tasking @generalization DSH make this a property-based customization point
+  // TODO @tasking @generalization DSH make this a property-based customization
+  // point
   KOKKOS_INLINE_FUNCTION
-  team_scheduler_info_type
-  initial_team_scheduler_info(int rank_in_league) const noexcept {
+  team_scheduler_info_type initial_team_scheduler_info(int rank_in_league) const
+      noexcept {
     return team_scheduler_info_type{
-      typename team_scheduler_info_type::team_queue_id_t(rank_in_league % n_queues())
-    };
+        typename team_scheduler_info_type::team_queue_id_t(rank_in_league %
+                                                           n_queues())};
   }
 
-  // TODO @tasking @generalization DSH make this a property-based customization point
-  static /* KOKKOS_CONSTEXPR_14 */ size_t
-  task_queue_allocation_size(
-    typename base_t::execution_space const& exec_space,
-    typename base_t::memory_space const&,
-    typename base_t::memory_pool const&
-  )
-  {
-    using specialization =
-      Impl::TaskQueueSpecialization<
-        // TODO @tasking @generalization DSH avoid referencing SimpleTaskScheduler directly?
-        SimpleTaskScheduler<typename base_t::execution_space, MultipleTaskQueue>
-      >;
+  // TODO @tasking @generalization DSH make this a property-based customization
+  // point
+  static /* KOKKOS_CONSTEXPR_14 */ size_t task_queue_allocation_size(
+      typename base_t::execution_space const& exec_space,
+      typename base_t::memory_space const&,
+      typename base_t::memory_pool const&) {
+    using specialization = Impl::TaskQueueSpecialization<
+        // TODO @tasking @generalization DSH avoid referencing
+        // SimpleTaskScheduler directly?
+        SimpleTaskScheduler<typename base_t::execution_space,
+                            MultipleTaskQueue>>;
 
     return vla_emulation_base_t::required_allocation_size(
-      /* num_vla_entries = */ specialization::get_max_team_count(exec_space)
-    );
+        /* num_vla_entries = */ specialization::get_max_team_count(exec_space));
   }
 
   // Provide a sensible default that can be overridden
   KOKKOS_INLINE_FUNCTION
   void update_scheduling_info_from_completed_predecessor(
-    runnable_task_base_type& ready_task,
-    runnable_task_base_type const& predecessor
-  ) const
-  {
+      runnable_task_base_type& ready_task,
+      runnable_task_base_type const& predecessor) const {
     // Do nothing; we're using the extra storage for the failure linked list
   }
 
   // Provide a sensible default that can be overridden
   KOKKOS_INLINE_FUNCTION
   void update_scheduling_info_from_completed_predecessor(
-    aggregate_task_type& aggregate,
-    runnable_task_base_type const& predecessor
-  ) const
-  {
+      aggregate_task_type& aggregate,
+      runnable_task_base_type const& predecessor) const {
     // Do nothing; we're using the extra storage for the failure linked list
   }
 
   // Provide a sensible default that can be overridden
   KOKKOS_INLINE_FUNCTION
   void update_scheduling_info_from_completed_predecessor(
-    aggregate_task_type& aggregate,
-    aggregate_task_type const& predecessor
-  ) const
-  {
+      aggregate_task_type& aggregate,
+      aggregate_task_type const& predecessor) const {
     // Do nothing; we're using the extra storage for the failure linked list
   }
 
   // Provide a sensible default that can be overridden
   KOKKOS_INLINE_FUNCTION
   void update_scheduling_info_from_completed_predecessor(
-    runnable_task_base_type& ready_task,
-    aggregate_task_type const& predecessor
-  ) const
-  {
+      runnable_task_base_type& ready_task,
+      aggregate_task_type const& predecessor) const {
     // Do nothing; we're using the extra storage for the failure linked list
   }
 
   KOKKOS_INLINE_FUNCTION
-  void
-  handle_failed_ready_queue_insertion(
-    runnable_task_base_type&& task,
-    ready_queue_type&,
-    team_scheduler_info_type const& info
-  ) {
-    KOKKOS_EXPECTS(info.team_association != team_scheduler_info_type::NoAssociatedTeam);
-
-    this->vla_value_at(info.team_association).do_handle_failed_insertion(
-      std::move(task)
-    );
+  void handle_failed_ready_queue_insertion(
+      runnable_task_base_type&& task, ready_queue_type&,
+      team_scheduler_info_type const& info) {
+    KOKKOS_EXPECTS(info.team_association !=
+                   team_scheduler_info_type::NoAssociatedTeam);
+
+    this->vla_value_at(info.team_association)
+        .do_handle_failed_insertion(std::move(task));
   }
 };
 
-
 } /* namespace Impl */
 } /* namespace Kokkos */
 
@@ -613,4 +533,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_MULTIPLETASKQUEUE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_OldMacros.hpp b/lib/kokkos/core/src/impl/Kokkos_OldMacros.hpp
index c3198c0f13f09037229f338d1072f7885b63b018..6b1e8b63cceff7fd1ba7b29aa18c10375591ce6d 100644
--- a/lib/kokkos/core/src/impl/Kokkos_OldMacros.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_OldMacros.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -108,7 +109,8 @@
 
 #ifdef KOKKOS_CUDA_USE_RELOCATABLE_DEVICE_CODE
 #ifndef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-#define KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE KOKKOS_CUDA_USE_RELOCATABLE_DEVICE_CODE
+#define KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE \
+  KOKKOS_CUDA_USE_RELOCATABLE_DEVICE_CODE
 #endif
 #endif
 
@@ -142,7 +144,6 @@
 #endif
 #endif
 
-
 #if defined(KOKKOS_HAVE_CXX1Z) || defined(KOKKOS_ENABLE_CXX17)
 #ifndef KOKKOS_ENABLE_CXX1Z
 #define KOKKOS_ENABLE_CXX1Z KOKKOS_HAVE_CXX1Z
@@ -151,25 +152,29 @@
 
 #ifdef KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_CUDA
 #ifndef KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA
-#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_CUDA
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA \
+  KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_CUDA
 #endif
 #endif
 
 #ifdef KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_OPENMP
 #ifndef KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP
-#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_OPENMP
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP \
+  KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_OPENMP
 #endif
 #endif
 
 #ifdef KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_SERIAL
 #ifndef KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL
-#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_SERIAL
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL \
+  KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_SERIAL
 #endif
 #endif
 
 #ifdef KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_THREADS
 #ifndef KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS
-#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_THREADS
+#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS \
+  KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_THREADS
 #endif
 #endif
 
@@ -205,7 +210,8 @@
 
 #ifdef KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
 #ifndef KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
-#define KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
+#define KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION \
+  KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION
 #endif
 #endif
 
@@ -299,7 +305,6 @@
 #endif
 #endif
 
-
 #ifdef KOKKOS_MEMPOOL_PRINTERR
 #ifndef KOKKOS_ENABLE_MEMPOOL_PRINTERR
 #define KOKKOS_ENABLE_MEMPOOL_PRINTERR KOKKOS_MEMPOOL_PRINTERR
@@ -308,25 +313,29 @@
 
 #ifdef KOKKOS_MEMPOOL_PRINT_ACTIVE_SUPERBLOCKS
 #ifndef KOKKOS_ENABLE_MEMPOOL_PRINT_ACTIVE_SUPERBLOCKS
-#define KOKKOS_ENABLE_MEMPOOL_PRINT_ACTIVE_SUPERBLOCKS KOKKOS_MEMPOOL_PRINT_ACTIVE_SUPERBLOCKS
+#define KOKKOS_ENABLE_MEMPOOL_PRINT_ACTIVE_SUPERBLOCKS \
+  KOKKOS_MEMPOOL_PRINT_ACTIVE_SUPERBLOCKS
 #endif
 #endif
 
 #ifdef KOKKOS_MEMPOOL_PRINT_BLOCKSIZE_INFO
 #ifndef KOKKOS_ENABLE_MEMPOOL_PRINT_BLOCKSIZE_INFO
-#define KOKKOS_ENABLE_MEMPOOL_PRINT_BLOCKSIZE_INFO KOKKOS_MEMPOOL_PRINT_BLOCKSIZE_INFO
+#define KOKKOS_ENABLE_MEMPOOL_PRINT_BLOCKSIZE_INFO \
+  KOKKOS_MEMPOOL_PRINT_BLOCKSIZE_INFO
 #endif
 #endif
 
 #ifdef KOKKOS_MEMPOOL_PRINT_CONSTRUCTOR_INFO
 #ifndef KOKKOS_ENABLE_MEMPOOL_PRINT_CONSTRUCTOR_INFO
-#define KOKKOS_ENABLE_MEMPOOL_PRINT_CONSTRUCTOR_INFO KOKKOS_MEMPOOL_PRINT_CONSTRUCTOR_INFO
+#define KOKKOS_ENABLE_MEMPOOL_PRINT_CONSTRUCTOR_INFO \
+  KOKKOS_MEMPOOL_PRINT_CONSTRUCTOR_INFO
 #endif
 #endif
 
 #ifdef KOKKOS_MEMPOOL_PRINT_INDIVIDUAL_PAGE_INFO
 #ifndef KOKKOS_ENABLE_MEMPOOL_PRINT_INDIVIDUAL_PAGE_INFO
-#define KOKKOS_ENABLE_MEMPOOL_PRINT_INDIVIDUAL_PAGE_INFO KOKKOS_MEMPOOL_PRINT_INDIVIDUAL_PAGE_INFO
+#define KOKKOS_ENABLE_MEMPOOL_PRINT_INDIVIDUAL_PAGE_INFO \
+  KOKKOS_MEMPOOL_PRINT_INDIVIDUAL_PAGE_INFO
 #endif
 #endif
 
@@ -344,7 +353,8 @@
 
 #ifdef KOKKOS_MEMPOOL_PRINT_SUPERBLOCK_INFO
 #ifndef KOKKOS_ENABLE_MEMPOOL_PRINT_SUPERBLOCK_INFO
-#define KOKKOS_ENABLE_MEMPOOL_PRINT_SUPERBLOCK_INFO KOKKOS_MEMPOOL_PRINT_SUPERBLOCK_INFO
+#define KOKKOS_ENABLE_MEMPOOL_PRINT_SUPERBLOCK_INFO \
+  KOKKOS_MEMPOOL_PRINT_SUPERBLOCK_INFO
 #endif
 #endif
 
@@ -368,19 +378,22 @@
 
 #ifdef KOKKOS_SHARED_ALLOCATION_TRACKER_DECREMENT
 #ifndef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT KOKKOS_SHARED_ALLOCATION_TRACKER_DECREMENT
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT \
+  KOKKOS_SHARED_ALLOCATION_TRACKER_DECREMENT
 #endif
 #endif
 
 #ifdef KOKKOS_SHARED_ALLOCATION_TRACKER_ENABLED
 #ifndef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED KOKKOS_SHARED_ALLOCATION_TRACKER_ENABLED
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED \
+  KOKKOS_SHARED_ALLOCATION_TRACKER_ENABLED
 #endif
 #endif
 
 #ifdef KOKKOS_SHARED_ALLOCATION_TRACKER_INCREMENT
 #ifndef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT KOKKOS_SHARED_ALLOCATION_TRACKER_INCREMENT
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT \
+  KOKKOS_SHARED_ALLOCATION_TRACKER_INCREMENT
 #endif
 #endif
 
@@ -420,7 +433,7 @@
 #endif
 #endif
 
-#if defined( KOKKOS_ENABLE_PTHREAD ) || defined( KOKKOS_ENABLE_WINTHREAD )
+#if defined(KOKKOS_ENABLE_PTHREAD) || defined(KOKKOS_ENABLE_WINTHREAD)
 #ifndef KOKKOS_ENABLE_THREADS
 #define KOKKOS_ENABLE_THREADS
 #endif
@@ -491,7 +504,8 @@
 #define KOKKOS_HAVE_HBWSPACE 1
 #endif
 
-#if (!defined(KOKKOS_CUDA_USE_LDG_INTRINSIC)) && defined(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC)
+#if (!defined(KOKKOS_CUDA_USE_LDG_INTRINSIC)) && \
+    defined(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC)
 #define KOKKOS_CUDA_USE_LDG_INTRINSIC 1
 #endif
 
@@ -499,7 +513,8 @@
 #define KOKKOS_CUDA_USE_UVM 1
 #endif
 
-#if (!defined(KOKKOS_CUDA_USE_RELOCATABLE_DEVICE_CODE)) && defined(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
+#if (!defined(KOKKOS_CUDA_USE_RELOCATABLE_DEVICE_CODE)) && \
+    defined(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
 #define KOKKOS_CUDA_USE_RELOCATABLE_DEVICE_CODE 1
 #endif
 
@@ -507,7 +522,8 @@
 #define KOKKOS_CUDA_USE_LAMBDA 1
 #endif
 
-#if (!defined(KOKKOS_CUDA_CLANG_WORKAROUND)) && defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
+#if (!defined(KOKKOS_CUDA_CLANG_WORKAROUND)) && \
+    defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 #define KOKKOS_CUDA_CLANG_WORKAROUND 1
 #endif
 
@@ -515,6 +531,6 @@
 #define KOKKOS_HAVE_MPI 1
 #endif
 
-#endif // KOKKOS_ENABLE_DEPRECATED_CODE
+#endif  // KOKKOS_ENABLE_DEPRECATED_CODE
 
-#endif //KOKKOS_IMPL_OLD_MACROS_HPP
+#endif  // KOKKOS_IMPL_OLD_MACROS_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_OptionalRef.hpp b/lib/kokkos/core/src/impl/Kokkos_OptionalRef.hpp
index bf83d1831c2550fc88c2f7780fb8c72ea8312651..668e7c09161409298b84e840bdad3f77259af68c 100644
--- a/lib/kokkos/core/src/impl/Kokkos_OptionalRef.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_OptionalRef.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -58,16 +59,14 @@
 namespace Kokkos {
 namespace Impl {
 
-struct InPlaceTag { };
+struct InPlaceTag {};
 
 template <class T>
 struct OptionalRef {
-private:
-
+ private:
   ObservingRawPtr<T> m_value = nullptr;
 
-public:
-
+ public:
   using value_type = T;
 
   KOKKOS_INLINE_FUNCTION
@@ -75,7 +74,7 @@ public:
 
   KOKKOS_INLINE_FUNCTION
   OptionalRef(OptionalRef const&) = default;
-  
+
   KOKKOS_INLINE_FUNCTION
   OptionalRef(OptionalRef&&) = default;
 
@@ -83,11 +82,9 @@ public:
   OptionalRef& operator=(OptionalRef const&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  // Can't return a reference to volatile OptionalRef, since GCC issues a warning about
-  // reference to volatile not accessing the underlying value
-  void
-  operator=(OptionalRef const volatile& other) volatile noexcept
-  {
+  // Can't return a reference to volatile OptionalRef, since GCC issues a
+  // warning about reference to volatile not accessing the underlying value
+  void operator=(OptionalRef const volatile& other) volatile noexcept {
     m_value = other.m_value;
   }
 
@@ -98,34 +95,40 @@ public:
   ~OptionalRef() = default;
 
   KOKKOS_INLINE_FUNCTION
-  explicit OptionalRef(T& arg_value) : m_value(&arg_value) { }
+  explicit OptionalRef(T& arg_value) : m_value(&arg_value) {}
 
   KOKKOS_INLINE_FUNCTION
-  explicit OptionalRef(std::nullptr_t) : m_value(nullptr) { }
+  explicit OptionalRef(std::nullptr_t) : m_value(nullptr) {}
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef& operator=(T& arg_value) { m_value = &arg_value; return *this; }
+  OptionalRef& operator=(T& arg_value) {
+    m_value = &arg_value;
+    return *this;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef& operator=(std::nullptr_t) { m_value = nullptr; return *this; }
+  OptionalRef& operator=(std::nullptr_t) {
+    m_value = nullptr;
+    return *this;
+  }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
   OptionalRef<typename std::add_volatile<T>::type>
   as_volatile() volatile noexcept {
-    return 
-      OptionalRef<typename std::add_volatile<T>::type>(*(*this));
+    return OptionalRef<typename std::add_volatile<T>::type>(*(*this));
   }
 
   KOKKOS_INLINE_FUNCTION
-  OptionalRef<typename std::add_volatile<typename std::add_const<T>::type>::type>
+  OptionalRef<
+      typename std::add_volatile<typename std::add_const<T>::type>::type>
   as_volatile() const volatile noexcept {
-    return 
-      OptionalRef<typename std::add_volatile<typename std::add_const<T>::type>::type>(*(*this));
+    return OptionalRef<
+        typename std::add_volatile<typename std::add_const<T>::type>::type>(
+        *(*this));
   }
 
-
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
@@ -133,21 +136,21 @@ public:
     KOKKOS_EXPECTS(this->has_value());
     return *m_value;
   }
-   
+
   KOKKOS_INLINE_FUNCTION
-  T const& operator*() const & {
+  T const& operator*() const& {
     KOKKOS_EXPECTS(this->has_value());
     return *m_value;
   }
 
   KOKKOS_INLINE_FUNCTION
-  T volatile& operator*() volatile & {
+  T volatile& operator*() volatile& {
     KOKKOS_EXPECTS(this->has_value());
     return *m_value;
   }
 
   KOKKOS_INLINE_FUNCTION
-  T const volatile& operator*() const volatile & {
+  T const volatile& operator*() const volatile& {
     KOKKOS_EXPECTS(this->has_value());
     return *m_value;
   }
@@ -183,24 +186,16 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  T* get() {
-    return m_value;
-  }
+  T* get() { return m_value; }
 
   KOKKOS_INLINE_FUNCTION
-  T const* get() const {
-    return m_value;
-  }
+  T const* get() const { return m_value; }
 
   KOKKOS_INLINE_FUNCTION
-  T volatile* get() volatile {
-    return m_value;
-  }
+  T volatile* get() volatile { return m_value; }
 
   KOKKOS_INLINE_FUNCTION
-  T const volatile* get() const volatile {
-    return m_value;
-  }
+  T const volatile* get() const volatile { return m_value; }
 
   //----------------------------------------
 
@@ -227,16 +222,12 @@ public:
 
   KOKKOS_INLINE_FUNCTION
   bool has_value() const volatile { return m_value != nullptr; }
-  
 };
 
-} // end namespace Impl
-} // end namespace Kokkos
+}  // end namespace Impl
+}  // end namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-
-
 #endif /* #ifndef KOKKOS_IMPL_OPTIONALREF_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_PhysicalLayout.hpp b/lib/kokkos/core/src/impl/Kokkos_PhysicalLayout.hpp
index 919f6769452a7378794b9c3b2050da27c52c8ed8..bc0a7df3e03969a37f70c71ce5497fd0f864fb2d 100644
--- a/lib/kokkos/core/src/impl/Kokkos_PhysicalLayout.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_PhysicalLayout.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,23 +51,27 @@ namespace Kokkos {
 namespace Impl {
 
 struct PhysicalLayout {
-  enum LayoutType {Left,Right,Scalar,Error};
+  enum LayoutType { Left, Right, Scalar, Error };
   LayoutType layout_type;
   int rank;
-  long long int stride[9]; //distance between two neighboring elements in a given dimension
+  long long int stride[9];  // distance between two neighboring elements in a
+                            // given dimension
 
-  template< class T , class L , class D , class M >
-  PhysicalLayout( const View<T,L,D,M> & view )
-    : layout_type( is_same< typename View<T,L,D,M>::array_layout , LayoutLeft  >::value ? Left : (
-                   is_same< typename View<T,L,D,M>::array_layout , LayoutRight >::value ? Right : Error ))
-    , rank( view.Rank )
-    {
-      for(int i=0;i<9;i++) stride[i] = 0;
-      view.stride( stride );
-    }
+  template <class T, class L, class D, class M>
+  PhysicalLayout(const View<T, L, D, M>& view)
+      : layout_type(
+            is_same<typename View<T, L, D, M>::array_layout, LayoutLeft>::value
+                ? Left
+                : (is_same<typename View<T, L, D, M>::array_layout,
+                           LayoutRight>::value
+                       ? Right
+                       : Error)),
+        rank(view.Rank) {
+    for (int i = 0; i < 9; i++) stride[i] = 0;
+    view.stride(stride);
+  }
 };
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Profiling_DeviceInfo.hpp b/lib/kokkos/core/src/impl/Kokkos_Profiling_DeviceInfo.hpp
index 7f2f2bc3943369d1689f03cbdeb1dc290dbc1f24..e35ff84e9787be40ad36a1a74e68afe1e651cdd9 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Profiling_DeviceInfo.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Profiling_DeviceInfo.hpp
@@ -1,44 +1,45 @@
 /*
- //@HEADER
- // ************************************************************************
- //
- //                        Kokkos v. 2.0
- //              Copyright (2014) Sandia Corporation
- //
- // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
- // the U.S. Government retains certain rights in this software.
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // 1. Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- //
- // 2. Redistributions in binary form must reproduce the above copyright
- // notice, this list of conditions and the following disclaimer in the
- // documentation and/or other materials provided with the distribution.
- //
- // 3. Neither the name of the Corporation nor the names of the
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
- // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
- // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- //
- // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
- //
- // ************************************************************************
- //@HEADER
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
 */
 
 #ifndef KOKKOSP_DEVICE_INFO_HPP
@@ -53,7 +54,7 @@ struct KokkosPDeviceInfo {
   uint32_t deviceID;
 };
 
-}
-}
+}  // namespace Profiling
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.cpp b/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.cpp
index 51c94781505a09e42d81fb3d0a40a00d45598b25..a069a695fc4e7fec79c02c489716e69d623a9c4d 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.cpp
@@ -1,45 +1,46 @@
 /*
- //@HEADER
- // ************************************************************************
- //
- //                        Kokkos v. 2.0
- //              Copyright (2014) Sandia Corporation
- //
- // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
- // the U.S. Government retains certain rights in this software.
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // 1. Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- //
- // 2. Redistributions in binary form must reproduce the above copyright
- // notice, this list of conditions and the following disclaimer in the
- // documentation and/or other materials provided with the distribution.
- //
- // 3. Neither the name of the Corporation nor the names of the
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
- // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
- // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- //
- // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
- //
- // ************************************************************************
- //@HEADER
- */
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
 
 #include <Kokkos_Macros.hpp>
 
@@ -51,246 +52,249 @@
 namespace Kokkos {
 namespace Profiling {
 
-static initFunction initProfileLibrary = nullptr;
+static initFunction initProfileLibrary         = nullptr;
 static finalizeFunction finalizeProfileLibrary = nullptr;
 
-static beginFunction beginForCallee = nullptr;
-static beginFunction beginScanCallee = nullptr;
+static beginFunction beginForCallee    = nullptr;
+static beginFunction beginScanCallee   = nullptr;
 static beginFunction beginReduceCallee = nullptr;
-static endFunction endForCallee = nullptr;
-static endFunction endScanCallee = nullptr;
-static endFunction endReduceCallee = nullptr;
+static endFunction endForCallee        = nullptr;
+static endFunction endScanCallee       = nullptr;
+static endFunction endReduceCallee     = nullptr;
 
 static pushFunction pushRegionCallee = nullptr;
-static popFunction popRegionCallee = nullptr;
+static popFunction popRegionCallee   = nullptr;
 
-static allocateDataFunction allocateDataCallee = nullptr;
+static allocateDataFunction allocateDataCallee     = nullptr;
 static deallocateDataFunction deallocateDataCallee = nullptr;
 
 static beginDeepCopyFunction beginDeepCopyCallee = nullptr;
-static endDeepCopyFunction endDeepCopyCallee = nullptr;
+static endDeepCopyFunction endDeepCopyCallee     = nullptr;
 
-static createProfileSectionFunction createSectionCallee = nullptr;
-static startProfileSectionFunction startSectionCallee = nullptr;
-static stopProfileSectionFunction stopSectionCallee = nullptr;
+static createProfileSectionFunction createSectionCallee   = nullptr;
+static startProfileSectionFunction startSectionCallee     = nullptr;
+static stopProfileSectionFunction stopSectionCallee       = nullptr;
 static destroyProfileSectionFunction destroySectionCallee = nullptr;
 
 static profileEventFunction profileEventCallee = nullptr;
 
 SpaceHandle::SpaceHandle(const char* space_name) {
-  strncpy(name,space_name,64);
+  strncpy(name, space_name, 64);
 }
 
-bool profileLibraryLoaded() {
-  return (nullptr != initProfileLibrary);
-}
+bool profileLibraryLoaded() { return (nullptr != initProfileLibrary); }
 
-void beginParallelFor(const std::string& kernelPrefix, const uint32_t devID, uint64_t* kernelID) {
-  if(nullptr != beginForCallee) {
+void beginParallelFor(const std::string& kernelPrefix, const uint32_t devID,
+                      uint64_t* kernelID) {
+  if (nullptr != beginForCallee) {
     Kokkos::fence();
     (*beginForCallee)(kernelPrefix.c_str(), devID, kernelID);
   }
 }
 
 void endParallelFor(const uint64_t kernelID) {
-  if(nullptr != endForCallee) {
+  if (nullptr != endForCallee) {
     Kokkos::fence();
     (*endForCallee)(kernelID);
   }
 }
 
-void beginParallelScan(const std::string& kernelPrefix, const uint32_t devID, uint64_t* kernelID) {
-  if(nullptr != beginScanCallee) {
+void beginParallelScan(const std::string& kernelPrefix, const uint32_t devID,
+                       uint64_t* kernelID) {
+  if (nullptr != beginScanCallee) {
     Kokkos::fence();
     (*beginScanCallee)(kernelPrefix.c_str(), devID, kernelID);
   }
 }
 
 void endParallelScan(const uint64_t kernelID) {
-  if(nullptr != endScanCallee) {
+  if (nullptr != endScanCallee) {
     Kokkos::fence();
     (*endScanCallee)(kernelID);
   }
 }
 
-void beginParallelReduce(const std::string& kernelPrefix, const uint32_t devID, uint64_t* kernelID) {
-  if(nullptr != beginReduceCallee) {
+void beginParallelReduce(const std::string& kernelPrefix, const uint32_t devID,
+                         uint64_t* kernelID) {
+  if (nullptr != beginReduceCallee) {
     Kokkos::fence();
     (*beginReduceCallee)(kernelPrefix.c_str(), devID, kernelID);
   }
 }
 
 void endParallelReduce(const uint64_t kernelID) {
-  if(nullptr != endReduceCallee) {
+  if (nullptr != endReduceCallee) {
     Kokkos::fence();
     (*endReduceCallee)(kernelID);
   }
 }
 
-
 void pushRegion(const std::string& kName) {
-  if( nullptr != pushRegionCallee ) {
+  if (nullptr != pushRegionCallee) {
     Kokkos::fence();
     (*pushRegionCallee)(kName.c_str());
   }
 }
 
 void popRegion() {
-  if( nullptr != popRegionCallee ) {
+  if (nullptr != popRegionCallee) {
     Kokkos::fence();
     (*popRegionCallee)();
   }
 }
 
-void allocateData(const SpaceHandle space, const std::string label, const void* ptr, const uint64_t size) {
-  if(nullptr != allocateDataCallee) {
-    (*allocateDataCallee)(space,label.c_str(),ptr,size);
+void allocateData(const SpaceHandle space, const std::string label,
+                  const void* ptr, const uint64_t size) {
+  if (nullptr != allocateDataCallee) {
+    (*allocateDataCallee)(space, label.c_str(), ptr, size);
   }
 }
 
-void deallocateData(const SpaceHandle space, const std::string label, const void* ptr, const uint64_t size) {
-  if(nullptr != deallocateDataCallee) {
-    (*deallocateDataCallee)(space,label.c_str(),ptr,size);
+void deallocateData(const SpaceHandle space, const std::string label,
+                    const void* ptr, const uint64_t size) {
+  if (nullptr != deallocateDataCallee) {
+    (*deallocateDataCallee)(space, label.c_str(), ptr, size);
   }
 }
 
-void beginDeepCopy(const SpaceHandle dst_space, const std::string dst_label, const void* dst_ptr,
-    const SpaceHandle src_space, const std::string src_label, const void* src_ptr,
-    const uint64_t size) {
-  if(nullptr != beginDeepCopyCallee) {
-    (*beginDeepCopyCallee)(dst_space, dst_label.c_str(), dst_ptr,
-                      src_space, src_label.c_str(), src_ptr,
-                      size);
+void beginDeepCopy(const SpaceHandle dst_space, const std::string dst_label,
+                   const void* dst_ptr, const SpaceHandle src_space,
+                   const std::string src_label, const void* src_ptr,
+                   const uint64_t size) {
+  if (nullptr != beginDeepCopyCallee) {
+    (*beginDeepCopyCallee)(dst_space, dst_label.c_str(), dst_ptr, src_space,
+                           src_label.c_str(), src_ptr, size);
   }
 }
 
 void endDeepCopy() {
-  if(nullptr != endDeepCopyCallee) {
+  if (nullptr != endDeepCopyCallee) {
     (*endDeepCopyCallee)();
   }
 }
 
 void createProfileSection(const std::string& sectionName, uint32_t* secID) {
-
-	if(nullptr != createSectionCallee) {
-		(*createSectionCallee)(sectionName.c_str(), secID);
-	}
+  if (nullptr != createSectionCallee) {
+    (*createSectionCallee)(sectionName.c_str(), secID);
+  }
 }
 
 void startSection(const uint32_t secID) {
-	if(nullptr != startSectionCallee) {
-		(*startSectionCallee)(secID);
-	}
+  if (nullptr != startSectionCallee) {
+    (*startSectionCallee)(secID);
+  }
 }
 
 void stopSection(const uint32_t secID) {
-	if(nullptr != stopSectionCallee) {
-		(*stopSectionCallee)(secID);
-	}
+  if (nullptr != stopSectionCallee) {
+    (*stopSectionCallee)(secID);
+  }
 }
 
 void destroyProfileSection(const uint32_t secID) {
-	if(nullptr != destroySectionCallee) {
-		(*destroySectionCallee)(secID);
-	}
+  if (nullptr != destroySectionCallee) {
+    (*destroySectionCallee)(secID);
+  }
 }
 
 void markEvent(const std::string& eventName) {
-	if(nullptr != profileEventCallee) {
-		(*profileEventCallee)(eventName.c_str());
-	}
+  if (nullptr != profileEventCallee) {
+    (*profileEventCallee)(eventName.c_str());
+  }
 }
 
 void initialize() {
-
   // Make sure initialize calls happens only once
   static int is_initialized = 0;
-  if(is_initialized) return;
+  if (is_initialized) return;
   is_initialized = 1;
 
   void* firstProfileLibrary;
 
-  char* envProfileLibrary  = getenv("KOKKOS_PROFILE_LIBRARY");
+  char* envProfileLibrary = getenv("KOKKOS_PROFILE_LIBRARY");
 
   // If we do not find a profiling library in the environment then exit
   // early.
-  if( nullptr == envProfileLibrary ) {
-    return ;
+  if (nullptr == envProfileLibrary) {
+    return;
   }
 
-  char* envProfileCopy = (char*) malloc(sizeof(char) * (strlen(envProfileLibrary) + 1));
+  char* envProfileCopy =
+      (char*)malloc(sizeof(char) * (strlen(envProfileLibrary) + 1));
   sprintf(envProfileCopy, "%s", envProfileLibrary);
 
   char* profileLibraryName = strtok(envProfileCopy, ";");
 
-  if( (nullptr != profileLibraryName) && (strcmp(profileLibraryName, "") != 0) ) {
+  if ((nullptr != profileLibraryName) &&
+      (strcmp(profileLibraryName, "") != 0)) {
     firstProfileLibrary = dlopen(profileLibraryName, RTLD_NOW | RTLD_GLOBAL);
 
-    if(nullptr == firstProfileLibrary) {
-      std::cerr << "Error: Unable to load KokkosP library: " <<
-        profileLibraryName << std::endl;
-      std::cerr << "dlopen(" << profileLibraryName << ", RTLD_NOW | RTLD_GLOBAL) failed with "
-        << dlerror() << '\n';
+    if (nullptr == firstProfileLibrary) {
+      std::cerr << "Error: Unable to load KokkosP library: "
+                << profileLibraryName << std::endl;
+      std::cerr << "dlopen(" << profileLibraryName
+                << ", RTLD_NOW | RTLD_GLOBAL) failed with " << dlerror()
+                << '\n';
     } else {
 #ifdef KOKKOS_ENABLE_PROFILING_LOAD_PRINT
-      std::cout << "KokkosP: Library Loaded: " << profileLibraryName << std::endl;
+      std::cout << "KokkosP: Library Loaded: " << profileLibraryName
+                << std::endl;
 #endif
 
-      // dlsym returns a pointer to an object, while we want to assign to pointer to function
-      // A direct cast will give warnings hence, we have to workaround the issue by casting pointer to pointers.
-      auto p1 = dlsym(firstProfileLibrary, "kokkosp_begin_parallel_for");
-      beginForCallee = *((beginFunction*) &p1);
+      // dlsym returns a pointer to an object, while we want to assign to
+      // pointer to function A direct cast will give warnings hence, we have to
+      // workaround the issue by casting pointer to pointers.
+      auto p1        = dlsym(firstProfileLibrary, "kokkosp_begin_parallel_for");
+      beginForCallee = *((beginFunction*)&p1);
       auto p2 = dlsym(firstProfileLibrary, "kokkosp_begin_parallel_scan");
-      beginScanCallee = *((beginFunction*) &p2);
+      beginScanCallee = *((beginFunction*)&p2);
       auto p3 = dlsym(firstProfileLibrary, "kokkosp_begin_parallel_reduce");
-      beginReduceCallee = *((beginFunction*) &p3);
+      beginReduceCallee = *((beginFunction*)&p3);
 
-      auto p4 = dlsym(firstProfileLibrary, "kokkosp_end_parallel_scan");
-      endScanCallee = *((endFunction*) &p4);
-      auto p5 = dlsym(firstProfileLibrary, "kokkosp_end_parallel_for");
-      endForCallee = *((endFunction*) &p5);
-      auto p6 = dlsym(firstProfileLibrary, "kokkosp_end_parallel_reduce");
-      endReduceCallee = *((endFunction*) &p6);
+      auto p4       = dlsym(firstProfileLibrary, "kokkosp_end_parallel_scan");
+      endScanCallee = *((endFunction*)&p4);
+      auto p5       = dlsym(firstProfileLibrary, "kokkosp_end_parallel_for");
+      endForCallee  = *((endFunction*)&p5);
+      auto p6       = dlsym(firstProfileLibrary, "kokkosp_end_parallel_reduce");
+      endReduceCallee = *((endFunction*)&p6);
 
-      auto p7 = dlsym(firstProfileLibrary, "kokkosp_init_library");
-      initProfileLibrary = *((initFunction*) &p7);
+      auto p7            = dlsym(firstProfileLibrary, "kokkosp_init_library");
+      initProfileLibrary = *((initFunction*)&p7);
       auto p8 = dlsym(firstProfileLibrary, "kokkosp_finalize_library");
-      finalizeProfileLibrary = *((finalizeFunction*) &p8);
+      finalizeProfileLibrary = *((finalizeFunction*)&p8);
 
       auto p9 = dlsym(firstProfileLibrary, "kokkosp_push_profile_region");
-      pushRegionCallee = *((pushFunction*) &p9);
+      pushRegionCallee = *((pushFunction*)&p9);
       auto p10 = dlsym(firstProfileLibrary, "kokkosp_pop_profile_region");
-      popRegionCallee = *((popFunction*) &p10);
+      popRegionCallee = *((popFunction*)&p10);
 
-      auto p11 = dlsym(firstProfileLibrary, "kokkosp_allocate_data");
-      allocateDataCallee = *((allocateDataFunction*) &p11);
+      auto p11           = dlsym(firstProfileLibrary, "kokkosp_allocate_data");
+      allocateDataCallee = *((allocateDataFunction*)&p11);
       auto p12 = dlsym(firstProfileLibrary, "kokkosp_deallocate_data");
-      deallocateDataCallee = *((deallocateDataFunction*) &p12);
+      deallocateDataCallee = *((deallocateDataFunction*)&p12);
 
       auto p13 = dlsym(firstProfileLibrary, "kokkosp_begin_deep_copy");
-      beginDeepCopyCallee = *((beginDeepCopyFunction*) &p13);
-      auto p14 = dlsym(firstProfileLibrary, "kokkosp_end_deep_copy");
-      endDeepCopyCallee = *((endDeepCopyFunction*) &p14);
-      
+      beginDeepCopyCallee = *((beginDeepCopyFunction*)&p13);
+      auto p14            = dlsym(firstProfileLibrary, "kokkosp_end_deep_copy");
+      endDeepCopyCallee   = *((endDeepCopyFunction*)&p14);
+
       auto p15 = dlsym(firstProfileLibrary, "kokkosp_create_profile_section");
-      createSectionCallee = *((createProfileSectionFunction*) &p15);
+      createSectionCallee = *((createProfileSectionFunction*)&p15);
       auto p16 = dlsym(firstProfileLibrary, "kokkosp_start_profile_section");
-      startSectionCallee = *((startProfileSectionFunction*) &p16);
+      startSectionCallee = *((startProfileSectionFunction*)&p16);
       auto p17 = dlsym(firstProfileLibrary, "kokkosp_stop_profile_section");
-      stopSectionCallee = *((stopProfileSectionFunction*) &p17);      
+      stopSectionCallee = *((stopProfileSectionFunction*)&p17);
       auto p18 = dlsym(firstProfileLibrary, "kokkosp_destroy_profile_section");
-      destroySectionCallee = *((destroyProfileSectionFunction*) &p18);
-      
-      auto p19 = dlsym(firstProfileLibrary, "kokkosp_profile_event");
-      profileEventCallee = *((profileEventFunction*) &p19);
+      destroySectionCallee = *((destroyProfileSectionFunction*)&p18);
+
+      auto p19           = dlsym(firstProfileLibrary, "kokkosp_profile_event");
+      profileEventCallee = *((profileEventFunction*)&p19);
     }
   }
 
-  if(nullptr != initProfileLibrary) {
-    (*initProfileLibrary)(0,
-        (uint64_t) KOKKOSP_INTERFACE_VERSION,
-        (uint32_t) 0,
-        nullptr);
+  if (nullptr != initProfileLibrary) {
+    (*initProfileLibrary)(0, (uint64_t)KOKKOSP_INTERFACE_VERSION, (uint32_t)0,
+                          nullptr);
   }
 
   free(envProfileCopy);
@@ -299,44 +303,44 @@ void initialize() {
 void finalize() {
   // Make sure finalize calls happens only once
   static int is_finalized = 0;
-  if(is_finalized) return;
+  if (is_finalized) return;
   is_finalized = 1;
 
-  if(nullptr != finalizeProfileLibrary) {
+  if (nullptr != finalizeProfileLibrary) {
     (*finalizeProfileLibrary)();
 
     // Set all profile hooks to nullptr to prevent
     // any additional calls. Once we are told to
     // finalize, we mean it
-    initProfileLibrary = nullptr;
+    initProfileLibrary     = nullptr;
     finalizeProfileLibrary = nullptr;
 
-    beginForCallee = nullptr;
-    beginScanCallee = nullptr;
+    beginForCallee    = nullptr;
+    beginScanCallee   = nullptr;
     beginReduceCallee = nullptr;
-    endScanCallee = nullptr;
-    endForCallee = nullptr;
-    endReduceCallee = nullptr;
+    endScanCallee     = nullptr;
+    endForCallee      = nullptr;
+    endReduceCallee   = nullptr;
 
     pushRegionCallee = nullptr;
-    popRegionCallee = nullptr;
+    popRegionCallee  = nullptr;
 
-    allocateDataCallee = nullptr;
+    allocateDataCallee   = nullptr;
     deallocateDataCallee = nullptr;
 
     beginDeepCopyCallee = nullptr;
-    endDeepCopyCallee = nullptr;
-    
-    createSectionCallee = nullptr;
-	startSectionCallee = nullptr;
-	stopSectionCallee = nullptr;
-	destroySectionCallee = nullptr;
-
-	profileEventCallee = nullptr;
+    endDeepCopyCallee   = nullptr;
+
+    createSectionCallee  = nullptr;
+    startSectionCallee   = nullptr;
+    stopSectionCallee    = nullptr;
+    destroySectionCallee = nullptr;
+
+    profileEventCallee = nullptr;
   }
 }
-}
-}
+}  // namespace Profiling
+}  // namespace Kokkos
 
 #else
 
@@ -348,34 +352,36 @@ namespace Profiling {
 
 bool profileLibraryLoaded() { return false; }
 
+void beginParallelFor(const std::string&, const uint32_t, uint64_t*) {}
+void endParallelFor(const uint64_t) {}
+void beginParallelScan(const std::string&, const uint32_t, uint64_t*) {}
+void endParallelScan(const uint64_t) {}
+void beginParallelReduce(const std::string&, const uint32_t, uint64_t*) {}
+void endParallelReduce(const uint64_t) {}
 
-void beginParallelFor(const std::string& , const uint32_t , uint64_t* ) {}
-void endParallelFor(const uint64_t ) {}
-void beginParallelScan(const std::string& , const uint32_t , uint64_t* ) {}
-void endParallelScan(const uint64_t ) {}
-void beginParallelReduce(const std::string& , const uint32_t , uint64_t* ) {}
-void endParallelReduce(const uint64_t ) {}
-
-void pushRegion(const std::string& ) {}
+void pushRegion(const std::string&) {}
 void popRegion() {}
-void createProfileSection(const std::string& , uint32_t* ) {}
-void startSection(const uint32_t ) {}
-void stopSection(const uint32_t ) {}
-void destroyProfileSection(const uint32_t ) {}
+void createProfileSection(const std::string&, uint32_t*) {}
+void startSection(const uint32_t) {}
+void stopSection(const uint32_t) {}
+void destroyProfileSection(const uint32_t) {}
 
-void markEvent(const std::string& ) {}
+void markEvent(const std::string&) {}
 
-void allocateData(const SpaceHandle , const std::string , const void* , const uint64_t ) {}
-void deallocateData(const SpaceHandle , const std::string , const void* , const uint64_t ) {}
+void allocateData(const SpaceHandle, const std::string, const void*,
+                  const uint64_t) {}
+void deallocateData(const SpaceHandle, const std::string, const void*,
+                    const uint64_t) {}
 
-void beginDeepCopy(const SpaceHandle , const std::string , const void* , 
-    const SpaceHandle , const std::string , const void* ,
-    const uint64_t ) {}
+void beginDeepCopy(const SpaceHandle, const std::string, const void*,
+                   const SpaceHandle, const std::string, const void*,
+                   const uint64_t) {}
 void endDeepCopy() {}
 
 void initialize() {}
 void finalize() {}
 
-}} // end namespace Kokkos::Profiling
+}  // namespace Profiling
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.hpp b/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.hpp
index b245db09a723ffe62a9d24d0455c64ba5d02506c..ac37401e1080fcedbbac1d01ac52860699f82ea5 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Profiling_Interface.hpp
@@ -1,45 +1,46 @@
 /*
- //@HEADER
- // ************************************************************************
- //
- //                        Kokkos v. 2.0
- //              Copyright (2014) Sandia Corporation
- //
- // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
- // the U.S. Government retains certain rights in this software.
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // 1. Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- //
- // 2. Redistributions in binary form must reproduce the above copyright
- // notice, this list of conditions and the following disclaimer in the
- // documentation and/or other materials provided with the distribution.
- //
- // 3. Neither the name of the Corporation nor the names of the
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
- // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
- // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- //
- // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
- //
- // ************************************************************************
- //@HEADER
- */
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
 
 #ifndef KOKKOSP_INTERFACE_HPP
 #define KOKKOSP_INTERFACE_HPP
@@ -53,7 +54,6 @@
 #include <iostream>
 #include <cstdlib>
 
-
 #if defined(KOKKOS_ENABLE_PROFILING)
 #include <dlfcn.h>
 
@@ -69,9 +69,7 @@ struct SpaceHandle {
   char name[64];
 };
 
-typedef void (*initFunction)(const int,
-                             const uint64_t,
-                             const uint32_t,
+typedef void (*initFunction)(const int, const uint64_t, const uint32_t,
                              KokkosPDeviceInfo*);
 typedef void (*finalizeFunction)();
 typedef void (*beginFunction)(const char*, const uint32_t, uint64_t*);
@@ -80,8 +78,10 @@ typedef void (*endFunction)(uint64_t);
 typedef void (*pushFunction)(const char*);
 typedef void (*popFunction)();
 
-typedef void (*allocateDataFunction)(const SpaceHandle, const char*, const void*, const uint64_t);
-typedef void (*deallocateDataFunction)(const SpaceHandle, const char*, const void*, const uint64_t);
+typedef void (*allocateDataFunction)(const SpaceHandle, const char*,
+                                     const void*, const uint64_t);
+typedef void (*deallocateDataFunction)(const SpaceHandle, const char*,
+                                       const void*, const uint64_t);
 
 typedef void (*createProfileSectionFunction)(const char*, uint32_t*);
 typedef void (*startProfileSectionFunction)(const uint32_t);
@@ -90,19 +90,21 @@ typedef void (*destroyProfileSectionFunction)(const uint32_t);
 
 typedef void (*profileEventFunction)(const char*);
 
-typedef void (*beginDeepCopyFunction)(
-    SpaceHandle, const char*, const void*,
-    SpaceHandle, const char*, const void*,
-    uint64_t);
+typedef void (*beginDeepCopyFunction)(SpaceHandle, const char*, const void*,
+                                      SpaceHandle, const char*, const void*,
+                                      uint64_t);
 typedef void (*endDeepCopyFunction)();
 
 bool profileLibraryLoaded();
 
-void beginParallelFor(const std::string& kernelPrefix, const uint32_t devID, uint64_t* kernelID);
+void beginParallelFor(const std::string& kernelPrefix, const uint32_t devID,
+                      uint64_t* kernelID);
 void endParallelFor(const uint64_t kernelID);
-void beginParallelScan(const std::string& kernelPrefix, const uint32_t devID, uint64_t* kernelID);
+void beginParallelScan(const std::string& kernelPrefix, const uint32_t devID,
+                       uint64_t* kernelID);
 void endParallelScan(const uint64_t kernelID);
-void beginParallelReduce(const std::string& kernelPrefix, const uint32_t devID, uint64_t* kernelID);
+void beginParallelReduce(const std::string& kernelPrefix, const uint32_t devID,
+                         uint64_t* kernelID);
 void endParallelReduce(const uint64_t kernelID);
 
 void pushRegion(const std::string& kName);
@@ -115,19 +117,22 @@ void destroyProfileSection(const uint32_t secID);
 
 void markEvent(const std::string* evName);
 
-void allocateData(const SpaceHandle space, const std::string label, const void* ptr, const uint64_t size);
-void deallocateData(const SpaceHandle space, const std::string label, const void* ptr, const uint64_t size);
+void allocateData(const SpaceHandle space, const std::string label,
+                  const void* ptr, const uint64_t size);
+void deallocateData(const SpaceHandle space, const std::string label,
+                    const void* ptr, const uint64_t size);
 
-void beginDeepCopy(const SpaceHandle dst_space, const std::string dst_label, const void* dst_ptr,
-    const SpaceHandle src_space, const std::string src_label, const void* src_ptr,
-    const uint64_t size);
+void beginDeepCopy(const SpaceHandle dst_space, const std::string dst_label,
+                   const void* dst_ptr, const SpaceHandle src_space,
+                   const std::string src_label, const void* src_ptr,
+                   const uint64_t size);
 void endDeepCopy();
 
 void initialize();
 void finalize();
 
-}
-}
+}  // namespace Profiling
+}  // namespace Kokkos
 
 #else
 namespace Kokkos {
@@ -138,40 +143,39 @@ struct SpaceHandle {
   char name[64];
 };
 
-
 bool profileLibraryLoaded();
 
+void beginParallelFor(const std::string&, const uint32_t, uint64_t*);
+void endParallelFor(const uint64_t);
+void beginParallelScan(const std::string&, const uint32_t, uint64_t*);
+void endParallelScan(const uint64_t);
+void beginParallelReduce(const std::string&, const uint32_t, uint64_t*);
+void endParallelReduce(const uint64_t);
 
-void beginParallelFor(const std::string& , const uint32_t , uint64_t* );
-void endParallelFor(const uint64_t );
-void beginParallelScan(const std::string& , const uint32_t , uint64_t* );
-void endParallelScan(const uint64_t );
-void beginParallelReduce(const std::string& , const uint32_t , uint64_t* );
-void endParallelReduce(const uint64_t );
-
-void pushRegion(const std::string& );
+void pushRegion(const std::string&);
 void popRegion();
-void createProfileSection(const std::string& , uint32_t* );
-void startSection(const uint32_t );
-void stopSection(const uint32_t );
-void destroyProfileSection(const uint32_t );
+void createProfileSection(const std::string&, uint32_t*);
+void startSection(const uint32_t);
+void stopSection(const uint32_t);
+void destroyProfileSection(const uint32_t);
 
-void markEvent(const std::string& );
+void markEvent(const std::string&);
 
-void allocateData(const SpaceHandle , const std::string , const void* , const uint64_t );
-void deallocateData(const SpaceHandle , const std::string , const void* , const uint64_t );
+void allocateData(const SpaceHandle, const std::string, const void*,
+                  const uint64_t);
+void deallocateData(const SpaceHandle, const std::string, const void*,
+                    const uint64_t);
 
-void beginDeepCopy(const SpaceHandle , const std::string , const void* , 
-    const SpaceHandle , const std::string , const void* ,
-    const uint64_t );
+void beginDeepCopy(const SpaceHandle, const std::string, const void*,
+                   const SpaceHandle, const std::string, const void*,
+                   const uint64_t);
 void endDeepCopy();
 
 void initialize();
 void finalize();
 
-}
-}
+}  // namespace Profiling
+}  // namespace Kokkos
 
 #endif
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Serial.cpp b/lib/kokkos/core/src/impl/Kokkos_Serial.cpp
index c299858c7436d18d043b76a030813a2103c619e7..40aeaa1b7a9a6d5259bbd05e9f25e64b17d262f4 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Serial.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Serial.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_SERIAL )
+#if defined(KOKKOS_ENABLE_SERIAL)
 
 #include <cstdlib>
 #include <sstream>
@@ -58,81 +59,87 @@ namespace Kokkos {
 namespace Impl {
 namespace {
 
-HostThreadTeamData g_serial_thread_team_data ;
+HostThreadTeamData g_serial_thread_team_data;
 
 bool g_serial_is_initialized = false;
 
-}
+}  // namespace
 
 // Resize thread team data scratch memory
-void serial_resize_thread_team_data( size_t pool_reduce_bytes
-                                   , size_t team_reduce_bytes
-                                   , size_t team_shared_bytes
-                                   , size_t thread_local_bytes )
-{
-  if ( pool_reduce_bytes < 512 ) pool_reduce_bytes = 512 ;
-  if ( team_reduce_bytes < 512 ) team_reduce_bytes = 512 ;
-
-  const size_t old_pool_reduce  = g_serial_thread_team_data.pool_reduce_bytes();
-  const size_t old_team_reduce  = g_serial_thread_team_data.team_reduce_bytes();
-  const size_t old_team_shared  = g_serial_thread_team_data.team_shared_bytes();
-  const size_t old_thread_local = g_serial_thread_team_data.thread_local_bytes();
-  const size_t old_alloc_bytes  = g_serial_thread_team_data.scratch_bytes();
+void serial_resize_thread_team_data(size_t pool_reduce_bytes,
+                                    size_t team_reduce_bytes,
+                                    size_t team_shared_bytes,
+                                    size_t thread_local_bytes) {
+  if (pool_reduce_bytes < 512) pool_reduce_bytes = 512;
+  if (team_reduce_bytes < 512) team_reduce_bytes = 512;
+
+  const size_t old_pool_reduce = g_serial_thread_team_data.pool_reduce_bytes();
+  const size_t old_team_reduce = g_serial_thread_team_data.team_reduce_bytes();
+  const size_t old_team_shared = g_serial_thread_team_data.team_shared_bytes();
+  const size_t old_thread_local =
+      g_serial_thread_team_data.thread_local_bytes();
+  const size_t old_alloc_bytes = g_serial_thread_team_data.scratch_bytes();
 
   // Allocate if any of the old allocation is tool small:
 
-  const bool allocate = ( old_pool_reduce  < pool_reduce_bytes ) ||
-                        ( old_team_reduce  < team_reduce_bytes ) ||
-                        ( old_team_shared  < team_shared_bytes ) ||
-                        ( old_thread_local < thread_local_bytes );
-
-  if ( allocate ) {
+  const bool allocate = (old_pool_reduce < pool_reduce_bytes) ||
+                        (old_team_reduce < team_reduce_bytes) ||
+                        (old_team_shared < team_shared_bytes) ||
+                        (old_thread_local < thread_local_bytes);
 
-    Kokkos::HostSpace space ;
+  if (allocate) {
+    Kokkos::HostSpace space;
 
-    if ( old_alloc_bytes ) {
+    if (old_alloc_bytes) {
       g_serial_thread_team_data.disband_team();
       g_serial_thread_team_data.disband_pool();
 
-      space.deallocate( g_serial_thread_team_data.scratch_buffer()
-                      , g_serial_thread_team_data.scratch_bytes() );
+      space.deallocate(g_serial_thread_team_data.scratch_buffer(),
+                       g_serial_thread_team_data.scratch_bytes());
     }
 
-    if ( pool_reduce_bytes < old_pool_reduce ) { pool_reduce_bytes = old_pool_reduce ; }
-    if ( team_reduce_bytes < old_team_reduce ) { team_reduce_bytes = old_team_reduce ; }
-    if ( team_shared_bytes < old_team_shared ) { team_shared_bytes = old_team_shared ; }
-    if ( thread_local_bytes < old_thread_local ) { thread_local_bytes = old_thread_local ; }
+    if (pool_reduce_bytes < old_pool_reduce) {
+      pool_reduce_bytes = old_pool_reduce;
+    }
+    if (team_reduce_bytes < old_team_reduce) {
+      team_reduce_bytes = old_team_reduce;
+    }
+    if (team_shared_bytes < old_team_shared) {
+      team_shared_bytes = old_team_shared;
+    }
+    if (thread_local_bytes < old_thread_local) {
+      thread_local_bytes = old_thread_local;
+    }
 
     const size_t alloc_bytes =
-      HostThreadTeamData::scratch_size( pool_reduce_bytes
-                                      , team_reduce_bytes
-                                      , team_shared_bytes
-                                      , thread_local_bytes );
-
-    void * const ptr = space.allocate( alloc_bytes );
+        HostThreadTeamData::scratch_size(pool_reduce_bytes, team_reduce_bytes,
+                                         team_shared_bytes, thread_local_bytes);
+
+    void* ptr = nullptr;
+    try {
+      ptr = space.allocate(alloc_bytes);
+    } catch (Kokkos::Experimental::RawMemoryAllocationFailure const& failure) {
+      // For now, just rethrow the error message the existing way
+      Kokkos::Impl::throw_runtime_exception(failure.get_error_message());
+    }
 
-    g_serial_thread_team_data.
-      scratch_assign( ((char *)ptr)
-                    , alloc_bytes
-                    , pool_reduce_bytes
-                    , team_reduce_bytes
-                    , team_shared_bytes
-                    , thread_local_bytes );
+    g_serial_thread_team_data.scratch_assign(
+        ((char*)ptr), alloc_bytes, pool_reduce_bytes, team_reduce_bytes,
+        team_shared_bytes, thread_local_bytes);
 
-    HostThreadTeamData * pool[1] = { & g_serial_thread_team_data };
+    HostThreadTeamData* pool[1] = {&g_serial_thread_team_data};
 
-    g_serial_thread_team_data.organize_pool( pool , 1 );
+    g_serial_thread_team_data.organize_pool(pool, 1);
     g_serial_thread_team_data.organize_team(1);
   }
 }
 
-HostThreadTeamData * serial_get_thread_team_data()
-{
-  return & g_serial_thread_team_data ;
+HostThreadTeamData* serial_get_thread_team_data() {
+  return &g_serial_thread_team_data;
 }
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
 
@@ -144,31 +151,28 @@ bool Serial::is_initialized()
 bool Serial::impl_is_initialized()
 #endif
 {
-  return Impl::g_serial_is_initialized ;
+  return Impl::g_serial_is_initialized;
 }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-void Serial::initialize( unsigned threads_count
-                       , unsigned use_numa_count
-                       , unsigned use_cores_per_numa
-                       , bool allow_asynchronous_threadpool )
-{
-  (void) threads_count;
-  (void) use_numa_count;
-  (void) use_cores_per_numa;
-  (void) allow_asynchronous_threadpool;
+void Serial::initialize(unsigned threads_count, unsigned use_numa_count,
+                        unsigned use_cores_per_numa,
+                        bool allow_asynchronous_threadpool) {
+  (void)threads_count;
+  (void)use_numa_count;
+  (void)use_cores_per_numa;
+  (void)allow_asynchronous_threadpool;
 #else
-void Serial::impl_initialize()
-{
+void Serial::impl_initialize() {
 #endif
 
-  Impl::SharedAllocationRecord< void, void >::tracking_enable();
+  Impl::SharedAllocationRecord<void, void>::tracking_enable();
 
   // Init the array of locks used for arbitrarily sized atomics
   Impl::init_lock_array_host_space();
-  #if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::initialize();
-  #endif
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::initialize();
+#endif
 
   Impl::g_serial_is_initialized = true;
 }
@@ -179,30 +183,29 @@ void Serial::finalize()
 void Serial::impl_finalize()
 #endif
 {
-  if ( Impl::g_serial_thread_team_data.scratch_buffer() ) {
+  if (Impl::g_serial_thread_team_data.scratch_buffer()) {
     Impl::g_serial_thread_team_data.disband_team();
     Impl::g_serial_thread_team_data.disband_pool();
 
-    Kokkos::HostSpace space ;
+    Kokkos::HostSpace space;
 
-    space.deallocate( Impl::g_serial_thread_team_data.scratch_buffer()
-                    , Impl::g_serial_thread_team_data.scratch_bytes() );
+    space.deallocate(Impl::g_serial_thread_team_data.scratch_buffer(),
+                     Impl::g_serial_thread_team_data.scratch_bytes());
 
-    Impl::g_serial_thread_team_data.scratch_assign( (void*) 0, 0, 0, 0, 0, 0 );
+    Impl::g_serial_thread_team_data.scratch_assign((void*)0, 0, 0, 0, 0, 0);
   }
 
-  #if defined(KOKKOS_ENABLE_PROFILING)
-    Kokkos::Profiling::finalize();
-  #endif
+#if defined(KOKKOS_ENABLE_PROFILING)
+  Kokkos::Profiling::finalize();
+#endif
 
   Impl::g_serial_is_initialized = false;
 }
 
 const char* Serial::name() { return "Serial"; }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 #else
 void KOKKOS_CORE_SRC_IMPL_SERIAL_PREVENT_LINK_ERROR() {}
-#endif // defined( KOKKOS_ENABLE_SERIAL )
-
+#endif  // defined( KOKKOS_ENABLE_SERIAL )
diff --git a/lib/kokkos/core/src/impl/Kokkos_Serial_Task.cpp b/lib/kokkos/core/src/impl/Kokkos_Serial_Task.cpp
index 687a0e9c371292b81ce9ebde90bb52e037397083..179c55b10dd5357fecc1016dfa239ebd2813149f 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Serial_Task.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Serial_Task.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,7 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_SERIAL ) && defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_SERIAL) && defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core.hpp>
 
@@ -57,9 +58,10 @@ namespace Impl {
 
 template class TaskQueue<Kokkos::Serial, typename Kokkos::Serial::memory_space>;
 
-}} /* namespace Kokkos::Impl */
+}
+}  // namespace Kokkos
 
 #else
 void KOKKOS_CORE_SRC_IMPL_SERIAL_TASK_PREVENT_LINK_ERROR() {}
-#endif /* #if defined( KOKKOS_ENABLE_SERIAL ) && defined( KOKKOS_ENABLE_TASKDAG ) */
-
+#endif /* #if defined( KOKKOS_ENABLE_SERIAL ) && defined( \
+          KOKKOS_ENABLE_TASKDAG ) */
diff --git a/lib/kokkos/core/src/impl/Kokkos_Serial_Task.hpp b/lib/kokkos/core/src/impl/Kokkos_Serial_Task.hpp
index c379a12fb13be9e9e453c668aa701e11ecba0d1c..6871e4f14a4d80290a8a4e33bd0880f73f384fb5 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Serial_Task.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Serial_Task.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_IMPL_SERIAL_TASK_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
@@ -59,47 +60,39 @@
 namespace Kokkos {
 namespace Impl {
 
-template<class QueueType>
-class TaskQueueSpecialization<
-  SimpleTaskScheduler<Kokkos::Serial, QueueType>
->
-{
-public:
-
+template <class QueueType>
+class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::Serial, QueueType> > {
+ public:
   // Note: Scheduler may be an incomplete type at class scope (but not inside
   // of the methods, obviously)
 
   using execution_space = Kokkos::Serial;
-  using memory_space = Kokkos::HostSpace;
-  using scheduler_type = SimpleTaskScheduler<Kokkos::Serial, QueueType>;
-  using member_type = TaskTeamMemberAdapter<
-    HostThreadTeamMember<Kokkos::Serial>, scheduler_type
-  >;
-
-  static
-  void execute(scheduler_type const& scheduler)
-  {
+  using memory_space    = Kokkos::HostSpace;
+  using scheduler_type  = SimpleTaskScheduler<Kokkos::Serial, QueueType>;
+  using member_type =
+      TaskTeamMemberAdapter<HostThreadTeamMember<Kokkos::Serial>,
+                            scheduler_type>;
+
+  static void execute(scheduler_type const& scheduler) {
     using task_base_type = typename scheduler_type::task_base_type;
 
     // Set default buffers
-    serial_resize_thread_team_data(
-      0,   /* global reduce buffer */
-      512, /* team reduce buffer */
-      0,   /* team shared buffer */
-      0    /* thread local buffer */
+    serial_resize_thread_team_data(0,   /* global reduce buffer */
+                                   512, /* team reduce buffer */
+                                   0,   /* team shared buffer */
+                                   0    /* thread local buffer */
     );
 
     Impl::HostThreadTeamData& self = *Impl::serial_get_thread_team_data();
 
-    auto& queue = scheduler.queue();
+    auto& queue         = scheduler.queue();
     auto team_scheduler = scheduler.get_team_scheduler(0);
 
     member_type member(scheduler, self);
 
     auto current_task = OptionalRef<task_base_type>(nullptr);
 
-    while(not queue.is_done()) {
-
+    while (not queue.is_done()) {
       // Each team lead attempts to acquire either a thread team task
       // or a single thread task for the team.
 
@@ -107,135 +100,115 @@ public:
       current_task = queue.pop_ready_task(team_scheduler.team_scheduler_info());
 
       // run the task
-      if(current_task) {
+      if (current_task) {
         current_task->as_runnable_task().run(member);
         // Respawns are handled in the complete function
-        queue.complete(
-          (*std::move(current_task)).as_runnable_task(),
-          team_scheduler.team_scheduler_info()
-        );
+        queue.complete((*std::move(current_task)).as_runnable_task(),
+                       team_scheduler.team_scheduler_info());
       }
-
     }
-
   }
 
-  static constexpr uint32_t
-  get_max_team_count(execution_space const&) noexcept
-  {
+  static constexpr uint32_t get_max_team_count(
+      execution_space const&) noexcept {
     return 1;
   }
 
   template <typename TaskType>
-  static void
-  get_function_pointer(
-    typename TaskType::function_type& ptr,
-    typename TaskType::destroy_type& dtor
-  )
-  {
-    ptr = TaskType::apply;
+  static void get_function_pointer(typename TaskType::function_type& ptr,
+                                   typename TaskType::destroy_type& dtor) {
+    ptr  = TaskType::apply;
     dtor = TaskType::destroy;
   }
 };
 
 //----------------------------------------------------------------------------
 
-template<class Scheduler>
+template <class Scheduler>
 class TaskQueueSpecializationConstrained<
-  Scheduler,
-  typename std::enable_if<
-    std::is_same<typename Scheduler::execution_space, Kokkos::Serial>::value
-  >::type
->
-{
-public:
-
+    Scheduler,
+    typename std::enable_if<std::is_same<typename Scheduler::execution_space,
+                                         Kokkos::Serial>::value>::type> {
+ public:
   // Note: Scheduler may be an incomplete type at class scope (but not inside
   // of the methods, obviously)
 
   using execution_space = Kokkos::Serial;
-  using memory_space = Kokkos::HostSpace;
-  using scheduler_type = Scheduler;
-  using member_type = TaskTeamMemberAdapter<
-    HostThreadTeamMember<Kokkos::Serial>, scheduler_type
-  >;
-
-  static
-  void iff_single_thread_recursive_execute(scheduler_type const& scheduler) {
+  using memory_space    = Kokkos::HostSpace;
+  using scheduler_type  = Scheduler;
+  using member_type =
+      TaskTeamMemberAdapter<HostThreadTeamMember<Kokkos::Serial>,
+                            scheduler_type>;
+
+  static void iff_single_thread_recursive_execute(
+      scheduler_type const& scheduler) {
     using task_base_type = TaskBase;
-    using queue_type = typename scheduler_type::queue_type;
+    using queue_type     = typename scheduler_type::queue_type;
 
-    task_base_type * const end = (task_base_type *) task_base_type::EndTag ;
+    task_base_type* const end = (task_base_type*)task_base_type::EndTag;
 
-    Impl::HostThreadTeamData * const data = Impl::serial_get_thread_team_data();
+    Impl::HostThreadTeamData* const data = Impl::serial_get_thread_team_data();
 
-    member_type exec( scheduler, *data );
+    member_type exec(scheduler, *data);
 
     // Loop until no runnable task
 
-    task_base_type * task = end ;
+    task_base_type* task = end;
 
     auto* const queue = scheduler.m_queue;
 
     do {
+      task = end;
 
-      task = end ;
-
-      for ( int i = 0 ; i < queue_type::NumQueue && end == task ; ++i ) {
-        for ( int j = 0 ; j < 2 && end == task ; ++j ) {
-          task = queue_type::pop_ready_task( & queue->m_ready[i][j] );
+      for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+        for (int j = 0; j < 2 && end == task; ++j) {
+          task = queue_type::pop_ready_task(&queue->m_ready[i][j]);
         }
       }
 
-      if ( end == task ) break ;
-
-      (*task->m_apply)( task , & exec );
+      if (end == task) break;
 
-      queue->complete( task );
+      (*task->m_apply)(task, &exec);
 
-    } while(1);
+      queue->complete(task);
 
+    } while (1);
   }
 
-  static
-  void execute(scheduler_type const& scheduler)
-  {
+  static void execute(scheduler_type const& scheduler) {
     using task_base_type = TaskBase;
-    using queue_type = typename scheduler_type::queue_type;
+    using queue_type     = typename scheduler_type::queue_type;
 
-    task_base_type * const end = (task_base_type *) task_base_type::EndTag ;
+    task_base_type* const end = (task_base_type*)task_base_type::EndTag;
 
     // Set default buffers
-    serial_resize_thread_team_data(
-      0,   /* global reduce buffer */
-      512, /* team reduce buffer */
-      0,   /* team shared buffer */
-      0    /* thread local buffer */
+    serial_resize_thread_team_data(0,   /* global reduce buffer */
+                                   512, /* team reduce buffer */
+                                   0,   /* team shared buffer */
+                                   0    /* thread local buffer */
     );
 
     auto* const queue = scheduler.m_queue;
 
-    Impl::HostThreadTeamData * const data = Impl::serial_get_thread_team_data();
+    Impl::HostThreadTeamData* const data = Impl::serial_get_thread_team_data();
 
-    member_type exec( scheduler, *data );
+    member_type exec(scheduler, *data);
 
     // Loop until all queues are empty
-    while ( 0 < queue->m_ready_count ) {
-
-      task_base_type * task = end ;
+    while (0 < queue->m_ready_count) {
+      task_base_type* task = end;
 
-      for ( int i = 0 ; i < queue_type::NumQueue && end == task ; ++i ) {
-        for ( int j = 0 ; j < 2 && end == task ; ++j ) {
-          task = queue_type::pop_ready_task( & queue->m_ready[i][j] );
+      for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+        for (int j = 0; j < 2 && end == task; ++j) {
+          task = queue_type::pop_ready_task(&queue->m_ready[i][j]);
         }
       }
 
-      if ( end != task ) {
-
+      if (end != task) {
         // pop_ready_task resulted in lock == task->m_next
         // In the executing state
 
-        (*task->m_apply)( task , & exec );
+        (*task->m_apply)(task, &exec);
 
 #if 0
         printf( "TaskQueue<Serial>::executed: 0x%lx { 0x%lx 0x%lx %d %d %d }\n"
@@ -249,33 +222,29 @@ public:
 
         // If a respawn then re-enqueue otherwise the task is complete
         // and all tasks waiting on this task are updated.
-        queue->complete( task );
-      }
-      else if ( 0 != queue->m_ready_count ) {
+        queue->complete(task);
+      } else if (0 != queue->m_ready_count) {
         Kokkos::abort("TaskQueue<Serial>::execute ERROR: ready_count");
       }
     }
   }
 
   template <typename TaskType>
-  static void
-  get_function_pointer(
-    typename TaskType::function_type& ptr,
-    typename TaskType::destroy_type& dtor
-  )
-  {
-    ptr = TaskType::apply;
+  static void get_function_pointer(typename TaskType::function_type& ptr,
+                                   typename TaskType::destroy_type& dtor) {
+    ptr  = TaskType::apply;
     dtor = TaskType::destroy;
   }
 };
 
-extern template class TaskQueue< Kokkos::Serial, typename Kokkos::Serial::memory_space > ;
+extern template class TaskQueue<Kokkos::Serial,
+                                typename Kokkos::Serial::memory_space>;
 
-}} /* namespace Kokkos::Impl */
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_SERIAL_TASK_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Serial_WorkGraphPolicy.hpp b/lib/kokkos/core/src/impl/Kokkos_Serial_WorkGraphPolicy.hpp
index 07a207b556316f34af0cd514986668c0809cfd33..4e26e0b138934fe3e8a2371fce29726e85313d89 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Serial_WorkGraphPolicy.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Serial_WorkGraphPolicy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,55 +48,47 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class FunctorType , class ... Traits >
-class ParallelFor< FunctorType ,
-                   Kokkos::WorkGraphPolicy< Traits ... > ,
-                   Kokkos::Serial
-                 >
-{
-private:
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
+                  Kokkos::Serial> {
+ private:
+  typedef Kokkos::WorkGraphPolicy<Traits...> Policy;
 
-  typedef Kokkos::WorkGraphPolicy< Traits ... > Policy ;
+  Policy m_policy;
+  FunctorType m_functor;
 
-  Policy       m_policy ;
-  FunctorType  m_functor ;
+  template <class TagType>
+  typename std::enable_if<std::is_same<TagType, void>::value>::type exec_one(
+      const std::int32_t w) const noexcept {
+    m_functor(w);
+  }
 
-  template< class TagType >
-  typename std::enable_if< std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { m_functor( w ); }
+  template <class TagType>
+  typename std::enable_if<!std::is_same<TagType, void>::value>::type exec_one(
+      const std::int32_t w) const noexcept {
+    const TagType t{};
+    m_functor(t, w);
+  }
 
-  template< class TagType >
-  typename std::enable_if< ! std::is_same< TagType , void >::value >::type
-  exec_one( const std::int32_t w ) const noexcept
-    { const TagType t{}; m_functor( t , w ); }
+ public:
+  inline void execute() const noexcept {
+    // Spin until COMPLETED_TOKEN.
+    // END_TOKEN indicates no work is currently available.
 
-public:
-
-  inline
-  void execute() const noexcept
-    {
-      // Spin until COMPLETED_TOKEN.
-      // END_TOKEN indicates no work is currently available.
-        
-      for ( std::int32_t w = Policy::END_TOKEN ;
-            Policy::COMPLETED_TOKEN != ( w = m_policy.pop_work() ) ; ) {
-        if ( Policy::END_TOKEN != w ) {
-          exec_one< typename Policy::work_tag >( w );
-          m_policy.completed_work(w);
-        }
+    for (std::int32_t w = Policy::END_TOKEN;
+         Policy::COMPLETED_TOKEN != (w = m_policy.pop_work());) {
+      if (Policy::END_TOKEN != w) {
+        exec_one<typename Policy::work_tag>(w);
+        m_policy.completed_work(w);
       }
     }
+  }
 
-  inline
-  ParallelFor( const FunctorType & arg_functor
-             , const Policy      & arg_policy )
-    : m_policy( arg_policy )
-    , m_functor( arg_functor )
-    {}
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_policy(arg_policy), m_functor(arg_functor) {}
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #define KOKKOS_SERIAL_WORKGRAPHPOLICY_HPP */
diff --git a/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.cpp b/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.cpp
index 77eb69d0812620a5c5801b7500e145ecd810d215..3688f069e56e0d8ec457ca30b9e8e31faf41c626 100644
--- a/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,129 +50,143 @@ namespace Impl {
 __thread int SharedAllocationRecord<void, void>::t_tracking_enabled = 1;
 
 #ifdef KOKKOS_DEBUG
-bool
-SharedAllocationRecord< void , void >::
-is_sane( SharedAllocationRecord< void , void > * arg_record )
-{
-  SharedAllocationRecord * const root = arg_record ? arg_record->m_root : 0 ;
+bool SharedAllocationRecord<void, void>::is_sane(
+    SharedAllocationRecord<void, void>* arg_record) {
+  SharedAllocationRecord* const root = arg_record ? arg_record->m_root : 0;
 
-  bool ok = root != 0 && root->use_count() == 0 ;
+  bool ok = root != 0 && root->use_count() == 0;
 
-  if ( ok ) {
-    SharedAllocationRecord * root_next = 0 ;
-    static constexpr SharedAllocationRecord * zero = nullptr;
+  if (ok) {
+    SharedAllocationRecord* root_next             = 0;
+    static constexpr SharedAllocationRecord* zero = nullptr;
     // Lock the list:
-    while ( ( root_next = Kokkos::atomic_exchange( & root->m_next , zero ) ) == nullptr );
-
-    for ( SharedAllocationRecord * rec = root_next ; ok && rec != root ; rec = rec->m_next ) {
-      const bool ok_non_null  = rec && rec->m_prev && ( rec == root || rec->m_next );
-      const bool ok_root      = ok_non_null && rec->m_root == root ;
-      const bool ok_prev_next = ok_non_null && ( rec->m_prev != root ? rec->m_prev->m_next == rec : root_next == rec );
-      const bool ok_next_prev = ok_non_null && rec->m_next->m_prev == rec ;
-      const bool ok_count     = ok_non_null && 0 <= rec->use_count() ;
-
-      ok = ok_root && ok_prev_next && ok_next_prev && ok_count ;
-
-      if ( ! ok ) {
-        //Formatting dependent on sizeof(uintptr_t)
-        const char * format_string;
+    while ((root_next = Kokkos::atomic_exchange(&root->m_next, zero)) ==
+           nullptr)
+      ;
+
+    for (SharedAllocationRecord* rec = root_next; ok && rec != root;
+         rec                         = rec->m_next) {
+      const bool ok_non_null =
+          rec && rec->m_prev && (rec == root || rec->m_next);
+      const bool ok_root = ok_non_null && rec->m_root == root;
+      const bool ok_prev_next =
+          ok_non_null &&
+          (rec->m_prev != root ? rec->m_prev->m_next == rec : root_next == rec);
+      const bool ok_next_prev = ok_non_null && rec->m_next->m_prev == rec;
+      const bool ok_count     = ok_non_null && 0 <= rec->use_count();
+
+      ok = ok_root && ok_prev_next && ok_next_prev && ok_count;
+
+      if (!ok) {
+        // Formatting dependent on sizeof(uintptr_t)
+        const char* format_string;
 
         if (sizeof(uintptr_t) == sizeof(unsigned long)) {
-          format_string = "Kokkos::Impl::SharedAllocationRecord failed is_sane: rec(0x%.12lx){ m_count(%d) m_root(0x%.12lx) m_next(0x%.12lx) m_prev(0x%.12lx) m_next->m_prev(0x%.12lx) m_prev->m_next(0x%.12lx) }\n";
-        }
-        else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
-          format_string = "Kokkos::Impl::SharedAllocationRecord failed is_sane: rec(0x%.12llx){ m_count(%d) m_root(0x%.12llx) m_next(0x%.12llx) m_prev(0x%.12llx) m_next->m_prev(0x%.12llx) m_prev->m_next(0x%.12llx) }\n";
+          format_string =
+              "Kokkos::Impl::SharedAllocationRecord failed is_sane: "
+              "rec(0x%.12lx){ m_count(%d) m_root(0x%.12lx) m_next(0x%.12lx) "
+              "m_prev(0x%.12lx) m_next->m_prev(0x%.12lx) "
+              "m_prev->m_next(0x%.12lx) }\n";
+        } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
+          format_string =
+              "Kokkos::Impl::SharedAllocationRecord failed is_sane: "
+              "rec(0x%.12llx){ m_count(%d) m_root(0x%.12llx) m_next(0x%.12llx) "
+              "m_prev(0x%.12llx) m_next->m_prev(0x%.12llx) "
+              "m_prev->m_next(0x%.12llx) }\n";
         }
 
-        fprintf(stderr
-            , format_string
-            , reinterpret_cast< uintptr_t >( rec )
-            , rec->use_count()
-            , reinterpret_cast< uintptr_t >( rec->m_root )
-            , reinterpret_cast< uintptr_t >( rec->m_next )
-            , reinterpret_cast< uintptr_t >( rec->m_prev )
-            , reinterpret_cast< uintptr_t >( rec->m_next != NULL ? rec->m_next->m_prev : NULL )
-            , reinterpret_cast< uintptr_t >( rec->m_prev != rec->m_root ? rec->m_prev->m_next : root_next )
-            );
+        fprintf(stderr, format_string, reinterpret_cast<uintptr_t>(rec),
+                rec->use_count(), reinterpret_cast<uintptr_t>(rec->m_root),
+                reinterpret_cast<uintptr_t>(rec->m_next),
+                reinterpret_cast<uintptr_t>(rec->m_prev),
+                reinterpret_cast<uintptr_t>(
+                    rec->m_next != NULL ? rec->m_next->m_prev : NULL),
+                reinterpret_cast<uintptr_t>(rec->m_prev != rec->m_root
+                                                ? rec->m_prev->m_next
+                                                : root_next));
       }
-
     }
 
-    if ( nullptr != Kokkos::atomic_exchange( & root->m_next , root_next ) ) {
-      Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord failed is_sane unlocking");
+    if (nullptr != Kokkos::atomic_exchange(&root->m_next, root_next)) {
+      Kokkos::Impl::throw_runtime_exception(
+          "Kokkos::Impl::SharedAllocationRecord failed is_sane unlocking");
     }
   }
-  return ok ;
+  return ok;
 }
 
 #else
 
-bool
-SharedAllocationRecord< void , void >::
-is_sane( SharedAllocationRecord< void , void > * )
-{
-  Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord::is_sane only works with KOKKOS_DEBUG enabled");
-  return false ;
+bool SharedAllocationRecord<void, void>::is_sane(
+    SharedAllocationRecord<void, void>*) {
+  Kokkos::Impl::throw_runtime_exception(
+      "Kokkos::Impl::SharedAllocationRecord::is_sane only works with "
+      "KOKKOS_DEBUG enabled");
+  return false;
 }
-#endif //#ifdef KOKKOS_DEBUG
+#endif  //#ifdef KOKKOS_DEBUG
 
 #ifdef KOKKOS_DEBUG
-SharedAllocationRecord<void,void> *
-SharedAllocationRecord<void,void>::find( SharedAllocationRecord<void,void> * const arg_root , void * const arg_data_ptr )
-{
-  SharedAllocationRecord * root_next = 0 ;
-  static constexpr SharedAllocationRecord * zero = nullptr;
+SharedAllocationRecord<void, void>* SharedAllocationRecord<void, void>::find(
+    SharedAllocationRecord<void, void>* const arg_root,
+    void* const arg_data_ptr) {
+  SharedAllocationRecord* root_next             = 0;
+  static constexpr SharedAllocationRecord* zero = nullptr;
 
   // Lock the list:
-  while ( ( root_next = Kokkos::atomic_exchange( & arg_root->m_next , zero ) ) == nullptr );
+  while ((root_next = Kokkos::atomic_exchange(&arg_root->m_next, zero)) ==
+         nullptr)
+    ;
 
   // Iterate searching for the record with this data pointer
 
-  SharedAllocationRecord * r = root_next ;
+  SharedAllocationRecord* r = root_next;
 
-  while ( ( r != arg_root ) && ( r->data() != arg_data_ptr ) ) { r = r->m_next ; }
+  while ((r != arg_root) && (r->data() != arg_data_ptr)) {
+    r = r->m_next;
+  }
 
-  if ( r == arg_root ) { r = 0 ; }
+  if (r == arg_root) {
+    r = 0;
+  }
 
-  if ( nullptr != Kokkos::atomic_exchange( & arg_root->m_next , root_next ) ) {
-    Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord failed locking/unlocking");
+  if (nullptr != Kokkos::atomic_exchange(&arg_root->m_next, root_next)) {
+    Kokkos::Impl::throw_runtime_exception(
+        "Kokkos::Impl::SharedAllocationRecord failed locking/unlocking");
   }
-  return r ;
+  return r;
 }
 #else
-SharedAllocationRecord<void,void> *
-SharedAllocationRecord<void,void>::find( SharedAllocationRecord<void,void> * const , void * const )
-{
-  Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord::find only works with KOKKOS_DEBUG enabled");
+SharedAllocationRecord<void, void>* SharedAllocationRecord<void, void>::find(
+    SharedAllocationRecord<void, void>* const, void* const) {
+  Kokkos::Impl::throw_runtime_exception(
+      "Kokkos::Impl::SharedAllocationRecord::find only works with KOKKOS_DEBUG "
+      "enabled");
   return nullptr;
 }
 #endif
 
-
 /**\brief  Construct and insert into 'arg_root' tracking set.
  *         use_count is zero.
  */
-SharedAllocationRecord< void , void >::
-SharedAllocationRecord(
+SharedAllocationRecord<void, void>::SharedAllocationRecord(
 #ifdef KOKKOS_DEBUG
-                        SharedAllocationRecord<void,void> * arg_root,
+    SharedAllocationRecord<void, void>* arg_root,
 #endif
-                        SharedAllocationHeader            * arg_alloc_ptr
-                      , size_t                              arg_alloc_size
-                      , SharedAllocationRecord< void , void >::function_type  arg_dealloc
-                      )
-  : m_alloc_ptr(  arg_alloc_ptr )
-  , m_alloc_size( arg_alloc_size )
-  , m_dealloc(    arg_dealloc )
+    SharedAllocationHeader* arg_alloc_ptr, size_t arg_alloc_size,
+    SharedAllocationRecord<void, void>::function_type arg_dealloc)
+    : m_alloc_ptr(arg_alloc_ptr),
+      m_alloc_size(arg_alloc_size),
+      m_dealloc(arg_dealloc)
 #ifdef KOKKOS_DEBUG
-  , m_root( arg_root )
-  , m_prev( 0 )
-  , m_next( 0 )
+      ,
+      m_root(arg_root),
+      m_prev(0),
+      m_next(0)
 #endif
-  , m_count( 0 )
-{
-  if ( 0 != arg_alloc_ptr ) {
-
+      ,
+      m_count(0) {
+  if (0 != arg_alloc_ptr) {
 #ifdef KOKKOS_DEBUG
     // Insert into the root double-linked list for tracking
     //
@@ -179,47 +194,45 @@ SharedAllocationRecord(
     // after:   arg_root->m_next == this ; this->m_prev == arg_root ;
     //              this->m_next == next ; next->m_prev == this
 
-    m_prev = m_root ;
-    static constexpr SharedAllocationRecord * zero = nullptr;
+    m_prev                                        = m_root;
+    static constexpr SharedAllocationRecord* zero = nullptr;
 
     // Read root->m_next and lock by setting to NULL
-    while ( ( m_next = Kokkos::atomic_exchange( & m_root->m_next , zero ) ) == nullptr );
+    while ((m_next = Kokkos::atomic_exchange(&m_root->m_next, zero)) == nullptr)
+      ;
 
-    m_next->m_prev = this ;
+    m_next->m_prev = this;
 
     // memory fence before completing insertion into linked list
     Kokkos::memory_fence();
 
-    if ( nullptr != Kokkos::atomic_exchange( & m_root->m_next , this ) ) {
-      Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord failed locking/unlocking");
+    if (nullptr != Kokkos::atomic_exchange(&m_root->m_next, this)) {
+      Kokkos::Impl::throw_runtime_exception(
+          "Kokkos::Impl::SharedAllocationRecord failed locking/unlocking");
     }
 #endif
 
-  }
-  else {
-    Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord given NULL allocation");
+  } else {
+    Kokkos::Impl::throw_runtime_exception(
+        "Kokkos::Impl::SharedAllocationRecord given NULL allocation");
   }
 }
 
-void
-SharedAllocationRecord< void , void >::
-increment( SharedAllocationRecord< void , void > * arg_record )
-{
-  const int old_count = Kokkos::atomic_fetch_add( & arg_record->m_count , 1 );
+void SharedAllocationRecord<void, void>::increment(
+    SharedAllocationRecord<void, void>* arg_record) {
+  const int old_count = Kokkos::atomic_fetch_add(&arg_record->m_count, 1);
 
-  if ( old_count < 0 ) { // Error
-    Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord failed increment");
+  if (old_count < 0) {  // Error
+    Kokkos::Impl::throw_runtime_exception(
+        "Kokkos::Impl::SharedAllocationRecord failed increment");
   }
 }
 
-SharedAllocationRecord< void , void > *
-SharedAllocationRecord< void , void >::
-decrement( SharedAllocationRecord< void , void > * arg_record )
-{
-  const int old_count = Kokkos::atomic_fetch_sub( & arg_record->m_count , 1 );
-
-  if ( old_count == 1 ) {
+SharedAllocationRecord<void, void>* SharedAllocationRecord<
+    void, void>::decrement(SharedAllocationRecord<void, void>* arg_record) {
+  const int old_count = Kokkos::atomic_fetch_sub(&arg_record->m_count, 1);
 
+  if (old_count == 1) {
     if (!Kokkos::is_initialized()) {
       std::stringstream ss;
       ss << "Kokkos allocation \"";
@@ -228,7 +241,8 @@ decrement( SharedAllocationRecord< void , void > * arg_record )
       auto s = ss.str();
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
       std::cerr << s;
-      std::cerr << "This behavior is incorrect Kokkos usage, and will crash in future releases\n";
+      std::cerr << "This behavior is incorrect Kokkos usage, and will crash in "
+                   "future releases\n";
 #else
       Kokkos::Impl::throw_runtime_exception(s);
 #endif
@@ -241,124 +255,113 @@ decrement( SharedAllocationRecord< void , void > * arg_record )
     // after:   arg_record->m_prev->m_next == arg_record->m_next  &&
     //          arg_record->m_next->m_prev == arg_record->m_prev
 
-    SharedAllocationRecord * root_next = 0 ;
-    static constexpr SharedAllocationRecord * zero = nullptr;
+    SharedAllocationRecord* root_next             = 0;
+    static constexpr SharedAllocationRecord* zero = nullptr;
 
     // Lock the list:
-    while ( ( root_next = Kokkos::atomic_exchange( & arg_record->m_root->m_next , zero ) ) == nullptr );
+    while ((root_next = Kokkos::atomic_exchange(&arg_record->m_root->m_next,
+                                                zero)) == nullptr)
+      ;
 
-    arg_record->m_next->m_prev = arg_record->m_prev ;
+    arg_record->m_next->m_prev = arg_record->m_prev;
 
-    if ( root_next != arg_record ) {
-      arg_record->m_prev->m_next = arg_record->m_next ;
-    }
-    else {
+    if (root_next != arg_record) {
+      arg_record->m_prev->m_next = arg_record->m_next;
+    } else {
       // before:  arg_record->m_root == arg_record->m_prev
       // after:   arg_record->m_root == arg_record->m_next
-      root_next = arg_record->m_next ;
+      root_next = arg_record->m_next;
     }
 
     Kokkos::memory_fence();
 
     // Unlock the list:
-    if ( nullptr != Kokkos::atomic_exchange( & arg_record->m_root->m_next , root_next ) ) {
-      Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord failed decrement unlocking");
+    if (nullptr !=
+        Kokkos::atomic_exchange(&arg_record->m_root->m_next, root_next)) {
+      Kokkos::Impl::throw_runtime_exception(
+          "Kokkos::Impl::SharedAllocationRecord failed decrement unlocking");
     }
 
-    arg_record->m_next = 0 ;
-    arg_record->m_prev = 0 ;
+    arg_record->m_next = 0;
+    arg_record->m_prev = 0;
 #endif
 
-    function_type d = arg_record->m_dealloc ;
-    (*d)( arg_record );
-    arg_record = 0 ;
-  }
-  else if ( old_count < 1 ) { // Error
-    fprintf(stderr,"Kokkos::Impl::SharedAllocationRecord '%s' failed decrement count = %d\n", arg_record->m_alloc_ptr->m_label , old_count );
+    function_type d = arg_record->m_dealloc;
+    (*d)(arg_record);
+    arg_record = 0;
+  } else if (old_count < 1) {  // Error
+    fprintf(stderr,
+            "Kokkos::Impl::SharedAllocationRecord '%s' failed decrement count "
+            "= %d\n",
+            arg_record->m_alloc_ptr->m_label, old_count);
     fflush(stderr);
-    Kokkos::Impl::throw_runtime_exception("Kokkos::Impl::SharedAllocationRecord failed decrement count");
+    Kokkos::Impl::throw_runtime_exception(
+        "Kokkos::Impl::SharedAllocationRecord failed decrement count");
   }
 
-  return arg_record ;
+  return arg_record;
 }
 
 #ifdef KOKKOS_DEBUG
-void
-SharedAllocationRecord< void , void >::
-print_host_accessible_records( std::ostream & s
-                             , const char * const space_name
-                             , const SharedAllocationRecord * const root
-                             , const bool detail )
-{
-  const SharedAllocationRecord< void , void > * r = root ;
-
-  char buffer[256] ;
-
-  if ( detail ) {
+void SharedAllocationRecord<void, void>::print_host_accessible_records(
+    std::ostream& s, const char* const space_name,
+    const SharedAllocationRecord* const root, const bool detail) {
+  const SharedAllocationRecord<void, void>* r = root;
+
+  char buffer[256];
+
+  if (detail) {
     do {
-      //Formatting dependent on sizeof(uintptr_t)
-      const char * format_string;
+      // Formatting dependent on sizeof(uintptr_t)
+      const char* format_string;
 
       if (sizeof(uintptr_t) == sizeof(unsigned long)) {
-        format_string = "%s addr( 0x%.12lx ) list( 0x%.12lx 0x%.12lx ) extent[ 0x%.12lx + %.8ld ] count(%d) dealloc(0x%.12lx) %s\n";
-      }
-      else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
-        format_string = "%s addr( 0x%.12llx ) list( 0x%.12llx 0x%.12llx ) extent[ 0x%.12llx + %.8ld ] count(%d) dealloc(0x%.12llx) %s\n";
+        format_string =
+            "%s addr( 0x%.12lx ) list( 0x%.12lx 0x%.12lx ) extent[ 0x%.12lx + "
+            "%.8ld ] count(%d) dealloc(0x%.12lx) %s\n";
+      } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
+        format_string =
+            "%s addr( 0x%.12llx ) list( 0x%.12llx 0x%.12llx ) extent[ "
+            "0x%.12llx + %.8ld ] count(%d) dealloc(0x%.12llx) %s\n";
       }
 
-      snprintf( buffer , 256
-              , format_string
-              , space_name
-              , reinterpret_cast<uintptr_t>( r )
-              , reinterpret_cast<uintptr_t>( r->m_prev )
-              , reinterpret_cast<uintptr_t>( r->m_next )
-              , reinterpret_cast<uintptr_t>( r->m_alloc_ptr )
-              , r->m_alloc_size
-              , r->use_count()
-              , reinterpret_cast<uintptr_t>( r->m_dealloc )
-              , r->m_alloc_ptr->m_label
-              );
-      s << buffer ;
-      r = r->m_next ;
-    } while ( r != root );
-  }
-  else {
+      snprintf(buffer, 256, format_string, space_name,
+               reinterpret_cast<uintptr_t>(r),
+               reinterpret_cast<uintptr_t>(r->m_prev),
+               reinterpret_cast<uintptr_t>(r->m_next),
+               reinterpret_cast<uintptr_t>(r->m_alloc_ptr), r->m_alloc_size,
+               r->use_count(), reinterpret_cast<uintptr_t>(r->m_dealloc),
+               r->m_alloc_ptr->m_label);
+      s << buffer;
+      r = r->m_next;
+    } while (r != root);
+  } else {
     do {
-      if ( r->m_alloc_ptr ) {
-        //Formatting dependent on sizeof(uintptr_t)
-        const char * format_string;
+      if (r->m_alloc_ptr) {
+        // Formatting dependent on sizeof(uintptr_t)
+        const char* format_string;
 
         if (sizeof(uintptr_t) == sizeof(unsigned long)) {
           format_string = "%s [ 0x%.12lx + %ld ] %s\n";
-        }
-        else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
+        } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
           format_string = "%s [ 0x%.12llx + %ld ] %s\n";
         }
 
-        snprintf( buffer , 256
-                , format_string
-                , space_name
-                , reinterpret_cast< uintptr_t >( r->data() )
-                , r->size()
-                , r->m_alloc_ptr->m_label
-                );
+        snprintf(buffer, 256, format_string, space_name,
+                 reinterpret_cast<uintptr_t>(r->data()), r->size(),
+                 r->m_alloc_ptr->m_label);
+      } else {
+        snprintf(buffer, 256, "%s [ 0 + 0 ]\n", space_name);
       }
-      else {
-        snprintf( buffer , 256 , "%s [ 0 + 0 ]\n" , space_name );
-      }
-      s << buffer ;
-      r = r->m_next ;
-    } while ( r != root );
+      s << buffer;
+      r = r->m_next;
+    } while (r != root);
   }
 }
 #else
-void
-SharedAllocationRecord< void , void >::
-print_host_accessible_records( std::ostream &
-                             , const char * const
-                             , const SharedAllocationRecord * const
-                             , const bool )
-{
+void SharedAllocationRecord<void, void>::print_host_accessible_records(
+    std::ostream&, const char* const, const SharedAllocationRecord* const,
+    const bool) {
   Kokkos::Impl::throw_runtime_exception(
       "Kokkos::Impl::SharedAllocationRecord::print_host_accessible_records"
       " only works with KOKKOS_DEBUG enabled");
@@ -367,4 +370,3 @@ print_host_accessible_records( std::ostream &
 
 } /* namespace Impl */
 } /* namespace Kokkos */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.hpp b/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.hpp
index 54021a71be555398341056b18a23c7c7896f549b..b68c0834c913f2ea653ae7d2a1b82722821332d9 100644
--- a/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_SharedAlloc.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,73 +51,73 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class MemorySpace = void , class DestroyFunctor = void >
-class SharedAllocationRecord ;
+template <class MemorySpace = void, class DestroyFunctor = void>
+class SharedAllocationRecord;
 
 class SharedAllocationHeader {
-private:
+ private:
+  typedef SharedAllocationRecord<void, void> Record;
 
-  typedef SharedAllocationRecord<void,void>  Record ;
+  static constexpr unsigned maximum_label_length =
+      (1u << 7 /* 128 */) - sizeof(Record*);
 
-  static constexpr unsigned maximum_label_length = ( 1u << 7 /* 128 */ ) - sizeof(Record*);
+  template <class, class>
+  friend class SharedAllocationRecord;
 
-  template< class , class > friend class SharedAllocationRecord ;
-
-  Record * m_record ;
-  char     m_label[ maximum_label_length ];
-
-public:
+  Record* m_record;
+  char m_label[maximum_label_length];
 
+ public:
   /* Given user memory get pointer to the header */
-  KOKKOS_INLINE_FUNCTION static
-  const SharedAllocationHeader * get_header( void * alloc_ptr )
-    { return reinterpret_cast<SharedAllocationHeader*>( reinterpret_cast<char*>(alloc_ptr) - sizeof(SharedAllocationHeader) ); }
+  KOKKOS_INLINE_FUNCTION static const SharedAllocationHeader* get_header(
+      void* alloc_ptr) {
+    return reinterpret_cast<SharedAllocationHeader*>(
+        reinterpret_cast<char*>(alloc_ptr) - sizeof(SharedAllocationHeader));
+  }
 
   KOKKOS_INLINE_FUNCTION
   const char* label() const { return m_label; }
 };
 
-template<>
-class SharedAllocationRecord< void , void > {
-protected:
+template <>
+class SharedAllocationRecord<void, void> {
+ protected:
+  static_assert(sizeof(SharedAllocationHeader) == (1u << 7 /* 128 */),
+                "sizeof(SharedAllocationHeader) != 128");
 
-  static_assert( sizeof(SharedAllocationHeader) == ( 1u << 7 /* 128 */ ) , "sizeof(SharedAllocationHeader) != 128" );
+  template <class, class>
+  friend class SharedAllocationRecord;
 
-  template< class , class > friend class SharedAllocationRecord ;
+  using function_type = void (*)(SharedAllocationRecord<void, void>*);
 
-  typedef void (* function_type )( SharedAllocationRecord<void,void> * );
-
-  SharedAllocationHeader * const m_alloc_ptr ;
-  size_t                   const m_alloc_size ;
-  function_type            const m_dealloc ;
+  SharedAllocationHeader* const m_alloc_ptr;
+  size_t const m_alloc_size;
+  function_type const m_dealloc;
 #ifdef KOKKOS_DEBUG
-  SharedAllocationRecord * const m_root ;
-  SharedAllocationRecord *       m_prev ;
-  SharedAllocationRecord *       m_next ;
+  SharedAllocationRecord* const m_root;
+  SharedAllocationRecord* m_prev;
+  SharedAllocationRecord* m_next;
 #endif
-  int                            m_count ;
+  int m_count;
 
-  SharedAllocationRecord( SharedAllocationRecord && ) = delete ;
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( SharedAllocationRecord && ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
+  SharedAllocationRecord(SharedAllocationRecord&&)      = delete;
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(SharedAllocationRecord&&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
   /**\brief  Construct and insert into 'arg_root' tracking set.
    *         use_count is zero.
    */
   SharedAllocationRecord(
 #ifdef KOKKOS_DEBUG
-                          SharedAllocationRecord * arg_root,
+      SharedAllocationRecord* arg_root,
 #endif
-                          SharedAllocationHeader * arg_alloc_ptr
-                        , size_t                   arg_alloc_size
-                        , function_type            arg_dealloc
-                        );
-private:
-  
+      SharedAllocationHeader* arg_alloc_ptr, size_t arg_alloc_size,
+      function_type arg_dealloc);
+ private:
   static __thread int t_tracking_enabled;
 
-public:
+ public:
   virtual std::string get_label() const { return std::string("Unmanaged"); }
 
   static int tracking_enabled() { return t_tracking_enabled; }
@@ -134,155 +135,153 @@ public:
   virtual ~SharedAllocationRecord() {}
 
   SharedAllocationRecord()
-    : m_alloc_ptr( 0 )
-    , m_alloc_size( 0 )
-    , m_dealloc( 0 )
+      : m_alloc_ptr(nullptr),
+        m_alloc_size(0),
+        m_dealloc(nullptr)
 #ifdef KOKKOS_DEBUG
-    , m_root( this )
-    , m_prev( this )
-    , m_next( this )
+        ,
+        m_root(this),
+        m_prev(this),
+        m_next(this)
 #endif
-    , m_count( 0 )
-    {}
+        ,
+        m_count(0) {
+  }
 
-  static constexpr unsigned maximum_label_length = SharedAllocationHeader::maximum_label_length ;
+  static constexpr unsigned maximum_label_length =
+      SharedAllocationHeader::maximum_label_length;
 
   KOKKOS_INLINE_FUNCTION
-  const SharedAllocationHeader * head() const { return m_alloc_ptr ; }
+  const SharedAllocationHeader* head() const { return m_alloc_ptr; }
 
   /* User's memory begins at the end of the header */
   KOKKOS_INLINE_FUNCTION
-  void * data() const { return reinterpret_cast<void*>( m_alloc_ptr + 1 ); }
+  void* data() const { return reinterpret_cast<void*>(m_alloc_ptr + 1); }
 
   /* User's memory begins at the end of the header */
-  size_t size() const { return m_alloc_size - sizeof(SharedAllocationHeader) ; }
+  size_t size() const { return m_alloc_size - sizeof(SharedAllocationHeader); }
 
   /* Cannot be 'constexpr' because 'm_count' is volatile */
-  int use_count() const { return *static_cast<const volatile int *>(&m_count); }
+  int use_count() const { return *static_cast<const volatile int*>(&m_count); }
 
   /* Increment use count */
-  static void increment( SharedAllocationRecord * );
+  static void increment(SharedAllocationRecord*);
 
-  /* Decrement use count. If 1->0 then remove from the tracking list and invoke m_dealloc */
-  static SharedAllocationRecord * decrement( SharedAllocationRecord * );
+  /* Decrement use count. If 1->0 then remove from the tracking list and invoke
+   * m_dealloc */
+  static SharedAllocationRecord* decrement(SharedAllocationRecord*);
 
   /* Given a root record and data pointer find the record */
-  static SharedAllocationRecord * find( SharedAllocationRecord * const , void * const );
+  static SharedAllocationRecord* find(SharedAllocationRecord* const,
+                                      void* const);
 
-  /*  Sanity check for the whole set of records to which the input record belongs.
-   *  Locks the set's insert/erase operations until the sanity check is complete.
+  /*  Sanity check for the whole set of records to which the input record
+   * belongs. Locks the set's insert/erase operations until the sanity check is
+   * complete.
    */
-  static bool is_sane( SharedAllocationRecord * );
+  static bool is_sane(SharedAllocationRecord*);
 
   /*  Print host-accessible records */
-  static void print_host_accessible_records( std::ostream &
-                                           , const char * const space_name
-                                           , const SharedAllocationRecord * const root
-                                           , const bool detail );
+  static void print_host_accessible_records(
+      std::ostream&, const char* const space_name,
+      const SharedAllocationRecord* const root, const bool detail);
 };
 
 namespace {
 
 /* Taking the address of this function so make sure it is unique */
-template < class MemorySpace , class DestroyFunctor >
-void deallocate( SharedAllocationRecord<void,void> * record_ptr )
-{
-  typedef SharedAllocationRecord< MemorySpace , void > base_type ;
-  typedef SharedAllocationRecord< MemorySpace , DestroyFunctor > this_type ;
+template <class MemorySpace, class DestroyFunctor>
+void deallocate(SharedAllocationRecord<void, void>* record_ptr) {
+  typedef SharedAllocationRecord<MemorySpace, void> base_type;
+  typedef SharedAllocationRecord<MemorySpace, DestroyFunctor> this_type;
 
-  this_type * const ptr = static_cast< this_type * >(
-                          static_cast< base_type * >( record_ptr ) );
+  this_type* const ptr =
+      static_cast<this_type*>(static_cast<base_type*>(record_ptr));
 
   ptr->m_destroy.destroy_shared_allocation();
 
-  delete ptr ;
+  delete ptr;
 }
 
-}
+}  // namespace
 
 /*
- *  Memory space specialization of SharedAllocationRecord< Space , void > requires :
+ *  Memory space specialization of SharedAllocationRecord< Space , void >
+ * requires :
  *
- *  SharedAllocationRecord< Space , void > : public SharedAllocationRecord< void , void >
+ *  SharedAllocationRecord< Space , void > : public SharedAllocationRecord< void
+ * , void >
  *  {
  *    // delete allocated user memory via static_cast to this type.
  *    static void deallocate( const SharedAllocationRecord<void,void> * );
  *    Space m_space ;
  *  }
  */
-template< class MemorySpace , class DestroyFunctor >
-class SharedAllocationRecord : public SharedAllocationRecord< MemorySpace , void >
-{
-private:
-
-  SharedAllocationRecord( const MemorySpace & arg_space
-                        , const std::string & arg_label
-                        , const size_t        arg_alloc
-                        )
-    /*  Allocate user memory as [ SharedAllocationHeader , user_memory ] */
-    : SharedAllocationRecord< MemorySpace , void >( arg_space , arg_label , arg_alloc , & Kokkos::Impl::deallocate< MemorySpace , DestroyFunctor > )
-    , m_destroy()
-    {}
-
-  SharedAllocationRecord() = delete ;
-  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
-  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
-
-public:
-
-  DestroyFunctor  m_destroy ;
-
-  // Allocate with a zero use count.  Incrementing the use count from zero to one
-  // inserts the record into the tracking list.  Decrementing the count from one to zero
-  // removes from the trakcing list and deallocates.
-  KOKKOS_INLINE_FUNCTION static
-  SharedAllocationRecord * allocate( const MemorySpace & arg_space
-                                   , const std::string & arg_label
-                                   , const size_t        arg_alloc
-                                   )
-    {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      return new SharedAllocationRecord( arg_space , arg_label , arg_alloc );
+template <class MemorySpace, class DestroyFunctor>
+class SharedAllocationRecord
+    : public SharedAllocationRecord<MemorySpace, void> {
+ private:
+  SharedAllocationRecord(const MemorySpace& arg_space,
+                         const std::string& arg_label, const size_t arg_alloc)
+      /*  Allocate user memory as [ SharedAllocationHeader , user_memory ] */
+      : SharedAllocationRecord<MemorySpace, void>(
+            arg_space, arg_label, arg_alloc,
+            &Kokkos::Impl::deallocate<MemorySpace, DestroyFunctor>),
+        m_destroy() {}
+
+  SharedAllocationRecord()                              = delete;
+  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
+  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
+
+ public:
+  DestroyFunctor m_destroy;
+
+  // Allocate with a zero use count.  Incrementing the use count from zero to
+  // one inserts the record into the tracking list.  Decrementing the count from
+  // one to zero removes from the trakcing list and deallocates.
+  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
+      const MemorySpace& arg_space, const std::string& arg_label,
+      const size_t arg_alloc) {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    return new SharedAllocationRecord(arg_space, arg_label, arg_alloc);
 #else
-      return (SharedAllocationRecord *) 0 ;
+    return (SharedAllocationRecord*)0;
 #endif
-    }
+  }
 };
 
-template< class MemorySpace >
-class SharedAllocationRecord<MemorySpace,void> : public SharedAllocationRecord< void , void > {};
+template <class MemorySpace>
+class SharedAllocationRecord<MemorySpace, void>
+    : public SharedAllocationRecord<void, void> {};
 
 union SharedAllocationTracker {
-private:
-
-  typedef SharedAllocationRecord<void,void>  Record ;
+ private:
+  typedef SharedAllocationRecord<void, void> Record;
 
   enum : uintptr_t { DO_NOT_DEREF_FLAG = 0x01ul };
 
   // The allocation record resides in Host memory space
-  uintptr_t m_record_bits ;
-  Record  * m_record ;
-
-public:
+  uintptr_t m_record_bits;
+  Record* m_record;
 
+ public:
   // Use macros instead of inline functions to reduce
   // pressure on compiler optimization by reducing
   // number of symbols and inline functions.
 
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
 
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED	\
-  Record::tracking_enabled()
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED Record::tracking_enabled()
 
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT	\
-  if ( ! ( m_record_bits & DO_NOT_DEREF_FLAG ) ) Record::increment( m_record );
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT \
+  if (!(m_record_bits & DO_NOT_DEREF_FLAG)) Record::increment(m_record);
 
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT	\
-  if ( ! ( m_record_bits & DO_NOT_DEREF_FLAG ) ) Record::decrement( m_record );
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT \
+  if (!(m_record_bits & DO_NOT_DEREF_FLAG)) Record::decrement(m_record);
 
 #else
 
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED  0
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED 0
 
 #define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT /* */
 
@@ -290,53 +289,50 @@ public:
 
 #endif
 
-#define KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs, override_tracking) \
-  (((!override_tracking) || (rhs.m_record_bits & DO_NOT_DEREF_FLAG) \
-    || (!KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED)) \
-  ? rhs.m_record_bits | DO_NOT_DEREF_FLAG \
-  : rhs.m_record_bits)
+#define KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs,               \
+                                                        override_tracking) \
+  (((!override_tracking) || (rhs.m_record_bits & DO_NOT_DEREF_FLAG) ||     \
+    (!KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED))                      \
+       ? rhs.m_record_bits | DO_NOT_DEREF_FLAG                             \
+       : rhs.m_record_bits)
 
   /** \brief  Assign a specialized record */
-  inline
-  void assign_allocated_record_to_uninitialized( Record * arg_record )
-    {
-      if ( arg_record ) {
-        Record::increment( m_record = arg_record );
-      }
-      else {
-        m_record_bits = DO_NOT_DEREF_FLAG ;
-      }
+  inline void assign_allocated_record_to_uninitialized(Record* arg_record) {
+    if (arg_record) {
+      Record::increment(m_record = arg_record);
+    } else {
+      m_record_bits = DO_NOT_DEREF_FLAG;
     }
+  }
 
-  template< class MemorySpace >
-  constexpr
-  SharedAllocationRecord< MemorySpace , void > *
-  get_record() const noexcept
-    {
-      return ( m_record_bits & DO_NOT_DEREF_FLAG )
-             ? (SharedAllocationRecord< MemorySpace,void>*) 0
-             : static_cast<SharedAllocationRecord<MemorySpace,void>*>(m_record);
-    }
+  template <class MemorySpace>
+  constexpr SharedAllocationRecord<MemorySpace, void>* get_record() const
+      noexcept {
+    return (m_record_bits & DO_NOT_DEREF_FLAG)
+               ? (SharedAllocationRecord<MemorySpace, void>*)0
+               : static_cast<SharedAllocationRecord<MemorySpace, void>*>(
+                     m_record);
+  }
 
-  template< class MemorySpace >
-  std::string get_label() const
-    {
-      return ( m_record_bits == DO_NOT_DEREF_FLAG )
-             ? std::string()
-             : reinterpret_cast< SharedAllocationRecord< MemorySpace , void > * >( m_record_bits & ~DO_NOT_DEREF_FLAG )->get_label()
-             ;
-    }
+  template <class MemorySpace>
+  std::string get_label() const {
+    return (m_record_bits == DO_NOT_DEREF_FLAG)
+               ? std::string()
+               : reinterpret_cast<SharedAllocationRecord<MemorySpace, void>*>(
+                     m_record_bits & ~DO_NOT_DEREF_FLAG)
+                     ->get_label();
+  }
 
   KOKKOS_INLINE_FUNCTION
-  int use_count() const
-    {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      Record * const tmp = reinterpret_cast<Record*>( m_record_bits & ~DO_NOT_DEREF_FLAG );
-      return ( tmp ? tmp->use_count() : 0 );
+  int use_count() const {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    Record* const tmp =
+        reinterpret_cast<Record*>(m_record_bits & ~DO_NOT_DEREF_FLAG);
+    return (tmp ? tmp->use_count() : 0);
 #else
-      return 0 ;
+    return 0;
 #endif
-    }
+  }
 
   KOKKOS_INLINE_FUNCTION
   bool has_record() const {
@@ -344,84 +340,75 @@ public:
   }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  void clear()
-    {
-      // If this is tracking then must decrement
-      KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
-      // Reset to default constructed value.
-      m_record_bits = DO_NOT_DEREF_FLAG ;
-    }
+  void clear() {
+    // If this is tracking then must decrement
+    KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
+    // Reset to default constructed value.
+    m_record_bits = DO_NOT_DEREF_FLAG;
+  }
 
   // Copy:
   KOKKOS_FORCEINLINE_FUNCTION
-  ~SharedAllocationTracker()
-    { KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT }
+  ~SharedAllocationTracker(){KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT}
 
-  KOKKOS_FORCEINLINE_FUNCTION
-  constexpr SharedAllocationTracker()
-    : m_record_bits( DO_NOT_DEREF_FLAG ) {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr SharedAllocationTracker()
+      : m_record_bits(DO_NOT_DEREF_FLAG) {}
 
   // Move:
 
   KOKKOS_FORCEINLINE_FUNCTION
-  SharedAllocationTracker( SharedAllocationTracker && rhs )
-    : m_record_bits( rhs.m_record_bits )
-    { rhs.m_record_bits = DO_NOT_DEREF_FLAG ; }
+  SharedAllocationTracker(SharedAllocationTracker&& rhs)
+      : m_record_bits(rhs.m_record_bits) {
+    rhs.m_record_bits = DO_NOT_DEREF_FLAG;
+  }
 
   KOKKOS_FORCEINLINE_FUNCTION
-  SharedAllocationTracker & operator = ( SharedAllocationTracker && rhs )
-    {
-      auto swap_tmp = m_record_bits;
-      m_record_bits = rhs.m_record_bits;
-      rhs.m_record_bits = swap_tmp;
-      return *this ;
-    }
+  SharedAllocationTracker& operator=(SharedAllocationTracker&& rhs) {
+    auto swap_tmp     = m_record_bits;
+    m_record_bits     = rhs.m_record_bits;
+    rhs.m_record_bits = swap_tmp;
+    return *this;
+  }
 
   // Copy:
 
   KOKKOS_FORCEINLINE_FUNCTION
-  SharedAllocationTracker( const SharedAllocationTracker & rhs )
-    : m_record_bits( KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs, true) )
-    {
-      KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
-    }
-
-  /** \brief  Copy construction may disable tracking. */
-  KOKKOS_FORCEINLINE_FUNCTION
-  SharedAllocationTracker( const SharedAllocationTracker & rhs
-                         , const bool enable_tracking )
-    : m_record_bits( KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs, enable_tracking) )
-    { KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT }
-
-  KOKKOS_FORCEINLINE_FUNCTION
-  SharedAllocationTracker & operator = ( const SharedAllocationTracker & rhs )
-    {
-      // If this is tracking then must decrement
-      KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
-      m_record_bits = KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs, true);
-      KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
-      return *this ;
-    }
+  SharedAllocationTracker(const SharedAllocationTracker& rhs)
+      : m_record_bits(KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(
+            rhs, true)){KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT}
+
+        /** \brief  Copy construction may disable tracking. */
+        KOKKOS_FORCEINLINE_FUNCTION SharedAllocationTracker(
+            const SharedAllocationTracker& rhs, const bool enable_tracking)
+      : m_record_bits(KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(
+            rhs,
+            enable_tracking)){KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT}
+
+        KOKKOS_FORCEINLINE_FUNCTION SharedAllocationTracker
+        &
+        operator=(const SharedAllocationTracker& rhs) {
+    // If this is tracking then must decrement
+    KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
+    m_record_bits = KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs, true);
+    KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
+    return *this;
+  }
 
   /** \brief  Copy assignment may disable tracking */
   KOKKOS_FORCEINLINE_FUNCTION
-  void assign( const SharedAllocationTracker & rhs
-             , const bool enable_tracking )
-    {
-      KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
-      m_record_bits = KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs, enable_tracking);
-      KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
-    }
+  void assign(const SharedAllocationTracker& rhs, const bool enable_tracking) {
+    KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
+    m_record_bits =
+        KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs, enable_tracking);
+    KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
+  }
 
 #undef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_ENABLED
 #undef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
 #undef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
-
 };
 
-
 } /* namespace Impl */
 } /* namespace Kokkos */
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_SimpleTaskScheduler.hpp b/lib/kokkos/core/src/impl/Kokkos_SimpleTaskScheduler.hpp
index c2dbc968146fe93ad6642b0eec81b92ebf97304b..f01bdce17b5f5feee9056ec8410d30cfa2689bb3 100644
--- a/lib/kokkos/core/src/impl/Kokkos_SimpleTaskScheduler.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_SimpleTaskScheduler.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 //----------------------------------------------------------------------------
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core_fwd.hpp>
 #include <Kokkos_TaskScheduler_fwd.hpp>
@@ -77,135 +78,120 @@ template <class T>
 struct DefaultDestroy {
   T* managed_object;
   KOKKOS_FUNCTION
-  void destroy_shared_allocation() {
-    managed_object->~T();
-  }
+  void destroy_shared_allocation() { managed_object->~T(); }
 };
 
-
 template <class ExecutionSpace>
 class ExecutionSpaceInstanceStorage
-  : private NoUniqueAddressMemberEmulation<ExecutionSpace, DefaultCtorNotOnDevice>
-{
-private:
-
-  using base_t = NoUniqueAddressMemberEmulation<ExecutionSpace, DefaultCtorNotOnDevice>;
+    : private NoUniqueAddressMemberEmulation<ExecutionSpace,
+                                             DefaultCtorNotOnDevice> {
+ private:
+  using base_t =
+      NoUniqueAddressMemberEmulation<ExecutionSpace, DefaultCtorNotOnDevice>;
 
-protected:
-
-  constexpr explicit
-  ExecutionSpaceInstanceStorage()
-    : base_t()
-  { }
+ protected:
+  constexpr explicit ExecutionSpaceInstanceStorage() : base_t() {}
 
   KOKKOS_INLINE_FUNCTION
-  constexpr explicit
-  ExecutionSpaceInstanceStorage(ExecutionSpace const& arg_execution_space)
-    : base_t(arg_execution_space)
-  { }
+  constexpr explicit ExecutionSpaceInstanceStorage(
+      ExecutionSpace const& arg_execution_space)
+      : base_t(arg_execution_space) {}
 
   KOKKOS_INLINE_FUNCTION
-  constexpr explicit
-  ExecutionSpaceInstanceStorage(ExecutionSpace&& arg_execution_space)
-    : base_t(std::move(arg_execution_space))
-  { }
+  constexpr explicit ExecutionSpaceInstanceStorage(
+      ExecutionSpace&& arg_execution_space)
+      : base_t(std::move(arg_execution_space)) {}
 
   KOKKOS_INLINE_FUNCTION
-  ExecutionSpace& execution_space_instance() &
-  {
+  ExecutionSpace& execution_space_instance() & {
     return this->no_unique_address_data_member();
   }
 
   KOKKOS_INLINE_FUNCTION
-  ExecutionSpace const& execution_space_instance() const &
-  {
+  ExecutionSpace const& execution_space_instance() const& {
     return this->no_unique_address_data_member();
   }
 
   KOKKOS_INLINE_FUNCTION
-  ExecutionSpace&& execution_space_instance() &&
-  {
+  ExecutionSpace&& execution_space_instance() && {
     return std::move(*this).no_unique_address_data_member();
   }
 };
 
-
 template <class MemorySpace>
 class MemorySpaceInstanceStorage
-  : private NoUniqueAddressMemberEmulation<MemorySpace, DefaultCtorNotOnDevice>
-{
-private:
+    : private NoUniqueAddressMemberEmulation<MemorySpace,
+                                             DefaultCtorNotOnDevice> {
+ private:
+  using base_t =
+      NoUniqueAddressMemberEmulation<MemorySpace, DefaultCtorNotOnDevice>;
 
-  using base_t = NoUniqueAddressMemberEmulation<MemorySpace, DefaultCtorNotOnDevice>;
-
-protected:
-
-  MemorySpaceInstanceStorage()
-    : base_t()
-  { }
+ protected:
+  MemorySpaceInstanceStorage() : base_t() {}
 
   KOKKOS_INLINE_FUNCTION
   MemorySpaceInstanceStorage(MemorySpace const& arg_memory_space)
-    : base_t(arg_memory_space)
-  { }
+      : base_t(arg_memory_space) {}
 
   KOKKOS_INLINE_FUNCTION
-  constexpr explicit
-  MemorySpaceInstanceStorage(MemorySpace&& arg_memory_space)
-    : base_t(arg_memory_space)
-  { }
+  constexpr explicit MemorySpaceInstanceStorage(MemorySpace&& arg_memory_space)
+      : base_t(arg_memory_space) {}
 
   KOKKOS_INLINE_FUNCTION
-  MemorySpace& memory_space_instance() &
-  {
+  MemorySpace& memory_space_instance() & {
     return this->no_unique_address_data_member();
   }
 
   KOKKOS_INLINE_FUNCTION
-  MemorySpace const& memory_space_instance() const &
-  {
+  MemorySpace const& memory_space_instance() const& {
     return this->no_unique_address_data_member();
   }
 
   KOKKOS_INLINE_FUNCTION
-  MemorySpace&& memory_space_instance() &&
-  {
+  MemorySpace&& memory_space_instance() && {
     return std::move(*this).no_unique_address_data_member();
   }
 };
 
-} // end namespace Impl
+}  // end namespace Impl
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 template <class ExecSpace, class QueueType>
-  // requires ExecutionSpace<ExecSpace> && TaskQueue<QueueType>
+// requires ExecutionSpace<ExecSpace> && TaskQueue<QueueType>
 class SimpleTaskScheduler
-  : public Impl::TaskSchedulerBase,
-    private Impl::ExecutionSpaceInstanceStorage<ExecSpace>,
-    private Impl::MemorySpaceInstanceStorage<typename QueueType::memory_space>,
-    private Impl::NoUniqueAddressMemberEmulation<typename QueueType::team_scheduler_info_type>
-{
-public:
-  // TODO @tasking @generalization (maybe?) don't force QueueType to be complete here
-
-  using scheduler_type = SimpleTaskScheduler; // tag as scheduler concept
+    : public Impl::TaskSchedulerBase,
+      private Impl::ExecutionSpaceInstanceStorage<ExecSpace>,
+      private Impl::MemorySpaceInstanceStorage<
+          typename QueueType::memory_space>,
+      private Impl::NoUniqueAddressMemberEmulation<
+          typename QueueType::team_scheduler_info_type> {
+ public:
+  // TODO @tasking @generalization (maybe?) don't force QueueType to be complete
+  // here
+
+  using scheduler_type  = SimpleTaskScheduler;  // tag as scheduler concept
   using execution_space = ExecSpace;
   using task_queue_type = QueueType;
-  using memory_space = typename task_queue_type::memory_space;
-  using memory_pool = typename task_queue_type::memory_pool;
+  using memory_space    = typename task_queue_type::memory_space;
+  using memory_pool     = typename task_queue_type::memory_pool;
 
-  using team_scheduler_info_type = typename task_queue_type::team_scheduler_info_type;
-  using task_scheduling_info_type = typename task_queue_type::task_scheduling_info_type;
+  using team_scheduler_info_type =
+      typename task_queue_type::team_scheduler_info_type;
+  using task_scheduling_info_type =
+      typename task_queue_type::task_scheduling_info_type;
   using specialization = Impl::TaskQueueSpecialization<SimpleTaskScheduler>;
-  using member_type = typename specialization::member_type;
+  using member_type    = typename specialization::member_type;
 
   template <class Functor>
-  using runnable_task_type = typename QueueType::template runnable_task_type<Functor, SimpleTaskScheduler>;
+  using runnable_task_type =
+      typename QueueType::template runnable_task_type<Functor,
+                                                      SimpleTaskScheduler>;
 
   using task_base_type = typename task_queue_type::task_base_type;
-  using runnable_task_base_type = typename task_queue_type::runnable_task_base_type;
+  using runnable_task_base_type =
+      typename task_queue_type::runnable_task_base_type;
 
   using task_queue_traits = typename QueueType::task_queue_traits;
 
@@ -214,268 +200,228 @@ public:
   template <class FunctorType>
   using future_type_for_functor = future_type<typename FunctorType::value_type>;
 
-private:
-
+ private:
   template <typename, typename>
   friend class BasicFuture;
 
   using track_type = Kokkos::Impl::SharedAllocationTracker;
-  using execution_space_storage = Impl::ExecutionSpaceInstanceStorage<execution_space>;
+  using execution_space_storage =
+      Impl::ExecutionSpaceInstanceStorage<execution_space>;
   using memory_space_storage = Impl::MemorySpaceInstanceStorage<memory_space>;
-  using team_scheduler_info_storage = Impl::NoUniqueAddressMemberEmulation<team_scheduler_info_type>;
+  using team_scheduler_info_storage =
+      Impl::NoUniqueAddressMemberEmulation<team_scheduler_info_type>;
 
   track_type m_track;
   task_queue_type* m_queue = nullptr;
 
   KOKKOS_INLINE_FUNCTION
-  static constexpr task_base_type* _get_task_ptr(std::nullptr_t) { return nullptr; }
+  static constexpr task_base_type* _get_task_ptr(std::nullptr_t) {
+    return nullptr;
+  }
 
   template <class ValueType>
-  KOKKOS_INLINE_FUNCTION
-  static constexpr task_base_type* _get_task_ptr(future_type<ValueType>&& f)
-  {
+  KOKKOS_INLINE_FUNCTION static constexpr task_base_type* _get_task_ptr(
+      future_type<ValueType>&& f) {
     return f.m_task;
   }
 
-  template <
-    int TaskEnum,
-    class DepTaskType,
-    class FunctorType
-  >
+  template <int TaskEnum, class DepTaskType, class FunctorType>
   KOKKOS_FUNCTION
-  future_type_for_functor<typename std::decay<FunctorType>::type>
-  _spawn_impl(
-    DepTaskType arg_predecessor_task,
-    TaskPriority arg_priority,
-    typename runnable_task_base_type::function_type apply_function_ptr,
-    typename runnable_task_base_type::destroy_type destroy_function_ptr,
-    FunctorType&& functor
-  )
-  {
+      future_type_for_functor<typename std::decay<FunctorType>::type>
+      _spawn_impl(
+          DepTaskType arg_predecessor_task, TaskPriority arg_priority,
+          typename runnable_task_base_type::function_type apply_function_ptr,
+          typename runnable_task_base_type::destroy_type destroy_function_ptr,
+          FunctorType&& functor) {
     KOKKOS_EXPECTS(m_queue != nullptr);
 
-    using functor_future_type = future_type_for_functor<typename std::decay<FunctorType>::type>;
-    using task_type = typename task_queue_type::template runnable_task_type<
-      FunctorType, scheduler_type
-    >;
+    using functor_future_type =
+        future_type_for_functor<typename std::decay<FunctorType>::type>;
+    using task_type =
+        typename task_queue_type::template runnable_task_type<FunctorType,
+                                                              scheduler_type>;
 
     // Reference count starts at two:
     //   +1 for the matching decrement when task is complete
     //   +1 for the future
     auto& runnable_task = *m_queue->template allocate_and_construct<task_type>(
-      /* functor = */ std::forward<FunctorType>(functor),
-      /* apply_function_ptr = */ apply_function_ptr,
-      /* task_type = */ static_cast<Impl::TaskType>(TaskEnum),
-      /* priority = */ arg_priority,
-      /* queue_base = */ m_queue,
-      /* initial_reference_count = */ 2
-    );
-
-    if(arg_predecessor_task != nullptr) {
+        /* functor = */ std::forward<FunctorType>(functor),
+        /* apply_function_ptr = */ apply_function_ptr,
+        /* task_type = */ static_cast<Impl::TaskType>(TaskEnum),
+        /* priority = */ arg_priority,
+        /* queue_base = */ m_queue,
+        /* initial_reference_count = */ 2);
+
+    if (arg_predecessor_task != nullptr) {
       m_queue->initialize_scheduling_info_from_predecessor(
-        runnable_task, *arg_predecessor_task
-      );
+          runnable_task, *arg_predecessor_task);
       runnable_task.set_predecessor(*arg_predecessor_task);
       arg_predecessor_task->decrement_and_check_reference_count();
-    }
-    else {
+    } else {
       m_queue->initialize_scheduling_info_from_team_scheduler_info(
-        runnable_task, team_scheduler_info()
-      );
+          runnable_task, team_scheduler_info());
     }
 
     auto rv = functor_future_type(&runnable_task);
 
-    Kokkos::memory_fence(); // fence to ensure dependent stores are visible
+    Kokkos::memory_fence();  // fence to ensure dependent stores are visible
 
-    m_queue->schedule_runnable(
-      std::move(runnable_task),
-      team_scheduler_info()
-    );
-    // note that task may be already completed even here, so don't touch it again
+    m_queue->schedule_runnable(std::move(runnable_task), team_scheduler_info());
+    // note that task may be already completed even here, so don't touch it
+    // again
 
     return rv;
   }
 
-
-public:
-
+ public:
   //----------------------------------------------------------------------------
   // <editor-fold desc="Constructors, destructor, and assignment"> {{{2
 
   SimpleTaskScheduler() = default;
 
-  explicit
-  SimpleTaskScheduler(
-    execution_space const& arg_execution_space,
-    memory_space const& arg_memory_space,
-    memory_pool const& arg_memory_pool
-  ) : execution_space_storage(arg_execution_space),
-      memory_space_storage(arg_memory_space)
-  {
+  explicit SimpleTaskScheduler(execution_space const& arg_execution_space,
+                               memory_space const& arg_memory_space,
+                               memory_pool const& arg_memory_pool)
+      : execution_space_storage(arg_execution_space),
+        memory_space_storage(arg_memory_space) {
     // Ask the task queue how much space it needs (usually will just be
     // sizeof(task_queue_type), but some queues may need additional storage
     // dependent on runtime conditions or properties of the execution space)
     auto const allocation_size = task_queue_type::task_queue_allocation_size(
-      arg_execution_space,
-      arg_memory_space,
-      arg_memory_pool
-    );
+        arg_execution_space, arg_memory_space, arg_memory_pool);
 
-    // TODO @tasking @generalization DSH better encapsulation of the SharedAllocationRecord pattern
-    using record_type = Impl::SharedAllocationRecord<
-      memory_space, Impl::DefaultDestroy<task_queue_type>
-    >;
+    // TODO @tasking @generalization DSH better encapsulation of the
+    // SharedAllocationRecord pattern
+    using record_type =
+        Impl::SharedAllocationRecord<memory_space,
+                                     Impl::DefaultDestroy<task_queue_type> >;
 
     // Allocate space for the task queue
-    auto* record = record_type::allocate(
-      memory_space(), "TaskQueue", allocation_size
-    );
-    m_queue = new (record->data()) task_queue_type(
-      arg_execution_space,
-      arg_memory_space,
-      arg_memory_pool
-    );
+    auto* record =
+        record_type::allocate(memory_space(), "TaskQueue", allocation_size);
+    m_queue = new (record->data())
+        task_queue_type(arg_execution_space, arg_memory_space, arg_memory_pool);
     record->m_destroy.managed_object = m_queue;
     m_track.assign_allocated_record_to_uninitialized(record);
   }
 
-  explicit
-  SimpleTaskScheduler(
-    execution_space const& arg_execution_space,
-    memory_pool const& pool
-  ) : SimpleTaskScheduler(arg_execution_space, memory_space{}, pool)
-  { /* forwarding ctor, must be empty */ }
-
-  explicit
-  SimpleTaskScheduler(memory_pool const& pool)
-    : SimpleTaskScheduler(execution_space{}, memory_space{}, pool)
-  { /* forwarding ctor, must be empty */ }
-
-  SimpleTaskScheduler(
-    memory_space const & arg_memory_space,
-    size_t const mempool_capacity,
-    unsigned const mempool_min_block_size, // = 1u << 6
-    unsigned const mempool_max_block_size, // = 1u << 10
-    unsigned const mempool_superblock_size // = 1u << 12
-  ) : SimpleTaskScheduler(
-        execution_space{},
-        arg_memory_space,
-        memory_pool(
-          arg_memory_space, mempool_capacity, mempool_min_block_size,
-          mempool_max_block_size, mempool_superblock_size
-        )
-      )
-  { /* forwarding ctor, must be empty */ }
+  explicit SimpleTaskScheduler(execution_space const& arg_execution_space,
+                               memory_pool const& pool)
+      : SimpleTaskScheduler(arg_execution_space, memory_space{},
+                            pool) { /* forwarding ctor, must be empty */
+  }
+
+  explicit SimpleTaskScheduler(memory_pool const& pool)
+      : SimpleTaskScheduler(execution_space{}, memory_space{},
+                            pool) { /* forwarding ctor, must be empty */
+  }
+
+  SimpleTaskScheduler(memory_space const& arg_memory_space,
+                      size_t const mempool_capacity,
+                      unsigned const mempool_min_block_size,  // = 1u << 6
+                      unsigned const mempool_max_block_size,  // = 1u << 10
+                      unsigned const mempool_superblock_size  // = 1u << 12
+                      )
+      : SimpleTaskScheduler(
+            execution_space{}, arg_memory_space,
+            memory_pool(
+                arg_memory_space, mempool_capacity, mempool_min_block_size,
+                mempool_max_block_size,
+                mempool_superblock_size)) { /* forwarding ctor, must be empty */
+  }
 
   // </editor-fold> end Constructors, destructor, and assignment }}}2
   //----------------------------------------------------------------------------
 
   // Note that this is an expression of shallow constness
   KOKKOS_INLINE_FUNCTION
-  task_queue_type& queue() const
-  {
+  task_queue_type& queue() const {
     KOKKOS_EXPECTS(m_queue != nullptr);
     return *m_queue;
   }
 
   KOKKOS_INLINE_FUNCTION
-  SimpleTaskScheduler
-  get_team_scheduler(int rank_in_league) const noexcept
-  {
+  SimpleTaskScheduler get_team_scheduler(int rank_in_league) const noexcept {
     KOKKOS_EXPECTS(m_queue != nullptr);
-    auto rv = SimpleTaskScheduler{ *this };
-    rv.team_scheduler_info() = m_queue->initial_team_scheduler_info(rank_in_league);
+    auto rv = SimpleTaskScheduler{*this};
+    rv.team_scheduler_info() =
+        m_queue->initial_team_scheduler_info(rank_in_league);
     return rv;
   }
 
   KOKKOS_INLINE_FUNCTION
-  execution_space const& get_execution_space() const { return this->execution_space_instance(); }
+  execution_space const& get_execution_space() const {
+    return this->execution_space_instance();
+  }
 
   KOKKOS_INLINE_FUNCTION
-  team_scheduler_info_type& team_scheduler_info() &
-  {
+  team_scheduler_info_type& team_scheduler_info() & {
     return this->team_scheduler_info_storage::no_unique_address_data_member();
   }
 
   KOKKOS_INLINE_FUNCTION
-  team_scheduler_info_type const& team_scheduler_info() const &
-  {
+  team_scheduler_info_type const& team_scheduler_info() const& {
     return this->team_scheduler_info_storage::no_unique_address_data_member();
   }
 
   //----------------------------------------------------------------------------
 
-  #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   // For backwards compatibility purposes only
   KOKKOS_DEPRECATED
   KOKKOS_INLINE_FUNCTION
-  memory_pool*
-  memory() const noexcept KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE
-  {
-    if(m_queue != nullptr) return &(m_queue->get_memory_pool());
-    else return nullptr;
+  memory_pool* memory() const noexcept KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE {
+    if (m_queue != nullptr)
+      return &(m_queue->get_memory_pool());
+    else
+      return nullptr;
   }
-  #endif
+#endif
 
   //----------------------------------------------------------------------------
 
   template <int TaskEnum, typename DepFutureType, typename FunctorType>
-  KOKKOS_FUNCTION
-  static
-  Kokkos::BasicFuture<typename FunctorType::value_type, scheduler_type>
-  spawn(
-    Impl::TaskPolicyWithScheduler<TaskEnum, scheduler_type, DepFutureType>&& arg_policy,
-    typename runnable_task_base_type::function_type arg_function,
-    typename runnable_task_base_type::destroy_type arg_destroy,
-    FunctorType&& arg_functor
-  )
-  {
-    return std::move(arg_policy.scheduler()).template _spawn_impl<TaskEnum>(
-      _get_task_ptr(std::move(arg_policy.predecessor())),
-      arg_policy.priority(),
-      arg_function,
-      arg_destroy,
-      std::forward<FunctorType>(arg_functor)
-    );
+  KOKKOS_FUNCTION static Kokkos::BasicFuture<typename FunctorType::value_type,
+                                             scheduler_type>
+  spawn(Impl::TaskPolicyWithScheduler<TaskEnum, scheduler_type, DepFutureType>&&
+            arg_policy,
+        typename runnable_task_base_type::function_type arg_function,
+        typename runnable_task_base_type::destroy_type arg_destroy,
+        FunctorType&& arg_functor) {
+    return std::move(arg_policy.scheduler())
+        .template _spawn_impl<TaskEnum>(
+            _get_task_ptr(std::move(arg_policy.predecessor())),
+            arg_policy.priority(), arg_function, arg_destroy,
+            std::forward<FunctorType>(arg_functor));
   }
 
   template <int TaskEnum, typename DepFutureType, typename FunctorType>
-  KOKKOS_FUNCTION
-  Kokkos::BasicFuture<typename FunctorType::value_type, scheduler_type>
-  spawn(
-    Impl::TaskPolicyWithPredecessor<TaskEnum, DepFutureType>&& arg_policy,
-    FunctorType&& arg_functor
-  )
-  {
-    static_assert(
-      std::is_same<typename DepFutureType::scheduler_type, scheduler_type>::value,
-      "Can't create a task policy from a scheduler and a future from a different scheduler"
-    );
+  KOKKOS_FUNCTION Kokkos::BasicFuture<typename FunctorType::value_type,
+                                      scheduler_type>
+  spawn(Impl::TaskPolicyWithPredecessor<TaskEnum, DepFutureType>&& arg_policy,
+        FunctorType&& arg_functor) {
+    static_assert(std::is_same<typename DepFutureType::scheduler_type,
+                               scheduler_type>::value,
+                  "Can't create a task policy from a scheduler and a future "
+                  "from a different scheduler");
 
     using task_type = runnable_task_type<FunctorType>;
     typename task_type::function_type const ptr = task_type::apply;
     typename task_type::destroy_type const dtor = task_type::destroy;
 
-    return _spawn_impl<TaskEnum>(
-      std::move(arg_policy).predecessor().m_task,
-      arg_policy.priority(),
-      ptr, dtor,
-      std::forward<FunctorType>(arg_functor)
-    );
+    return _spawn_impl<TaskEnum>(std::move(arg_policy).predecessor().m_task,
+                                 arg_policy.priority(), ptr, dtor,
+                                 std::forward<FunctorType>(arg_functor));
   }
 
   template <class FunctorType, class ValueType, class Scheduler>
-  KOKKOS_FUNCTION
-  static void
-  respawn(
-    FunctorType* functor,
-    BasicFuture<ValueType, Scheduler> const& predecessor,
-    TaskPriority priority = TaskPriority::Regular
-  ) {
-    using task_type = typename task_queue_type::template runnable_task_type<
-      FunctorType, scheduler_type
-    >;
+  KOKKOS_FUNCTION static void respawn(
+      FunctorType* functor,
+      BasicFuture<ValueType, Scheduler> const& predecessor,
+      TaskPriority priority = TaskPriority::Regular) {
+    using task_type =
+        typename task_queue_type::template runnable_task_type<FunctorType,
+                                                              scheduler_type>;
 
     auto& task = *static_cast<task_type*>(functor);
 
@@ -487,16 +433,12 @@ public:
   }
 
   template <class FunctorType>
-  KOKKOS_FUNCTION
-  static void
-  respawn(
-    FunctorType* functor,
-    scheduler_type const&,
-    TaskPriority priority = TaskPriority::Regular
-  ) {
-    using task_type = typename task_queue_type::template runnable_task_type<
-      FunctorType, scheduler_type
-    >;
+  KOKKOS_FUNCTION static void respawn(
+      FunctorType* functor, scheduler_type const&,
+      TaskPriority priority = TaskPriority::Regular) {
+    using task_type =
+        typename task_queue_type::template runnable_task_type<FunctorType,
+                                                              scheduler_type>;
 
     auto& task = *static_cast<task_type*>(functor);
 
@@ -507,64 +449,67 @@ public:
     task.set_respawn_flag(true);
   }
 
-
   template <class ValueType>
-  KOKKOS_FUNCTION
-  future_type<void>
-  when_all(BasicFuture<ValueType, scheduler_type> const predecessors[], int n_predecessors) {
-
+  KOKKOS_FUNCTION future_type<void> when_all(
+      BasicFuture<ValueType, scheduler_type> const predecessors[],
+      int n_predecessors) {
     // TODO @tasking @generalization DSH propagate scheduling info
 
     using task_type = typename task_queue_type::aggregate_task_type;
 
     future_type<void> rv;
 
-    if(n_predecessors > 0) {
+    if (n_predecessors > 0) {
       task_queue_type* queue_ptr = nullptr;
 
-      // Loop over the predecessors to find the queue and increment the reference
-      // counts
-      for(int i_pred = 0; i_pred < n_predecessors; ++i_pred) {
-
+      // Loop over the predecessors to find the queue and increment the
+      // reference counts
+      for (int i_pred = 0; i_pred < n_predecessors; ++i_pred) {
         auto* predecessor_task_ptr = predecessors[i_pred].m_task;
 
-        if(predecessor_task_ptr != nullptr) {
-          // TODO @tasking @cleanup DSH figure out when this is allowed to be nullptr (if at all anymore)
+        if (predecessor_task_ptr != nullptr) {
+          // TODO @tasking @cleanup DSH figure out when this is allowed to be
+          // nullptr (if at all anymore)
 
           // Increment reference count to track subsequent assignment.
-          // TODO @tasking @optimization DSH figure out if this reference count increment is necessary
+          // TODO @tasking @optimization DSH figure out if this reference count
+          // increment is necessary
           predecessor_task_ptr->increment_reference_count();
 
-          // TODO @tasking @cleanup DSH we should just set a boolean here instead to make this more readable
+          // TODO @tasking @cleanup DSH we should just set a boolean here
+          // instead to make this more readable
           queue_ptr = m_queue;
         }
 
-      } // end loop over predecessors
+      }  // end loop over predecessors
 
-      // This only represents a non-ready future if at least one of the predecessors
-      // has a task (and thus, a queue)
-      if(queue_ptr != nullptr) {
+      // This only represents a non-ready future if at least one of the
+      // predecessors has a task (and thus, a queue)
+      if (queue_ptr != nullptr) {
         auto& q = *queue_ptr;
 
-        auto* aggregate_task_ptr = q.template allocate_and_construct_with_vla_emulation<
-          task_type, task_base_type*
-        >(
-          /* n_vla_entries = */ n_predecessors,
-          /* aggregate_predecessor_count = */ n_predecessors,
-          /* queue_base = */ &q,
-          /* initial_reference_count = */ 2
-        );
+        auto* aggregate_task_ptr =
+            q.template allocate_and_construct_with_vla_emulation<
+                task_type, task_base_type*>(
+                /* n_vla_entries = */ n_predecessors,
+                /* aggregate_predecessor_count = */ n_predecessors,
+                /* queue_base = */ &q,
+                /* initial_reference_count = */ 2);
 
         rv = future_type<void>(aggregate_task_ptr);
 
-        for(int i_pred = 0; i_pred < n_predecessors; ++i_pred) {
-          aggregate_task_ptr->vla_value_at(i_pred) = predecessors[i_pred].m_task;
+        for (int i_pred = 0; i_pred < n_predecessors; ++i_pred) {
+          aggregate_task_ptr->vla_value_at(i_pred) =
+              predecessors[i_pred].m_task;
         }
 
-        Kokkos::memory_fence(); // we're touching very questionable memory, so be sure to fence
+        Kokkos::memory_fence();  // we're touching very questionable memory, so
+                                 // be sure to fence
 
-        q.schedule_aggregate(std::move(*aggregate_task_ptr), team_scheduler_info());
-        // the aggregate may be processed at any time, so don't touch it after this
+        q.schedule_aggregate(std::move(*aggregate_task_ptr),
+                             team_scheduler_info());
+        // the aggregate may be processed at any time, so don't touch it after
+        // this
       }
     }
 
@@ -572,75 +517,66 @@ public:
   }
 
   template <class F>
-  KOKKOS_FUNCTION
-  future_type<void>
-  when_all(int n_calls, F&& func)
-  {
+  KOKKOS_FUNCTION future_type<void> when_all(int n_calls, F&& func) {
     // TODO @tasking @generalization DSH propagate scheduling info?
 
     // later this should be std::invoke_result_t
     using generated_type = decltype(func(0));
-    using task_type = typename task_queue_type::aggregate_task_type;
+    using task_type      = typename task_queue_type::aggregate_task_type;
 
+    static_assert(is_future<generated_type>::value,
+                  "when_all function must return a Kokkos future (an instance "
+                  "of Kokkos::BasicFuture)");
     static_assert(
-      is_future<generated_type>::value,
-      "when_all function must return a Kokkos future (an instance of Kokkos::BasicFuture)"
-    );
-    static_assert(
-      std::is_base_of<scheduler_type, typename generated_type::scheduler_type>::value,
-      "when_all function must return a Kokkos::BasicFuture of a compatible scheduler type"
-    );
-
-    auto* aggregate_task = m_queue->template allocate_and_construct_with_vla_emulation<
-      task_type, task_base_type*
-    >(
-      /* n_vla_entries = */ n_calls,
-      /* aggregate_predecessor_count = */ n_calls,
-      /* queue_base = */ m_queue,
-      /* initial_reference_count = */ 2
-    );
+        std::is_base_of<scheduler_type,
+                        typename generated_type::scheduler_type>::value,
+        "when_all function must return a Kokkos::BasicFuture of a compatible "
+        "scheduler type");
+
+    auto* aggregate_task =
+        m_queue->template allocate_and_construct_with_vla_emulation<
+            task_type, task_base_type*>(
+            /* n_vla_entries = */ n_calls,
+            /* aggregate_predecessor_count = */ n_calls,
+            /* queue_base = */ m_queue,
+            /* initial_reference_count = */ 2);
 
     auto rv = future_type<void>(aggregate_task);
 
-    for(int i_call = 0; i_call < n_calls; ++i_call) {
-
+    for (int i_call = 0; i_call < n_calls; ++i_call) {
       auto generated_future = func(i_call);
 
-      if(generated_future.m_task != nullptr) {
+      if (generated_future.m_task != nullptr) {
         generated_future.m_task->increment_reference_count();
         aggregate_task->vla_value_at(i_call) = generated_future.m_task;
 
-        KOKKOS_ASSERT(m_queue == generated_future.m_task->ready_queue_base_ptr()
-          && "Queue mismatch in when_all"
-        );
+        KOKKOS_ASSERT(m_queue ==
+                          generated_future.m_task->ready_queue_base_ptr() &&
+                      "Queue mismatch in when_all");
       }
-
     }
 
     Kokkos::memory_fence();
 
-    m_queue->schedule_aggregate(std::move(*aggregate_task), team_scheduler_info());
+    m_queue->schedule_aggregate(std::move(*aggregate_task),
+                                team_scheduler_info());
     // This could complete at any moment, so don't touch anything after this
 
     return rv;
   }
-
 };
 
-
-template<class ExecSpace, class QueueType>
-inline
-void wait(SimpleTaskScheduler<ExecSpace, QueueType> const& scheduler)
-{
+template <class ExecSpace, class QueueType>
+inline void wait(SimpleTaskScheduler<ExecSpace, QueueType> const& scheduler) {
   using scheduler_type = SimpleTaskScheduler<ExecSpace, QueueType>;
   scheduler_type::specialization::execute(scheduler);
 }
 
-} // namespace Kokkos
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
-//---------------------------------------------------------------------------#endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
+//---------------------------------------------------------------------------#endif
+///* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_SIMPLETASKSCHEDULER_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_SingleTaskQueue.hpp b/lib/kokkos/core/src/impl/Kokkos_SingleTaskQueue.hpp
index d73028eb5b9da77a3a3cc46c6f327327299d1239..8c149e978f7985fce3b59800c32aa4bbe6645993 100644
--- a/lib/kokkos/core/src/impl/Kokkos_SingleTaskQueue.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_SingleTaskQueue.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,8 +46,7 @@
 #define KOKKOS_IMPL_SINGLETASKQUEUE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
-
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -67,7 +67,6 @@
 #include <typeinfo>
 #include <stdexcept>
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
@@ -77,73 +76,63 @@ namespace Impl {
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template <
-  class ExecSpace,
-  class MemorySpace,
-  class TaskQueueTraits,
-  class MemoryPool
->
+template <class ExecSpace, class MemorySpace, class TaskQueueTraits,
+          class MemoryPool>
 class SingleTaskQueue
-  : public TaskQueueMemoryManager<ExecSpace, MemorySpace, MemoryPool>,
-    public TaskQueueCommonMixin<SingleTaskQueue<ExecSpace, MemorySpace, TaskQueueTraits, MemoryPool>>
-{
-private:
-
+    : public TaskQueueMemoryManager<ExecSpace, MemorySpace, MemoryPool>,
+      public TaskQueueCommonMixin<SingleTaskQueue<
+          ExecSpace, MemorySpace, TaskQueueTraits, MemoryPool>> {
+ private:
   using base_t = TaskQueueMemoryManager<ExecSpace, MemorySpace, MemoryPool>;
   using common_mixin_t = TaskQueueCommonMixin<SingleTaskQueue>;
 
-  struct EmptyTeamSchedulerInfo { };
-  struct EmptyTaskSchedulingInfo { };
+  struct EmptyTeamSchedulerInfo {};
+  struct EmptyTaskSchedulingInfo {};
 
-public:
-
-  using task_queue_type = SingleTaskQueue; // mark as task_queue concept
+ public:
+  using task_queue_type   = SingleTaskQueue;  // mark as task_queue concept
   using task_queue_traits = TaskQueueTraits;
-  using task_base_type = TaskNode<TaskQueueTraits>;
-  using ready_queue_type = typename TaskQueueTraits::template ready_queue_type<task_base_type>;
+  using task_base_type    = TaskNode<TaskQueueTraits>;
+  using ready_queue_type =
+      typename TaskQueueTraits::template ready_queue_type<task_base_type>;
 
-  using team_scheduler_info_type = EmptyTeamSchedulerInfo;
+  using team_scheduler_info_type  = EmptyTeamSchedulerInfo;
   using task_scheduling_info_type = EmptyTaskSchedulingInfo;
 
   using runnable_task_base_type = RunnableTaskBase<TaskQueueTraits>;
 
   template <class Functor, class Scheduler>
-    // requires TaskScheduler<Scheduler> && TaskFunctor<Functor>
-  using runnable_task_type = RunnableTask<
-    task_queue_traits, Scheduler, typename Functor::value_type, Functor
-  >;
+  // requires TaskScheduler<Scheduler> && TaskFunctor<Functor>
+  using runnable_task_type =
+      RunnableTask<task_queue_traits, Scheduler, typename Functor::value_type,
+                   Functor>;
 
-  using aggregate_task_type = AggregateTask<task_queue_traits, task_scheduling_info_type>;
+  using aggregate_task_type =
+      AggregateTask<task_queue_traits, task_scheduling_info_type>;
 
   // Number of allowed priorities
   static constexpr int NumQueue = 3;
 
-private:
-
+ private:
   ready_queue_type m_ready_queues[NumQueue][2];
 
-public:
-
+ public:
   //----------------------------------------------------------------------------
   // <editor-fold desc="Constructors, destructors, and assignment"> {{{2
 
-  SingleTaskQueue() = delete;
+  SingleTaskQueue()                       = delete;
   SingleTaskQueue(SingleTaskQueue const&) = delete;
-  SingleTaskQueue(SingleTaskQueue&&) = delete;
+  SingleTaskQueue(SingleTaskQueue&&)      = delete;
   SingleTaskQueue& operator=(SingleTaskQueue const&) = delete;
   SingleTaskQueue& operator=(SingleTaskQueue&&) = delete;
 
-  explicit
-  SingleTaskQueue(
-    typename base_t::execution_space const&,
-    typename base_t::memory_space const&,
-    typename base_t::memory_pool const& arg_memory_pool
-  )
-    : base_t(arg_memory_pool)
-  { }
+  explicit SingleTaskQueue(typename base_t::execution_space const&,
+                           typename base_t::memory_space const&,
+                           typename base_t::memory_pool const& arg_memory_pool)
+      : base_t(arg_memory_pool) {}
 
   ~SingleTaskQueue() {
-    for(int i_priority = 0; i_priority < NumQueue; ++i_priority) {
+    for (int i_priority = 0; i_priority < NumQueue; ++i_priority) {
       KOKKOS_EXPECTS(m_ready_queues[i_priority][TaskTeam].empty());
       KOKKOS_EXPECTS(m_ready_queues[i_priority][TaskSingle].empty());
     }
@@ -153,47 +142,40 @@ public:
   //----------------------------------------------------------------------------
 
   KOKKOS_FUNCTION
-  void
-  schedule_runnable(
-    runnable_task_base_type&& task,
-    team_scheduler_info_type const& info
-  ) {
+  void schedule_runnable(runnable_task_base_type&& task,
+                         team_scheduler_info_type const& info) {
     this->schedule_runnable_to_queue(
-      std::move(task),
-      m_ready_queues[int(task.get_priority())][int(task.get_task_type())],
-      info
-    );
+        std::move(task),
+        m_ready_queues[int(task.get_priority())][int(task.get_task_type())],
+        info);
     // Task may be enqueued and may be run at any point; don't touch it (hence
     // the use of move semantics)
   }
 
   KOKKOS_FUNCTION
-  OptionalRef<task_base_type>
-  pop_ready_task(
-    team_scheduler_info_type const& info
-  )
-  {
+  OptionalRef<task_base_type> pop_ready_task(
+      team_scheduler_info_type const& info) {
     OptionalRef<task_base_type> return_value;
-    // always loop in order of priority first, then prefer team tasks over single tasks
-    for(int i_priority = 0; i_priority < NumQueue; ++i_priority) {
-
+    // always loop in order of priority first, then prefer team tasks over
+    // single tasks
+    for (int i_priority = 0; i_priority < NumQueue; ++i_priority) {
       // Check for a team task with this priority
       return_value = m_ready_queues[i_priority][TaskTeam].pop();
-      if(return_value) return return_value;
+      if (return_value) return return_value;
 
       // Check for a single task with this priority
       return_value = m_ready_queues[i_priority][TaskSingle].pop();
-      if(return_value) return return_value;
-
+      if (return_value) return return_value;
     }
     // if nothing was found, return a default-constructed (empty) OptionalRef
     return return_value;
   }
 
   KOKKOS_INLINE_FUNCTION
-  constexpr team_scheduler_info_type
-  initial_team_scheduler_info(int) const noexcept { return { }; }
-
+  constexpr team_scheduler_info_type initial_team_scheduler_info(int) const
+      noexcept {
+    return {};
+  }
 };
 
 } /* namespace Impl */
@@ -204,4 +186,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_SINGLETASKQUEUE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Spinwait.cpp b/lib/kokkos/core/src/impl/Kokkos_Spinwait.cpp
index 6bcb9c6cc42370c7ff7f5781a6a044f6de7de7ca..2ae5c7863c4d25ee70769cf51e8df83e50a74861 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Spinwait.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Spinwait.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,21 +43,21 @@
 */
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
 
 #include <Kokkos_Atomic.hpp>
 #include <impl/Kokkos_Spinwait.hpp>
 #include <impl/Kokkos_BitOps.hpp>
 
-#if defined( KOKKOS_ENABLE_STDTHREAD) || defined( _WIN32 )
-  #include <thread>
-#elif !defined( _WIN32 )
-  #include <sched.h>
-  #include <time.h>
+#if defined(KOKKOS_ENABLE_STDTHREAD) || defined(_WIN32)
+#include <thread>
+#elif !defined(_WIN32)
+#include <sched.h>
+#include <time.h>
 #else
-  #include <process.h>
-  #include <winsock2.h>
-  #include <windows.h>
+#include <process.h>
+#include <winsock2.h>
+#include <windows.h>
 #endif
 
 /*--------------------------------------------------------------------------*/
@@ -64,99 +65,95 @@
 namespace Kokkos {
 namespace Impl {
 
-void host_thread_yield( const uint32_t i , const WaitMode mode )
-{
-  static constexpr uint32_t sleep_limit = 1 << 13 ;
-  static constexpr uint32_t yield_limit = 1 << 12 ;
+void host_thread_yield(const uint32_t i, const WaitMode mode) {
+  static constexpr uint32_t sleep_limit = 1 << 13;
+  static constexpr uint32_t yield_limit = 1 << 12;
 
   const int c = Kokkos::log2(i);
 
-  if ( WaitMode::ROOT != mode ) {
-    if ( sleep_limit < i ) {
-
+  if (WaitMode::ROOT != mode) {
+    if (sleep_limit < i) {
       // Attempt to put the thread to sleep for 'c' milliseconds
 
-      #if defined( KOKKOS_ENABLE_STDTHREAD ) || defined( _WIN32 )
-        auto start = std::chrono::high_resolution_clock::now();
-        std::this_thread::yield();
-        std::this_thread::sleep_until( start + std::chrono::nanoseconds( c * 1000 ) );
-      #else
-        timespec req ;
-        req.tv_sec  = 0 ;
-        req.tv_nsec = 1000 * c ;
-        nanosleep( &req, nullptr );
-      #endif
+#if defined(KOKKOS_ENABLE_STDTHREAD) || defined(_WIN32)
+      auto start = std::chrono::high_resolution_clock::now();
+      std::this_thread::yield();
+      std::this_thread::sleep_until(start + std::chrono::nanoseconds(c * 1000));
+#else
+      timespec req;
+      req.tv_sec  = 0;
+      req.tv_nsec = 1000 * c;
+      nanosleep(&req, nullptr);
+#endif
     }
 
-    else if ( mode == WaitMode::PASSIVE || yield_limit < i ) {
-
+    else if (mode == WaitMode::PASSIVE || yield_limit < i) {
       // Attempt to yield thread resources to runtime
 
-      #if defined( KOKKOS_ENABLE_STDTHREAD ) || defined( _WIN32 )
-        std::this_thread::yield();
-      #else
-        sched_yield();
-      #endif
+#if defined(KOKKOS_ENABLE_STDTHREAD) || defined(_WIN32)
+      std::this_thread::yield();
+#else
+      sched_yield();
+#endif
     }
+#if defined(KOKKOS_ENABLE_ASM)
 
-    #if defined( KOKKOS_ENABLE_ASM )
-
-    else if ( (1u<<4) < i ) {
+    else if ((1u << 4) < i) {
 
       // Insert a few no-ops to quiet the thread:
 
-      for ( int k = 0 ; k < c ; ++k ) {
-        #if defined( __amd64 ) || defined( __amd64__ ) || \
-              defined( __x86_64 ) || defined( __x86_64__ )
-          #if !defined( _WIN32 ) /* IS NOT Microsoft Windows */
-            asm volatile( "nop\n" );
-          #else
-            __asm__ __volatile__( "nop\n" );
-          #endif
-        #elif defined(__PPC64__)
-            asm volatile( "nop\n" );
-        #endif
+      for (int k = 0; k < c; ++k) {
+#if defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
+    defined(__x86_64__)
+#if !defined(_WIN32) /* IS NOT Microsoft Windows */
+        asm volatile("nop\n");
+#else
+        __asm__ __volatile__("nop\n");
+#endif
+#elif defined(__PPC64__)
+        asm volatile("nop\n");
+#endif
       }
     }
-    #endif /* defined( KOKKOS_ENABLE_ASM ) */
+#endif /* defined( KOKKOS_ENABLE_ASM ) */
   }
-  #if defined( KOKKOS_ENABLE_ASM )
-  else if ( (1u<<3) < i ) {
+#if defined(KOKKOS_ENABLE_ASM)
+  else if ((1u << 3) < i) {
     // no-ops for root thread
-    for ( int k = 0 ; k < c ; ++k ) {
-      #if defined( __amd64 ) || defined( __amd64__ ) || \
-            defined( __x86_64 ) || defined( __x86_64__ )
-        #if !defined( _WIN32 ) /* IS NOT Microsoft Windows */
-          asm volatile( "nop\n" );
-        #else
-          __asm__ __volatile__( "nop\n" );
-        #endif
-      #elif defined(__PPC64__)
-          asm volatile( "nop\n" );
-      #endif
+    for (int k = 0; k < c; ++k) {
+#if defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
+    defined(__x86_64__)
+#if !defined(_WIN32) /* IS NOT Microsoft Windows */
+      asm volatile("nop\n");
+#else
+      __asm__ __volatile__("nop\n");
+#endif
+#elif defined(__PPC64__)
+      asm volatile("nop\n");
+#endif
     }
   }
 
   {
     // Insert memory pause
-      #if defined( __amd64 )  || defined( __amd64__ ) || \
-       	  defined( __x86_64 ) || defined( __x86_64__ )
-    	  #if !defined( _WIN32 ) /* IS NOT Microsoft Windows */
-          asm volatile( "pause\n":::"memory" );
-	      #else
-          __asm__ __volatile__( "pause\n":::"memory" );
-        #endif
-      #elif defined(__PPC64__)
-	      asm volatile( "or 27, 27, 27" ::: "memory" );
-      #endif
+#if defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
+    defined(__x86_64__)
+#if !defined(_WIN32) /* IS NOT Microsoft Windows */
+    asm volatile("pause\n" ::: "memory");
+#else
+    __asm__ __volatile__("pause\n" ::: "memory");
+#endif
+#elif defined(__PPC64__)
+    asm volatile("or 27, 27, 27" ::: "memory");
+#endif
   }
 
-  #endif /* defined( KOKKOS_ENABLE_ASM ) */
+#endif /* defined( KOKKOS_ENABLE_ASM ) */
 }
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 #else
 void KOKKOS_CORE_SRC_IMPL_SPINWAIT_PREVENT_LINK_ERROR() {}
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Spinwait.hpp b/lib/kokkos/core/src/impl/Kokkos_Spinwait.hpp
index 5cad7e48ccaf8c7c5a35775028745fce7d966928..1c65fb91f2942aca57e66b09bd99ccaf5e450783 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Spinwait.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Spinwait.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,6 @@
 //@HEADER
 */
 
-
 #ifndef KOKKOS_SPINWAIT_HPP
 #define KOKKOS_SPINWAIT_HPP
 
@@ -56,81 +56,76 @@ namespace Kokkos {
 namespace Impl {
 
 enum class WaitMode : int {
-    ACTIVE   // Used for tight loops to keep threads active longest
-  , PASSIVE  // Used to quickly yield the thread to quite down the system
-  , ROOT     // Never sleep or yield the root thread
+  ACTIVE  // Used for tight loops to keep threads active longest
+  ,
+  PASSIVE  // Used to quickly yield the thread to quite down the system
+  ,
+  ROOT  // Never sleep or yield the root thread
 };
 
-
-void host_thread_yield( const uint32_t i , const WaitMode mode );
+void host_thread_yield(const uint32_t i, const WaitMode mode);
 
 template <typename T>
-typename std::enable_if< std::is_integral<T>::value, void>::type
-root_spinwait_while_equal( T const volatile & flag, const T value )
-{
+typename std::enable_if<std::is_integral<T>::value, void>::type
+root_spinwait_while_equal(T const volatile& flag, const T value) {
   Kokkos::store_fence();
-  uint32_t i = 0 ;
-  while( value == flag ) {
+  uint32_t i = 0;
+  while (value == flag) {
     host_thread_yield(++i, WaitMode::ROOT);
   }
   Kokkos::load_fence();
 }
 
 template <typename T>
-typename std::enable_if< std::is_integral<T>::value, void>::type
-root_spinwait_until_equal( T const volatile & flag, const T value )
-{
+typename std::enable_if<std::is_integral<T>::value, void>::type
+root_spinwait_until_equal(T const volatile& flag, const T value) {
   Kokkos::store_fence();
-  uint32_t i = 0 ;
-  while( value != flag ) {
+  uint32_t i = 0;
+  while (value != flag) {
     host_thread_yield(++i, WaitMode::ROOT);
   }
   Kokkos::load_fence();
 }
 
 template <typename T>
-typename std::enable_if< std::is_integral<T>::value, void>::type
-spinwait_while_equal( T const volatile & flag, const T value )
-{
+typename std::enable_if<std::is_integral<T>::value, void>::type
+spinwait_while_equal(T const volatile& flag, const T value) {
   Kokkos::store_fence();
-  uint32_t i = 0 ;
-  while( value == flag ) {
+  uint32_t i = 0;
+  while (value == flag) {
     host_thread_yield(++i, WaitMode::ACTIVE);
   }
   Kokkos::load_fence();
 }
 
 template <typename T>
-typename std::enable_if< std::is_integral<T>::value, void>::type
-yield_while_equal( T const volatile & flag, const T value )
-{
+typename std::enable_if<std::is_integral<T>::value, void>::type
+yield_while_equal(T const volatile& flag, const T value) {
   Kokkos::store_fence();
-  uint32_t i = 0 ;
-  while( value == flag ) {
+  uint32_t i = 0;
+  while (value == flag) {
     host_thread_yield(++i, WaitMode::PASSIVE);
   }
   Kokkos::load_fence();
 }
 
 template <typename T>
-typename std::enable_if< std::is_integral<T>::value, void>::type
-spinwait_until_equal( T const volatile & flag, const T value )
-{
+typename std::enable_if<std::is_integral<T>::value, void>::type
+spinwait_until_equal(T const volatile& flag, const T value) {
   Kokkos::store_fence();
-  uint32_t i = 0 ;
-  while( value != flag ) {
+  uint32_t i = 0;
+  while (value != flag) {
     host_thread_yield(++i, WaitMode::ACTIVE);
   }
   Kokkos::load_fence();
 }
 
 template <typename T>
-typename std::enable_if< std::is_integral<T>::value, void>::type
-yield_until_equal( T const volatile & flag, const T value )
-{
+typename std::enable_if<std::is_integral<T>::value, void>::type
+yield_until_equal(T const volatile& flag, const T value) {
   Kokkos::store_fence();
-  uint32_t i = 0 ;
-  while( value != flag ) {
+  uint32_t i = 0;
+  while (value != flag) {
     host_thread_yield(++i, WaitMode::PASSIVE);
   }
   Kokkos::load_fence();
@@ -140,4 +135,3 @@ yield_until_equal( T const volatile & flag, const T value )
 } /* namespace Kokkos */
 
 #endif /* #ifndef KOKKOS_SPINWAIT_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Stacktrace.cpp b/lib/kokkos/core/src/impl/Kokkos_Stacktrace.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..582f6979363cd0d63689bd323affb4bb3e184575
--- /dev/null
+++ b/lib/kokkos/core/src/impl/Kokkos_Stacktrace.cpp
@@ -0,0 +1,247 @@
+#include "Kokkos_Macros.hpp"
+#include "Kokkos_Stacktrace.hpp"
+
+#ifdef KOKKOS_IMPL_ENABLE_STACKTRACE
+// backtrace() function for retrieving the stacktrace
+#include <execinfo.h>
+#endif
+#ifdef KOKKOS_IMPL_ENABLE_CXXABI
+#include <cxxabi.h>
+#endif  // KOKKOS_ENABLE_CXXABI
+
+#include <exception>
+#include <iostream>
+#include <tuple>
+#include <vector>
+
+namespace Kokkos {
+namespace Impl {
+#ifndef KOKKOS_IMPL_ENABLE_STACKTRACE
+int backtrace(void**, int) { return 0; }
+char** backtrace_symbols(void* const*, int) { return NULL; }
+#endif
+
+std::string demangle(const std::string& name) {
+#ifndef KOKKOS_IMPL_ENABLE_CXXABI
+  return name;
+#else
+  size_t found_end = name.find_first_of("+)", 0, 2);
+  if (found_end == std::string::npos) {
+    found_end = name.size();
+  }
+  size_t found_parenthesis = name.find_first_of("(");
+  size_t start             = found_parenthesis + 1;
+  if (found_parenthesis == std::string::npos) start = 0;
+
+  std::string s = name.substr(start, found_end - start);
+
+  if (s.length() != 0) {
+    int status          = 0;
+    char* output_buffer = nullptr;
+    size_t length       = s.length();
+    char* d = abi::__cxa_demangle(s.c_str(), output_buffer, &length, &status);
+    if (d != nullptr) {
+      s = d;
+      free(d);
+    }
+  }
+
+  // Special cases for "main" and "start" on Mac
+  if (s.length() == 0) {
+    if (name == "main" || name == "start") {
+      s = name;
+    }
+  }
+  return s;
+#endif  // KOKKOS_ENABLE_CXXABI
+}
+
+class Stacktrace {
+ public:
+  Stacktrace()                  = delete;
+  Stacktrace(const Stacktrace&) = delete;
+  Stacktrace& operator=(const Stacktrace&) = delete;
+  Stacktrace(Stacktrace&&)                 = delete;
+  Stacktrace& operator=(Stacktrace&&) = delete;
+  ~Stacktrace()                       = delete;
+
+  // These are public only to avoid wasting an extra stacktrace line.
+  // See save_stacktrace below.
+  static constexpr int capacity = 100;
+  static void* buffer[capacity];
+  static int length;
+
+  static std::vector<std::string> lines() {
+    char** symbols = backtrace_symbols(buffer, length);
+    if (symbols == nullptr) {
+      return {};
+    } else {
+      std::vector<std::string> trace(length);
+      for (int i = 0; i < length; ++i) {
+        if (symbols[i] != nullptr) {
+          trace[i] = std::string(symbols[i]);
+        }
+      }
+      free(symbols);
+      return trace;
+    }
+  }
+};
+
+int Stacktrace::length = 0;
+void* Stacktrace::buffer[Stacktrace::capacity];
+
+void save_stacktrace() {
+  Stacktrace::length = backtrace(Stacktrace::buffer, Stacktrace::capacity);
+}
+
+size_t find_first_non_whitespace(const std::string& s, const size_t start_pos) {
+  constexpr size_t num_ws_chars = 3;
+  const char ws_chars[]         = "\n\t ";
+  return s.find_first_not_of(ws_chars, start_pos, num_ws_chars);
+}
+
+size_t find_first_whitespace(const std::string& s, const size_t start_pos) {
+  constexpr size_t num_ws_chars = 3;
+  const char ws_chars[]         = "\n\t ";
+  return s.find_first_of(ws_chars, start_pos, num_ws_chars);
+}
+
+template <class Callback>
+void for_each_token(const std::string& s, Callback c) {
+  size_t cur = find_first_non_whitespace(s, 0);
+  while (cur != std::string::npos) {
+    const size_t end   = find_first_whitespace(s, cur);
+    const bool last    = (end == std::string::npos);
+    const size_t count = last ? end : size_t(end - cur);
+    c(s.substr(cur, count), last);
+    cur = find_first_non_whitespace(s, end);
+  }
+}
+
+// Search the whole backtrace, column by column, for "main".
+// This tells us what column has the function names.
+// While we're doing that, figure out the longest column,
+// so we can compute spacing correctly.
+
+struct main_column_info {
+  bool found_main;
+  size_t main_col;
+  std::vector<size_t> main_col_lens;
+};
+
+main_column_info find_main_column(const std::vector<std::string>& traceback) {
+  bool found_main = false;
+  size_t main_col = 0;
+  for (auto&& entry : traceback) {
+    size_t col_count = 0;
+    for_each_token(entry, [&](const std::string& s, bool) {
+      const size_t pos = s.find("main");
+      if (pos != std::string::npos) {
+        found_main = true;
+        main_col   = col_count;
+      }
+      ++col_count;
+    });
+    if (found_main) {
+      break;
+    }
+  }
+
+  // Make another pass to get the column lengths.
+  // Only demangle the column of functions.
+  std::vector<size_t> max_col_lengths;
+  for (auto&& entry : traceback) {
+    size_t col_count = 0;
+    for_each_token(entry, [&](const std::string& s, bool) {
+      const size_t cur_col_len =
+          (found_main && col_count == main_col) ? demangle(s).size() : s.size();
+      ++col_count;
+      if (max_col_lengths.size() < col_count) {
+        max_col_lengths.push_back(cur_col_len);
+      } else {
+        const size_t old_max_len = max_col_lengths[col_count - 1];
+        if (old_max_len < cur_col_len) {
+          max_col_lengths[col_count - 1] = cur_col_len;
+        }
+      }
+    });
+  }
+  return main_column_info{found_main, main_col, max_col_lengths};
+}
+
+void demangle_and_print_traceback_entry(
+    std::ostream& out, const std::string& traceback_entry,
+    const bool found_main, const size_t main_col,
+    const std::vector<size_t>& max_col_lens) {
+  std::vector<std::string> tokens;
+  size_t cur_col = 0;
+  for_each_token(traceback_entry, [&](const std::string& s, bool last) {
+    const size_t old_width(out.width());
+    out.width(max_col_lens[cur_col]);
+    try {
+      if (found_main && cur_col == main_col) {
+        out << demangle(s);
+      } else {
+        out << s;
+      }
+      if (!last) {
+        out << " ";
+      }
+      ++cur_col;
+    } catch (...) {
+      out.width(old_width);
+      throw;
+    }
+    out.width(old_width);
+  });
+}
+
+void demangle_and_print_traceback(std::ostream& out,
+                                  const std::vector<std::string>& traceback) {
+  const auto result = find_main_column(traceback);
+  for (auto&& entry : traceback) {
+    demangle_and_print_traceback_entry(out, entry, result.found_main,
+                                       result.main_col, result.main_col_lens);
+    out << std::endl;
+  }
+}
+
+void print_saved_stacktrace(std::ostream& out) {
+  auto lines = Stacktrace::lines();
+  for (auto&& entry : lines) {
+    out << entry << std::endl;
+  }
+}
+
+void print_demangled_saved_stacktrace(std::ostream& out) {
+  demangle_and_print_traceback(out, Stacktrace::lines());
+}
+
+std::function<void()> user_terminate_handler_post_ = nullptr;
+
+void kokkos_terminate_handler() {
+  using std::cerr;
+  using std::endl;
+
+  cerr << "Kokkos observes that std::terminate has been called.  "
+          "Here is the last saved stack trace.  Note that this does not "
+          "necessarily show what called std::terminate."
+       << endl
+       << endl;
+  print_demangled_saved_stacktrace(std::cerr);
+
+  if (user_terminate_handler_post_ != nullptr) {
+    user_terminate_handler_post_();
+  } else {
+    std::abort();
+  }
+}
+
+void set_kokkos_terminate_handler(std::function<void()> user_post) {
+  user_terminate_handler_post_ = user_post;
+  std::set_terminate(kokkos_terminate_handler);
+}
+
+}  // namespace Impl
+}  // namespace Kokkos
diff --git a/lib/kokkos/core/src/impl/Kokkos_Stacktrace.hpp b/lib/kokkos/core/src/impl/Kokkos_Stacktrace.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b5cf4ee1b647f1cdf86bccfe3e73b68ec7127d7b
--- /dev/null
+++ b/lib/kokkos/core/src/impl/Kokkos_Stacktrace.hpp
@@ -0,0 +1,45 @@
+#ifndef KOKKOS_STACKTRACE_HPP
+#define KOKKOS_STACKTRACE_HPP
+
+#include <functional>
+#include <ostream>
+#include <string>
+
+namespace Kokkos {
+namespace Impl {
+
+/// \brief Return the demangled version of the input symbol, or the
+///   original input if demangling is not possible.
+std::string demangle(const std::string& name);
+
+/// \brief Save the current stacktrace.
+///
+/// You may only save one stacktrace at a time.  If you call this
+/// twice, the second call will overwrite the result of the first
+/// call.
+void save_stacktrace();
+
+/// \brief Print the raw form of the currently saved stacktrace, if
+///   any, to the given output stream.
+void print_saved_stacktrace(std::ostream& out);
+
+/// \brief Print the currently saved, demangled stacktrace, if any, to
+///   the given output stream.
+///
+/// Demangling is best effort only.
+void print_demangled_saved_stacktrace(std::ostream& out);
+
+/// \brief Set the std::terminate handler so that it prints the
+///   currently saved stack trace, then calls user_post.
+///
+/// This is useful if you want to call, say, MPI_Abort instead of
+/// std::abort.  The MPI Standard frowns upon calling MPI functions
+/// without including their header file, and Kokkos does not depend on
+/// MPI, so there's no way for Kokkos to depend on MPI_Abort in a
+/// portable way.
+void set_kokkos_terminate_handler(std::function<void()> user_post = nullptr);
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif  // KOKKOS_STACKTRACE_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_Tags.hpp b/lib/kokkos/core/src/impl/Kokkos_Tags.hpp
index 0cd84108baae39f707d1c499d5e30421b222ca70..1b33180ed276b4aef27908b1f81a0896ac03e808 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Tags.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Tags.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -61,29 +62,34 @@
  *   struct Foo { using array_layout = void; };
  *   have_array_layout<Foo>::value == 1;
  */
-#define KOKKOS_IMPL_HAS_TYPE( TYPE ) \
-template <typename T> struct have_ ## TYPE { \
-private: \
-  template <typename U, typename = void > struct X : std::false_type {}; \
-  template <typename U> struct X<U,typename std::conditional<true,void,typename X:: TYPE >::type > : std::true_type {}; \
-public: \
-  typedef typename X<T>::type type ; \
-  enum : bool { value = type::value }; \
-};
+#define KOKKOS_IMPL_HAS_TYPE(TYPE)                                             \
+  template <typename T>                                                        \
+  struct have_##TYPE {                                                         \
+   private:                                                                    \
+    template <typename U, typename = void>                                     \
+    struct X : std::false_type {};                                             \
+    template <typename U>                                                      \
+    struct X<U, typename std::conditional<true, void, typename X::TYPE>::type> \
+        : std::true_type {};                                                   \
+                                                                               \
+   public:                                                                     \
+    typedef typename X<T>::type type;                                          \
+    enum : bool { value = type::value };                                       \
+  };
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 template <typename T>
-using is_void = std::is_same<void,T>;
-
-}} // namespace Kokkos::Impl
+using is_void = std::is_same<void, T>;
 
+}
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskBase.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskBase.hpp
index b0c06fb26eb9e82ab365ef9afe676d6c1fd3c388..e3de5d0eb9a13a32ca9317d83f17b9dabf41428c 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskBase.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskBase.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 #define KOKKOS_IMPL_TASKBASE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -136,101 +137,96 @@ namespace Impl {
  *      m_next == LockTag: not a member of a wait queue
  *
  */
-class TaskBase
-{
-public:
+class TaskBase {
+ public:
+  enum : int16_t { TaskTeam = 0, TaskSingle = 1, Aggregate = 2 };
+  enum : uintptr_t { LockTag = ~uintptr_t(0), EndTag = ~uintptr_t(1) };
 
-  enum : int16_t   { TaskTeam = 0 , TaskSingle = 1 , Aggregate = 2 };
-  enum : uintptr_t { LockTag = ~uintptr_t(0) , EndTag = ~uintptr_t(1) };
-
-  template<typename, typename> friend class Kokkos::BasicTaskScheduler ;
+  template <typename, typename>
+  friend class Kokkos::BasicTaskScheduler;
 
   using queue_type = TaskQueueBase;
 
-  using function_type = void(*)( TaskBase * , void * );
-  typedef void (* destroy_type) ( TaskBase * );
+  using function_type = void (*)(TaskBase*, void*);
+  typedef void (*destroy_type)(TaskBase*);
 
   // sizeof(TaskBase) == 48
 
-  function_type m_apply = nullptr;         ///< Apply function pointer
-  queue_type* m_queue = nullptr;          ///< Pointer to the scheduler
-  TaskBase* m_next = nullptr; ///< next in linked list of ready tasks
-  TaskBase* m_wait = nullptr; ///< Queue of tasks waiting on this
-  int32_t m_ref_count = 0;
-  int32_t m_alloc_size = 0;
-  int32_t m_dep_count ;                    ///< Aggregate's number of dependences
-  int16_t        m_task_type ;   ///< Type of task
-  int16_t        m_priority ;    ///< Priority of runnable task
-
-  TaskBase( TaskBase && ) = delete ;
-  TaskBase( const TaskBase & ) = delete ;
-  TaskBase & operator = ( TaskBase && ) = delete ;
-  TaskBase & operator = ( const TaskBase & ) = delete ;
+  function_type m_apply = nullptr;  ///< Apply function pointer
+  queue_type* m_queue   = nullptr;  ///< Pointer to the scheduler
+  TaskBase* m_next      = nullptr;  ///< next in linked list of ready tasks
+  TaskBase* m_wait      = nullptr;  ///< Queue of tasks waiting on this
+  int32_t m_ref_count   = 0;
+  int32_t m_alloc_size  = 0;
+  int32_t m_dep_count;  ///< Aggregate's number of dependences
+  int16_t m_task_type;  ///< Type of task
+  int16_t m_priority;   ///< Priority of runnable task
+
+  TaskBase(TaskBase&&)      = delete;
+  TaskBase(const TaskBase&) = delete;
+  TaskBase& operator=(TaskBase&&) = delete;
+  TaskBase& operator=(const TaskBase&) = delete;
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
-  KOKKOS_INLINE_FUNCTION ~TaskBase() {};
+  KOKKOS_INLINE_FUNCTION ~TaskBase(){};
 #else
   KOKKOS_INLINE_FUNCTION ~TaskBase() = default;
 #endif
 
-  KOKKOS_INLINE_FUNCTION constexpr
-  TaskBase()
-    : m_apply( nullptr )
-    , m_queue( nullptr )
-    , m_next( nullptr )
-    , m_wait( nullptr )
-    , m_ref_count( 0 )
-    , m_alloc_size( 0 )
-    , m_dep_count( 0 )
-    , m_task_type( 0 )
-    , m_priority( 0 )
-    {}
+  KOKKOS_INLINE_FUNCTION constexpr TaskBase()
+      : m_apply(nullptr),
+        m_queue(nullptr),
+        m_next(nullptr),
+        m_wait(nullptr),
+        m_ref_count(0),
+        m_alloc_size(0),
+        m_dep_count(0),
+        m_task_type(0),
+        m_priority(0) {}
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  TaskBase * volatile * aggregate_dependences() volatile
-    { return reinterpret_cast<TaskBase*volatile*>( this + 1 ); }
+  TaskBase* volatile* aggregate_dependences() volatile {
+    return reinterpret_cast<TaskBase* volatile*>(this + 1);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  bool requested_respawn()
-    {
-      // This should only be called when a task has finished executing and is
-      // in the transition to either the complete or executing-respawn state.
-      TaskBase * const lock = reinterpret_cast< TaskBase * >( LockTag );
-      return lock != m_next;
-    }
+  bool requested_respawn() {
+    // This should only be called when a task has finished executing and is
+    // in the transition to either the complete or executing-respawn state.
+    TaskBase* const lock = reinterpret_cast<TaskBase*>(LockTag);
+    return lock != m_next;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void add_dependence( TaskBase* dep )
-    {
-      // Precondition: lock == m_next
-
-      TaskBase * const lock = (TaskBase *) LockTag ;
-
-      // Assign dependence to m_next.  It will be processed in the subsequent
-      // call to schedule.  Error if the dependence is reset.
-      if ( lock != Kokkos::atomic_exchange( & m_next, dep ) ) {
-        Kokkos::abort("TaskScheduler ERROR: resetting task dependence");
-      }
-
-      if ( 0 != dep ) {
-        // The future may be destroyed upon returning from this call
-        // so increment reference count to track this assignment.
-        Kokkos::atomic_increment( &(dep->m_ref_count) );
-      }
+  void add_dependence(TaskBase* dep) {
+    // Precondition: lock == m_next
+
+    TaskBase* const lock = (TaskBase*)LockTag;
+
+    // Assign dependence to m_next.  It will be processed in the subsequent
+    // call to schedule.  Error if the dependence is reset.
+    if (lock != Kokkos::atomic_exchange(&m_next, dep)) {
+      Kokkos::abort("TaskScheduler ERROR: resetting task dependence");
+    }
+
+    if (0 != dep) {
+      // The future may be destroyed upon returning from this call
+      // so increment reference count to track this assignment.
+      Kokkos::atomic_increment(&(dep->m_ref_count));
     }
+  }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  int32_t reference_count() const
-    { return *((int32_t volatile *)( & m_ref_count )); }
-
+  int32_t reference_count() const {
+    return *((int32_t volatile*)(&m_ref_count));
+  }
 };
 
-static_assert( sizeof(TaskBase) == 48
-             , "Verifying expected sizeof(TaskBase)" );
+static_assert(sizeof(TaskBase) == 48, "Verifying expected sizeof(TaskBase)");
 
 } /* namespace Impl */
 } /* namespace Kokkos */
@@ -241,78 +237,68 @@ static_assert( sizeof(TaskBase) == 48
 namespace Kokkos {
 namespace Impl {
 
-template< class Scheduler, typename ResultType , class FunctorType >
-class Task
-  : public TaskBase,
-    public FunctorType
-{
-public:
-
-  Task() = delete ;
-  Task( Task && ) = delete ;
-  Task( const Task & ) = delete ;
-  Task & operator = ( Task && ) = delete ;
-  Task & operator = ( const Task & ) = delete ;
+template <class Scheduler, typename ResultType, class FunctorType>
+class Task : public TaskBase, public FunctorType {
+ public:
+  Task()            = delete;
+  Task(Task&&)      = delete;
+  Task(const Task&) = delete;
+  Task& operator=(Task&&) = delete;
+  Task& operator=(const Task&) = delete;
 
+  using root_type    = TaskBase;
+  using functor_type = FunctorType;
+  using result_type  = ResultType;
 
-  using root_type = TaskBase;
-  using functor_type = FunctorType ;
-  using result_type = ResultType ;
-
-  using specialization = TaskQueueSpecialization<Scheduler> ;
-  using member_type = typename specialization::member_type ;
+  using specialization = TaskQueueSpecialization<Scheduler>;
+  using member_type    = typename specialization::member_type;
 
   KOKKOS_INLINE_FUNCTION
-  void apply_functor( member_type * const member , void * )
-    { this->functor_type::operator()( *member ); }
+  void apply_functor(member_type* const member, void*) {
+    this->functor_type::operator()(*member);
+  }
 
-  template< typename T >
-  KOKKOS_INLINE_FUNCTION
-  void apply_functor( member_type * const member
-                    , T           * const result )
-    { this->functor_type::operator()( *member , *result ); }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION void apply_functor(member_type* const member,
+                                            T* const result) {
+    this->functor_type::operator()(*member, *result);
+  }
 
-  KOKKOS_FUNCTION static
-  void destroy( root_type * root )
-  {
+  KOKKOS_FUNCTION static void destroy(root_type* root) {
     TaskResult<result_type>::destroy(root);
   }
 
-  KOKKOS_FUNCTION static
-  void apply( root_type * root , void * exec )
-    {
-      Task* const task = static_cast< Task * >( root );
-      member_type * const member = reinterpret_cast< member_type * >( exec );
-      result_type * const result = TaskResult< result_type >::ptr( task );
+  KOKKOS_FUNCTION static void apply(root_type* root, void* exec) {
+    Task* const task          = static_cast<Task*>(root);
+    member_type* const member = reinterpret_cast<member_type*>(exec);
+    result_type* const result = TaskResult<result_type>::ptr(task);
 
-      // Task may be serial or team.
-      // If team then must synchronize before querying if respawn was requested.
-      // If team then only one thread calls destructor.
+    // Task may be serial or team.
+    // If team then must synchronize before querying if respawn was requested.
+    // If team then only one thread calls destructor.
 
-      const bool only_one_thread =
+    const bool only_one_thread =
 #if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
-        0 == threadIdx.x && 0 == threadIdx.y ;
+        0 == threadIdx.x && 0 == threadIdx.y;
 #else
         0 == member->team_rank();
 #endif
 
-      task->apply_functor( member , result );
+    task->apply_functor(member, result);
 
-      member->team_barrier();
+    member->team_barrier();
 
-      if ( only_one_thread && !(task->requested_respawn()) ) {
-        // Did not respawn, destroy the functor to free memory.
-        task->functor_type::~functor_type();
-        // Cannot destroy and deallocate the task until its dependences
-        // have been processed.
-      }
+    if (only_one_thread && !(task->requested_respawn())) {
+      // Did not respawn, destroy the functor to free memory.
+      task->functor_type::~functor_type();
+      // Cannot destroy and deallocate the task until its dependences
+      // have been processed.
     }
+  }
 
   // Constructor for runnable task
-  KOKKOS_INLINE_FUNCTION constexpr
-  Task( FunctorType && arg_functor )
-    : root_type() , functor_type( std::move(arg_functor) )
-  { }
+  KOKKOS_INLINE_FUNCTION constexpr Task(FunctorType&& arg_functor)
+      : root_type(), functor_type(std::move(arg_functor)) {}
 
   KOKKOS_INLINE_FUNCTION
   ~Task() = delete;
@@ -326,4 +312,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKBASE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskNode.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskNode.hpp
index 49aa4b4b21751c8f7f7432918acc3f90db02c1e9..1ea7fc2049a722c8f965616c44517ce0c91b08c3 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskNode.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskNode.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 #define KOKKOS_IMPL_TASKNODE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -70,7 +71,20 @@
 namespace Kokkos {
 namespace Impl {
 
-enum TaskType : int16_t   { TaskTeam = 0 , TaskSingle = 1 , Aggregate = 2, TaskSpecial = -1 };
+#ifdef KOKKOS_COMPILER_PGI
+// Bizzarely, an extra jump instruction forces the PGI compiler to not have a
+// bug related to (probably?) empty base optimization and/or aggregate
+// construction.  This must be defined out-of-line to generate a jump
+// jump instruction
+void _kokkos_pgi_compiler_bug_workaround();
+#endif
+
+enum TaskType : int16_t {
+  TaskTeam    = 0,
+  TaskSingle  = 1,
+  Aggregate   = 2,
+  TaskSpecial = -1
+};
 
 //==============================================================================
 
@@ -87,50 +101,46 @@ enum TaskType : int16_t   { TaskTeam = 0 , TaskSingle = 1 , Aggregate = 2, TaskS
  */
 template <class CountType = int32_t>
 class alignas(void*) PoolAllocatedObjectBase {
-public:
-
+ public:
   using pool_allocation_size_type = CountType;
 
-private:
-
+ private:
   pool_allocation_size_type m_alloc_size;
 
-public:
-
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  constexpr explicit PoolAllocatedObjectBase(pool_allocation_size_type allocation_size)
-    : m_alloc_size(allocation_size)
-  { }
+  constexpr explicit PoolAllocatedObjectBase(
+      pool_allocation_size_type allocation_size)
+      : m_alloc_size(allocation_size) {}
 
   KOKKOS_INLINE_FUNCTION
   CountType get_allocation_size() const noexcept { return m_alloc_size; }
-
 };
 
 //==============================================================================
 
-
 // TODO @tasking @cleanup DSH move this?
 template <class CountType = int32_t>
 class ReferenceCountedBase {
-public:
-
+ public:
   using reference_count_size_type = CountType;
 
-private:
-
+ private:
   reference_count_size_type m_ref_count = 0;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  constexpr explicit
-  ReferenceCountedBase(reference_count_size_type initial_reference_count)
-    : m_ref_count(initial_reference_count)
-  {
+#ifndef KOKKOS_COMPILER_PGI
+  constexpr
+#endif
+      explicit ReferenceCountedBase(
+          reference_count_size_type initial_reference_count)
+      : m_ref_count(initial_reference_count) {
     // This can't be here because it breaks constexpr
     // KOKKOS_EXPECTS(initial_reference_count > 0);
+#ifdef KOKKOS_COMPILER_PGI
+    Impl::_kokkos_pgi_compiler_bug_workaround();
+#endif
   }
 
   /** Decrement the reference count,
@@ -138,8 +148,7 @@ public:
    *  the reference count to become zero
    */
   KOKKOS_INLINE_FUNCTION
-  bool decrement_and_check_reference_count()
-  {
+  bool decrement_and_check_reference_count() {
     // TODO @tasking @memory_order DSH memory order
     auto old_count = Kokkos::atomic_fetch_add(&m_ref_count, -1);
 
@@ -149,11 +158,7 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void increment_reference_count()
-  {
-    Kokkos::atomic_increment(&m_ref_count);
-  }
-
+  void increment_reference_count() { Kokkos::atomic_increment(&m_ref_count); }
 };
 
 template <class TaskQueueTraits, class SchedulingInfo>
@@ -166,133 +171,131 @@ class RunnableTaskBase;
 
 template <class TaskQueueTraits>
 class TaskNode
-  : public PoolAllocatedObjectBase<int32_t>, // size 4, must be first!
-    public ReferenceCountedBase<int32_t>, // size 4
-    public TaskQueueTraits::template intrusive_task_base_type<TaskNode<TaskQueueTraits>> // size 8+
+    : public PoolAllocatedObjectBase<int32_t>,  // size 4, must be first!
+      public ReferenceCountedBase<int32_t>,     // size 4
+      public TaskQueueTraits::template intrusive_task_base_type<
+          TaskNode<TaskQueueTraits>>  // size 8+
 {
-public:
-
+ public:
   using priority_type = int16_t;
 
-private:
-
-  using task_base_type = TaskNode<TaskQueueTraits>;
-  using pool_allocated_base_type = PoolAllocatedObjectBase<int32_t>;
+ private:
+  using task_base_type              = TaskNode<TaskQueueTraits>;
+  using pool_allocated_base_type    = PoolAllocatedObjectBase<int32_t>;
   using reference_counted_base_type = ReferenceCountedBase<int32_t>;
-  using task_queue_traits = TaskQueueTraits;
+  using task_queue_traits           = TaskQueueTraits;
   using waiting_queue_type =
-    typename task_queue_traits::template waiting_queue_type<TaskNode>;
+      typename task_queue_traits::template waiting_queue_type<TaskNode>;
 
-  waiting_queue_type m_wait_queue; // size 8+
+  waiting_queue_type m_wait_queue;  // size 8+
 
-  // TODO @tasking @cleanup DSH eliminate this, or make its purpose a bit more clear.  It's only used in BasicFuture, and only for deallocation purposes
+  // TODO @tasking @cleanup DSH eliminate this, or make its purpose a bit more
+  // clear.  It's only used in BasicFuture, and only for deallocation purposes
   TaskQueueBase* m_ready_queue_base;
 
-  TaskType m_task_type;  // size 2
-  priority_type m_priority; // size 2
+  TaskType m_task_type;      // size 2
+  priority_type m_priority;  // size 2
   bool m_is_respawning = false;
 
-public:
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr
-  TaskNode(
-    TaskType task_type,
-    TaskPriority priority,
-    TaskQueueBase* queue_base,
-    reference_count_size_type initial_reference_count,
-    pool_allocation_size_type allocation_size
-  ) : pool_allocated_base_type(
-        /* allocation_size = */ allocation_size
-      ),
-      reference_counted_base_type(
-        /* initial_reference_count = */ initial_reference_count
-      ),
-      m_wait_queue(),
-      m_ready_queue_base(queue_base),
-      m_task_type(task_type),
-      m_priority(static_cast<priority_type>(priority)),
-      m_is_respawning(false)
-  { }
-
-  TaskNode() = delete;
+ public:
+  KOKKOS_INLINE_FUNCTION
+  constexpr TaskNode(TaskType task_type, TaskPriority priority,
+                     TaskQueueBase* queue_base,
+                     reference_count_size_type initial_reference_count,
+                     pool_allocation_size_type allocation_size)
+      : pool_allocated_base_type(
+            /* allocation_size = */ allocation_size),
+        reference_counted_base_type(
+            /* initial_reference_count = */ initial_reference_count),
+        m_wait_queue(),
+        m_ready_queue_base(queue_base),
+        m_task_type(task_type),
+        m_priority(static_cast<priority_type>(priority)),
+        m_is_respawning(false) {}
+
+  TaskNode()                = delete;
   TaskNode(TaskNode const&) = delete;
-  TaskNode(TaskNode&&) = delete;
+  TaskNode(TaskNode&&)      = delete;
   TaskNode& operator=(TaskNode const&) = delete;
   TaskNode& operator=(TaskNode&&) = delete;
 
   KOKKOS_INLINE_FUNCTION
-  bool is_aggregate() const noexcept { return m_task_type == TaskType::Aggregate; }
+  bool is_aggregate() const noexcept {
+    return m_task_type == TaskType::Aggregate;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  bool is_runnable() const noexcept { return m_task_type != TaskType::Aggregate; }
+  bool is_runnable() const noexcept {
+    return m_task_type != TaskType::Aggregate;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  bool is_runnable() const volatile noexcept { return m_task_type != TaskType::Aggregate; }
+  bool is_runnable() const volatile noexcept {
+    return m_task_type != TaskType::Aggregate;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  bool is_single_runnable() const noexcept { return m_task_type == TaskType::TaskSingle; }
+  bool is_single_runnable() const noexcept {
+    return m_task_type == TaskType::TaskSingle;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  bool is_team_runnable() const noexcept { return m_task_type == TaskType::TaskTeam; }
+  bool is_team_runnable() const noexcept {
+    return m_task_type == TaskType::TaskTeam;
+  }
 
   KOKKOS_INLINE_FUNCTION
   TaskType get_task_type() const noexcept { return m_task_type; }
 
   KOKKOS_INLINE_FUNCTION
-  RunnableTaskBase<TaskQueueTraits>&
-  as_runnable_task() & {
+  RunnableTaskBase<TaskQueueTraits>& as_runnable_task() & {
     KOKKOS_EXPECTS(this->is_runnable());
     return static_cast<RunnableTaskBase<TaskQueueTraits>&>(*this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  RunnableTaskBase<TaskQueueTraits> const&
-  as_runnable_task() const & {
+  RunnableTaskBase<TaskQueueTraits> const& as_runnable_task() const& {
     KOKKOS_EXPECTS(this->is_runnable());
     return static_cast<RunnableTaskBase<TaskQueueTraits> const&>(*this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  RunnableTaskBase<TaskQueueTraits> volatile&
-  as_runnable_task() volatile & {
+  RunnableTaskBase<TaskQueueTraits> volatile& as_runnable_task() volatile& {
     KOKKOS_EXPECTS(this->is_runnable());
     return static_cast<RunnableTaskBase<TaskQueueTraits> volatile&>(*this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  RunnableTaskBase<TaskQueueTraits> const volatile&
-  as_runnable_task() const volatile & {
+  RunnableTaskBase<TaskQueueTraits> const volatile& as_runnable_task() const
+      volatile& {
     KOKKOS_EXPECTS(this->is_runnable());
-    return static_cast<RunnableTaskBase<TaskQueueTraits> const volatile&>(*this);
+    return static_cast<RunnableTaskBase<TaskQueueTraits> const volatile&>(
+        *this);
   }
 
   KOKKOS_INLINE_FUNCTION
-  RunnableTaskBase<TaskQueueTraits>&&
-  as_runnable_task() && {
+  RunnableTaskBase<TaskQueueTraits>&& as_runnable_task() && {
     KOKKOS_EXPECTS(this->is_runnable());
     return static_cast<RunnableTaskBase<TaskQueueTraits>&&>(*this);
   }
 
   template <class SchedulingInfo>
-  KOKKOS_INLINE_FUNCTION
-  AggregateTask<TaskQueueTraits, SchedulingInfo>&
+  KOKKOS_INLINE_FUNCTION AggregateTask<TaskQueueTraits, SchedulingInfo>&
   as_aggregate() & {
     KOKKOS_EXPECTS(this->is_aggregate());
     return static_cast<AggregateTask<TaskQueueTraits, SchedulingInfo>&>(*this);
   }
 
   template <class SchedulingInfo>
-  KOKKOS_INLINE_FUNCTION
-  AggregateTask<TaskQueueTraits, SchedulingInfo> const&
-  as_aggregate() const & {
+  KOKKOS_INLINE_FUNCTION AggregateTask<TaskQueueTraits, SchedulingInfo> const&
+  as_aggregate() const& {
     KOKKOS_EXPECTS(this->is_aggregate());
-    return static_cast<AggregateTask<TaskQueueTraits, SchedulingInfo> const&>(*this);
+    return static_cast<AggregateTask<TaskQueueTraits, SchedulingInfo> const&>(
+        *this);
   }
 
   template <class SchedulingInfo>
-  KOKKOS_INLINE_FUNCTION
-  AggregateTask<TaskQueueTraits, SchedulingInfo>&&
+  KOKKOS_INLINE_FUNCTION AggregateTask<TaskQueueTraits, SchedulingInfo>&&
   as_aggregate() && {
     KOKKOS_EXPECTS(this->is_aggregate());
     return static_cast<AggregateTask<TaskQueueTraits, SchedulingInfo>&&>(*this);
@@ -304,8 +307,7 @@ public:
   }
 
   template <class Function>
-  KOKKOS_INLINE_FUNCTION
-  void consume_wait_queue(Function&& f) {
+  KOKKOS_INLINE_FUNCTION void consume_wait_queue(Function&& f) {
     KOKKOS_EXPECTS(not m_wait_queue.is_consumed());
     m_wait_queue.consume(std::forward<Function>(f));
   }
@@ -317,8 +319,7 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  TaskQueueBase*
-  ready_queue_base_ptr() const noexcept {
+  TaskQueueBase* ready_queue_base_ptr() const noexcept {
     return m_ready_queue_base;
   }
 
@@ -343,15 +344,10 @@ public:
   bool get_respawn_flag() const { return m_is_respawning; }
 
   KOKKOS_INLINE_FUNCTION
-  void set_respawn_flag(bool value = true) {
-    m_is_respawning = value;
-  }
+  void set_respawn_flag(bool value = true) { m_is_respawning = value; }
 
   KOKKOS_INLINE_FUNCTION
-  void set_respawn_flag(bool value = true) volatile {
-    m_is_respawning = value;
-  }
-
+  void set_respawn_flag(bool value = true) volatile { m_is_respawning = value; }
 };
 
 //==============================================================================
@@ -363,127 +359,100 @@ class SchedulingInfoStorage;
 
 template <class BaseType, class SchedulingInfo>
 class SchedulingInfoStorage
-  : public BaseType, // must be first base class for allocation reasons!!!
-    private NoUniqueAddressMemberEmulation<SchedulingInfo>
-{
-
-private:
-
-  using base_t = BaseType;
+    : public BaseType,  // must be first base class for allocation reasons!!!
+      private NoUniqueAddressMemberEmulation<SchedulingInfo> {
+ private:
+  using base_t                    = BaseType;
   using task_scheduling_info_type = SchedulingInfo;
 
-public:
-
-  using base_t::base_t;
+ public:
+  // Can't just do using base_t::base_t because of stupid stuff with clang cuda
+  template <class... Args>
+  // requires std::is_constructible_v<base_t, Args&&...>
+  KOKKOS_INLINE_FUNCTION constexpr explicit SchedulingInfoStorage(
+      Args&&... args)
+      : base_t(std::forward<Args>(args)...) {}
 
   KOKKOS_INLINE_FUNCTION
-  task_scheduling_info_type& scheduling_info() &
-  {
+  task_scheduling_info_type& scheduling_info() & {
     return this->no_unique_address_data_member();
   }
 
   KOKKOS_INLINE_FUNCTION
-  task_scheduling_info_type const& scheduling_info() const &
-  {
+  task_scheduling_info_type const& scheduling_info() const& {
     return this->no_unique_address_data_member();
   }
 
   KOKKOS_INLINE_FUNCTION
-  task_scheduling_info_type&& scheduling_info() &&
-  {
+  task_scheduling_info_type&& scheduling_info() && {
     return std::move(*this).no_unique_address_data_member();
   }
-
 };
 
-
 //==============================================================================
 
 template <class TaskQueueTraits, class SchedulingInfo>
 class alignas(16) AggregateTask final
-  : public SchedulingInfoStorage<
-      TaskNode<TaskQueueTraits>,
-      SchedulingInfo
-    >, // must be first base class for allocation reasons!!!
-    public ObjectWithVLAEmulation<
-      AggregateTask<TaskQueueTraits, SchedulingInfo>,
-      OwningRawPtr<TaskNode<TaskQueueTraits>>
-    >
-{
-private:
-
-  using base_t = SchedulingInfoStorage<
-    TaskNode<TaskQueueTraits>,
-    SchedulingInfo
-  >;
-  using vla_base_t = ObjectWithVLAEmulation<
-    AggregateTask<TaskQueueTraits, SchedulingInfo>,
-    OwningRawPtr<TaskNode<TaskQueueTraits>>
-  >;
+    : public SchedulingInfoStorage<TaskNode<TaskQueueTraits>,
+                                   SchedulingInfo>,  // must be first base class
+                                                     // for allocation
+                                                     // reasons!!!
+      public ObjectWithVLAEmulation<
+          AggregateTask<TaskQueueTraits, SchedulingInfo>,
+          OwningRawPtr<TaskNode<TaskQueueTraits>>> {
+ private:
+  using base_t =
+      SchedulingInfoStorage<TaskNode<TaskQueueTraits>, SchedulingInfo>;
+  using vla_base_t =
+      ObjectWithVLAEmulation<AggregateTask<TaskQueueTraits, SchedulingInfo>,
+                             OwningRawPtr<TaskNode<TaskQueueTraits>>>;
 
   using task_base_type = TaskNode<TaskQueueTraits>;
 
-public:
-
-  using aggregate_task_type = AggregateTask; // concept marker
+ public:
+  using aggregate_task_type = AggregateTask;  // concept marker
 
   template <class... Args>
-    // requires std::is_constructible_v<base_t, Args&&...>
-  KOKKOS_INLINE_FUNCTION
-  constexpr explicit
-  AggregateTask(
-    int32_t aggregate_predecessor_count,
-    Args&&... args
-  ) : base_t(
-        TaskType::Aggregate,
-        TaskPriority::Regular, // all aggregates are regular priority
-        std::forward<Args>(args)...
-      ),
-      vla_base_t(aggregate_predecessor_count)
-  { }
+  // requires std::is_constructible_v<base_t, Args&&...>
+  KOKKOS_INLINE_FUNCTION constexpr explicit AggregateTask(
+      int32_t aggregate_predecessor_count, Args&&... args)
+      : base_t(TaskType::Aggregate,
+               TaskPriority::Regular,  // all aggregates are regular priority
+               std::forward<Args>(args)...),
+        vla_base_t(aggregate_predecessor_count) {}
 
   KOKKOS_INLINE_FUNCTION
   int32_t dependence_count() const { return this->n_vla_entries(); }
-
 };
 
-//KOKKOS_IMPL_IS_CONCEPT(aggregate_task);
+// KOKKOS_IMPL_IS_CONCEPT(aggregate_task);
 
 //==============================================================================
 
-
 template <class TaskQueueTraits>
 class RunnableTaskBase
-  : public TaskNode<TaskQueueTraits> // must be first base class for allocation reasons!!!
+    : public TaskNode<TaskQueueTraits>  // must be first base class for
+                                        // allocation reasons!!!
 {
-private:
-
+ private:
   using base_t = TaskNode<TaskQueueTraits>;
 
-public:
-
-  using task_base_type = TaskNode<TaskQueueTraits>;
-  using function_type = void(*)( task_base_type * , void * );
-  using destroy_type = void(*)( task_base_type * );
+ public:
+  using task_base_type     = TaskNode<TaskQueueTraits>;
+  using function_type      = void (*)(task_base_type*, void*);
+  using destroy_type       = void (*)(task_base_type*);
   using runnable_task_type = RunnableTaskBase;
 
-private:
-
+ private:
   function_type m_apply;
   task_base_type* m_predecessor = nullptr;
 
-public:
-
+ public:
   template <class... Args>
-    // requires std::is_constructible_v<base_t, Args&&...>
-  KOKKOS_INLINE_FUNCTION
-  constexpr explicit
-  RunnableTaskBase(
-    function_type apply_function_ptr,
-    Args&&... args
-  ) : base_t(std::forward<Args>(args)...),
-      m_apply(apply_function_ptr)
-  { }
+  // requires std::is_constructible_v<base_t, Args&&...>
+  KOKKOS_INLINE_FUNCTION constexpr explicit RunnableTaskBase(
+      function_type apply_function_ptr, Args&&... args)
+      : base_t(std::forward<Args>(args)...), m_apply(apply_function_ptr) {}
 
   KOKKOS_INLINE_FUNCTION
   bool has_predecessor() const { return m_predecessor != nullptr; }
@@ -495,26 +464,21 @@ public:
   void clear_predecessor() volatile { m_predecessor = nullptr; }
 
   template <class SchedulingInfo>
-  KOKKOS_INLINE_FUNCTION
-  SchedulingInfo&
-  scheduling_info_as()
-  {
-    using info_storage_type = SchedulingInfoStorage<RunnableTaskBase, SchedulingInfo>;
+  KOKKOS_INLINE_FUNCTION SchedulingInfo& scheduling_info_as() {
+    using info_storage_type =
+        SchedulingInfoStorage<RunnableTaskBase, SchedulingInfo>;
 
     return static_cast<info_storage_type*>(this)->scheduling_info();
   }
 
   template <class SchedulingInfo>
-  KOKKOS_INLINE_FUNCTION
-  SchedulingInfo const&
-  scheduling_info_as() const
-  {
-    using info_storage_type = SchedulingInfoStorage<RunnableTaskBase, SchedulingInfo>;
+  KOKKOS_INLINE_FUNCTION SchedulingInfo const& scheduling_info_as() const {
+    using info_storage_type =
+        SchedulingInfoStorage<RunnableTaskBase, SchedulingInfo>;
 
     return static_cast<info_storage_type const*>(this)->scheduling_info();
   }
 
-
   KOKKOS_INLINE_FUNCTION
   task_base_type& get_predecessor() const {
     KOKKOS_EXPECTS(m_predecessor != nullptr);
@@ -522,8 +486,7 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void set_predecessor(task_base_type& predecessor)
-  {
+  void set_predecessor(task_base_type& predecessor) {
     KOKKOS_EXPECTS(m_predecessor == nullptr);
     // Increment the reference count so that predecessor doesn't go away
     // before this task is enqueued.
@@ -533,53 +496,53 @@ public:
   }
 
   KOKKOS_INLINE_FUNCTION
-  void acquire_predecessor_from(runnable_task_type& other)
-  {
-    KOKKOS_EXPECTS(m_predecessor == nullptr || other.m_predecessor == m_predecessor);
+  void acquire_predecessor_from(runnable_task_type& other) {
+    KOKKOS_EXPECTS(m_predecessor == nullptr ||
+                   other.m_predecessor == m_predecessor);
     // since we're transferring, no need to modify the reference count
-    m_predecessor = other.m_predecessor;
+    m_predecessor       = other.m_predecessor;
     other.m_predecessor = nullptr;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void acquire_predecessor_from(runnable_task_type& other) volatile
-  {
-    KOKKOS_EXPECTS(m_predecessor == nullptr || other.m_predecessor == m_predecessor);
+  void acquire_predecessor_from(runnable_task_type& other) volatile {
+    KOKKOS_EXPECTS(m_predecessor == nullptr ||
+                   other.m_predecessor == m_predecessor);
     // since we're transferring, no need to modify the reference count
-    m_predecessor = other.m_predecessor;
+    m_predecessor       = other.m_predecessor;
     other.m_predecessor = nullptr;
   }
 
   template <class TeamMember>
-  KOKKOS_INLINE_FUNCTION
-  void run(TeamMember& member) {
+  KOKKOS_INLINE_FUNCTION void run(TeamMember& member) {
     (*m_apply)(this, &member);
   }
 };
 
-//KOKKOS_IMPL_IS_CONCEPT(runnable_task);
+// KOKKOS_IMPL_IS_CONCEPT(runnable_task);
 
 //==============================================================================
 
 template <class ResultType, class Base>
-class TaskResultStorage : public Base
-{
-private:
-
+class TaskResultStorage : public Base {
+ private:
   using base_t = Base;
 
   alignas(Base) ResultType m_value = ResultType{};
 
-
-public:
-
-  using base_t::base_t;
+ public:
+  // using base_t::base_t;
+  // Can't just do using base_t::base_t because of stupid stuff with clang cuda
+  template <class... Args>
+  // requires std::is_constructible_v<base_t, Args&&...>
+  KOKKOS_INLINE_FUNCTION constexpr explicit TaskResultStorage(Args&&... args)
+      : base_t(std::forward<Args>(args)...) {}
 
   KOKKOS_INLINE_FUNCTION
   ResultType* value_pointer() {
     // Over-alignment makes this a non-standard-layout class,
     // so alignas() doesn't work
-    //static_assert(
+    // static_assert(
     //  offsetof(TaskResultStorage, m_value) == sizeof(Base),
     //  "TaskResultStorage must be POD for layout purposes"
     //);
@@ -588,131 +551,111 @@ public:
 
   KOKKOS_INLINE_FUNCTION
   ResultType& value_reference() { return m_value; }
-
 };
 
-
-// TODO @tasking @optimization DSH optimization for empty types (in addition to void)
+// TODO @tasking @optimization DSH optimization for empty types (in addition to
+// void)
 template <class Base>
-class TaskResultStorage<void, Base> : public Base
-{
-private:
-
+class TaskResultStorage<void, Base> : public Base {
+ private:
   using base_t = Base;
 
-public:
-
-  using base_t::base_t;
+ public:
+  // using base_t::base_t;
+  // Can't just do using base_t::base_t because of stupid stuff with clang cuda
+  template <class... Args>
+  // requires std::is_constructible_v<base_t, Args&&...>
+  KOKKOS_INLINE_FUNCTION constexpr explicit TaskResultStorage(Args&&... args)
+      : base_t(std::forward<Args>(args)...) {}
 
   KOKKOS_INLINE_FUNCTION
   void* value_pointer() noexcept { return nullptr; }
 
   KOKKOS_INLINE_FUNCTION
-  void value_reference() noexcept { }
-
+  void value_reference() noexcept {}
 };
 
 //==============================================================================
 
-template <
-  class TaskQueueTraits,
-  class Scheduler,
-  class ResultType,
-  class FunctorType
->
+template <class TaskQueueTraits, class Scheduler, class ResultType,
+          class FunctorType>
 class alignas(16) RunnableTask
-  : // using nesting of base classes to control layout; multiple empty base classes
-    // may not be ABI compatible with CUDA on Windows
-    public TaskResultStorage<
+    :  // using nesting of base classes to control layout; multiple empty base
+       // classes may not be ABI compatible with CUDA on Windows
+       public TaskResultStorage<
+           ResultType,
+           SchedulingInfoStorage<RunnableTaskBase<TaskQueueTraits>,
+                                 typename Scheduler::task_queue_type::
+                                     task_scheduling_info_type>>,  // must be
+                                                                   // first base
+                                                                   // class
+       public FunctorType {
+ private:
+  using base_t = TaskResultStorage<
       ResultType,
       SchedulingInfoStorage<
-        RunnableTaskBase<TaskQueueTraits>,
-        typename Scheduler::task_queue_type::task_scheduling_info_type
-      >
-    >, // must be first base class
-    public FunctorType
-{
-private:
-  using base_t = TaskResultStorage<
-    ResultType,
-    SchedulingInfoStorage<
-      RunnableTaskBase<TaskQueueTraits>,
-      typename Scheduler::task_queue_type::task_scheduling_info_type
-    >
-  >;
+          RunnableTaskBase<TaskQueueTraits>,
+          typename Scheduler::task_queue_type::task_scheduling_info_type>>;
 
   using runnable_task_base_type = RunnableTaskBase<TaskQueueTraits>;
-  using scheduler_type = Scheduler;
+  using scheduler_type          = Scheduler;
   using scheduling_info_type =
       typename scheduler_type::task_scheduling_info_type;
   using scheduling_info_storage_base = base_t;
 
   using task_base_type = TaskNode<TaskQueueTraits>;
   using specialization = TaskQueueSpecialization<scheduler_type>;
-  using member_type = typename specialization::member_type;
-  using result_type = ResultType;
-  using functor_type = FunctorType;
-
-public:
+  using member_type    = typename specialization::member_type;
+  using result_type    = ResultType;
+  using functor_type   = FunctorType;
 
+ public:
   template <class... Args>
-    // requires std::is_constructible_v<base_t, Args&&...>
-  KOKKOS_INLINE_FUNCTION
-  constexpr explicit
-  RunnableTask(
-    FunctorType&& functor,
-    Args&&... args
-  ) : base_t(
-        std::forward<Args>(args)...
-      ),
-      functor_type(std::move(functor))
-  { }
+  // requires std::is_constructible_v<base_t, Args&&...>
+  KOKKOS_INLINE_FUNCTION constexpr explicit RunnableTask(FunctorType&& functor,
+                                                         Args&&... args)
+      : base_t(std::forward<Args>(args)...), functor_type(std::move(functor)) {}
 
   KOKKOS_INLINE_FUNCTION
   ~RunnableTask() = delete;
 
   KOKKOS_INLINE_FUNCTION
-  void update_scheduling_info(
-    member_type& member
-  ) {
-    // TODO @tasking @generalization DSH call a queue-specific hook here; for now, this info is already updated elsewhere
-    // this->scheduling_info() = member.scheduler().scheduling_info();
+  void update_scheduling_info(member_type& member) {
+    // TODO @tasking @generalization DSH call a queue-specific hook here; for
+    // now, this info is already updated elsewhere this->scheduling_info() =
+    // member.scheduler().scheduling_info();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void apply_functor(member_type* member, void*)
-  {
+  void apply_functor(member_type* member, void*) {
     update_scheduling_info(*member);
     this->functor_type::operator()(*member);
   }
 
   template <typename T>
-  KOKKOS_INLINE_FUNCTION
-  void apply_functor(member_type* member, T* val)
-  {
+  KOKKOS_INLINE_FUNCTION void apply_functor(member_type* member, T* val) {
     update_scheduling_info(*member);
-    //this->functor_type::operator()(*member, *val);
+    // this->functor_type::operator()(*member, *val);
     this->functor_type::operator()(*member, *val);
   }
 
-  KOKKOS_FUNCTION static
-  void destroy( task_base_type * root )
-  {
-    //TaskResult<result_type>::destroy(root);
+  KOKKOS_FUNCTION static void destroy(task_base_type* root) {
+    // TaskResult<result_type>::destroy(root);
   }
 
-  KOKKOS_FUNCTION static
-  void apply(task_base_type* self, void* member_as_void)
-  {
-    using task_type = Impl::RunnableTask<TaskQueueTraits, Scheduler, ResultType, FunctorType>*;
-    auto* const task = static_cast<task_type>(self);
+  KOKKOS_FUNCTION static void apply(task_base_type* self,
+                                    void* member_as_void) {
+    using task_type = Impl::RunnableTask<TaskQueueTraits, Scheduler, ResultType,
+                                         FunctorType>*;
+    auto* const task   = static_cast<task_type>(self);
     auto* const member = reinterpret_cast<member_type*>(member_as_void);
 
-    // Now that we're over-aligning the result storage, this isn't a problem any more
-    //static_assert(std::is_standard_layout<task_type>::value,
+    // Now that we're over-aligning the result storage, this isn't a problem any
+    // more
+    // static_assert(std::is_standard_layout<task_type>::value,
     //  "Tasks must be standard layout"
     //);
-    //static_assert(std::is_pod<task_type>::value,
+    // static_assert(std::is_pod<task_type>::value,
     //  "Tasks must be PODs"
     //);
 
@@ -722,32 +665,30 @@ public:
 
     const bool only_one_thread =
 #if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
-      0 == threadIdx.x && 0 == threadIdx.y ;
+        0 == threadIdx.x && 0 == threadIdx.y;
 #else
-      0 == member->team_rank();
+        0 == member->team_rank();
 #endif
 
     // Ensure that the respawn flag is set to zero
     self->set_respawn_flag(false);
 
-    //task->apply_functor(member, TaskResult<result_type>::ptr(task));
+    // task->apply_functor(member, TaskResult<result_type>::ptr(task));
     task->apply_functor(member, task->value_pointer());
 
     member->team_barrier();
 
-    if ( only_one_thread && !(task->get_respawn_flag()) ) {
+    if (only_one_thread && !(task->get_respawn_flag())) {
       // Did not respawn, destroy the functor to free memory.
       task->functor_type::~functor_type();
       // Cannot destroy and deallocate the task until its dependences
       // have been processed.
     }
   }
-
 };
 
 } /* namespace Impl */
 
-
 } /* namespace Kokkos */
 
 //----------------------------------------------------------------------------
@@ -755,4 +696,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKNODE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskPolicyData.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskPolicyData.hpp
index 85e665fffc169af03b20f17f214dce6c96daaf02..c5b8c2fc686f4365f506149ef2293408ac734de1 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskPolicyData.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskPolicyData.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 //----------------------------------------------------------------------------
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core_fwd.hpp>
 #include <Kokkos_TaskScheduler_fwd.hpp>
@@ -60,23 +61,17 @@ namespace Impl {
 
 //----------------------------------------------------------------------------
 
-template<int TaskEnum, typename DepFutureType>
-struct TaskPolicyWithPredecessor
-{
-private:
-
+template <int TaskEnum, typename DepFutureType>
+struct TaskPolicyWithPredecessor {
+ private:
   DepFutureType m_predecessor;
   Kokkos::TaskPriority m_priority;
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  TaskPolicyWithPredecessor(
-    DepFutureType arg_predecessor,
-    Kokkos::TaskPriority arg_priority
-  ) : m_predecessor(std::move(arg_predecessor)),
-      m_priority(arg_priority)
-  { }
+  TaskPolicyWithPredecessor(DepFutureType arg_predecessor,
+                            Kokkos::TaskPriority arg_priority)
+      : m_predecessor(std::move(arg_predecessor)), m_priority(arg_priority) {}
 
   TaskPolicyWithPredecessor() = delete;
 
@@ -87,61 +82,50 @@ public:
   TaskPolicyWithPredecessor(TaskPolicyWithPredecessor&&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  TaskPolicyWithPredecessor& operator=(TaskPolicyWithPredecessor const&) = default;
+  TaskPolicyWithPredecessor& operator=(TaskPolicyWithPredecessor const&) =
+      default;
 
   KOKKOS_INLINE_FUNCTION
   TaskPolicyWithPredecessor& operator=(TaskPolicyWithPredecessor&&) = default;
-  
+
   KOKKOS_INLINE_FUNCTION
   ~TaskPolicyWithPredecessor() = default;
 
   KOKKOS_INLINE_FUNCTION
-  DepFutureType&& predecessor() && {
-    return std::move(m_predecessor);
-  }
+  DepFutureType&& predecessor() && { return std::move(m_predecessor); }
 
   KOKKOS_INLINE_FUNCTION
   constexpr TaskPriority priority() const { return m_priority; }
 
   KOKKOS_INLINE_FUNCTION
   static constexpr int task_type() noexcept { return TaskEnum; }
-
 };
 
 // TODO @tasking @cleanup DSH clean this up. Using nullptr_t here is too clever
-template<int TaskEnum, typename Scheduler, typename PredecessorFuture=std::nullptr_t>
-struct TaskPolicyWithScheduler
-{
-public:
-
+template <int TaskEnum, typename Scheduler,
+          typename PredecessorFuture = std::nullptr_t>
+struct TaskPolicyWithScheduler {
+ public:
   using predecessor_future_type = PredecessorFuture;
 
-private:
-
+ private:
   Scheduler m_scheduler;
   Kokkos::TaskPriority m_priority;
   predecessor_future_type m_predecessor;
 
-public:
-
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  TaskPolicyWithScheduler(
-    Scheduler arg_scheduler,
-    Kokkos::TaskPriority arg_priority
-  ) : m_scheduler(std::move(arg_scheduler)),
-      m_priority(arg_priority)
-  { }
+  TaskPolicyWithScheduler(Scheduler arg_scheduler,
+                          Kokkos::TaskPriority arg_priority)
+      : m_scheduler(std::move(arg_scheduler)), m_priority(arg_priority) {}
 
   KOKKOS_INLINE_FUNCTION
-  TaskPolicyWithScheduler(
-    Scheduler arg_scheduler,
-    predecessor_future_type arg_predecessor,
-    Kokkos::TaskPriority arg_priority
-  ) : m_scheduler(std::move(arg_scheduler)),
-      m_priority(arg_priority),
-      m_predecessor(std::move(arg_predecessor))
-  { }
+  TaskPolicyWithScheduler(Scheduler arg_scheduler,
+                          predecessor_future_type arg_predecessor,
+                          Kokkos::TaskPriority arg_priority)
+      : m_scheduler(std::move(arg_scheduler)),
+        m_priority(arg_priority),
+        m_predecessor(std::move(arg_predecessor)) {}
 
   TaskPolicyWithScheduler() = delete;
 
@@ -150,10 +134,10 @@ public:
 
   KOKKOS_INLINE_FUNCTION
   TaskPolicyWithScheduler(TaskPolicyWithScheduler&&) = default;
- 
+
   KOKKOS_INLINE_FUNCTION
   TaskPolicyWithScheduler& operator=(TaskPolicyWithScheduler const&) = default;
-  
+
   KOKKOS_INLINE_FUNCTION
   TaskPolicyWithScheduler& operator=(TaskPolicyWithScheduler&&) = default;
 
@@ -161,35 +145,28 @@ public:
   ~TaskPolicyWithScheduler() = default;
 
   KOKKOS_INLINE_FUNCTION
-  Scheduler& scheduler() & {
-    return m_scheduler;
-  }
+  Scheduler& scheduler() & { return m_scheduler; }
 
   KOKKOS_INLINE_FUNCTION
   constexpr TaskPriority priority() const { return m_priority; }
 
   KOKKOS_INLINE_FUNCTION
-  predecessor_future_type& predecessor() & {
-    return m_predecessor;
-  }
+  predecessor_future_type& predecessor() & { return m_predecessor; }
 
   KOKKOS_INLINE_FUNCTION
-  static constexpr bool has_predecessor() noexcept
-  {
+  static constexpr bool has_predecessor() noexcept {
     return not std::is_same<PredecessorFuture, std::nullptr_t>::value;
   }
 
   KOKKOS_INLINE_FUNCTION
   static constexpr int task_type() noexcept { return TaskEnum; }
-
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKPOLICYDATA_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskQueue.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskQueue.hpp
index 1adcfe4cc4ca3215636af44d390049dafdc7b67d..f7787dae0cf07dd4764c524172199b29f2ecd80d 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskQueue.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskQueue.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,8 +48,7 @@
 #define KOKKOS_IMPL_TASKQUEUE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
-
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -67,23 +67,20 @@
 #include <typeinfo>
 #include <stdexcept>
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-
 /** \brief  Manage task allocation, deallocation, and scheduling.
  *
  *  Task execution is deferred to the TaskQueueSpecialization.
  *  All other aspects of task management have shared implementation.
  */
-template< typename ExecSpace, typename MemorySpace >
+template <typename ExecSpace, typename MemorySpace>
 class TaskQueue : public TaskQueueBase {
-protected:
-
+ protected:
   template <class>
   friend struct TaskQueueSpecialization;
   template <class, class>
@@ -92,14 +89,14 @@ protected:
   friend class Kokkos::BasicTaskScheduler;
 
   using execution_space = ExecSpace;
-  using memory_space = MemorySpace;
-  using device_type = Kokkos::Device< execution_space , memory_space > ;
-  using memory_pool = Kokkos::MemoryPool< device_type > ;
-  using task_root_type = Kokkos::Impl::TaskBase;
+  using memory_space    = MemorySpace;
+  using device_type     = Kokkos::Device<execution_space, memory_space>;
+  using memory_pool     = Kokkos::MemoryPool<device_type>;
+  using task_root_type  = Kokkos::Impl::TaskBase;
   using team_queue_type = TaskQueue;
 
   struct Destroy {
-    TaskQueue * m_queue ;
+    TaskQueue* m_queue;
     void destroy_shared_allocation();
   };
 
@@ -109,23 +106,24 @@ protected:
 
   // Queue is organized as [ priority ][ type ]
 
-  memory_pool               m_memory ;
-  task_root_type * volatile m_ready[ NumQueue ][ 2 ];
-  //long                      m_accum_alloc ; // Accumulated number of allocations
-  int                       m_count_alloc = 0 ; // Current number of allocations
-  int                       m_max_alloc ;   // Maximum number of allocations
-  int                       m_ready_count ; // Number of ready or executing
+  memory_pool m_memory;
+  task_root_type* volatile m_ready[NumQueue][2];
+  // long                      m_accum_alloc ; // Accumulated number of
+  // allocations
+  int m_count_alloc = 0;  // Current number of allocations
+  int m_max_alloc;        // Maximum number of allocations
+  int m_ready_count;      // Number of ready or executing
 
   //----------------------------------------
 
   ~TaskQueue();
-  TaskQueue() = delete ;
-  TaskQueue( TaskQueue && ) = delete ;
-  TaskQueue( TaskQueue const & ) = delete ;
-  TaskQueue & operator = ( TaskQueue && ) = delete ;
-  TaskQueue & operator = ( TaskQueue const & ) = delete ;
+  TaskQueue()                 = delete;
+  TaskQueue(TaskQueue&&)      = delete;
+  TaskQueue(TaskQueue const&) = delete;
+  TaskQueue& operator=(TaskQueue&&) = delete;
+  TaskQueue& operator=(TaskQueue const&) = delete;
 
-  TaskQueue( const memory_pool & arg_memory_pool );
+  TaskQueue(const memory_pool& arg_memory_pool);
 
   // Schedule a task
   //   Precondition:
@@ -144,7 +142,7 @@ protected:
   //     task is in Executing-Respawn state
   //     task->m_next == 0 (no dependence)
   KOKKOS_FUNCTION
-  void reschedule( task_root_type * );
+  void reschedule(task_root_type*);
 
   // Complete a task
   //   Precondition:
@@ -155,27 +153,22 @@ protected:
   //     task->m_wait == LockTag  =>  task is complete
   //     task->m_wait != LockTag  =>  task is waiting
   KOKKOS_FUNCTION
-  void complete( task_root_type * );
+  void complete(task_root_type*);
 
   KOKKOS_FUNCTION
-  static bool push_task( task_root_type * volatile * const
-                       , task_root_type * const );
+  static bool push_task(task_root_type* volatile* const, task_root_type* const);
 
   KOKKOS_FUNCTION
-  static task_root_type * pop_ready_task( task_root_type * volatile * const );
-
-  KOKKOS_FUNCTION static
-  void decrement( task_root_type * task );
+  static task_root_type* pop_ready_task(task_root_type* volatile* const);
 
+  KOKKOS_FUNCTION static void decrement(task_root_type* task);
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
   int allocation_count() const noexcept { return m_count_alloc; }
 
-
   KOKKOS_INLINE_FUNCTION
-  void initialize_team_queues(int pool_size) const noexcept { }
+  void initialize_team_queues(int pool_size) const noexcept {}
 
   KOKKOS_INLINE_FUNCTION
   task_root_type* attempt_to_steal_task() const noexcept { return nullptr; }
@@ -183,21 +176,18 @@ public:
   KOKKOS_INLINE_FUNCTION
   team_queue_type& get_team_queue(int team_rank) { return *this; }
 
-  //void execute() { specialization::execute( this ); }
+  // void execute() { specialization::execute( this ); }
 
-  template< typename FunctorType >
-  void proc_set_apply( typename task_root_type::function_type * ptr )
-    {
-      using specialization =
+  template <typename FunctorType>
+  void proc_set_apply(typename task_root_type::function_type* ptr) {
+    using specialization =
         TaskQueueSpecialization<BasicTaskScheduler<ExecSpace, TaskQueue>>;
-      specialization::template proc_set_apply< FunctorType >( ptr );
-    }
+    specialization::template proc_set_apply<FunctorType>(ptr);
+  }
 
   // Assign task pointer with reference counting of assigned tasks
-  KOKKOS_FUNCTION static
-  void assign( task_root_type ** const lhs
-             , task_root_type *  const rhs )
-    {
+  KOKKOS_FUNCTION static void assign(task_root_type** const lhs,
+                                     task_root_type* const rhs) {
 #if 0
   {
     printf( "assign( 0x%lx { 0x%lx %d %d } , 0x%lx { 0x%lx %d %d } )\n"
@@ -214,54 +204,54 @@ public:
   }
 #endif
 
-      if ( *lhs ) decrement( *lhs );
-      if ( rhs ) { Kokkos::atomic_increment( &(rhs->m_ref_count) ); }
+    if (*lhs) decrement(*lhs);
+    if (rhs) {
+      Kokkos::atomic_increment(&(rhs->m_ref_count));
+    }
 
-      // Force write of *lhs
+    // Force write of *lhs
 
-      *static_cast< task_root_type * volatile * >(lhs) = rhs ;
+    *static_cast<task_root_type* volatile*>(lhs) = rhs;
 
-      Kokkos::memory_fence();
-    }
+    Kokkos::memory_fence();
+  }
 
   KOKKOS_FUNCTION
-  size_t allocate_block_size( size_t n ); ///< Actual block size allocated
+  size_t allocate_block_size(size_t n);  ///< Actual block size allocated
 
   KOKKOS_FUNCTION
-  void * allocate( size_t n ); ///< Allocate from the memory pool
+  void* allocate(size_t n);  ///< Allocate from the memory pool
 
   KOKKOS_FUNCTION
-  void deallocate( void * p , size_t n ); ///< Deallocate to the memory pool
-
+  void deallocate(void* p, size_t n);  ///< Deallocate to the memory pool
 
   //----------------------------------------
   /**\brief  Allocation size for a spawned task */
 
-  template< typename FunctorType >
-  KOKKOS_FUNCTION
-  size_t spawn_allocation_size() const
-    {
-      using value_type = typename FunctorType::value_type ;
+  template <typename FunctorType>
+  KOKKOS_FUNCTION size_t spawn_allocation_size() const {
+    using value_type = typename FunctorType::value_type;
 
-      using task_type = Impl::Task<execution_space, value_type, FunctorType> ;
+    using task_type = Impl::Task<execution_space, value_type, FunctorType>;
 
-      enum : size_t { align = ( 1 << 4 ) , align_mask = align - 1 };
-      enum : size_t { task_size   = sizeof(task_type) };
-      enum : size_t { result_size = Impl::TaskResult< value_type >::size };
-      enum : size_t { alloc_size =
-        ( ( task_size   + align_mask ) & ~align_mask ) +
-        ( ( result_size + align_mask ) & ~align_mask ) };
+    enum : size_t { align = (1 << 4), align_mask = align - 1 };
+    enum : size_t { task_size = sizeof(task_type) };
+    enum : size_t { result_size = Impl::TaskResult<value_type>::size };
+    enum : size_t {
+      alloc_size = ((task_size + align_mask) & ~align_mask) +
+                   ((result_size + align_mask) & ~align_mask)
+    };
 
-      return m_memory.allocate_block_size( task_size );
-    }
+    return m_memory.allocate_block_size(task_size);
+  }
 
   /**\brief  Allocation size for a when_all aggregate */
 
   KOKKOS_FUNCTION
-  size_t when_all_allocation_size( int narg ) const
-    {
-      return m_memory.allocate_block_size( sizeof(task_root_type) + narg * sizeof(task_root_type*) );
-    }
+  size_t when_all_allocation_size(int narg) const {
+    return m_memory.allocate_block_size(sizeof(task_root_type) +
+                                        narg * sizeof(task_root_type*));
+  }
 };
 
 } /* namespace Impl */
@@ -272,4 +262,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKQUEUE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskQueueCommon.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskQueueCommon.hpp
index b0685506d45b846e69de62721aee1131cb46edfd..b3444420d613280da831083dbcd3e8a628270b02 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskQueueCommon.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskQueueCommon.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,8 +46,7 @@
 #define KOKKOS_IMPL_TASKQUEUECOMMON_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
-
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -66,34 +66,30 @@
 #include <typeinfo>
 #include <stdexcept>
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-/// @brief CRTP Base class implementing the ready count parts common to most task queues
+/// @brief CRTP Base class implementing the ready count parts common to most
+/// task queues
 template <class Derived>
-class TaskQueueCommonMixin
-{
-private:
-
+class TaskQueueCommonMixin {
+ private:
   int32_t m_ready_count = 0;
 
   // CRTP boilerplate
   KOKKOS_INLINE_FUNCTION
   Derived& _self() { return *static_cast<Derived*>(this); }
 
-public:
-
+ public:
   //----------------------------------------------------------------------------
   // <editor-fold desc="Constructors, destructor, and assignment"> {{{2
 
-  TaskQueueCommonMixin()
-    : m_ready_count(0)
-  {
-    // TODO @tasking @memory_order DSH figure out if I need this store to be atomic
+  TaskQueueCommonMixin() : m_ready_count(0) {
+    // TODO @tasking @memory_order DSH figure out if I need this store to be
+    // atomic
   }
 
   ~TaskQueueCommonMixin() {
@@ -104,12 +100,10 @@ public:
   // </editor-fold> end Constructors, destructor, and assignment }}}2
   //----------------------------------------------------------------------------
 
-
   //----------------------------------------------------------------------------
   // <editor-fold desc="Task and queue completion"> {{{2
 
-private:
-
+ private:
   // This would be more readable with a lambda, but that comes with
   // all the baggage associated with a lambda (compilation times, bugs with
   // nvcc, etc.), so we'll use a simple little helper functor here.
@@ -120,57 +114,43 @@ private:
     TeamSchedulerInfo const& m_info;
     KOKKOS_INLINE_FUNCTION
     void operator()(TaskNode<TaskQueueTraits>&& task) const noexcept
-      // requires Same<TaskType, Derived::task_base_type>
+    // requires Same<TaskType, Derived::task_base_type>
     {
-      using task_scheduling_info_type = typename Derived::task_scheduling_info_type;
-      if(task.is_runnable()) // KOKKOS_LIKELY
+      using task_scheduling_info_type =
+          typename Derived::task_scheduling_info_type;
+      if (task.is_runnable())  // KOKKOS_LIKELY
       {
         // TODO @tasking @optimiazation DSH check this outside of the loop ?
-        if(m_predecessor.is_runnable()) {
+        if (m_predecessor.is_runnable()) {
           m_queue.update_scheduling_info_from_completed_predecessor(
-            /* ready_task = */ task.as_runnable_task(),
-            /* predecessor = */ m_predecessor.as_runnable_task()
-          );
-        }
-        else {
+              /* ready_task = */ task.as_runnable_task(),
+              /* predecessor = */ m_predecessor.as_runnable_task());
+        } else {
           KOKKOS_ASSERT(m_predecessor.is_aggregate());
           m_queue.update_scheduling_info_from_completed_predecessor(
-            /* ready_task = */ task.as_runnable_task(),
-            /* predecessor = */ m_predecessor.template as_aggregate<task_scheduling_info_type>()
-          );
+              /* ready_task = */ task.as_runnable_task(),
+              /* predecessor = */ m_predecessor
+                  .template as_aggregate<task_scheduling_info_type>());
         }
-        m_queue.schedule_runnable(
-          std::move(task).as_runnable_task(),
-          m_info
-        );
-      }
-      else {
+        m_queue.schedule_runnable(std::move(task).as_runnable_task(), m_info);
+      } else {
         // The scheduling info update happens inside of schedule_aggregate
         m_queue.schedule_aggregate(
-          std::move(task).template as_aggregate<task_scheduling_info_type>(),
-          m_info
-        );
+            std::move(task).template as_aggregate<task_scheduling_info_type>(),
+            m_info);
       }
     }
   };
 
-protected:
-
+ protected:
   template <class TaskQueueTraits, class TeamSchedulerInfo>
-  KOKKOS_FUNCTION
-  void _complete_finished_task(
-    TaskNode<TaskQueueTraits>&& task,
-    TeamSchedulerInfo const& info
-  ) {
+  KOKKOS_FUNCTION void _complete_finished_task(TaskNode<TaskQueueTraits>&& task,
+                                               TeamSchedulerInfo const& info) {
     task.consume_wait_queue(
-      _schedule_waiting_tasks_operation<TaskQueueTraits, TeamSchedulerInfo>{
-        task,
-        _self(),
-        info
-      }
-    );
+        _schedule_waiting_tasks_operation<TaskQueueTraits, TeamSchedulerInfo>{
+            task, _self(), info});
     bool should_delete = task.decrement_and_check_reference_count();
-    if(should_delete) {
+    if (should_delete) {
       _self().deallocate(std::move(task));
     }
   }
@@ -188,8 +168,7 @@ protected:
     Kokkos::memory_fence();
   }
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
   bool is_done() const noexcept {
     // TODO @tasking @memory_order DSH Memory order, instead of volatile
@@ -203,17 +182,11 @@ public:
   }
 
   template <class TaskQueueTraits, class TeamSchedulerInfo>
-  KOKKOS_FUNCTION
-  void
-  complete(
-    RunnableTaskBase<TaskQueueTraits>&& task,
-    TeamSchedulerInfo const& info
-  )
-  {
-    if(task.get_respawn_flag()) {
+  KOKKOS_FUNCTION void complete(RunnableTaskBase<TaskQueueTraits>&& task,
+                                TeamSchedulerInfo const& info) {
+    if (task.get_respawn_flag()) {
       _self().schedule_runnable(std::move(task), info);
-    }
-    else {
+    } else {
       _complete_finished_task(std::move(task), info);
     }
     // A runnable task was popped from a ready queue finished executing.
@@ -227,38 +200,31 @@ public:
     _decrement_ready_count();
   }
 
-  template <class TaskQueueTraits, class SchedulingInfo, class TeamSchedulerInfo>
-  KOKKOS_FUNCTION
-  void
-  complete(
-    AggregateTask<TaskQueueTraits, SchedulingInfo>&& task,
-    TeamSchedulerInfo const& info
-  ) {
-    // TODO @tasking DSH old code has a ifndef __HCC_ACCELERATOR__ here; figure out why
+  template <class TaskQueueTraits, class SchedulingInfo,
+            class TeamSchedulerInfo>
+  KOKKOS_FUNCTION void complete(
+      AggregateTask<TaskQueueTraits, SchedulingInfo>&& task,
+      TeamSchedulerInfo const& info) {
+    // TODO @tasking DSH old code has a ifndef __HCC_ACCELERATOR__ here; figure
+    // out why
     _complete_finished_task(std::move(task), info);
   }
 
   // </editor-fold> end Task and queue completion }}}2
   //----------------------------------------------------------------------------
 
-
   //----------------------------------------------------------------------------
   // <editor-fold desc="Scheduling"> {{{2
 
-public:
-
+ public:
   // This isn't actually generic; the template parameters are just to keep
   // Derived from having to be complete
-  template <class TaskQueueTraits, class ReadyQueueType, class TeamSchedulerInfo>
-  KOKKOS_INLINE_FUNCTION
-  void
-  schedule_runnable_to_queue(
-    RunnableTaskBase<TaskQueueTraits>&& task,
-    ReadyQueueType& ready_queue,
-    TeamSchedulerInfo const& info
-  )
-  {
-    bool task_is_ready = true;
+  template <class TaskQueueTraits, class ReadyQueueType,
+            class TeamSchedulerInfo>
+  KOKKOS_INLINE_FUNCTION void schedule_runnable_to_queue(
+      RunnableTaskBase<TaskQueueTraits>&& task, ReadyQueueType& ready_queue,
+      TeamSchedulerInfo const& info) {
+    bool task_is_ready           = true;
     bool scheduling_info_updated = false;
 
     // do this before enqueueing and potentially losing exclusive access to task
@@ -269,19 +235,21 @@ public:
     // thread to access it might be a Cuda thread from a different thread block.
     ((RunnableTaskBase<TaskQueueTraits> volatile&)task).set_respawn_flag(false);
 
-    if(task.has_predecessor()) {
+    if (task.has_predecessor()) {
       // save the predecessor into a local variable, then clear it from the
       // task before adding it to the wait queue of the predecessor
       // (We have exclusive access to the task's predecessor, so we don't need
       // to do this atomically)
-      // TODO @tasking @internal_documentation DSH document that we expect exclusive access to `task` in this function
+      // TODO @tasking @internal_documentation DSH document that we expect
+      // exclusive access to `task` in this function
       auto& predecessor = task.get_predecessor();
       // This needs a load/store fence here, technically
       // making this a release store would also do this
       ((RunnableTaskBase<TaskQueueTraits> volatile&)task).clear_predecessor();
 
-      // TODO @tasking @memory_order DSH remove this fence in favor of memory orders
-      Kokkos::memory_fence(); // for now
+      // TODO @tasking @memory_order DSH remove this fence in favor of memory
+      // orders
+      Kokkos::memory_fence();  // for now
 
       // Try to add the task to the predecessor's waiting queue.  If it fails,
       // the predecessor is already done
@@ -293,17 +261,16 @@ public:
       // If the predecessor is not done, then task is not ready
       task_is_ready = not predecessor_not_ready;
 
-      if(task_is_ready and predecessor.is_runnable()) {
+      if (task_is_ready and predecessor.is_runnable()) {
         // this is our last chance to update the scheduling info before
         // predecessor is potentially deleted
         _self().update_scheduling_info_from_completed_predecessor(
-          /* ready_task = */ task,
-          /* predecessor = */ predecessor.as_runnable_task()
-        );
+            /* ready_task = */ task,
+            /* predecessor = */ predecessor.as_runnable_task());
         scheduling_info_updated = true;
       }
 
-      if(task_is_respawning) {
+      if (task_is_respawning) {
         // Reference count for predecessor was incremented when
         // respawn called set_dependency()
         // so that if predecessor completed prior to the
@@ -311,7 +278,7 @@ public:
         // predecessor reference count can now be decremented,
         // which may deallocate it.
         bool should_delete = predecessor.decrement_and_check_reference_count();
-        if(should_delete) {
+        if (should_delete) {
           // TODO @tasking @cleanup DSH better encapsulation of this!
           _self().deallocate(std::move(predecessor));
         }
@@ -320,22 +287,21 @@ public:
       // here
     }
 
-    if(scheduling_info_updated) {
+    if (scheduling_info_updated) {
       // We need to go back to the queue itself and see if it wants to schedule
       // somewhere else
       _self().schedule_runnable(std::move(task), info);
     }
     // Put it in the appropriate ready queue if it's ready
-    else if(task_is_ready) {
+    else if (task_is_ready) {
       // Increment the ready count
       _self()._increment_ready_count();
       // and enqueue the task
       // (can't move because the task isn't expired unless the push succeeds
       bool push_success = ready_queue.push(task);
-      if(not push_success) {
-        _self().handle_failed_ready_queue_insertion(
-          std::move(task), ready_queue, info
-        );
+      if (not push_success) {
+        _self().handle_failed_ready_queue_insertion(std::move(task),
+                                                    ready_queue, info);
       }
     }
 
@@ -343,46 +309,38 @@ public:
     // the use of move semantics)
   }
 
-  template <class TaskQueueTraits, class ReadyQueueType, class TeamSchedulerInfo>
-  KOKKOS_INLINE_FUNCTION
-  void
-  handle_failed_ready_queue_insertion(
-    RunnableTaskBase<TaskQueueTraits>&& task,
-    ReadyQueueType& ready_queue,
-    TeamSchedulerInfo const& info
-  ) {
+  template <class TaskQueueTraits, class ReadyQueueType,
+            class TeamSchedulerInfo>
+  KOKKOS_INLINE_FUNCTION void handle_failed_ready_queue_insertion(
+      RunnableTaskBase<TaskQueueTraits>&& task, ReadyQueueType& ready_queue,
+      TeamSchedulerInfo const& info) {
     Kokkos::abort("Unhandled failure of ready task queue insertion!\n");
   }
 
   // This isn't actually generic; the template parameters are just to keep
   // Derived from having to be complete
-  template <class TaskQueueTraits, class SchedulingInfo, class TeamSchedulerInfo>
-  KOKKOS_FUNCTION
-  void
-  schedule_aggregate(
-    AggregateTask<TaskQueueTraits, SchedulingInfo>&& aggregate,
-    TeamSchedulerInfo const& info
-  )
-  {
+  template <class TaskQueueTraits, class SchedulingInfo,
+            class TeamSchedulerInfo>
+  KOKKOS_FUNCTION void schedule_aggregate(
+      AggregateTask<TaskQueueTraits, SchedulingInfo>&& aggregate,
+      TeamSchedulerInfo const& info) {
     // Because the aggregate is being scheduled, should not be in any queue
     KOKKOS_EXPECTS(not aggregate.is_enqueued());
 
-    using task_scheduling_info_type = typename Derived::task_scheduling_info_type;
+    using task_scheduling_info_type =
+        typename Derived::task_scheduling_info_type;
     using team_scheduler_info_type = typename Derived::team_scheduler_info_type;
     static_assert(
-      std::is_same<TeamSchedulerInfo, team_scheduler_info_type>::value,
-      "SchedulingInfo type mismatch!"
-    );
+        std::is_same<TeamSchedulerInfo, team_scheduler_info_type>::value,
+        "SchedulingInfo type mismatch!");
 
     bool incomplete_dependence_found = false;
 
-    for(auto*& predecessor_ptr_ref : aggregate) {
-
+    for (auto*& predecessor_ptr_ref : aggregate) {
       // if a previous scheduling operation hasn't already set the predecessor
-      // to nullptr, try to enqueue the aggregate into the predecessorendence's waiting
-      // queue
-      if(predecessor_ptr_ref != nullptr) {
-
+      // to nullptr, try to enqueue the aggregate into the predecessorendence's
+      // waiting queue
+      if (predecessor_ptr_ref != nullptr) {
         // Swap the pointer onto the stack and set the one in the aggregate VLA
         // to nullptr before we try to add it to the waiting queue so that some
         // other thread doesn't also get to here and find the pointer to be
@@ -392,14 +350,16 @@ public:
         // exclusive access to aggregate until an insertion succeeds
         auto* predecessor_ptr = std::move(predecessor_ptr_ref);
 
-        // TODO @tasking @memory_order DSH I think this needs to be a store release so that it doesn't get reordered after the queue insertion
+        // TODO @tasking @memory_order DSH I think this needs to be a store
+        // release so that it doesn't get reordered after the queue insertion
         predecessor_ptr_ref = nullptr;
 
-        // TODO @tasking @memory_order DSH remove this fence in favor of memory orders
+        // TODO @tasking @memory_order DSH remove this fence in favor of memory
+        // orders
         Kokkos::memory_fence();
 
-        // If adding the aggregate to the waiting queue succeeds, the predecessor is not
-        // complete
+        // If adding the aggregate to the waiting queue succeeds, the
+        // predecessor is not complete
         bool pred_not_ready = predecessor_ptr->try_add_waiting(aggregate);
 
         // NOTE! At this point it is unsafe to access aggregate (unless the
@@ -409,85 +369,79 @@ public:
         // ready yet
         incomplete_dependence_found = pred_not_ready;
 
-        if(not pred_not_ready) {
+        if (not pred_not_ready) {
           // A predecessor was done, and we didn't enqueue the aggregate
           // Update the aggregate's scheduling info (we still have exclusive
           // access to it here)
-          if(predecessor_ptr->is_runnable()) {
+          if (predecessor_ptr->is_runnable()) {
             _self().update_scheduling_info_from_completed_predecessor(
-              aggregate, predecessor_ptr->as_runnable_task()
-            );
-          }
-          else {
+                aggregate, predecessor_ptr->as_runnable_task());
+          } else {
             KOKKOS_ASSERT(predecessor_ptr->is_aggregate());
             _self().update_scheduling_info_from_completed_predecessor(
-              aggregate, (*predecessor_ptr).template as_aggregate<task_scheduling_info_type>()
-            );
+                aggregate,
+                (*predecessor_ptr)
+                    .template as_aggregate<task_scheduling_info_type>());
           }
         }
 
         // the reference count for the predecessor was incremented when we put
         // it into the predecessor list, so decrement it here
-        bool should_delete = predecessor_ptr->decrement_and_check_reference_count();
-        if(should_delete) {
+        bool should_delete =
+            predecessor_ptr->decrement_and_check_reference_count();
+        if (should_delete) {
           // TODO @tasking @cleanup DSH better encapsulation of this!
           _self().deallocate(std::move(*predecessor_ptr));
         }
 
         // Stop the loop if we found an incomplete dependence
-        if(incomplete_dependence_found) break;
+        if (incomplete_dependence_found) break;
       }
     }
 
-    // NOTE: it's not safe to access aggregate any more if an incomplete dependence
-    // was found, because some other thread could have already popped it off
-    // of another waiting queue
+    // NOTE: it's not safe to access aggregate any more if an incomplete
+    // dependence was found, because some other thread could have already popped
+    // it off of another waiting queue
 
-    if(not incomplete_dependence_found) {
+    if (not incomplete_dependence_found) {
       // all of the predecessors were completed, so we can complete `task`
       _self().complete(std::move(aggregate), info);
     }
-    // Note!! task may have been deleted at this point, so don't add anything here!
+    // Note!! task may have been deleted at this point, so don't add anything
+    // here!
   }
 
   // Provide a sensible default that can be overridden
   template <class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION
-  void update_scheduling_info_from_completed_predecessor(
-    RunnableTaskBase<TaskQueueTraits>& ready_task,
-    RunnableTaskBase<TaskQueueTraits> const& predecessor
-  ) const
-  {
+  KOKKOS_INLINE_FUNCTION void update_scheduling_info_from_completed_predecessor(
+      RunnableTaskBase<TaskQueueTraits>& ready_task,
+      RunnableTaskBase<TaskQueueTraits> const& predecessor) const {
     // by default, tell a ready task to use the scheduling info of its most
     // recent predecessor
-    using task_scheduling_info_type = typename Derived::task_scheduling_info_type;
+    using task_scheduling_info_type =
+        typename Derived::task_scheduling_info_type;
     ready_task.template scheduling_info_as<task_scheduling_info_type>() =
-      predecessor.template scheduling_info_as<task_scheduling_info_type>();
+        predecessor.template scheduling_info_as<task_scheduling_info_type>();
   }
 
   // Provide a sensible default that can be overridden
   template <class SchedulingInfo, class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION
-  void update_scheduling_info_from_completed_predecessor(
-    AggregateTask<TaskQueueTraits, SchedulingInfo>& aggregate,
-    RunnableTaskBase<TaskQueueTraits> const& predecessor
-  ) const
-  {
+  KOKKOS_INLINE_FUNCTION void update_scheduling_info_from_completed_predecessor(
+      AggregateTask<TaskQueueTraits, SchedulingInfo>& aggregate,
+      RunnableTaskBase<TaskQueueTraits> const& predecessor) const {
     // by default, tell a ready task to use the scheduling info of its most
     // recent predecessor
-    using task_scheduling_info_type = typename Derived::task_scheduling_info_type;
+    using task_scheduling_info_type =
+        typename Derived::task_scheduling_info_type;
     aggregate.scheduling_info() =
-      predecessor.template scheduling_info_as<task_scheduling_info_type>();
+        predecessor.template scheduling_info_as<task_scheduling_info_type>();
   }
 
   // Provide a sensible default that can be overridden
   template <class SchedulingInfo, class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION
-  void update_scheduling_info_from_completed_predecessor(
-    AggregateTask<TaskQueueTraits, SchedulingInfo>& aggregate,
-    AggregateTask<TaskQueueTraits, SchedulingInfo> const& predecessor
-  ) const
-  {
+  KOKKOS_INLINE_FUNCTION void update_scheduling_info_from_completed_predecessor(
+      AggregateTask<TaskQueueTraits, SchedulingInfo>& aggregate,
+      AggregateTask<TaskQueueTraits, SchedulingInfo> const& predecessor) const {
     // by default, tell a ready task to use the scheduling info of its most
     // recent predecessor
     aggregate.scheduling_info() = predecessor.scheduling_info();
@@ -495,67 +449,50 @@ public:
 
   // Provide a sensible default that can be overridden
   template <class SchedulingInfo, class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION
-  void update_scheduling_info_from_completed_predecessor(
-    RunnableTaskBase<TaskQueueTraits>& ready_task,
-    AggregateTask<TaskQueueTraits, SchedulingInfo> const& predecessor
-  ) const
-  {
+  KOKKOS_INLINE_FUNCTION void update_scheduling_info_from_completed_predecessor(
+      RunnableTaskBase<TaskQueueTraits>& ready_task,
+      AggregateTask<TaskQueueTraits, SchedulingInfo> const& predecessor) const {
     // by default, tell a ready task to use the scheduling info of its most
     // recent predecessor
-    using task_scheduling_info_type = typename Derived::task_scheduling_info_type;
+    using task_scheduling_info_type =
+        typename Derived::task_scheduling_info_type;
     ready_task.template scheduling_info_as<task_scheduling_info_type>() =
-      predecessor.scheduling_info();
+        predecessor.scheduling_info();
   }
 
   template <class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION
-  void initialize_scheduling_info_from_predecessor(
-    TaskNode<TaskQueueTraits>& task,
-    TaskNode<TaskQueueTraits>& predecessor
-  ) const
-  {
+  KOKKOS_INLINE_FUNCTION void initialize_scheduling_info_from_predecessor(
+      TaskNode<TaskQueueTraits>& task,
+      TaskNode<TaskQueueTraits>& predecessor) const {
     /* do nothing by default */
   }
 
   template <class TeamSchedulerInfo, class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION
-  void initialize_scheduling_info_from_team_scheduler_info(
-    TaskNode<TaskQueueTraits>& task,
-    TeamSchedulerInfo const& info
-  ) const
-  {
+  KOKKOS_INLINE_FUNCTION void
+  initialize_scheduling_info_from_team_scheduler_info(
+      TaskNode<TaskQueueTraits>& task, TeamSchedulerInfo const& info) const {
     /* do nothing by default */
   }
 
-  template <
-    class ExecutionSpace,
-    class MemorySpace,
-    class MemoryPool
-  >
-  static /* KOKKOS_CONSTEXPR_14 */ size_t
-  task_queue_allocation_size(
-    ExecutionSpace const&,
-    MemorySpace const&,
-    MemoryPool const&
-  )
-    // requires Same<ExecutionSpace, typename Derived::execution_space>
-    //            && Same<MemorySpace, typename Derived::memory_space>
-    //            && Same<MemoryPool, typename Derived::memory_pool>
+  template <class ExecutionSpace, class MemorySpace, class MemoryPool>
+  static /* KOKKOS_CONSTEXPR_14 */ size_t task_queue_allocation_size(
+      ExecutionSpace const&, MemorySpace const&, MemoryPool const&)
+  // requires Same<ExecutionSpace, typename Derived::execution_space>
+  //            && Same<MemorySpace, typename Derived::memory_space>
+  //            && Same<MemoryPool, typename Derived::memory_pool>
   {
     static_assert(
-      std::is_same<ExecutionSpace, typename Derived::execution_space>::value
-        && std::is_same<MemorySpace, typename Derived::memory_space>::value
-        && std::is_same<MemoryPool, typename Derived::memory_pool>::value,
-      "Type mismatch in task_queue_allocation_size customization point"
-    );
+        std::is_same<ExecutionSpace,
+                     typename Derived::execution_space>::value &&
+            std::is_same<MemorySpace, typename Derived::memory_space>::value &&
+            std::is_same<MemoryPool, typename Derived::memory_pool>::value,
+        "Type mismatch in task_queue_allocation_size customization point");
 
     return sizeof(Derived);
   }
 
   // </editor-fold> end Scheduling }}}2
   //----------------------------------------------------------------------------
-
 };
 
 } /* namespace Impl */
@@ -566,4 +503,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKQUEUECOMMON_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp
index c3ed1d6c71687cdf9768e4e21d7b6302724cb569..6e2481f93567a671a5ad66f3536b45c009286eca 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,8 +46,7 @@
 #define KOKKOS_IMPL_TASKQUEUEMEMORYMANAGER_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
-
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -65,36 +65,29 @@
 #include <typeinfo>
 #include <stdexcept>
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-template <
-  class ExecSpace,
-  class MemorySpace,
-  class MemoryPool = Kokkos::MemoryPool<Kokkos::Device<ExecSpace, MemorySpace>>
->
-class TaskQueueMemoryManager
-  : public TaskQueueBase
-{
-public:
-
-  using execution_space = ExecSpace;
-  using memory_space = MemorySpace;
-  using device_type = Kokkos::Device<execution_space, memory_space>;
-  using memory_pool = MemoryPool;
+template <class ExecSpace, class MemorySpace,
+          class MemoryPool =
+              Kokkos::MemoryPool<Kokkos::Device<ExecSpace, MemorySpace>>>
+class TaskQueueMemoryManager : public TaskQueueBase {
+ public:
+  using execution_space      = ExecSpace;
+  using memory_space         = MemorySpace;
+  using device_type          = Kokkos::Device<execution_space, memory_space>;
+  using memory_pool          = MemoryPool;
   using allocation_size_type = size_t;
 
-private:
-
+ private:
   memory_pool m_pool;
   // TODO @tasking @generalization DSH re-enable this with a flag in the type
-  //long m_accum_alloc = 0;
+  // long m_accum_alloc = 0;
   int m_count_alloc = 0;
-  int m_max_alloc = 0;
+  int m_max_alloc   = 0;
 
   struct _allocation_result {
     bool success;
@@ -102,116 +95,101 @@ private:
   };
 
   KOKKOS_INLINE_FUNCTION
-  _allocation_result
-  _do_pool_allocate(allocation_size_type requested_size) {
-    // KOKKOS_EXPECTS(requested_size >= 0); generates a warning when allocation_size_type is unsigned
-    if(requested_size == 0 ) {
-      return { true, nullptr };
-    }
-    else {
+  _allocation_result _do_pool_allocate(allocation_size_type requested_size) {
+    // KOKKOS_EXPECTS(requested_size >= 0); generates a warning when
+    // allocation_size_type is unsigned
+    if (requested_size == 0) {
+      return {true, nullptr};
+    } else {
       void* data = m_pool.allocate(static_cast<size_t>(requested_size));
 
-      //Kokkos::atomic_increment(&m_accum_alloc); // memory_order_relaxed
-      Kokkos::atomic_increment(&m_count_alloc); // memory_order_relaxed
-      // TODO @tasking @minor DSH make this thread safe? (otherwise, it's just an approximation, which is probably fine...)
-      if(m_max_alloc < m_count_alloc) m_max_alloc = m_count_alloc;
+      // Kokkos::atomic_increment(&m_accum_alloc); // memory_order_relaxed
+      Kokkos::atomic_increment(&m_count_alloc);  // memory_order_relaxed
+      // TODO @tasking @minor DSH make this thread safe? (otherwise, it's just
+      // an approximation, which is probably fine...)
+      if (m_max_alloc < m_count_alloc) m_max_alloc = m_count_alloc;
 
-      return { data != nullptr, data };
+      return {data != nullptr, data};
     }
   }
 
   template <class T, class... Args>
-  KOKKOS_INLINE_FUNCTION
-  T*
-  _do_contruct(void* allocated, allocation_size_type allocated_size, Args&&... args) {
-
-    static_assert(
-      std::is_base_of<PoolAllocatedObjectBase<int32_t>, T>::value,
-      "TaskQueueMemoryManager can only allocate objects with PoolAllocatedObjectBase base class"
-    );
+  KOKKOS_INLINE_FUNCTION T* _do_contruct(void* allocated,
+                                         allocation_size_type allocated_size,
+                                         Args&&... args) {
+    static_assert(std::is_base_of<PoolAllocatedObjectBase<int32_t>, T>::value,
+                  "TaskQueueMemoryManager can only allocate objects with "
+                  "PoolAllocatedObjectBase base class");
 
     // TODO @tasking DSH figure out why this isn't working
-    //static_assert(
+    // static_assert(
     //  std::is_constructible<T, Args..., int32_t>::value,
-    //  "TaskQueueMemoryManager can't construct object of the requested type from the "
-    //  " allocation size and the given arguments"
+    //  "TaskQueueMemoryManager can't construct object of the requested type
+    //  from the " " allocation size and the given arguments"
     //);
 
-
-    auto rv = new (allocated) T(
-      std::forward<Args>(args)...,
-      allocated_size
-    );
+    auto rv = new (allocated) T(std::forward<Args>(args)..., allocated_size);
 
     // It feels like there should be a way to check this at compile-time
     KOKKOS_ASSERT(
-      (intptr_t)(rv) == (intptr_t)(static_cast<PoolAllocatedObjectBase<int32_t>*>(rv))
-        && "PoolAllocatedObjectBase must be the first base class of the allocated type"
-    );
+        (intptr_t)(rv) ==
+            (intptr_t)(static_cast<PoolAllocatedObjectBase<int32_t>*>(rv)) &&
+        "PoolAllocatedObjectBase must be the first base class of the allocated "
+        "type");
 
     return rv;
-
   }
 
-
-public:
-
-  explicit
-  TaskQueueMemoryManager(memory_pool const& pool)
-    : m_pool(pool)
-  { }
-
+ public:
+  explicit TaskQueueMemoryManager(memory_pool const& pool) : m_pool(pool) {}
 
   template <class T, class... Args>
-  KOKKOS_FUNCTION
-  T*
-  allocate_and_construct(Args&&... args)
-    // requires
-    //   std::is_base_of_v<PoolAllocatedObjectBase<typename memory_pool::size_type>, T>
-    //     && std::is_constructible_v<T, Args&&..., allocation_size_type>
+  KOKKOS_FUNCTION T* allocate_and_construct(Args&&... args)
+  // requires
+  //   std::is_base_of_v<PoolAllocatedObjectBase<typename
+  //   memory_pool::size_type>, T>
+  //     && std::is_constructible_v<T, Args&&..., allocation_size_type>
   {
     constexpr auto allocation_size = sizeof(T);
 
-
     auto result = _do_pool_allocate(allocation_size);
 
     KOKKOS_ASSERT(result.success && "Memory allocation failure");
 
-    auto rv = _do_contruct<T>(result.pointer, allocation_size, std::forward<Args>(args)...);
+    auto rv = _do_contruct<T>(result.pointer, allocation_size,
+                              std::forward<Args>(args)...);
 
-    KOKKOS_ENSURES(intptr_t(rv) % alignof(T) == 0 && "alignment not preserved!");
+    KOKKOS_ENSURES(intptr_t(rv) % alignof(T) == 0 &&
+                   "alignment not preserved!");
 
     return rv;
   }
 
   template <class T, class VLAValueType, class... Args>
-  KOKKOS_INLINE_FUNCTION
-  T*
-  allocate_and_construct_with_vla_emulation(
-    allocation_size_type n_vla_entries,
-    Args&&... args
-  )
-    // requires
-    //   std::is_base_of_v<PoolAllocatedObjectBase<typename memory_pool::size_type>, T>
-    //     && std::is_base_of<ObjectWithVLAEmulation<T, VLAValueType>, T>::value
-    //     && std::is_constructible_v<T, allocation_size_type, Args&&...>
+  KOKKOS_INLINE_FUNCTION T* allocate_and_construct_with_vla_emulation(
+      allocation_size_type n_vla_entries, Args&&... args)
+  // requires
+  //   std::is_base_of_v<PoolAllocatedObjectBase<typename
+  //   memory_pool::size_type>, T>
+  //     && std::is_base_of<ObjectWithVLAEmulation<T, VLAValueType>, T>::value
+  //     && std::is_constructible_v<T, allocation_size_type, Args&&...>
   {
-
-
     static_assert(
-      std::is_base_of<ObjectWithVLAEmulation<T, VLAValueType>, T>::value,
-      "Can't append emulated variable length array of type with greater alignment than"
-      "  the type to which the VLA is being appended"
-    );
+        std::is_base_of<ObjectWithVLAEmulation<T, VLAValueType>, T>::value,
+        "Can't append emulated variable length array of type with greater "
+        "alignment than"
+        "  the type to which the VLA is being appended");
 
     using vla_emulation_base = ObjectWithVLAEmulation<T, VLAValueType>;
 
-    auto const allocation_size = vla_emulation_base::required_allocation_size(n_vla_entries);
+    auto const allocation_size =
+        vla_emulation_base::required_allocation_size(n_vla_entries);
     auto result = _do_pool_allocate(allocation_size);
 
     KOKKOS_ASSERT(result.success && "Memory allocation failure");
 
-    auto rv = _do_contruct<T>(result.pointer, allocation_size, std::forward<Args>(args)...);
+    auto rv = _do_contruct<T>(result.pointer, allocation_size,
+                              std::forward<Args>(args)...);
 
     KOKKOS_ENSURES(intptr_t(rv) % alignof(T) == 0);
 
@@ -219,11 +197,10 @@ public:
   }
 
   template <class CountType>
-  KOKKOS_INLINE_FUNCTION
-  void deallocate(PoolAllocatedObjectBase<CountType>&& obj)
-  {
+  KOKKOS_INLINE_FUNCTION void deallocate(
+      PoolAllocatedObjectBase<CountType>&& obj) {
     m_pool.deallocate((void*)&obj, 1);
-    Kokkos::atomic_decrement(&m_count_alloc); // memory_order_relaxed
+    Kokkos::atomic_decrement(&m_count_alloc);  // memory_order_relaxed
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -242,10 +219,8 @@ public:
 // END OLD CODE
 ////////////////////////////////////////////////////////////////////////////////
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKQUEUEMEMORYMANAGER_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple.hpp
index 17c357ff31252020c84b801af0b50d7f87bfa81b..090bffd23a367e39685f8872039bc2f0d5da2076 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,8 +48,7 @@
 #define KOKKOS_IMPL_TASKQUEUEMULTIPLE_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
-
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -68,21 +68,20 @@
 #include <stdexcept>
 #include <cassert>
 
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-template< typename ExecSpace, typename MemorySpace = typename ExecSpace::memory_space >
+template <typename ExecSpace,
+          typename MemorySpace = typename ExecSpace::memory_space>
 class LeagueQueueCollection;
 
 template <class ExecSpace, class MemorySpace>
 class TaskQueueMultiple : public TaskQueue<ExecSpace, MemorySpace> {
-private:
-
-  using base_t = TaskQueue<ExecSpace, MemorySpace>;
+ private:
+  using base_t             = TaskQueue<ExecSpace, MemorySpace>;
   using queue_collection_t = LeagueQueueCollection<ExecSpace, MemorySpace>;
 
   int m_league_rank = static_cast<int>(KOKKOS_INVALID_INDEX);
@@ -90,41 +89,33 @@ private:
   // This pointer is owning only if m_league_rank == 0
   queue_collection_t* m_other_queues = nullptr;
 
-
-public:
-
+ public:
   struct Destroy {
-    TaskQueueMultiple* m_queue ;
+    TaskQueueMultiple* m_queue;
     void destroy_shared_allocation();
   };
 
-
   using team_queue_type = TaskQueueMultiple;
 
-  TaskQueueMultiple(
-    int arg_league_rank,
-    queue_collection_t* arg_other_queues,
-    typename base_t::memory_pool const& arg_memory_pool
-  )
-    : base_t(arg_memory_pool),
-      m_league_rank(arg_league_rank),
-      m_other_queues(arg_other_queues)
-  { }
+  TaskQueueMultiple(int arg_league_rank, queue_collection_t* arg_other_queues,
+                    typename base_t::memory_pool const& arg_memory_pool)
+      : base_t(arg_memory_pool),
+        m_league_rank(arg_league_rank),
+        m_other_queues(arg_other_queues) {}
 
   explicit TaskQueueMultiple(
-    typename base_t::memory_pool const& arg_memory_pool
-  )
-    : base_t(arg_memory_pool),
-      m_league_rank(0)
-  {
-    void* other_queues_buffer = typename base_t::memory_space{}.allocate(sizeof(queue_collection_t));
-    m_other_queues = new(other_queues_buffer) queue_collection_t(this);
+      typename base_t::memory_pool const& arg_memory_pool)
+      : base_t(arg_memory_pool), m_league_rank(0) {
+    void* other_queues_buffer =
+        typename base_t::memory_space{}.allocate(sizeof(queue_collection_t));
+    m_other_queues = new (other_queues_buffer) queue_collection_t(this);
   }
 
   ~TaskQueueMultiple() {
-    if(m_league_rank == 0 && m_other_queues != nullptr) {
+    if (m_league_rank == 0 && m_other_queues != nullptr) {
       m_other_queues->~queue_collection_t();
-      typename base_t::memory_space{}.deallocate(m_other_queues, sizeof(queue_collection_t));
+      typename base_t::memory_space{}.deallocate(m_other_queues,
+                                                 sizeof(queue_collection_t));
     }
     // rest of destruction is handled in the base class
   }
@@ -137,14 +128,15 @@ public:
 
   KOKKOS_INLINE_FUNCTION
   team_queue_type& get_team_queue(int arg_league_rank) noexcept {
-    if(arg_league_rank == m_league_rank) return *this;
-    else return m_other_queues->get_team_queue(arg_league_rank);
+    if (arg_league_rank == m_league_rank)
+      return *this;
+    else
+      return m_other_queues->get_team_queue(arg_league_rank);
   }
 
   KOKKOS_INLINE_FUNCTION
-  typename base_t::task_root_type*
-  attempt_to_steal_task() noexcept {
-    TaskBase* rv = nullptr;
+  typename base_t::task_root_type* attempt_to_steal_task() noexcept {
+    TaskBase* rv        = nullptr;
     auto* const end_tag = reinterpret_cast<TaskBase*>(TaskBase::EndTag);
 
     if (m_other_queues == nullptr) {
@@ -152,18 +144,18 @@ public:
     }
 
     // Loop by priority and then type, and then team
-    for ( int i = 0 ; i < base_t::NumQueue; ++i ) {
-      for ( int j = 0 ; j < 2; ++j ) {
+    for (int i = 0; i < base_t::NumQueue; ++i) {
+      for (int j = 0; j < 2; ++j) {
         // for now, always start by trying to steal from team zero
-        for(int iteam = 0; iteam < m_other_queues->size(); ++iteam) {
-          if(iteam == m_league_rank) continue;
+        for (int iteam = 0; iteam < m_other_queues->size(); ++iteam) {
+          if (iteam == m_league_rank) continue;
           auto& steal_from = get_team_queue(iteam);
-          if( *((volatile int *) & steal_from.m_ready_count) > 0 ) {
-            // we've found at least one queue that's not done, so even if we can't
-            // pop something off of it we shouldn't return a nullptr indicating
-            // completion.  rv will be end_tag when the pop fails
+          if (*((volatile int*)&steal_from.m_ready_count) > 0) {
+            // we've found at least one queue that's not done, so even if we
+            // can't pop something off of it we shouldn't return a nullptr
+            // indicating completion.  rv will be end_tag when the pop fails
             rv = base_t::pop_ready_task(&steal_from.m_ready[i][j]);
-            if(rv != end_tag) {
+            if (rv != end_tag) {
               // task stolen.
               // first increment our ready count, then decrement the ready count
               // on the other queue:
@@ -182,30 +174,27 @@ public:
     // was called and returned end_tag if it couldn't pop a task
     return rv;
   }
-
-
 };
 
-template<typename ExecSpace, typename MemorySpace>
+template <typename ExecSpace, typename MemorySpace>
 class LeagueQueueCollection {
-private:
-
-  using execution_space = ExecSpace;
-  using memory_space = MemorySpace;
-  using device_type = Kokkos::Device<execution_space, memory_space>;
-  using memory_pool = Kokkos::MemoryPool<device_type>;
-  using team_queue_type = TaskQueueMultiple<execution_space, memory_space>;
+ private:
+  using execution_space     = ExecSpace;
+  using memory_space        = MemorySpace;
+  using device_type         = Kokkos::Device<execution_space, memory_space>;
+  using memory_pool         = Kokkos::MemoryPool<device_type>;
+  using team_queue_type     = TaskQueueMultiple<execution_space, memory_space>;
   using team_scheduler_type = BasicTaskScheduler<ExecSpace, team_queue_type>;
-  using specialization = TaskQueueSpecialization<team_scheduler_type>;
+  using specialization      = TaskQueueSpecialization<team_scheduler_type>;
 
-  enum : long { max_num_queues = 6 }; //specialization::max_league_size };
+  enum : long { max_num_queues = 6 };  // specialization::max_league_size };
 
   // this is a non-owning pointer
   team_queue_type* m_rank_zero_queue = nullptr;
   // This really needs to be an optional<TaskQueue<ExecSpace>>
   union optional_queue {
     KOKKOS_INLINE_FUNCTION
-    optional_queue() : uninitialized(0) { }
+    optional_queue() : uninitialized(0) {}
     KOKKOS_INLINE_FUNCTION
     ~optional_queue() { uninitialized = 0; }
     char uninitialized;
@@ -213,38 +202,33 @@ private:
   } m_queues[max_num_queues];
   int m_size = static_cast<int>(KOKKOS_INVALID_INDEX);
 
-public:
-
-  LeagueQueueCollection() = delete;
+ public:
+  LeagueQueueCollection()                             = delete;
   LeagueQueueCollection(LeagueQueueCollection const&) = delete;
-  LeagueQueueCollection(LeagueQueueCollection&&) = delete;
+  LeagueQueueCollection(LeagueQueueCollection&&)      = delete;
   LeagueQueueCollection& operator=(LeagueQueueCollection const&) = delete;
   LeagueQueueCollection& operator=(LeagueQueueCollection&&) = delete;
 
   ~LeagueQueueCollection() {
     // destroy only the initialized queues that we own
-    for(int iteam = 0; iteam < m_size - 1; ++iteam) {
+    for (int iteam = 0; iteam < m_size - 1; ++iteam) {
       m_queues[iteam].initialized.~team_queue_type();
       m_queues[iteam].uninitialized = 0;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  explicit LeagueQueueCollection(
-    team_queue_type* arg_rank_zero_queue
-  ) : m_rank_zero_queue(arg_rank_zero_queue),
-      m_size(1)
-  { }
-
-  void initialize_team_queues(
-    int arg_count, memory_pool const& arg_memory_pool
-  ) noexcept
-  {
+  explicit LeagueQueueCollection(team_queue_type* arg_rank_zero_queue)
+      : m_rank_zero_queue(arg_rank_zero_queue), m_size(1) {}
+
+  void initialize_team_queues(int arg_count,
+                              memory_pool const& arg_memory_pool) noexcept {
     arg_count = std::min((int)max_num_queues, arg_count);
-    //assert(arg_count <= max_num_queues);
-    if(arg_count > m_size) {
-      for(int i = m_size; i < arg_count; ++i) {
-        new(&m_queues[i-1].initialized) team_queue_type(i, this, arg_memory_pool);
+    // assert(arg_count <= max_num_queues);
+    if (arg_count > m_size) {
+      for (int i = m_size; i < arg_count; ++i) {
+        new (&m_queues[i - 1].initialized)
+            team_queue_type(i, this, arg_memory_pool);
       }
       m_size = arg_count;
     }
@@ -254,28 +238,28 @@ public:
   constexpr int size() const noexcept { return m_size; }
 
   KOKKOS_INLINE_FUNCTION
-  constexpr bool initialized() const noexcept { return m_size != int(KOKKOS_INVALID_INDEX); }
+  constexpr bool initialized() const noexcept {
+    return m_size != int(KOKKOS_INVALID_INDEX);
+  }
 
   KOKKOS_INLINE_FUNCTION
   team_queue_type& get_team_queue(int iteam) {
     iteam %= max_num_queues;
-    #if !defined(__HCC_ACCELERATOR__) && !defined(__CUDA_ARCH__)
+#if !defined(__HCC_ACCELERATOR__) && !defined(__CUDA_ARCH__)
     assert(initialized());
     assert(iteam < m_size);
     assert(iteam >= 0);
-    #endif
-    if(iteam == 0) return *m_rank_zero_queue;
-    else return m_queues[iteam-1].initialized;
+#endif
+    if (iteam == 0)
+      return *m_rank_zero_queue;
+    else
+      return m_queues[iteam - 1].initialized;
   }
-
 };
 
-
 } /* namespace Impl */
 } /* namespace Kokkos */
 
-
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
@@ -283,4 +267,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKQUEUEMULTIPLE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple_impl.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple_impl.hpp
index 81bcc968315ca00e22a1e41f857d3160621ba168..1af97918b8a057444b9653202838a7dff06bb143 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple_impl.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskQueueMultiple_impl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,7 +46,7 @@
 #define KOKKOS_IMPL_TASKQUEUEMULTIPLE_IMPL_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <impl/Kokkos_TaskQueueMultiple.hpp>
 
@@ -55,9 +56,11 @@ namespace Kokkos {
 namespace Impl {
 
 template <class ExecSpace, class MemorySpace>
-void TaskQueueMultiple<ExecSpace, MemorySpace>::Destroy::destroy_shared_allocation() {
+void TaskQueueMultiple<ExecSpace,
+                       MemorySpace>::Destroy::destroy_shared_allocation() {
 // KOKKOS WORKAROUND for CUDA 10.1 with GCC 7.3.0
-#if(KOKKOS_COMPILER_CUDA_VERSION==101) && defined(KOKKOS_COMPILER_NVCC) && (KOKKOS_COMPILER_GNU>=730)
+#if (KOKKOS_COMPILER_CUDA_VERSION == 101) && defined(KOKKOS_COMPILER_NVCC) && \
+    (KOKKOS_COMPILER_GNU >= 730)
   (*m_queue).get_team_queue(0).~TaskQueueMultiple();
 #else
   m_queue->get_team_queue(0).~TaskQueueMultiple();
@@ -69,4 +72,3 @@ void TaskQueueMultiple<ExecSpace, MemorySpace>::Destroy::destroy_shared_allocati
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKQUEUEMULTIPLE_IMPL_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskQueue_impl.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskQueue_impl.hpp
index 7a0e00a2f29a79dc0c918d09763b2c835902c60d..c64c497966b596968e0815216f45ef6b36c9f875 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskQueue_impl.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskQueue_impl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,7 +45,7 @@
 #ifndef KOKKOS_IMPL_TASKQUEUE_IMPL_HPP
 #define KOKKOS_IMPL_TASKQUEUE_IMPL_HPP
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #define KOKKOS_IMPL_DEBUG_TASKDAG_SCHEDULING 0
 
@@ -53,133 +54,120 @@ namespace Impl {
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace >
-void TaskQueue< ExecSpace, MemorySpace >::Destroy::destroy_shared_allocation()
-{
+template <typename ExecSpace, typename MemorySpace>
+void TaskQueue<ExecSpace, MemorySpace>::Destroy::destroy_shared_allocation() {
   m_queue->~TaskQueue();
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-TaskQueue< ExecSpace, MemorySpace>::TaskQueue
-  ( typename TaskQueue< ExecSpace, MemorySpace>::memory_pool const & arg_memory_pool )
-  : m_memory( arg_memory_pool )
-  , m_ready()
-  //, m_accum_alloc(0)
-  //, m_count_alloc(0)
-  //, m_max_alloc(0)
-  , m_ready_count(0)
-{
-  for ( int i = 0 ; i < NumQueue ; ++i ) {
-    m_ready[i][0] = (task_root_type *) task_root_type::EndTag ;
-    m_ready[i][1] = (task_root_type *) task_root_type::EndTag ;
+template <typename ExecSpace, typename MemorySpace>
+TaskQueue<ExecSpace, MemorySpace>::TaskQueue(
+    typename TaskQueue<ExecSpace, MemorySpace>::memory_pool const
+        &arg_memory_pool)
+    : m_memory(arg_memory_pool),
+      m_ready()
+      //, m_accum_alloc(0)
+      //, m_count_alloc(0)
+      //, m_max_alloc(0)
+      ,
+      m_ready_count(0) {
+  for (int i = 0; i < NumQueue; ++i) {
+    m_ready[i][0] = (task_root_type *)task_root_type::EndTag;
+    m_ready[i][1] = (task_root_type *)task_root_type::EndTag;
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-TaskQueue< ExecSpace, MemorySpace>::~TaskQueue()
-{
+template <typename ExecSpace, typename MemorySpace>
+TaskQueue<ExecSpace, MemorySpace>::~TaskQueue() {
   // Verify that queues are empty and ready count is zero
 
-  for ( int i = 0 ; i < NumQueue ; ++i ) {
-    for ( int j = 0 ; j < 2 ; ++j ) {
-      if ( m_ready[i][j] != (task_root_type *) task_root_type::EndTag ) {
+  for (int i = 0; i < NumQueue; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      if (m_ready[i][j] != (task_root_type *)task_root_type::EndTag) {
         Kokkos::abort("TaskQueue::~TaskQueue ERROR: has ready tasks");
       }
     }
   }
 
-  if ( 0 != m_ready_count ) {
+  if (0 != m_ready_count) {
     Kokkos::abort("TaskQueue::~TaskQueue ERROR: has ready or executing tasks");
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace, MemorySpace>::decrement
-  ( TaskQueue< ExecSpace, MemorySpace>::task_root_type * task )
-{
-  task_root_type volatile & t = *task ;
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::decrement(
+    TaskQueue<ExecSpace, MemorySpace>::task_root_type *task) {
+  task_root_type volatile &t = *task;
 
-  const int count = Kokkos::atomic_fetch_add(&(t.m_ref_count),-1);
+  const int count = Kokkos::atomic_fetch_add(&(t.m_ref_count), -1);
 
 #if KOKKOS_IMPL_DEBUG_TASKDAG_SCHEDULING
-  if ( 1 == count ) {
-    printf( "decrement-destroy( 0x%lx { 0x%lx %d %d } )\n"
-          , uintptr_t( task )
-          , uintptr_t( task->m_next )
-          , int( task->m_task_type )
-          , int( task->m_ref_count )
-          );
+  if (1 == count) {
+    printf("decrement-destroy( 0x%lx { 0x%lx %d %d } )\n", uintptr_t(task),
+           uintptr_t(task->m_next), int(task->m_task_type),
+           int(task->m_ref_count));
   }
 #endif
 
-  if ( ( 1 == count ) &&
-       ( t.m_next == (task_root_type *) task_root_type::LockTag ) ) {
+  if ((1 == count) && (t.m_next == (task_root_type *)task_root_type::LockTag)) {
     // Reference count is zero and task is complete, deallocate.
 
-    //TaskQueue< ExecSpace, MemorySpace> * const queue =
+    // TaskQueue< ExecSpace, MemorySpace> * const queue =
     //  static_cast<scheduler_type const *>( t.m_scheduler )->m_queue;
-    auto* const volatile queue = static_cast<TaskQueue*>(t.m_queue);
+    auto *const volatile queue = static_cast<TaskQueue *>(t.m_queue);
 
-    // TODO @tasking @minor DSH this should call the destructor for a non-trivially destructible type (possibly just ignore this in the old version, though?)
-    // (Can't just do this; it needs to be queued since it's device code
-    // if(task->m_destroy) task->m_destroy(task);
+    // TODO @tasking @minor DSH this should call the destructor for a
+    // non-trivially destructible type (possibly just ignore this in the old
+    // version, though?) (Can't just do this; it needs to be queued since it's
+    // device code if(task->m_destroy) task->m_destroy(task);
 
-    queue->deallocate( task , t.m_alloc_size );
-  }
-  else if ( count <= 1 ) {
-    Kokkos::abort("TaskScheduler task has negative reference count or is incomplete" );
+    queue->deallocate(task, t.m_alloc_size);
+  } else if (count <= 1) {
+    Kokkos::abort(
+        "TaskScheduler task has negative reference count or is incomplete");
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-size_t TaskQueue< ExecSpace, MemorySpace>::allocate_block_size( size_t n )
-{
-  return m_memory.allocate_block_size( n );
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION size_t
+TaskQueue<ExecSpace, MemorySpace>::allocate_block_size(size_t n) {
+  return m_memory.allocate_block_size(n);
 }
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-void * TaskQueue< ExecSpace, MemorySpace>::allocate( size_t n )
-{
-  void * const p = m_memory.allocate(n);
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION void *TaskQueue<ExecSpace, MemorySpace>::allocate(size_t n) {
+  void *const p = m_memory.allocate(n);
 
-  if ( p ) {
-    //Kokkos::atomic_increment( & m_accum_alloc );
-    Kokkos::atomic_increment( & m_count_alloc );
+  if (p) {
+    // Kokkos::atomic_increment( & m_accum_alloc );
+    Kokkos::atomic_increment(&m_count_alloc);
 
-    //if ( m_max_alloc < m_count_alloc ) m_max_alloc = m_count_alloc ;
+    // if ( m_max_alloc < m_count_alloc ) m_max_alloc = m_count_alloc ;
   }
 
-  return p ;
+  return p;
 }
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace, MemorySpace>::deallocate( void * p , size_t n )
-{
-  m_memory.deallocate( p , n );
-  Kokkos::atomic_decrement( & m_count_alloc );
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::deallocate(void *p,
+                                                                   size_t n) {
+  m_memory.deallocate(p, n);
+  Kokkos::atomic_decrement(&m_count_alloc);
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-bool TaskQueue< ExecSpace, MemorySpace>::push_task
-  ( TaskQueue< ExecSpace, MemorySpace>::task_root_type * volatile * const queue
-  , TaskQueue< ExecSpace, MemorySpace>::task_root_type * const task
-  )
-{
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION bool TaskQueue<ExecSpace, MemorySpace>::push_task(
+    TaskQueue<ExecSpace, MemorySpace>::task_root_type *volatile *const queue,
+    TaskQueue<ExecSpace, MemorySpace>::task_root_type *const task) {
   // Push task into a concurrently pushed and popped queue.
   // The queue can be either a ready task queue or a waiting task queue.
   // The queue is a linked list where 'task->m_next' form the links.
@@ -187,31 +175,26 @@ bool TaskQueue< ExecSpace, MemorySpace>::push_task
   // otherwise retry until the push succeeds.
 
 #if KOKKOS_IMPL_DEBUG_TASKDAG_SCHEDULING
-  printf( "push_task( 0x%lx { 0x%lx } 0x%lx { 0x%lx 0x%lx %d %d %d } )\n"
-        , uintptr_t(queue)
-        , uintptr_t(*queue)
-        , uintptr_t(task)
-        , uintptr_t(task->m_wait)
-        , uintptr_t(task->m_next)
-        , task->m_task_type
-        , task->m_priority
-        , task->m_ref_count );
+  printf("push_task( 0x%lx { 0x%lx } 0x%lx { 0x%lx 0x%lx %d %d %d } )\n",
+         uintptr_t(queue), uintptr_t(*queue), uintptr_t(task),
+         uintptr_t(task->m_wait), uintptr_t(task->m_next), task->m_task_type,
+         task->m_priority, task->m_ref_count);
 #endif
 
-  task_root_type * const zero = (task_root_type *) 0 ;
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
+  task_root_type *const zero = (task_root_type *)0;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
 
-  task_root_type * volatile & next = task->m_next ;
+  task_root_type *volatile &next = task->m_next;
 
-  if ( zero != next ) {
-    Kokkos::abort("TaskQueue::push_task ERROR: already a member of another queue" );
+  if (zero != next) {
+    Kokkos::abort(
+        "TaskQueue::push_task ERROR: already a member of another queue");
   }
 
   // store the head of the queue
-  task_root_type * old_head = *queue ;
-
-  while ( old_head != lock ) {
+  task_root_type *old_head = *queue;
 
+  while (old_head != lock) {
     // set task->next to the head of the queue
     next = old_head;
 
@@ -219,7 +202,7 @@ bool TaskQueue< ExecSpace, MemorySpace>::push_task
     Kokkos::memory_fence();
 
     // store the old head
-    task_root_type * const old_head_tmp = old_head;
+    task_root_type *const old_head_tmp = old_head;
 
     // attempt to swap task with the old head of the queue
     // as if this were done atomically:
@@ -229,33 +212,31 @@ bool TaskQueue< ExecSpace, MemorySpace>::push_task
     //   old_head = *queue;
     old_head = Kokkos::atomic_compare_exchange(queue, old_head, task);
 
-    if(old_head_tmp == old_head) return true;
+    if (old_head_tmp == old_head) return true;
   }
 
   // Failed, replace 'task->m_next' value since 'task' remains
   // not a member of a queue.
 
-  next = zero ;
+  next = zero;
 
   // Do not proceed until 'next' has been stored.
   Kokkos::memory_fence();
 
-  return false ;
+  return false;
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-typename TaskQueue< ExecSpace, MemorySpace>::task_root_type *
-TaskQueue< ExecSpace, MemorySpace>::pop_ready_task
-  ( TaskQueue< ExecSpace, MemorySpace>::task_root_type * volatile * const queue )
-{
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION typename TaskQueue<ExecSpace, MemorySpace>::task_root_type *
+TaskQueue<ExecSpace, MemorySpace>::pop_ready_task(
+    TaskQueue<ExecSpace, MemorySpace>::task_root_type *volatile *const queue) {
   // Pop task from a concurrently pushed and popped ready task queue.
   // The queue is a linked list where 'task->m_next' form the links.
 
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
-  task_root_type * const end  = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
+  task_root_type *const end  = (task_root_type *)task_root_type::EndTag;
 
   // *queue is
   //   end   => an empty queue
@@ -264,23 +245,22 @@ TaskQueue< ExecSpace, MemorySpace>::pop_ready_task
 
   // Retry until the lock is acquired or the queue is empty.
 
-  task_root_type * task = *queue ;
-
-  while ( end != task ) {
+  task_root_type *task = *queue;
 
+  while (end != task) {
     // The only possible values for the queue are
     // (1) lock, (2) end, or (3) a valid task.
     // Thus zero will never appear in the queue.
     //
     // If queue is locked then just read by guaranteeing the CAS will fail.
 
-    if ( lock == task ) task = 0 ;
+    if (lock == task) task = 0;
 
-    task_root_type * const x = task ;
+    task_root_type *const x = task;
 
-    task = Kokkos::atomic_compare_exchange(queue,x,lock);
+    task = Kokkos::atomic_compare_exchange(queue, x, lock);
 
-    if ( x == task ) {
+    if (x == task) {
       // CAS succeeded and queue is locked
       //
       // This thread has locked the queue and removed 'task' from the queue.
@@ -294,41 +274,36 @@ TaskQueue< ExecSpace, MemorySpace>::pop_ready_task
       // This thread has exclusive access to
       // the queue and the popped task's m_next.
 
-      task_root_type * volatile & next = task->m_next ;
+      task_root_type *volatile &next = task->m_next;
 
       // This algorithm is not lockfree because a adversarial scheduler could
       // context switch this thread at this point and the rest of the threads
       // calling this method would never make forward progress
 
-      *queue = next ; next = lock ;
+      *queue = next;
+      next   = lock;
 
       Kokkos::memory_fence();
 
 #if KOKKOS_IMPL_DEBUG_TASKDAG_SCHEDULING
-      printf( "pop_ready_task( 0x%lx 0x%lx { 0x%lx 0x%lx %d %d %d } )\n"
-            , uintptr_t(queue)
-            , uintptr_t(task)
-            , uintptr_t(task->m_wait)
-            , uintptr_t(task->m_next)
-            , int(task->m_task_type)
-            , int(task->m_priority)
-            , int(task->m_ref_count) );
+      printf("pop_ready_task( 0x%lx 0x%lx { 0x%lx 0x%lx %d %d %d } )\n",
+             uintptr_t(queue), uintptr_t(task), uintptr_t(task->m_wait),
+             uintptr_t(task->m_next), int(task->m_task_type),
+             int(task->m_priority), int(task->m_ref_count));
 #endif
 
-      return task ;
+      return task;
     }
   }
 
-  return end ;
+  return end;
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace, MemorySpace>::schedule_runnable
-  ( TaskQueue< ExecSpace, MemorySpace>::task_root_type * const task )
-{
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::schedule_runnable(
+    TaskQueue<ExecSpace, MemorySpace>::task_root_type *const task) {
   // Schedule a runnable task upon construction / spawn
   // and upon completion of other tasks that 'task' is waiting on.
   //
@@ -354,41 +329,35 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_runnable
   //     task->m_next == member of linked list (queue)
 
 #if KOKKOS_IMPL_DEBUG_TASKDAG_SCHEDULING
-  printf( "schedule_runnable( 0x%lx { 0x%lx 0x%lx %d %d %d }\n"
-        , uintptr_t(task)
-        , uintptr_t(task->m_wait)
-        , uintptr_t(task->m_next)
-        , task->m_task_type
-        , task->m_priority
-        , task->m_ref_count );
+  printf("schedule_runnable( 0x%lx { 0x%lx 0x%lx %d %d %d }\n", uintptr_t(task),
+         uintptr_t(task->m_wait), uintptr_t(task->m_next), task->m_task_type,
+         task->m_priority, task->m_ref_count);
 #endif
 
-  task_root_type * const zero = (task_root_type *) 0 ;
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
-  task_root_type * const end  = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const zero = (task_root_type *)0;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
+  task_root_type *const end  = (task_root_type *)task_root_type::EndTag;
 
-  task_root_type volatile & t = *task ;
+  task_root_type volatile &t = *task;
 
-  bool respawn = false ;
+  bool respawn = false;
 
   //----------------------------------------
 
-  if ( zero == t.m_wait ) {
+  if (zero == t.m_wait) {
     // Task in Constructing state
     // - Transition to Waiting state
     // Preconditions:
     // - call occurs exclusively within a single thread
 
-    t.m_wait = end ;
+    t.m_wait = end;
     // Task in Waiting state
-  }
-  else if ( lock != t.m_wait ) {
+  } else if (lock != t.m_wait) {
     // Task in Executing state with Respawn request
     // - Update dependence
     // - Transition to Waiting state
-    respawn = true ;
-  }
-  else {
+    respawn = true;
+  } else {
     // Task in Complete state
     Kokkos::abort("TaskQueue::schedule_runnable ERROR: task is complete");
   }
@@ -405,36 +374,36 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_runnable
 
   // Exclusive access so don't need an atomic exchange
   // task_root_type * dep = Kokkos::atomic_exchange( & task->m_next , zero );
-  task_root_type * dep = t.m_next ; t.m_next = zero ;
+  task_root_type *dep = t.m_next;
+  t.m_next            = zero;
 
   Kokkos::memory_fence();
 
-  // If we don't have a dependency, or if pushing onto the wait queue of that dependency
-  // failed (since the only time that queue should be locked is when the task is transitioning to complete??!?)
-  const bool is_ready =
-    ( 0 == dep ) || ( ! push_task( & dep->m_wait , task ) );
+  // If we don't have a dependency, or if pushing onto the wait queue of that
+  // dependency failed (since the only time that queue should be locked is when
+  // the task is transitioning to complete??!?)
+  const bool is_ready = (0 == dep) || (!push_task(&dep->m_wait, task));
 
-  if ( ( 0 != dep ) && respawn ) {
+  if ((0 != dep) && respawn) {
     // Reference count for dep was incremented when
     // respawn assigned dependency to task->m_next
     // so that if dep completed prior to the
     // above push_task dep would not be destroyed.
     // dep reference count can now be decremented,
     // which may deallocate the task.
-    TaskQueue::assign( & dep , (task_root_type *)0 );
+    TaskQueue::assign(&dep, (task_root_type *)0);
   }
 
-  if ( is_ready ) {
-
+  if (is_ready) {
     // No dependence or 'dep' is complete so push task into ready queue.
     // Increment the ready count before pushing into ready queue
     // to track number of ready + executing tasks.
     // The ready count will be decremented when the task is complete.
 
-    Kokkos::atomic_increment( & m_ready_count );
+    Kokkos::atomic_increment(&m_ready_count);
 
-    task_root_type * volatile * const ready_queue =
-      & m_ready[ t.m_priority ][ t.m_task_type ];
+    task_root_type *volatile *const ready_queue =
+        &m_ready[t.m_priority][t.m_task_type];
 
     // A push_task fails if the ready queue is locked.
     // A ready queue is only locked during a push or pop;
@@ -443,7 +412,8 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_runnable
     // When the push succeeds then 'task' may be
     // processed or executed by another thread at any time.
 
-    while ( ! push_task( ready_queue , task ) );
+    while (!push_task(ready_queue, task))
+      ;
   }
 
   //----------------------------------------
@@ -453,11 +423,9 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_runnable
   //   from a queue and processed it as appropriate.
 }
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace, MemorySpace>::schedule_aggregate
-  ( TaskQueue< ExecSpace, MemorySpace>::task_root_type * const task )
-{
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::schedule_aggregate(
+    TaskQueue<ExecSpace, MemorySpace>::task_root_type *const task) {
   // Schedule an aggregate task upon construction
   // and upon completion of other tasks that 'task' is waiting on.
   //
@@ -478,34 +446,29 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_aggregate
   //     task->m_next == member of linked list (queue)
 
 #if KOKKOS_IMPL_DEBUG_TASKDAG_SCHEDULING
-  printf( "schedule_aggregate( 0x%lx { 0x%lx 0x%lx %d %d %d %d }\n"
-        , uintptr_t(task)
-        , uintptr_t(task->m_wait)
-        , uintptr_t(task->m_next)
-        , task->m_dep_count
-        , task->m_task_type
-        , task->m_priority
-        , task->m_ref_count );
+  printf("schedule_aggregate( 0x%lx { 0x%lx 0x%lx %d %d %d %d }\n",
+         uintptr_t(task), uintptr_t(task->m_wait), uintptr_t(task->m_next),
+         task->m_dep_count, task->m_task_type, task->m_priority,
+         task->m_ref_count);
 #endif
 
-  task_root_type * const zero = (task_root_type *) 0 ;
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
-  task_root_type * const end  = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const zero = (task_root_type *)0;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
+  task_root_type *const end  = (task_root_type *)task_root_type::EndTag;
 
-  task_root_type volatile & t = *task ;
+  task_root_type volatile &t = *task;
 
   //----------------------------------------
 
-  if ( zero == t.m_wait ) {
+  if (zero == t.m_wait) {
     // Task in Constructing state
     // - Transition to Waiting state
     // Preconditions:
     // - call occurs exclusively within a single thread
 
-    t.m_wait = end ;
+    t.m_wait = end;
     // Task in Waiting state
-  }
-  else if ( lock == t.m_wait ) {
+  } else if (lock == t.m_wait) {
     // Task in Complete state
     Kokkos::abort("TaskQueue::schedule_aggregate ERROR: task is complete");
   }
@@ -516,16 +479,15 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_aggregate
   // (1) created or
   // (2) being removed from a completed task's wait list.
 
-  task_root_type * volatile * const aggr = t.aggregate_dependences();
+  task_root_type *volatile *const aggr = t.aggregate_dependences();
 
   // Assume the 'when_all' is complete until a dependence is
   // found that is not complete.
 
-  bool is_complete = true ;
-
-  for ( int i = t.m_dep_count ; 0 < i && is_complete ; ) {
+  bool is_complete = true;
 
-    --i ;
+  for (int i = t.m_dep_count; 0 < i && is_complete;) {
+    --i;
 
     // Loop dependences looking for an incomplete task.
     // Add this task to the incomplete task's wait queue.
@@ -536,10 +498,10 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_aggregate
 
     // Exclusive access so don't need an atomic exchange
     // task_root_type * x = Kokkos::atomic_exchange( aggr + i , zero );
-    task_root_type * x = aggr[i] ; aggr[i] = zero ;
-
-    if ( x ) {
+    task_root_type *x = aggr[i];
+    aggr[i]           = zero;
 
+    if (x) {
       // If x->m_wait is not locked then push succeeds
       // and the aggregate is not complete.
       // If the push succeeds then this when_all 'task' may be
@@ -547,24 +509,24 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_aggregate
       // For example, 'x' may be completeed by another
       // thread and then re-schedule this when_all 'task'.
 
-      is_complete = ! push_task( & x->m_wait , task );
+      is_complete = !push_task(&x->m_wait, task);
 
       // Decrement reference count which had been incremented
       // when 'x' was added to the dependence list.
 
-      TaskQueue::assign( & x , zero );
+      TaskQueue::assign(&x, zero);
     }
   }
 
-  if ( is_complete ) {
+  if (is_complete) {
     // The when_all 'task' was not added to a wait queue because
     // all dependences were complete so this aggregate is complete.
     // Complete the when_all 'task' to schedule other tasks
     // that are waiting for the when_all 'task' to complete.
 
-    t.m_next = lock ;
+    t.m_next = lock;
 
-    complete( task );
+    complete(task);
 
     // '*task' may have been deleted upon completion
   }
@@ -578,10 +540,9 @@ void TaskQueue< ExecSpace, MemorySpace>::schedule_aggregate
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace, MemorySpace>::reschedule( task_root_type * task )
-{
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::reschedule(
+    task_root_type *task) {
   // Precondition:
   //   task is in Executing state
   //   task->m_next == LockTag
@@ -590,49 +551,43 @@ void TaskQueue< ExecSpace, MemorySpace>::reschedule( task_root_type * task )
   //   task is in Executing-Respawn state
   //   task->m_next == 0 (no dependence)
 
-  task_root_type * const zero = (task_root_type *) 0 ;
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
+  task_root_type *const zero = (task_root_type *)0;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
 
-  if ( lock != Kokkos::atomic_exchange( & task->m_next, zero ) ) {
+  if (lock != Kokkos::atomic_exchange(&task->m_next, zero)) {
     Kokkos::abort("TaskScheduler::respawn ERROR: already respawned");
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< typename ExecSpace, typename MemorySpace>
-KOKKOS_FUNCTION
-void TaskQueue< ExecSpace, MemorySpace>::complete
-  ( TaskQueue< ExecSpace, MemorySpace>::task_root_type * task )
-{
+template <typename ExecSpace, typename MemorySpace>
+KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::complete(
+    TaskQueue<ExecSpace, MemorySpace>::task_root_type *task) {
   // Complete a runnable task that has finished executing
   // or a when_all task when all of its dependeneces are complete.
 
-  task_root_type * const zero = (task_root_type *) 0 ;
-  task_root_type * const lock = (task_root_type *) task_root_type::LockTag ;
-  task_root_type * const end  = (task_root_type *) task_root_type::EndTag ;
+  task_root_type *const zero = (task_root_type *)0;
+  task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
+  task_root_type *const end  = (task_root_type *)task_root_type::EndTag;
 
 #if KOKKOS_IMPL_DEBUG_TASKDAG_SCHEDULING
-  printf( "complete( 0x%lx { 0x%lx 0x%lx %d %d %d }\n"
-        , uintptr_t(task)
-        , uintptr_t(task->m_wait)
-        , uintptr_t(task->m_next)
-        , task->m_task_type
-        , task->m_priority
-        , task->m_ref_count );
+  printf("complete( 0x%lx { 0x%lx 0x%lx %d %d %d }\n", uintptr_t(task),
+         uintptr_t(task->m_wait), uintptr_t(task->m_next), task->m_task_type,
+         task->m_priority, task->m_ref_count);
 #endif
 
-  task_root_type volatile & t = *task ;
+  task_root_type volatile &t = *task;
 
-  const bool runnable = task_root_type::Aggregate != t.m_task_type ;
+  const bool runnable = task_root_type::Aggregate != t.m_task_type;
 
   //----------------------------------------
 
-  if ( runnable && lock != t.m_next ) {
+  if (runnable && lock != t.m_next) {
     // Is a runnable task has finished executing and requested respawn.
     // Schedule the task for subsequent execution.
 
-    schedule_runnable( task );
+    schedule_runnable(task);
   }
   //----------------------------------------
   else {
@@ -647,51 +602,50 @@ void TaskQueue< ExecSpace, MemorySpace>::complete
     // Stop other tasks from adding themselves to this task's wait queue
     // by locking the head of this task's wait queue.
 
-    task_root_type * x = Kokkos::atomic_exchange( & t.m_wait , lock );
-
-    if ( x != (task_root_type *) lock ) {
+    task_root_type *x = Kokkos::atomic_exchange(&t.m_wait, lock);
 
+    if (x != (task_root_type *)lock) {
       // This thread has transitioned this 'task' to complete.
       // 'task' is no longer in a queue and is not executing
       // so decrement the reference count from 'task's creation.
       // If no other references to this 'task' then it will be deleted.
 
-      TaskQueue::assign( & task , zero );
+      TaskQueue::assign(&task, zero);
 
       // This thread has exclusive access to the wait list so
       // the concurrency-safe pop_ready_task function is not needed.
       // Schedule the tasks that have been waiting on the input 'task',
       // which may have been deleted.
 
-      while ( x != end ) {
+      while (x != end) {
         // Have exclusive access to 'x' until it is scheduled
         // Set x->m_next = zero  <=  no dependence, not a respawn
 
-        task_root_type volatile & vx = *x ;
+        task_root_type volatile &vx = *x;
 
-        task_root_type * const next = vx.m_next ; vx.m_next = 0 ;
+        task_root_type *const next = vx.m_next;
+        vx.m_next                  = 0;
 
         Kokkos::memory_fence();
 
-        if ( task_root_type::Aggregate != vx.m_task_type ) {
-          schedule_runnable( x );
-        }
-        else {
-#if !defined( __HCC_ACCELERATOR__ )
-          schedule_aggregate( x );
+        if (task_root_type::Aggregate != vx.m_task_type) {
+          schedule_runnable(x);
+        } else {
+#if !defined(__HCC_ACCELERATOR__)
+          schedule_aggregate(x);
 #endif
         }
 
-        x = next ;
+        x = next;
       }
     }
   }
 
-  if ( runnable ) {
+  if (runnable) {
     // A runnable task was popped from a ready queue and executed.
     // If respawned into a ready queue then the ready count was incremented
     // so decrement whether respawned or not.
-    Kokkos::atomic_decrement( & m_ready_count );
+    Kokkos::atomic_decrement(&m_ready_count);
   }
 }
 
@@ -702,4 +656,3 @@ void TaskQueue< ExecSpace, MemorySpace>::complete
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKQUEUE_IMPL_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskResult.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskResult.hpp
index d45ebff00b07d390d16292b87fa62f559771e11b..f846ff4ea6237742a5df18ec1cabfb36ce122ed4 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskResult.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskResult.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 #define KOKKOS_IMPL_TASKRESULT_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 #include <Kokkos_Core_fwd.hpp>
@@ -65,78 +66,71 @@
 namespace Kokkos {
 namespace Impl {
 
-template< typename ResultType >
+template <typename ResultType>
 struct TaskResult {
-
   enum : int32_t { size = sizeof(ResultType) };
 
-  using reference_type = ResultType & ;
+  using reference_type = ResultType&;
 
   template <class CountType>
-  KOKKOS_INLINE_FUNCTION static
-  ResultType * ptr( PoolAllocatedObjectBase<CountType>* task )
-  {
-    return reinterpret_cast< ResultType * >
-    ( reinterpret_cast< char * >(task) + task->get_allocation_size() - sizeof(ResultType) );
+  KOKKOS_INLINE_FUNCTION static ResultType* ptr(
+      PoolAllocatedObjectBase<CountType>* task) {
+    return reinterpret_cast<ResultType*>(reinterpret_cast<char*>(task) +
+                                         task->get_allocation_size() -
+                                         sizeof(ResultType));
   }
 
-  KOKKOS_INLINE_FUNCTION static
-  ResultType * ptr( TaskBase* task )
-    {
-      return reinterpret_cast< ResultType * >
-        ( reinterpret_cast< char * >(task) + task->m_alloc_size - sizeof(ResultType) );
-    }
+  KOKKOS_INLINE_FUNCTION static ResultType* ptr(TaskBase* task) {
+    return reinterpret_cast<ResultType*>(reinterpret_cast<char*>(task) +
+                                         task->m_alloc_size -
+                                         sizeof(ResultType));
+  }
 
-  KOKKOS_INLINE_FUNCTION static
-  reference_type get( TaskBase* task )
-    { return *ptr( task ); }
+  KOKKOS_INLINE_FUNCTION static reference_type get(TaskBase* task) {
+    return *ptr(task);
+  }
 
   template <class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION static
-  reference_type get( TaskNode<TaskQueueTraits>* task )
-  { return *ptr( task ); }
-
-  KOKKOS_INLINE_FUNCTION static
-  void destroy( TaskBase* task )
-    { get(task).~ResultType(); }
+  KOKKOS_INLINE_FUNCTION static reference_type get(
+      TaskNode<TaskQueueTraits>* task) {
+    return *ptr(task);
+  }
 
+  KOKKOS_INLINE_FUNCTION static void destroy(TaskBase* task) {
+    get(task).~ResultType();
+  }
 
-  //template <class TaskQueueTraits>
-  //KOKKOS_INLINE_FUNCTION static
-  //void destroy( TaskNode<TaskQueueTraits>* task )
+  // template <class TaskQueueTraits>
+  // KOKKOS_INLINE_FUNCTION static
+  // void destroy( TaskNode<TaskQueueTraits>* task )
   //{ get(task).~ResultType(); }
 };
 
-template<>
-struct TaskResult< void > {
-
+template <>
+struct TaskResult<void> {
   enum : int32_t { size = 0 };
 
-  using reference_type = void ;
+  using reference_type = void;
 
   template <class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION static
-  void* ptr( TaskNode<TaskQueueTraits>* task )
-  { return nullptr; }
+  KOKKOS_INLINE_FUNCTION static void* ptr(TaskNode<TaskQueueTraits>* task) {
+    return nullptr;
+  }
 
-  KOKKOS_INLINE_FUNCTION static
-  void * ptr( TaskBase* ) { return (void*) nullptr ; }
+  KOKKOS_INLINE_FUNCTION static void* ptr(TaskBase*) { return (void*)nullptr; }
 
   template <class TaskQueueTraits>
-  KOKKOS_INLINE_FUNCTION static
-  reference_type get( TaskNode<TaskQueueTraits>* task )
-  { /* Should never be called */ }
+  KOKKOS_INLINE_FUNCTION static reference_type get(
+      TaskNode<TaskQueueTraits>* task) { /* Should never be called */
+  }
 
-  KOKKOS_INLINE_FUNCTION static
-  reference_type get( TaskBase* ) {}
+  KOKKOS_INLINE_FUNCTION static reference_type get(TaskBase*) {}
 
-  KOKKOS_INLINE_FUNCTION static
-  void destroy( TaskBase* task )
-    { }
+  KOKKOS_INLINE_FUNCTION static void destroy(TaskBase* task) {}
 
-  //template <class TaskQueueTraits>
-  //KOKKOS_INLINE_FUNCTION static
-  //void destroy( TaskNode<TaskQueueTraits>* task )
+  // template <class TaskQueueTraits>
+  // KOKKOS_INLINE_FUNCTION static
+  // void destroy( TaskNode<TaskQueueTraits>* task )
   //{ }
 };
 
@@ -148,4 +142,3 @@ struct TaskResult< void > {
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_TASKRESULT_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_TaskTeamMember.hpp b/lib/kokkos/core/src/impl/Kokkos_TaskTeamMember.hpp
index 4bf3f4fa94d366541af3cbeab399249116c62562..5a9d4c77bf601e230b2c320f780592e1cb577e7f 100644
--- a/lib/kokkos/core/src/impl/Kokkos_TaskTeamMember.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_TaskTeamMember.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 //----------------------------------------------------------------------------
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core_fwd.hpp>
 #include <Kokkos_TaskScheduler_fwd.hpp>
@@ -70,28 +71,22 @@ namespace Impl {
 
 template <class TeamMember, class Scheduler>
 class TaskTeamMemberAdapter : public TeamMember {
-private:
-
+ private:
   Scheduler m_scheduler;
 
-public:
-
+ public:
   //----------------------------------------
 
   // Forward everything but the Scheduler to the constructor of the TeamMember
   // type that we're adapting
   template <typename... Args>
-  KOKKOS_INLINE_FUNCTION
-  explicit TaskTeamMemberAdapter(
-    typename std::enable_if<
-      std::is_constructible<TeamMember, Args...>::value,
-      Scheduler
-    >::type arg_scheduler,
-    Args&&... args
-  ) // TODO @tasking @minor DSH noexcept specification
-    : TeamMember(std::forward<Args>(args)...),
-      m_scheduler(std::move(arg_scheduler).get_team_scheduler(this->league_rank()))
-  { }
+  KOKKOS_INLINE_FUNCTION explicit TaskTeamMemberAdapter(
+      typename std::enable_if<std::is_constructible<TeamMember, Args...>::value,
+                              Scheduler>::type arg_scheduler,
+      Args&&... args)  // TODO @tasking @minor DSH noexcept specification
+      : TeamMember(std::forward<Args>(args)...),
+        m_scheduler(
+            std::move(arg_scheduler).get_team_scheduler(this->league_rank())) {}
 
   // (rule of 6 constructors)
 
@@ -121,15 +116,13 @@ public:
   Scheduler& scheduler() noexcept { return m_scheduler; }
 
   //----------------------------------------
-
 };
 
-} // end namespace Impl
-} // namespace Kokkos
+}  // end namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_TASKTEAMMEMBER_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Timer.hpp b/lib/kokkos/core/src/impl/Kokkos_Timer.hpp
index 9897225c3801a3f581f5423559cace0d6eb35dee..e8004ff85258975d3f36ee2a9345414e27ea09ad 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Timer.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Timer.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -49,15 +50,14 @@
 namespace Kokkos {
 namespace Impl {
 
-/** \brief  Time since construction 
+/** \brief  Time since construction
  *   Timer promoted from Impl to Kokkos ns
  *   This file included for backwards compatibility
  */
 
-  using Kokkos::Timer ;
+using Kokkos::Timer;
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* #ifndef KOKKOS_IMPLWALLTIME_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Traits.hpp b/lib/kokkos/core/src/impl/Kokkos_Traits.hpp
index fc501cb73ea919def74914499aff7e451f7f5173..6f7e164bafbd6728f3a4e0d4277e50339d4ac8ef 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Traits.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Traits.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,86 +58,82 @@ namespace Impl {
 //----------------------------------------------------------------------------
 // Help with C++11 variadic argument packs
 
-template< unsigned I , typename ... Pack >
-struct get_type { typedef void type ; };
-
-template< typename T , typename ... Pack >
-struct get_type< 0 , T , Pack ... >
-{ typedef T type ; };
-
-template< unsigned I , typename T , typename ... Pack >
-struct get_type< I , T , Pack ... >
-{ typedef typename get_type< I - 1 , Pack ... >::type type ; };
-
+template <unsigned I, typename... Pack>
+struct get_type {
+  typedef void type;
+};
 
-template< typename T , typename ... Pack >
-struct has_type { enum { value = false }; };
+template <typename T, typename... Pack>
+struct get_type<0, T, Pack...> {
+  typedef T type;
+};
 
-template< typename T , typename S , typename ... Pack >
-struct has_type<T,S,Pack...>
-{
-private:
+template <unsigned I, typename T, typename... Pack>
+struct get_type<I, T, Pack...> {
+  typedef typename get_type<I - 1, Pack...>::type type;
+};
 
-  enum { self_value = std::is_same<T,S>::value };
+template <typename T, typename... Pack>
+struct has_type {
+  enum { value = false };
+};
 
-  typedef has_type<T,Pack...> next ;
+template <typename T, typename S, typename... Pack>
+struct has_type<T, S, Pack...> {
+ private:
+  enum { self_value = std::is_same<T, S>::value };
 
-  static_assert( ! ( self_value && next::value )
-               , "Error: more than one member of the argument pack matches the type" );
+  typedef has_type<T, Pack...> next;
 
-public:
+  static_assert(
+      !(self_value && next::value),
+      "Error: more than one member of the argument pack matches the type");
 
+ public:
   enum { value = self_value || next::value };
-
 };
 
-
-template< typename DefaultType
-        , template< typename > class Condition
-        , typename ... Pack >
-struct has_condition
-{
+template <typename DefaultType, template <typename> class Condition,
+          typename... Pack>
+struct has_condition {
   enum { value = false };
-  typedef DefaultType type ;
+  typedef DefaultType type;
 };
 
-template< typename DefaultType
-        , template< typename > class Condition
-        , typename S
-        , typename ... Pack >
-struct has_condition< DefaultType , Condition , S , Pack... >
-{
-private:
-
+template <typename DefaultType, template <typename> class Condition, typename S,
+          typename... Pack>
+struct has_condition<DefaultType, Condition, S, Pack...> {
+ private:
   enum { self_value = Condition<S>::value };
 
-  typedef has_condition< DefaultType , Condition , Pack... > next ;
-
-  static_assert( ! ( self_value && next::value )
-               , "Error: more than one member of the argument pack satisfies condition" );
+  typedef has_condition<DefaultType, Condition, Pack...> next;
 
-public:
+  static_assert(
+      !(self_value && next::value),
+      "Error: more than one member of the argument pack satisfies condition");
 
+ public:
   enum { value = self_value || next::value };
 
-  typedef typename
-    std::conditional< self_value , S , typename next::type >::type
-      type ;
+  typedef
+      typename std::conditional<self_value, S, typename next::type>::type type;
 };
 
+template <class... Args>
+struct are_integral {
+  enum { value = true };
+};
 
-template< class ... Args >
-struct are_integral { enum { value = true }; };
-
-template< typename T , class ... Args >
-struct are_integral<T,Args...> {
-  enum { value =
-    // Accept std::is_integral OR std::is_enum as an integral value
-    // since a simple enum value is automically convertible to an
-    // integral value.
-    ( std::is_integral<T>::value || std::is_enum<T>::value )
-    &&
-    are_integral<Args...>::value };
+template <typename T, class... Args>
+struct are_integral<T, Args...> {
+  enum {
+    value =
+        // Accept std::is_integral OR std::is_enum as an integral value
+        // since a simple enum value is automically convertible to an
+        // integral value.
+    (std::is_integral<T>::value || std::is_enum<T>::value) &&
+    are_integral<Args...>::value
+  };
 };
 
 //----------------------------------------------------------------------------
@@ -146,76 +143,128 @@ struct are_integral<T,Args...> {
 //----------------------------------------------------------------------------
 // C++11 Helpers:
 
-template < class T , T v >
-struct integral_constant
-{
+template <class T, T v>
+struct integral_constant {
   // Declaration of 'static const' causes an unresolved linker symbol in debug
   // static const T value = v ;
   enum { value = T(v) };
   typedef T value_type;
-  typedef integral_constant<T,v> type;
-  KOKKOS_INLINE_FUNCTION operator T() { return v ; }
+  typedef integral_constant<T, v> type;
+  KOKKOS_INLINE_FUNCTION operator T() { return v; }
 };
 
-typedef integral_constant<bool,false> false_type ;
-typedef integral_constant<bool,true>  true_type ;
+typedef integral_constant<bool, false> false_type;
+typedef integral_constant<bool, true> true_type;
 
 //----------------------------------------------------------------------------
 // C++11 Type relationships:
 
-template< class X , class Y > struct is_same : public false_type {};
-template< class X >           struct is_same<X,X> : public true_type {};
+template <class X, class Y>
+struct is_same : public false_type {};
+template <class X>
+struct is_same<X, X> : public true_type {};
 
 //----------------------------------------------------------------------------
 // C++11 Type properties:
 
-template <typename T> struct is_const : public false_type {};
-template <typename T> struct is_const<const T> : public true_type {};
-template <typename T> struct is_const<const T & > : public true_type {};
+template <typename T>
+struct is_const : public false_type {};
+template <typename T>
+struct is_const<const T> : public true_type {};
+template <typename T>
+struct is_const<const T&> : public true_type {};
 
-template <typename T> struct is_array : public false_type {};
-template <typename T> struct is_array< T[] > : public true_type {};
-template <typename T, unsigned N > struct is_array< T[N] > : public true_type {};
+template <typename T>
+struct is_array : public false_type {};
+template <typename T>
+struct is_array<T[]> : public true_type {};
+template <typename T, unsigned N>
+struct is_array<T[N]> : public true_type {};
 
 //----------------------------------------------------------------------------
 // C++11 Type transformations:
 
-template <typename T> struct remove_const { typedef T type; };
-template <typename T> struct remove_const<const T> { typedef T type; };
-template <typename T> struct remove_const<const T & > { typedef T & type; };
+template <typename T>
+struct remove_const {
+  typedef T type;
+};
+template <typename T>
+struct remove_const<const T> {
+  typedef T type;
+};
+template <typename T>
+struct remove_const<const T&> {
+  typedef T& type;
+};
 
-template <typename T> struct add_const { typedef const T type; };
-template <typename T> struct add_const<T & > { typedef const T & type; };
-template <typename T> struct add_const<const T> { typedef const T type; };
-template <typename T> struct add_const<const T & > { typedef const T & type; };
+template <typename T>
+struct add_const {
+  typedef const T type;
+};
+template <typename T>
+struct add_const<T&> {
+  typedef const T& type;
+};
+template <typename T>
+struct add_const<const T> {
+  typedef const T type;
+};
+template <typename T>
+struct add_const<const T&> {
+  typedef const T& type;
+};
 
-template <typename T> struct remove_reference { typedef T type ; };
-template <typename T> struct remove_reference< T & > { typedef T type ; };
-template <typename T> struct remove_reference< const T & > { typedef const T type ; };
+template <typename T>
+struct remove_reference {
+  typedef T type;
+};
+template <typename T>
+struct remove_reference<T&> {
+  typedef T type;
+};
+template <typename T>
+struct remove_reference<const T&> {
+  typedef const T type;
+};
 
-template <typename T> struct remove_extent { typedef T type ; };
-template <typename T> struct remove_extent<T[]> { typedef T type ; };
-template <typename T, unsigned N > struct remove_extent<T[N]> { typedef T type ; };
+template <typename T>
+struct remove_extent {
+  typedef T type;
+};
+template <typename T>
+struct remove_extent<T[]> {
+  typedef T type;
+};
+template <typename T, unsigned N>
+struct remove_extent<T[N]> {
+  typedef T type;
+};
 
 //----------------------------------------------------------------------------
 // C++11 Other type generators:
 
-template< bool , class T , class F >
-struct condition { typedef F type ; };
+template <bool, class T, class F>
+struct condition {
+  typedef F type;
+};
 
-template< class T , class F >
-struct condition<true,T,F> { typedef T type ; };
+template <class T, class F>
+struct condition<true, T, F> {
+  typedef T type;
+};
 
-template< bool , class = void >
-struct enable_if ;
+template <bool, class = void>
+struct enable_if;
 
-template< class T >
-struct enable_if< true , T > { typedef T type ; };
+template <class T>
+struct enable_if<true, T> {
+  typedef T type;
+};
 
 //----------------------------------------------------------------------------
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -226,107 +275,111 @@ namespace Impl {
 
 //----------------------------------------------------------------------------
 
-template< class , class T = void >
-struct enable_if_type { typedef T type ; };
+template <class, class T = void>
+struct enable_if_type {
+  typedef T type;
+};
 
 //----------------------------------------------------------------------------
 
-template< bool B >
-struct bool_ : public integral_constant<bool,B> {};
+template <bool B>
+struct bool_ : public integral_constant<bool, B> {};
 
-template< unsigned I >
-struct unsigned_ : public integral_constant<unsigned,I> {};
+template <unsigned I>
+struct unsigned_ : public integral_constant<unsigned, I> {};
 
-template< int I >
-struct int_ : public integral_constant<int,I> {};
+template <int I>
+struct int_ : public integral_constant<int, I> {};
 
 typedef bool_<true> true_;
 typedef bool_<false> false_;
 //----------------------------------------------------------------------------
 // if_
 
-template < bool Cond , typename TrueType , typename FalseType>
-struct if_c
-{
+template <bool Cond, typename TrueType, typename FalseType>
+struct if_c {
   enum { value = Cond };
 
   typedef FalseType type;
 
+  typedef typename remove_const<typename remove_reference<type>::type>::type
+      value_type;
 
-  typedef typename remove_const<
-          typename remove_reference<type>::type >::type value_type ;
-
-  typedef typename add_const<value_type>::type const_value_type ;
+  typedef typename add_const<value_type>::type const_value_type;
 
-  static KOKKOS_INLINE_FUNCTION
-  const_value_type & select( const_value_type & v ) { return v ; }
-
-  static KOKKOS_INLINE_FUNCTION
-  value_type & select( value_type & v ) { return v ; }
+  static KOKKOS_INLINE_FUNCTION const_value_type& select(const_value_type& v) {
+    return v;
+  }
 
-  template< class T >
-  static KOKKOS_INLINE_FUNCTION
-  value_type & select( const T & ) { value_type * ptr(0); return *ptr ; }
+  static KOKKOS_INLINE_FUNCTION value_type& select(value_type& v) { return v; }
 
+  template <class T>
+  static KOKKOS_INLINE_FUNCTION value_type& select(const T&) {
+    value_type* ptr(0);
+    return *ptr;
+  }
 
-  template< class T >
-  static KOKKOS_INLINE_FUNCTION
-  const_value_type & select( const T & , const_value_type & v ) { return v ; }
+  template <class T>
+  static KOKKOS_INLINE_FUNCTION const_value_type& select(const T&,
+                                                         const_value_type& v) {
+    return v;
+  }
 
-  template< class T >
-  static KOKKOS_INLINE_FUNCTION
-  value_type & select( const T & , value_type & v ) { return v ; }
+  template <class T>
+  static KOKKOS_INLINE_FUNCTION value_type& select(const T&, value_type& v) {
+    return v;
+  }
 };
 
 template <typename TrueType, typename FalseType>
-struct if_c< true , TrueType , FalseType >
-{
+struct if_c<true, TrueType, FalseType> {
   enum { value = true };
 
   typedef TrueType type;
 
+  typedef typename remove_const<typename remove_reference<type>::type>::type
+      value_type;
 
-  typedef typename remove_const<
-          typename remove_reference<type>::type >::type value_type ;
-
-  typedef typename add_const<value_type>::type const_value_type ;
+  typedef typename add_const<value_type>::type const_value_type;
 
-  static KOKKOS_INLINE_FUNCTION
-  const_value_type & select( const_value_type & v ) { return v ; }
-
-  static KOKKOS_INLINE_FUNCTION
-  value_type & select( value_type & v ) { return v ; }
+  static KOKKOS_INLINE_FUNCTION const_value_type& select(const_value_type& v) {
+    return v;
+  }
 
-  template< class T >
-  static KOKKOS_INLINE_FUNCTION
-  value_type & select( const T & ) { value_type * ptr(0); return *ptr ; }
+  static KOKKOS_INLINE_FUNCTION value_type& select(value_type& v) { return v; }
 
+  template <class T>
+  static KOKKOS_INLINE_FUNCTION value_type& select(const T&) {
+    value_type* ptr(0);
+    return *ptr;
+  }
 
-  template< class F >
-  static KOKKOS_INLINE_FUNCTION
-  const_value_type & select( const_value_type & v , const F & ) { return v ; }
+  template <class F>
+  static KOKKOS_INLINE_FUNCTION const_value_type& select(const_value_type& v,
+                                                         const F&) {
+    return v;
+  }
 
-  template< class F >
-  static KOKKOS_INLINE_FUNCTION
-  value_type & select( value_type & v , const F & ) { return v ; }
+  template <class F>
+  static KOKKOS_INLINE_FUNCTION value_type& select(value_type& v, const F&) {
+    return v;
+  }
 };
 
-template< typename TrueType >
-struct if_c< false , TrueType , void >
-{
+template <typename TrueType>
+struct if_c<false, TrueType, void> {
   enum { value = false };
 
-  typedef void type ;
-  typedef void value_type ;
+  typedef void type;
+  typedef void value_type;
 };
 
-template< typename FalseType >
-struct if_c< true , void , FalseType >
-{
+template <typename FalseType>
+struct if_c<true, void, FalseType> {
   enum { value = true };
 
-  typedef void type ;
-  typedef void value_type ;
+  typedef void type;
+  typedef void value_type;
 };
 
 template <typename Cond, typename TrueType, typename FalseType>
@@ -335,53 +388,48 @@ struct if_ : public if_c<Cond::value, TrueType, FalseType> {};
 //----------------------------------------------------------------------------
 
 // Allows aliased types:
-template< typename T >
-struct is_integral : public integral_constant< bool ,
-  (
-    std::is_same< T ,          char >::value ||
-    std::is_same< T , unsigned char >::value ||
-    std::is_same< T ,          short int >::value ||
-    std::is_same< T , unsigned short int >::value ||
-    std::is_same< T ,          int >::value ||
-    std::is_same< T , unsigned int >::value ||
-    std::is_same< T ,          long int >::value ||
-    std::is_same< T , unsigned long int >::value ||
-    std::is_same< T ,          long long int >::value ||
-    std::is_same< T , unsigned long long int >::value ||
-
-    std::is_same< T , int8_t   >::value ||
-    std::is_same< T , int16_t  >::value ||
-    std::is_same< T , int32_t  >::value ||
-    std::is_same< T , int64_t  >::value ||
-    std::is_same< T , uint8_t  >::value ||
-    std::is_same< T , uint16_t >::value ||
-    std::is_same< T , uint32_t >::value ||
-    std::is_same< T , uint64_t >::value
-  )>
-{};
+template <typename T>
+struct is_integral
+    : public integral_constant<
+          bool,
+          (std::is_same<T, char>::value ||
+           std::is_same<T, unsigned char>::value ||
+           std::is_same<T, short int>::value ||
+           std::is_same<T, unsigned short int>::value ||
+           std::is_same<T, int>::value ||
+           std::is_same<T, unsigned int>::value ||
+           std::is_same<T, long int>::value ||
+           std::is_same<T, unsigned long int>::value ||
+           std::is_same<T, long long int>::value ||
+           std::is_same<T, unsigned long long int>::value ||
+
+           std::is_same<T, int8_t>::value || std::is_same<T, int16_t>::value ||
+           std::is_same<T, int32_t>::value || std::is_same<T, int64_t>::value ||
+           std::is_same<T, uint8_t>::value ||
+           std::is_same<T, uint16_t>::value ||
+           std::is_same<T, uint32_t>::value ||
+           std::is_same<T, uint64_t>::value)> {};
 //----------------------------------------------------------------------------
 
-template<typename T>
+template <typename T>
 struct is_label : public false_type {};
 
-template<>
+template <>
 struct is_label<const char*> : public true_type {};
 
-template<>
+template <>
 struct is_label<char*> : public true_type {};
 
-
-template<int N>
+template <int N>
 struct is_label<const char[N]> : public true_type {};
 
-template<int N>
+template <int N>
 struct is_label<char[N]> : public true_type {};
 
-
-template<>
+template <>
 struct is_label<const std::string> : public true_type {};
 
-template<>
+template <>
 struct is_label<std::string> : public true_type {};
 
 // These 'constexpr'functions can be used as
@@ -389,47 +437,47 @@ struct is_label<std::string> : public true_type {};
 
 /**\brief  There exists integral 'k' such that N = 2^k */
 KOKKOS_INLINE_FUNCTION
-constexpr bool is_integral_power_of_two( const size_t N )
-{ return ( 0 < N ) && ( 0 == ( N & ( N - 1 ) ) ); }
+constexpr bool is_integral_power_of_two(const size_t N) {
+  return (0 < N) && (0 == (N & (N - 1)));
+}
 
 /**\brief  Return integral 'k' such that N = 2^k, assuming valid.  */
 KOKKOS_INLINE_FUNCTION
-constexpr unsigned integral_power_of_two_assume_valid( const size_t N )
-{ return N == 1 ? 0 : 1 + integral_power_of_two_assume_valid( N >> 1 ); }
+constexpr unsigned integral_power_of_two_assume_valid(const size_t N) {
+  return N == 1 ? 0 : 1 + integral_power_of_two_assume_valid(N >> 1);
+}
 
 /**\brief  Return integral 'k' such that N = 2^k, if exists.
  *         If does not exist return ~0u.
  */
 KOKKOS_INLINE_FUNCTION
-constexpr unsigned integral_power_of_two( const size_t N )
-{ return is_integral_power_of_two(N) ? integral_power_of_two_assume_valid(N) : ~0u ; }
+constexpr unsigned integral_power_of_two(const size_t N) {
+  return is_integral_power_of_two(N) ? integral_power_of_two_assume_valid(N)
+                                     : ~0u;
+}
 
 //----------------------------------------------------------------------------
 
-template < size_t N >
-struct is_power_of_two
-{
-  enum type { value = (N > 0) && !(N & (N-1)) };
+template <size_t N>
+struct is_power_of_two {
+  enum type { value = (N > 0) && !(N & (N - 1)) };
 };
 
-template < size_t N , bool OK = is_power_of_two<N>::value >
-struct power_of_two ;
+template <size_t N, bool OK = is_power_of_two<N>::value>
+struct power_of_two;
 
-template < size_t N >
-struct power_of_two<N,true>
-{
-  enum type { value = 1+ power_of_two<(N>>1),true>::value };
+template <size_t N>
+struct power_of_two<N, true> {
+  enum type { value = 1 + power_of_two<(N >> 1), true>::value };
 };
 
 template <>
-struct power_of_two<2,true>
-{
+struct power_of_two<2, true> {
   enum type { value = 1 };
 };
 
 template <>
-struct power_of_two<1,true>
-{
+struct power_of_two<1, true> {
   enum type { value = 0 };
 };
 
@@ -437,49 +485,45 @@ struct power_of_two<1,true>
  *          otherwise return ~0u.
  */
 KOKKOS_FORCEINLINE_FUNCTION
-unsigned power_of_two_if_valid( const unsigned N )
-{
-  unsigned p = ~0u ;
-  if ( is_integral_power_of_two ( N ) ) {
-    p = bit_scan_forward ( N ) ;
+unsigned power_of_two_if_valid(const unsigned N) {
+  unsigned p = ~0u;
+  if (is_integral_power_of_two(N)) {
+    p = bit_scan_forward(N);
   }
-  return p ;
+  return p;
 }
 
 //----------------------------------------------------------------------------
 
-template< typename T , T v , bool NonZero = ( v != T(0) ) >
-struct integral_nonzero_constant
-{
+template <typename T, T v, bool NonZero = (v != T(0))>
+struct integral_nonzero_constant {
   // Declaration of 'static const' causes an unresolved linker symbol in debug
   // static const T value = v ;
   enum { value = T(v) };
-  typedef T value_type ;
-  typedef integral_nonzero_constant<T,v> type ;
-  KOKKOS_INLINE_FUNCTION integral_nonzero_constant( const T & ) {}
+  typedef T value_type;
+  typedef integral_nonzero_constant<T, v> type;
+  KOKKOS_INLINE_FUNCTION integral_nonzero_constant(const T&) {}
 };
 
-template< typename T , T zero >
-struct integral_nonzero_constant<T,zero,false>
-{
-  const T value ;
-  typedef T value_type ;
-  typedef integral_nonzero_constant<T,0> type ;
-  KOKKOS_INLINE_FUNCTION integral_nonzero_constant( const T & v ) : value(v) {}
+template <typename T, T zero>
+struct integral_nonzero_constant<T, zero, false> {
+  const T value;
+  typedef T value_type;
+  typedef integral_nonzero_constant<T, 0> type;
+  KOKKOS_INLINE_FUNCTION integral_nonzero_constant(const T& v) : value(v) {}
 };
 
 //----------------------------------------------------------------------------
 
-template < class C > struct is_integral_constant : public false_
-{
-  typedef void integral_type ;
+template <class C>
+struct is_integral_constant : public false_ {
+  typedef void integral_type;
   enum { integral_value = 0 };
 };
 
-template < typename T , T v >
-struct is_integral_constant< integral_constant<T,v> > : public true_
-{
-  typedef T integral_type ;
+template <typename T, T v>
+struct is_integral_constant<integral_constant<T, v>> : public true_ {
+  typedef T integral_type;
   enum { integral_value = v };
 };
 
@@ -497,7 +541,8 @@ template <class Head, class... Tail>
 struct ReverseTypeList<TypeList<Head, Tail...>> {
   template <class... ReversedTail>
   struct impl {
-    using type = typename ReverseTypeList<TypeList<Tail...>>::template impl<Head, ReversedTail...>::type;
+    using type = typename ReverseTypeList<TypeList<Tail...>>::template impl<
+        Head, ReversedTail...>::type;
   };
   using type = typename impl<>::type;
 };
@@ -514,28 +559,24 @@ struct ReverseTypeList<TypeList<>> {
 //----------------------------------------------------------------------------
 
 template <class T>
-struct make_all_extents_into_pointers
-{
+struct make_all_extents_into_pointers {
   using type = T;
 };
 
 template <class T, unsigned N>
-struct make_all_extents_into_pointers<T[N]>
-{
+struct make_all_extents_into_pointers<T[N]> {
   using type = typename make_all_extents_into_pointers<T>::type*;
 };
 
 template <class T>
-struct make_all_extents_into_pointers<T*>
-{
+struct make_all_extents_into_pointers<T*> {
   using type = typename make_all_extents_into_pointers<T>::type*;
 };
 
-} // namespace Impl
-} // namespace Kokkos
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOSTRAITS_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_Utilities.hpp b/lib/kokkos/core/src/impl/Kokkos_Utilities.hpp
index 611a32c4fe04d925b1fa9e8b34fe2dc3ccb842b6..1b095248ebdb8374c3a68bbb4fb40e4611aa03e3 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Utilities.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Utilities.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,100 +52,108 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-namespace Kokkos { namespace Impl {
+namespace Kokkos {
+namespace Impl {
 
 // same as std::forward
 // needed to allow perfect forwarding on the device
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-constexpr
-T&& forward( typename std::remove_reference<T>::type& arg ) noexcept
-{ return static_cast<T&&>(arg); }
+KOKKOS_INLINE_FUNCTION constexpr T&& forward(
+    typename std::remove_reference<T>::type& arg) noexcept {
+  return static_cast<T&&>(arg);
+}
 
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-constexpr
-T&& forward( typename std::remove_reference<T>::type&& arg ) noexcept
-{ return static_cast<T&&>(arg); }
+KOKKOS_INLINE_FUNCTION constexpr T&& forward(
+    typename std::remove_reference<T>::type&& arg) noexcept {
+  return static_cast<T&&>(arg);
+}
 
 // same as std::move
 // needed to allowing moving on the device
 template <typename T>
-KOKKOS_INLINE_FUNCTION
-constexpr
-typename std::remove_reference<T>::type&& move( T&& arg ) noexcept
-{ return static_cast<typename std::remove_reference<T>::type&&>(arg); }
+KOKKOS_INLINE_FUNCTION constexpr typename std::remove_reference<T>::type&& move(
+    T&& arg) noexcept {
+  return static_cast<typename std::remove_reference<T>::type&&>(arg);
+}
 
 // empty function to allow expanding a variadic argument pack
-template<typename... Args>
-KOKKOS_INLINE_FUNCTION
-void expand_variadic(Args &&...) {}
+template <typename... Args>
+KOKKOS_INLINE_FUNCTION void expand_variadic(Args&&...) {}
 
 //----------------------------------------
 // C++14 integer sequence
-template< typename T , T ... Ints >
+template <typename T, T... Ints>
 struct integer_sequence {
-  using value_type = T ;
+  using value_type = T;
   static constexpr std::size_t size() noexcept { return sizeof...(Ints); }
 };
 
-template< typename T , std::size_t N >
-struct make_integer_sequence_helper ;
+template <typename T, std::size_t N>
+struct make_integer_sequence_helper;
 
-template< typename T , T N >
-using make_integer_sequence =
-  typename make_integer_sequence_helper<T,N>::type ;
+template <typename T, T N>
+using make_integer_sequence = typename make_integer_sequence_helper<T, N>::type;
 
-template< typename T >
-struct make_integer_sequence_helper< T , 0 >
-{ using type = integer_sequence<T> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 0> {
+  using type = integer_sequence<T>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 1 >
-{ using type = integer_sequence<T,0> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 1> {
+  using type = integer_sequence<T, 0>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 2 >
-{ using type = integer_sequence<T,0,1> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 2> {
+  using type = integer_sequence<T, 0, 1>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 3 >
-{ using type = integer_sequence<T,0,1,2> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 3> {
+  using type = integer_sequence<T, 0, 1, 2>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 4 >
-{ using type = integer_sequence<T,0,1,2,3> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 4> {
+  using type = integer_sequence<T, 0, 1, 2, 3>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 5 >
-{ using type = integer_sequence<T,0,1,2,3,4> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 5> {
+  using type = integer_sequence<T, 0, 1, 2, 3, 4>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 6 >
-{ using type = integer_sequence<T,0,1,2,3,4,5> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 6> {
+  using type = integer_sequence<T, 0, 1, 2, 3, 4, 5>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 7 >
-{ using type = integer_sequence<T,0,1,2,3,4,5,6> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 7> {
+  using type = integer_sequence<T, 0, 1, 2, 3, 4, 5, 6>;
+};
 
-template< typename T >
-struct make_integer_sequence_helper< T , 8 >
-{ using type = integer_sequence<T,0,1,2,3,4,5,6,7> ; };
+template <typename T>
+struct make_integer_sequence_helper<T, 8> {
+  using type = integer_sequence<T, 0, 1, 2, 3, 4, 5, 6, 7>;
+};
 
-template< typename X , typename Y >
-struct make_integer_sequence_concat ;
+template <typename X, typename Y>
+struct make_integer_sequence_concat;
 
-template< typename T , T ... x , T ... y >
-struct make_integer_sequence_concat< integer_sequence<T,x...>
-                                   , integer_sequence<T,y...> >
-{ using type = integer_sequence< T , x ... , (sizeof...(x)+y)... > ; };
+template <typename T, T... x, T... y>
+struct make_integer_sequence_concat<integer_sequence<T, x...>,
+                                    integer_sequence<T, y...> > {
+  using type = integer_sequence<T, x..., (sizeof...(x) + y)...>;
+};
 
-template< typename T , std::size_t N >
+template <typename T, std::size_t N>
 struct make_integer_sequence_helper {
-  using type = typename make_integer_sequence_concat
-    < typename make_integer_sequence_helper< T , N/2 >::type
-    , typename make_integer_sequence_helper< T , N - N/2 >::type
-    >::type ;
+  using type = typename make_integer_sequence_concat<
+      typename make_integer_sequence_helper<T, N / 2>::type,
+      typename make_integer_sequence_helper<T, N - N / 2>::type>::type;
 };
 
 //----------------------------------------
@@ -152,8 +161,8 @@ struct make_integer_sequence_helper {
 template <std::size_t... Indices>
 using index_sequence = integer_sequence<std::size_t, Indices...>;
 
-template< std::size_t N >
-using make_index_sequence = make_integer_sequence< std::size_t, N>;
+template <std::size_t N>
+using make_index_sequence = make_integer_sequence<std::size_t, N>;
 
 //----------------------------------------
 
@@ -162,258 +171,253 @@ struct integer_sequence_at;
 
 template <unsigned I, typename T, T h0, T... tail>
 struct integer_sequence_at<I, integer_sequence<T, h0, tail...> >
-  : public integer_sequence_at<I-1u, integer_sequence<T,tail...> >
-{
-  static_assert( 8 <= I , "Reasoning Error" );
-  static_assert( I < integer_sequence<T, h0, tail...>::size(), "Error: Index out of bounds");
+    : public integer_sequence_at<I - 1u, integer_sequence<T, tail...> > {
+  static_assert(8 <= I, "Reasoning Error");
+  static_assert(I < integer_sequence<T, h0, tail...>::size(),
+                "Error: Index out of bounds");
 };
 
-template < typename T, T h0, T... tail>
-struct integer_sequence_at<0u, integer_sequence<T,h0, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T... tail>
+struct integer_sequence_at<0u, integer_sequence<T, h0, tail...> > {
+  using type               = T;
   static constexpr T value = h0;
 };
 
-template < typename T, T h0, T h1, T... tail>
-struct integer_sequence_at<1u, integer_sequence<T, h0, h1, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T h1, T... tail>
+struct integer_sequence_at<1u, integer_sequence<T, h0, h1, tail...> > {
+  using type               = T;
   static constexpr T value = h1;
 };
 
-template < typename T, T h0, T h1, T h2, T... tail>
-struct integer_sequence_at<2u, integer_sequence<T, h0, h1, h2, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T h1, T h2, T... tail>
+struct integer_sequence_at<2u, integer_sequence<T, h0, h1, h2, tail...> > {
+  using type               = T;
   static constexpr T value = h2;
 };
 
-template < typename T, T h0, T h1, T h2, T h3, T... tail>
-struct integer_sequence_at<3u, integer_sequence<T, h0, h1, h2, h3, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T h1, T h2, T h3, T... tail>
+struct integer_sequence_at<3u, integer_sequence<T, h0, h1, h2, h3, tail...> > {
+  using type               = T;
   static constexpr T value = h3;
 };
 
-template < typename T, T h0, T h1, T h2, T h3, T h4, T... tail>
-struct integer_sequence_at<4u, integer_sequence<T, h0, h1, h2, h3, h4, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T h1, T h2, T h3, T h4, T... tail>
+struct integer_sequence_at<4u,
+                           integer_sequence<T, h0, h1, h2, h3, h4, tail...> > {
+  using type               = T;
   static constexpr T value = h4;
 };
 
-template < typename T, T h0, T h1, T h2, T h3, T h4, T h5, T... tail>
-struct integer_sequence_at<5u, integer_sequence<T, h0, h1, h2, h3, h4, h5, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T h1, T h2, T h3, T h4, T h5, T... tail>
+struct integer_sequence_at<
+    5u, integer_sequence<T, h0, h1, h2, h3, h4, h5, tail...> > {
+  using type               = T;
   static constexpr T value = h5;
 };
 
-template < typename T, T h0, T h1, T h2, T h3, T h4, T h5, T h6, T... tail>
-struct integer_sequence_at<6u, integer_sequence<T, h0, h1, h2, h3, h4, h5, h6, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T h1, T h2, T h3, T h4, T h5, T h6, T... tail>
+struct integer_sequence_at<
+    6u, integer_sequence<T, h0, h1, h2, h3, h4, h5, h6, tail...> > {
+  using type               = T;
   static constexpr T value = h6;
 };
 
-template < typename T, T h0, T h1, T h2, T h3, T h4, T h5, T h6, T h7, T... tail>
-struct integer_sequence_at<7u, integer_sequence<T, h0, h1, h2, h3, h4, h5, h6, h7, tail...> >
-{
-  using type = T;
+template <typename T, T h0, T h1, T h2, T h3, T h4, T h5, T h6, T h7, T... tail>
+struct integer_sequence_at<
+    7u, integer_sequence<T, h0, h1, h2, h3, h4, h5, h6, h7, tail...> > {
+  using type               = T;
   static constexpr T value = h7;
 };
 
 //----------------------------------------
 
 template <typename T>
-constexpr
-T at( const unsigned, integer_sequence<T> ) noexcept
-{ return ~static_cast<T>(0); }
+constexpr T at(const unsigned, integer_sequence<T>) noexcept {
+  return ~static_cast<T>(0);
+}
 
 template <typename T, T h0, T... tail>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0> ) noexcept
-{ return i==0u ? h0 : ~static_cast<T>(0); }
+constexpr T at(const unsigned i, integer_sequence<T, h0>) noexcept {
+  return i == 0u ? h0 : ~static_cast<T>(0);
+}
 
 template <typename T, T h0, T h1>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0, h1> ) noexcept
-{ return i==0u ? h0 :
-         i==1u ? h1 : ~static_cast<T>(0);
+constexpr T at(const unsigned i, integer_sequence<T, h0, h1>) noexcept {
+  return i == 0u ? h0 : i == 1u ? h1 : ~static_cast<T>(0);
 }
 
 template <typename T, T h0, T h1, T h2>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0, h1, h2> ) noexcept
-{ return i==0u ? h0 :
-         i==1u ? h1 :
-         i==2u ? h2 : ~static_cast<T>(0);
+constexpr T at(const unsigned i, integer_sequence<T, h0, h1, h2>) noexcept {
+  return i == 0u ? h0 : i == 1u ? h1 : i == 2u ? h2 : ~static_cast<T>(0);
 }
 
 template <typename T, T h0, T h1, T h2, T h3>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0, h1, h2, h3> ) noexcept
-{ return i==0u ? h0 :
-         i==1u ? h1 :
-         i==2u ? h2 :
-         i==3u ? h3 : ~static_cast<T>(0);
+constexpr T at(const unsigned i, integer_sequence<T, h0, h1, h2, h3>) noexcept {
+  return i == 0u
+             ? h0
+             : i == 1u ? h1 : i == 2u ? h2 : i == 3u ? h3 : ~static_cast<T>(0);
 }
 
 template <typename T, T h0, T h1, T h2, T h3, T h4>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0, h1, h2, h3, h4> ) noexcept
-{ return i==0u ? h0 :
-         i==1u ? h1 :
-         i==2u ? h2 :
-         i==3u ? h3 :
-         i==4u ? h4 : ~static_cast<T>(0);
+constexpr T at(const unsigned i,
+               integer_sequence<T, h0, h1, h2, h3, h4>) noexcept {
+  return i == 0u
+             ? h0
+             : i == 1u
+                   ? h1
+                   : i == 2u ? h2
+                             : i == 3u ? h3 : i == 4u ? h4 : ~static_cast<T>(0);
 }
 
 template <typename T, T h0, T h1, T h2, T h3, T h4, T h5>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0, h1, h2, h3, h4, h5> ) noexcept
-{ return i==0u ? h0 :
-         i==1u ? h1 :
-         i==2u ? h2 :
-         i==3u ? h3 :
-         i==4u ? h4 :
-         i==5u ? h5 : ~static_cast<T>(0);
+constexpr T at(const unsigned i,
+               integer_sequence<T, h0, h1, h2, h3, h4, h5>) noexcept {
+  return i == 0u
+             ? h0
+             : i == 1u
+                   ? h1
+                   : i == 2u ? h2
+                             : i == 3u ? h3
+                                       : i == 4u ? h4
+                                                 : i == 5u ? h5
+                                                           : ~static_cast<T>(0);
 }
 
 template <typename T, T h0, T h1, T h2, T h3, T h4, T h5, T h6>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0, h1, h2, h3, h4, h5, h6> ) noexcept
-{ return i==0u ? h0 :
-         i==1u ? h1 :
-         i==2u ? h2 :
-         i==3u ? h3 :
-         i==4u ? h4 :
-         i==5u ? h5 :
-         i==6u ? h6 : ~static_cast<T>(0);
+constexpr T at(const unsigned i,
+               integer_sequence<T, h0, h1, h2, h3, h4, h5, h6>) noexcept {
+  return i == 0u
+             ? h0
+             : i == 1u
+                   ? h1
+                   : i == 2u
+                         ? h2
+                         : i == 3u
+                               ? h3
+                               : i == 4u
+                                     ? h4
+                                     : i == 5u
+                                           ? h5
+                                           : i == 6u ? h6 : ~static_cast<T>(0);
 }
 
 template <typename T, T h0, T h1, T h2, T h3, T h4, T h5, T h6, T h7, T... tail>
-constexpr
-T at( const unsigned i, integer_sequence<T, h0, h1, h2, h3, h4, h5, h6, h7, tail...> ) noexcept
-{ return i==0u ? h0 :
-         i==1u ? h1 :
-         i==2u ? h2 :
-         i==3u ? h3 :
-         i==4u ? h4 :
-         i==5u ? h5 :
-         i==6u ? h6 :
-         i==7u ? h7 : at(i-8u, integer_sequence<T, tail...>{} );
+constexpr T at(
+    const unsigned i,
+    integer_sequence<T, h0, h1, h2, h3, h4, h5, h6, h7, tail...>) noexcept {
+  return i == 0u
+             ? h0
+             : i == 1u
+                   ? h1
+                   : i == 2u
+                         ? h2
+                         : i == 3u
+                               ? h3
+                               : i == 4u
+                                     ? h4
+                                     : i == 5u
+                                           ? h5
+                                           : i == 6u
+                                                 ? h6
+                                                 : i == 7u
+                                                       ? h7
+                                                       : at(i - 8u,
+                                                            integer_sequence<
+                                                                T, tail...>{});
 }
 
 //----------------------------------------
 
-
-template < typename IntegerSequence
-         , typename ResultSequence = integer_sequence<typename IntegerSequence::value_type>
-         >
+template <typename IntegerSequence,
+          typename ResultSequence =
+              integer_sequence<typename IntegerSequence::value_type> >
 struct reverse_integer_sequence_helper;
 
 template <typename T, T h0, T... tail, T... results>
-struct reverse_integer_sequence_helper< integer_sequence<T, h0, tail...>, integer_sequence<T, results...> >
-  : public reverse_integer_sequence_helper< integer_sequence<T, tail...>, integer_sequence<T, h0, results...> >
-{};
+struct reverse_integer_sequence_helper<integer_sequence<T, h0, tail...>,
+                                       integer_sequence<T, results...> >
+    : public reverse_integer_sequence_helper<
+          integer_sequence<T, tail...>, integer_sequence<T, h0, results...> > {
+};
 
 template <typename T, T... results>
-struct reverse_integer_sequence_helper< integer_sequence<T>, integer_sequence<T, results...> >
-{
+struct reverse_integer_sequence_helper<integer_sequence<T>,
+                                       integer_sequence<T, results...> > {
   using type = integer_sequence<T, results...>;
 };
 
-
 template <typename IntegerSequence>
-using reverse_integer_sequence = typename reverse_integer_sequence_helper<IntegerSequence>::type;
+using reverse_integer_sequence =
+    typename reverse_integer_sequence_helper<IntegerSequence>::type;
 
 //----------------------------------------
 
-template < typename IntegerSequence
-         , typename Result
-         , typename ResultSequence = integer_sequence<typename IntegerSequence::value_type>
-         >
+template <typename IntegerSequence, typename Result,
+          typename ResultSequence =
+              integer_sequence<typename IntegerSequence::value_type> >
 struct exclusive_scan_integer_sequence_helper;
 
 template <typename T, T h0, T... tail, typename Result, T... results>
-struct exclusive_scan_integer_sequence_helper
-  < integer_sequence<T, h0, tail...>
-  , Result
-  , integer_sequence<T, results...> >
-  : public exclusive_scan_integer_sequence_helper
-     < integer_sequence<T, tail...>
-     , std::integral_constant<T,Result::value+h0>
-     , integer_sequence<T, 0, (results+h0)...> >
-{};
+struct exclusive_scan_integer_sequence_helper<
+    integer_sequence<T, h0, tail...>, Result, integer_sequence<T, results...> >
+    : public exclusive_scan_integer_sequence_helper<
+          integer_sequence<T, tail...>,
+          std::integral_constant<T, Result::value + h0>,
+          integer_sequence<T, 0, (results + h0)...> > {};
 
 template <typename T, typename Result, T... results>
-struct exclusive_scan_integer_sequence_helper
-  < integer_sequence<T>, Result, integer_sequence<T, results...> >
-{
-  using type = integer_sequence<T, results...>;
-  static constexpr T value = Result::value ;
+struct exclusive_scan_integer_sequence_helper<
+    integer_sequence<T>, Result, integer_sequence<T, results...> > {
+  using type               = integer_sequence<T, results...>;
+  static constexpr T value = Result::value;
 };
 
 template <typename IntegerSequence>
-struct exclusive_scan_integer_sequence
-{
+struct exclusive_scan_integer_sequence {
   using value_type = typename IntegerSequence::value_type;
-  using helper =
-    exclusive_scan_integer_sequence_helper
-       < reverse_integer_sequence<IntegerSequence>
-       , std::integral_constant< value_type , 0 >
-       > ;
-  using type = typename helper::type ;
-  static constexpr value_type value  = helper::value ;
+  using helper     = exclusive_scan_integer_sequence_helper<
+      reverse_integer_sequence<IntegerSequence>,
+      std::integral_constant<value_type, 0> >;
+  using type                        = typename helper::type;
+  static constexpr value_type value = helper::value;
 };
 
 //----------------------------------------
 
-template < typename IntegerSequence
-         , typename Result
-         , typename ResultSequence = integer_sequence<typename IntegerSequence::value_type>
-         >
+template <typename IntegerSequence, typename Result,
+          typename ResultSequence =
+              integer_sequence<typename IntegerSequence::value_type> >
 struct inclusive_scan_integer_sequence_helper;
 
 template <typename T, T h0, T... tail, typename Result, T... results>
-struct inclusive_scan_integer_sequence_helper
-  < integer_sequence<T, h0, tail...>
-  , Result
-  , integer_sequence<T, results...> >
-  : public inclusive_scan_integer_sequence_helper
-     < integer_sequence<T, tail...>
-     , std::integral_constant<T,Result::value+h0>
-     , integer_sequence<T, h0, (results+h0)...> >
-{};
+struct inclusive_scan_integer_sequence_helper<
+    integer_sequence<T, h0, tail...>, Result, integer_sequence<T, results...> >
+    : public inclusive_scan_integer_sequence_helper<
+          integer_sequence<T, tail...>,
+          std::integral_constant<T, Result::value + h0>,
+          integer_sequence<T, h0, (results + h0)...> > {};
 
 template <typename T, typename Result, T... results>
-struct inclusive_scan_integer_sequence_helper
-  < integer_sequence<T>, Result, integer_sequence<T, results...> >
-{
-  using type = integer_sequence<T, results...>;
-  static constexpr T value = Result::value ;
+struct inclusive_scan_integer_sequence_helper<
+    integer_sequence<T>, Result, integer_sequence<T, results...> > {
+  using type               = integer_sequence<T, results...>;
+  static constexpr T value = Result::value;
 };
 
 template <typename IntegerSequence>
-struct inclusive_scan_integer_sequence
-{
+struct inclusive_scan_integer_sequence {
   using value_type = typename IntegerSequence::value_type;
-  using helper =
-    inclusive_scan_integer_sequence_helper
-       < reverse_integer_sequence<IntegerSequence>
-       , std::integral_constant< value_type , 0 >
-       > ;
-  using type = typename helper::type ;
-  static constexpr value_type value  = helper::value ;
+  using helper     = inclusive_scan_integer_sequence_helper<
+      reverse_integer_sequence<IntegerSequence>,
+      std::integral_constant<value_type, 0> >;
+  using type                        = typename helper::type;
+  static constexpr value_type value = helper::value;
 };
 
 template <typename T>
 using identity_t = T;
 
-}} // namespace Kokkos::Impl
-
-
-#endif //KOKKOS_CORE_IMPL_UTILITIES_HPP
+}  // namespace Impl
+}  // namespace Kokkos
 
+#endif  // KOKKOS_CORE_IMPL_UTILITIES_HPP
diff --git a/lib/kokkos/core/src/impl/Kokkos_VLAEmulation.hpp b/lib/kokkos/core/src/impl/Kokkos_VLAEmulation.hpp
index 48e1851e60f382d93e6e69424b68b7e754350cd7..2746932878631039a1f842421fbb9ef8112ee7eb 100644
--- a/lib/kokkos/core/src/impl/Kokkos_VLAEmulation.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_VLAEmulation.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,14 +46,13 @@
 #define KOKKOS_IMPL_VLAEMULATION_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
-
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
 #include <Kokkos_Core_fwd.hpp>
 
-#include <impl/Kokkos_Error.hpp> // KOKKOS_EXPECTS
+#include <impl/Kokkos_Error.hpp>  // KOKKOS_EXPECTS
 
-#include <type_traits> // std::is_abstract<>, ...
+#include <type_traits>  // std::is_abstract<>, ...
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -60,89 +60,86 @@
 namespace Kokkos {
 namespace Impl {
 
-template <
-  class Derived,
-  class VLAValueType,
-  class EntryCountType = int32_t
->
+template <class Derived, class VLAValueType, class EntryCountType = int32_t>
 struct ObjectWithVLAEmulation;
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-/** @brief Attorney to enable private CRTP inheritance from ObjectWithVLAEmulation
+/** @brief Attorney to enable private CRTP inheritance from
+ * ObjectWithVLAEmulation
  */
 struct VLAEmulationAccess {
-private:
-
+ private:
   template <class, class, class>
   friend struct ObjectWithVLAEmulation;
 
   template <class Derived, class VLAValueType, class EntryCountType>
-  KOKKOS_FORCEINLINE_FUNCTION
-  static constexpr Derived*
-  _cast_to_derived(ObjectWithVLAEmulation<Derived, VLAValueType, EntryCountType>* base) noexcept
-  {
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr Derived* _cast_to_derived(
+      ObjectWithVLAEmulation<Derived, VLAValueType, EntryCountType>*
+          base) noexcept {
     return static_cast<Derived*>(base);
   }
 
   template <class Derived, class VLAValueType, class EntryCountType>
-  KOKKOS_FORCEINLINE_FUNCTION
-  static constexpr Derived const*
-  _cast_to_derived(ObjectWithVLAEmulation<Derived, VLAValueType, EntryCountType> const* base) noexcept
-  {
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr Derived const* _cast_to_derived(
+      ObjectWithVLAEmulation<Derived, VLAValueType, EntryCountType> const*
+          base) noexcept {
     return static_cast<Derived const*>(base);
   }
-
 };
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-/** \brief A CRTP base class for a type that includes a variable-length array by allocation
+/** \brief A CRTP base class for a type that includes a variable-length array by
+ * allocation
  *
  *  The storage for the derived type must be allocated manually and the objects
  *  (both derived type and VLA objects) must be constructed with placement new.
  *  Obviously, this can't be done for objects on the stack.
  *
- *  Note: Though most uses of this currently delete the copy and move constructor
- *  in the `Derived` type, this type is intended to have value semantics.
+ *  Note: Though most uses of this currently delete the copy and move
+ * constructor in the `Derived` type, this type is intended to have value
+ * semantics.
  *
- *  \todo @documentation elaborate on implications of value semantics for this class template
+ *  \todo @documentation elaborate on implications of value semantics for this
+ * class template
  *
  */
-template <
-  class Derived,
-  class VLAValueType,
-  class EntryCountType /* = int32_t */
->
+template <class Derived, class VLAValueType,
+          class EntryCountType /* = int32_t */
+          >
 struct ObjectWithVLAEmulation {
-public:
-
-  using object_type = Derived;
-  using vla_value_type = VLAValueType;
+ public:
+  using object_type          = Derived;
+  using vla_value_type       = VLAValueType;
   using vla_entry_count_type = EntryCountType;
 
-  using iterator = VLAValueType*;
+  using iterator       = VLAValueType*;
   using const_iterator = typename std::add_const<VLAValueType>::type*;
 
+  // TODO @tasking @minor DSH require that Derived be marked final? (note that
+  // std::is_final is C++14)
+  // TODO @tasking @minor DSH delete non-placement operator new for Derived
+  // type?
 
-  // TODO @tasking @minor DSH require that Derived be marked final? (note that std::is_final is C++14)
-  // TODO @tasking @minor DSH delete non-placement operator new for Derived type?
-
-private:
-
+ private:
   vla_entry_count_type m_num_entries;
 
   // CRTP boilerplate
 
   KOKKOS_FORCEINLINE_FUNCTION
   /* KOKKOS_CONSTEXPR_14 */
-  Derived* _this() noexcept { return VLAEmulationAccess::_cast_to_derived(this); }
+  Derived* _this() noexcept {
+    return VLAEmulationAccess::_cast_to_derived(this);
+  }
 
   KOKKOS_FORCEINLINE_FUNCTION
   /* KOKKOS_CONSTEXPR_14 */
-  Derived const* _this() const noexcept { return VLAEmulationAccess::_cast_to_derived(this); }
+  Derived const* _this() const noexcept {
+    return VLAEmulationAccess::_cast_to_derived(this);
+  }
 
   // Note: can't be constexpr because of reinterpret_cast
   KOKKOS_FORCEINLINE_FUNCTION
@@ -160,11 +157,10 @@ private:
     return reinterpret_cast<vla_value_type const*>(_this() + 1);
   }
 
-public:
-
+ public:
   KOKKOS_INLINE_FUNCTION
-  static /* KOKKOS_CONSTEXPR_14 */ size_t
-  required_allocation_size(vla_entry_count_type num_vla_entries) {
+  static /* KOKKOS_CONSTEXPR_14 */ size_t required_allocation_size(
+      vla_entry_count_type num_vla_entries) {
     KOKKOS_EXPECTS(num_vla_entries >= 0);
     return sizeof(Derived) + num_vla_entries * sizeof(VLAValueType);
   }
@@ -172,53 +168,52 @@ public:
   //----------------------------------------------------------------------------
   // <editor-fold desc="Constructors, destructor, and assignment"> {{{2
 
-  // TODO @tasking @optimization DSH specialization for trivially constructible VLAValueType?
-  // TODO @tasking @minor DSH SFINAE-out this constructor for non-default contructible vla_value_types
+  // TODO @tasking @optimization DSH specialization for trivially constructible
+  // VLAValueType?
+  // TODO @tasking @minor DSH SFINAE-out this constructor for non-default
+  // contructible vla_value_types
   KOKKOS_INLINE_FUNCTION
-  explicit
-  ObjectWithVLAEmulation(vla_entry_count_type num_entries)
-    noexcept(noexcept(vla_value_type()))
-    : m_num_entries(num_entries)
-  {
+  explicit ObjectWithVLAEmulation(vla_entry_count_type num_entries) noexcept(
+      noexcept(vla_value_type()))
+      : m_num_entries(num_entries) {
     // Note: We can't do this at class scope because it unnecessarily requires
     // object_type to be a complete type
-    static_assert(
-      alignof(object_type) >= alignof(vla_value_type),
-      "Can't append emulated variable length array of type with greater alignment than"
-      "  the type to which the VLA is being appended"
-    );
+    static_assert(alignof(object_type) >= alignof(vla_value_type),
+                  "Can't append emulated variable length array of type with "
+                  "greater alignment than"
+                  "  the type to which the VLA is being appended");
 
     // Note: We can't do this at class scope because it unnecessarily requires
     // vla_value_type to be a complete type
-    static_assert(
-      not std::is_abstract<vla_value_type>::value,
-      "Can't use abstract type with VLA emulation"
-    );
+    static_assert(not std::is_abstract<vla_value_type>::value,
+                  "Can't use abstract type with VLA emulation");
 
     KOKKOS_EXPECTS(num_entries >= 0);
-    for(vla_entry_count_type i = 0; i < m_num_entries; ++i) {
+    for (vla_entry_count_type i = 0; i < m_num_entries; ++i) {
       new (_vla_pointer() + i) vla_value_type();
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  ~ObjectWithVLAEmulation()
-    noexcept(noexcept(std::declval<vla_value_type>().~vla_value_type()))
-  {
-    for(auto&& value : *this) { value.~vla_value_type(); }
+  ~ObjectWithVLAEmulation() noexcept(
+      noexcept(std::declval<vla_value_type>().~vla_value_type())) {
+    for (auto&& value : *this) {
+      value.~vla_value_type();
+    }
   }
 
-  // TODO @tasking @new_feature DSH constrained analogs for move and copy ctors and assignment ops
+  // TODO @tasking @new_feature DSH constrained analogs for move and copy ctors
+  // and assignment ops
   // TODO @tasking @new_feature DSH forwarding in_place constructor
   // TODO @tasking @new_feature DSH initializer_list constructor?
 
   // </editor-fold> end Constructors, destructor, and assignment }}}2
   //----------------------------------------------------------------------------
 
-
   KOKKOS_INLINE_FUNCTION
-  constexpr EntryCountType n_vla_entries() const noexcept { return m_num_entries; }
-
+  constexpr EntryCountType n_vla_entries() const noexcept {
+    return m_num_entries;
+  }
 
   //----------------------------------------------------------------------------
   // <editor-fold desc="Accessing the object and the VLA values"> {{{2
@@ -227,29 +222,27 @@ public:
   object_type& object() & { return static_cast<Derived&>(*this); }
 
   KOKKOS_INLINE_FUNCTION
-  object_type const& object() const & { return static_cast<Derived const&>(*this); }
+  object_type const& object() const& {
+    return static_cast<Derived const&>(*this);
+  }
 
   KOKKOS_INLINE_FUNCTION
   object_type&& object() && { return static_cast<Derived&&>(*this); }
 
-
   KOKKOS_INLINE_FUNCTION
-  vla_value_type& vla_value_at(vla_entry_count_type n) &
-  {
+  vla_value_type& vla_value_at(vla_entry_count_type n) & {
     KOKKOS_EXPECTS(n < n_vla_entries());
     return _vla_pointer()[n];
   }
 
   KOKKOS_INLINE_FUNCTION
-  vla_value_type const& vla_value_at(vla_entry_count_type n) const &
-  {
+  vla_value_type const& vla_value_at(vla_entry_count_type n) const& {
     KOKKOS_EXPECTS(n < n_vla_entries());
     return _vla_pointer()[n];
   }
 
   KOKKOS_INLINE_FUNCTION
-  vla_value_type& vla_value_at(vla_entry_count_type n) &&
-  {
+  vla_value_type& vla_value_at(vla_entry_count_type n) && {
     KOKKOS_EXPECTS(n < n_vla_entries());
     return _vla_pointer()[n];
   }
@@ -257,7 +250,6 @@ public:
   // </editor-fold> end Accessing the object and the VLA values }}}2
   //----------------------------------------------------------------------------
 
-
   //----------------------------------------------------------------------------
   // <editor-fold desc="Iterators"> {{{2
 
@@ -281,7 +273,6 @@ public:
 
   // </editor-fold> end Iterators }}}2
   //----------------------------------------------------------------------------
-
 };
 
 } /* namespace Impl */
@@ -292,4 +283,3 @@ public:
 
 #endif /* #if defined( KOKKOS_ENABLE_TASKDAG ) */
 #endif /* #ifndef KOKKOS_IMPL_VLAEMULATION_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewArray.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewArray.hpp
index 07774da27915f94664268f76471a728890888ca7..6123a608a7ca9329bc6cf8727395e9b9a16c8c11 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewArray.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewArray.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,51 +50,56 @@
 namespace Kokkos {
 namespace Impl {
 
-template< class DataType , class ArrayLayout , class V , size_t N , class P >
-struct ViewDataAnalysis< DataType , ArrayLayout , Kokkos::Array<V,N,P> >
-{
-private:
-
-  typedef ViewArrayAnalysis<DataType> array_analysis ;
-
-  static_assert( std::is_same<P,void>::value , "" );
-  static_assert( std::is_same<typename array_analysis::non_const_value_type , Kokkos::Array<V,N,P> >::value , "" );
-  static_assert( std::is_scalar<V>::value , "View of Array type must be of a scalar type" );
-
-public:
-
-  typedef Kokkos::Array<>  specialize ;
-
-  typedef typename array_analysis::dimension  dimension ;
-
-private:
-
-  enum { is_const = std::is_same< typename array_analysis::value_type
-                                , typename array_analysis::const_value_type
-                                >::value };
-
-  typedef typename dimension::template append<N>::type array_scalar_dimension ;
-
-  typedef typename std::conditional< is_const , const V , V >::type  scalar_type ;
-  typedef V       non_const_scalar_type ;
-  typedef const V const_scalar_type ;
-
-public:
-
-  typedef typename array_analysis::value_type            value_type ;
-  typedef typename array_analysis::const_value_type      const_value_type ;
-  typedef typename array_analysis::non_const_value_type  non_const_value_type ;
-
-  typedef typename ViewDataType<           value_type , dimension >::type  type ;
-  typedef typename ViewDataType<     const_value_type , dimension >::type  const_type ;
-  typedef typename ViewDataType< non_const_value_type , dimension >::type  non_const_type ;
-
-  typedef typename ViewDataType<           scalar_type , array_scalar_dimension >::type  scalar_array_type ;
-  typedef typename ViewDataType<     const_scalar_type , array_scalar_dimension >::type  const_scalar_array_type ;
-  typedef typename ViewDataType< non_const_scalar_type , array_scalar_dimension >::type  non_const_scalar_array_type ;
+template <class DataType, class ArrayLayout, class V, size_t N, class P>
+struct ViewDataAnalysis<DataType, ArrayLayout, Kokkos::Array<V, N, P> > {
+ private:
+  typedef ViewArrayAnalysis<DataType> array_analysis;
+
+  static_assert(std::is_same<P, void>::value, "");
+  static_assert(std::is_same<typename array_analysis::non_const_value_type,
+                             Kokkos::Array<V, N, P> >::value,
+                "");
+  static_assert(std::is_scalar<V>::value,
+                "View of Array type must be of a scalar type");
+
+ public:
+  typedef Kokkos::Array<> specialize;
+
+  typedef typename array_analysis::dimension dimension;
+
+ private:
+  enum {
+    is_const = std::is_same<typename array_analysis::value_type,
+                            typename array_analysis::const_value_type>::value
+  };
+
+  typedef typename dimension::template append<N>::type array_scalar_dimension;
+
+  typedef typename std::conditional<is_const, const V, V>::type scalar_type;
+  typedef V non_const_scalar_type;
+  typedef const V const_scalar_type;
+
+ public:
+  typedef typename array_analysis::value_type value_type;
+  typedef typename array_analysis::const_value_type const_value_type;
+  typedef typename array_analysis::non_const_value_type non_const_value_type;
+
+  typedef typename ViewDataType<value_type, dimension>::type type;
+  typedef typename ViewDataType<const_value_type, dimension>::type const_type;
+  typedef typename ViewDataType<non_const_value_type, dimension>::type
+      non_const_type;
+
+  typedef typename ViewDataType<scalar_type, array_scalar_dimension>::type
+      scalar_array_type;
+  typedef typename ViewDataType<const_scalar_type, array_scalar_dimension>::type
+      const_scalar_array_type;
+  typedef
+      typename ViewDataType<non_const_scalar_type, array_scalar_dimension>::type
+          non_const_scalar_array_type;
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -102,442 +108,552 @@ namespace Kokkos {
 namespace Impl {
 
 /** \brief  View mapping for non-specialized data type and standard layout */
-template< class Traits >
-class ViewMapping< Traits , Kokkos::Array<> >
-{
-private:
-
-  template< class , class ... > friend class ViewMapping ;
-  template< class , class ... > friend class Kokkos::View ;
-
-  typedef ViewOffset< typename Traits::dimension
-                    , typename Traits::array_layout
-                    , void
-                    >  offset_type ;
-
-  typedef typename Traits::value_type::pointer handle_type ;
-
-  handle_type  m_impl_handle ;
-  offset_type  m_impl_offset ;
-  size_t       m_stride ;
-
-  typedef typename Traits::value_type::value_type scalar_type ;
-
-  typedef Kokkos::Array< scalar_type ,KOKKOS_INVALID_INDEX , Kokkos::Array<>::contiguous >  contiguous_reference ;
-  typedef Kokkos::Array< scalar_type ,KOKKOS_INVALID_INDEX , Kokkos::Array<>::strided >     strided_reference ;
-
-  enum { is_contiguous_reference =
-    ( Traits::rank == 0 ) || ( std::is_same< typename Traits::array_layout , Kokkos::LayoutRight >::value ) };
+template <class Traits>
+class ViewMapping<Traits, Kokkos::Array<> > {
+ private:
+  template <class, class...>
+  friend class ViewMapping;
+  template <class, class...>
+  friend class Kokkos::View;
+
+  typedef ViewOffset<typename Traits::dimension, typename Traits::array_layout,
+                     void>
+      offset_type;
+
+  typedef typename Traits::value_type::pointer handle_type;
+
+  handle_type m_impl_handle;
+  offset_type m_impl_offset;
+  size_t m_stride;
+
+  typedef typename Traits::value_type::value_type scalar_type;
+
+  typedef Kokkos::Array<scalar_type, KOKKOS_INVALID_INDEX,
+                        Kokkos::Array<>::contiguous>
+      contiguous_reference;
+  typedef Kokkos::Array<scalar_type, KOKKOS_INVALID_INDEX,
+                        Kokkos::Array<>::strided>
+      strided_reference;
+
+  enum {
+    is_contiguous_reference =
+        (Traits::rank == 0) || (std::is_same<typename Traits::array_layout,
+                                             Kokkos::LayoutRight>::value)
+  };
 
   enum { Array_N = Traits::value_type::size() };
   enum { Array_S = is_contiguous_reference ? Array_N : 1 };
 
   KOKKOS_INLINE_FUNCTION
-  ViewMapping( const handle_type & arg_handle , const offset_type & arg_offset )
-    : m_impl_handle( arg_handle )
-    , m_impl_offset( arg_offset )
-    , m_stride( is_contiguous_reference ? 0 : arg_offset.span() )
-    {}
-
-public:
+  ViewMapping(const handle_type &arg_handle, const offset_type &arg_offset)
+      : m_impl_handle(arg_handle),
+        m_impl_offset(arg_offset),
+        m_stride(is_contiguous_reference ? 0 : arg_offset.span()) {}
 
+ public:
   //----------------------------------------
   // Domain dimensions
 
   enum { Rank = Traits::dimension::rank };
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION constexpr size_t extent( const iType & r ) const
-    { return m_impl_offset.m_dim.extent(r); }
-
-  KOKKOS_INLINE_FUNCTION constexpr
-  typename Traits::array_layout layout() const
-    { return m_impl_offset.layout(); }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION constexpr size_t extent(const iType &r) const {
+    return m_impl_offset.m_dim.extent(r);
+  }
 
+  KOKKOS_INLINE_FUNCTION constexpr typename Traits::array_layout layout()
+      const {
+    return m_impl_offset.layout();
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const { return m_impl_offset.dimension_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return m_impl_offset.dimension_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return m_impl_offset.dimension_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return m_impl_offset.dimension_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return m_impl_offset.dimension_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return m_impl_offset.dimension_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return m_impl_offset.dimension_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return m_impl_offset.dimension_7(); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const {
+    return m_impl_offset.dimension_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const {
+    return m_impl_offset.dimension_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const {
+    return m_impl_offset.dimension_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const {
+    return m_impl_offset.dimension_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const {
+    return m_impl_offset.dimension_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const {
+    return m_impl_offset.dimension_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const {
+    return m_impl_offset.dimension_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const {
+    return m_impl_offset.dimension_7();
+  }
 
   // Is a regular layout with uniform striding for each index.
-  using is_regular = typename offset_type::is_regular ;
+  using is_regular = typename offset_type::is_regular;
 
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return m_impl_offset.stride_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return m_impl_offset.stride_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return m_impl_offset.stride_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return m_impl_offset.stride_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return m_impl_offset.stride_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return m_impl_offset.stride_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return m_impl_offset.stride_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return m_impl_offset.stride_7(); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const {
+    return m_impl_offset.stride_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const {
+    return m_impl_offset.stride_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const {
+    return m_impl_offset.stride_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const {
+    return m_impl_offset.stride_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const {
+    return m_impl_offset.stride_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const {
+    return m_impl_offset.stride_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const {
+    return m_impl_offset.stride_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const {
+    return m_impl_offset.stride_7();
+  }
 
   //----------------------------------------
   // Range span
 
   /** \brief  Span of the mapped range */
-  KOKKOS_INLINE_FUNCTION constexpr size_t span() const
-    { return m_impl_offset.span() * Array_N ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_t span() const {
+    return m_impl_offset.span() * Array_N;
+  }
 
   /** \brief  Is the mapped range span contiguous */
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const
-    { return m_impl_offset.span_is_contiguous(); }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return m_impl_offset.span_is_contiguous();
+  }
 
-  typedef typename std::conditional< is_contiguous_reference , contiguous_reference , strided_reference >::type  reference_type ;
+  typedef
+      typename std::conditional<is_contiguous_reference, contiguous_reference,
+                                strided_reference>::type reference_type;
 
-  typedef handle_type pointer_type ;
+  typedef handle_type pointer_type;
 
-  /** \brief  If data references are lvalue_reference than can query pointer to memory */
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const
-    { return m_impl_handle ; }
+  /** \brief  If data references are lvalue_reference than can query pointer to
+   * memory */
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const {
+    return m_impl_handle;
+  }
 
   //----------------------------------------
   // The View class performs all rank and bounds checking before
   // calling these element reference methods.
 
   KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference() const { return reference_type( m_impl_handle + 0 , Array_N , 0 ); }
+  reference_type reference() const {
+    return reference_type(m_impl_handle + 0, Array_N, 0);
+  }
 
-  template< typename I0 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type
-  reference( const I0 & i0 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0) * Array_S , Array_N , m_stride ); }
+  template <typename I0>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0) const {
+    return reference_type(m_impl_handle + m_impl_offset(i0) * Array_S, Array_N,
+                          m_stride);
+  }
 
-  template< typename I0 , typename I1 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0,i1) * Array_S , Array_N , m_stride ); }
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0,
+                                                       const I1 &i1) const {
+    return reference_type(m_impl_handle + m_impl_offset(i0, i1) * Array_S,
+                          Array_N, m_stride);
+  }
 
-  template< typename I0 , typename I1 , typename I2 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0,i1,i2) * Array_S , Array_N , m_stride ); }
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0,
+                                                       const I1 &i1,
+                                                       const I2 &i2) const {
+    return reference_type(m_impl_handle + m_impl_offset(i0, i1, i2) * Array_S,
+                          Array_N, m_stride);
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0,i1,i2,i3) * Array_S , Array_N , m_stride ); }
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3) const {
+    return reference_type(
+        m_impl_handle + m_impl_offset(i0, i1, i2, i3) * Array_S, Array_N,
+        m_stride);
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0,i1,i2,i3,i4) * Array_S , Array_N , m_stride ); }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0,
+                                                       const I1 &i1,
+                                                       const I2 &i2,
+                                                       const I3 &i3,
+                                                       const I4 &i4) const {
+    return reference_type(
+        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4) * Array_S, Array_N,
+        m_stride);
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 , const I5 & i5 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0,i1,i2,i3,i4,i5) * Array_S , Array_N , m_stride ); }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3,
+            const I4 &i4, const I5 &i5) const {
+    return reference_type(
+        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4, i5) * Array_S,
+        Array_N, m_stride);
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 , const I5 & i5 , const I6 & i6 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0,i1,i2,i3,i4,i5,i6) * Array_S , Array_N , m_stride ); }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3,
+            const I4 &i4, const I5 &i5, const I6 &i6) const {
+    return reference_type(
+        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4, i5, i6) * Array_S,
+        Array_N, m_stride);
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6 , typename I7 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7 ) const
-    { return reference_type( m_impl_handle + m_impl_offset(i0,i1,i2,i3,i4,i5,i6,i7) * Array_S , Array_N , m_stride ); }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3,
+            const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7) const {
+    return reference_type(
+        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4, i5, i6, i7) * Array_S,
+        Array_N, m_stride);
+  }
 
   //----------------------------------------
 
-private:
-
+ private:
   enum { MemorySpanMask = 8 - 1 /* Force alignment on 8 byte boundary */ };
   enum { MemorySpanSize = sizeof(scalar_type) };
 
-public:
-
+ public:
   /** \brief  Span, in bytes, of the referenced memory */
-  KOKKOS_INLINE_FUNCTION constexpr size_t memory_span() const
-    {
-      return ( m_impl_offset.span() * Array_N * MemorySpanSize + MemorySpanMask ) & ~size_t(MemorySpanMask);
-    }
+  KOKKOS_INLINE_FUNCTION constexpr size_t memory_span() const {
+    return (m_impl_offset.span() * Array_N * MemorySpanSize + MemorySpanMask) &
+           ~size_t(MemorySpanMask);
+  }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION ~ViewMapping() {}
-  KOKKOS_INLINE_FUNCTION ViewMapping() : m_impl_handle(), m_impl_offset(), m_stride(0) {}
-  KOKKOS_INLINE_FUNCTION ViewMapping( const ViewMapping & rhs )
-    : m_impl_handle( rhs.m_impl_handle ), m_impl_offset( rhs.m_impl_offset ), m_stride( rhs.m_stride ) {}
-  KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( const ViewMapping & rhs )
-    { m_impl_handle = rhs.m_impl_handle ; m_impl_offset = rhs.m_impl_offset ; m_stride = rhs.m_stride ; ; return *this ; }
+  KOKKOS_INLINE_FUNCTION ViewMapping()
+      : m_impl_handle(), m_impl_offset(), m_stride(0) {}
+  KOKKOS_INLINE_FUNCTION ViewMapping(const ViewMapping &rhs)
+      : m_impl_handle(rhs.m_impl_handle),
+        m_impl_offset(rhs.m_impl_offset),
+        m_stride(rhs.m_stride) {}
+  KOKKOS_INLINE_FUNCTION ViewMapping &operator=(const ViewMapping &rhs) {
+    m_impl_handle = rhs.m_impl_handle;
+    m_impl_offset = rhs.m_impl_offset;
+    m_stride      = rhs.m_stride;
+    ;
+    return *this;
+  }
 
-  KOKKOS_INLINE_FUNCTION ViewMapping( ViewMapping && rhs )
-    : m_impl_handle( rhs.m_impl_handle ), m_impl_offset( rhs.m_impl_offset ), m_stride( rhs.m_stride ) {}
-  KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( ViewMapping && rhs )
-    { m_impl_handle = rhs.m_impl_handle ; m_impl_offset = rhs.m_impl_offset ; m_stride = rhs.m_stride ; return *this ; }
+  KOKKOS_INLINE_FUNCTION ViewMapping(ViewMapping &&rhs)
+      : m_impl_handle(rhs.m_impl_handle),
+        m_impl_offset(rhs.m_impl_offset),
+        m_stride(rhs.m_stride) {}
+  KOKKOS_INLINE_FUNCTION ViewMapping &operator=(ViewMapping &&rhs) {
+    m_impl_handle = rhs.m_impl_handle;
+    m_impl_offset = rhs.m_impl_offset;
+    m_stride      = rhs.m_stride;
+    return *this;
+  }
 
   //----------------------------------------
 
-  template< class ... Args >
-  KOKKOS_INLINE_FUNCTION
-  ViewMapping( pointer_type ptr , Args ... args )
-    : m_impl_handle( ptr )
-    , m_impl_offset( std::integral_constant< unsigned , 0 >() , args... )
-    , m_stride( m_impl_offset.span() )
-    {}
+  template <class... Args>
+  KOKKOS_INLINE_FUNCTION ViewMapping(pointer_type ptr, Args... args)
+      : m_impl_handle(ptr),
+        m_impl_offset(std::integral_constant<unsigned, 0>(), args...),
+        m_stride(m_impl_offset.span()) {}
 
   //----------------------------------------
 
-  template< class ... P >
-  Kokkos::Impl::SharedAllocationRecord<> *
-  allocate_shared( Kokkos::Impl::ViewCtorProp< P... > const & arg_prop
-                 , typename Traits::array_layout const & arg_layout
-                 )
-  {
-    typedef Kokkos::Impl::ViewCtorProp< P... > alloc_prop ;
+  template <class... P>
+  Kokkos::Impl::SharedAllocationRecord<> *allocate_shared(
+      Kokkos::Impl::ViewCtorProp<P...> const &arg_prop,
+      typename Traits::array_layout const &arg_layout) {
+    typedef Kokkos::Impl::ViewCtorProp<P...> alloc_prop;
 
-    typedef typename alloc_prop::execution_space  execution_space ;
-    typedef typename Traits::memory_space         memory_space ;
-    typedef ViewValueFunctor< execution_space , scalar_type > functor_type ;
-    typedef Kokkos::Impl::SharedAllocationRecord< memory_space , functor_type > record_type ;
+    typedef typename alloc_prop::execution_space execution_space;
+    typedef typename Traits::memory_space memory_space;
+    typedef ViewValueFunctor<execution_space, scalar_type> functor_type;
+    typedef Kokkos::Impl::SharedAllocationRecord<memory_space, functor_type>
+        record_type;
 
     // Query the mapping for byte-size of allocation.
-    typedef std::integral_constant< unsigned ,
-      alloc_prop::allow_padding ? sizeof(scalar_type) : 0 > padding ;
+    typedef std::integral_constant<
+        unsigned, alloc_prop::allow_padding ? sizeof(scalar_type) : 0>
+        padding;
 
-    m_impl_offset = offset_type( padding(), arg_layout );
+    m_impl_offset = offset_type(padding(), arg_layout);
 
     const size_t alloc_size =
-      ( m_impl_offset.span() * Array_N * MemorySpanSize + MemorySpanMask ) & ~size_t(MemorySpanMask);
+        (m_impl_offset.span() * Array_N * MemorySpanSize + MemorySpanMask) &
+        ~size_t(MemorySpanMask);
 
     // Allocate memory from the memory space and create tracking record.
-    record_type * const record =
-      record_type::allocate( ((Kokkos::Impl::ViewCtorProp<void,memory_space> const &) arg_prop ).value
-                           , ((Kokkos::Impl::ViewCtorProp<void,std::string>  const &) arg_prop ).value
-                           , alloc_size );
+    record_type *const record = record_type::allocate(
+        ((Kokkos::Impl::ViewCtorProp<void, memory_space> const &)arg_prop)
+            .value,
+        ((Kokkos::Impl::ViewCtorProp<void, std::string> const &)arg_prop).value,
+        alloc_size);
 
-    if ( alloc_size ) {
+    if (alloc_size) {
       m_impl_handle =
-        handle_type( reinterpret_cast< pointer_type >( record->data() ) );
+          handle_type(reinterpret_cast<pointer_type>(record->data()));
 
-      if ( alloc_prop::initialize ) {
+      if (alloc_prop::initialize) {
         // The functor constructs and destroys
-        record->m_destroy = functor_type( ((Kokkos::Impl::ViewCtorProp<void,execution_space> const & )arg_prop).value
-                                        , (pointer_type) m_impl_handle
-                                        , m_impl_offset.span() * Array_N
-                                        );
+        record->m_destroy = functor_type(
+            ((Kokkos::Impl::ViewCtorProp<void, execution_space> const &)
+                 arg_prop)
+                .value,
+            (pointer_type)m_impl_handle, m_impl_offset.span() * Array_N);
 
         record->m_destroy.construct_shared_allocation();
       }
     }
 
-    return record ;
+    return record;
   }
 };
 
 /** \brief Assign Array to non-Array */
 
-template< class DstTraits , class SrcTraits >
-class ViewMapping< DstTraits , SrcTraits ,
-  typename std::enable_if<(
-    std::is_same< typename DstTraits::memory_space , typename SrcTraits::memory_space >::value
-    &&
-    std::is_same< typename DstTraits::specialize , void >::value
-    &&
-    (
-      std::is_same< typename DstTraits::array_layout , Kokkos::LayoutLeft >::value ||
-      std::is_same< typename DstTraits::array_layout , Kokkos::LayoutRight >::value ||
-      std::is_same< typename DstTraits::array_layout , Kokkos::LayoutStride >::value
-    )
-    &&
-    std::is_same< typename SrcTraits::specialize , Kokkos::Array<> >::value
-    &&
-    (
-      std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value ||
-      std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value ||
-      std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutStride >::value
-    )
-  )>::type >
-{
-public:
-
+template <class DstTraits, class SrcTraits>
+class ViewMapping<
+    DstTraits, SrcTraits,
+    typename std::enable_if<(
+        std::is_same<typename DstTraits::memory_space,
+                     typename SrcTraits::memory_space>::value &&
+        std::is_same<typename DstTraits::specialize, void>::value &&
+        (std::is_same<typename DstTraits::array_layout,
+                      Kokkos::LayoutLeft>::value ||
+         std::is_same<typename DstTraits::array_layout,
+                      Kokkos::LayoutRight>::value ||
+         std::is_same<typename DstTraits::array_layout,
+                      Kokkos::LayoutStride>::value) &&
+        std::is_same<typename SrcTraits::specialize, Kokkos::Array<> >::value &&
+        (std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutLeft>::value ||
+         std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutRight>::value ||
+         std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutStride>::value))>::type> {
+ public:
   // Can only convert to View::array_type
 
-  enum { is_assignable_data_type = std::is_same< typename DstTraits::data_type ,    typename SrcTraits::scalar_array_type >::value &&
-                                   (DstTraits::rank==SrcTraits::rank+1)};
-  enum { is_assignable = std::is_same< typename DstTraits::data_type ,    typename SrcTraits::scalar_array_type >::value &&
-                         std::is_same< typename DstTraits::array_layout , typename SrcTraits::array_layout >::value };
-
-  typedef Kokkos::Impl::SharedAllocationTracker  TrackType ;
-  typedef ViewMapping< DstTraits , void >  DstType ;
-  typedef ViewMapping< SrcTraits , Kokkos::Array<> >  SrcType ;
+  enum {
+    is_assignable_data_type =
+        std::is_same<typename DstTraits::data_type,
+                     typename SrcTraits::scalar_array_type>::value &&
+        (DstTraits::rank == SrcTraits::rank + 1)
+  };
+  enum {
+    is_assignable =
+        std::is_same<typename DstTraits::data_type,
+                     typename SrcTraits::scalar_array_type>::value &&
+        std::is_same<typename DstTraits::array_layout,
+                     typename SrcTraits::array_layout>::value
+  };
+
+  typedef Kokkos::Impl::SharedAllocationTracker TrackType;
+  typedef ViewMapping<DstTraits, void> DstType;
+  typedef ViewMapping<SrcTraits, Kokkos::Array<> > SrcType;
 
   KOKKOS_INLINE_FUNCTION
-  static void assign( DstType & dst , const SrcType & src , const TrackType & src_track )
-    {
-      static_assert( is_assignable , "Can only convert to array_type" );
-
-      typedef typename DstType::offset_type  dst_offset_type ;
-
-      // Array dimension becomes the last dimension.
-      // Arguments beyond the destination rank are ignored.
-      if ( src.span_is_contiguous() ) { // not padded
-        dst.m_impl_offset = dst_offset_type( std::integral_constant<unsigned,0>() ,
-          typename DstTraits::array_layout
-            ( ( 0 < SrcType::Rank ? src.dimension_0() : SrcTraits::value_type::size() )
-            , ( 1 < SrcType::Rank ? src.dimension_1() : SrcTraits::value_type::size() )
-            , ( 2 < SrcType::Rank ? src.dimension_2() : SrcTraits::value_type::size() )
-            , ( 3 < SrcType::Rank ? src.dimension_3() : SrcTraits::value_type::size() )
-            , ( 4 < SrcType::Rank ? src.dimension_4() : SrcTraits::value_type::size() )
-            , ( 5 < SrcType::Rank ? src.dimension_5() : SrcTraits::value_type::size() )
-            , ( 6 < SrcType::Rank ? src.dimension_6() : SrcTraits::value_type::size() )
-            , ( 7 < SrcType::Rank ? src.dimension_7() : SrcTraits::value_type::size() )
-            ) );
-      }
-      else { // is padded
-        typedef std::integral_constant<unsigned,sizeof(typename SrcTraits::value_type::value_type)> padded ;
-
-        dst.m_impl_offset = dst_offset_type( padded() ,
-          typename DstTraits::array_layout
-            ( ( 0 < SrcType::Rank ? src.dimension_0() : SrcTraits::value_type::size() )
-            , ( 1 < SrcType::Rank ? src.dimension_1() : SrcTraits::value_type::size() )
-            , ( 2 < SrcType::Rank ? src.dimension_2() : SrcTraits::value_type::size() )
-            , ( 3 < SrcType::Rank ? src.dimension_3() : SrcTraits::value_type::size() )
-            , ( 4 < SrcType::Rank ? src.dimension_4() : SrcTraits::value_type::size() )
-            , ( 5 < SrcType::Rank ? src.dimension_5() : SrcTraits::value_type::size() )
-            , ( 6 < SrcType::Rank ? src.dimension_6() : SrcTraits::value_type::size() )
-            , ( 7 < SrcType::Rank ? src.dimension_7() : SrcTraits::value_type::size() )
-            ) );
-      }
-
-      dst.m_impl_handle = src.m_impl_handle ;
+  static void assign(DstType &dst, const SrcType &src,
+                     const TrackType &src_track) {
+    static_assert(is_assignable, "Can only convert to array_type");
+
+    typedef typename DstType::offset_type dst_offset_type;
+
+    // Array dimension becomes the last dimension.
+    // Arguments beyond the destination rank are ignored.
+    if (src.span_is_contiguous()) {  // not padded
+      dst.m_impl_offset = dst_offset_type(
+          std::integral_constant<unsigned, 0>(),
+          typename DstTraits::array_layout(
+              (0 < SrcType::Rank ? src.dimension_0()
+                                 : SrcTraits::value_type::size()),
+              (1 < SrcType::Rank ? src.dimension_1()
+                                 : SrcTraits::value_type::size()),
+              (2 < SrcType::Rank ? src.dimension_2()
+                                 : SrcTraits::value_type::size()),
+              (3 < SrcType::Rank ? src.dimension_3()
+                                 : SrcTraits::value_type::size()),
+              (4 < SrcType::Rank ? src.dimension_4()
+                                 : SrcTraits::value_type::size()),
+              (5 < SrcType::Rank ? src.dimension_5()
+                                 : SrcTraits::value_type::size()),
+              (6 < SrcType::Rank ? src.dimension_6()
+                                 : SrcTraits::value_type::size()),
+              (7 < SrcType::Rank ? src.dimension_7()
+                                 : SrcTraits::value_type::size())));
+    } else {  // is padded
+      typedef std::integral_constant<
+          unsigned, sizeof(typename SrcTraits::value_type::value_type)>
+          padded;
+
+      dst.m_impl_offset = dst_offset_type(
+          padded(), typename DstTraits::array_layout(
+                        (0 < SrcType::Rank ? src.dimension_0()
+                                           : SrcTraits::value_type::size()),
+                        (1 < SrcType::Rank ? src.dimension_1()
+                                           : SrcTraits::value_type::size()),
+                        (2 < SrcType::Rank ? src.dimension_2()
+                                           : SrcTraits::value_type::size()),
+                        (3 < SrcType::Rank ? src.dimension_3()
+                                           : SrcTraits::value_type::size()),
+                        (4 < SrcType::Rank ? src.dimension_4()
+                                           : SrcTraits::value_type::size()),
+                        (5 < SrcType::Rank ? src.dimension_5()
+                                           : SrcTraits::value_type::size()),
+                        (6 < SrcType::Rank ? src.dimension_6()
+                                           : SrcTraits::value_type::size()),
+                        (7 < SrcType::Rank ? src.dimension_7()
+                                           : SrcTraits::value_type::size())));
     }
-};
 
+    dst.m_impl_handle = src.m_impl_handle;
+  }
+};
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template< class SrcTraits , class ... Args >
-struct ViewMapping
-  < typename std::enable_if<(
-      std::is_same< typename SrcTraits::specialize , Kokkos::Array<> >::value
-      &&
-      (
-        std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value ||
-        std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value ||
-        std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutStride >::value
-      )
-    )>::type
-  , SrcTraits
-  , Args ... >
-{
-private:
-
-  static_assert( SrcTraits::rank == sizeof...(Args) , "" );
-
-  enum : bool
-    { R0 = is_integral_extent<0,Args...>::value
-    , R1 = is_integral_extent<1,Args...>::value
-    , R2 = is_integral_extent<2,Args...>::value
-    , R3 = is_integral_extent<3,Args...>::value
-    , R4 = is_integral_extent<4,Args...>::value
-    , R5 = is_integral_extent<5,Args...>::value
-    , R6 = is_integral_extent<6,Args...>::value
-    , R7 = is_integral_extent<7,Args...>::value
-    };
-
-  enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
-              + unsigned(R4) + unsigned(R5) + unsigned(R6) + unsigned(R7) };
+template <class SrcTraits, class... Args>
+struct ViewMapping<
+    typename std::enable_if<(
+        std::is_same<typename SrcTraits::specialize, Kokkos::Array<> >::value &&
+        (std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutLeft>::value ||
+         std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutRight>::value ||
+         std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutStride>::value))>::type,
+    SrcTraits, Args...> {
+ private:
+  static_assert(SrcTraits::rank == sizeof...(Args), "");
+
+  enum : bool {
+    R0 = is_integral_extent<0, Args...>::value,
+    R1 = is_integral_extent<1, Args...>::value,
+    R2 = is_integral_extent<2, Args...>::value,
+    R3 = is_integral_extent<3, Args...>::value,
+    R4 = is_integral_extent<4, Args...>::value,
+    R5 = is_integral_extent<5, Args...>::value,
+    R6 = is_integral_extent<6, Args...>::value,
+    R7 = is_integral_extent<7, Args...>::value
+  };
+
+  enum {
+    rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3) +
+           unsigned(R4) + unsigned(R5) + unsigned(R6) + unsigned(R7)
+  };
 
   // Whether right-most rank is a range.
-  enum { R0_rev = 0 == SrcTraits::rank ? false : (
-                  1 == SrcTraits::rank ? R0 : (
-                  2 == SrcTraits::rank ? R1 : (
-                  3 == SrcTraits::rank ? R2 : (
-                  4 == SrcTraits::rank ? R3 : (
-                  5 == SrcTraits::rank ? R4 : (
-                  6 == SrcTraits::rank ? R5 : (
-                  7 == SrcTraits::rank ? R6 : R7 ))))))) };
+  enum {
+    R0_rev =
+        0 == SrcTraits::rank
+            ? false
+            : (1 == SrcTraits::rank
+                   ? R0
+                   : (2 == SrcTraits::rank
+                          ? R1
+                          : (3 == SrcTraits::rank
+                                 ? R2
+                                 : (4 == SrcTraits::rank
+                                        ? R3
+                                        : (5 == SrcTraits::rank
+                                               ? R4
+                                               : (6 == SrcTraits::rank
+                                                      ? R5
+                                                      : (7 == SrcTraits::rank
+                                                             ? R6
+                                                             : R7)))))))
+  };
 
   // Subview's layout
   typedef typename std::conditional<
-      ( /* Same array layout IF */
-        ( rank == 0 ) /* output rank zero */
-        ||
-        // OutputRank 1 or 2, InputLayout Left, Interval 0
-        // because single stride one or second index has a stride.
-        ( rank <= 2 && R0 && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value )
-        ||
-        // OutputRank 1 or 2, InputLayout Right, Interval [InputRank-1]
-        // because single stride one or second index has a stride.
-        ( rank <= 2 && R0_rev && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value )
-      ), typename SrcTraits::array_layout , Kokkos::LayoutStride
-      >::type array_layout ;
-
-  typedef typename SrcTraits::value_type  value_type ;
-
-  typedef typename std::conditional< rank == 0 , value_type ,
-          typename std::conditional< rank == 1 , value_type * ,
-          typename std::conditional< rank == 2 , value_type ** ,
-          typename std::conditional< rank == 3 , value_type *** ,
-          typename std::conditional< rank == 4 , value_type **** ,
-          typename std::conditional< rank == 5 , value_type ***** ,
-          typename std::conditional< rank == 6 , value_type ****** ,
-          typename std::conditional< rank == 7 , value_type ******* ,
-                                                 value_type ********
-          >::type >::type >::type >::type >::type >::type >::type >::type
-     data_type ;
-
-public:
-
-  typedef Kokkos::ViewTraits
-    < data_type
-    , array_layout
-    , typename SrcTraits::device_type
-    , typename SrcTraits::memory_traits > traits_type ;
-
-  typedef Kokkos::View
-    < data_type
-    , array_layout
-    , typename SrcTraits::device_type
-    , typename SrcTraits::memory_traits > type ;
+      (            /* Same array layout IF */
+       (rank == 0) /* output rank zero */
+       ||
+       // OutputRank 1 or 2, InputLayout Left, Interval 0
+       // because single stride one or second index has a stride.
+       (rank <= 2 && R0 &&
+        std::is_same<typename SrcTraits::array_layout,
+                     Kokkos::LayoutLeft>::value) ||
+       // OutputRank 1 or 2, InputLayout Right, Interval [InputRank-1]
+       // because single stride one or second index has a stride.
+       (rank <= 2 && R0_rev &&
+        std::is_same<typename SrcTraits::array_layout,
+                     Kokkos::LayoutRight>::value)),
+      typename SrcTraits::array_layout, Kokkos::LayoutStride>::type
+      array_layout;
+
+  typedef typename SrcTraits::value_type value_type;
+
+  typedef typename std::conditional<
+      rank == 0, value_type,
+      typename std::conditional<
+          rank == 1, value_type *,
+          typename std::conditional<
+              rank == 2, value_type **,
+              typename std::conditional<
+                  rank == 3, value_type ***,
+                  typename std::conditional<
+                      rank == 4, value_type ****,
+                      typename std::conditional<
+                          rank == 5, value_type *****,
+                          typename std::conditional<
+                              rank == 6, value_type ******,
+                              typename std::conditional<
+                                  rank == 7, value_type *******,
+                                  value_type ********>::type>::type>::type>::
+                      type>::type>::type>::type>::type data_type;
+
+ public:
+  typedef Kokkos::ViewTraits<data_type, array_layout,
+                             typename SrcTraits::device_type,
+                             typename SrcTraits::memory_traits>
+      traits_type;
+
+  typedef Kokkos::View<data_type, array_layout, typename SrcTraits::device_type,
+                       typename SrcTraits::memory_traits>
+      type;
 
   KOKKOS_INLINE_FUNCTION
-  static void assign( ViewMapping< traits_type , void > & dst
-                    , ViewMapping< SrcTraits , void > const & src
-                    , Args ... args )
-    {
-      typedef ViewMapping< traits_type , void >  DstType ;
-
-      typedef typename DstType::offset_type  dst_offset_type ;
-      typedef typename DstType::handle_type  dst_handle_type ;
-
-      const SubviewExtents< SrcTraits::rank , rank >
-        extents( src.m_impl_offset.m_dim , args... );
-
-      dst.m_impl_offset = dst_offset_type( src.m_impl_offset , extents );
-      dst.m_impl_handle = dst_handle_type( src.m_impl_handle +
-                                      src.m_impl_offset( extents.domain_offset(0)
-                                                  , extents.domain_offset(1)
-                                                  , extents.domain_offset(2)
-                                                  , extents.domain_offset(3)
-                                                  , extents.domain_offset(4)
-                                                  , extents.domain_offset(5)
-                                                  , extents.domain_offset(6)
-                                                  , extents.domain_offset(7)
-                                                  ) );
-    }
+  static void assign(ViewMapping<traits_type, void> &dst,
+                     ViewMapping<SrcTraits, void> const &src, Args... args) {
+    typedef ViewMapping<traits_type, void> DstType;
+
+    typedef typename DstType::offset_type dst_offset_type;
+    typedef typename DstType::handle_type dst_handle_type;
+
+    const SubviewExtents<SrcTraits::rank, rank> extents(src.m_impl_offset.m_dim,
+                                                        args...);
+
+    dst.m_impl_offset = dst_offset_type(src.m_impl_offset, extents);
+    dst.m_impl_handle = dst_handle_type(
+        src.m_impl_handle +
+        src.m_impl_offset(extents.domain_offset(0), extents.domain_offset(1),
+                          extents.domain_offset(2), extents.domain_offset(3),
+                          extents.domain_offset(4), extents.domain_offset(5),
+                          extents.domain_offset(6), extents.domain_offset(7)));
+  }
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_EXPERIMENTAL_VIEW_ARRAY_MAPPING_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewCtor.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewCtor.hpp
index f5b19f915fd81f26913884b158ca6be647520bf4..33c6e73f0564199c66c20099ddb24d9bfcbc3442 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewCtor.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewCtor.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -52,16 +53,15 @@ namespace Kokkos {
 /* For backward compatibility */
 
 struct ViewAllocateWithoutInitializing {
-
-  const std::string label ;
+  const std::string label;
 
   ViewAllocateWithoutInitializing() : label() {}
 
-  explicit
-  ViewAllocateWithoutInitializing( const std::string & arg_label ) : label( arg_label ) {}
+  explicit ViewAllocateWithoutInitializing(const std::string &arg_label)
+      : label(arg_label) {}
 
-  explicit
-  ViewAllocateWithoutInitializing( const char * const  arg_label ) : label( arg_label ) {}
+  explicit ViewAllocateWithoutInitializing(const char *const arg_label)
+      : label(arg_label) {}
 };
 
 } /* namespace Kokkos */
@@ -79,189 +79,166 @@ struct NullSpace_t {};
 //----------------------------------------------------------------------------
 /**\brief Whether a type can be used for a view label */
 
-template < typename >
+template <typename>
 struct is_view_label : public std::false_type {};
 
-template<>
-struct is_view_label< std::string > : public std::true_type {};
+template <>
+struct is_view_label<std::string> : public std::true_type {};
 
-template< unsigned N >
-struct is_view_label< char[N] > : public std::true_type {};
+template <unsigned N>
+struct is_view_label<char[N]> : public std::true_type {};
 
-template< unsigned N >
-struct is_view_label< const char[N] > : public std::true_type {};
+template <unsigned N>
+struct is_view_label<const char[N]> : public std::true_type {};
 
 //----------------------------------------------------------------------------
 
-template< typename ... P >
-struct ViewCtorProp ;
+template <typename... P>
+struct ViewCtorProp;
 
 // Forward declare
-template< typename Specialize , typename T >
-struct CommonViewAllocProp ;
+template <typename Specialize, typename T>
+struct CommonViewAllocProp;
 
 /* Common value_type stored as ViewCtorProp
  */
-template< typename Specialize , typename T >
-struct ViewCtorProp< void , CommonViewAllocProp<Specialize,T> >
-{
-  ViewCtorProp() = default ;
-  ViewCtorProp( const ViewCtorProp & ) = default ;
-  ViewCtorProp & operator = ( const ViewCtorProp & ) = default ;
+template <typename Specialize, typename T>
+struct ViewCtorProp<void, CommonViewAllocProp<Specialize, T> > {
+  ViewCtorProp()                     = default;
+  ViewCtorProp(const ViewCtorProp &) = default;
+  ViewCtorProp &operator=(const ViewCtorProp &) = default;
 
-  using type = CommonViewAllocProp<Specialize,T> ;
+  using type = CommonViewAllocProp<Specialize, T>;
 
   KOKKOS_INLINE_FUNCTION
-  ViewCtorProp( const type & arg ) : value( arg ) {}
+  ViewCtorProp(const type &arg) : value(arg) {}
   KOKKOS_INLINE_FUNCTION
-  ViewCtorProp( type && arg ) : value( arg ) {}
+  ViewCtorProp(type &&arg) : value(arg) {}
 
-  type value ;
+  type value;
 };
 
 /*  std::integral_constant<unsigned,I> are dummy arguments
  *  that avoid duplicate base class errors
  */
-template< unsigned I >
-struct ViewCtorProp< void , std::integral_constant<unsigned,I> >
-{
-  ViewCtorProp() = default ;
-  ViewCtorProp( const ViewCtorProp & ) = default ;
-  ViewCtorProp & operator = ( const ViewCtorProp & ) = default ;
-
-  template< typename P >
-  KOKKOS_INLINE_FUNCTION
-  ViewCtorProp( const P & ) {}
+template <unsigned I>
+struct ViewCtorProp<void, std::integral_constant<unsigned, I> > {
+  ViewCtorProp()                     = default;
+  ViewCtorProp(const ViewCtorProp &) = default;
+  ViewCtorProp &operator=(const ViewCtorProp &) = default;
+
+  template <typename P>
+  KOKKOS_INLINE_FUNCTION ViewCtorProp(const P &) {}
 };
 
 /* Property flags have constexpr value */
-template< typename P >
-struct ViewCtorProp
-  < typename std::enable_if<
-      std::is_same< P , AllowPadding_t >::value ||
-      std::is_same< P , WithoutInitializing_t >::value
-    >::type
-  , P
-  >
-{
-  ViewCtorProp() = default ;
-  ViewCtorProp( const ViewCtorProp & ) = default ;
-  ViewCtorProp & operator = ( const ViewCtorProp & ) = default ;
-
-  typedef P type ;
-
-  ViewCtorProp( const type & ) {}
+template <typename P>
+struct ViewCtorProp<typename std::enable_if<
+                        std::is_same<P, AllowPadding_t>::value ||
+                        std::is_same<P, WithoutInitializing_t>::value>::type,
+                    P> {
+  ViewCtorProp()                     = default;
+  ViewCtorProp(const ViewCtorProp &) = default;
+  ViewCtorProp &operator=(const ViewCtorProp &) = default;
+
+  typedef P type;
+
+  ViewCtorProp(const type &) {}
 
   static constexpr type value = type();
 };
 
 /* Map input label type to std::string */
-template< typename Label >
-struct ViewCtorProp
-  < typename std::enable_if< is_view_label< Label >::value >::type
-  , Label
-  >
-{
-  ViewCtorProp() = default ;
-  ViewCtorProp( const ViewCtorProp & ) = default ;
-  ViewCtorProp & operator = ( const ViewCtorProp & ) = default ;
-
-  typedef std::string type ;
-
-  ViewCtorProp( const type & arg ) : value( arg ) {}
-  ViewCtorProp( type && arg ) : value( arg ) {}
-
-  type value ;
-};
+template <typename Label>
+struct ViewCtorProp<typename std::enable_if<is_view_label<Label>::value>::type,
+                    Label> {
+  ViewCtorProp()                     = default;
+  ViewCtorProp(const ViewCtorProp &) = default;
+  ViewCtorProp &operator=(const ViewCtorProp &) = default;
 
-template< typename Space >
-struct ViewCtorProp
-  < typename std::enable_if<
-      Kokkos::Impl::is_memory_space<Space>::value ||
-      Kokkos::Impl::is_execution_space<Space>::value
-    >::type
-  , Space
-  >
-{
-  ViewCtorProp() = default ;
-  ViewCtorProp( const ViewCtorProp & ) = default ;
-  ViewCtorProp & operator = ( const ViewCtorProp & ) = default ;
+  typedef std::string type;
 
-  typedef Space type ;
+  ViewCtorProp(const type &arg) : value(arg) {}
+  ViewCtorProp(type &&arg) : value(arg) {}
 
-  ViewCtorProp( const type & arg ) : value( arg ) {}
-
-  type value ;
+  type value;
 };
 
+template <typename Space>
+struct ViewCtorProp<typename std::enable_if<
+                        Kokkos::Impl::is_memory_space<Space>::value ||
+                        Kokkos::Impl::is_execution_space<Space>::value>::type,
+                    Space> {
+  ViewCtorProp()                     = default;
+  ViewCtorProp(const ViewCtorProp &) = default;
+  ViewCtorProp &operator=(const ViewCtorProp &) = default;
 
-template< typename T >
-struct ViewCtorProp < void , T * >
-{
-  ViewCtorProp() = default ;
-  ViewCtorProp( const ViewCtorProp & ) = default ;
-  ViewCtorProp & operator = ( const ViewCtorProp & ) = default ;
-
-  typedef T * type ;
+  typedef Space type;
 
-  KOKKOS_INLINE_FUNCTION
-  ViewCtorProp( const type arg ) : value( arg ) {}
+  ViewCtorProp(const type &arg) : value(arg) {}
 
-  type value ;
+  type value;
 };
 
+template <typename T>
+struct ViewCtorProp<void, T *> {
+  ViewCtorProp()                     = default;
+  ViewCtorProp(const ViewCtorProp &) = default;
+  ViewCtorProp &operator=(const ViewCtorProp &) = default;
+
+  typedef T *type;
 
-template< typename ... P >
-struct ViewCtorProp : public ViewCtorProp< void , P > ...
-{
-private:
+  KOKKOS_INLINE_FUNCTION
+  ViewCtorProp(const type arg) : value(arg) {}
 
-  typedef Kokkos::Impl::has_condition< void , Kokkos::Impl::is_memory_space , P ... >
-    var_memory_space ;
+  type value;
+};
 
-  typedef Kokkos::Impl::has_condition< void , Kokkos::Impl::is_execution_space , P ... >
-    var_execution_space ;
+template <typename... P>
+struct ViewCtorProp : public ViewCtorProp<void, P>... {
+ private:
+  typedef Kokkos::Impl::has_condition<void, Kokkos::Impl::is_memory_space, P...>
+      var_memory_space;
 
-  struct VOIDDUMMY{};
+  typedef Kokkos::Impl::has_condition<void, Kokkos::Impl::is_execution_space,
+                                      P...>
+      var_execution_space;
 
-  typedef Kokkos::Impl::has_condition< VOIDDUMMY , std::is_pointer , P ... >
-    var_pointer ;
+  struct VOIDDUMMY {};
 
-public:
+  typedef Kokkos::Impl::has_condition<VOIDDUMMY, std::is_pointer, P...>
+      var_pointer;
 
+ public:
   /* Flags for the common properties */
-  enum { has_memory_space    = var_memory_space::value };
+  enum { has_memory_space = var_memory_space::value };
   enum { has_execution_space = var_execution_space::value };
-  enum { has_pointer         = var_pointer::value };
-  enum { has_label           = Kokkos::Impl::has_type< std::string , P... >::value };
-  enum { allow_padding       = Kokkos::Impl::has_type< AllowPadding_t , P... >::value };
-  enum { initialize          = ! Kokkos::Impl::has_type< WithoutInitializing_t , P ... >::value };
+  enum { has_pointer = var_pointer::value };
+  enum { has_label = Kokkos::Impl::has_type<std::string, P...>::value };
+  enum { allow_padding = Kokkos::Impl::has_type<AllowPadding_t, P...>::value };
+  enum {
+    initialize = !Kokkos::Impl::has_type<WithoutInitializing_t, P...>::value
+  };
 
-  typedef typename var_memory_space::type     memory_space ;
-  typedef typename var_execution_space::type  execution_space ;
-  typedef typename var_pointer::type          pointer_type ;
+  typedef typename var_memory_space::type memory_space;
+  typedef typename var_execution_space::type execution_space;
+  typedef typename var_pointer::type pointer_type;
 
   /*  Copy from a matching argument list.
    *  Requires  std::is_same< P , ViewCtorProp< void , Args >::value ...
    */
-  template< typename ... Args >
-  inline
-  ViewCtorProp( Args const & ... args )
-    : ViewCtorProp< void , P >( args ) ...
-    {}
+  template <typename... Args>
+  inline ViewCtorProp(Args const &... args) : ViewCtorProp<void, P>(args)... {}
 
-  template< typename ... Args >
-  KOKKOS_INLINE_FUNCTION
-  ViewCtorProp( pointer_type arg0 , Args const & ... args )
-    : ViewCtorProp< void , pointer_type >( arg0 )
-    , ViewCtorProp< void , typename ViewCtorProp< void , Args >::type >( args ) ...
-    {}
+  template <typename... Args>
+  KOKKOS_INLINE_FUNCTION ViewCtorProp(pointer_type arg0, Args const &... args)
+      : ViewCtorProp<void, pointer_type>(arg0),
+        ViewCtorProp<void, typename ViewCtorProp<void, Args>::type>(args)... {}
 
   /* Copy from a matching property subset */
-  template< typename ... Args >
-  ViewCtorProp( ViewCtorProp< Args ... > const & arg )
-    : ViewCtorProp< void , Args >( ((ViewCtorProp<void,Args> const &) arg ) ) ...
-    {}
+  template <typename... Args>
+  ViewCtorProp(ViewCtorProp<Args...> const &arg)
+      : ViewCtorProp<void, Args>(((ViewCtorProp<void, Args> const &)arg))... {}
 };
 
 } /* namespace Impl */
@@ -271,4 +248,3 @@ public:
 //----------------------------------------------------------------------------
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIAvail.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIAvail.hpp
index 3a5c31ab5027e73b172302dea44f0b168b601e86..b415cb6d5034f71c59389dc2e689ac01553ea664 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIAvail.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIAvail.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,59 +48,78 @@
 namespace Kokkos {
 namespace Impl {
 
-template<class ViewTypeA,class ViewTypeB, class Layout, class ExecSpace, int Rank, typename iType>
+template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
+          int Rank, typename iType>
 struct ViewCopyETIAvail {
-  enum {value=false};
+  enum { value = false };
 };
 
-#define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(DATATYPE,LAYOUTA,LAYOUTB,EXECSPACE,ITYPE) \
-  template<> \
-  struct ViewCopyETIAvail<Kokkos::View<DATATYPE,LAYOUTA,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                          Kokkos::View<const DATATYPE,LAYOUTB,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                          Kokkos::LayoutLeft,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE> { \
-    enum {value=true}; \
-  }; \
-  template<> \
-  struct ViewCopyETIAvail<Kokkos::View<DATATYPE,LAYOUTA,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                          Kokkos::View<const DATATYPE,LAYOUTB,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                          Kokkos::LayoutRight,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE> { \
-    enum {value=true}; \
+#define KOKKOS_IMPL_VIEWCOPY_ETI_AVAIL(DATATYPE, LAYOUTA, LAYOUTB, EXECSPACE, \
+                                       ITYPE)                                 \
+  template <>                                                                 \
+  struct ViewCopyETIAvail<                                                    \
+      Kokkos::View<DATATYPE, LAYOUTA,                                         \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,         \
+                   Kokkos::MemoryTraits<0>>,                                  \
+      Kokkos::View<const DATATYPE, LAYOUTB,                                   \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,         \
+                   Kokkos::MemoryTraits<0>>,                                  \
+      Kokkos::LayoutLeft, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE> {   \
+    enum { value = true };                                                    \
+  };                                                                          \
+  template <>                                                                 \
+  struct ViewCopyETIAvail<                                                    \
+      Kokkos::View<DATATYPE, LAYOUTA,                                         \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,         \
+                   Kokkos::MemoryTraits<0>>,                                  \
+      Kokkos::View<const DATATYPE, LAYOUTB,                                   \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,         \
+                   Kokkos::MemoryTraits<0>>,                                  \
+      Kokkos::LayoutRight, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE> {  \
+    enum { value = true };                                                    \
   };
 
-template<class ViewType, class Layout, class ExecSpace, int Rank, typename iType>
+template <class ViewType, class Layout, class ExecSpace, int Rank,
+          typename iType>
 struct ViewFillETIAvail {
-  enum {value=false};
+  enum { value = false };
 };
 
-#define KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(DATATYPE,LAYOUT,EXECSPACE,ITYPE) \
-  template<> \
-  struct ViewFillETIAvail<Kokkos::View<DATATYPE,LAYOUT,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                          Kokkos::LayoutLeft,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE> { \
-    enum {value=true}; \
-  }; \
-  template<> \
-  struct ViewFillETIAvail<Kokkos::View<DATATYPE,LAYOUT,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                          Kokkos::LayoutRight,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE> { \
-    enum {value=true}; \
+#define KOKKOS_IMPL_VIEWFILL_ETI_AVAIL(DATATYPE, LAYOUT, EXECSPACE, ITYPE)   \
+  template <>                                                                \
+  struct ViewFillETIAvail<                                                   \
+      Kokkos::View<DATATYPE, LAYOUT,                                         \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::LayoutLeft, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE> {  \
+    enum { value = true };                                                   \
+  };                                                                         \
+  template <>                                                                \
+  struct ViewFillETIAvail<                                                   \
+      Kokkos::View<DATATYPE, LAYOUT,                                         \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::LayoutRight, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE> { \
+    enum { value = true };                                                   \
   };
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #ifdef KOKKOS_ENABLE_ETI
 #ifdef KOKKOS_ENABLE_Serial
-#include<Serial/Kokkos_Serial_ViewCopyETIAvail.hpp>
+#include <Serial/Kokkos_Serial_ViewCopyETIAvail.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_OPENMP
-#include<OpenMP/Kokkos_OpenMP_ViewCopyETIAvail.hpp>
+#include <OpenMP/Kokkos_OpenMP_ViewCopyETIAvail.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_THREADS
-#include<Threads/Kokkos_Threads_ViewCopyETIAvail.hpp>
+#include <Threads/Kokkos_Threads_ViewCopyETIAvail.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_CUDA
-#include<Cuda/Kokkos_Cuda_ViewCopyETIAvail.hpp>
+#include <Cuda/Kokkos_Cuda_ViewCopyETIAvail.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_ROCM
-#include<ROCm/Kokkos_ROCm_ViewCopyETIAvail.hpp>
+#include <ROCm/Kokkos_ROCm_ViewCopyETIAvail.hpp>
 #endif
 #endif
 
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIDecl.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIDecl.hpp
index c2905d911985ccef79648a47673355760400ae39..e23dabd8406f3726b024718bfb229744a211e436 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIDecl.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewFillCopyETIDecl.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,51 +48,93 @@
 namespace Kokkos {
 namespace Impl {
 
-#define KOKKOS_IMPL_VIEWCOPY_ETI_DECL(DATATYPE,LAYOUTA,LAYOUTB,EXECSPACE,ITYPE) \
-  extern template struct ViewCopy<Kokkos::View<DATATYPE,LAYOUTA,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::View<const DATATYPE,LAYOUTB,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::LayoutLeft,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>; \
-  extern template struct ViewCopy<Kokkos::View<DATATYPE,LAYOUTA,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::View<const DATATYPE,LAYOUTB,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::LayoutRight,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>;
+#define KOKKOS_IMPL_VIEWCOPY_ETI_DECL(DATATYPE, LAYOUTA, LAYOUTB, EXECSPACE, \
+                                      ITYPE)                                 \
+  extern template struct ViewCopy<                                           \
+      Kokkos::View<DATATYPE, LAYOUTA,                                        \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::View<const DATATYPE, LAYOUTB,                                  \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::LayoutLeft, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE,    \
+      true>;                                                                 \
+  extern template struct ViewCopy<                                           \
+      Kokkos::View<DATATYPE, LAYOUTA,                                        \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::View<const DATATYPE, LAYOUTB,                                  \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::LayoutRight, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE,   \
+      true>;
 
-#define KOKKOS_IMPL_VIEWFILL_ETI_DECL(DATATYPE,LAYOUT,EXECSPACE,ITYPE) \
-  extern template struct ViewFill<Kokkos::View<DATATYPE,LAYOUT,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                                  Kokkos::LayoutLeft,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>; \
-  extern template struct ViewFill<Kokkos::View<DATATYPE,LAYOUT,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                                  Kokkos::LayoutRight,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>;
+#define KOKKOS_IMPL_VIEWFILL_ETI_DECL(DATATYPE, LAYOUT, EXECSPACE, ITYPE)  \
+  extern template struct ViewFill<                                         \
+      Kokkos::View<DATATYPE, LAYOUT,                                       \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,      \
+                   Kokkos::MemoryTraits<0>>,                               \
+      Kokkos::LayoutLeft, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE,  \
+      true>;                                                               \
+  extern template struct ViewFill<                                         \
+      Kokkos::View<DATATYPE, LAYOUT,                                       \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,      \
+                   Kokkos::MemoryTraits<0>>,                               \
+      Kokkos::LayoutRight, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE, \
+      true>;
 
-#define KOKKOS_IMPL_VIEWCOPY_ETI_INST(DATATYPE,LAYOUTA,LAYOUTB,EXECSPACE,ITYPE) \
-  template struct ViewCopy<Kokkos::View<DATATYPE,LAYOUTA,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::View<const DATATYPE,LAYOUTB,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::LayoutLeft,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>; \
-  template struct ViewCopy<Kokkos::View<DATATYPE,LAYOUTA,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::View<const DATATYPE,LAYOUTB,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                  Kokkos::LayoutRight,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>;
+#define KOKKOS_IMPL_VIEWCOPY_ETI_INST(DATATYPE, LAYOUTA, LAYOUTB, EXECSPACE, \
+                                      ITYPE)                                 \
+  template struct ViewCopy<                                                  \
+      Kokkos::View<DATATYPE, LAYOUTA,                                        \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::View<const DATATYPE, LAYOUTB,                                  \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::LayoutLeft, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE,    \
+      true>;                                                                 \
+  template struct ViewCopy<                                                  \
+      Kokkos::View<DATATYPE, LAYOUTA,                                        \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::View<const DATATYPE, LAYOUTB,                                  \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,        \
+                   Kokkos::MemoryTraits<0>>,                                 \
+      Kokkos::LayoutRight, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE,   \
+      true>;
 
-#define KOKKOS_IMPL_VIEWFILL_ETI_INST(DATATYPE,LAYOUT,EXECSPACE,ITYPE) \
-  template struct ViewFill<Kokkos::View<DATATYPE,LAYOUT,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                                  Kokkos::LayoutLeft,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>; \
-  template struct ViewFill<Kokkos::View<DATATYPE,LAYOUT,Kokkos::Device<EXECSPACE,Kokkos::AnonymousSpace>,Kokkos::MemoryTraits<0>>, \
-                                  Kokkos::LayoutRight,EXECSPACE,Kokkos::View<DATATYPE>::rank,ITYPE,true>;
+#define KOKKOS_IMPL_VIEWFILL_ETI_INST(DATATYPE, LAYOUT, EXECSPACE, ITYPE)  \
+  template struct ViewFill<                                                \
+      Kokkos::View<DATATYPE, LAYOUT,                                       \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,      \
+                   Kokkos::MemoryTraits<0>>,                               \
+      Kokkos::LayoutLeft, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE,  \
+      true>;                                                               \
+  template struct ViewFill<                                                \
+      Kokkos::View<DATATYPE, LAYOUT,                                       \
+                   Kokkos::Device<EXECSPACE, Kokkos::AnonymousSpace>,      \
+                   Kokkos::MemoryTraits<0>>,                               \
+      Kokkos::LayoutRight, EXECSPACE, Kokkos::View<DATATYPE>::rank, ITYPE, \
+      true>;
 
-}
-}
+}  // namespace Impl
+}  // namespace Kokkos
 #ifdef KOKKOS_ENABLE_ETI
 #ifdef KOKKOS_ENABLE_Serial
-#include<Serial/Kokkos_Serial_ViewCopyETIDecl.hpp>
+#include <Serial/Kokkos_Serial_ViewCopyETIDecl.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_OPENMP
-#include<OpenMP/Kokkos_OpenMP_ViewCopyETIDecl.hpp>
+#include <OpenMP/Kokkos_OpenMP_ViewCopyETIDecl.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_THREADS
-#include<Threads/Kokkos_Threads_ViewCopyETIDecl.hpp>
+#include <Threads/Kokkos_Threads_ViewCopyETIDecl.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_CUDA
-#include<Cuda/Kokkos_Cuda_ViewCopyETIDecl.hpp>
+#include <Cuda/Kokkos_Cuda_ViewCopyETIDecl.hpp>
 #endif
 #ifdef KOKKOS_ENABLE_ROCM
-#include<ROCm/Kokkos_ROCm_ViewCopyETIDecl.hpp>
+#include <ROCm/Kokkos_ROCm_ViewCopyETIDecl.hpp>
 #endif
 #endif
 #endif
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewLayoutTiled.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewLayoutTiled.hpp
index a64101110ff0be63d93d4453b9acdf8b6eccb2f8..2071f931e39571239111aad65831c4b2fee8197d 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewLayoutTiled.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewLayoutTiled.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -56,53 +57,75 @@ namespace Kokkos {
 
 // View offset and mapping for tiled view's
 
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 >
-struct is_array_layout < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, 0, 0, 0, 0, 0, 0, true> > : public std::true_type {};
-
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 >
-struct is_array_layout < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, 0, 0, 0, 0, 0, true> > : public std::true_type {};
-
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 >
-struct is_array_layout < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, 0, 0, 0, 0, true> > : public std::true_type {};
-
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 >
-struct is_array_layout < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, 0, 0, 0, true> > : public std::true_type {};
-
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 >
-struct is_array_layout < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, 0, 0, true> > : public std::true_type {};
-
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 ,  unsigned ArgN6 >
-struct is_array_layout < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, 0, true> > : public std::true_type {};
-
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 ,  unsigned ArgN6 ,  unsigned ArgN7 > 
-struct is_array_layout < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, true> > : public std::true_type {};
-
-
-template< class L >
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1>
+struct is_array_layout<Kokkos::Experimental::LayoutTiled<
+    OuterP, InnerP, ArgN0, ArgN1, 0, 0, 0, 0, 0, 0, true> >
+    : public std::true_type {};
+
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1, unsigned ArgN2>
+struct is_array_layout<Kokkos::Experimental::LayoutTiled<
+    OuterP, InnerP, ArgN0, ArgN1, ArgN2, 0, 0, 0, 0, 0, true> >
+    : public std::true_type {};
+
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3>
+struct is_array_layout<Kokkos::Experimental::LayoutTiled<
+    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, 0, 0, 0, 0, true> >
+    : public std::true_type {};
+
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4>
+struct is_array_layout<Kokkos::Experimental::LayoutTiled<
+    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, 0, 0, 0, true> >
+    : public std::true_type {};
+
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
+          unsigned ArgN5>
+struct is_array_layout<Kokkos::Experimental::LayoutTiled<
+    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, 0, 0, true> >
+    : public std::true_type {};
+
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
+          unsigned ArgN5, unsigned ArgN6>
+struct is_array_layout<Kokkos::Experimental::LayoutTiled<
+    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, 0, true> >
+    : public std::true_type {};
+
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
+          unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
+struct is_array_layout<
+    Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2,
+                                      ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, true> >
+    : public std::true_type {};
+
+template <class L>
 struct is_array_layout_tiled : public std::false_type {};
 
-template < Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0 , unsigned ArgN1 , unsigned ArgN2 ,  unsigned ArgN3 ,  unsigned ArgN4 ,  unsigned ArgN5 ,  unsigned ArgN6 , unsigned ArgN7 , bool IsPowerTwo >
-struct is_array_layout_tiled < Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, IsPowerTwo> > : public std::true_type {}; // Last template parameter "true" meaning this currently only supports powers-of-two
-
+template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
+          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
+          unsigned ArgN5, unsigned ArgN6, unsigned ArgN7, bool IsPowerTwo>
+struct is_array_layout_tiled<Kokkos::Experimental::LayoutTiled<
+    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7,
+    IsPowerTwo> > : public std::true_type {
+};  // Last template parameter "true" meaning this currently only supports
+    // powers-of-two
 
 namespace Impl {
 
-template< class Dimension , class Layout >
-struct ViewOffset< Dimension , Layout ,
-  typename std::enable_if<(
-    ( Dimension::rank <= 8 )
-    &&
-    ( Dimension::rank >= 2 )
-    &&
-    is_array_layout< Layout >::value
-    &&
-    is_array_layout_tiled< Layout >::value
-  )>::type >
-{
-public:
-
-//  enum { outer_pattern = Layout::outer_pattern };
-//  enum { inner_pattern = Layout::inner_pattern };
+template <class Dimension, class Layout>
+struct ViewOffset<
+    Dimension, Layout,
+    typename std::enable_if<((Dimension::rank <= 8) && (Dimension::rank >= 2) &&
+                             is_array_layout<Layout>::value &&
+                             is_array_layout_tiled<Layout>::value)>::type> {
+ public:
+  //  enum { outer_pattern = Layout::outer_pattern };
+  //  enum { inner_pattern = Layout::inner_pattern };
   static constexpr Kokkos::Iterate outer_pattern = Layout::outer_pattern;
   static constexpr Kokkos::Iterate inner_pattern = Layout::inner_pattern;
 
@@ -116,258 +139,484 @@ public:
   enum { SHIFT_5 = Kokkos::Impl::integral_power_of_two(Layout::N5) };
   enum { SHIFT_6 = Kokkos::Impl::integral_power_of_two(Layout::N6) };
   enum { SHIFT_7 = Kokkos::Impl::integral_power_of_two(Layout::N7) };
-  enum { MASK_0  = Layout::N0 - 1 };
-  enum { MASK_1  = Layout::N1 - 1 };
-  enum { MASK_2  = Layout::N2 - 1 };
-  enum { MASK_3  = Layout::N3 - 1 };
-  enum { MASK_4  = Layout::N4 - 1 };
-  enum { MASK_5  = Layout::N5 - 1 };
-  enum { MASK_6  = Layout::N6 - 1 };
-  enum { MASK_7  = Layout::N7 - 1 };
+  enum { MASK_0 = Layout::N0 - 1 };
+  enum { MASK_1 = Layout::N1 - 1 };
+  enum { MASK_2 = Layout::N2 - 1 };
+  enum { MASK_3 = Layout::N3 - 1 };
+  enum { MASK_4 = Layout::N4 - 1 };
+  enum { MASK_5 = Layout::N5 - 1 };
+  enum { MASK_6 = Layout::N6 - 1 };
+  enum { MASK_7 = Layout::N7 - 1 };
 
   enum { SHIFT_2T = SHIFT_0 + SHIFT_1 };
   enum { SHIFT_3T = SHIFT_0 + SHIFT_1 + SHIFT_2 };
   enum { SHIFT_4T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 };
   enum { SHIFT_5T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 };
   enum { SHIFT_6T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5 };
-  enum { SHIFT_7T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5 + SHIFT_6 };
-  enum { SHIFT_8T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5 + SHIFT_6 + SHIFT_7 };
+  enum {
+    SHIFT_7T =
+        SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5 + SHIFT_6
+  };
+  enum {
+    SHIFT_8T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5 +
+               SHIFT_6 + SHIFT_7
+  };
 
   // Is an irregular layout that does not have uniform striding for each index.
-  using is_mapping_plugin = std::true_type ;
-  using is_regular        = std::false_type ;
-
-  typedef size_t     size_type ;
-  typedef Dimension  dimension_type ;
-  typedef Layout     array_layout ;
-
-  dimension_type m_dim ;
-  size_type      m_tile_N0 ; // Num tiles dim 0
-  size_type      m_tile_N1 ;
-  size_type      m_tile_N2 ;
-  size_type      m_tile_N3 ;
-  size_type      m_tile_N4 ;
-  size_type      m_tile_N5 ;
-  size_type      m_tile_N6 ;
-  size_type      m_tile_N7 ;
+  using is_mapping_plugin = std::true_type;
+  using is_regular        = std::false_type;
+
+  typedef size_t size_type;
+  typedef Dimension dimension_type;
+  typedef Layout array_layout;
+
+  dimension_type m_dim;
+  size_type m_tile_N0;  // Num tiles dim 0
+  size_type m_tile_N1;
+  size_type m_tile_N2;
+  size_type m_tile_N3;
+  size_type m_tile_N4;
+  size_type m_tile_N5;
+  size_type m_tile_N6;
+  size_type m_tile_N7;
 
   //----------------------------------------
 
 #define DEBUG_OUTPUT_CHECK 0
 
   // Rank 2
-  template< typename I0 , typename I1 >
-  KOKKOS_INLINE_FUNCTION
-  size_type operator()( I0 const & i0 , I1 const & i1 ) const {
-    auto tile_offset = (outer_pattern == (Kokkos::Iterate::Left)) 
-                     ? ( ( (i0>>SHIFT_0) + m_tile_N0*((i1>>SHIFT_1)) ) << SHIFT_2T)
-                     : ( ( (m_tile_N1*(i0>>SHIFT_0) + (i1>>SHIFT_1)) ) << SHIFT_2T) ;
+  template <typename I0, typename I1>
+  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0,
+                                              I1 const& i1) const {
+    auto tile_offset =
+        (outer_pattern == (Kokkos::Iterate::Left))
+            ? (((i0 >> SHIFT_0) + m_tile_N0 * ((i1 >> SHIFT_1))) << SHIFT_2T)
+            : (((m_tile_N1 * (i0 >> SHIFT_0) + (i1 >> SHIFT_1))) << SHIFT_2T);
     //                     ( num_tiles[1] * ti0     +  ti1 ) * FTD
 
-    auto local_offset = (inner_pattern == (Kokkos::Iterate::Left)) 
-                      ? ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) )
-                      : ( ((i0 & MASK_0) << SHIFT_1) + (i1 & MASK_1) ) ;
+    auto local_offset = (inner_pattern == (Kokkos::Iterate::Left))
+                            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0))
+                            : (((i0 & MASK_0) << SHIFT_1) + (i1 & MASK_1));
     //                     ( tile_dim[1] * li0         +  li1 )
 
 #if DEBUG_OUTPUT_CHECK
-    std::cout << "Am I Outer Left? " << (outer_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "Am I Inner Left? " << (inner_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "i0 = " << i0
-      << " i1 = " << i1
-      << "\ntilei0 = " << (i0>>SHIFT_0)
-      << " tilei1 = " << (i1>>SHIFT_1)
-      << "locali0 = " << (i0 & MASK_0)
-      << "\nlocali1 = " << (i1 & MASK_1) 
-      << std::endl;
+    std::cout << "Am I Outer Left? "
+              << (outer_pattern == (Kokkos::Iterate::Left)) << std::endl;
+    std::cout << "Am I Inner Left? "
+              << (inner_pattern == (Kokkos::Iterate::Left)) << std::endl;
+    std::cout << "i0 = " << i0 << " i1 = " << i1
+              << "\ntilei0 = " << (i0 >> SHIFT_0)
+              << " tilei1 = " << (i1 >> SHIFT_1)
+              << "locali0 = " << (i0 & MASK_0)
+              << "\nlocali1 = " << (i1 & MASK_1) << std::endl;
 #endif
 
     return tile_offset + local_offset;
   }
 
   // Rank 3
-  template< typename I0 , typename I1 , typename I2 >
-  KOKKOS_INLINE_FUNCTION
-  size_type operator()( I0 const & i0 , I1 const & i1 , I2 const & i2 ) const {
-    auto tile_offset = (outer_pattern == Kokkos::Iterate::Left) 
-                     ? ( ( (i0>>SHIFT_0) + m_tile_N0*((i1>>SHIFT_1) + m_tile_N1*(i2>>SHIFT_2)) ) << SHIFT_3T)
-                     : ( ( m_tile_N2*(m_tile_N1*(i0>>SHIFT_0) + (i1>>SHIFT_1)) + (i2>>SHIFT_2) ) << SHIFT_3T) ;
-
-    auto local_offset = (inner_pattern == Kokkos::Iterate::Left) 
-                      ? ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) + ((i2 & MASK_2)<<(SHIFT_0+SHIFT_1)) )
-                      : ( ((i0 & MASK_0) << (SHIFT_2+SHIFT_1)) + ((i1 & MASK_1) << (SHIFT_2)) + (i2 & MASK_2) ) ;
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
+                                              I2 const& i2) const {
+    auto tile_offset =
+        (outer_pattern == Kokkos::Iterate::Left)
+            ? (((i0 >> SHIFT_0) +
+                m_tile_N0 * ((i1 >> SHIFT_1) + m_tile_N1 * (i2 >> SHIFT_2)))
+               << SHIFT_3T)
+            : ((m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) + (i1 >> SHIFT_1)) +
+                (i2 >> SHIFT_2))
+               << SHIFT_3T);
+
+    auto local_offset = (inner_pattern == Kokkos::Iterate::Left)
+                            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
+                               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)))
+                            : (((i0 & MASK_0) << (SHIFT_2 + SHIFT_1)) +
+                               ((i1 & MASK_1) << (SHIFT_2)) + (i2 & MASK_2));
 
 #if DEBUG_OUTPUT_CHECK
-    std::cout << "Am I Outer Left? " << (outer_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "Am I Inner Left? " << (inner_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "i0 = " << i0
-      << " i1 = " << i1
-      << " i2 = " << i2
-      << "\ntilei0 = " << (i0>>SHIFT_0)
-      << " tilei1 = " << (i1>>SHIFT_1)
-      << " tilei2 = " << (i2>>SHIFT_2)
-      << "\nlocali0 = " << (i0 & MASK_0)
-      << "locali1 = " << (i1 & MASK_1)
-      << "locali2 = " << (i2 & MASK_2)
-      << std::endl;
+    std::cout << "Am I Outer Left? "
+              << (outer_pattern == (Kokkos::Iterate::Left)) << std::endl;
+    std::cout << "Am I Inner Left? "
+              << (inner_pattern == (Kokkos::Iterate::Left)) << std::endl;
+    std::cout << "i0 = " << i0 << " i1 = " << i1 << " i2 = " << i2
+              << "\ntilei0 = " << (i0 >> SHIFT_0)
+              << " tilei1 = " << (i1 >> SHIFT_1)
+              << " tilei2 = " << (i2 >> SHIFT_2)
+              << "\nlocali0 = " << (i0 & MASK_0)
+              << "locali1 = " << (i1 & MASK_1) << "locali2 = " << (i2 & MASK_2)
+              << std::endl;
 #endif
 
     return tile_offset + local_offset;
   }
 
   // Rank 4
-  template< typename I0 , typename I1 , typename I2 , typename I3 >
-  KOKKOS_INLINE_FUNCTION
-  size_type operator()( I0 const & i0 , I1 const & i1 , I2 const & i2 , I3 const & i3 ) const {
-    auto tile_offset = (outer_pattern == Kokkos::Iterate::Left) 
-                     ? ( ( (i0>>SHIFT_0) + m_tile_N0*((i1>>SHIFT_1) + m_tile_N1*((i2>>SHIFT_2) + m_tile_N2*(i3>>SHIFT_3))) ) << SHIFT_4T)
-                     : ( ( m_tile_N3*(m_tile_N2*(m_tile_N1*(i0>>SHIFT_0) + (i1>>SHIFT_1)) + (i2>>SHIFT_2)) + (i3>>SHIFT_3) ) << SHIFT_4T) ;
-
-    auto local_offset = (inner_pattern == Kokkos::Iterate::Left) 
-                      ? ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) + ((i2 & MASK_2)<<(SHIFT_0+SHIFT_1)) + ((i3 & MASK_3)<<(SHIFT_0+SHIFT_1+SHIFT_2)) )
-                      : ( ((i0 & MASK_0) << (SHIFT_3+SHIFT_2+SHIFT_1)) + ((i1 & MASK_1) << (SHIFT_3+SHIFT_2)) + ((i2 & MASK_2)<<(SHIFT_3)) + (i3 & MASK_3) ) ;
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
+                                              I2 const& i2,
+                                              I3 const& i3) const {
+    auto tile_offset =
+        (outer_pattern == Kokkos::Iterate::Left)
+            ? (((i0 >> SHIFT_0) +
+                m_tile_N0 * ((i1 >> SHIFT_1) +
+                             m_tile_N1 * ((i2 >> SHIFT_2) +
+                                          m_tile_N2 * (i3 >> SHIFT_3))))
+               << SHIFT_4T)
+            : ((m_tile_N3 * (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
+                                          (i1 >> SHIFT_1)) +
+                             (i2 >> SHIFT_2)) +
+                (i3 >> SHIFT_3))
+               << SHIFT_4T);
+
+    auto local_offset =
+        (inner_pattern == Kokkos::Iterate::Left)
+            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
+               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
+               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)))
+            : (((i0 & MASK_0) << (SHIFT_3 + SHIFT_2 + SHIFT_1)) +
+               ((i1 & MASK_1) << (SHIFT_3 + SHIFT_2)) +
+               ((i2 & MASK_2) << (SHIFT_3)) + (i3 & MASK_3));
 
     return tile_offset + local_offset;
   }
 
   // Rank 5
-  template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 >
-  KOKKOS_INLINE_FUNCTION
-  size_type operator()( I0 const & i0 , I1 const & i1 , I2 const & i2 , I3 const & i3 , I4 const & i4 ) const {
-    auto tile_offset = (outer_pattern == Kokkos::Iterate::Left) 
-                     ? ( ( (i0>>SHIFT_0) + m_tile_N0*((i1>>SHIFT_1) + m_tile_N1*((i2>>SHIFT_2) + m_tile_N2*((i3>>SHIFT_3) + m_tile_N3*(i4>>SHIFT_4)))) ) << SHIFT_5T)
-                     : ( ( m_tile_N4*(m_tile_N3*(m_tile_N2*(m_tile_N1*(i0>>SHIFT_0) + (i1>>SHIFT_1)) + (i2>>SHIFT_2)) + (i3>>SHIFT_3)) + (i4>>SHIFT_4) ) << SHIFT_5T) ;
-
-    auto local_offset = (inner_pattern == Kokkos::Iterate::Left) 
-                      ? ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) + ((i2 & MASK_2)<<(SHIFT_0+SHIFT_1)) + ((i3 & MASK_3)<<(SHIFT_0+SHIFT_1+SHIFT_2)) + ((i4 & MASK_4)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3)) )
-                      : ( ((i0 & MASK_0) << (SHIFT_4+SHIFT_3+SHIFT_2+SHIFT_1)) + ((i1 & MASK_1) << (SHIFT_4+SHIFT_3+SHIFT_2)) + ((i2 & MASK_2)<<(SHIFT_4+SHIFT_3)) + ((i3 & MASK_3)<<(SHIFT_4)) + (i4 & MASK_4) ) ;
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
+                                              I2 const& i2, I3 const& i3,
+                                              I4 const& i4) const {
+    auto tile_offset =
+        (outer_pattern == Kokkos::Iterate::Left)
+            ? (((i0 >> SHIFT_0) +
+                m_tile_N0 *
+                    ((i1 >> SHIFT_1) +
+                     m_tile_N1 * ((i2 >> SHIFT_2) +
+                                  m_tile_N2 * ((i3 >> SHIFT_3) +
+                                               m_tile_N3 * (i4 >> SHIFT_4)))))
+               << SHIFT_5T)
+            : ((m_tile_N4 *
+                    (m_tile_N3 * (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
+                                               (i1 >> SHIFT_1)) +
+                                  (i2 >> SHIFT_2)) +
+                     (i3 >> SHIFT_3)) +
+                (i4 >> SHIFT_4))
+               << SHIFT_5T);
+
+    auto local_offset =
+        (inner_pattern == Kokkos::Iterate::Left)
+            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
+               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
+               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
+               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)))
+            : (((i0 & MASK_0) << (SHIFT_4 + SHIFT_3 + SHIFT_2 + SHIFT_1)) +
+               ((i1 & MASK_1) << (SHIFT_4 + SHIFT_3 + SHIFT_2)) +
+               ((i2 & MASK_2) << (SHIFT_4 + SHIFT_3)) +
+               ((i3 & MASK_3) << (SHIFT_4)) + (i4 & MASK_4));
 
     return tile_offset + local_offset;
   }
 
   // Rank 6
-  template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 >
-  KOKKOS_INLINE_FUNCTION
-  size_type operator()( I0 const & i0 , I1 const & i1 , I2 const & i2 , I3 const & i3 , I4 const & i4 , I5 const & i5 ) const {
-    auto tile_offset = (outer_pattern == Kokkos::Iterate::Left) 
-                     ? ( ( (i0>>SHIFT_0) + m_tile_N0*((i1>>SHIFT_1) + m_tile_N1*((i2>>SHIFT_2) + m_tile_N2*((i3>>SHIFT_3) + m_tile_N3*((i4>>SHIFT_4) + m_tile_N4*(i5>>SHIFT_5))))) ) << SHIFT_6T)
-                     : ( ( m_tile_N5*(m_tile_N4*(m_tile_N3*(m_tile_N2*(m_tile_N1*(i0>>SHIFT_0) + (i1>>SHIFT_1)) + (i2>>SHIFT_2)) + (i3>>SHIFT_3)) + (i4>>SHIFT_4)) + (i5>>SHIFT_5) ) << SHIFT_6T) ;
-
-    auto local_offset = (inner_pattern == Kokkos::Iterate::Left) 
-                      ? ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) + ((i2 & MASK_2)<<(SHIFT_0+SHIFT_1)) + ((i3 & MASK_3)<<(SHIFT_0+SHIFT_1+SHIFT_2)) + ((i4 & MASK_4)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3)) + ((i5 & MASK_5)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3+SHIFT_4)) )
-                      : ( ((i0 & MASK_0) << (SHIFT_5+SHIFT_4+SHIFT_3+SHIFT_2+SHIFT_1)) + ((i1 & MASK_1) << (SHIFT_5+SHIFT_4+SHIFT_3+SHIFT_2)) + ((i2 & MASK_2)<<(SHIFT_5+SHIFT_4+SHIFT_3)) + ((i3 & MASK_3)<<(SHIFT_5+SHIFT_4)) + ((i4 & MASK_4)<<(SHIFT_5)) + (i5 & MASK_5) ) ;
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
+                                              I2 const& i2, I3 const& i3,
+                                              I4 const& i4,
+                                              I5 const& i5) const {
+    auto tile_offset =
+        (outer_pattern == Kokkos::Iterate::Left)
+            ? (((i0 >> SHIFT_0) +
+                m_tile_N0 *
+                    ((i1 >> SHIFT_1) +
+                     m_tile_N1 *
+                         ((i2 >> SHIFT_2) +
+                          m_tile_N2 *
+                              ((i3 >> SHIFT_3) +
+                               m_tile_N3 * ((i4 >> SHIFT_4) +
+                                            m_tile_N4 * (i5 >> SHIFT_5))))))
+               << SHIFT_6T)
+            : ((m_tile_N5 *
+                    (m_tile_N4 *
+                         (m_tile_N3 *
+                              (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
+                                            (i1 >> SHIFT_1)) +
+                               (i2 >> SHIFT_2)) +
+                          (i3 >> SHIFT_3)) +
+                     (i4 >> SHIFT_4)) +
+                (i5 >> SHIFT_5))
+               << SHIFT_6T);
+
+    auto local_offset =
+        (inner_pattern == Kokkos::Iterate::Left)
+            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
+               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
+               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
+               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)) +
+               ((i5 & MASK_5)
+                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4)))
+            : (((i0 & MASK_0)
+                << (SHIFT_5 + SHIFT_4 + SHIFT_3 + SHIFT_2 + SHIFT_1)) +
+               ((i1 & MASK_1) << (SHIFT_5 + SHIFT_4 + SHIFT_3 + SHIFT_2)) +
+               ((i2 & MASK_2) << (SHIFT_5 + SHIFT_4 + SHIFT_3)) +
+               ((i3 & MASK_3) << (SHIFT_5 + SHIFT_4)) +
+               ((i4 & MASK_4) << (SHIFT_5)) + (i5 & MASK_5));
 
     return tile_offset + local_offset;
   }
 
   // Rank 7
-  template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , typename I6 >
-  KOKKOS_INLINE_FUNCTION
-  size_type operator()( I0 const & i0 , I1 const & i1 , I2 const & i2 , I3 const & i3 , I4 const & i4 , I5 const & i5 , I6 const & i6 ) const {
-    auto tile_offset = (outer_pattern == Kokkos::Iterate::Left) 
-                     ? ( ( (i0>>SHIFT_0) + m_tile_N0*((i1>>SHIFT_1) + m_tile_N1*((i2>>SHIFT_2) + m_tile_N2*((i3>>SHIFT_3) + m_tile_N3*((i4>>SHIFT_4) + m_tile_N4*((i5>>SHIFT_5) + m_tile_N5*(i6>>SHIFT_6)))))) ) << SHIFT_7T)
-                     : ( ( m_tile_N6*(m_tile_N5*(m_tile_N4*(m_tile_N3*(m_tile_N2*(m_tile_N1*(i0>>SHIFT_0) + (i1>>SHIFT_1)) + (i2>>SHIFT_2)) + (i3>>SHIFT_3)) + (i4>>SHIFT_4)) + (i5>>SHIFT_5)) + (i6>>SHIFT_6) ) << SHIFT_7T) ;
-
-    auto local_offset = (inner_pattern == Kokkos::Iterate::Left) 
-                      ? ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) + ((i2 & MASK_2)<<(SHIFT_0+SHIFT_1)) + ((i3 & MASK_3)<<(SHIFT_0+SHIFT_1+SHIFT_2)) + ((i4 & MASK_4)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3)) + ((i5 & MASK_5)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3+SHIFT_4)) + ((i6 & MASK_6)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3+SHIFT_4+SHIFT_5)) )
-                      : ( ((i0 & MASK_0) << (SHIFT_6+SHIFT_5+SHIFT_4+SHIFT_3+SHIFT_2+SHIFT_1)) + ((i1 & MASK_1) << (SHIFT_6+SHIFT_5+SHIFT_4+SHIFT_3+SHIFT_2)) + ((i2 & MASK_2)<<(SHIFT_6+SHIFT_5+SHIFT_4+SHIFT_3)) + ((i3 & MASK_3)<<(SHIFT_6+SHIFT_5+SHIFT_4)) + ((i4 & MASK_4)<<(SHIFT_6+SHIFT_5)) + ((i5 & MASK_5)<<(SHIFT_6)) + (i6 & MASK_6) ) ;
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
+                                              I2 const& i2, I3 const& i3,
+                                              I4 const& i4, I5 const& i5,
+                                              I6 const& i6) const {
+    auto tile_offset =
+        (outer_pattern == Kokkos::Iterate::Left)
+            ? (((i0 >> SHIFT_0) +
+                m_tile_N0 *
+                    ((i1 >> SHIFT_1) +
+                     m_tile_N1 *
+                         ((i2 >> SHIFT_2) +
+                          m_tile_N2 *
+                              ((i3 >> SHIFT_3) +
+                               m_tile_N3 *
+                                   ((i4 >> SHIFT_4) +
+                                    m_tile_N4 *
+                                        ((i5 >> SHIFT_5) +
+                                         m_tile_N5 * (i6 >> SHIFT_6)))))))
+               << SHIFT_7T)
+            : ((m_tile_N6 *
+                    (m_tile_N5 *
+                         (m_tile_N4 *
+                              (m_tile_N3 *
+                                   (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
+                                                 (i1 >> SHIFT_1)) +
+                                    (i2 >> SHIFT_2)) +
+                               (i3 >> SHIFT_3)) +
+                          (i4 >> SHIFT_4)) +
+                     (i5 >> SHIFT_5)) +
+                (i6 >> SHIFT_6))
+               << SHIFT_7T);
+
+    auto local_offset =
+        (inner_pattern == Kokkos::Iterate::Left)
+            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
+               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
+               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
+               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)) +
+               ((i5 & MASK_5)
+                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4)) +
+               ((i6 & MASK_6)
+                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5)))
+            : (((i0 & MASK_0) << (SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3 +
+                                  SHIFT_2 + SHIFT_1)) +
+               ((i1 & MASK_1)
+                << (SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3 + SHIFT_2)) +
+               ((i2 & MASK_2) << (SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3)) +
+               ((i3 & MASK_3) << (SHIFT_6 + SHIFT_5 + SHIFT_4)) +
+               ((i4 & MASK_4) << (SHIFT_6 + SHIFT_5)) +
+               ((i5 & MASK_5) << (SHIFT_6)) + (i6 & MASK_6));
 
     return tile_offset + local_offset;
   }
 
   // Rank 8
-  template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , typename I6 , typename I7 >
-  KOKKOS_INLINE_FUNCTION
-  size_type operator()( I0 const & i0 , I1 const & i1 , I2 const & i2 , I3 const & i3 , I4 const & i4 , I5 const & i5 , I6 const & i6 , I7 const & i7 ) const {
-    auto tile_offset = (outer_pattern == Kokkos::Iterate::Left) 
-                     ? ( ( (i0>>SHIFT_0) + m_tile_N0*((i1>>SHIFT_1) + m_tile_N1*((i2>>SHIFT_2) + m_tile_N2*((i3>>SHIFT_3) + m_tile_N3*((i4>>SHIFT_4) + m_tile_N4*((i5>>SHIFT_5) + m_tile_N5*((i6>>SHIFT_6) + m_tile_N6*(i7>>SHIFT_7))))))) ) << SHIFT_8T)
-                     : ( ( m_tile_N7*(m_tile_N6*(m_tile_N5*(m_tile_N4*(m_tile_N3*(m_tile_N2*(m_tile_N1*(i0>>SHIFT_0) + (i1>>SHIFT_1)) + (i2>>SHIFT_2)) + (i3>>SHIFT_3)) + (i4>>SHIFT_4)) + (i5>>SHIFT_5)) + (i6>>SHIFT_6)) + (i7>>SHIFT_7) ) << SHIFT_8T) ;
-
-    auto local_offset = (inner_pattern == Kokkos::Iterate::Left) 
-                      ? ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) + ((i2 & MASK_2)<<(SHIFT_0+SHIFT_1)) + ((i3 & MASK_3)<<(SHIFT_0+SHIFT_1+SHIFT_2)) + ((i4 & MASK_4)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3)) + ((i5 & MASK_5)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3+SHIFT_4)) + ((i6 & MASK_6)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3+SHIFT_4+SHIFT_5)) + ((i7 & MASK_7)<<(SHIFT_0+SHIFT_1+SHIFT_2+SHIFT_3+SHIFT_4+SHIFT_5+SHIFT_6)) )
-                      : ( ((i0 & MASK_0) << (SHIFT_7+SHIFT_6+SHIFT_5+SHIFT_4+SHIFT_3+SHIFT_2+SHIFT_1)) + ((i1 & MASK_1) << (SHIFT_7+SHIFT_6+SHIFT_5+SHIFT_4+SHIFT_3+SHIFT_2)) + ((i2 & MASK_2)<<(SHIFT_7+SHIFT_6+SHIFT_5+SHIFT_4+SHIFT_3)) + ((i3 & MASK_3)<<(SHIFT_7+SHIFT_6+SHIFT_5+SHIFT_4)) + ((i4 & MASK_4)<<(SHIFT_7+SHIFT_6+SHIFT_5)) + ((i5 & MASK_5)<<(SHIFT_7+SHIFT_6)) + ((i6 & MASK_6)<<(SHIFT_7)) + (i7 & MASK_7) ) ;
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
+                                              I2 const& i2, I3 const& i3,
+                                              I4 const& i4, I5 const& i5,
+                                              I6 const& i6,
+                                              I7 const& i7) const {
+    auto tile_offset =
+        (outer_pattern == Kokkos::Iterate::Left)
+            ? (((i0 >> SHIFT_0) +
+                m_tile_N0 *
+                    ((i1 >> SHIFT_1) +
+                     m_tile_N1 *
+                         ((i2 >> SHIFT_2) +
+                          m_tile_N2 *
+                              ((i3 >> SHIFT_3) +
+                               m_tile_N3 *
+                                   ((i4 >> SHIFT_4) +
+                                    m_tile_N4 *
+                                        ((i5 >> SHIFT_5) +
+                                         m_tile_N5 *
+                                             ((i6 >> SHIFT_6) +
+                                              m_tile_N6 * (i7 >> SHIFT_7))))))))
+               << SHIFT_8T)
+            : ((m_tile_N7 *
+                    (m_tile_N6 *
+                         (m_tile_N5 *
+                              (m_tile_N4 *
+                                   (m_tile_N3 *
+                                        (m_tile_N2 *
+                                             (m_tile_N1 * (i0 >> SHIFT_0) +
+                                              (i1 >> SHIFT_1)) +
+                                         (i2 >> SHIFT_2)) +
+                                    (i3 >> SHIFT_3)) +
+                               (i4 >> SHIFT_4)) +
+                          (i5 >> SHIFT_5)) +
+                     (i6 >> SHIFT_6)) +
+                (i7 >> SHIFT_7))
+               << SHIFT_8T);
+
+    auto local_offset =
+        (inner_pattern == Kokkos::Iterate::Left)
+            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
+               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
+               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
+               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)) +
+               ((i5 & MASK_5)
+                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4)) +
+               ((i6 & MASK_6) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 +
+                                  SHIFT_4 + SHIFT_5)) +
+               ((i7 & MASK_7) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 +
+                                  SHIFT_4 + SHIFT_5 + SHIFT_6)))
+            : (((i0 & MASK_0) << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4 +
+                                  SHIFT_3 + SHIFT_2 + SHIFT_1)) +
+               ((i1 & MASK_1) << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4 +
+                                  SHIFT_3 + SHIFT_2)) +
+               ((i2 & MASK_2)
+                << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3)) +
+               ((i3 & MASK_3) << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4)) +
+               ((i4 & MASK_4) << (SHIFT_7 + SHIFT_6 + SHIFT_5)) +
+               ((i5 & MASK_5) << (SHIFT_7 + SHIFT_6)) +
+               ((i6 & MASK_6) << (SHIFT_7)) + (i7 & MASK_7));
 
     return tile_offset + local_offset;
   }
 
   //----------------------------------------
 
-  KOKKOS_INLINE_FUNCTION constexpr
-  array_layout layout() const
-    { return array_layout( m_dim.N0 , m_dim.N1 , m_dim.N2 , m_dim.N2  , m_dim.N3  , m_dim.N4  , m_dim.N5  , m_dim.N6  , m_dim.N7 ); }
+  KOKKOS_INLINE_FUNCTION constexpr array_layout layout() const {
+    return array_layout(m_dim.N0, m_dim.N1, m_dim.N2, m_dim.N2, m_dim.N3,
+                        m_dim.N4, m_dim.N5, m_dim.N6, m_dim.N7);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const { return m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return m_dim.N7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
+    return m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const {
+    return m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const {
+    return m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const {
+    return m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const {
+    return m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const {
+    return m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const {
+    return m_dim.N7;
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type size() const { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type size() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
   // Strides are meaningless due to irregularity
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 0 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 0; }
 
   // Stride with [ rank ] value is the total length
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void stride( iType * const s ) const
-    {
-      s[0] = 0 ;
-      if ( 0 < dimension_type::rank ) { s[1] = 0 ; }
-      if ( 1 < dimension_type::rank ) { s[2] = 0 ; }
-      if ( 2 < dimension_type::rank ) { s[3] = 0 ; }
-      if ( 3 < dimension_type::rank ) { s[4] = 0 ; }
-      if ( 4 < dimension_type::rank ) { s[5] = 0 ; }
-      if ( 5 < dimension_type::rank ) { s[6] = 0 ; }
-      if ( 6 < dimension_type::rank ) { s[7] = 0 ; }
-      if ( 7 < dimension_type::rank ) { s[8] = 0 ; }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[0] = 0;
+    if (0 < dimension_type::rank) {
+      s[1] = 0;
     }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type span() const
-    {
-      // Rank2: ( NumTile0 * ( NumTile1 ) ) * TileSize, etc
-      return   ( VORank == 2 ) ? ( m_tile_N0 * m_tile_N1 ) << SHIFT_2T
-             : ( VORank == 3 ) ? ( m_tile_N0 * m_tile_N1 * m_tile_N2 ) << SHIFT_3T
-             : ( VORank == 4 ) ? ( m_tile_N0 * m_tile_N1 * m_tile_N2 * m_tile_N3 ) << SHIFT_4T
-             : ( VORank == 5 ) ? ( m_tile_N0 * m_tile_N1 * m_tile_N2 * m_tile_N3 * m_tile_N4 ) << SHIFT_5T
-             : ( VORank == 6 ) ? ( m_tile_N0 * m_tile_N1 * m_tile_N2 * m_tile_N3 * m_tile_N4 * m_tile_N5 ) << SHIFT_6T
-             : ( VORank == 7 ) ? ( m_tile_N0 * m_tile_N1 * m_tile_N2 * m_tile_N3 * m_tile_N4 * m_tile_N5 * m_tile_N6 ) << SHIFT_7T
-             : ( m_tile_N0 * m_tile_N1 * m_tile_N2 * m_tile_N3 * m_tile_N4 * m_tile_N5 * m_tile_N6 * m_tile_N7 ) << SHIFT_8T ;
+    if (1 < dimension_type::rank) {
+      s[2] = 0;
     }
-
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const
-    {
-      return true;
+    if (2 < dimension_type::rank) {
+      s[3] = 0;
+    }
+    if (3 < dimension_type::rank) {
+      s[4] = 0;
+    }
+    if (4 < dimension_type::rank) {
+      s[5] = 0;
+    }
+    if (5 < dimension_type::rank) {
+      s[6] = 0;
+    }
+    if (6 < dimension_type::rank) {
+      s[7] = 0;
+    }
+    if (7 < dimension_type::rank) {
+      s[8] = 0;
     }
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_type span() const {
+    // Rank2: ( NumTile0 * ( NumTile1 ) ) * TileSize, etc
+    return (VORank == 2)
+               ? (m_tile_N0 * m_tile_N1) << SHIFT_2T
+               : (VORank == 3)
+                     ? (m_tile_N0 * m_tile_N1 * m_tile_N2) << SHIFT_3T
+                     : (VORank == 4)
+                           ? (m_tile_N0 * m_tile_N1 * m_tile_N2 * m_tile_N3)
+                                 << SHIFT_4T
+                           : (VORank == 5)
+                                 ? (m_tile_N0 * m_tile_N1 * m_tile_N2 *
+                                    m_tile_N3 * m_tile_N4)
+                                       << SHIFT_5T
+                                 : (VORank == 6)
+                                       ? (m_tile_N0 * m_tile_N1 * m_tile_N2 *
+                                          m_tile_N3 * m_tile_N4 * m_tile_N5)
+                                             << SHIFT_6T
+                                       : (VORank == 7)
+                                             ? (m_tile_N0 * m_tile_N1 *
+                                                m_tile_N2 * m_tile_N3 *
+                                                m_tile_N4 * m_tile_N5 *
+                                                m_tile_N6)
+                                                   << SHIFT_7T
+                                             : (m_tile_N0 * m_tile_N1 *
+                                                m_tile_N2 * m_tile_N3 *
+                                                m_tile_N4 * m_tile_N5 *
+                                                m_tile_N6 * m_tile_N7)
+                                                   << SHIFT_8T;
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return true;
+  }
 
   //----------------------------------------
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
   KOKKOS_INLINE_FUNCTION ~ViewOffset() {}
   KOKKOS_INLINE_FUNCTION ViewOffset() {}
-  KOKKOS_INLINE_FUNCTION ViewOffset( const ViewOffset & rhs )
-  : m_dim(rhs.m_dim)
-  , m_tile_N0(rhs.m_tile_N0)
-  , m_tile_N1(rhs.m_tile_N1)
-  , m_tile_N2(rhs.m_tile_N2)
-  , m_tile_N3(rhs.m_tile_N3)
-  , m_tile_N4(rhs.m_tile_N4)
-  , m_tile_N5(rhs.m_tile_N5)
-  , m_tile_N6(rhs.m_tile_N6)
-  , m_tile_N7(rhs.m_tile_N7)
-  {}
-
-  KOKKOS_INLINE_FUNCTION ViewOffset & operator = ( const ViewOffset & rhs ) {
-    m_dim = rhs.m_dim;
+  KOKKOS_INLINE_FUNCTION ViewOffset(const ViewOffset& rhs)
+      : m_dim(rhs.m_dim),
+        m_tile_N0(rhs.m_tile_N0),
+        m_tile_N1(rhs.m_tile_N1),
+        m_tile_N2(rhs.m_tile_N2),
+        m_tile_N3(rhs.m_tile_N3),
+        m_tile_N4(rhs.m_tile_N4),
+        m_tile_N5(rhs.m_tile_N5),
+        m_tile_N6(rhs.m_tile_N6),
+        m_tile_N7(rhs.m_tile_N7) {}
+
+  KOKKOS_INLINE_FUNCTION ViewOffset& operator=(const ViewOffset& rhs) {
+    m_dim     = rhs.m_dim;
     m_tile_N0 = rhs.m_tile_N0;
     m_tile_N1 = rhs.m_tile_N1;
     m_tile_N2 = rhs.m_tile_N2;
@@ -380,394 +629,513 @@ public:
   }
 
 #else
-  KOKKOS_INLINE_FUNCTION ~ViewOffset() = default;
-  KOKKOS_INLINE_FUNCTION ViewOffset() = default;
-  KOKKOS_INLINE_FUNCTION ViewOffset( const ViewOffset & ) = default;
-  KOKKOS_INLINE_FUNCTION ViewOffset & operator = ( const ViewOffset & ) = default;
+  KOKKOS_INLINE_FUNCTION ~ViewOffset()                 = default;
+  KOKKOS_INLINE_FUNCTION ViewOffset()                  = default;
+  KOKKOS_INLINE_FUNCTION ViewOffset(const ViewOffset&) = default;
+  KOKKOS_INLINE_FUNCTION ViewOffset& operator=(const ViewOffset&) = default;
 #endif
 
-  template< unsigned TrivialScalarSize >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( std::integral_constant<unsigned,TrivialScalarSize> const & ,
-                        array_layout const arg_layout )
-    : m_dim( arg_layout.dimension[0], arg_layout.dimension[1], arg_layout.dimension[2], arg_layout.dimension[3], arg_layout.dimension[4], arg_layout.dimension[5], arg_layout.dimension[6], arg_layout.dimension[7] )
-    , m_tile_N0( ( arg_layout.dimension[0] + MASK_0 ) >> SHIFT_0 /* number of tiles in first dimension */ )
-    , m_tile_N1( ( arg_layout.dimension[1] + MASK_1 ) >> SHIFT_1 )
-    , m_tile_N2( (VORank > 2 ) ? ( arg_layout.dimension[2] + MASK_2 ) >> SHIFT_2 : 0 )
-    , m_tile_N3( (VORank > 3 ) ? ( arg_layout.dimension[3] + MASK_3 ) >> SHIFT_3 : 0 )
-    , m_tile_N4( (VORank > 4 ) ? ( arg_layout.dimension[4] + MASK_4 ) >> SHIFT_4 : 0 )
-    , m_tile_N5( (VORank > 5 ) ? ( arg_layout.dimension[5] + MASK_5 ) >> SHIFT_5 : 0 )
-    , m_tile_N6( (VORank > 6 ) ? ( arg_layout.dimension[6] + MASK_6 ) >> SHIFT_6 : 0 )
-    , m_tile_N7( (VORank > 7 ) ? ( arg_layout.dimension[7] + MASK_7 ) >> SHIFT_7 : 0 )
-    {}
-
+  template <unsigned TrivialScalarSize>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      std::integral_constant<unsigned, TrivialScalarSize> const&,
+      array_layout const arg_layout)
+      : m_dim(arg_layout.dimension[0], arg_layout.dimension[1],
+              arg_layout.dimension[2], arg_layout.dimension[3],
+              arg_layout.dimension[4], arg_layout.dimension[5],
+              arg_layout.dimension[6], arg_layout.dimension[7]),
+        m_tile_N0((arg_layout.dimension[0] + MASK_0) >>
+                  SHIFT_0 /* number of tiles in first dimension */),
+        m_tile_N1((arg_layout.dimension[1] + MASK_1) >> SHIFT_1),
+        m_tile_N2((VORank > 2) ? (arg_layout.dimension[2] + MASK_2) >> SHIFT_2
+                               : 0),
+        m_tile_N3((VORank > 3) ? (arg_layout.dimension[3] + MASK_3) >> SHIFT_3
+                               : 0),
+        m_tile_N4((VORank > 4) ? (arg_layout.dimension[4] + MASK_4) >> SHIFT_4
+                               : 0),
+        m_tile_N5((VORank > 5) ? (arg_layout.dimension[5] + MASK_5) >> SHIFT_5
+                               : 0),
+        m_tile_N6((VORank > 6) ? (arg_layout.dimension[6] + MASK_6) >> SHIFT_6
+                               : 0),
+        m_tile_N7((VORank > 7) ? (arg_layout.dimension[7] + MASK_7) >> SHIFT_7
+                               : 0) {}
 };
 
-
 //----------------------------------------
 
-
-// ViewMapping assign method needed in order to return a 'subview' tile as a proper View
-// The outer iteration pattern determines the mapping of the pointer offset to the beginning of requested tile
-// The inner iteration pattern is needed for the layout of the tile's View to be returned
-// Rank 2
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7
-        , class ... P
-        , typename iType0 , typename iType1
-        >
-struct ViewMapping
-  < typename std::enable_if< (N2 == 0 && N3 == 0 && N4 == 0 && N5 == 0 && N6 == 0 && N7 == 0) >::type //void
-  , Kokkos::ViewTraits<T**,Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>,P...>
-  , Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>
-  , iType0
-  , iType1 >
-{
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T** , src_layout , P... > src_traits ;
+// ViewMapping assign method needed in order to return a 'subview' tile as a
+// proper View The outer iteration pattern determines the mapping of the pointer
+// offset to the beginning of requested tile The inner iteration pattern is
+// needed for the layout of the tile's View to be returned Rank 2
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
+          typename iType1>
+struct ViewMapping<
+    typename std::enable_if<(N2 == 0 && N3 == 0 && N4 == 0 && N5 == 0 &&
+                             N6 == 0 && N7 == 0)>::type  // void
+    ,
+    Kokkos::ViewTraits<
+        T**,
+        Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                          N5, N6, N7, true>,
+        P...>,
+    Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
+                                      N6, N7, true>,
+    iType0, iType1> {
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      src_layout;
+  typedef Kokkos::ViewTraits<T**, src_layout, P...> src_traits;
 
   enum { is_outer_left = (OuterP == Kokkos::Iterate::Left) };
   enum { is_inner_left = (InnerP == Kokkos::Iterate::Left) };
-  typedef typename std::conditional< is_inner_left, Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::ViewTraits< T[N0][N1] , array_layout , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1] , array_layout , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const iType0 i_tile0
-             , const iType1 i_tile1
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                          ( is_outer_left ? ( (i_tile0 + src.m_impl_offset.m_tile_N0 * i_tile1) << src_offset_type::SHIFT_2T )
-                                          : ( (src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1) << src_offset_type::SHIFT_2T )
-                          ) // offset to start of the tile
-                        )
-       , dst_offset_type() );
-    }
+  typedef typename std::conditional<is_inner_left, Kokkos::LayoutLeft,
+                                    Kokkos::LayoutRight>::type array_layout;
+  typedef Kokkos::ViewTraits<T[N0][N1], array_layout, P...> traits;
+  typedef Kokkos::View<T[N0][N1], array_layout, P...> type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const iType0 i_tile0, const iType1 i_tile1) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(
+            src.m_impl_handle +
+            (is_outer_left ? ((i_tile0 + src.m_impl_offset.m_tile_N0 * i_tile1)
+                              << src_offset_type::SHIFT_2T)
+                           : ((src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1)
+                              << src_offset_type::SHIFT_2T))  // offset to start
+                                                              // of the tile
+            ),
+        dst_offset_type());
+  }
 };
 
 // Rank 3
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7
-        , class ... P
-        , typename iType0 , typename iType1 , typename iType2
-        >
-struct ViewMapping
-  < typename std::enable_if< (N3 == 0 && N4 == 0 && N5 == 0 && N6 == 0 && N7 == 0) >::type //void
-  , Kokkos::ViewTraits<T***,Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>,P...>
-  , Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>
-  , iType0
-  , iType1
-  , iType2 >
-{
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T*** , src_layout , P... > src_traits ;
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
+          typename iType1, typename iType2>
+struct ViewMapping<typename std::enable_if<(N3 == 0 && N4 == 0 && N5 == 0 &&
+                                            N6 == 0 && N7 == 0)>::type  // void
+                   ,
+                   Kokkos::ViewTraits<T***,
+                                      Kokkos::Experimental::LayoutTiled<
+                                          OuterP, InnerP, N0, N1, N2, N3, N4,
+                                          N5, N6, N7, true>,
+                                      P...>,
+                   Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                     N3, N4, N5, N6, N7, true>,
+                   iType0, iType1, iType2> {
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      src_layout;
+  typedef Kokkos::ViewTraits<T***, src_layout, P...> src_traits;
 
   enum { is_outer_left = (OuterP == Kokkos::Iterate::Left) };
   enum { is_inner_left = (InnerP == Kokkos::Iterate::Left) };
-  typedef typename std::conditional< is_inner_left, Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::ViewTraits< T[N0][N1][N2] , array_layout , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1][N2] , array_layout , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const iType0 i_tile0
-             , const iType1 i_tile1
-             , const iType2 i_tile2
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                          ( is_outer_left ? ( ( i_tile0 + src.m_impl_offset.m_tile_N0 * ( i_tile1 + src.m_impl_offset.m_tile_N1 * i_tile2 ) ) << src_offset_type::SHIFT_3T ) 
-                                          : ( ( src.m_impl_offset.m_tile_N2 * ( src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1 ) + i_tile2 ) << src_offset_type::SHIFT_3T )
-                          )
-                        ) // offset to start of the tile
-       , dst_offset_type() );
-    }
+  typedef typename std::conditional<is_inner_left, Kokkos::LayoutLeft,
+                                    Kokkos::LayoutRight>::type array_layout;
+  typedef Kokkos::ViewTraits<T[N0][N1][N2], array_layout, P...> traits;
+  typedef Kokkos::View<T[N0][N1][N2], array_layout, P...> type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
+      const iType2 i_tile2) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(
+            src.m_impl_handle +
+            (is_outer_left
+                 ? ((i_tile0 +
+                     src.m_impl_offset.m_tile_N0 *
+                         (i_tile1 + src.m_impl_offset.m_tile_N1 * i_tile2))
+                    << src_offset_type::SHIFT_3T)
+                 : ((src.m_impl_offset.m_tile_N2 *
+                         (src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1) +
+                     i_tile2)
+                    << src_offset_type::SHIFT_3T)))  // offset to start of the
+                                                     // tile
+        ,
+        dst_offset_type());
+  }
 };
 
 // Rank 4
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7
-        , class ... P
-        , typename iType0 , typename iType1 , typename iType2 , typename iType3
-        >
-struct ViewMapping
-  < typename std::enable_if< (N4 == 0 && N5 == 0 && N6 == 0 && N7 == 0) >::type //void
-  , Kokkos::ViewTraits<T****,Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>,P...>
-  , Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>
-  , iType0
-  , iType1
-  , iType2 
-  , iType3 >
-{
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T**** , src_layout , P... > src_traits ;
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
+          typename iType1, typename iType2, typename iType3>
+struct ViewMapping<typename std::enable_if<(N4 == 0 && N5 == 0 && N6 == 0 &&
+                                            N7 == 0)>::type  // void
+                   ,
+                   Kokkos::ViewTraits<T****,
+                                      Kokkos::Experimental::LayoutTiled<
+                                          OuterP, InnerP, N0, N1, N2, N3, N4,
+                                          N5, N6, N7, true>,
+                                      P...>,
+                   Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                     N3, N4, N5, N6, N7, true>,
+                   iType0, iType1, iType2, iType3> {
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      src_layout;
+  typedef Kokkos::ViewTraits<T****, src_layout, P...> src_traits;
 
   enum { is_outer_left = (OuterP == Kokkos::Iterate::Left) };
   enum { is_inner_left = (InnerP == Kokkos::Iterate::Left) };
-  typedef typename std::conditional< is_inner_left, Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::ViewTraits< T[N0][N1][N2][N3] , array_layout , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1][N2][N3] , array_layout , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const iType0 i_tile0
-             , const iType1 i_tile1
-             , const iType2 i_tile2
-             , const iType3 i_tile3
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                          ( is_outer_left ? ( ( i_tile0 + src.m_impl_offset.m_tile_N0 * ( i_tile1 + src.m_impl_offset.m_tile_N1 * ( i_tile2 + src.m_impl_offset.m_tile_N2 * i_tile3 ) ) ) << src_offset_type::SHIFT_4T ) 
-                                          : ( ( src.m_impl_offset.m_tile_N3 * ( src.m_impl_offset.m_tile_N2 * ( src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1 ) + i_tile2 ) + i_tile3 ) << src_offset_type::SHIFT_4T )
-                          )
-                        ) // offset to start of the tile
-       , dst_offset_type() );
-    }
+  typedef typename std::conditional<is_inner_left, Kokkos::LayoutLeft,
+                                    Kokkos::LayoutRight>::type array_layout;
+  typedef Kokkos::ViewTraits<T[N0][N1][N2][N3], array_layout, P...> traits;
+  typedef Kokkos::View<T[N0][N1][N2][N3], array_layout, P...> type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
+      const iType2 i_tile2, const iType3 i_tile3) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(
+            src.m_impl_handle +
+            (is_outer_left
+                 ? ((i_tile0 +
+                     src.m_impl_offset.m_tile_N0 *
+                         (i_tile1 + src.m_impl_offset.m_tile_N1 *
+                                        (i_tile2 + src.m_impl_offset.m_tile_N2 *
+                                                       i_tile3)))
+                    << src_offset_type::SHIFT_4T)
+                 : ((src.m_impl_offset.m_tile_N3 *
+                         (src.m_impl_offset.m_tile_N2 *
+                              (src.m_impl_offset.m_tile_N1 * i_tile0 +
+                               i_tile1) +
+                          i_tile2) +
+                     i_tile3)
+                    << src_offset_type::SHIFT_4T)))  // offset to start of the
+                                                     // tile
+        ,
+        dst_offset_type());
+  }
 };
 
 // Rank 5
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7
-        , class ... P
-        , typename iType0 , typename iType1 , typename iType2 , typename iType3 , typename iType4
-        >
-struct ViewMapping
-  < typename std::enable_if< (N5 == 0 && N6 == 0 && N7 == 0) >::type //void
-  , Kokkos::ViewTraits<T*****,Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>,P...>
-  , Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>
-  , iType0
-  , iType1
-  , iType2 
-  , iType3
-  , iType4 >
-{
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T***** , src_layout , P... > src_traits ;
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
+          typename iType1, typename iType2, typename iType3, typename iType4>
+struct ViewMapping<
+    typename std::enable_if<(N5 == 0 && N6 == 0 && N7 == 0)>::type  // void
+    ,
+    Kokkos::ViewTraits<
+        T*****,
+        Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                          N5, N6, N7, true>,
+        P...>,
+    Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
+                                      N6, N7, true>,
+    iType0, iType1, iType2, iType3, iType4> {
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      src_layout;
+  typedef Kokkos::ViewTraits<T*****, src_layout, P...> src_traits;
 
   enum { is_outer_left = (OuterP == Kokkos::Iterate::Left) };
   enum { is_inner_left = (InnerP == Kokkos::Iterate::Left) };
-  typedef typename std::conditional< is_inner_left, Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::ViewTraits< T[N0][N1][N2][N3][N4] , array_layout , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1][N2][N3][N4] , array_layout , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const iType0 i_tile0
-             , const iType1 i_tile1
-             , const iType2 i_tile2
-             , const iType3 i_tile3
-             , const iType4 i_tile4
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                          ( is_outer_left ? ( ( i_tile0 + src.m_impl_offset.m_tile_N0 * ( i_tile1 + src.m_impl_offset.m_tile_N1 * ( i_tile2 + src.m_impl_offset.m_tile_N2 * ( i_tile3 + src.m_impl_offset.m_tile_N3 * i_tile4 ) ) ) ) << src_offset_type::SHIFT_5T ) 
-                                          : ( ( src.m_impl_offset.m_tile_N4 * ( src.m_impl_offset.m_tile_N3 * ( src.m_impl_offset.m_tile_N2 * ( src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1 ) + i_tile2 ) + i_tile3 ) + i_tile4 ) << src_offset_type::SHIFT_5T )
-                          )
-                        ) // offset to start of the tile
-       , dst_offset_type() );
-    }
+  typedef typename std::conditional<is_inner_left, Kokkos::LayoutLeft,
+                                    Kokkos::LayoutRight>::type array_layout;
+  typedef Kokkos::ViewTraits<T[N0][N1][N2][N3][N4], array_layout, P...> traits;
+  typedef Kokkos::View<T[N0][N1][N2][N3][N4], array_layout, P...> type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
+      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(
+            src.m_impl_handle +
+            (is_outer_left
+                 ? ((i_tile0 +
+                     src.m_impl_offset.m_tile_N0 *
+                         (i_tile1 +
+                          src.m_impl_offset.m_tile_N1 *
+                              (i_tile2 +
+                               src.m_impl_offset.m_tile_N2 *
+                                   (i_tile3 +
+                                    src.m_impl_offset.m_tile_N3 * i_tile4))))
+                    << src_offset_type::SHIFT_5T)
+                 : ((src.m_impl_offset.m_tile_N4 *
+                         (src.m_impl_offset.m_tile_N3 *
+                              (src.m_impl_offset.m_tile_N2 *
+                                   (src.m_impl_offset.m_tile_N1 * i_tile0 +
+                                    i_tile1) +
+                               i_tile2) +
+                          i_tile3) +
+                     i_tile4)
+                    << src_offset_type::SHIFT_5T)))  // offset to start of the
+                                                     // tile
+        ,
+        dst_offset_type());
+  }
 };
 
 // Rank 6
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7
-        , class ... P
-        , typename iType0 , typename iType1 , typename iType2 , typename iType3 , typename iType4 , typename iType5
-        >
-struct ViewMapping
-  < typename std::enable_if< (N6 == 0 && N7 == 0) >::type //void
-  , Kokkos::ViewTraits<T******,Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>,P...>
-  , Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>
-  , iType0
-  , iType1
-  , iType2 
-  , iType3
-  , iType4
-  , iType5 >
-{
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T****** , src_layout , P... > src_traits ;
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
+          typename iType1, typename iType2, typename iType3, typename iType4,
+          typename iType5>
+struct ViewMapping<typename std::enable_if<(N6 == 0 && N7 == 0)>::type  // void
+                   ,
+                   Kokkos::ViewTraits<T******,
+                                      Kokkos::Experimental::LayoutTiled<
+                                          OuterP, InnerP, N0, N1, N2, N3, N4,
+                                          N5, N6, N7, true>,
+                                      P...>,
+                   Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                     N3, N4, N5, N6, N7, true>,
+                   iType0, iType1, iType2, iType3, iType4, iType5> {
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      src_layout;
+  typedef Kokkos::ViewTraits<T******, src_layout, P...> src_traits;
 
   enum { is_outer_left = (OuterP == Kokkos::Iterate::Left) };
   enum { is_inner_left = (InnerP == Kokkos::Iterate::Left) };
-  typedef typename std::conditional< is_inner_left, Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::ViewTraits< T[N0][N1][N2][N3][N4][N5] , array_layout , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1][N2][N3][N4][N5] , array_layout , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const iType0 i_tile0
-             , const iType1 i_tile1
-             , const iType2 i_tile2
-             , const iType3 i_tile3
-             , const iType4 i_tile4
-             , const iType5 i_tile5
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                          ( is_outer_left ? ( ( i_tile0 + src.m_impl_offset.m_tile_N0 * ( i_tile1 + src.m_impl_offset.m_tile_N1 * ( i_tile2 + src.m_impl_offset.m_tile_N2 * ( i_tile3 + src.m_impl_offset.m_tile_N3 * ( i_tile4 + src.m_impl_offset.m_tile_N4 * i_tile5 ) ) ) ) ) << src_offset_type::SHIFT_6T ) 
-                                          : ( ( src.m_impl_offset.m_tile_N5 * ( src.m_impl_offset.m_tile_N4 * ( src.m_impl_offset.m_tile_N3 * ( src.m_impl_offset.m_tile_N2 * ( src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1 ) + i_tile2 ) + i_tile3 ) + i_tile4 ) + i_tile5 ) << src_offset_type::SHIFT_6T )
-                          )
-                        ) // offset to start of the tile
-       , dst_offset_type() );
-    }
+  typedef typename std::conditional<is_inner_left, Kokkos::LayoutLeft,
+                                    Kokkos::LayoutRight>::type array_layout;
+  typedef Kokkos::ViewTraits<T[N0][N1][N2][N3][N4][N5], array_layout, P...>
+      traits;
+  typedef Kokkos::View<T[N0][N1][N2][N3][N4][N5], array_layout, P...> type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
+      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4,
+      const iType5 i_tile5) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(
+            src.m_impl_handle +
+            (is_outer_left
+                 ? ((i_tile0 +
+                     src.m_impl_offset.m_tile_N0 *
+                         (i_tile1 +
+                          src.m_impl_offset.m_tile_N1 *
+                              (i_tile2 +
+                               src.m_impl_offset.m_tile_N2 *
+                                   (i_tile3 +
+                                    src.m_impl_offset.m_tile_N3 *
+                                        (i_tile4 + src.m_impl_offset.m_tile_N4 *
+                                                       i_tile5)))))
+                    << src_offset_type::SHIFT_6T)
+                 : ((src.m_impl_offset.m_tile_N5 *
+                         (src.m_impl_offset.m_tile_N4 *
+                              (src.m_impl_offset.m_tile_N3 *
+                                   (src.m_impl_offset.m_tile_N2 *
+                                        (src.m_impl_offset.m_tile_N1 * i_tile0 +
+                                         i_tile1) +
+                                    i_tile2) +
+                               i_tile3) +
+                          i_tile4) +
+                     i_tile5)
+                    << src_offset_type::SHIFT_6T)))  // offset to start of the
+                                                     // tile
+        ,
+        dst_offset_type());
+  }
 };
 
 // Rank 7
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7
-        , class ... P
-        , typename iType0 , typename iType1 , typename iType2 , typename iType3 , typename iType4 , typename iType5 , typename iType6
-        >
-struct ViewMapping
-  < typename std::enable_if< (N7 == 0) >::type //void
-  , Kokkos::ViewTraits<T*******,Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>,P...>
-  , Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>
-  , iType0
-  , iType1
-  , iType2 
-  , iType3
-  , iType4
-  , iType5 
-  , iType6 >
-{
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T******* , src_layout , P... > src_traits ;
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
+          typename iType1, typename iType2, typename iType3, typename iType4,
+          typename iType5, typename iType6>
+struct ViewMapping<typename std::enable_if<(N7 == 0)>::type  // void
+                   ,
+                   Kokkos::ViewTraits<T*******,
+                                      Kokkos::Experimental::LayoutTiled<
+                                          OuterP, InnerP, N0, N1, N2, N3, N4,
+                                          N5, N6, N7, true>,
+                                      P...>,
+                   Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                     N3, N4, N5, N6, N7, true>,
+                   iType0, iType1, iType2, iType3, iType4, iType5, iType6> {
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      src_layout;
+  typedef Kokkos::ViewTraits<T*******, src_layout, P...> src_traits;
 
   enum { is_outer_left = (OuterP == Kokkos::Iterate::Left) };
   enum { is_inner_left = (InnerP == Kokkos::Iterate::Left) };
-  typedef typename std::conditional< is_inner_left, Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::ViewTraits< T[N0][N1][N2][N3][N4][N5][N6] , array_layout , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1][N2][N3][N4][N5][N6] , array_layout , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const iType0 i_tile0
-             , const iType1 i_tile1
-             , const iType2 i_tile2
-             , const iType3 i_tile3
-             , const iType4 i_tile4
-             , const iType5 i_tile5
-             , const iType6 i_tile6
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                          ( is_outer_left ? ( ( i_tile0 + src.m_impl_offset.m_tile_N0 * ( i_tile1 + src.m_impl_offset.m_tile_N1 * ( i_tile2 + src.m_impl_offset.m_tile_N2 * ( i_tile3 + src.m_impl_offset.m_tile_N3 * ( i_tile4 + src.m_impl_offset.m_tile_N4 * ( i_tile5 + src.m_impl_offset.m_tile_N5 * i_tile6 ) ) ) ) ) ) << src_offset_type::SHIFT_7T ) 
-                                          : ( ( src.m_impl_offset.m_tile_N6 * ( src.m_impl_offset.m_tile_N5 * ( src.m_impl_offset.m_tile_N4 * ( src.m_impl_offset.m_tile_N3 * ( src.m_impl_offset.m_tile_N2 * ( src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1 ) + i_tile2 ) + i_tile3 ) + i_tile4 ) + i_tile5 ) + i_tile6 ) << src_offset_type::SHIFT_7T )
-                          )
-                        ) // offset to start of the tile
-       , dst_offset_type() );
-    }
+  typedef typename std::conditional<is_inner_left, Kokkos::LayoutLeft,
+                                    Kokkos::LayoutRight>::type array_layout;
+  typedef Kokkos::ViewTraits<T[N0][N1][N2][N3][N4][N5][N6], array_layout, P...>
+      traits;
+  typedef Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6], array_layout, P...> type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
+      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4,
+      const iType5 i_tile5, const iType6 i_tile6) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(
+            src.m_impl_handle +
+            (is_outer_left
+                 ? ((i_tile0 +
+                     src.m_impl_offset.m_tile_N0 *
+                         (i_tile1 +
+                          src.m_impl_offset.m_tile_N1 *
+                              (i_tile2 +
+                               src.m_impl_offset.m_tile_N2 *
+                                   (i_tile3 +
+                                    src.m_impl_offset.m_tile_N3 *
+                                        (i_tile4 +
+                                         src.m_impl_offset.m_tile_N4 *
+                                             (i_tile5 +
+                                              src.m_impl_offset.m_tile_N5 *
+                                                  i_tile6))))))
+                    << src_offset_type::SHIFT_7T)
+                 : ((src.m_impl_offset.m_tile_N6 *
+                         (src.m_impl_offset.m_tile_N5 *
+                              (src.m_impl_offset.m_tile_N4 *
+                                   (src.m_impl_offset.m_tile_N3 *
+                                        (src.m_impl_offset.m_tile_N2 *
+                                             (src.m_impl_offset.m_tile_N1 *
+                                                  i_tile0 +
+                                              i_tile1) +
+                                         i_tile2) +
+                                    i_tile3) +
+                               i_tile4) +
+                          i_tile5) +
+                     i_tile6)
+                    << src_offset_type::SHIFT_7T)))  // offset to start of the
+                                                     // tile
+        ,
+        dst_offset_type());
+  }
 };
 
 // Rank 8
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7
-        , class ... P
-        , typename iType0 , typename iType1 , typename iType2 , typename iType3 , typename iType4 , typename iType5 , typename iType6 , typename iType7
-        >
-struct ViewMapping
-  < typename std::enable_if< (N0 != 0 && N1 != 0 && N2 != 0 && N3 != 0 && N4 != 0 && N5 != 0 && N6 != 0 && N7 != 0) >::type //void
-  , Kokkos::ViewTraits<T********,Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>,P...>
-  , Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>
-  , iType0
-  , iType1
-  , iType2 
-  , iType3
-  , iType4
-  , iType5 
-  , iType6
-  , iType7 >
-{
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T******** , src_layout , P... > src_traits ;
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
+          typename iType1, typename iType2, typename iType3, typename iType4,
+          typename iType5, typename iType6, typename iType7>
+struct ViewMapping<
+    typename std::enable_if<(N0 != 0 && N1 != 0 && N2 != 0 && N3 != 0 &&
+                             N4 != 0 && N5 != 0 && N6 != 0 &&
+                             N7 != 0)>::type  // void
+    ,
+    Kokkos::ViewTraits<
+        T********,
+        Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                          N5, N6, N7, true>,
+        P...>,
+    Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
+                                      N6, N7, true>,
+    iType0, iType1, iType2, iType3, iType4, iType5, iType6, iType7> {
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      src_layout;
+  typedef Kokkos::ViewTraits<T********, src_layout, P...> src_traits;
 
   enum { is_outer_left = (OuterP == Kokkos::Iterate::Left) };
   enum { is_inner_left = (InnerP == Kokkos::Iterate::Left) };
-  typedef typename std::conditional< is_inner_left, Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::ViewTraits< T[N0][N1][N2][N3][N4][N5][N6][N7] , array_layout , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1][N2][N3][N4][N5][N6][N7] , array_layout , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const iType0 i_tile0
-             , const iType1 i_tile1
-             , const iType2 i_tile2
-             , const iType3 i_tile3
-             , const iType4 i_tile4
-             , const iType5 i_tile5
-             , const iType6 i_tile6
-             , const iType7 i_tile7
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                          ( is_outer_left ? ( ( i_tile0 + src.m_impl_offset.m_tile_N0 * ( i_tile1 + src.m_impl_offset.m_tile_N1 * ( i_tile2 + src.m_impl_offset.m_tile_N2 * ( i_tile3 + src.m_impl_offset.m_tile_N3 * ( i_tile4 + src.m_impl_offset.m_tile_N4 * ( i_tile5 + src.m_impl_offset.m_tile_N5 * ( i_tile6 + src.m_impl_offset.m_tile_N6 * i_tile7 ) ) ) ) ) ) ) << src_offset_type::SHIFT_8T ) 
-                                          : ( ( src.m_impl_offset.m_tile_N7 * ( src.m_impl_offset.m_tile_N6 * ( src.m_impl_offset.m_tile_N5 * ( src.m_impl_offset.m_tile_N4 * ( src.m_impl_offset.m_tile_N3 * ( src.m_impl_offset.m_tile_N2 * ( src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1 ) + i_tile2 ) + i_tile3 ) + i_tile4 ) + i_tile5 ) + i_tile6 ) + i_tile7 ) << src_offset_type::SHIFT_8T )
-                          )
-                        ) // offset to start of the tile
-       , dst_offset_type() );
-    }
+  typedef typename std::conditional<is_inner_left, Kokkos::LayoutLeft,
+                                    Kokkos::LayoutRight>::type array_layout;
+  typedef Kokkos::ViewTraits<T[N0][N1][N2][N3][N4][N5][N6][N7], array_layout,
+                             P...>
+      traits;
+  typedef Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6][N7], array_layout, P...>
+      type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
+      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4,
+      const iType5 i_tile5, const iType6 i_tile6, const iType7 i_tile7) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(
+            src.m_impl_handle +
+            (is_outer_left
+                 ? ((i_tile0 +
+                     src.m_impl_offset.m_tile_N0 *
+                         (i_tile1 +
+                          src.m_impl_offset.m_tile_N1 *
+                              (i_tile2 +
+                               src.m_impl_offset.m_tile_N2 *
+                                   (i_tile3 +
+                                    src.m_impl_offset.m_tile_N3 *
+                                        (i_tile4 +
+                                         src.m_impl_offset.m_tile_N4 *
+                                             (i_tile5 +
+                                              src.m_impl_offset.m_tile_N5 *
+                                                  (i_tile6 +
+                                                   src.m_impl_offset.m_tile_N6 *
+                                                       i_tile7)))))))
+                    << src_offset_type::SHIFT_8T)
+                 : ((src.m_impl_offset.m_tile_N7 *
+                         (src.m_impl_offset.m_tile_N6 *
+                              (src.m_impl_offset.m_tile_N5 *
+                                   (src.m_impl_offset.m_tile_N4 *
+                                        (src.m_impl_offset.m_tile_N3 *
+                                             (src.m_impl_offset.m_tile_N2 *
+                                                  (src.m_impl_offset.m_tile_N1 *
+                                                       i_tile0 +
+                                                   i_tile1) +
+                                              i_tile2) +
+                                         i_tile3) +
+                                    i_tile4) +
+                               i_tile5) +
+                          i_tile6) +
+                     i_tile7)
+                    << src_offset_type::SHIFT_8T)))  // offset to start of the
+                                                     // tile
+        ,
+        dst_offset_type());
+  }
 };
 
-
 } /* namespace Impl */
 } /* namespace Kokkos */
 
@@ -776,170 +1144,220 @@ struct ViewMapping
 namespace Kokkos {
 
 // Rank 2
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7 
-        , class ... P 
-        >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1] , typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type , P... >
-tile_subview( const Kokkos::View<T**, Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>, P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            )
-{
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<
+    T[N0][N1],
+    typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                              Kokkos::LayoutLeft, Kokkos::LayoutRight>::type,
+    P...>
+tile_subview(const Kokkos::View<
+                 T**,
+                 Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                   N3, N4, N5, N6, N7, true>,
+                 P...>& src,
+             const size_t i_tile0, const size_t i_tile1) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true> SrcLayout ;
-
-  return Kokkos::View< T[N0][N1] , array_layout , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 );
+  typedef
+      typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                                Kokkos::LayoutLeft, Kokkos::LayoutRight>::type
+          array_layout;
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      SrcLayout;
+
+  return Kokkos::View<T[N0][N1], array_layout, P...>(src, SrcLayout(), i_tile0,
+                                                     i_tile1);
 }
 
 // Rank 3
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7 
-        , class ... P 
-        >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1][N2] , typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type , P... >
-tile_subview( const Kokkos::View<T***, Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>, P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            , const size_t i_tile2
-            )
-{
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<
+    T[N0][N1][N2],
+    typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                              Kokkos::LayoutLeft, Kokkos::LayoutRight>::type,
+    P...>
+tile_subview(const Kokkos::View<
+                 T***,
+                 Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                   N3, N4, N5, N6, N7, true>,
+                 P...>& src,
+             const size_t i_tile0, const size_t i_tile1, const size_t i_tile2) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true> SrcLayout ;
-
-  return Kokkos::View< T[N0][N1][N2] , array_layout , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 , i_tile2 );
+  typedef
+      typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                                Kokkos::LayoutLeft, Kokkos::LayoutRight>::type
+          array_layout;
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      SrcLayout;
+
+  return Kokkos::View<T[N0][N1][N2], array_layout, P...>(
+      src, SrcLayout(), i_tile0, i_tile1, i_tile2);
 }
 
 // Rank 4
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7 
-        , class ... P 
-        >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1][N2][N3] , typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type , P... >
-tile_subview( const Kokkos::View<T****, Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>, P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            , const size_t i_tile2
-            , const size_t i_tile3
-            )
-{
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<
+    T[N0][N1][N2][N3],
+    typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                              Kokkos::LayoutLeft, Kokkos::LayoutRight>::type,
+    P...>
+tile_subview(const Kokkos::View<
+                 T****,
+                 Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                   N3, N4, N5, N6, N7, true>,
+                 P...>& src,
+             const size_t i_tile0, const size_t i_tile1, const size_t i_tile2,
+             const size_t i_tile3) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true> SrcLayout ;
-
-  return Kokkos::View< T[N0][N1][N2][N3] , array_layout , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 , i_tile2 , i_tile3 );
+  typedef
+      typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                                Kokkos::LayoutLeft, Kokkos::LayoutRight>::type
+          array_layout;
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      SrcLayout;
+
+  return Kokkos::View<T[N0][N1][N2][N3], array_layout, P...>(
+      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3);
 }
 
 // Rank 5
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7 
-        , class ... P 
-        >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1][N2][N3][N4] , typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type , P... >
-tile_subview( const Kokkos::View<T*****, Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>, P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            , const size_t i_tile2
-            , const size_t i_tile3
-            , const size_t i_tile4
-            )
-{
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<
+    T[N0][N1][N2][N3][N4],
+    typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                              Kokkos::LayoutLeft, Kokkos::LayoutRight>::type,
+    P...>
+tile_subview(const Kokkos::View<
+                 T*****,
+                 Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                   N3, N4, N5, N6, N7, true>,
+                 P...>& src,
+             const size_t i_tile0, const size_t i_tile1, const size_t i_tile2,
+             const size_t i_tile3, const size_t i_tile4) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true> SrcLayout ;
-
-  return Kokkos::View< T[N0][N1][N2][N3][N4] , array_layout , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 , i_tile2 , i_tile3 , i_tile4 );
+  typedef
+      typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                                Kokkos::LayoutLeft, Kokkos::LayoutRight>::type
+          array_layout;
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      SrcLayout;
+
+  return Kokkos::View<T[N0][N1][N2][N3][N4], array_layout, P...>(
+      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4);
 }
 
 // Rank 6
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7 
-        , class ... P 
-        >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1][N2][N3][N4][N5] , typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type , P... >
-tile_subview( const Kokkos::View<T******, Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>, P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            , const size_t i_tile2
-            , const size_t i_tile3
-            , const size_t i_tile4
-            , const size_t i_tile5
-            )
-{
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<
+    T[N0][N1][N2][N3][N4][N5],
+    typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                              Kokkos::LayoutLeft, Kokkos::LayoutRight>::type,
+    P...>
+tile_subview(const Kokkos::View<
+                 T******,
+                 Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                   N3, N4, N5, N6, N7, true>,
+                 P...>& src,
+             const size_t i_tile0, const size_t i_tile1, const size_t i_tile2,
+             const size_t i_tile3, const size_t i_tile4, const size_t i_tile5) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true> SrcLayout ;
-
-  return Kokkos::View< T[N0][N1][N2][N3][N4][N5] , array_layout , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 , i_tile2 , i_tile3 , i_tile4 , i_tile5 );
+  typedef
+      typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                                Kokkos::LayoutLeft, Kokkos::LayoutRight>::type
+          array_layout;
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      SrcLayout;
+
+  return Kokkos::View<T[N0][N1][N2][N3][N4][N5], array_layout, P...>(
+      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4, i_tile5);
 }
 
 // Rank 7
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7 
-        , class ... P 
-        >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1][N2][N3][N4][N5][N6] , typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type , P... >
-tile_subview( const Kokkos::View<T*******, Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>, P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            , const size_t i_tile2
-            , const size_t i_tile3
-            , const size_t i_tile4
-            , const size_t i_tile5
-            , const size_t i_tile6
-            )
-{
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<
+    T[N0][N1][N2][N3][N4][N5][N6],
+    typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                              Kokkos::LayoutLeft, Kokkos::LayoutRight>::type,
+    P...>
+tile_subview(const Kokkos::View<
+                 T*******,
+                 Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                   N3, N4, N5, N6, N7, true>,
+                 P...>& src,
+             const size_t i_tile0, const size_t i_tile1, const size_t i_tile2,
+             const size_t i_tile3, const size_t i_tile4, const size_t i_tile5,
+             const size_t i_tile6) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true> SrcLayout ;
-
-  return Kokkos::View< T[N0][N1][N2][N3][N4][N5][N6] , array_layout , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 , i_tile2 , i_tile3 , i_tile4 , i_tile5 , i_tile6 );
+  typedef
+      typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                                Kokkos::LayoutLeft, Kokkos::LayoutRight>::type
+          array_layout;
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      SrcLayout;
+
+  return Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6], array_layout, P...>(
+      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4, i_tile5,
+      i_tile6);
 }
 
 // Rank 8
-template< typename T , Kokkos::Iterate OuterP , Kokkos::Iterate InnerP , unsigned N0 , unsigned N1 , unsigned N2 , unsigned N3 , unsigned N4 , unsigned N5 , unsigned N6 , unsigned N7 
-        , class ... P 
-        >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1][N2][N3][N4][N5][N6][N7] , typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type , P... >
-tile_subview( const Kokkos::View<T********, Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true>, P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            , const size_t i_tile2
-            , const size_t i_tile3
-            , const size_t i_tile4
-            , const size_t i_tile5
-            , const size_t i_tile6
-            , const size_t i_tile7
-            )
-{
+template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
+          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+          unsigned N5, unsigned N6, unsigned N7, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<
+    T[N0][N1][N2][N3][N4][N5][N6][N7],
+    typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                              Kokkos::LayoutLeft, Kokkos::LayoutRight>::type,
+    P...>
+tile_subview(const Kokkos::View<
+                 T********,
+                 Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
+                                                   N3, N4, N5, N6, N7, true>,
+                 P...>& src,
+             const size_t i_tile0, const size_t i_tile1, const size_t i_tile2,
+             const size_t i_tile3, const size_t i_tile4, const size_t i_tile5,
+             const size_t i_tile6, const size_t i_tile7) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef typename std::conditional< (InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft, Kokkos::LayoutRight >::type array_layout;
-  typedef Kokkos::Experimental::LayoutTiled<OuterP,InnerP,N0,N1,N2,N3,N4,N5,N6,N7,true> SrcLayout ;
-
-  return Kokkos::View< T[N0][N1][N2][N3][N4][N5][N6][N7] , array_layout , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 , i_tile2 , i_tile3 , i_tile4 , i_tile5 , i_tile6 , i_tile7 );
+  typedef
+      typename std::conditional<(InnerP == Kokkos::Iterate::Left),
+                                Kokkos::LayoutLeft, Kokkos::LayoutRight>::type
+          array_layout;
+  typedef Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
+                                            N5, N6, N7, true>
+      SrcLayout;
+
+  return Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6][N7], array_layout, P...>(
+      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4, i_tile5,
+      i_tile6, i_tile7);
 }
 
 } /* namespace Kokkos */
-#endif //!defined(KOKKOS_ENABLE_DEPRECATED_CODE
+#endif  //! defined(KOKKOS_ENABLE_DEPRECATED_CODE
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_EXPERIENTAL_VIEWLAYOUTTILE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewMapping.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewMapping.hpp
index b2d8dea20acc398f9e480116e1069e62e26d7d78..f6dfacb4d8b4e48baad75977b4d877ffacda8bc9 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewMapping.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewMapping.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -65,205 +66,240 @@
 namespace Kokkos {
 namespace Impl {
 
-template< unsigned I , size_t ... Args >
-struct variadic_size_t
-  { enum { value =KOKKOS_INVALID_INDEX }; };
+template <unsigned I, size_t... Args>
+struct variadic_size_t {
+  enum { value = KOKKOS_INVALID_INDEX };
+};
 
-template< size_t Val , size_t ... Args >
-struct variadic_size_t< 0 , Val , Args ... >
-  { enum { value = Val }; };
+template <size_t Val, size_t... Args>
+struct variadic_size_t<0, Val, Args...> {
+  enum { value = Val };
+};
 
-template< unsigned I , size_t Val , size_t ... Args >
-struct variadic_size_t< I , Val , Args ... >
-  { enum { value = variadic_size_t< I - 1 , Args ... >::value }; };
+template <unsigned I, size_t Val, size_t... Args>
+struct variadic_size_t<I, Val, Args...> {
+  enum { value = variadic_size_t<I - 1, Args...>::value };
+};
 
-template< size_t ... Args >
-struct rank_dynamic ;
+template <size_t... Args>
+struct rank_dynamic;
 
-template<>
-struct rank_dynamic<> { enum { value = 0 }; };
+template <>
+struct rank_dynamic<> {
+  enum { value = 0 };
+};
 
-template< size_t Val , size_t ... Args >
-struct rank_dynamic< Val , Args... >
-{
-  enum { value = ( Val == 0 ? 1 : 0 ) + rank_dynamic< Args... >::value };
+template <size_t Val, size_t... Args>
+struct rank_dynamic<Val, Args...> {
+  enum { value = (Val == 0 ? 1 : 0) + rank_dynamic<Args...>::value };
 };
 
-#define KOKKOS_IMPL_VIEW_DIMENSION( R ) \
-  template< size_t V , unsigned > struct ViewDimension ## R \
-    { \
-      enum { ArgN ## R = ( V !=KOKKOS_INVALID_INDEX ? V : 1 ) }; \
-      enum { N ## R = ( V !=KOKKOS_INVALID_INDEX ? V : 1 ) }; \
-      KOKKOS_INLINE_FUNCTION explicit ViewDimension ## R ( size_t ) {} \
-      ViewDimension ## R () = default ; \
-      ViewDimension ## R ( const ViewDimension ## R  & ) = default ; \
-      ViewDimension ## R & operator = ( const ViewDimension ## R  & ) = default ; \
-    }; \
-  template< unsigned RD > struct ViewDimension ## R < 0 , RD > \
-    { \
-      enum { ArgN ## R = 0 }; \
-      typename std::conditional<( RD < 3 ), size_t , unsigned >::type N ## R ; \
-      ViewDimension ## R () = default ; \
-      ViewDimension ## R ( const ViewDimension ## R  & ) = default ; \
-      ViewDimension ## R & operator = ( const ViewDimension ## R  & ) = default ; \
-      KOKKOS_INLINE_FUNCTION explicit ViewDimension ## R ( size_t V ) : N ## R ( V ) {} \
-    };
+#define KOKKOS_IMPL_VIEW_DIMENSION(R)                                       \
+  template <size_t V, unsigned>                                             \
+  struct ViewDimension##R {                                                 \
+    enum { ArgN##R = (V != KOKKOS_INVALID_INDEX ? V : 1) };                 \
+    enum { N##R = (V != KOKKOS_INVALID_INDEX ? V : 1) };                    \
+    KOKKOS_INLINE_FUNCTION explicit ViewDimension##R(size_t) {}             \
+    ViewDimension##R()                        = default;                    \
+    ViewDimension##R(const ViewDimension##R&) = default;                    \
+    ViewDimension##R& operator=(const ViewDimension##R&) = default;         \
+  };                                                                        \
+  template <unsigned RD>                                                    \
+  struct ViewDimension##R<0, RD> {                                          \
+    enum { ArgN##R = 0 };                                                   \
+    typename std::conditional<(RD < 3), size_t, unsigned>::type N##R;       \
+    ViewDimension##R()                        = default;                    \
+    ViewDimension##R(const ViewDimension##R&) = default;                    \
+    ViewDimension##R& operator=(const ViewDimension##R&) = default;         \
+    KOKKOS_INLINE_FUNCTION explicit ViewDimension##R(size_t V) : N##R(V) {} \
+  };
 
-KOKKOS_IMPL_VIEW_DIMENSION( 0 )
-KOKKOS_IMPL_VIEW_DIMENSION( 1 )
-KOKKOS_IMPL_VIEW_DIMENSION( 2 )
-KOKKOS_IMPL_VIEW_DIMENSION( 3 )
-KOKKOS_IMPL_VIEW_DIMENSION( 4 )
-KOKKOS_IMPL_VIEW_DIMENSION( 5 )
-KOKKOS_IMPL_VIEW_DIMENSION( 6 )
-KOKKOS_IMPL_VIEW_DIMENSION( 7 )
+KOKKOS_IMPL_VIEW_DIMENSION(0)
+KOKKOS_IMPL_VIEW_DIMENSION(1)
+KOKKOS_IMPL_VIEW_DIMENSION(2)
+KOKKOS_IMPL_VIEW_DIMENSION(3)
+KOKKOS_IMPL_VIEW_DIMENSION(4)
+KOKKOS_IMPL_VIEW_DIMENSION(5)
+KOKKOS_IMPL_VIEW_DIMENSION(6)
+KOKKOS_IMPL_VIEW_DIMENSION(7)
 
 #undef KOKKOS_IMPL_VIEW_DIMENSION
 
-template< size_t ... Vals >
-struct ViewDimension
-  : public ViewDimension0< variadic_size_t<0,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-  , public ViewDimension1< variadic_size_t<1,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-  , public ViewDimension2< variadic_size_t<2,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-  , public ViewDimension3< variadic_size_t<3,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-  , public ViewDimension4< variadic_size_t<4,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-  , public ViewDimension5< variadic_size_t<5,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-  , public ViewDimension6< variadic_size_t<6,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-  , public ViewDimension7< variadic_size_t<7,Vals...>::value
-                         , rank_dynamic< Vals... >::value >
-{
-  typedef ViewDimension0< variadic_size_t<0,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D0 ;
-  typedef ViewDimension1< variadic_size_t<1,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D1 ;
-  typedef ViewDimension2< variadic_size_t<2,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D2 ;
-  typedef ViewDimension3< variadic_size_t<3,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D3 ;
-  typedef ViewDimension4< variadic_size_t<4,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D4 ;
-  typedef ViewDimension5< variadic_size_t<5,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D5 ;
-  typedef ViewDimension6< variadic_size_t<6,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D6 ;
-  typedef ViewDimension7< variadic_size_t<7,Vals...>::value
-                        , rank_dynamic< Vals... >::value > D7 ;
-
-  using D0::ArgN0 ;
-  using D1::ArgN1 ;
-  using D2::ArgN2 ;
-  using D3::ArgN3 ;
-  using D4::ArgN4 ;
-  using D5::ArgN5 ;
-  using D6::ArgN6 ;
-  using D7::ArgN7 ;
-
-  using D0::N0 ;
-  using D1::N1 ;
-  using D2::N2 ;
-  using D3::N3 ;
-  using D4::N4 ;
-  using D5::N5 ;
-  using D6::N6 ;
-  using D7::N7 ;
+template <size_t... Vals>
+struct ViewDimension : public ViewDimension0<variadic_size_t<0, Vals...>::value,
+                                             rank_dynamic<Vals...>::value>,
+                       public ViewDimension1<variadic_size_t<1, Vals...>::value,
+                                             rank_dynamic<Vals...>::value>,
+                       public ViewDimension2<variadic_size_t<2, Vals...>::value,
+                                             rank_dynamic<Vals...>::value>,
+                       public ViewDimension3<variadic_size_t<3, Vals...>::value,
+                                             rank_dynamic<Vals...>::value>,
+                       public ViewDimension4<variadic_size_t<4, Vals...>::value,
+                                             rank_dynamic<Vals...>::value>,
+                       public ViewDimension5<variadic_size_t<5, Vals...>::value,
+                                             rank_dynamic<Vals...>::value>,
+                       public ViewDimension6<variadic_size_t<6, Vals...>::value,
+                                             rank_dynamic<Vals...>::value>,
+                       public ViewDimension7<variadic_size_t<7, Vals...>::value,
+                                             rank_dynamic<Vals...>::value> {
+  typedef ViewDimension0<variadic_size_t<0, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D0;
+  typedef ViewDimension1<variadic_size_t<1, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D1;
+  typedef ViewDimension2<variadic_size_t<2, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D2;
+  typedef ViewDimension3<variadic_size_t<3, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D3;
+  typedef ViewDimension4<variadic_size_t<4, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D4;
+  typedef ViewDimension5<variadic_size_t<5, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D5;
+  typedef ViewDimension6<variadic_size_t<6, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D6;
+  typedef ViewDimension7<variadic_size_t<7, Vals...>::value,
+                         rank_dynamic<Vals...>::value>
+      D7;
+
+  using D0::ArgN0;
+  using D1::ArgN1;
+  using D2::ArgN2;
+  using D3::ArgN3;
+  using D4::ArgN4;
+  using D5::ArgN5;
+  using D6::ArgN6;
+  using D7::ArgN7;
+
+  using D0::N0;
+  using D1::N1;
+  using D2::N2;
+  using D3::N3;
+  using D4::N4;
+  using D5::N5;
+  using D6::N6;
+  using D7::N7;
 
   enum { rank = sizeof...(Vals) };
-  enum { rank_dynamic = Impl::rank_dynamic< Vals... >::value };
-
-  ViewDimension() = default ;
-  ViewDimension( const ViewDimension & ) = default ;
-  ViewDimension & operator = ( const ViewDimension & ) = default ;
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr
-  ViewDimension( size_t n0 , size_t n1 , size_t n2 , size_t n3
-               , size_t n4 , size_t n5 , size_t n6 , size_t n7 )
-    : D0( n0 )
-    , D1( n1 )
-    , D2( n2 )
-    , D3( n3 )
-    , D4( n4 )
-    , D5( n5 )
-    , D6( n6 )
-    , D7( n7 )
-    {}
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr size_t extent( const unsigned r ) const noexcept
-    {
-      return r == 0 ? N0 : (
-             r == 1 ? N1 : (
-             r == 2 ? N2 : (
-             r == 3 ? N3 : (
-             r == 4 ? N4 : (
-             r == 5 ? N5 : (
-             r == 6 ? N6 : (
-             r == 7 ? N7 : 0 )))))));
-    }
+  enum { rank_dynamic = Impl::rank_dynamic<Vals...>::value };
+
+  ViewDimension()                     = default;
+  ViewDimension(const ViewDimension&) = default;
+  ViewDimension& operator=(const ViewDimension&) = default;
+
+  KOKKOS_INLINE_FUNCTION
+  constexpr ViewDimension(size_t n0, size_t n1, size_t n2, size_t n3, size_t n4,
+                          size_t n5, size_t n6, size_t n7)
+      : D0(n0), D1(n1), D2(n2), D3(n3), D4(n4), D5(n5), D6(n6), D7(n7) {}
+
+  KOKKOS_INLINE_FUNCTION
+  constexpr size_t extent(const unsigned r) const noexcept {
+    return r == 0
+               ? N0
+               : (r == 1
+                      ? N1
+                      : (r == 2
+                             ? N2
+                             : (r == 3
+                                    ? N3
+                                    : (r == 4
+                                           ? N4
+                                           : (r == 5
+                                                  ? N5
+                                                  : (r == 6
+                                                         ? N6
+                                                         : (r == 7 ? N7
+                                                                   : 0)))))));
+  }
 
-  static KOKKOS_INLINE_FUNCTION
-  constexpr size_t static_extent( const unsigned r ) noexcept
-    {
-      return r == 0 ? ArgN0 : (
-             r == 1 ? ArgN1 : (
-             r == 2 ? ArgN2 : (
-             r == 3 ? ArgN3 : (
-             r == 4 ? ArgN4 : (
-             r == 5 ? ArgN5 : (
-             r == 6 ? ArgN6 : (
-             r == 7 ? ArgN7 : 0 )))))));
-    }
+  static KOKKOS_INLINE_FUNCTION constexpr size_t static_extent(
+      const unsigned r) noexcept {
+    return r == 0
+               ? ArgN0
+               : (r == 1
+                      ? ArgN1
+                      : (r == 2
+                             ? ArgN2
+                             : (r == 3
+                                    ? ArgN3
+                                    : (r == 4
+                                           ? ArgN4
+                                           : (r == 5
+                                                  ? ArgN5
+                                                  : (r == 6
+                                                         ? ArgN6
+                                                         : (r == 7 ? ArgN7
+                                                                   : 0)))))));
+  }
 
-  template< size_t N >
-  struct prepend { typedef ViewDimension< N , Vals... > type ; };
+  template <size_t N>
+  struct prepend {
+    typedef ViewDimension<N, Vals...> type;
+  };
 
-  template< size_t N >
-  struct append { typedef ViewDimension< Vals... , N > type ; };
+  template <size_t N>
+  struct append {
+    typedef ViewDimension<Vals..., N> type;
+  };
 };
 
-template< class A , class B >
-struct ViewDimensionJoin ;
+template <class A, class B>
+struct ViewDimensionJoin;
 
-template< size_t ... A , size_t ... B >
-struct ViewDimensionJoin< ViewDimension< A... > , ViewDimension< B... > > {
-  typedef ViewDimension< A... , B... > type ;
+template <size_t... A, size_t... B>
+struct ViewDimensionJoin<ViewDimension<A...>, ViewDimension<B...> > {
+  typedef ViewDimension<A..., B...> type;
 };
 
 //----------------------------------------------------------------------------
 
-template< class DstDim , class SrcDim >
-struct ViewDimensionAssignable ;
-
-template< size_t ... DstArgs , size_t ... SrcArgs >
-struct ViewDimensionAssignable< ViewDimension< DstArgs ... >
-                              , ViewDimension< SrcArgs ... > >
-{
-  typedef ViewDimension< DstArgs... > dst ;
-  typedef ViewDimension< SrcArgs... > src ;
-
-  enum { value =
-    unsigned(dst::rank) == unsigned(src::rank) && (
-      //Compile time check that potential static dimensions match
-      ( ( 1 > dst::rank_dynamic && 1 > src::rank_dynamic ) ? (size_t(dst::ArgN0) == size_t(src::ArgN0)) : true ) &&
-      ( ( 2 > dst::rank_dynamic && 2 > src::rank_dynamic ) ? (size_t(dst::ArgN1) == size_t(src::ArgN1)) : true ) &&
-      ( ( 3 > dst::rank_dynamic && 3 > src::rank_dynamic ) ? (size_t(dst::ArgN2) == size_t(src::ArgN2)) : true ) &&
-      ( ( 4 > dst::rank_dynamic && 4 > src::rank_dynamic ) ? (size_t(dst::ArgN3) == size_t(src::ArgN3)) : true ) &&
-      ( ( 5 > dst::rank_dynamic && 5 > src::rank_dynamic ) ? (size_t(dst::ArgN4) == size_t(src::ArgN4)) : true ) &&
-      ( ( 6 > dst::rank_dynamic && 6 > src::rank_dynamic ) ? (size_t(dst::ArgN5) == size_t(src::ArgN5)) : true ) &&
-      ( ( 7 > dst::rank_dynamic && 7 > src::rank_dynamic ) ? (size_t(dst::ArgN6) == size_t(src::ArgN6)) : true ) &&
-      ( ( 8 > dst::rank_dynamic && 8 > src::rank_dynamic ) ? (size_t(dst::ArgN7) == size_t(src::ArgN7)) : true )
-    )};
-
+template <class DstDim, class SrcDim>
+struct ViewDimensionAssignable;
+
+template <size_t... DstArgs, size_t... SrcArgs>
+struct ViewDimensionAssignable<ViewDimension<DstArgs...>,
+                               ViewDimension<SrcArgs...> > {
+  typedef ViewDimension<DstArgs...> dst;
+  typedef ViewDimension<SrcArgs...> src;
+
+  enum {
+    value = unsigned(dst::rank) == unsigned(src::rank) &&
+            (
+                // Compile time check that potential static dimensions match
+                ((1 > dst::rank_dynamic && 1 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN0) == size_t(src::ArgN0))
+                     : true) &&
+                ((2 > dst::rank_dynamic && 2 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN1) == size_t(src::ArgN1))
+                     : true) &&
+                ((3 > dst::rank_dynamic && 3 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN2) == size_t(src::ArgN2))
+                     : true) &&
+                ((4 > dst::rank_dynamic && 4 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN3) == size_t(src::ArgN3))
+                     : true) &&
+                ((5 > dst::rank_dynamic && 5 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN4) == size_t(src::ArgN4))
+                     : true) &&
+                ((6 > dst::rank_dynamic && 6 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN5) == size_t(src::ArgN5))
+                     : true) &&
+                ((7 > dst::rank_dynamic && 7 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN6) == size_t(src::ArgN6))
+                     : true) &&
+                ((8 > dst::rank_dynamic && 8 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN7) == size_t(src::ArgN7))
+                     : true))
+  };
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -273,418 +309,411 @@ namespace Impl {
 
 struct ALL_t {
   KOKKOS_INLINE_FUNCTION
-  constexpr const ALL_t & operator()() const { return *this ; }
+  constexpr const ALL_t& operator()() const { return *this; }
 
   KOKKOS_INLINE_FUNCTION
-  constexpr bool operator == ( const ALL_t & ) const { return true;}
+  constexpr bool operator==(const ALL_t&) const { return true; }
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 namespace Kokkos {
 namespace Impl {
 
-template< class T >
-struct is_integral_extent_type
-{ enum { value = std::is_same<T,Kokkos::Impl::ALL_t>::value ? 1 : 0 }; };
+template <class T>
+struct is_integral_extent_type {
+  enum { value = std::is_same<T, Kokkos::Impl::ALL_t>::value ? 1 : 0 };
+};
 
-template< class iType >
-struct is_integral_extent_type< std::pair<iType,iType> >
-{ enum { value = std::is_integral<iType>::value ? 1 : 0 }; };
+template <class iType>
+struct is_integral_extent_type<std::pair<iType, iType> > {
+  enum { value = std::is_integral<iType>::value ? 1 : 0 };
+};
 
-template< class iType >
-struct is_integral_extent_type< Kokkos::pair<iType,iType> >
-{ enum { value = std::is_integral<iType>::value ? 1 : 0 }; };
+template <class iType>
+struct is_integral_extent_type<Kokkos::pair<iType, iType> > {
+  enum { value = std::is_integral<iType>::value ? 1 : 0 };
+};
 
 // Assuming '2 == initializer_list<iType>::size()'
-template< class iType >
-struct is_integral_extent_type< std::initializer_list<iType> >
-{ enum { value = std::is_integral<iType>::value ? 1 : 0 }; };
+template <class iType>
+struct is_integral_extent_type<std::initializer_list<iType> > {
+  enum { value = std::is_integral<iType>::value ? 1 : 0 };
+};
 
-template < unsigned I , class ... Args >
-struct is_integral_extent
-{
+template <unsigned I, class... Args>
+struct is_integral_extent {
   // get_type is void when sizeof...(Args) <= I
-  typedef typename std::remove_cv<
-          typename std::remove_reference<
-          typename Kokkos::Impl::get_type<I,Args...
-          >::type >::type >::type type ;
+  typedef typename std::remove_cv<typename std::remove_reference<
+      typename Kokkos::Impl::get_type<I, Args...>::type>::type>::type type;
 
   enum { value = is_integral_extent_type<type>::value };
 
-  static_assert( value ||
-                 std::is_integral<type>::value ||
-                 std::is_same<type,void>::value
-               , "subview argument must be either integral or integral extent" );
+  static_assert(value || std::is_integral<type>::value ||
+                    std::is_same<type, void>::value,
+                "subview argument must be either integral or integral extent");
 };
 
 // Rules for subview arguments and layouts matching
 
-template<class LayoutDest, class LayoutSrc, int RankDest, int RankSrc, int CurrentArg, class ... SubViewArgs>
+template <class LayoutDest, class LayoutSrc, int RankDest, int RankSrc,
+          int CurrentArg, class... SubViewArgs>
 struct SubviewLegalArgsCompileTime;
 
 // Rules which allow LayoutLeft to LayoutLeft assignment
 
-template<int RankDest, int RankSrc, int CurrentArg, class Arg, class ... SubViewArgs>
-struct SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft, RankDest, RankSrc, CurrentArg, Arg, SubViewArgs...> {
-  enum { value      =(((CurrentArg==RankDest-1) && (Kokkos::Impl::is_integral_extent_type<Arg>::value)) ||
-                      ((CurrentArg>=RankDest) && (std::is_integral<Arg>::value)) ||
-                      ((CurrentArg<RankDest) && (std::is_same<Arg,Kokkos::Impl::ALL_t>::value)) ||
-                      ((CurrentArg==0) && (Kokkos::Impl::is_integral_extent_type<Arg>::value))
-                     ) && (SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft, RankDest, RankSrc, CurrentArg+1, SubViewArgs...>::value)};
+template <int RankDest, int RankSrc, int CurrentArg, class Arg,
+          class... SubViewArgs>
+struct SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                   RankDest, RankSrc, CurrentArg, Arg,
+                                   SubViewArgs...> {
+  enum {
+    value = (((CurrentArg == RankDest - 1) &&
+              (Kokkos::Impl::is_integral_extent_type<Arg>::value)) ||
+             ((CurrentArg >= RankDest) && (std::is_integral<Arg>::value)) ||
+             ((CurrentArg < RankDest) &&
+              (std::is_same<Arg, Kokkos::Impl::ALL_t>::value)) ||
+             ((CurrentArg == 0) &&
+              (Kokkos::Impl::is_integral_extent_type<Arg>::value))) &&
+            (SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                         RankDest, RankSrc, CurrentArg + 1,
+                                         SubViewArgs...>::value)
+  };
 };
 
-template<int RankDest, int RankSrc, int CurrentArg, class Arg>
-struct SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft, RankDest, RankSrc, CurrentArg, Arg> {
-  enum { value = ((CurrentArg==RankDest-1) || (std::is_integral<Arg>::value)) &&
-                 (CurrentArg==RankSrc-1) };
+template <int RankDest, int RankSrc, int CurrentArg, class Arg>
+struct SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                   RankDest, RankSrc, CurrentArg, Arg> {
+  enum {
+    value = ((CurrentArg == RankDest - 1) || (std::is_integral<Arg>::value)) &&
+            (CurrentArg == RankSrc - 1)
+  };
 };
 
 // Rules which allow LayoutRight to LayoutRight assignment
 
-template<int RankDest, int RankSrc, int CurrentArg, class Arg, class ... SubViewArgs>
-struct SubviewLegalArgsCompileTime<Kokkos::LayoutRight, Kokkos::LayoutRight, RankDest, RankSrc, CurrentArg, Arg, SubViewArgs...> {
-  enum { value      =(((CurrentArg==RankSrc-RankDest) && (Kokkos::Impl::is_integral_extent_type<Arg>::value)) ||
-                      ((CurrentArg<RankSrc-RankDest) && (std::is_integral<Arg>::value)) ||
-                      ((CurrentArg>=RankSrc-RankDest) && (std::is_same<Arg,Kokkos::Impl::ALL_t>::value))
-                     ) && (SubviewLegalArgsCompileTime<Kokkos::LayoutRight, Kokkos::LayoutRight, RankDest, RankSrc, CurrentArg+1, SubViewArgs...>::value)};
+template <int RankDest, int RankSrc, int CurrentArg, class Arg,
+          class... SubViewArgs>
+struct SubviewLegalArgsCompileTime<Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                   RankDest, RankSrc, CurrentArg, Arg,
+                                   SubViewArgs...> {
+  enum {
+    value = (((CurrentArg == RankSrc - RankDest) &&
+              (Kokkos::Impl::is_integral_extent_type<Arg>::value)) ||
+             ((CurrentArg < RankSrc - RankDest) &&
+              (std::is_integral<Arg>::value)) ||
+             ((CurrentArg >= RankSrc - RankDest) &&
+              (std::is_same<Arg, Kokkos::Impl::ALL_t>::value))) &&
+            (SubviewLegalArgsCompileTime<Kokkos::LayoutRight,
+                                         Kokkos::LayoutRight, RankDest, RankSrc,
+                                         CurrentArg + 1, SubViewArgs...>::value)
+  };
 };
 
-template<int RankDest, int RankSrc, int CurrentArg, class Arg>
-struct SubviewLegalArgsCompileTime<Kokkos::LayoutRight, Kokkos::LayoutRight, RankDest, RankSrc, CurrentArg, Arg> {
-  enum { value = ((CurrentArg==RankSrc-1) && (std::is_same<Arg,Kokkos::Impl::ALL_t>::value)) };
+template <int RankDest, int RankSrc, int CurrentArg, class Arg>
+struct SubviewLegalArgsCompileTime<Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                   RankDest, RankSrc, CurrentArg, Arg> {
+  enum {
+    value = ((CurrentArg == RankSrc - 1) &&
+             (std::is_same<Arg, Kokkos::Impl::ALL_t>::value))
+  };
 };
 
 // Rules which allow assignment to LayoutStride
 
-template<int RankDest, int RankSrc, int CurrentArg, class ... SubViewArgs>
-struct SubviewLegalArgsCompileTime<Kokkos::LayoutStride,Kokkos::LayoutLeft,RankDest,RankSrc,CurrentArg,SubViewArgs...> {
+template <int RankDest, int RankSrc, int CurrentArg, class... SubViewArgs>
+struct SubviewLegalArgsCompileTime<Kokkos::LayoutStride, Kokkos::LayoutLeft,
+                                   RankDest, RankSrc, CurrentArg,
+                                   SubViewArgs...> {
   enum { value = true };
 };
 
-template<int RankDest, int RankSrc, int CurrentArg, class ... SubViewArgs>
-struct SubviewLegalArgsCompileTime<Kokkos::LayoutStride,Kokkos::LayoutRight,RankDest,RankSrc,CurrentArg,SubViewArgs...> {
+template <int RankDest, int RankSrc, int CurrentArg, class... SubViewArgs>
+struct SubviewLegalArgsCompileTime<Kokkos::LayoutStride, Kokkos::LayoutRight,
+                                   RankDest, RankSrc, CurrentArg,
+                                   SubViewArgs...> {
   enum { value = true };
 };
 
-template<int RankDest, int RankSrc, int CurrentArg, class ... SubViewArgs>
-struct SubviewLegalArgsCompileTime<Kokkos::LayoutStride,Kokkos::LayoutStride,RankDest,RankSrc,CurrentArg,SubViewArgs...> {
+template <int RankDest, int RankSrc, int CurrentArg, class... SubViewArgs>
+struct SubviewLegalArgsCompileTime<Kokkos::LayoutStride, Kokkos::LayoutStride,
+                                   RankDest, RankSrc, CurrentArg,
+                                   SubViewArgs...> {
   enum { value = true };
 };
 
-
-template< unsigned DomainRank , unsigned RangeRank >
+template <unsigned DomainRank, unsigned RangeRank>
 struct SubviewExtents {
-private:
-
+ private:
   // Cannot declare zero-length arrays
-  // '+' is used to silence GCC 7.2.0 -Wduplicated-branches warning when RangeRank=1
+  // '+' is used to silence GCC 7.2.0 -Wduplicated-branches warning when
+  // RangeRank=1
   enum { InternalRangeRank = RangeRank ? RangeRank : +1u };
 
-  size_t   m_begin[  DomainRank ];
-  size_t   m_length[ InternalRangeRank ];
-  unsigned m_index[  InternalRangeRank ];
+  size_t m_begin[DomainRank];
+  size_t m_length[InternalRangeRank];
+  unsigned m_index[InternalRangeRank];
 
-  template< size_t ... DimArgs >
-  KOKKOS_FORCEINLINE_FUNCTION
-  bool set( unsigned
-          , unsigned
-          , const ViewDimension< DimArgs ... > & )
-    { return true ; }
+  template <size_t... DimArgs>
+  KOKKOS_FORCEINLINE_FUNCTION bool set(unsigned, unsigned,
+                                       const ViewDimension<DimArgs...>&) {
+    return true;
+  }
 
-  template< class T , size_t ... DimArgs , class ... Args >
-  KOKKOS_FORCEINLINE_FUNCTION
-  bool set( unsigned domain_rank
-          , unsigned range_rank
-          , const ViewDimension< DimArgs ... > & dim
-          , const T & val
-          , Args ... args )
-    {
-      const size_t v = static_cast<size_t>(val);
-
-      m_begin[ domain_rank ] = v ;
-
-      return set( domain_rank + 1 , range_rank , dim , args... )
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-             && ( v < dim.extent( domain_rank ) )
+  template <class T, size_t... DimArgs, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION bool set(unsigned domain_rank,
+                                       unsigned range_rank,
+                                       const ViewDimension<DimArgs...>& dim,
+                                       const T& val, Args... args) {
+    const size_t v = static_cast<size_t>(val);
+
+    m_begin[domain_rank] = v;
+
+    return set(domain_rank + 1, range_rank, dim, args...)
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+           && (v < dim.extent(domain_rank))
 #endif
-      ;
-    }
+        ;
+  }
 
   // ALL_t
-  template< size_t ... DimArgs , class ... Args >
-  KOKKOS_FORCEINLINE_FUNCTION
-  bool set( unsigned domain_rank
-          , unsigned range_rank
-          , const ViewDimension< DimArgs ... > & dim
-          , const Kokkos::Impl::ALL_t
-          , Args ... args )
-    {
-      m_begin[  domain_rank ] = 0 ;
-      m_length[ range_rank  ] = dim.extent( domain_rank );
-      m_index[  range_rank  ] = domain_rank ;
-
-      return set( domain_rank + 1 , range_rank + 1 , dim , args... );
-    }
+  template <size_t... DimArgs, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION bool set(unsigned domain_rank,
+                                       unsigned range_rank,
+                                       const ViewDimension<DimArgs...>& dim,
+                                       const Kokkos::Impl::ALL_t,
+                                       Args... args) {
+    m_begin[domain_rank] = 0;
+    m_length[range_rank] = dim.extent(domain_rank);
+    m_index[range_rank]  = domain_rank;
+
+    return set(domain_rank + 1, range_rank + 1, dim, args...);
+  }
 
   // std::pair range
-  template< class T , size_t ... DimArgs , class ... Args >
-  KOKKOS_FORCEINLINE_FUNCTION
-  bool set( unsigned domain_rank
-          , unsigned range_rank
-          , const ViewDimension< DimArgs ... > & dim
-          , const std::pair<T,T> & val
-          , Args ... args )
-    {
-      const size_t b = static_cast<size_t>( val.first );
-      const size_t e = static_cast<size_t>( val.second );
-
-      m_begin[  domain_rank ] = b ;
-      m_length[ range_rank  ] = e - b ;
-      m_index[  range_rank  ] = domain_rank ;
-
-      return set( domain_rank + 1 , range_rank + 1 , dim , args... )
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-             && ( e <= b + dim.extent( domain_rank ) )
+  template <class T, size_t... DimArgs, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION bool set(unsigned domain_rank,
+                                       unsigned range_rank,
+                                       const ViewDimension<DimArgs...>& dim,
+                                       const std::pair<T, T>& val,
+                                       Args... args) {
+    const size_t b = static_cast<size_t>(val.first);
+    const size_t e = static_cast<size_t>(val.second);
+
+    m_begin[domain_rank] = b;
+    m_length[range_rank] = e - b;
+    m_index[range_rank]  = domain_rank;
+
+    return set(domain_rank + 1, range_rank + 1, dim, args...)
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+           && (e <= b + dim.extent(domain_rank))
 #endif
-      ;
-    }
+        ;
+  }
 
   // Kokkos::pair range
-  template< class T , size_t ... DimArgs , class ... Args >
-  KOKKOS_FORCEINLINE_FUNCTION
-  bool set( unsigned domain_rank
-          , unsigned range_rank
-          , const ViewDimension< DimArgs ... > & dim
-          , const Kokkos::pair<T,T> & val
-          , Args ... args )
-    {
-      const size_t b = static_cast<size_t>( val.first );
-      const size_t e = static_cast<size_t>( val.second );
-
-      m_begin[  domain_rank ] = b ;
-      m_length[ range_rank  ] = e - b ;
-      m_index[  range_rank  ] = domain_rank ;
-
-      return set( domain_rank + 1 , range_rank + 1 , dim , args... )
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-             && ( e <= b + dim.extent( domain_rank ) )
+  template <class T, size_t... DimArgs, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION bool set(unsigned domain_rank,
+                                       unsigned range_rank,
+                                       const ViewDimension<DimArgs...>& dim,
+                                       const Kokkos::pair<T, T>& val,
+                                       Args... args) {
+    const size_t b = static_cast<size_t>(val.first);
+    const size_t e = static_cast<size_t>(val.second);
+
+    m_begin[domain_rank] = b;
+    m_length[range_rank] = e - b;
+    m_index[range_rank]  = domain_rank;
+
+    return set(domain_rank + 1, range_rank + 1, dim, args...)
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+           && (e <= b + dim.extent(domain_rank))
 #endif
-      ;
-    }
+        ;
+  }
 
   // { begin , end } range
-  template< class T , size_t ... DimArgs , class ... Args >
-  KOKKOS_FORCEINLINE_FUNCTION
-  bool set( unsigned domain_rank
-          , unsigned range_rank
-          , const ViewDimension< DimArgs ... > & dim
-          , const std::initializer_list< T > & val
-          , Args ... args )
-    {
-      const size_t b = static_cast<size_t>( val.begin()[0] );
-      const size_t e = static_cast<size_t>( val.begin()[1] );
-
-      m_begin[  domain_rank ] = b ;
-      m_length[ range_rank  ] = e - b ;
-      m_index[  range_rank  ] = domain_rank ;
-
-      return set( domain_rank + 1 , range_rank + 1 , dim , args... )
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-             && ( val.size() == 2 )
-             && ( e <= b + dim.extent( domain_rank ) )
+  template <class T, size_t... DimArgs, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION bool set(unsigned domain_rank,
+                                       unsigned range_rank,
+                                       const ViewDimension<DimArgs...>& dim,
+                                       const std::initializer_list<T>& val,
+                                       Args... args) {
+    const size_t b = static_cast<size_t>(val.begin()[0]);
+    const size_t e = static_cast<size_t>(val.begin()[1]);
+
+    m_begin[domain_rank] = b;
+    m_length[range_rank] = e - b;
+    m_index[range_rank]  = domain_rank;
+
+    return set(domain_rank + 1, range_rank + 1, dim, args...)
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+           && (val.size() == 2) && (e <= b + dim.extent(domain_rank))
 #endif
-      ;
-    }
+        ;
+  }
 
   //------------------------------
 
-#if defined( KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK )
-
-  template< size_t ... DimArgs >
-  void error( char *
-            , int
-            , unsigned
-            , unsigned
-            , const ViewDimension< DimArgs ... > & ) const
-    {}
-
-  template< class T , size_t ... DimArgs , class ... Args >
-  void error( char * buf , int buf_len
-            , unsigned domain_rank
-            , unsigned range_rank
-            , const ViewDimension< DimArgs ... > & dim
-            , const T & val
-            , Args ... args ) const
-    {
-      const int n = std::min( buf_len ,
-        snprintf( buf , buf_len
-                , " %lu < %lu %c"
-                , static_cast<unsigned long>(val)
-                , static_cast<unsigned long>( dim.extent( domain_rank ) )
-                , int( sizeof...(Args) ? ',' : ')' ) ) );
-
-      error( buf+n, buf_len-n, domain_rank + 1 , range_rank , dim , args... );
-    }
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+
+  template <size_t... DimArgs>
+  void error(char*, int, unsigned, unsigned,
+             const ViewDimension<DimArgs...>&) const {}
+
+  template <class T, size_t... DimArgs, class... Args>
+  void error(char* buf, int buf_len, unsigned domain_rank, unsigned range_rank,
+             const ViewDimension<DimArgs...>& dim, const T& val,
+             Args... args) const {
+    const int n = std::min(
+        buf_len,
+        snprintf(buf, buf_len, " %lu < %lu %c", static_cast<unsigned long>(val),
+                 static_cast<unsigned long>(dim.extent(domain_rank)),
+                 int(sizeof...(Args) ? ',' : ')')));
+
+    error(buf + n, buf_len - n, domain_rank + 1, range_rank, dim, args...);
+  }
 
   // std::pair range
-  template< size_t ... DimArgs , class ... Args >
-  void error( char * buf , int buf_len
-            , unsigned domain_rank
-            , unsigned range_rank
-            , const ViewDimension< DimArgs ... > & dim
-            , const Kokkos::Impl::ALL_t
-            , Args ... args ) const
-    {
-      const int n = std::min( buf_len ,
-        snprintf( buf , buf_len
-                , " Kokkos::ALL %c"
-                , int( sizeof...(Args) ? ',' : ')' ) ) );
-
-      error( buf+n , buf_len-n , domain_rank + 1 , range_rank + 1 , dim , args... );
-    }
+  template <size_t... DimArgs, class... Args>
+  void error(char* buf, int buf_len, unsigned domain_rank, unsigned range_rank,
+             const ViewDimension<DimArgs...>& dim, const Kokkos::Impl::ALL_t,
+             Args... args) const {
+    const int n = std::min(buf_len, snprintf(buf, buf_len, " Kokkos::ALL %c",
+                                             int(sizeof...(Args) ? ',' : ')')));
+
+    error(buf + n, buf_len - n, domain_rank + 1, range_rank + 1, dim, args...);
+  }
 
   // std::pair range
-  template< class T , size_t ... DimArgs , class ... Args >
-  void error( char * buf , int buf_len
-            , unsigned domain_rank
-            , unsigned range_rank
-            , const ViewDimension< DimArgs ... > & dim
-            , const std::pair<T,T> & val
-            , Args ... args ) const
-    {
-      // d <= e - b
-      const int n = std::min( buf_len ,
-        snprintf( buf , buf_len
-                , " %lu <= %lu - %lu %c"
-                , static_cast<unsigned long>( dim.extent( domain_rank ) )
-                , static_cast<unsigned long>( val.second )
-                , static_cast<unsigned long>( val.first )
-                , int( sizeof...(Args) ? ',' : ')' ) ) );
-
-      error( buf+n , buf_len-n , domain_rank + 1 , range_rank + 1 , dim , args... );
-    }
+  template <class T, size_t... DimArgs, class... Args>
+  void error(char* buf, int buf_len, unsigned domain_rank, unsigned range_rank,
+             const ViewDimension<DimArgs...>& dim, const std::pair<T, T>& val,
+             Args... args) const {
+    // d <= e - b
+    const int n = std::min(
+        buf_len, snprintf(buf, buf_len, " %lu <= %lu - %lu %c",
+                          static_cast<unsigned long>(dim.extent(domain_rank)),
+                          static_cast<unsigned long>(val.second),
+                          static_cast<unsigned long>(val.first),
+                          int(sizeof...(Args) ? ',' : ')')));
+
+    error(buf + n, buf_len - n, domain_rank + 1, range_rank + 1, dim, args...);
+  }
 
   // Kokkos::pair range
-  template< class T , size_t ... DimArgs , class ... Args >
-  void error( char * buf , int buf_len
-            , unsigned domain_rank
-            , unsigned range_rank
-            , const ViewDimension< DimArgs ... > & dim
-            , const Kokkos::pair<T,T> & val
-            , Args ... args ) const
-    {
-      // d <= e - b
-      const int n = std::min( buf_len ,
-        snprintf( buf , buf_len
-                , " %lu <= %lu - %lu %c"
-                , static_cast<unsigned long>( dim.extent( domain_rank ) )
-                , static_cast<unsigned long>( val.second )
-                , static_cast<unsigned long>( val.first )
-                , int( sizeof...(Args) ? ',' : ')' ) ) );
-
-      error( buf+n , buf_len-n , domain_rank + 1 , range_rank + 1 , dim , args... );
-    }
+  template <class T, size_t... DimArgs, class... Args>
+  void error(char* buf, int buf_len, unsigned domain_rank, unsigned range_rank,
+             const ViewDimension<DimArgs...>& dim,
+             const Kokkos::pair<T, T>& val, Args... args) const {
+    // d <= e - b
+    const int n = std::min(
+        buf_len, snprintf(buf, buf_len, " %lu <= %lu - %lu %c",
+                          static_cast<unsigned long>(dim.extent(domain_rank)),
+                          static_cast<unsigned long>(val.second),
+                          static_cast<unsigned long>(val.first),
+                          int(sizeof...(Args) ? ',' : ')')));
+
+    error(buf + n, buf_len - n, domain_rank + 1, range_rank + 1, dim, args...);
+  }
 
   // { begin , end } range
-  template< class T , size_t ... DimArgs , class ... Args >
-  void error( char * buf , int buf_len
-            , unsigned domain_rank
-            , unsigned range_rank
-            , const ViewDimension< DimArgs ... > & dim
-            , const std::initializer_list< T > & val
-            , Args ... args ) const
-    {
-      // d <= e - b
-      int n = 0 ;
-      if ( val.size() == 2 ) {
-        n = std::min( buf_len ,
-          snprintf( buf , buf_len
-                  , " %lu <= %lu - %lu %c"
-                  , static_cast<unsigned long>( dim.extent( domain_rank ) )
-                  , static_cast<unsigned long>( val.begin()[0] )
-                  , static_cast<unsigned long>( val.begin()[1] )
-                  , int( sizeof...(Args) ? ',' : ')' ) ) );
-      }
-      else {
-        n = std::min( buf_len ,
-          snprintf( buf , buf_len
-                  , " { ... }.size() == %u %c"
-                  , unsigned(val.size())
-                  , int( sizeof...(Args) ? ',' : ')' ) ) );
-      }
-
-      error( buf+n , buf_len-n , domain_rank + 1 , range_rank + 1 , dim , args... );
+  template <class T, size_t... DimArgs, class... Args>
+  void error(char* buf, int buf_len, unsigned domain_rank, unsigned range_rank,
+             const ViewDimension<DimArgs...>& dim,
+             const std::initializer_list<T>& val, Args... args) const {
+    // d <= e - b
+    int n = 0;
+    if (val.size() == 2) {
+      n = std::min(buf_len,
+                   snprintf(buf, buf_len, " %lu <= %lu - %lu %c",
+                            static_cast<unsigned long>(dim.extent(domain_rank)),
+                            static_cast<unsigned long>(val.begin()[0]),
+                            static_cast<unsigned long>(val.begin()[1]),
+                            int(sizeof...(Args) ? ',' : ')')));
+    } else {
+      n = std::min(buf_len, snprintf(buf, buf_len, " { ... }.size() == %u %c",
+                                     unsigned(val.size()),
+                                     int(sizeof...(Args) ? ',' : ')')));
     }
 
-  template< size_t ... DimArgs , class ... Args >
-  KOKKOS_FORCEINLINE_FUNCTION
-  void error( const ViewDimension< DimArgs ... > & dim , Args ... args ) const
-    {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-      enum { LEN = 1024 };
-      char buffer[ LEN ];
+    error(buf + n, buf_len - n, domain_rank + 1, range_rank + 1, dim, args...);
+  }
+
+  template <size_t... DimArgs, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION void error(const ViewDimension<DimArgs...>& dim,
+                                         Args... args) const {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+    enum { LEN = 1024 };
+    char buffer[LEN];
 
-      const int n = snprintf(buffer,LEN,"Kokkos::subview bounds error (");
-      error( buffer+n , LEN-n , 0 , 0 , dim , args... );
+    const int n = snprintf(buffer, LEN, "Kokkos::subview bounds error (");
+    error(buffer + n, LEN - n, 0, 0, dim, args...);
 
-      Kokkos::Impl::throw_runtime_exception(std::string(buffer));
+    Kokkos::Impl::throw_runtime_exception(std::string(buffer));
 #else
-      Kokkos::abort("Kokkos::subview bounds error");
+    Kokkos::abort("Kokkos::subview bounds error");
 #endif
-    }
+  }
 
 #else
 
-  template< size_t ... DimArgs , class ... Args >
-  KOKKOS_FORCEINLINE_FUNCTION
-  void error( const ViewDimension< DimArgs ... > & , Args ... ) const {}
+  template <size_t... DimArgs, class... Args>
+  KOKKOS_FORCEINLINE_FUNCTION void error(const ViewDimension<DimArgs...>&,
+                                         Args...) const {}
 
 #endif
 
-public:
-
-  template< size_t ... DimArgs , class ... Args >
-  KOKKOS_INLINE_FUNCTION
-  SubviewExtents( const ViewDimension< DimArgs ... > & dim , Args ... args )
-    {
-      static_assert( DomainRank == sizeof...(DimArgs) , "" );
-      static_assert( DomainRank == sizeof...(Args) , "" );
-
-      // Verifies that all arguments, up to 8, are integral types,
-      // integral extents, or don't exist.
-      static_assert( RangeRank ==
-        unsigned( is_integral_extent<0,Args...>::value ) +
-        unsigned( is_integral_extent<1,Args...>::value ) +
-        unsigned( is_integral_extent<2,Args...>::value ) +
-        unsigned( is_integral_extent<3,Args...>::value ) +
-        unsigned( is_integral_extent<4,Args...>::value ) +
-        unsigned( is_integral_extent<5,Args...>::value ) +
-        unsigned( is_integral_extent<6,Args...>::value ) +
-        unsigned( is_integral_extent<7,Args...>::value ) , "" );
-
-      if ( RangeRank == 0 ) { m_length[0] = 0 ; m_index[0] = ~0u ; }
-
-      if ( ! set( 0 , 0 , dim , args... ) ) error( dim , args... );
+ public:
+  template <size_t... DimArgs, class... Args>
+  KOKKOS_INLINE_FUNCTION SubviewExtents(const ViewDimension<DimArgs...>& dim,
+                                        Args... args) {
+    static_assert(DomainRank == sizeof...(DimArgs), "");
+    static_assert(DomainRank == sizeof...(Args), "");
+
+    // Verifies that all arguments, up to 8, are integral types,
+    // integral extents, or don't exist.
+    static_assert(
+        RangeRank == unsigned(is_integral_extent<0, Args...>::value) +
+                         unsigned(is_integral_extent<1, Args...>::value) +
+                         unsigned(is_integral_extent<2, Args...>::value) +
+                         unsigned(is_integral_extent<3, Args...>::value) +
+                         unsigned(is_integral_extent<4, Args...>::value) +
+                         unsigned(is_integral_extent<5, Args...>::value) +
+                         unsigned(is_integral_extent<6, Args...>::value) +
+                         unsigned(is_integral_extent<7, Args...>::value),
+        "");
+
+    if (RangeRank == 0) {
+      m_length[0] = 0;
+      m_index[0]  = ~0u;
     }
 
-  template < typename iType >
-  KOKKOS_FORCEINLINE_FUNCTION
-  constexpr size_t domain_offset( const iType i ) const
-    { return unsigned(i) < DomainRank ? m_begin[i] : 0 ; }
+    if (!set(0, 0, dim, args...)) error(dim, args...);
+  }
 
-  template < typename iType >
-  KOKKOS_FORCEINLINE_FUNCTION
-  constexpr size_t range_extent( const iType i ) const
-    { return unsigned(i) < InternalRangeRank ? m_length[i] : 0 ; }
+  template <typename iType>
+  KOKKOS_FORCEINLINE_FUNCTION constexpr size_t domain_offset(
+      const iType i) const {
+    return unsigned(i) < DomainRank ? m_begin[i] : 0;
+  }
 
-  template < typename iType >
-  KOKKOS_FORCEINLINE_FUNCTION
-  constexpr unsigned range_index( const iType i ) const
-    { return unsigned(i) < InternalRangeRank ? m_index[i] : ~0u ; }
+  template <typename iType>
+  KOKKOS_FORCEINLINE_FUNCTION constexpr size_t range_extent(
+      const iType i) const {
+    return unsigned(i) < InternalRangeRank ? m_length[i] : 0;
+  }
+
+  template <typename iType>
+  KOKKOS_FORCEINLINE_FUNCTION constexpr unsigned range_index(
+      const iType i) const {
+    return unsigned(i) < InternalRangeRank ? m_index[i] : ~0u;
+  }
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -693,25 +722,22 @@ namespace Kokkos {
 namespace Impl {
 
 /** \brief  Given a value type and dimension generate the View data type */
-template< class T , class Dim >
-struct ViewDataType ;
+template <class T, class Dim>
+struct ViewDataType;
 
-template< class T >
-struct ViewDataType< T , ViewDimension<> >
-{
-  typedef T type ;
+template <class T>
+struct ViewDataType<T, ViewDimension<> > {
+  typedef T type;
 };
 
-template< class T , size_t ... Args >
-struct ViewDataType< T , ViewDimension< 0 , Args... > >
-{
-  typedef typename ViewDataType<T*,ViewDimension<Args...> >::type type ;
+template <class T, size_t... Args>
+struct ViewDataType<T, ViewDimension<0, Args...> > {
+  typedef typename ViewDataType<T*, ViewDimension<Args...> >::type type;
 };
 
-template< class T , size_t N , size_t ... Args >
-struct ViewDataType< T , ViewDimension< N , Args... > >
-{
-  typedef typename ViewDataType<T,ViewDimension<Args...> >::type type[N] ;
+template <class T, size_t N, size_t... Args>
+struct ViewDataType<T, ViewDimension<N, Args...> > {
+  typedef typename ViewDataType<T, ViewDimension<Args...> >::type type[N];
 };
 
 /**\brief  Analysis of View data type.
@@ -723,111 +749,108 @@ struct ViewDataType< T , ViewDimension< N , Args... > >
  *
  *  Provide typedef for the ViewDimension<...> and value_type.
  */
-template< class T >
-struct ViewArrayAnalysis
-{
-  typedef T                                      value_type ;
-  typedef typename std::add_const<    T >::type  const_value_type ;
-  typedef typename std::remove_const< T >::type  non_const_value_type ;
-  typedef ViewDimension<>                        static_dimension ;
-  typedef ViewDimension<>                        dynamic_dimension ;
-  typedef ViewDimension<>                        dimension ;
+template <class T>
+struct ViewArrayAnalysis {
+  typedef T value_type;
+  typedef typename std::add_const<T>::type const_value_type;
+  typedef typename std::remove_const<T>::type non_const_value_type;
+  typedef ViewDimension<> static_dimension;
+  typedef ViewDimension<> dynamic_dimension;
+  typedef ViewDimension<> dimension;
 };
 
-template< class T , size_t N >
-struct ViewArrayAnalysis< T[N] >
-{
-private:
-  typedef ViewArrayAnalysis< T > nested ;
-public:
-  typedef typename nested::value_type            value_type ;
-  typedef typename nested::const_value_type      const_value_type ;
-  typedef typename nested::non_const_value_type  non_const_value_type ;
+template <class T, size_t N>
+struct ViewArrayAnalysis<T[N]> {
+ private:
+  typedef ViewArrayAnalysis<T> nested;
+
+ public:
+  typedef typename nested::value_type value_type;
+  typedef typename nested::const_value_type const_value_type;
+  typedef typename nested::non_const_value_type non_const_value_type;
 
   typedef typename nested::static_dimension::template prepend<N>::type
-    static_dimension ;
+      static_dimension;
 
-  typedef typename nested::dynamic_dimension dynamic_dimension ;
+  typedef typename nested::dynamic_dimension dynamic_dimension;
 
-  typedef typename
-    ViewDimensionJoin< dynamic_dimension , static_dimension >::type
-      dimension ;
+  typedef typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type
+      dimension;
 };
 
-template< class T >
-struct ViewArrayAnalysis< T[] >
-{
-private:
-  typedef ViewArrayAnalysis< T > nested ;
-  typedef typename nested::dimension nested_dimension ;
-public:
-  typedef typename nested::value_type            value_type ;
-  typedef typename nested::const_value_type      const_value_type ;
-  typedef typename nested::non_const_value_type  non_const_value_type ;
+template <class T>
+struct ViewArrayAnalysis<T[]> {
+ private:
+  typedef ViewArrayAnalysis<T> nested;
+  typedef typename nested::dimension nested_dimension;
+
+ public:
+  typedef typename nested::value_type value_type;
+  typedef typename nested::const_value_type const_value_type;
+  typedef typename nested::non_const_value_type non_const_value_type;
 
   typedef typename nested::dynamic_dimension::template prepend<0>::type
-    dynamic_dimension ;
+      dynamic_dimension;
 
-  typedef typename nested::static_dimension static_dimension ;
+  typedef typename nested::static_dimension static_dimension;
 
-  typedef typename
-    ViewDimensionJoin< dynamic_dimension , static_dimension >::type
-      dimension ;
+  typedef typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type
+      dimension;
 };
 
-template< class T >
-struct ViewArrayAnalysis< T* >
-{
-private:
-  typedef ViewArrayAnalysis< T > nested ;
-public:
-  typedef typename nested::value_type            value_type ;
-  typedef typename nested::const_value_type      const_value_type ;
-  typedef typename nested::non_const_value_type  non_const_value_type ;
+template <class T>
+struct ViewArrayAnalysis<T*> {
+ private:
+  typedef ViewArrayAnalysis<T> nested;
+
+ public:
+  typedef typename nested::value_type value_type;
+  typedef typename nested::const_value_type const_value_type;
+  typedef typename nested::non_const_value_type non_const_value_type;
 
   typedef typename nested::dynamic_dimension::template prepend<0>::type
-    dynamic_dimension ;
+      dynamic_dimension;
 
-  typedef typename nested::static_dimension static_dimension ;
+  typedef typename nested::static_dimension static_dimension;
 
-  typedef typename
-    ViewDimensionJoin< dynamic_dimension , static_dimension >::type
-      dimension ;
+  typedef typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type
+      dimension;
 };
 
-
-template< class DataType , class ArrayLayout , class ValueType >
-struct ViewDataAnalysis
-{
-private:
-
-  typedef ViewArrayAnalysis< DataType > array_analysis ;
+template <class DataType, class ArrayLayout, class ValueType>
+struct ViewDataAnalysis {
+ private:
+  typedef ViewArrayAnalysis<DataType> array_analysis;
 
   // ValueType is opportunity for partial specialization.
   // Must match array analysis when this default template is used.
-  static_assert( std::is_same< ValueType , typename array_analysis::non_const_value_type >::value , "" );
-
-public:
+  static_assert(
+      std::is_same<ValueType,
+                   typename array_analysis::non_const_value_type>::value,
+      "");
 
-  typedef void specialize ; // No specialization
+ public:
+  typedef void specialize;  // No specialization
 
-  typedef typename array_analysis::dimension             dimension ;
-  typedef typename array_analysis::value_type            value_type ;
-  typedef typename array_analysis::const_value_type      const_value_type ;
-  typedef typename array_analysis::non_const_value_type  non_const_value_type ;
+  typedef typename array_analysis::dimension dimension;
+  typedef typename array_analysis::value_type value_type;
+  typedef typename array_analysis::const_value_type const_value_type;
+  typedef typename array_analysis::non_const_value_type non_const_value_type;
 
   // Generate analogous multidimensional array specification type.
-  typedef typename ViewDataType<           value_type , dimension >::type  type ;
-  typedef typename ViewDataType<     const_value_type , dimension >::type  const_type ;
-  typedef typename ViewDataType< non_const_value_type , dimension >::type  non_const_type ;
+  typedef typename ViewDataType<value_type, dimension>::type type;
+  typedef typename ViewDataType<const_value_type, dimension>::type const_type;
+  typedef typename ViewDataType<non_const_value_type, dimension>::type
+      non_const_type;
 
   // Generate "flattened" multidimensional array specification type.
-  typedef type            scalar_array_type ;
-  typedef const_type      const_scalar_array_type ;
-  typedef non_const_type  non_const_scalar_array_type ;
+  typedef type scalar_array_type;
+  typedef const_type const_scalar_array_type;
+  typedef non_const_type non_const_scalar_array_type;
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -835,467 +858,568 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template < class Dimension , class Layout , typename Enable = void >
+template <class Dimension, class Layout, typename Enable = void>
 struct ViewOffset {
-  using is_mapping_plugin = std::false_type ;
+  using is_mapping_plugin = std::false_type;
 };
 
 //----------------------------------------------------------------------------
 // LayoutLeft AND ( 1 >= rank OR 0 == rank_dynamic ) : no padding / striding
-template < class Dimension >
-struct ViewOffset< Dimension , Kokkos::LayoutLeft
-                 , typename std::enable_if<( 1 >= Dimension::rank
-                                             ||
-                                             0 == Dimension::rank_dynamic
-                                           )>::type >
-{
-  using is_mapping_plugin = std::true_type ;
-  using is_regular        = std::true_type ;
-
-  typedef size_t             size_type ;
-  typedef Dimension          dimension_type ;
-  typedef Kokkos::LayoutLeft array_layout ;
-
-  dimension_type m_dim ;
+template <class Dimension>
+struct ViewOffset<
+    Dimension, Kokkos::LayoutLeft,
+    typename std::enable_if<(1 >= Dimension::rank ||
+                             0 == Dimension::rank_dynamic)>::type> {
+  using is_mapping_plugin = std::true_type;
+  using is_regular        = std::true_type;
+
+  typedef size_t size_type;
+  typedef Dimension dimension_type;
+  typedef Kokkos::LayoutLeft array_layout;
+
+  dimension_type m_dim;
 
   //----------------------------------------
 
   // rank 1
-  template< typename I0 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 ) const { return i0 ; }
+  template <typename I0>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0) const {
+    return i0;
+  }
 
   // rank 2
-  template < typename I0 , typename I1 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 , I1 const & i1 ) const
-    { return i0 + m_dim.N0 * i1 ; }
-
-  //rank 3
-  template < typename I0, typename I1, typename I2 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2 ) const
-  {
-    return i0 + m_dim.N0 * ( i1 + m_dim.N1 * i2 );
+  template <typename I0, typename I1>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1) const {
+    return i0 + m_dim.N0 * i1;
   }
 
-  //rank 4
-  template < typename I0, typename I1, typename I2, typename I3 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3 ) const
-  {
-    return i0 + m_dim.N0 * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * i3 ));
+  // rank 3
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2) const {
+    return i0 + m_dim.N0 * (i1 + m_dim.N1 * i2);
   }
 
-  //rank 5
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4 ) const
-  {
-    return i0 + m_dim.N0 * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * i4 )));
-  }
-
-  //rank 6
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5 ) const
-  {
-    return i0 + m_dim.N0 * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * (
-           i4 + m_dim.N4 * i5 ))));
-  }
-
-  //rank 7
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6 ) const
-  {
-    return i0 + m_dim.N0 * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * (
-           i4 + m_dim.N4 * (
-           i5 + m_dim.N5 * i6 )))));
-  }
-
-  //rank 8
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6, typename I7 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6, I7 const & i7 ) const
-  {
-    return i0 + m_dim.N0 * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * (
-           i4 + m_dim.N4 * (
-           i5 + m_dim.N5 * (
-           i6 + m_dim.N6 * i7 ))))));
+  // rank 4
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3) const {
+    return i0 + m_dim.N0 * (i1 + m_dim.N1 * (i2 + m_dim.N2 * i3));
+  }
+
+  // rank 5
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3,
+                                                        I4 const& i4) const {
+    return i0 +
+           m_dim.N0 * (i1 + m_dim.N1 * (i2 + m_dim.N2 * (i3 + m_dim.N3 * i4)));
+  }
+
+  // rank 6
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5) const {
+    return i0 +
+           m_dim.N0 *
+               (i1 +
+                m_dim.N1 *
+                    (i2 + m_dim.N2 * (i3 + m_dim.N3 * (i4 + m_dim.N4 * i5))));
+  }
+
+  // rank 7
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6) const {
+    return i0 +
+           m_dim.N0 *
+               (i1 + m_dim.N1 *
+                         (i2 + m_dim.N2 *
+                                   (i3 + m_dim.N3 *
+                                             (i4 + m_dim.N4 *
+                                                       (i5 + m_dim.N5 * i6)))));
+  }
+
+  // rank 8
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6, I7 const& i7) const {
+    return i0 +
+           m_dim.N0 *
+               (i1 +
+                m_dim.N1 *
+                    (i2 + m_dim.N2 *
+                              (i3 + m_dim.N3 *
+                                        (i4 + m_dim.N4 *
+                                                  (i5 + m_dim.N5 *
+                                                            (i6 + m_dim.N6 *
+                                                                      i7))))));
   }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  constexpr array_layout layout() const
-    {
-      return array_layout( m_dim.N0 , m_dim.N1 , m_dim.N2 , m_dim.N3
-                         , m_dim.N4 , m_dim.N5 , m_dim.N6 , m_dim.N7 );
-    }
+  constexpr array_layout layout() const {
+    return array_layout(m_dim.N0, m_dim.N1, m_dim.N2, m_dim.N3, m_dim.N4,
+                        m_dim.N5, m_dim.N6, m_dim.N7);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const { return m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return m_dim.N7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
+    return m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const {
+    return m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const {
+    return m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const {
+    return m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const {
+    return m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const {
+    return m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const {
+    return m_dim.N7;
+  }
 
   /* Cardinality of the domain index space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type size() const
-    { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  constexpr size_type size() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
   /* Span of the range space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type span() const
-    { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  constexpr size_type span() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const { return true ; }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return true;
+  }
 
   /* Strides of dimensions */
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return m_dim.N0 * m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return m_dim.N0 * m_dim.N1 * m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const {
+    return m_dim.N0 * m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6;
+  }
 
   // Stride with [ rank ] value is the total length
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void stride( iType * const s ) const
-    {
-      s[0] = 1 ;
-      if ( 0 < dimension_type::rank ) { s[1] = m_dim.N0 ; }
-      if ( 1 < dimension_type::rank ) { s[2] = s[1] * m_dim.N1 ; }
-      if ( 2 < dimension_type::rank ) { s[3] = s[2] * m_dim.N2 ; }
-      if ( 3 < dimension_type::rank ) { s[4] = s[3] * m_dim.N3 ; }
-      if ( 4 < dimension_type::rank ) { s[5] = s[4] * m_dim.N4 ; }
-      if ( 5 < dimension_type::rank ) { s[6] = s[5] * m_dim.N5 ; }
-      if ( 6 < dimension_type::rank ) { s[7] = s[6] * m_dim.N6 ; }
-      if ( 7 < dimension_type::rank ) { s[8] = s[7] * m_dim.N7 ; }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[0] = 1;
+    if (0 < dimension_type::rank) {
+      s[1] = m_dim.N0;
+    }
+    if (1 < dimension_type::rank) {
+      s[2] = s[1] * m_dim.N1;
+    }
+    if (2 < dimension_type::rank) {
+      s[3] = s[2] * m_dim.N2;
+    }
+    if (3 < dimension_type::rank) {
+      s[4] = s[3] * m_dim.N3;
+    }
+    if (4 < dimension_type::rank) {
+      s[5] = s[4] * m_dim.N4;
+    }
+    if (5 < dimension_type::rank) {
+      s[6] = s[5] * m_dim.N5;
+    }
+    if (6 < dimension_type::rank) {
+      s[7] = s[6] * m_dim.N6;
     }
+    if (7 < dimension_type::rank) {
+      s[8] = s[7] * m_dim.N7;
+    }
+  }
 
   //----------------------------------------
 
-  ViewOffset() = default ;
-  ViewOffset( const ViewOffset & ) = default ;
-  ViewOffset & operator = ( const ViewOffset & ) = default ;
-
-  template< unsigned TrivialScalarSize >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( std::integral_constant<unsigned,TrivialScalarSize> const &
-    , Kokkos::LayoutLeft const & arg_layout
-    )
-    : m_dim( arg_layout.dimension[0], 0, 0, 0, 0, 0, 0, 0 )
-    {}
-
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutLeft , void > & rhs )
-    : m_dim( rhs.m_dim.N0 , rhs.m_dim.N1 , rhs.m_dim.N2 , rhs.m_dim.N3
-           , rhs.m_dim.N4 , rhs.m_dim.N5 , rhs.m_dim.N6 , rhs.m_dim.N7 )
-    {
-      static_assert( int(DimRHS::rank) == int(dimension_type::rank) , "ViewOffset assignment requires equal rank" );
-      // Also requires equal static dimensions ...
-    }
+  ViewOffset()                  = default;
+  ViewOffset(const ViewOffset&) = default;
+  ViewOffset& operator=(const ViewOffset&) = default;
+
+  template <unsigned TrivialScalarSize>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      std::integral_constant<unsigned, TrivialScalarSize> const&,
+      Kokkos::LayoutLeft const& arg_layout)
+      : m_dim(arg_layout.dimension[0], 0, 0, 0, 0, 0, 0, 0) {}
+
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutLeft, void>& rhs)
+      : m_dim(rhs.m_dim.N0, rhs.m_dim.N1, rhs.m_dim.N2, rhs.m_dim.N3,
+              rhs.m_dim.N4, rhs.m_dim.N5, rhs.m_dim.N6, rhs.m_dim.N7) {
+    static_assert(int(DimRHS::rank) == int(dimension_type::rank),
+                  "ViewOffset assignment requires equal rank");
+    // Also requires equal static dimensions ...
+  }
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutRight , void > & rhs )
-    : m_dim( rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0 )
-    {
-      static_assert(
-        ( DimRHS::rank == 0 &&
-          dimension_type::rank == 0 ) ||
-        ( DimRHS::rank == 1 &&
-          dimension_type::rank == 1 &&
-          dimension_type::rank_dynamic == 1 )
-        , "ViewOffset LayoutLeft and LayoutRight are only compatible when rank <= 1" );
-    }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutRight, void>& rhs)
+      : m_dim(rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0) {
+    static_assert((DimRHS::rank == 0 && dimension_type::rank == 0) ||
+                      (DimRHS::rank == 1 && dimension_type::rank == 1 &&
+                       dimension_type::rank_dynamic == 1),
+                  "ViewOffset LayoutLeft and LayoutRight are only compatible "
+                  "when rank <= 1");
+  }
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutStride , void > & rhs )
-    : m_dim( rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0 )
-    {
-      if ( rhs.m_stride.S0 != 1 ) {
-        Kokkos::abort("Kokkos::Impl::ViewOffset assignment of LayoutLeft from LayoutStride  requires stride == 1" );
-      }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutStride, void>& rhs)
+      : m_dim(rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0) {
+    if (rhs.m_stride.S0 != 1) {
+      Kokkos::abort(
+          "Kokkos::Impl::ViewOffset assignment of LayoutLeft from LayoutStride "
+          " requires stride == 1");
     }
+  }
 
   //----------------------------------------
   // Subview construction
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset(
-    const ViewOffset< DimRHS , Kokkos::LayoutLeft , void > & ,
-    const SubviewExtents< DimRHS::rank , dimension_type::rank > & sub )
-    : m_dim( sub.range_extent(0), 0, 0, 0, 0, 0, 0, 0 )
-    {
-      static_assert( ( 0 == dimension_type::rank ) ||
-                     ( 1 == dimension_type::rank && 1 == dimension_type::rank_dynamic && 1 <= DimRHS::rank )
-                   , "ViewOffset subview construction requires compatible rank" );
-    }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutLeft, void>&,
+      const SubviewExtents<DimRHS::rank, dimension_type::rank>& sub)
+      : m_dim(sub.range_extent(0), 0, 0, 0, 0, 0, 0, 0) {
+    static_assert((0 == dimension_type::rank_dynamic) ||
+                      (1 == dimension_type::rank &&
+                       1 == dimension_type::rank_dynamic && 1 <= DimRHS::rank),
+                  "ViewOffset subview construction requires compatible rank");
+  }
 };
 
 //----------------------------------------------------------------------------
 // LayoutLeft AND ( 1 < rank AND 0 < rank_dynamic ) : has padding / striding
-template < class Dimension >
-struct ViewOffset< Dimension , Kokkos::LayoutLeft
-                 , typename std::enable_if<( 1 < Dimension::rank
-                                             &&
-                                             0 < Dimension::rank_dynamic
-                                           )>::type >
-{
-  using is_mapping_plugin = std::true_type ;
-  using is_regular        = std::true_type ;
-
-  typedef size_t             size_type ;
-  typedef Dimension          dimension_type ;
-  typedef Kokkos::LayoutLeft array_layout ;
-
-  dimension_type m_dim ;
-  size_type      m_stride ;
+template <class Dimension>
+struct ViewOffset<
+    Dimension, Kokkos::LayoutLeft,
+    typename std::enable_if<(1 < Dimension::rank &&
+                             0 < Dimension::rank_dynamic)>::type> {
+  using is_mapping_plugin = std::true_type;
+  using is_regular        = std::true_type;
+
+  typedef size_t size_type;
+  typedef Dimension dimension_type;
+  typedef Kokkos::LayoutLeft array_layout;
+
+  dimension_type m_dim;
+  size_type m_stride;
 
   //----------------------------------------
 
   // rank 1
-  template< typename I0 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 ) const { return i0 ; }
+  template <typename I0>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0) const {
+    return i0;
+  }
 
   // rank 2
-  template < typename I0 , typename I1 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 , I1 const & i1 ) const
-    { return i0 + m_stride * i1 ; }
-
-  //rank 3
-  template < typename I0, typename I1, typename I2 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2 ) const
-  {
-    return i0 + m_stride * ( i1 + m_dim.N1 * i2 );
+  template <typename I0, typename I1>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1) const {
+    return i0 + m_stride * i1;
   }
 
-  //rank 4
-  template < typename I0, typename I1, typename I2, typename I3 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3 ) const
-  {
-    return i0 + m_stride * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * i3 ));
+  // rank 3
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2) const {
+    return i0 + m_stride * (i1 + m_dim.N1 * i2);
   }
 
-  //rank 5
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4 ) const
-  {
-    return i0 + m_stride * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * i4 )));
-  }
-
-  //rank 6
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5 ) const
-  {
-    return i0 + m_stride * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * (
-           i4 + m_dim.N4 * i5 ))));
-  }
-
-  //rank 7
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6 ) const
-  {
-    return i0 + m_stride * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * (
-           i4 + m_dim.N4 * (
-           i5 + m_dim.N5 * i6 )))));
-  }
-
-  //rank 8
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6, typename I7 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6, I7 const & i7 ) const
-  {
-    return i0 + m_stride * (
-           i1 + m_dim.N1 * (
-           i2 + m_dim.N2 * (
-           i3 + m_dim.N3 * (
-           i4 + m_dim.N4 * (
-           i5 + m_dim.N5 * (
-           i6 + m_dim.N6 * i7 ))))));
+  // rank 4
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3) const {
+    return i0 + m_stride * (i1 + m_dim.N1 * (i2 + m_dim.N2 * i3));
+  }
+
+  // rank 5
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3,
+                                                        I4 const& i4) const {
+    return i0 +
+           m_stride * (i1 + m_dim.N1 * (i2 + m_dim.N2 * (i3 + m_dim.N3 * i4)));
+  }
+
+  // rank 6
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5) const {
+    return i0 +
+           m_stride *
+               (i1 +
+                m_dim.N1 *
+                    (i2 + m_dim.N2 * (i3 + m_dim.N3 * (i4 + m_dim.N4 * i5))));
+  }
+
+  // rank 7
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6) const {
+    return i0 +
+           m_stride *
+               (i1 + m_dim.N1 *
+                         (i2 + m_dim.N2 *
+                                   (i3 + m_dim.N3 *
+                                             (i4 + m_dim.N4 *
+                                                       (i5 + m_dim.N5 * i6)))));
+  }
+
+  // rank 8
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6, I7 const& i7) const {
+    return i0 +
+           m_stride *
+               (i1 +
+                m_dim.N1 *
+                    (i2 + m_dim.N2 *
+                              (i3 + m_dim.N3 *
+                                        (i4 + m_dim.N4 *
+                                                  (i5 + m_dim.N5 *
+                                                            (i6 + m_dim.N6 *
+                                                                      i7))))));
   }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  constexpr array_layout layout() const
-    {
-      return array_layout( m_dim.N0 , m_dim.N1 , m_dim.N2 , m_dim.N3
-                         , m_dim.N4 , m_dim.N5 , m_dim.N6 , m_dim.N7 );
-    }
+  constexpr array_layout layout() const {
+    return array_layout(m_dim.N0, m_dim.N1, m_dim.N2, m_dim.N3, m_dim.N4,
+                        m_dim.N5, m_dim.N6, m_dim.N7);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const { return m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return m_dim.N7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
+    return m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const {
+    return m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const {
+    return m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const {
+    return m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const {
+    return m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const {
+    return m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const {
+    return m_dim.N7;
+  }
 
   /* Cardinality of the domain index space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type size() const
-    { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  constexpr size_type size() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
   /* Span of the range space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type span() const
-    { return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  constexpr size_type span() const {
+    return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const { return m_stride == m_dim.N0 ; }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return m_stride == m_dim.N0;
+  }
 
   /* Strides of dimensions */
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return m_stride ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return m_stride * m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return m_stride * m_dim.N1 * m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const {
+    return m_stride;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const {
+    return m_stride * m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const {
+    return m_stride * m_dim.N1 * m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const {
+    return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const {
+    return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const {
+    return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const {
+    return m_stride * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6;
+  }
 
   // Stride with [ rank ] value is the total length
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void stride( iType * const s ) const
-    {
-      s[0] = 1 ;
-      if ( 0 < dimension_type::rank ) { s[1] = m_stride ; }
-      if ( 1 < dimension_type::rank ) { s[2] = s[1] * m_dim.N1 ; }
-      if ( 2 < dimension_type::rank ) { s[3] = s[2] * m_dim.N2 ; }
-      if ( 3 < dimension_type::rank ) { s[4] = s[3] * m_dim.N3 ; }
-      if ( 4 < dimension_type::rank ) { s[5] = s[4] * m_dim.N4 ; }
-      if ( 5 < dimension_type::rank ) { s[6] = s[5] * m_dim.N5 ; }
-      if ( 6 < dimension_type::rank ) { s[7] = s[6] * m_dim.N6 ; }
-      if ( 7 < dimension_type::rank ) { s[8] = s[7] * m_dim.N7 ; }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[0] = 1;
+    if (0 < dimension_type::rank) {
+      s[1] = m_stride;
+    }
+    if (1 < dimension_type::rank) {
+      s[2] = s[1] * m_dim.N1;
     }
+    if (2 < dimension_type::rank) {
+      s[3] = s[2] * m_dim.N2;
+    }
+    if (3 < dimension_type::rank) {
+      s[4] = s[3] * m_dim.N3;
+    }
+    if (4 < dimension_type::rank) {
+      s[5] = s[4] * m_dim.N4;
+    }
+    if (5 < dimension_type::rank) {
+      s[6] = s[5] * m_dim.N5;
+    }
+    if (6 < dimension_type::rank) {
+      s[7] = s[6] * m_dim.N6;
+    }
+    if (7 < dimension_type::rank) {
+      s[8] = s[7] * m_dim.N7;
+    }
+  }
 
   //----------------------------------------
 
-private:
-
-  template< unsigned TrivialScalarSize >
+ private:
+  template <unsigned TrivialScalarSize>
   struct Padding {
-    enum { div = TrivialScalarSize == 0 ? 0 : Kokkos::Impl::MEMORY_ALIGNMENT / ( TrivialScalarSize ? TrivialScalarSize : 1 ) };
-    enum { mod = TrivialScalarSize == 0 ? 0 : Kokkos::Impl::MEMORY_ALIGNMENT % ( TrivialScalarSize ? TrivialScalarSize : 1 ) };
+    enum {
+      div = TrivialScalarSize == 0
+                ? 0
+                : Kokkos::Impl::MEMORY_ALIGNMENT /
+                      (TrivialScalarSize ? TrivialScalarSize : 1)
+    };
+    enum {
+      mod = TrivialScalarSize == 0
+                ? 0
+                : Kokkos::Impl::MEMORY_ALIGNMENT %
+                      (TrivialScalarSize ? TrivialScalarSize : 1)
+    };
 
-    // If memory alignment is a multiple of the trivial scalar size then attempt to align.
+    // If memory alignment is a multiple of the trivial scalar size then attempt
+    // to align.
     enum { align = 0 != TrivialScalarSize && 0 == mod ? div : 0 };
-    enum { div_ok = (div != 0) ? div : 1 }; // To valid modulo zero in constexpr
+    enum {
+      div_ok = (div != 0) ? div : 1
+    };  // To valid modulo zero in constexpr
 
     KOKKOS_INLINE_FUNCTION
-    static constexpr size_t stride( size_t const N )
-    {
-      return ( (align != 0) && ((Kokkos::Impl::MEMORY_ALIGNMENT_THRESHOLD * align) < N) && ((N % div_ok) != 0) )
-             ? N + align - ( N % div_ok ) : N ;
+    static constexpr size_t stride(size_t const N) {
+      return ((align != 0) &&
+              ((Kokkos::Impl::MEMORY_ALIGNMENT_THRESHOLD * align) < N) &&
+              ((N % div_ok) != 0))
+                 ? N + align - (N % div_ok)
+                 : N;
     }
   };
 
-public:
+ public:
+  ViewOffset()                  = default;
+  ViewOffset(const ViewOffset&) = default;
+  ViewOffset& operator=(const ViewOffset&) = default;
 
-  ViewOffset() = default ;
-  ViewOffset( const ViewOffset & ) = default ;
-  ViewOffset & operator = ( const ViewOffset & ) = default ;
-
-  /* Enable padding for trivial scalar types with non-zero trivial scalar size */
-  template< unsigned TrivialScalarSize >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( std::integral_constant<unsigned,TrivialScalarSize> const &
-    , Kokkos::LayoutLeft const & arg_layout
-    )
-    : m_dim( arg_layout.dimension[0] , arg_layout.dimension[1]
-           , arg_layout.dimension[2] , arg_layout.dimension[3]
-           , arg_layout.dimension[4] , arg_layout.dimension[5]
-           , arg_layout.dimension[6] , arg_layout.dimension[7]
-           )
-    , m_stride( Padding<TrivialScalarSize>::stride( arg_layout.dimension[0] ) )
-    {}
-
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutLeft , void > & rhs )
-    : m_dim( rhs.m_dim.N0 , rhs.m_dim.N1 , rhs.m_dim.N2 , rhs.m_dim.N3
-           , rhs.m_dim.N4 , rhs.m_dim.N5 , rhs.m_dim.N6 , rhs.m_dim.N7 )
-    , m_stride( rhs.stride_1() )
-    {
-      static_assert( int(DimRHS::rank) == int(dimension_type::rank) , "ViewOffset assignment requires equal rank" );
-      // Also requires equal static dimensions ...
-    }
+  /* Enable padding for trivial scalar types with non-zero trivial scalar size
+   */
+  template <unsigned TrivialScalarSize>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      std::integral_constant<unsigned, TrivialScalarSize> const&,
+      Kokkos::LayoutLeft const& arg_layout)
+      : m_dim(arg_layout.dimension[0], arg_layout.dimension[1],
+              arg_layout.dimension[2], arg_layout.dimension[3],
+              arg_layout.dimension[4], arg_layout.dimension[5],
+              arg_layout.dimension[6], arg_layout.dimension[7]),
+        m_stride(Padding<TrivialScalarSize>::stride(arg_layout.dimension[0])) {}
+
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutLeft, void>& rhs)
+      : m_dim(rhs.m_dim.N0, rhs.m_dim.N1, rhs.m_dim.N2, rhs.m_dim.N3,
+              rhs.m_dim.N4, rhs.m_dim.N5, rhs.m_dim.N6, rhs.m_dim.N7),
+        m_stride(rhs.stride_1()) {
+    static_assert(int(DimRHS::rank) == int(dimension_type::rank),
+                  "ViewOffset assignment requires equal rank");
+    // Also requires equal static dimensions ...
+  }
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutStride , void > & rhs )
-    : m_dim( rhs.m_dim.N0 , rhs.m_dim.N1 , rhs.m_dim.N2 , rhs.m_dim.N3
-           , rhs.m_dim.N4 , rhs.m_dim.N5 , rhs.m_dim.N6 , rhs.m_dim.N7 )
-    , m_stride( rhs.stride_1() )
-    {
-      if ( rhs.m_stride.S0 != 1 ) {
-        Kokkos::abort("Kokkos::Impl::ViewOffset assignment of LayoutLeft from LayoutStride requires stride == 1" );
-      }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutStride, void>& rhs)
+      : m_dim(rhs.m_dim.N0, rhs.m_dim.N1, rhs.m_dim.N2, rhs.m_dim.N3,
+              rhs.m_dim.N4, rhs.m_dim.N5, rhs.m_dim.N6, rhs.m_dim.N7),
+        m_stride(rhs.stride_1()) {
+    if (rhs.m_stride.S0 != 1) {
+      Kokkos::abort(
+          "Kokkos::Impl::ViewOffset assignment of LayoutLeft from LayoutStride "
+          "requires stride == 1");
     }
+  }
 
   //----------------------------------------
   // Subview construction
@@ -1304,973 +1428,1116 @@ public:
   // The source dimension #0 must be non-zero for stride-one leading dimension.
   // At most subsequent dimension can be non-zero.
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( const ViewOffset< DimRHS , Kokkos::LayoutLeft , void > & rhs ,
-      const SubviewExtents< DimRHS::rank , dimension_type::rank > & sub )
-    : m_dim( sub.range_extent(0)
-           , sub.range_extent(1)
-           , sub.range_extent(2)
-           , sub.range_extent(3)
-           , sub.range_extent(4)
-           , sub.range_extent(5)
-           , sub.range_extent(6)
-           , sub.range_extent(7))
-    , m_stride( ( 1 == sub.range_index(1) ? rhs.stride_1() :
-                ( 2 == sub.range_index(1) ? rhs.stride_2() :
-                ( 3 == sub.range_index(1) ? rhs.stride_3() :
-                ( 4 == sub.range_index(1) ? rhs.stride_4() :
-                ( 5 == sub.range_index(1) ? rhs.stride_5() :
-                ( 6 == sub.range_index(1) ? rhs.stride_6() :
-                ( 7 == sub.range_index(1) ? rhs.stride_7() : 0 ))))))))
-    {
-      //static_assert( ( 2 == dimension_type::rank ) &&
-      //               ( 2 == dimension_type::rank_dynamic ) &&
-      //               ( 2 <= DimRHS::rank )
-      //             , "ViewOffset subview construction requires compatible rank" );
-    }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutLeft, void>& rhs,
+      const SubviewExtents<DimRHS::rank, dimension_type::rank>& sub)
+      : m_dim(sub.range_extent(0), sub.range_extent(1), sub.range_extent(2),
+              sub.range_extent(3), sub.range_extent(4), sub.range_extent(5),
+              sub.range_extent(6), sub.range_extent(7)),
+        m_stride(
+            (1 == sub.range_index(1)
+                 ? rhs.stride_1()
+                 : (2 == sub.range_index(1)
+                        ? rhs.stride_2()
+                        : (3 == sub.range_index(1)
+                               ? rhs.stride_3()
+                               : (4 == sub.range_index(1)
+                                      ? rhs.stride_4()
+                                      : (5 == sub.range_index(1)
+                                             ? rhs.stride_5()
+                                             : (6 == sub.range_index(1)
+                                                    ? rhs.stride_6()
+                                                    : (7 == sub.range_index(1)
+                                                           ? rhs.stride_7()
+                                                           : 0)))))))) {
+    // static_assert( ( 2 == dimension_type::rank ) &&
+    //               ( 2 == dimension_type::rank_dynamic ) &&
+    //               ( 2 <= DimRHS::rank )
+    //             , "ViewOffset subview construction requires compatible rank"
+    //             );
+  }
 };
 
 //----------------------------------------------------------------------------
 // LayoutRight AND ( 1 >= rank OR 0 == rank_dynamic ) : no padding / striding
-template < class Dimension >
-struct ViewOffset< Dimension , Kokkos::LayoutRight
-                 , typename std::enable_if<( 1 >= Dimension::rank
-                                             ||
-                                             0 == Dimension::rank_dynamic
-                                           )>::type >
-{
-  using is_mapping_plugin = std::true_type ;
-  using is_regular        = std::true_type ;
-
-  typedef size_t              size_type ;
-  typedef Dimension           dimension_type ;
-  typedef Kokkos::LayoutRight array_layout ;
-
-  dimension_type m_dim ;
+template <class Dimension>
+struct ViewOffset<
+    Dimension, Kokkos::LayoutRight,
+    typename std::enable_if<(1 >= Dimension::rank ||
+                             0 == Dimension::rank_dynamic)>::type> {
+  using is_mapping_plugin = std::true_type;
+  using is_regular        = std::true_type;
+
+  typedef size_t size_type;
+  typedef Dimension dimension_type;
+  typedef Kokkos::LayoutRight array_layout;
+
+  dimension_type m_dim;
 
   //----------------------------------------
 
   // rank 1
-  template< typename I0 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 ) const { return i0 ; }
+  template <typename I0>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0) const {
+    return i0;
+  }
 
   // rank 2
-  template < typename I0 , typename I1 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 , I1 const & i1 ) const
-    { return i1 + m_dim.N1 * i0 ; }
-
-  //rank 3
-  template < typename I0, typename I1, typename I2 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2 ) const
-  {
-    return i2 + m_dim.N2 * ( i1 + m_dim.N1 * ( i0 ));
+  template <typename I0, typename I1>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1) const {
+    return i1 + m_dim.N1 * i0;
   }
 
-  //rank 4
-  template < typename I0, typename I1, typename I2, typename I3 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3 ) const
-  {
-    return i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * (
-           i1 + m_dim.N1 * ( i0 )));
+  // rank 3
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2) const {
+    return i2 + m_dim.N2 * (i1 + m_dim.N1 * (i0));
   }
 
-  //rank 5
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4 ) const
-  {
-    return i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * (
-           i1 + m_dim.N1 * ( i0 ))));
-  }
-
-  //rank 6
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5 ) const
-  {
-    return i5 + m_dim.N5 * (
-           i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * (
-           i1 + m_dim.N1 * ( i0 )))));
-  }
-
-  //rank 7
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6 ) const
-  {
-    return i6 + m_dim.N6 * (
-           i5 + m_dim.N5 * (
-           i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * (
-           i1 + m_dim.N1 * ( i0 ))))));
-  }
-
-  //rank 8
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6, typename I7 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6, I7 const & i7 ) const
-  {
-    return i7 + m_dim.N7 * (
-           i6 + m_dim.N6 * (
-           i5 + m_dim.N5 * (
-           i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * (
-           i1 + m_dim.N1 * ( i0 )))))));
+  // rank 4
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3) const {
+    return i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1 + m_dim.N1 * (i0)));
+  }
+
+  // rank 5
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3,
+                                                        I4 const& i4) const {
+    return i4 + m_dim.N4 *
+                    (i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1 + m_dim.N1 * (i0))));
+  }
+
+  // rank 6
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5) const {
+    return i5 +
+           m_dim.N5 *
+               (i4 +
+                m_dim.N4 *
+                    (i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1 + m_dim.N1 * (i0)))));
+  }
+
+  // rank 7
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6) const {
+    return i6 +
+           m_dim.N6 *
+               (i5 +
+                m_dim.N5 *
+                    (i4 +
+                     m_dim.N4 *
+                         (i3 + m_dim.N3 *
+                                   (i2 + m_dim.N2 * (i1 + m_dim.N1 * (i0))))));
+  }
+
+  // rank 8
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6, I7 const& i7) const {
+    return i7 +
+           m_dim.N7 *
+               (i6 +
+                m_dim.N6 *
+                    (i5 +
+                     m_dim.N5 *
+                         (i4 +
+                          m_dim.N4 *
+                              (i3 +
+                               m_dim.N3 *
+                                   (i2 + m_dim.N2 * (i1 + m_dim.N1 * (i0)))))));
   }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  constexpr array_layout layout() const
-    {
-      return array_layout( m_dim.N0 , m_dim.N1 , m_dim.N2 , m_dim.N3
-                         , m_dim.N4 , m_dim.N5 , m_dim.N6 , m_dim.N7 );
-    }
+  constexpr array_layout layout() const {
+    return array_layout(m_dim.N0, m_dim.N1, m_dim.N2, m_dim.N3, m_dim.N4,
+                        m_dim.N5, m_dim.N6, m_dim.N7);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const { return m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return m_dim.N7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
+    return m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const {
+    return m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const {
+    return m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const {
+    return m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const {
+    return m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const {
+    return m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const {
+    return m_dim.N7;
+  }
 
   /* Cardinality of the domain index space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type size() const
-    { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  constexpr size_type size() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
   /* Span of the range space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type span() const
-    { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  constexpr size_type span() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const { return true ; }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return true;
+  }
 
   /* Strides of dimensions */
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return m_dim.N7 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return m_dim.N7 * m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 * m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 * m_dim.N2 * m_dim.N1 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const {
+    return m_dim.N7;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const {
+    return m_dim.N7 * m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 * m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 * m_dim.N2 *
+           m_dim.N1;
+  }
 
   // Stride with [ rank ] value is the total length
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void stride( iType * const s ) const
-    {
-      size_type n = 1 ;
-      if ( 7 < dimension_type::rank ) { s[7] = n ; n *= m_dim.N7 ; }
-      if ( 6 < dimension_type::rank ) { s[6] = n ; n *= m_dim.N6 ; }
-      if ( 5 < dimension_type::rank ) { s[5] = n ; n *= m_dim.N5 ; }
-      if ( 4 < dimension_type::rank ) { s[4] = n ; n *= m_dim.N4 ; }
-      if ( 3 < dimension_type::rank ) { s[3] = n ; n *= m_dim.N3 ; }
-      if ( 2 < dimension_type::rank ) { s[2] = n ; n *= m_dim.N2 ; }
-      if ( 1 < dimension_type::rank ) { s[1] = n ; n *= m_dim.N1 ; }
-      if ( 0 < dimension_type::rank ) { s[0] = n ; }
-      s[dimension_type::rank] = n * m_dim.N0 ;
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    size_type n = 1;
+    if (7 < dimension_type::rank) {
+      s[7] = n;
+      n *= m_dim.N7;
+    }
+    if (6 < dimension_type::rank) {
+      s[6] = n;
+      n *= m_dim.N6;
+    }
+    if (5 < dimension_type::rank) {
+      s[5] = n;
+      n *= m_dim.N5;
+    }
+    if (4 < dimension_type::rank) {
+      s[4] = n;
+      n *= m_dim.N4;
+    }
+    if (3 < dimension_type::rank) {
+      s[3] = n;
+      n *= m_dim.N3;
+    }
+    if (2 < dimension_type::rank) {
+      s[2] = n;
+      n *= m_dim.N2;
     }
+    if (1 < dimension_type::rank) {
+      s[1] = n;
+      n *= m_dim.N1;
+    }
+    if (0 < dimension_type::rank) {
+      s[0] = n;
+    }
+    s[dimension_type::rank] = n * m_dim.N0;
+  }
 
   //----------------------------------------
 
-  ViewOffset() = default ;
-  ViewOffset( const ViewOffset & ) = default ;
-  ViewOffset & operator = ( const ViewOffset & ) = default ;
-
-  template< unsigned TrivialScalarSize >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( std::integral_constant<unsigned,TrivialScalarSize> const &
-    , Kokkos::LayoutRight const & arg_layout
-    )
-    : m_dim( arg_layout.dimension[0], 0, 0, 0, 0, 0, 0, 0 )
-    {}
-
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutRight , void > & rhs )
-    : m_dim( rhs.m_dim.N0 , rhs.m_dim.N1 , rhs.m_dim.N2 , rhs.m_dim.N3
-           , rhs.m_dim.N4 , rhs.m_dim.N5 , rhs.m_dim.N6 , rhs.m_dim.N7 )
-    {
-      static_assert( int(DimRHS::rank) == int(dimension_type::rank) , "ViewOffset assignment requires equal rank" );
-      // Also requires equal static dimensions ...
-    }
-
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutLeft , void > & rhs )
-    : m_dim( rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0 )
-    {
-      static_assert(
-       ( DimRHS::rank == 0 &&
-         dimension_type::rank == 0 ) ||
-       ( DimRHS::rank == 1 &&
-         dimension_type::rank == 1 &&
-         dimension_type::rank_dynamic == 1 )
-      , "ViewOffset LayoutRight and LayoutLeft are only compatible when rank <= 1" );
-    }
+  ViewOffset()                  = default;
+  ViewOffset(const ViewOffset&) = default;
+  ViewOffset& operator=(const ViewOffset&) = default;
+
+  template <unsigned TrivialScalarSize>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      std::integral_constant<unsigned, TrivialScalarSize> const&,
+      Kokkos::LayoutRight const& arg_layout)
+      : m_dim(arg_layout.dimension[0], 0, 0, 0, 0, 0, 0, 0) {}
+
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutRight, void>& rhs)
+      : m_dim(rhs.m_dim.N0, rhs.m_dim.N1, rhs.m_dim.N2, rhs.m_dim.N3,
+              rhs.m_dim.N4, rhs.m_dim.N5, rhs.m_dim.N6, rhs.m_dim.N7) {
+    static_assert(int(DimRHS::rank) == int(dimension_type::rank),
+                  "ViewOffset assignment requires equal rank");
+    // Also requires equal static dimensions ...
+  }
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutStride , void > & rhs )
-    : m_dim( rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0 )
-    {
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutLeft, void>& rhs)
+      : m_dim(rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0) {
+    static_assert((DimRHS::rank == 0 && dimension_type::rank == 0) ||
+                      (DimRHS::rank == 1 && dimension_type::rank == 1 &&
+                       dimension_type::rank_dynamic == 1),
+                  "ViewOffset LayoutRight and LayoutLeft are only compatible "
+                  "when rank <= 1");
+  }
 
-    }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutStride, void>& rhs)
+      : m_dim(rhs.m_dim.N0, 0, 0, 0, 0, 0, 0, 0) {}
 
   //----------------------------------------
   // Subview construction
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( const ViewOffset< DimRHS , Kokkos::LayoutRight , void > &
-    , const SubviewExtents< DimRHS::rank , dimension_type::rank > & sub
-    )
-    : m_dim( sub.range_extent(0) , 0, 0, 0, 0, 0, 0, 0 )
-    {
-      static_assert( ( 0 == dimension_type::rank_dynamic ) ||
-                     ( 1 == dimension_type::rank && 1 == dimension_type::rank_dynamic && 1 <= DimRHS::rank )
-                   , "ViewOffset subview construction requires compatible rank" );
-    }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutRight, void>&,
+      const SubviewExtents<DimRHS::rank, dimension_type::rank>& sub)
+      : m_dim(sub.range_extent(0), 0, 0, 0, 0, 0, 0, 0) {
+    static_assert((0 == dimension_type::rank_dynamic) ||
+                      (1 == dimension_type::rank &&
+                       1 == dimension_type::rank_dynamic && 1 <= DimRHS::rank),
+                  "ViewOffset subview construction requires compatible rank");
+  }
 };
 
 //----------------------------------------------------------------------------
 // LayoutRight AND ( 1 < rank AND 0 < rank_dynamic ) : has padding / striding
-template < class Dimension >
-struct ViewOffset< Dimension , Kokkos::LayoutRight
-                 , typename std::enable_if<( 1 < Dimension::rank
-                                             &&
-                                             0 < Dimension::rank_dynamic
-                                           )>::type >
-{
-  using is_mapping_plugin = std::true_type ;
-  using is_regular        = std::true_type ;
-
-  typedef size_t               size_type ;
-  typedef Dimension            dimension_type ;
-  typedef Kokkos::LayoutRight  array_layout ;
-
-  dimension_type m_dim ;
-  size_type      m_stride ;
+template <class Dimension>
+struct ViewOffset<
+    Dimension, Kokkos::LayoutRight,
+    typename std::enable_if<(1 < Dimension::rank &&
+                             0 < Dimension::rank_dynamic)>::type> {
+  using is_mapping_plugin = std::true_type;
+  using is_regular        = std::true_type;
+
+  typedef size_t size_type;
+  typedef Dimension dimension_type;
+  typedef Kokkos::LayoutRight array_layout;
+
+  dimension_type m_dim;
+  size_type m_stride;
 
   //----------------------------------------
 
   // rank 1
-  template< typename I0 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 ) const { return i0 ; }
+  template <typename I0>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0) const {
+    return i0;
+  }
 
   // rank 2
-  template < typename I0 , typename I1 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 , I1 const & i1 ) const
-  { return i1 + i0 * m_stride ; }
-
-  //rank 3
-  template < typename I0, typename I1, typename I2 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2 ) const
-  { return i2 + m_dim.N2 * ( i1 ) + i0 * m_stride ; }
-
-  //rank 4
-  template < typename I0, typename I1, typename I2, typename I3 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3 ) const
-  {
-    return i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * ( i1 )) +
-           i0 * m_stride ;
+  template <typename I0, typename I1>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1) const {
+    return i1 + i0 * m_stride;
   }
 
-  //rank 5
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4 ) const
-  {
-    return i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * ( i1 ))) +
-           i0 * m_stride ;
-  }
-
-  //rank 6
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5 ) const
-  {
-    return i5 + m_dim.N5 * (
-           i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * ( i1 )))) +
-           i0 * m_stride ;
-  }
-
-  //rank 7
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6 ) const
-  {
-    return i6 + m_dim.N6 * (
-           i5 + m_dim.N5 * (
-           i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * ( i1 ))))) +
-           i0 * m_stride ;
-  }
-
-  //rank 8
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6, typename I7 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6, I7 const & i7 ) const
-  {
-    return i7 + m_dim.N7 * (
-           i6 + m_dim.N6 * (
-           i5 + m_dim.N5 * (
-           i4 + m_dim.N4 * (
-           i3 + m_dim.N3 * (
-           i2 + m_dim.N2 * ( i1 )))))) +
-           i0 * m_stride ;
+  // rank 3
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2) const {
+    return i2 + m_dim.N2 * (i1) + i0 * m_stride;
+  }
+
+  // rank 4
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3) const {
+    return i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1)) + i0 * m_stride;
+  }
+
+  // rank 5
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3,
+                                                        I4 const& i4) const {
+    return i4 + m_dim.N4 * (i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1))) +
+           i0 * m_stride;
+  }
+
+  // rank 6
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5) const {
+    return i5 +
+           m_dim.N5 *
+               (i4 + m_dim.N4 * (i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1)))) +
+           i0 * m_stride;
+  }
+
+  // rank 7
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6) const {
+    return i6 +
+           m_dim.N6 *
+               (i5 + m_dim.N5 *
+                         (i4 + m_dim.N4 *
+                                   (i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1))))) +
+           i0 * m_stride;
+  }
+
+  // rank 8
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6, I7 const& i7) const {
+    return i7 +
+           m_dim.N7 *
+               (i6 +
+                m_dim.N6 *
+                    (i5 +
+                     m_dim.N5 *
+                         (i4 + m_dim.N4 *
+                                   (i3 + m_dim.N3 * (i2 + m_dim.N2 * (i1)))))) +
+           i0 * m_stride;
   }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  constexpr array_layout layout() const
-    {
-      return array_layout( m_dim.N0 , m_dim.N1 , m_dim.N2 , m_dim.N3
-                         , m_dim.N4 , m_dim.N5 , m_dim.N6 , m_dim.N7 );
-    }
+  constexpr array_layout layout() const {
+    return array_layout(m_dim.N0, m_dim.N1, m_dim.N2, m_dim.N3, m_dim.N4,
+                        m_dim.N5, m_dim.N6, m_dim.N7);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const { return m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return m_dim.N7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
+    return m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const {
+    return m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const {
+    return m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const {
+    return m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const {
+    return m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const {
+    return m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const {
+    return m_dim.N7;
+  }
 
   /* Cardinality of the domain index space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type size() const
-    { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
+  constexpr size_type size() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
   /* Span of the range space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type span() const
-    { return m_dim.N0 * m_stride ; }
+  constexpr size_type span() const { return m_dim.N0 * m_stride; }
 
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const
-    { return m_stride == m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 * m_dim.N2 * m_dim.N1 ; }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return m_stride == m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 *
+                           m_dim.N2 * m_dim.N1;
+  }
 
   /* Strides of dimensions */
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return m_dim.N7 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return m_dim.N7 * m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 * m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return m_stride ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const {
+    return m_dim.N7;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const {
+    return m_dim.N7 * m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const {
+    return m_dim.N7 * m_dim.N6 * m_dim.N5 * m_dim.N4 * m_dim.N3 * m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const {
+    return m_stride;
+  }
 
   // Stride with [ rank ] value is the total length
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void stride( iType * const s ) const
-    {
-      size_type n = 1 ;
-      if ( 7 < dimension_type::rank ) { s[7] = n ; n *= m_dim.N7 ; }
-      if ( 6 < dimension_type::rank ) { s[6] = n ; n *= m_dim.N6 ; }
-      if ( 5 < dimension_type::rank ) { s[5] = n ; n *= m_dim.N5 ; }
-      if ( 4 < dimension_type::rank ) { s[4] = n ; n *= m_dim.N4 ; }
-      if ( 3 < dimension_type::rank ) { s[3] = n ; n *= m_dim.N3 ; }
-      if ( 2 < dimension_type::rank ) { s[2] = n ; n *= m_dim.N2 ; }
-      if ( 1 < dimension_type::rank ) { s[1] = n ; }
-      if ( 0 < dimension_type::rank ) { s[0] = m_stride ; }
-      s[dimension_type::rank] = m_stride * m_dim.N0 ;
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    size_type n = 1;
+    if (7 < dimension_type::rank) {
+      s[7] = n;
+      n *= m_dim.N7;
+    }
+    if (6 < dimension_type::rank) {
+      s[6] = n;
+      n *= m_dim.N6;
+    }
+    if (5 < dimension_type::rank) {
+      s[5] = n;
+      n *= m_dim.N5;
+    }
+    if (4 < dimension_type::rank) {
+      s[4] = n;
+      n *= m_dim.N4;
+    }
+    if (3 < dimension_type::rank) {
+      s[3] = n;
+      n *= m_dim.N3;
+    }
+    if (2 < dimension_type::rank) {
+      s[2] = n;
+      n *= m_dim.N2;
+    }
+    if (1 < dimension_type::rank) {
+      s[1] = n;
+    }
+    if (0 < dimension_type::rank) {
+      s[0] = m_stride;
     }
+    s[dimension_type::rank] = m_stride * m_dim.N0;
+  }
 
   //----------------------------------------
 
-private:
-
-  template< unsigned TrivialScalarSize >
+ private:
+  template <unsigned TrivialScalarSize>
   struct Padding {
-    enum { div = TrivialScalarSize == 0 ? 0 : Kokkos::Impl::MEMORY_ALIGNMENT / ( TrivialScalarSize ? TrivialScalarSize : 1 ) };
-    enum { mod = TrivialScalarSize == 0 ? 0 : Kokkos::Impl::MEMORY_ALIGNMENT % ( TrivialScalarSize ? TrivialScalarSize : 1 ) };
+    enum {
+      div = TrivialScalarSize == 0
+                ? 0
+                : Kokkos::Impl::MEMORY_ALIGNMENT /
+                      (TrivialScalarSize ? TrivialScalarSize : 1)
+    };
+    enum {
+      mod = TrivialScalarSize == 0
+                ? 0
+                : Kokkos::Impl::MEMORY_ALIGNMENT %
+                      (TrivialScalarSize ? TrivialScalarSize : 1)
+    };
 
-    // If memory alignment is a multiple of the trivial scalar size then attempt to align.
+    // If memory alignment is a multiple of the trivial scalar size then attempt
+    // to align.
     enum { align = 0 != TrivialScalarSize && 0 == mod ? div : 0 };
-    enum { div_ok = (div != 0) ? div : 1 }; // To valid modulo zero in constexpr
+    enum {
+      div_ok = (div != 0) ? div : 1
+    };  // To valid modulo zero in constexpr
 
     KOKKOS_INLINE_FUNCTION
-    static constexpr size_t stride( size_t const N )
-    {
-      return ( (align != 0) && ((Kokkos::Impl::MEMORY_ALIGNMENT_THRESHOLD * align) < N) && ((N % div_ok) != 0) )
-             ? N + align - ( N % div_ok ) : N ;
+    static constexpr size_t stride(size_t const N) {
+      return ((align != 0) &&
+              ((Kokkos::Impl::MEMORY_ALIGNMENT_THRESHOLD * align) < N) &&
+              ((N % div_ok) != 0))
+                 ? N + align - (N % div_ok)
+                 : N;
     }
   };
 
-public:
+ public:
+  ViewOffset()                  = default;
+  ViewOffset(const ViewOffset&) = default;
+  ViewOffset& operator=(const ViewOffset&) = default;
 
-  ViewOffset() = default ;
-  ViewOffset( const ViewOffset & ) = default ;
-  ViewOffset & operator = ( const ViewOffset & ) = default ;
+  /* Enable padding for trivial scalar types with non-zero trivial scalar size.
+   */
+  template <unsigned TrivialScalarSize>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      std::integral_constant<unsigned, TrivialScalarSize> const&,
+      Kokkos::LayoutRight const& arg_layout)
+      : m_dim(arg_layout.dimension[0], arg_layout.dimension[1],
+              arg_layout.dimension[2], arg_layout.dimension[3],
+              arg_layout.dimension[4], arg_layout.dimension[5],
+              arg_layout.dimension[6], arg_layout.dimension[7]),
+        m_stride(
+            Padding<TrivialScalarSize>::
+                stride(/* 2 <= rank */
+                       m_dim.N1 *
+                       (dimension_type::rank == 2
+                            ? 1
+                            : m_dim.N2 *
+                                  (dimension_type::rank == 3
+                                       ? 1
+                                       : m_dim.N3 *
+                                             (dimension_type::rank == 4
+                                                  ? 1
+                                                  : m_dim.N4 *
+                                                        (dimension_type::rank ==
+                                                                 5
+                                                             ? 1
+                                                             : m_dim.N5 *
+                                                                   (dimension_type::
+                                                                                rank ==
+                                                                            6
+                                                                        ? 1
+                                                                        : m_dim.N6 *
+                                                                              (dimension_type::
+                                                                                           rank ==
+                                                                                       7
+                                                                                   ? 1
+                                                                                   : m_dim
+                                                                                         .N7)))))))) {
+  }
 
-  /* Enable padding for trivial scalar types with non-zero trivial scalar size.  */
-  template< unsigned TrivialScalarSize >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( std::integral_constant<unsigned,TrivialScalarSize> const &
-    , Kokkos::LayoutRight const & arg_layout
-    )
-    : m_dim( arg_layout.dimension[0] , arg_layout.dimension[1]
-           , arg_layout.dimension[2] , arg_layout.dimension[3]
-           , arg_layout.dimension[4] , arg_layout.dimension[5]
-           , arg_layout.dimension[6] , arg_layout.dimension[7]
-           )
-    , m_stride( Padding<TrivialScalarSize>::
-                  stride( /* 2 <= rank */
-                          m_dim.N1 * ( dimension_type::rank == 2 ? 1 :
-                          m_dim.N2 * ( dimension_type::rank == 3 ? 1 :
-                          m_dim.N3 * ( dimension_type::rank == 4 ? 1 :
-                          m_dim.N4 * ( dimension_type::rank == 5 ? 1 :
-                          m_dim.N5 * ( dimension_type::rank == 6 ? 1 :
-                          m_dim.N6 * ( dimension_type::rank == 7 ? 1 : m_dim.N7 )))))) ))
-    {}
-
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutRight , void > & rhs )
-    : m_dim( rhs.m_dim.N0 , rhs.m_dim.N1 , rhs.m_dim.N2 , rhs.m_dim.N3
-           , rhs.m_dim.N4 , rhs.m_dim.N5 , rhs.m_dim.N6 , rhs.m_dim.N7 )
-    , m_stride( rhs.stride_0() )
-    {
-      static_assert( int(DimRHS::rank) == int(dimension_type::rank) , "ViewOffset assignment requires equal rank" );
-      // Also requires equal static dimensions ...
-    }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutRight, void>& rhs)
+      : m_dim(rhs.m_dim.N0, rhs.m_dim.N1, rhs.m_dim.N2, rhs.m_dim.N3,
+              rhs.m_dim.N4, rhs.m_dim.N5, rhs.m_dim.N6, rhs.m_dim.N7),
+        m_stride(rhs.stride_0()) {
+    static_assert(int(DimRHS::rank) == int(dimension_type::rank),
+                  "ViewOffset assignment requires equal rank");
+    // Also requires equal static dimensions ...
+  }
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  ViewOffset( const ViewOffset< DimRHS , Kokkos::LayoutStride , void > & rhs )
-    : m_dim( rhs.m_dim.N0 , rhs.m_dim.N1 , rhs.m_dim.N2 , rhs.m_dim.N3
-           , rhs.m_dim.N4 , rhs.m_dim.N5 , rhs.m_dim.N6 , rhs.m_dim.N7 )
-    , m_stride( rhs.stride_0() )
-    {
-      if ( ((dimension_type::rank == 2)?rhs.m_stride.S1:
-           ((dimension_type::rank == 3)?rhs.m_stride.S2:
-           ((dimension_type::rank == 4)?rhs.m_stride.S3:
-           ((dimension_type::rank == 5)?rhs.m_stride.S4:
-           ((dimension_type::rank == 6)?rhs.m_stride.S5:
-           ((dimension_type::rank == 7)?rhs.m_stride.S6:rhs.m_stride.S7)))))) != 1 ){
-        Kokkos::abort("Kokkos::Impl::ViewOffset assignment of LayoutRight from LayoutStride requires right-most stride == 1" );
-      }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutStride, void>& rhs)
+      : m_dim(rhs.m_dim.N0, rhs.m_dim.N1, rhs.m_dim.N2, rhs.m_dim.N3,
+              rhs.m_dim.N4, rhs.m_dim.N5, rhs.m_dim.N6, rhs.m_dim.N7),
+        m_stride(rhs.stride_0()) {
+    if (((dimension_type::rank == 2)
+             ? rhs.m_stride.S1
+             : ((dimension_type::rank == 3)
+                    ? rhs.m_stride.S2
+                    : ((dimension_type::rank == 4)
+                           ? rhs.m_stride.S3
+                           : ((dimension_type::rank == 5)
+                                  ? rhs.m_stride.S4
+                                  : ((dimension_type::rank == 6)
+                                         ? rhs.m_stride.S5
+                                         : ((dimension_type::rank == 7)
+                                                ? rhs.m_stride.S6
+                                                : rhs.m_stride.S7)))))) != 1) {
+      Kokkos::abort(
+          "Kokkos::Impl::ViewOffset assignment of LayoutRight from "
+          "LayoutStride requires right-most stride == 1");
     }
+  }
 
   //----------------------------------------
   // Subview construction
   // Last dimension must be non-zero
 
-  template< class DimRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( const ViewOffset< DimRHS , Kokkos::LayoutRight , void > & rhs
-    , const SubviewExtents< DimRHS::rank , dimension_type::rank > & sub
-    )
-    : m_dim( sub.range_extent(0)
-           , sub.range_extent(1)
-           , sub.range_extent(2)
-           , sub.range_extent(3)
-           , sub.range_extent(4)
-           , sub.range_extent(5)
-           , sub.range_extent(6)
-           , sub.range_extent(7))
-    , m_stride( 0 == sub.range_index(0) ? rhs.stride_0() : (
-                1 == sub.range_index(0) ? rhs.stride_1() : (
-                2 == sub.range_index(0) ? rhs.stride_2() : (
-                3 == sub.range_index(0) ? rhs.stride_3() : (
-                4 == sub.range_index(0) ? rhs.stride_4() : (
-                5 == sub.range_index(0) ? rhs.stride_5() : (
-                6 == sub.range_index(0) ? rhs.stride_6() : 0 )))))))
-    {
-/*      // This subview must be 2 == rank and 2 == rank_dynamic
-      // due to only having stride #0.
-      // The source dimension #0 must be non-zero for stride-one leading dimension.
-      // At most subsequent dimension can be non-zero.
-
-      static_assert( (( 2 == dimension_type::rank ) &&
-                      ( 2 <= DimRHS::rank )) ||
-                     ()
-                   , "ViewOffset subview construction requires compatible rank" );
-*/
-    }
+  template <class DimRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, Kokkos::LayoutRight, void>& rhs,
+      const SubviewExtents<DimRHS::rank, dimension_type::rank>& sub)
+      : m_dim(sub.range_extent(0), sub.range_extent(1), sub.range_extent(2),
+              sub.range_extent(3), sub.range_extent(4), sub.range_extent(5),
+              sub.range_extent(6), sub.range_extent(7)),
+        m_stride(
+            0 == sub.range_index(0)
+                ? rhs.stride_0()
+                : (1 == sub.range_index(0)
+                       ? rhs.stride_1()
+                       : (2 == sub.range_index(0)
+                              ? rhs.stride_2()
+                              : (3 == sub.range_index(0)
+                                     ? rhs.stride_3()
+                                     : (4 == sub.range_index(0)
+                                            ? rhs.stride_4()
+                                            : (5 == sub.range_index(0)
+                                                   ? rhs.stride_5()
+                                                   : (6 == sub.range_index(0)
+                                                          ? rhs.stride_6()
+                                                          : 0))))))) {
+    /*      // This subview must be 2 == rank and 2 == rank_dynamic
+          // due to only having stride #0.
+          // The source dimension #0 must be non-zero for stride-one leading
+       dimension.
+          // At most subsequent dimension can be non-zero.
+
+          static_assert( (( 2 == dimension_type::rank ) &&
+                          ( 2 <= DimRHS::rank )) ||
+                         ()
+                       , "ViewOffset subview construction requires compatible
+       rank" );
+    */
+  }
 };
 
 //----------------------------------------------------------------------------
 /* Strided array layout only makes sense for 0 < rank */
 /* rank = 0 included for DynRankView case */
 
-template< unsigned Rank >
-struct ViewStride ;
+template <unsigned Rank>
+struct ViewStride;
 
-template<>
+template <>
 struct ViewStride<0> {
-  enum { S0 = 0 , S1 = 0 , S2 = 0 , S3 = 0 , S4 = 0 , S5 = 0 , S6 = 0 , S7 = 0 };
+  enum { S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t , size_t , size_t , size_t
-                      , size_t , size_t , size_t , size_t )
-    {}
+  constexpr ViewStride(size_t, size_t, size_t, size_t, size_t, size_t, size_t,
+                       size_t) {}
 };
 
-template<>
+template <>
 struct ViewStride<1> {
-  size_t S0 ;
-  enum { S1 = 0 , S2 = 0 , S3 = 0 , S4 = 0 , S5 = 0 , S6 = 0 , S7 = 0 };
+  size_t S0;
+  enum { S1 = 0, S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t , size_t , size_t
-                      , size_t , size_t , size_t , size_t )
-    : S0( aS0 )
-    {}
+  constexpr ViewStride(size_t aS0, size_t, size_t, size_t, size_t, size_t,
+                       size_t, size_t)
+      : S0(aS0) {}
 };
 
-template<>
+template <>
 struct ViewStride<2> {
-  size_t S0 , S1 ;
-  enum { S2 = 0 , S3 = 0 , S4 = 0 , S5 = 0 , S6 = 0 , S7 = 0 };
+  size_t S0, S1;
+  enum { S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t aS1 , size_t , size_t
-                      , size_t , size_t , size_t , size_t )
-    : S0( aS0 ) , S1( aS1 )
-    {}
+  constexpr ViewStride(size_t aS0, size_t aS1, size_t, size_t, size_t, size_t,
+                       size_t, size_t)
+      : S0(aS0), S1(aS1) {}
 };
 
-template<>
+template <>
 struct ViewStride<3> {
-  size_t S0 , S1 , S2 ;
-  enum { S3 = 0 , S4 = 0 , S5 = 0 , S6 = 0 , S7 = 0 };
+  size_t S0, S1, S2;
+  enum { S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t aS1 , size_t aS2 , size_t
-                      , size_t , size_t , size_t , size_t )
-    : S0( aS0 ) , S1( aS1 ) , S2( aS2 )
-    {}
+  constexpr ViewStride(size_t aS0, size_t aS1, size_t aS2, size_t, size_t,
+                       size_t, size_t, size_t)
+      : S0(aS0), S1(aS1), S2(aS2) {}
 };
 
-template<>
+template <>
 struct ViewStride<4> {
-  size_t S0 , S1 , S2 , S3 ;
-  enum { S4 = 0 , S5 = 0 , S6 = 0 , S7 = 0 };
+  size_t S0, S1, S2, S3;
+  enum { S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t aS1 , size_t aS2 , size_t aS3
-                      , size_t , size_t , size_t , size_t )
-    : S0( aS0 ) , S1( aS1 ) , S2( aS2 ) , S3( aS3 )
-    {}
+  constexpr ViewStride(size_t aS0, size_t aS1, size_t aS2, size_t aS3, size_t,
+                       size_t, size_t, size_t)
+      : S0(aS0), S1(aS1), S2(aS2), S3(aS3) {}
 };
 
-template<>
+template <>
 struct ViewStride<5> {
-  size_t S0 , S1 , S2 , S3 , S4 ;
-  enum { S5 = 0 , S6 = 0 , S7 = 0 };
+  size_t S0, S1, S2, S3, S4;
+  enum { S5 = 0, S6 = 0, S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t aS1 , size_t aS2 , size_t aS3
-                      , size_t aS4 , size_t , size_t , size_t )
-    : S0( aS0 ) , S1( aS1 ) , S2( aS2 ) , S3( aS3 )
-    , S4( aS4 )
-    {}
+  constexpr ViewStride(size_t aS0, size_t aS1, size_t aS2, size_t aS3,
+                       size_t aS4, size_t, size_t, size_t)
+      : S0(aS0), S1(aS1), S2(aS2), S3(aS3), S4(aS4) {}
 };
 
-template<>
+template <>
 struct ViewStride<6> {
-  size_t S0 , S1 , S2 , S3 , S4 , S5 ;
-  enum { S6 = 0 , S7 = 0 };
+  size_t S0, S1, S2, S3, S4, S5;
+  enum { S6 = 0, S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t aS1 , size_t aS2 , size_t aS3
-                      , size_t aS4 , size_t aS5 , size_t , size_t )
-    : S0( aS0 ) , S1( aS1 ) , S2( aS2 ) , S3( aS3 )
-    , S4( aS4 ) , S5( aS5 )
-    {}
+  constexpr ViewStride(size_t aS0, size_t aS1, size_t aS2, size_t aS3,
+                       size_t aS4, size_t aS5, size_t, size_t)
+      : S0(aS0), S1(aS1), S2(aS2), S3(aS3), S4(aS4), S5(aS5) {}
 };
 
-template<>
+template <>
 struct ViewStride<7> {
-  size_t S0 , S1 , S2 , S3 , S4 , S5 , S6 ;
+  size_t S0, S1, S2, S3, S4, S5, S6;
   enum { S7 = 0 };
 
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
 
   KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t aS1 , size_t aS2 , size_t aS3
-                      , size_t aS4 , size_t aS5 , size_t aS6 , size_t )
-    : S0( aS0 ) , S1( aS1 ) , S2( aS2 ) , S3( aS3 )
-    , S4( aS4 ) , S5( aS5 ) , S6( aS6 )
-    {}
+  constexpr ViewStride(size_t aS0, size_t aS1, size_t aS2, size_t aS3,
+                       size_t aS4, size_t aS5, size_t aS6, size_t)
+      : S0(aS0), S1(aS1), S2(aS2), S3(aS3), S4(aS4), S5(aS5), S6(aS6) {}
 };
 
-template<>
+template <>
 struct ViewStride<8> {
-  size_t S0 , S1 , S2 , S3 , S4 , S5 , S6 , S7 ;
-
-  ViewStride() = default ;
-  ViewStride( const ViewStride & ) = default ;
-  ViewStride & operator = ( const ViewStride & ) = default ;
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewStride( size_t aS0 , size_t aS1 , size_t aS2 , size_t aS3
-                      , size_t aS4 , size_t aS5 , size_t aS6 , size_t aS7 )
-    : S0( aS0 ) , S1( aS1 ) , S2( aS2 ) , S3( aS3 )
-    , S4( aS4 ) , S5( aS5 ) , S6( aS6 ) , S7( aS7 )
-    {}
+  size_t S0, S1, S2, S3, S4, S5, S6, S7;
+
+  ViewStride()                  = default;
+  ViewStride(const ViewStride&) = default;
+  ViewStride& operator=(const ViewStride&) = default;
+
+  KOKKOS_INLINE_FUNCTION
+  constexpr ViewStride(size_t aS0, size_t aS1, size_t aS2, size_t aS3,
+                       size_t aS4, size_t aS5, size_t aS6, size_t aS7)
+      : S0(aS0),
+        S1(aS1),
+        S2(aS2),
+        S3(aS3),
+        S4(aS4),
+        S5(aS5),
+        S6(aS6),
+        S7(aS7) {}
 };
 
-template < class Dimension >
-struct ViewOffset< Dimension , Kokkos::LayoutStride
-                 , void >
-{
-private:
-  typedef ViewStride< Dimension::rank >  stride_type ;
-public:
+template <class Dimension>
+struct ViewOffset<Dimension, Kokkos::LayoutStride, void> {
+ private:
+  typedef ViewStride<Dimension::rank> stride_type;
 
-  using is_mapping_plugin = std::true_type ;
-  using is_regular        = std::true_type ;
+ public:
+  using is_mapping_plugin = std::true_type;
+  using is_regular        = std::true_type;
 
-  typedef size_t                size_type ;
-  typedef Dimension             dimension_type ;
-  typedef Kokkos::LayoutStride  array_layout ;
+  typedef size_t size_type;
+  typedef Dimension dimension_type;
+  typedef Kokkos::LayoutStride array_layout;
 
-  dimension_type  m_dim ;
-  stride_type     m_stride ;
+  dimension_type m_dim;
+  stride_type m_stride;
 
   //----------------------------------------
 
   // rank 1
-  template< typename I0 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 ) const
-  {
-    return i0 * m_stride.S0 ;
+  template <typename I0>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0) const {
+    return i0 * m_stride.S0;
   }
 
   // rank 2
-  template < typename I0 , typename I1 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 , I1 const & i1 ) const
-  {
-    return i0 * m_stride.S0 +
-           i1 * m_stride.S1 ;
+  template <typename I0, typename I1>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1) const {
+    return i0 * m_stride.S0 + i1 * m_stride.S1;
   }
 
-  //rank 3
-  template < typename I0, typename I1, typename I2 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2 ) const
-  {
-    return i0 * m_stride.S0 +
-           i1 * m_stride.S1 +
-           i2 * m_stride.S2 ;
+  // rank 3
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2) const {
+    return i0 * m_stride.S0 + i1 * m_stride.S1 + i2 * m_stride.S2;
   }
 
-  //rank 4
-  template < typename I0, typename I1, typename I2, typename I3 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3 ) const
-  {
-    return i0 * m_stride.S0 +
-           i1 * m_stride.S1 +
-           i2 * m_stride.S2 +
-           i3 * m_stride.S3 ;
-  }
-
-  //rank 5
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4 ) const
-  {
-    return i0 * m_stride.S0 +
-           i1 * m_stride.S1 +
-           i2 * m_stride.S2 +
-           i3 * m_stride.S3 +
-           i4 * m_stride.S4 ;
-  }
-
-  //rank 6
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5 ) const
-  {
-    return i0 * m_stride.S0 +
-           i1 * m_stride.S1 +
-           i2 * m_stride.S2 +
-           i3 * m_stride.S3 +
-           i4 * m_stride.S4 +
-           i5 * m_stride.S5 ;
-  }
-
-  //rank 7
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6 ) const
-  {
-    return i0 * m_stride.S0 +
-           i1 * m_stride.S1 +
-           i2 * m_stride.S2 +
-           i3 * m_stride.S3 +
-           i4 * m_stride.S4 +
-           i5 * m_stride.S5 +
-           i6 * m_stride.S6 ;
-  }
-
-  //rank 8
-  template < typename I0, typename I1, typename I2, typename I3
-           , typename I4, typename I5, typename I6, typename I7 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0, I1 const & i1, I2 const & i2, I3 const & i3
-                      , I4 const & i4, I5 const & i5, I6 const & i6, I7 const & i7 ) const
-  {
-    return i0 * m_stride.S0 +
-           i1 * m_stride.S1 +
-           i2 * m_stride.S2 +
-           i3 * m_stride.S3 +
-           i4 * m_stride.S4 +
-           i5 * m_stride.S5 +
-           i6 * m_stride.S6 +
-           i7 * m_stride.S7 ;
+  // rank 4
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3) const {
+    return i0 * m_stride.S0 + i1 * m_stride.S1 + i2 * m_stride.S2 +
+           i3 * m_stride.S3;
+  }
+
+  // rank 5
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1,
+                                                        I2 const& i2,
+                                                        I3 const& i3,
+                                                        I4 const& i4) const {
+    return i0 * m_stride.S0 + i1 * m_stride.S1 + i2 * m_stride.S2 +
+           i3 * m_stride.S3 + i4 * m_stride.S4;
+  }
+
+  // rank 6
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5) const {
+    return i0 * m_stride.S0 + i1 * m_stride.S1 + i2 * m_stride.S2 +
+           i3 * m_stride.S3 + i4 * m_stride.S4 + i5 * m_stride.S5;
+  }
+
+  // rank 7
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6) const {
+    return i0 * m_stride.S0 + i1 * m_stride.S1 + i2 * m_stride.S2 +
+           i3 * m_stride.S3 + i4 * m_stride.S4 + i5 * m_stride.S5 +
+           i6 * m_stride.S6;
+  }
+
+  // rank 8
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(
+      I0 const& i0, I1 const& i1, I2 const& i2, I3 const& i3, I4 const& i4,
+      I5 const& i5, I6 const& i6, I7 const& i7) const {
+    return i0 * m_stride.S0 + i1 * m_stride.S1 + i2 * m_stride.S2 +
+           i3 * m_stride.S3 + i4 * m_stride.S4 + i5 * m_stride.S5 +
+           i6 * m_stride.S6 + i7 * m_stride.S7;
   }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION
-  constexpr array_layout layout() const
-    {
-      return array_layout( m_dim.N0 , m_stride.S0
-                         , m_dim.N1 , m_stride.S1
-                         , m_dim.N2 , m_stride.S2
-                         , m_dim.N3 , m_stride.S3
-                         , m_dim.N4 , m_stride.S4
-                         , m_dim.N5 , m_stride.S5
-                         , m_dim.N6 , m_stride.S6
-                         , m_dim.N7 , m_stride.S7
-                         );
-    }
+  constexpr array_layout layout() const {
+    return array_layout(m_dim.N0, m_stride.S0, m_dim.N1, m_stride.S1, m_dim.N2,
+                        m_stride.S2, m_dim.N3, m_stride.S3, m_dim.N4,
+                        m_stride.S4, m_dim.N5, m_stride.S5, m_dim.N6,
+                        m_stride.S6, m_dim.N7, m_stride.S7);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const { return m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return m_dim.N2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return m_dim.N3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return m_dim.N4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return m_dim.N5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return m_dim.N6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return m_dim.N7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
+    return m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const {
+    return m_dim.N2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const {
+    return m_dim.N3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const {
+    return m_dim.N4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const {
+    return m_dim.N5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const {
+    return m_dim.N6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const {
+    return m_dim.N7;
+  }
 
   /* Cardinality of the domain index space */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type size() const
-    { return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 * m_dim.N6 * m_dim.N7 ; }
-
-private:
+  constexpr size_type size() const {
+    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
+           m_dim.N6 * m_dim.N7;
+  }
 
+ private:
   KOKKOS_INLINE_FUNCTION
-  static constexpr size_type Max( size_type lhs , size_type rhs )
-    { return lhs < rhs ? rhs : lhs ; }
-
-public:
+  static constexpr size_type Max(size_type lhs, size_type rhs) {
+    return lhs < rhs ? rhs : lhs;
+  }
 
+ public:
   /* Span of the range space, largest stride * dimension */
   KOKKOS_INLINE_FUNCTION
-  constexpr size_type span() const
-    {
-      return Max( m_dim.N0 * m_stride.S0 ,
-             Max( m_dim.N1 * m_stride.S1 ,
-             Max( m_dim.N2 * m_stride.S2 ,
-             Max( m_dim.N3 * m_stride.S3 ,
-             Max( m_dim.N4 * m_stride.S4 ,
-             Max( m_dim.N5 * m_stride.S5 ,
-             Max( m_dim.N6 * m_stride.S6 ,
-                  m_dim.N7 * m_stride.S7 )))))));
-    }
+  constexpr size_type span() const {
+    return Max(m_dim.N0 * m_stride.S0,
+               Max(m_dim.N1 * m_stride.S1,
+                   Max(m_dim.N2 * m_stride.S2,
+                       Max(m_dim.N3 * m_stride.S3,
+                           Max(m_dim.N4 * m_stride.S4,
+                               Max(m_dim.N5 * m_stride.S5,
+                                   Max(m_dim.N6 * m_stride.S6,
+                                       m_dim.N7 * m_stride.S7)))))));
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const { return span() == size(); }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return span() == size();
+  }
 
   /* Strides of dimensions */
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return m_stride.S0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return m_stride.S1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return m_stride.S2 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return m_stride.S3 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return m_stride.S4 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return m_stride.S5 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return m_stride.S6 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return m_stride.S7 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const {
+    return m_stride.S0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const {
+    return m_stride.S1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const {
+    return m_stride.S2;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const {
+    return m_stride.S3;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const {
+    return m_stride.S4;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const {
+    return m_stride.S5;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const {
+    return m_stride.S6;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const {
+    return m_stride.S7;
+  }
 
   // Stride with [ rank ] value is the total length
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void stride( iType * const s ) const
-    {
-      if ( 0 < dimension_type::rank ) { s[0] = m_stride.S0 ; }
-      if ( 1 < dimension_type::rank ) { s[1] = m_stride.S1 ; }
-      if ( 2 < dimension_type::rank ) { s[2] = m_stride.S2 ; }
-      if ( 3 < dimension_type::rank ) { s[3] = m_stride.S3 ; }
-      if ( 4 < dimension_type::rank ) { s[4] = m_stride.S4 ; }
-      if ( 5 < dimension_type::rank ) { s[5] = m_stride.S5 ; }
-      if ( 6 < dimension_type::rank ) { s[6] = m_stride.S6 ; }
-      if ( 7 < dimension_type::rank ) { s[7] = m_stride.S7 ; }
-      s[dimension_type::rank] = span();
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    if (0 < dimension_type::rank) {
+      s[0] = m_stride.S0;
+    }
+    if (1 < dimension_type::rank) {
+      s[1] = m_stride.S1;
+    }
+    if (2 < dimension_type::rank) {
+      s[2] = m_stride.S2;
     }
+    if (3 < dimension_type::rank) {
+      s[3] = m_stride.S3;
+    }
+    if (4 < dimension_type::rank) {
+      s[4] = m_stride.S4;
+    }
+    if (5 < dimension_type::rank) {
+      s[5] = m_stride.S5;
+    }
+    if (6 < dimension_type::rank) {
+      s[6] = m_stride.S6;
+    }
+    if (7 < dimension_type::rank) {
+      s[7] = m_stride.S7;
+    }
+    s[dimension_type::rank] = span();
+  }
 
   //----------------------------------------
 
-  ViewOffset() = default ;
-  ViewOffset( const ViewOffset & ) = default ;
-  ViewOffset & operator = ( const ViewOffset & ) = default ;
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( std::integral_constant<unsigned,0> const &
-                      , Kokkos::LayoutStride const & rhs )
-    : m_dim( rhs.dimension[0] , rhs.dimension[1] , rhs.dimension[2] , rhs.dimension[3]
-           , rhs.dimension[4] , rhs.dimension[5] , rhs.dimension[6] , rhs.dimension[7] )
-    , m_stride( rhs.stride[0] , rhs.stride[1] , rhs.stride[2] , rhs.stride[3]
-              , rhs.stride[4] , rhs.stride[5] , rhs.stride[6] , rhs.stride[7] )
-    {}
-
-  template< class DimRHS , class LayoutRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( const ViewOffset< DimRHS , LayoutRHS , void > & rhs )
-    : m_dim( rhs.m_dim.N0 , rhs.m_dim.N1 , rhs.m_dim.N2 , rhs.m_dim.N3
-           , rhs.m_dim.N4 , rhs.m_dim.N5 , rhs.m_dim.N6 , rhs.m_dim.N7 )
-    , m_stride( rhs.stride_0() , rhs.stride_1() , rhs.stride_2() , rhs.stride_3()
-              , rhs.stride_4() , rhs.stride_5() , rhs.stride_6() , rhs.stride_7() )
-    {
-      static_assert( int(DimRHS::rank) == int(dimension_type::rank) , "ViewOffset assignment requires equal rank" );
-      // Also requires equal static dimensions ...
-    }
+  ViewOffset()                  = default;
+  ViewOffset(const ViewOffset&) = default;
+  ViewOffset& operator=(const ViewOffset&) = default;
+
+  KOKKOS_INLINE_FUNCTION
+  constexpr ViewOffset(std::integral_constant<unsigned, 0> const&,
+                       Kokkos::LayoutStride const& rhs)
+      : m_dim(rhs.dimension[0], rhs.dimension[1], rhs.dimension[2],
+              rhs.dimension[3], rhs.dimension[4], rhs.dimension[5],
+              rhs.dimension[6], rhs.dimension[7]),
+        m_stride(rhs.stride[0], rhs.stride[1], rhs.stride[2], rhs.stride[3],
+                 rhs.stride[4], rhs.stride[5], rhs.stride[6], rhs.stride[7]) {}
+
+  template <class DimRHS, class LayoutRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, LayoutRHS, void>& rhs)
+      : m_dim(rhs.m_dim.N0, rhs.m_dim.N1, rhs.m_dim.N2, rhs.m_dim.N3,
+              rhs.m_dim.N4, rhs.m_dim.N5, rhs.m_dim.N6, rhs.m_dim.N7),
+        m_stride(rhs.stride_0(), rhs.stride_1(), rhs.stride_2(), rhs.stride_3(),
+                 rhs.stride_4(), rhs.stride_5(), rhs.stride_6(),
+                 rhs.stride_7()) {
+    static_assert(int(DimRHS::rank) == int(dimension_type::rank),
+                  "ViewOffset assignment requires equal rank");
+    // Also requires equal static dimensions ...
+  }
 
   //----------------------------------------
   // Subview construction
 
-private:
-
-  template< class DimRHS , class LayoutRHS >
-  KOKKOS_INLINE_FUNCTION static
-  constexpr size_t stride
-    ( unsigned r , const ViewOffset< DimRHS , LayoutRHS , void > & rhs )
-    {
-      return r >  7 ? 0 : (
-             r == 0 ? rhs.stride_0() : (
-             r == 1 ? rhs.stride_1() : (
-             r == 2 ? rhs.stride_2() : (
-             r == 3 ? rhs.stride_3() : (
-             r == 4 ? rhs.stride_4() : (
-             r == 5 ? rhs.stride_5() : (
-             r == 6 ? rhs.stride_6() : rhs.stride_7() )))))));
-    }
-
-public:
+ private:
+  template <class DimRHS, class LayoutRHS>
+  KOKKOS_INLINE_FUNCTION static constexpr size_t stride(
+      unsigned r, const ViewOffset<DimRHS, LayoutRHS, void>& rhs) {
+    return r > 7
+               ? 0
+               : (r == 0
+                      ? rhs.stride_0()
+                      : (r == 1
+                             ? rhs.stride_1()
+                             : (r == 2
+                                    ? rhs.stride_2()
+                                    : (r == 3
+                                           ? rhs.stride_3()
+                                           : (r == 4
+                                                  ? rhs.stride_4()
+                                                  : (r == 5
+                                                         ? rhs.stride_5()
+                                                         : (r == 6
+                                                                ? rhs.stride_6()
+                                                                : rhs.stride_7())))))));
+  }
 
-  template< class DimRHS , class LayoutRHS >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset
-    ( const ViewOffset< DimRHS , LayoutRHS , void > & rhs
-    , const SubviewExtents< DimRHS::rank , dimension_type::rank > & sub
-    )
-    // range_extent(r) returns 0 when dimension_type::rank <= r
-    : m_dim( sub.range_extent(0)
-           , sub.range_extent(1)
-           , sub.range_extent(2)
-           , sub.range_extent(3)
-           , sub.range_extent(4)
-           , sub.range_extent(5)
-           , sub.range_extent(6)
-           , sub.range_extent(7)
-           )
-    // range_index(r) returns ~0u when dimension_type::rank <= r
-    , m_stride( stride( sub.range_index(0), rhs )
-              , stride( sub.range_index(1), rhs )
-              , stride( sub.range_index(2), rhs )
-              , stride( sub.range_index(3), rhs )
-              , stride( sub.range_index(4), rhs )
-              , stride( sub.range_index(5), rhs )
-              , stride( sub.range_index(6), rhs )
-              , stride( sub.range_index(7), rhs )
-              )
-    {}
+ public:
+  template <class DimRHS, class LayoutRHS>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      const ViewOffset<DimRHS, LayoutRHS, void>& rhs,
+      const SubviewExtents<DimRHS::rank, dimension_type::rank>& sub)
+      // range_extent(r) returns 0 when dimension_type::rank <= r
+      : m_dim(sub.range_extent(0), sub.range_extent(1), sub.range_extent(2),
+              sub.range_extent(3), sub.range_extent(4), sub.range_extent(5),
+              sub.range_extent(6), sub.range_extent(7))
+        // range_index(r) returns ~0u when dimension_type::rank <= r
+        ,
+        m_stride(
+            stride(sub.range_index(0), rhs), stride(sub.range_index(1), rhs),
+            stride(sub.range_index(2), rhs), stride(sub.range_index(3), rhs),
+            stride(sub.range_index(4), rhs), stride(sub.range_index(5), rhs),
+            stride(sub.range_index(6), rhs), stride(sub.range_index(7), rhs)) {}
 };
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -2286,187 +2553,170 @@ namespace Impl {
  *          'return_type' which is what the view operators will give back.
  *          Specialisation of this object allows three things depending
  *          on ViewTraits and compiler options:
- *          (i)   Use special allocator (e.g. huge pages/small pages and pinned memory)
- *          (ii)  Use special data handle type (e.g. add Cuda Texture Object)
- *          (iii) Use special access intrinsics (e.g. texture fetch and non-caching loads)
+ *          (i)   Use special allocator (e.g. huge pages/small pages and pinned
+ * memory) (ii)  Use special data handle type (e.g. add Cuda Texture Object)
+ *          (iii) Use special access intrinsics (e.g. texture fetch and
+ * non-caching loads)
  */
-template< class Traits , class Enable = void >
+template <class Traits, class Enable = void>
 struct ViewDataHandle {
-
-  typedef typename Traits::value_type   value_type  ;
-  typedef typename Traits::value_type * handle_type ;
-  typedef typename Traits::value_type & return_type ;
-  typedef Kokkos::Impl::SharedAllocationTracker  track_type  ;
+  typedef typename Traits::value_type value_type;
+  typedef typename Traits::value_type* handle_type;
+  typedef typename Traits::value_type& return_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
 
   KOKKOS_INLINE_FUNCTION
-  static handle_type assign( value_type * arg_data_ptr
-                           , track_type const & /*arg_tracker*/ )
-  {
-    return handle_type( arg_data_ptr );
+  static handle_type assign(value_type* arg_data_ptr,
+                            track_type const& /*arg_tracker*/) {
+    return handle_type(arg_data_ptr);
   }
 
   KOKKOS_INLINE_FUNCTION
-  static handle_type assign( handle_type const arg_data_ptr
-                           , size_t offset )
-  {
-    return handle_type( arg_data_ptr + offset );
+  static handle_type assign(handle_type const arg_data_ptr, size_t offset) {
+    return handle_type(arg_data_ptr + offset);
   }
 };
 
-template< class Traits >
-struct ViewDataHandle< Traits ,
-  typename std::enable_if<( std::is_same< typename Traits::non_const_value_type
-                                        , typename Traits::value_type >::value
-                            &&
-                            std::is_same< typename Traits::specialize , void >::value
-                            &&
-                            Traits::memory_traits::is_atomic
-                          )>::type >
-{
-  typedef typename Traits::value_type  value_type ;
-  typedef typename Kokkos::Impl::AtomicViewDataHandle< Traits >  handle_type ;
-  typedef typename Kokkos::Impl::AtomicDataElement< Traits >     return_type ;
-  typedef Kokkos::Impl::SharedAllocationTracker                  track_type  ;
-
-  KOKKOS_INLINE_FUNCTION
-  static handle_type assign( value_type * arg_data_ptr
-                           , track_type const & /*arg_tracker*/ )
-  {
-    return handle_type( arg_data_ptr );
+template <class Traits>
+struct ViewDataHandle<
+    Traits, typename std::enable_if<(
+                std::is_same<typename Traits::non_const_value_type,
+                             typename Traits::value_type>::value &&
+                std::is_same<typename Traits::specialize, void>::value &&
+                Traits::memory_traits::is_atomic)>::type> {
+  typedef typename Traits::value_type value_type;
+  typedef typename Kokkos::Impl::AtomicViewDataHandle<Traits> handle_type;
+  typedef typename Kokkos::Impl::AtomicDataElement<Traits> return_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
+
+  KOKKOS_INLINE_FUNCTION
+  static handle_type assign(value_type* arg_data_ptr,
+                            track_type const& /*arg_tracker*/) {
+    return handle_type(arg_data_ptr);
   }
 
-  template<class SrcHandleType>
-  KOKKOS_INLINE_FUNCTION
-  static handle_type assign( const SrcHandleType& arg_handle
-                           , size_t offset )
-  {
-    return handle_type( arg_handle.ptr + offset );
+  template <class SrcHandleType>
+  KOKKOS_INLINE_FUNCTION static handle_type assign(
+      const SrcHandleType& arg_handle, size_t offset) {
+    return handle_type(arg_handle.ptr + offset);
   }
 };
 
-template< class Traits >
-struct ViewDataHandle< Traits ,
-  typename std::enable_if<(
-                            std::is_same< typename Traits::specialize , void >::value
-                            &&
-                            (!Traits::memory_traits::is_aligned)
-                            &&
-                            Traits::memory_traits::is_restrict
+template <class Traits>
+struct ViewDataHandle<
+    Traits, typename std::enable_if<(
+                std::is_same<typename Traits::specialize, void>::value &&
+                (!Traits::memory_traits::is_aligned) &&
+                Traits::memory_traits::is_restrict
 #ifdef KOKKOS_ENABLE_CUDA
-                            &&
-                            (!( std::is_same< typename Traits::memory_space,Kokkos::CudaSpace>::value ||
-                                std::is_same< typename Traits::memory_space,Kokkos::CudaUVMSpace>::value ))
+                && (!(std::is_same<typename Traits::memory_space,
+                                   Kokkos::CudaSpace>::value ||
+                      std::is_same<typename Traits::memory_space,
+                                   Kokkos::CudaUVMSpace>::value))
 #endif
-                            &&
-                            (!Traits::memory_traits::is_atomic)
-                          )>::type >
-{
-  typedef typename Traits::value_type  value_type ;
-  typedef typename Traits::value_type * KOKKOS_RESTRICT handle_type ;
-  typedef typename Traits::value_type & KOKKOS_RESTRICT return_type ;
-  typedef Kokkos::Impl::SharedAllocationTracker  track_type  ;
+                && (!Traits::memory_traits::is_atomic))>::type> {
+  typedef typename Traits::value_type value_type;
+  typedef typename Traits::value_type* KOKKOS_RESTRICT handle_type;
+  typedef typename Traits::value_type& KOKKOS_RESTRICT return_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
 
   KOKKOS_INLINE_FUNCTION
-  static value_type* assign( value_type * arg_data_ptr
-                           , track_type const & /*arg_tracker*/ )
-  {
-    return (value_type*)( arg_data_ptr );
+  static value_type* assign(value_type* arg_data_ptr,
+                            track_type const& /*arg_tracker*/) {
+    return (value_type*)(arg_data_ptr);
   }
 
   KOKKOS_INLINE_FUNCTION
-  static value_type* assign( handle_type const arg_data_ptr
-                           , size_t offset )
-  {
-    return (value_type*)( arg_data_ptr + offset );
+  static value_type* assign(handle_type const arg_data_ptr, size_t offset) {
+    return (value_type*)(arg_data_ptr + offset);
   }
 };
 
-template< class Traits >
-struct ViewDataHandle< Traits ,
-  typename std::enable_if<(
-                            std::is_same< typename Traits::specialize , void >::value
-                            &&
-                            Traits::memory_traits::is_aligned
-			    &&
-                            (!Traits::memory_traits::is_restrict)
+template <class Traits>
+struct ViewDataHandle<
+    Traits, typename std::enable_if<(
+                std::is_same<typename Traits::specialize, void>::value &&
+                Traits::memory_traits::is_aligned &&
+                (!Traits::memory_traits::is_restrict)
 #ifdef KOKKOS_ENABLE_CUDA
-                            &&
-                            (!( std::is_same< typename Traits::memory_space,Kokkos::CudaSpace>::value ||
-                                std::is_same< typename Traits::memory_space,Kokkos::CudaUVMSpace>::value ))
+                && (!(std::is_same<typename Traits::memory_space,
+                                   Kokkos::CudaSpace>::value ||
+                      std::is_same<typename Traits::memory_space,
+                                   Kokkos::CudaUVMSpace>::value))
 #endif
-                            &&
-                            (!Traits::memory_traits::is_atomic)
-                          )>::type >
-{
-  typedef typename Traits::value_type  value_type ;
-  typedef typename Traits::value_type * KOKKOS_IMPL_ALIGN_PTR(KOKKOS_MEMORY_ALIGNMENT) handle_type ;
-  typedef typename Traits::value_type & return_type ;
-  typedef Kokkos::Impl::SharedAllocationTracker  track_type  ;
-
-  KOKKOS_INLINE_FUNCTION
-  static handle_type assign( value_type * arg_data_ptr
-                           , track_type const & /*arg_tracker*/ )
-  {
-    if ( reinterpret_cast<uintptr_t>(arg_data_ptr) % Impl::MEMORY_ALIGNMENT ) {
-      Kokkos::abort("Assigning NonAligned View or Pointer to Kokkos::View with Aligned attribute");
+                && (!Traits::memory_traits::is_atomic))>::type> {
+  typedef typename Traits::value_type value_type;
+  typedef typename Traits::value_type* KOKKOS_IMPL_ALIGN_PTR(
+      KOKKOS_MEMORY_ALIGNMENT) handle_type;
+  typedef typename Traits::value_type& return_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
+
+  KOKKOS_INLINE_FUNCTION
+  static handle_type assign(value_type* arg_data_ptr,
+                            track_type const& /*arg_tracker*/) {
+    if (reinterpret_cast<uintptr_t>(arg_data_ptr) % Impl::MEMORY_ALIGNMENT) {
+      Kokkos::abort(
+          "Assigning NonAligned View or Pointer to Kokkos::View with Aligned "
+          "attribute");
     }
-    return handle_type( arg_data_ptr );
+    return handle_type(arg_data_ptr);
   }
 
   KOKKOS_INLINE_FUNCTION
-  static handle_type assign( handle_type const arg_data_ptr
-                           , size_t offset )
-  {
-    if ( reinterpret_cast<uintptr_t>(arg_data_ptr+offset) % Impl::MEMORY_ALIGNMENT ) {
-      Kokkos::abort("Assigning NonAligned View or Pointer to Kokkos::View with Aligned attribute");
+  static handle_type assign(handle_type const arg_data_ptr, size_t offset) {
+    if (reinterpret_cast<uintptr_t>(arg_data_ptr + offset) %
+        Impl::MEMORY_ALIGNMENT) {
+      Kokkos::abort(
+          "Assigning NonAligned View or Pointer to Kokkos::View with Aligned "
+          "attribute");
     }
-    return handle_type( arg_data_ptr + offset );
+    return handle_type(arg_data_ptr + offset);
   }
 };
 
-template< class Traits >
-struct ViewDataHandle< Traits ,
-  typename std::enable_if<(
-                            std::is_same< typename Traits::specialize , void >::value
-                            &&
-                            Traits::memory_traits::is_aligned
-                            &&
-                            Traits::memory_traits::is_restrict
+template <class Traits>
+struct ViewDataHandle<
+    Traits,
+    typename std::enable_if<(
+        std::is_same<typename Traits::specialize, void>::value &&
+        Traits::memory_traits::is_aligned && Traits::memory_traits::is_restrict
 #ifdef KOKKOS_ENABLE_CUDA
-                            &&
-                            (!( std::is_same< typename Traits::memory_space,Kokkos::CudaSpace>::value ||
-                                std::is_same< typename Traits::memory_space,Kokkos::CudaUVMSpace>::value ))
+        && (!(std::is_same<typename Traits::memory_space,
+                           Kokkos::CudaSpace>::value ||
+              std::is_same<typename Traits::memory_space,
+                           Kokkos::CudaUVMSpace>::value))
 #endif
-                            &&
-                            (!Traits::memory_traits::is_atomic)
-                          )>::type >
-{
-  typedef typename Traits::value_type  value_type ;
-  typedef typename Traits::value_type * KOKKOS_RESTRICT KOKKOS_IMPL_ALIGN_PTR(KOKKOS_MEMORY_ALIGNMENT) handle_type ;
-  typedef typename Traits::value_type & return_type ;
-  typedef Kokkos::Impl::SharedAllocationTracker  track_type  ;
-
-  KOKKOS_INLINE_FUNCTION
-  static value_type* assign( value_type * arg_data_ptr
-                           , track_type const & /*arg_tracker*/ )
-  {
-    if ( reinterpret_cast<uintptr_t>(arg_data_ptr) % Impl::MEMORY_ALIGNMENT ) {
-      Kokkos::abort("Assigning NonAligned View or Pointer to Kokkos::View with Aligned attribute");
+        && (!Traits::memory_traits::is_atomic))>::type> {
+  typedef typename Traits::value_type value_type;
+  typedef typename Traits::value_type* KOKKOS_RESTRICT
+      KOKKOS_IMPL_ALIGN_PTR(KOKKOS_MEMORY_ALIGNMENT) handle_type;
+  typedef typename Traits::value_type& return_type;
+  typedef Kokkos::Impl::SharedAllocationTracker track_type;
+
+  KOKKOS_INLINE_FUNCTION
+  static value_type* assign(value_type* arg_data_ptr,
+                            track_type const& /*arg_tracker*/) {
+    if (reinterpret_cast<uintptr_t>(arg_data_ptr) % Impl::MEMORY_ALIGNMENT) {
+      Kokkos::abort(
+          "Assigning NonAligned View or Pointer to Kokkos::View with Aligned "
+          "attribute");
     }
-    return (value_type*)( arg_data_ptr );
+    return (value_type*)(arg_data_ptr);
   }
 
   KOKKOS_INLINE_FUNCTION
-  static value_type* assign( handle_type const arg_data_ptr
-                           , size_t offset )
-  {
-    if ( reinterpret_cast<uintptr_t>(arg_data_ptr+offset) % Impl::MEMORY_ALIGNMENT ) {
-      Kokkos::abort("Assigning NonAligned View or Pointer to Kokkos::View with Aligned attribute");
+  static value_type* assign(handle_type const arg_data_ptr, size_t offset) {
+    if (reinterpret_cast<uintptr_t>(arg_data_ptr + offset) %
+        Impl::MEMORY_ALIGNMENT) {
+      Kokkos::abort(
+          "Assigning NonAligned View or Pointer to Kokkos::View with Aligned "
+          "attribute");
     }
-    return (value_type*)( arg_data_ptr + offset );
+    return (value_type*)(arg_data_ptr + offset);
   }
 };
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -2484,164 +2734,143 @@ namespace Impl {
  *  called from the shared memory tracking destruction.
  *  Secondarily to have two fewer partial specializations.
  */
-template< class ExecSpace
-        , class ValueType
-        , bool IsScalar = std::is_scalar< ValueType >::value
-        >
-struct ViewValueFunctor ;
-
-template< class ExecSpace , class ValueType >
-struct ViewValueFunctor< ExecSpace , ValueType , false /* is_scalar */ >
-{
-  typedef Kokkos::RangePolicy< ExecSpace > PolicyType ;
+template <class ExecSpace, class ValueType,
+          bool IsScalar = std::is_scalar<ValueType>::value>
+struct ViewValueFunctor;
+
+template <class ExecSpace, class ValueType>
+struct ViewValueFunctor<ExecSpace, ValueType, false /* is_scalar */> {
+  typedef Kokkos::RangePolicy<ExecSpace> PolicyType;
   typedef typename ExecSpace::execution_space Exec;
 
-  Exec        space ;
-  ValueType * ptr ;
-  size_t      n ;
-  bool        destroy ;
+  Exec space;
+  ValueType* ptr;
+  size_t n;
+  bool destroy;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_t i ) const
-    {
-      if ( destroy ) { (ptr+i)->~ValueType(); } //KOKKOS_IMPL_CUDA_CLANG_WORKAROUND this line causes ptax error __cxa_begin_catch in nested_view unit-test
-      else           { new (ptr+i) ValueType(); }
+  void operator()(const size_t i) const {
+    if (destroy) {
+      (ptr + i)->~ValueType();
+    }  // KOKKOS_IMPL_CUDA_CLANG_WORKAROUND this line causes ptax error
+       // __cxa_begin_catch in nested_view unit-test
+    else {
+      new (ptr + i) ValueType();
     }
+  }
+
+  ViewValueFunctor()                        = default;
+  ViewValueFunctor(const ViewValueFunctor&) = default;
+  ViewValueFunctor& operator=(const ViewValueFunctor&) = default;
 
-  ViewValueFunctor() = default ;
-  ViewValueFunctor( const ViewValueFunctor & ) = default ;
-  ViewValueFunctor & operator = ( const ViewValueFunctor & ) = default ;
-
-  ViewValueFunctor( ExecSpace   const & arg_space
-                  , ValueType * const arg_ptr
-                  , size_t      const arg_n )
-    : space( arg_space )
-    , ptr( arg_ptr )
-    , n( arg_n )
-    , destroy( false )
-    {}
-
-  void execute( bool arg )
-    {
-      destroy = arg ;
-      if ( ! space.in_parallel() ) {
+  ViewValueFunctor(ExecSpace const& arg_space, ValueType* const arg_ptr,
+                   size_t const arg_n)
+      : space(arg_space), ptr(arg_ptr), n(arg_n), destroy(false) {}
+
+  void execute(bool arg) {
+    destroy = arg;
+    if (!space.in_parallel()) {
 #if defined(KOKKOS_ENABLE_PROFILING)
-        uint64_t kpID = 0;
-        if(Kokkos::Profiling::profileLibraryLoaded()) {
-          Kokkos::Profiling::beginParallelFor((destroy ? "Kokkos::View::destruction" : "Kokkos::View::initialization"), 0, &kpID);
-        }
+      uint64_t kpID = 0;
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        Kokkos::Profiling::beginParallelFor(
+            (destroy ? "Kokkos::View::destruction"
+                     : "Kokkos::View::initialization"),
+            0, &kpID);
+      }
 #endif
-        const Kokkos::Impl::ParallelFor< ViewValueFunctor , PolicyType >
-          closure( *this , PolicyType( 0 , n ) );
-        closure.execute();
-        space.fence();
+      const Kokkos::Impl::ParallelFor<ViewValueFunctor, PolicyType> closure(
+          *this, PolicyType(0, n));
+      closure.execute();
+      space.fence();
 #if defined(KOKKOS_ENABLE_PROFILING)
-        if(Kokkos::Profiling::profileLibraryLoaded()) {
-          Kokkos::Profiling::endParallelFor(kpID);
-        }
-#endif
-      }
-      else {
-        for ( size_t i = 0 ; i < n ; ++i ) operator()(i);
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        Kokkos::Profiling::endParallelFor(kpID);
       }
+#endif
+    } else {
+      for (size_t i = 0; i < n; ++i) operator()(i);
     }
+  }
 
-  void construct_shared_allocation()
-    { execute( false ); }
+  void construct_shared_allocation() { execute(false); }
 
-  void destroy_shared_allocation()
-    { execute( true ); }
+  void destroy_shared_allocation() { execute(true); }
 };
 
+template <class ExecSpace, class ValueType>
+struct ViewValueFunctor<ExecSpace, ValueType, true /* is_scalar */> {
+  typedef Kokkos::RangePolicy<ExecSpace> PolicyType;
 
-template< class ExecSpace , class ValueType >
-struct ViewValueFunctor< ExecSpace , ValueType , true /* is_scalar */ >
-{
-  typedef Kokkos::RangePolicy< ExecSpace > PolicyType ;
-
-  ExecSpace   space ;
-  ValueType * ptr ;
-  size_t      n ;
+  ExecSpace space;
+  ValueType* ptr;
+  size_t n;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_t i ) const
-    { ptr[i] = ValueType(); }
-
-  ViewValueFunctor() = default ;
-  ViewValueFunctor( const ViewValueFunctor & ) = default ;
-  ViewValueFunctor & operator = ( const ViewValueFunctor & ) = default ;
-
-  ViewValueFunctor( ExecSpace   const & arg_space
-                  , ValueType * const arg_ptr
-                  , size_t      const arg_n )
-    : space( arg_space )
-    , ptr( arg_ptr )
-    , n( arg_n )
-    {}
-
-  void construct_shared_allocation()
-    {
-      if ( ! space.in_parallel() ) {
+  void operator()(const size_t i) const { ptr[i] = ValueType(); }
+
+  ViewValueFunctor()                        = default;
+  ViewValueFunctor(const ViewValueFunctor&) = default;
+  ViewValueFunctor& operator=(const ViewValueFunctor&) = default;
+
+  ViewValueFunctor(ExecSpace const& arg_space, ValueType* const arg_ptr,
+                   size_t const arg_n)
+      : space(arg_space), ptr(arg_ptr), n(arg_n) {}
+
+  void construct_shared_allocation() {
+    if (!space.in_parallel()) {
 #if defined(KOKKOS_ENABLE_PROFILING)
-        uint64_t kpID = 0;
-        if(Kokkos::Profiling::profileLibraryLoaded()) {
-          Kokkos::Profiling::beginParallelFor("Kokkos::View::initialization", 0, &kpID);
-        }
+      uint64_t kpID = 0;
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        Kokkos::Profiling::beginParallelFor("Kokkos::View::initialization", 0,
+                                            &kpID);
+      }
 #endif
-        const Kokkos::Impl::ParallelFor< ViewValueFunctor , PolicyType >
-          closure( *this , PolicyType( 0 , n ) );
-        closure.execute();
-        space.fence();
+      const Kokkos::Impl::ParallelFor<ViewValueFunctor, PolicyType> closure(
+          *this, PolicyType(0, n));
+      closure.execute();
+      space.fence();
 #if defined(KOKKOS_ENABLE_PROFILING)
-        if(Kokkos::Profiling::profileLibraryLoaded()) {
-          Kokkos::Profiling::endParallelFor(kpID);
-        }
-#endif
-      }
-      else {
-        for ( size_t i = 0 ; i < n ; ++i ) operator()(i);
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        Kokkos::Profiling::endParallelFor(kpID);
       }
+#endif
+    } else {
+      for (size_t i = 0; i < n; ++i) operator()(i);
     }
+  }
 
   void destroy_shared_allocation() {}
 };
 
 //----------------------------------------------------------------------------
 /** \brief  View mapping for non-specialized data type and standard layout */
-template< class Traits >
-class ViewMapping< Traits ,
-  typename std::enable_if<(
-    std::is_same< typename Traits::specialize , void >::value
-    &&
-    ViewOffset< typename Traits::dimension
-              , typename Traits::array_layout
-              , void >::is_mapping_plugin::value
-  )>::type >
-{
-
-public:
-  typedef ViewOffset< typename Traits::dimension
-                    , typename Traits::array_layout
-                    , void
-                    >  offset_type ;
+template <class Traits>
+class ViewMapping<
+    Traits,
+    typename std::enable_if<(
+        std::is_same<typename Traits::specialize, void>::value &&
+        ViewOffset<typename Traits::dimension, typename Traits::array_layout,
+                   void>::is_mapping_plugin::value)>::type> {
+ public:
+  typedef ViewOffset<typename Traits::dimension, typename Traits::array_layout,
+                     void>
+      offset_type;
 
-  typedef typename ViewDataHandle< Traits >::handle_type  handle_type ;
+  typedef typename ViewDataHandle<Traits>::handle_type handle_type;
 
-  handle_type  m_impl_handle ;
-  offset_type  m_impl_offset ;
+  handle_type m_impl_handle;
+  offset_type m_impl_offset;
 
-private:
-
-  template < class , class ...> friend class ViewMapping;
+ private:
+  template <class, class...>
+  friend class ViewMapping;
 
   KOKKOS_INLINE_FUNCTION
-  ViewMapping( const handle_type & arg_handle , const offset_type & arg_offset )
-    : m_impl_handle( arg_handle )
-    , m_impl_offset( arg_offset )
-    {}
-
-public:
+  ViewMapping(const handle_type& arg_handle, const offset_type& arg_offset)
+      : m_impl_handle(arg_handle), m_impl_offset(arg_offset) {}
 
+ public:
   typedef void printable_label_typedef;
   enum { is_managed = Traits::is_managed };
 
@@ -2650,61 +2879,100 @@ public:
 
   enum { Rank = Traits::dimension::rank };
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION constexpr size_t extent( const iType & r ) const
-    { return m_impl_offset.m_dim.extent(r); }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION constexpr size_t extent(const iType& r) const {
+    return m_impl_offset.m_dim.extent(r);
+  }
 
-  static KOKKOS_INLINE_FUNCTION constexpr size_t static_extent( const unsigned r ) noexcept
-    {
-      using dim_type = typename offset_type::dimension_type;
-      return dim_type::static_extent(r);
-    }
+  static KOKKOS_INLINE_FUNCTION constexpr size_t static_extent(
+      const unsigned r) noexcept {
+    using dim_type = typename offset_type::dimension_type;
+    return dim_type::static_extent(r);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr
-  typename Traits::array_layout layout() const
-    { return m_impl_offset.layout(); }
+  KOKKOS_INLINE_FUNCTION constexpr typename Traits::array_layout layout()
+      const {
+    return m_impl_offset.layout();
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const { return m_impl_offset.dimension_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return m_impl_offset.dimension_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return m_impl_offset.dimension_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return m_impl_offset.dimension_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return m_impl_offset.dimension_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return m_impl_offset.dimension_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return m_impl_offset.dimension_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return m_impl_offset.dimension_7(); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const {
+    return m_impl_offset.dimension_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const {
+    return m_impl_offset.dimension_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const {
+    return m_impl_offset.dimension_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const {
+    return m_impl_offset.dimension_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const {
+    return m_impl_offset.dimension_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const {
+    return m_impl_offset.dimension_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const {
+    return m_impl_offset.dimension_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const {
+    return m_impl_offset.dimension_7();
+  }
 
   // Is a regular layout with uniform striding for each index.
-  using is_regular = typename offset_type::is_regular ;
+  using is_regular = typename offset_type::is_regular;
 
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return m_impl_offset.stride_0(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return m_impl_offset.stride_1(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return m_impl_offset.stride_2(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return m_impl_offset.stride_3(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return m_impl_offset.stride_4(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return m_impl_offset.stride_5(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return m_impl_offset.stride_6(); }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return m_impl_offset.stride_7(); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const {
+    return m_impl_offset.stride_0();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const {
+    return m_impl_offset.stride_1();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const {
+    return m_impl_offset.stride_2();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const {
+    return m_impl_offset.stride_3();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const {
+    return m_impl_offset.stride_4();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const {
+    return m_impl_offset.stride_5();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const {
+    return m_impl_offset.stride_6();
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const {
+    return m_impl_offset.stride_7();
+  }
 
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION void stride( iType * const s ) const { m_impl_offset.stride(s); }
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    m_impl_offset.stride(s);
+  }
 
   //----------------------------------------
   // Range span
 
   /** \brief  Span of the mapped range */
-  KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return m_impl_offset.span(); }
+  KOKKOS_INLINE_FUNCTION constexpr size_t span() const {
+    return m_impl_offset.span();
+  }
 
   /** \brief  Is the mapped range span contiguous */
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const { return m_impl_offset.span_is_contiguous(); }
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    return m_impl_offset.span_is_contiguous();
+  }
 
-  typedef typename ViewDataHandle< Traits >::return_type  reference_type ;
-  typedef typename Traits::value_type *                   pointer_type ;
+  typedef typename ViewDataHandle<Traits>::return_type reference_type;
+  typedef typename Traits::value_type* pointer_type;
 
   /** \brief  Query raw pointer to memory */
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const
-    {
-      return m_impl_handle;
-    }
+  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const {
+    return m_impl_handle;
+  }
 
   //----------------------------------------
   // The View class performs all rank and bounds checking before
@@ -2713,179 +2981,203 @@ public:
   KOKKOS_FORCEINLINE_FUNCTION
   reference_type reference() const { return m_impl_handle[0]; }
 
-  template< typename I0 >
+  template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename
-    std::enable_if< std::is_integral<I0>::value &&
-                    ! std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
-                  , reference_type >::type
-  reference( const I0 & i0 ) const { return m_impl_handle[i0]; }
+      typename std::enable_if<std::is_integral<I0>::value &&
+                                  !std::is_same<typename Traits::array_layout,
+                                                Kokkos::LayoutStride>::value,
+                              reference_type>::type
+      reference(const I0& i0) const {
+    return m_impl_handle[i0];
+  }
 
-  template< typename I0 >
+  template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
-  typename
-    std::enable_if< std::is_integral<I0>::value &&
-                    std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
-                  , reference_type >::type
-  reference( const I0 & i0 ) const { return m_impl_handle[ m_impl_offset(i0) ]; }
+      typename std::enable_if<std::is_integral<I0>::value &&
+                                  std::is_same<typename Traits::array_layout,
+                                               Kokkos::LayoutStride>::value,
+                              reference_type>::type
+      reference(const I0& i0) const {
+    return m_impl_handle[m_impl_offset(i0)];
+  }
 
-  template< typename I0 , typename I1 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 ) const
-    { return m_impl_handle[ m_impl_offset(i0,i1) ]; }
+  template <typename I0, typename I1>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0& i0,
+                                                       const I1& i1) const {
+    return m_impl_handle[m_impl_offset(i0, i1)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 ) const
-    { return m_impl_handle[ m_impl_offset(i0,i1,i2) ]; }
+  template <typename I0, typename I1, typename I2>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0& i0,
+                                                       const I1& i1,
+                                                       const I2& i2) const {
+    return m_impl_handle[m_impl_offset(i0, i1, i2)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 ) const
-    { return m_impl_handle[ m_impl_offset(i0,i1,i2,i3) ]; }
+  template <typename I0, typename I1, typename I2, typename I3>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0& i0, const I1& i1, const I2& i2, const I3& i3) const {
+    return m_impl_handle[m_impl_offset(i0, i1, i2, i3)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 ) const
-    { return m_impl_handle[ m_impl_offset(i0,i1,i2,i3,i4) ]; }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0& i0,
+                                                       const I1& i1,
+                                                       const I2& i2,
+                                                       const I3& i3,
+                                                       const I4& i4) const {
+    return m_impl_handle[m_impl_offset(i0, i1, i2, i3, i4)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 , const I5 & i5 ) const
-    { return m_impl_handle[ m_impl_offset(i0,i1,i2,i3,i4,i5) ]; }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+            const I4& i4, const I5& i5) const {
+    return m_impl_handle[m_impl_offset(i0, i1, i2, i3, i4, i5)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 , const I5 & i5 , const I6 & i6 ) const
-    { return m_impl_handle[ m_impl_offset(i0,i1,i2,i3,i4,i5,i6) ]; }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+            const I4& i4, const I5& i5, const I6& i6) const {
+    return m_impl_handle[m_impl_offset(i0, i1, i2, i3, i4, i5, i6)];
+  }
 
-  template< typename I0 , typename I1 , typename I2 , typename I3
-          , typename I4 , typename I5 , typename I6 , typename I7 >
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
-                          , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7 ) const
-    { return m_impl_handle[ m_impl_offset(i0,i1,i2,i3,i4,i5,i6,i7) ]; }
+  template <typename I0, typename I1, typename I2, typename I3, typename I4,
+            typename I5, typename I6, typename I7>
+  KOKKOS_FORCEINLINE_FUNCTION reference_type
+  reference(const I0& i0, const I1& i1, const I2& i2, const I3& i3,
+            const I4& i4, const I5& i5, const I6& i6, const I7& i7) const {
+    return m_impl_handle[m_impl_offset(i0, i1, i2, i3, i4, i5, i6, i7)];
+  }
 
   //----------------------------------------
 
-private:
-
+ private:
   enum { MemorySpanMask = 8 - 1 /* Force alignment on 8 byte boundary */ };
   enum { MemorySpanSize = sizeof(typename Traits::value_type) };
 
-public:
-
+ public:
   /** \brief  Span, in bytes, of the referenced memory */
-  KOKKOS_INLINE_FUNCTION constexpr size_t memory_span() const
-    {
-      return ( m_impl_offset.span() * sizeof(typename Traits::value_type) + MemorySpanMask ) & ~size_t(MemorySpanMask);
-    }
+  KOKKOS_INLINE_FUNCTION constexpr size_t memory_span() const {
+    return (m_impl_offset.span() * sizeof(typename Traits::value_type) +
+            MemorySpanMask) &
+           ~size_t(MemorySpanMask);
+  }
 
   //----------------------------------------
 
   KOKKOS_INLINE_FUNCTION ~ViewMapping() {}
   KOKKOS_INLINE_FUNCTION ViewMapping() : m_impl_handle(), m_impl_offset() {}
-  KOKKOS_INLINE_FUNCTION ViewMapping( const ViewMapping & rhs )
-    : m_impl_handle( rhs.m_impl_handle ), m_impl_offset( rhs.m_impl_offset ) {}
-  KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( const ViewMapping & rhs )
-    { m_impl_handle = rhs.m_impl_handle ; m_impl_offset = rhs.m_impl_offset ; return *this ; }
+  KOKKOS_INLINE_FUNCTION ViewMapping(const ViewMapping& rhs)
+      : m_impl_handle(rhs.m_impl_handle), m_impl_offset(rhs.m_impl_offset) {}
+  KOKKOS_INLINE_FUNCTION ViewMapping& operator=(const ViewMapping& rhs) {
+    m_impl_handle = rhs.m_impl_handle;
+    m_impl_offset = rhs.m_impl_offset;
+    return *this;
+  }
 
-  KOKKOS_INLINE_FUNCTION ViewMapping( ViewMapping && rhs )
-    : m_impl_handle( rhs.m_impl_handle ), m_impl_offset( rhs.m_impl_offset ) {}
-  KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( ViewMapping && rhs )
-    { m_impl_handle = rhs.m_impl_handle ; m_impl_offset = rhs.m_impl_offset ; return *this ; }
+  KOKKOS_INLINE_FUNCTION ViewMapping(ViewMapping&& rhs)
+      : m_impl_handle(rhs.m_impl_handle), m_impl_offset(rhs.m_impl_offset) {}
+  KOKKOS_INLINE_FUNCTION ViewMapping& operator=(ViewMapping&& rhs) {
+    m_impl_handle = rhs.m_impl_handle;
+    m_impl_offset = rhs.m_impl_offset;
+    return *this;
+  }
 
   //----------------------------------------
 
   /**\brief  Span, in bytes, of the required memory */
   KOKKOS_INLINE_FUNCTION
-  static constexpr size_t memory_span( typename Traits::array_layout const & arg_layout )
-    {
-      typedef std::integral_constant< unsigned , 0 >  padding ;
-      return ( offset_type( padding(), arg_layout ).span() * MemorySpanSize + MemorySpanMask ) & ~size_t(MemorySpanMask);
-    }
+  static constexpr size_t memory_span(
+      typename Traits::array_layout const& arg_layout) {
+    typedef std::integral_constant<unsigned, 0> padding;
+    return (offset_type(padding(), arg_layout).span() * MemorySpanSize +
+            MemorySpanMask) &
+           ~size_t(MemorySpanMask);
+  }
 
   /**\brief  Wrap a span of memory */
-  template< class ... P >
-  KOKKOS_INLINE_FUNCTION
-  ViewMapping( Kokkos::Impl::ViewCtorProp< P ... > const & arg_prop
-             , typename Traits::array_layout const & arg_layout
-             )
-    : m_impl_handle( ( (Kokkos::Impl::ViewCtorProp<void,pointer_type> const &) arg_prop ).value )
-    , m_impl_offset( std::integral_constant< unsigned , 0 >() , arg_layout )
-    {}
+  template <class... P>
+  KOKKOS_INLINE_FUNCTION ViewMapping(
+      Kokkos::Impl::ViewCtorProp<P...> const& arg_prop,
+      typename Traits::array_layout const& arg_layout)
+      : m_impl_handle(
+            ((Kokkos::Impl::ViewCtorProp<void, pointer_type> const&)arg_prop)
+                .value),
+        m_impl_offset(std::integral_constant<unsigned, 0>(), arg_layout) {}
 
   /**\brief  Assign data */
   KOKKOS_INLINE_FUNCTION
-  void assign_data( pointer_type arg_ptr )
-    { m_impl_handle = handle_type( arg_ptr ); }
+  void assign_data(pointer_type arg_ptr) {
+    m_impl_handle = handle_type(arg_ptr);
+  }
 
   //----------------------------------------
   /*  Allocate and construct mapped array.
    *  Allocate via shared allocation record and
    *  return that record for allocation tracking.
    */
-  template< class ... P >
-  Kokkos::Impl::SharedAllocationRecord<> *
-  allocate_shared( Kokkos::Impl::ViewCtorProp< P... > const & arg_prop
-                 , typename Traits::array_layout const & arg_layout )
-  {
-    typedef Kokkos::Impl::ViewCtorProp< P... > alloc_prop ;
-
-    typedef typename alloc_prop::execution_space  execution_space ;
-    typedef typename Traits::memory_space         memory_space ;
-    typedef typename Traits::value_type           value_type ;
-    typedef ViewValueFunctor< execution_space , value_type > functor_type ;
-    typedef Kokkos::Impl::SharedAllocationRecord< memory_space , functor_type > record_type ;
+  template <class... P>
+  Kokkos::Impl::SharedAllocationRecord<>* allocate_shared(
+      Kokkos::Impl::ViewCtorProp<P...> const& arg_prop,
+      typename Traits::array_layout const& arg_layout) {
+    typedef Kokkos::Impl::ViewCtorProp<P...> alloc_prop;
+
+    typedef typename alloc_prop::execution_space execution_space;
+    typedef typename Traits::memory_space memory_space;
+    typedef typename Traits::value_type value_type;
+    typedef ViewValueFunctor<execution_space, value_type> functor_type;
+    typedef Kokkos::Impl::SharedAllocationRecord<memory_space, functor_type>
+        record_type;
 
     // Query the mapping for byte-size of allocation.
     // If padding is allowed then pass in sizeof value type
     // for padding computation.
-    typedef std::integral_constant
-      < unsigned
-      , alloc_prop::allow_padding ? sizeof(value_type) : 0
-      > padding ;
+    typedef std::integral_constant<
+        unsigned, alloc_prop::allow_padding ? sizeof(value_type) : 0>
+        padding;
 
-    m_impl_offset = offset_type( padding(), arg_layout );
+    m_impl_offset = offset_type(padding(), arg_layout);
 
     const size_t alloc_size =
-      ( m_impl_offset.span() * MemorySpanSize + MemorySpanMask ) & ~size_t(MemorySpanMask);
+        (m_impl_offset.span() * MemorySpanSize + MemorySpanMask) &
+        ~size_t(MemorySpanMask);
 
-    // Create shared memory tracking record with allocate memory from the memory space
-    record_type * const record =
-      record_type::allocate( ( (Kokkos::Impl::ViewCtorProp<void,memory_space> const &) arg_prop ).value
-                           , ( (Kokkos::Impl::ViewCtorProp<void,std::string>  const &) arg_prop ).value
-                           , alloc_size );
+    // Create shared memory tracking record with allocate memory from the memory
+    // space
+    record_type* const record = record_type::allocate(
+        ((Kokkos::Impl::ViewCtorProp<void, memory_space> const&)arg_prop).value,
+        ((Kokkos::Impl::ViewCtorProp<void, std::string> const&)arg_prop).value,
+        alloc_size);
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    if ( alloc_size ) {
+    if (alloc_size) {
 #endif
-    m_impl_handle = handle_type( reinterpret_cast< pointer_type >( record->data() ) );
+      m_impl_handle =
+          handle_type(reinterpret_cast<pointer_type>(record->data()));
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     }
 #endif
 
     //  Only initialize if the allocation is non-zero.
     //  May be zero if one of the dimensions is zero.
-    if ( alloc_size && alloc_prop::initialize ) {
+    if (alloc_size && alloc_prop::initialize) {
       // Assume destruction is only required when construction is requested.
-      // The ViewValueFunctor has both value construction and destruction operators.
-      record->m_destroy = functor_type( ( (Kokkos::Impl::ViewCtorProp<void,execution_space> const &) arg_prop).value
-                                      , (value_type *) m_impl_handle
-                                      , m_impl_offset.span()
-                                      );
+      // The ViewValueFunctor has both value construction and destruction
+      // operators.
+      record->m_destroy = functor_type(
+          ((Kokkos::Impl::ViewCtorProp<void, execution_space> const&)arg_prop)
+              .value,
+          (value_type*)m_impl_handle, m_impl_offset.span());
 
       // Construct values
       record->m_destroy.construct_shared_allocation();
     }
 
-    return record ;
+    return record;
   }
 };
 
@@ -2893,243 +3185,302 @@ public:
 //----------------------------------------------------------------------------
 /** \brief  Assign compatible default mappings */
 
-template< class DstTraits , class SrcTraits >
-class ViewMapping< DstTraits , SrcTraits ,
-  typename std::enable_if<(
-    !(std::is_same<typename SrcTraits::array_layout, LayoutStride>::value) && //Added to have a new specialization for SrcType of LayoutStride
-    // default mappings
-    std::is_same< typename DstTraits::specialize , void >::value
-    &&
-    std::is_same< typename SrcTraits::specialize , void >::value
-    &&
-    (
-      // same layout
-      std::is_same< typename DstTraits::array_layout , typename SrcTraits::array_layout >::value
-      ||
-      // known layout
-      (
-        (
-          std::is_same< typename DstTraits::array_layout , Kokkos::LayoutLeft >::value ||
-          std::is_same< typename DstTraits::array_layout , Kokkos::LayoutRight >::value ||
-          std::is_same< typename DstTraits::array_layout , Kokkos::LayoutStride >::value
-        )
-        &&
+template <class DstTraits, class SrcTraits>
+class ViewMapping<
+    DstTraits, SrcTraits,
+    typename std::enable_if<(
+        !(std::is_same<typename SrcTraits::array_layout, LayoutStride>::
+              value) &&  // Added to have a new specialization for SrcType of
+                         // LayoutStride
+        // default mappings
+        std::is_same<typename DstTraits::specialize, void>::value &&
+        std::is_same<typename SrcTraits::specialize, void>::value &&
         (
-          std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value ||
-          std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value ||
-          std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutStride >::value
-        )
-      )
-    )
-  )>::type >
-{
-private:
-
-  enum { is_assignable_space =
+            // same layout
+            std::is_same<typename DstTraits::array_layout,
+                         typename SrcTraits::array_layout>::value ||
+            // known layout
+            ((std::is_same<typename DstTraits::array_layout,
+                           Kokkos::LayoutLeft>::value ||
+              std::is_same<typename DstTraits::array_layout,
+                           Kokkos::LayoutRight>::value ||
+              std::is_same<typename DstTraits::array_layout,
+                           Kokkos::LayoutStride>::value) &&
+             (std::is_same<typename SrcTraits::array_layout,
+                           Kokkos::LayoutLeft>::value ||
+              std::is_same<typename SrcTraits::array_layout,
+                           Kokkos::LayoutRight>::value ||
+              std::is_same<typename SrcTraits::array_layout,
+                           Kokkos::LayoutStride>::value))))>::type> {
+ private:
+  enum {
+    is_assignable_space =
 #if 1
-   Kokkos::Impl::MemorySpaceAccess
-     < typename DstTraits::memory_space
-     , typename SrcTraits::memory_space >::assignable };
+        Kokkos::Impl::MemorySpaceAccess<
+            typename DstTraits::memory_space,
+            typename SrcTraits::memory_space>::assignable
+  };
 #else
-   std::is_same< typename DstTraits::memory_space
-               , typename SrcTraits::memory_space >::value };
+        std::is_same<typename DstTraits::memory_space,
+                     typename SrcTraits::memory_space>::value
+  };
 #endif
 
-  enum { is_assignable_value_type =
-    std::is_same< typename DstTraits::value_type
-                , typename SrcTraits::value_type >::value ||
-    std::is_same< typename DstTraits::value_type
-                , typename SrcTraits::const_value_type >::value };
-
-  enum { is_assignable_dimension =
-    ViewDimensionAssignable< typename DstTraits::dimension
-                           , typename SrcTraits::dimension >::value };
-
-  enum { is_assignable_layout =
-    std::is_same< typename DstTraits::array_layout
-                , typename SrcTraits::array_layout >::value ||
-    std::is_same< typename DstTraits::array_layout
-                , Kokkos::LayoutStride >::value ||
-    ( DstTraits::dimension::rank == 0 ) ||
-    ( DstTraits::dimension::rank == 1 &&
-      DstTraits::dimension::rank_dynamic == 1 )
-    };
+  enum {
+    is_assignable_value_type =
+        std::is_same<typename DstTraits::value_type,
+                     typename SrcTraits::value_type>::value ||
+        std::is_same<typename DstTraits::value_type,
+                     typename SrcTraits::const_value_type>::value
+  };
+
+  enum {
+    is_assignable_dimension =
+        ViewDimensionAssignable<typename DstTraits::dimension,
+                                typename SrcTraits::dimension>::value
+  };
 
-public:
-  enum { is_assignable_data_type = is_assignable_value_type &&
-                                   is_assignable_dimension };
-  enum { is_assignable = is_assignable_space &&
-                         is_assignable_value_type &&
-                         is_assignable_dimension &&
-                         is_assignable_layout };
+  enum {
+    is_assignable_layout =
+        std::is_same<typename DstTraits::array_layout,
+                     typename SrcTraits::array_layout>::value ||
+        std::is_same<typename DstTraits::array_layout,
+                     Kokkos::LayoutStride>::value ||
+        (DstTraits::dimension::rank == 0) ||
+        (DstTraits::dimension::rank == 1 &&
+         DstTraits::dimension::rank_dynamic == 1)
+  };
 
-  typedef Kokkos::Impl::SharedAllocationTracker  TrackType ;
-  typedef ViewMapping< DstTraits , void >  DstType ;
-  typedef ViewMapping< SrcTraits , void >  SrcType ;
+ public:
+  enum {
+    is_assignable_data_type =
+        is_assignable_value_type && is_assignable_dimension
+  };
+  enum {
+    is_assignable = is_assignable_space && is_assignable_value_type &&
+                    is_assignable_dimension && is_assignable_layout
+  };
 
-  KOKKOS_INLINE_FUNCTION
-  static void assign( DstType & dst , const SrcType & src , const TrackType & src_track )
-    {
-      static_assert( is_assignable_space
-                   , "View assignment must have compatible spaces" );
-
-      static_assert( is_assignable_value_type
-                   , "View assignment must have same value type or const = non-const" );
-
-      static_assert( is_assignable_dimension
-                   , "View assignment must have compatible dimensions" );
-
-      static_assert( is_assignable_layout
-                   , "View assignment must have compatible layout or have rank <= 1" );
-
-      typedef typename DstType::offset_type  dst_offset_type ;
-
-      if ( size_t(DstTraits::dimension::rank_dynamic) < size_t(SrcTraits::dimension::rank_dynamic) ) {
-        typedef typename DstTraits::dimension dst_dim;
-        bool assignable =
-          ( ( 1 > DstTraits::dimension::rank_dynamic && 1 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN0 == src.dimension_0() : true ) &&
-          ( ( 2 > DstTraits::dimension::rank_dynamic && 2 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN1 == src.dimension_1() : true ) &&
-          ( ( 3 > DstTraits::dimension::rank_dynamic && 3 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN2 == src.dimension_2() : true ) &&
-          ( ( 4 > DstTraits::dimension::rank_dynamic && 4 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN3 == src.dimension_3() : true ) &&
-          ( ( 5 > DstTraits::dimension::rank_dynamic && 5 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN4 == src.dimension_4() : true ) &&
-          ( ( 6 > DstTraits::dimension::rank_dynamic && 6 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN5 == src.dimension_5() : true ) &&
-          ( ( 7 > DstTraits::dimension::rank_dynamic && 7 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN6 == src.dimension_6() : true ) &&
-          ( ( 8 > DstTraits::dimension::rank_dynamic && 8 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN7 == src.dimension_7() : true )
-          ;
-        if(!assignable)
-          Kokkos::abort("View Assignment: trying to assign runtime dimension to non matching compile time dimension.");
-      }
-      dst.m_impl_offset = dst_offset_type( src.m_impl_offset );
-      dst.m_impl_handle = Kokkos::Impl::ViewDataHandle< DstTraits >::assign( src.m_impl_handle , src_track );
+  typedef Kokkos::Impl::SharedAllocationTracker TrackType;
+  typedef ViewMapping<DstTraits, void> DstType;
+  typedef ViewMapping<SrcTraits, void> SrcType;
+
+  KOKKOS_INLINE_FUNCTION
+  static void assign(DstType& dst, const SrcType& src,
+                     const TrackType& src_track) {
+    static_assert(is_assignable_space,
+                  "View assignment must have compatible spaces");
+
+    static_assert(
+        is_assignable_value_type,
+        "View assignment must have same value type or const = non-const");
+
+    static_assert(is_assignable_dimension,
+                  "View assignment must have compatible dimensions");
+
+    static_assert(
+        is_assignable_layout,
+        "View assignment must have compatible layout or have rank <= 1");
+
+    typedef typename DstType::offset_type dst_offset_type;
+
+    if (size_t(DstTraits::dimension::rank_dynamic) <
+        size_t(SrcTraits::dimension::rank_dynamic)) {
+      typedef typename DstTraits::dimension dst_dim;
+      bool assignable = ((1 > DstTraits::dimension::rank_dynamic &&
+                          1 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN0 == src.dimension_0()
+                             : true) &&
+                        ((2 > DstTraits::dimension::rank_dynamic &&
+                          2 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN1 == src.dimension_1()
+                             : true) &&
+                        ((3 > DstTraits::dimension::rank_dynamic &&
+                          3 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN2 == src.dimension_2()
+                             : true) &&
+                        ((4 > DstTraits::dimension::rank_dynamic &&
+                          4 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN3 == src.dimension_3()
+                             : true) &&
+                        ((5 > DstTraits::dimension::rank_dynamic &&
+                          5 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN4 == src.dimension_4()
+                             : true) &&
+                        ((6 > DstTraits::dimension::rank_dynamic &&
+                          6 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN5 == src.dimension_5()
+                             : true) &&
+                        ((7 > DstTraits::dimension::rank_dynamic &&
+                          7 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN6 == src.dimension_6()
+                             : true) &&
+                        ((8 > DstTraits::dimension::rank_dynamic &&
+                          8 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN7 == src.dimension_7()
+                             : true);
+      if (!assignable)
+        Kokkos::abort(
+            "View Assignment: trying to assign runtime dimension to non "
+            "matching compile time dimension.");
     }
+    dst.m_impl_offset = dst_offset_type(src.m_impl_offset);
+    dst.m_impl_handle = Kokkos::Impl::ViewDataHandle<DstTraits>::assign(
+        src.m_impl_handle, src_track);
+  }
 };
 
 //----------------------------------------------------------------------------
-//Create new specialization for SrcType of LayoutStride. Runtime check for compatible layout
-template< class DstTraits , class SrcTraits >
-class ViewMapping< DstTraits , SrcTraits ,
-  typename std::enable_if<(
-    std::is_same< typename SrcTraits::array_layout, Kokkos::LayoutStride >::value
-    &&
-    std::is_same< typename DstTraits::specialize , void >::value
-    &&
-    std::is_same< typename SrcTraits::specialize , void >::value
-    &&
-    (
-      // same layout
-      std::is_same< typename DstTraits::array_layout , typename SrcTraits::array_layout >::value
-      ||
-      // known layout
-      (
-        std::is_same< typename DstTraits::array_layout , Kokkos::LayoutLeft >::value ||
-        std::is_same< typename DstTraits::array_layout , Kokkos::LayoutRight >::value ||
-        std::is_same< typename DstTraits::array_layout , Kokkos::LayoutStride >::value
-      )
-    )
-  )>::type >
-{
-private:
-
-  enum { is_assignable_space =
-   Kokkos::Impl::MemorySpaceAccess
-     < typename DstTraits::memory_space
-     , typename SrcTraits::memory_space >::assignable };
-
-  enum { is_assignable_value_type =
-    std::is_same< typename DstTraits::value_type
-                , typename SrcTraits::value_type >::value ||
-    std::is_same< typename DstTraits::value_type
-                , typename SrcTraits::const_value_type >::value };
-
-  enum { is_assignable_dimension =
-    ViewDimensionAssignable< typename DstTraits::dimension
-                           , typename SrcTraits::dimension >::value };
-
-public:
-  enum { is_assignable_data_type = is_assignable_value_type &&
-                                   is_assignable_dimension };
-  enum { is_assignable = is_assignable_space &&
-                         is_assignable_value_type &&
-                         is_assignable_dimension };
-
-  typedef Kokkos::Impl::SharedAllocationTracker  TrackType ;
-  typedef ViewMapping< DstTraits , void >  DstType ;
-  typedef ViewMapping< SrcTraits , void >  SrcType ;
+// Create new specialization for SrcType of LayoutStride. Runtime check for
+// compatible layout
+template <class DstTraits, class SrcTraits>
+class ViewMapping<
+    DstTraits, SrcTraits,
+    typename std::enable_if<(
+        std::is_same<typename SrcTraits::array_layout,
+                     Kokkos::LayoutStride>::value &&
+        std::is_same<typename DstTraits::specialize, void>::value &&
+        std::is_same<typename SrcTraits::specialize, void>::value &&
+        (
+            // same layout
+            std::is_same<typename DstTraits::array_layout,
+                         typename SrcTraits::array_layout>::value ||
+            // known layout
+            (std::is_same<typename DstTraits::array_layout,
+                          Kokkos::LayoutLeft>::value ||
+             std::is_same<typename DstTraits::array_layout,
+                          Kokkos::LayoutRight>::value ||
+             std::is_same<typename DstTraits::array_layout,
+                          Kokkos::LayoutStride>::value)))>::type> {
+ private:
+  enum {
+    is_assignable_space = Kokkos::Impl::MemorySpaceAccess<
+        typename DstTraits::memory_space,
+        typename SrcTraits::memory_space>::assignable
+  };
+
+  enum {
+    is_assignable_value_type =
+        std::is_same<typename DstTraits::value_type,
+                     typename SrcTraits::value_type>::value ||
+        std::is_same<typename DstTraits::value_type,
+                     typename SrcTraits::const_value_type>::value
+  };
+
+  enum {
+    is_assignable_dimension =
+        ViewDimensionAssignable<typename DstTraits::dimension,
+                                typename SrcTraits::dimension>::value
+  };
+
+ public:
+  enum {
+    is_assignable_data_type =
+        is_assignable_value_type && is_assignable_dimension
+  };
+  enum {
+    is_assignable = is_assignable_space && is_assignable_value_type &&
+                    is_assignable_dimension
+  };
+
+  typedef Kokkos::Impl::SharedAllocationTracker TrackType;
+  typedef ViewMapping<DstTraits, void> DstType;
+  typedef ViewMapping<SrcTraits, void> SrcType;
 
   KOKKOS_INLINE_FUNCTION
-  static bool assignable_layout_check(DstType &, const SrcType & src) //Runtime check
-    {
-      size_t strides[9];
-      bool assignable = true;
-      src.stride(strides);
-      size_t exp_stride = 1;
-      if (std::is_same< typename DstTraits::array_layout, Kokkos::LayoutLeft >::value) {
-	    for(int i=0; i<src.Rank; i++) {
-          if (i>0) exp_stride *= src.extent(i-1);
-          if (strides[i] != exp_stride){assignable=false;break;}
-	    }
+  static bool assignable_layout_check(DstType&,
+                                      const SrcType& src)  // Runtime check
+  {
+    size_t strides[9];
+    bool assignable = true;
+    src.stride(strides);
+    size_t exp_stride = 1;
+    if (std::is_same<typename DstTraits::array_layout,
+                     Kokkos::LayoutLeft>::value) {
+      for (int i = 0; i < src.Rank; i++) {
+        if (i > 0) exp_stride *= src.extent(i - 1);
+        if (strides[i] != exp_stride) {
+          assignable = false;
+          break;
+        }
       }
-      else if (std::is_same< typename DstTraits::array_layout, Kokkos::LayoutRight >::value) {
-	    for(int i=src.Rank-1; i>=0; i--) {
-          if (i<src.Rank-1) exp_stride *= src.extent(i+1);
-          if (strides[i] != exp_stride){assignable=false;break;}
-	    }
+    } else if (std::is_same<typename DstTraits::array_layout,
+                            Kokkos::LayoutRight>::value) {
+      for (int i = src.Rank - 1; i >= 0; i--) {
+        if (i < src.Rank - 1) exp_stride *= src.extent(i + 1);
+        if (strides[i] != exp_stride) {
+          assignable = false;
+          break;
+        }
       }
-      return assignable; 
     }
+    return assignable;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void assign( DstType & dst , const SrcType & src , const TrackType & src_track )
-    {
-      static_assert( is_assignable_space
-                   , "View assignment must have compatible spaces" );
-
-      static_assert( is_assignable_value_type
-                   , "View assignment must have same value type or const = non-const" );
-
-      static_assert( is_assignable_dimension
-                   , "View assignment must have compatible dimensions" );
-
-      bool assignable_layout = assignable_layout_check(dst, src); //Runtime check
-      if(!assignable_layout)
-          Kokkos::abort("View assignment must have compatible layouts\n");
-	  
-      typedef typename DstType::offset_type  dst_offset_type ;
-
-      if ( size_t(DstTraits::dimension::rank_dynamic) < size_t(SrcTraits::dimension::rank_dynamic) ) {
-        typedef typename DstTraits::dimension dst_dim;
-        bool assignable =
-          ( ( 1 > DstTraits::dimension::rank_dynamic && 1 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN0 == src.dimension_0() : true ) &&
-          ( ( 2 > DstTraits::dimension::rank_dynamic && 2 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN1 == src.dimension_1() : true ) &&
-          ( ( 3 > DstTraits::dimension::rank_dynamic && 3 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN2 == src.dimension_2() : true ) &&
-          ( ( 4 > DstTraits::dimension::rank_dynamic && 4 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN3 == src.dimension_3() : true ) &&
-          ( ( 5 > DstTraits::dimension::rank_dynamic && 5 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN4 == src.dimension_4() : true ) &&
-          ( ( 6 > DstTraits::dimension::rank_dynamic && 6 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN5 == src.dimension_5() : true ) &&
-          ( ( 7 > DstTraits::dimension::rank_dynamic && 7 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN6 == src.dimension_6() : true ) &&
-          ( ( 8 > DstTraits::dimension::rank_dynamic && 8 <= SrcTraits::dimension::rank_dynamic ) ?
-            dst_dim::ArgN7 == src.dimension_7() : true )
-          ;
-        if(!assignable)
-          Kokkos::abort("View Assignment: trying to assign runtime dimension to non matching compile time dimension.");
-      }
-      dst.m_impl_offset = dst_offset_type( src.m_impl_offset );
-      dst.m_impl_handle = Kokkos::Impl::ViewDataHandle< DstTraits >::assign( src.m_impl_handle , src_track );
+  static void assign(DstType& dst, const SrcType& src,
+                     const TrackType& src_track) {
+    static_assert(is_assignable_space,
+                  "View assignment must have compatible spaces");
+
+    static_assert(
+        is_assignable_value_type,
+        "View assignment must have same value type or const = non-const");
+
+    static_assert(is_assignable_dimension,
+                  "View assignment must have compatible dimensions");
+
+    bool assignable_layout = assignable_layout_check(dst, src);  // Runtime
+                                                                 // check
+    if (!assignable_layout)
+      Kokkos::abort("View assignment must have compatible layouts\n");
+
+    typedef typename DstType::offset_type dst_offset_type;
+
+    if (size_t(DstTraits::dimension::rank_dynamic) <
+        size_t(SrcTraits::dimension::rank_dynamic)) {
+      typedef typename DstTraits::dimension dst_dim;
+      bool assignable = ((1 > DstTraits::dimension::rank_dynamic &&
+                          1 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN0 == src.dimension_0()
+                             : true) &&
+                        ((2 > DstTraits::dimension::rank_dynamic &&
+                          2 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN1 == src.dimension_1()
+                             : true) &&
+                        ((3 > DstTraits::dimension::rank_dynamic &&
+                          3 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN2 == src.dimension_2()
+                             : true) &&
+                        ((4 > DstTraits::dimension::rank_dynamic &&
+                          4 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN3 == src.dimension_3()
+                             : true) &&
+                        ((5 > DstTraits::dimension::rank_dynamic &&
+                          5 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN4 == src.dimension_4()
+                             : true) &&
+                        ((6 > DstTraits::dimension::rank_dynamic &&
+                          6 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN5 == src.dimension_5()
+                             : true) &&
+                        ((7 > DstTraits::dimension::rank_dynamic &&
+                          7 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN6 == src.dimension_6()
+                             : true) &&
+                        ((8 > DstTraits::dimension::rank_dynamic &&
+                          8 <= SrcTraits::dimension::rank_dynamic)
+                             ? dst_dim::ArgN7 == src.dimension_7()
+                             : true);
+      if (!assignable)
+        Kokkos::abort(
+            "View Assignment: trying to assign runtime dimension to non "
+            "matching compile time dimension.");
     }
+    dst.m_impl_offset = dst_offset_type(src.m_impl_offset);
+    dst.m_impl_handle = Kokkos::Impl::ViewDataHandle<DstTraits>::assign(
+        src.m_impl_handle, src_track);
+  }
 };
 
 //----------------------------------------------------------------------------
@@ -3142,144 +3493,130 @@ struct SubViewDataTypeImpl;
 
 /* base case */
 template <class ValueType>
-struct SubViewDataTypeImpl<
-  void,
-  ValueType,
-  Experimental::Extents<>
->
-{ using type = ValueType; };
+struct SubViewDataTypeImpl<void, ValueType, Experimental::Extents<> > {
+  using type = ValueType;
+};
 
 /* for integral args, subview doesn't have that dimension */
-template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class Integral, class... Args>
+template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class Integral,
+          class... Args>
 struct SubViewDataTypeImpl<
-  typename std::enable_if<std::is_integral<typename std::decay<Integral>::type>::value>::type,
-  ValueType,
-  Experimental::Extents<Ext, Exts...>,
-  Integral, Args...
-> : SubViewDataTypeImpl<
-      void, ValueType,
-      Experimental::Extents<Exts...>,
-      Args...
-    >
-{ };
-
+    typename std::enable_if<
+        std::is_integral<typename std::decay<Integral>::type>::value>::type,
+    ValueType, Experimental::Extents<Ext, Exts...>, Integral, Args...>
+    : SubViewDataTypeImpl<void, ValueType, Experimental::Extents<Exts...>,
+                          Args...> {};
 
 /* for ALL slice, subview has the same dimension */
 template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class... Args>
+struct SubViewDataTypeImpl<void, ValueType, Experimental::Extents<Ext, Exts...>,
+                           ALL_t, Args...>
+    : SubViewDataTypeImpl<void, typename ApplyExtent<ValueType, Ext>::type,
+                          Experimental::Extents<Exts...>, Args...> {};
+
+/* for pair-style slice, subview has dynamic dimension, since pair doesn't give
+ * static sizes */
+/* Since we don't allow interleaving of dynamic and static extents, make all of
+ * the dimensions to the left dynamic  */
+template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class PairLike,
+          class... Args>
 struct SubViewDataTypeImpl<
-  void,
-  ValueType,
-  Experimental::Extents<Ext, Exts...>,
-  ALL_t, Args...
-> : SubViewDataTypeImpl<
-      void, typename ApplyExtent<ValueType, Ext>::type,
-      Experimental::Extents<Exts...>,
-      Args...
-    >
-{ };
-
-
-/* for pair-style slice, subview has dynamic dimension, since pair doesn't give static sizes */
-/* Since we don't allow interleaving of dynamic and static extents, make all of the dimensions to the left dynamic  */
-template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class PairLike, class... Args>
-struct SubViewDataTypeImpl<
-  typename std::enable_if<is_pair_like<PairLike>::value>::type,
-  ValueType,
-  Experimental::Extents<Ext, Exts...>,
-  PairLike, Args...
-> : SubViewDataTypeImpl<
-      void, typename make_all_extents_into_pointers<ValueType>::type*,
-      Experimental::Extents<Exts...>,
-      Args...
-    >
-{ };
-
+    typename std::enable_if<is_pair_like<PairLike>::value>::type, ValueType,
+    Experimental::Extents<Ext, Exts...>, PairLike, Args...>
+    : SubViewDataTypeImpl<
+          void, typename make_all_extents_into_pointers<ValueType>::type*,
+          Experimental::Extents<Exts...>, Args...> {};
 
 template <class ValueType, class Exts, class... Args>
-struct SubViewDataType
-  : SubViewDataTypeImpl<
-      void, ValueType, Exts, Args...
-    >
-{ };
+struct SubViewDataType : SubViewDataTypeImpl<void, ValueType, Exts, Args...> {};
 
 //----------------------------------------------------------------------------
 
-template< class SrcTraits , class ... Args >
-struct ViewMapping
-  < typename std::enable_if<(
-      std::is_same< typename SrcTraits::specialize , void >::value
-      &&
-      (
-        std::is_same< typename SrcTraits::array_layout
-                    , Kokkos::LayoutLeft >::value ||
-        std::is_same< typename SrcTraits::array_layout
-                    , Kokkos::LayoutRight >::value ||
-        std::is_same< typename SrcTraits::array_layout
-                    , Kokkos::LayoutStride >::value
-      )
-    )>::type
-  , SrcTraits
-  , Args ... >
-{
-private:
-
-  static_assert( SrcTraits::rank == sizeof...(Args) ,
-    "Subview mapping requires one argument for each dimension of source View" );
-
-  enum
-    { RZ = false
-    , R0 = bool(is_integral_extent<0,Args...>::value)
-    , R1 = bool(is_integral_extent<1,Args...>::value)
-    , R2 = bool(is_integral_extent<2,Args...>::value)
-    , R3 = bool(is_integral_extent<3,Args...>::value)
-    , R4 = bool(is_integral_extent<4,Args...>::value)
-    , R5 = bool(is_integral_extent<5,Args...>::value)
-    , R6 = bool(is_integral_extent<6,Args...>::value)
-    , R7 = bool(is_integral_extent<7,Args...>::value)
-    };
+template <class SrcTraits, class... Args>
+struct ViewMapping<
+    typename std::enable_if<(
+        std::is_same<typename SrcTraits::specialize, void>::value &&
+        (std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutLeft>::value ||
+         std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutRight>::value ||
+         std::is_same<typename SrcTraits::array_layout,
+                      Kokkos::LayoutStride>::value))>::type,
+    SrcTraits, Args...> {
+ private:
+  static_assert(SrcTraits::rank == sizeof...(Args),
+                "Subview mapping requires one argument for each dimension of "
+                "source View");
+
+  enum {
+    RZ = false,
+    R0 = bool(is_integral_extent<0, Args...>::value),
+    R1 = bool(is_integral_extent<1, Args...>::value),
+    R2 = bool(is_integral_extent<2, Args...>::value),
+    R3 = bool(is_integral_extent<3, Args...>::value),
+    R4 = bool(is_integral_extent<4, Args...>::value),
+    R5 = bool(is_integral_extent<5, Args...>::value),
+    R6 = bool(is_integral_extent<6, Args...>::value),
+    R7 = bool(is_integral_extent<7, Args...>::value)
+  };
 
-  enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
-              + unsigned(R4) + unsigned(R5) + unsigned(R6) + unsigned(R7) };
+  enum {
+    rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3) +
+           unsigned(R4) + unsigned(R5) + unsigned(R6) + unsigned(R7)
+  };
 
   // Whether right-most rank is a range.
-  enum { R0_rev = ( 0 == SrcTraits::rank ? RZ : (
-                    1 == SrcTraits::rank ? R0 : (
-                    2 == SrcTraits::rank ? R1 : (
-                    3 == SrcTraits::rank ? R2 : (
-                    4 == SrcTraits::rank ? R3 : (
-                    5 == SrcTraits::rank ? R4 : (
-                    6 == SrcTraits::rank ? R5 : (
-                    7 == SrcTraits::rank ? R6 : R7 )))))))) };
+  enum {
+    R0_rev =
+        (0 == SrcTraits::rank
+             ? RZ
+             : (1 == SrcTraits::rank
+                    ? R0
+                    : (2 == SrcTraits::rank
+                           ? R1
+                           : (3 == SrcTraits::rank
+                                  ? R2
+                                  : (4 == SrcTraits::rank
+                                         ? R3
+                                         : (5 == SrcTraits::rank
+                                                ? R4
+                                                : (6 == SrcTraits::rank
+                                                       ? R5
+                                                       : (7 == SrcTraits::rank
+                                                              ? R6
+                                                              : R7))))))))
+  };
 
   // Subview's layout
   typedef typename std::conditional<
-      ( /* Same array layout IF */
-        ( rank == 0 ) /* output rank zero */
-        ||
-        SubviewLegalArgsCompileTime<typename SrcTraits::array_layout, typename SrcTraits::array_layout,
-                                    rank, SrcTraits::rank, 0, Args...>::value
-        ||
-        // OutputRank 1 or 2, InputLayout Left, Interval 0
-        // because single stride one or second index has a stride.
-        ( rank <= 2 && R0 && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value ) //replace with input rank
-        ||
-        // OutputRank 1 or 2, InputLayout Right, Interval [InputRank-1]
-        // because single stride one or second index has a stride.
-        ( rank <= 2 && R0_rev && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value ) //replace input rank
-      ), typename SrcTraits::array_layout , Kokkos::LayoutStride
-      >::type array_layout ;
-
-  typedef typename SrcTraits::value_type  value_type ;
+      (            /* Same array layout IF */
+       (rank == 0) /* output rank zero */
+       || SubviewLegalArgsCompileTime<typename SrcTraits::array_layout,
+                                      typename SrcTraits::array_layout, rank,
+                                      SrcTraits::rank, 0, Args...>::value ||
+       // OutputRank 1 or 2, InputLayout Left, Interval 0
+       // because single stride one or second index has a stride.
+       (rank <= 2 && R0 &&
+        std::is_same<typename SrcTraits::array_layout,
+                     Kokkos::LayoutLeft>::value)  // replace with input rank
+       ||
+       // OutputRank 1 or 2, InputLayout Right, Interval [InputRank-1]
+       // because single stride one or second index has a stride.
+       (rank <= 2 && R0_rev &&
+        std::is_same<typename SrcTraits::array_layout,
+                     Kokkos::LayoutRight>::value)  // replace input rank
+       ),
+      typename SrcTraits::array_layout, Kokkos::LayoutStride>::type
+      array_layout;
+
+  typedef typename SrcTraits::value_type value_type;
 
   using data_type =
-    typename SubViewDataType<
-      value_type,
-      typename Kokkos::Impl::ParseViewExtents<
-        typename SrcTraits::data_type
-      >::type,
-      Args...
-    >::type;
-  //typedef typename std::conditional< rank == 0 , value_type ,
+      typename SubViewDataType<value_type,
+                               typename Kokkos::Impl::ParseViewExtents<
+                                   typename SrcTraits::data_type>::type,
+                               Args...>::type;
+  // typedef typename std::conditional< rank == 0 , value_type ,
   //        typename std::conditional< rank == 1 , value_type * ,
   //        typename std::conditional< rank == 2 , value_type ** ,
   //        typename std::conditional< rank == 3 , value_type *** ,
@@ -3291,77 +3628,61 @@ private:
   //        >::type >::type >::type >::type >::type >::type >::type >::type
   //   data_type ;
 
-public:
-
-  typedef Kokkos::ViewTraits
-    < data_type
-    , array_layout
-    , typename SrcTraits::device_type
-    , typename SrcTraits::memory_traits > traits_type ;
+ public:
+  typedef Kokkos::ViewTraits<data_type, array_layout,
+                             typename SrcTraits::device_type,
+                             typename SrcTraits::memory_traits>
+      traits_type;
 
-  typedef Kokkos::View
-    < data_type
-    , array_layout
-    , typename SrcTraits::device_type
-    , typename SrcTraits::memory_traits > type ;
+  typedef Kokkos::View<data_type, array_layout, typename SrcTraits::device_type,
+                       typename SrcTraits::memory_traits>
+      type;
 
-  template< class MemoryTraits >
+  template <class MemoryTraits>
   struct apply {
+    static_assert(Kokkos::Impl::is_memory_traits<MemoryTraits>::value, "");
 
-    static_assert( Kokkos::Impl::is_memory_traits< MemoryTraits >::value , "" );
+    typedef Kokkos::ViewTraits<data_type, array_layout,
+                               typename SrcTraits::device_type, MemoryTraits>
+        traits_type;
 
-    typedef Kokkos::ViewTraits
-      < data_type
-      , array_layout
-      , typename SrcTraits::device_type
-      , MemoryTraits > traits_type ;
-
-    typedef Kokkos::View
-      < data_type
-      , array_layout
-      , typename SrcTraits::device_type
-      , MemoryTraits > type ;
+    typedef Kokkos::View<data_type, array_layout,
+                         typename SrcTraits::device_type, MemoryTraits>
+        type;
   };
 
   // The presumed type is 'ViewMapping< traits_type , void >'
   // However, a compatible ViewMapping is acceptable.
-  template< class DstTraits >
-  KOKKOS_INLINE_FUNCTION
-  static void assign( ViewMapping< DstTraits , void > & dst
-                    , ViewMapping< SrcTraits , void > const & src
-                    , Args ... args )
-    {
-      static_assert(
-        ViewMapping< DstTraits , traits_type , void >::is_assignable ,
-        "Subview destination type must be compatible with subview derived type" );
-
-      typedef ViewMapping< DstTraits , void >  DstType ;
-
-      typedef typename DstType::offset_type  dst_offset_type ;
-
-      const SubviewExtents< SrcTraits::rank , rank >
-        extents( src.m_impl_offset.m_dim , args... );
-
-      dst.m_impl_offset = dst_offset_type( src.m_impl_offset , extents );
-
-      dst.m_impl_handle = ViewDataHandle< DstTraits >::assign(src.m_impl_handle,
-          src.m_impl_offset( extents.domain_offset(0)
-                      , extents.domain_offset(1)
-                      , extents.domain_offset(2)
-                      , extents.domain_offset(3)
-                      , extents.domain_offset(4)
-                      , extents.domain_offset(5)
-                      , extents.domain_offset(6)
-                      , extents.domain_offset(7)
-          ));
-    }
-};
+  template <class DstTraits>
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<DstTraits, void>& dst,
+      ViewMapping<SrcTraits, void> const& src, Args... args) {
+    static_assert(ViewMapping<DstTraits, traits_type, void>::is_assignable,
+                  "Subview destination type must be compatible with subview "
+                  "derived type");
 
+    typedef ViewMapping<DstTraits, void> DstType;
 
+    typedef typename DstType::offset_type dst_offset_type;
+
+    const SubviewExtents<SrcTraits::rank, rank> extents(src.m_impl_offset.m_dim,
+                                                        args...);
+
+    dst.m_impl_offset = dst_offset_type(src.m_impl_offset, extents);
+
+    dst.m_impl_handle = ViewDataHandle<DstTraits>::assign(
+        src.m_impl_handle,
+        src.m_impl_offset(extents.domain_offset(0), extents.domain_offset(1),
+                          extents.domain_offset(2), extents.domain_offset(3),
+                          extents.domain_offset(4), extents.domain_offset(5),
+                          extents.domain_offset(6), extents.domain_offset(7)));
+  }
+};
 
 //----------------------------------------------------------------------------
 
-}} // namespace Kokkos::Impl
+}  // namespace Impl
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -3369,131 +3690,105 @@ public:
 namespace Kokkos {
 namespace Impl {
 
-template< unsigned , class MapType >
-KOKKOS_INLINE_FUNCTION
-bool view_verify_operator_bounds( const MapType & )
-{ return true ; }
-
-template< unsigned R , class MapType , class iType , class ... Args >
-KOKKOS_INLINE_FUNCTION
-bool view_verify_operator_bounds
-  ( const MapType & map
-  , const iType   & i
-  , Args ... args
-  )
-{
-  return ( size_t(i) < map.extent(R) )
-         && view_verify_operator_bounds<R+1>( map , args ... );
+template <unsigned, class MapType>
+KOKKOS_INLINE_FUNCTION bool view_verify_operator_bounds(const MapType&) {
+  return true;
 }
 
-
-template< unsigned , class MapType >
-inline
-void view_error_operator_bounds( char * , int , const MapType & )
-{}
-
-template< unsigned R , class MapType , class iType , class ... Args >
-inline
-void view_error_operator_bounds
-  ( char * buf
-  , int len
-  , const MapType & map
-  , const iType   & i
-  , Args ... args
-  )
-{
-  const int n =
-    snprintf(buf,len," %ld < %ld %c"
-            , static_cast<unsigned long>(i)
-            , static_cast<unsigned long>( map.extent(R) )
-            , ( sizeof...(Args) ? ',' : ')' )
-            );
-  view_error_operator_bounds<R+1>(buf+n,len-n,map,args...);
+template <unsigned R, class MapType, class iType, class... Args>
+KOKKOS_INLINE_FUNCTION bool view_verify_operator_bounds(const MapType& map,
+                                                        const iType& i,
+                                                        Args... args) {
+  return (size_t(i) < map.extent(R)) &&
+         view_verify_operator_bounds<R + 1>(map, args...);
 }
 
+template <unsigned, class MapType>
+inline void view_error_operator_bounds(char*, int, const MapType&) {}
+
+template <unsigned R, class MapType, class iType, class... Args>
+inline void view_error_operator_bounds(char* buf, int len, const MapType& map,
+                                       const iType& i, Args... args) {
+  const int n = snprintf(
+      buf, len, " %ld < %ld %c", static_cast<unsigned long>(i),
+      static_cast<unsigned long>(map.extent(R)), (sizeof...(Args) ? ',' : ')'));
+  view_error_operator_bounds<R + 1>(buf + n, len - n, map, args...);
+}
 
-#if ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#if !defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
 
 /* Check #3: is the View managed as determined by the MemoryTraits? */
-template< class MapType,
-  bool is_managed = (MapType::is_managed != 0) >
+template <class MapType, bool is_managed = (MapType::is_managed != 0)>
 struct OperatorBoundsErrorOnDevice;
 
-template< class MapType >
-struct OperatorBoundsErrorOnDevice< MapType, false > {
-KOKKOS_INLINE_FUNCTION
-static void run(MapType const&) {
-  Kokkos::abort("View bounds error");
-}
+template <class MapType>
+struct OperatorBoundsErrorOnDevice<MapType, false> {
+  KOKKOS_INLINE_FUNCTION
+  static void run(MapType const&) { Kokkos::abort("View bounds error"); }
 };
 
-template< class MapType >
-struct OperatorBoundsErrorOnDevice< MapType, true > {
-KOKKOS_INLINE_FUNCTION
-static void run(MapType const& map) {
-  SharedAllocationHeader const* const header =
-    SharedAllocationHeader::get_header((void*)(map.data()));
-  char const* const label = header->label();
-  enum { LEN = 128 };
-  char msg[LEN];
-  char const* const first_part = "View bounds error of view ";
-  char* p = msg;
-  char* const end = msg + LEN - 1;
-  for (char const* p2 = first_part; (*p2 != '\0') && (p < end); ++p, ++p2) {
-    *p = *p2;
-  }
-  for (char const* p2 = label; (*p2 != '\0') && (p < end); ++p, ++p2) {
-    *p = *p2;
-  }
-  *p = '\0';
-  Kokkos::abort(msg);
-}
+template <class MapType>
+struct OperatorBoundsErrorOnDevice<MapType, true> {
+  KOKKOS_INLINE_FUNCTION
+  static void run(MapType const& map) {
+    SharedAllocationHeader const* const header =
+        SharedAllocationHeader::get_header((void*)(map.data()));
+    char const* const label = header->label();
+    enum { LEN = 128 };
+    char msg[LEN];
+    char const* const first_part = "View bounds error of view ";
+    char* p                      = msg;
+    char* const end              = msg + LEN - 1;
+    for (char const* p2 = first_part; (*p2 != '\0') && (p < end); ++p, ++p2) {
+      *p = *p2;
+    }
+    for (char const* p2 = label; (*p2 != '\0') && (p < end); ++p, ++p2) {
+      *p = *p2;
+    }
+    *p = '\0';
+    Kokkos::abort(msg);
+  }
 };
 
 /* Check #2: does the ViewMapping have the printable_label_typedef defined?
    See above that only the non-specialized standard-layout ViewMapping has
    this defined by default.
-   The existence of this typedef indicates the existence of MapType::is_managed */
-template< class T, class Enable = void >
+   The existence of this typedef indicates the existence of MapType::is_managed
+ */
+template <class T, class Enable = void>
 struct has_printable_label_typedef : public std::false_type {};
 
-template<class T>
+template <class T>
 struct has_printable_label_typedef<
-  T, typename enable_if_type<typename T::printable_label_typedef>::type>
-  : public std::true_type
-{};
-
-template< class MapType >
-KOKKOS_INLINE_FUNCTION
-void operator_bounds_error_on_device(
-    MapType const&,
-    std::false_type) {
+    T, typename enable_if_type<typename T::printable_label_typedef>::type>
+    : public std::true_type {};
+
+template <class MapType>
+KOKKOS_INLINE_FUNCTION void operator_bounds_error_on_device(MapType const&,
+                                                            std::false_type) {
   Kokkos::abort("View bounds error");
 }
 
-template< class MapType >
-KOKKOS_INLINE_FUNCTION
-void operator_bounds_error_on_device(
-    MapType const& map,
-    std::true_type) {
-  OperatorBoundsErrorOnDevice< MapType >::run(map);
+template <class MapType>
+KOKKOS_INLINE_FUNCTION void operator_bounds_error_on_device(MapType const& map,
+                                                            std::true_type) {
+  OperatorBoundsErrorOnDevice<MapType>::run(map);
 }
 
-#endif // ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#endif  // ! defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
 
-template< class MemorySpace , class MapType , class ... Args >
-KOKKOS_INLINE_FUNCTION
-void view_verify_operator_bounds
-  ( Kokkos::Impl::SharedAllocationTracker const & tracker
-  , const MapType & map , Args ... args )
-{
-  if ( ! view_verify_operator_bounds<0>( map , args ... ) ) {
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+template <class MemorySpace, class MapType, class... Args>
+KOKKOS_INLINE_FUNCTION void view_verify_operator_bounds(
+    Kokkos::Impl::SharedAllocationTracker const& tracker, const MapType& map,
+    Args... args) {
+  if (!view_verify_operator_bounds<0>(map, args...)) {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
     enum { LEN = 1024 };
-    char buffer[ LEN ];
+    char buffer[LEN];
     const std::string label = tracker.template get_label<MemorySpace>();
-    int n = snprintf(buffer,LEN,"View bounds error of view %s (",label.c_str());
-    view_error_operator_bounds<0>( buffer + n , LEN - n , map , args ... );
+    int n =
+        snprintf(buffer, LEN, "View bounds error of view %s (", label.c_str());
+    view_error_operator_bounds<0>(buffer + n, LEN - n, map, args...);
     Kokkos::Impl::throw_runtime_exception(std::string(buffer));
 #else
     /* Check #1: is there a SharedAllocationRecord?
@@ -3511,8 +3806,6 @@ void view_verify_operator_bounds
   }
 }
 
-
-
 } /* namespace Impl */
 } /* namespace Kokkos */
 
@@ -3520,4 +3813,3 @@ void view_verify_operator_bounds
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_EXPERIMENTAL_VIEW_MAPPING_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewTile.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewTile.hpp
index a8645db451c6ff5831bf331cdf327cdd89547056..f1227c2ab61d548c7a02fe6eec48eed7ef1f5603 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewTile.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewTile.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -55,163 +56,151 @@ namespace Impl {
 
 // View mapping for rank two tiled array
 
-template< class L >
+template <class L>
 struct is_layout_tile : public std::false_type {};
 
-template< unsigned N0 , unsigned N1 >
-struct is_layout_tile< Kokkos::LayoutTileLeft<N0,N1,true> > : public std::true_type {};
-
-template< class Dimension , class Layout >
-struct ViewOffset< Dimension , Layout ,
-  typename std::enable_if<(
-    ( Dimension::rank == 2 )
-    &&
-    is_layout_tile< Layout >::value
-  )>::type >
-{
-public:
+template <unsigned N0, unsigned N1>
+struct is_layout_tile<Kokkos::LayoutTileLeft<N0, N1, true> >
+    : public std::true_type {};
 
+template <class Dimension, class Layout>
+struct ViewOffset<
+    Dimension, Layout,
+    typename std::enable_if<((Dimension::rank == 2) &&
+                             is_layout_tile<Layout>::value)>::type> {
+ public:
   enum { SHIFT_0 = Kokkos::Impl::integral_power_of_two(Layout::N0) };
   enum { SHIFT_1 = Kokkos::Impl::integral_power_of_two(Layout::N1) };
   enum { SHIFT_T = SHIFT_0 + SHIFT_1 };
-  enum { MASK_0  = Layout::N0 - 1 };
-  enum { MASK_1  = Layout::N1 - 1 };
+  enum { MASK_0 = Layout::N0 - 1 };
+  enum { MASK_1 = Layout::N1 - 1 };
 
   // Is an irregular layout that does not have uniform striding for each index.
-  using is_mapping_plugin = std::true_type ;
-  using is_regular        = std::false_type ;
+  using is_mapping_plugin = std::true_type;
+  using is_regular        = std::false_type;
 
-  typedef size_t     size_type ;
-  typedef Dimension  dimension_type ;
-  typedef Layout     array_layout ;
+  typedef size_t size_type;
+  typedef Dimension dimension_type;
+  typedef Layout array_layout;
 
-  dimension_type m_dim ;
-  size_type      m_tile_N0 ;
+  dimension_type m_dim;
+  size_type m_tile_N0;
 
   //----------------------------------------
 
   // Only instantiated for rank 2
-  template< typename I0 , typename I1 >
-  KOKKOS_INLINE_FUNCTION constexpr
-  size_type operator()( I0 const & i0 , I1 const & i1
-                      , int = 0 , int = 0
-                      , int = 0 , int = 0
-                      , int = 0 , int = 0
-                      ) const
-    {
-      return /* ( ( Tile offset                               ) * Tile size ) */
-                ( ( (i0>>SHIFT_0) + m_tile_N0 * (i1>>SHIFT_1) ) << SHIFT_T) +
-             /* ( Offset within tile                       ) */
-                ( (i0 & MASK_0) + ((i1 & MASK_1)<<SHIFT_0) ) ;
-    }
+  template <typename I0, typename I1>
+  KOKKOS_INLINE_FUNCTION constexpr size_type operator()(I0 const& i0,
+                                                        I1 const& i1, int = 0,
+                                                        int = 0, int = 0,
+                                                        int = 0, int = 0,
+                                                        int = 0) const {
+    return /* ( ( Tile offset                               ) * Tile size ) */
+        (((i0 >> SHIFT_0) + m_tile_N0 * (i1 >> SHIFT_1)) << SHIFT_T) +
+        /* ( Offset within tile                       ) */
+        ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0));
+  }
 
   //----------------------------------------
 
-  KOKKOS_INLINE_FUNCTION constexpr
-  array_layout layout() const
-    { return array_layout( m_dim.N0 , m_dim.N1 ); }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const { return m_dim.N0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const { return m_dim.N1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return 1 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return 1 ; }
+  KOKKOS_INLINE_FUNCTION constexpr array_layout layout() const {
+    return array_layout(m_dim.N0, m_dim.N1);
+  }
 
-  KOKKOS_INLINE_FUNCTION constexpr size_type size() const { return m_dim.N0 * m_dim.N1 ; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
+    return m_dim.N0;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
+    return m_dim.N1;
+  }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const { return 1; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const { return 1; }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_type size() const {
+    return m_dim.N0 * m_dim.N1;
+  }
 
   // Strides are meaningless due to irregularity
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return 0 ; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 0 ; }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type span() const
-    {
-      // ( TileDim0 * ( TileDim1 ) ) * TileSize
-      return ( m_tile_N0 * ( ( m_dim.N1 + MASK_1 ) >> SHIFT_1 ) ) << SHIFT_T ;
-    }
-
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const
-    {
-      // Only if dimensions align with tile size
-      return ( m_dim.N0 & MASK_0 ) == 0 && ( m_dim.N1 & MASK_1 ) == 0 ;
-    }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return 0; }
+  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 0; }
+
+  KOKKOS_INLINE_FUNCTION constexpr size_type span() const {
+    // ( TileDim0 * ( TileDim1 ) ) * TileSize
+    return (m_tile_N0 * ((m_dim.N1 + MASK_1) >> SHIFT_1)) << SHIFT_T;
+  }
+
+  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
+    // Only if dimensions align with tile size
+    return (m_dim.N0 & MASK_0) == 0 && (m_dim.N1 & MASK_1) == 0;
+  }
 
   //----------------------------------------
 
 #ifdef KOKKOS_CUDA_9_DEFAULTED_BUG_WORKAROUND
   KOKKOS_INLINE_FUNCTION ~ViewOffset() {}
   KOKKOS_INLINE_FUNCTION ViewOffset() {}
-  KOKKOS_INLINE_FUNCTION ViewOffset( const ViewOffset & rhs )
-  : m_dim(rhs.m_dim)
-  , m_tile_N0(rhs.m_tile_N0)
-  {
-  }
-  KOKKOS_INLINE_FUNCTION ViewOffset & operator = ( const ViewOffset & rhs ) {
-    m_dim = rhs.m_dim;
+  KOKKOS_INLINE_FUNCTION ViewOffset(const ViewOffset& rhs)
+      : m_dim(rhs.m_dim), m_tile_N0(rhs.m_tile_N0) {}
+  KOKKOS_INLINE_FUNCTION ViewOffset& operator=(const ViewOffset& rhs) {
+    m_dim     = rhs.m_dim;
     m_tile_N0 = rhs.m_tile_N0;
     return *this;
   }
 #else
-  KOKKOS_INLINE_FUNCTION ~ViewOffset() = default;
-  KOKKOS_INLINE_FUNCTION ViewOffset() = default;
-  KOKKOS_INLINE_FUNCTION ViewOffset( const ViewOffset & ) = default;
-  KOKKOS_INLINE_FUNCTION ViewOffset & operator = ( const ViewOffset & ) = default;
+  KOKKOS_INLINE_FUNCTION ~ViewOffset()                 = default;
+  KOKKOS_INLINE_FUNCTION ViewOffset()                  = default;
+  KOKKOS_INLINE_FUNCTION ViewOffset(const ViewOffset&) = default;
+  KOKKOS_INLINE_FUNCTION ViewOffset& operator=(const ViewOffset&) = default;
 #endif
 
-  template< unsigned TrivialScalarSize >
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewOffset( std::integral_constant<unsigned,TrivialScalarSize> const & ,
-                        array_layout const arg_layout )
-    : m_dim( arg_layout.dimension[0], arg_layout.dimension[1], 0, 0, 0, 0, 0, 0 )
-    , m_tile_N0( ( arg_layout.dimension[0] + MASK_0 ) >> SHIFT_0 /* number of tiles in first dimension */ )
-    {}
+  template <unsigned TrivialScalarSize>
+  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
+      std::integral_constant<unsigned, TrivialScalarSize> const&,
+      array_layout const arg_layout)
+      : m_dim(arg_layout.dimension[0], arg_layout.dimension[1], 0, 0, 0, 0, 0,
+              0),
+        m_tile_N0((arg_layout.dimension[0] + MASK_0) >>
+                  SHIFT_0 /* number of tiles in first dimension */) {}
 };
 
-template< typename T , unsigned N0 , unsigned N1 , class ... P
-        , typename iType0 , typename iType1
-        >
-struct ViewMapping
-  < void
-  , Kokkos::ViewTraits<T**,Kokkos::LayoutTileLeft<N0,N1,true>,P...>
-  , Kokkos::LayoutTileLeft<N0,N1,true>
-  , iType0
-  , iType1 >
-{
-  typedef Kokkos::LayoutTileLeft<N0,N1,true>  src_layout ;
-  typedef Kokkos::ViewTraits< T** , src_layout , P... > src_traits ;
-  typedef Kokkos::ViewTraits< T[N0][N1] , LayoutLeft , P ... > traits ;
-  typedef Kokkos::View< T[N0][N1] , LayoutLeft , P ... > type ;
-
-  KOKKOS_INLINE_FUNCTION static
-  void assign( ViewMapping< traits , void > & dst
-             , const ViewMapping< src_traits , void > & src
-             , const src_layout &
-             , const size_t i_tile0
-             , const size_t i_tile1
-             )
-    {
-      typedef ViewMapping< traits , void >        dst_map_type ;
-      typedef ViewMapping< src_traits , void >    src_map_type ;
-      typedef typename dst_map_type::handle_type  dst_handle_type ;
-      typedef typename dst_map_type::offset_type  dst_offset_type ;
-      typedef typename src_map_type::offset_type  src_offset_type ;
-
-      dst = dst_map_type(
-         dst_handle_type( src.m_impl_handle +
-                        ( ( i_tile0 + src.m_impl_offset.m_tile_N0 * i_tile1 ) << src_offset_type::SHIFT_T ) ) ,
-         dst_offset_type() );
-    }
+template <typename T, unsigned N0, unsigned N1, class... P, typename iType0,
+          typename iType1>
+struct ViewMapping<
+    void, Kokkos::ViewTraits<T**, Kokkos::LayoutTileLeft<N0, N1, true>, P...>,
+    Kokkos::LayoutTileLeft<N0, N1, true>, iType0, iType1> {
+  typedef Kokkos::LayoutTileLeft<N0, N1, true> src_layout;
+  typedef Kokkos::ViewTraits<T**, src_layout, P...> src_traits;
+  typedef Kokkos::ViewTraits<T[N0][N1], LayoutLeft, P...> traits;
+  typedef Kokkos::View<T[N0][N1], LayoutLeft, P...> type;
+
+  KOKKOS_INLINE_FUNCTION static void assign(
+      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
+      const src_layout&, const size_t i_tile0, const size_t i_tile1) {
+    typedef ViewMapping<traits, void> dst_map_type;
+    typedef ViewMapping<src_traits, void> src_map_type;
+    typedef typename dst_map_type::handle_type dst_handle_type;
+    typedef typename dst_map_type::offset_type dst_offset_type;
+    typedef typename src_map_type::offset_type src_offset_type;
+
+    dst = dst_map_type(
+        dst_handle_type(src.m_impl_handle +
+                        ((i_tile0 + src.m_impl_offset.m_tile_N0 * i_tile1)
+                         << src_offset_type::SHIFT_T)),
+        dst_offset_type());
+  }
 };
 
-#endif // KOKKOS_ENABLE_DEPRECATED_CODE
+#endif  // KOKKOS_ENABLE_DEPRECATED_CODE
 // ===============================================================================
 
 } /* namespace Impl */
@@ -222,23 +211,19 @@ namespace Kokkos {
 // ==============================================================================
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
 
-template< typename T , unsigned N0 , unsigned N1 , class ... P >
-KOKKOS_INLINE_FUNCTION
-Kokkos::View< T[N0][N1] , LayoutLeft , P... >
-tile_subview( const Kokkos::View<T**,Kokkos::LayoutTileLeft<N0,N1,true>,P...> & src
-            , const size_t i_tile0
-            , const size_t i_tile1
-            )
-{
+template <typename T, unsigned N0, unsigned N1, class... P>
+KOKKOS_INLINE_FUNCTION Kokkos::View<T[N0][N1], LayoutLeft, P...> tile_subview(
+    const Kokkos::View<T**, Kokkos::LayoutTileLeft<N0, N1, true>, P...>& src,
+    const size_t i_tile0, const size_t i_tile1) {
   // Force the specialized ViewMapping for extracting a tile
   // by using the first subview argument as the layout.
-  typedef Kokkos::LayoutTileLeft<N0,N1,true> SrcLayout ;
+  typedef Kokkos::LayoutTileLeft<N0, N1, true> SrcLayout;
 
-  return Kokkos::View< T[N0][N1] , LayoutLeft , P... >
-    ( src , SrcLayout() , i_tile0 , i_tile1 );
+  return Kokkos::View<T[N0][N1], LayoutLeft, P...>(src, SrcLayout(), i_tile0,
+                                                   i_tile1);
 }
 
-#endif // KOKKOS_ENABLE_DEPRECATED_CODE
+#endif  // KOKKOS_ENABLE_DEPRECATED_CODE
 // ===============================================================================
 
 } /* namespace Kokkos */
@@ -247,4 +232,3 @@ tile_subview( const Kokkos::View<T**,Kokkos::LayoutTileLeft<N0,N1,true>,P...> &
 //----------------------------------------------------------------------------
 
 #endif /* #ifndef KOKKOS_EXPERIENTAL_VIEWTILE_HPP */
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_ViewUniformType.hpp b/lib/kokkos/core/src/impl/Kokkos_ViewUniformType.hpp
index 1d2dbfcf0da619a61962e95ace88526181958060..7ce3a532b4bacbd583e52e474192311a8b67432f 100644
--- a/lib/kokkos/core/src/impl/Kokkos_ViewUniformType.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_ViewUniformType.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,56 +47,77 @@
 
 namespace Kokkos {
 namespace Impl {
-  template< class ScalarType, int Rank>
-  struct ViewScalarToDataType {
-    typedef typename ViewScalarToDataType<ScalarType,Rank-1>::type* type;
-  };
+template <class ScalarType, int Rank>
+struct ViewScalarToDataType {
+  typedef typename ViewScalarToDataType<ScalarType, Rank - 1>::type* type;
+};
 
-  template< class ScalarType>
-  struct ViewScalarToDataType<ScalarType,0> {
-    typedef ScalarType type;
-  };
+template <class ScalarType>
+struct ViewScalarToDataType<ScalarType, 0> {
+  typedef ScalarType type;
+};
 
-  template< class LayoutType, int Rank>
-  struct ViewUniformLayout {
-    typedef LayoutType array_layout;
-  };
+template <class LayoutType, int Rank>
+struct ViewUniformLayout {
+  typedef LayoutType array_layout;
+};
 
-  template< class LayoutType>
-  struct ViewUniformLayout<LayoutType, 0> {
-    typedef Kokkos::LayoutLeft array_layout;
-  };
+template <class LayoutType>
+struct ViewUniformLayout<LayoutType, 0> {
+  typedef Kokkos::LayoutLeft array_layout;
+};
 
-  template<>
-  struct ViewUniformLayout<Kokkos::LayoutRight, 1> {
-    typedef Kokkos::LayoutLeft array_layout;
-  };
+template <>
+struct ViewUniformLayout<Kokkos::LayoutRight, 1> {
+  typedef Kokkos::LayoutLeft array_layout;
+};
 
-  template< class ViewType , int Traits>
-  struct ViewUniformType {
-    typedef typename ViewType::data_type data_type;
-    typedef typename std::add_const<typename ViewType::data_type>::type const_data_type;
-    typedef typename ViewScalarToDataType<typename ViewType::value_type,ViewType::rank>::type runtime_data_type;
-    typedef typename ViewScalarToDataType<typename std::add_const<typename ViewType::value_type>::type,ViewType::rank>::type runtime_const_data_type;
+template <class ViewType, int Traits>
+struct ViewUniformType {
+  typedef typename ViewType::data_type data_type;
+  typedef typename std::add_const<typename ViewType::data_type>::type
+      const_data_type;
+  typedef typename ViewScalarToDataType<typename ViewType::value_type,
+                                        ViewType::rank>::type runtime_data_type;
+  typedef typename ViewScalarToDataType<
+      typename std::add_const<typename ViewType::value_type>::type,
+      ViewType::rank>::type runtime_const_data_type;
 
-    typedef typename ViewUniformLayout<typename ViewType::array_layout, ViewType::rank>::array_layout array_layout;
+  typedef typename ViewUniformLayout<typename ViewType::array_layout,
+                                     ViewType::rank>::array_layout array_layout;
 
-    typedef typename ViewType::device_type device_type;
-    typedef typename Kokkos::Device<typename device_type::execution_space,Kokkos::AnonymousSpace> anonymous_device_type;
+  typedef typename ViewType::device_type device_type;
+  typedef typename Kokkos::Device<typename device_type::execution_space,
+                                  Kokkos::AnonymousSpace>
+      anonymous_device_type;
 
-    typedef typename Kokkos::MemoryTraits<Traits> memory_traits;
-    typedef Kokkos::View<data_type,array_layout,device_type,memory_traits> type;
-    typedef Kokkos::View<const_data_type,array_layout,device_type,memory_traits> const_type;
-    typedef Kokkos::View<runtime_data_type,array_layout,device_type,memory_traits> runtime_type;
-    typedef Kokkos::View<runtime_const_data_type,array_layout,device_type,memory_traits> runtime_const_type;
-
-    typedef Kokkos::View<data_type,array_layout,anonymous_device_type,memory_traits> nomemspace_type;
-    typedef Kokkos::View<const_data_type,array_layout,anonymous_device_type,memory_traits> const_nomemspace_type;
-    typedef Kokkos::View<runtime_data_type,array_layout,anonymous_device_type,memory_traits> runtime_nomemspace_type;
-    typedef Kokkos::View<runtime_const_data_type,array_layout,anonymous_device_type,memory_traits> runtime_const_nomemspace_type;
-  };
-}
-}
+  typedef typename Kokkos::MemoryTraits<Traits> memory_traits;
+  typedef Kokkos::View<data_type, array_layout, device_type, memory_traits>
+      type;
+  typedef Kokkos::View<const_data_type, array_layout, device_type,
+                       memory_traits>
+      const_type;
+  typedef Kokkos::View<runtime_data_type, array_layout, device_type,
+                       memory_traits>
+      runtime_type;
+  typedef Kokkos::View<runtime_const_data_type, array_layout, device_type,
+                       memory_traits>
+      runtime_const_type;
 
+  typedef Kokkos::View<data_type, array_layout, anonymous_device_type,
+                       memory_traits>
+      nomemspace_type;
+  typedef Kokkos::View<const_data_type, array_layout, anonymous_device_type,
+                       memory_traits>
+      const_nomemspace_type;
+  typedef Kokkos::View<runtime_data_type, array_layout, anonymous_device_type,
+                       memory_traits>
+      runtime_nomemspace_type;
+  typedef Kokkos::View<runtime_const_data_type, array_layout,
+                       anonymous_device_type, memory_traits>
+      runtime_const_nomemspace_type;
+};
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif
diff --git a/lib/kokkos/core/src/impl/Kokkos_Volatile_Load.hpp b/lib/kokkos/core/src/impl/Kokkos_Volatile_Load.hpp
index f36ffc8addefbd610a71be2ce86037a35270bc61..3626a1f17c50e964246b22bb3458864ab2748ab9 100644
--- a/lib/kokkos/core/src/impl/Kokkos_Volatile_Load.hpp
+++ b/lib/kokkos/core/src/impl/Kokkos_Volatile_Load.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,12 +42,11 @@
 //@HEADER
 */
 
-#if defined( KOKKOS_ATOMIC_HPP ) && ! defined( KOKKOS_VOLATILE_LOAD_HPP )
+#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_VOLATILE_LOAD_HPP)
 #define KOKKOS_VOLATILE_LOAD_HPP
 
-#if defined( __GNUC__ ) /* GNU C   */ || \
-    defined( __GNUG__ ) /* GNU C++ */ || \
-    defined( __clang__ )
+#if defined(__GNUC__) /* GNU C   */ || defined(__GNUG__) /* GNU C++ */ || \
+    defined(__clang__)
 
 #define KOKKOS_IMPL_MAY_ALIAS __attribute__((__may_alias__))
 
@@ -61,13 +61,11 @@ namespace Kokkos {
 //----------------------------------------------------------------------------
 
 template <typename T>
-KOKKOS_FORCEINLINE_FUNCTION
-T volatile_load(T const volatile * const src_ptr)
-{
+KOKKOS_FORCEINLINE_FUNCTION T volatile_load(T const volatile* const src_ptr) {
   typedef uint64_t KOKKOS_IMPL_MAY_ALIAS T64;
   typedef uint32_t KOKKOS_IMPL_MAY_ALIAS T32;
   typedef uint16_t KOKKOS_IMPL_MAY_ALIAS T16;
-  typedef uint8_t  KOKKOS_IMPL_MAY_ALIAS T8;
+  typedef uint8_t KOKKOS_IMPL_MAY_ALIAS T8;
 
   enum {
     NUM_8  = sizeof(T),
@@ -77,50 +75,49 @@ T volatile_load(T const volatile * const src_ptr)
   };
 
   union {
-    T   const volatile * const ptr;
-    T64 const volatile * const ptr64;
-    T32 const volatile * const ptr32;
-    T16 const volatile * const ptr16;
-    T8  const volatile * const ptr8;
+    T const volatile* const ptr;
+    T64 const volatile* const ptr64;
+    T32 const volatile* const ptr32;
+    T16 const volatile* const ptr16;
+    T8 const volatile* const ptr8;
   } src = {src_ptr};
 
   T result;
 
   union {
-    T   * const ptr;
-    T64 * const ptr64;
-    T32 * const ptr32;
-    T16 * const ptr16;
-    T8  * const ptr8;
+    T* const ptr;
+    T64* const ptr64;
+    T32* const ptr32;
+    T16* const ptr16;
+    T8* const ptr8;
   } dst = {&result};
 
-  for (int i=0; i < NUM_64; ++i) {
+  for (int i = 0; i < NUM_64; ++i) {
     dst.ptr64[i] = src.ptr64[i];
   }
 
-  if ( NUM_64*2 < NUM_32 ) {
-    dst.ptr32[NUM_64*2] = src.ptr32[NUM_64*2];
+  if (NUM_64 * 2 < NUM_32) {
+    dst.ptr32[NUM_64 * 2] = src.ptr32[NUM_64 * 2];
   }
 
-  if ( NUM_32*2 < NUM_16 ) {
-    dst.ptr16[NUM_32*2] = src.ptr16[NUM_32*2];
+  if (NUM_32 * 2 < NUM_16) {
+    dst.ptr16[NUM_32 * 2] = src.ptr16[NUM_32 * 2];
   }
 
-  if ( NUM_16*2 < NUM_8 ) {
-    dst.ptr8[NUM_16*2] = src.ptr8[NUM_16*2];
+  if (NUM_16 * 2 < NUM_8) {
+    dst.ptr8[NUM_16 * 2] = src.ptr8[NUM_16 * 2];
   }
 
   return result;
 }
 
 template <typename T>
-KOKKOS_FORCEINLINE_FUNCTION
-void volatile_store(T volatile * const dst_ptr, T const volatile * const src_ptr)
-{
+KOKKOS_FORCEINLINE_FUNCTION void volatile_store(
+    T volatile* const dst_ptr, T const volatile* const src_ptr) {
   typedef uint64_t KOKKOS_IMPL_MAY_ALIAS T64;
   typedef uint32_t KOKKOS_IMPL_MAY_ALIAS T32;
   typedef uint16_t KOKKOS_IMPL_MAY_ALIAS T16;
-  typedef uint8_t  KOKKOS_IMPL_MAY_ALIAS T8;
+  typedef uint8_t KOKKOS_IMPL_MAY_ALIAS T8;
 
   enum {
     NUM_8  = sizeof(T),
@@ -130,46 +127,45 @@ void volatile_store(T volatile * const dst_ptr, T const volatile * const src_ptr
   };
 
   union {
-    T   const volatile * const ptr;
-    T64 const volatile * const ptr64;
-    T32 const volatile * const ptr32;
-    T16 const volatile * const ptr16;
-    T8  const volatile * const ptr8;
+    T const volatile* const ptr;
+    T64 const volatile* const ptr64;
+    T32 const volatile* const ptr32;
+    T16 const volatile* const ptr16;
+    T8 const volatile* const ptr8;
   } src = {src_ptr};
 
   union {
-    T   volatile * const ptr;
-    T64 volatile * const ptr64;
-    T32 volatile * const ptr32;
-    T16 volatile * const ptr16;
-    T8  volatile * const ptr8;
+    T volatile* const ptr;
+    T64 volatile* const ptr64;
+    T32 volatile* const ptr32;
+    T16 volatile* const ptr16;
+    T8 volatile* const ptr8;
   } dst = {dst_ptr};
 
-  for (int i=0; i < NUM_64; ++i) {
+  for (int i = 0; i < NUM_64; ++i) {
     dst.ptr64[i] = src.ptr64[i];
   }
 
-  if ( NUM_64*2 < NUM_32 ) {
-    dst.ptr32[NUM_64*2] = src.ptr32[NUM_64*2];
+  if (NUM_64 * 2 < NUM_32) {
+    dst.ptr32[NUM_64 * 2] = src.ptr32[NUM_64 * 2];
   }
 
-  if ( NUM_32*2 < NUM_16 ) {
-    dst.ptr16[NUM_32*2] = src.ptr16[NUM_32*2];
+  if (NUM_32 * 2 < NUM_16) {
+    dst.ptr16[NUM_32 * 2] = src.ptr16[NUM_32 * 2];
   }
 
-  if ( NUM_16*2 < NUM_8 ) {
-    dst.ptr8[NUM_16*2] = src.ptr8[NUM_16*2];
+  if (NUM_16 * 2 < NUM_8) {
+    dst.ptr8[NUM_16 * 2] = src.ptr8[NUM_16 * 2];
   }
 }
 
 template <typename T>
-KOKKOS_FORCEINLINE_FUNCTION
-void volatile_store(T volatile * const dst_ptr, T const * const src_ptr)
-{
+KOKKOS_FORCEINLINE_FUNCTION void volatile_store(T volatile* const dst_ptr,
+                                                T const* const src_ptr) {
   typedef uint64_t KOKKOS_IMPL_MAY_ALIAS T64;
   typedef uint32_t KOKKOS_IMPL_MAY_ALIAS T32;
   typedef uint16_t KOKKOS_IMPL_MAY_ALIAS T16;
-  typedef uint8_t  KOKKOS_IMPL_MAY_ALIAS T8;
+  typedef uint8_t KOKKOS_IMPL_MAY_ALIAS T8;
 
   enum {
     NUM_8  = sizeof(T),
@@ -179,62 +175,61 @@ void volatile_store(T volatile * const dst_ptr, T const * const src_ptr)
   };
 
   union {
-    T   const * const ptr;
-    T64 const * const ptr64;
-    T32 const * const ptr32;
-    T16 const * const ptr16;
-    T8  const * const ptr8;
+    T const* const ptr;
+    T64 const* const ptr64;
+    T32 const* const ptr32;
+    T16 const* const ptr16;
+    T8 const* const ptr8;
   } src = {src_ptr};
 
   union {
-    T   volatile * const ptr;
-    T64 volatile * const ptr64;
-    T32 volatile * const ptr32;
-    T16 volatile * const ptr16;
-    T8  volatile * const ptr8;
+    T volatile* const ptr;
+    T64 volatile* const ptr64;
+    T32 volatile* const ptr32;
+    T16 volatile* const ptr16;
+    T8 volatile* const ptr8;
   } dst = {dst_ptr};
 
-  for (int i=0; i < NUM_64; ++i) {
+  for (int i = 0; i < NUM_64; ++i) {
     dst.ptr64[i] = src.ptr64[i];
   }
 
-  if ( NUM_64*2 < NUM_32 ) {
-    dst.ptr32[NUM_64*2] = src.ptr32[NUM_64*2];
+  if (NUM_64 * 2 < NUM_32) {
+    dst.ptr32[NUM_64 * 2] = src.ptr32[NUM_64 * 2];
   }
 
-  if ( NUM_32*2 < NUM_16 ) {
-    dst.ptr16[NUM_32*2] = src.ptr16[NUM_32*2];
+  if (NUM_32 * 2 < NUM_16) {
+    dst.ptr16[NUM_32 * 2] = src.ptr16[NUM_32 * 2];
   }
 
-  if ( NUM_16*2 < NUM_8 ) {
-    dst.ptr8[NUM_16*2] = src.ptr8[NUM_16*2];
+  if (NUM_16 * 2 < NUM_8) {
+    dst.ptr8[NUM_16 * 2] = src.ptr8[NUM_16 * 2];
   }
 }
 
 template <typename T>
-KOKKOS_FORCEINLINE_FUNCTION
-void volatile_store(T volatile * dst_ptr, T const volatile & src)
-{ volatile_store(dst_ptr, &src); }
+KOKKOS_FORCEINLINE_FUNCTION void volatile_store(T volatile* dst_ptr,
+                                                T const volatile& src) {
+  volatile_store(dst_ptr, &src);
+}
 
 template <typename T>
-KOKKOS_FORCEINLINE_FUNCTION
-void volatile_store(T volatile * dst_ptr, T const & src)
-{ volatile_store(dst_ptr, &src); }
+KOKKOS_FORCEINLINE_FUNCTION void volatile_store(T volatile* dst_ptr,
+                                                T const& src) {
+  volatile_store(dst_ptr, &src);
+}
 
 template <typename T>
-KOKKOS_FORCEINLINE_FUNCTION
-T safe_load(T const * const ptr)
-{
-#if !defined( __MIC__ )
+KOKKOS_FORCEINLINE_FUNCTION T safe_load(T const* const ptr) {
+#if !defined(__MIC__)
   return *ptr;
 #else
   return volatile_load(ptr);
 #endif
 }
 
-} // namespace kokkos
+}  // namespace Kokkos
 
 #undef KOKKOS_IMPL_MAY_ALIAS
 
 #endif
-
diff --git a/lib/kokkos/core/src/impl/Kokkos_hwloc.cpp b/lib/kokkos/core/src/impl/Kokkos_hwloc.cpp
index 423944962b34a1900b9758ec4fd9b3bc30ff651b..04507b0984a78b12ea16c8c1ee33c4fc99f24b08 100644
--- a/lib/kokkos/core/src/impl/Kokkos_hwloc.cpp
+++ b/lib/kokkos/core/src/impl/Kokkos_hwloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -59,147 +60,168 @@ namespace Kokkos {
 namespace hwloc {
 
 /* Return 0 if asynchronous, 1 if synchronous and include process. */
-unsigned thread_mapping( const char * const label ,
-                         const bool allow_async ,
-                         unsigned & thread_count ,
-                         unsigned & use_numa_count ,
-                         unsigned & use_cores_per_numa ,
-                         std::pair<unsigned,unsigned> threads_coord[] )
-{
-  const bool     hwloc_avail            = Kokkos::hwloc::available();
-  const unsigned avail_numa_count       = hwloc_avail ? hwloc::get_available_numa_count() : 1 ;
-  const unsigned avail_cores_per_numa   = hwloc_avail ? hwloc::get_available_cores_per_numa() : thread_count ;
-  const unsigned avail_threads_per_core = hwloc_avail ? hwloc::get_available_threads_per_core() : 1 ;
+unsigned thread_mapping(const char* const label, const bool allow_async,
+                        unsigned& thread_count, unsigned& use_numa_count,
+                        unsigned& use_cores_per_numa,
+                        std::pair<unsigned, unsigned> threads_coord[]) {
+  const bool hwloc_avail = Kokkos::hwloc::available();
+  const unsigned avail_numa_count =
+      hwloc_avail ? hwloc::get_available_numa_count() : 1;
+  const unsigned avail_cores_per_numa =
+      hwloc_avail ? hwloc::get_available_cores_per_numa() : thread_count;
+  const unsigned avail_threads_per_core =
+      hwloc_avail ? hwloc::get_available_threads_per_core() : 1;
 
   // (numa,core) coordinate of the process:
-  const std::pair<unsigned,unsigned> proc_coord = Kokkos::hwloc::get_this_thread_coordinate();
+  const std::pair<unsigned, unsigned> proc_coord =
+      Kokkos::hwloc::get_this_thread_coordinate();
 
   //------------------------------------------------------------------------
   // Defaults for unspecified inputs:
 
-  if ( ! use_numa_count ) {
+  if (!use_numa_count) {
     // Default to use all NUMA regions
-    use_numa_count = ! thread_count ? avail_numa_count : (
-                       thread_count < avail_numa_count ? thread_count : avail_numa_count );
+    use_numa_count = !thread_count
+                         ? avail_numa_count
+                         : (thread_count < avail_numa_count ? thread_count
+                                                            : avail_numa_count);
   }
 
-  if ( ! use_cores_per_numa ) {
-    // Default to use all but one core if asynchronous, all cores if synchronous.
-    const unsigned threads_per_numa = thread_count / use_numa_count ;
+  if (!use_cores_per_numa) {
+    // Default to use all but one core if asynchronous, all cores if
+    // synchronous.
+    const unsigned threads_per_numa = thread_count / use_numa_count;
 
-    use_cores_per_numa = ! threads_per_numa ? avail_cores_per_numa - ( allow_async ? 1 : 0 ) : (
-                           threads_per_numa < avail_cores_per_numa ? threads_per_numa : avail_cores_per_numa );
+    use_cores_per_numa =
+        !threads_per_numa
+            ? avail_cores_per_numa - (allow_async ? 1 : 0)
+            : (threads_per_numa < avail_cores_per_numa ? threads_per_numa
+                                                       : avail_cores_per_numa);
   }
 
-  if ( ! thread_count ) {
-    thread_count = use_numa_count * use_cores_per_numa * avail_threads_per_core ;
+  if (!thread_count) {
+    thread_count = use_numa_count * use_cores_per_numa * avail_threads_per_core;
   }
 
   //------------------------------------------------------------------------
   // Input verification:
 
-  const bool valid_numa      = use_numa_count <= avail_numa_count ;
-  const bool valid_cores     = use_cores_per_numa &&
-                               use_cores_per_numa <= avail_cores_per_numa ;
-  const bool valid_threads   = thread_count &&
-                               thread_count <= use_numa_count * use_cores_per_numa * avail_threads_per_core ;
-  const bool balanced_numa   = ! ( thread_count % use_numa_count );
-  const bool balanced_cores  = ! ( thread_count % ( use_numa_count * use_cores_per_numa ) );
+  const bool valid_numa = use_numa_count <= avail_numa_count;
+  const bool valid_cores =
+      use_cores_per_numa && use_cores_per_numa <= avail_cores_per_numa;
+  const bool valid_threads =
+      thread_count && thread_count <= use_numa_count * use_cores_per_numa *
+                                          avail_threads_per_core;
+  const bool balanced_numa = !(thread_count % use_numa_count);
+  const bool balanced_cores =
+      !(thread_count % (use_numa_count * use_cores_per_numa));
 
-  const bool valid_input = valid_numa && valid_cores && valid_threads && balanced_numa && balanced_cores ;
+  const bool valid_input = valid_numa && valid_cores && valid_threads &&
+                           balanced_numa && balanced_cores;
 
-  if ( ! valid_input ) {
+  if (!valid_input) {
+    std::ostringstream msg;
 
-    std::ostringstream msg ;
+    msg << label << " HWLOC ERROR(s)";
 
-    msg << label << " HWLOC ERROR(s)" ;
-
-    if ( ! valid_threads ) {
-      msg << " : thread_count(" << thread_count
-          << ") exceeds capacity("
+    if (!valid_threads) {
+      msg << " : thread_count(" << thread_count << ") exceeds capacity("
           << use_numa_count * use_cores_per_numa * avail_threads_per_core
-          << ")" ;
+          << ")";
     }
-    if ( ! valid_numa ) {
-      msg << " : use_numa_count(" << use_numa_count
-          << ") exceeds capacity(" << avail_numa_count << ")" ;
+    if (!valid_numa) {
+      msg << " : use_numa_count(" << use_numa_count << ") exceeds capacity("
+          << avail_numa_count << ")";
     }
-    if ( ! valid_cores ) {
+    if (!valid_cores) {
       msg << " : use_cores_per_numa(" << use_cores_per_numa
-          << ") exceeds capacity(" << avail_cores_per_numa << ")" ;
+          << ") exceeds capacity(" << avail_cores_per_numa << ")";
     }
-    if ( ! balanced_numa ) {
-      msg << " : thread_count(" << thread_count
-          << ") imbalanced among numa(" << use_numa_count << ")" ;
+    if (!balanced_numa) {
+      msg << " : thread_count(" << thread_count << ") imbalanced among numa("
+          << use_numa_count << ")";
     }
-    if ( ! balanced_cores ) {
-      msg << " : thread_count(" << thread_count
-          << ") imbalanced among cores(" << use_numa_count * use_cores_per_numa << ")" ;
+    if (!balanced_cores) {
+      msg << " : thread_count(" << thread_count << ") imbalanced among cores("
+          << use_numa_count * use_cores_per_numa << ")";
     }
 
-    Kokkos::Impl::throw_runtime_exception( msg.str() );
+    Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
   const unsigned thread_spawn_synchronous =
-    ( allow_async &&
-      1 < thread_count &&
-      ( use_numa_count     < avail_numa_count ||
-        use_cores_per_numa < avail_cores_per_numa ) )
-     ? 0 /* asyncronous */
-     : 1 /* synchronous, threads_coord[0] is process core */ ;
+      (allow_async && 1 < thread_count &&
+       (use_numa_count < avail_numa_count ||
+        use_cores_per_numa < avail_cores_per_numa))
+          ? 0 /* asyncronous */
+          : 1 /* synchronous, threads_coord[0] is process core */;
 
   // Determine binding coordinates for to-be-spawned threads so that
   // threads may be bound to cores as they are spawned.
 
-  const unsigned threads_per_core = thread_count / ( use_numa_count * use_cores_per_numa );
+  const unsigned threads_per_core =
+      thread_count / (use_numa_count * use_cores_per_numa);
 
-  if ( thread_spawn_synchronous ) {
+  if (thread_spawn_synchronous) {
     // Working synchronously and include process core as threads_coord[0].
     // Swap the NUMA coordinate of the process core with 0
     // Swap the CORE coordinate of the process core with 0
-    for ( unsigned i = 0 , inuma = avail_numa_count - use_numa_count ; inuma < avail_numa_count ; ++inuma ) {
-      const unsigned numa_coord = 0 == inuma ? proc_coord.first : ( proc_coord.first == inuma ? 0 : inuma );
-      for ( unsigned icore = avail_cores_per_numa - use_cores_per_numa ; icore < avail_cores_per_numa ; ++icore ) {
-        const unsigned core_coord = 0 == icore ? proc_coord.second : ( proc_coord.second == icore ? 0 : icore );
-        for ( unsigned ith = 0 ; ith < threads_per_core ; ++ith , ++i ) {
-          threads_coord[i].first  = numa_coord ;
-          threads_coord[i].second = core_coord ;
+    for (unsigned i = 0, inuma = avail_numa_count - use_numa_count;
+         inuma < avail_numa_count; ++inuma) {
+      const unsigned numa_coord = 0 == inuma
+                                      ? proc_coord.first
+                                      : (proc_coord.first == inuma ? 0 : inuma);
+      for (unsigned icore = avail_cores_per_numa - use_cores_per_numa;
+           icore < avail_cores_per_numa; ++icore) {
+        const unsigned core_coord =
+            0 == icore ? proc_coord.second
+                       : (proc_coord.second == icore ? 0 : icore);
+        for (unsigned ith = 0; ith < threads_per_core; ++ith, ++i) {
+          threads_coord[i].first  = numa_coord;
+          threads_coord[i].second = core_coord;
         }
       }
     }
-  }
-  else if ( use_numa_count < avail_numa_count ) {
+  } else if (use_numa_count < avail_numa_count) {
     // Working asynchronously and omit the process' NUMA region from the pool.
-    // Swap the NUMA coordinate of the process core with ( ( avail_numa_count - use_numa_count ) - 1 )
-    const unsigned numa_coord_swap = ( avail_numa_count - use_numa_count ) - 1 ;
-    for ( unsigned i = 0 , inuma = avail_numa_count - use_numa_count ; inuma < avail_numa_count ; ++inuma ) {
-      const unsigned numa_coord = proc_coord.first == inuma ? numa_coord_swap : inuma ;
-      for ( unsigned icore = avail_cores_per_numa - use_cores_per_numa ; icore < avail_cores_per_numa ; ++icore ) {
-        const unsigned core_coord = icore ;
-        for ( unsigned ith = 0 ; ith < threads_per_core ; ++ith , ++i ) {
-          threads_coord[i].first  = numa_coord ;
-          threads_coord[i].second = core_coord ;
+    // Swap the NUMA coordinate of the process core with ( ( avail_numa_count -
+    // use_numa_count ) - 1 )
+    const unsigned numa_coord_swap = (avail_numa_count - use_numa_count) - 1;
+    for (unsigned i = 0, inuma = avail_numa_count - use_numa_count;
+         inuma < avail_numa_count; ++inuma) {
+      const unsigned numa_coord =
+          proc_coord.first == inuma ? numa_coord_swap : inuma;
+      for (unsigned icore = avail_cores_per_numa - use_cores_per_numa;
+           icore < avail_cores_per_numa; ++icore) {
+        const unsigned core_coord = icore;
+        for (unsigned ith = 0; ith < threads_per_core; ++ith, ++i) {
+          threads_coord[i].first  = numa_coord;
+          threads_coord[i].second = core_coord;
         }
       }
     }
-  }
-  else if ( use_cores_per_numa < avail_cores_per_numa ) {
+  } else if (use_cores_per_numa < avail_cores_per_numa) {
     // Working asynchronously and omit the process' core from the pool.
-    // Swap the CORE coordinate of the process core with ( ( avail_cores_per_numa - use_cores_per_numa ) - 1 )
-    const unsigned core_coord_swap = ( avail_cores_per_numa - use_cores_per_numa ) - 1 ;
-    for ( unsigned i = 0 , inuma = avail_numa_count - use_numa_count ; inuma < avail_numa_count ; ++inuma ) {
-      const unsigned numa_coord = inuma ;
-      for ( unsigned icore = avail_cores_per_numa - use_cores_per_numa ; icore < avail_cores_per_numa ; ++icore ) {
-        const unsigned core_coord = proc_coord.second == icore ? core_coord_swap : icore ;
-        for ( unsigned ith = 0 ; ith < threads_per_core ; ++ith , ++i ) {
-          threads_coord[i].first  = numa_coord ;
-          threads_coord[i].second = core_coord ;
+    // Swap the CORE coordinate of the process core with ( (
+    // avail_cores_per_numa - use_cores_per_numa ) - 1 )
+    const unsigned core_coord_swap =
+        (avail_cores_per_numa - use_cores_per_numa) - 1;
+    for (unsigned i = 0, inuma = avail_numa_count - use_numa_count;
+         inuma < avail_numa_count; ++inuma) {
+      const unsigned numa_coord = inuma;
+      for (unsigned icore = avail_cores_per_numa - use_cores_per_numa;
+           icore < avail_cores_per_numa; ++icore) {
+        const unsigned core_coord =
+            proc_coord.second == icore ? core_coord_swap : icore;
+        for (unsigned ith = 0; ith < threads_per_core; ++ith, ++i) {
+          threads_coord[i].first  = numa_coord;
+          threads_coord[i].second = core_coord;
         }
       }
     }
   }
 
-  return thread_spawn_synchronous ;
+  return thread_spawn_synchronous;
 }
 
 } /* namespace hwloc */
@@ -208,7 +230,7 @@ unsigned thread_mapping( const char * const label ,
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
-#if defined( KOKKOS_ENABLE_HWLOC )
+#if defined(KOKKOS_ENABLE_HWLOC)
 
 #include <iostream>
 #include <sstream>
@@ -220,10 +242,11 @@ unsigned thread_mapping( const char * const label ,
 /* Hardware locality library: http://www.open-mpi.org/projects/hwloc/ */
 #include <hwloc.h>
 
-#define  REQUIRED_HWLOC_API_VERSION  0x000010300
+#define REQUIRED_HWLOC_API_VERSION 0x000010300
 
 #if HWLOC_API_VERSION < REQUIRED_HWLOC_API_VERSION
-#error "Requires  http://www.open-mpi.org/projects/hwloc/  Version 1.3 or greater"
+#error \
+    "Requires  http://www.open-mpi.org/projects/hwloc/  Version 1.3 or greater"
 #endif
 
 /*--------------------------------------------------------------------------*/
@@ -234,458 +257,453 @@ namespace {
 
 #if DEBUG_PRINT
 
-inline
-void print_bitmap( std::ostream & s , const hwloc_const_bitmap_t bitmap )
-{
-  s << "{" ;
-  for ( int i = hwloc_bitmap_first( bitmap ) ;
-        -1 != i ; i = hwloc_bitmap_next( bitmap , i ) ) {
-    s << " " << i ;
+inline void print_bitmap(std::ostream& s, const hwloc_const_bitmap_t bitmap) {
+  s << "{";
+  for (int i = hwloc_bitmap_first(bitmap); - 1 != i;
+       i     = hwloc_bitmap_next(bitmap, i)) {
+    s << " " << i;
   }
-  s << " }" ;
+  s << " }";
 }
 
 #endif
 
 enum { MAX_CORE = 1024 };
 
-std::pair<unsigned,unsigned> s_core_topology(0,0);
-unsigned                     s_core_capacity(0);
-hwloc_topology_t             s_hwloc_topology(0);
-hwloc_bitmap_t               s_hwloc_location(0);
-hwloc_bitmap_t               s_process_binding(0);
-hwloc_bitmap_t               s_core[ MAX_CORE ];
-bool                         s_can_bind_threads(true);
+std::pair<unsigned, unsigned> s_core_topology(0, 0);
+unsigned s_core_capacity(0);
+hwloc_topology_t s_hwloc_topology(0);
+hwloc_bitmap_t s_hwloc_location(0);
+hwloc_bitmap_t s_process_binding(0);
+hwloc_bitmap_t s_core[MAX_CORE];
+bool s_can_bind_threads(true);
 
 struct Sentinel {
   ~Sentinel();
   Sentinel();
 };
 
-bool sentinel()
-{
-  static Sentinel self ;
+bool sentinel() {
+  static Sentinel self;
 
-  if ( 0 == s_hwloc_topology ) {
-    std::cerr << "Kokkos::hwloc ERROR : Called after return from main()" << std::endl ;
+  if (0 == s_hwloc_topology) {
+    std::cerr << "Kokkos::hwloc ERROR : Called after return from main()"
+              << std::endl;
     std::cerr.flush();
   }
 
-  return 0 != s_hwloc_topology ;
+  return 0 != s_hwloc_topology;
 }
 
-Sentinel::~Sentinel()
-{
-  hwloc_topology_destroy( s_hwloc_topology );
-  hwloc_bitmap_free( s_process_binding );
-  hwloc_bitmap_free( s_hwloc_location );
-
-  s_core_topology.first  = 0 ;
-  s_core_topology.second = 0 ;
-  s_core_capacity   = 0 ;
-  s_hwloc_topology  = 0 ;
-  s_hwloc_location  = 0 ;
-  s_process_binding = 0 ;
+Sentinel::~Sentinel() {
+  hwloc_topology_destroy(s_hwloc_topology);
+  hwloc_bitmap_free(s_process_binding);
+  hwloc_bitmap_free(s_hwloc_location);
+
+  s_core_topology.first  = 0;
+  s_core_topology.second = 0;
+  s_core_capacity        = 0;
+  s_hwloc_topology       = 0;
+  s_hwloc_location       = 0;
+  s_process_binding      = 0;
 }
 
-Sentinel::Sentinel()
-{
+Sentinel::Sentinel() {
 #if defined(__MIC__)
-  static const bool remove_core_0 = true ;
+  static const bool remove_core_0 = true;
 #else
-  static const bool remove_core_0 = false ;
+  static const bool remove_core_0 = false;
 #endif
 
-  s_core_topology   = std::pair<unsigned,unsigned>(0,0);
-  s_core_capacity   = 0 ;
-  s_hwloc_topology  = 0 ;
-  s_hwloc_location  = 0 ;
-  s_process_binding = 0 ;
+  s_core_topology   = std::pair<unsigned, unsigned>(0, 0);
+  s_core_capacity   = 0;
+  s_hwloc_topology  = 0;
+  s_hwloc_location  = 0;
+  s_process_binding = 0;
 
-  for ( unsigned i = 0 ; i < MAX_CORE ; ++i ) s_core[i] = 0 ;
+  for (unsigned i = 0; i < MAX_CORE; ++i) s_core[i] = 0;
 
-  hwloc_topology_init( & s_hwloc_topology );
-  hwloc_topology_load( s_hwloc_topology );
+  hwloc_topology_init(&s_hwloc_topology);
+  hwloc_topology_load(s_hwloc_topology);
 
   s_hwloc_location  = hwloc_bitmap_alloc();
   s_process_binding = hwloc_bitmap_alloc();
 
-  hwloc_get_cpubind( s_hwloc_topology , s_process_binding ,  HWLOC_CPUBIND_PROCESS );
+  hwloc_get_cpubind(s_hwloc_topology, s_process_binding, HWLOC_CPUBIND_PROCESS);
 
-  if ( hwloc_bitmap_iszero( s_process_binding ) ) {
-    if (Kokkos::show_warnings() ) {
-      std::cerr << "WARNING: Cannot detect process binding -- ASSUMING ALL processing units" << std::endl;
-    }
-    const int pu_depth = hwloc_get_type_depth( s_hwloc_topology, HWLOC_OBJ_PU );
-    int num_pu = 1;
-    if ( pu_depth != HWLOC_TYPE_DEPTH_UNKNOWN ) {
-      num_pu = hwloc_get_nbobjs_by_depth( s_hwloc_topology, pu_depth );
+  if (hwloc_bitmap_iszero(s_process_binding)) {
+    if (Kokkos::show_warnings()) {
+      std::cerr << "WARNING: Cannot detect process binding -- ASSUMING ALL "
+                   "processing units"
+                << std::endl;
     }
-    else {
-      if (Kokkos::show_warnings() ) {
-        std::cerr << "WARNING: Cannot detect number of processing units -- ASSUMING 1 (serial)." << std::endl;
+    const int pu_depth = hwloc_get_type_depth(s_hwloc_topology, HWLOC_OBJ_PU);
+    int num_pu         = 1;
+    if (pu_depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
+      num_pu = hwloc_get_nbobjs_by_depth(s_hwloc_topology, pu_depth);
+    } else {
+      if (Kokkos::show_warnings()) {
+        std::cerr << "WARNING: Cannot detect number of processing units -- "
+                     "ASSUMING 1 (serial)."
+                  << std::endl;
       }
       num_pu = 1;
     }
-    hwloc_bitmap_set_range( s_process_binding, 0, num_pu-1);
+    hwloc_bitmap_set_range(s_process_binding, 0, num_pu - 1);
     s_can_bind_threads = false;
   }
 
+  if (remove_core_0) {
+    const hwloc_obj_t core =
+        hwloc_get_obj_by_type(s_hwloc_topology, HWLOC_OBJ_CORE, 0);
 
-  if ( remove_core_0 ) {
-
-    const hwloc_obj_t core = hwloc_get_obj_by_type( s_hwloc_topology , HWLOC_OBJ_CORE , 0 );
-
-    if ( hwloc_bitmap_intersects( s_process_binding , core->cpuset ) ) {
-
+    if (hwloc_bitmap_intersects(s_process_binding, core->cpuset)) {
       hwloc_bitmap_t s_process_no_core_zero = hwloc_bitmap_alloc();
 
-      hwloc_bitmap_andnot( s_process_no_core_zero , s_process_binding , core->cpuset );
+      hwloc_bitmap_andnot(s_process_no_core_zero, s_process_binding,
+                          core->cpuset);
 
-      bool ok = 0 == hwloc_set_cpubind( s_hwloc_topology ,
-                                        s_process_no_core_zero ,
-                                        HWLOC_CPUBIND_PROCESS | HWLOC_CPUBIND_STRICT );
+      bool ok =
+          0 == hwloc_set_cpubind(s_hwloc_topology, s_process_no_core_zero,
+                                 HWLOC_CPUBIND_PROCESS | HWLOC_CPUBIND_STRICT);
 
-      if ( ok ) {
-        hwloc_get_cpubind( s_hwloc_topology , s_process_binding ,  HWLOC_CPUBIND_PROCESS );
+      if (ok) {
+        hwloc_get_cpubind(s_hwloc_topology, s_process_binding,
+                          HWLOC_CPUBIND_PROCESS);
 
-        ok = 0 != hwloc_bitmap_isequal( s_process_binding , s_process_no_core_zero );
+        ok = 0 !=
+             hwloc_bitmap_isequal(s_process_binding, s_process_no_core_zero);
       }
 
-      hwloc_bitmap_free( s_process_no_core_zero );
+      hwloc_bitmap_free(s_process_no_core_zero);
 
-      if ( Kokkos::show_warnings() && ! ok ) {
-        std::cerr << "WARNING: Kokkos::hwloc attempted and failed to move process off of core #0" << std::endl ;
+      if (Kokkos::show_warnings() && !ok) {
+        std::cerr << "WARNING: Kokkos::hwloc attempted and failed to move "
+                     "process off of core #0"
+                  << std::endl;
       }
     }
   }
 
   // Choose a hwloc object type for the NUMA level, which may not exist.
 
-  hwloc_obj_type_t root_type = HWLOC_OBJ_TYPE_MAX ;
+  hwloc_obj_type_t root_type = HWLOC_OBJ_TYPE_MAX;
 
   {
     // Object types to search, in order.
-    static const hwloc_obj_type_t candidate_root_type[] =
-      { HWLOC_OBJ_NODE     /* NUMA region     */
-      , HWLOC_OBJ_SOCKET   /* hardware socket */
-      , HWLOC_OBJ_MACHINE  /* local machine   */
-      };
-
-    enum { CANDIDATE_ROOT_TYPE_COUNT =
-             sizeof(candidate_root_type) / sizeof(hwloc_obj_type_t) };
-
-    for ( int k = 0 ; k < CANDIDATE_ROOT_TYPE_COUNT && HWLOC_OBJ_TYPE_MAX == root_type ; ++k ) {
-      if ( 0 < hwloc_get_nbobjs_by_type( s_hwloc_topology , candidate_root_type[k] ) ) {
-        root_type = candidate_root_type[k] ;
+    static const hwloc_obj_type_t candidate_root_type[] = {
+        HWLOC_OBJ_NODE /* NUMA region     */
+        ,
+        HWLOC_OBJ_SOCKET /* hardware socket */
+        ,
+        HWLOC_OBJ_MACHINE /* local machine   */
+    };
+
+    enum {
+      CANDIDATE_ROOT_TYPE_COUNT =
+          sizeof(candidate_root_type) / sizeof(hwloc_obj_type_t)
+    };
+
+    for (int k = 0;
+         k < CANDIDATE_ROOT_TYPE_COUNT && HWLOC_OBJ_TYPE_MAX == root_type;
+         ++k) {
+      if (0 <
+          hwloc_get_nbobjs_by_type(s_hwloc_topology, candidate_root_type[k])) {
+        root_type = candidate_root_type[k];
       }
     }
   }
 
   // Determine which of these 'root' types are available to this process.
-  // The process may have been bound (e.g., by MPI) to a subset of these root types.
-  // Determine current location of the master (calling) process>
+  // The process may have been bound (e.g., by MPI) to a subset of these root
+  // types. Determine current location of the master (calling) process>
 
   hwloc_bitmap_t proc_cpuset_location = hwloc_bitmap_alloc();
 
-  hwloc_get_last_cpu_location( s_hwloc_topology , proc_cpuset_location , HWLOC_CPUBIND_THREAD );
+  hwloc_get_last_cpu_location(s_hwloc_topology, proc_cpuset_location,
+                              HWLOC_CPUBIND_THREAD);
 
-  const unsigned max_root = hwloc_get_nbobjs_by_type( s_hwloc_topology , root_type );
+  const unsigned max_root =
+      hwloc_get_nbobjs_by_type(s_hwloc_topology, root_type);
 
-  unsigned root_base     = max_root ;
-  unsigned root_count    = 0 ;
-  unsigned core_per_root = 0 ;
-  unsigned pu_per_core   = 0 ;
-  bool     symmetric     = true ;
+  unsigned root_base     = max_root;
+  unsigned root_count    = 0;
+  unsigned core_per_root = 0;
+  unsigned pu_per_core   = 0;
+  bool symmetric         = true;
 
-  for ( unsigned i = 0 ; i < max_root ; ++i ) {
+  for (unsigned i = 0; i < max_root; ++i) {
+    const hwloc_obj_t root =
+        hwloc_get_obj_by_type(s_hwloc_topology, root_type, i);
 
-    const hwloc_obj_t root = hwloc_get_obj_by_type( s_hwloc_topology , root_type , i );
-
-    if ( hwloc_bitmap_intersects( s_process_binding , root->cpuset ) ) {
-
-      ++root_count ;
+    if (hwloc_bitmap_intersects(s_process_binding, root->cpuset)) {
+      ++root_count;
 
       // Remember which root (NUMA) object the master thread is running on.
       // This will be logical NUMA rank #0 for this process.
 
-      if ( hwloc_bitmap_intersects( proc_cpuset_location, root->cpuset ) ) {
-        root_base = i ;
+      if (hwloc_bitmap_intersects(proc_cpuset_location, root->cpuset)) {
+        root_base = i;
       }
 
       // Count available cores:
 
-      const unsigned max_core =
-        hwloc_get_nbobjs_inside_cpuset_by_type( s_hwloc_topology ,
-                                                root->cpuset ,
-                                                HWLOC_OBJ_CORE );
+      const unsigned max_core = hwloc_get_nbobjs_inside_cpuset_by_type(
+          s_hwloc_topology, root->cpuset, HWLOC_OBJ_CORE);
 
-      unsigned core_count = 0 ;
+      unsigned core_count = 0;
 
-      for ( unsigned j = 0 ; j < max_core ; ++j ) {
+      for (unsigned j = 0; j < max_core; ++j) {
+        const hwloc_obj_t core = hwloc_get_obj_inside_cpuset_by_type(
+            s_hwloc_topology, root->cpuset, HWLOC_OBJ_CORE, j);
 
-        const hwloc_obj_t core =
-          hwloc_get_obj_inside_cpuset_by_type( s_hwloc_topology ,
-                                               root->cpuset ,
-                                               HWLOC_OBJ_CORE , j );
-
-        // If process' cpuset intersects core's cpuset then process can access this core.
-        // Must use intersection instead of inclusion because the Intel-Phi
-        // MPI may bind the process to only one of the core's hyperthreads.
+        // If process' cpuset intersects core's cpuset then process can access
+        // this core. Must use intersection instead of inclusion because the
+        // Intel-Phi MPI may bind the process to only one of the core's
+        // hyperthreads.
         //
         // Assumption: if the process can access any hyperthread of the core
         // then it has ownership of the entire core.
         // This assumes that it would be performance-detrimental
         // to spawn more than one MPI process per core and use nested threading.
 
-        if ( hwloc_bitmap_intersects( s_process_binding , core->cpuset ) ) {
-
-          ++core_count ;
+        if (hwloc_bitmap_intersects(s_process_binding, core->cpuset)) {
+          ++core_count;
 
-          const unsigned pu_count =
-            hwloc_get_nbobjs_inside_cpuset_by_type( s_hwloc_topology ,
-                                                    core->cpuset ,
-                                                    HWLOC_OBJ_PU );
+          const unsigned pu_count = hwloc_get_nbobjs_inside_cpuset_by_type(
+              s_hwloc_topology, core->cpuset, HWLOC_OBJ_PU);
 
-          if ( pu_per_core == 0 ) pu_per_core = pu_count ;
+          if (pu_per_core == 0) pu_per_core = pu_count;
 
           // Enforce symmetry by taking the minimum:
 
-          pu_per_core = std::min( pu_per_core , pu_count );
+          pu_per_core = std::min(pu_per_core, pu_count);
 
-          if ( pu_count != pu_per_core ) symmetric = false ;
+          if (pu_count != pu_per_core) symmetric = false;
         }
       }
 
-      if ( 0 == core_per_root ) core_per_root = core_count ;
+      if (0 == core_per_root) core_per_root = core_count;
 
       // Enforce symmetry by taking the minimum:
 
-      core_per_root = std::min( core_per_root , core_count );
+      core_per_root = std::min(core_per_root, core_count);
 
-      if ( core_count != core_per_root ) symmetric = false ;
+      if (core_count != core_per_root) symmetric = false;
     }
   }
 
-  s_core_topology.first  = root_count ;
-  s_core_topology.second = core_per_root ;
-  s_core_capacity        = pu_per_core ;
+  s_core_topology.first  = root_count;
+  s_core_topology.second = core_per_root;
+  s_core_capacity        = pu_per_core;
 
   // Fill the 's_core' array for fast mapping from a core coordinate to the
   // hwloc cpuset object required for thread location querying and binding.
 
-  for ( unsigned i = 0 ; i < max_root ; ++i ) {
-
-    const unsigned root_rank = ( i + root_base ) % max_root ;
-
-    const hwloc_obj_t root = hwloc_get_obj_by_type( s_hwloc_topology , root_type , root_rank );
-
-    if ( hwloc_bitmap_intersects( s_process_binding , root->cpuset ) ) {
+  for (unsigned i = 0; i < max_root; ++i) {
+    const unsigned root_rank = (i + root_base) % max_root;
 
-      const unsigned max_core =
-        hwloc_get_nbobjs_inside_cpuset_by_type( s_hwloc_topology ,
-                                                root->cpuset ,
-                                                HWLOC_OBJ_CORE );
+    const hwloc_obj_t root =
+        hwloc_get_obj_by_type(s_hwloc_topology, root_type, root_rank);
 
-      unsigned core_count = 0 ;
+    if (hwloc_bitmap_intersects(s_process_binding, root->cpuset)) {
+      const unsigned max_core = hwloc_get_nbobjs_inside_cpuset_by_type(
+          s_hwloc_topology, root->cpuset, HWLOC_OBJ_CORE);
 
-      for ( unsigned j = 0 ; j < max_core && core_count < core_per_root ; ++j ) {
+      unsigned core_count = 0;
 
-        const hwloc_obj_t core =
-          hwloc_get_obj_inside_cpuset_by_type( s_hwloc_topology ,
-                                               root->cpuset ,
-                                               HWLOC_OBJ_CORE , j );
+      for (unsigned j = 0; j < max_core && core_count < core_per_root; ++j) {
+        const hwloc_obj_t core = hwloc_get_obj_inside_cpuset_by_type(
+            s_hwloc_topology, root->cpuset, HWLOC_OBJ_CORE, j);
 
-        if ( hwloc_bitmap_intersects( s_process_binding , core->cpuset ) ) {
+        if (hwloc_bitmap_intersects(s_process_binding, core->cpuset)) {
+          s_core[core_count + core_per_root * i] = core->cpuset;
 
-          s_core[ core_count + core_per_root * i ] = core->cpuset ;
-
-          ++core_count ;
+          ++core_count;
         }
       }
     }
   }
 
-  hwloc_bitmap_free( proc_cpuset_location );
+  hwloc_bitmap_free(proc_cpuset_location);
 
-  if ( Kokkos::show_warnings() && ! symmetric ) {
-    std::cerr << "Kokkos::hwloc WARNING: Using a symmetric subset of a non-symmetric core topology."
-              << std::endl ;
+  if (Kokkos::show_warnings() && !symmetric) {
+    std::cerr << "Kokkos::hwloc WARNING: Using a symmetric subset of a "
+                 "non-symmetric core topology."
+              << std::endl;
   }
 }
 
-
-} // namespace
+}  // namespace
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-bool available()
-{ return true ; }
+bool available() { return true; }
 
-unsigned get_available_numa_count()
-{ sentinel(); return s_core_topology.first ; }
+unsigned get_available_numa_count() {
+  sentinel();
+  return s_core_topology.first;
+}
 
-unsigned get_available_cores_per_numa()
-{ sentinel(); return s_core_topology.second ; }
+unsigned get_available_cores_per_numa() {
+  sentinel();
+  return s_core_topology.second;
+}
 
-unsigned get_available_threads_per_core()
-{ sentinel(); return s_core_capacity ; }
+unsigned get_available_threads_per_core() {
+  sentinel();
+  return s_core_capacity;
+}
 
-bool can_bind_threads()
-{ sentinel(); return s_can_bind_threads; }
+bool can_bind_threads() {
+  sentinel();
+  return s_can_bind_threads;
+}
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-unsigned bind_this_thread(
-  const unsigned               coordinate_count ,
-  std::pair<unsigned,unsigned> coordinate[] )
-{
-  unsigned i = 0 ;
+unsigned bind_this_thread(const unsigned coordinate_count,
+                          std::pair<unsigned, unsigned> coordinate[]) {
+  unsigned i = 0;
 
   try {
-    const std::pair<unsigned,unsigned> current = get_this_thread_coordinate();
+    const std::pair<unsigned, unsigned> current = get_this_thread_coordinate();
 
     // Match one of the requests:
-    for ( i = 0 ; i < coordinate_count && current != coordinate[i] ; ++i );
+    for (i = 0; i < coordinate_count && current != coordinate[i]; ++i)
+      ;
 
-    if ( coordinate_count == i ) {
+    if (coordinate_count == i) {
       // Match the first request (typically NUMA):
-      for ( i = 0 ; i < coordinate_count && current.first != coordinate[i].first ; ++i );
+      for (i = 0; i < coordinate_count && current.first != coordinate[i].first;
+           ++i)
+        ;
     }
 
-    if ( coordinate_count == i ) {
+    if (coordinate_count == i) {
       // Match any unclaimed request:
-      for ( i = 0 ; i < coordinate_count && ~0u == coordinate[i].first  ; ++i );
+      for (i = 0; i < coordinate_count && ~0u == coordinate[i].first; ++i)
+        ;
     }
 
-    if ( coordinate_count == i || ! bind_this_thread( coordinate[i] ) ) {
-       // Failed to bind:
-       i = ~0u ;
+    if (coordinate_count == i || !bind_this_thread(coordinate[i])) {
+      // Failed to bind:
+      i = ~0u;
     }
 
-    if ( i < coordinate_count ) {
-
+    if (i < coordinate_count) {
 #if DEBUG_PRINT
-      if ( current != coordinate[i] ) {
-        std::cout << "  bind_this_thread: rebinding from ("
-                  << current.first << ","
-                  << current.second
-                  << ") to ("
-                  << coordinate[i].first << ","
-                  << coordinate[i].second
-                  << ")" << std::endl ;
+      if (current != coordinate[i]) {
+        std::cout << "  bind_this_thread: rebinding from (" << current.first
+                  << "," << current.second << ") to (" << coordinate[i].first
+                  << "," << coordinate[i].second << ")" << std::endl;
       }
 #endif
 
-      coordinate[i].first  = ~0u ;
-      coordinate[i].second = ~0u ;
+      coordinate[i].first  = ~0u;
+      coordinate[i].second = ~0u;
     }
-  }
-  catch( ... ) {
-    i = ~0u ;
+  } catch (...) {
+    i = ~0u;
   }
 
-  return i ;
+  return i;
 }
 
-
-bool bind_this_thread( const std::pair<unsigned,unsigned> coord )
-{
-  if ( ! sentinel() ) return false ;
+bool bind_this_thread(const std::pair<unsigned, unsigned> coord) {
+  if (!sentinel()) return false;
 
 #if DEBUG_PRINT
 
-  std::cout << "Kokkos::bind_this_thread() at " ;
+  std::cout << "Kokkos::bind_this_thread() at ";
 
-  hwloc_get_last_cpu_location( s_hwloc_topology ,
-                               s_hwloc_location , HWLOC_CPUBIND_THREAD );
+  hwloc_get_last_cpu_location(s_hwloc_topology, s_hwloc_location,
+                              HWLOC_CPUBIND_THREAD);
 
-  print_bitmap( std::cout , s_hwloc_location );
+  print_bitmap(std::cout, s_hwloc_location);
 
-  std::cout << " to " ;
+  std::cout << " to ";
 
-  print_bitmap( std::cout , s_core[ coord.second + coord.first * s_core_topology.second ] );
+  print_bitmap(std::cout,
+               s_core[coord.second + coord.first * s_core_topology.second]);
 
-  std::cout << std::endl ;
+  std::cout << std::endl;
 
 #endif
 
   // As safe and fast as possible.
   // Fast-lookup by caching the coordinate -> hwloc cpuset mapping in 's_core'.
-  return coord.first  < s_core_topology.first &&
+  return coord.first < s_core_topology.first &&
          coord.second < s_core_topology.second &&
-         0 == hwloc_set_cpubind( s_hwloc_topology ,
-                                 s_core[ coord.second + coord.first * s_core_topology.second ] ,
-                                 HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT );
+         0 == hwloc_set_cpubind(
+                  s_hwloc_topology,
+                  s_core[coord.second + coord.first * s_core_topology.second],
+                  HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT);
 }
 
-bool unbind_this_thread()
-{
-  if ( ! sentinel() ) return false ;
+bool unbind_this_thread() {
+  if (!sentinel()) return false;
 
 #define HWLOC_DEBUG_PRINT 0
 
 #if HWLOC_DEBUG_PRINT
 
-  std::cout << "Kokkos::unbind_this_thread() from " ;
+  std::cout << "Kokkos::unbind_this_thread() from ";
 
-  hwloc_get_cpubind( s_hwloc_topology , s_hwloc_location , HWLOC_CPUBIND_THREAD );
+  hwloc_get_cpubind(s_hwloc_topology, s_hwloc_location, HWLOC_CPUBIND_THREAD);
 
-  print_bitmap( std::cout , s_hwloc_location );
+  print_bitmap(std::cout, s_hwloc_location);
 
 #endif
 
   const bool result =
-    s_hwloc_topology &&
-    0 == hwloc_set_cpubind( s_hwloc_topology ,
-                            s_process_binding ,
-                            HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT );
+      s_hwloc_topology &&
+      0 == hwloc_set_cpubind(s_hwloc_topology, s_process_binding,
+                             HWLOC_CPUBIND_THREAD | HWLOC_CPUBIND_STRICT);
 
 #if HWLOC_DEBUG_PRINT
 
-  std::cout << " to " ;
+  std::cout << " to ";
 
-  hwloc_get_cpubind( s_hwloc_topology , s_hwloc_location , HWLOC_CPUBIND_THREAD );
+  hwloc_get_cpubind(s_hwloc_topology, s_hwloc_location, HWLOC_CPUBIND_THREAD);
 
-  print_bitmap( std::cout , s_hwloc_location );
+  print_bitmap(std::cout, s_hwloc_location);
 
-  std::cout << std::endl ;
+  std::cout << std::endl;
 
 #endif
 
-  return result ;
+  return result;
 
 #undef HWLOC_DEBUG_PRINT
-
 }
 
 //----------------------------------------------------------------------------
 
-std::pair<unsigned,unsigned> get_this_thread_coordinate()
-{
-  std::pair<unsigned,unsigned> coord(0u,0u);
+std::pair<unsigned, unsigned> get_this_thread_coordinate() {
+  std::pair<unsigned, unsigned> coord(0u, 0u);
 
-  if ( ! sentinel() ) return coord ;
+  if (!sentinel()) return coord;
 
-  const unsigned n = s_core_topology.first * s_core_topology.second ;
+  const unsigned n = s_core_topology.first * s_core_topology.second;
 
   // Using the pre-allocated 's_hwloc_location' to avoid memory
   // allocation by this thread.  This call is NOT thread-safe.
-  hwloc_get_last_cpu_location( s_hwloc_topology ,
-                               s_hwloc_location , HWLOC_CPUBIND_THREAD );
+  hwloc_get_last_cpu_location(s_hwloc_topology, s_hwloc_location,
+                              HWLOC_CPUBIND_THREAD);
 
-  unsigned i = 0 ;
+  unsigned i = 0;
 
-  while ( i < n && ! hwloc_bitmap_intersects( s_hwloc_location , s_core[ i ] ) ) ++i ;
+  while (i < n && !hwloc_bitmap_intersects(s_hwloc_location, s_core[i])) ++i;
 
-  if ( i < n ) {
-    coord.first  = i / s_core_topology.second ;
-    coord.second = i % s_core_topology.second ;
+  if (i < n) {
+    coord.first  = i / s_core_topology.second;
+    coord.second = i % s_core_topology.second;
   }
 
-  return coord ;
+  return coord;
 }
 
 //----------------------------------------------------------------------------
@@ -701,30 +719,29 @@ std::pair<unsigned,unsigned> get_this_thread_coordinate()
 namespace Kokkos {
 namespace hwloc {
 
-bool available() { return false ; }
-bool can_bind_threads() { return false ; }
+bool available() { return false; }
+bool can_bind_threads() { return false; }
 
-unsigned get_available_numa_count() { return 1 ; }
-unsigned get_available_cores_per_numa() { return 1 ; }
-unsigned get_available_threads_per_core() { return 1 ; }
+unsigned get_available_numa_count() { return 1; }
+unsigned get_available_cores_per_numa() { return 1; }
+unsigned get_available_threads_per_core() { return 1; }
 
-unsigned bind_this_thread( const unsigned , std::pair<unsigned,unsigned>[] )
-{ return ~0 ; }
+unsigned bind_this_thread(const unsigned, std::pair<unsigned, unsigned>[]) {
+  return ~0;
+}
 
-bool bind_this_thread( const std::pair<unsigned,unsigned> )
-{ return false ; }
+bool bind_this_thread(const std::pair<unsigned, unsigned>) { return false; }
 
-bool unbind_this_thread()
-{ return true ; }
+bool unbind_this_thread() { return true; }
 
-std::pair<unsigned,unsigned> get_this_thread_coordinate()
-{ return std::pair<unsigned,unsigned>(0,0); }
+std::pair<unsigned, unsigned> get_this_thread_coordinate() {
+  return std::pair<unsigned, unsigned>(0, 0);
+}
 
-} // namespace hwloc
-} // namespace Kokkos
+}  // namespace hwloc
+}  // namespace Kokkos
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 #endif
-
diff --git a/lib/kokkos/core/src/kokkos.pc.in b/lib/kokkos/core/src/kokkos.pc.in
index f27b57c960781c334e98eb0c61adf55aee7614e8..47786faefb9668a62763ed9b79fe71254fe3e500 100644
--- a/lib/kokkos/core/src/kokkos.pc.in
+++ b/lib/kokkos/core/src/kokkos.pc.in
@@ -1,8 +1,9 @@
 # 
-#                        Kokkos v. 2.0
-#              Copyright (2014) Sandia Corporation
+#                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 # 
-# Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+# Under the terms of Contract DE-NA0003525 with NTESS,
 # the U.S. Government retains certain rights in this software.
 # 
 # Redistribution and use in source and binary forms, with or without
@@ -20,10 +21,10 @@
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
-# THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+# THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,14 +58,13 @@
 # pkg_check_modules(KOKKOS IMPORTED_TARGET kokkos)
 # target_link_libraries(<lib> PkgConfig::KOKKOS)
 
-prefix=@CMAKE_INSTALL_PREFIX@
-libdir=${prefix}/lib
-includedir=${prefix}/include
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
 
 Name: kokkos
 Description: Kokkos C++ Performance Portability Programming EcoSystem
 URL: https://github.com/kokkos
-Version:
+Version: @Kokkos_VERSION@
 Requires:
 Libs: -L${libdir} -lkokkos @KOKKOS_EXTRA_LIBS_LIST@ @KOKKOS_LINK_FLAGS@
 Libs.private: -lm
diff --git a/lib/kokkos/core/unit_test/CMakeLists.txt b/lib/kokkos/core/unit_test/CMakeLists.txt
index 6a480daa8d4ea3c13b3826fbe9a3afb8acefec06..c0957e83a886f4464dcdc01893177a775768dfc4 100644
--- a/lib/kokkos/core/unit_test/CMakeLists.txt
+++ b/lib/kokkos/core/unit_test/CMakeLists.txt
@@ -2,635 +2,162 @@
 # Add test-only library for gtest to be reused by all the subpackages
 #
 
-IF(NOT KOKKOS_HAS_TRILINOS)
-  IF(KOKKOS_SEPARATE_LIBS)
-    set(TEST_LINK_TARGETS kokkoscore)
-  ELSE()
-    set(TEST_LINK_TARGETS kokkos)
-  ENDIF()
-ENDIF()
 
 SET(GTEST_SOURCE_DIR ${${PARENT_PACKAGE_NAME}_SOURCE_DIR}/tpls/gtest)
-# TODO get the C++ standard flag from KOKKOS_CXX_STANDARD
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGTEST_HAS_PTHREAD=0")
 
-INCLUDE_DIRECTORIES(${GTEST_SOURCE_DIR})
-TRIBITS_ADD_LIBRARY(
+#need here for tribits
+KOKKOS_INCLUDE_DIRECTORIES(${GTEST_SOURCE_DIR})
+KOKKOS_ADD_TEST_LIBRARY(
   kokkos_gtest
   HEADERS ${GTEST_SOURCE_DIR}/gtest/gtest.h
   SOURCES ${GTEST_SOURCE_DIR}/gtest/gtest-all.cc
-  TESTONLY
-  )
-
-IF(NOT KOKKOS_HAS_TRILINOS)
-target_compile_options(
-  kokkos_gtest
-  PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${KOKKOS_CXX_FLAGS}>
 )
-target_link_libraries(
-  kokkos_gtest
-  PUBLIC ${KOKKOS_LD_FLAGS}
-)
-ENDIF()
+KOKKOS_TARGET_COMPILE_DEFINITIONS(kokkos_gtest PUBLIC "-DGTEST_HAS_PTHREAD=0")
+KOKKOS_TARGET_INCLUDE_DIRECTORIES(kokkos_gtest PUBLIC ${GTEST_SOURCE_DIR})
+
 
 #
 # Define the tests
 #
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
+#I will leave these alone for now because I don't need transitive dependencies on tests
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
 
-IF(Kokkos_ENABLE_Serial)
-  IF(KOKKOS_SEPARATE_TESTS)
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_Atomics
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_AtomicOperations_int.cpp
-        serial/TestSerial_AtomicOperations_unsignedint.cpp
-        serial/TestSerial_AtomicOperations_longint.cpp
-        serial/TestSerial_AtomicOperations_unsignedlongint.cpp
-        serial/TestSerial_AtomicOperations_longlongint.cpp
-        serial/TestSerial_AtomicOperations_double.cpp
-        serial/TestSerial_AtomicOperations_float.cpp
-        serial/TestSerial_AtomicOperations_complexdouble.cpp
-        serial/TestSerial_AtomicOperations_complexfloat.cpp
-        serial/TestSerial_AtomicViews.cpp
-        serial/TestSerial_Atomics.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_SubView
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_SubView_a.cpp
-        serial/TestSerial_SubView_b.cpp
-        serial/TestSerial_SubView_c01.cpp
-        serial/TestSerial_SubView_c02.cpp
-        serial/TestSerial_SubView_c03.cpp
-        serial/TestSerial_SubView_c04.cpp
-        serial/TestSerial_SubView_c05.cpp
-        serial/TestSerial_SubView_c06.cpp
-        serial/TestSerial_SubView_c07.cpp
-        serial/TestSerial_SubView_c08.cpp
-        serial/TestSerial_SubView_c09.cpp
-        serial/TestSerial_SubView_c10.cpp
-        serial/TestSerial_SubView_c11.cpp
-        serial/TestSerial_SubView_c12.cpp
-        serial/TestSerial_SubView_c13.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_ViewAPI
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_ViewAPI_a.cpp
-        serial/TestSerial_ViewAPI_b.cpp
-        serial/TestSerial_ViewAPI_c.cpp
-        serial/TestSerial_ViewAPI_d.cpp
-        serial/TestSerial_ViewAPI_e.cpp
-        serial/TestSerial_ViewOfClass.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_ViewMapping
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_ViewMapping_a.cpp
-        serial/TestSerial_ViewMapping_b.cpp
-        serial/TestSerial_ViewMapping_subview.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_Reducers
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_Reductions.cpp
-        serial/TestSerial_Reducers_a.cpp
-        serial/TestSerial_Reducers_b.cpp
-        serial/TestSerial_Reducers_c.cpp
-        serial/TestSerial_Reducers_d.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_MDRange
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_MDRange_a.cpp
-        serial/TestSerial_MDRange_b.cpp
-        serial/TestSerial_MDRange_c.cpp
-        serial/TestSerial_MDRange_d.cpp
-        serial/TestSerial_MDRange_e.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_Team
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_Team.cpp
-        serial/TestSerial_TeamReductionScan.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_Tasking
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_Task.cpp
-        serial/TestSerial_WorkGraph.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial_Misc
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_Complex.cpp
-        serial/TestSerial_Init.cpp
-        serial/TestSerial_Other.cpp
-        serial/TestSerial_RangePolicy.cpp
-        serial/TestSerial_Scan.cpp
-        serial/TestSerial_SharedAlloc.cpp
-        serial/TestSerial_Crs.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-  ELSE()
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_Serial
-      SOURCES
-        UnitTestMainInit.cpp
-        serial/TestSerial_AtomicOperations_int.cpp
-        serial/TestSerial_AtomicOperations_unsignedint.cpp
-        serial/TestSerial_AtomicOperations_longint.cpp
-        serial/TestSerial_AtomicOperations_unsignedlongint.cpp
-        serial/TestSerial_AtomicOperations_longlongint.cpp
-        serial/TestSerial_AtomicOperations_double.cpp
-        serial/TestSerial_AtomicOperations_float.cpp
-        serial/TestSerial_AtomicOperations_complexdouble.cpp
-        serial/TestSerial_AtomicOperations_complexfloat.cpp
-        serial/TestSerial_AtomicViews.cpp
-        serial/TestSerial_Atomics.cpp
-        serial/TestSerial_Complex.cpp
-        serial/TestSerial_Init.cpp
-        serial/TestSerial_MDRange_a.cpp
-        serial/TestSerial_MDRange_b.cpp
-        serial/TestSerial_MDRange_c.cpp
-        serial/TestSerial_MDRange_d.cpp
-        serial/TestSerial_MDRange_e.cpp
-        serial/TestSerial_Other.cpp
-        serial/TestSerial_RangePolicy.cpp
-        serial/TestSerial_Reductions.cpp
-        serial/TestSerial_Reducers_a.cpp
-        serial/TestSerial_Reducers_b.cpp
-        serial/TestSerial_Reducers_c.cpp
-        serial/TestSerial_Reducers_d.cpp
-        serial/TestSerial_Scan.cpp
-        serial/TestSerial_SharedAlloc.cpp
-        serial/TestSerial_SubView_a.cpp
-        serial/TestSerial_SubView_b.cpp
-        serial/TestSerial_SubView_c01.cpp
-        serial/TestSerial_SubView_c02.cpp
-        serial/TestSerial_SubView_c03.cpp
-        serial/TestSerial_SubView_c04.cpp
-        serial/TestSerial_SubView_c05.cpp
-        serial/TestSerial_SubView_c06.cpp
-        serial/TestSerial_SubView_c07.cpp
-        serial/TestSerial_SubView_c08.cpp
-        serial/TestSerial_SubView_c09.cpp
-        serial/TestSerial_SubView_c10.cpp
-        serial/TestSerial_SubView_c11.cpp
-        serial/TestSerial_SubView_c12.cpp
-        serial/TestSerial_SubView_c13.cpp
-        serial/TestSerial_Task.cpp
-        serial/TestSerial_Team.cpp
-        serial/TestSerial_TeamReductionScan.cpp
-        serial/TestSerial_TeamScratch.cpp
-        serial/TestSerial_ViewAPI_a.cpp
-        serial/TestSerial_ViewAPI_b.cpp
-        serial/TestSerial_ViewAPI_c.cpp
-        serial/TestSerial_ViewAPI_d.cpp
-        serial/TestSerial_ViewAPI_e.cpp
-        serial/TestSerial_ViewMapping_a.cpp
-        serial/TestSerial_ViewMapping_b.cpp
-        serial/TestSerial_ViewMapping_subview.cpp
-        serial/TestSerial_ViewOfClass.cpp
-        serial/TestSerial_Crs.cpp
-        serial/TestSerial_WorkGraph.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-  ENDIF()
-ENDIF()
+foreach(Tag Threads;Serial;OpenMP;Cuda;HPX)
+  # Because there is always an exception to the rule
+  if(Tag STREQUAL "Threads")
+    set(DEVICE "PTHREAD")
+  else()
+    string(TOUPPER ${Tag} DEVICE)
+  endif()
+  string(TOLOWER ${Tag} dir)
 
-IF(Kokkos_ENABLE_Pthread)
-  TRIBITS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_Threads
-    SOURCES
+  SET(${Tag}_SOURCES
       UnitTestMainInit.cpp
-      threads/TestThreads_AtomicOperations_int.cpp
-      threads/TestThreads_AtomicOperations_unsignedint.cpp
-      threads/TestThreads_AtomicOperations_longint.cpp
-      threads/TestThreads_AtomicOperations_unsignedlongint.cpp
-      threads/TestThreads_AtomicOperations_longlongint.cpp
-      threads/TestThreads_AtomicOperations_double.cpp
-      threads/TestThreads_AtomicOperations_float.cpp
-      threads/TestThreads_AtomicOperations_complexdouble.cpp
-      threads/TestThreads_AtomicOperations_complexfloat.cpp
-      threads/TestThreads_AtomicViews.cpp
-      threads/TestThreads_Atomics.cpp
-      threads/TestThreads_Complex.cpp
-      threads/TestThreads_Init.cpp
-      threads/TestThreads_MDRange_a.cpp
-      threads/TestThreads_MDRange_b.cpp
-      threads/TestThreads_MDRange_c.cpp
-      threads/TestThreads_MDRange_d.cpp
-      threads/TestThreads_MDRange_e.cpp
-      threads/TestThreads_Other.cpp
-      threads/TestThreads_RangePolicy.cpp
-      threads/TestThreads_Reductions.cpp
-      threads/TestThreads_Reducers_a.cpp
-      threads/TestThreads_Reducers_b.cpp
-      threads/TestThreads_Reducers_c.cpp
-      threads/TestThreads_Reducers_d.cpp
-      threads/TestThreads_Scan.cpp
-      threads/TestThreads_SharedAlloc.cpp
-      threads/TestThreads_SubView_a.cpp
-      threads/TestThreads_SubView_b.cpp
-      threads/TestThreads_SubView_c01.cpp
-      threads/TestThreads_SubView_c02.cpp
-      threads/TestThreads_SubView_c03.cpp
-      threads/TestThreads_SubView_c04.cpp
-      threads/TestThreads_SubView_c05.cpp
-      threads/TestThreads_SubView_c06.cpp
-      threads/TestThreads_SubView_c07.cpp
-      threads/TestThreads_SubView_c08.cpp
-      threads/TestThreads_SubView_c09.cpp
-      threads/TestThreads_SubView_c10.cpp
-      threads/TestThreads_SubView_c11.cpp
-      threads/TestThreads_SubView_c12.cpp
-      threads/TestThreads_SubView_c13.cpp
-      threads/TestThreads_Team.cpp
-      threads/TestThreads_TeamReductionScan.cpp
-      threads/TestThreads_TeamScratch.cpp
-      threads/TestThreads_ViewAPI_a.cpp
-      threads/TestThreads_ViewAPI_b.cpp
-      threads/TestThreads_ViewAPI_c.cpp
-      threads/TestThreads_ViewAPI_d.cpp
-      threads/TestThreads_ViewAPI_e.cpp
-      threads/TestThreads_ViewMapping_a.cpp
-      threads/TestThreads_ViewMapping_b.cpp
-      threads/TestThreads_ViewMapping_subview.cpp
-      threads/TestThreads_ViewOfClass.cpp
-      threads/TestThreads_Crs.cpp
-      threads/TestThreads_WorkGraph.cpp
-    COMM serial mpi
-    NUM_MPI_PROCS 1
-    FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
+      ${dir}/Test${Tag}_AtomicOperations_int.cpp
+      ${dir}/Test${Tag}_AtomicOperations_unsignedint.cpp
+      ${dir}/Test${Tag}_AtomicOperations_longint.cpp
+      ${dir}/Test${Tag}_AtomicOperations_unsignedlongint.cpp
+      ${dir}/Test${Tag}_AtomicOperations_longlongint.cpp
+      ${dir}/Test${Tag}_AtomicOperations_double.cpp
+      ${dir}/Test${Tag}_AtomicOperations_float.cpp
+      ${dir}/Test${Tag}_AtomicOperations_complexdouble.cpp
+      ${dir}/Test${Tag}_AtomicOperations_complexfloat.cpp
+      ${dir}/Test${Tag}_AtomicViews.cpp
+      ${dir}/Test${Tag}_Atomics.cpp
+      ${dir}/Test${Tag}_Complex.cpp
+      ${dir}/Test${Tag}_Crs.cpp
+      ${dir}/Test${Tag}_DeepCopyAlignment.cpp
+      ${dir}/Test${Tag}_FunctorAnalysis.cpp
+      ${dir}/Test${Tag}_Init.cpp
+      ${dir}/Test${Tag}_LocalDeepCopy.cpp
+      ${dir}/Test${Tag}_MDRange_a.cpp
+      ${dir}/Test${Tag}_MDRange_b.cpp
+      ${dir}/Test${Tag}_MDRange_c.cpp
+      ${dir}/Test${Tag}_MDRange_d.cpp
+      ${dir}/Test${Tag}_MDRange_e.cpp
+      ${dir}/Test${Tag}_Other.cpp
+      ${dir}/Test${Tag}_RangePolicy.cpp
+      ${dir}/Test${Tag}_Reductions.cpp
+      ${dir}/Test${Tag}_Reducers_a.cpp
+      ${dir}/Test${Tag}_Reducers_b.cpp
+      ${dir}/Test${Tag}_Reducers_c.cpp
+      ${dir}/Test${Tag}_Reducers_d.cpp
+      ${dir}/Test${Tag}_Reductions_DeviceView.cpp
+      ${dir}/Test${Tag}_Scan.cpp
+      ${dir}/Test${Tag}_SharedAlloc.cpp
+      ${dir}/Test${Tag}_SubView_a.cpp
+      ${dir}/Test${Tag}_SubView_b.cpp
+      ${dir}/Test${Tag}_SubView_c01.cpp
+      ${dir}/Test${Tag}_SubView_c02.cpp
+      ${dir}/Test${Tag}_SubView_c03.cpp
+      ${dir}/Test${Tag}_SubView_c04.cpp
+      ${dir}/Test${Tag}_SubView_c05.cpp
+      ${dir}/Test${Tag}_SubView_c06.cpp
+      ${dir}/Test${Tag}_SubView_c07.cpp
+      ${dir}/Test${Tag}_SubView_c08.cpp
+      ${dir}/Test${Tag}_SubView_c09.cpp
+      ${dir}/Test${Tag}_SubView_c10.cpp
+      ${dir}/Test${Tag}_SubView_c11.cpp
+      ${dir}/Test${Tag}_SubView_c12.cpp
+      ${dir}/Test${Tag}_SubView_c13.cpp
+      ${dir}/Test${Tag}_Team.cpp
+      ${dir}/Test${Tag}_TeamReductionScan.cpp
+      ${dir}/Test${Tag}_TeamScratch.cpp
+      ${dir}/Test${Tag}_TeamTeamSize.cpp
+      ${dir}/Test${Tag}_TeamVectorRange.cpp
+      ${dir}/Test${Tag}_UniqueToken.cpp
+      ${dir}/Test${Tag}_ViewAPI_a.cpp
+      ${dir}/Test${Tag}_ViewAPI_b.cpp
+      ${dir}/Test${Tag}_ViewAPI_c.cpp
+      ${dir}/Test${Tag}_ViewAPI_d.cpp
+      ${dir}/Test${Tag}_ViewAPI_e.cpp
+      ${dir}/Test${Tag}_ViewLayoutStrideAssignment.cpp
+      ${dir}/Test${Tag}_ViewMapping_a.cpp
+      ${dir}/Test${Tag}_ViewMapping_b.cpp
+      ${dir}/Test${Tag}_ViewMapping_subview.cpp
+      ${dir}/Test${Tag}_ViewOfClass.cpp
+      ${dir}/Test${Tag}_WorkGraph.cpp
+      ${dir}/Test${Tag}_View_64bit.cpp
+      ${dir}/Test${Tag}_ViewResize.cpp
   )
-ENDIF()
+endforeach()
 
-IF(Kokkos_ENABLE_OpenMP)
-  IF(KOKKOS_SEPARATE_TESTS)
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_Atomics
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_AtomicOperations_int.cpp
-        openmp/TestOpenMP_AtomicOperations_unsignedint.cpp
-        openmp/TestOpenMP_AtomicOperations_longint.cpp
-        openmp/TestOpenMP_AtomicOperations_unsignedlongint.cpp
-        openmp/TestOpenMP_AtomicOperations_longlongint.cpp
-        openmp/TestOpenMP_AtomicOperations_double.cpp
-        openmp/TestOpenMP_AtomicOperations_float.cpp
-        openmp/TestOpenMP_AtomicOperations_complexdouble.cpp
-        openmp/TestOpenMP_AtomicOperations_complexfloat.cpp
-        openmp/TestOpenMP_AtomicViews.cpp
-        openmp/TestOpenMP_Atomics.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_SubView
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_SubView_a.cpp
-        openmp/TestOpenMP_SubView_b.cpp
-        openmp/TestOpenMP_SubView_c01.cpp
-        openmp/TestOpenMP_SubView_c02.cpp
-        openmp/TestOpenMP_SubView_c03.cpp
-        openmp/TestOpenMP_SubView_c04.cpp
-        openmp/TestOpenMP_SubView_c05.cpp
-        openmp/TestOpenMP_SubView_c06.cpp
-        openmp/TestOpenMP_SubView_c07.cpp
-        openmp/TestOpenMP_SubView_c08.cpp
-        openmp/TestOpenMP_SubView_c09.cpp
-        openmp/TestOpenMP_SubView_c10.cpp
-        openmp/TestOpenMP_SubView_c11.cpp
-        openmp/TestOpenMP_SubView_c12.cpp
-        openmp/TestOpenMP_SubView_c13.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_ViewAPI
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_ViewAPI_a.cpp
-        openmp/TestOpenMP_ViewAPI_b.cpp
-        openmp/TestOpenMP_ViewAPI_c.cpp
-        openmp/TestOpenMP_ViewAPI_d.cpp
-        openmp/TestOpenMP_ViewAPI_e.cpp
-        openmp/TestOpenMP_ViewOfClass.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_ViewMapping
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_ViewMapping_a.cpp
-        openmp/TestOpenMP_ViewMapping_b.cpp
-        openmp/TestOpenMP_ViewMapping_subview.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_Reducers
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_Reductions.cpp
-        openmp/TestOpenMP_Reducers_a.cpp
-        openmp/TestOpenMP_Reducers_b.cpp
-        openmp/TestOpenMP_Reducers_c.cpp
-        openmp/TestOpenMP_Reducers_d.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_MDRange
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_MDRange_a.cpp
-        openmp/TestOpenMP_MDRange_b.cpp
-        openmp/TestOpenMP_MDRange_c.cpp
-        openmp/TestOpenMP_MDRange_d.cpp
-        openmp/TestOpenMP_MDRange_e.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_Team
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_Team.cpp
-        openmp/TestOpenMP_TeamReductionScan.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_Tasking
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_Task.cpp
-        openmp/TestOpenMP_WorkGraph.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP_Misc
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_Complex.cpp
-        openmp/TestOpenMP_Init.cpp
-        openmp/TestOpenMP_Other.cpp
-        openmp/TestOpenMP_RangePolicy.cpp
-        openmp/TestOpenMP_Scan.cpp
-        openmp/TestOpenMP_SharedAlloc.cpp
-        openmp/TestOpenMP_Crs.cpp
-        openmp/TestOpenMP_UniqueToken.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMPInterOp
-      SOURCES
-        UnitTestMain.cpp
-        openmp/TestOpenMP_InterOp.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-  ELSE()
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMP
-      SOURCES
-        UnitTestMainInit.cpp
-        openmp/TestOpenMP_AtomicOperations_int.cpp
-        openmp/TestOpenMP_AtomicOperations_unsignedint.cpp
-        openmp/TestOpenMP_AtomicOperations_longint.cpp
-        openmp/TestOpenMP_AtomicOperations_unsignedlongint.cpp
-        openmp/TestOpenMP_AtomicOperations_longlongint.cpp
-        openmp/TestOpenMP_AtomicOperations_double.cpp
-        openmp/TestOpenMP_AtomicOperations_float.cpp
-        openmp/TestOpenMP_AtomicOperations_complexdouble.cpp
-        openmp/TestOpenMP_AtomicOperations_complexfloat.cpp
-        openmp/TestOpenMP_AtomicViews.cpp
-        openmp/TestOpenMP_Atomics.cpp
-        openmp/TestOpenMP_Complex.cpp
-        openmp/TestOpenMP_Init.cpp
-        openmp/TestOpenMP_MDRange_a.cpp
-        openmp/TestOpenMP_MDRange_b.cpp
-        openmp/TestOpenMP_MDRange_c.cpp
-        openmp/TestOpenMP_MDRange_d.cpp
-        openmp/TestOpenMP_MDRange_e.cpp
-        openmp/TestOpenMP_Other.cpp
-        openmp/TestOpenMP_RangePolicy.cpp
-        openmp/TestOpenMP_Reductions.cpp
-        openmp/TestOpenMP_Reducers_a.cpp
-        openmp/TestOpenMP_Reducers_b.cpp
-        openmp/TestOpenMP_Reducers_c.cpp
-        openmp/TestOpenMP_Reducers_d.cpp
-        openmp/TestOpenMP_Scan.cpp
-        openmp/TestOpenMP_SharedAlloc.cpp
-        openmp/TestOpenMP_SubView_a.cpp
-        openmp/TestOpenMP_SubView_b.cpp
-        openmp/TestOpenMP_SubView_c01.cpp
-        openmp/TestOpenMP_SubView_c02.cpp
-        openmp/TestOpenMP_SubView_c03.cpp
-        openmp/TestOpenMP_SubView_c04.cpp
-        openmp/TestOpenMP_SubView_c05.cpp
-        openmp/TestOpenMP_SubView_c06.cpp
-        openmp/TestOpenMP_SubView_c07.cpp
-        openmp/TestOpenMP_SubView_c08.cpp
-        openmp/TestOpenMP_SubView_c09.cpp
-        openmp/TestOpenMP_SubView_c10.cpp
-        openmp/TestOpenMP_SubView_c11.cpp
-        openmp/TestOpenMP_SubView_c12.cpp
-        openmp/TestOpenMP_SubView_c13.cpp
-        openmp/TestOpenMP_Task.cpp
-        openmp/TestOpenMP_Team.cpp
-        openmp/TestOpenMP_TeamReductionScan.cpp
-        openmp/TestOpenMP_ViewAPI_a.cpp
-        openmp/TestOpenMP_ViewAPI_b.cpp
-        openmp/TestOpenMP_ViewAPI_c.cpp
-        openmp/TestOpenMP_ViewAPI_d.cpp
-        openmp/TestOpenMP_ViewAPI_e.cpp
-        openmp/TestOpenMP_ViewMapping_a.cpp
-        openmp/TestOpenMP_ViewMapping_b.cpp
-        openmp/TestOpenMP_ViewMapping_subview.cpp
-        openmp/TestOpenMP_ViewOfClass.cpp
-        openmp/TestOpenMP_Crs.cpp
-        openmp/TestOpenMP_WorkGraph.cpp
-        openmp/TestOpenMP_UniqueToken.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-    TRIBITS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_OpenMPInterOp
-      SOURCES
-        UnitTestMain.cpp
-        openmp/TestOpenMP_InterOp.cpp
-      COMM serial mpi
-      NUM_MPI_PROCS 1
-      FAIL_REGULAR_EXPRESSION "  FAILED  "
-      TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
-    )
-  ENDIF()
-ENDIF()
+if(Kokkos_ENABLE_SERIAL)
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_Serial
+    SOURCES
+    ${Serial_SOURCES}
+    serial/TestSerial_Task.cpp
+  )
+endif()
 
-IF(Kokkos_ENABLE_HPX)
-  TRIBITS_ADD_EXECUTABLE_AND_TEST(
+if(Kokkos_ENABLE_PTHREAD)
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_Threads
+    SOURCES ${Threads_SOURCES}
+  )
+endif()
+
+if(Kokkos_ENABLE_OPENMP)
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_OpenMP
+    SOURCES
+    ${OpenMP_SOURCES}
+    openmp/TestOpenMP_Task.cpp
+  )
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_OpenMPInterOp
+    SOURCES
+      UnitTestMain.cpp
+      openmp/TestOpenMP_InterOp.cpp
+  )
+endif()
+
+if(Kokkos_ENABLE_HPX)
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
     UnitTest_HPX
     SOURCES
-      UnitTestMainInit.cpp
-      hpx/TestHPX_AtomicOperations_int.cpp
-      hpx/TestHPX_AtomicOperations_unsignedint.cpp
-      hpx/TestHPX_AtomicOperations_longint.cpp
-      hpx/TestHPX_AtomicOperations_unsignedlongint.cpp
-      hpx/TestHPX_AtomicOperations_longlongint.cpp
-      hpx/TestHPX_AtomicOperations_double.cpp
-      hpx/TestHPX_AtomicOperations_float.cpp
-      hpx/TestHPX_AtomicViews.cpp
-      hpx/TestHPX_Atomics.cpp
-      hpx/TestHPX_Complex.cpp
-      hpx/TestHPX_Init.cpp
-      hpx/TestHPX_MDRange_a.cpp
-      hpx/TestHPX_MDRange_b.cpp
-      hpx/TestHPX_MDRange_c.cpp
-      hpx/TestHPX_MDRange_d.cpp
-      hpx/TestHPX_MDRange_e.cpp
-      hpx/TestHPX_Other.cpp
-      hpx/TestHPX_RangePolicy.cpp
-      hpx/TestHPX_Reductions.cpp
-      hpx/TestHPX_Reducers_a.cpp
-      hpx/TestHPX_Reducers_b.cpp
-      hpx/TestHPX_Reducers_c.cpp
-      hpx/TestHPX_Reducers_d.cpp
-      hpx/TestHPX_Scan.cpp
-      hpx/TestHPX_SharedAlloc.cpp
-      hpx/TestHPX_SubView_a.cpp
-      hpx/TestHPX_SubView_b.cpp
-      hpx/TestHPX_SubView_c01.cpp
-      hpx/TestHPX_SubView_c02.cpp
-      hpx/TestHPX_SubView_c03.cpp
-      hpx/TestHPX_SubView_c04.cpp
-      hpx/TestHPX_SubView_c05.cpp
-      hpx/TestHPX_SubView_c06.cpp
-      hpx/TestHPX_SubView_c07.cpp
-      hpx/TestHPX_SubView_c08.cpp
-      hpx/TestHPX_SubView_c09.cpp
-      hpx/TestHPX_SubView_c10.cpp
-      hpx/TestHPX_SubView_c11.cpp
-      hpx/TestHPX_SubView_c12.cpp
-      hpx/TestHPX_SubView_c13.cpp
+      ${HPX_SOURCES}
       hpx/TestHPX_Task.cpp
-      hpx/TestHPX_Team.cpp
-      hpx/TestHPX_TeamReductionScan.cpp
-      hpx/TestHPX_ViewAPI_a.cpp
-      hpx/TestHPX_ViewAPI_b.cpp
-      hpx/TestHPX_ViewAPI_c.cpp
-      hpx/TestHPX_ViewAPI_d.cpp
-      hpx/TestHPX_ViewAPI_e.cpp
-      hpx/TestHPX_ViewMapping_a.cpp
-      hpx/TestHPX_ViewMapping_b.cpp
-      hpx/TestHPX_ViewMapping_subview.cpp
-      hpx/TestHPX_ViewOfClass.cpp
-      hpx/TestHPX_Crs.cpp
-      hpx/TestHPX_WorkGraph.cpp
-      hpx/TestHPX_UniqueToken.cpp
-    COMM serial mpi
-    NUM_MPI_PROCS 1
-    FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
   )
-  TRIBITS_ADD_EXECUTABLE_AND_TEST(
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
     UnitTest_HPXInterOp
     SOURCES
       UnitTestMain.cpp
       hpx/TestHPX_InterOp.cpp
-    COMM serial mpi
-    NUM_MPI_PROCS 1
-    FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
   )
-ENDIF()
+endif()
 
-IF(Kokkos_ENABLE_Qthreads)
-  TRIBITS_ADD_EXECUTABLE_AND_TEST(
+if(Kokkos_ENABLE_QTHREADS)
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
     UnitTest_Qthreads
     SOURCES
       UnitTestMainInit.cpp
       qthreads/TestQthreads_Atomics.cpp
       qthreads/TestQthreads_Complex.cpp
+      qthreads/TestQthreads_DeepCopyAlignment.cpp
       qthreads/TestQthreads_Other.cpp
       qthreads/TestQthreads_Reductions.cpp
       qthreads/TestQthreads_Reducers_a.cpp
@@ -653,23 +180,21 @@ IF(Kokkos_ENABLE_Qthreads)
       qthreads/TestQthreads_SubView_c12.cpp
       qthreads/TestQthreads_SubView_c13.cpp
       qthreads/TestQthreads_Team.cpp
+      qthreads/TestQthreads_View_64bit.cpp
       qthreads/TestQthreads_ViewAPI_a.cpp
       qthreads/TestQthreads_ViewAPI_b.cpp
       qthreads/TestQthreads_ViewAPI_c.cpp
       qthreads/TestQthreads_ViewAPI_d.cpp
       qthreads/TestQthreads_ViewAPI_e.cpp
-    COMM serial mpi
-    NUM_MPI_PROCS 1
-    FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
   )
-ENDIF()
+endif()
 
-IF(Kokkos_ENABLE_Cuda)
-  TRIBITS_ADD_EXECUTABLE_AND_TEST(
+if(Kokkos_ENABLE_CUDA)
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
     UnitTest_Cuda
     SOURCES
-      UnitTestMainInit.cpp
+      ${Cuda_SOURCES}
+      cuda/TestCuda_Task.cpp
       cuda/TestCudaHostPinned_SharedAlloc.cpp
       cuda/TestCudaHostPinned_ViewCopy.cpp
       cuda/TestCudaHostPinned_ViewAPI_a.cpp
@@ -690,93 +215,25 @@ IF(Kokkos_ENABLE_Cuda)
       cuda/TestCudaUVM_ViewMapping_a.cpp
       cuda/TestCudaUVM_ViewMapping_b.cpp
       cuda/TestCudaUVM_ViewMapping_subview.cpp
-      cuda/TestCuda_AtomicOperations_int.cpp
-      cuda/TestCuda_AtomicOperations_unsignedint.cpp
-      cuda/TestCuda_AtomicOperations_longint.cpp
-      cuda/TestCuda_AtomicOperations_unsignedlongint.cpp
-      cuda/TestCuda_AtomicOperations_longlongint.cpp
-      cuda/TestCuda_AtomicOperations_double.cpp
-      cuda/TestCuda_AtomicOperations_float.cpp
-      cuda/TestCuda_AtomicOperations_complexdouble.cpp
-      cuda/TestCuda_AtomicOperations_complexfloat.cpp
-      cuda/TestCuda_AtomicViews.cpp
-      cuda/TestCuda_Atomics.cpp
-      cuda/TestCuda_Complex.cpp
-      cuda/TestCuda_Init.cpp
-      cuda/TestCuda_MDRange_a.cpp
-      cuda/TestCuda_MDRange_b.cpp
-      cuda/TestCuda_MDRange_c.cpp
-      cuda/TestCuda_MDRange_d.cpp
-      cuda/TestCuda_MDRange_e.cpp
-      cuda/TestCuda_Other.cpp
-      cuda/TestCuda_RangePolicy.cpp
-      cuda/TestCuda_Reductions.cpp
-      cuda/TestCuda_Reducers_a.cpp
-      cuda/TestCuda_Reducers_b.cpp
-      cuda/TestCuda_Reducers_c.cpp
-      cuda/TestCuda_Reducers_d.cpp
-      cuda/TestCuda_Scan.cpp
-      cuda/TestCuda_SharedAlloc.cpp
       cuda/TestCuda_Spaces.cpp
-      cuda/TestCuda_SubView_a.cpp
-      cuda/TestCuda_SubView_b.cpp
-      cuda/TestCuda_SubView_c01.cpp
-      cuda/TestCuda_SubView_c02.cpp
-      cuda/TestCuda_SubView_c03.cpp
-      cuda/TestCuda_SubView_c04.cpp
-      cuda/TestCuda_SubView_c05.cpp
-      cuda/TestCuda_SubView_c06.cpp
-      cuda/TestCuda_SubView_c07.cpp
-      cuda/TestCuda_SubView_c08.cpp
-      cuda/TestCuda_SubView_c09.cpp
-      cuda/TestCuda_SubView_c10.cpp
-      cuda/TestCuda_SubView_c11.cpp
-      cuda/TestCuda_SubView_c12.cpp
-      cuda/TestCuda_SubView_c13.cpp
-      cuda/TestCuda_Task.cpp
-      cuda/TestCuda_Team.cpp
-      cuda/TestCuda_TeamReductionScan.cpp
-      cuda/TestCuda_TeamScratch.cpp
-      cuda/TestCuda_ViewAPI_a.cpp
-      cuda/TestCuda_ViewAPI_b.cpp
-      cuda/TestCuda_ViewAPI_c.cpp
-      cuda/TestCuda_ViewAPI_d.cpp
-      cuda/TestCuda_ViewAPI_e.cpp
-      cuda/TestCuda_ViewMapping_a.cpp
-      cuda/TestCuda_ViewMapping_b.cpp
-      cuda/TestCuda_ViewMapping_subview.cpp
-      cuda/TestCuda_ViewOfClass.cpp
-      cuda/TestCuda_Crs.cpp
-      cuda/TestCuda_WorkGraph.cpp
-      cuda/TestCuda_UniqueToken.cpp
-    COMM serial mpi
-    NUM_MPI_PROCS 1
-    FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
+      cuda/TestCuda_DebugSerialExecution.cpp
+      cuda/TestCuda_DebugPinUVMSpace.cpp
   )
-  TRIBITS_ADD_EXECUTABLE_AND_TEST(
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
     UnitTest_CudaInterOpInit
     SOURCES
       UnitTestMain.cpp
       cuda/TestCuda_InterOp_Init.cpp
-    COMM serial mpi
-    NUM_MPI_PROCS 1
-    FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
   )
-  TRIBITS_ADD_EXECUTABLE_AND_TEST(
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
     UnitTest_CudaInterOpStreams
     SOURCES
       UnitTestMain.cpp
       cuda/TestCuda_InterOp_Streams.cpp
-    COMM serial mpi
-    NUM_MPI_PROCS 1
-    FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
   )
-ENDIF()
+endif()
 
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
   UnitTest_Default
   SOURCES
     UnitTestMainInit.cpp
@@ -792,33 +249,24 @@ TRIBITS_ADD_EXECUTABLE_AND_TEST(
     default/TestDefaultDeviceType_c3.cpp
     default/TestDefaultDeviceType_d.cpp
     default/TestDefaultDeviceTypeResize.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
 )
 
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
   UnitTest_PushFinalizeHook
   SOURCES
     UnitTest_PushFinalizeHook.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "FAILED"
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
 )
 
 # This test is special, because it passes exactly when it prints the
 # message "PASSED: I am the custom std::terminate handler.", AND calls
 # std::terminate.  This means that we can't use
-# TRIBITS_ADD_EXECUTABLE_AND_TEST.  See GitHub issue #2147.
+# KOKKOS_ADD_EXECUTABLE_AND_TEST.  See GitHub issue #2147.
 
-TRIBITS_ADD_EXECUTABLE( push_finalize_hook_terminate
+KOKKOS_ADD_TEST_EXECUTABLE( push_finalize_hook_terminate
   SOURCES UnitTest_PushFinalizeHook_terminate.cpp
-  TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
 )
 
-TRIBITS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
+KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
   TEST_0
     EXEC push_finalize_hook_terminate
     NUM_MPI_PROCS 1
@@ -827,68 +275,55 @@ TRIBITS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
     ALWAYS_FAIL_ON_ZERO_RETURN
 )
 
+KOKKOS_ADD_TEST_EXECUTABLE(
+  StackTraceTestExec
+  SOURCES
+    TestStackTrace.cpp
+    TestStackTrace_f0.cpp
+    TestStackTrace_f1.cpp
+    TestStackTrace_f2.cpp
+    TestStackTrace_f3.cpp
+    TestStackTrace_f4.cpp
+)
+# We need -rdynamic on GNU platforms for the stacktrace functionality
+# to work correctly with shared libraries
+if(NOT KOKKOS_HAS_TRILINOS)
+SET_PROPERTY(TARGET StackTraceTestExec PROPERTY ENABLE_EXPORTS 1)
+
+KOKKOS_ADD_TEST( NAME UnitTest_StackTraceTest_normal
+                 EXE  StackTraceTestExec 
+                 FAIL_REGULAR_EXPRESSION "FAILED"
+               )
+
+KOKKOS_ADD_TEST( NAME UnitTest_StackTraceTest_terminate
+                 EXE  StackTraceTestExec
+                 FAIL_REGULAR_EXPRESSION "FAILED"
+               )
+
+KOKKOS_ADD_TEST( NAME UnitTest_StackTraceTest_generic_term
+                 EXE  StackTraceTestExec
+                 FAIL_REGULAR_EXPRESSION "FAILED"
+               )
+endif()
+
 foreach(INITTESTS_NUM RANGE 1 16)
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
   UnitTest_DefaultInit_${INITTESTS_NUM}
   SOURCES UnitTestMain.cpp default/TestDefaultDeviceTypeInit_${INITTESTS_NUM}.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
 )
 endforeach(INITTESTS_NUM)
 
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
+if (KOKKOS_ENABLE_HWLOC)
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
   UnitTest_HWLOC
   SOURCES UnitTestMain.cpp  TestHWLOC.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
 )
+endif()
 
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
   UnitTest_HostBarrier
   SOURCES UnitTestMain.cpp  TestHostBarrier.cpp
-  COMM serial mpi
-  NUM_MPI_PROCS 1
-  FAIL_REGULAR_EXPRESSION "  FAILED  "
-    TESTONLYLIBS kokkos_gtest ${TEST_LINK_TARGETS}
 )
 
-#
-# Compile-only tests
-#
-FUNCTION(KOKKOS_ADD_COMPILE_TEST TEST_NAME)
-
-  SET(options LINK_KOKKOS)
-  SET(oneValueArgs)
-  SET(multiValueArgs)
-
-  CMAKE_PARSE_ARGUMENTS(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  IF(PARSE_LINK_KOKKOS)
-    SET(libs ${TEST_LINK_TARGETS})
-  ELSE()
-    SET(libs)
-  ENDIF()
-
-  TRIBITS_ADD_EXECUTABLE(
-    ${TEST_NAME}
-    TESTONLY
-    COMM serial
-    TESTONLYLIBS ${libs}
-    ${PARSE_UNPARSED_ARGUMENTS}
-  )
-
-  target_compile_options(
-    ${PACKAGE_NAME}_${TEST_NAME}
-    PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${KOKKOS_CXX_FLAGS}>
-  )
-  target_link_libraries(
-    ${PACKAGE_NAME}_${TEST_NAME}
-    PUBLIC ${KOKKOS_LD_FLAGS}
-  )
 
-ENDFUNCTION()
 
diff --git a/lib/kokkos/core/unit_test/Makefile b/lib/kokkos/core/unit_test/Makefile
index 5a6921310884c639925954112babd8cdc43c243d..cf945bd718f5f346cff72c3cdc7c2cae1bfd5f25 100644
--- a/lib/kokkos/core/unit_test/Makefile
+++ b/lib/kokkos/core/unit_test/Makefile
@@ -38,6 +38,31 @@ KOKKOS_CXXFLAGS += -I$(GTEST_PATH) -I${KOKKOS_PATH}/core/unit_test
 TEST_TARGETS =
 TARGETS =
 
+KOKKOS_INTERNAL_HAS_OPTIMIZATIONS := $(call kokkos_has_string,$(KOKKOS_CXXFLAGS),O3)
+ifneq ($(KOKKOS_INTERNAL_HAS_OPTIMIZATIONS), 1)
+   KOKKOS_INTERNAL_HAS_OPTIMIZATIONS := $(call kokkos_has_string,$(KOKKOS_CXXFLAGS),O2)
+   ifneq ($(KOKKOS_INTERNAL_HAS_OPTIMIZATIONS), 1)
+      KOKKOS_INTERNAL_HAS_OPTIMIZATIONS := $(call kokkos_has_string,$(CXXFLAGS),O3)
+      ifneq ($(KOKKOS_INTERNAL_HAS_OPTIMIZATIONS), 1)
+         KOKKOS_INTERNAL_HAS_OPTIMIZATIONS := $(call kokkos_has_string,$(CXXFLAGS),O2)
+      endif
+   endif
+endif
+KOKKOS_INTERNAL_USE_RDYNAMIC := $(call kokkos_has_string,$(KOKKOS_CXXFLAGS),rdynamic)
+ifneq ($(KOKKOS_INTERNAL_USE_RDYNAMIC), 1)
+   KOKKOS_INTERNAL_USE_RDYNAMIC := $(call kokkos_has_string,$(CXXFLAGS),rdynamic)
+endif
+
+ifeq ($(KOKKOS_INTERNAL_USE_RDYNAMIC),1) 
+   ifneq ($(KOKKOS_INTERNAL_HAS_OPTIMIZATIONS),1) 
+      STACK_TRACE_TERMINATE_FILTER :=_dynamic
+   else
+      STACK_TRACE_TERMINATE_FILTER :=
+   endif
+else
+   STACK_TRACE_TERMINATE_FILTER :=
+endif
+
 ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     OBJ_CUDA = UnitTestMainInit.o gtest-all.o
     OBJ_CUDA += TestCuda_Init.o
@@ -45,7 +70,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     OBJ_CUDA += TestCuda_RangePolicy.o
     OBJ_CUDA += TestCuda_ViewAPI_a.o TestCuda_ViewAPI_b.o TestCuda_ViewAPI_c.o TestCuda_ViewAPI_d.o TestCuda_ViewAPI_e.o
     OBJ_CUDA += TestCuda_DeepCopyAlignment.o
-    OBJ_CUDA += TestCuda_ViewMapping_a.o TestCuda_ViewMapping_b.o TestCuda_ViewMapping_subview.o TestCuda_ViewLayoutStrideAssignment.o
+    OBJ_CUDA += TestCuda_ViewMapping_a.o TestCuda_ViewMapping_b.o TestCuda_ViewMapping_subview.o TestCuda_ViewResize.o TestCuda_ViewLayoutStrideAssignment.o
     OBJ_CUDA += TestCudaUVM_ViewCopy.o TestCudaUVM_ViewAPI_a.o TestCudaUVM_ViewAPI_b.o TestCudaUVM_ViewAPI_c.o TestCudaUVM_ViewAPI_d.o TestCudaUVM_ViewAPI_e.o
     OBJ_CUDA += TestCudaUVM_ViewMapping_a.o TestCudaUVM_ViewMapping_b.o TestCudaUVM_ViewMapping_subview.o
     OBJ_CUDA += TestCudaHostPinned_ViewCopy.o TestCudaHostPinned_ViewAPI_a.o TestCudaHostPinned_ViewAPI_b.o TestCudaHostPinned_ViewAPI_c.o TestCudaHostPinned_ViewAPI_d.o TestCudaHostPinned_ViewAPI_e.o
@@ -76,7 +101,9 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     OBJ_CUDA += TestCuda_Spaces.o
     OBJ_CUDA += TestCuda_UniqueToken.o
     OBJ_CUDA += TestCuda_LocalDeepCopy.o
-
+    OBJ_CUDA += TestCuda_DebugSerialExecution.o
+    OBJ_CUDA += TestCuda_DebugPinUVMSpace.o
+  
     TARGETS += KokkosCore_UnitTest_Cuda
     TARGETS += KokkosCore_UnitTest_CudaInterOpInit
     TARGETS += KokkosCore_UnitTest_CudaInterOpStreams
@@ -143,7 +170,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
     OBJ_THREADS += TestThreads_View_64bit.o
     OBJ_THREADS += TestThreads_ViewAPI_a.o TestThreads_ViewAPI_b.o TestThreads_ViewAPI_c.o TestThreads_ViewAPI_d.o TestThreads_ViewAPI_e.o
     OBJ_THREADS += TestThreads_DeepCopyAlignment.o
-    OBJ_THREADS += TestThreads_ViewMapping_a.o TestThreads_ViewMapping_b.o TestThreads_ViewMapping_subview.o TestThreads_ViewLayoutStrideAssignment.o
+    OBJ_THREADS += TestThreads_ViewMapping_a.o TestThreads_ViewMapping_b.o TestThreads_ViewMapping_subview.o TestThreads_ViewResize.o TestThreads_ViewLayoutStrideAssignment.o
     OBJ_THREADS += TestThreads_ViewOfClass.o
     OBJ_THREADS += TestThreads_SubView_a.o TestThreads_SubView_b.o
     OBJ_THREADS += TestThreads_SubView_c01.o TestThreads_SubView_c02.o TestThreads_SubView_c03.o
@@ -178,7 +205,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
     OBJ_OPENMP += TestOpenMP_View_64bit.o
     OBJ_OPENMP += TestOpenMP_ViewAPI_a.o TestOpenMP_ViewAPI_b.o TestOpenMP_ViewAPI_c.o TestOpenMP_ViewAPI_d.o TestOpenMP_ViewAPI_e.o
     OBJ_OPENMP += TestOpenMP_DeepCopyAlignment.o
-    OBJ_OPENMP += TestOpenMP_ViewMapping_a.o TestOpenMP_ViewMapping_b.o TestOpenMP_ViewMapping_subview.o TestOpenMP_ViewLayoutStrideAssignment.o
+    OBJ_OPENMP += TestOpenMP_ViewMapping_a.o TestOpenMP_ViewMapping_b.o TestOpenMP_ViewMapping_subview.o TestOpenMP_ViewResize.o TestOpenMP_ViewLayoutStrideAssignment.o
     OBJ_OPENMP += TestOpenMP_ViewOfClass.o
     OBJ_OPENMP += TestOpenMP_SubView_a.o TestOpenMP_SubView_b.o
     OBJ_OPENMP += TestOpenMP_SubView_c01.o TestOpenMP_SubView_c02.o TestOpenMP_SubView_c03.o
@@ -272,7 +299,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
 	OBJ_HPX += TestHPX_RangePolicy.o
 	OBJ_HPX += TestHPX_View_64bit.o
 	OBJ_HPX += TestHPX_ViewAPI_a.o TestHPX_ViewAPI_b.o TestHPX_ViewAPI_c.o TestHPX_ViewAPI_d.o TestHPX_ViewAPI_e.o
-	OBJ_HPX += TestHPX_ViewMapping_a.o TestHPX_ViewMapping_b.o TestHPX_ViewMapping_subview.o
+	OBJ_HPX += TestHPX_ViewMapping_a.o TestHPX_ViewMapping_b.o TestHPX_ViewMapping_subview.o TestHPX_ViewResize.o
 	OBJ_HPX += TestHPX_ViewOfClass.o
 	OBJ_HPX += TestHPX_SubView_a.o TestHPX_SubView_b.o
 	OBJ_HPX += TestHPX_SubView_c01.o TestHPX_SubView_c02.o TestHPX_SubView_c03.o
@@ -312,7 +339,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
     OBJ_SERIAL += TestSerial_View_64bit.o
     OBJ_SERIAL += TestSerial_ViewAPI_a.o TestSerial_ViewAPI_b.o TestSerial_ViewAPI_c.o TestSerial_ViewAPI_d.o TestSerial_ViewAPI_e.o
     OBJ_SERIAL += TestSerial_DeepCopyAlignment.o
-    OBJ_SERIAL += TestSerial_ViewMapping_a.o TestSerial_ViewMapping_b.o TestSerial_ViewMapping_subview.o TestSerial_ViewLayoutStrideAssignment.o
+    OBJ_SERIAL += TestSerial_ViewMapping_a.o TestSerial_ViewMapping_b.o TestSerial_ViewMapping_subview.o TestSerial_ViewResize.o TestSerial_ViewLayoutStrideAssignment.o
     OBJ_SERIAL += TestSerial_ViewOfClass.o
     OBJ_SERIAL += TestSerial_SubView_a.o TestSerial_SubView_b.o
     OBJ_SERIAL += TestSerial_SubView_c01.o TestSerial_SubView_c02.o TestSerial_SubView_c03.o
@@ -373,6 +400,11 @@ TEST_TARGETS += test-push-finalize-hook
 TARGETS += KokkosCore_UnitTest_PushFinalizeHook_terminate
 TEST_TARGETS += test-push-finalize-hook-terminate
 
+TARGETS += KokkosCore_UnitTest_StackTraceTestExec
+TEST_TARGETS += test-stack-trace
+TEST_TARGETS += test-stack-trace-terminate
+TEST_TARGETS += test-stack-trace-generic-term
+
 NUM_INITTESTS = 16
 INITTESTS_NUMBERS := $(shell seq 1 ${NUM_INITTESTS})
 INITTESTS_TARGETS := $(addprefix KokkosCore_UnitTest_DefaultDeviceTypeInit_,${INITTESTS_NUMBERS})
@@ -440,6 +472,9 @@ KokkosCore_UnitTest_PushFinalizeHook_terminate: $(OBJ_DEFAULT) $(KOKKOS_LINK_DEP
 ${INITTESTS_TARGETS}: KokkosCore_UnitTest_DefaultDeviceTypeInit_%: TestDefaultDeviceTypeInit_%.o UnitTestMain.o gtest-all.o $(KOKKOS_LINK_DEPENDS)
 	$(LINK) $(EXTRA_PATH) TestDefaultDeviceTypeInit_$*.o UnitTestMain.o gtest-all.o $(KOKKOS_LIBS) $(LIB) $(KOKKOS_LDFLAGS) $(LDFLAGS) -o KokkosCore_UnitTest_DefaultDeviceTypeInit_$*
 
+KokkosCore_UnitTest_StackTraceTestExec: TestStackTrace.o  TestStackTrace_f0.o TestStackTrace_f1.o TestStackTrace_f2.o TestStackTrace_f3.o TestStackTrace_f4.o $(KOKKOS_LINK_DEPENDS) gtest-all.o
+	$(LINK) $(EXTRA_PATH) TestStackTrace.o TestStackTrace_f0.o TestStackTrace_f1.o TestStackTrace_f2.o TestStackTrace_f3.o TestStackTrace_f4.o gtest-all.o $(KOKKOS_LIBS) $(LIB) $(KOKKOS_LDFLAGS) $(LDFLAGS) -o KokkosCore_UnitTest_StackTraceTestExec
+
 test-cuda: KokkosCore_UnitTest_Cuda
 	./KokkosCore_UnitTest_Cuda
 	./KokkosCore_UnitTest_CudaInterOpInit
@@ -486,6 +521,16 @@ test-push-finalize-hook: KokkosCore_UnitTest_PushFinalizeHook
 
 test-push-finalize-hook-terminate: KokkosCore_UnitTest_PushFinalizeHook_terminate
 	./KokkosCore_UnitTest_PushFinalizeHook_terminate
+	
+test-stack-trace: KokkosCore_UnitTest_StackTraceTestExec
+	./KokkosCore_UnitTest_StackTraceTestExec --gtest_filter=*normal$(STACK_TRACE_TERMINATE_FILTER)
+
+test-stack-trace-terminate: KokkosCore_UnitTest_StackTraceTestExec
+	./KokkosCore_UnitTest_StackTraceTestExec --gtest_filter=*terminate$(STACK_TRACE_TERMINATE_FILTER)
+
+test-stack-trace-generic-term: KokkosCore_UnitTest_StackTraceTestExec
+	./KokkosCore_UnitTest_StackTraceTestExec --gtest_filter=*generic_term$(STACK_TRACE_TERMINATE_FILTER)
+
 
 ${INITTESTS_TEST_TARGETS}: test-default-init-%: KokkosCore_UnitTest_DefaultDeviceTypeInit_%
 	./KokkosCore_UnitTest_DefaultDeviceTypeInit_$*
diff --git a/lib/kokkos/core/unit_test/TestAggregate.hpp b/lib/kokkos/core/unit_test/TestAggregate.hpp
index 83813b5b1b47667a0648fc0726bfd5f6edbd0634..1f812cc11ebb41a7d7c56fcf48c6f0c5d6648e17 100644
--- a/lib/kokkos/core/unit_test/TestAggregate.hpp
+++ b/lib/kokkos/core/unit_test/TestAggregate.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -54,43 +55,53 @@
 
 namespace Test {
 
-template< class DeviceType >
-void TestViewAggregate()
-{
-  typedef Kokkos::Array< double, 32 >  value_type;
-  typedef Kokkos::Impl::ViewDataAnalysis< value_type *, Kokkos::LayoutLeft, value_type > analysis_1d;
-
-  static_assert( std::is_same< typename analysis_1d::specialize, Kokkos::Array<> >::value, "" );
-
-  typedef Kokkos::ViewTraits< value_type **, DeviceType > a32_traits;
-  typedef Kokkos::ViewTraits< typename a32_traits::scalar_array_type, DeviceType > flat_traits;
-
-  static_assert( std::is_same< typename a32_traits::specialize, Kokkos::Array<> >::value, "" );
-  static_assert( std::is_same< typename a32_traits::value_type, value_type >::value, "" );
-  static_assert( a32_traits::rank == 2, "" );
-  static_assert( a32_traits::rank_dynamic == 2, "" );
-
-  static_assert( std::is_same< typename flat_traits::specialize, void >::value, "" );
-  static_assert( flat_traits::rank == 3, "" );
-  static_assert( flat_traits::rank_dynamic == 2, "" );
-  static_assert( flat_traits::dimension::N2 == 32, "" );
-
-  typedef Kokkos::View< Kokkos::Array< double, 32 > **, DeviceType > a32_type;
-  typedef typename a32_type::array_type  a32_flat_type;
-
-  static_assert( std::is_same< typename a32_type::value_type, value_type >::value, "" );
-  static_assert( std::is_same< typename a32_type::pointer_type, double * >::value, "" );
-  static_assert( a32_type::Rank == 2, "" );
-  static_assert( a32_flat_type::Rank == 3, "" );
-
-  a32_type x( "test", 4, 5 );
-  a32_flat_type y( x );
-
-  ASSERT_EQ( x.extent( 0 ), 4 );
-  ASSERT_EQ( x.extent( 1 ), 5 );
-  ASSERT_EQ( y.extent( 0 ), 4 );
-  ASSERT_EQ( y.extent( 1 ), 5 );
-  ASSERT_EQ( y.extent( 2 ), 32 );
+template <class DeviceType>
+void TestViewAggregate() {
+  typedef Kokkos::Array<double, 32> value_type;
+  typedef Kokkos::Impl::ViewDataAnalysis<value_type *, Kokkos::LayoutLeft,
+                                         value_type>
+      analysis_1d;
+
+  static_assert(
+      std::is_same<typename analysis_1d::specialize, Kokkos::Array<> >::value,
+      "");
+
+  typedef Kokkos::ViewTraits<value_type **, DeviceType> a32_traits;
+  typedef Kokkos::ViewTraits<typename a32_traits::scalar_array_type, DeviceType>
+      flat_traits;
+
+  static_assert(
+      std::is_same<typename a32_traits::specialize, Kokkos::Array<> >::value,
+      "");
+  static_assert(
+      std::is_same<typename a32_traits::value_type, value_type>::value, "");
+  static_assert(a32_traits::rank == 2, "");
+  static_assert(a32_traits::rank_dynamic == 2, "");
+
+  static_assert(std::is_same<typename flat_traits::specialize, void>::value,
+                "");
+  static_assert(flat_traits::rank == 3, "");
+  static_assert(flat_traits::rank_dynamic == 2, "");
+  static_assert(flat_traits::dimension::N2 == 32, "");
+
+  typedef Kokkos::View<Kokkos::Array<double, 32> **, DeviceType> a32_type;
+  typedef typename a32_type::array_type a32_flat_type;
+
+  static_assert(std::is_same<typename a32_type::value_type, value_type>::value,
+                "");
+  static_assert(std::is_same<typename a32_type::pointer_type, double *>::value,
+                "");
+  static_assert(a32_type::Rank == 2, "");
+  static_assert(a32_flat_type::Rank == 3, "");
+
+  a32_type x("test", 4, 5);
+  a32_flat_type y(x);
+
+  ASSERT_EQ(x.extent(0), 4);
+  ASSERT_EQ(x.extent(1), 5);
+  ASSERT_EQ(y.extent(0), 4);
+  ASSERT_EQ(y.extent(1), 5);
+  ASSERT_EQ(y.extent(2), 32);
 
   // Initialize arrays from brace-init-list as for std::array.
   //
@@ -101,29 +112,36 @@ void TestViewAggregate()
   //            warning: suggest braces around initialization of subobject
   //
   //          but single brace syntax would be valid as well.
-  Kokkos::Array< float, 2 > aggregate_initialization_syntax_1 = { { 1.41, 3.14 } };
-  ASSERT_FLOAT_EQ( aggregate_initialization_syntax_1[0], 1.41 );
-  ASSERT_FLOAT_EQ( aggregate_initialization_syntax_1[1], 3.14 );
-
-  Kokkos::Array< int, 3 > aggregate_initialization_syntax_2{ { 0, 1, 2 } }; // since C++11
-  for ( int i = 0; i < 3; ++i ) {
-    ASSERT_EQ( aggregate_initialization_syntax_2[i], i );
+  Kokkos::Array<float, 2> aggregate_initialization_syntax_1 = {{1.41, 3.14}};
+  ASSERT_FLOAT_EQ(aggregate_initialization_syntax_1[0], 1.41);
+  ASSERT_FLOAT_EQ(aggregate_initialization_syntax_1[1], 3.14);
+
+  Kokkos::Array<int, 3> aggregate_initialization_syntax_2{
+      {0, 1, 2}};  // since C++11
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_EQ(aggregate_initialization_syntax_2[i], i);
   }
 
   // Note that this is a valid initialization.
-  Kokkos::Array< double, 3 > initialized_with_one_argument_missing = { { 255, 255 } };
+  Kokkos::Array<double, 3> initialized_with_one_argument_missing = {{255, 255}};
   for (int i = 0; i < 2; ++i) {
-    ASSERT_DOUBLE_EQ( initialized_with_one_argument_missing[i], 255 );
+    ASSERT_DOUBLE_EQ(initialized_with_one_argument_missing[i], 255);
   }
   // But the following line would not compile
-//  Kokkos::Array< double, 3 > initialized_with_too_many{ { 1, 2, 3, 4 } };
-}
+  //  Kokkos::Array< double, 3 > initialized_with_too_many{ { 1, 2, 3, 4 } };
 
-TEST_F( TEST_CATEGORY, view_aggregate )
-{
-  TestViewAggregate< TEST_EXECSPACE >();
+  // The code below must compile for zero-sized arrays.
+  using T = float;
+
+  constexpr int N = 0;
+  Kokkos::Array<T, N> a;
+  for (int i = 0; i < N; ++i) {
+    a[i] = T();
+  }
 }
 
-} // namespace Test
+TEST(TEST_CATEGORY, view_aggregate) { TestViewAggregate<TEST_EXECSPACE>(); }
+
+}  // namespace Test
 
 #endif /* #ifndef TEST_AGGREGATE_HPP */
diff --git a/lib/kokkos/core/unit_test/TestAtomic.hpp b/lib/kokkos/core/unit_test/TestAtomic.hpp
index ee93d5347037b39b98957fcfc2d398bb6290aa8b..a72a179e02e62132fdb4b59249565b119a24859e 100644
--- a/lib/kokkos/core/unit_test/TestAtomic.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomic.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,201 +48,194 @@ namespace TestAtomic {
 
 // Struct for testing arbitrary size atomics.
 
-template< int N >
+template <int N>
 struct SuperScalar {
   double val[N];
 
   KOKKOS_INLINE_FUNCTION
   SuperScalar() {
-    for ( int i = 0; i < N; i++ ) {
+    for (int i = 0; i < N; i++) {
       val[i] = 0.0;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar( const SuperScalar & src ) {
-    for ( int i = 0; i < N; i++ ) {
+  SuperScalar(const SuperScalar& src) {
+    for (int i = 0; i < N; i++) {
       val[i] = src.val[i];
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar( const volatile SuperScalar & src ) {
-    for ( int i = 0; i < N; i++ ) {
+  SuperScalar(const volatile SuperScalar& src) {
+    for (int i = 0; i < N; i++) {
       val[i] = src.val[i];
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar& operator=( const SuperScalar & src ) {
-    for ( int i = 0; i < N; i++ ) {
+  SuperScalar& operator=(const SuperScalar& src) {
+    for (int i = 0; i < N; i++) {
       val[i] = src.val[i];
     }
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar& operator=( const volatile SuperScalar & src ) {
-    for ( int i = 0; i < N; i++ ) {
+  SuperScalar& operator=(const volatile SuperScalar& src) {
+    for (int i = 0; i < N; i++) {
       val[i] = src.val[i];
     }
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator=( const SuperScalar & src ) volatile  {
-    for ( int i = 0; i < N; i++ ) {
+  void operator=(const SuperScalar& src) volatile {
+    for (int i = 0; i < N; i++) {
       val[i] = src.val[i];
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar operator+( const SuperScalar & src ) {
+  SuperScalar operator+(const SuperScalar& src) {
     SuperScalar tmp = *this;
-    for ( int i = 0; i < N; i++ ) {
+    for (int i = 0; i < N; i++) {
       tmp.val[i] += src.val[i];
     }
     return tmp;
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar& operator+=( const double & src ) {
-    for ( int i = 0; i < N; i++ ) {
-      val[i] += 1.0 * ( i + 1 ) * src;
+  SuperScalar& operator+=(const double& src) {
+    for (int i = 0; i < N; i++) {
+      val[i] += 1.0 * (i + 1) * src;
     }
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar& operator+=( const SuperScalar & src ) {
-    for ( int i = 0; i < N; i++ ) {
+  SuperScalar& operator+=(const SuperScalar& src) {
+    for (int i = 0; i < N; i++) {
       val[i] += src.val[i];
     }
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator==( const SuperScalar & src ) {
+  bool operator==(const SuperScalar& src) {
     bool compare = true;
-    for( int i = 0; i < N; i++ ) {
-      compare = compare && ( val[i] == src.val[i] );
+    for (int i = 0; i < N; i++) {
+      compare = compare && (val[i] == src.val[i]);
     }
     return compare;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator!=( const SuperScalar & src ) {
+  bool operator!=(const SuperScalar& src) {
     bool compare = true;
-    for ( int i = 0; i < N; i++ ) {
-      compare = compare && ( val[i] == src.val[i] );
+    for (int i = 0; i < N; i++) {
+      compare = compare && (val[i] == src.val[i]);
     }
     return !compare;
   }
 
   KOKKOS_INLINE_FUNCTION
-  SuperScalar( const double & src ) {
-    for ( int i = 0; i < N; i++ ) {
-      val[i] = 1.0 * ( i + 1 ) * src;
+  SuperScalar(const double& src) {
+    for (int i = 0; i < N; i++) {
+      val[i] = 1.0 * (i + 1) * src;
     }
   }
 };
 
-template< int N >
-std::ostream & operator<<( std::ostream & os, const SuperScalar< N > & dt )
-{
+template <int N>
+std::ostream& operator<<(std::ostream& os, const SuperScalar<N>& dt) {
   os << "{ ";
-  for ( int  i = 0; i < N - 1; i++ ) {
-     os << dt.val[i] << ", ";
+  for (int i = 0; i < N - 1; i++) {
+    os << dt.val[i] << ", ";
   }
-  os << dt.val[N-1] << "}";
+  os << dt.val[N - 1] << "}";
 
   return os;
 }
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct ZeroFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef typename Kokkos::View< T, execution_space > type;
-  typedef typename Kokkos::View< T, execution_space >::HostMirror h_type;
+  typedef typename Kokkos::View<T, execution_space> type;
+  typedef typename Kokkos::View<T, execution_space>::HostMirror h_type;
 
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    data() = 0;
-  }
+  void operator()(int) const { data() = 0; }
 };
 
 //---------------------------------------------------
 //--------------atomic_fetch_add---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct AddFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_add( &data(), (T) 1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_add(&data(), (T)1); }
 };
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct AddFunctorReduce {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int , int& ) const {
-    Kokkos::atomic_fetch_add( &data(), (T) 1 );
-  }
+  void operator()(int, int&) const { Kokkos::atomic_fetch_add(&data(), (T)1); }
 };
 
-template< class T, class execution_space >
-T AddLoop( int loop ) {
-  struct ZeroFunctor< T, execution_space > f_zero;
-  typename ZeroFunctor< T, execution_space >::type data( "Data" );
-  typename ZeroFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T AddLoop(int loop) {
+  struct ZeroFunctor<T, execution_space> f_zero;
+  typename ZeroFunctor<T, execution_space>::type data("Data");
+  typename ZeroFunctor<T, execution_space>::h_type h_data("HData");
 
   f_zero.data = data;
 
-  Kokkos::parallel_for( 1, f_zero );
+  Kokkos::parallel_for(1, f_zero);
   execution_space().fence();
 
-  struct AddFunctor< T, execution_space > f_add;
+  struct AddFunctor<T, execution_space> f_add;
 
   f_add.data = data;
-  Kokkos::parallel_for( loop, f_add );
+  Kokkos::parallel_for(loop, f_add);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
-  struct AddFunctorReduce< T, execution_space > f_add_red;
+  struct AddFunctorReduce<T, execution_space> f_add_red;
   f_add_red.data = data;
   int dummy_result;
-  Kokkos::parallel_reduce( loop, f_add_red , dummy_result );
+  Kokkos::parallel_reduce(loop, f_add_red, dummy_result);
   execution_space().fence();
 
   return val;
 }
 
-template< class T >
-T AddLoopSerial( int loop ) {
+template <class T>
+T AddLoopSerial(int loop) {
   T* data = new T[1];
   data[0] = 0;
 
-  for ( int i = 0; i < loop; i++ ) {
-    *data += (T) 1;
+  for (int i = 0; i < loop; i++) {
+    *data += (T)1;
   }
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
@@ -250,93 +244,93 @@ T AddLoopSerial( int loop ) {
 //--------------atomic_compare_exchange-----------------
 //------------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct CASFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
+  void operator()(int) const {
     T old = data();
     T newval, assumed;
 
     do {
       assumed = old;
-      newval = assumed + (T) 1;
-      old = Kokkos::atomic_compare_exchange( &data(), assumed, newval );
-    } while( old != assumed );
+      newval  = assumed + (T)1;
+      old     = Kokkos::atomic_compare_exchange(&data(), assumed, newval);
+    } while (old != assumed);
   }
 };
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct CASFunctorReduce {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int , int& ) const {
+  void operator()(int, int&) const {
     T old = data();
     T newval, assumed;
 
     do {
       assumed = old;
-      newval = assumed + (T) 1;
-      old = Kokkos::atomic_compare_exchange( &data(), assumed, newval );
-    } while( old != assumed );
+      newval  = assumed + (T)1;
+      old     = Kokkos::atomic_compare_exchange(&data(), assumed, newval);
+    } while (old != assumed);
   }
 };
 
-template< class T, class execution_space >
-T CASLoop( int loop ) {
-  struct ZeroFunctor< T, execution_space > f_zero;
-  typename ZeroFunctor< T, execution_space >::type data( "Data" );
-  typename ZeroFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T CASLoop(int loop) {
+  struct ZeroFunctor<T, execution_space> f_zero;
+  typename ZeroFunctor<T, execution_space>::type data("Data");
+  typename ZeroFunctor<T, execution_space>::h_type h_data("HData");
 
   f_zero.data = data;
-  Kokkos::parallel_for( 1, f_zero );
+  Kokkos::parallel_for(1, f_zero);
   execution_space().fence();
 
-  struct CASFunctor< T, execution_space > f_cas;
+  struct CASFunctor<T, execution_space> f_cas;
   f_cas.data = data;
-  Kokkos::parallel_for( loop, f_cas );
+  Kokkos::parallel_for(loop, f_cas);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
-  struct CASFunctorReduce< T, execution_space > f_cas_red;
+  struct CASFunctorReduce<T, execution_space> f_cas_red;
   f_cas_red.data = data;
   int dummy_result;
-  Kokkos::parallel_reduce( loop, f_cas_red , dummy_result );
+  Kokkos::parallel_reduce(loop, f_cas_red, dummy_result);
   execution_space().fence();
 
   return val;
 }
 
-template< class T >
-T CASLoopSerial( int loop ) {
+template <class T>
+T CASLoopSerial(int loop) {
   T* data = new T[1];
   data[0] = 0;
 
-  for ( int i = 0; i < loop; i++ ) {
+  for (int i = 0; i < loop; i++) {
     T assumed;
     T newval;
     T old;
 
     do {
       assumed = *data;
-      newval = assumed + (T) 1;
-      old = *data;
-      *data = newval;
-    } while( !( assumed == old ) );
+      newval  = assumed + (T)1;
+      old     = *data;
+      *data   = newval;
+    } while (!(assumed == old));
   }
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
@@ -345,209 +339,228 @@ T CASLoopSerial( int loop ) {
 //--------------atomic_exchange-----------------
 //----------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct ExchFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data, data2;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i ) const {
-    T old = Kokkos::atomic_exchange( &data(), (T) i );
-    Kokkos::atomic_fetch_add( &data2(), old );
+  void operator()(int i) const {
+    T old = Kokkos::atomic_exchange(&data(), (T)i);
+    Kokkos::atomic_fetch_add(&data2(), old);
   }
 };
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct ExchFunctorReduce {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data, data2;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i , int& ) const {
-    T old = Kokkos::atomic_exchange( &data(), (T) i );
-    Kokkos::atomic_fetch_add( &data2(), old );
+  void operator()(int i, int&) const {
+    T old = Kokkos::atomic_exchange(&data(), (T)i);
+    Kokkos::atomic_fetch_add(&data2(), old);
   }
 };
 
-template< class T, class execution_space >
-T ExchLoop( int loop ) {
-  struct ZeroFunctor< T, execution_space > f_zero;
-  typename ZeroFunctor< T, execution_space >::type data( "Data" );
-  typename ZeroFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T ExchLoop(int loop) {
+  struct ZeroFunctor<T, execution_space> f_zero;
+  typename ZeroFunctor<T, execution_space>::type data("Data");
+  typename ZeroFunctor<T, execution_space>::h_type h_data("HData");
 
   f_zero.data = data;
-  Kokkos::parallel_for( 1, f_zero );
+  Kokkos::parallel_for(1, f_zero);
   execution_space().fence();
 
-  typename ZeroFunctor< T, execution_space >::type data2( "Data" );
-  typename ZeroFunctor< T, execution_space >::h_type h_data2( "HData" );
+  typename ZeroFunctor<T, execution_space>::type data2("Data");
+  typename ZeroFunctor<T, execution_space>::h_type h_data2("HData");
 
   f_zero.data = data2;
-  Kokkos::parallel_for( 1, f_zero );
+  Kokkos::parallel_for(1, f_zero);
   execution_space().fence();
 
-  struct ExchFunctor< T, execution_space > f_exch;
-  f_exch.data = data;
+  struct ExchFunctor<T, execution_space> f_exch;
+  f_exch.data  = data;
   f_exch.data2 = data2;
-  Kokkos::parallel_for( loop, f_exch );
+  Kokkos::parallel_for(loop, f_exch);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
-  Kokkos::deep_copy( h_data2, data2 );
+  Kokkos::deep_copy(h_data, data);
+  Kokkos::deep_copy(h_data2, data2);
   T val = h_data() + h_data2();
 
-  struct ExchFunctorReduce< T, execution_space > f_exch_red;
-  f_exch_red.data = data;
+  struct ExchFunctorReduce<T, execution_space> f_exch_red;
+  f_exch_red.data  = data;
   f_exch_red.data2 = data2;
   int dummy_result;
-  Kokkos::parallel_reduce( loop, f_exch_red , dummy_result );
+  Kokkos::parallel_reduce(loop, f_exch_red, dummy_result);
   execution_space().fence();
 
   return val;
 }
 
-template< class T >
-T ExchLoopSerial( typename std::conditional< !std::is_same< T, Kokkos::complex<double> >::value, int, void >::type loop ) {
-  T* data = new T[1];
+template <class T>
+T ExchLoopSerial(
+    typename std::conditional<!std::is_same<T, Kokkos::complex<double> >::value,
+                              int, void>::type loop) {
+  T* data  = new T[1];
   T* data2 = new T[1];
-  data[0] = 0;
+  data[0]  = 0;
   data2[0] = 0;
 
-  for ( int i = 0; i < loop; i++ ) {
+  for (int i = 0; i < loop; i++) {
     T old = *data;
-    *data = (T) i;
+    *data = (T)i;
     *data2 += old;
   }
 
   T val = *data2 + *data;
-  delete [] data;
-  delete [] data2;
+  delete[] data;
+  delete[] data2;
 
   return val;
 }
 
-template< class T >
-T ExchLoopSerial( typename std::conditional< std::is_same< T, Kokkos::complex<double> >::value, int, void >::type loop ) {
-  T* data = new T[1];
+template <class T>
+T ExchLoopSerial(
+    typename std::conditional<std::is_same<T, Kokkos::complex<double> >::value,
+                              int, void>::type loop) {
+  T* data  = new T[1];
   T* data2 = new T[1];
-  data[0] = 0;
+  data[0]  = 0;
   data2[0] = 0;
 
-  for ( int i = 0; i < loop; i++ ) {
-    T old = *data;
-    data->real() = ( static_cast<double>( i ) );
+  for (int i = 0; i < loop; i++) {
+    T old        = *data;
+    data->real() = (static_cast<double>(i));
     data->imag() = 0;
     *data2 += old;
   }
 
   T val = *data2 + *data;
-  delete [] data;
-  delete [] data2;
+  delete[] data;
+  delete[] data2;
 
   return val;
 }
 
-template< class T, class DeviceType >
-T LoopVariant( int loop, int test ) {
-  switch ( test ) {
-    case 1: return AddLoop< T, DeviceType >( loop );
-    case 2: return CASLoop< T, DeviceType >( loop );
-    case 3: return ExchLoop< T, DeviceType >( loop );
+template <class T, class DeviceType>
+T LoopVariant(int loop, int test) {
+  switch (test) {
+    case 1: return AddLoop<T, DeviceType>(loop);
+    case 2: return CASLoop<T, DeviceType>(loop);
+    case 3: return ExchLoop<T, DeviceType>(loop);
   }
 
   return 0;
 }
 
-template< class T >
-T LoopVariantSerial( int loop, int test ) {
-  switch ( test ) {
-    case 1: return AddLoopSerial< T >( loop );
-    case 2: return CASLoopSerial< T >( loop );
-    case 3: return ExchLoopSerial< T >( loop );
+template <class T>
+T LoopVariantSerial(int loop, int test) {
+  switch (test) {
+    case 1: return AddLoopSerial<T>(loop);
+    case 2: return CASLoopSerial<T>(loop);
+    case 3: return ExchLoopSerial<T>(loop);
   }
 
   return 0;
 }
 
-template< class T, class DeviceType >
-bool Loop( int loop, int test )
-{
-  T res       = LoopVariant< T, DeviceType >( loop, test );
-  T resSerial = LoopVariantSerial< T >( loop, test );
+template <class T, class DeviceType>
+bool Loop(int loop, int test) {
+  T res       = LoopVariant<T, DeviceType>(loop, test);
+  T resSerial = LoopVariantSerial<T>(loop, test);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = "
-              << test << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = " << test
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
 }
 
-} // namespace TestAtomic
+}  // namespace TestAtomic
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, atomics )
-{
+TEST(TEST_CATEGORY, atomics) {
   const int loop_count = 1e4;
 
-  ASSERT_TRUE( ( TestAtomic::Loop< int, TEST_EXECSPACE >( loop_count, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< int, TEST_EXECSPACE >( loop_count, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< int, TEST_EXECSPACE >( loop_count, 3 ) ) );
+  ASSERT_TRUE((TestAtomic::Loop<int, TEST_EXECSPACE>(loop_count, 1)));
+  ASSERT_TRUE((TestAtomic::Loop<int, TEST_EXECSPACE>(loop_count, 2)));
+  ASSERT_TRUE((TestAtomic::Loop<int, TEST_EXECSPACE>(loop_count, 3)));
 
-  ASSERT_TRUE( ( TestAtomic::Loop< unsigned int, TEST_EXECSPACE >( loop_count, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< unsigned int, TEST_EXECSPACE >( loop_count, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< unsigned int, TEST_EXECSPACE >( loop_count, 3 ) ) );
+  ASSERT_TRUE((TestAtomic::Loop<unsigned int, TEST_EXECSPACE>(loop_count, 1)));
+  ASSERT_TRUE((TestAtomic::Loop<unsigned int, TEST_EXECSPACE>(loop_count, 2)));
+  ASSERT_TRUE((TestAtomic::Loop<unsigned int, TEST_EXECSPACE>(loop_count, 3)));
 
-  ASSERT_TRUE( ( TestAtomic::Loop< long int, TEST_EXECSPACE >( loop_count, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< long int, TEST_EXECSPACE >( loop_count, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< long int, TEST_EXECSPACE >( loop_count, 3 ) ) );
+  ASSERT_TRUE((TestAtomic::Loop<long int, TEST_EXECSPACE>(loop_count, 1)));
+  ASSERT_TRUE((TestAtomic::Loop<long int, TEST_EXECSPACE>(loop_count, 2)));
+  ASSERT_TRUE((TestAtomic::Loop<long int, TEST_EXECSPACE>(loop_count, 3)));
 
-  ASSERT_TRUE( ( TestAtomic::Loop< unsigned long int, TEST_EXECSPACE >( loop_count, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< unsigned long int, TEST_EXECSPACE >( loop_count, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< unsigned long int, TEST_EXECSPACE >( loop_count, 3 ) ) );
+  ASSERT_TRUE(
+      (TestAtomic::Loop<unsigned long int, TEST_EXECSPACE>(loop_count, 1)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<unsigned long int, TEST_EXECSPACE>(loop_count, 2)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<unsigned long int, TEST_EXECSPACE>(loop_count, 3)));
 
-  ASSERT_TRUE( ( TestAtomic::Loop< long long int, TEST_EXECSPACE >( loop_count, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< long long int, TEST_EXECSPACE >( loop_count, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< long long int, TEST_EXECSPACE >( loop_count, 3 ) ) );
+  ASSERT_TRUE((TestAtomic::Loop<long long int, TEST_EXECSPACE>(loop_count, 1)));
+  ASSERT_TRUE((TestAtomic::Loop<long long int, TEST_EXECSPACE>(loop_count, 2)));
+  ASSERT_TRUE((TestAtomic::Loop<long long int, TEST_EXECSPACE>(loop_count, 3)));
 
-  ASSERT_TRUE( ( TestAtomic::Loop< double, TEST_EXECSPACE >( loop_count, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< double, TEST_EXECSPACE >( loop_count, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< double, TEST_EXECSPACE >( loop_count, 3 ) ) );
+  ASSERT_TRUE((TestAtomic::Loop<double, TEST_EXECSPACE>(loop_count, 1)));
+  ASSERT_TRUE((TestAtomic::Loop<double, TEST_EXECSPACE>(loop_count, 2)));
+  ASSERT_TRUE((TestAtomic::Loop<double, TEST_EXECSPACE>(loop_count, 3)));
 
-  ASSERT_TRUE( ( TestAtomic::Loop< float, TEST_EXECSPACE >( 100, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< float, TEST_EXECSPACE >( 100, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< float, TEST_EXECSPACE >( 100, 3 ) ) );
+  ASSERT_TRUE((TestAtomic::Loop<float, TEST_EXECSPACE>(100, 1)));
+  ASSERT_TRUE((TestAtomic::Loop<float, TEST_EXECSPACE>(100, 2)));
+  ASSERT_TRUE((TestAtomic::Loop<float, TEST_EXECSPACE>(100, 3)));
 
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
-#ifndef KOKKOS_ENABLE_ROCM // ROCM doesn't yet support atomics for >64bit types
-  ASSERT_TRUE( ( TestAtomic::Loop< Kokkos::complex<double>, TEST_EXECSPACE >( 1, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< Kokkos::complex<double>, TEST_EXECSPACE >( 1, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< Kokkos::complex<double>, TEST_EXECSPACE >( 1, 3 ) ) );
-
-  ASSERT_TRUE( ( TestAtomic::Loop< Kokkos::complex<double>, TEST_EXECSPACE >( 100, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< Kokkos::complex<double>, TEST_EXECSPACE >( 100, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< Kokkos::complex<double>, TEST_EXECSPACE >( 100, 3 ) ) );
-
-  ASSERT_TRUE( ( TestAtomic::Loop< TestAtomic::SuperScalar<4>, TEST_EXECSPACE >( 100, 1 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< TestAtomic::SuperScalar<4>, TEST_EXECSPACE >( 100, 2 ) ) );
-  ASSERT_TRUE( ( TestAtomic::Loop< TestAtomic::SuperScalar<4>, TEST_EXECSPACE >( 100, 3 ) ) );
+#ifndef KOKKOS_ENABLE_ROCM  // ROCM doesn't yet support atomics for >64bit types
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<double>, TEST_EXECSPACE>(1, 1)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<double>, TEST_EXECSPACE>(1, 2)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<double>, TEST_EXECSPACE>(1, 3)));
+
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<double>, TEST_EXECSPACE>(100, 1)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<double>, TEST_EXECSPACE>(100, 2)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<double>, TEST_EXECSPACE>(100, 3)));
+
+  ASSERT_TRUE((TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(1, 1)));
+  ASSERT_TRUE((TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(1, 2)));
+  ASSERT_TRUE((TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(1, 3)));
+
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(100, 1)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(100, 2)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(100, 3)));
+
+  ASSERT_TRUE(
+      (TestAtomic::Loop<TestAtomic::SuperScalar<4>, TEST_EXECSPACE>(100, 1)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<TestAtomic::SuperScalar<4>, TEST_EXECSPACE>(100, 2)));
+  ASSERT_TRUE(
+      (TestAtomic::Loop<TestAtomic::SuperScalar<4>, TEST_EXECSPACE>(100, 3)));
 #endif
 #endif
 }
 
-
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations.hpp
index e043737e423809938c3e04efc38b12a009d9e8be..109adaa1b3cc973f3d6a3f3602e0d095f2293a02 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,114 +50,105 @@ namespace TestAtomicOperations {
 //--------------zero_functor---------------------
 //-----------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct ZeroFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef typename Kokkos::View< T, execution_space > type;
-  typedef typename Kokkos::View< T, execution_space >::HostMirror h_type;
+  typedef typename Kokkos::View<T, execution_space> type;
+  typedef typename Kokkos::View<T, execution_space>::HostMirror h_type;
 
   type data;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    data() = 0;
-  }
+  void operator()(int) const { data() = 0; }
 };
 
 //-----------------------------------------------
 //--------------init_functor---------------------
 //-----------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct InitFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef typename Kokkos::View< T, execution_space > type;
-  typedef typename Kokkos::View< T, execution_space >::HostMirror h_type;
+  typedef typename Kokkos::View<T, execution_space> type;
+  typedef typename Kokkos::View<T, execution_space>::HostMirror h_type;
 
   type data;
   T init_value;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    data() = init_value;
-  }
+  void operator()(int) const { data() = init_value; }
 
-  InitFunctor( T _init_value ) : init_value( _init_value ) {}
+  InitFunctor(T _init_value) : init_value(_init_value) {}
 };
 
 //---------------------------------------------------
 //--------------atomic_fetch_max---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct MaxFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    //Kokkos::atomic_fetch_max( &data(), (T) 1 );
-    Kokkos::atomic_fetch_max( &data(), (T) i1 );
+  void operator()(int) const {
+    // Kokkos::atomic_fetch_max( &data(), (T) 1 );
+    Kokkos::atomic_fetch_max(&data(), (T)i1);
   }
-  MaxFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  MaxFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T MaxAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T MaxAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct MaxFunctor< T, execution_space > f( i0, i1 );
+  struct MaxFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T MaxAtomicCheck( T i0, T i1 ) {
+template <class T>
+T MaxAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
-  *data = ( i0 > i1 ? i0 : i1 );
+  *data = (i0 > i1 ? i0 : i1);
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool MaxAtomicTest( T i0, T i1 )
-{
-  T res       = MaxAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = MaxAtomicCheck<T>( i0, i1 );
+template <class T, class DeviceType>
+bool MaxAtomicTest(T i0, T i1) {
+  T res       = MaxAtomic<T, DeviceType>(i0, i1);
+  T resSerial = MaxAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = MaxAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = MaxAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -166,75 +158,68 @@ bool MaxAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_min---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct MinFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_min( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_min(&data(), (T)i1); }
 
-  MinFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  MinFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T MinAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T MinAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct MinFunctor< T, execution_space > f( i0, i1 );
+  struct MinFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T MinAtomicCheck( T i0, T i1 ) {
+template <class T>
+T MinAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
-  *data = ( i0 < i1 ? i0 : i1 );
+  *data = (i0 < i1 ? i0 : i1);
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool MinAtomicTest( T i0, T i1 )
-{
-  T res       = MinAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = MinAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool MinAtomicTest(T i0, T i1) {
+  T res       = MinAtomic<T, DeviceType>(i0, i1);
+  T resSerial = MinAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = MinAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = MinAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -244,74 +229,67 @@ bool MinAtomicTest( T i0, T i1 )
 //--------------atomic_increment---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct IncFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_increment( &data() );
-  }
+  void operator()(int) const { Kokkos::atomic_increment(&data()); }
 
-  IncFunctor( T _i0 ) : i0( _i0 ) {}
+  IncFunctor(T _i0) : i0(_i0) {}
 };
 
-template< class T, class execution_space >
-T IncAtomic( T i0 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T IncAtomic(T i0) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct IncFunctor< T, execution_space > f( i0 );
+  struct IncFunctor<T, execution_space> f(i0);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T IncAtomicCheck( T i0 ) {
+template <class T>
+T IncAtomicCheck(T i0) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 + 1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool IncAtomicTest( T i0 )
-{
-  T res       = IncAtomic< T, DeviceType >( i0 );
-  T resSerial = IncAtomicCheck< T >( i0 );
+template <class T, class DeviceType>
+bool IncAtomicTest(T i0) {
+  T res       = IncAtomic<T, DeviceType>(i0);
+  T resSerial = IncAtomicCheck<T>(i0);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = IncAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = IncAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -321,74 +299,67 @@ bool IncAtomicTest( T i0 )
 //--------------atomic_decrement---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct DecFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_decrement( &data() );
-  }
+  void operator()(int) const { Kokkos::atomic_decrement(&data()); }
 
-  DecFunctor( T _i0 ) : i0( _i0 ) {}
+  DecFunctor(T _i0) : i0(_i0) {}
 };
 
-template< class T, class execution_space >
-T DecAtomic( T i0 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T DecAtomic(T i0) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct DecFunctor< T, execution_space > f( i0 );
+  struct DecFunctor<T, execution_space> f(i0);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T DecAtomicCheck( T i0 ) {
+template <class T>
+T DecAtomicCheck(T i0) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 - 1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool DecAtomicTest( T i0 )
-{
-  T res       = DecAtomic< T, DeviceType >( i0 );
-  T resSerial = DecAtomicCheck< T >( i0 );
+template <class T, class DeviceType>
+bool DecAtomicTest(T i0) {
+  T res       = DecAtomic<T, DeviceType>(i0);
+  T resSerial = DecAtomicCheck<T>(i0);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = DecAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = DecAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -398,75 +369,68 @@ bool DecAtomicTest( T i0 )
 //--------------atomic_fetch_mul---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct MulFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_mul( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_mul(&data(), (T)i1); }
 
-  MulFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  MulFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T MulAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T MulAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct MulFunctor< T, execution_space > f( i0, i1 );
+  struct MulFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T MulAtomicCheck( T i0, T i1 ) {
+template <class T>
+T MulAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
-  *data = i0*i1;
+  *data = i0 * i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool MulAtomicTest( T i0, T i1 )
-{
-  T res       = MulAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = MulAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool MulAtomicTest(T i0, T i1) {
+  T res       = MulAtomic<T, DeviceType>(i0, i1);
+  T resSerial = MulAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = MulAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = MulAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -476,77 +440,70 @@ bool MulAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_div---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct DivFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_div( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_div(&data(), (T)i1); }
 
-  DivFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  DivFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T DivAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T DivAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct DivFunctor< T, execution_space > f( i0, i1 );
+  struct DivFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T DivAtomicCheck( T i0, T i1 ) {
+template <class T>
+T DivAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 / i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool DivAtomicTest( T i0, T i1 )
-{
-  T res       = DivAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = DivAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool DivAtomicTest(T i0, T i1) {
+  T res       = DivAtomic<T, DeviceType>(i0, i1);
+  T resSerial = DivAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  using std::abs;
   using Kokkos::abs;
-  if ( abs( (resSerial-res) * 1.) > 1e-5 ) {
+  using std::abs;
+  if (abs((resSerial - res) * 1.) > 1e-5) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = DivAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = DivAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -556,75 +513,68 @@ bool DivAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_mod---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct ModFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_mod( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_mod(&data(), (T)i1); }
 
-  ModFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  ModFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T ModAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T ModAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct ModFunctor< T, execution_space > f( i0, i1 );
+  struct ModFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T ModAtomicCheck( T i0, T i1 ) {
+template <class T>
+T ModAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 % i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool ModAtomicTest( T i0, T i1 )
-{
-  T res       = ModAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = ModAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool ModAtomicTest(T i0, T i1) {
+  T res       = ModAtomic<T, DeviceType>(i0, i1);
+  T resSerial = ModAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = ModAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = ModAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -634,75 +584,68 @@ bool ModAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_and---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct AndFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_and( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_and(&data(), (T)i1); }
 
-  AndFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  AndFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T AndAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T AndAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct AndFunctor< T, execution_space > f( i0, i1 );
+  struct AndFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T AndAtomicCheck( T i0, T i1 ) {
+template <class T>
+T AndAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 & i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool AndAtomicTest( T i0, T i1 )
-{
-  T res       = AndAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = AndAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool AndAtomicTest(T i0, T i1) {
+  T res       = AndAtomic<T, DeviceType>(i0, i1);
+  T resSerial = AndAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = AndAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = AndAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -712,75 +655,68 @@ bool AndAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_or----------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct OrFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_or( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_or(&data(), (T)i1); }
 
-  OrFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  OrFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T OrAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T OrAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct OrFunctor< T, execution_space > f( i0, i1 );
+  struct OrFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T OrAtomicCheck( T i0, T i1 ) {
+template <class T>
+T OrAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 | i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool OrAtomicTest( T i0, T i1 )
-{
-  T res       = OrAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = OrAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool OrAtomicTest(T i0, T i1) {
+  T res       = OrAtomic<T, DeviceType>(i0, i1);
+  T resSerial = OrAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = OrAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = OrAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -790,75 +726,68 @@ bool OrAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_xor---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct XorFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_xor( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_xor(&data(), (T)i1); }
 
-  XorFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  XorFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T XorAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T XorAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct XorFunctor< T, execution_space > f( i0, i1 );
+  struct XorFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T XorAtomicCheck( T i0, T i1 ) {
+template <class T>
+T XorAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 ^ i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool XorAtomicTest( T i0, T i1 )
-{
-  T res       = XorAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = XorAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool XorAtomicTest(T i0, T i1) {
+  T res       = XorAtomic<T, DeviceType>(i0, i1);
+  T resSerial = XorAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = XorAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = XorAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -868,75 +797,68 @@ bool XorAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_lshift---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct LShiftFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_lshift( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_lshift(&data(), (T)i1); }
 
-  LShiftFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  LShiftFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T LShiftAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T LShiftAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct LShiftFunctor< T, execution_space > f( i0, i1 );
+  struct LShiftFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T LShiftAtomicCheck( T i0, T i1 ) {
+template <class T>
+T LShiftAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 << i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool LShiftAtomicTest( T i0, T i1 )
-{
-  T res       = LShiftAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = LShiftAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool LShiftAtomicTest(T i0, T i1) {
+  T res       = LShiftAtomic<T, DeviceType>(i0, i1);
+  T resSerial = LShiftAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = LShiftAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = LShiftAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -946,75 +868,68 @@ bool LShiftAtomicTest( T i0, T i1 )
 //--------------atomic_fetch_rshift---------------------
 //---------------------------------------------------
 
-template< class T, class DEVICE_TYPE >
+template <class T, class DEVICE_TYPE>
 struct RShiftFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef Kokkos::View< T, execution_space > type;
+  typedef Kokkos::View<T, execution_space> type;
 
   type data;
   T i0;
   T i1;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const {
-    Kokkos::atomic_fetch_rshift( &data(), (T) i1 );
-  }
+  void operator()(int) const { Kokkos::atomic_fetch_rshift(&data(), (T)i1); }
 
-  RShiftFunctor( T _i0, T _i1 ) : i0( _i0 ), i1( _i1 ) {}
+  RShiftFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
 
-template< class T, class execution_space >
-T RShiftAtomic( T i0, T i1 ) {
-  struct InitFunctor< T, execution_space > f_init( i0 );
-  typename InitFunctor< T, execution_space >::type data( "Data" );
-  typename InitFunctor< T, execution_space >::h_type h_data( "HData" );
+template <class T, class execution_space>
+T RShiftAtomic(T i0, T i1) {
+  struct InitFunctor<T, execution_space> f_init(i0);
+  typename InitFunctor<T, execution_space>::type data("Data");
+  typename InitFunctor<T, execution_space>::h_type h_data("HData");
 
   f_init.data = data;
-  Kokkos::parallel_for( 1, f_init );
+  Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-  struct RShiftFunctor< T, execution_space > f( i0, i1 );
+  struct RShiftFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
-  Kokkos::parallel_for( 1, f );
+  Kokkos::parallel_for(1, f);
   execution_space().fence();
 
-  Kokkos::deep_copy( h_data, data );
+  Kokkos::deep_copy(h_data, data);
   T val = h_data();
 
   return val;
 }
 
-template< class T >
-T RShiftAtomicCheck( T i0, T i1 ) {
+template <class T>
+T RShiftAtomicCheck(T i0, T i1) {
   T* data = new T[1];
   data[0] = 0;
 
   *data = i0 >> i1;
 
   T val = *data;
-  delete [] data;
+  delete[] data;
 
   return val;
 }
 
-template< class T, class DeviceType >
-bool RShiftAtomicTest( T i0, T i1 )
-{
-  T res       = RShiftAtomic< T, DeviceType >( i0, i1 );
-  T resSerial = RShiftAtomicCheck< T >( i0, i1 );
+template <class T, class DeviceType>
+bool RShiftAtomicTest(T i0, T i1) {
+  T res       = RShiftAtomic<T, DeviceType>(i0, i1);
+  T resSerial = RShiftAtomicCheck<T>(i0, i1);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
-              << ">( test = RShiftAtomicTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+    std::cout << "Loop<" << typeid(T).name() << ">( test = RShiftAtomicTest"
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -1024,39 +939,36 @@ bool RShiftAtomicTest( T i0, T i1 )
 //--------------atomic_test_control------------------
 //---------------------------------------------------
 
-template< class T, class DeviceType >
-bool AtomicOperationsTestIntegralType( int i0, int i1, int test )
-{
-  switch ( test ) {
-    case 1: return MaxAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 2: return MinAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 3: return MulAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 4: return DivAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 5: return ModAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 6: return AndAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 7: return OrAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 8: return XorAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 9: return LShiftAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 10: return RShiftAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 11: return IncAtomicTest< T, DeviceType >( (T) i0 );
-    case 12: return DecAtomicTest< T, DeviceType >( (T) i0 );
+template <class T, class DeviceType>
+bool AtomicOperationsTestIntegralType(int i0, int i1, int test) {
+  switch (test) {
+    case 1: return MaxAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 2: return MinAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 3: return MulAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 4: return DivAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 5: return ModAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 6: return AndAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 7: return OrAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 8: return XorAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 9: return LShiftAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 10: return RShiftAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 11: return IncAtomicTest<T, DeviceType>((T)i0);
+    case 12: return DecAtomicTest<T, DeviceType>((T)i0);
   }
 
   return 0;
 }
 
-template< class T, class DeviceType >
-bool AtomicOperationsTestNonIntegralType( int i0, int i1, int test )
-{
-  switch ( test ) {
-    case 1: return MaxAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 2: return MinAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 3: return MulAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
-    case 4: return DivAtomicTest< T, DeviceType >( (T) i0, (T) i1 );
+template <class T, class DeviceType>
+bool AtomicOperationsTestNonIntegralType(int i0, int i1, int test) {
+  switch (test) {
+    case 1: return MaxAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 2: return MinAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 3: return MulAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 4: return DivAtomicTest<T, DeviceType>((T)i0, (T)i1);
   }
 
   return 0;
 }
 
-}
-
+}  // namespace TestAtomicOperations
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_complexdouble.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_complexdouble.hpp
index a8474d895222e95b400655a5dc6f6a6314ce7c4a..612247d03fa7f823bbe7699b15d5a0bf65fe2db6 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_complexdouble.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_complexdouble.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,17 +42,19 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_complexdouble )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::MulAtomicTest< Kokkos::complex<double>, TEST_EXECSPACE >( start , end - i) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::DivAtomicTest< Kokkos::complex<double>, TEST_EXECSPACE >( start , end - i) ) );
+TEST(TEST_CATEGORY, atomic_operations_complexdouble) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE(
+        (TestAtomicOperations::MulAtomicTest<Kokkos::complex<double>,
+                                             TEST_EXECSPACE>(start, end - i)));
+    ASSERT_TRUE(
+        (TestAtomicOperations::DivAtomicTest<Kokkos::complex<double>,
+                                             TEST_EXECSPACE>(start, end - i)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_complexfloat.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_complexfloat.hpp
index 961418e675749064bae6c38a728e68937a0ed082..e812d32074c0213c8547fed4353e0d3898b2adeb 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_complexfloat.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_complexfloat.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,17 +42,19 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_complexfloat )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::MulAtomicTest< Kokkos::complex<float>, TEST_EXECSPACE >( start , end - i) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::DivAtomicTest< Kokkos::complex<float>, TEST_EXECSPACE >( start , end - i) ) );
+TEST(TEST_CATEGORY, atomic_operations_complexfloat) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE(
+        (TestAtomicOperations::MulAtomicTest<Kokkos::complex<float>,
+                                             TEST_EXECSPACE>(start, end - i)));
+    ASSERT_TRUE(
+        (TestAtomicOperations::DivAtomicTest<Kokkos::complex<float>,
+                                             TEST_EXECSPACE>(start, end - i)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_double.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_double.hpp
index 7b9f9b7fe3502082c10d9f878a794491f3a2ce93..ba9937e1c6643bfd8a4decde2c7823061b0fcbe4 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_double.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_double.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,19 +42,21 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_double )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< double, TEST_EXECSPACE >( start, end - i, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< double, TEST_EXECSPACE >( start, end - i, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< double, TEST_EXECSPACE >( start, end - i, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< double, TEST_EXECSPACE >( start, end - i, 4 ) ) );
+TEST(TEST_CATEGORY, atomic_operations_double) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 double, TEST_EXECSPACE>(start, end - i, 1)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 double, TEST_EXECSPACE>(start, end - i, 2)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 double, TEST_EXECSPACE>(start, end - i, 3)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 double, TEST_EXECSPACE>(start, end - i, 4)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_float.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_float.hpp
index ec28f2262d9a84e99b84f1b5e8af89ef8d3e3575..aa56b5ff10e770d2964d498f99e25611d85311c6 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_float.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_float.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,19 +42,21 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_float )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< float, TEST_EXECSPACE >( start, end - i, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< float, TEST_EXECSPACE >( start, end - i, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< float, TEST_EXECSPACE >( start, end - i, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestNonIntegralType< float, TEST_EXECSPACE >( start, end - i, 4 ) ) );
+TEST(TEST_CATEGORY, atomic_operations_float) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 float, TEST_EXECSPACE>(start, end - i, 1)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 float, TEST_EXECSPACE>(start, end - i, 2)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 float, TEST_EXECSPACE>(start, end - i, 3)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                 float, TEST_EXECSPACE>(start, end - i, 4)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_int.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_int.hpp
index 3165ba037d24ed68480c5b590087336874111094..f828be6223c7b4e7554252fd04927ce1a3fcb69a 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_int.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_int.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,26 +42,35 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_int )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 4 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 5 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 6 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 7 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 8 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 9 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 11 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< int, TEST_EXECSPACE >( start, end - i, 12 ) ) );
+TEST(TEST_CATEGORY, atomic_operations_int) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 1)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 2)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 3)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 4)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 5)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 6)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 7)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 8)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 9)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 11)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 int, TEST_EXECSPACE>(start, end - i, 12)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_longint.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_longint.hpp
index 8cb0d68af320e86df2e9668958bc66b518f8aa20..eee44c9571cf890b25a9a1b9bb32edd279d3cae7 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_longint.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_longint.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,26 +42,35 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_long )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 4 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 5 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 6 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 7 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 8 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 9 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 11 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long int, TEST_EXECSPACE >( start, end - i, 12 ) ) );
+TEST(TEST_CATEGORY, atomic_operations_long) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 1)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 2)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 3)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 4)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 5)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 6)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 7)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 8)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 9)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 11)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long int, TEST_EXECSPACE>(start, end - i, 12)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_longlongint.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_longlongint.hpp
index 472cf3318c1fc8e046359eb2e57cbb9359a883b0..73d4a61d7291f852d1ff2d6607d36a1d0bb2f829 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_longlongint.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_longlongint.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,26 +42,35 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_longlong )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 4 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 5 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 6 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 7 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 8 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 9 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 11 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< long long int, TEST_EXECSPACE >( start, end - i, 12 ) ) );
+TEST(TEST_CATEGORY, atomic_operations_longlong) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 1)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 2)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 3)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 4)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 5)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 6)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 7)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 8)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 9)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 11)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 long long int, TEST_EXECSPACE>(start, end - i, 12)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedint.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedint.hpp
index 7e72c9f2e60b67e29326cbdd4ed054cda553d03d..02f337c57c64633d62d8111c28ae49cee05e80e3 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedint.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedint.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,26 +42,35 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_unsigned )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 4 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 5 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 6 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 7 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 8 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 9 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 11 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned int, TEST_EXECSPACE >( start, end - i, 12 ) ) );
+TEST(TEST_CATEGORY, atomic_operations_unsigned) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 1)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 2)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 3)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 4)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 5)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 6)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 7)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 8)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 9)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 11)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned int, TEST_EXECSPACE>(start, end - i, 12)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedlongint.hpp b/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
index dedddcc7adabb782d6ae572ca17bbe448224904f..f4340475f573c3c8f4c108f8b7bfacef0d72af4e 100644
--- a/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,26 +42,35 @@
 //@HEADER
 */
 
-#include<TestAtomicOperations.hpp>
+#include <TestAtomicOperations.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY , atomic_operations_unsignedlong )
-{
-  const int start = 1; // Avoid zero for division.
-  const int end = 11;
-  for ( int i = start; i < end; ++i )
-  {
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 4 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 5 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 6 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 7 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 8 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 9 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 11 ) ) );
-    ASSERT_TRUE( ( TestAtomicOperations::AtomicOperationsTestIntegralType< unsigned long int, TEST_EXECSPACE >( start, end - i, 12 ) ) );
+TEST(TEST_CATEGORY, atomic_operations_unsignedlong) {
+  const int start = 1;  // Avoid zero for division.
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 1)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 2)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 3)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 4)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 5)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 6)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 7)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 8)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 9)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 11)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                 unsigned long int, TEST_EXECSPACE>(start, end - i, 12)));
   }
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestAtomicViews.hpp b/lib/kokkos/core/unit_test/TestAtomicViews.hpp
index 38b49730d41164811f1b9ece85ee6e573f597fa8..d7a45dc40fe8cc529db6fa53d8374537a6cdb659 100644
--- a/lib/kokkos/core/unit_test/TestAtomicViews.hpp
+++ b/lib/kokkos/core/unit_test/TestAtomicViews.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,241 +50,262 @@ namespace TestAtomicViews {
 //-----------atomic view api tests-----------------
 //-------------------------------------------------
 
-template< class T, class ... P >
-size_t allocation_count( const Kokkos::View< T, P... > & view )
-{
+template <class T, class... P>
+size_t allocation_count(const Kokkos::View<T, P...>& view) {
   const size_t card  = view.size();
   const size_t alloc = view.span();
 
-  const int memory_span = Kokkos::View< int* >::required_allocation_size( 100 );
+  const int memory_span = Kokkos::View<int*>::required_allocation_size(100);
 
-  return ( card <= alloc && memory_span == 400 ) ? alloc : 0;
+  return (card <= alloc && memory_span == 400) ? alloc : 0;
 }
 
-template< class DataType,
-          class DeviceType,
-          unsigned Rank = Kokkos::ViewTraits< DataType >::rank >
+template <class DataType, class DeviceType,
+          unsigned Rank = Kokkos::ViewTraits<DataType>::rank>
 struct TestViewOperator_LeftAndRight;
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 1 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 1> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-    { update |= input; }
+  static void join(volatile value_type& update,
+                   const volatile value_type& input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-    { update = 0; }
+  static void init(value_type& update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      left_view;
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      right_view;
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutStride, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > stride_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutStride, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      stride_view;
 
-  left_view    left;
-  right_view   right;
-  stride_view  left_stride;
-  stride_view  right_stride;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  static void testit()
-  {
+      : left("left"),
+        right("right"),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
+
+  static void testit() {
     TestViewOperator_LeftAndRight driver;
 
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, driver, error_flag );
+    Kokkos::parallel_reduce(1, driver, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
+  void operator()(const size_type, value_type& update) const {
+    for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
       // Below checks that values match, but unable to check the references.
       // Should this be able to be checked?
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-        if ( left( i0 )  != left( i0, 0, 0, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-        if ( right( i0 ) != right( i0, 0, 0, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+      if (left(i0) != left(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
+      if (right(i0) != right(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
 #else
-        if ( left( i0 )  != left.access( i0, 0, 0, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-        if ( right( i0 ) != right.access( i0, 0, 0, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+      if (left(i0) != left.access(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
+      if (right(i0) != right.access(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
 #endif
-      if ( left( i0 )  != left_stride( i0 ) ) { update |= 4; }
-      if ( right( i0 ) != right_stride( i0 ) ) { update |= 8; }
-/*
-      if ( &left( i0 )  != &left( i0, 0, 0, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-      if ( &right( i0 ) != &right( i0, 0, 0, 0, 0, 0, 0, 0 ) ) { update |= 3; }
-      if ( &left( i0 )  != &left_stride( i0 ) ) { update |= 4; }
-      if ( &right( i0 ) != &right_stride( i0 ) ) { update |= 8; }
-*/
+      if (left(i0) != left_stride(i0)) {
+        update |= 4;
+      }
+      if (right(i0) != right_stride(i0)) {
+        update |= 8;
+      }
+      /*
+            if ( &left( i0 )  != &left( i0, 0, 0, 0, 0, 0, 0, 0 ) )  { update |=
+         3; } if ( &right( i0 ) != &right( i0, 0, 0, 0, 0, 0, 0, 0 ) ) { update
+         |= 3; } if ( &left( i0 )  != &left_stride( i0 ) ) { update |= 4; } if (
+         &right( i0 ) != &right_stride( i0 ) ) { update |= 8; }
+      */
     }
   }
 };
 
-template< typename T, class DeviceType >
-class TestAtomicViewAPI
-{
-public:
+template <typename T, class DeviceType>
+class TestAtomicViewAPI {
+ public:
   typedef DeviceType device;
 
-  enum { N0 = 1000,
-         N1 = 3,
-         N2 = 5,
-         N3 = 7 };
-
-  typedef Kokkos::View< T, device > dView0;
-  typedef Kokkos::View< T*, device > dView1;
-  typedef Kokkos::View< T*[N1], device > dView2;
-  typedef Kokkos::View< T*[N1][N2], device > dView3;
-  typedef Kokkos::View< T*[N1][N2][N3], device > dView4;
-  typedef Kokkos::View< const T*[N1][N2][N3], device > const_dView4;
-  typedef Kokkos::View< T****, device, Kokkos::MemoryUnmanaged > dView4_unmanaged;
-  typedef typename dView0::host_mirror_space host;
+  enum { N0 = 1000, N1 = 3, N2 = 5, N3 = 7 };
 
-  typedef Kokkos::View< T, device, Kokkos::MemoryTraits< Kokkos::Atomic > > aView0;
-  typedef Kokkos::View< T*, device, Kokkos::MemoryTraits< Kokkos::Atomic > > aView1;
-  typedef Kokkos::View< T*[N1], device, Kokkos::MemoryTraits< Kokkos::Atomic > > aView2;
-  typedef Kokkos::View< T*[N1][N2], device, Kokkos::MemoryTraits< Kokkos::Atomic > > aView3;
-  typedef Kokkos::View< T*[N1][N2][N3], device, Kokkos::MemoryTraits< Kokkos::Atomic > > aView4;
-  typedef Kokkos::View< const T*[N1][N2][N3], device, Kokkos::MemoryTraits< Kokkos::Atomic > > const_aView4;
+  typedef Kokkos::View<T, device> dView0;
+  typedef Kokkos::View<T*, device> dView1;
+  typedef Kokkos::View<T * [N1], device> dView2;
+  typedef Kokkos::View<T * [N1][N2], device> dView3;
+  typedef Kokkos::View<T * [N1][N2][N3], device> dView4;
+  typedef Kokkos::View<const T * [N1][N2][N3], device> const_dView4;
+  typedef Kokkos::View<T****, device, Kokkos::MemoryUnmanaged> dView4_unmanaged;
+  typedef typename dView0::host_mirror_space host;
 
-  typedef Kokkos::View< T****, device, Kokkos::MemoryTraits< Kokkos::Unmanaged | Kokkos::Atomic > > aView4_unmanaged;
+  typedef Kokkos::View<T, device, Kokkos::MemoryTraits<Kokkos::Atomic> > aView0;
+  typedef Kokkos::View<T*, device, Kokkos::MemoryTraits<Kokkos::Atomic> >
+      aView1;
+  typedef Kokkos::View<T * [N1], device, Kokkos::MemoryTraits<Kokkos::Atomic> >
+      aView2;
+  typedef Kokkos::View<T * [N1][N2], device,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      aView3;
+  typedef Kokkos::View<T * [N1][N2][N3], device,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      aView4;
+  typedef Kokkos::View<const T * [N1][N2][N3], device,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      const_aView4;
+
+  typedef Kokkos::View<
+      T****, device, Kokkos::MemoryTraits<Kokkos::Unmanaged | Kokkos::Atomic> >
+      aView4_unmanaged;
 
   typedef typename aView0::host_mirror_space host_atomic;
 
-  TestAtomicViewAPI()
-  {
-    TestViewOperator_LeftAndRight< int[2], device >::testit();
+  TestAtomicViewAPI() {
+    TestViewOperator_LeftAndRight<int[2], device>::testit();
     run_test_rank0();
     run_test_rank4();
     run_test_const();
   }
 
-  static void run_test_rank0()
-  {
+  static void run_test_rank0() {
     dView0 dx, dy;
     aView0 ax, ay, az;
 
-    dx = dView0( "dx" );
-    dy = dView0( "dy" );
-    ASSERT_EQ( dx.use_count(), size_t( 1 ) );
-    ASSERT_EQ( dy.use_count(), size_t( 1 ) );
+    dx = dView0("dx");
+    dy = dView0("dy");
+    ASSERT_EQ(dx.use_count(), size_t(1));
+    ASSERT_EQ(dy.use_count(), size_t(1));
 
     ax = dx;
     ay = dy;
-    ASSERT_EQ( dx.use_count(), size_t( 2 ) );
-    ASSERT_EQ( dy.use_count(), size_t( 2 ) );
-    ASSERT_EQ( dx.use_count(), ax.use_count() );
+    ASSERT_EQ(dx.use_count(), size_t(2));
+    ASSERT_EQ(dy.use_count(), size_t(2));
+    ASSERT_EQ(dx.use_count(), ax.use_count());
 
     az = ax;
-    ASSERT_EQ( dx.use_count(), size_t( 3 ) );
-    ASSERT_EQ( ax.use_count(), size_t( 3 ) );
-    ASSERT_EQ( az.use_count(), size_t( 3 ) );
-    ASSERT_EQ( az.use_count(), ax.use_count() );
+    ASSERT_EQ(dx.use_count(), size_t(3));
+    ASSERT_EQ(ax.use_count(), size_t(3));
+    ASSERT_EQ(az.use_count(), size_t(3));
+    ASSERT_EQ(az.use_count(), ax.use_count());
   }
 
-  static void run_test_rank4()
-  {
+  static void run_test_rank4() {
     dView4 dx, dy;
     aView4 ax, ay, az;
 
-    dx = dView4( "dx", N0 );
-    dy = dView4( "dy", N0 );
-    ASSERT_EQ( dx.use_count(), size_t( 1 ) );
-    ASSERT_EQ( dy.use_count(), size_t( 1 ) );
+    dx = dView4("dx", N0);
+    dy = dView4("dy", N0);
+    ASSERT_EQ(dx.use_count(), size_t(1));
+    ASSERT_EQ(dy.use_count(), size_t(1));
 
     ax = dx;
     ay = dy;
-    ASSERT_EQ( dx.use_count(), size_t( 2 ) );
-    ASSERT_EQ( dy.use_count(), size_t( 2 ) );
-    ASSERT_EQ( dx.use_count(), ax.use_count() );
+    ASSERT_EQ(dx.use_count(), size_t(2));
+    ASSERT_EQ(dy.use_count(), size_t(2));
+    ASSERT_EQ(dx.use_count(), ax.use_count());
 
     dView4_unmanaged unmanaged_dx = dx;
-    ASSERT_EQ( dx.use_count(), size_t( 2 ) );
+    ASSERT_EQ(dx.use_count(), size_t(2));
 
     az = ax;
-    ASSERT_EQ( dx.use_count(), size_t( 3 ) );
-    ASSERT_EQ( ax.use_count(), size_t( 3 ) );
-    ASSERT_EQ( az.use_count(), size_t( 3 ) );
-    ASSERT_EQ( az.use_count(), ax.use_count() );
+    ASSERT_EQ(dx.use_count(), size_t(3));
+    ASSERT_EQ(ax.use_count(), size_t(3));
+    ASSERT_EQ(az.use_count(), size_t(3));
+    ASSERT_EQ(az.use_count(), ax.use_count());
 
     aView4_unmanaged unmanaged_ax = ax;
-    ASSERT_EQ( ax.use_count(), size_t( 3 ) );
+    ASSERT_EQ(ax.use_count(), size_t(3));
 
-    aView4_unmanaged unmanaged_ax_from_ptr_dx =
-      aView4_unmanaged( dx.data(), dx.extent(0), dx.extent(1), dx.extent(2), dx.extent(3) );
-    ASSERT_EQ( ax.use_count(), size_t( 3 ) );
+    aView4_unmanaged unmanaged_ax_from_ptr_dx = aView4_unmanaged(
+        dx.data(), dx.extent(0), dx.extent(1), dx.extent(2), dx.extent(3));
+    ASSERT_EQ(ax.use_count(), size_t(3));
 
     const_aView4 const_ax = ax;
-    ASSERT_EQ( ax.use_count(), size_t( 4 ) );
-    ASSERT_EQ( const_ax.use_count(), ax.use_count() );
-
-    ASSERT_FALSE( ax.data() == 0 );
-    ASSERT_FALSE( const_ax.data() == 0 ); // referenceable ptr
-    ASSERT_FALSE( unmanaged_ax.data() == 0 );
-    ASSERT_FALSE( unmanaged_ax_from_ptr_dx.data() == 0 );
-    ASSERT_FALSE( ay.data() == 0 );
-//    ASSERT_NE( ax, ay );
-//    Above test results in following runtime error from gtest:
-//    Expected: (ax) != (ay), actual: 32-byte object <30-01 D0-A0 D8-7F 00-00 00-31 44-0C 01-00 00-00 E8-03 00-00 00-00 00-00 69-00 00-00 00-00 00-00> vs 32-byte object <80-01 D0-A0 D8-7F 00-00 00-A1 4A-0C 01-00 00-00 E8-03 00-00 00-00 00-00 69-00 00-00 00-00 00-00>
-
-    ASSERT_EQ( ax.extent(0), unsigned( N0 ) );
-    ASSERT_EQ( ax.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( ax.extent(2), unsigned( N2 ) );
-    ASSERT_EQ( ax.extent(3), unsigned( N3 ) );
-
-    ASSERT_EQ( ay.extent(0), unsigned( N0 ) );
-    ASSERT_EQ( ay.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( ay.extent(2), unsigned( N2 ) );
-    ASSERT_EQ( ay.extent(3), unsigned( N3 ) );
-
-    ASSERT_EQ( unmanaged_ax_from_ptr_dx.span(), unsigned( N0 ) * unsigned( N1 ) * unsigned( N2 ) * unsigned( N3 ) );
+    ASSERT_EQ(ax.use_count(), size_t(4));
+    ASSERT_EQ(const_ax.use_count(), ax.use_count());
+
+    ASSERT_FALSE(ax.data() == 0);
+    ASSERT_FALSE(const_ax.data() == 0);  // referenceable ptr
+    ASSERT_FALSE(unmanaged_ax.data() == 0);
+    ASSERT_FALSE(unmanaged_ax_from_ptr_dx.data() == 0);
+    ASSERT_FALSE(ay.data() == 0);
+    //    ASSERT_NE( ax, ay );
+    //    Above test results in following runtime error from gtest:
+    //    Expected: (ax) != (ay), actual: 32-byte object <30-01 D0-A0 D8-7F
+    //    00-00 00-31 44-0C 01-00 00-00 E8-03 00-00 00-00 00-00 69-00 00-00
+    //    00-00 00-00> vs 32-byte object <80-01 D0-A0 D8-7F 00-00 00-A1 4A-0C
+    //    01-00 00-00 E8-03 00-00 00-00 00-00 69-00 00-00 00-00 00-00>
+
+    ASSERT_EQ(ax.extent(0), unsigned(N0));
+    ASSERT_EQ(ax.extent(1), unsigned(N1));
+    ASSERT_EQ(ax.extent(2), unsigned(N2));
+    ASSERT_EQ(ax.extent(3), unsigned(N3));
+
+    ASSERT_EQ(ay.extent(0), unsigned(N0));
+    ASSERT_EQ(ay.extent(1), unsigned(N1));
+    ASSERT_EQ(ay.extent(2), unsigned(N2));
+    ASSERT_EQ(ay.extent(3), unsigned(N3));
+
+    ASSERT_EQ(unmanaged_ax_from_ptr_dx.span(),
+              unsigned(N0) * unsigned(N1) * unsigned(N2) * unsigned(N3));
   }
 
   typedef T DataType[2];
 
-  static void
-  check_auto_conversion_to_const(
-     const Kokkos::View< const DataType, device, Kokkos::MemoryTraits<Kokkos::Atomic> > & arg_const,
-     const Kokkos::View< const DataType, device, Kokkos::MemoryTraits<Kokkos::Atomic> > & arg )
-  {
-    ASSERT_TRUE( arg_const == arg );
+  static void check_auto_conversion_to_const(
+      const Kokkos::View<const DataType, device,
+                         Kokkos::MemoryTraits<Kokkos::Atomic> >& arg_const,
+      const Kokkos::View<const DataType, device,
+                         Kokkos::MemoryTraits<Kokkos::Atomic> >& arg) {
+    ASSERT_TRUE(arg_const == arg);
   }
 
-  static void run_test_const()
-  {
-    typedef Kokkos::View< DataType, device, Kokkos::MemoryTraits<Kokkos::Atomic> > typeX;
-    typedef Kokkos::View< const DataType, device, Kokkos::MemoryTraits<Kokkos::Atomic> > const_typeX;
+  static void run_test_const() {
+    typedef Kokkos::View<DataType, device,
+                         Kokkos::MemoryTraits<Kokkos::Atomic> >
+        typeX;
+    typedef Kokkos::View<const DataType, device,
+                         Kokkos::MemoryTraits<Kokkos::Atomic> >
+        const_typeX;
 
-    typeX x( "X" );
+    typeX x("X");
     const_typeX xc = x;
 
-    //ASSERT_TRUE( xc == x ); // const xc is referenceable, non-const x is not
-    //ASSERT_TRUE( x == xc );
+    // ASSERT_TRUE( xc == x ); // const xc is referenceable, non-const x is not
+    // ASSERT_TRUE( x == xc );
 
-    check_auto_conversion_to_const( x, xc );
+    check_auto_conversion_to_const(x, xc);
   }
 };
 
@@ -291,72 +313,65 @@ public:
 //-----------initialization functors-----------------
 //---------------------------------------------------
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct InitFunctor_Seq {
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   const long length;
 
-  InitFunctor_Seq( view_type & input_, const long length_ )
-    : input( input_ )
-    , length( length_ )
-  {}
+  InitFunctor_Seq(view_type& input_, const long length_)
+      : input(input_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      input( i ) = (T) i;
+  void operator()(const long i) const {
+    if (i < length) {
+      input(i) = (T)i;
     }
   }
 };
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct InitFunctor_ModTimes {
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   const long length;
   const long remainder;
 
-  InitFunctor_ModTimes( view_type & input_, const long length_, const long remainder_ )
-    : input( input_ )
-    , length( length_ )
-    , remainder( remainder_ )
-  {}
+  InitFunctor_ModTimes(view_type& input_, const long length_,
+                       const long remainder_)
+      : input(input_), length(length_), remainder(remainder_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % ( remainder + 1 ) == remainder ) {
-        input( i ) = (T) 2;
-      }
-      else {
-        input( i ) = (T) 1;
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % (remainder + 1) == remainder) {
+        input(i) = (T)2;
+      } else {
+        input(i) = (T)1;
       }
     }
   }
 };
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct InitFunctor_ModShift {
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   const long length;
   const long remainder;
 
-  InitFunctor_ModShift( view_type & input_, const long length_, const long remainder_ )
-    : input( input_ )
-    , length( length_ )
-    , remainder( remainder_ )
-  {}
+  InitFunctor_ModShift(view_type& input_, const long length_,
+                       const long remainder_)
+      : input(input_), length(length_), remainder(remainder_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % ( remainder + 1 ) == remainder ) {
-        input( i ) = 1;
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % (remainder + 1) == remainder) {
+        input(i) = 1;
       }
     }
   }
@@ -366,96 +381,94 @@ struct InitFunctor_ModShift {
 //-----------atomic view plus-equal------------------
 //---------------------------------------------------
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct PlusEqualAtomicViewFunctor {
-  typedef Kokkos::View< T*, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   atomic_view_type even_odd_result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator
-  PlusEqualAtomicViewFunctor( const view_type & input_, view_type & even_odd_result_, const long length_ )
-    : input( input_ )
-    , even_odd_result( even_odd_result_ )
-    , length( length_ )
-  {}
+  PlusEqualAtomicViewFunctor(const view_type& input_,
+                             view_type& even_odd_result_, const long length_)
+      : input(input_), even_odd_result(even_odd_result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % 2 == 0 ) {
-        even_odd_result( 0 ) += input( i );
-      }
-      else {
-        even_odd_result( 1 ) += input( i );
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % 2 == 0) {
+        even_odd_result(0) += input(i);
+      } else {
+        even_odd_result(1) += input(i);
       }
     }
   }
 };
 
-template< class T, class execution_space >
-T PlusEqualAtomicView( const long input_length ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
+template <class T, class execution_space>
+T PlusEqualAtomicView(const long input_length) {
+  typedef Kokkos::View<T*, execution_space> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  view_type result_view( "result_view", 2 );
+  view_type input("input_view", length);
+  view_type result_view("result_view", 2);
 
-  InitFunctor_Seq< T, execution_space > init_f( input, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_Seq<T, execution_space> init_f(input, length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  PlusEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy<execution_space>( 0, length ), functor );
+  PlusEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                         length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 0 ) + h_result_view( 1 ) );
+  return (T)(h_result_view(0) + h_result_view(1));
 }
 
-template< class T >
-T PlusEqualAtomicViewCheck( const long input_length ) {
+template <class T>
+T PlusEqualAtomicViewCheck(const long input_length) {
   const long N = input_length;
   T result[2];
 
-  if ( N % 2 == 0 ) {
-    const long half_sum_end = ( N / 2 ) - 1;
+  if (N % 2 == 0) {
+    const long half_sum_end = (N / 2) - 1;
     const long full_sum_end = N - 1;
-    result[0] = half_sum_end * ( half_sum_end + 1 ) / 2; // Even sum.
-    result[1] = ( full_sum_end * ( full_sum_end + 1 ) / 2 ) - result[0]; // Odd sum.
-  }
-  else {
-    const long half_sum_end = (T) ( N / 2 );
+    result[0] = half_sum_end * (half_sum_end + 1) / 2;  // Even sum.
+    result[1] =
+        (full_sum_end * (full_sum_end + 1) / 2) - result[0];  // Odd sum.
+  } else {
+    const long half_sum_end = (T)(N / 2);
     const long full_sum_end = N - 2;
-    result[0] = half_sum_end * ( half_sum_end - 1 ) / 2; // Even sum.
-    result[1] = ( full_sum_end * ( full_sum_end - 1 ) / 2 ) - result[0]; // Odd sum.
+    result[0] = half_sum_end * (half_sum_end - 1) / 2;  // Even sum.
+    result[1] =
+        (full_sum_end * (full_sum_end - 1) / 2) - result[0];  // Odd sum.
   }
 
-  return (T) ( result[0] + result[1] );
+  return (T)(result[0] + result[1]);
 }
 
-template< class T, class DeviceType >
-bool PlusEqualAtomicViewTest( long input_length )
-{
-  T res       = PlusEqualAtomicView< T, DeviceType >( input_length );
-  T resSerial = PlusEqualAtomicViewCheck< T >( input_length );
+template <class T, class DeviceType>
+bool PlusEqualAtomicViewTest(long input_length) {
+  T res       = PlusEqualAtomicView<T, DeviceType>(input_length);
+  T resSerial = PlusEqualAtomicViewCheck<T>(input_length);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = PlusEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -465,96 +478,94 @@ bool PlusEqualAtomicViewTest( long input_length )
 //-----------atomic view minus-equal-----------------
 //---------------------------------------------------
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct MinusEqualAtomicViewFunctor {
-  typedef Kokkos::View< T*, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   atomic_view_type even_odd_result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator.
-  MinusEqualAtomicViewFunctor( const view_type & input_, view_type & even_odd_result_, const long length_ )
-    : input( input_ )
-    , even_odd_result( even_odd_result_ )
-    , length( length_ )
-  {}
+  MinusEqualAtomicViewFunctor(const view_type& input_,
+                              view_type& even_odd_result_, const long length_)
+      : input(input_), even_odd_result(even_odd_result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % 2 == 0 ) {
-        even_odd_result( 0 ) -= input( i );
-      }
-      else {
-        even_odd_result( 1 ) -= input( i );
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % 2 == 0) {
+        even_odd_result(0) -= input(i);
+      } else {
+        even_odd_result(1) -= input(i);
       }
     }
   }
 };
 
-template< class T, class execution_space >
-T MinusEqualAtomicView( const long input_length ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
+template <class T, class execution_space>
+T MinusEqualAtomicView(const long input_length) {
+  typedef Kokkos::View<T*, execution_space> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  view_type result_view( "result_view", 2 );
+  view_type input("input_view", length);
+  view_type result_view("result_view", 2);
 
-  InitFunctor_Seq< T, execution_space > init_f( input, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_Seq<T, execution_space> init_f(input, length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  MinusEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  MinusEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                          length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 0 ) + h_result_view( 1 ) );
+  return (T)(h_result_view(0) + h_result_view(1));
 }
 
-template< class T >
-T MinusEqualAtomicViewCheck( const long input_length ) {
+template <class T>
+T MinusEqualAtomicViewCheck(const long input_length) {
   const long N = input_length;
   T result[2];
 
-  if ( N % 2 == 0 ) {
-    const long half_sum_end = ( N / 2 ) - 1;
+  if (N % 2 == 0) {
+    const long half_sum_end = (N / 2) - 1;
     const long full_sum_end = N - 1;
-    result[0] = -1 * ( half_sum_end * ( half_sum_end + 1 ) / 2 ); // Even sum.
-    result[1] = -1 * ( ( full_sum_end * ( full_sum_end + 1 ) / 2 ) + result[0] ); // Odd sum.
-  }
-  else {
-    const long half_sum_end = (long) ( N / 2 );
+    result[0] = -1 * (half_sum_end * (half_sum_end + 1) / 2);  // Even sum.
+    result[1] =
+        -1 * ((full_sum_end * (full_sum_end + 1) / 2) + result[0]);  // Odd sum.
+  } else {
+    const long half_sum_end = (long)(N / 2);
     const long full_sum_end = N - 2;
-    result[0] = -1 * ( half_sum_end * ( half_sum_end - 1 ) / 2 ); // Even sum.
-    result[1] = -1 * ( ( full_sum_end * ( full_sum_end - 1 ) / 2 ) + result[0] ); // Odd sum.
+    result[0] = -1 * (half_sum_end * (half_sum_end - 1) / 2);  // Even sum.
+    result[1] =
+        -1 * ((full_sum_end * (full_sum_end - 1) / 2) + result[0]);  // Odd sum.
   }
 
-  return ( result[0] + result[1] );
+  return (result[0] + result[1]);
 }
 
-template< class T, class DeviceType >
-bool MinusEqualAtomicViewTest( long input_length )
-{
-  T res       = MinusEqualAtomicView< T, DeviceType >( input_length );
-  T resSerial = MinusEqualAtomicViewCheck< T >( input_length );
+template <class T, class DeviceType>
+bool MinusEqualAtomicViewTest(long input_length) {
+  T res       = MinusEqualAtomicView<T, DeviceType>(input_length);
+  T resSerial = MinusEqualAtomicViewCheck<T>(input_length);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = MinusEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -564,90 +575,87 @@ bool MinusEqualAtomicViewTest( long input_length )
 //-----------atomic view times-equal-----------------
 //---------------------------------------------------
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct TimesEqualAtomicViewFunctor {
-  typedef Kokkos::View< T*, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   atomic_view_type result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator
-  TimesEqualAtomicViewFunctor( const view_type & input_, view_type & result_, const long length_ )
-    : input( input_ )
-    , result( result_ )
-    , length( length_ )
-  {}
+  TimesEqualAtomicViewFunctor(const view_type& input_, view_type& result_,
+                              const long length_)
+      : input(input_), result(result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length && i > 0 ) {
-      result( 0 ) *= (double) input( i );
+  void operator()(const long i) const {
+    if (i < length && i > 0) {
+      result(0) *= (double)input(i);
     }
   }
 };
 
-template< class T, class execution_space >
-T TimesEqualAtomicView( const long input_length, const long remainder ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
+template <class T, class execution_space>
+T TimesEqualAtomicView(const long input_length, const long remainder) {
+  typedef Kokkos::View<T*, execution_space> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  view_type result_view( "result_view", 1 );
-  deep_copy( result_view, 1.0 );
+  view_type input("input_view", length);
+  view_type result_view("result_view", 1);
+  deep_copy(result_view, 1.0);
 
-  InitFunctor_ModTimes< T, execution_space > init_f( input, length, remainder );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_ModTimes<T, execution_space> init_f(input, length, remainder);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  TimesEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  TimesEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                          length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 0 ) );
+  return (T)(h_result_view(0));
 }
 
-template< class T >
-T TimesEqualAtomicViewCheck( const long input_length, const long remainder ) {
+template <class T>
+T TimesEqualAtomicViewCheck(const long input_length, const long remainder) {
   // Analytical result.
   const long N = input_length;
-  T result = 1.0;
+  T result     = 1.0;
 
-  for ( long i = 2; i < N; ++i ) {
-    if ( i % ( remainder + 1 ) == remainder ) {
+  for (long i = 2; i < N; ++i) {
+    if (i % (remainder + 1) == remainder) {
       result *= 2.0;
-    }
-    else {
+    } else {
       result *= 1.0;
     }
   }
 
-  return (T) result;
+  return (T)result;
 }
 
-template< class T, class DeviceType>
-bool TimesEqualAtomicViewTest( const long input_length )
-{
+template <class T, class DeviceType>
+bool TimesEqualAtomicViewTest(const long input_length) {
   const long remainder = 23;
-  T res       = TimesEqualAtomicView< T, DeviceType >( input_length, remainder );
-  T resSerial = TimesEqualAtomicViewCheck< T >( input_length, remainder );
+  T res       = TimesEqualAtomicView<T, DeviceType>(input_length, remainder);
+  T resSerial = TimesEqualAtomicViewCheck<T>(input_length, remainder);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = TimesEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -657,91 +665,88 @@ bool TimesEqualAtomicViewTest( const long input_length )
 //------------atomic view div-equal------------------
 //---------------------------------------------------
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct DivEqualAtomicViewFunctor {
-  typedef Kokkos::View< T, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T, execution_space > scalar_view_type;
+  typedef Kokkos::View<T, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T, execution_space> scalar_view_type;
 
   view_type input;
   atomic_view_type result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator.
-  DivEqualAtomicViewFunctor( const view_type & input_, scalar_view_type & result_, const long length_ )
-    : input( input_ )
-    , result( result_ )
-    , length( length_ )
-  {}
+  DivEqualAtomicViewFunctor(const view_type& input_, scalar_view_type& result_,
+                            const long length_)
+      : input(input_), result(result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length && i > 0 ) {
-      result() /= (double) ( input( i ) );
+  void operator()(const long i) const {
+    if (i < length && i > 0) {
+      result() /= (double)(input(i));
     }
   }
 };
 
-template< class T, class execution_space >
-T DivEqualAtomicView( const long input_length, const long remainder ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T, execution_space > scalar_view_type;
+template <class T, class execution_space>
+T DivEqualAtomicView(const long input_length, const long remainder) {
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T, execution_space> scalar_view_type;
   typedef typename scalar_view_type::HostMirror host_scalar_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  scalar_view_type result_view( "result_view" );
-  Kokkos::deep_copy( result_view, 12121212121 );
+  view_type input("input_view", length);
+  scalar_view_type result_view("result_view");
+  Kokkos::deep_copy(result_view, 12121212121);
 
-  InitFunctor_ModTimes< T, execution_space > init_f( input, length, remainder );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_ModTimes<T, execution_space> init_f(input, length, remainder);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  DivEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  DivEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                        length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_scalar_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_scalar_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view() );
+  return (T)(h_result_view());
 }
 
-template< class T >
-T DivEqualAtomicViewCheck( const long input_length, const long remainder ) {
+template <class T>
+T DivEqualAtomicViewCheck(const long input_length, const long remainder) {
   const long N = input_length;
-  T result = 12121212121.0;
-  for ( long i = 2; i < N; ++i ) {
-    if ( i % ( remainder + 1 ) == remainder ) {
+  T result     = 12121212121.0;
+  for (long i = 2; i < N; ++i) {
+    if (i % (remainder + 1) == remainder) {
       result /= 1.0;
-    }
-    else {
+    } else {
       result /= 2.0;
     }
   }
 
-  return (T) result;
+  return (T)result;
 }
 
-template< class T, class DeviceType >
-bool DivEqualAtomicViewTest( const long input_length )
-{
+template <class T, class DeviceType>
+bool DivEqualAtomicViewTest(const long input_length) {
   const long remainder = 23;
 
-  T res       = DivEqualAtomicView< T, DeviceType >( input_length, remainder );
-  T resSerial = DivEqualAtomicViewCheck< T >( input_length, remainder );
+  T res       = DivEqualAtomicView<T, DeviceType>(input_length, remainder);
+  T resSerial = DivEqualAtomicViewCheck<T>(input_length, remainder);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = DivEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -751,93 +756,92 @@ bool DivEqualAtomicViewTest( const long input_length )
 //------------atomic view mod-equal------------------
 //---------------------------------------------------
 
-template< class T, class execution_space >
+template <class T, class execution_space>
 struct ModEqualAtomicViewFunctor {
-  typedef Kokkos::View< T, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T, execution_space > scalar_view_type;
+  typedef Kokkos::View<T, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T, execution_space> scalar_view_type;
 
   view_type input;
   atomic_view_type result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator.
-  ModEqualAtomicViewFunctor( const view_type & input_, scalar_view_type & result_, const long length_ )
-    : input( input_ )
-    , result( result_ )
-    , length( length_ )
-  {}
+  ModEqualAtomicViewFunctor(const view_type& input_, scalar_view_type& result_,
+                            const long length_)
+      : input(input_), result(result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length && i > 0 ) {
-      result() %= (double) ( input( i ) );
+  void operator()(const long i) const {
+    if (i < length && i > 0) {
+      result() %= (double)(input(i));
     }
   }
 };
 
-template< class T, class execution_space >
-T ModEqualAtomicView( const long input_length, const long remainder ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T, execution_space > scalar_view_type;
+template <class T, class execution_space>
+T ModEqualAtomicView(const long input_length, const long remainder) {
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T, execution_space> scalar_view_type;
   typedef typename scalar_view_type::HostMirror host_scalar_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  scalar_view_type result_view( "result_view" );
-  Kokkos::deep_copy( result_view, 12121212121 );
+  view_type input("input_view", length);
+  scalar_view_type result_view("result_view");
+  Kokkos::deep_copy(result_view, 12121212121);
 
-  InitFunctor_ModTimes< T, execution_space > init_f( input, length, remainder );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_ModTimes<T, execution_space> init_f(input, length, remainder);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  ModEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  ModEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                        length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_scalar_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_scalar_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view() );
+  return (T)(h_result_view());
 }
 
-template< class T >
-T ModEqualAtomicViewCheck( const long input_length, const long remainder ) {
+template <class T>
+T ModEqualAtomicViewCheck(const long input_length, const long remainder) {
   const long N = input_length;
-  T result = 12121212121;
-  for ( long i = 2; i < N; ++i ) {
-    if ( i % ( remainder + 1 ) == remainder ) {
+  T result     = 12121212121;
+  for (long i = 2; i < N; ++i) {
+    if (i % (remainder + 1) == remainder) {
       result %= 1;
-    }
-    else {
+    } else {
       result %= 2;
     }
   }
 
-  return (T) result;
+  return (T)result;
 }
 
-template< class T, class DeviceType >
-bool ModEqualAtomicViewTest( const long input_length )
-{
-  static_assert( std::is_integral< T >::value, "ModEqualAtomicView Error: Type must be integral type for this unit test" );
+template <class T, class DeviceType>
+bool ModEqualAtomicViewTest(const long input_length) {
+  static_assert(std::is_integral<T>::value,
+                "ModEqualAtomicView Error: Type must be integral type for this "
+                "unit test");
 
   const long remainder = 23;
 
-  T res       = ModEqualAtomicView< T, DeviceType >( input_length, remainder );
-  T resSerial = ModEqualAtomicViewCheck< T >( input_length, remainder );
+  T res       = ModEqualAtomicView<T, DeviceType>(input_length, remainder);
+  T resSerial = ModEqualAtomicViewCheck<T>(input_length, remainder);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = ModEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -847,11 +851,13 @@ bool ModEqualAtomicViewTest( const long input_length )
 //------------atomic view rs-equal------------------
 //---------------------------------------------------
 
-template< class T, class execution_space >
+template <class T, class execution_space>
 struct RSEqualAtomicViewFunctor {
-  typedef Kokkos::View< T****, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T****, execution_space > result_view_type;
+  typedef Kokkos::View<T****, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T****, execution_space> result_view_type;
 
   const view_type input;
   atomic_view_type result;
@@ -859,120 +865,111 @@ struct RSEqualAtomicViewFunctor {
   const long value;
 
   // Wrap the result view in an atomic view, use this for operator.
-  RSEqualAtomicViewFunctor( const view_type & input_, result_view_type & result_, const long & length_, const long & value_ )
-    : input( input_ )
-    , result( result_ )
-    , length( length_ )
-    , value( value_ )
-  {}
+  RSEqualAtomicViewFunctor(const view_type& input_, result_view_type& result_,
+                           const long& length_, const long& value_)
+      : input(input_), result(result_), length(length_), value(value_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % 4 == 0 ) {
-        result( 1, 0, 0, 0 ) >>= input( i );
-      }
-      else if ( i % 4 == 1 ) {
-        result( 0, 1, 0, 0 ) >>= input( i );
-      }
-      else if ( i % 4 == 2 ) {
-        result( 0, 0, 1, 0 ) >>= input( i );
-      }
-      else if ( i % 4 == 3 ) {
-        result( 0, 0, 0, 1 ) >>= input( i );
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % 4 == 0) {
+        result(1, 0, 0, 0) >>= input(i);
+      } else if (i % 4 == 1) {
+        result(0, 1, 0, 0) >>= input(i);
+      } else if (i % 4 == 2) {
+        result(0, 0, 1, 0) >>= input(i);
+      } else if (i % 4 == 3) {
+        result(0, 0, 0, 1) >>= input(i);
       }
     }
   }
 };
 
-template< class T, class execution_space >
-T RSEqualAtomicView( const long input_length, const long value, const long remainder ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T****, execution_space > result_view_type;
+template <class T, class execution_space>
+T RSEqualAtomicView(const long input_length, const long value,
+                    const long remainder) {
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T****, execution_space> result_view_type;
   typedef typename result_view_type::HostMirror host_scalar_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  result_view_type result_view( "result_view", 2, 2, 2, 2 );
-  host_scalar_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  h_result_view( 1, 0, 0, 0 ) = value;
-  h_result_view( 0, 1, 0, 0 ) = value;
-  h_result_view( 0, 0, 1, 0 ) = value;
-  h_result_view( 0, 0, 0, 1 ) = value;
-  Kokkos::deep_copy( result_view, h_result_view );
-
-  InitFunctor_ModShift< T, execution_space > init_f( input, length, remainder );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
-
-  RSEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length, value );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  view_type input("input_view", length);
+  result_view_type result_view("result_view", 2, 2, 2, 2);
+  host_scalar_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  h_result_view(1, 0, 0, 0)           = value;
+  h_result_view(0, 1, 0, 0)           = value;
+  h_result_view(0, 0, 1, 0)           = value;
+  h_result_view(0, 0, 0, 1)           = value;
+  Kokkos::deep_copy(result_view, h_result_view);
+
+  InitFunctor_ModShift<T, execution_space> init_f(input, length, remainder);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
+
+  RSEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                       length, value);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  Kokkos::deep_copy( h_result_view, result_view );
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 1, 0, 0, 0 ) );
+  return (T)(h_result_view(1, 0, 0, 0));
 }
 
-template< class T >
-T RSEqualAtomicViewCheck( const long input_length, const long value, const long remainder ) {
+template <class T>
+T RSEqualAtomicViewCheck(const long input_length, const long value,
+                         const long remainder) {
   T result[4];
   result[0] = value;
   result[1] = value;
   result[2] = value;
   result[3] = value;
 
-  T * input = new T[input_length];
-  for ( long i = 0; i < input_length; ++i ) {
-    if ( i % ( remainder + 1 ) == remainder ) {
+  T* input = new T[input_length];
+  for (long i = 0; i < input_length; ++i) {
+    if (i % (remainder + 1) == remainder) {
       input[i] = 1;
-    }
-    else {
+    } else {
       input[i] = 0;
     }
   }
 
-  for ( long i = 0; i < input_length; ++i ) {
-    if ( i % 4 == 0 ) {
+  for (long i = 0; i < input_length; ++i) {
+    if (i % 4 == 0) {
       result[0] >>= input[i];
-    }
-    else if ( i % 4 == 1 ) {
+    } else if (i % 4 == 1) {
       result[1] >>= input[i];
-    }
-    else if ( i % 4 == 2 ) {
+    } else if (i % 4 == 2) {
       result[2] >>= input[i];
-    }
-    else if ( i % 4 == 3 ) {
+    } else if (i % 4 == 3) {
       result[3] >>= input[i];
     }
   }
 
-  delete [] input;
+  delete[] input;
 
-  return (T) result[0];
+  return (T)result[0];
 }
 
-template< class T, class DeviceType >
-bool RSEqualAtomicViewTest( const long input_length )
-{
-  static_assert( std::is_integral< T >::value, "RSEqualAtomicViewTest: Must be integral type for test" );
+template <class T, class DeviceType>
+bool RSEqualAtomicViewTest(const long input_length) {
+  static_assert(std::is_integral<T>::value,
+                "RSEqualAtomicViewTest: Must be integral type for test");
 
-  const long remainder = 61042; //prime - 1
-  const long value = 1073741825; //  2^30+1
-  T res       = RSEqualAtomicView< T, DeviceType >( input_length, value, remainder );
-  T resSerial = RSEqualAtomicViewCheck< T >( input_length, value, remainder );
+  const long remainder = 61042;       // prime - 1
+  const long value     = 1073741825;  //  2^30+1
+  T res = RSEqualAtomicView<T, DeviceType>(input_length, value, remainder);
+  T resSerial = RSEqualAtomicViewCheck<T>(input_length, value, remainder);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = RSEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -982,11 +979,13 @@ bool RSEqualAtomicViewTest( const long input_length )
 //------------atomic view ls-equal------------------
 //---------------------------------------------------
 
-template<class T, class execution_space >
+template <class T, class execution_space>
 struct LSEqualAtomicViewFunctor {
-  typedef Kokkos::View< T****, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T****, execution_space > result_view_type;
+  typedef Kokkos::View<T****, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T****, execution_space> result_view_type;
 
   view_type input;
   atomic_view_type result;
@@ -994,120 +993,111 @@ struct LSEqualAtomicViewFunctor {
   const long value;
 
   // Wrap the result view in an atomic view, use this for operator.
-  LSEqualAtomicViewFunctor( const view_type & input_, result_view_type & result_, const long & length_, const long & value_ )
-    : input( input_ )
-    , result( result_ )
-    , length( length_ )
-    , value( value_ )
-  {}
+  LSEqualAtomicViewFunctor(const view_type& input_, result_view_type& result_,
+                           const long& length_, const long& value_)
+      : input(input_), result(result_), length(length_), value(value_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % 4 == 0 ) {
-        result( 1, 0, 0, 0 ) <<= input( i );
-      }
-      else if ( i % 4 == 1 ) {
-        result( 0, 1, 0, 0 ) <<= input( i );
-      }
-      else if ( i % 4 == 2 ) {
-        result( 0, 0, 1, 0 ) <<= input( i );
-      }
-      else if ( i % 4 == 3 ) {
-        result( 0, 0, 0, 1 ) <<= input( i );
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % 4 == 0) {
+        result(1, 0, 0, 0) <<= input(i);
+      } else if (i % 4 == 1) {
+        result(0, 1, 0, 0) <<= input(i);
+      } else if (i % 4 == 2) {
+        result(0, 0, 1, 0) <<= input(i);
+      } else if (i % 4 == 3) {
+        result(0, 0, 0, 1) <<= input(i);
       }
     }
   }
 };
 
-template< class T, class execution_space >
-T LSEqualAtomicView( const long input_length, const long value, const long remainder ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
-  typedef Kokkos::View< T****, execution_space > result_view_type;
+template <class T, class execution_space>
+T LSEqualAtomicView(const long input_length, const long value,
+                    const long remainder) {
+  typedef Kokkos::View<T*, execution_space> view_type;
+  typedef Kokkos::View<T****, execution_space> result_view_type;
   typedef typename result_view_type::HostMirror host_scalar_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  result_view_type result_view( "result_view", 2, 2, 2, 2 );
-  host_scalar_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-    h_result_view( 1, 0, 0, 0 ) = value;
-    h_result_view( 0, 1, 0, 0 ) = value;
-    h_result_view( 0, 0, 1, 0 ) = value;
-    h_result_view( 0, 0, 0, 1 ) = value;
-  Kokkos::deep_copy( result_view, h_result_view );
-
-  InitFunctor_ModShift< T, execution_space > init_f( input, length, remainder );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
-
-  LSEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length, value );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  view_type input("input_view", length);
+  result_view_type result_view("result_view", 2, 2, 2, 2);
+  host_scalar_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  h_result_view(1, 0, 0, 0)           = value;
+  h_result_view(0, 1, 0, 0)           = value;
+  h_result_view(0, 0, 1, 0)           = value;
+  h_result_view(0, 0, 0, 1)           = value;
+  Kokkos::deep_copy(result_view, h_result_view);
+
+  InitFunctor_ModShift<T, execution_space> init_f(input, length, remainder);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
+
+  LSEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                       length, value);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  Kokkos::deep_copy( h_result_view, result_view );
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 1, 0, 0, 0 ) );
+  return (T)(h_result_view(1, 0, 0, 0));
 }
 
-template< class T >
-T LSEqualAtomicViewCheck( const long input_length, const long value, const long remainder ) {
+template <class T>
+T LSEqualAtomicViewCheck(const long input_length, const long value,
+                         const long remainder) {
   T result[4];
   result[0] = value;
   result[1] = value;
   result[2] = value;
   result[3] = value;
 
-  T * input = new T[input_length];
-  for ( long i = 0; i < input_length; ++i ) {
-    if ( i % ( remainder + 1 ) == remainder ) {
+  T* input = new T[input_length];
+  for (long i = 0; i < input_length; ++i) {
+    if (i % (remainder + 1) == remainder) {
       input[i] = 1;
-    }
-    else {
+    } else {
       input[i] = 0;
     }
   }
 
-  for ( long i = 0; i < input_length; ++i ) {
-    if ( i % 4 == 0 ) {
+  for (long i = 0; i < input_length; ++i) {
+    if (i % 4 == 0) {
       result[0] <<= input[i];
-    }
-    else if ( i % 4 == 1 ) {
+    } else if (i % 4 == 1) {
       result[1] <<= input[i];
-    }
-    else if ( i % 4 == 2 ) {
+    } else if (i % 4 == 2) {
       result[2] <<= input[i];
-    }
-    else if ( i % 4 == 3 ) {
+    } else if (i % 4 == 3) {
       result[3] <<= input[i];
     }
   }
 
-  delete [] input;
+  delete[] input;
 
-  return (T) result[0];
+  return (T)result[0];
 }
 
-template< class T, class DeviceType >
-bool LSEqualAtomicViewTest( const long input_length )
-{
-  static_assert( std::is_integral< T >::value, "LSEqualAtomicViewTest: Must be integral type for test" );
+template <class T, class DeviceType>
+bool LSEqualAtomicViewTest(const long input_length) {
+  static_assert(std::is_integral<T>::value,
+                "LSEqualAtomicViewTest: Must be integral type for test");
 
-  const long remainder = 61042; //prime - 1
-  const long value = 1; //  2^30+1
-  T res       = LSEqualAtomicView< T, DeviceType >( input_length, value, remainder );
-  T resSerial = LSEqualAtomicViewCheck< T >( input_length, value, remainder );
+  const long remainder = 61042;  // prime - 1
+  const long value     = 1;      //  2^30+1
+  T res = LSEqualAtomicView<T, DeviceType>(input_length, value, remainder);
+  T resSerial = LSEqualAtomicViewCheck<T>(input_length, value, remainder);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = RSEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -1117,94 +1107,91 @@ bool LSEqualAtomicViewTest( const long input_length )
 //-----------atomic view and-equal-----------------
 //---------------------------------------------------
 
-template< class T, class execution_space >
+template <class T, class execution_space>
 struct AndEqualAtomicViewFunctor {
-  typedef Kokkos::View< T*, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   atomic_view_type even_odd_result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator.
-  AndEqualAtomicViewFunctor( const view_type & input_, view_type & even_odd_result_, const long length_ )
-    : input( input_ )
-    , even_odd_result( even_odd_result_ )
-    , length( length_ )
-  {}
+  AndEqualAtomicViewFunctor(const view_type& input_,
+                            view_type& even_odd_result_, const long length_)
+      : input(input_), even_odd_result(even_odd_result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % 2 == 0 ) {
-        even_odd_result( 0 ) &= input( i );
-      }
-      else {
-        even_odd_result( 1 ) &= input( i );
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % 2 == 0) {
+        even_odd_result(0) &= input(i);
+      } else {
+        even_odd_result(1) &= input(i);
       }
     }
   }
 };
 
-template< class T, class execution_space >
-T AndEqualAtomicView( const long input_length ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
+template <class T, class execution_space>
+T AndEqualAtomicView(const long input_length) {
+  typedef Kokkos::View<T*, execution_space> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  view_type result_view( "result_view", 2 );
-  Kokkos::deep_copy( result_view, 1 );
+  view_type input("input_view", length);
+  view_type result_view("result_view", 2);
+  Kokkos::deep_copy(result_view, 1);
 
-  InitFunctor_Seq< T, execution_space > init_f( input, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_Seq<T, execution_space> init_f(input, length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  AndEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  AndEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                        length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 0 ) );
+  return (T)(h_result_view(0));
 }
 
-template< class T >
-T AndEqualAtomicViewCheck( const long input_length ) {
+template <class T>
+T AndEqualAtomicViewCheck(const long input_length) {
   const long N = input_length;
-  T result[2] = { 1 };
-  for ( long i = 0; i < N; ++i ) {
-    if ( N % 2 == 0 ) {
-      result[0] &= (T) i;
-    }
-    else {
-      result[1] &= (T) i;
+  T result[2]  = {1};
+  for (long i = 0; i < N; ++i) {
+    if (N % 2 == 0) {
+      result[0] &= (T)i;
+    } else {
+      result[1] &= (T)i;
     }
   }
 
-  return ( result[0] );
+  return (result[0]);
 }
 
-template< class T, class DeviceType >
-bool AndEqualAtomicViewTest( long input_length )
-{
-  static_assert( std::is_integral< T >::value, "AndEqualAtomicViewTest: Must be integral type for test" );
+template <class T, class DeviceType>
+bool AndEqualAtomicViewTest(long input_length) {
+  static_assert(std::is_integral<T>::value,
+                "AndEqualAtomicViewTest: Must be integral type for test");
 
-  T res       = AndEqualAtomicView< T, DeviceType >( input_length );
-  T resSerial = AndEqualAtomicViewCheck< T >( input_length );
+  T res       = AndEqualAtomicView<T, DeviceType>(input_length);
+  T resSerial = AndEqualAtomicViewCheck<T>(input_length);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = AndEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -1214,94 +1201,90 @@ bool AndEqualAtomicViewTest( long input_length )
 //-----------atomic view or-equal-----------------
 //---------------------------------------------------
 
-template< class T, class execution_space >
+template <class T, class execution_space>
 struct OrEqualAtomicViewFunctor {
-  typedef Kokkos::View< T*, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   atomic_view_type even_odd_result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator.
-  OrEqualAtomicViewFunctor( const view_type & input_, view_type & even_odd_result_, const long length_ )
-    : input( input_ )
-    , even_odd_result( even_odd_result_ )
-    , length( length_ )
-  {}
+  OrEqualAtomicViewFunctor(const view_type& input_, view_type& even_odd_result_,
+                           const long length_)
+      : input(input_), even_odd_result(even_odd_result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % 2 == 0 ) {
-        even_odd_result( 0 ) |= input( i );
-      }
-      else {
-        even_odd_result( 1 ) |= input( i );
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % 2 == 0) {
+        even_odd_result(0) |= input(i);
+      } else {
+        even_odd_result(1) |= input(i);
       }
     }
   }
 };
 
-template< class T, class execution_space >
-T OrEqualAtomicView( const long input_length ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
+template <class T, class execution_space>
+T OrEqualAtomicView(const long input_length) {
+  typedef Kokkos::View<T*, execution_space> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  view_type result_view( "result_view", 2 );
+  view_type input("input_view", length);
+  view_type result_view("result_view", 2);
 
-  InitFunctor_Seq< T, execution_space > init_f( input, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_Seq<T, execution_space> init_f(input, length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  OrEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  OrEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                       length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 0 ) );
+  return (T)(h_result_view(0));
 }
 
-template< class T >
-T OrEqualAtomicViewCheck( const long input_length ) {
-
+template <class T>
+T OrEqualAtomicViewCheck(const long input_length) {
   const long N = input_length;
-  T result[2] = { 0 };
-  for ( long i = 0; i < N; ++i ) {
-    if ( i % 2 == 0 ) {
-      result[0] |= (T) i;
-    }
-    else {
-      result[1] |= (T) i;
+  T result[2]  = {0};
+  for (long i = 0; i < N; ++i) {
+    if (i % 2 == 0) {
+      result[0] |= (T)i;
+    } else {
+      result[1] |= (T)i;
     }
   }
 
-  return (T) ( result[0] );
+  return (T)(result[0]);
 }
 
-template< class T, class DeviceType >
-bool OrEqualAtomicViewTest( long input_length )
-{
-  static_assert( std::is_integral< T >::value, "OrEqualAtomicViewTest: Must be integral type for test" );
+template <class T, class DeviceType>
+bool OrEqualAtomicViewTest(long input_length) {
+  static_assert(std::is_integral<T>::value,
+                "OrEqualAtomicViewTest: Must be integral type for test");
 
-  T res       = OrEqualAtomicView< T, DeviceType >( input_length );
-  T resSerial = OrEqualAtomicViewCheck< T >( input_length );
+  T res       = OrEqualAtomicView<T, DeviceType>(input_length);
+  T resSerial = OrEqualAtomicViewCheck<T>(input_length);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = OrEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -1311,93 +1294,90 @@ bool OrEqualAtomicViewTest( long input_length )
 //-----------atomic view xor-equal-----------------
 //---------------------------------------------------
 
-template< class T, class execution_space >
+template <class T, class execution_space>
 struct XOrEqualAtomicViewFunctor {
-  typedef Kokkos::View< T*, execution_space, Kokkos::MemoryTraits<Kokkos::Atomic> > atomic_view_type;
-  typedef Kokkos::View< T*, execution_space > view_type;
+  typedef Kokkos::View<T*, execution_space,
+                       Kokkos::MemoryTraits<Kokkos::Atomic> >
+      atomic_view_type;
+  typedef Kokkos::View<T*, execution_space> view_type;
 
   view_type input;
   atomic_view_type even_odd_result;
   const long length;
 
   // Wrap the result view in an atomic view, use this for operator.
-  XOrEqualAtomicViewFunctor( const view_type & input_, view_type & even_odd_result_, const long length_ )
-    : input( input_ )
-    , even_odd_result( even_odd_result_ )
-    , length( length_ )
-  {}
+  XOrEqualAtomicViewFunctor(const view_type& input_,
+                            view_type& even_odd_result_, const long length_)
+      : input(input_), even_odd_result(even_odd_result_), length(length_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const long i ) const {
-    if ( i < length ) {
-      if ( i % 2 == 0 ) {
-        even_odd_result( 0 ) ^= input( i );
-      }
-      else {
-        even_odd_result( 1 ) ^= input( i );
+  void operator()(const long i) const {
+    if (i < length) {
+      if (i % 2 == 0) {
+        even_odd_result(0) ^= input(i);
+      } else {
+        even_odd_result(1) ^= input(i);
       }
     }
   }
 };
 
-template< class T, class execution_space >
-T XOrEqualAtomicView( const long input_length ) {
-  typedef Kokkos::View< T*, execution_space > view_type;
+template <class T, class execution_space>
+T XOrEqualAtomicView(const long input_length) {
+  typedef Kokkos::View<T*, execution_space> view_type;
   typedef typename view_type::HostMirror host_view_type;
 
   const long length = input_length;
 
-  view_type input( "input_view", length );
-  view_type result_view( "result_view", 2 );
+  view_type input("input_view", length);
+  view_type result_view("result_view", 2);
 
-  InitFunctor_Seq< T, execution_space > init_f( input, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), init_f );
+  InitFunctor_Seq<T, execution_space> init_f(input, length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length), init_f);
 
-  XOrEqualAtomicViewFunctor< T, execution_space > functor( input, result_view, length );
-  Kokkos::parallel_for( Kokkos::RangePolicy< execution_space >( 0, length ), functor );
+  XOrEqualAtomicViewFunctor<T, execution_space> functor(input, result_view,
+                                                        length);
+  Kokkos::parallel_for(Kokkos::RangePolicy<execution_space>(0, length),
+                       functor);
   Kokkos::fence();
 
-  host_view_type h_result_view = Kokkos::create_mirror_view( result_view );
-  Kokkos::deep_copy( h_result_view, result_view );
+  host_view_type h_result_view = Kokkos::create_mirror_view(result_view);
+  Kokkos::deep_copy(h_result_view, result_view);
 
-  return (T) ( h_result_view( 0 ) );
+  return (T)(h_result_view(0));
 }
 
-template< class T >
-T XOrEqualAtomicViewCheck( const long input_length ) {
+template <class T>
+T XOrEqualAtomicViewCheck(const long input_length) {
   const long N = input_length;
-  T result[2] = { 0 };
-  for ( long i = 0; i < N; ++i ) {
-    if ( i % 2 == 0 ) {
-      result[0] ^= (T) i;
-    }
-    else {
-      result[1] ^= (T) i;
+  T result[2]  = {0};
+  for (long i = 0; i < N; ++i) {
+    if (i % 2 == 0) {
+      result[0] ^= (T)i;
+    } else {
+      result[1] ^= (T)i;
     }
   }
 
-  return (T) ( result[0] );
+  return (T)(result[0]);
 }
 
-template< class T, class DeviceType >
-bool XOrEqualAtomicViewTest( long input_length )
-{
-  static_assert( std::is_integral< T >::value, "XOrEqualAtomicViewTest: Must be integral type for test" );
+template <class T, class DeviceType>
+bool XOrEqualAtomicViewTest(long input_length) {
+  static_assert(std::is_integral<T>::value,
+                "XOrEqualAtomicViewTest: Must be integral type for test");
 
-  T res       = XOrEqualAtomicView< T, DeviceType >( input_length );
-  T resSerial = XOrEqualAtomicViewCheck< T >( input_length );
+  T res       = XOrEqualAtomicView<T, DeviceType>(input_length);
+  T resSerial = XOrEqualAtomicViewCheck<T>(input_length);
 
   bool passed = true;
 
-  if ( resSerial != res ) {
+  if (resSerial != res) {
     passed = false;
 
-    std::cout << "Loop<"
-              << typeid( T ).name()
+    std::cout << "Loop<" << typeid(T).name()
               << ">( test = XOrEqualAtomicViewTest"
-              << " FAILED : "
-              << resSerial << " != " << res
-              << std::endl;
+              << " FAILED : " << resSerial << " != " << res << std::endl;
   }
 
   return passed;
@@ -1409,72 +1389,93 @@ bool XOrEqualAtomicViewTest( long input_length )
 //--------------atomic_test_control------------------
 //---------------------------------------------------
 
-template< class T, class DeviceType >
-bool AtomicViewsTestIntegralType( const int length, int test )
-{
-  static_assert( std::is_integral< T >::value, "TestAtomicViews Error: Non-integral type passed into IntegralType tests" );
-
-  switch ( test ) {
-    case 1: return PlusEqualAtomicViewTest< T, DeviceType >( length );
-    case 2: return MinusEqualAtomicViewTest< T, DeviceType >( length );
-    case 3: return RSEqualAtomicViewTest< T, DeviceType >( length );
-    case 4: return LSEqualAtomicViewTest< T, DeviceType >( length );
-    case 5: return ModEqualAtomicViewTest< T, DeviceType >( length );
-    case 6: return AndEqualAtomicViewTest< T, DeviceType >( length );
-    case 7: return OrEqualAtomicViewTest< T, DeviceType >( length );
-    case 8: return XOrEqualAtomicViewTest< T, DeviceType >( length );
+template <class T, class DeviceType>
+bool AtomicViewsTestIntegralType(const int length, int test) {
+  static_assert(std::is_integral<T>::value,
+                "TestAtomicViews Error: Non-integral type passed into "
+                "IntegralType tests");
+
+  switch (test) {
+    case 1: return PlusEqualAtomicViewTest<T, DeviceType>(length);
+    case 2: return MinusEqualAtomicViewTest<T, DeviceType>(length);
+    case 3: return RSEqualAtomicViewTest<T, DeviceType>(length);
+    case 4: return LSEqualAtomicViewTest<T, DeviceType>(length);
+    case 5: return ModEqualAtomicViewTest<T, DeviceType>(length);
+    case 6: return AndEqualAtomicViewTest<T, DeviceType>(length);
+    case 7: return OrEqualAtomicViewTest<T, DeviceType>(length);
+    case 8: return XOrEqualAtomicViewTest<T, DeviceType>(length);
   }
 
   return 0;
 }
 
-template< class T, class DeviceType >
-bool AtomicViewsTestNonIntegralType( const int length, int test )
-{
-  switch ( test ) {
-    case 1: return PlusEqualAtomicViewTest< T, DeviceType >( length );
-    case 2: return MinusEqualAtomicViewTest< T, DeviceType >( length );
-    case 3: return TimesEqualAtomicViewTest< T, DeviceType >( length );
-    case 4: return DivEqualAtomicViewTest< T, DeviceType >( length );
+template <class T, class DeviceType>
+bool AtomicViewsTestNonIntegralType(const int length, int test) {
+  switch (test) {
+    case 1: return PlusEqualAtomicViewTest<T, DeviceType>(length);
+    case 2: return MinusEqualAtomicViewTest<T, DeviceType>(length);
+    case 3: return TimesEqualAtomicViewTest<T, DeviceType>(length);
+    case 4: return DivEqualAtomicViewTest<T, DeviceType>(length);
   }
 
   return 0;
 }
 
-} // namespace TestAtomicViews
+}  // namespace TestAtomicViews
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, atomic_views_integral )
-{
+TEST(TEST_CATEGORY, atomic_views_integral) {
   const long length = 1000000;
   {
     // Integral Types.
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 4 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 5 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 6 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 7 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestIntegralType< long, TEST_EXECSPACE >( length, 8 ) ) );
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 1)));
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 2)));
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 3)));
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 4)));
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 5)));
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 6)));
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 7)));
+    ASSERT_TRUE(
+        (TestAtomicViews::AtomicViewsTestIntegralType<long, TEST_EXECSPACE>(
+            length, 8)));
   }
 }
 
-TEST_F( TEST_CATEGORY, atomic_views_nonintegral )
-{
+TEST(TEST_CATEGORY, atomic_views_nonintegral) {
   const long length = 1000000;
   {
     // Non-Integral Types.
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestNonIntegralType< double, TEST_EXECSPACE >( length, 1 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestNonIntegralType< double, TEST_EXECSPACE >( length, 2 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestNonIntegralType< double, TEST_EXECSPACE >( length, 3 ) ) );
-    ASSERT_TRUE( ( TestAtomicViews::AtomicViewsTestNonIntegralType< double, TEST_EXECSPACE >( length, 4 ) ) );
+    ASSERT_TRUE((
+        TestAtomicViews::AtomicViewsTestNonIntegralType<double, TEST_EXECSPACE>(
+            length, 1)));
+    ASSERT_TRUE((
+        TestAtomicViews::AtomicViewsTestNonIntegralType<double, TEST_EXECSPACE>(
+            length, 2)));
+    ASSERT_TRUE((
+        TestAtomicViews::AtomicViewsTestNonIntegralType<double, TEST_EXECSPACE>(
+            length, 3)));
+    ASSERT_TRUE((
+        TestAtomicViews::AtomicViewsTestNonIntegralType<double, TEST_EXECSPACE>(
+            length, 4)));
   }
 }
 
-TEST_F( TEST_CATEGORY, atomic_view_api )
-{
-  TestAtomicViews::TestAtomicViewAPI< int, TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, atomic_view_api) {
+  TestAtomicViews::TestAtomicViewAPI<int, TEST_EXECSPACE>();
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestCXX11.hpp b/lib/kokkos/core/unit_test/TestCXX11.hpp
index 542b4a1912f4701ca37ff8a47a641fe5c255fc34..876a3b5da80193356339d5f39ebf4a13b2877b17 100644
--- a/lib/kokkos/core/unit_test/TestCXX11.hpp
+++ b/lib/kokkos/core/unit_test/TestCXX11.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,303 +46,317 @@
 
 namespace TestCXX11 {
 
-template< class DeviceType >
+template <class DeviceType>
 struct FunctorAddTest {
-  typedef Kokkos::View< double**, DeviceType > view_type;
+  typedef Kokkos::View<double**, DeviceType> view_type;
   typedef DeviceType execution_space;
-  typedef typename Kokkos::TeamPolicy< execution_space >::member_type team_member;
+  typedef typename Kokkos::TeamPolicy<execution_space>::member_type team_member;
 
   view_type a_, b_;
 
-  FunctorAddTest( view_type & a, view_type & b ) : a_( a ), b_( b ) {}
+  FunctorAddTest(view_type& a, view_type& b) : a_(a), b_(b) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const int& i ) const {
-    b_( i, 0 ) = a_( i, 1 ) + a_( i, 2 );
-    b_( i, 1 ) = a_( i, 0 ) - a_( i, 3 );
-    b_( i, 2 ) = a_( i, 4 ) + a_( i, 0 );
-    b_( i, 3 ) = a_( i, 2 ) - a_( i, 1 );
-    b_( i, 4 ) = a_( i, 3 ) + a_( i, 4 );
+  void operator()(const int& i) const {
+    b_(i, 0) = a_(i, 1) + a_(i, 2);
+    b_(i, 1) = a_(i, 0) - a_(i, 3);
+    b_(i, 2) = a_(i, 4) + a_(i, 0);
+    b_(i, 3) = a_(i, 2) - a_(i, 1);
+    b_(i, 4) = a_(i, 3) + a_(i, 4);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const team_member & dev ) const {
+  void operator()(const team_member& dev) const {
     const int begin = dev.league_rank() * 4;
     const int end   = begin + 4;
-    for ( int i = begin + dev.team_rank(); i < end; i += dev.team_size() ) {
-      b_( i, 0 ) = a_( i, 1 ) + a_( i, 2 );
-      b_( i, 1 ) = a_( i, 0 ) - a_( i, 3 );
-      b_( i, 2 ) = a_( i, 4 ) + a_( i, 0 );
-      b_( i, 3 ) = a_( i, 2 ) - a_( i, 1 );
-      b_( i, 4 ) = a_( i, 3 ) + a_( i, 4 );
+    for (int i = begin + dev.team_rank(); i < end; i += dev.team_size()) {
+      b_(i, 0) = a_(i, 1) + a_(i, 2);
+      b_(i, 1) = a_(i, 0) - a_(i, 3);
+      b_(i, 2) = a_(i, 4) + a_(i, 0);
+      b_(i, 3) = a_(i, 2) - a_(i, 1);
+      b_(i, 4) = a_(i, 3) + a_(i, 4);
     }
   }
 };
 
-template< class DeviceType, bool PWRTest >
+template <class DeviceType, bool PWRTest>
 double AddTestFunctor() {
-  typedef Kokkos::TeamPolicy< DeviceType > policy_type;
-
-  Kokkos::View< double**, DeviceType > a( "A", 100, 5 );
-  Kokkos::View< double**, DeviceType > b( "B", 100, 5 );
-  typename Kokkos::View< double**, DeviceType >::HostMirror h_a = Kokkos::create_mirror_view( a );
-  typename Kokkos::View< double**, DeviceType >::HostMirror h_b = Kokkos::create_mirror_view( b );
-
-  for ( int i = 0; i < 100; i++ ) {
-    for  ( int j = 0; j < 5; j++ ) {
-       h_a( i, j ) = 0.1 * i / ( 1.1 * j + 1.0 ) + 0.5 * j;
+  typedef Kokkos::TeamPolicy<DeviceType> policy_type;
+
+  Kokkos::View<double**, DeviceType> a("A", 100, 5);
+  Kokkos::View<double**, DeviceType> b("B", 100, 5);
+  typename Kokkos::View<double**, DeviceType>::HostMirror h_a =
+      Kokkos::create_mirror_view(a);
+  typename Kokkos::View<double**, DeviceType>::HostMirror h_b =
+      Kokkos::create_mirror_view(b);
+
+  for (int i = 0; i < 100; i++) {
+    for (int j = 0; j < 5; j++) {
+      h_a(i, j) = 0.1 * i / (1.1 * j + 1.0) + 0.5 * j;
     }
   }
-  Kokkos::deep_copy( a, h_a );
+  Kokkos::deep_copy(a, h_a);
 
-  if ( PWRTest == false ) {
-    Kokkos::parallel_for( 100, FunctorAddTest< DeviceType >( a, b ) );
-  }
-  else {
-    Kokkos::parallel_for( policy_type( 25, Kokkos::AUTO ), FunctorAddTest< DeviceType >( a, b ) );
+  if (PWRTest == false) {
+    Kokkos::parallel_for(100, FunctorAddTest<DeviceType>(a, b));
+  } else {
+    Kokkos::parallel_for(policy_type(25, Kokkos::AUTO),
+                         FunctorAddTest<DeviceType>(a, b));
   }
-  Kokkos::deep_copy( h_b, b );
+  Kokkos::deep_copy(h_b, b);
 
   double result = 0;
-  for ( int i = 0; i < 100; i++ ) {
-    for ( int j = 0; j < 5; j++ ) {
-      result += h_b( i, j );
+  for (int i = 0; i < 100; i++) {
+    for (int j = 0; j < 5; j++) {
+      result += h_b(i, j);
     }
   }
 
   return result;
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-template< class DeviceType, bool PWRTest >
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+template <class DeviceType, bool PWRTest>
 double AddTestLambda() {
-  Kokkos::View< double**, DeviceType > a( "A", 100, 5 );
-  Kokkos::View< double**, DeviceType > b( "B", 100, 5 );
-  typename Kokkos::View< double**, DeviceType >::HostMirror h_a = Kokkos::create_mirror_view( a );
-  typename Kokkos::View< double**, DeviceType >::HostMirror h_b = Kokkos::create_mirror_view( b );
-
-  for ( int i = 0; i < 100; i++ ) {
-    for ( int j = 0; j < 5; j++ ) {
-       h_a( i, j ) = 0.1 * i / ( 1.1 * j + 1.0 ) + 0.5 * j;
+  Kokkos::View<double**, DeviceType> a("A", 100, 5);
+  Kokkos::View<double**, DeviceType> b("B", 100, 5);
+  typename Kokkos::View<double**, DeviceType>::HostMirror h_a =
+      Kokkos::create_mirror_view(a);
+  typename Kokkos::View<double**, DeviceType>::HostMirror h_b =
+      Kokkos::create_mirror_view(b);
+
+  for (int i = 0; i < 100; i++) {
+    for (int j = 0; j < 5; j++) {
+      h_a(i, j) = 0.1 * i / (1.1 * j + 1.0) + 0.5 * j;
     }
   }
-  Kokkos::deep_copy( a, h_a );
-
-  if ( PWRTest == false ) {
-    Kokkos::parallel_for( 100, KOKKOS_LAMBDA( const int & i ) {
-      b( i, 0 ) = a( i, 1 ) + a( i, 2 );
-      b( i, 1 ) = a( i, 0 ) - a( i, 3 );
-      b( i, 2 ) = a( i, 4 ) + a( i, 0 );
-      b( i, 3 ) = a( i, 2 ) - a( i, 1 );
-      b( i, 4 ) = a( i, 3 ) + a( i, 4 );
-    });
-  }
-  else {
-    typedef Kokkos::TeamPolicy< DeviceType > policy_type;
+  Kokkos::deep_copy(a, h_a);
+
+  if (PWRTest == false) {
+    Kokkos::parallel_for(
+        100, KOKKOS_LAMBDA(const int& i) {
+          b(i, 0) = a(i, 1) + a(i, 2);
+          b(i, 1) = a(i, 0) - a(i, 3);
+          b(i, 2) = a(i, 4) + a(i, 0);
+          b(i, 3) = a(i, 2) - a(i, 1);
+          b(i, 4) = a(i, 3) + a(i, 4);
+        });
+  } else {
+    typedef Kokkos::TeamPolicy<DeviceType> policy_type;
     typedef typename policy_type::member_type team_member;
 
-    policy_type policy( 25, Kokkos::AUTO );
-
-    Kokkos::parallel_for( policy, KOKKOS_LAMBDA( const team_member & dev ) {
-      const int begin = dev.league_rank() * 4;
-      const int end   = begin + 4;
-      for ( int i = begin + dev.team_rank(); i < end; i += dev.team_size() ) {
-        b( i, 0 ) = a( i, 1 ) + a( i, 2 );
-        b( i, 1 ) = a( i, 0 ) - a( i, 3 );
-        b( i, 2 ) = a( i, 4 ) + a( i, 0 );
-        b( i, 3 ) = a( i, 2 ) - a( i, 1 );
-        b( i, 4 ) = a( i, 3 ) + a( i, 4 );
-      }
-    });
+    policy_type policy(25, Kokkos::AUTO);
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(const team_member& dev) {
+          const int begin = dev.league_rank() * 4;
+          const int end   = begin + 4;
+          for (int i = begin + dev.team_rank(); i < end; i += dev.team_size()) {
+            b(i, 0) = a(i, 1) + a(i, 2);
+            b(i, 1) = a(i, 0) - a(i, 3);
+            b(i, 2) = a(i, 4) + a(i, 0);
+            b(i, 3) = a(i, 2) - a(i, 1);
+            b(i, 4) = a(i, 3) + a(i, 4);
+          }
+        });
   }
-  Kokkos::deep_copy( h_b, b );
+  Kokkos::deep_copy(h_b, b);
 
   double result = 0;
-  for ( int i = 0; i < 100; i++ ) {
-    for ( int j = 0; j < 5; j++ ) {
-      result += h_b( i, j );
+  for (int i = 0; i < 100; i++) {
+    for (int j = 0; j < 5; j++) {
+      result += h_b(i, j);
     }
   }
 
   return result;
 }
 #else
-template< class DeviceType, bool PWRTest >
+template <class DeviceType, bool PWRTest>
 double AddTestLambda() {
-  return AddTestFunctor< DeviceType, PWRTest >();
+  return AddTestFunctor<DeviceType, PWRTest>();
 }
 #endif
 
-template< class DeviceType >
+template <class DeviceType>
 struct FunctorReduceTest {
-  typedef Kokkos::View< double**, DeviceType > view_type;
+  typedef Kokkos::View<double**, DeviceType> view_type;
   typedef DeviceType execution_space;
   typedef double value_type;
-  typedef typename Kokkos::TeamPolicy< execution_space >::member_type team_member;
+  typedef typename Kokkos::TeamPolicy<execution_space>::member_type team_member;
 
   view_type a_;
 
-  FunctorReduceTest( view_type & a ) : a_( a ) {}
+  FunctorReduceTest(view_type& a) : a_(a) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const int & i, value_type & sum ) const {
-    sum += a_( i, 1 ) + a_( i, 2 );
-    sum += a_( i, 0 ) - a_( i, 3 );
-    sum += a_( i, 4 ) + a_( i, 0 );
-    sum += a_( i, 2 ) - a_( i, 1 );
-    sum += a_( i, 3 ) + a_( i, 4 );
+  void operator()(const int& i, value_type& sum) const {
+    sum += a_(i, 1) + a_(i, 2);
+    sum += a_(i, 0) - a_(i, 3);
+    sum += a_(i, 4) + a_(i, 0);
+    sum += a_(i, 2) - a_(i, 1);
+    sum += a_(i, 3) + a_(i, 4);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const team_member & dev, value_type & sum ) const {
+  void operator()(const team_member& dev, value_type& sum) const {
     const int begin = dev.league_rank() * 4;
     const int end   = begin + 4;
-    for ( int i = begin + dev.team_rank(); i < end; i += dev.team_size() ) {
-      sum += a_( i, 1 ) + a_( i, 2 );
-      sum += a_( i, 0 ) - a_( i, 3 );
-      sum += a_( i, 4 ) + a_( i, 0 );
-      sum += a_( i, 2 ) - a_( i, 1 );
-      sum += a_( i, 3 ) + a_( i, 4 );
+    for (int i = begin + dev.team_rank(); i < end; i += dev.team_size()) {
+      sum += a_(i, 1) + a_(i, 2);
+      sum += a_(i, 0) - a_(i, 3);
+      sum += a_(i, 4) + a_(i, 0);
+      sum += a_(i, 2) - a_(i, 1);
+      sum += a_(i, 3) + a_(i, 4);
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & update ) const { update = 0.0; }
+  void init(value_type& update) const { update = 0.0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & update, volatile value_type const & input ) const { update += input; }
+  void join(volatile value_type& update,
+            volatile value_type const& input) const {
+    update += input;
+  }
 };
 
-template< class DeviceType, bool PWRTest >
+template <class DeviceType, bool PWRTest>
 double ReduceTestFunctor() {
-  typedef Kokkos::TeamPolicy< DeviceType > policy_type;
-  typedef Kokkos::View< double**, DeviceType > view_type;
-  typedef Kokkos::View< double, Kokkos::HostSpace, Kokkos::MemoryUnmanaged > unmanaged_result;
+  typedef Kokkos::TeamPolicy<DeviceType> policy_type;
+  typedef Kokkos::View<double**, DeviceType> view_type;
+  typedef Kokkos::View<double, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      unmanaged_result;
 
-  view_type a( "A", 100, 5 );
-  typename view_type::HostMirror h_a = Kokkos::create_mirror_view( a );
+  view_type a("A", 100, 5);
+  typename view_type::HostMirror h_a = Kokkos::create_mirror_view(a);
 
-  for ( int i = 0; i < 100; i++ ) {
-    for ( int j = 0; j < 5; j++ ) {
-       h_a( i, j ) = 0.1 * i / ( 1.1 * j + 1.0 ) + 0.5 * j;
+  for (int i = 0; i < 100; i++) {
+    for (int j = 0; j < 5; j++) {
+      h_a(i, j) = 0.1 * i / (1.1 * j + 1.0) + 0.5 * j;
     }
   }
-  Kokkos::deep_copy( a, h_a );
+  Kokkos::deep_copy(a, h_a);
 
   double result = 0.0;
-  if ( PWRTest == false ) {
-    Kokkos::parallel_reduce( 100, FunctorReduceTest< DeviceType >( a ), unmanaged_result( & result ) );
-  }
-  else {
-    Kokkos::parallel_reduce( policy_type( 25, Kokkos::AUTO ), FunctorReduceTest< DeviceType >( a ), unmanaged_result( & result ) );
+  if (PWRTest == false) {
+    Kokkos::parallel_reduce(100, FunctorReduceTest<DeviceType>(a),
+                            unmanaged_result(&result));
+  } else {
+    Kokkos::parallel_reduce(policy_type(25, Kokkos::AUTO),
+                            FunctorReduceTest<DeviceType>(a),
+                            unmanaged_result(&result));
   }
   Kokkos::fence();
 
   return result;
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-template< class DeviceType, bool PWRTest >
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+template <class DeviceType, bool PWRTest>
 double ReduceTestLambda() {
-  typedef Kokkos::TeamPolicy< DeviceType > policy_type;
-  typedef Kokkos::View< double**, DeviceType > view_type;
-  typedef Kokkos::View< double, Kokkos::HostSpace, Kokkos::MemoryUnmanaged > unmanaged_result;
+  typedef Kokkos::TeamPolicy<DeviceType> policy_type;
+  typedef Kokkos::View<double**, DeviceType> view_type;
+  typedef Kokkos::View<double, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      unmanaged_result;
 
-  view_type a( "A", 100, 5 );
-  typename view_type::HostMirror h_a = Kokkos::create_mirror_view( a );
+  view_type a("A", 100, 5);
+  typename view_type::HostMirror h_a = Kokkos::create_mirror_view(a);
 
-  for ( int i = 0; i < 100; i++ ) {
-    for ( int j = 0; j < 5; j++ ) {
-       h_a( i, j ) = 0.1 * i / ( 1.1 * j + 1.0 ) + 0.5 * j;
+  for (int i = 0; i < 100; i++) {
+    for (int j = 0; j < 5; j++) {
+      h_a(i, j) = 0.1 * i / (1.1 * j + 1.0) + 0.5 * j;
     }
   }
-  Kokkos::deep_copy( a, h_a );
+  Kokkos::deep_copy(a, h_a);
 
   double result = 0.0;
 
-  if ( PWRTest == false ) {
-    Kokkos::parallel_reduce( 100, KOKKOS_LAMBDA( const int & i, double & sum ) {
-      sum += a( i, 1 ) + a( i, 2 );
-      sum += a( i, 0 ) - a( i, 3 );
-      sum += a( i, 4 ) + a( i, 0 );
-      sum += a( i, 2 ) - a( i, 1 );
-      sum += a( i, 3 ) + a( i, 4 );
-    }, unmanaged_result( & result ) );
-  }
-  else {
+  if (PWRTest == false) {
+    Kokkos::parallel_reduce(
+        100,
+        KOKKOS_LAMBDA(const int& i, double& sum) {
+          sum += a(i, 1) + a(i, 2);
+          sum += a(i, 0) - a(i, 3);
+          sum += a(i, 4) + a(i, 0);
+          sum += a(i, 2) - a(i, 1);
+          sum += a(i, 3) + a(i, 4);
+        },
+        unmanaged_result(&result));
+  } else {
     typedef typename policy_type::member_type team_member;
-    Kokkos::parallel_reduce( policy_type( 25, Kokkos::AUTO ), KOKKOS_LAMBDA( const team_member & dev, double & sum ) {
-      const int begin = dev.league_rank() * 4;
-      const int end   = begin + 4;
-      for ( int i = begin + dev.team_rank(); i < end; i += dev.team_size() ) {
-        sum += a( i, 1 ) + a( i, 2 );
-        sum += a( i, 0 ) - a( i, 3 );
-        sum += a( i, 4 ) + a( i, 0 );
-        sum += a( i, 2 ) - a( i, 1 );
-        sum += a( i, 3 ) + a( i, 4 );
-      }
-    }, unmanaged_result( & result ) );
+    Kokkos::parallel_reduce(
+        policy_type(25, Kokkos::AUTO),
+        KOKKOS_LAMBDA(const team_member& dev, double& sum) {
+          const int begin = dev.league_rank() * 4;
+          const int end   = begin + 4;
+          for (int i = begin + dev.team_rank(); i < end; i += dev.team_size()) {
+            sum += a(i, 1) + a(i, 2);
+            sum += a(i, 0) - a(i, 3);
+            sum += a(i, 4) + a(i, 0);
+            sum += a(i, 2) - a(i, 1);
+            sum += a(i, 3) + a(i, 4);
+          }
+        },
+        unmanaged_result(&result));
   }
   Kokkos::fence();
 
   return result;
 }
 #else
-template< class DeviceType, bool PWRTest >
+template <class DeviceType, bool PWRTest>
 double ReduceTestLambda() {
-  return ReduceTestFunctor< DeviceType, PWRTest >();
+  return ReduceTestFunctor<DeviceType, PWRTest>();
 }
 #endif
 
-template< class DeviceType >
-double TestVariantLambda( int test ) {
-  switch ( test ) {
-    case 1: return AddTestLambda< DeviceType, false >();
-    case 2: return AddTestLambda< DeviceType, true >();
-    case 3: return ReduceTestLambda< DeviceType, false >();
-    case 4: return ReduceTestLambda< DeviceType, true >();
+template <class DeviceType>
+double TestVariantLambda(int test) {
+  switch (test) {
+    case 1: return AddTestLambda<DeviceType, false>();
+    case 2: return AddTestLambda<DeviceType, true>();
+    case 3: return ReduceTestLambda<DeviceType, false>();
+    case 4: return ReduceTestLambda<DeviceType, true>();
   }
 
   return 0;
 }
 
-template< class DeviceType >
-double TestVariantFunctor( int test ) {
-  switch ( test ) {
-    case 1: return AddTestFunctor< DeviceType, false >();
-    case 2: return AddTestFunctor< DeviceType, true >();
-    case 3: return ReduceTestFunctor< DeviceType, false >();
-    case 4: return ReduceTestFunctor< DeviceType, true >();
+template <class DeviceType>
+double TestVariantFunctor(int test) {
+  switch (test) {
+    case 1: return AddTestFunctor<DeviceType, false>();
+    case 2: return AddTestFunctor<DeviceType, true>();
+    case 3: return ReduceTestFunctor<DeviceType, false>();
+    case 4: return ReduceTestFunctor<DeviceType, true>();
   }
 
   return 0;
 }
 
-template< class DeviceType >
-bool Test( int test ) {
+template <class DeviceType>
+bool Test(int test) {
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-  double res_functor = TestVariantFunctor< DeviceType >( test );
-  double res_lambda = TestVariantLambda< DeviceType >( test );
+  double res_functor = TestVariantFunctor<DeviceType>(test);
+  double res_lambda  = TestVariantLambda<DeviceType>(test);
 
-  char testnames[5][256] = { " "
-                           , "AddTest", "AddTest TeamPolicy"
-                           , "ReduceTest", "ReduceTest TeamPolicy"
-                           };
-  bool passed = true;
+  char testnames[5][256] = {" ", "AddTest", "AddTest TeamPolicy", "ReduceTest",
+                            "ReduceTest TeamPolicy"};
+  bool passed            = true;
 
   auto a = res_functor;
   auto b = res_lambda;
-  // use a tolerant comparison because functors and lambdas vectorize differently
-  // https://github.com/trilinos/Trilinos/issues/3233
+  // use a tolerant comparison because functors and lambdas vectorize
+  // differently https://github.com/trilinos/Trilinos/issues/3233
   auto rel_err = (std::abs(b - a) / std::max(std::abs(a), std::abs(b)));
-  auto tol = 1e-14;
+  auto tol     = 1e-14;
   if (rel_err > tol) {
     passed = false;
 
-    std::cout << "CXX11 ( test = '"
-              << testnames[test] << "' FAILED : relative error "
-              << rel_err << " > tolerance " << tol
-              << std::endl;
+    std::cout << "CXX11 ( test = '" << testnames[test]
+              << "' FAILED : relative error " << rel_err << " > tolerance "
+              << tol << std::endl;
   }
 
   return passed;
@@ -350,18 +365,16 @@ bool Test( int test ) {
 #endif
 }
 
-} // namespace TestCXX11
+}  // namespace TestCXX11
 
 namespace Test {
-TEST_F( TEST_CATEGORY, cxx11 )
-{
-  if ( std::is_same< Kokkos::DefaultExecutionSpace, TEST_EXECSPACE >::value ) {
-    ASSERT_TRUE( ( TestCXX11::Test< TEST_EXECSPACE >( 1 ) ) );
-    ASSERT_TRUE( ( TestCXX11::Test< TEST_EXECSPACE >( 2 ) ) );
-    ASSERT_TRUE( ( TestCXX11::Test< TEST_EXECSPACE >( 3 ) ) );
-    ASSERT_TRUE( ( TestCXX11::Test< TEST_EXECSPACE >( 4 ) ) );
+TEST(TEST_CATEGORY, cxx11) {
+  if (std::is_same<Kokkos::DefaultExecutionSpace, TEST_EXECSPACE>::value) {
+    ASSERT_TRUE((TestCXX11::Test<TEST_EXECSPACE>(1)));
+    ASSERT_TRUE((TestCXX11::Test<TEST_EXECSPACE>(2)));
+    ASSERT_TRUE((TestCXX11::Test<TEST_EXECSPACE>(3)));
+    ASSERT_TRUE((TestCXX11::Test<TEST_EXECSPACE>(4)));
   }
 }
 
-}
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestCXX11Deduction.hpp b/lib/kokkos/core/unit_test/TestCXX11Deduction.hpp
index 220732918d1b1fc0fd6c0ebf19b920179e27980a..0e60d91a89c343c7b43171750a6e10eca986d690 100644
--- a/lib/kokkos/core/unit_test/TestCXX11Deduction.hpp
+++ b/lib/kokkos/core/unit_test/TestCXX11Deduction.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,49 +52,57 @@ namespace TestCXX11 {
 struct TestReductionDeductionTagA {};
 struct TestReductionDeductionTagB {};
 
-template < class ExecSpace >
+template <class ExecSpace>
 struct TestReductionDeductionFunctor {
   // KOKKOS_INLINE_FUNCTION
   // void operator()( long i, long & value ) const
   // { value += i + 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TestReductionDeductionTagA, long i, long & value ) const
-  { value += ( 2 * i + 1 ) + ( 2 * i + 2 ); }
+  void operator()(TestReductionDeductionTagA, long i, long &value) const {
+    value += (2 * i + 1) + (2 * i + 2);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TestReductionDeductionTagB &, const long i, long & value ) const
-  { value += ( 3 * i + 1 ) + ( 3 * i + 2 ) + ( 3 * i + 3 ); }
+  void operator()(const TestReductionDeductionTagB &, const long i,
+                  long &value) const {
+    value += (3 * i + 1) + (3 * i + 2) + (3 * i + 3);
+  }
 };
 
-template< class ExecSpace >
-void test_reduction_deduction()
-{
-  typedef TestReductionDeductionFunctor< ExecSpace > Functor;
+template <class ExecSpace>
+void test_reduction_deduction() {
+  typedef TestReductionDeductionFunctor<ExecSpace> Functor;
 
   const long N = 50;
-  // const long answer  = N % 2 ? ( N * ( ( N + 1 ) / 2 ) ) : ( ( N / 2 ) * ( N + 1 ) );
-  const long answerA = N % 2 ? ( ( 2 * N ) * ( ( ( 2 * N ) + 1 ) / 2 ) ) : ( ( ( 2 * N ) / 2 ) * ( ( 2 * N ) + 1 ) );
-  const long answerB = N % 2 ? ( ( 3 * N ) * ( ( ( 3 * N ) + 1 ) / 2 ) ) : ( ( ( 3 * N ) / 2 ) * ( ( 3 * N ) + 1 ) );
+  // const long answer  = N % 2 ? ( N * ( ( N + 1 ) / 2 ) ) : ( ( N / 2 ) * ( N
+  // + 1 ) );
+  const long answerA =
+      N % 2 ? ((2 * N) * (((2 * N) + 1) / 2)) : (((2 * N) / 2) * ((2 * N) + 1));
+  const long answerB =
+      N % 2 ? ((3 * N) * (((3 * N) + 1) / 2)) : (((3 * N) / 2) * ((3 * N) + 1));
   long result = 0;
 
-  // Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), Functor(), result );
-  // ASSERT_EQ( answer, result );
+  // Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ),
+  // Functor(), result ); ASSERT_EQ( answer, result );
 
-  Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace, TestReductionDeductionTagA >( 0, N ), Functor(), result );
-  ASSERT_EQ( answerA, result );
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecSpace, TestReductionDeductionTagA>(0, N),
+      Functor(), result);
+  ASSERT_EQ(answerA, result);
 
-  Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace, TestReductionDeductionTagB >( 0, N ), Functor(), result );
-  ASSERT_EQ( answerB, result );
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecSpace, TestReductionDeductionTagB>(0, N),
+      Functor(), result);
+  ASSERT_EQ(answerB, result);
 }
 
-} // namespace TestCXX11
+}  // namespace TestCXX11
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, reduction_deduction )
-{
-  TestCXX11::test_reduction_deduction< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, reduction_deduction) {
+  TestCXX11::test_reduction_deduction<TEST_EXECSPACE>();
 }
+}  // namespace Test
 #endif
diff --git a/lib/kokkos/core/unit_test/TestCompilerMacros.hpp b/lib/kokkos/core/unit_test/TestCompilerMacros.hpp
index 07c332a9ae226d86b1e4bd084ebfb7c05934abd2..e8daab9db606d0e1dbb606c63461ec2fee912a9b 100644
--- a/lib/kokkos/core/unit_test/TestCompilerMacros.hpp
+++ b/lib/kokkos/core/unit_test/TestCompilerMacros.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,75 +44,74 @@
 
 #include <Kokkos_Core.hpp>
 
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    ( !defined(KOKKOS_ENABLE_CUDA_LAMBDA) || \
-      (  ( defined(KOKKOS_ENABLE_SERIAL) || defined(KOKKOS_ENABLE_OPENMP) ) && \
-         (  (CUDA_VERSION < 8000) && defined( __NVCC__ ))))
-  #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-    #error "Macro bug: KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA shouldn't be defined"
-  #endif
+#if defined(KOKKOS_ENABLE_CUDA) &&                                        \
+    (!defined(KOKKOS_ENABLE_CUDA_LAMBDA) ||                               \
+     ((defined(KOKKOS_ENABLE_SERIAL) || defined(KOKKOS_ENABLE_OPENMP)) && \
+      ((CUDA_VERSION < 8000) && defined(__NVCC__))))
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#error "Macro bug: KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA shouldn't be defined"
+#endif
 #else
-  #if !defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-    #error "Macro bug: KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA should be defined"
-  #endif
+#if !defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#error "Macro bug: KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA should be defined"
+#endif
 #endif
 
 #define KOKKOS_PRAGMA_UNROLL(a)
 
 namespace TestCompilerMacros {
 
-template< class DEVICE_TYPE >
+template <class DEVICE_TYPE>
 struct AddFunctor {
   typedef DEVICE_TYPE execution_space;
-  typedef typename Kokkos::View< int**, execution_space > type;
+  typedef typename Kokkos::View<int**, execution_space> type;
   type a, b;
   int length;
 
-  AddFunctor( type a_, type b_ ) : a( a_ ), b( b_ ), length( a.extent(1) ) {}
+  AddFunctor(type a_, type b_) : a(a_), b(b_), length(a.extent(1)) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i ) const {
+  void operator()(int i) const {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
-    #pragma unroll
+#pragma unroll
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-    #pragma ivdep
+#pragma ivdep
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
-    #pragma vector always
+#pragma vector always
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_LOOPCOUNT
-    #pragma loop count(128)
+#pragma loop count(128)
 #endif
 #ifndef KOKKOS_DEBUG
 #ifdef KOKKOS_ENABLE_PRAGMA_SIMD
-    #pragma simd
+#pragma simd
 #endif
 #endif
-    for ( int j = 0; j < length; j++ ) {
-      a( i, j ) += b( i, j );
+    for (int j = 0; j < length; j++) {
+      a(i, j) += b(i, j);
     }
   }
 };
 
-template< class DeviceType >
+template <class DeviceType>
 bool Test() {
-  typedef typename Kokkos::View< int**, DeviceType > type;
-  type a( "A", 1024, 128 );
-  type b( "B", 1024, 128 );
+  typedef typename Kokkos::View<int**, DeviceType> type;
+  type a("A", 1024, 128);
+  type b("B", 1024, 128);
 
-  AddFunctor< DeviceType > f( a, b );
-  Kokkos::parallel_for( 1024, f );
+  AddFunctor<DeviceType> f(a, b);
+  Kokkos::parallel_for(1024, f);
   DeviceType().fence();
 
   return true;
 }
 
-} // namespace TestCompilerMacros
+}  // namespace TestCompilerMacros
 
 namespace Test {
-TEST_F( TEST_CATEGORY, compiler_macros )
-{
-  ASSERT_TRUE( ( TestCompilerMacros::Test< TEST_EXECSPACE >() ) );
-}
+TEST(TEST_CATEGORY, compiler_macros) {
+  ASSERT_TRUE((TestCompilerMacros::Test<TEST_EXECSPACE>()));
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestComplex.hpp b/lib/kokkos/core/unit_test/TestComplex.hpp
index f4343df0cef756a9576ca4a904ffbae2d05f181e..e049dcd17566a7ed9c800a5876e877c96cba28a7 100644
--- a/lib/kokkos/core/unit_test/TestComplex.hpp
+++ b/lib/kokkos/core/unit_test/TestComplex.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,57 +42,78 @@
 //@HEADER
 */
 
-#include<Kokkos_Core.hpp>
-#include<cstdio>
+#include <Kokkos_Core.hpp>
+#include <cstdio>
+#include <sstream>
 
 namespace Test {
 
 // Test construction and assignment
 
-template<class ExecSpace>
+template <class ExecSpace>
 struct TestComplexConstruction {
-  Kokkos::View<Kokkos::complex<double>*,ExecSpace> d_results;
-  typename Kokkos::View<Kokkos::complex<double>*,ExecSpace>::HostMirror h_results;
-  
-  void testit () {
-    d_results = Kokkos::View<Kokkos::complex<double>*,ExecSpace>("TestComplexConstruction",10);
+  Kokkos::View<Kokkos::complex<double> *, ExecSpace> d_results;
+  typename Kokkos::View<Kokkos::complex<double> *, ExecSpace>::HostMirror
+      h_results;
+
+  void testit() {
+    d_results = Kokkos::View<Kokkos::complex<double> *, ExecSpace>(
+        "TestComplexConstruction", 10);
     h_results = Kokkos::create_mirror_view(d_results);
-   
-    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0,1), *this);
+
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, 1), *this);
     Kokkos::fence();
-    Kokkos::deep_copy(h_results,d_results);
-
-    ASSERT_FLOAT_EQ(h_results(0).real(),1.5);  ASSERT_FLOAT_EQ(h_results(0).imag(),2.5);
-    ASSERT_FLOAT_EQ(h_results(1).real(),1.5);  ASSERT_FLOAT_EQ(h_results(1).imag(),2.5);
-    ASSERT_FLOAT_EQ(h_results(2).real(),0.0);  ASSERT_FLOAT_EQ(h_results(2).imag(),0.0);
-    ASSERT_FLOAT_EQ(h_results(3).real(),3.5);  ASSERT_FLOAT_EQ(h_results(3).imag(),0.0);
-    ASSERT_FLOAT_EQ(h_results(4).real(),4.5);  ASSERT_FLOAT_EQ(h_results(4).imag(),5.5);
-    ASSERT_FLOAT_EQ(h_results(5).real(),1.5);  ASSERT_FLOAT_EQ(h_results(5).imag(),2.5);
-    ASSERT_FLOAT_EQ(h_results(6).real(),4.5);  ASSERT_FLOAT_EQ(h_results(6).imag(),5.5);
-    ASSERT_FLOAT_EQ(h_results(7).real(),7.5);  ASSERT_FLOAT_EQ(h_results(7).imag(),0.0);
-    ASSERT_FLOAT_EQ(h_results(8).real(),double(8));  ASSERT_FLOAT_EQ(h_results(8).imag(),0.0);
-
-#ifndef KOKKOS_ENABLE_ROCM // Copy construction conversion between Kokkos::complex and std::complex doesn't compile
-    Kokkos::complex<double> a(1.5,2.5),b(3.25,5.25),r_kk;
-    std::complex<double> sa(a),sb(3.25,5.25),r;
-    r = a; r_kk = a;         ASSERT_FLOAT_EQ(r.real(),r_kk.real()); ASSERT_FLOAT_EQ(r.imag(),r_kk.imag());
-    r = sb*a; r_kk = b*a;    ASSERT_FLOAT_EQ(r.real(),r_kk.real()); ASSERT_FLOAT_EQ(r.imag(),r_kk.imag());
-    r = sa; r_kk = a;        ASSERT_FLOAT_EQ(r.real(),r_kk.real()); ASSERT_FLOAT_EQ(r.imag(),r_kk.imag());
+    Kokkos::deep_copy(h_results, d_results);
+
+    ASSERT_FLOAT_EQ(h_results(0).real(), 1.5);
+    ASSERT_FLOAT_EQ(h_results(0).imag(), 2.5);
+    ASSERT_FLOAT_EQ(h_results(1).real(), 1.5);
+    ASSERT_FLOAT_EQ(h_results(1).imag(), 2.5);
+    ASSERT_FLOAT_EQ(h_results(2).real(), 0.0);
+    ASSERT_FLOAT_EQ(h_results(2).imag(), 0.0);
+    ASSERT_FLOAT_EQ(h_results(3).real(), 3.5);
+    ASSERT_FLOAT_EQ(h_results(3).imag(), 0.0);
+    ASSERT_FLOAT_EQ(h_results(4).real(), 4.5);
+    ASSERT_FLOAT_EQ(h_results(4).imag(), 5.5);
+    ASSERT_FLOAT_EQ(h_results(5).real(), 1.5);
+    ASSERT_FLOAT_EQ(h_results(5).imag(), 2.5);
+    ASSERT_FLOAT_EQ(h_results(6).real(), 4.5);
+    ASSERT_FLOAT_EQ(h_results(6).imag(), 5.5);
+    ASSERT_FLOAT_EQ(h_results(7).real(), 7.5);
+    ASSERT_FLOAT_EQ(h_results(7).imag(), 0.0);
+    ASSERT_FLOAT_EQ(h_results(8).real(), double(8));
+    ASSERT_FLOAT_EQ(h_results(8).imag(), 0.0);
+
+#ifndef KOKKOS_ENABLE_ROCM  // Copy construction conversion between
+                            // Kokkos::complex and std::complex doesn't compile
+    Kokkos::complex<double> a(1.5, 2.5), b(3.25, 5.25), r_kk;
+    std::complex<double> sa(a), sb(3.25, 5.25), r;
+    r    = a;
+    r_kk = a;
+    ASSERT_FLOAT_EQ(r.real(), r_kk.real());
+    ASSERT_FLOAT_EQ(r.imag(), r_kk.imag());
+    r    = sb * a;
+    r_kk = b * a;
+    ASSERT_FLOAT_EQ(r.real(), r_kk.real());
+    ASSERT_FLOAT_EQ(r.imag(), r_kk.imag());
+    r    = sa;
+    r_kk = a;
+    ASSERT_FLOAT_EQ(r.real(), r_kk.real());
+    ASSERT_FLOAT_EQ(r.imag(), r_kk.imag());
 #endif
-
   }
 
-  KOKKOS_INLINE_FUNCTION 
-  void operator() (const int &i ) const {
-    Kokkos::complex<double> a(1.5,2.5);
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int &i) const {
+    Kokkos::complex<double> a(1.5, 2.5);
     d_results(0) = a;
     Kokkos::complex<double> b(a);
-    d_results(1) = b;
+    d_results(1)              = b;
     Kokkos::complex<double> c = Kokkos::complex<double>();
-    d_results(2) = c;
+    d_results(2)              = c;
     Kokkos::complex<double> d(3.5);
-    d_results(3) = d; 
-    volatile Kokkos::complex<double> a_v(4.5,5.5);
+    d_results(3) = d;
+    volatile Kokkos::complex<double> a_v(4.5, 5.5);
     d_results(4) = a_v;
     volatile Kokkos::complex<double> b_v(a);
     d_results(5) = b_v;
@@ -100,164 +122,238 @@ struct TestComplexConstruction {
 
     d_results(7) = double(7.5);
     d_results(8) = int(8);
-  } 
+  }
 };
 
-TEST_F(TEST_CATEGORY, complex_construction) {
+TEST(TEST_CATEGORY, complex_construction) {
   TestComplexConstruction<TEST_EXECSPACE> test;
   test.testit();
-} 
+}
 
 // Test Math FUnction
 
-template<class ExecSpace>
+template <class ExecSpace>
 struct TestComplexBasicMath {
-  Kokkos::View<Kokkos::complex<double>*,ExecSpace> d_results;
-  typename Kokkos::View<Kokkos::complex<double>*,ExecSpace>::HostMirror h_results;
+  Kokkos::View<Kokkos::complex<double> *, ExecSpace> d_results;
+  typename Kokkos::View<Kokkos::complex<double> *, ExecSpace>::HostMirror
+      h_results;
 
-  void testit () {
-    d_results = Kokkos::View<Kokkos::complex<double>*,ExecSpace>("TestComplexBasicMath",24);
+  void testit() {
+    d_results = Kokkos::View<Kokkos::complex<double> *, ExecSpace>(
+        "TestComplexBasicMath", 24);
     h_results = Kokkos::create_mirror_view(d_results);
 
-    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0,1), *this);
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, 1), *this);
     Kokkos::fence();
-    Kokkos::deep_copy(h_results,d_results);
+    Kokkos::deep_copy(h_results, d_results);
 
-    std::complex<double> a(1.5,2.5);
-    std::complex<double> b(3.25,5.75);
-    std::complex<double> d(1.0,2.0);
+    std::complex<double> a(1.5, 2.5);
+    std::complex<double> b(3.25, 5.75);
+    std::complex<double> d(1.0, 2.0);
     double c = 9.3;
-    int e = 2;
+    int e    = 2;
 
     std::complex<double> r;
-    r = a+b; ASSERT_FLOAT_EQ(h_results(0).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(0).imag(),  r.imag());
-    r = a-b; ASSERT_FLOAT_EQ(h_results(1).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(1).imag(),  r.imag());
-    r = a*b; ASSERT_FLOAT_EQ(h_results(2).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(2).imag(),  r.imag());
-    r = a/b; ASSERT_FLOAT_EQ(h_results(3).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(3).imag(),  r.imag());
-    r = d+a; ASSERT_FLOAT_EQ(h_results(4).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(4).imag(),  r.imag());
-    r = d-a; ASSERT_FLOAT_EQ(h_results(5).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(5).imag(),  r.imag());
-    r = d*a; ASSERT_FLOAT_EQ(h_results(6).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(6).imag(),  r.imag());
-    r = d/a; ASSERT_FLOAT_EQ(h_results(7).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(7).imag(),  r.imag());
-    r = a+c; ASSERT_FLOAT_EQ(h_results(8).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(8).imag(),  r.imag());
-    r = a-c; ASSERT_FLOAT_EQ(h_results(9).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(9).imag(),  r.imag());
-    r = a*c; ASSERT_FLOAT_EQ(h_results(10).real(), r.real()); ASSERT_FLOAT_EQ(h_results(10).imag(), r.imag());
-    r = a/c; ASSERT_FLOAT_EQ(h_results(11).real(), r.real()); ASSERT_FLOAT_EQ(h_results(11).imag(), r.imag());
-    r = d+c; ASSERT_FLOAT_EQ(h_results(12).real(), r.real()); ASSERT_FLOAT_EQ(h_results(12).imag(), r.imag());
-    r = d-c; ASSERT_FLOAT_EQ(h_results(13).real(), r.real()); ASSERT_FLOAT_EQ(h_results(13).imag(), r.imag());
-    r = d*c; ASSERT_FLOAT_EQ(h_results(14).real(), r.real()); ASSERT_FLOAT_EQ(h_results(14).imag(), r.imag());
-    r = d/c; ASSERT_FLOAT_EQ(h_results(15).real(), r.real()); ASSERT_FLOAT_EQ(h_results(15).imag(), r.imag());
-    r = c+a; ASSERT_FLOAT_EQ(h_results(16).real(), r.real()); ASSERT_FLOAT_EQ(h_results(16).imag(), r.imag());
-    r = c-a; ASSERT_FLOAT_EQ(h_results(17).real(), r.real()); ASSERT_FLOAT_EQ(h_results(17).imag(), r.imag());
-    r = c*a; ASSERT_FLOAT_EQ(h_results(18).real(), r.real()); ASSERT_FLOAT_EQ(h_results(18).imag(), r.imag());
-    r = c/a; ASSERT_FLOAT_EQ(h_results(19).real(), r.real()); ASSERT_FLOAT_EQ(h_results(19).imag(), r.imag());
-
-    r = a; 
-    /* r = a+e; */ ASSERT_FLOAT_EQ(h_results(20).real(),  r.real()+e); ASSERT_FLOAT_EQ(h_results(20).imag(),  r.imag());
-    /* r = a-e; */ ASSERT_FLOAT_EQ(h_results(21).real(),  r.real()-e); ASSERT_FLOAT_EQ(h_results(21).imag(),  r.imag());
-    /* r = a*e; */ ASSERT_FLOAT_EQ(h_results(22).real(),  r.real()*e); ASSERT_FLOAT_EQ(h_results(22).imag(),  r.imag()*e);
-    /* r = a/e; */ ASSERT_FLOAT_EQ(h_results(23).real(),  r.real()/2); ASSERT_FLOAT_EQ(h_results(23).imag(),  r.imag()/e);
+    r = a + b;
+    ASSERT_FLOAT_EQ(h_results(0).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(0).imag(), r.imag());
+    r = a - b;
+    ASSERT_FLOAT_EQ(h_results(1).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(1).imag(), r.imag());
+    r = a * b;
+    ASSERT_FLOAT_EQ(h_results(2).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(2).imag(), r.imag());
+    r = a / b;
+    ASSERT_FLOAT_EQ(h_results(3).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(3).imag(), r.imag());
+    r = d + a;
+    ASSERT_FLOAT_EQ(h_results(4).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(4).imag(), r.imag());
+    r = d - a;
+    ASSERT_FLOAT_EQ(h_results(5).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(5).imag(), r.imag());
+    r = d * a;
+    ASSERT_FLOAT_EQ(h_results(6).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(6).imag(), r.imag());
+    r = d / a;
+    ASSERT_FLOAT_EQ(h_results(7).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(7).imag(), r.imag());
+    r = a + c;
+    ASSERT_FLOAT_EQ(h_results(8).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(8).imag(), r.imag());
+    r = a - c;
+    ASSERT_FLOAT_EQ(h_results(9).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(9).imag(), r.imag());
+    r = a * c;
+    ASSERT_FLOAT_EQ(h_results(10).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(10).imag(), r.imag());
+    r = a / c;
+    ASSERT_FLOAT_EQ(h_results(11).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(11).imag(), r.imag());
+    r = d + c;
+    ASSERT_FLOAT_EQ(h_results(12).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(12).imag(), r.imag());
+    r = d - c;
+    ASSERT_FLOAT_EQ(h_results(13).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(13).imag(), r.imag());
+    r = d * c;
+    ASSERT_FLOAT_EQ(h_results(14).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(14).imag(), r.imag());
+    r = d / c;
+    ASSERT_FLOAT_EQ(h_results(15).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(15).imag(), r.imag());
+    r = c + a;
+    ASSERT_FLOAT_EQ(h_results(16).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(16).imag(), r.imag());
+    r = c - a;
+    ASSERT_FLOAT_EQ(h_results(17).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(17).imag(), r.imag());
+    r = c * a;
+    ASSERT_FLOAT_EQ(h_results(18).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(18).imag(), r.imag());
+    r = c / a;
+    ASSERT_FLOAT_EQ(h_results(19).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(19).imag(), r.imag());
+
+    r = a;
+    /* r = a+e; */ ASSERT_FLOAT_EQ(h_results(20).real(), r.real() + e);
+    ASSERT_FLOAT_EQ(h_results(20).imag(), r.imag());
+    /* r = a-e; */ ASSERT_FLOAT_EQ(h_results(21).real(), r.real() - e);
+    ASSERT_FLOAT_EQ(h_results(21).imag(), r.imag());
+    /* r = a*e; */ ASSERT_FLOAT_EQ(h_results(22).real(), r.real() * e);
+    ASSERT_FLOAT_EQ(h_results(22).imag(), r.imag() * e);
+    /* r = a/e; */ ASSERT_FLOAT_EQ(h_results(23).real(), r.real() / 2);
+    ASSERT_FLOAT_EQ(h_results(23).imag(), r.imag() / e);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int &i ) const {
-    Kokkos::complex<double> a(1.5,2.5);
-    Kokkos::complex<double> b(3.25,5.75);
+  void operator()(const int &i) const {
+    Kokkos::complex<double> a(1.5, 2.5);
+    Kokkos::complex<double> b(3.25, 5.75);
     // Basic math complex / complex
-    d_results(0) = a+b;
-    d_results(1) = a-b;
-    d_results(2) = a*b;
-    d_results(3) = a/b;
+    d_results(0) = a + b;
+    d_results(1) = a - b;
+    d_results(2) = a * b;
+    d_results(3) = a / b;
     d_results(4).real(1.0);
     d_results(4).imag(2.0);
     d_results(4) += a;
-    d_results(5) = Kokkos::complex<double>(1.0,2.0);
+    d_results(5) = Kokkos::complex<double>(1.0, 2.0);
     d_results(5) -= a;
-    d_results(6) = Kokkos::complex<double>(1.0,2.0);
+    d_results(6) = Kokkos::complex<double>(1.0, 2.0);
     d_results(6) *= a;
-    d_results(7) = Kokkos::complex<double>(1.0,2.0);
+    d_results(7) = Kokkos::complex<double>(1.0, 2.0);
     d_results(7) /= a;
 
     // Basic math complex / scalar
-    double c = 9.3;
-    d_results(8) = a+c;
-    d_results(9) = a-c;
-    d_results(10) = a*c;
-    d_results(11) = a/c;
+    double c      = 9.3;
+    d_results(8)  = a + c;
+    d_results(9)  = a - c;
+    d_results(10) = a * c;
+    d_results(11) = a / c;
     d_results(12).real(1.0);
     d_results(12).imag(2.0);
     d_results(12) += c;
-    d_results(13) = Kokkos::complex<double>(1.0,2.0);
+    d_results(13) = Kokkos::complex<double>(1.0, 2.0);
     d_results(13) -= c;
-    d_results(14) = Kokkos::complex<double>(1.0,2.0);
+    d_results(14) = Kokkos::complex<double>(1.0, 2.0);
     d_results(14) *= c;
-    d_results(15) = Kokkos::complex<double>(1.0,2.0);
+    d_results(15) = Kokkos::complex<double>(1.0, 2.0);
     d_results(15) /= c;
 
-
     // Basic math scalar / complex
-    d_results(16) = c+a;
-    d_results(17) = c-a;
-    d_results(18) = c*a;
-    d_results(19) = c/a;
-
-    int e = 2;
-    d_results(20) = a+e;
-    d_results(21) = a-e;
-    d_results(22) = a*e;
-    d_results(23) = a/e;
+    d_results(16) = c + a;
+    d_results(17) = c - a;
+    d_results(18) = c * a;
+    d_results(19) = c / a;
+
+    int e         = 2;
+    d_results(20) = a + e;
+    d_results(21) = a - e;
+    d_results(22) = a * e;
+    d_results(23) = a / e;
   }
 };
 
-TEST_F(TEST_CATEGORY, complex_basic_math) {
+TEST(TEST_CATEGORY, complex_basic_math) {
   TestComplexBasicMath<TEST_EXECSPACE> test;
   test.testit();
 }
 
-
-template<class ExecSpace>
+template <class ExecSpace>
 struct TestComplexSpecialFunctions {
-  Kokkos::View<Kokkos::complex<double>*,ExecSpace> d_results;
-  typename Kokkos::View<Kokkos::complex<double>*,ExecSpace>::HostMirror h_results;
+  Kokkos::View<Kokkos::complex<double> *, ExecSpace> d_results;
+  typename Kokkos::View<Kokkos::complex<double> *, ExecSpace>::HostMirror
+      h_results;
 
-  void testit () {
-    d_results = Kokkos::View<Kokkos::complex<double>*,ExecSpace>("TestComplexSpecialFunctions",20);
+  void testit() {
+    d_results = Kokkos::View<Kokkos::complex<double> *, ExecSpace>(
+        "TestComplexSpecialFunctions", 20);
     h_results = Kokkos::create_mirror_view(d_results);
 
-    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0,1), *this);
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, 1), *this);
     Kokkos::fence();
-    Kokkos::deep_copy(h_results,d_results);
+    Kokkos::deep_copy(h_results, d_results);
 
-    std::complex<double> a(1.5,2.5);
+    std::complex<double> a(1.5, 2.5);
     double c = 9.3;
 
     std::complex<double> r;
-    r = a;               ASSERT_FLOAT_EQ(h_results(0).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(0).imag(),  r.imag());
-    r = std::sqrt(a);    ASSERT_FLOAT_EQ(h_results(1).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(1).imag(),  r.imag());
-    r = std::pow(a,c);   ASSERT_FLOAT_EQ(h_results(2).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(2).imag(),  r.imag());
-    r = std::abs(a);     ASSERT_FLOAT_EQ(h_results(3).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(3).imag(),  r.imag());
-    r = std::exp(a);     ASSERT_FLOAT_EQ(h_results(4).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(4).imag(),  r.imag());
-    r = Kokkos::exp(a);  ASSERT_FLOAT_EQ(h_results(4).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(4).imag(),  r.imag());
+    r = a;
+    ASSERT_FLOAT_EQ(h_results(0).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(0).imag(), r.imag());
+    r = std::sqrt(a);
+    ASSERT_FLOAT_EQ(h_results(1).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(1).imag(), r.imag());
+    r = std::pow(a, c);
+    ASSERT_FLOAT_EQ(h_results(2).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(2).imag(), r.imag());
+    r = std::abs(a);
+    ASSERT_FLOAT_EQ(h_results(3).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(3).imag(), r.imag());
+    r = std::exp(a);
+    ASSERT_FLOAT_EQ(h_results(4).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(4).imag(), r.imag());
+    r = Kokkos::exp(a);
+    ASSERT_FLOAT_EQ(h_results(4).real(), r.real());
+    ASSERT_FLOAT_EQ(h_results(4).imag(), r.imag());
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int &i ) const {
-    Kokkos::complex<double> a(1.5,2.5);
-    Kokkos::complex<double> b(3.25,5.75);
+  void operator()(const int &i) const {
+    Kokkos::complex<double> a(1.5, 2.5);
+    Kokkos::complex<double> b(3.25, 5.75);
     double c = 9.3;
 
-    d_results(0) = Kokkos::complex<double>(Kokkos::real(a),Kokkos::imag(a));
+    d_results(0) = Kokkos::complex<double>(Kokkos::real(a), Kokkos::imag(a));
     d_results(1) = Kokkos::sqrt(a);
-    d_results(2) = Kokkos::pow(a,c);
+    d_results(2) = Kokkos::pow(a, c);
     d_results(3) = Kokkos::abs(a);
     d_results(4) = Kokkos::exp(a);
-
   }
 };
 
-TEST_F(TEST_CATEGORY, complex_special_funtions) {
+void testComplexIO() {
+  Kokkos::complex<double> z = {3.14, 1.41};
+  std::stringstream ss;
+  ss << z;
+  ASSERT_EQ(ss.str(), "(3.14,1.41)");
+
+  ss.str("1 (2) (3,4)");
+  ss.clear();
+  ss >> z;
+  ASSERT_EQ(z, (Kokkos::complex<double>{1, 0}));
+  ss >> z;
+  ASSERT_EQ(z, (Kokkos::complex<double>{2, 0}));
+  ss >> z;
+  ASSERT_EQ(z, (Kokkos::complex<double>{3, 4}));
+}
+
+TEST(TEST_CATEGORY, complex_special_funtions) {
   TestComplexSpecialFunctions<TEST_EXECSPACE> test;
   test.testit();
 }
-} // namespace Test
 
+TEST(TEST_CATEGORY, complex_io) { testComplexIO(); }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestConcurrentBitset.hpp b/lib/kokkos/core/unit_test/TestConcurrentBitset.hpp
index f479998ede4a6b0b054da947f1cfabd356b60ed6..db451495b460cb11c1fc368447ba4ad93f447fac 100644
--- a/lib/kokkos/core/unit_test/TestConcurrentBitset.hpp
+++ b/lib/kokkos/core/unit_test/TestConcurrentBitset.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -54,124 +55,115 @@
 
 namespace Test {
 
-template< class DeviceType >
+template <class DeviceType>
 struct ConcurrentBitset {
-
-  typedef Kokkos::View<uint32_t*,DeviceType> view_unsigned_type ;
-  typedef Kokkos::View<int*,DeviceType>      view_int_type ;
-
-  view_unsigned_type  bitset ;
-  view_int_type       acquired ;
-  uint32_t            bitset_count_lg2 ;
-  uint32_t            bitset_count_mask ;
-
-  ConcurrentBitset( const uint32_t arg_bitset_count_lg2
-                  , const view_unsigned_type & arg_bitset
-                  , const view_int_type & arg_acquired )
-    : bitset( arg_bitset ), acquired( arg_acquired )
-    , bitset_count_lg2( arg_bitset_count_lg2 )
-    , bitset_count_mask( uint32_t( 1u << arg_bitset_count_lg2 ) - 1 )
-    {}
+  typedef Kokkos::View<uint32_t*, DeviceType> view_unsigned_type;
+  typedef Kokkos::View<int*, DeviceType> view_int_type;
+
+  view_unsigned_type bitset;
+  view_int_type acquired;
+  uint32_t bitset_count_lg2;
+  uint32_t bitset_count_mask;
+
+  ConcurrentBitset(const uint32_t arg_bitset_count_lg2,
+                   const view_unsigned_type& arg_bitset,
+                   const view_int_type& arg_acquired)
+      : bitset(arg_bitset),
+        acquired(arg_acquired),
+        bitset_count_lg2(arg_bitset_count_lg2),
+        bitset_count_mask(uint32_t(1u << arg_bitset_count_lg2) - 1) {}
 
   struct TagAcquire {};
   struct TagRelease {};
   struct TagReacquire {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagAcquire , int i , long & update ) const
-    {
-      unsigned hint = Kokkos::Impl::clock_tic() & bitset_count_mask ;
+  void operator()(TagAcquire, int i, long& update) const {
+    unsigned hint = Kokkos::Impl::clock_tic() & bitset_count_mask;
 
-      Kokkos::pair<int,int> result =
-        Kokkos::Impl::concurrent_bitset::acquire_bounded_lg2
-          ( bitset.data() , bitset_count_lg2 , hint );
+    Kokkos::pair<int, int> result =
+        Kokkos::Impl::concurrent_bitset::acquire_bounded_lg2(
+            bitset.data(), bitset_count_lg2, hint);
 
-      acquired(i) = result.first ;
+    acquired(i) = result.first;
 
-      if ( 0 <= result.first ) ++update ;
-    }
+    if (0 <= result.first) ++update;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagRelease , int i , long & update ) const
-    {
-      if ( 0 == ( i % 3 ) && 0 <= acquired(i) ) {
-        Kokkos::Impl::concurrent_bitset::release( bitset.data() , acquired(i) );
-        acquired(i) = -1 ;
-        ++update ;
-      }
+  void operator()(TagRelease, int i, long& update) const {
+    if (0 == (i % 3) && 0 <= acquired(i)) {
+      Kokkos::Impl::concurrent_bitset::release(bitset.data(), acquired(i));
+      acquired(i) = -1;
+      ++update;
     }
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagReacquire , int i , long & update ) const
-    {
-      if ( acquired(i) < 0 ) {
-
-        unsigned hint = Kokkos::Impl::clock_tic() & bitset_count_mask ;
+  void operator()(TagReacquire, int i, long& update) const {
+    if (acquired(i) < 0) {
+      unsigned hint = Kokkos::Impl::clock_tic() & bitset_count_mask;
 
-        Kokkos::pair<int,int> result  = Kokkos::Impl::concurrent_bitset::acquire_bounded_lg2
-            ( bitset.data() , bitset_count_lg2 , hint );
+      Kokkos::pair<int, int> result =
+          Kokkos::Impl::concurrent_bitset::acquire_bounded_lg2(
+              bitset.data(), bitset_count_lg2, hint);
 
-        acquired(i) = result.first ;
+      acquired(i) = result.first;
 
-        if ( 0 <= result.first ) ++update ;
-      }
+      if (0 <= result.first) ++update;
     }
+  }
 };
 
-template< class DeviceType >
-void test_concurrent_bitset( int bit_count )
-{
-  typedef ConcurrentBitset< DeviceType > Functor ;
-  typedef typename Functor::view_unsigned_type view_unsigned_type ;
-  typedef typename Functor::view_int_type      view_int_type ;
+template <class DeviceType>
+void test_concurrent_bitset(int bit_count) {
+  typedef ConcurrentBitset<DeviceType> Functor;
+  typedef typename Functor::view_unsigned_type view_unsigned_type;
+  typedef typename Functor::view_int_type view_int_type;
 
-  int bit_count_lg2 = 1 ;
+  int bit_count_lg2 = 1;
 
-  while ( ( 1 << bit_count_lg2 ) < bit_count ) ++bit_count_lg2 ;
+  while ((1 << bit_count_lg2) < bit_count) ++bit_count_lg2;
 
-  bit_count = 1 << bit_count_lg2 ;
+  bit_count = 1 << bit_count_lg2;
 
   const int buffer_length =
-    Kokkos::Impl::concurrent_bitset::buffer_bound_lg2(bit_count_lg2);
+      Kokkos::Impl::concurrent_bitset::buffer_bound_lg2(bit_count_lg2);
 
-  view_unsigned_type bitset("bitset",buffer_length);
+  view_unsigned_type bitset("bitset", buffer_length);
 
   // Try to acquire more than available:
 
-  const size_t n = ( bit_count * 3 ) / 2 ;
+  const size_t n = (bit_count * 3) / 2;
 
-  view_int_type acquired("acquired", n );
+  view_int_type acquired("acquired", n);
 
   typename view_unsigned_type::HostMirror bitset_host =
-    Kokkos::create_mirror_view( bitset );
-
-  Kokkos::deep_copy( bitset , 0u );
+      Kokkos::create_mirror_view(bitset);
 
-  long total = 0 ;
-  long total_release = 0 ;
-  long total_reacquire = 0 ;
+  Kokkos::deep_copy(bitset, 0u);
 
-  Kokkos::parallel_reduce
-    ( Kokkos::RangePolicy< DeviceType , typename Functor::TagAcquire >(0,n)
-    , Functor( bit_count_lg2 , bitset , acquired )
-    , total );
+  long total           = 0;
+  long total_release   = 0;
+  long total_reacquire = 0;
 
-  ASSERT_EQ( bit_count , total );
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<DeviceType, typename Functor::TagAcquire>(0, n),
+      Functor(bit_count_lg2, bitset, acquired), total);
 
-  Kokkos::parallel_reduce
-    ( Kokkos::RangePolicy< DeviceType , typename Functor::TagRelease >(0,n)
-    , Functor( bit_count_lg2 , bitset , acquired )
-    , total_release );
+  ASSERT_EQ(bit_count, total);
 
-  Kokkos::parallel_reduce
-    ( Kokkos::RangePolicy< DeviceType , typename Functor::TagReacquire >(0,n)
-    , Functor( bit_count_lg2 , bitset , acquired )
-    , total_reacquire );
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<DeviceType, typename Functor::TagRelease>(0, n),
+      Functor(bit_count_lg2, bitset, acquired), total_release);
 
-  ASSERT_EQ( total_release , total_reacquire );
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<DeviceType, typename Functor::TagReacquire>(0, n),
+      Functor(bit_count_lg2, bitset, acquired), total_reacquire);
 
+  ASSERT_EQ(total_release, total_reacquire);
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif /* #ifndef TEST_CONCURRENTBITSET_HPP */
diff --git a/lib/kokkos/core/unit_test/TestCrs.hpp b/lib/kokkos/core/unit_test/TestCrs.hpp
index 08087ae0625b62aabecbe03a07d840ada9ae046b..580710960191f306d152835c5ddd600fa0a24a31 100644
--- a/lib/kokkos/core/unit_test/TestCrs.hpp
+++ b/lib/kokkos/core/unit_test/TestCrs.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,10 +50,10 @@ namespace Test {
 
 namespace {
 
-template< class ExecSpace >
+template <class ExecSpace>
 struct CountFillFunctor {
   KOKKOS_INLINE_FUNCTION
-  std::int32_t operator()(std::int32_t row, std::int32_t* fill) const {
+  std::int32_t operator()(std::int32_t row, std::int32_t *fill) const {
     auto n = (row % 4) + 1;
     if (fill) {
       for (std::int32_t j = 0; j < n; ++j) {
@@ -65,85 +66,92 @@ struct CountFillFunctor {
 
 /* RunUpdateCrsTest
  *   4 test cases:
- *     1. use member object version which is constructed directly using the copy constructor
+ *     1. use member object version which is constructed directly using the copy
+ * constructor
  *     2. excplicity copy construct in local variable
  *     3. construct default and assign to input object
  *     4. construct object from views
  */
-template< class CrsType, class ExecSpace, class scalarType >
+template <class CrsType, class ExecSpace, class scalarType>
 struct RunUpdateCrsTest {
-
   struct TestOne {};
   struct TestTwo {};
   struct TestThree {};
   struct TestFour {};
 
   CrsType graph;
-  RunUpdateCrsTest( CrsType g_in ) : graph(g_in)
-  {
-  }
+  RunUpdateCrsTest(CrsType g_in) : graph(g_in) {}
 
   void run_test(int nTest) {
-     switch (nTest)
-     {
-        case 1:
-           parallel_for ("TestCrs1", Kokkos::RangePolicy<ExecSpace, TestOne>(0,graph.numRows()),*this);
-           break;
-        case 2:
-           parallel_for ("TestCrs2", Kokkos::RangePolicy<ExecSpace, TestTwo>(0,graph.numRows()),*this);
-           break;
-        case 3:
-           parallel_for ("TestCrs3", Kokkos::RangePolicy<ExecSpace, TestThree>(0,graph.numRows()),*this);
-           break;
-        case 4:
-           parallel_for ("TestCrs4", Kokkos::RangePolicy<ExecSpace, TestFour>(0,graph.numRows()),*this);
-           break;
-        default:
-           break;
-     }
+    switch (nTest) {
+      case 1:
+        parallel_for(
+            "TestCrs1",
+            Kokkos::RangePolicy<ExecSpace, TestOne>(0, graph.numRows()), *this);
+        break;
+      case 2:
+        parallel_for(
+            "TestCrs2",
+            Kokkos::RangePolicy<ExecSpace, TestTwo>(0, graph.numRows()), *this);
+        break;
+      case 3:
+        parallel_for(
+            "TestCrs3",
+            Kokkos::RangePolicy<ExecSpace, TestThree>(0, graph.numRows()),
+            *this);
+        break;
+      case 4:
+        parallel_for(
+            "TestCrs4",
+            Kokkos::RangePolicy<ExecSpace, TestFour>(0, graph.numRows()),
+            *this);
+        break;
+      default: break;
+    }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void updateGraph(const CrsType & g_in, const scalarType row) const {
-     auto row_map = g_in.row_map;
-     auto entries = g_in.entries;
-     auto j_start = row_map(row);
-     auto j_end = row_map(row+1)-j_start;
-     for (scalarType j = 0; j < j_end; ++j) {
-        entries(j_start+j) = (j+1)*(j+1);
-     }
+  void updateGraph(const CrsType &g_in, const scalarType row) const {
+    auto row_map = g_in.row_map;
+    auto entries = g_in.entries;
+    auto j_start = row_map(row);
+    auto j_end   = row_map(row + 1) - j_start;
+    for (scalarType j = 0; j < j_end; ++j) {
+      entries(j_start + j) = (j + 1) * (j + 1);
+    }
   }
 
   // Test Crs class from class member
   KOKKOS_INLINE_FUNCTION
   void operator()(const TestOne &, const scalarType row) const {
-      updateGraph(graph, row);
+    updateGraph(graph, row);
   }
 
   // Test Crs class from copy constructor (local_graph(graph)
   KOKKOS_INLINE_FUNCTION
   void operator()(const TestTwo &, const scalarType row) const {
-      CrsType local_graph(graph);
-      updateGraph(local_graph, row);
+    CrsType local_graph(graph);
+    updateGraph(local_graph, row);
   }
 
   // Test Crs class from default constructor assigned to function parameter
   KOKKOS_INLINE_FUNCTION
   void operator()(const TestThree &, const scalarType row) const {
-      CrsType local_graph;
-      local_graph = graph;
-      updateGraph(local_graph, row);
+    CrsType local_graph;
+    local_graph = graph;
+    updateGraph(local_graph, row);
   }
 
-  // Test Crs class from local graph constructed from row_map and entities access on input parameter)
+  // Test Crs class from local graph constructed from row_map and entities
+  // access on input parameter)
   KOKKOS_INLINE_FUNCTION
   void operator()(const TestFour &, const scalarType row) const {
-      CrsType local_graph(graph.row_map, graph.entries);
-      updateGraph(local_graph, row);
+    CrsType local_graph(graph.row_map, graph.entries);
+    updateGraph(local_graph, row);
   }
 };
 
-template< class ExecSpace >
+template <class ExecSpace>
 void test_count_fill(std::int32_t nrows) {
   Kokkos::Crs<std::int32_t, ExecSpace, void, std::int32_t> graph;
   Kokkos::count_and_fill_crs(graph, nrows, CountFillFunctor<ExecSpace>());
@@ -161,42 +169,39 @@ void test_count_fill(std::int32_t nrows) {
   }
 }
 
-// Test Crs Constructor / assignment operation by 
+// Test Crs Constructor / assignment operation by
 // using count and fill to create/populate initial graph,
 // then use parallel_for with Crs directly to update content
 // then verify results
-template< class ExecSpace >
+template <class ExecSpace>
 void test_constructor(std::int32_t nrows) {
-
-  for (int nTest = 1; nTest < 5; nTest++)
-  {
-     typedef Kokkos::Crs<std::int32_t, ExecSpace, void, std::int32_t> crs_int32;
-     crs_int32 graph;
-     Kokkos::count_and_fill_crs(graph, nrows, CountFillFunctor<ExecSpace>());
-     ASSERT_EQ(graph.numRows(), nrows);
-
-     RunUpdateCrsTest<crs_int32, ExecSpace, std::int32_t> crstest(graph);
-     crstest.run_test(nTest);
-
-     auto row_map = Kokkos::create_mirror_view(graph.row_map);
-     Kokkos::deep_copy(row_map, graph.row_map);
-     auto entries = Kokkos::create_mirror_view(graph.entries);
-     Kokkos::deep_copy(entries, graph.entries);
-
-     for (std::int32_t row = 0; row < nrows; ++row) {
-       auto n = (row % 4) + 1;
-       ASSERT_EQ(row_map(row + 1) - row_map(row), n);    
-       for (std::int32_t j = 0; j < n; ++j) {
-         ASSERT_EQ(entries(row_map(row) + j), (j + 1)*(j+1));
-       }
-     }
+  for (int nTest = 1; nTest < 5; nTest++) {
+    typedef Kokkos::Crs<std::int32_t, ExecSpace, void, std::int32_t> crs_int32;
+    crs_int32 graph;
+    Kokkos::count_and_fill_crs(graph, nrows, CountFillFunctor<ExecSpace>());
+    ASSERT_EQ(graph.numRows(), nrows);
+
+    RunUpdateCrsTest<crs_int32, ExecSpace, std::int32_t> crstest(graph);
+    crstest.run_test(nTest);
+
+    auto row_map = Kokkos::create_mirror_view(graph.row_map);
+    Kokkos::deep_copy(row_map, graph.row_map);
+    auto entries = Kokkos::create_mirror_view(graph.entries);
+    Kokkos::deep_copy(entries, graph.entries);
+
+    for (std::int32_t row = 0; row < nrows; ++row) {
+      auto n = (row % 4) + 1;
+      ASSERT_EQ(row_map(row + 1) - row_map(row), n);
+      for (std::int32_t j = 0; j < n; ++j) {
+        ASSERT_EQ(entries(row_map(row) + j), (j + 1) * (j + 1));
+      }
+    }
   }
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
-TEST_F( TEST_CATEGORY, crs_count_fill )
-{
+TEST(TEST_CATEGORY, crs_count_fill) {
   test_count_fill<TEST_EXECSPACE>(0);
   test_count_fill<TEST_EXECSPACE>(1);
   test_count_fill<TEST_EXECSPACE>(2);
@@ -207,8 +212,7 @@ TEST_F( TEST_CATEGORY, crs_count_fill )
   test_count_fill<TEST_EXECSPACE>(10000);
 }
 
-TEST_F( TEST_CATEGORY, crs_copy_constructor )
-{
+TEST(TEST_CATEGORY, crs_copy_constructor) {
   test_constructor<TEST_EXECSPACE>(0);
   test_constructor<TEST_EXECSPACE>(1);
   test_constructor<TEST_EXECSPACE>(2);
@@ -219,5 +223,4 @@ TEST_F( TEST_CATEGORY, crs_copy_constructor )
   test_constructor<TEST_EXECSPACE>(10000);
 }
 
-
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestDeepCopy.hpp b/lib/kokkos/core/unit_test/TestDeepCopy.hpp
index aebf263290b78c7f08e4d9af72fa10b00221820a..a7e80cef366742e4a78bdb74f5943eebc6dd2da0 100644
--- a/lib/kokkos/core/unit_test/TestDeepCopy.hpp
+++ b/lib/kokkos/core/unit_test/TestDeepCopy.hpp
@@ -1,11 +1,10 @@
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 
 namespace Test {
 
 namespace Impl {
-template<class MemorySpaceA, class MemorySpaceB>
+template <class MemorySpaceA, class MemorySpaceB>
 struct TestDeepCopy {
-
   typedef Kokkos::View<double*, Kokkos::LayoutRight, MemorySpaceA> a_base_t;
   typedef Kokkos::View<double*, Kokkos::LayoutRight, MemorySpaceB> b_base_t;
   typedef Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char_t;
@@ -14,59 +13,76 @@ struct TestDeepCopy {
   typedef Kokkos::RangePolicy<typename MemorySpaceA::execution_space> policyA_t;
   typedef Kokkos::RangePolicy<typename MemorySpaceB::execution_space> policyB_t;
 
-  static void reset_a_copy_and_b(Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char_copy, Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceB> b_char) {
+  static void reset_a_copy_and_b(
+      Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char_copy,
+      Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceB> b_char) {
     const int N = b_char.extent(0);
-    Kokkos::parallel_for("TestDeepCopy: FillA_copy",policyA_t(0,N), KOKKOS_LAMBDA (const int& i) {
-      a_char_copy(i) = char(0);
-    });
-    Kokkos::parallel_for("TestDeepCopy: FillB",policyB_t(0,N), KOKKOS_LAMBDA (const int& i) {
-      b_char(i) = char(0);
-    });
+    Kokkos::parallel_for(
+        "TestDeepCopy: FillA_copy", policyA_t(0, N),
+        KOKKOS_LAMBDA(const int& i) { a_char_copy(i) = char(0); });
+    Kokkos::parallel_for(
+        "TestDeepCopy: FillB", policyB_t(0, N),
+        KOKKOS_LAMBDA(const int& i) { b_char(i) = char(0); });
   }
 
-  static int compare_equal(Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char_copy, Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char) {
+  static int compare_equal(
+      Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char_copy,
+      Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char) {
     const int N = a_char.extent(0);
     int errors;
-    Kokkos::parallel_reduce("TestDeepCopy: FillA_copy",policyA_t(0,N), KOKKOS_LAMBDA (const int& i, int& lsum) {
-      if(a_char_copy(i) != a_char(i)) lsum++;
-    },errors);
+    Kokkos::parallel_reduce(
+        "TestDeepCopy: FillA_copy", policyA_t(0, N),
+        KOKKOS_LAMBDA(const int& i, int& lsum) {
+          if (a_char_copy(i) != a_char(i)) lsum++;
+        },
+        errors);
     return errors;
   }
 
   static void run_test(int num_bytes) {
-    a_base_t a_base("test_space_to_space",(num_bytes+128)/8);
-    a_base_t a_base_copy("test_space_to_space",(num_bytes+128)/8);
-    Kokkos::View<double*, Kokkos::LayoutRight, MemorySpaceB> b_base("test_space_to_space",(num_bytes+128)/8);
-    
-    Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char((char*) a_base.data(),a_base.extent(0)*8);
-    Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char_copy((char*) a_base_copy.data(),a_base.extent(0)*8);
-    Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceB> b_char((char*) b_base.data(),b_base.extent(0)*8);
-
-    Kokkos::parallel_for("TestDeepCopy: FillA",policyA_t(0,a_char.extent(0)), KOKKOS_LAMBDA (const int& i) {
-      a_char(i) = static_cast<char>(i%97)+1;
-    });
+    a_base_t a_base("test_space_to_space", (num_bytes + 128) / 8);
+    a_base_t a_base_copy("test_space_to_space", (num_bytes + 128) / 8);
+    Kokkos::View<double*, Kokkos::LayoutRight, MemorySpaceB> b_base(
+        "test_space_to_space", (num_bytes + 128) / 8);
+
+    Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char(
+        (char*)a_base.data(), a_base.extent(0) * 8);
+    Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceA> a_char_copy(
+        (char*)a_base_copy.data(), a_base.extent(0) * 8);
+    Kokkos::View<char*, Kokkos::LayoutRight, MemorySpaceB> b_char(
+        (char*)b_base.data(), b_base.extent(0) * 8);
+
+    Kokkos::parallel_for(
+        "TestDeepCopy: FillA", policyA_t(0, a_char.extent(0)),
+        KOKKOS_LAMBDA(const int& i) {
+          a_char(i) = static_cast<char>(i % 97) + 1;
+        });
 
     reset_a_copy_and_b(a_char_copy, b_char);
 
     {
-      int check = compare_equal(a_char_copy,a_char);
-      ASSERT_EQ( check, a_char.extent(0) );
+      int check = compare_equal(a_char_copy, a_char);
+      ASSERT_EQ(check, a_char.extent(0));
     }
 
-    // (a.data()%8, (a.data()+a.extent(0))%8, b.data()%8, (b.data()+b.extent(0))%8
-    // (0,0,0,0) 
+    // (a.data()%8, (a.data()+a.extent(0))%8, b.data()%8,
+    // (b.data()+b.extent(0))%8 (0,0,0,0)
     {
       int a_begin = 0;
       int a_end   = 0;
       int b_begin = 0;
       int b_end   = 0;
-      auto a = Kokkos::subview(a_char,std::pair<int,int>(a_begin,a_char.extent(0)-a_end));
-      auto b = Kokkos::subview(b_char,std::pair<int,int>(b_begin,b_char.extent(0)-b_end));
-      auto a_copy = Kokkos::subview(a_char_copy,std::pair<int,int>(a_begin,a_char_copy.extent(0)-a_end));
-      Kokkos::deep_copy(b,a);
-      Kokkos::deep_copy(a_copy,b);
-      int check = compare_equal(a_copy,a);
-      ASSERT_EQ( check, 0 );
+      auto a      = Kokkos::subview(
+          a_char, std::pair<int, int>(a_begin, a_char.extent(0) - a_end));
+      auto b = Kokkos::subview(
+          b_char, std::pair<int, int>(b_begin, b_char.extent(0) - b_end));
+      auto a_copy = Kokkos::subview(
+          a_char_copy,
+          std::pair<int, int>(a_begin, a_char_copy.extent(0) - a_end));
+      Kokkos::deep_copy(b, a);
+      Kokkos::deep_copy(a_copy, b);
+      int check = compare_equal(a_copy, a);
+      ASSERT_EQ(check, 0);
     }
 
     {
@@ -74,27 +90,35 @@ struct TestDeepCopy {
       int a_end   = 5;
       int b_begin = 0;
       int b_end   = 5;
-      auto a = Kokkos::subview(a_char,std::pair<int,int>(a_begin,a_char.extent(0)-a_end));
-      auto b = Kokkos::subview(b_char,std::pair<int,int>(b_begin,b_char.extent(0)-b_end));
-      auto a_copy = Kokkos::subview(a_char_copy,std::pair<int,int>(a_begin,a_char_copy.extent(0)-a_end));
-      Kokkos::deep_copy(b,a);
-      Kokkos::deep_copy(a_copy,b);
-      int check = compare_equal(a_copy,a);
-      ASSERT_EQ( check, 0 );
+      auto a      = Kokkos::subview(
+          a_char, std::pair<int, int>(a_begin, a_char.extent(0) - a_end));
+      auto b = Kokkos::subview(
+          b_char, std::pair<int, int>(b_begin, b_char.extent(0) - b_end));
+      auto a_copy = Kokkos::subview(
+          a_char_copy,
+          std::pair<int, int>(a_begin, a_char_copy.extent(0) - a_end));
+      Kokkos::deep_copy(b, a);
+      Kokkos::deep_copy(a_copy, b);
+      int check = compare_equal(a_copy, a);
+      ASSERT_EQ(check, 0);
     }
-    
+
     {
       int a_begin = 3;
       int a_end   = 0;
       int b_begin = 3;
       int b_end   = 0;
-      auto a = Kokkos::subview(a_char,std::pair<int,int>(a_begin,a_char.extent(0)-a_end));
-      auto b = Kokkos::subview(b_char,std::pair<int,int>(b_begin,b_char.extent(0)-b_end));
-      auto a_copy = Kokkos::subview(a_char_copy,std::pair<int,int>(a_begin,a_char_copy.extent(0)-a_end));
-      Kokkos::deep_copy(b,a);
-      Kokkos::deep_copy(a_copy,b);
-      int check = compare_equal(a_copy,a);
-      ASSERT_EQ( check, 0 );
+      auto a      = Kokkos::subview(
+          a_char, std::pair<int, int>(a_begin, a_char.extent(0) - a_end));
+      auto b = Kokkos::subview(
+          b_char, std::pair<int, int>(b_begin, b_char.extent(0) - b_end));
+      auto a_copy = Kokkos::subview(
+          a_char_copy,
+          std::pair<int, int>(a_begin, a_char_copy.extent(0) - a_end));
+      Kokkos::deep_copy(b, a);
+      Kokkos::deep_copy(a_copy, b);
+      int check = compare_equal(a_copy, a);
+      ASSERT_EQ(check, 0);
     }
 
     {
@@ -102,13 +126,17 @@ struct TestDeepCopy {
       int a_end   = 6;
       int b_begin = 3;
       int b_end   = 6;
-      auto a = Kokkos::subview(a_char,std::pair<int,int>(a_begin,a_char.extent(0)-a_end));
-      auto b = Kokkos::subview(b_char,std::pair<int,int>(b_begin,b_char.extent(0)-b_end));
-      auto a_copy = Kokkos::subview(a_char_copy,std::pair<int,int>(a_begin,a_char_copy.extent(0)-a_end));
-      Kokkos::deep_copy(b,a);
-      Kokkos::deep_copy(a_copy,b);
-      int check = compare_equal(a_copy,a);
-      ASSERT_EQ( check, 0 );
+      auto a      = Kokkos::subview(
+          a_char, std::pair<int, int>(a_begin, a_char.extent(0) - a_end));
+      auto b = Kokkos::subview(
+          b_char, std::pair<int, int>(b_begin, b_char.extent(0) - b_end));
+      auto a_copy = Kokkos::subview(
+          a_char_copy,
+          std::pair<int, int>(a_begin, a_char_copy.extent(0) - a_end));
+      Kokkos::deep_copy(b, a);
+      Kokkos::deep_copy(a_copy, b);
+      int check = compare_equal(a_copy, a);
+      ASSERT_EQ(check, 0);
     }
 
     {
@@ -116,13 +144,17 @@ struct TestDeepCopy {
       int a_end   = 4;
       int b_begin = 3;
       int b_end   = 6;
-      auto a = Kokkos::subview(a_char,std::pair<int,int>(a_begin,a_char.extent(0)-a_end));
-      auto b = Kokkos::subview(b_char,std::pair<int,int>(b_begin,b_char.extent(0)-b_end));
-      auto a_copy = Kokkos::subview(a_char_copy,std::pair<int,int>(a_begin,a_char_copy.extent(0)-a_end));
-      Kokkos::deep_copy(b,a);
-      Kokkos::deep_copy(a_copy,b);
-      int check = compare_equal(a_copy,a);
-      ASSERT_EQ( check, 0 );
+      auto a      = Kokkos::subview(
+          a_char, std::pair<int, int>(a_begin, a_char.extent(0) - a_end));
+      auto b = Kokkos::subview(
+          b_char, std::pair<int, int>(b_begin, b_char.extent(0) - b_end));
+      auto a_copy = Kokkos::subview(
+          a_char_copy,
+          std::pair<int, int>(a_begin, a_char_copy.extent(0) - a_end));
+      Kokkos::deep_copy(b, a);
+      Kokkos::deep_copy(a_copy, b);
+      int check = compare_equal(a_copy, a);
+      ASSERT_EQ(check, 0);
     }
 
     {
@@ -130,38 +162,53 @@ struct TestDeepCopy {
       int a_end   = 8;
       int b_begin = 2;
       int b_end   = 6;
-      auto a = Kokkos::subview(a_char,std::pair<int,int>(a_begin,a_char.extent(0)-a_end));
-      auto b = Kokkos::subview(b_char,std::pair<int,int>(b_begin,b_char.extent(0)-b_end));
-      auto a_copy = Kokkos::subview(a_char_copy,std::pair<int,int>(a_begin,a_char_copy.extent(0)-a_end));
-      Kokkos::deep_copy(b,a);
-      Kokkos::deep_copy(a_copy,b);
-      int check = compare_equal(a_copy,a);
-      ASSERT_EQ( check, 0 );
+      auto a      = Kokkos::subview(
+          a_char, std::pair<int, int>(a_begin, a_char.extent(0) - a_end));
+      auto b = Kokkos::subview(
+          b_char, std::pair<int, int>(b_begin, b_char.extent(0) - b_end));
+      auto a_copy = Kokkos::subview(
+          a_char_copy,
+          std::pair<int, int>(a_begin, a_char_copy.extent(0) - a_end));
+      Kokkos::deep_copy(b, a);
+      Kokkos::deep_copy(a_copy, b);
+      int check = compare_equal(a_copy, a);
+      ASSERT_EQ(check, 0);
     }
-     
+
     {
       int a_begin = 2;
       int a_end   = 6;
       int b_begin = 0;
       int b_end   = 8;
-      auto a = Kokkos::subview(a_char,std::pair<int,int>(a_begin,a_char.extent(0)-a_end));
-      auto b = Kokkos::subview(b_char,std::pair<int,int>(b_begin,b_char.extent(0)-b_end));
-      auto a_copy = Kokkos::subview(a_char_copy,std::pair<int,int>(a_begin,a_char_copy.extent(0)-a_end));
-      Kokkos::deep_copy(b,a);
-      Kokkos::deep_copy(a_copy,b);
-      int check = compare_equal(a_copy,a);
-      ASSERT_EQ( check, 0 );
+      auto a      = Kokkos::subview(
+          a_char, std::pair<int, int>(a_begin, a_char.extent(0) - a_end));
+      auto b = Kokkos::subview(
+          b_char, std::pair<int, int>(b_begin, b_char.extent(0) - b_end));
+      auto a_copy = Kokkos::subview(
+          a_char_copy,
+          std::pair<int, int>(a_begin, a_char_copy.extent(0) - a_end));
+      Kokkos::deep_copy(b, a);
+      Kokkos::deep_copy(a_copy, b);
+      int check = compare_equal(a_copy, a);
+      ASSERT_EQ(check, 0);
     }
-
   }
 };
-}
+}  // namespace Impl
 
-TEST_F( TEST_CATEGORY, deep_copy_alignment )
-{
-  { Impl::TestDeepCopy< TEST_EXECSPACE::memory_space , TEST_EXECSPACE::memory_space >::run_test( 100000 ); }
-  { Impl::TestDeepCopy< Kokkos::HostSpace , TEST_EXECSPACE::memory_space >::run_test( 100000 ); }
-  { Impl::TestDeepCopy< TEST_EXECSPACE::memory_space , Kokkos::HostSpace >::run_test( 100000 ); }
+TEST(TEST_CATEGORY, deep_copy_alignment) {
+  {
+    Impl::TestDeepCopy<TEST_EXECSPACE::memory_space,
+                       TEST_EXECSPACE::memory_space>::run_test(100000);
+  }
+  {
+    Impl::TestDeepCopy<Kokkos::HostSpace,
+                       TEST_EXECSPACE::memory_space>::run_test(100000);
+  }
+  {
+    Impl::TestDeepCopy<TEST_EXECSPACE::memory_space,
+                       Kokkos::HostSpace>::run_test(100000);
+  }
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestDefaultDeviceTypeInit.hpp b/lib/kokkos/core/unit_test/TestDefaultDeviceTypeInit.hpp
index 1261948f87662b8146d4cc37c05c4fd58b194516..33c736c5e01aa2b0e1b33a4b813749ee68ebd220 100644
--- a/lib/kokkos/core/unit_test/TestDefaultDeviceTypeInit.hpp
+++ b/lib/kokkos/core/unit_test/TestDefaultDeviceTypeInit.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,106 +50,110 @@
 #include <omp.h>
 #endif
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 namespace Test {
 
 namespace Impl {
 
-char** init_kokkos_args( bool do_threads, bool do_numa, bool do_device, bool do_other, int & nargs, Kokkos::InitArguments & init_args ) {
-  nargs = ( do_threads ? 1 : 0 ) +
-          ( do_numa ? 1 : 0 ) +
-          ( do_device ? 1 : 0 ) +
-          ( do_other ? 4 : 0 );
+char** init_kokkos_args(bool do_threads, bool do_numa, bool do_device,
+                        bool do_other, int& nargs,
+                        Kokkos::InitArguments& init_args) {
+  nargs = (do_threads ? 1 : 0) + (do_numa ? 1 : 0) + (do_device ? 1 : 0) +
+          (do_other ? 4 : 0);
 
   char** args_kokkos = new char*[nargs];
-  for ( int i = 0; i < nargs; i++ ) {
+  for (int i = 0; i < nargs; i++) {
     args_kokkos[i] = new char[20];
   }
 
   int threads_idx = do_other ? 1 : 0;
-  int numa_idx = ( do_other ? 3 : 0 ) + ( do_threads ? 1 : 0 );
-  int device_idx = ( do_other ? 3 : 0 ) + ( do_threads ? 1 : 0 ) + ( do_numa ? 1 : 0 );
+  int numa_idx    = (do_other ? 3 : 0) + (do_threads ? 1 : 0);
+  int device_idx =
+      (do_other ? 3 : 0) + (do_threads ? 1 : 0) + (do_numa ? 1 : 0);
 
-  if ( do_threads ) {
+  if (do_threads) {
     int nthreads = 3;
 
 #ifdef KOKKOS_ENABLE_OPENMP
-    if ( omp_get_max_threads() < 3 )
-      nthreads = omp_get_max_threads();
+    if (omp_get_max_threads() < 3) nthreads = omp_get_max_threads();
 #endif
 
-    if ( Kokkos::hwloc::available() ) {
-      if ( Kokkos::hwloc::get_available_threads_per_core() < 3 )
-        nthreads =   Kokkos::hwloc::get_available_threads_per_core()
-                   * Kokkos::hwloc::get_available_numa_count();
+    if (Kokkos::hwloc::available()) {
+      if (Kokkos::hwloc::get_available_threads_per_core() < 3)
+        nthreads = Kokkos::hwloc::get_available_threads_per_core() *
+                   Kokkos::hwloc::get_available_numa_count();
     }
 
 #ifdef KOKKOS_ENABLE_SERIAL
-    if ( std::is_same< Kokkos::Serial, Kokkos::DefaultExecutionSpace >::value ||
-         std::is_same< Kokkos::Serial, Kokkos::DefaultHostExecutionSpace >::value ) {
+    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
+        std::is_same<Kokkos::Serial,
+                     Kokkos::DefaultHostExecutionSpace>::value) {
       nthreads = 1;
     }
 #endif
 
     init_args.num_threads = nthreads;
-    sprintf( args_kokkos[threads_idx], "--threads=%i", nthreads );
+    sprintf(args_kokkos[threads_idx], "--threads=%i", nthreads);
   }
 
-  if ( do_numa ) {
+  if (do_numa) {
     int numa = 1;
-    if ( Kokkos::hwloc::available() ) {
+    if (Kokkos::hwloc::available()) {
       numa = Kokkos::hwloc::get_available_numa_count();
     }
 
 #ifdef KOKKOS_ENABLE_SERIAL
-    if ( std::is_same< Kokkos::Serial, Kokkos::DefaultExecutionSpace >::value ||
-         std::is_same< Kokkos::Serial, Kokkos::DefaultHostExecutionSpace >::value ) {
+    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
+        std::is_same<Kokkos::Serial,
+                     Kokkos::DefaultHostExecutionSpace>::value) {
       numa = 1;
     }
 #endif
 
     init_args.num_numa = numa;
-    sprintf( args_kokkos[numa_idx], "--numa=%i", numa );
+    sprintf(args_kokkos[numa_idx], "--numa=%i", numa);
   }
 
-  if ( do_device ) {
+  if (do_device) {
     init_args.device_id = 0;
-    sprintf( args_kokkos[device_idx], "--device=%i", 0 );
+    sprintf(args_kokkos[device_idx], "--device=%i", 0);
   }
 
-  if ( do_other ) {
-    sprintf( args_kokkos[0], "--dummyarg=1" );
-    sprintf( args_kokkos[ threads_idx + ( do_threads ? 1 : 0 ) ], "--dummy2arg" );
-    sprintf( args_kokkos[ threads_idx + ( do_threads ? 1 : 0 ) + 1 ], "dummy3arg" );
-    sprintf( args_kokkos[ device_idx + ( do_device ? 1 : 0 ) ], "dummy4arg=1" );
+  if (do_other) {
+    sprintf(args_kokkos[0], "--dummyarg=1");
+    sprintf(args_kokkos[threads_idx + (do_threads ? 1 : 0)], "--dummy2arg");
+    sprintf(args_kokkos[threads_idx + (do_threads ? 1 : 0) + 1], "dummy3arg");
+    sprintf(args_kokkos[device_idx + (do_device ? 1 : 0)], "dummy4arg=1");
   }
 
   return args_kokkos;
 }
 
-Kokkos::InitArguments init_initstruct( bool do_threads, bool do_numa, bool do_device ) {
+Kokkos::InitArguments init_initstruct(bool do_threads, bool do_numa,
+                                      bool do_device) {
   Kokkos::InitArguments args;
 
-  if ( do_threads ) {
+  if (do_threads) {
     int nthreads = 3;
 
 #ifdef KOKKOS_ENABLE_OPENMP
-    if ( omp_get_max_threads() < 3 ) {
+    if (omp_get_max_threads() < 3) {
       nthreads = omp_get_max_threads();
     }
 #endif
 
-    if ( Kokkos::hwloc::available() ) {
-      if ( Kokkos::hwloc::get_available_threads_per_core() < 3 ) {
-        nthreads =   Kokkos::hwloc::get_available_threads_per_core()
-                   * Kokkos::hwloc::get_available_numa_count();
+    if (Kokkos::hwloc::available()) {
+      if (Kokkos::hwloc::get_available_threads_per_core() < 3) {
+        nthreads = Kokkos::hwloc::get_available_threads_per_core() *
+                   Kokkos::hwloc::get_available_numa_count();
       }
     }
 
 #ifdef KOKKOS_ENABLE_SERIAL
-    if ( std::is_same< Kokkos::Serial, Kokkos::DefaultExecutionSpace >::value ||
-         std::is_same< Kokkos::Serial, Kokkos::DefaultHostExecutionSpace >::value ) {
+    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
+        std::is_same<Kokkos::Serial,
+                     Kokkos::DefaultHostExecutionSpace>::value) {
       nthreads = 1;
     }
 #endif
@@ -156,15 +161,16 @@ Kokkos::InitArguments init_initstruct( bool do_threads, bool do_numa, bool do_de
     args.num_threads = nthreads;
   }
 
-  if ( do_numa ) {
+  if (do_numa) {
     int numa = 1;
-    if ( Kokkos::hwloc::available() ) {
+    if (Kokkos::hwloc::available()) {
       numa = Kokkos::hwloc::get_available_numa_count();
     }
 
 #ifdef KOKKOS_ENABLE_SERIAL
-    if ( std::is_same< Kokkos::Serial, Kokkos::DefaultExecutionSpace >::value ||
-         std::is_same< Kokkos::Serial, Kokkos::DefaultHostExecutionSpace >::value ) {
+    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
+        std::is_same<Kokkos::Serial,
+                     Kokkos::DefaultHostExecutionSpace>::value) {
       numa = 1;
     }
 #endif
@@ -172,61 +178,65 @@ Kokkos::InitArguments init_initstruct( bool do_threads, bool do_numa, bool do_de
     args.num_numa = numa;
   }
 
-  if ( do_device ) {
+  if (do_device) {
     args.device_id = 0;
   }
 
   return args;
 }
 
-void check_correct_initialization( const Kokkos::InitArguments & argstruct ) {
+void check_correct_initialization(const Kokkos::InitArguments& argstruct) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  ASSERT_EQ( Kokkos::DefaultExecutionSpace::is_initialized(), 1 );
-  ASSERT_EQ( Kokkos::HostSpace::execution_space::is_initialized(), 1 );
+  ASSERT_EQ(Kokkos::DefaultExecutionSpace::is_initialized(), 1);
+  ASSERT_EQ(Kokkos::HostSpace::execution_space::is_initialized(), 1);
 #else
-  ASSERT_EQ( Kokkos::DefaultExecutionSpace::impl_is_initialized(), 1 );
-  ASSERT_EQ( Kokkos::HostSpace::execution_space::impl_is_initialized(), 1 );
+  ASSERT_EQ(Kokkos::DefaultExecutionSpace::impl_is_initialized(), 1);
+  ASSERT_EQ(Kokkos::HostSpace::execution_space::impl_is_initialized(), 1);
 #endif
 
-  // Figure out the number of threads the HostSpace ExecutionSpace should have initialized to.
+  // Figure out the number of threads the HostSpace ExecutionSpace should have
+  // initialized to.
   int expected_nthreads = argstruct.num_threads;
 
 #ifdef KOKKOS_ENABLE_OPENMP
-  if ( std::is_same< Kokkos::HostSpace::execution_space, Kokkos::OpenMP >::value ) {
+  if (std::is_same<Kokkos::HostSpace::execution_space, Kokkos::OpenMP>::value) {
     // use openmp default num threads
-    if ( expected_nthreads < 0 || ( expected_nthreads == 0 && !Kokkos::hwloc::available() ) ) {
+    if (expected_nthreads < 0 ||
+        (expected_nthreads == 0 && !Kokkos::hwloc::available())) {
       expected_nthreads = omp_get_max_threads();
     }
     // use hwloc if available
-    else if ( expected_nthreads == 0 && Kokkos::hwloc::available() ) {
-      expected_nthreads = Kokkos::hwloc::get_available_numa_count()
-                        * Kokkos::hwloc::get_available_cores_per_numa()
-                        * Kokkos::hwloc::get_available_threads_per_core();
+    else if (expected_nthreads == 0 && Kokkos::hwloc::available()) {
+      expected_nthreads = Kokkos::hwloc::get_available_numa_count() *
+                          Kokkos::hwloc::get_available_cores_per_numa() *
+                          Kokkos::hwloc::get_available_threads_per_core();
     }
   }
 #endif
 
-  if ( expected_nthreads < 1 ) {
-    if ( Kokkos::hwloc::available() ) {
-      expected_nthreads = Kokkos::hwloc::get_available_numa_count()
-                        * Kokkos::hwloc::get_available_cores_per_numa()
-                        * Kokkos::hwloc::get_available_threads_per_core();
-    }
-    else {
-        expected_nthreads = 1;
+  if (expected_nthreads < 1) {
+    if (Kokkos::hwloc::available()) {
+      expected_nthreads = Kokkos::hwloc::get_available_numa_count() *
+                          Kokkos::hwloc::get_available_cores_per_numa() *
+                          Kokkos::hwloc::get_available_threads_per_core();
+    } else {
+      expected_nthreads = 1;
     }
 
 #ifdef KOKKOS_ENABLE_SERIAL
-    if ( std::is_same< Kokkos::DefaultExecutionSpace, Kokkos::Serial >::value ||
-         std::is_same< Kokkos::DefaultHostExecutionSpace, Kokkos::Serial >::value ) {
+    if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Serial>::value ||
+        std::is_same<Kokkos::DefaultHostExecutionSpace,
+                     Kokkos::Serial>::value) {
       expected_nthreads = 1;
     }
 #endif
 
 #ifdef KOKKOS_ENABLE_HPX
     // HPX uses all cores on machine by default. Skip this test.
-    if ( std::is_same< Kokkos::DefaultExecutionSpace, Kokkos::Experimental::HPX >::value ||
-         std::is_same< Kokkos::DefaultHostExecutionSpace, Kokkos::Experimental::HPX >::value ) {
+    if (std::is_same<Kokkos::DefaultExecutionSpace,
+                     Kokkos::Experimental::HPX>::value ||
+        std::is_same<Kokkos::DefaultHostExecutionSpace,
+                     Kokkos::Experimental::HPX>::value) {
       return;
     }
 #endif
@@ -234,38 +244,39 @@ void check_correct_initialization( const Kokkos::InitArguments & argstruct ) {
 
   int expected_numa = argstruct.num_numa;
 
-  if ( expected_numa < 1 ) {
-    if ( Kokkos::hwloc::available() ) {
+  if (expected_numa < 1) {
+    if (Kokkos::hwloc::available()) {
       expected_numa = Kokkos::hwloc::get_available_numa_count();
-    }
-    else {
+    } else {
       expected_numa = 1;
     }
 
 #ifdef KOKKOS_ENABLE_SERIAL
-    if ( std::is_same< Kokkos::DefaultExecutionSpace, Kokkos::Serial >::value ||
-         std::is_same< Kokkos::DefaultHostExecutionSpace, Kokkos::Serial >::value )
+    if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Serial>::value ||
+        std::is_same<Kokkos::DefaultHostExecutionSpace, Kokkos::Serial>::value)
       expected_numa = 1;
 #endif
   }
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  ASSERT_EQ( Kokkos::HostSpace::execution_space::thread_pool_size(), expected_nthreads );
+  ASSERT_EQ(Kokkos::HostSpace::execution_space::thread_pool_size(),
+            expected_nthreads);
 #else
-  ASSERT_EQ( Kokkos::HostSpace::execution_space::impl_thread_pool_size(), expected_nthreads );
+  ASSERT_EQ(Kokkos::HostSpace::execution_space::impl_thread_pool_size(),
+            expected_nthreads);
 #endif
 
 #ifdef KOKKOS_ENABLE_CUDA
-  if ( std::is_same< Kokkos::DefaultExecutionSpace, Kokkos::Cuda >::value ) {
+  if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Cuda>::value) {
     int device;
-    cudaGetDevice( &device );
+    cudaGetDevice(&device);
 
     int expected_device = argstruct.device_id;
-    if ( argstruct.device_id < 0 ) {
+    if (argstruct.device_id < 0) {
       expected_device = 0;
     }
 
-    ASSERT_EQ( expected_device, device );
+    ASSERT_EQ(expected_device, device);
   }
 #endif
 }
@@ -273,221 +284,206 @@ void check_correct_initialization( const Kokkos::InitArguments & argstruct ) {
 // TODO: Add check whether correct number of threads are actually started.
 void test_no_arguments() {
   Kokkos::initialize();
-  check_correct_initialization( Kokkos::InitArguments() );
+  check_correct_initialization(Kokkos::InitArguments());
   Kokkos::finalize();
 }
 
-void test_commandline_args( int nargs, char** args, const Kokkos::InitArguments & argstruct ) {
-  Kokkos::initialize( nargs, args );
-  check_correct_initialization( argstruct );
+void test_commandline_args(int nargs, char** args,
+                           const Kokkos::InitArguments& argstruct) {
+  Kokkos::initialize(nargs, args);
+  check_correct_initialization(argstruct);
   Kokkos::finalize();
 }
 
-void test_initstruct_args( const Kokkos::InitArguments & args ) {
-  Kokkos::initialize( args );
-  check_correct_initialization( args );
+void test_initstruct_args(const Kokkos::InitArguments& args) {
+  Kokkos::initialize(args);
+  check_correct_initialization(args);
   Kokkos::finalize();
 }
 
-} // namespace Impl
-
-class defaultdevicetypeinit : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {}
-
-  static void TearDownTestCase() {}
-};
+}  // namespace Impl
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_01
-TEST_F( defaultdevicetypeinit, no_args )
-{
-  Impl::test_no_arguments();
-}
+TEST(defaultdevicetypeinit, no_args) { Impl::test_no_arguments(); }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_02
-TEST_F( defaultdevicetypeinit, commandline_args_empty )
-{
+TEST(defaultdevicetypeinit, commandline_args_empty) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( false, false, false, false, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(false, false, false, false, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_03
-TEST_F( defaultdevicetypeinit, commandline_args_other )
-{
+TEST(defaultdevicetypeinit, commandline_args_other) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( false, false, false, true, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(false, false, false, true, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_04
-TEST_F( defaultdevicetypeinit, commandline_args_nthreads )
-{
+TEST(defaultdevicetypeinit, commandline_args_nthreads) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( true, false, false, false, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(true, false, false, false, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_05
-TEST_F( defaultdevicetypeinit, commandline_args_nthreads_numa )
-{
+TEST(defaultdevicetypeinit, commandline_args_nthreads_numa) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( true, true, false, false, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(true, true, false, false, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_06
-TEST_F( defaultdevicetypeinit, commandline_args_nthreads_numa_device )
-{
+TEST(defaultdevicetypeinit, commandline_args_nthreads_numa_device) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( true, true, true, false, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(true, true, true, false, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_07
-TEST_F( defaultdevicetypeinit, commandline_args_nthreads_device )
-{
+TEST(defaultdevicetypeinit, commandline_args_nthreads_device) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( true, false, true, false, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(true, false, true, false, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_08
-TEST_F( defaultdevicetypeinit, commandline_args_numa_device )
-{
+TEST(defaultdevicetypeinit, commandline_args_numa_device) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( false, true, true, false, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(false, true, true, false, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_09
-TEST_F( defaultdevicetypeinit, commandline_args_device )
-{
+TEST(defaultdevicetypeinit, commandline_args_device) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( false, false, true, false, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(false, false, true, false, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_10
-TEST_F( defaultdevicetypeinit, commandline_args_nthreads_numa_device_other )
-{
+TEST(defaultdevicetypeinit, commandline_args_nthreads_numa_device_other) {
   Kokkos::InitArguments argstruct;
   int nargs = 0;
-  char** args = Impl::init_kokkos_args( true, true, true, true, nargs, argstruct );
-  Impl::test_commandline_args( nargs, args, argstruct );
+  char** args =
+      Impl::init_kokkos_args(true, true, true, true, nargs, argstruct);
+  Impl::test_commandline_args(nargs, args, argstruct);
 
-  for ( int i = 0; i < nargs; i++ ) {
-    delete [] args[i];
+  for (int i = 0; i < nargs; i++) {
+    delete[] args[i];
   }
-  delete [] args;
+  delete[] args;
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_11
-TEST_F( defaultdevicetypeinit, initstruct_default )
-{
+TEST(defaultdevicetypeinit, initstruct_default) {
   Kokkos::InitArguments args;
-  Impl::test_initstruct_args( args );
+  Impl::test_initstruct_args(args);
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_12
-TEST_F( defaultdevicetypeinit, initstruct_nthreads )
-{
-  Kokkos::InitArguments args = Impl::init_initstruct( true, false, false );
-  Impl::test_initstruct_args( args );
+TEST(defaultdevicetypeinit, initstruct_nthreads) {
+  Kokkos::InitArguments args = Impl::init_initstruct(true, false, false);
+  Impl::test_initstruct_args(args);
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_13
-TEST_F( defaultdevicetypeinit, initstruct_nthreads_numa )
-{
-  Kokkos::InitArguments args = Impl::init_initstruct( true, true, false );
-  Impl::test_initstruct_args( args );
+TEST(defaultdevicetypeinit, initstruct_nthreads_numa) {
+  Kokkos::InitArguments args = Impl::init_initstruct(true, true, false);
+  Impl::test_initstruct_args(args);
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_14
-TEST_F( defaultdevicetypeinit, initstruct_device )
-{
-  Kokkos::InitArguments args = Impl::init_initstruct( false, false, true );
-  Impl::test_initstruct_args( args );
+TEST(defaultdevicetypeinit, initstruct_device) {
+  Kokkos::InitArguments args = Impl::init_initstruct(false, false, true);
+  Impl::test_initstruct_args(args);
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_15
-TEST_F( defaultdevicetypeinit, initstruct_nthreads_device )
-{
-  Kokkos::InitArguments args = Impl::init_initstruct( true, false, true );
-  Impl::test_initstruct_args( args );
+TEST(defaultdevicetypeinit, initstruct_nthreads_device) {
+  Kokkos::InitArguments args = Impl::init_initstruct(true, false, true);
+  Impl::test_initstruct_args(args);
 }
 #endif
 
 #ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_16
-TEST_F( defaultdevicetypeinit, initstruct_nthreads_numa_device )
-{
-  Kokkos::InitArguments args = Impl::init_initstruct( true, true, true );
-  Impl::test_initstruct_args( args );
+TEST(defaultdevicetypeinit, initstruct_nthreads_numa_device) {
+  Kokkos::InitArguments args = Impl::init_initstruct(true, true, true);
+  Impl::test_initstruct_args(args);
 }
 #endif
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/TestFunctorAnalysis.hpp b/lib/kokkos/core/unit_test/TestFunctorAnalysis.hpp
index e1dcbbdb4d0394bf4004ad713182164fa6fd2534..5e72972bedc5e9e72281c282f72e22815e30da16 100644
--- a/lib/kokkos/core/unit_test/TestFunctorAnalysis.hpp
+++ b/lib/kokkos/core/unit_test/TestFunctorAnalysis.hpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -52,102 +53,100 @@
 namespace Test {
 
 struct TestFunctorAnalysis_03 {
-
-  struct value_type { double x[2]; };
+  struct value_type {
+    double x[2];
+  };
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int , value_type & ) const {}
+  void operator()(int, value_type&) const {}
 
   KOKKOS_INLINE_FUNCTION
-  void join( value_type volatile & , value_type const volatile & ) const {}
+  void join(value_type volatile&, value_type const volatile&) const {}
 
-  KOKKOS_INLINE_FUNCTION static
-  void init( value_type & ) {}
+  KOKKOS_INLINE_FUNCTION static void init(value_type&) {}
 };
 
-
-template< class ExecSpace >
-void test_functor_analysis()
-{
+template <class ExecSpace>
+void test_functor_analysis() {
   //------------------------------
-  auto c01 = KOKKOS_LAMBDA(int){} ;
-  typedef Kokkos::Impl::FunctorAnalysis
-            < Kokkos::Impl::FunctorPatternInterface::FOR
-            , Kokkos::RangePolicy< ExecSpace >
-            , decltype( c01 ) >
-    A01 ;
-
-  typedef typename A01::template Reducer< typename ExecSpace::memory_space >
-    R01 ;
-
-  static_assert( std::is_same< typename A01::value_type , void >::value , "" );
-  static_assert( std::is_same< typename A01::pointer_type , void >::value , "" );
-  static_assert( std::is_same< typename A01::reference_type , void >::value , "" );
-  static_assert( std::is_same< typename R01::functor_type , decltype(c01) >::value , "" );
-
-  static_assert( ! A01::has_join_member_function , "" );
-  static_assert( ! A01::has_init_member_function , "" );
-  static_assert( ! A01::has_final_member_function , "" );
-  static_assert( A01::StaticValueSize == 0 , "" );
-  ASSERT_EQ( R01( & c01 ).length() , 0 );
+  auto c01 = KOKKOS_LAMBDA(int){};
+  typedef Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::FOR,
+      Kokkos::RangePolicy<ExecSpace>, decltype(c01)>
+      A01;
+
+  typedef typename A01::template Reducer<typename ExecSpace::memory_space> R01;
+
+  static_assert(std::is_same<typename A01::value_type, void>::value, "");
+  static_assert(std::is_same<typename A01::pointer_type, void>::value, "");
+  static_assert(std::is_same<typename A01::reference_type, void>::value, "");
+  static_assert(std::is_same<typename R01::functor_type, decltype(c01)>::value,
+                "");
+
+  static_assert(!A01::has_join_member_function, "");
+  static_assert(!A01::has_init_member_function, "");
+  static_assert(!A01::has_final_member_function, "");
+  static_assert(A01::StaticValueSize == 0, "");
+  ASSERT_EQ(R01(&c01).length(), 0);
 
   //------------------------------
-  auto c02 = KOKKOS_LAMBDA(int,double&){} ;
-  typedef Kokkos::Impl::FunctorAnalysis
-    < Kokkos::Impl::FunctorPatternInterface::REDUCE
-    , Kokkos::RangePolicy< ExecSpace >
-    , decltype( c02 ) >
-    A02 ;
-  typedef typename A02::template Reducer< typename ExecSpace::memory_space >
-    R02 ;
-
-  static_assert( std::is_same< typename A02::value_type , double >::value , "" );
-  static_assert( std::is_same< typename A02::pointer_type , double * >::value , "" );
-  static_assert( std::is_same< typename A02::reference_type , double & >::value , "" );
-  static_assert( std::is_same< typename R02::functor_type , decltype(c02) >::value , "" );
-
-  static_assert( ! A02::has_join_member_function , "" );
-  static_assert( ! A02::has_init_member_function , "" );
-  static_assert( ! A02::has_final_member_function , "" );
-  static_assert( A02::StaticValueSize == sizeof(double) , "" );
-  ASSERT_EQ( R02( & c02 ).length() , 1 );
+  auto c02 = KOKKOS_LAMBDA(int, double&){};
+  typedef Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::REDUCE,
+      Kokkos::RangePolicy<ExecSpace>, decltype(c02)>
+      A02;
+  typedef typename A02::template Reducer<typename ExecSpace::memory_space> R02;
+
+  static_assert(std::is_same<typename A02::value_type, double>::value, "");
+  static_assert(std::is_same<typename A02::pointer_type, double*>::value, "");
+  static_assert(std::is_same<typename A02::reference_type, double&>::value, "");
+  static_assert(std::is_same<typename R02::functor_type, decltype(c02)>::value,
+                "");
+
+  static_assert(!A02::has_join_member_function, "");
+  static_assert(!A02::has_init_member_function, "");
+  static_assert(!A02::has_final_member_function, "");
+  static_assert(A02::StaticValueSize == sizeof(double), "");
+  ASSERT_EQ(R02(&c02).length(), 1);
 
   //------------------------------
-  
-  TestFunctorAnalysis_03 c03 ;
-  typedef Kokkos::Impl::FunctorAnalysis
-    < Kokkos::Impl::FunctorPatternInterface::REDUCE
-    , Kokkos::RangePolicy< ExecSpace >
-    , TestFunctorAnalysis_03 > 
-    A03 ;
-  typedef typename A03::template Reducer< typename ExecSpace::memory_space >
-    R03 ;
-
-  static_assert( std::is_same< typename A03::value_type , TestFunctorAnalysis_03::value_type >::value , "" );
-  static_assert( std::is_same< typename A03::pointer_type , TestFunctorAnalysis_03::value_type * >::value , "" );
-  static_assert( std::is_same< typename A03::reference_type , TestFunctorAnalysis_03::value_type & >::value , "" );
-  static_assert( std::is_same< typename R03::functor_type , TestFunctorAnalysis_03 >::value , "" );
-
-  static_assert( A03::has_join_member_function , "" );
-  static_assert( A03::has_init_member_function , "" );
-  static_assert( ! A03::has_final_member_function , "" );
-  static_assert( A03::StaticValueSize == sizeof(TestFunctorAnalysis_03::value_type) , "" );
-  ASSERT_EQ( R03( & c03 ).length() , 1 );
 
-  //------------------------------
-
-  
+  TestFunctorAnalysis_03 c03;
+  typedef Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::REDUCE,
+      Kokkos::RangePolicy<ExecSpace>, TestFunctorAnalysis_03>
+      A03;
+  typedef typename A03::template Reducer<typename ExecSpace::memory_space> R03;
+
+  static_assert(std::is_same<typename A03::value_type,
+                             TestFunctorAnalysis_03::value_type>::value,
+                "");
+  static_assert(std::is_same<typename A03::pointer_type,
+                             TestFunctorAnalysis_03::value_type*>::value,
+                "");
+  static_assert(std::is_same<typename A03::reference_type,
+                             TestFunctorAnalysis_03::value_type&>::value,
+                "");
+  static_assert(
+      std::is_same<typename R03::functor_type, TestFunctorAnalysis_03>::value,
+      "");
+
+  static_assert(A03::has_join_member_function, "");
+  static_assert(A03::has_init_member_function, "");
+  static_assert(!A03::has_final_member_function, "");
+  static_assert(
+      A03::StaticValueSize == sizeof(TestFunctorAnalysis_03::value_type), "");
+  ASSERT_EQ(R03(&c03).length(), 1);
 
+  //------------------------------
 }
 
-TEST_F( TEST_CATEGORY , functor_analysis )
-{
-  test_functor_analysis< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, functor_analysis) {
+  test_functor_analysis<TEST_EXECSPACE>();
 }
 
-}
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
 
 #endif /* #ifndef TEST_FUNCTOR_ANALYSIS_HPP */
-
diff --git a/lib/kokkos/core/unit_test/TestHWLOC.cpp b/lib/kokkos/core/unit_test/TestHWLOC.cpp
index 40a4a441eb4be9034463a75ce1532fac7617239e..428a67048451a6adbfbf77ab94bcf7a1ced910dc 100644
--- a/lib/kokkos/core/unit_test/TestHWLOC.cpp
+++ b/lib/kokkos/core/unit_test/TestHWLOC.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,19 +50,11 @@
 
 namespace Test {
 
-class hwloc : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {}
-
-  static void TearDownTestCase() {}
-};
-
-TEST_F( hwloc, query )
-{
+TEST(hwloc, query) {
   std::cout << " NUMA[" << Kokkos::hwloc::get_available_numa_count() << "]"
             << " CORE[" << Kokkos::hwloc::get_available_cores_per_numa() << "]"
-            << " PU[" << Kokkos::hwloc::get_available_threads_per_core()  << "]"
+            << " PU[" << Kokkos::hwloc::get_available_threads_per_core() << "]"
             << std::endl;
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestHostBarrier.cpp b/lib/kokkos/core/unit_test/TestHostBarrier.cpp
index 6806ecec38f05f43838133c82a801607ea6d8fcf..230ba2fb83a278d2fef085ae7540789e0e1a74d2 100644
--- a/lib/kokkos/core/unit_test/TestHostBarrier.cpp
+++ b/lib/kokkos/core/unit_test/TestHostBarrier.cpp
@@ -2,15 +2,6 @@
 
 namespace Test {
 
-class host_barrier : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {}
-  static void TearDownTestCase() {}
-};
+TEST(host_barrier, openmp) {}
 
-TEST_F( host_barrier, openmp )
-{
-
-}
-
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestInit.hpp b/lib/kokkos/core/unit_test/TestInit.hpp
index 1f3aef7141f47cc2c4afc0fc4efc4ae2c6014016..03ceb45d773904a29ee4e48508c208ca748e962c 100644
--- a/lib/kokkos/core/unit_test/TestInit.hpp
+++ b/lib/kokkos/core/unit_test/TestInit.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,28 +50,22 @@
 #include <Kokkos_Core.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY, init )
-{
-   ;
-}
+TEST(TEST_CATEGORY, init) { ; }
 
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
 
-template<class ExecSpace>
-void test_dispatch () {
+template <class ExecSpace>
+void test_dispatch() {
   const int repeat = 100;
-  for ( int i = 0; i < repeat; ++i ) {
-    for ( int j = 0; j < repeat; ++j ) {
-      Kokkos::parallel_for( Kokkos::RangePolicy< TEST_EXECSPACE >( 0, j )
-                          , KOKKOS_LAMBDA( int ) {} );
+  for (int i = 0; i < repeat; ++i) {
+    for (int j = 0; j < repeat; ++j) {
+      Kokkos::parallel_for(Kokkos::RangePolicy<TEST_EXECSPACE>(0, j),
+                           KOKKOS_LAMBDA(int){});
     }
   }
 }
 
-TEST_F( TEST_CATEGORY, dispatch )
-{
-  test_dispatch<TEST_EXECSPACE>();
-}
+TEST(TEST_CATEGORY, dispatch) { test_dispatch<TEST_EXECSPACE>(); }
 #endif
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestLocalDeepCopy.hpp b/lib/kokkos/core/unit_test/TestLocalDeepCopy.hpp
index 31bda530a5020c7a9b7c8a49aae369cbe485b2bb..9bca373a407bc0bd2676a65ea0ff59ce3043170d 100644
--- a/lib/kokkos/core/unit_test/TestLocalDeepCopy.hpp
+++ b/lib/kokkos/core/unit_test/TestLocalDeepCopy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,853 +53,995 @@
 
 namespace Test {
 
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_teampolicy_rank_1 (const int N) {
-
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    typedef Kokkos::TeamPolicy<ExecSpace>               team_policy;
-    typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type  member_type;
-
-    //Deep Copy
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, 1, 1, lid, Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, lid, Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_teampolicy_rank_1(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA =
+      Kokkos::subview(A, 1, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  typedef Kokkos::TeamPolicy<ExecSpace> team_policy;
+  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type member_type;
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, 1, 1, lid, Kokkos::ALL());
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, lid, Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N      
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, lid, Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, lid, Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N );  
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_teampolicy_rank_2 (const int N) {
-
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    typedef Kokkos::TeamPolicy<ExecSpace>               team_policy;
-    typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type  member_type;
-
-    //Deep Copy
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_teampolicy_rank_2(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  typedef Kokkos::TeamPolicy<ExecSpace> team_policy;
+  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type member_type;
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, 1, lid, Kokkos::ALL(),
+                                      Kokkos::ALL());
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, lid, Kokkos::ALL(),
+                                      Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N      
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, lid, Kokkos::ALL(),
+                                      Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_teampolicy_rank_3 (const int N) {
-  
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    typedef Kokkos::TeamPolicy<ExecSpace>               team_policy;
-    typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type  member_type;
-
-    //Deep Copy
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_teampolicy_rank_3(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  typedef Kokkos::TeamPolicy<ExecSpace> team_policy;
+  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type member_type;
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, lid, Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, lid, Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N      
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, lid, Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_teampolicy_rank_4 (const int N) {
-  
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    typedef Kokkos::TeamPolicy<ExecSpace>               team_policy;
-    typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type  member_type;
-
-    //Deep Copy
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_teampolicy_rank_4(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  typedef Kokkos::TeamPolicy<ExecSpace> team_policy;
+  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type member_type;
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subSrc =
+            Kokkos::subview(A, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL());
+        auto subDst =
+            Kokkos::subview(B, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N      
-      auto subDst = Kokkos::subview(B, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subDst =
+            Kokkos::subview(B, 1, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_teampolicy_rank_5 (const int N) {
-  
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    typedef Kokkos::TeamPolicy<ExecSpace>               team_policy;
-    typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type  member_type;
-
-    //Deep Copy
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N
-      auto subSrc = Kokkos::subview(A, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_teampolicy_rank_5(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA =
+      Kokkos::subview(A, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                      Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  typedef Kokkos::TeamPolicy<ExecSpace> team_policy;
+  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type member_type;
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subSrc =
+            Kokkos::subview(A, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        auto subDst =
+            Kokkos::subview(B, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N      
-      auto subDst = Kokkos::subview(B, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subDst =
+            Kokkos::subview(B, 1, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_teampolicy_rank_6 (const int N) {
-  
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    typedef Kokkos::TeamPolicy<ExecSpace>               team_policy;
-    typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type  member_type;
-
-    //Deep Copy
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N
-      auto subSrc = Kokkos::subview(A, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_teampolicy_rank_6(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  typedef Kokkos::TeamPolicy<ExecSpace> team_policy;
+  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type member_type;
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subSrc = Kokkos::subview(A, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        auto subDst = Kokkos::subview(B, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N      
-      auto subDst = Kokkos::subview(B, 1, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subDst = Kokkos::subview(B, 1, lid, Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_teampolicy_rank_7 (const int N) {
-  
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    Kokkos::deep_copy( A, 10.0 );
-
-    typedef Kokkos::TeamPolicy<ExecSpace>               team_policy;
-    typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type  member_type;
-
-    //Deep Copy
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N
-      auto subSrc = Kokkos::subview(A, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_teampolicy_rank_7(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  Kokkos::deep_copy(A, 10.0);
+
+  typedef Kokkos::TeamPolicy<ExecSpace> team_policy;
+  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type member_type;
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subSrc = Kokkos::subview(
+            A, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        auto subDst = Kokkos::subview(
+            B, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( team_policy( N, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type &teamMember ) {
-      int lid = teamMember.league_rank();// returns a number between 0 and N      
-      auto subDst = Kokkos::subview(B, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(teamMember,subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      team_policy(N, Kokkos::AUTO),
+      KOKKOS_LAMBDA(const member_type& teamMember) {
+        int lid = teamMember.league_rank();  // returns a number between 0 and N
+        auto subDst = Kokkos::subview(
+            B, lid, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(teamMember, subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_rangepolicy_rank_1 (const int N) {
-  
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    //Deep Copy
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, 1, 1, i, Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, i, Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_rangepolicy_rank_1(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA =
+      Kokkos::subview(A, 1, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, 1, 1, i, Kokkos::ALL());
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, i, Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {      
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, i, Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, 1, i, Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N );  
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_rangepolicy_rank_2 (const int N) {
-
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    //Deep Copy
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_rangepolicy_rank_2(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subSrc =
+            Kokkos::subview(A, 1, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL());
+        auto subDst =
+            Kokkos::subview(B, 1, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {      
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subDst =
+            Kokkos::subview(B, 1, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_rangepolicy_rank_3 (const int N) {
- 
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    //Deep Copy
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_rangepolicy_rank_3(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subSrc = Kokkos::subview(A, 1, 1, 1, 1, i, Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, i, Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subDst = Kokkos::subview(B, 1, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subDst = Kokkos::subview(B, 1, 1, 1, 1, i, Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_rangepolicy_rank_4 (const int N) {
- 
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    //Deep Copy
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subSrc = Kokkos::subview(A, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_rangepolicy_rank_4(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, 1, 1, Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subSrc =
+            Kokkos::subview(A, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL());
+        auto subDst =
+            Kokkos::subview(B, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subDst = Kokkos::subview(B, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subDst =
+            Kokkos::subview(B, 1, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_rangepolicy_rank_5 (const int N) {
- 
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    //Deep Copy
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subSrc = Kokkos::subview(A, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_rangepolicy_rank_5(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA =
+      Kokkos::subview(A, 1, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                      Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subSrc =
+            Kokkos::subview(A, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        auto subDst =
+            Kokkos::subview(B, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subDst = Kokkos::subview(B, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subDst =
+            Kokkos::subview(B, 1, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_rangepolicy_rank_6 (const int N) {
- 
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    auto subA = Kokkos::subview(A, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-    Kokkos::deep_copy( subA, 10.0 );
-
-    //Deep Copy
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subSrc = Kokkos::subview(A, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_rangepolicy_rank_6(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  auto subA = Kokkos::subview(A, 1, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+                              Kokkos::ALL());
+  Kokkos::deep_copy(subA, 10.0);
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subSrc = Kokkos::subview(A, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        auto subDst = Kokkos::subview(B, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subDst = Kokkos::subview(B, 1, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subDst = Kokkos::subview(B, 1, i, Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL(),
+                                      Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
+
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N * N * N);
+}
 //-------------------------------------------------------------------------------------------------------------
-  template<typename ExecSpace, typename ViewType>
-  void impl_test_local_deepcopy_rangepolicy_rank_7 (const int N) {
- 
-    // Allocate matrices on device.
-    ViewType A( "A", N, N, N, N, N, N, N, N );
-    ViewType B( "B", N, N, N, N, N, N, N, N );
-
-    // Create host mirrors of device views.
-    typename ViewType::HostMirror h_A = Kokkos::create_mirror_view( A );
-    typename ViewType::HostMirror h_B = Kokkos::create_mirror_view( B );
-
-    // Initialize A matrix.
-    Kokkos::deep_copy( A, 10.0 );
-
-    //Deep Copy
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subSrc = Kokkos::subview(A, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      auto subDst = Kokkos::subview(B, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,subSrc);
-    });
-
-    Kokkos::deep_copy( h_A, A );
-    Kokkos::deep_copy( h_B, B );
-
-    bool test = true;
-    for(size_t i=0; i<A.span();i++){
-      if (h_A.data()[i]!=h_B.data()[i]) {test = false;break;}
+template <typename ExecSpace, typename ViewType>
+void impl_test_local_deepcopy_rangepolicy_rank_7(const int N) {
+  // Allocate matrices on device.
+  ViewType A("A", N, N, N, N, N, N, N, N);
+  ViewType B("B", N, N, N, N, N, N, N, N);
+
+  // Create host mirrors of device views.
+  typename ViewType::HostMirror h_A = Kokkos::create_mirror_view(A);
+  typename ViewType::HostMirror h_B = Kokkos::create_mirror_view(B);
+
+  // Initialize A matrix.
+  Kokkos::deep_copy(A, 10.0);
+
+  // Deep Copy
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subSrc = Kokkos::subview(
+            A, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        auto subDst = Kokkos::subview(
+            B, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, subSrc);
+      });
+
+  Kokkos::deep_copy(h_A, A);
+  Kokkos::deep_copy(h_B, B);
+
+  bool test = true;
+  for (size_t i = 0; i < A.span(); i++) {
+    if (h_A.data()[i] != h_B.data()[i]) {
+      test = false;
+      break;
     }
+  }
 
-    ASSERT_EQ( test, true );
-
-    //Fill
-    Kokkos::deep_copy( B, 0.0 );
+  ASSERT_EQ(test, true);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<ExecSpace>(0,N), KOKKOS_LAMBDA ( const int& i ) {
-      auto subDst = Kokkos::subview(B, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
-      Kokkos::Experimental::local_deep_copy(subDst,20.0);
-    });
+  // Fill
+  Kokkos::deep_copy(B, 0.0);
 
-    Kokkos::deep_copy( h_B, B );
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace>(0, N), KOKKOS_LAMBDA(const int& i) {
+        auto subDst = Kokkos::subview(
+            B, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(),
+            Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
+        Kokkos::Experimental::local_deep_copy(subDst, 20.0);
+      });
 
-    double sum_all = 0.0;
-    for(size_t i=0; i<B.span();i++){
-      sum_all += h_B.data()[i];
-    }
+  Kokkos::deep_copy(h_B, B);
 
-    ASSERT_EQ( sum_all, 20.0*N*N*N*N*N*N*N*N );
+  double sum_all = 0.0;
+  for (size_t i = 0; i < B.span(); i++) {
+    sum_all += h_B.data()[i];
   }
-//-------------------------------------------------------------------------------------------------------------  
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-TEST_F( TEST_CATEGORY , local_deepcopy_teampolicy_layoutleft )
-{
+  ASSERT_EQ(sum_all, 20.0 * N * N * N * N * N * N * N * N);
+}
+//-------------------------------------------------------------------------------------------------------------
+
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+TEST(TEST_CATEGORY, local_deepcopy_teampolicy_layoutleft) {
   typedef TEST_EXECSPACE ExecSpace;
-  typedef Kokkos::View<double********,Kokkos::LayoutLeft,ExecSpace> ViewType;
-  
-  { //Rank-1
-    impl_test_local_deepcopy_teampolicy_rank_1<ExecSpace,ViewType>(8);
+  typedef Kokkos::View<double********, Kokkos::LayoutLeft, ExecSpace> ViewType;
+
+  {  // Rank-1
+    impl_test_local_deepcopy_teampolicy_rank_1<ExecSpace, ViewType>(8);
   }
-  { //Rank-2
-    impl_test_local_deepcopy_teampolicy_rank_2<ExecSpace,ViewType>(8);
+  {  // Rank-2
+    impl_test_local_deepcopy_teampolicy_rank_2<ExecSpace, ViewType>(8);
   }
-  { //Rank-3
-    impl_test_local_deepcopy_teampolicy_rank_3<ExecSpace,ViewType>(8);
+  {  // Rank-3
+    impl_test_local_deepcopy_teampolicy_rank_3<ExecSpace, ViewType>(8);
   }
-  { //Rank-4
-    impl_test_local_deepcopy_teampolicy_rank_4<ExecSpace,ViewType>(8);
+  {  // Rank-4
+    impl_test_local_deepcopy_teampolicy_rank_4<ExecSpace, ViewType>(8);
   }
-  { //Rank-5
-    impl_test_local_deepcopy_teampolicy_rank_5<ExecSpace,ViewType>(8);
+  {  // Rank-5
+    impl_test_local_deepcopy_teampolicy_rank_5<ExecSpace, ViewType>(8);
   }
-  { //Rank-6
-    impl_test_local_deepcopy_teampolicy_rank_6<ExecSpace,ViewType>(8);
+  {  // Rank-6
+    impl_test_local_deepcopy_teampolicy_rank_6<ExecSpace, ViewType>(8);
   }
-  { //Rank-7
-    impl_test_local_deepcopy_teampolicy_rank_7<ExecSpace,ViewType>(8);
+  {  // Rank-7
+    impl_test_local_deepcopy_teampolicy_rank_7<ExecSpace, ViewType>(8);
   }
 }
 //-------------------------------------------------------------------------------------------------------------
-TEST_F( TEST_CATEGORY , local_deepcopy_rangepolicy_layoutleft )
-{
+TEST(TEST_CATEGORY, local_deepcopy_rangepolicy_layoutleft) {
   typedef TEST_EXECSPACE ExecSpace;
-  typedef Kokkos::View<double********,Kokkos::LayoutLeft,ExecSpace> ViewType;
+  typedef Kokkos::View<double********, Kokkos::LayoutLeft, ExecSpace> ViewType;
 
-  { //Rank-1
-    impl_test_local_deepcopy_rangepolicy_rank_1<ExecSpace,ViewType>(8);
+  {  // Rank-1
+    impl_test_local_deepcopy_rangepolicy_rank_1<ExecSpace, ViewType>(8);
   }
-  { //Rank-2
-    impl_test_local_deepcopy_rangepolicy_rank_2<ExecSpace,ViewType>(8);
+  {  // Rank-2
+    impl_test_local_deepcopy_rangepolicy_rank_2<ExecSpace, ViewType>(8);
   }
-  { //Rank-3
-    impl_test_local_deepcopy_rangepolicy_rank_3<ExecSpace,ViewType>(8);
+  {  // Rank-3
+    impl_test_local_deepcopy_rangepolicy_rank_3<ExecSpace, ViewType>(8);
   }
-  { //Rank-4
-    impl_test_local_deepcopy_rangepolicy_rank_4<ExecSpace,ViewType>(8);
+  {  // Rank-4
+    impl_test_local_deepcopy_rangepolicy_rank_4<ExecSpace, ViewType>(8);
   }
-  { //Rank-5
-    impl_test_local_deepcopy_rangepolicy_rank_5<ExecSpace,ViewType>(8);
+  {  // Rank-5
+    impl_test_local_deepcopy_rangepolicy_rank_5<ExecSpace, ViewType>(8);
   }
-  { //Rank-6
-    impl_test_local_deepcopy_rangepolicy_rank_6<ExecSpace,ViewType>(8);
+  {  // Rank-6
+    impl_test_local_deepcopy_rangepolicy_rank_6<ExecSpace, ViewType>(8);
   }
-  { //Rank-7
-    impl_test_local_deepcopy_rangepolicy_rank_7<ExecSpace,ViewType>(8);
+  {  // Rank-7
+    impl_test_local_deepcopy_rangepolicy_rank_7<ExecSpace, ViewType>(8);
   }
 }
 //-------------------------------------------------------------------------------------------------------------
-TEST_F( TEST_CATEGORY , local_deepcopy_teampolicy_layoutright )
-{
+TEST(TEST_CATEGORY, local_deepcopy_teampolicy_layoutright) {
   typedef TEST_EXECSPACE ExecSpace;
-  typedef Kokkos::View<double********,Kokkos::LayoutRight,ExecSpace> ViewType;
+  typedef Kokkos::View<double********, Kokkos::LayoutRight, ExecSpace> ViewType;
 
-  { //Rank-1
-    impl_test_local_deepcopy_teampolicy_rank_1<ExecSpace,ViewType>(8);
+  {  // Rank-1
+    impl_test_local_deepcopy_teampolicy_rank_1<ExecSpace, ViewType>(8);
   }
-  { //Rank-2
-    impl_test_local_deepcopy_teampolicy_rank_2<ExecSpace,ViewType>(8);
+  {  // Rank-2
+    impl_test_local_deepcopy_teampolicy_rank_2<ExecSpace, ViewType>(8);
   }
-  { //Rank-3
-    impl_test_local_deepcopy_teampolicy_rank_3<ExecSpace,ViewType>(8);
+  {  // Rank-3
+    impl_test_local_deepcopy_teampolicy_rank_3<ExecSpace, ViewType>(8);
   }
-  { //Rank-4
-    impl_test_local_deepcopy_teampolicy_rank_4<ExecSpace,ViewType>(8);
+  {  // Rank-4
+    impl_test_local_deepcopy_teampolicy_rank_4<ExecSpace, ViewType>(8);
   }
-  { //Rank-5
-    impl_test_local_deepcopy_teampolicy_rank_5<ExecSpace,ViewType>(8);
+  {  // Rank-5
+    impl_test_local_deepcopy_teampolicy_rank_5<ExecSpace, ViewType>(8);
   }
-  { //Rank-6
-    impl_test_local_deepcopy_teampolicy_rank_6<ExecSpace,ViewType>(8);
+  {  // Rank-6
+    impl_test_local_deepcopy_teampolicy_rank_6<ExecSpace, ViewType>(8);
   }
-  { //Rank-7
-    impl_test_local_deepcopy_teampolicy_rank_7<ExecSpace,ViewType>(8);
+  {  // Rank-7
+    impl_test_local_deepcopy_teampolicy_rank_7<ExecSpace, ViewType>(8);
   }
 }
 //-------------------------------------------------------------------------------------------------------------
-TEST_F( TEST_CATEGORY , local_deepcopy_rangepolicy_layoutright )
-{
+TEST(TEST_CATEGORY, local_deepcopy_rangepolicy_layoutright) {
   typedef TEST_EXECSPACE ExecSpace;
-  typedef Kokkos::View<double********,Kokkos::LayoutRight,ExecSpace> ViewType;
+  typedef Kokkos::View<double********, Kokkos::LayoutRight, ExecSpace> ViewType;
 
-  { //Rank-1
-    impl_test_local_deepcopy_rangepolicy_rank_1<ExecSpace,ViewType>(8);
+  {  // Rank-1
+    impl_test_local_deepcopy_rangepolicy_rank_1<ExecSpace, ViewType>(8);
   }
-  { //Rank-2
-    impl_test_local_deepcopy_rangepolicy_rank_2<ExecSpace,ViewType>(8);
+  {  // Rank-2
+    impl_test_local_deepcopy_rangepolicy_rank_2<ExecSpace, ViewType>(8);
   }
-  { //Rank-3
-    impl_test_local_deepcopy_rangepolicy_rank_3<ExecSpace,ViewType>(8);
+  {  // Rank-3
+    impl_test_local_deepcopy_rangepolicy_rank_3<ExecSpace, ViewType>(8);
   }
-  { //Rank-4
-    impl_test_local_deepcopy_rangepolicy_rank_4<ExecSpace,ViewType>(8);
+  {  // Rank-4
+    impl_test_local_deepcopy_rangepolicy_rank_4<ExecSpace, ViewType>(8);
   }
-  { //Rank-5
-    impl_test_local_deepcopy_rangepolicy_rank_5<ExecSpace,ViewType>(8);
+  {  // Rank-5
+    impl_test_local_deepcopy_rangepolicy_rank_5<ExecSpace, ViewType>(8);
   }
-  { //Rank-6
-    impl_test_local_deepcopy_rangepolicy_rank_6<ExecSpace,ViewType>(8);
+  {  // Rank-6
+    impl_test_local_deepcopy_rangepolicy_rank_6<ExecSpace, ViewType>(8);
   }
-  { //Rank-7
-    impl_test_local_deepcopy_rangepolicy_rank_7<ExecSpace,ViewType>(8);
+  {  // Rank-7
+    impl_test_local_deepcopy_rangepolicy_rank_7<ExecSpace, ViewType>(8);
   }
 }
 #endif
 #endif
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestMDRange.hpp b/lib/kokkos/core/unit_test/TestMDRange.hpp
index cea89a487202fa65c6451863f3adac748c75a727..1e1bd869ca0857dac84521403b5f426df223534a 100644
--- a/lib/kokkos/core/unit_test/TestMDRange.hpp
+++ b/lib/kokkos/core/unit_test/TestMDRange.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,916 +54,996 @@ namespace {
 
 using namespace Kokkos;
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_ReduceArray_2D {
-
   using DataType       = int;
-  using ViewType_2     = typename Kokkos::View< DataType**, ExecSpace >;
+  using ViewType_2     = typename Kokkos::View<DataType **, ExecSpace>;
   using HostViewType_2 = typename ViewType_2::HostMirror;
 
   ViewType_2 input_view;
 
   using scalar_type = double;
-  using value_type = scalar_type[];
+  using value_type  = scalar_type[];
   const unsigned value_count;
 
-  TestMDRange_ReduceArray_2D( const int N0, const int N1, const unsigned array_size ) 
-    : input_view( "input_view", N0, N1 ) 
-    , value_count( array_size )
-  {}
+  TestMDRange_ReduceArray_2D(const int N0, const int N1,
+                             const unsigned array_size)
+      : input_view("input_view", N0, N1), value_count(array_size) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( scalar_type dst[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) {
+  void init(scalar_type dst[]) const {
+    for (unsigned i = 0; i < value_count; ++i) {
       dst[i] = 0.0;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile scalar_type dst[],
-             const volatile scalar_type src[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) {
-        dst[i] += src[i];
+  void join(volatile scalar_type dst[],
+            const volatile scalar_type src[]) const {
+    for (unsigned i = 0; i < value_count; ++i) {
+      dst[i] += src[i];
     }
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j ) const
-  {
-    input_view( i, j ) = 1;
-  }
+  void operator()(const int i, const int j) const { input_view(i, j) = 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, value_type lsum ) const
-  {
-    lsum[0] += input_view( i, j ) * 2; //+=6 each time if InitTag => N0*N1*6
-    lsum[1] += input_view( i, j ) ;    //+=3 each time if InitTag => N0*N1*3
+  void operator()(const int i, const int j, value_type lsum) const {
+    lsum[0] += input_view(i, j) * 2;  //+=6 each time if InitTag => N0*N1*6
+    lsum[1] += input_view(i, j);      //+=3 each time if InitTag => N0*N1*3
   }
 
   // tagged operators
   struct InitTag {};
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j ) const
-  {
-    input_view( i, j ) = 3;
+  void operator()(const InitTag &, const int i, const int j) const {
+    input_view(i, j) = 3;
   }
 
-  static void test_arrayreduce2( const int N0, const int N1 )
-  {
-
+  static void test_arrayreduce2(const int N0, const int N1) {
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int>, InitTag > range_type_init;
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int>, InitTag>
+          range_type_init;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type_init range_init( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
+      range_type_init range_init(point_type{{0, 0}}, point_type{{N0, N1}},
+                                 tile_type{{3, 3}});
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
 
       const unsigned array_size = 2;
 
-      TestMDRange_ReduceArray_2D functor( N0, N1, array_size );
+      TestMDRange_ReduceArray_2D functor(N0, N1, array_size);
 
-      parallel_for( range_init, functor ); // Init the view to 3's
+      parallel_for(range_init, functor);  // Init the view to 3's
 
-      double sums[ array_size ];
-      parallel_reduce( range, functor, sums );
+      double sums[array_size];
+      parallel_reduce(range, functor, sums);
 
       // Check output
-      //printf("Array Reduce result. N0 = %d  N1 = %d  N0*N1 = %d  sums[0] = %lf  sums[1] = %lf \n", N0, N1, N0*N1, sums[0], sums[1]);
+      // printf("Array Reduce result. N0 = %d  N1 = %d  N0*N1 = %d  sums[0] =
+      // %lf  sums[1] = %lf \n", N0, N1, N0*N1, sums[0], sums[1]);
 
-      ASSERT_EQ( sums[0], 6 * N0 * N1 );
-      ASSERT_EQ( sums[1], 3 * N0 * N1 );
+      ASSERT_EQ(sums[0], 6 * N0 * N1);
+      ASSERT_EQ(sums[1], 3 * N0 * N1);
     }
   }
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_ReduceArray_3D {
-
   using DataType       = int;
-  using ViewType_3     = typename Kokkos::View< DataType***, ExecSpace >;
+  using ViewType_3     = typename Kokkos::View<DataType ***, ExecSpace>;
   using HostViewType_3 = typename ViewType_3::HostMirror;
 
   ViewType_3 input_view;
 
   using scalar_type = double;
-  using value_type = scalar_type[];
+  using value_type  = scalar_type[];
   const unsigned value_count;
 
-  TestMDRange_ReduceArray_3D( const int N0, const int N1, const int N2, const unsigned array_size ) 
-    : input_view( "input_view", N0, N1, N2 ) 
-    , value_count( array_size )
-  {}
+  TestMDRange_ReduceArray_3D(const int N0, const int N1, const int N2,
+                             const unsigned array_size)
+      : input_view("input_view", N0, N1, N2), value_count(array_size) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( scalar_type dst[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) {
+  void init(scalar_type dst[]) const {
+    for (unsigned i = 0; i < value_count; ++i) {
       dst[i] = 0.0;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile scalar_type dst[],
-             const volatile scalar_type src[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) {
-        dst[i] += src[i];
+  void join(volatile scalar_type dst[],
+            const volatile scalar_type src[]) const {
+    for (unsigned i = 0; i < value_count; ++i) {
+      dst[i] += src[i];
     }
   }
 
-
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k ) const
-  {
-    input_view( i, j, k ) = 1;
+  void operator()(const int i, const int j, const int k) const {
+    input_view(i, j, k) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, value_type lsum ) const
-  {
-    lsum[0] += input_view( i, j, k ) * 2; //+=6 each time if InitTag => N0*N1*N2*6
-    lsum[1] += input_view( i, j, k ) ;    //+=3 each time if InitTag => N0*N1*N2*3
+  void operator()(const int i, const int j, const int k,
+                  value_type lsum) const {
+    lsum[0] +=
+        input_view(i, j, k) * 2;     //+=6 each time if InitTag => N0*N1*N2*6
+    lsum[1] += input_view(i, j, k);  //+=3 each time if InitTag => N0*N1*N2*3
   }
 
   // tagged operators
   struct InitTag {};
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k ) const
-  {
-    input_view( i, j, k ) = 3;
+  void operator()(const InitTag &, const int i, const int j,
+                  const int k) const {
+    input_view(i, j, k) = 3;
   }
 
-  static void test_arrayreduce3( const int N0, const int N1, const int N2 )
-  {
-
+  static void test_arrayreduce3(const int N0, const int N1, const int N2) {
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int>, InitTag > range_type_init;
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int>, InitTag>
+          range_type_init;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type_init range_init( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
+      range_type_init range_init(point_type{{0, 0, 0}},
+                                 point_type{{N0, N1, N2}},
+                                 tile_type{{3, 3, 3}});
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 3, 3}});
 
       const unsigned array_size = 2;
 
-      TestMDRange_ReduceArray_3D functor( N0, N1, N2, array_size );
+      TestMDRange_ReduceArray_3D functor(N0, N1, N2, array_size);
 
-      parallel_for( range_init, functor ); // Init the view to 3's
+      parallel_for(range_init, functor);  // Init the view to 3's
 
-      double sums[ array_size ];
-      parallel_reduce( range, functor, sums );
+      double sums[array_size];
+      parallel_reduce(range, functor, sums);
 
-      ASSERT_EQ( sums[0], 6 * N0 * N1 * N2 );
-      ASSERT_EQ( sums[1], 3 * N0 * N1 * N2 );
+      ASSERT_EQ(sums[0], 6 * N0 * N1 * N2);
+      ASSERT_EQ(sums[1], 3 * N0 * N1 * N2);
     }
   }
 };
 
-
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_2D {
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType**, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType **, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   using value_type = double;
 
-  TestMDRange_2D( const DataType N0, const DataType N1 ) : input_view( "input_view", N0, N1 ) {}
+  TestMDRange_2D(const DataType N0, const DataType N1)
+      : input_view("input_view", N0, N1) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j ) const
-  {
-    input_view( i, j ) = 1;
-  }
+  void operator()(const int i, const int j) const { input_view(i, j) = 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, value_type &lsum ) const
-  {
-    lsum += input_view( i, j ) * 2;
+  void operator()(const int i, const int j, value_type &lsum) const {
+    lsum += input_view(i, j) * 2;
   }
 
   // tagged operators
   struct InitTag {};
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j ) const
-  {
-    input_view( i, j ) = 3;
+  void operator()(const InitTag &, const int i, const int j) const {
+    input_view(i, j) = 3;
   }
 
   // reduction tagged operators
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, value_type &lsum ) const
-  {
-    lsum += input_view( i, j ) * 3;
+  void operator()(const InitTag &, const int i, const int j,
+                  value_type &lsum) const {
+    lsum += input_view(i, j) * 3;
   }
 
-  static void test_reduce2( const int N0, const int N1 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_reduce2(const int N0, const int N1) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
       double sum = 0.0;
-      parallel_reduce( range
-        , KOKKOS_LAMBDA(const int i, const int j, double &lsum) {
-            lsum+=1.0;
-          }
-        , sum );
-      ASSERT_EQ( sum, N0 * N1 );
+      parallel_reduce(
+          range,
+          KOKKOS_LAMBDA(const int i, const int j, double &lsum) {
+            lsum += 1.0;
+          },
+          sum);
+      ASSERT_EQ(sum, N0 * N1);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 );
+      ASSERT_EQ(sum, 2 * N0 * N1);
     }
 
     // Test with reducers - scalar
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       int s0 = 1;
       int s1 = 1;
-      range_type range( {{ s0, s1 }}, {{ N0, N1 }}, {{ 3, 3 }} );
+      range_type range({{s0, s1}}, {{N0, N1}}, {{3, 3}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( range, functor, reducer_scalar );
+      parallel_reduce(range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * (N0 - s0) * (N1 - s1) );
+      ASSERT_EQ(sum, 2 * (N0 - s0) * (N1 - s1));
     }
     // Test with reducers - scalar + label
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       int s0 = 1;
       int s1 = 1;
-      range_type range( {{ s0, s1 }}, {{ N0, N1 }}, {{ 3, 3 }} );
+      range_type range({{s0, s1}}, {{N0, N1}}, {{3, 3}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( "rank2-parfor-label", range, functor );
+      parallel_for("rank2-parfor-label", range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( "rank2-reducer-label", range, functor, reducer_scalar );
+      parallel_reduce("rank2-reducer-label", range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * (N0 - s0) * (N1 - s1) );
+      ASSERT_EQ(sum, 2 * (N0 - s0) * (N1 - s1));
     }
     // Test with reducers - scalar view
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0 }}, {{ N0, N1 }}, {{ 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0}}, {{N0, N1}}, {{3, 3}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::View< value_type, Kokkos::HostSpace > sum_view("sum_view");
+      Kokkos::View<value_type, Kokkos::HostSpace> sum_view("sum_view");
       sum_view() = sum;
-      Kokkos::Sum< value_type > reducer_view( sum_view );
+      Kokkos::Sum<value_type> reducer_view(sum_view);
 
-      parallel_reduce( range, functor, reducer_view);
+      parallel_reduce(range, functor, reducer_view);
       Kokkos::fence();
       sum = sum_view();
 
-      ASSERT_EQ( sum, 2 * N0 * N1 );
+      ASSERT_EQ(sum, 2 * N0 * N1);
     }
     // Test Min reducer with lambda
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 1, 1 }}, {{ N0, N1 }}, {{ 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{1, 1}}, {{N0, N1}}, {{3, 3}});
 
-      Kokkos::View< double**, ExecSpace > v_in("v_in", N0, N1 );
+      Kokkos::View<double **, ExecSpace> v_in("v_in", N0, N1);
 
-      parallel_for( "rank2-init-lambda", range, KOKKOS_LAMBDA ( const int i, const int j ) {
-          v_in( i , j ) = (i+1) * (j+1) ;
-        });
+      parallel_for(
+          "rank2-init-lambda", range, KOKKOS_LAMBDA(const int i, const int j) {
+            v_in(i, j) = (i + 1) * (j + 1);
+          });
 
       double min;
-      Kokkos::Min< double > reducer_scalar( min );
+      Kokkos::Min<double> reducer_scalar(min);
 
-      parallel_reduce( "rank2-min-reducer", range, KOKKOS_LAMBDA ( const int i, const int j, double& min_val ) {
-            min_val = fmin( v_in(i,j), min_val );
-          }
-        , reducer_scalar);
+      parallel_reduce(
+          "rank2-min-reducer", range,
+          KOKKOS_LAMBDA(const int i, const int j, double &min_val) {
+            min_val = fmin(v_in(i, j), min_val);
+          },
+          reducer_scalar);
 
-      ASSERT_EQ( min, 4.0 );
+      ASSERT_EQ(min, 4.0);
     }
 #endif
 #endif
     // Tagged operator test
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Default, Iterate::Default >, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 2, 4 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{2, 4}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       // check parallel_for results correct with InitTag
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 3 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 3) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "Defaults + InitTag op(): Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Defaults + InitTag op(): Errors in test_for3; mismatches = %d\n\n",
+            counter);
       }
-      ASSERT_EQ( counter, 0 );
-
+      ASSERT_EQ(counter, 0);
 
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 9 * N0 * N1 );
+      ASSERT_EQ(sum, 9 * N0 * N1);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Default, Iterate::Default>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 2, 6 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{2, 6}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 );
+      ASSERT_EQ(sum, 2 * N0 * N1);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 2, 6 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{2, 6}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 );
+      ASSERT_EQ(sum, 2 * N0 * N1);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 2, 6 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{2, 6}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 );
+      ASSERT_EQ(sum, 2 * N0 * N1);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 2, 6 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{2, 6}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 );
+      ASSERT_EQ(sum, 2 * N0 * N1);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 2, 6 } } );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{2, 6}});
 
-      TestMDRange_2D functor( N0, N1 );
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 );
+      ASSERT_EQ(sum, 2 * N0 * N1);
     }
-  } // end test_reduce2
+  }  // end test_reduce2
 
-  static void test_for2( const int N0, const int N1 )
-  {
-
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_for2(const int N0, const int N1) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       const int s0 = 1;
       const int s1 = 1;
 
-      range_type range( point_type{ { s0, s1 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
+      range_type range(point_type{{s0, s1}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
 
-      TestMDRange_2D::ViewType v( "v", N0, N1 );
+      TestMDRange_2D::ViewType v("v", N0, N1);
 
-      parallel_for( range, 
-          KOKKOS_LAMBDA ( const int i , const int j ) {
-            v(i, j) = 3;
-          }
-        );
+      parallel_for(
+          range, KOKKOS_LAMBDA(const int i, const int j) { v(i, j) = 3; });
 
-      TestMDRange_2D::HostViewType h_view = Kokkos::create_mirror_view( v );
-      Kokkos::deep_copy( h_view, v );
+      TestMDRange_2D::HostViewType h_view = Kokkos::create_mirror_view(v);
+      Kokkos::deep_copy(h_view, v);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 3 ) {
-          ++counter;
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j) {
+          if (h_view(i, j) != 3) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Default Layouts + InitTag op(): Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Default Layouts + InitTag op(): Errors in "
+            "test_for2; mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       const int s0 = 1;
       const int s1 = 1;
-      range_type range( point_type{ { s0, s1 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{s0, s1}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 3 ) {
-          ++counter;
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j) {
+          if (h_view(i, j) != 3) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Default Layouts + InitTag op(): Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Default Layouts + InitTag op(): Errors in "
+            "test_for2; mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, InitTag > range_type;
+      typedef
+          typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>, InitTag>
+              range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 3 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 3) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "Default Layouts + InitTag op(): Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Default Layouts + InitTag op(): Errors in test_for2; mismatches = "
+            "%d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, InitTag > range_type;
+      typedef
+          typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>, InitTag>
+              range_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 3 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 3) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "Default Layouts + InitTag op() + Default Tile: Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Default Layouts + InitTag op() + Default Tile: Errors in "
+            "test_for2; mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 1 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 1) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "No info: Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("No info: Errors in test_for2; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Default, Iterate::Default>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 4, 4 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{4, 4}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 1 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 1) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "D D: Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("D D: Errors in test_for2; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 3, 3 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{3, 3}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 1 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 1) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "L L: Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("L L: Errors in test_for2; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 7, 7 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{7, 7}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 1 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 1) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "L R: Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("L R: Errors in test_for2; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 16, 16 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{16, 16}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 1 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 1) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "R L: Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("R L: Errors in test_for2; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<2, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0 } }, point_type{ { N0, N1 } }, tile_type{ { 5, 16 } } );
-      TestMDRange_2D functor( N0, N1 );
+      range_type range(point_type{{0, 0}}, point_type{{N0, N1}},
+                       tile_type{{5, 16}});
+      TestMDRange_2D functor(N0, N1);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      {
-        if ( h_view( i, j ) != 1 ) {
-          ++counter;
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j) {
+          if (h_view(i, j) != 1) {
+            ++counter;
+          }
         }
-      }
 
-      if ( counter != 0 ) {
-        printf( "R R: Errors in test_for2; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("R R: Errors in test_for2; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
-  } // end test_for2
-}; // MDRange_2D
+  }  // end test_for2
+};   // MDRange_2D
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_3D {
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType***, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType ***, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   using value_type = double;
 
-  TestMDRange_3D( const DataType N0, const DataType N1, const DataType N2 ) : input_view( "input_view", N0, N1, N2 ) {}
+  TestMDRange_3D(const DataType N0, const DataType N1, const DataType N2)
+      : input_view("input_view", N0, N1, N2) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k ) const
-  {
-    input_view( i, j, k ) = 1;
+  void operator()(const int i, const int j, const int k) const {
+    input_view(i, j, k) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, double &lsum ) const
-  {
-    lsum += input_view( i, j, k ) * 2;
+  void operator()(const int i, const int j, const int k, double &lsum) const {
+    lsum += input_view(i, j, k) * 2;
   }
 
   // tagged operators
   struct InitTag {};
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k ) const
-  {
-    input_view( i, j, k ) = 3;
+  void operator()(const InitTag &, const int i, const int j,
+                  const int k) const {
+    input_view(i, j, k) = 3;
   }
 
   // reduction tagged operators
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k, value_type &lsum ) const
-  {
-    lsum += input_view( i, j, k ) * 3;
+  void operator()(const InitTag &, const int i, const int j, const int k,
+                  value_type &lsum) const {
+    lsum += input_view(i, j, k) * 3;
   }
 
-  static void test_reduce3( const int N0, const int N1, const int N2 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_reduce3(const int N0, const int N1, const int N2) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 3, 3}});
       double sum = 0.0;
-      parallel_reduce( range
-        , KOKKOS_LAMBDA(const int i, const int j, const int k, double &lsum) {
-            lsum+=1.0;
-          }
-        , sum );
-      ASSERT_EQ( sum, N0 * N1 * N2 );
+      parallel_reduce(
+          range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, double &lsum) {
+            lsum += 1.0;
+          },
+          sum);
+      ASSERT_EQ(sum, N0 * N1 * N2);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       int s0 = 1;
       int s1 = 1;
       int s2 = 1;
-      range_type range( point_type{ { s0, s1, s2 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
+      range_type range(point_type{{s0, s1, s2}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 3, 3}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (N0 - s0) * (N1 - s1) * (N2 - s2) );
+      ASSERT_EQ(sum, 2 * (N0 - s0) * (N1 - s1) * (N2 - s2));
     }
 
     // Test with reducers - scalar
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0 }}, {{ N0, N1, N2 }}, {{ 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0}}, {{N0, N1, N2}}, {{3, 3, 3}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( range, functor, reducer_scalar );
+      parallel_reduce(range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
     // Test with reducers - scalar + label
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0 }}, {{ N0, N1, N2 }}, {{ 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0}}, {{N0, N1, N2}}, {{3, 3, 3}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( "rank3-parfor-label", range, functor );
+      parallel_for("rank3-parfor-label", range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( "rank3-reducer-label", range, functor, reducer_scalar );
+      parallel_reduce("rank3-reducer-label", range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
     // Test with reducers - scalar view
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0 }}, {{ N0, N1, N2 }}, {{ 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0}}, {{N0, N1, N2}}, {{3, 3, 3}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::View< value_type, Kokkos::HostSpace > sum_view("sum_view");
+      Kokkos::View<value_type, Kokkos::HostSpace> sum_view("sum_view");
       sum_view() = sum;
-      Kokkos::Sum< value_type > reducer_view( sum_view );
+      Kokkos::Sum<value_type> reducer_view(sum_view);
 
-      parallel_reduce( range, functor, reducer_view);
+      parallel_reduce(range, functor, reducer_view);
       Kokkos::fence();
       sum = sum_view();
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
     // Test Min reducer with lambda
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
 
-      range_type range( {{ 1, 1, 1 }}, {{ N0, N1, N2 }}, {{ 3, 3, 3 }} );
+      range_type range({{1, 1, 1}}, {{N0, N1, N2}}, {{3, 3, 3}});
 
-      Kokkos::View< double***, ExecSpace > v_in("v_in", N0, N1, N2 );
+      Kokkos::View<double ***, ExecSpace> v_in("v_in", N0, N1, N2);
 
-      parallel_for( "rank3-init-lambda", range, KOKKOS_LAMBDA ( const int i, const int j, const int k ) {
-          v_in( i, j, k ) = (i+1) * (j+1) * (k+1) ;
-        });
+      parallel_for(
+          "rank3-init-lambda", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k) {
+            v_in(i, j, k) = (i + 1) * (j + 1) * (k + 1);
+          });
 
       double min;
 
-      parallel_reduce("rank3-min-reducer", range, KOKKOS_LAMBDA ( const int i, const int j, const int k, double& min_val ) {
-            min_val = (v_in(i,j,k) < min_val) ? v_in(i,j,k) : min_val;
-          }
-        , Kokkos::Min<double>(min) );
+      parallel_reduce(
+          "rank3-min-reducer", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k,
+                        double &min_val) {
+            min_val = (v_in(i, j, k) < min_val) ? v_in(i, j, k) : min_val;
+          },
+          Kokkos::Min<double>(min));
 
-      if((N0-1)*(N1-1)*(N2-1)>0)
-        ASSERT_EQ( min, 8.0 );
+      if ((N0 - 1) * (N1 - 1) * (N2 - 1) > 0)
+        ASSERT_EQ(min, 8.0);
       else {
         double min_identity = Kokkos::reduction_identity<double>::min();
-        ASSERT_EQ( min, min_identity );
+        ASSERT_EQ(min, min_identity);
       }
     }
 #endif
@@ -970,128 +1051,153 @@ struct TestMDRange_3D {
 
     // Tagged operator test
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Default, Iterate::Default >, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 6 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 6}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       // check parallel_for results correct with InitTag
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 3) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( "Defaults + InitTag op(): Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Defaults + InitTag op(): Errors in test_for3; mismatches = %d\n\n",
+            counter);
       }
-      ASSERT_EQ( counter, 0 );
-
+      ASSERT_EQ(counter, 0);
 
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 9 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 9 * N0 * N1 * N2);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Default, Iterate::Default >, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 6 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 6}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 6 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 6}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 6 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 6}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 6 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 6}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 6 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 6}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2);
     }
-  } // end test_reduce3
+  }  // end test_reduce3
 
-  static void test_for3( const int N0, const int N1, const int N2 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_for3(const int N0, const int N1, const int N2) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -1099,344 +1205,375 @@ struct TestMDRange_3D {
       const int s1 = 1;
       const int s2 = 1;
 
-      range_type range( point_type{ { s0, s1, s2 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
+      range_type range(point_type{{s0, s1, s2}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 3, 3}});
 
-      TestMDRange_3D::ViewType v( "v", N0, N1, N2 );
+      TestMDRange_3D::ViewType v("v", N0, N1, N2);
 
-      parallel_for( range, 
-          KOKKOS_LAMBDA ( const int i , const int j , const int k ) {
+      parallel_for(
+          range, KOKKOS_LAMBDA(const int i, const int j, const int k) {
             v(i, j, k) = 3;
-          }
-        );
+          });
 
-      TestMDRange_3D::HostViewType h_view = Kokkos::create_mirror_view( v );
-      Kokkos::deep_copy( h_view, v );
+      TestMDRange_3D::HostViewType h_view = Kokkos::create_mirror_view(v);
+      Kokkos::deep_copy(h_view, v);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k) {
+            if (h_view(i, j, k) != 3) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Default Layouts + InitTag op(): Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Default Layouts + InitTag op(): Errors in "
+            "test_for3; mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3> >
+          range_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } } );
-      TestMDRange_3D functor( N0, N1, N2 );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}});
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 1) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( "Defaults + No Tile: Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("Defaults + No Tile: Errors in test_for3; mismatches = %d\n\n",
+               counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       int s0 = 1;
       int s1 = 1;
       int s2 = 1;
-      range_type range( point_type{ { s0, s1, s2 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
-      TestMDRange_3D functor( N0, N1, N2 );
+      range_type range(point_type{{s0, s1, s2}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 3, 3}});
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k) {
+            if (h_view(i, j, k) != 3) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Defaults + InitTag op(): Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Defaults + InitTag op(): Errors in test_for3; "
+            "mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 3, 3}});
 
-      TestMDRange_3D functor( N0, N1, N2 );
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 1) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for3; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Default, Iterate::Default>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 3, 3 } } );
-      TestMDRange_3D functor( N0, N1, N2 );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 3, 3}});
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 1) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for3; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 2 } } );
-      TestMDRange_3D functor( N0, N1, N2 );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 2}});
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 1) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for3; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 3, 5, 7 } } );
-      TestMDRange_3D functor( N0, N1, N2 );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{3, 5, 7}});
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 1) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for3; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 8, 8, 8 } } );
-      TestMDRange_3D functor( N0, N1, N2 );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{8, 8, 8}});
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 1) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for3; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<3, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0 } }, point_type{ { N0, N1, N2 } }, tile_type{ { 2, 4, 2 } } );
-      TestMDRange_3D functor( N0, N1, N2 );
+      range_type range(point_type{{0, 0, 0}}, point_type{{N0, N1, N2}},
+                       tile_type{{2, 4, 2}});
+      TestMDRange_3D functor(N0, N1, N2);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      {
-        if ( h_view( i, j, k ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k) {
+            if (h_view(i, j, k) != 1) {
+              ++counter;
+            }
+          }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for3; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for3; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
-  } // end test_for3
+  }  // end test_for3
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_4D {
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType****, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType ****, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   using value_type = double;
 
-  TestMDRange_4D( const DataType N0, const DataType N1, const DataType N2, const DataType N3 ) : input_view( "input_view", N0, N1, N2, N3 ) {}
+  TestMDRange_4D(const DataType N0, const DataType N1, const DataType N2,
+                 const DataType N3)
+      : input_view("input_view", N0, N1, N2, N3) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l ) const
-  {
-    input_view( i, j, k, l ) = 1;
+  void operator()(const int i, const int j, const int k, const int l) const {
+    input_view(i, j, k, l) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, double &lsum ) const
-  {
-    lsum += input_view( i, j, k, l ) * 2;
+  void operator()(const int i, const int j, const int k, const int l,
+                  double &lsum) const {
+    lsum += input_view(i, j, k, l) * 2;
   }
 
   // tagged operators
   struct InitTag {};
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k, const int l ) const
-  {
-    input_view( i, j, k, l ) = 3;
+  void operator()(const InitTag &, const int i, const int j, const int k,
+                  const int l) const {
+    input_view(i, j, k, l) = 3;
   }
 
   // reduction tagged operators
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k, const int l, value_type &lsum ) const
-  {
-    lsum += input_view( i, j, k, l ) * 3;
+  void operator()(const InitTag &, const int i, const int j, const int k,
+                  const int l, value_type &lsum) const {
+    lsum += input_view(i, j, k, l) * 3;
   }
 
-  static void test_reduce4( const int N0, const int N1, const int N2, const int N3 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_reduce4(const int N0, const int N1, const int N2,
+                           const int N3) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 3, 3, 3, 3 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{3, 3, 3, 3}});
       double sum = 0.0;
-      parallel_reduce( range
-        , KOKKOS_LAMBDA(const int i, const int j, const int k, const int l, double &lsum) {
-            lsum+=1.0;
-          }
-        , sum );
-      ASSERT_EQ( sum, N0 * N1 * N2 * N3 );
+      parallel_reduce(
+          range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        double &lsum) { lsum += 1.0; },
+          sum);
+      ASSERT_EQ(sum, N0 * N1 * N2 * N3);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -1444,225 +1581,264 @@ struct TestMDRange_4D {
       int s1 = 1;
       int s2 = 1;
       int s3 = 1;
-      range_type range( point_type{ { s0, s1, s2, s3 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 3, 3, 3, 3 } } );
+      range_type range(point_type{{s0, s1, s2, s3}},
+                       point_type{{N0, N1, N2, N3}}, tile_type{{3, 3, 3, 3}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (N0 - s0) * (N1 - s1) * (N2 - s2) * (N3 - s3) );
+      ASSERT_EQ(sum, 2 * (N0 - s0) * (N1 - s1) * (N2 - s2) * (N3 - s3));
     }
 
     // Test with reducers - scalar
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0 }}, {{ N0, N1, N2, N3 }}, {{ 3, 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0}}, {{N0, N1, N2, N3}}, {{3, 3, 3, 3}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( range, functor, reducer_scalar );
+      parallel_reduce(range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
 
     // Test with reducers - scalar + label
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0 }}, {{ N0, N1, N2, N3 }}, {{ 3, 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0}}, {{N0, N1, N2, N3}}, {{3, 3, 3, 3}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( "rank4-parfor-label", range, functor );
+      parallel_for("rank4-parfor-label", range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( "rank4-reducer-label", range, functor, reducer_scalar );
+      parallel_reduce("rank4-reducer-label", range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
 
     // Test with reducers - scalar view
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0 }}, {{ N0, N1, N2, N3 }}, {{ 3, 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0}}, {{N0, N1, N2, N3}}, {{3, 3, 3, 3}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::View< value_type, Kokkos::HostSpace > sum_view("sum_view");
+      Kokkos::View<value_type, Kokkos::HostSpace> sum_view("sum_view");
       sum_view() = sum;
-      Kokkos::Sum< value_type > reducer_view( sum_view );
+      Kokkos::Sum<value_type> reducer_view(sum_view);
 
-      parallel_reduce( range, functor, reducer_view);
+      parallel_reduce(range, functor, reducer_view);
       Kokkos::fence();
       sum = sum_view();
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
 
     // Test Min reducer with lambda
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
 
-      range_type range( {{ 1, 1, 1, 1 }}, {{ N0, N1, N2, N3 }}, {{ 3, 3, 3, 3 }} );
+      range_type range({{1, 1, 1, 1}}, {{N0, N1, N2, N3}}, {{3, 3, 3, 3}});
 
-      Kokkos::View< double****, ExecSpace > v_in("v_in", N0, N1, N2, N3 );
+      Kokkos::View<double ****, ExecSpace> v_in("v_in", N0, N1, N2, N3);
 
-      parallel_for( "rank4-init-lambda", range, KOKKOS_LAMBDA ( const int i, const int j, const int k, const int l ) {
-          v_in( i, j, k, l ) = (i+1) * (j+1) * (k+1) * (l+1) ;
-        });
+      parallel_for(
+          "rank4-init-lambda", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
+            v_in(i, j, k, l) = (i + 1) * (j + 1) * (k + 1) * (l + 1);
+          });
 
       double min;
 
-      parallel_reduce("rank4-min-reducer", range, KOKKOS_LAMBDA ( const int i, const int j, const int k, const int l, double& min_val ) {
-            min_val = (v_in(i,j,k,l) < min_val) ? v_in(i,j,k,l) : min_val;
-          }
-        , Kokkos::Min<double>(min) );
+      parallel_reduce(
+          "rank4-min-reducer", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        double &min_val) {
+            min_val = (v_in(i, j, k, l) < min_val) ? v_in(i, j, k, l) : min_val;
+          },
+          Kokkos::Min<double>(min));
 
-      ASSERT_EQ( min, 16.0 );
+      ASSERT_EQ(min, 16.0);
     }
 #endif
 #endif
 
     // Tagged operator test
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Default, Iterate::Default >, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 2, 4, 6, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{2, 4, 6, 2}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       // check parallel_for results correct with InitTag
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 3 ) {
-          ++counter;
-        }
-      }
-
-      if ( counter != 0 ) {
-        printf( "Defaults + InitTag op(): Errors in test_reduce4 parallel_for init; mismatches = %d\n\n", counter );
-      }
-      ASSERT_EQ( counter, 0 );
-
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 3) {
+                ++counter;
+              }
+            }
+
+      if (counter != 0) {
+        printf(
+            "Defaults + InitTag op(): Errors in test_reduce4 parallel_for "
+            "init; mismatches = %d\n\n",
+            counter);
+      }
+      ASSERT_EQ(counter, 0);
 
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 9 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 9 * N0 * N1 * N2 * N3);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Default, Iterate::Default >, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 2, 4, 6, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{2, 4, 6, 2}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 2, 4, 6, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{2, 4, 6, 2}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 2, 4, 6, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{2, 4, 6, 2}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 2, 4, 6, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{2, 4, 6, 2}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 2, 4, 6, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{2, 4, 6, 2}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3);
     }
-  } // end test_reduce
-
+  }  // end test_reduce
 
-
-  static void test_for4( const int N0, const int N1, const int N2, const int N3 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_for4(const int N0, const int N1, const int N2,
+                        const int N3) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -1671,71 +1847,75 @@ struct TestMDRange_4D {
       const int s2 = 1;
       const int s3 = 1;
 
-      range_type range( point_type{ { s0, s1, s2, s3 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 3, 3, 3, 3 } } );
+      range_type range(point_type{{s0, s1, s2, s3}},
+                       point_type{{N0, N1, N2, N3}}, tile_type{{3, 3, 3, 3}});
 
-      TestMDRange_4D::ViewType v( "v", N0, N1, N2, N3 );
+      TestMDRange_4D::ViewType v("v", N0, N1, N2, N3);
 
-      parallel_for( range, 
-          KOKKOS_LAMBDA ( const int i , const int j , const int k, const int l ) {
-            v(i, j, k, l) = 3;
-          }
-        );
+      parallel_for(
+          range, KOKKOS_LAMBDA(const int i, const int j, const int k,
+                               const int l) { v(i, j, k, l) = 3; });
 
-      TestMDRange_4D::HostViewType h_view = Kokkos::create_mirror_view( v );
-      Kokkos::deep_copy( h_view, v );
+      TestMDRange_4D::HostViewType h_view = Kokkos::create_mirror_view(v);
+      Kokkos::deep_copy(h_view, v);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      for ( int l = s3; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k)
+            for (int l = s3; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 3) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Default Layouts + InitTag op(): Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Default Layouts + InitTag op(): Errors in "
+            "test_for4; mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4> >
+          range_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } } );
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}});
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 1) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( "Defaults + No Tile: Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("Defaults + No Tile: Errors in test_for4; mismatches = %d\n\n",
+               counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -1743,287 +1923,315 @@ struct TestMDRange_4D {
       int s1 = 1;
       int s2 = 1;
       int s3 = 1;
-      range_type range( point_type{ { s0, s1, s2, s3 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 3, 11, 3, 3 } } );
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      range_type range(point_type{{s0, s1, s2, s3}},
+                       point_type{{N0, N1, N2, N3}}, tile_type{{3, 11, 3, 3}});
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      for ( int l = s3; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k)
+            for (int l = s3; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 3) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf("Offset Start + Defaults +m_tile > m_upper dim2 InitTag op(): Errors in test_for4; mismatches = %d\n\n",counter);
+      if (counter != 0) {
+        printf(
+            "Offset Start + Defaults +m_tile > m_upper dim2 InitTag op(): "
+            "Errors in test_for4; mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 4, 4, 4, 4 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{4, 4, 4, 4}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 1) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for4; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Default, Iterate::Default>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 4, 4, 4, 4 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{4, 4, 4, 4}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 1) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for4; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 4, 4, 4, 4 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{4, 4, 4, 4}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 1) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for4; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 4, 4, 4, 4 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{4, 4, 4, 4}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 1) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for4; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 4, 4, 4, 4 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{4, 4, 4, 4}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 1) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for4; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<4, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3 } }, tile_type{ { 4, 4, 4, 4 } } );
+      range_type range(point_type{{0, 0, 0, 0}}, point_type{{N0, N1, N2, N3}},
+                       tile_type{{4, 4, 4, 4}});
 
-      TestMDRange_4D functor( N0, N1, N2, N3 );
+      TestMDRange_4D functor(N0, N1, N2, N3);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      {
-        if ( h_view( i, j, k, l ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l) {
+              if (h_view(i, j, k, l) != 1) {
+                ++counter;
+              }
+            }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for4; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for4; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
-  } // end test_for4
+  }  // end test_for4
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_5D {
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType*****, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType *****, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   using value_type = double;
 
-  TestMDRange_5D( const DataType N0, const DataType N1, const DataType N2, const DataType N3, const DataType N4 ) : input_view( "input_view", N0, N1, N2, N3, N4 ) {}
+  TestMDRange_5D(const DataType N0, const DataType N1, const DataType N2,
+                 const DataType N3, const DataType N4)
+      : input_view("input_view", N0, N1, N2, N3, N4) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m ) const
-  {
-    input_view( i, j, k, l, m ) = 1;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m) const {
+    input_view(i, j, k, l, m) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m, value_type &lsum ) const
-  {
-    lsum += input_view( i, j, k, l, m ) * 2;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m, value_type &lsum) const {
+    lsum += input_view(i, j, k, l, m) * 2;
   }
 
   // tagged operators
   struct InitTag {};
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k, const int l, const int m ) const
-  {
-    input_view( i, j, k, l, m ) = 3;
+  void operator()(const InitTag &, const int i, const int j, const int k,
+                  const int l, const int m) const {
+    input_view(i, j, k, l, m) = 3;
   }
 
   // reduction tagged operators
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k, const int l, const int m, value_type &lsum ) const
-  {
-    lsum += input_view( i, j, k, l, m ) * 3;
+  void operator()(const InitTag &, const int i, const int j, const int k,
+                  const int l, const int m, value_type &lsum) const {
+    lsum += input_view(i, j, k, l, m) * 3;
   }
 
-  static void test_reduce5( const int N0, const int N1, const int N2, const int N3, const int N4 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_reduce5(const int N0, const int N1, const int N2,
+                           const int N3, const int N4) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 3, 3, 3, 3, 1 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{3, 3, 3, 3, 1}});
       double sum = 0.0;
-      parallel_reduce( range
-        , KOKKOS_LAMBDA(const int i, const int j, const int k, const int l, const int m, double &lsum) {
-            lsum+=1.0;
-          }
-        , sum );
-      ASSERT_EQ( sum, N0 * N1 * N2 * N3 * N4 );
+      parallel_reduce(
+          range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m, double &lsum) { lsum += 1.0; },
+          sum);
+      ASSERT_EQ(sum, N0 * N1 * N2 * N3 * N4);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -2032,144 +2240,175 @@ struct TestMDRange_5D {
       int s2 = 1;
       int s3 = 1;
       int s4 = 1;
-      range_type range( point_type{ { s0, s1, s2, s3, s4 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 3, 3, 3, 3, 3 } } );
+      range_type range(point_type{{s0, s1, s2, s3, s4}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{3, 3, 3, 3, 3}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (N0 - s0) * (N1 - s1) * (N2 - s2) * (N3 - s3) * (N4 - s4) );
+      ASSERT_EQ(sum,
+                2 * (N0 - s0) * (N1 - s1) * (N2 - s2) * (N3 - s3) * (N4 - s4));
     }
 
     // Test with reducers - scalar
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0, 0 }}, {{ N0, N1, N2, N3, N4 }}, {{ 3, 3, 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0, 0}}, {{N0, N1, N2, N3, N4}},
+                       {{3, 3, 3, 3, 3}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( range, functor, reducer_scalar );
+      parallel_reduce(range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 * N4 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3 * N4);
     }
 
     // Test with reducers - scalar + label
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0, 0 }}, {{ N0, N1, N2, N3, N4 }}, {{ 3, 3, 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0, 0}}, {{N0, N1, N2, N3, N4}},
+                       {{3, 3, 3, 3, 3}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( "rank5-parfor-label", range, functor );
+      parallel_for("rank5-parfor-label", range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( "rank5-reducer-label", range, functor, reducer_scalar );
+      parallel_reduce("rank5-reducer-label", range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 * N4 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3 * N4);
     }
 
     // Test with reducers - scalar view
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0, 0 }}, {{ N0, N1, N2, N3, N4 }}, {{ 3, 3, 3, 3, 3 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0, 0}}, {{N0, N1, N2, N3, N4}},
+                       {{3, 3, 3, 3, 3}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::View< value_type, Kokkos::HostSpace > sum_view("sum_view");
+      Kokkos::View<value_type, Kokkos::HostSpace> sum_view("sum_view");
       sum_view() = sum;
-      Kokkos::Sum< value_type > reducer_view( sum_view );
+      Kokkos::Sum<value_type> reducer_view(sum_view);
 
-      parallel_reduce( range, functor, reducer_view);
+      parallel_reduce(range, functor, reducer_view);
       Kokkos::fence();
       sum = sum_view();
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 * N4 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3 * N4);
     }
 
     // Test Min reducer with lambda
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
 
-      range_type range( {{ 1, 1, 1, 1, 1 }}, {{ N0, N1, N2, N3, N4 }}, {{ 3, 3, 3, 2, 2 }} );
+      range_type range({{1, 1, 1, 1, 1}}, {{N0, N1, N2, N3, N4}},
+                       {{3, 3, 3, 2, 2}});
 
-      Kokkos::View< double*****, ExecSpace > v_in("v_in", N0, N1, N2, N3, N4 );
+      Kokkos::View<double *****, ExecSpace> v_in("v_in", N0, N1, N2, N3, N4);
 
-      parallel_for( "rank5-init-lambda", range, KOKKOS_LAMBDA ( const int i, const int j, const int k, const int l, const int m ) {
-          v_in( i, j, k, l, m ) = (i+1) * (j+1) * (k+1) * (l+1) * (m+1) ;
-        });
+      parallel_for(
+          "rank5-init-lambda", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m) {
+            v_in(i, j, k, l, m) =
+                (i + 1) * (j + 1) * (k + 1) * (l + 1) * (m + 1);
+          });
 
       double min;
 
-      parallel_reduce("rank5-min-reducer", range, KOKKOS_LAMBDA ( const int i, const int j, const int k, const int l, const int m, double& min_val ) {
-            min_val = (v_in(i,j,k,l,m) < min_val) ? v_in(i,j,k,l,m) : min_val;
-          }
-        , Kokkos::Min<double>(min) );
+      parallel_reduce(
+          "rank5-min-reducer", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m, double &min_val) {
+            min_val =
+                (v_in(i, j, k, l, m) < min_val) ? v_in(i, j, k, l, m) : min_val;
+          },
+          Kokkos::Min<double>(min));
 
-      ASSERT_EQ( min, 32.0 );
+      ASSERT_EQ(min, 32.0);
     }
 #endif
 #endif
 
     // Tagged operator test
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5, Iterate::Default, Iterate::Default >, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<5, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 2, 4, 6, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{2, 4, 6, 2, 2}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       // check parallel_for results correct with InitTag
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 3 ) {
-          ++counter;
-        }
-      }
-
-      if ( counter != 0 ) {
-        printf( "Defaults + InitTag op(): Errors in test_reduce5 parallel_for init; mismatches = %d\n\n", counter );
-      }
-      ASSERT_EQ( counter, 0 );
-
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 3) {
+                  ++counter;
+                }
+              }
+
+      if (counter != 0) {
+        printf(
+            "Defaults + InitTag op(): Errors in test_reduce5 parallel_for "
+            "init; mismatches = %d\n\n",
+            counter);
+      }
+      ASSERT_EQ(counter, 0);
 
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 9 * N0 * N1 * N2 * N3 * N4 );
+      ASSERT_EQ(sum, 9 * N0 * N1 * N2 * N3 * N4);
     }
   }
 
-  static void test_for5( const int N0, const int N1, const int N2, const int N3, const int N4 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_for5(const int N0, const int N1, const int N2, const int N3,
+                        const int N4) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -2179,73 +2418,80 @@ struct TestMDRange_5D {
       const int s3 = 1;
       const int s4 = 1;
 
-      range_type range( point_type{ { s0, s1, s2, s3, s4 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 3, 3, 3, 3, 1 } } );
+      range_type range(point_type{{s0, s1, s2, s3, s4}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{3, 3, 3, 3, 1}});
 
-      TestMDRange_5D::ViewType v( "v", N0, N1, N2, N3, N4 );
+      TestMDRange_5D::ViewType v("v", N0, N1, N2, N3, N4);
 
-      parallel_for( range, 
-          KOKKOS_LAMBDA ( const int i , const int j , const int k, const int l, const int m ) {
-            v(i, j, k, l, m) = 3;
-          }
-        );
+      parallel_for(
+          range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m) { v(i, j, k, l, m) = 3; });
 
-      TestMDRange_5D::HostViewType h_view = Kokkos::create_mirror_view( v );
-      Kokkos::deep_copy( h_view, v );
+      TestMDRange_5D::HostViewType h_view = Kokkos::create_mirror_view(v);
+      Kokkos::deep_copy(h_view, v);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      for ( int l = s3; l < N3; ++l )
-      for ( int m = s4; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k)
+            for (int l = s3; l < N3; ++l)
+              for (int m = s4; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 3) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Default Layouts + InitTag op(): Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Default Layouts + InitTag op(): Errors in "
+            "test_for5; mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5> >
+          range_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } } );
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}});
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 1) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( "Defaults + No Tile: Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("Defaults + No Tile: Errors in test_for5; mismatches = %d\n\n",
+               counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -2254,294 +2500,331 @@ struct TestMDRange_5D {
       int s2 = 1;
       int s3 = 1;
       int s4 = 1;
-      range_type range( point_type{ { s0, s1, s2, s3, s4 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 3, 3, 3, 3, 5 } } );
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      range_type range(point_type{{s0, s1, s2, s3, s4}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{3, 3, 3, 3, 5}});
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      for ( int l = s3; l < N3; ++l )
-      for ( int m = s4; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k)
+            for (int l = s3; l < N3; ++l)
+              for (int m = s4; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 3) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Defaults + InitTag op(): Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Defaults + InitTag op(): Errors in test_for5; "
+            "mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 4, 4, 4, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{4, 4, 4, 2, 2}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 1) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for5; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5, Iterate::Default, Iterate::Default>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<5, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 4, 4, 4, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{4, 4, 4, 2, 2}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 1) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for5; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<5, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 4, 4, 4, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{4, 4, 4, 2, 2}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 1) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for5; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<5, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 4, 4, 4, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{4, 4, 4, 2, 2}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 1) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for5; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<5, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 4, 4, 4, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{4, 4, 4, 2, 2}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 1) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for5; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<5, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4 } }, tile_type{ { 4, 4, 4, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4}},
+                       tile_type{{4, 4, 4, 2, 2}});
 
-      TestMDRange_5D functor( N0, N1, N2, N3, N4 );
+      TestMDRange_5D functor(N0, N1, N2, N3, N4);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      {
-        if ( h_view( i, j, k, l, m ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m) {
+                if (h_view(i, j, k, l, m) != 1) {
+                  ++counter;
+                }
+              }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for5; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for5; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
   }
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_6D {
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType******, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType ******, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   using value_type = double;
 
-  TestMDRange_6D( const DataType N0, const DataType N1, const DataType N2, const DataType N3, const DataType N4, const DataType N5 ) : input_view( "input_view", N0, N1, N2, N3, N4, N5 ) {}
+  TestMDRange_6D(const DataType N0, const DataType N1, const DataType N2,
+                 const DataType N3, const DataType N4, const DataType N5)
+      : input_view("input_view", N0, N1, N2, N3, N4, N5) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m, const int n ) const
-  {
-    input_view( i, j, k, l, m, n ) = 1;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m, const int n) const {
+    input_view(i, j, k, l, m, n) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m, const int n, value_type &lsum ) const
-  {
-    lsum += input_view( i, j, k, l, m, n ) * 2;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m, const int n, value_type &lsum) const {
+    lsum += input_view(i, j, k, l, m, n) * 2;
   }
 
   // tagged operators
   struct InitTag {};
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k, const int l, const int m, const int n ) const
-  {
-    input_view( i, j, k, l, m, n ) = 3;
+  void operator()(const InitTag &, const int i, const int j, const int k,
+                  const int l, const int m, const int n) const {
+    input_view(i, j, k, l, m, n) = 3;
   }
 
   // reduction tagged operators
   KOKKOS_INLINE_FUNCTION
-  void operator()( const InitTag &, const int i, const int j, const int k, const int l, const int m, const int n, value_type &lsum ) const
-  {
-    lsum += input_view( i, j, k, l, m, n ) * 3;
+  void operator()(const InitTag &, const int i, const int j, const int k,
+                  const int l, const int m, const int n,
+                  value_type &lsum) const {
+    lsum += input_view(i, j, k, l, m, n) * 3;
   }
 
-  static void test_reduce6( const int N0, const int N1, const int N2, const int N3, const int N4, const int N5 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_reduce6(const int N0, const int N1, const int N2,
+                           const int N3, const int N4, const int N5) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 3, 3, 3, 3, 1, 1 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{3, 3, 3, 3, 1, 1}});
       double sum = 0.0;
-      parallel_reduce( range
-        , KOKKOS_LAMBDA(const int i, const int j, const int k, const int l, const int m, const int n, double &lsum) {
-            lsum+=1.0;
-          }
-        , sum );
-      ASSERT_EQ( sum, N0 * N1 * N2 * N3 * N4 * N5 );
+      parallel_reduce(
+          range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m, const int n,
+                        double &lsum) { lsum += 1.0; },
+          sum);
+      ASSERT_EQ(sum, N0 * N1 * N2 * N3 * N4 * N5);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -2551,145 +2834,178 @@ struct TestMDRange_6D {
       int s3 = 1;
       int s4 = 1;
       int s5 = 1;
-      range_type range( point_type{ { s0, s1, s2, s3, s4, s5 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 3, 3, 3, 3, 3, 2 } } );
+      range_type range(point_type{{s0, s1, s2, s3, s4, s5}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{3, 3, 3, 3, 3, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (N0 - s0) * (N1 - s1) * (N2 - s2) * (N3 - s3) * (N4 - s4) * (N5 - s5) );
+      ASSERT_EQ(sum, 2 * (N0 - s0) * (N1 - s1) * (N2 - s2) * (N3 - s3) *
+                         (N4 - s4) * (N5 - s5));
     }
 
     // Test with reducers - scalar
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0, 0, 0 }}, {{ N0, N1, N2, N3, N4, N5 }}, {{ 3, 3, 3, 3, 3, 2 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0, 0, 0}}, {{N0, N1, N2, N3, N4, N5}},
+                       {{3, 3, 3, 3, 3, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( range, functor, reducer_scalar );
+      parallel_reduce(range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 * N4 * N5 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3 * N4 * N5);
     }
 
     // Test with reducers - scalar + label
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0, 0, 0 }}, {{ N0, N1, N2, N3, N4, N5 }}, {{ 3, 3, 3, 3, 3, 2 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0, 0, 0}}, {{N0, N1, N2, N3, N4, N5}},
+                       {{3, 3, 3, 3, 3, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( "rank6-parfor-label", range, functor );
+      parallel_for("rank6-parfor-label", range, functor);
 
       value_type sum = 0.0;
-      Kokkos::Sum< value_type > reducer_scalar( sum );
+      Kokkos::Sum<value_type> reducer_scalar(sum);
 
-      parallel_reduce( "rank6-reducer-label", range, functor, reducer_scalar );
+      parallel_reduce("rank6-reducer-label", range, functor, reducer_scalar);
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 * N4 * N5 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3 * N4 * N5);
     }
 
     // Test with reducers - scalar view
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
-      range_type range( {{ 0, 0, 0, 0, 0, 0 }}, {{ N0, N1, N2, N3, N4, N5 }}, {{ 3, 3, 3, 3, 3, 2 }} );
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
+      range_type range({{0, 0, 0, 0, 0, 0}}, {{N0, N1, N2, N3, N4, N5}},
+                       {{3, 3, 3, 3, 3, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       value_type sum = 0.0;
-      Kokkos::View< value_type, Kokkos::HostSpace > sum_view("sum_view");
+      Kokkos::View<value_type, Kokkos::HostSpace> sum_view("sum_view");
       sum_view() = sum;
-      Kokkos::Sum< value_type > reducer_view( sum_view );
+      Kokkos::Sum<value_type> reducer_view(sum_view);
 
-      parallel_reduce( range, functor, reducer_view);
+      parallel_reduce(range, functor, reducer_view);
       Kokkos::fence();
       sum = sum_view();
 
-      ASSERT_EQ( sum, 2 * N0 * N1 * N2 * N3 * N4 * N5 );
+      ASSERT_EQ(sum, 2 * N0 * N1 * N2 * N3 * N4 * N5);
     }
 
     // Test Min reducer with lambda
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
 
-      range_type range( {{ 1, 1, 1, 1, 1, 1 }}, {{ N0, N1, N2, N3, N4, N5 }}, {{ 3, 3, 3, 2, 2, 1 }} );
+      range_type range({{1, 1, 1, 1, 1, 1}}, {{N0, N1, N2, N3, N4, N5}},
+                       {{3, 3, 3, 2, 2, 1}});
 
-      Kokkos::View< double******, ExecSpace > v_in("v_in", N0, N1, N2, N3, N4, N5 );
+      Kokkos::View<double ******, ExecSpace> v_in("v_in", N0, N1, N2, N3, N4,
+                                                  N5);
 
-      parallel_for( "rank6-init-lambda", range, KOKKOS_LAMBDA ( const int i, const int j, const int k, const int l, const int m, const int n ) {
-          v_in( i, j, k, l, m, n ) = (i+1) * (j+1) * (k+1) * (l+1) * (m+1) * (n+1) ;
-        });
+      parallel_for(
+          "rank6-init-lambda", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m, const int n) {
+            v_in(i, j, k, l, m, n) =
+                (i + 1) * (j + 1) * (k + 1) * (l + 1) * (m + 1) * (n + 1);
+          });
 
       double min;
 
-      parallel_reduce("rank6-min-reducer",  range, KOKKOS_LAMBDA ( const int i, const int j, const int k, const int l, const int m, const int n, double& min_val ) {
-            min_val = (v_in(i,j,k,l,m,n) < min_val) ? v_in(i,j,k,l,m,n) : min_val;
-          }
-        , Kokkos::Min<double>(min) );
+      parallel_reduce(
+          "rank6-min-reducer", range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m, const int n, double &min_val) {
+            min_val = (v_in(i, j, k, l, m, n) < min_val)
+                          ? v_in(i, j, k, l, m, n)
+                          : min_val;
+          },
+          Kokkos::Min<double>(min));
 
-      ASSERT_EQ( min, 64.0 );
+      ASSERT_EQ(min, 64.0);
     }
 #endif
 #endif
 
     // Tagged operator test
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6, Iterate::Default, Iterate::Default >, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<6, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 2, 4, 6, 2, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{2, 4, 6, 2, 2, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
       // check parallel_for results correct with InitTag
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 3 ) {
-          ++counter;
-        }
-      }
-
-      if ( counter != 0 ) {
-        printf( "Defaults + InitTag op(): Errors in test_reduce6 parallel_for init; mismatches = %d\n\n", counter );
-      }
-      ASSERT_EQ( counter, 0 );
-
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 3) {
+                    ++counter;
+                  }
+                }
+
+      if (counter != 0) {
+        printf(
+            "Defaults + InitTag op(): Errors in test_reduce6 parallel_for "
+            "init; mismatches = %d\n\n",
+            counter);
+      }
+      ASSERT_EQ(counter, 0);
 
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 9 * N0 * N1 * N2 * N3 * N4 * N5 );
+      ASSERT_EQ(sum, 9 * N0 * N1 * N2 * N3 * N4 * N5);
     }
   }
 
-  static void test_for6( const int N0, const int N1, const int N2, const int N3, const int N4, const int N5 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_for6(const int N0, const int N1, const int N2, const int N3,
+                        const int N4, const int N5) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -2700,75 +3016,82 @@ struct TestMDRange_6D {
       const int s4 = 1;
       const int s5 = 1;
 
-      range_type range( point_type{ { s0, s1, s2, s3, s4, s5 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 3, 3, 3, 3, 1, 1 } } );
+      range_type range(point_type{{s0, s1, s2, s3, s4, s5}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{3, 3, 3, 3, 1, 1}});
 
-      TestMDRange_6D::ViewType v( "v", N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D::ViewType v("v", N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, 
-          KOKKOS_LAMBDA ( const int i , const int j , const int k, const int l, const int m, const int n ) {
-            v(i, j, k, l, m, n) = 3;
-          }
-        );
+      parallel_for(
+          range,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l,
+                        const int m, const int n) { v(i, j, k, l, m, n) = 3; });
 
-      TestMDRange_6D::HostViewType h_view = Kokkos::create_mirror_view( v );
-      Kokkos::deep_copy( h_view, v );
+      TestMDRange_6D::HostViewType h_view = Kokkos::create_mirror_view(v);
+      Kokkos::deep_copy(h_view, v);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      for ( int l = s3; l < N3; ++l )
-      for ( int m = s4; m < N4; ++m )
-      for ( int n = s5; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 3 ) {
-          ++counter;
-        }
-      }
-
-      if ( counter != 0 ) {
-        printf( "Offset Start + Default Layouts + InitTag op(): Errors in test_for6; mismatches = %d\n\n", counter );
-      }
-
-      ASSERT_EQ( counter, 0 );
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k)
+            for (int l = s3; l < N3; ++l)
+              for (int m = s4; m < N4; ++m)
+                for (int n = s5; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 3) {
+                    ++counter;
+                  }
+                }
+
+      if (counter != 0) {
+        printf(
+            "Offset Start + Default Layouts + InitTag op(): Errors in "
+            "test_for6; mismatches = %d\n\n",
+            counter);
+      }
+
+      ASSERT_EQ(counter, 0);
     }
 #endif
 #endif
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6> >
+          range_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } } );
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}});
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 1) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( "Defaults + No Tile: Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf("Defaults + No Tile: Errors in test_for6; mismatches = %d\n\n",
+               counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int>, InitTag > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int>, InitTag>
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
@@ -2778,426 +3101,473 @@ struct TestMDRange_6D {
       int s3 = 1;
       int s4 = 1;
       int s5 = 1;
-      range_type range( point_type{ { s0, s1, s2, s3, s4, s5 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 3, 3, 3, 3, 2, 3 } } ); //tile dims 3,3,3,3,3,3 more than cuda can handle with debugging
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      range_type range(
+          point_type{{s0, s1, s2, s3, s4, s5}},
+          point_type{{N0, N1, N2, N3, N4, N5}},
+          tile_type{{3, 3, 3, 3, 2, 3}});  // tile dims 3,3,3,3,3,3 more than
+                                           // cuda can handle with debugging
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = s0; i < N0; ++i )
-      for ( int j = s1; j < N1; ++j )
-      for ( int k = s2; k < N2; ++k )
-      for ( int l = s3; l < N3; ++l )
-      for ( int m = s4; m < N4; ++m )
-      for ( int n = s5; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 3 ) {
-          ++counter;
-        }
-      }
+      for (int i = s0; i < N0; ++i)
+        for (int j = s1; j < N1; ++j)
+          for (int k = s2; k < N2; ++k)
+            for (int l = s3; l < N3; ++l)
+              for (int m = s4; m < N4; ++m)
+                for (int n = s5; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 3) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( "Offset Start + Defaults + InitTag op(): Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(
+            "Offset Start + Defaults + InitTag op(): Errors in test_for6; "
+            "mismatches = %d\n\n",
+            counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 4, 4, 4, 2, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{4, 4, 4, 2, 2, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 1) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for6; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6, Iterate::Default, Iterate::Default>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<6, Iterate::Default, Iterate::Default>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 4, 4, 4, 2, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{4, 4, 4, 2, 2, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 1) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for6; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6, Iterate::Left, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<6, Iterate::Left, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 4, 4, 4, 2, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{4, 4, 4, 2, 2, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 1) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for6; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6, Iterate::Left, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<6, Iterate::Left, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 4, 4, 4, 2, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{4, 4, 4, 2, 2, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 1) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for6; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6, Iterate::Right, Iterate::Left>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<6, Iterate::Right, Iterate::Left>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 4, 4, 4, 2, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{4, 4, 4, 2, 2, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 1) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for6; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
 
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6, Iterate::Right, Iterate::Right>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<
+          ExecSpace, Kokkos::Rank<6, Iterate::Right, Iterate::Right>,
+          Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
-      range_type range( point_type{ { 0, 0, 0, 0, 0, 0 } }, point_type{ { N0, N1, N2, N3, N4, N5 } }, tile_type{ { 4, 4, 4, 2, 2, 2 } } );
+      range_type range(point_type{{0, 0, 0, 0, 0, 0}},
+                       point_type{{N0, N1, N2, N3, N4, N5}},
+                       tile_type{{4, 4, 4, 2, 2, 2}});
 
-      TestMDRange_6D functor( N0, N1, N2, N3, N4, N5 );
+      TestMDRange_6D functor(N0, N1, N2, N3, N4, N5);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
 
-      HostViewType h_view = Kokkos::create_mirror_view( functor.input_view );
-      Kokkos::deep_copy( h_view, functor.input_view );
+      HostViewType h_view = Kokkos::create_mirror_view(functor.input_view);
+      Kokkos::deep_copy(h_view, functor.input_view);
 
       int counter = 0;
-      for ( int i = 0; i < N0; ++i )
-      for ( int j = 0; j < N1; ++j )
-      for ( int k = 0; k < N2; ++k )
-      for ( int l = 0; l < N3; ++l )
-      for ( int m = 0; m < N4; ++m )
-      for ( int n = 0; n < N5; ++n )
-      {
-        if ( h_view( i, j, k, l, m, n ) != 1 ) {
-          ++counter;
-        }
-      }
+      for (int i = 0; i < N0; ++i)
+        for (int j = 0; j < N1; ++j)
+          for (int k = 0; k < N2; ++k)
+            for (int l = 0; l < N3; ++l)
+              for (int m = 0; m < N4; ++m)
+                for (int n = 0; n < N5; ++n) {
+                  if (h_view(i, j, k, l, m, n) != 1) {
+                    ++counter;
+                  }
+                }
 
-      if ( counter != 0 ) {
-        printf( " Errors in test_for6; mismatches = %d\n\n", counter );
+      if (counter != 0) {
+        printf(" Errors in test_for6; mismatches = %d\n\n", counter);
       }
 
-      ASSERT_EQ( counter, 0 );
+      ASSERT_EQ(counter, 0);
     }
   }
 };
 
-
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_2D_NegIdx {
-
   using value_type = double;
 
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType**, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType **, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   DataType lower_offset[2];
 
-  TestMDRange_2D_NegIdx( const DataType L0, const DataType L1, const DataType N0, const DataType N1 ) : input_view( "input_view", N0 - L0, N1 - L1 ) 
-  {
+  TestMDRange_2D_NegIdx(const DataType L0, const DataType L1, const DataType N0,
+                        const DataType N1)
+      : input_view("input_view", N0 - L0, N1 - L1) {
     lower_offset[0] = L0;
     lower_offset[1] = L1;
   }
 
-  // When using negative indices, must offset View appropriately as views cannot take a negative index
+  // When using negative indices, must offset View appropriately as views cannot
+  // take a negative index
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j ) const
-  {
-    input_view( i - lower_offset[0], j - lower_offset[1] ) = 1;
+  void operator()(const int i, const int j) const {
+    input_view(i - lower_offset[0], j - lower_offset[1]) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, value_type &lsum ) const
-  {
-    lsum += input_view( i - lower_offset[0], j - lower_offset[1] ) * 2;
+  void operator()(const int i, const int j, value_type &lsum) const {
+    lsum += input_view(i - lower_offset[0], j - lower_offset[1]) * 2;
   }
 
-  static void test_2D_negidx( const int N0, const int N1 )
-  {
-
+  static void test_2D_negidx(const int N0, const int N1) {
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<2>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       const point_type lower{{-1, -1}};
       const point_type upper{{N0, N1}};
-      const tile_type  tile{{8,8}};
+      const tile_type tile{{8, 8}};
 
-      range_type range( point_type{{ lower[0], lower[1] }}, point_type{{ upper[0], upper[1] }}, tile_type{{ tile[0], tile[1] }} );
+      range_type range(point_type{{lower[0], lower[1]}},
+                       point_type{{upper[0], upper[1]}},
+                       tile_type{{tile[0], tile[1]}});
 
-      TestMDRange_2D_NegIdx functor( lower[0], lower[1], upper[0], upper[1] );
+      TestMDRange_2D_NegIdx functor(lower[0], lower[1], upper[0], upper[1]);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) );
+      ASSERT_EQ(sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]));
     }
   }
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_3D_NegIdx {
-
   using value_type = double;
 
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType***, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType ***, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   DataType lower_offset[3];
 
-  TestMDRange_3D_NegIdx( const DataType L0, const DataType L1, const DataType L2, const DataType N0, const DataType N1, const DataType N2 ) : input_view( "input_view", N0 - L0, N1 - L1, N2 - L2 ) 
-  {
+  TestMDRange_3D_NegIdx(const DataType L0, const DataType L1, const DataType L2,
+                        const DataType N0, const DataType N1, const DataType N2)
+      : input_view("input_view", N0 - L0, N1 - L1, N2 - L2) {
     lower_offset[0] = L0;
     lower_offset[1] = L1;
     lower_offset[2] = L2;
   }
 
-  // When using negative indices, must offset View appropriately as views cannot take a negative index
+  // When using negative indices, must offset View appropriately as views cannot
+  // take a negative index
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k ) const
-  {
-    input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2] ) = 1;
+  void operator()(const int i, const int j, const int k) const {
+    input_view(i - lower_offset[0], j - lower_offset[1], k - lower_offset[2]) =
+        1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, value_type &lsum ) const
-  {
-    lsum += input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2] ) * 2;
+  void operator()(const int i, const int j, const int k,
+                  value_type &lsum) const {
+    lsum += input_view(i - lower_offset[0], j - lower_offset[1],
+                       k - lower_offset[2]) *
+            2;
   }
 
-  static void test_3D_negidx( const int N0, const int N1, const int N2 )
-  {
-
+  static void test_3D_negidx(const int N0, const int N1, const int N2) {
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<3>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<3>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       const point_type lower{{-1, -1, -1}};
       const point_type upper{{N0, N1, N2}};
-      const tile_type  tile{{8,8,2}};
+      const tile_type tile{{8, 8, 2}};
 
-      range_type range( point_type{{ lower[0], lower[1], lower[2] }}, point_type{{ upper[0], upper[1], upper[2] }}, tile_type{{ tile[0], tile[1], tile[2] }} );
+      range_type range(point_type{{lower[0], lower[1], lower[2]}},
+                       point_type{{upper[0], upper[1], upper[2]}},
+                       tile_type{{tile[0], tile[1], tile[2]}});
 
-      TestMDRange_3D_NegIdx functor( lower[0], lower[1], lower[2], upper[0], upper[1], upper[2] );
+      TestMDRange_3D_NegIdx functor(lower[0], lower[1], lower[2], upper[0],
+                                    upper[1], upper[2]);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) * (upper[2] - lower[2]) );
+      ASSERT_EQ(sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) *
+                         (upper[2] - lower[2]));
     }
   }
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_4D_NegIdx {
-
   using value_type = double;
 
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType****, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType ****, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   DataType lower_offset[4];
 
-  TestMDRange_4D_NegIdx( const DataType L0, const DataType L1, const DataType L2, const DataType L3, const DataType N0, const DataType N1, const DataType N2, const DataType N3 ) : input_view( "input_view", N0 - L0, N1 - L1, N2 - L2, N3 - L3 ) 
-  {
+  TestMDRange_4D_NegIdx(const DataType L0, const DataType L1, const DataType L2,
+                        const DataType L3, const DataType N0, const DataType N1,
+                        const DataType N2, const DataType N3)
+      : input_view("input_view", N0 - L0, N1 - L1, N2 - L2, N3 - L3) {
     lower_offset[0] = L0;
     lower_offset[1] = L1;
     lower_offset[2] = L2;
     lower_offset[3] = L3;
   }
 
-  // When using negative indices, must offset View appropriately as views cannot take a negative index
+  // When using negative indices, must offset View appropriately as views cannot
+  // take a negative index
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l ) const
-  {
-    input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2], l - lower_offset[3] ) = 1;
+  void operator()(const int i, const int j, const int k, const int l) const {
+    input_view(i - lower_offset[0], j - lower_offset[1], k - lower_offset[2],
+               l - lower_offset[3]) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, value_type &lsum ) const
-  {
-    lsum += input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2], l - lower_offset[3] ) * 2;
+  void operator()(const int i, const int j, const int k, const int l,
+                  value_type &lsum) const {
+    lsum += input_view(i - lower_offset[0], j - lower_offset[1],
+                       k - lower_offset[2], l - lower_offset[3]) *
+            2;
   }
 
-  static void test_4D_negidx( const int N0, const int N1, const int N2, const int N3 )
-  {
-
+  static void test_4D_negidx(const int N0, const int N1, const int N2,
+                             const int N3) {
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<4>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<4>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       const point_type lower{{-1, -1, -1, -1}};
       const point_type upper{{N0, N1, N2, N3}};
-      const tile_type  tile{{8,8,2,2}};
+      const tile_type tile{{8, 8, 2, 2}};
 
-      range_type range( point_type{{ lower[0], lower[1], lower[2], lower[3] }}, point_type{{ upper[0], upper[1], upper[2], upper[3] }}, tile_type{{ tile[0], tile[1], tile[2], tile[3] }} );
+      range_type range(point_type{{lower[0], lower[1], lower[2], lower[3]}},
+                       point_type{{upper[0], upper[1], upper[2], upper[3]}},
+                       tile_type{{tile[0], tile[1], tile[2], tile[3]}});
 
-      TestMDRange_4D_NegIdx functor( lower[0], lower[1], lower[2], lower[3], upper[0], upper[1], upper[2], upper[3] );
+      TestMDRange_4D_NegIdx functor(lower[0], lower[1], lower[2], lower[3],
+                                    upper[0], upper[1], upper[2], upper[3]);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) * (upper[2] - lower[2]) * (upper[3] - lower[3]) );
+      ASSERT_EQ(sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) *
+                         (upper[2] - lower[2]) * (upper[3] - lower[3]));
     }
   }
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_5D_NegIdx {
-
   using value_type = double;
 
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType*****, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType *****, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   DataType lower_offset[5];
 
-  TestMDRange_5D_NegIdx( const DataType L0, const DataType L1, const DataType L2, const DataType L3, const DataType L4, const DataType N0, const DataType N1, const DataType N2, const DataType N3, const DataType N4 ) : input_view( "input_view", N0 - L0, N1 - L1, N2 - L2, N3 - L3, N4 - L4 ) 
-  {
+  TestMDRange_5D_NegIdx(const DataType L0, const DataType L1, const DataType L2,
+                        const DataType L3, const DataType L4, const DataType N0,
+                        const DataType N1, const DataType N2, const DataType N3,
+                        const DataType N4)
+      : input_view("input_view", N0 - L0, N1 - L1, N2 - L2, N3 - L3, N4 - L4) {
     lower_offset[0] = L0;
     lower_offset[1] = L1;
     lower_offset[2] = L2;
@@ -3205,58 +3575,74 @@ struct TestMDRange_5D_NegIdx {
     lower_offset[4] = L4;
   }
 
-  // When using negative indices, must offset View appropriately as views cannot take a negative index
+  // When using negative indices, must offset View appropriately as views cannot
+  // take a negative index
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m ) const
-  {
-    input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2], l - lower_offset[3], m - lower_offset[4] ) = 1;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m) const {
+    input_view(i - lower_offset[0], j - lower_offset[1], k - lower_offset[2],
+               l - lower_offset[3], m - lower_offset[4]) = 1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m, value_type &lsum ) const
-  {
-    lsum += input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2], l - lower_offset[3], m - lower_offset[4] ) * 2;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m, value_type &lsum) const {
+    lsum += input_view(i - lower_offset[0], j - lower_offset[1],
+                       k - lower_offset[2], l - lower_offset[3],
+                       m - lower_offset[4]) *
+            2;
   }
 
-  static void test_5D_negidx( const int N0, const int N1, const int N2, const int N3, const int N4 )
-  {
-
+  static void test_5D_negidx(const int N0, const int N1, const int N2,
+                             const int N3, const int N4) {
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<5>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<5>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       const point_type lower{{-1, -1, -1, -1, -1}};
       const point_type upper{{N0, N1, N2, N3, N4}};
-      const tile_type  tile{{8,4,2,2,2}};
+      const tile_type tile{{8, 4, 2, 2, 2}};
 
-      range_type range( point_type{{ lower[0], lower[1], lower[2], lower[3], lower[4] }}, point_type{{ upper[0], upper[1], upper[2], upper[3], upper[4] }}, tile_type{{ tile[0], tile[1], tile[2], tile[3], tile[4] }} );
+      range_type range(
+          point_type{{lower[0], lower[1], lower[2], lower[3], lower[4]}},
+          point_type{{upper[0], upper[1], upper[2], upper[3], upper[4]}},
+          tile_type{{tile[0], tile[1], tile[2], tile[3], tile[4]}});
 
-      TestMDRange_5D_NegIdx functor( lower[0], lower[1], lower[2], lower[3], lower[4], upper[0], upper[1], upper[2], upper[3], upper[4] );
+      TestMDRange_5D_NegIdx functor(lower[0], lower[1], lower[2], lower[3],
+                                    lower[4], upper[0], upper[1], upper[2],
+                                    upper[3], upper[4]);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) * (upper[2] - lower[2]) * (upper[3] - lower[3]) * (upper[4] - lower[4]) );
+      ASSERT_EQ(sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) *
+                         (upper[2] - lower[2]) * (upper[3] - lower[3]) *
+                         (upper[4] - lower[4]));
     }
   }
 };
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestMDRange_6D_NegIdx {
-
   using value_type = double;
 
   using DataType     = int;
-  using ViewType     = typename Kokkos::View< DataType******, ExecSpace >;
+  using ViewType     = typename Kokkos::View<DataType ******, ExecSpace>;
   using HostViewType = typename ViewType::HostMirror;
 
   ViewType input_view;
   DataType lower_offset[6];
 
-  TestMDRange_6D_NegIdx( const DataType L0, const DataType L1, const DataType L2, const DataType L3, const DataType L4, const DataType L5, const DataType N0, const DataType N1, const DataType N2, const DataType N3, const DataType N4, const DataType N5 ) : input_view( "input_view", N0 - L0, N1 - L1, N2 - L2, N3 - L3, N4 - L4, N5 - L5 ) 
-  {
+  TestMDRange_6D_NegIdx(const DataType L0, const DataType L1, const DataType L2,
+                        const DataType L3, const DataType L4, const DataType L5,
+                        const DataType N0, const DataType N1, const DataType N2,
+                        const DataType N3, const DataType N4, const DataType N5)
+      : input_view("input_view", N0 - L0, N1 - L1, N2 - L2, N3 - L3, N4 - L4,
+                   N5 - L5) {
     lower_offset[0] = L0;
     lower_offset[1] = L1;
     lower_offset[2] = L2;
@@ -3265,45 +3651,60 @@ struct TestMDRange_6D_NegIdx {
     lower_offset[5] = L5;
   }
 
-  // When using negative indices, must offset View appropriately as views cannot take a negative index
+  // When using negative indices, must offset View appropriately as views cannot
+  // take a negative index
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m, const int n ) const
-  {
-    input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2], l - lower_offset[3], m - lower_offset[4], n - lower_offset[5] ) = 1;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m, const int n) const {
+    input_view(i - lower_offset[0], j - lower_offset[1], k - lower_offset[2],
+               l - lower_offset[3], m - lower_offset[4], n - lower_offset[5]) =
+        1;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, const int j, const int k, const int l, const int m, const int n, value_type &lsum ) const
-  {
-    lsum += input_view( i - lower_offset[0], j - lower_offset[1], k - lower_offset[2], l - lower_offset[3], m - lower_offset[4], n - lower_offset[5] ) * 2;
+  void operator()(const int i, const int j, const int k, const int l,
+                  const int m, const int n, value_type &lsum) const {
+    lsum += input_view(i - lower_offset[0], j - lower_offset[1],
+                       k - lower_offset[2], l - lower_offset[3],
+                       m - lower_offset[4], n - lower_offset[5]) *
+            2;
   }
 
-  static void test_6D_negidx( const int N0, const int N1, const int N2, const int N3, const int N4, const int N5 )
-  {
-
+  static void test_6D_negidx(const int N0, const int N1, const int N2,
+                             const int N3, const int N4, const int N5) {
     {
-      typedef typename Kokkos::MDRangePolicy< ExecSpace, Kokkos::Rank<6>, Kokkos::IndexType<int> > range_type;
+      typedef typename Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<6>,
+                                             Kokkos::IndexType<int> >
+          range_type;
       typedef typename range_type::tile_type tile_type;
       typedef typename range_type::point_type point_type;
 
       const point_type lower{{-1, -1, -1, -1, -1, -1}};
       const point_type upper{{N0, N1, N2, N3, N4, N5}};
-      const tile_type  tile{{8,4,2,2,2,1}};
+      const tile_type tile{{8, 4, 2, 2, 2, 1}};
 
-      range_type range( point_type{{ lower[0], lower[1], lower[2], lower[3], lower[4], lower[5] }}, point_type{{ upper[0], upper[1], upper[2], upper[3], upper[4], upper[5] }}, tile_type{{ tile[0], tile[1], tile[2], tile[3], tile[4], tile[5] }} );
+      range_type range(
+          point_type{
+              {lower[0], lower[1], lower[2], lower[3], lower[4], lower[5]}},
+          point_type{
+              {upper[0], upper[1], upper[2], upper[3], upper[4], upper[5]}},
+          tile_type{{tile[0], tile[1], tile[2], tile[3], tile[4], tile[5]}});
 
-      TestMDRange_6D_NegIdx functor( lower[0], lower[1], lower[2], lower[3], lower[4], lower[5], upper[0], upper[1], upper[2], upper[3], upper[4], upper[5] );
+      TestMDRange_6D_NegIdx functor(lower[0], lower[1], lower[2], lower[3],
+                                    lower[4], lower[5], upper[0], upper[1],
+                                    upper[2], upper[3], upper[4], upper[5]);
 
-      parallel_for( range, functor );
+      parallel_for(range, functor);
       double sum = 0.0;
-      parallel_reduce( range, functor, sum );
+      parallel_reduce(range, functor, sum);
 
-      ASSERT_EQ( sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) * (upper[2] - lower[2]) * (upper[3] - lower[3]) * (upper[4] - lower[4]) * (upper[5] - lower[5]) );
+      ASSERT_EQ(sum, 2 * (upper[0] - lower[0]) * (upper[1] - lower[1]) *
+                         (upper[2] - lower[2]) * (upper[3] - lower[3]) *
+                         (upper[4] - lower[4]) * (upper[5] - lower[5]));
     }
   }
 };
 
+}  // namespace
 
-} // namespace
-
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestMDRange_a.hpp b/lib/kokkos/core/unit_test/TestMDRange_a.hpp
index 308b3a3029bb7ea7822dc37806f080a113cf04c1..3bb9ab089fd9e883516619e89f7eeebe0d447a48 100644
--- a/lib/kokkos/core/unit_test/TestMDRange_a.hpp
+++ b/lib/kokkos/core/unit_test/TestMDRange_a.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,15 +42,16 @@
 //@HEADER
 */
 
-#include<TestMDRange.hpp>
+#include <TestMDRange.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_5d ) {
-#if !defined ( KOKKOS_ENABLE_ROCM ) // MDRange Reduce explicitly handled in its own cpp file
-  TestMDRange_5D< TEST_EXECSPACE >::test_reduce5( 100, 10, 10, 10, 5 );
+TEST(TEST_CATEGORY, mdrange_5d) {
+#if !defined(KOKKOS_ENABLE_ROCM)  // MDRange Reduce explicitly handled in its
+                                  // own cpp file
+  TestMDRange_5D<TEST_EXECSPACE>::test_reduce5(100, 10, 10, 10, 5);
 #endif
-  TestMDRange_5D< TEST_EXECSPACE >::test_for5( 100, 10, 10, 10, 5 );
+  TestMDRange_5D<TEST_EXECSPACE>::test_for5(100, 10, 10, 10, 5);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestMDRange_b.hpp b/lib/kokkos/core/unit_test/TestMDRange_b.hpp
index e714f18395c9d2342a7acf3799164b5ae276ab1e..17dcedd428810f6a4f1f55bd6865fd16551672ea 100644
--- a/lib/kokkos/core/unit_test/TestMDRange_b.hpp
+++ b/lib/kokkos/core/unit_test/TestMDRange_b.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,15 +42,16 @@
 //@HEADER
 */
 
-#include<TestMDRange.hpp>
+#include <TestMDRange.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_6d ) {
-  TestMDRange_6D< TEST_EXECSPACE >::test_for6( 10, 10, 10, 10, 5, 5 );
-#if !defined( KOKKOS_ENABLE_ROCM ) // MDRange Reduce explicitly handled in its own cpp file
-  TestMDRange_6D< TEST_EXECSPACE >::test_reduce6( 100, 10, 10, 10, 5, 5 );
+TEST(TEST_CATEGORY, mdrange_6d) {
+  TestMDRange_6D<TEST_EXECSPACE>::test_for6(10, 10, 10, 10, 5, 5);
+#if !defined(KOKKOS_ENABLE_ROCM)  // MDRange Reduce explicitly handled in its
+                                  // own cpp file
+  TestMDRange_6D<TEST_EXECSPACE>::test_reduce6(100, 10, 10, 10, 5, 5);
 #endif
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestMDRange_c.hpp b/lib/kokkos/core/unit_test/TestMDRange_c.hpp
index 810e1d82bc4b29bed9974ef23912292ed37f0d87..c37b259937a817702784a409f99143e8ff0c5db0 100644
--- a/lib/kokkos/core/unit_test/TestMDRange_c.hpp
+++ b/lib/kokkos/core/unit_test/TestMDRange_c.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,20 +42,21 @@
 //@HEADER
 */
 
-#include<TestMDRange.hpp>
+#include <TestMDRange.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_2d) {
-#if !defined( KOKKOS_ENABLE_ROCM ) // MDRange Reduce explicitly handled in its own cpp file
-  TestMDRange_2D< TEST_EXECSPACE >::test_reduce2( 100, 100 );
+TEST(TEST_CATEGORY, mdrange_2d) {
+#if !defined(KOKKOS_ENABLE_ROCM)  // MDRange Reduce explicitly handled in its
+                                  // own cpp file
+  TestMDRange_2D<TEST_EXECSPACE>::test_reduce2(100, 100);
 #endif
-  TestMDRange_2D< TEST_EXECSPACE >::test_for2( 100, 100 );
+  TestMDRange_2D<TEST_EXECSPACE>::test_for2(100, 100);
 }
 
-TEST_F( TEST_CATEGORY , mdrange_array_reduce ) {
-  TestMDRange_ReduceArray_2D< TEST_EXECSPACE >::test_arrayreduce2( 4, 5 );
-  TestMDRange_ReduceArray_3D< TEST_EXECSPACE >::test_arrayreduce3( 4, 5, 10 );
+TEST(TEST_CATEGORY, mdrange_array_reduce) {
+  TestMDRange_ReduceArray_2D<TEST_EXECSPACE>::test_arrayreduce2(4, 5);
+  TestMDRange_ReduceArray_3D<TEST_EXECSPACE>::test_arrayreduce3(4, 5, 10);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestMDRange_d.hpp b/lib/kokkos/core/unit_test/TestMDRange_d.hpp
index e25213a28936149eef6f207510824f965e982a4d..75c33caf5a6b7556ca0cbe2293e85a64d3270aa5 100644
--- a/lib/kokkos/core/unit_test/TestMDRange_d.hpp
+++ b/lib/kokkos/core/unit_test/TestMDRange_d.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,25 +42,26 @@
 //@HEADER
 */
 
-#include<TestMDRange.hpp>
+#include <TestMDRange.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_3d) {
-  TestMDRange_3D< TEST_EXECSPACE >::test_for3( 1, 10, 100 );
-  TestMDRange_3D< TEST_EXECSPACE >::test_for3( 100, 10, 100 );
-#if !defined( KOKKOS_ENABLE_ROCM ) // MDRange Reduced explicitly handled in its own cpp file
-  TestMDRange_3D< TEST_EXECSPACE >::test_reduce3( 1, 10, 100 );
-  TestMDRange_3D< TEST_EXECSPACE >::test_reduce3( 100, 10, 100 );
+TEST(TEST_CATEGORY, mdrange_3d) {
+  TestMDRange_3D<TEST_EXECSPACE>::test_for3(1, 10, 100);
+  TestMDRange_3D<TEST_EXECSPACE>::test_for3(100, 10, 100);
+#if !defined(KOKKOS_ENABLE_ROCM)  // MDRange Reduced explicitly handled in its
+                                  // own cpp file
+  TestMDRange_3D<TEST_EXECSPACE>::test_reduce3(1, 10, 100);
+  TestMDRange_3D<TEST_EXECSPACE>::test_reduce3(100, 10, 100);
 #endif
 }
 
-TEST_F( TEST_CATEGORY , mdrange_neg_idx ) {
-  TestMDRange_2D_NegIdx< TEST_EXECSPACE >::test_2D_negidx( 128, 32 );
-  TestMDRange_3D_NegIdx< TEST_EXECSPACE >::test_3D_negidx( 128, 32, 8 );
-  TestMDRange_4D_NegIdx< TEST_EXECSPACE >::test_4D_negidx( 128, 32, 8, 8 );
-  TestMDRange_5D_NegIdx< TEST_EXECSPACE >::test_5D_negidx( 128, 32, 8, 8, 4 );
-  TestMDRange_6D_NegIdx< TEST_EXECSPACE >::test_6D_negidx( 128, 32, 8, 8, 4, 2 );
+TEST(TEST_CATEGORY, mdrange_neg_idx) {
+  TestMDRange_2D_NegIdx<TEST_EXECSPACE>::test_2D_negidx(128, 32);
+  TestMDRange_3D_NegIdx<TEST_EXECSPACE>::test_3D_negidx(128, 32, 8);
+  TestMDRange_4D_NegIdx<TEST_EXECSPACE>::test_4D_negidx(128, 32, 8, 8);
+  TestMDRange_5D_NegIdx<TEST_EXECSPACE>::test_5D_negidx(128, 32, 8, 8, 4);
+  TestMDRange_6D_NegIdx<TEST_EXECSPACE>::test_6D_negidx(128, 32, 8, 8, 4, 2);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestMDRange_e.hpp b/lib/kokkos/core/unit_test/TestMDRange_e.hpp
index a6267253528d4c94342203072dc29f8baabe0380..38746cd7853f5cb163ce72c25346d9016ff0cb38 100644
--- a/lib/kokkos/core/unit_test/TestMDRange_e.hpp
+++ b/lib/kokkos/core/unit_test/TestMDRange_e.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,15 +42,16 @@
 //@HEADER
 */
 
-#include<TestMDRange.hpp>
+#include <TestMDRange.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_4d ) {
-#if !defined( KOKKOS_ENABLE_ROCM ) // MDRange Reduce explicitly handled in its own cpp file
-  TestMDRange_4D< TEST_EXECSPACE >::test_reduce4( 100, 10, 10, 10 );
+TEST(TEST_CATEGORY, mdrange_4d) {
+#if !defined(KOKKOS_ENABLE_ROCM)  // MDRange Reduce explicitly handled in its
+                                  // own cpp file
+  TestMDRange_4D<TEST_EXECSPACE>::test_reduce4(100, 10, 10, 10);
 #endif
-  TestMDRange_4D< TEST_EXECSPACE >::test_for4( 100, 10, 10, 10 );
+  TestMDRange_4D<TEST_EXECSPACE>::test_for4(100, 10, 10, 10);
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestMemoryPool.hpp b/lib/kokkos/core/unit_test/TestMemoryPool.hpp
index 00079e02eee9073677aaaafb05dd015288dc80a5..bc78a2908ed316f1c48a645c75fea8b5abbd1337 100644
--- a/lib/kokkos/core/unit_test/TestMemoryPool.hpp
+++ b/lib/kokkos/core/unit_test/TestMemoryPool.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,7 +42,6 @@
 //@HEADER
 */
 
-
 #ifndef KOKKOS_UNITTEST_MEMPOOL_HPP
 #define KOKKOS_UNITTEST_MEMPOOL_HPP
 
@@ -54,466 +54,418 @@
 
 namespace TestMemoryPool {
 
-template< typename MemSpace = Kokkos::HostSpace >
-void test_host_memory_pool_defaults()
-{
-  typedef typename MemSpace::execution_space   Space ;
-  typedef typename Kokkos::MemoryPool< Space > MemPool ;
+template <typename MemSpace = Kokkos::HostSpace>
+void test_host_memory_pool_defaults() {
+  typedef typename MemSpace::execution_space Space;
+  typedef typename Kokkos::MemoryPool<Space> MemPool;
 
   {
-    const size_t MemoryCapacity = 32000 ;
-    const size_t MinBlockSize   =    64 ;
-    const size_t MaxBlockSize   =  1024 ;
-    const size_t SuperBlockSize =  4096 ;
-
-    MemPool pool( MemSpace()
-                , MemoryCapacity
-                , MinBlockSize
-                , MaxBlockSize
-                , SuperBlockSize
-                );
-
-    typename MemPool::usage_statistics stats ;
-
-    pool.get_usage_statistics( stats );
-
-    ASSERT_LE( MemoryCapacity , stats.capacity_bytes );
-    ASSERT_LE( MinBlockSize , stats.min_block_bytes );
-    ASSERT_LE( MaxBlockSize , stats.max_block_bytes );
-    ASSERT_LE( SuperBlockSize , stats.superblock_bytes );
+    const size_t MemoryCapacity = 32000;
+    const size_t MinBlockSize   = 64;
+    const size_t MaxBlockSize   = 1024;
+    const size_t SuperBlockSize = 4096;
+
+    MemPool pool(MemSpace(), MemoryCapacity, MinBlockSize, MaxBlockSize,
+                 SuperBlockSize);
+
+    typename MemPool::usage_statistics stats;
+
+    pool.get_usage_statistics(stats);
+
+    ASSERT_LE(MemoryCapacity, stats.capacity_bytes);
+    ASSERT_LE(MinBlockSize, stats.min_block_bytes);
+    ASSERT_LE(MaxBlockSize, stats.max_block_bytes);
+    ASSERT_LE(SuperBlockSize, stats.superblock_bytes);
   }
 
   {
-    const size_t MemoryCapacity = 10000 ;
+    const size_t MemoryCapacity = 10000;
 
-    MemPool pool( MemSpace()
-                , MemoryCapacity
-                );
+    MemPool pool(MemSpace(), MemoryCapacity);
 
-    typename MemPool::usage_statistics stats ;
+    typename MemPool::usage_statistics stats;
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    ASSERT_LE( MemoryCapacity , stats.capacity_bytes );
-    ASSERT_LE( 64u /* default */ , stats.min_block_bytes );
-    ASSERT_LE( stats.min_block_bytes , stats.max_block_bytes );
-    ASSERT_LE( stats.max_block_bytes , stats.superblock_bytes );
-    ASSERT_LE( stats.superblock_bytes , stats.capacity_bytes );
+    ASSERT_LE(MemoryCapacity, stats.capacity_bytes);
+    ASSERT_LE(64u /* default */, stats.min_block_bytes);
+    ASSERT_LE(stats.min_block_bytes, stats.max_block_bytes);
+    ASSERT_LE(stats.max_block_bytes, stats.superblock_bytes);
+    ASSERT_LE(stats.superblock_bytes, stats.capacity_bytes);
   }
 
   {
-    const size_t MemoryCapacity = 10000 ;
-    const size_t MinBlockSize   =    32 ; // power of two is exact
+    const size_t MemoryCapacity = 10000;
+    const size_t MinBlockSize   = 32;  // power of two is exact
 
-    MemPool pool( MemSpace()
-                , MemoryCapacity
-                , MinBlockSize
-                );
+    MemPool pool(MemSpace(), MemoryCapacity, MinBlockSize);
 
-    typename MemPool::usage_statistics stats ;
+    typename MemPool::usage_statistics stats;
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    ASSERT_LE( MemoryCapacity , stats.capacity_bytes );
-    ASSERT_EQ( MinBlockSize , stats.min_block_bytes );
-    ASSERT_LE( stats.min_block_bytes , stats.max_block_bytes );
-    ASSERT_LE( stats.max_block_bytes , stats.superblock_bytes );
-    ASSERT_LE( stats.superblock_bytes , stats.capacity_bytes );
+    ASSERT_LE(MemoryCapacity, stats.capacity_bytes);
+    ASSERT_EQ(MinBlockSize, stats.min_block_bytes);
+    ASSERT_LE(stats.min_block_bytes, stats.max_block_bytes);
+    ASSERT_LE(stats.max_block_bytes, stats.superblock_bytes);
+    ASSERT_LE(stats.superblock_bytes, stats.capacity_bytes);
   }
 
   {
-    const size_t MemoryCapacity = 32000 ;
-    const size_t MinBlockSize   =    32 ; // power of two is exact
-    const size_t MaxBlockSize   =  1024 ; // power of two is exact
+    const size_t MemoryCapacity = 32000;
+    const size_t MinBlockSize   = 32;    // power of two is exact
+    const size_t MaxBlockSize   = 1024;  // power of two is exact
 
-    MemPool pool( MemSpace()
-                , MemoryCapacity
-                , MinBlockSize
-                , MaxBlockSize
-                );
+    MemPool pool(MemSpace(), MemoryCapacity, MinBlockSize, MaxBlockSize);
 
-    typename MemPool::usage_statistics stats ;
+    typename MemPool::usage_statistics stats;
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    ASSERT_LE( MemoryCapacity , stats.capacity_bytes );
-    ASSERT_EQ( MinBlockSize , stats.min_block_bytes );
-    ASSERT_EQ( MaxBlockSize , stats.max_block_bytes );
-    ASSERT_LE( stats.max_block_bytes , stats.superblock_bytes );
-    ASSERT_LE( stats.superblock_bytes , stats.capacity_bytes );
+    ASSERT_LE(MemoryCapacity, stats.capacity_bytes);
+    ASSERT_EQ(MinBlockSize, stats.min_block_bytes);
+    ASSERT_EQ(MaxBlockSize, stats.max_block_bytes);
+    ASSERT_LE(stats.max_block_bytes, stats.superblock_bytes);
+    ASSERT_LE(stats.superblock_bytes, stats.capacity_bytes);
   }
 }
 
-template< typename MemSpace = Kokkos::HostSpace >
-void test_host_memory_pool_stats()
-{
-  typedef typename MemSpace::execution_space   Space ;
-  typedef typename Kokkos::MemoryPool< Space > MemPool ;
+template <typename MemSpace = Kokkos::HostSpace>
+void test_host_memory_pool_stats() {
+  typedef typename MemSpace::execution_space Space;
+  typedef typename Kokkos::MemoryPool<Space> MemPool;
 
-  const size_t MemoryCapacity = 32000 ;
-  const size_t MinBlockSize   =    64 ;
-  const size_t MaxBlockSize   =  1024 ;
-  const size_t SuperBlockSize =  4096 ;
+  const size_t MemoryCapacity = 32000;
+  const size_t MinBlockSize   = 64;
+  const size_t MaxBlockSize   = 1024;
+  const size_t SuperBlockSize = 4096;
 
-  MemPool pool( MemSpace()
-              , MemoryCapacity
-              , MinBlockSize
-              , MaxBlockSize
-              , SuperBlockSize
-              );
+  MemPool pool(MemSpace(), MemoryCapacity, MinBlockSize, MaxBlockSize,
+               SuperBlockSize);
 
   {
-    typename MemPool::usage_statistics stats ;
+    typename MemPool::usage_statistics stats;
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    ASSERT_LE( MemoryCapacity , stats.capacity_bytes );
-    ASSERT_LE( MinBlockSize , stats.min_block_bytes );
-    ASSERT_LE( MaxBlockSize , stats.max_block_bytes );
-    ASSERT_LE( SuperBlockSize , stats.superblock_bytes );
+    ASSERT_LE(MemoryCapacity, stats.capacity_bytes);
+    ASSERT_LE(MinBlockSize, stats.min_block_bytes);
+    ASSERT_LE(MaxBlockSize, stats.max_block_bytes);
+    ASSERT_LE(SuperBlockSize, stats.superblock_bytes);
   }
 
-  void * p0064 = pool.allocate(64);
-  void * p0128 = pool.allocate(128);
-  void * p0256 = pool.allocate(256);
-  void * p1024 = pool.allocate(1024);
+  void* p0064 = pool.allocate(64);
+  void* p0128 = pool.allocate(128);
+  void* p0256 = pool.allocate(256);
+  void* p1024 = pool.allocate(1024);
 
   // Aborts because exceeds max block size:
   // void * p2048 = pool.allocate(2048);
 
-  ASSERT_NE( p0064 , (void*) 0 );
-  ASSERT_NE( p0128 , (void*) 0 );
-  ASSERT_NE( p0256 , (void*) 0 );
-  ASSERT_NE( p1024 , (void*) 0 );
-
-  pool.deallocate( p0064 , 64 );
-  pool.deallocate( p0128 , 128 );
-  pool.deallocate( p0256 , 256 );
-  pool.deallocate( p1024 , 1024 );
+  ASSERT_NE(p0064, (void*)0);
+  ASSERT_NE(p0128, (void*)0);
+  ASSERT_NE(p0256, (void*)0);
+  ASSERT_NE(p1024, (void*)0);
 
+  pool.deallocate(p0064, 64);
+  pool.deallocate(p0128, 128);
+  pool.deallocate(p0256, 256);
+  pool.deallocate(p1024, 1024);
 }
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template< class DeviceType >
+template <class DeviceType>
 struct TestMemoryPool_Functor {
+  typedef Kokkos::View<uintptr_t*, DeviceType> ptrs_type;
+  typedef Kokkos::MemoryPool<DeviceType> pool_type;
 
-  typedef Kokkos::View< uintptr_t * , DeviceType >         ptrs_type ;
-  typedef Kokkos::MemoryPool< DeviceType > pool_type ;
+  pool_type pool;
+  ptrs_type ptrs;
 
-  pool_type pool ;
-  ptrs_type ptrs ;
-
-  TestMemoryPool_Functor( const pool_type & arg_pool , size_t n )
-    : pool( arg_pool )
-    , ptrs( "ptrs" , n )
-    {}
+  TestMemoryPool_Functor(const pool_type& arg_pool, size_t n)
+      : pool(arg_pool), ptrs("ptrs", n) {}
 
   // Specify reduction argument value_type to avoid
   // confusion with tag-dispatch.
 
-  using value_type = long ;
+  using value_type = long;
 
   struct TagAlloc {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagAlloc , int i , long & update ) const noexcept
-    {
-      unsigned alloc_size = 32 * ( 1 + ( i % 5 ));
-      ptrs(i) = (uintptr_t)  pool.allocate( alloc_size );
-      if ( ptrs(i) ) { ++update ; }
+  void operator()(TagAlloc, int i, long& update) const noexcept {
+    unsigned alloc_size = 32 * (1 + (i % 5));
+    ptrs(i)             = (uintptr_t)pool.allocate(alloc_size);
+    if (ptrs(i)) {
+      ++update;
     }
+  }
 
   struct TagDealloc {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagDealloc , int i , long & update ) const noexcept
-    {
-      if ( ptrs(i) && ( 0 == i % 3 ) ) {
-        unsigned alloc_size = 32 * ( 1 + ( i % 5 ));
-        pool.deallocate( (void*) ptrs(i) , alloc_size );
-        ptrs(i) = 0 ;
-        ++update ;
-      }
+  void operator()(TagDealloc, int i, long& update) const noexcept {
+    if (ptrs(i) && (0 == i % 3)) {
+      unsigned alloc_size = 32 * (1 + (i % 5));
+      pool.deallocate((void*)ptrs(i), alloc_size);
+      ptrs(i) = 0;
+      ++update;
     }
+  }
 
   struct TagRealloc {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagRealloc , int i , long & update ) const noexcept
-    {
-      if ( 0 == ptrs(i) ) {
-        unsigned alloc_size = 32 * ( 1 + ( i % 5 ));
-        ptrs(i) = (uintptr_t)  pool.allocate( alloc_size );
-        if ( ptrs(i) ) { ++update ; }
+  void operator()(TagRealloc, int i, long& update) const noexcept {
+    if (0 == ptrs(i)) {
+      unsigned alloc_size = 32 * (1 + (i % 5));
+      ptrs(i)             = (uintptr_t)pool.allocate(alloc_size);
+      if (ptrs(i)) {
+        ++update;
       }
     }
+  }
 
   struct TagMixItUp {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( TagMixItUp , int i , long & update ) const noexcept
-    {
-      if ( ptrs(i) && ( 0 == i % 3 ) ) {
-
-        unsigned alloc_size = 32 * ( 1 + ( i % 5 ));
+  void operator()(TagMixItUp, int i, long& update) const noexcept {
+    if (ptrs(i) && (0 == i % 3)) {
+      unsigned alloc_size = 32 * (1 + (i % 5));
 
-        pool.deallocate( (void*) ptrs(i) , alloc_size );
+      pool.deallocate((void*)ptrs(i), alloc_size);
 
-        ptrs(i) = (uintptr_t)  pool.allocate( alloc_size );
+      ptrs(i) = (uintptr_t)pool.allocate(alloc_size);
 
-        if ( ptrs(i) ) { ++update ; }
+      if (ptrs(i)) {
+        ++update;
       }
     }
+  }
 };
 
-template< class PoolType >
-void print_memory_pool_stats
-  ( typename PoolType::usage_statistics const & stats )
-{
+template <class PoolType>
+void print_memory_pool_stats(typename PoolType::usage_statistics const& stats) {
   std::cout << "MemoryPool {" << std::endl
             << "  bytes capacity = " << stats.capacity_bytes << std::endl
             << "  bytes used     = " << stats.consumed_bytes << std::endl
             << "  bytes reserved = " << stats.reserved_bytes << std::endl
-            << "  bytes free     = " << ( stats.capacity_bytes -
-               ( stats.consumed_bytes + stats.reserved_bytes ) ) << std::endl
+            << "  bytes free     = "
+            << (stats.capacity_bytes -
+                (stats.consumed_bytes + stats.reserved_bytes))
+            << std::endl
             << "  block used     = " << stats.consumed_blocks << std::endl
             << "  block reserved = " << stats.reserved_blocks << std::endl
             << "  super used     = " << stats.consumed_superblocks << std::endl
-            << "  super reserved = " << ( stats.capacity_superblocks -
-                                    stats.consumed_superblocks ) << std::endl
-            << "}" << std::endl ;
+            << "  super reserved = "
+            << (stats.capacity_superblocks - stats.consumed_superblocks)
+            << std::endl
+            << "}" << std::endl;
 }
 
-template< class DeviceType >
-void test_memory_pool_v2( const bool print_statistics
-                        , const bool print_superblocks )
-{
-  typedef typename DeviceType::memory_space     memory_space ;
-  typedef typename DeviceType::execution_space  execution_space ;
-  typedef Kokkos::MemoryPool< DeviceType > pool_type ;
-  typedef TestMemoryPool_Functor< DeviceType > functor_type ;
-
-  typedef typename functor_type::TagAlloc   TagAlloc ;
-  typedef typename functor_type::TagDealloc TagDealloc ;
-  typedef typename functor_type::TagRealloc TagRealloc ;
-  typedef typename functor_type::TagMixItUp TagMixItUp ;
+template <class DeviceType>
+void test_memory_pool_v2(const bool print_statistics,
+                         const bool print_superblocks) {
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename DeviceType::execution_space execution_space;
+  typedef Kokkos::MemoryPool<DeviceType> pool_type;
+  typedef TestMemoryPool_Functor<DeviceType> functor_type;
 
-  const size_t    total_alloc_size = 10000000 ;
-  const unsigned  min_block_size   = 64 ;
-  const unsigned  max_block_size   = 256 ;
-  const long      nfill            = 70000 ;
+  typedef typename functor_type::TagAlloc TagAlloc;
+  typedef typename functor_type::TagDealloc TagDealloc;
+  typedef typename functor_type::TagRealloc TagRealloc;
+  typedef typename functor_type::TagMixItUp TagMixItUp;
 
-  for ( uint32_t k = 0 , min_superblock_size = 10000 ;
-        k < 3 ; ++k , min_superblock_size *= 10 ) {
+  const size_t total_alloc_size = 10000000;
+  const unsigned min_block_size = 64;
+  const unsigned max_block_size = 256;
+  const long nfill              = 70000;
 
-    typename pool_type::usage_statistics stats ;
+  for (uint32_t k = 0, min_superblock_size = 10000; k < 3;
+       ++k, min_superblock_size *= 10) {
+    typename pool_type::usage_statistics stats;
 
-    pool_type pool( memory_space()
-                  , total_alloc_size
-                  , min_block_size
-                  , max_block_size
-                  , min_superblock_size );
+    pool_type pool(memory_space(), total_alloc_size, min_block_size,
+                   max_block_size, min_superblock_size);
 
-    functor_type functor(pool,nfill);
+    functor_type functor(pool, nfill);
 
-    long result = 0 ;
-    long ndel  = 0 ;
+    long result = 0;
+    long ndel   = 0;
 
-    Kokkos::parallel_reduce
-      ( Kokkos::RangePolicy< execution_space , TagAlloc >(0,nfill)
-      , functor
-      , result
-      );
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<execution_space, TagAlloc>(0, nfill), functor,
+        result);
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    const int fill_error = ( nfill != result ) ||
-                           ( nfill != long(stats.consumed_blocks) );
+    const int fill_error =
+        (nfill != result) || (nfill != long(stats.consumed_blocks));
 
-    if ( fill_error || print_statistics ) print_memory_pool_stats< pool_type >( stats );
-    if ( fill_error || print_superblocks ) pool.print_state( std::cout );
+    if (fill_error || print_statistics)
+      print_memory_pool_stats<pool_type>(stats);
+    if (fill_error || print_superblocks) pool.print_state(std::cout);
 
-    ASSERT_EQ( nfill , result );
-    ASSERT_EQ( nfill , long(stats.consumed_blocks) );
+    ASSERT_EQ(nfill, result);
+    ASSERT_EQ(nfill, long(stats.consumed_blocks));
 
-    Kokkos::parallel_reduce
-      ( Kokkos::RangePolicy< execution_space , TagDealloc >(0,nfill)
-      , functor
-      , ndel
-      );
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<execution_space, TagDealloc>(0, nfill), functor,
+        ndel);
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    const int del_error = ( nfill - ndel ) != long(stats.consumed_blocks);
+    const int del_error = (nfill - ndel) != long(stats.consumed_blocks);
 
-    if ( del_error || print_statistics ) print_memory_pool_stats< pool_type >( stats );
-    if ( del_error || print_superblocks ) pool.print_state( std::cout );
+    if (del_error || print_statistics)
+      print_memory_pool_stats<pool_type>(stats);
+    if (del_error || print_superblocks) pool.print_state(std::cout);
 
-    ASSERT_EQ( ( nfill - ndel ) , long(stats.consumed_blocks) );
+    ASSERT_EQ((nfill - ndel), long(stats.consumed_blocks));
 
-    Kokkos::parallel_reduce
-      ( Kokkos::RangePolicy< execution_space , TagRealloc >(0,nfill)
-      , functor
-      , result
-      );
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<execution_space, TagRealloc>(0, nfill), functor,
+        result);
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    const int refill_error = ( ndel != result ) ||
-                             ( nfill != long(stats.consumed_blocks) );
+    const int refill_error =
+        (ndel != result) || (nfill != long(stats.consumed_blocks));
 
-    if ( refill_error || print_statistics ) print_memory_pool_stats< pool_type >( stats );
-    if ( refill_error || print_superblocks ) pool.print_state( std::cout );
+    if (refill_error || print_statistics)
+      print_memory_pool_stats<pool_type>(stats);
+    if (refill_error || print_superblocks) pool.print_state(std::cout);
 
-    ASSERT_EQ( ndel , result );
-    ASSERT_EQ( nfill , long(stats.consumed_blocks) );
+    ASSERT_EQ(ndel, result);
+    ASSERT_EQ(nfill, long(stats.consumed_blocks));
 
-    Kokkos::parallel_reduce
-      ( Kokkos::RangePolicy< execution_space , TagMixItUp >(0,nfill)
-      , functor
-      , result
-      );
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<execution_space, TagMixItUp>(0, nfill), functor,
+        result);
 
-    pool.get_usage_statistics( stats );
+    pool.get_usage_statistics(stats);
 
-    const int mix_error = ( ndel != result ) ||
-                          ( nfill != long(stats.consumed_blocks) );
+    const int mix_error =
+        (ndel != result) || (nfill != long(stats.consumed_blocks));
 
-    if ( mix_error || print_statistics ) print_memory_pool_stats< pool_type >( stats );
-    if ( mix_error || print_superblocks ) pool.print_state( std::cout );
+    if (mix_error || print_statistics)
+      print_memory_pool_stats<pool_type>(stats);
+    if (mix_error || print_superblocks) pool.print_state(std::cout);
 
-    ASSERT_EQ( ndel , result );
-    ASSERT_EQ( nfill , long(stats.consumed_blocks) );
+    ASSERT_EQ(ndel, result);
+    ASSERT_EQ(nfill, long(stats.consumed_blocks));
   }
 }
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template< class DeviceType >
+template <class DeviceType>
 struct TestMemoryPoolCorners {
+  typedef Kokkos::View<uintptr_t*, DeviceType> ptrs_type;
+  typedef Kokkos::MemoryPool<DeviceType> pool_type;
+
+  pool_type pool;
+  ptrs_type ptrs;
+  uint32_t size;
+  uint32_t stride;
 
-  typedef Kokkos::View< uintptr_t * , DeviceType >  ptrs_type ;
-  typedef Kokkos::MemoryPool< DeviceType >          pool_type ;
-
-  pool_type pool ;
-  ptrs_type ptrs ;
-  uint32_t  size ;
-  uint32_t  stride ;
-
-  TestMemoryPoolCorners( const pool_type & arg_pool
-                       , const ptrs_type & arg_ptrs
-                       , const uint32_t arg_base
-                       , const uint32_t arg_stride
-                       )
-    : pool( arg_pool )
-    , ptrs( arg_ptrs )
-    , size( arg_base )
-    , stride( arg_stride )
-    {}
+  TestMemoryPoolCorners(const pool_type& arg_pool, const ptrs_type& arg_ptrs,
+                        const uint32_t arg_base, const uint32_t arg_stride)
+      : pool(arg_pool), ptrs(arg_ptrs), size(arg_base), stride(arg_stride) {}
 
   // Specify reduction argument value_type to
   // avoid confusion with tag-dispatch.
 
-  using value_type = long ;
+  using value_type = long;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i , long & err ) const noexcept
-    {
-      unsigned alloc_size = size << ( i % stride );
-      if ( 0 == ptrs(i) ) {
-        ptrs(i) = (uintptr_t) pool.allocate( alloc_size );
-        if ( ptrs(i) && ! alloc_size ) { ++err ; }
+  void operator()(int i, long& err) const noexcept {
+    unsigned alloc_size = size << (i % stride);
+    if (0 == ptrs(i)) {
+      ptrs(i) = (uintptr_t)pool.allocate(alloc_size);
+      if (ptrs(i) && !alloc_size) {
+        ++err;
       }
     }
+  }
 
   struct TagDealloc {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i ) const noexcept
-    {
-      unsigned alloc_size = size << ( i % stride );
-      if ( ptrs(i) ) { pool.deallocate( (void*) ptrs(i) , alloc_size ); }
-      ptrs(i) = 0 ;
+  void operator()(int i) const noexcept {
+    unsigned alloc_size = size << (i % stride);
+    if (ptrs(i)) {
+      pool.deallocate((void*)ptrs(i), alloc_size);
     }
+    ptrs(i) = 0;
+  }
 };
 
-template< class DeviceType >
-void test_memory_pool_corners( const bool print_statistics
-                             , const bool print_superblocks )
-{
-  typedef typename DeviceType::memory_space     memory_space ;
-  typedef typename DeviceType::execution_space  execution_space ;
-  typedef Kokkos::MemoryPool< DeviceType >      pool_type ;
-  typedef TestMemoryPoolCorners< DeviceType >   functor_type ;
-  typedef typename functor_type::ptrs_type      ptrs_type ;
+template <class DeviceType>
+void test_memory_pool_corners(const bool print_statistics,
+                              const bool print_superblocks) {
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename DeviceType::execution_space execution_space;
+  typedef Kokkos::MemoryPool<DeviceType> pool_type;
+  typedef TestMemoryPoolCorners<DeviceType> functor_type;
+  typedef typename functor_type::ptrs_type ptrs_type;
 
   {
-    // superblock size 1 << 14 
-    const size_t  min_superblock_size = 1u << 14 ;
+    // superblock size 1 << 14
+    const size_t min_superblock_size = 1u << 14;
 
     // four superblocks
-    const size_t total_alloc_size = min_superblock_size * 4 ;
+    const size_t total_alloc_size = min_superblock_size * 4;
 
     // block sizes  {  64 , 128 , 256 , 512 }
     // block counts { 256 , 128 ,  64 ,  32 }
-    const unsigned  min_block_size  = 64 ;
-    const unsigned  max_block_size  = 512 ;
-    const unsigned  num_blocks      = 480 ;
+    const unsigned min_block_size = 64;
+    const unsigned max_block_size = 512;
+    const unsigned num_blocks     = 480;
 
-    pool_type pool( memory_space()
-                  , total_alloc_size
-                  , min_block_size
-                  , max_block_size
-                  , min_superblock_size );
+    pool_type pool(memory_space(), total_alloc_size, min_block_size,
+                   max_block_size, min_superblock_size);
 
     // Allocate one block from each superblock to lock that
     // superblock into the block size.
 
-    ptrs_type ptrs("ptrs",num_blocks);
-
-    long err = 0 ;
+    ptrs_type ptrs("ptrs", num_blocks);
 
-    Kokkos::parallel_reduce
-      ( Kokkos::RangePolicy< execution_space >(0,4)
-      , functor_type( pool , ptrs , 64 , 4 )
-      , err
-      );
+    long err = 0;
 
-    if ( print_statistics || err ) {
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<execution_space>(0, 4),
+                            functor_type(pool, ptrs, 64, 4), err);
 
-      typename pool_type::usage_statistics stats ;
+    if (print_statistics || err) {
+      typename pool_type::usage_statistics stats;
 
-      pool.get_usage_statistics( stats );
+      pool.get_usage_statistics(stats);
 
-      print_memory_pool_stats< pool_type >( stats );
+      print_memory_pool_stats<pool_type>(stats);
     }
 
-    if ( print_superblocks || err ) {
-      pool.print_state( std::cout );
+    if (print_superblocks || err) {
+      pool.print_state(std::cout);
     }
 
     // Now fill remaining allocations with small size
 
-    Kokkos::parallel_reduce
-      ( Kokkos::RangePolicy< execution_space >(0,num_blocks)
-      , functor_type( pool , ptrs , 64 , 1 )
-      , err
-      );
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<execution_space>(0, num_blocks),
+                            functor_type(pool, ptrs, 64, 1), err);
 
-    if ( print_statistics || err ) {
+    if (print_statistics || err) {
+      typename pool_type::usage_statistics stats;
 
-      typename pool_type::usage_statistics stats ;
+      pool.get_usage_statistics(stats);
 
-      pool.get_usage_statistics( stats );
-
-      print_memory_pool_stats< pool_type >( stats );
+      print_memory_pool_stats<pool_type>(stats);
     }
 
-    if ( print_superblocks || err ) {
-      pool.print_state( std::cout );
+    if (print_superblocks || err) {
+      pool.print_state(std::cout);
     }
   }
 }
@@ -521,117 +473,106 @@ void test_memory_pool_corners( const bool print_statistics
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template< class DeviceType , class Enable = void >
-struct TestMemoryPoolHuge
-{
+template <class DeviceType, class Enable = void>
+struct TestMemoryPoolHuge {
   TestMemoryPoolHuge() {}
 
   enum : size_t { num_superblock = 0 };
 
-  using value_type = long ;
+  using value_type = long;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i , long & err ) const noexcept {}
+  void operator()(int i, long& err) const noexcept {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i ) const noexcept {}
+  void operator()(int i) const noexcept {}
 };
 
-template< class DeviceType >
-struct TestMemoryPoolHuge< DeviceType
-                         , typename std::enable_if<
-                           std::is_same< Kokkos::HostSpace
-                                       , typename DeviceType::memory_space >
-                             ::value >::type
-                         >
-{
-  typedef Kokkos::View< uintptr_t * , DeviceType >  ptrs_type ;
-  typedef Kokkos::MemoryPool< DeviceType >          pool_type ;
-  typedef typename DeviceType::memory_space         memory_space ;
-
-  pool_type pool ;
-  ptrs_type ptrs ;
-
-  enum : size_t { min_block_size = 512
-                , max_block_size = 1lu << 31
-                , min_superblock_size = max_block_size
-                , num_superblock = 4 
-                , total_alloc_size = num_superblock * max_block_size };
+template <class DeviceType>
+struct TestMemoryPoolHuge<
+    DeviceType,
+    typename std::enable_if<std::is_same<
+        Kokkos::HostSpace, typename DeviceType::memory_space>::value>::type> {
+  typedef Kokkos::View<uintptr_t*, DeviceType> ptrs_type;
+  typedef Kokkos::MemoryPool<DeviceType> pool_type;
+  typedef typename DeviceType::memory_space memory_space;
+
+  pool_type pool;
+  ptrs_type ptrs;
+
+  enum : size_t {
+    min_block_size      = 512,
+    max_block_size      = 1lu << 31,
+    min_superblock_size = max_block_size,
+    num_superblock      = 4,
+    total_alloc_size    = num_superblock * max_block_size
+  };
 
   TestMemoryPoolHuge()
-    : pool( memory_space()
-           , total_alloc_size
-           , min_block_size
-           , max_block_size
-           , min_superblock_size )
-    , ptrs( "ptrs" , num_superblock )
-    {}
+      : pool(memory_space(), total_alloc_size, min_block_size, max_block_size,
+             min_superblock_size),
+        ptrs("ptrs", num_superblock) {}
 
   // Specify reduction argument value_type to
   // avoid confusion with tag-dispatch.
 
-  using value_type = long ;
+  using value_type = long;
 
-  void operator()( int i , long & err ) const noexcept
-    {
-      if ( i < int(num_superblock) ) {
-        ptrs(i) = (uintptr_t) pool.allocate( max_block_size );
+  void operator()(int i, long& err) const noexcept {
+    if (i < int(num_superblock)) {
+      ptrs(i) = (uintptr_t)pool.allocate(max_block_size);
 #if 0
         printf("TestMemoryPoolHuge size(0x%lx) ptr(0x%lx)\n"
               , max_block_size
               , ptrs(i) );
 #endif
-        if ( ! ptrs(i) ) {
-          Kokkos::abort("TestMemoryPoolHuge");
-          ++err ;
-        }
+      if (!ptrs(i)) {
+        Kokkos::abort("TestMemoryPoolHuge");
+        ++err;
       }
     }
+  }
 
-  void operator()( int i ) const noexcept
-    {
-      if ( i < int(num_superblock) ) {
-        pool.deallocate( (void*) ptrs(i) , max_block_size );
-        ptrs(i) = 0 ;
-      }
+  void operator()(int i) const noexcept {
+    if (i < int(num_superblock)) {
+      pool.deallocate((void*)ptrs(i), max_block_size);
+      ptrs(i) = 0;
     }
+  }
 };
 
-template< class DeviceType >
-void test_memory_pool_huge()
-{
-  typedef typename DeviceType::execution_space  execution_space ;
-  typedef TestMemoryPoolHuge< DeviceType >      functor_type ;
-  typedef Kokkos::RangePolicy< execution_space > policy_type ;
+template <class DeviceType>
+void test_memory_pool_huge() {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef TestMemoryPoolHuge<DeviceType> functor_type;
+  typedef Kokkos::RangePolicy<execution_space> policy_type;
 
-  functor_type f ;
-  policy_type policy( 0 , functor_type::num_superblock );
+  functor_type f;
+  policy_type policy(0, functor_type::num_superblock);
 
-  long err = 0 ;
+  long err = 0;
 
-  Kokkos::parallel_reduce( policy , f , err );
-  Kokkos::parallel_for( policy , f );
+  Kokkos::parallel_reduce(policy, f, err);
+  Kokkos::parallel_for(policy, f);
 }
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-} // namespace TestMemoryPool
+}  // namespace TestMemoryPool
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, memory_pool )
-{
+TEST(TEST_CATEGORY, memory_pool) {
   TestMemoryPool::test_host_memory_pool_defaults<>();
   TestMemoryPool::test_host_memory_pool_stats<>();
-  TestMemoryPool::test_memory_pool_v2< TEST_EXECSPACE >(false,false);
-  TestMemoryPool::test_memory_pool_corners< TEST_EXECSPACE >(false,false);
+  TestMemoryPool::test_memory_pool_v2<TEST_EXECSPACE>(false, false);
+  TestMemoryPool::test_memory_pool_corners<TEST_EXECSPACE>(false, false);
 #ifdef KOKKOS_ENABLE_LARGE_MEM_TESTS
-  TestMemoryPool::test_memory_pool_huge< TEST_EXECSPACE >();
+  TestMemoryPool::test_memory_pool_huge<TEST_EXECSPACE>();
 #endif
 }
 
-}
+}  // namespace Test
 
 #endif
-
diff --git a/lib/kokkos/core/unit_test/TestPolicyConstruction.hpp b/lib/kokkos/core/unit_test/TestPolicyConstruction.hpp
index be744a77122a49843efdd4512bb21413b08f5cc2..a5ec173205c687295b3c981f0db8016e19de187b 100644
--- a/lib/kokkos/core/unit_test/TestPolicyConstruction.hpp
+++ b/lib/kokkos/core/unit_test/TestPolicyConstruction.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,679 +52,833 @@
 namespace Test {
 struct SomeTag {};
 
-template< class ExecutionSpace >
+template <class ExecutionSpace>
 class TestRangePolicyConstruction {
-public:
+ public:
   TestRangePolicyConstruction() {
     test_compile_time_parameters();
     test_runtime_parameters();
   }
 
-private:
+ private:
   void test_compile_time_parameters() {
     {
       Kokkos::Impl::expand_variadic();
-      Kokkos::Impl::expand_variadic( 1, 2, 3 );
+      Kokkos::Impl::expand_variadic(1, 2, 3);
     }
 
     {
       typedef Kokkos::RangePolicy<> policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Static>    >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Static> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
 
     {
-      typedef Kokkos::RangePolicy< ExecutionSpace > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Static>    >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
+      typedef Kokkos::RangePolicy<ExecutionSpace> policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Static> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
     {
-      typedef Kokkos::RangePolicy< ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
+      typedef Kokkos::RangePolicy<ExecutionSpace,
+                                  Kokkos::Schedule<Kokkos::Dynamic> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
 
     {
-      typedef Kokkos::RangePolicy< ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
+      typedef Kokkos::RangePolicy<ExecutionSpace,
+                                  Kokkos::Schedule<Kokkos::Dynamic>,
+                                  Kokkos::IndexType<long> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
 
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
+    {
+      typedef Kokkos::RangePolicy<Kokkos::IndexType<long>, ExecutionSpace,
+                                  Kokkos::Schedule<Kokkos::Dynamic> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::RangePolicy<ExecutionSpace,
+                                  Kokkos::Schedule<Kokkos::Dynamic>,
+                                  Kokkos::IndexType<long>, SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
+    }
+
+    {
+      typedef Kokkos::RangePolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                  ExecutionSpace, Kokkos::IndexType<long>,
+                                  SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
+    }
 
     {
-      typedef Kokkos::RangePolicy< Kokkos::IndexType<long>, ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
+      typedef Kokkos::RangePolicy<SomeTag, Kokkos::Schedule<Kokkos::Dynamic>,
+                                  Kokkos::IndexType<long>, ExecutionSpace>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
+    }
+
+    {
+      typedef Kokkos::RangePolicy<Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::RangePolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                  Kokkos::IndexType<long> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::RangePolicy<Kokkos::IndexType<long>,
+                                  Kokkos::Schedule<Kokkos::Dynamic> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::RangePolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                  Kokkos::IndexType<long>, SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
     }
-
-    {
-      typedef Kokkos::RangePolicy< ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
+
+    {
+      typedef Kokkos::RangePolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                  Kokkos::IndexType<long>, SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
     }
-
-    {
-      typedef Kokkos::RangePolicy< Kokkos::Schedule<Kokkos::Dynamic>, ExecutionSpace, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
-    }
-
-    {
-      typedef Kokkos::RangePolicy< SomeTag, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, ExecutionSpace > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
-    }
-
-    {
-      typedef Kokkos::RangePolicy< Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::RangePolicy< Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::RangePolicy< Kokkos::IndexType<long>, Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::RangePolicy< Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
-    }
-
-    {
-      typedef Kokkos::RangePolicy< Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
-    }
-
-    {
-      typedef Kokkos::RangePolicy< SomeTag, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
+
+    {
+      typedef Kokkos::RangePolicy<SomeTag, Kokkos::Schedule<Kokkos::Dynamic>,
+                                  Kokkos::IndexType<long> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
     }
   }
   void test_runtime_parameters() {
     {
       typedef Kokkos::RangePolicy<> policy_t;
-      policy_t p(5,15);
-      ASSERT_TRUE( (p.begin() == 5) );
-      ASSERT_TRUE( (p.end() == 15) );
+      policy_t p(5, 15);
+      ASSERT_TRUE((p.begin() == 5));
+      ASSERT_TRUE((p.end() == 15));
     }
     {
       typedef Kokkos::RangePolicy<> policy_t;
-      policy_t p(Kokkos::DefaultExecutionSpace(),5,15);
-      ASSERT_TRUE( (p.begin() == 5) );
-      ASSERT_TRUE( (p.end() == 15) );
+      policy_t p(Kokkos::DefaultExecutionSpace(), 5, 15);
+      ASSERT_TRUE((p.begin() == 5));
+      ASSERT_TRUE((p.end() == 15));
     }
     {
       typedef Kokkos::RangePolicy<> policy_t;
-      policy_t p(5,15,Kokkos::ChunkSize(10));
-      ASSERT_TRUE( (p.begin() == 5) );
-      ASSERT_TRUE( (p.end() == 15) );
-      ASSERT_TRUE( (p.chunk_size() == 10) );
+      policy_t p(5, 15, Kokkos::ChunkSize(10));
+      ASSERT_TRUE((p.begin() == 5));
+      ASSERT_TRUE((p.end() == 15));
+      ASSERT_TRUE((p.chunk_size() == 10));
     }
     {
       typedef Kokkos::RangePolicy<> policy_t;
-      policy_t p(Kokkos::DefaultExecutionSpace(),5,15,Kokkos::ChunkSize(10));
-      ASSERT_TRUE( (p.begin() == 5) );
-      ASSERT_TRUE( (p.end() == 15) );
-      ASSERT_TRUE( (p.chunk_size() == 10) );
+      policy_t p(Kokkos::DefaultExecutionSpace(), 5, 15, Kokkos::ChunkSize(10));
+      ASSERT_TRUE((p.begin() == 5));
+      ASSERT_TRUE((p.end() == 15));
+      ASSERT_TRUE((p.chunk_size() == 10));
     }
   }
 };
 
-template< class ExecutionSpace >
+template <class ExecutionSpace>
 class TestTeamPolicyConstruction {
-public:
+ public:
   TestTeamPolicyConstruction() {
     test_compile_time_parameters();
     test_run_time_parameters();
   }
 
-private:
+ private:
   void test_compile_time_parameters() {
     {
       typedef Kokkos::TeamPolicy<> policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Static>    >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Static> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
 
     {
-      typedef Kokkos::TeamPolicy< ExecutionSpace > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Static>    >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::TeamPolicy< ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::TeamPolicy< ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::TeamPolicy< Kokkos::IndexType<long>, ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::TeamPolicy< ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
-    }
-
-    {
-      typedef Kokkos::TeamPolicy< Kokkos::Schedule<Kokkos::Dynamic>, ExecutionSpace, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
-    }
-
-    {
-      typedef Kokkos::TeamPolicy< SomeTag, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, ExecutionSpace > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, ExecutionSpace                      >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
-    }
-
+      typedef Kokkos::TeamPolicy<ExecutionSpace> policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Static> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
     {
-      typedef Kokkos::TeamPolicy< Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace        >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      typename execution_space::size_type >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
-
-    {
-      typedef Kokkos::TeamPolicy< Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
+      typedef Kokkos::TeamPolicy<ExecutionSpace,
+                                 Kokkos::Schedule<Kokkos::Dynamic> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
 
     {
-      typedef Kokkos::TeamPolicy< Kokkos::IndexType<long>, Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
+      typedef Kokkos::TeamPolicy<ExecutionSpace,
+                                 Kokkos::Schedule<Kokkos::Dynamic>,
+                                 Kokkos::IndexType<long> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
 
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        void                                >::value ) );
-    }
+    {
+      typedef Kokkos::TeamPolicy<Kokkos::IndexType<long>, ExecutionSpace,
+                                 Kokkos::Schedule<Kokkos::Dynamic> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::TeamPolicy<ExecutionSpace,
+                                 Kokkos::Schedule<Kokkos::Dynamic>,
+                                 Kokkos::IndexType<long>, SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
+    }
+
+    {
+      typedef Kokkos::TeamPolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                 ExecutionSpace, Kokkos::IndexType<long>,
+                                 SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
+    }
 
     {
-      typedef Kokkos::TeamPolicy< Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
+      typedef Kokkos::TeamPolicy<SomeTag, Kokkos::Schedule<Kokkos::Dynamic>,
+                                 Kokkos::IndexType<long>, ExecutionSpace>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((std::is_same<execution_space, ExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
+    }
+
+    {
+      typedef Kokkos::TeamPolicy<Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type,
+                                typename execution_space::size_type>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::TeamPolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                 Kokkos::IndexType<long> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::TeamPolicy<Kokkos::IndexType<long>,
+                                 Kokkos::Schedule<Kokkos::Dynamic> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, void>::value));
+    }
+
+    {
+      typedef Kokkos::TeamPolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                 Kokkos::IndexType<long>, SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
     }
-
-    {
-      typedef Kokkos::TeamPolicy< Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, SomeTag > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
+
+    {
+      typedef Kokkos::TeamPolicy<Kokkos::Schedule<Kokkos::Dynamic>,
+                                 Kokkos::IndexType<long>, SomeTag>
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
     }
-
-    {
-      typedef Kokkos::TeamPolicy< SomeTag, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long> > policy_t;
-      typedef typename policy_t::execution_space  execution_space;
-      typedef typename policy_t::index_type       index_type;
-      typedef typename policy_t::schedule_type    schedule_type;
-      typedef typename policy_t::work_tag         work_tag;
-
-      ASSERT_TRUE( ( std::is_same< execution_space, Kokkos::DefaultExecutionSpace       >::value ) );
-      ASSERT_TRUE( ( std::is_same< index_type,      long                                >::value ) );
-      ASSERT_TRUE( ( std::is_same< schedule_type,   Kokkos::Schedule<Kokkos::Dynamic>   >::value ) );
-      ASSERT_TRUE( ( std::is_same< work_tag,        SomeTag                             >::value ) );
+
+    {
+      typedef Kokkos::TeamPolicy<SomeTag, Kokkos::Schedule<Kokkos::Dynamic>,
+                                 Kokkos::IndexType<long> >
+          policy_t;
+      typedef typename policy_t::execution_space execution_space;
+      typedef typename policy_t::index_type index_type;
+      typedef typename policy_t::schedule_type schedule_type;
+      typedef typename policy_t::work_tag work_tag;
+
+      ASSERT_TRUE((
+          std::is_same<execution_space, Kokkos::DefaultExecutionSpace>::value));
+      ASSERT_TRUE((std::is_same<index_type, long>::value));
+      ASSERT_TRUE((std::is_same<schedule_type,
+                                Kokkos::Schedule<Kokkos::Dynamic> >::value));
+      ASSERT_TRUE((std::is_same<work_tag, SomeTag>::value));
     }
   }
 
-
-  template< class policy_t >
+  template <class policy_t>
   void test_run_time_parameters_type() {
     int league_size = 131;
-    int team_size = 4 < policy_t::execution_space::concurrency() ? 4 : policy_t::execution_space::concurrency();
+    int team_size   = 4 < policy_t::execution_space::concurrency()
+                        ? 4
+                        : policy_t::execution_space::concurrency();
 #ifdef KOKKOS_ENABLE_HPX
     team_size = 1;
 #endif
-    int chunk_size = 4;
-    int per_team_scratch = 1024;
+    int chunk_size         = 4;
+    int per_team_scratch   = 1024;
     int per_thread_scratch = 16;
-    int scratch_size = per_team_scratch + per_thread_scratch * team_size;
+    int scratch_size       = per_team_scratch + per_thread_scratch * team_size;
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
     int vector_length = 4;
 #endif
 
-    policy_t p1( league_size, team_size );
-    ASSERT_EQ  ( p1.league_size(),     league_size                    );
-    ASSERT_EQ  ( p1.team_size(),       team_size                      );
-    ASSERT_TRUE( p1.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p1.scratch_size( 0 ), 0                              );
+    policy_t p1(league_size, team_size);
+    ASSERT_EQ(p1.league_size(), league_size);
+    ASSERT_EQ(p1.team_size(), team_size);
+    ASSERT_TRUE(p1.chunk_size() > 0);
+    ASSERT_EQ(p1.scratch_size(0), 0);
 
-    policy_t p2 = p1.set_chunk_size( chunk_size );
-    ASSERT_EQ  ( p1.league_size(),     league_size                    );
-    ASSERT_EQ  ( p1.team_size(),       team_size                      );
+    policy_t p2 = p1.set_chunk_size(chunk_size);
+    ASSERT_EQ(p1.league_size(), league_size);
+    ASSERT_EQ(p1.team_size(), team_size);
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    ASSERT_TRUE( p1.chunk_size()  > 0                                 );
+    ASSERT_TRUE(p1.chunk_size() > 0);
 #else
-    ASSERT_EQ  ( p1.chunk_size(),      chunk_size                     );
+    ASSERT_EQ(p1.chunk_size(), chunk_size);
 #endif
-    ASSERT_EQ  ( p1.scratch_size( 0 ), 0                              );
+    ASSERT_EQ(p1.scratch_size(0), 0);
 
-    ASSERT_EQ  ( p2.league_size(),     league_size                    );
-    ASSERT_EQ  ( p2.team_size(),       team_size                      );
-    ASSERT_EQ  ( p2.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p2.scratch_size( 0 ), 0                              );
+    ASSERT_EQ(p2.league_size(), league_size);
+    ASSERT_EQ(p2.team_size(), team_size);
+    ASSERT_EQ(p2.chunk_size(), chunk_size);
+    ASSERT_EQ(p2.scratch_size(0), 0);
 
-    policy_t p3 = p2.set_scratch_size( 0, Kokkos::PerTeam( per_team_scratch ) );
-    ASSERT_EQ  ( p2.league_size(),     league_size                    );
-    ASSERT_EQ  ( p2.team_size(),       team_size                      );
-    ASSERT_EQ  ( p2.chunk_size(),      chunk_size                     );
+    policy_t p3 = p2.set_scratch_size(0, Kokkos::PerTeam(per_team_scratch));
+    ASSERT_EQ(p2.league_size(), league_size);
+    ASSERT_EQ(p2.team_size(), team_size);
+    ASSERT_EQ(p2.chunk_size(), chunk_size);
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    ASSERT_EQ  ( p2.scratch_size( 0 ), 0                              );
+    ASSERT_EQ(p2.scratch_size(0), 0);
 #else
-    ASSERT_EQ  ( p2.scratch_size( 0 ), per_team_scratch               );
+    ASSERT_EQ(p2.scratch_size(0), per_team_scratch);
 #endif
-    ASSERT_EQ  ( p3.league_size(),     league_size                    );
-    ASSERT_EQ  ( p3.team_size(),       team_size                      );
-    ASSERT_EQ  ( p3.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p3.scratch_size( 0 ), per_team_scratch               );
-
-    policy_t p4 = p2.set_scratch_size( 0, Kokkos::PerThread( per_thread_scratch ) );
-    ASSERT_EQ  ( p2.league_size(),     league_size                    );
-    ASSERT_EQ  ( p2.team_size(),       team_size                      );
-    ASSERT_EQ  ( p2.chunk_size(),      chunk_size                     );
+    ASSERT_EQ(p3.league_size(), league_size);
+    ASSERT_EQ(p3.team_size(), team_size);
+    ASSERT_EQ(p3.chunk_size(), chunk_size);
+    ASSERT_EQ(p3.scratch_size(0), per_team_scratch);
+
+    policy_t p4 = p2.set_scratch_size(0, Kokkos::PerThread(per_thread_scratch));
+    ASSERT_EQ(p2.league_size(), league_size);
+    ASSERT_EQ(p2.team_size(), team_size);
+    ASSERT_EQ(p2.chunk_size(), chunk_size);
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    ASSERT_EQ  ( p2.scratch_size( 0 ), 0                              );
+    ASSERT_EQ(p2.scratch_size(0), 0);
 #else
-    ASSERT_EQ  ( p2.scratch_size( 0 ), scratch_size );
+    ASSERT_EQ(p2.scratch_size(0), scratch_size);
 #endif
-    ASSERT_EQ  ( p4.league_size(),     league_size                    );
-    ASSERT_EQ  ( p4.team_size(),       team_size                      );
-    ASSERT_EQ  ( p4.chunk_size(),      chunk_size                     );
+    ASSERT_EQ(p4.league_size(), league_size);
+    ASSERT_EQ(p4.team_size(), team_size);
+    ASSERT_EQ(p4.chunk_size(), chunk_size);
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    ASSERT_EQ  ( p4.scratch_size( 0 ), per_thread_scratch * team_size );
+    ASSERT_EQ(p4.scratch_size(0), per_thread_scratch * team_size);
 #else
-    ASSERT_EQ  ( p4.scratch_size( 0 ), scratch_size );
+    ASSERT_EQ(p4.scratch_size(0), scratch_size);
 #endif
 
-    policy_t p5 = p2.set_scratch_size( 0, Kokkos::PerThread( per_thread_scratch ), Kokkos::PerTeam( per_team_scratch ) );
-    ASSERT_EQ  ( p2.league_size(),     league_size                    );
-    ASSERT_EQ  ( p2.team_size(),       team_size                      );
-    ASSERT_EQ  ( p2.chunk_size(),      chunk_size                     );
+    policy_t p5 = p2.set_scratch_size(0, Kokkos::PerThread(per_thread_scratch),
+                                      Kokkos::PerTeam(per_team_scratch));
+    ASSERT_EQ(p2.league_size(), league_size);
+    ASSERT_EQ(p2.team_size(), team_size);
+    ASSERT_EQ(p2.chunk_size(), chunk_size);
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    ASSERT_EQ  ( p2.scratch_size( 0 ), 0                              );
+    ASSERT_EQ(p2.scratch_size(0), 0);
 #else
-    ASSERT_EQ  ( p2.scratch_size( 0 ), scratch_size                   );
+    ASSERT_EQ(p2.scratch_size(0), scratch_size);
 #endif
-    ASSERT_EQ  ( p5.league_size(),     league_size                    );
-    ASSERT_EQ  ( p5.team_size(),       team_size                      );
-    ASSERT_EQ  ( p5.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p5.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p6 = p2.set_scratch_size( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) );
-    ASSERT_EQ  ( p2.league_size(),     league_size                    );
-    ASSERT_EQ  ( p2.team_size(),       team_size                      );
-    ASSERT_EQ  ( p2.chunk_size(),      chunk_size                     );
+    ASSERT_EQ(p5.league_size(), league_size);
+    ASSERT_EQ(p5.team_size(), team_size);
+    ASSERT_EQ(p5.chunk_size(), chunk_size);
+    ASSERT_EQ(p5.scratch_size(0), scratch_size);
+
+    policy_t p6 = p2.set_scratch_size(0, Kokkos::PerTeam(per_team_scratch),
+                                      Kokkos::PerThread(per_thread_scratch));
+    ASSERT_EQ(p2.league_size(), league_size);
+    ASSERT_EQ(p2.team_size(), team_size);
+    ASSERT_EQ(p2.chunk_size(), chunk_size);
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    ASSERT_EQ  ( p2.scratch_size( 0 ), 0                              );
+    ASSERT_EQ(p2.scratch_size(0), 0);
 #else
-    ASSERT_EQ  ( p2.scratch_size( 0 ), scratch_size                   );
+    ASSERT_EQ(p2.scratch_size(0), scratch_size);
 #endif
-    ASSERT_EQ  ( p6.league_size(),     league_size                    );
-    ASSERT_EQ  ( p6.team_size(),       team_size                      );
-    ASSERT_EQ  ( p6.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p6.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p7 = p3.set_scratch_size( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) );
-    ASSERT_EQ  ( p3.league_size(),     league_size                    );
-    ASSERT_EQ  ( p3.team_size(),       team_size                      );
-    ASSERT_EQ  ( p3.chunk_size(),      chunk_size                     );
+    ASSERT_EQ(p6.league_size(), league_size);
+    ASSERT_EQ(p6.team_size(), team_size);
+    ASSERT_EQ(p6.chunk_size(), chunk_size);
+    ASSERT_EQ(p6.scratch_size(0), scratch_size);
+
+    policy_t p7 = p3.set_scratch_size(0, Kokkos::PerTeam(per_team_scratch),
+                                      Kokkos::PerThread(per_thread_scratch));
+    ASSERT_EQ(p3.league_size(), league_size);
+    ASSERT_EQ(p3.team_size(), team_size);
+    ASSERT_EQ(p3.chunk_size(), chunk_size);
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    ASSERT_EQ  ( p3.scratch_size( 0 ), per_team_scratch               );
+    ASSERT_EQ(p3.scratch_size(0), per_team_scratch);
 #else
-    ASSERT_EQ  ( p3.scratch_size( 0 ), scratch_size                   );
+    ASSERT_EQ(p3.scratch_size(0), scratch_size);
 #endif
-    ASSERT_EQ  ( p7.league_size(),     league_size                    );
-    ASSERT_EQ  ( p7.team_size(),       team_size                      );
-    ASSERT_EQ  ( p7.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p7.scratch_size( 0 ), scratch_size                   );
+    ASSERT_EQ(p7.league_size(), league_size);
+    ASSERT_EQ(p7.team_size(), team_size);
+    ASSERT_EQ(p7.chunk_size(), chunk_size);
+    ASSERT_EQ(p7.scratch_size(0), scratch_size);
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    policy_t p8(league_size, team_size, Kokkos::ChunkSize(chunk_size) );
-    ASSERT_EQ  ( p8.league_size(),     league_size                    );
-    ASSERT_EQ  ( p8.team_size(),       team_size                      );
-    ASSERT_EQ  ( p8.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p8.scratch_size( 0 ), 0                              );
-
-    policy_t p10( league_size, team_size, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p10.league_size(),     league_size                    );
-    ASSERT_EQ  ( p10.team_size(),       team_size                      );
-    ASSERT_TRUE( p10.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p10.scratch_size( 0 ), per_team_scratch               );
-
-    policy_t p11( league_size, team_size, Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p11.league_size(),     league_size                    );
-    ASSERT_EQ  ( p11.team_size(),       team_size                      );
-    ASSERT_TRUE( p11.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p11.scratch_size( 0 ), per_thread_scratch * team_size );
-
-    policy_t p12( league_size, team_size, Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ), Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p12.league_size(),     league_size                    );
-    ASSERT_EQ  ( p12.team_size(),       team_size                      );
-    ASSERT_TRUE( p12.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p12.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p13( league_size, team_size, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p13.league_size(),     league_size                    );
-    ASSERT_EQ  ( p13.team_size(),       team_size                      );
-    ASSERT_TRUE( p13.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p13.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p14( league_size, team_size, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p14.league_size(),     league_size                    );
-    ASSERT_EQ  ( p14.team_size(),       team_size                      );
-    ASSERT_TRUE( p14.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p14.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p15( league_size, team_size, Kokkos::ChunkSize(chunk_size), Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p15.league_size(),     league_size                    );
-    ASSERT_EQ  ( p15.team_size(),       team_size                      );
-    ASSERT_TRUE( p15.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p15.scratch_size( 0 ), per_team_scratch               );
-
-    policy_t p16( league_size, team_size, Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ) ), Kokkos::ChunkSize(chunk_size) );
-    ASSERT_EQ  ( p16.league_size(),     league_size                    );
-    ASSERT_EQ  ( p16.team_size(),       team_size                      );
-    ASSERT_EQ  ( p16.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p16.scratch_size( 0 ), per_thread_scratch * team_size );
-
-    policy_t p17( league_size, team_size, Kokkos::ChunkSize(chunk_size), Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ), Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p17.league_size(),     league_size                    );
-    ASSERT_EQ  ( p17.team_size(),       team_size                      );
-    ASSERT_EQ  ( p17.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p17.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p18( league_size, team_size, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ), Kokkos::ChunkSize(chunk_size) );
-    ASSERT_EQ  ( p18.league_size(),     league_size                    );
-    ASSERT_EQ  ( p18.team_size(),       team_size                      );
-    ASSERT_EQ  ( p18.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p18.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p19( league_size, team_size, Kokkos::ChunkSize(chunk_size), Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p19.league_size(),     league_size                    );
-    ASSERT_EQ  ( p19.team_size(),       team_size                      );
-    ASSERT_EQ  ( p19.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p19.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p20( league_size, team_size, vector_length, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p20.league_size(),     league_size                    );
-    ASSERT_EQ  ( p20.team_size(),       team_size                      );
-    ASSERT_TRUE( p20.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p20.scratch_size( 0 ), per_team_scratch               );
-
-    policy_t p21( league_size, team_size, vector_length, Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p21.league_size(),     league_size                    );
-    ASSERT_EQ  ( p21.team_size(),       team_size                      );
-    ASSERT_TRUE( p21.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p21.scratch_size( 0 ), per_thread_scratch * team_size );
-
-    policy_t p22( league_size, team_size, vector_length, Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ), Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p22.league_size(),     league_size                    );
-    ASSERT_EQ  ( p22.team_size(),       team_size                      );
-    ASSERT_TRUE( p22.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p22.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p23( league_size, team_size, (size_t) vector_length, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p23.league_size(),     league_size                    );
-    ASSERT_EQ  ( p23.team_size(),       team_size                      );
-    ASSERT_TRUE( p23.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p23.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p24( league_size, team_size, (size_t) vector_length, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p24.league_size(),     league_size                    );
-    ASSERT_EQ  ( p24.team_size(),       team_size                      );
-    ASSERT_TRUE( p24.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p24.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p25( league_size, team_size, vector_length, Kokkos::ChunkSize(chunk_size), Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p25.league_size(),     league_size                    );
-    ASSERT_EQ  ( p25.team_size(),       team_size                      );
-    ASSERT_TRUE( p25.chunk_size()  > 0                                 );
-    ASSERT_EQ  ( p25.scratch_size( 0 ), per_team_scratch               );
-
-    policy_t p26( league_size, team_size, vector_length, Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ) ), Kokkos::ChunkSize(chunk_size) );
-    ASSERT_EQ  ( p26.league_size(),     league_size                    );
-    ASSERT_EQ  ( p26.team_size(),       team_size                      );
-    ASSERT_EQ  ( p26.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p26.scratch_size( 0 ), per_thread_scratch * team_size );
-
-    policy_t p27( league_size, team_size, vector_length, Kokkos::ChunkSize(chunk_size), Kokkos::ScratchRequest( 0, Kokkos::PerThread( per_thread_scratch ), Kokkos::PerTeam( per_team_scratch ) ) );
-    ASSERT_EQ  ( p27.league_size(),     league_size                    );
-    ASSERT_EQ  ( p27.team_size(),       team_size                      );
-    ASSERT_EQ  ( p27.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p27.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p28( league_size, team_size, (size_t) vector_length, Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ), Kokkos::ChunkSize(chunk_size) );
-    ASSERT_EQ  ( p28.league_size(),     league_size                    );
-    ASSERT_EQ  ( p28.team_size(),       team_size                      );
-    ASSERT_EQ  ( p28.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p28.scratch_size( 0 ), scratch_size                   );
-
-    policy_t p29( league_size, team_size, (size_t) vector_length, Kokkos::ChunkSize(chunk_size), Kokkos::ScratchRequest( 0, Kokkos::PerTeam( per_team_scratch ), Kokkos::PerThread( per_thread_scratch ) ) );
-    ASSERT_EQ  ( p29.league_size(),     league_size                    );
-    ASSERT_EQ  ( p29.team_size(),       team_size                      );
-    ASSERT_EQ  ( p29.chunk_size(),      chunk_size                     );
-    ASSERT_EQ  ( p29.scratch_size( 0 ), scratch_size                   );
+    policy_t p8(league_size, team_size, Kokkos::ChunkSize(chunk_size));
+    ASSERT_EQ(p8.league_size(), league_size);
+    ASSERT_EQ(p8.team_size(), team_size);
+    ASSERT_EQ(p8.chunk_size(), chunk_size);
+    ASSERT_EQ(p8.scratch_size(0), 0);
+
+    policy_t p10(league_size, team_size,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p10.league_size(), league_size);
+    ASSERT_EQ(p10.team_size(), team_size);
+    ASSERT_TRUE(p10.chunk_size() > 0);
+    ASSERT_EQ(p10.scratch_size(0), per_team_scratch);
+
+    policy_t p11(
+        league_size, team_size,
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p11.league_size(), league_size);
+    ASSERT_EQ(p11.team_size(), team_size);
+    ASSERT_TRUE(p11.chunk_size() > 0);
+    ASSERT_EQ(p11.scratch_size(0), per_thread_scratch * team_size);
+
+    policy_t p12(
+        league_size, team_size,
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch),
+                               Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p12.league_size(), league_size);
+    ASSERT_EQ(p12.team_size(), team_size);
+    ASSERT_TRUE(p12.chunk_size() > 0);
+    ASSERT_EQ(p12.scratch_size(0), scratch_size);
+
+    policy_t p13(league_size, team_size,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p13.league_size(), league_size);
+    ASSERT_EQ(p13.team_size(), team_size);
+    ASSERT_TRUE(p13.chunk_size() > 0);
+    ASSERT_EQ(p13.scratch_size(0), scratch_size);
+
+    policy_t p14(league_size, team_size,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p14.league_size(), league_size);
+    ASSERT_EQ(p14.team_size(), team_size);
+    ASSERT_TRUE(p14.chunk_size() > 0);
+    ASSERT_EQ(p14.scratch_size(0), scratch_size);
+
+    policy_t p15(league_size, team_size, Kokkos::ChunkSize(chunk_size),
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p15.league_size(), league_size);
+    ASSERT_EQ(p15.team_size(), team_size);
+    ASSERT_TRUE(p15.chunk_size() > 0);
+    ASSERT_EQ(p15.scratch_size(0), per_team_scratch);
+
+    policy_t p16(
+        league_size, team_size,
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch)),
+        Kokkos::ChunkSize(chunk_size));
+    ASSERT_EQ(p16.league_size(), league_size);
+    ASSERT_EQ(p16.team_size(), team_size);
+    ASSERT_EQ(p16.chunk_size(), chunk_size);
+    ASSERT_EQ(p16.scratch_size(0), per_thread_scratch * team_size);
+
+    policy_t p17(
+        league_size, team_size, Kokkos::ChunkSize(chunk_size),
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch),
+                               Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p17.league_size(), league_size);
+    ASSERT_EQ(p17.team_size(), team_size);
+    ASSERT_EQ(p17.chunk_size(), chunk_size);
+    ASSERT_EQ(p17.scratch_size(0), scratch_size);
+
+    policy_t p18(league_size, team_size,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)),
+                 Kokkos::ChunkSize(chunk_size));
+    ASSERT_EQ(p18.league_size(), league_size);
+    ASSERT_EQ(p18.team_size(), team_size);
+    ASSERT_EQ(p18.chunk_size(), chunk_size);
+    ASSERT_EQ(p18.scratch_size(0), scratch_size);
+
+    policy_t p19(league_size, team_size, Kokkos::ChunkSize(chunk_size),
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p19.league_size(), league_size);
+    ASSERT_EQ(p19.team_size(), team_size);
+    ASSERT_EQ(p19.chunk_size(), chunk_size);
+    ASSERT_EQ(p19.scratch_size(0), scratch_size);
+
+    policy_t p20(league_size, team_size, vector_length,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p20.league_size(), league_size);
+    ASSERT_EQ(p20.team_size(), team_size);
+    ASSERT_TRUE(p20.chunk_size() > 0);
+    ASSERT_EQ(p20.scratch_size(0), per_team_scratch);
+
+    policy_t p21(
+        league_size, team_size, vector_length,
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p21.league_size(), league_size);
+    ASSERT_EQ(p21.team_size(), team_size);
+    ASSERT_TRUE(p21.chunk_size() > 0);
+    ASSERT_EQ(p21.scratch_size(0), per_thread_scratch * team_size);
+
+    policy_t p22(
+        league_size, team_size, vector_length,
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch),
+                               Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p22.league_size(), league_size);
+    ASSERT_EQ(p22.team_size(), team_size);
+    ASSERT_TRUE(p22.chunk_size() > 0);
+    ASSERT_EQ(p22.scratch_size(0), scratch_size);
+
+    policy_t p23(league_size, team_size, (size_t)vector_length,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p23.league_size(), league_size);
+    ASSERT_EQ(p23.team_size(), team_size);
+    ASSERT_TRUE(p23.chunk_size() > 0);
+    ASSERT_EQ(p23.scratch_size(0), scratch_size);
+
+    policy_t p24(league_size, team_size, (size_t)vector_length,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p24.league_size(), league_size);
+    ASSERT_EQ(p24.team_size(), team_size);
+    ASSERT_TRUE(p24.chunk_size() > 0);
+    ASSERT_EQ(p24.scratch_size(0), scratch_size);
+
+    policy_t p25(league_size, team_size, vector_length,
+                 Kokkos::ChunkSize(chunk_size),
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p25.league_size(), league_size);
+    ASSERT_EQ(p25.team_size(), team_size);
+    ASSERT_TRUE(p25.chunk_size() > 0);
+    ASSERT_EQ(p25.scratch_size(0), per_team_scratch);
+
+    policy_t p26(
+        league_size, team_size, vector_length,
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch)),
+        Kokkos::ChunkSize(chunk_size));
+    ASSERT_EQ(p26.league_size(), league_size);
+    ASSERT_EQ(p26.team_size(), team_size);
+    ASSERT_EQ(p26.chunk_size(), chunk_size);
+    ASSERT_EQ(p26.scratch_size(0), per_thread_scratch * team_size);
+
+    policy_t p27(
+        league_size, team_size, vector_length, Kokkos::ChunkSize(chunk_size),
+        Kokkos::ScratchRequest(0, Kokkos::PerThread(per_thread_scratch),
+                               Kokkos::PerTeam(per_team_scratch)));
+    ASSERT_EQ(p27.league_size(), league_size);
+    ASSERT_EQ(p27.team_size(), team_size);
+    ASSERT_EQ(p27.chunk_size(), chunk_size);
+    ASSERT_EQ(p27.scratch_size(0), scratch_size);
+
+    policy_t p28(league_size, team_size, (size_t)vector_length,
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)),
+                 Kokkos::ChunkSize(chunk_size));
+    ASSERT_EQ(p28.league_size(), league_size);
+    ASSERT_EQ(p28.team_size(), team_size);
+    ASSERT_EQ(p28.chunk_size(), chunk_size);
+    ASSERT_EQ(p28.scratch_size(0), scratch_size);
+
+    policy_t p29(league_size, team_size, (size_t)vector_length,
+                 Kokkos::ChunkSize(chunk_size),
+                 Kokkos::ScratchRequest(0, Kokkos::PerTeam(per_team_scratch),
+                                        Kokkos::PerThread(per_thread_scratch)));
+    ASSERT_EQ(p29.league_size(), league_size);
+    ASSERT_EQ(p29.team_size(), team_size);
+    ASSERT_EQ(p29.chunk_size(), chunk_size);
+    ASSERT_EQ(p29.scratch_size(0), scratch_size);
 #endif
-
   }
 
   void test_run_time_parameters() {
-    test_run_time_parameters_type< Kokkos::TeamPolicy<ExecutionSpace> >();
-    test_run_time_parameters_type< Kokkos::TeamPolicy<ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long> > >();
-    test_run_time_parameters_type< Kokkos::TeamPolicy<Kokkos::IndexType<long>, ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic> > >();
-    test_run_time_parameters_type< Kokkos::TeamPolicy<Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>, ExecutionSpace, SomeTag > >();
+    test_run_time_parameters_type<Kokkos::TeamPolicy<ExecutionSpace> >();
+    test_run_time_parameters_type<
+        Kokkos::TeamPolicy<ExecutionSpace, Kokkos::Schedule<Kokkos::Dynamic>,
+                           Kokkos::IndexType<long> > >();
+    test_run_time_parameters_type<
+        Kokkos::TeamPolicy<Kokkos::IndexType<long>, ExecutionSpace,
+                           Kokkos::Schedule<Kokkos::Dynamic> > >();
+    test_run_time_parameters_type<Kokkos::TeamPolicy<
+        Kokkos::Schedule<Kokkos::Dynamic>, Kokkos::IndexType<long>,
+        ExecutionSpace, SomeTag> >();
   }
 };
 
-TEST_F( TEST_CATEGORY, policy_construction )
-{
-   TestRangePolicyConstruction< TEST_EXECSPACE >();
-   TestTeamPolicyConstruction< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, policy_construction) {
+  TestRangePolicyConstruction<TEST_EXECSPACE>();
+  TestTeamPolicyConstruction<TEST_EXECSPACE>();
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestRange.hpp b/lib/kokkos/core/unit_test/TestRange.hpp
index be878046cb43e06b03ade5492900c89ee53286a9..1fd6a508f783a6126cea57a998c53b4c509533c1 100644
--- a/lib/kokkos/core/unit_test/TestRange.hpp
+++ b/lib/kokkos/core/unit_test/TestRange.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,11 +50,11 @@ namespace Test {
 
 namespace {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct TestRange {
-  typedef int value_type; ///< typedef required for the parallel_reduce
+  typedef int value_type;  ///< typedef required for the parallel_reduce
 
-  typedef Kokkos::View< int*, ExecSpace > view_type;
+  typedef Kokkos::View<int *, ExecSpace> view_type;
 
   view_type m_flags;
 
@@ -65,97 +66,107 @@ struct TestRange {
 
   int N;
   static const int offset = 13;
-  TestRange( const size_t N_ )
-    : m_flags( Kokkos::ViewAllocateWithoutInitializing( "flags" ), N_ ), N(N_)
-    {}
+  TestRange(const size_t N_)
+      : m_flags(Kokkos::ViewAllocateWithoutInitializing("flags"), N_), N(N_) {}
 
-  void test_for()
-  {
-
-    typename view_type::HostMirror host_flags = Kokkos::create_mirror_view( m_flags );
+  void test_for() {
+    typename view_type::HostMirror host_flags =
+        Kokkos::create_mirror_view(m_flags);
 
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, ScheduleType >( 0, N ), *this );
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, ScheduleType>(0, N),
+                         *this);
 
 #if defined(KOKKOS_ENABLE_PROFILING)
     {
-      typedef TestRange< ExecSpace, ScheduleType > ThisType;
+      typedef TestRange<ExecSpace, ScheduleType> ThisType;
       std::string label("parallel_for");
-      Kokkos::Impl::ParallelConstructName< ThisType, void> pcn(label);
-      ASSERT_EQ( pcn.get(), label );
+      Kokkos::Impl::ParallelConstructName<ThisType, void> pcn(label);
+      ASSERT_EQ(pcn.get(), label);
       std::string empty_label("");
-      Kokkos::Impl::ParallelConstructName< ThisType, void> empty_pcn(empty_label);
-      ASSERT_EQ( empty_pcn.get(), typeid(ThisType).name() );
+      Kokkos::Impl::ParallelConstructName<ThisType, void> empty_pcn(
+          empty_label);
+      ASSERT_EQ(empty_pcn.get(), typeid(ThisType).name());
     }
 #endif
 
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, ScheduleType, VerifyInitTag >( 0, N ), *this );
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, VerifyInitTag>(0, N),
+        *this);
 
 #if defined(KOKKOS_ENABLE_PROFILING)
     {
-      typedef TestRange< ExecSpace, ScheduleType > ThisType;
+      typedef TestRange<ExecSpace, ScheduleType> ThisType;
       std::string label("parallel_for");
-      Kokkos::Impl::ParallelConstructName< ThisType, VerifyInitTag> pcn(label);
-      ASSERT_EQ( pcn.get(), label );
+      Kokkos::Impl::ParallelConstructName<ThisType, VerifyInitTag> pcn(label);
+      ASSERT_EQ(pcn.get(), label);
       std::string empty_label("");
-      Kokkos::Impl::ParallelConstructName< ThisType, VerifyInitTag> empty_pcn(empty_label);
-      ASSERT_EQ( empty_pcn.get(), std::string(typeid(ThisType).name()) + "/" + typeid(VerifyInitTag).name() );
+      Kokkos::Impl::ParallelConstructName<ThisType, VerifyInitTag> empty_pcn(
+          empty_label);
+      ASSERT_EQ(empty_pcn.get(), std::string(typeid(ThisType).name()) + "/" +
+                                     typeid(VerifyInitTag).name());
     }
 #endif
 
-    Kokkos::deep_copy( host_flags, m_flags );
+    Kokkos::deep_copy(host_flags, m_flags);
 
     int error_count = 0;
-    for ( int i = 0; i < N; ++i ) {
-      if ( int( i ) != host_flags( i ) ) ++error_count;
+    for (int i = 0; i < N; ++i) {
+      if (int(i) != host_flags(i)) ++error_count;
     }
-    ASSERT_EQ( error_count, int( 0 ) );
+    ASSERT_EQ(error_count, int(0));
 
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, ScheduleType, ResetTag >( 0, N ), *this );
-    Kokkos::parallel_for( std::string( "TestKernelFor" ), Kokkos::RangePolicy< ExecSpace, ScheduleType, VerifyResetTag >( 0, N ), *this );
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, ResetTag>(0, N), *this);
+    Kokkos::parallel_for(
+        std::string("TestKernelFor"),
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, VerifyResetTag>(0, N),
+        *this);
 
-    Kokkos::deep_copy( host_flags, m_flags );
+    Kokkos::deep_copy(host_flags, m_flags);
 
     error_count = 0;
-    for ( int i = 0; i < N; ++i ) {
-      if ( int( 2 * i ) != host_flags( i ) ) ++error_count;
+    for (int i = 0; i < N; ++i) {
+      if (int(2 * i) != host_flags(i)) ++error_count;
     }
-    ASSERT_EQ( error_count, int( 0 ) );
+    ASSERT_EQ(error_count, int(0));
 
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, ScheduleType, OffsetTag >( offset, N + offset ), *this );
-    Kokkos::parallel_for( std::string("TestKernelFor"), Kokkos::RangePolicy<ExecSpace, ScheduleType, VerifyOffsetTag>( 0, N ), *this);
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(offset,
+                                                                N + offset),
+        *this);
+    Kokkos::parallel_for(
+        std::string("TestKernelFor"),
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, VerifyOffsetTag>(0, N),
+        *this);
 
     Kokkos::deep_copy(host_flags, m_flags);
 
     error_count = 0;
     for (int i = 0; i < N; ++i) {
-      if (i + offset != host_flags(i))
-        ++error_count;
+      if (i + offset != host_flags(i)) ++error_count;
     }
     ASSERT_EQ(error_count, int(0));
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i ) const
-  { m_flags( i )  = i; }
+  void operator()(const int i) const { m_flags(i) = i; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const VerifyInitTag &, const int i ) const
-  {
-    if ( i != m_flags( i ) ) {
-      printf( "TestRange::test_for error at %d != %d\n", i, m_flags( i ) );
+  void operator()(const VerifyInitTag &, const int i) const {
+    if (i != m_flags(i)) {
+      printf("TestRange::test_for error at %d != %d\n", i, m_flags(i));
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const ResetTag &, const int i ) const
-  { m_flags( i ) = 2 * m_flags( i ); }
+  void operator()(const ResetTag &, const int i) const {
+    m_flags(i) = 2 * m_flags(i);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const VerifyResetTag &, const int i ) const
-  {
-    if ( 2 * i != m_flags( i ) )
-    {
-      printf( "TestRange::test_for error at %d != %d\n", i, m_flags( i ) );
+  void operator()(const VerifyResetTag &, const int i) const {
+    if (2 * i != m_flags(i)) {
+      printf("TestRange::test_for error at %d != %d\n", i, m_flags(i));
     }
   }
 
@@ -173,131 +184,160 @@ struct TestRange {
 
   //----------------------------------------
 
-  void test_reduce( )
-  {
+  void test_reduce() {
     int total = 0;
 
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, ScheduleType >( 0, N ), *this );
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, ScheduleType>(0, N),
+                         *this);
 
-    Kokkos::parallel_reduce( "TestKernelReduce", Kokkos::RangePolicy< ExecSpace, ScheduleType >( 0, N ), *this, total );
+    Kokkos::parallel_reduce("TestKernelReduce",
+                            Kokkos::RangePolicy<ExecSpace, ScheduleType>(0, N),
+                            *this, total);
     // sum( 0 .. N-1 )
-    ASSERT_EQ( size_t( ( N - 1 ) * ( N ) / 2 ), size_t( total ) );
+    ASSERT_EQ(size_t((N - 1) * (N) / 2), size_t(total));
 
-    Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace, ScheduleType, OffsetTag>( offset, N+offset ), *this, total );
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(offset,
+                                                                N + offset),
+        *this, total);
     // sum( 1 .. N )
-    ASSERT_EQ( size_t( ( N ) * ( N + 1 ) / 2 ), size_t( total ) );
+    ASSERT_EQ(size_t((N) * (N + 1) / 2), size_t(total));
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i, value_type & update ) const
-  { update += m_flags( i ); }
+  void operator()(const int i, value_type &update) const {
+    update += m_flags(i);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const OffsetTag &, const int i, value_type & update ) const
-  { update += 1 + m_flags( i-offset ); }
+  void operator()(const OffsetTag &, const int i, value_type &update) const {
+    update += 1 + m_flags(i - offset);
+  }
 
   //----------------------------------------
 
-  void test_scan( )
-  {
-
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, ScheduleType >( 0, N ), *this );
+  void test_scan() {
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, ScheduleType>(0, N),
+                         *this);
 
-    Kokkos::parallel_scan( "TestKernelScan", Kokkos::RangePolicy< ExecSpace, ScheduleType, OffsetTag>( 0, N ), *this );
+    Kokkos::parallel_scan(
+        "TestKernelScan",
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(0, N), *this);
 
     int total = 0;
-    Kokkos::parallel_scan( "TestKernelScanWithTotal", Kokkos::RangePolicy< ExecSpace, ScheduleType, OffsetTag>( 0, N ), *this, total );
-    ASSERT_EQ( size_t( ( N - 1 ) * ( N ) / 2 ), size_t( total ) );// sum( 0 .. N-1 )
+    Kokkos::parallel_scan(
+        "TestKernelScanWithTotal",
+        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(0, N), *this,
+        total);
+    ASSERT_EQ(size_t((N - 1) * (N) / 2), size_t(total));  // sum( 0 .. N-1 )
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const OffsetTag &, const int i, value_type & update, bool final ) const
-  {
-    update += m_flags( i );
-
-    if ( final ) {
-      if ( update != ( i * ( i + 1 ) ) / 2 ) {
-        printf( "TestRange::test_scan error %d : %d != %d\n", i, ( i * ( i + 1 ) ) / 2, m_flags( i ) );
+  void operator()(const OffsetTag &, const int i, value_type &update,
+                  bool final) const {
+    update += m_flags(i);
+
+    if (final) {
+      if (update != (i * (i + 1)) / 2) {
+        printf("TestRange::test_scan error %d : %d != %d\n", i,
+               (i * (i + 1)) / 2, m_flags(i));
       }
     }
   }
 
-  void test_dynamic_policy()
-  {
-#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) 
-   #if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-     typedef Kokkos::RangePolicy< ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> > policy_t;
+  void test_dynamic_policy() {
+    auto const N_no_implicit_capture = N;
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+    typedef Kokkos::RangePolicy<ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >
+        policy_t;
 
     {
-      Kokkos::View< size_t*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > count( "Count", ExecSpace::concurrency() );
-      Kokkos::View< int*, ExecSpace > a( "A", N );
-
-      Kokkos::parallel_for( policy_t( 0, N ), KOKKOS_LAMBDA ( const int& i ) {
-        for ( int k = 0; k < ( i < N / 2 ? 1 : 10000 ); k++ ) {
-          a( i )++;
-        }
+      Kokkos::View<size_t *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> >
+          count("Count", ExecSpace::concurrency());
+      Kokkos::View<int *, ExecSpace> a("A", N);
+
+      Kokkos::parallel_for(
+          policy_t(0, N), KOKKOS_LAMBDA(const int &i) {
+            for (int k = 0; k < (i < N_no_implicit_capture / 2 ? 1 : 10000);
+                 k++) {
+              a(i)++;
+            }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-        count( ExecSpace::hardware_thread_id() )++;
+            count(ExecSpace::hardware_thread_id())++;
 #else
         count( ExecSpace::impl_hardware_thread_id() )++;
 #endif
-      });
+          });
 
       int error = 0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), KOKKOS_LAMBDA( const int & i, int & lsum ) {
-        lsum += ( a( i ) != ( i < N / 2 ? 1 : 10000 ) );
-      }, error );
-      ASSERT_EQ( error, 0 );
-
-      if ( ( ExecSpace::concurrency() > (int) 1 ) && ( N > static_cast<int>( 4 * ExecSpace::concurrency() ) ) ) {
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<ExecSpace>(0, N),
+          KOKKOS_LAMBDA(const int &i, int &lsum) {
+            lsum += (a(i) != (i < N_no_implicit_capture / 2 ? 1 : 10000));
+          },
+          error);
+      ASSERT_EQ(error, 0);
+
+      if ((ExecSpace::concurrency() > (int)1) &&
+          (N > static_cast<int>(4 * ExecSpace::concurrency()))) {
         size_t min = N;
         size_t max = 0;
-        for ( int t = 0; t < ExecSpace::concurrency(); t++ ) {
-          if ( count( t ) < min ) min = count( t );
-          if ( count( t ) > max ) max = count( t );
+        for (int t = 0; t < ExecSpace::concurrency(); t++) {
+          if (count(t) < min) min = count(t);
+          if (count(t) > max) max = count(t);
         }
-        ASSERT_TRUE( min < max );
+        ASSERT_TRUE(min < max);
 
-        //if ( ExecSpace::concurrency() > 2 ) {
+        // if ( ExecSpace::concurrency() > 2 ) {
         //  ASSERT_TRUE( 2 * min < max );
         //}
       }
     }
 
     {
-      Kokkos::View< size_t*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > count( "Count", ExecSpace::concurrency() );
-      Kokkos::View< int*, ExecSpace> a( "A", N );
+      Kokkos::View<size_t *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> >
+          count("Count", ExecSpace::concurrency());
+      Kokkos::View<int *, ExecSpace> a("A", N);
 
       int sum = 0;
-      Kokkos::parallel_reduce( policy_t( 0, N ), KOKKOS_LAMBDA( const int & i, int & lsum ) {
-        for ( int k = 0; k < ( i < N / 2 ? 1 : 10000 ); k++ ) {
-          a( i )++;
-        }
+      Kokkos::parallel_reduce(
+          policy_t(0, N),
+          KOKKOS_LAMBDA(const int &i, int &lsum) {
+            for (int k = 0; k < (i < N_no_implicit_capture / 2 ? 1 : 10000);
+                 k++) {
+              a(i)++;
+            }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-        count( ExecSpace::hardware_thread_id() )++;
+            count(ExecSpace::hardware_thread_id())++;
 #else
-        count( ExecSpace::impl_hardware_thread_id() )++;
+            count(ExecSpace::impl_hardware_thread_id())++;
 #endif
-        lsum++;
-      }, sum );
-      ASSERT_EQ( sum, N );
+            lsum++;
+          },
+          sum);
+      ASSERT_EQ(sum, N);
 
       int error = 0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), KOKKOS_LAMBDA( const int & i, int & lsum ) {
-        lsum += ( a( i ) != ( i < N / 2 ? 1 : 10000 ) );
-      }, error );
-      ASSERT_EQ( error, 0 );
-
-      if ( ( ExecSpace::concurrency() > (int) 1 ) && ( N > static_cast<int>( 4 * ExecSpace::concurrency() ) ) ) {
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<ExecSpace>(0, N),
+          KOKKOS_LAMBDA(const int &i, int &lsum) {
+            lsum += (a(i) != (i < N_no_implicit_capture / 2 ? 1 : 10000));
+          },
+          error);
+      ASSERT_EQ(error, 0);
+
+      if ((ExecSpace::concurrency() > (int)1) &&
+          (N > static_cast<int>(4 * ExecSpace::concurrency()))) {
         size_t min = N;
         size_t max = 0;
-        for ( int t = 0; t < ExecSpace::concurrency(); t++ ) {
-          if ( count( t ) < min ) min = count( t );
-          if ( count( t ) > max ) max = count( t );
+        for (int t = 0; t < ExecSpace::concurrency(); t++) {
+          if (count(t) < min) min = count(t);
+          if (count(t) > max) max = count(t);
         }
-        ASSERT_TRUE( min < max );
+        ASSERT_TRUE(min < max);
 
-        //if ( ExecSpace::concurrency() > 2 ) {
+        // if ( ExecSpace::concurrency() > 2 ) {
         //  ASSERT_TRUE( 2 * min < max );
         //}
       }
@@ -307,52 +347,112 @@ struct TestRange {
   }
 };
 
-} // namespace
+}  // namespace
 
-TEST_F( TEST_CATEGORY, range_for )
-{
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(0); f.test_for(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(0); f.test_for(); }
+TEST(TEST_CATEGORY, range_for) {
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(0);
+    f.test_for();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(0);
+    f.test_for();
+  }
 
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(2); f.test_for(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(3); f.test_for(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(2);
+    f.test_for();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(3);
+    f.test_for();
+  }
 
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(1000); f.test_for(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(1001); f.test_for(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(1000);
+    f.test_for();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(1001);
+    f.test_for();
+  }
 }
 
-TEST_F( TEST_CATEGORY, range_reduce )
-{
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(0); f.test_reduce(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(0); f.test_reduce(); }
+TEST(TEST_CATEGORY, range_reduce) {
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(0);
+    f.test_reduce();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(0);
+    f.test_reduce();
+  }
 
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(2); f.test_reduce(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(3); f.test_reduce(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(2);
+    f.test_reduce();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(3);
+    f.test_reduce();
+  }
 
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(1000); f.test_reduce(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(1001); f.test_reduce(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(1000);
+    f.test_reduce();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(1001);
+    f.test_reduce();
+  }
 }
 
-#ifndef KOKKOS_ENABLE_OPENMPTARGET 
-TEST_F( TEST_CATEGORY, range_scan )
-{
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(0); f.test_scan(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(0); f.test_scan(); }
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+TEST(TEST_CATEGORY, range_scan) {
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(0);
+    f.test_scan();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(0);
+    f.test_scan();
+  }
 #if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_ROCM)
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(0); f.test_dynamic_policy(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(0);
+    f.test_dynamic_policy();
+  }
 #endif
 
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(2); f.test_scan(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(3); f.test_scan(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(2);
+    f.test_scan();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(3);
+    f.test_scan();
+  }
 #if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_ROCM)
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(3); f.test_dynamic_policy(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(3);
+    f.test_dynamic_policy();
+  }
 #endif
 
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >f(1000); f.test_scan(); }
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(1001); f.test_scan(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(1000);
+    f.test_scan();
+  }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(1001);
+    f.test_scan();
+  }
 #if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_ROCM)
-  { TestRange< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >f(1001); f.test_dynamic_policy(); }
+  {
+    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(1001);
+    f.test_dynamic_policy();
+  }
 #endif
 }
 #endif
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReduce.hpp b/lib/kokkos/core/unit_test/TestReduce.hpp
index 924d8eb45f0f588fda657b4e90c2a4a738ac89c5..6c518429a05c8bda0df9ad89ddddb14a4446a686 100644
--- a/lib/kokkos/core/unit_test/TestReduce.hpp
+++ b/lib/kokkos/core/unit_test/TestReduce.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,10 +51,9 @@
 
 namespace Test {
 
-template< typename ScalarType, class DeviceType >
-class ReduceFunctor
-{
-public:
+template <typename ScalarType, class DeviceType>
+class ReduceFunctor {
+ public:
   typedef DeviceType execution_space;
   typedef typename execution_space::size_type size_type;
 
@@ -64,443 +64,400 @@ public:
   const size_type nwork;
 
   KOKKOS_INLINE_FUNCTION
-  ReduceFunctor( const size_type & arg_nwork )
-    : nwork( arg_nwork ) {}
+  ReduceFunctor(const size_type& arg_nwork) : nwork(arg_nwork) {}
 
   KOKKOS_INLINE_FUNCTION
-  ReduceFunctor( const ReduceFunctor & rhs )
-    : nwork( rhs.nwork ) {}
-
-/*
-  KOKKOS_INLINE_FUNCTION
-  void init( value_type & dst ) const
-  {
-    dst.value[0] = 0;
-    dst.value[1] = 0;
-    dst.value[2] = 0;
-  }
-*/
+  ReduceFunctor(const ReduceFunctor& rhs) : nwork(rhs.nwork) {}
+
+  /*
+    KOKKOS_INLINE_FUNCTION
+    void init( value_type & dst ) const
+    {
+      dst.value[0] = 0;
+      dst.value[1] = 0;
+      dst.value[2] = 0;
+    }
+  */
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & dst,
-             const volatile value_type & src ) const
-  {
+  void join(volatile value_type& dst, const volatile value_type& src) const {
     dst.value[0] += src.value[0];
     dst.value[1] += src.value[1];
     dst.value[2] += src.value[2];
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type iwork, value_type & dst ) const
-  {
+  void operator()(size_type iwork, value_type& dst) const {
     dst.value[0] += 1;
     dst.value[1] += iwork + 1;
     dst.value[2] += nwork - iwork;
   }
 };
 
-template< class DeviceType >
-class ReduceFunctorFinal : public ReduceFunctor< long, DeviceType > {
-public:
-  typedef typename ReduceFunctor< long, DeviceType >::value_type value_type;
+template <class DeviceType>
+class ReduceFunctorFinal : public ReduceFunctor<long, DeviceType> {
+ public:
+  typedef typename ReduceFunctor<long, DeviceType>::value_type value_type;
 
   KOKKOS_INLINE_FUNCTION
-  ReduceFunctorFinal( const size_t n )
-    : ReduceFunctor< long, DeviceType >( n ) {}
+  ReduceFunctorFinal(const size_t n) : ReduceFunctor<long, DeviceType>(n) {}
 
   KOKKOS_INLINE_FUNCTION
-  void final( value_type & dst ) const
-  {
+  void final(value_type& dst) const {
     dst.value[0] = -dst.value[0];
     dst.value[1] = -dst.value[1];
     dst.value[2] = -dst.value[2];
   }
 };
 
-template< typename ScalarType, class DeviceType >
-class RuntimeReduceFunctor
-{
-public:
+template <typename ScalarType, class DeviceType>
+class RuntimeReduceFunctor {
+ public:
   // Required for functor:
-  typedef DeviceType  execution_space;
-  typedef ScalarType  value_type[];
-  const unsigned      value_count;
+  typedef DeviceType execution_space;
+  typedef ScalarType value_type[];
+  const unsigned value_count;
 
   // Unit test details:
 
   typedef typename execution_space::size_type size_type;
 
-  const size_type     nwork;
+  const size_type nwork;
 
-  RuntimeReduceFunctor( const size_type arg_nwork,
-                        const size_type arg_count )
-    : value_count( arg_count )
-    , nwork( arg_nwork ) {}
+  RuntimeReduceFunctor(const size_type arg_nwork, const size_type arg_count)
+      : value_count(arg_count), nwork(arg_nwork) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( ScalarType dst[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) dst[i] = 0;
+  void init(ScalarType dst[]) const {
+    for (unsigned i = 0; i < value_count; ++i) dst[i] = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile ScalarType dst[],
-             const volatile ScalarType src[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) dst[i] += src[i];
+  void join(volatile ScalarType dst[], const volatile ScalarType src[]) const {
+    for (unsigned i = 0; i < value_count; ++i) dst[i] += src[i];
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type iwork, ScalarType dst[] ) const
-  {
-    const size_type tmp[3] = { 1, iwork + 1, nwork - iwork };
+  void operator()(size_type iwork, ScalarType dst[]) const {
+    const size_type tmp[3] = {1, iwork + 1, nwork - iwork};
 
-    for ( size_type i = 0; i < value_count; ++i ) {
-      dst[i] += tmp[ i % 3 ];
+    for (size_type i = 0; i < value_count; ++i) {
+      dst[i] += tmp[i % 3];
     }
   }
 };
 
-template< typename ScalarType, class DeviceType >
-class RuntimeReduceMinMax
-{
-public:
+template <typename ScalarType, class DeviceType>
+class RuntimeReduceMinMax {
+ public:
   // Required for functor:
-  typedef DeviceType  execution_space;
-  typedef ScalarType  value_type[];
-  const unsigned      value_count;
+  typedef DeviceType execution_space;
+  typedef ScalarType value_type[];
+  const unsigned value_count;
 
   // Unit test details:
 
   typedef typename execution_space::size_type size_type;
 
-  const size_type     nwork;
-  const ScalarType    amin;
-  const ScalarType    amax;
+  const size_type nwork;
+  const ScalarType amin;
+  const ScalarType amax;
 
-  RuntimeReduceMinMax( const size_type arg_nwork,
-                       const size_type arg_count )
-    : value_count( arg_count )
-    , nwork( arg_nwork )
-    , amin( std::numeric_limits< ScalarType >::min() )
-    , amax( std::numeric_limits< ScalarType >::max() )
-    {}
+  RuntimeReduceMinMax(const size_type arg_nwork, const size_type arg_count)
+      : value_count(arg_count),
+        nwork(arg_nwork),
+        amin(std::numeric_limits<ScalarType>::min()),
+        amax(std::numeric_limits<ScalarType>::max()) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( ScalarType dst[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) {
+  void init(ScalarType dst[]) const {
+    for (unsigned i = 0; i < value_count; ++i) {
       dst[i] = i % 2 ? amax : amin;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile ScalarType dst[],
-             const volatile ScalarType src[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) {
-      dst[i] = i % 2 ? ( dst[i] < src[i] ? dst[i] : src[i] )  // min
-                     : ( dst[i] > src[i] ? dst[i] : src[i] ); // max
+  void join(volatile ScalarType dst[], const volatile ScalarType src[]) const {
+    for (unsigned i = 0; i < value_count; ++i) {
+      dst[i] = i % 2 ? (dst[i] < src[i] ? dst[i] : src[i])   // min
+                     : (dst[i] > src[i] ? dst[i] : src[i]);  // max
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_type iwork, ScalarType dst[] ) const
-  {
-    const ScalarType tmp[2] = { ScalarType( iwork + 1 )
-                              , ScalarType( nwork - iwork ) };
-
-    for ( size_type i = 0; i < value_count; ++i ) {
-      dst[i] = i % 2 ? ( dst[i] < tmp[i % 2] ? dst[i] : tmp[i % 2] )
-                     : ( dst[i] > tmp[i % 2] ? dst[i] : tmp[i % 2] );
+  void operator()(size_type iwork, ScalarType dst[]) const {
+    const ScalarType tmp[2] = {ScalarType(iwork + 1),
+                               ScalarType(nwork - iwork)};
+
+    for (size_type i = 0; i < value_count; ++i) {
+      dst[i] = i % 2 ? (dst[i] < tmp[i % 2] ? dst[i] : tmp[i % 2])
+                     : (dst[i] > tmp[i % 2] ? dst[i] : tmp[i % 2]);
     }
   }
 };
 
-template< class DeviceType >
-class RuntimeReduceFunctorFinal : public RuntimeReduceFunctor< long, DeviceType > {
-public:
-  typedef RuntimeReduceFunctor< long, DeviceType > base_type;
+template <class DeviceType>
+class RuntimeReduceFunctorFinal
+    : public RuntimeReduceFunctor<long, DeviceType> {
+ public:
+  typedef RuntimeReduceFunctor<long, DeviceType> base_type;
   typedef typename base_type::value_type value_type;
   typedef long scalar_type;
 
-  RuntimeReduceFunctorFinal( const size_t theNwork, const size_t count )
-    : base_type( theNwork, count ) {}
+  RuntimeReduceFunctorFinal(const size_t theNwork, const size_t count)
+      : base_type(theNwork, count) {}
 
   KOKKOS_INLINE_FUNCTION
-  void final( value_type dst ) const
-  {
-    for ( unsigned i = 0; i < base_type::value_count; ++i ) {
+  void final(value_type dst) const {
+    for (unsigned i = 0; i < base_type::value_count; ++i) {
       dst[i] = -dst[i];
     }
   }
 };
 
-
 namespace {
 
-template< typename ScalarType, class DeviceType >
-class TestReduce
-{
-public:
+template <typename ScalarType, class DeviceType>
+class TestReduce {
+ public:
   typedef DeviceType execution_space;
   typedef typename execution_space::size_type size_type;
 
-  TestReduce( const size_type & nwork )
-  {
-    run_test( nwork );
-    run_test_final( nwork );
+  TestReduce(const size_type& nwork) {
+    run_test(nwork);
+    run_test_final(nwork);
   }
 
-  void run_test( const size_type & nwork )
-  {
-    typedef Test::ReduceFunctor< ScalarType, execution_space > functor_type;
+  void run_test(const size_type& nwork) {
+    typedef Test::ReduceFunctor<ScalarType, execution_space> functor_type;
     typedef typename functor_type::value_type value_type;
 
     enum { Count = 3 };
     enum { Repeat = 100 };
 
-    value_type result[ Repeat ];
+    value_type result[Repeat];
 
-    const unsigned long nw   = nwork;
-    const unsigned long nsum = nw % 2 ? nw * ( ( nw + 1 ) / 2 )
-                                      : ( nw / 2 ) * ( nw + 1 );
+    const unsigned long nw = nwork;
+    const unsigned long nsum =
+        nw % 2 ? nw * ((nw + 1) / 2) : (nw / 2) * (nw + 1);
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      Kokkos::parallel_reduce( nwork, functor_type( nwork ), result[i] );
+    for (unsigned i = 0; i < Repeat; ++i) {
+      Kokkos::parallel_reduce(nwork, functor_type(nwork), result[i]);
     }
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      for ( unsigned j = 0; j < Count; ++j ) {
+    for (unsigned i = 0; i < Repeat; ++i) {
+      for (unsigned j = 0; j < Count; ++j) {
         const unsigned long correct = 0 == j % 3 ? nw : nsum;
-        ASSERT_EQ( (ScalarType) correct, result[i].value[j] );
+        ASSERT_EQ((ScalarType)correct, result[i].value[j]);
       }
     }
   }
 
-  void run_test_final( const size_type & nwork )
-  {
-    typedef Test::ReduceFunctorFinal< execution_space > functor_type;
+  void run_test_final(const size_type& nwork) {
+    typedef Test::ReduceFunctorFinal<execution_space> functor_type;
     typedef typename functor_type::value_type value_type;
 
     enum { Count = 3 };
     enum { Repeat = 100 };
 
-    value_type result[ Repeat ];
+    value_type result[Repeat];
 
-    const unsigned long nw   = nwork;
-    const unsigned long nsum = nw % 2 ? nw * ( ( nw + 1 ) / 2 )
-                                      : ( nw / 2 ) * ( nw + 1 );
+    const unsigned long nw = nwork;
+    const unsigned long nsum =
+        nw % 2 ? nw * ((nw + 1) / 2) : (nw / 2) * (nw + 1);
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      if ( i % 2 == 0 ) {
-        Kokkos::parallel_reduce( nwork, functor_type( nwork ), result[i] );
-      }
-      else {
-        Kokkos::parallel_reduce( "Reduce", nwork, functor_type( nwork ), result[i] );
+    for (unsigned i = 0; i < Repeat; ++i) {
+      if (i % 2 == 0) {
+        Kokkos::parallel_reduce(nwork, functor_type(nwork), result[i]);
+      } else {
+        Kokkos::parallel_reduce("Reduce", nwork, functor_type(nwork),
+                                result[i]);
       }
     }
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      for ( unsigned j = 0; j < Count; ++j ) {
+    for (unsigned i = 0; i < Repeat; ++i) {
+      for (unsigned j = 0; j < Count; ++j) {
         const unsigned long correct = 0 == j % 3 ? nw : nsum;
-        ASSERT_EQ( (ScalarType) correct, -result[i].value[j] );
+        ASSERT_EQ((ScalarType)correct, -result[i].value[j]);
       }
     }
   }
 };
 
-template< typename ScalarType, class DeviceType >
-class TestReduceDynamic
-{
-public:
+template <typename ScalarType, class DeviceType>
+class TestReduceDynamic {
+ public:
   typedef DeviceType execution_space;
   typedef typename execution_space::size_type size_type;
 
-  TestReduceDynamic( const size_type nwork )
-  {
-    run_test_dynamic( nwork );
-    run_test_dynamic_minmax( nwork );
-    run_test_dynamic_final( nwork );
+  TestReduceDynamic(const size_type nwork) {
+    run_test_dynamic(nwork);
+    run_test_dynamic_minmax(nwork);
+    run_test_dynamic_final(nwork);
   }
 
-  void run_test_dynamic( const size_type nwork )
-  {
-    typedef Test::RuntimeReduceFunctor< ScalarType, execution_space > functor_type;
+  void run_test_dynamic(const size_type nwork) {
+    typedef Test::RuntimeReduceFunctor<ScalarType, execution_space>
+        functor_type;
 
     enum { Count = 3 };
     enum { Repeat = 100 };
 
-    ScalarType result[ Repeat ][ Count ];
+    ScalarType result[Repeat][Count];
 
-    const unsigned long nw   = nwork;
-    const unsigned long nsum = nw % 2 ? nw * ( ( nw + 1 ) / 2 )
-                                      : ( nw / 2 ) * ( nw + 1 );
+    const unsigned long nw = nwork;
+    const unsigned long nsum =
+        nw % 2 ? nw * ((nw + 1) / 2) : (nw / 2) * (nw + 1);
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      if ( i % 2 == 0 ) {
-        Kokkos::parallel_reduce( nwork, functor_type( nwork, Count ), result[i] );
-      }
-      else {
-        Kokkos::parallel_reduce( "Reduce", nwork, functor_type( nwork, Count ), result[i] );
+    for (unsigned i = 0; i < Repeat; ++i) {
+      if (i % 2 == 0) {
+        Kokkos::parallel_reduce(nwork, functor_type(nwork, Count), result[i]);
+      } else {
+        Kokkos::parallel_reduce("Reduce", nwork, functor_type(nwork, Count),
+                                result[i]);
       }
     }
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      for ( unsigned j = 0; j < Count; ++j ) {
+    for (unsigned i = 0; i < Repeat; ++i) {
+      for (unsigned j = 0; j < Count; ++j) {
         const unsigned long correct = 0 == j % 3 ? nw : nsum;
-        ASSERT_EQ( (ScalarType) correct, result[i][j] );
+        ASSERT_EQ((ScalarType)correct, result[i][j]);
       }
     }
   }
 
-  void run_test_dynamic_minmax( const size_type nwork )
-  {
-    typedef Test::RuntimeReduceMinMax< ScalarType, execution_space > functor_type;
+  void run_test_dynamic_minmax(const size_type nwork) {
+    typedef Test::RuntimeReduceMinMax<ScalarType, execution_space> functor_type;
 
     enum { Count = 2 };
     enum { Repeat = 100 };
 
-    ScalarType result[ Repeat ][ Count ];
+    ScalarType result[Repeat][Count];
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      if ( i % 2 == 0 ) {
-        Kokkos::parallel_reduce( nwork, functor_type( nwork, Count ), result[i] );
-      }
-      else {
-        Kokkos::parallel_reduce( "Reduce", nwork, functor_type( nwork, Count ), result[i] );
+    for (unsigned i = 0; i < Repeat; ++i) {
+      if (i % 2 == 0) {
+        Kokkos::parallel_reduce(nwork, functor_type(nwork, Count), result[i]);
+      } else {
+        Kokkos::parallel_reduce("Reduce", nwork, functor_type(nwork, Count),
+                                result[i]);
       }
     }
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      for ( unsigned j = 0; j < Count; ++j ) {
-        if ( nwork == 0 )
-        {
-          ScalarType amin( std::numeric_limits< ScalarType >::min() );
-          ScalarType amax( std::numeric_limits< ScalarType >::max() );
-          const ScalarType correct = ( j % 2 ) ? amax : amin;
-          ASSERT_EQ( (ScalarType) correct, result[i][j] );
-        }
-        else {
+    for (unsigned i = 0; i < Repeat; ++i) {
+      for (unsigned j = 0; j < Count; ++j) {
+        if (nwork == 0) {
+          ScalarType amin(std::numeric_limits<ScalarType>::min());
+          ScalarType amax(std::numeric_limits<ScalarType>::max());
+          const ScalarType correct = (j % 2) ? amax : amin;
+          ASSERT_EQ((ScalarType)correct, result[i][j]);
+        } else {
           const unsigned long correct = j % 2 ? 1 : nwork;
-          ASSERT_EQ( (ScalarType) correct, result[i][j] );
+          ASSERT_EQ((ScalarType)correct, result[i][j]);
         }
       }
     }
   }
 
-  void run_test_dynamic_final( const size_type nwork )
-  {
-    typedef Test::RuntimeReduceFunctorFinal< execution_space > functor_type;
+  void run_test_dynamic_final(const size_type nwork) {
+    typedef Test::RuntimeReduceFunctorFinal<execution_space> functor_type;
 
     enum { Count = 3 };
     enum { Repeat = 100 };
 
-    typename functor_type::scalar_type result[ Repeat ][ Count ];
+    typename functor_type::scalar_type result[Repeat][Count];
 
-    const unsigned long nw   = nwork;
-    const unsigned long nsum = nw % 2 ? nw * ( ( nw + 1 ) / 2 )
-                                      : ( nw / 2 ) * ( nw + 1 );
+    const unsigned long nw = nwork;
+    const unsigned long nsum =
+        nw % 2 ? nw * ((nw + 1) / 2) : (nw / 2) * (nw + 1);
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      if ( i % 2 == 0 ) {
-        Kokkos::parallel_reduce( nwork, functor_type( nwork, Count ), result[i] );
-      }
-      else {
-        Kokkos::parallel_reduce( "TestKernelReduce", nwork, functor_type( nwork, Count ), result[i] );
+    for (unsigned i = 0; i < Repeat; ++i) {
+      if (i % 2 == 0) {
+        Kokkos::parallel_reduce(nwork, functor_type(nwork, Count), result[i]);
+      } else {
+        Kokkos::parallel_reduce("TestKernelReduce", nwork,
+                                functor_type(nwork, Count), result[i]);
       }
-
     }
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      for ( unsigned j = 0; j < Count; ++j ) {
+    for (unsigned i = 0; i < Repeat; ++i) {
+      for (unsigned j = 0; j < Count; ++j) {
         const unsigned long correct = 0 == j % 3 ? nw : nsum;
-        ASSERT_EQ( (ScalarType) correct, -result[i][j] );
+        ASSERT_EQ((ScalarType)correct, -result[i][j]);
       }
     }
   }
 };
 
-template< typename ScalarType, class DeviceType >
-class TestReduceDynamicView
-{
-public:
+template <typename ScalarType, class DeviceType>
+class TestReduceDynamicView {
+ public:
   typedef DeviceType execution_space;
   typedef typename execution_space::size_type size_type;
 
-  TestReduceDynamicView( const size_type nwork )
-  {
-    run_test_dynamic_view( nwork );
-  }
+  TestReduceDynamicView(const size_type nwork) { run_test_dynamic_view(nwork); }
 
-  void run_test_dynamic_view( const size_type nwork )
-  {
-    typedef Test::RuntimeReduceFunctor< ScalarType, execution_space > functor_type;
+  void run_test_dynamic_view(const size_type nwork) {
+    typedef Test::RuntimeReduceFunctor<ScalarType, execution_space>
+        functor_type;
 
-    typedef Kokkos::View< ScalarType*, DeviceType > result_type;
+    typedef Kokkos::View<ScalarType*, DeviceType> result_type;
     typedef typename result_type::HostMirror result_host_type;
 
     const unsigned CountLimit = 23;
 
-    const unsigned long nw   = nwork;
-    const unsigned long nsum = nw % 2 ? nw * ( ( nw + 1 ) / 2 )
-                                      : ( nw / 2 ) * ( nw + 1 );
-
-    for ( unsigned count = 0; count < CountLimit; ++count ) {
+    const unsigned long nw = nwork;
+    const unsigned long nsum =
+        nw % 2 ? nw * ((nw + 1) / 2) : (nw / 2) * (nw + 1);
 
-      result_type result( "result", count );
-      result_host_type host_result = Kokkos::create_mirror( result );
+    for (unsigned count = 0; count < CountLimit; ++count) {
+      result_type result("result", count);
+      result_host_type host_result = Kokkos::create_mirror(result);
 
       // Test result to host pointer:
 
-      std::string str( "TestKernelReduce" );
-      if ( count % 2 == 0 ) {
-        Kokkos::parallel_reduce( nw, functor_type( nw, count ), host_result.data() );
-      }
-      else {
-        Kokkos::parallel_reduce( str, nw, functor_type( nw, count ), host_result.data() );
+      std::string str("TestKernelReduce");
+      if (count % 2 == 0) {
+        Kokkos::parallel_reduce(nw, functor_type(nw, count),
+                                host_result.data());
+      } else {
+        Kokkos::parallel_reduce(str, nw, functor_type(nw, count),
+                                host_result.data());
       }
 
-      for ( unsigned j = 0; j < count; ++j ) {
+      for (unsigned j = 0; j < count; ++j) {
         const unsigned long correct = 0 == j % 3 ? nw : nsum;
-        ASSERT_EQ( host_result( j ), (ScalarType) correct );
-        host_result( j ) = 0;
+        ASSERT_EQ(host_result(j), (ScalarType)correct);
+        host_result(j) = 0;
       }
     }
   }
 };
 
-} // namespace
-
+}  // namespace
 
-TEST_F( TEST_CATEGORY, long_reduce )
-{
-  TestReduce< long, TEST_EXECSPACE >( 0 );
-  TestReduce< long, TEST_EXECSPACE >( 1000000 );
+TEST(TEST_CATEGORY, long_reduce) {
+  TestReduce<long, TEST_EXECSPACE>(0);
+  TestReduce<long, TEST_EXECSPACE>(1000000);
 }
 
-TEST_F( TEST_CATEGORY, double_reduce )
-{
-  TestReduce< double, TEST_EXECSPACE >( 0 );
-  TestReduce< double, TEST_EXECSPACE >( 1000000 );
+TEST(TEST_CATEGORY, double_reduce) {
+  TestReduce<double, TEST_EXECSPACE>(0);
+  TestReduce<double, TEST_EXECSPACE>(1000000);
 }
 
-TEST_F( TEST_CATEGORY, long_reduce_dynamic )
-{
-  TestReduceDynamic< long, TEST_EXECSPACE >( 0 );
-  TestReduceDynamic< long, TEST_EXECSPACE >( 1000000 );
+TEST(TEST_CATEGORY, long_reduce_dynamic) {
+  TestReduceDynamic<long, TEST_EXECSPACE>(0);
+  TestReduceDynamic<long, TEST_EXECSPACE>(1000000);
 }
 
-TEST_F( TEST_CATEGORY, double_reduce_dynamic )
-{
-  TestReduceDynamic< double, TEST_EXECSPACE >( 0 );
-  TestReduceDynamic< double, TEST_EXECSPACE >( 1000000 );
+TEST(TEST_CATEGORY, double_reduce_dynamic) {
+  TestReduceDynamic<double, TEST_EXECSPACE>(0);
+  TestReduceDynamic<double, TEST_EXECSPACE>(1000000);
 }
 
-TEST_F( TEST_CATEGORY, long_reduce_dynamic_view )
-{
-  TestReduceDynamicView< long, TEST_EXECSPACE >( 0 );
-  TestReduceDynamicView< long, TEST_EXECSPACE >( 1000000 );
+TEST(TEST_CATEGORY, long_reduce_dynamic_view) {
+  TestReduceDynamicView<long, TEST_EXECSPACE>(0);
+  TestReduceDynamicView<long, TEST_EXECSPACE>(1000000);
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReduceCombinatorical.hpp b/lib/kokkos/core/unit_test/TestReduceCombinatorical.hpp
index 293cc0ca594ba45895c3a0151b9598330e0dcfd5..a03dbd114189106ce16d5cc5a5a0b03e5ee332dd 100644
--- a/lib/kokkos/core/unit_test/TestReduceCombinatorical.hpp
+++ b/lib/kokkos/core/unit_test/TestReduceCombinatorical.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,357 +53,311 @@ namespace Test {
 
 namespace ReduceCombinatorical {
 
-template< class Scalar, class Space = Kokkos::HostSpace >
+template <class Scalar, class Space = Kokkos::HostSpace>
 struct AddPlus {
-public:
+ public:
   // Required.
   typedef AddPlus reducer;
   typedef Scalar value_type;
 
-  typedef Kokkos::View< value_type, Space, Kokkos::MemoryTraits<Kokkos::Unmanaged> > result_view_type;
+  typedef Kokkos::View<value_type, Space,
+                       Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      result_view_type;
 
-private:
+ private:
   result_view_type result;
 
-public:
-  AddPlus( value_type & result_ ) : result( &result_ ) {}
+ public:
+  AddPlus(value_type& result_) : result(&result_) {}
 
   // Required.
   KOKKOS_INLINE_FUNCTION
-  void join( value_type & dest, const value_type & src ) const {
-    dest += src + 1;
-  }
+  void join(value_type& dest, const value_type& src) const { dest += src + 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & dest, const volatile value_type & src ) const {
+  void join(volatile value_type& dest, const volatile value_type& src) const {
     dest += src + 1;
   }
 
   // Optional.
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & val )  const {
-    val = value_type();
-  }
+  void init(value_type& val) const { val = value_type(); }
 
   KOKKOS_INLINE_FUNCTION
-  value_type& reference() const {
-    return result();
-  }
+  value_type& reference() const { return result(); }
 
   KOKKOS_INLINE_FUNCTION
-  result_view_type view() const {
-    return result;
-  }
+  result_view_type view() const { return result; }
 };
 
-template< int ISTEAM >
+template <int ISTEAM>
 struct FunctorScalar;
 
-template<>
-struct FunctorScalar< 0 > {
-  Kokkos::View< double > result;
+template <>
+struct FunctorScalar<0> {
+  Kokkos::View<double> result;
 
-  FunctorScalar( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalar(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 };
 
-template<>
-struct FunctorScalar< 1 > {
+template <>
+struct FunctorScalar<1> {
   typedef Kokkos::TeamPolicy<>::member_type team_type;
 
-  Kokkos::View< double > result;
+  Kokkos::View<double> result;
 
-  FunctorScalar( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalar(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_type & team, double & update ) const {
+  void operator()(const team_type& team, double& update) const {
     update += 1.0 / team.team_size() * team.league_rank();
   }
 };
 
-template< int ISTEAM >
+template <int ISTEAM>
 struct FunctorScalarInit;
 
-template<>
-struct FunctorScalarInit< 0 > {
-  Kokkos::View< double > result;
+template <>
+struct FunctorScalarInit<0> {
+  Kokkos::View<double> result;
 
-  FunctorScalarInit( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarInit(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 
   KOKKOS_INLINE_FUNCTION
-  void init( double & update ) const {
-    update = 0.0;
-  }
+  void init(double& update) const { update = 0.0; }
 };
 
-template<>
-struct FunctorScalarInit< 1 > {
+template <>
+struct FunctorScalarInit<1> {
   typedef Kokkos::TeamPolicy<>::member_type team_type;
 
-  Kokkos::View< double > result;
+  Kokkos::View<double> result;
 
-  FunctorScalarInit( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarInit(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_type & team, double & update ) const {
+  void operator()(const team_type& team, double& update) const {
     update += 1.0 / team.team_size() * team.league_rank();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( double & update ) const {
-    update = 0.0;
-  }
+  void init(double& update) const { update = 0.0; }
 };
 
-template< int ISTEAM >
+template <int ISTEAM>
 struct FunctorScalarFinal;
 
-template<>
-struct FunctorScalarFinal< 0 > {
+template <>
+struct FunctorScalarFinal<0> {
   Kokkos::View<double> result;
 
-  FunctorScalarFinal( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarFinal(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 
   KOKKOS_INLINE_FUNCTION
-  void final( double & update ) const {
-    result() = update;
-  }
+  void final(double& update) const { result() = update; }
 };
 
-template<>
-struct FunctorScalarFinal< 1 > {
+template <>
+struct FunctorScalarFinal<1> {
   typedef Kokkos::TeamPolicy<>::member_type team_type;
 
-  Kokkos::View< double > result;
+  Kokkos::View<double> result;
 
-  FunctorScalarFinal( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarFinal(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_type & team, double & update ) const {
+  void operator()(const team_type& team, double& update) const {
     update += 1.0 / team.team_size() * team.league_rank();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void final( double & update ) const {
-    result() = update;
-  }
+  void final(double& update) const { result() = update; }
 };
 
-template< int ISTEAM >
+template <int ISTEAM>
 struct FunctorScalarJoin;
 
-template<>
-struct FunctorScalarJoin< 0 > {
+template <>
+struct FunctorScalarJoin<0> {
   Kokkos::View<double> result;
 
-  FunctorScalarJoin( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoin(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 };
 
-template<>
-struct FunctorScalarJoin< 1 > {
+template <>
+struct FunctorScalarJoin<1> {
   typedef Kokkos::TeamPolicy<>::member_type team_type;
 
-  Kokkos::View< double > result;
+  Kokkos::View<double> result;
 
-  FunctorScalarJoin( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoin(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_type & team, double & update ) const {
+  void operator()(const team_type& team, double& update) const {
     update += 1.0 / team.team_size() * team.league_rank();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 };
 
-template< int ISTEAM >
+template <int ISTEAM>
 struct FunctorScalarJoinFinal;
 
-template<>
-struct FunctorScalarJoinFinal< 0 > {
-  Kokkos::View< double > result;
+template <>
+struct FunctorScalarJoinFinal<0> {
+  Kokkos::View<double> result;
 
-  FunctorScalarJoinFinal( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoinFinal(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void final( double & update ) const {
-    result() = update;
-  }
+  void final(double& update) const { result() = update; }
 };
 
-template<>
-struct FunctorScalarJoinFinal< 1 > {
+template <>
+struct FunctorScalarJoinFinal<1> {
   typedef Kokkos::TeamPolicy<>::member_type team_type;
 
-  Kokkos::View< double > result;
+  Kokkos::View<double> result;
 
-  FunctorScalarJoinFinal( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoinFinal(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_type & team, double & update ) const {
+  void operator()(const team_type& team, double& update) const {
     update += 1.0 / team.team_size() * team.league_rank();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void final( double & update ) const {
-    result() = update;
-  }
+  void final(double& update) const { result() = update; }
 };
 
-template< int ISTEAM >
+template <int ISTEAM>
 struct FunctorScalarJoinInit;
 
-template<>
-struct FunctorScalarJoinInit< 0 > {
-  Kokkos::View< double > result;
+template <>
+struct FunctorScalarJoinInit<0> {
+  Kokkos::View<double> result;
 
-  FunctorScalarJoinInit( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoinInit(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( double & update ) const {
-    update = 0.0;
-  }
+  void init(double& update) const { update = 0.0; }
 };
 
-template<>
-struct FunctorScalarJoinInit< 1 > {
+template <>
+struct FunctorScalarJoinInit<1> {
   typedef Kokkos::TeamPolicy<>::member_type team_type;
 
-  Kokkos::View< double > result;
+  Kokkos::View<double> result;
 
-  FunctorScalarJoinInit( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoinInit(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_type & team, double & update ) const {
+  void operator()(const team_type& team, double& update) const {
     update += 1.0 / team.team_size() * team.league_rank();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( double & update ) const {
-    update = 0.0;
-  }
+  void init(double& update) const { update = 0.0; }
 };
 
-template< int ISTEAM >
+template <int ISTEAM>
 struct FunctorScalarJoinFinalInit;
 
-template<>
-struct FunctorScalarJoinFinalInit< 0 > {
+template <>
+struct FunctorScalarJoinFinalInit<0> {
   Kokkos::View<double> result;
 
-  FunctorScalarJoinFinalInit( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoinFinalInit(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void final( double & update ) const {
-    result() = update;
-  }
+  void final(double& update) const { result() = update; }
 
   KOKKOS_INLINE_FUNCTION
-  void init( double & update ) const {
-    update = 0.0;
-  }
+  void init(double& update) const { update = 0.0; }
 };
 
-template<>
-struct FunctorScalarJoinFinalInit< 1 > {
+template <>
+struct FunctorScalarJoinFinalInit<1> {
   typedef Kokkos::TeamPolicy<>::member_type team_type;
 
-  Kokkos::View< double > result;
+  Kokkos::View<double> result;
 
-  FunctorScalarJoinFinalInit( Kokkos::View< double > r ) : result( r ) {}
+  FunctorScalarJoinFinalInit(Kokkos::View<double> r) : result(r) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_type & team, double & update ) const {
+  void operator()(const team_type& team, double& update) const {
     update += 1.0 / team.team_size() * team.league_rank();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double & dst, const volatile double & update ) const {
+  void join(volatile double& dst, const volatile double& update) const {
     dst += update;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void final( double & update ) const {
-    result() = update;
-  }
+  void final(double& update) const { result() = update; }
 
   KOKKOS_INLINE_FUNCTION
-  void init( double & update ) const {
-    update = 0.0;
-  }
+  void init(double& update) const { update = 0.0; }
 };
 
 struct Functor1 {
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & i, double & update ) const {
-    update += i;
-  }
+  void operator()(const int& i, double& update) const { update += i; }
 };
 
 struct Functor2 {
@@ -410,239 +365,277 @@ struct Functor2 {
 
   const unsigned value_count;
 
-  Functor2( unsigned n ) : value_count( n ) {}
+  Functor2(unsigned n) : value_count(n) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned & i, double update[] ) const {
-    for ( unsigned j = 0; j < value_count; j++ ) {
+  void operator()(const unsigned& i, double update[]) const {
+    for (unsigned j = 0; j < value_count; j++) {
       update[j] += i;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( double dst[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) dst[i] = 0;
+  void init(double dst[]) const {
+    for (unsigned i = 0; i < value_count; ++i) dst[i] = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile double dst[],
-             const volatile double src[] ) const
-  {
-    for ( unsigned i = 0; i < value_count; ++i ) dst[i] += src[i];
+  void join(volatile double dst[], const volatile double src[]) const {
+    for (unsigned i = 0; i < value_count; ++i) dst[i] += src[i];
   }
 };
 
-} // namespace ReduceCombinatorical
+}  // namespace ReduceCombinatorical
 
-template< class ExecSpace = Kokkos::DefaultExecutionSpace >
+template <class ExecSpace = Kokkos::DefaultExecutionSpace>
 struct TestReduceCombinatoricalInstantiation {
-  template< class ... Args >
-  static void CallParallelReduce( Args... args ) {
-    Kokkos::parallel_reduce( args... );
+  template <class... Args>
+  static void CallParallelReduce(Args... args) {
+    Kokkos::parallel_reduce(args...);
   }
 
-  template< class ... Args >
-  static void AddReturnArgument( Args... args ) {
-    Kokkos::View< double, Kokkos::HostSpace > result_view( "ResultView" );
+  template <class... Args>
+  static void AddReturnArgument(Args... args) {
+    Kokkos::View<double, Kokkos::HostSpace> result_view("ResultView");
     double expected_result = 1000.0 * 999.0 / 2.0;
 
     double value = 0;
-    Kokkos::parallel_reduce( args..., value );
-    ASSERT_EQ( expected_result, value );
+    Kokkos::parallel_reduce(args..., value);
+    ASSERT_EQ(expected_result, value);
 
     result_view() = 0;
-    CallParallelReduce( args..., result_view );
+    CallParallelReduce(args..., result_view);
     Kokkos::fence();
-    ASSERT_EQ( expected_result, result_view() );
+    ASSERT_EQ(expected_result, result_view());
 
     value = 0;
-    CallParallelReduce( args..., Kokkos::View< double, Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >( &value ) );
+    CallParallelReduce(
+        args...,
+        Kokkos::View<double, Kokkos::HostSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged> >(&value));
     Kokkos::fence();
-    ASSERT_EQ( expected_result, value );
+    ASSERT_EQ(expected_result, value);
 
     result_view() = 0;
-    const Kokkos::View< double, Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > result_view_const_um = result_view;
-    CallParallelReduce( args..., result_view_const_um );
+    const Kokkos::View<double, Kokkos::HostSpace,
+                       Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+        result_view_const_um = result_view;
+    CallParallelReduce(args..., result_view_const_um);
     Kokkos::fence();
-    ASSERT_EQ( expected_result, result_view_const_um() );
+    ASSERT_EQ(expected_result, result_view_const_um());
 
     value = 0;
-    CallParallelReduce( args..., Test::ReduceCombinatorical::AddPlus< double >( value ) );
-    if ( ( Kokkos::DefaultExecutionSpace::concurrency() > 1 ) && ( ExecSpace::concurrency() > 1 ) ) {
-      ASSERT_TRUE( expected_result < value );
-    }
-    else if ( ( Kokkos::DefaultExecutionSpace::concurrency() > 1 ) || ( ExecSpace::concurrency() > 1 ) ) {
-      ASSERT_TRUE( expected_result <= value );
-    }
-    else {
-      ASSERT_EQ( expected_result, value );
+    CallParallelReduce(args...,
+                       Test::ReduceCombinatorical::AddPlus<double>(value));
+    if ((Kokkos::DefaultExecutionSpace::concurrency() > 1) &&
+        (ExecSpace::concurrency() > 1)) {
+      ASSERT_TRUE(expected_result < value);
+    } else if ((Kokkos::DefaultExecutionSpace::concurrency() > 1) ||
+               (ExecSpace::concurrency() > 1)) {
+      ASSERT_TRUE(expected_result <= value);
+    } else {
+      ASSERT_EQ(expected_result, value);
     }
 
     value = 0;
-    Test::ReduceCombinatorical::AddPlus< double > add( value );
-    CallParallelReduce( args..., add );
-    if ( ( Kokkos::DefaultExecutionSpace::concurrency() > 1 ) && ( ExecSpace::concurrency() > 1 ) ) {
-      ASSERT_TRUE( expected_result < value );
-    }
-    else if ( ( Kokkos::DefaultExecutionSpace::concurrency() > 1 ) || ( ExecSpace::concurrency() > 1 ) ) {
-      ASSERT_TRUE( expected_result <= value );
-    }
-    else {
-      ASSERT_EQ( expected_result, value );
+    Test::ReduceCombinatorical::AddPlus<double> add(value);
+    CallParallelReduce(args..., add);
+    if ((Kokkos::DefaultExecutionSpace::concurrency() > 1) &&
+        (ExecSpace::concurrency() > 1)) {
+      ASSERT_TRUE(expected_result < value);
+    } else if ((Kokkos::DefaultExecutionSpace::concurrency() > 1) ||
+               (ExecSpace::concurrency() > 1)) {
+      ASSERT_TRUE(expected_result <= value);
+    } else {
+      ASSERT_EQ(expected_result, value);
     }
   }
 
-  template< class ... Args >
-  static void AddLambdaRange( void*, Args... args ) {
-    AddReturnArgument( args..., KOKKOS_LAMBDA ( const int & i, double & lsum ) {
-      lsum += i;
-    });
+  template <class... Args>
+  static void AddLambdaRange(void*, Args... args) {
+    AddReturnArgument(
+        args..., KOKKOS_LAMBDA(const int& i, double& lsum) { lsum += i; });
   }
 
-  template< class ... Args >
-  static void AddLambdaTeam( void*, Args... args ) {
-    AddReturnArgument( args..., KOKKOS_LAMBDA ( const Kokkos::TeamPolicy<>::member_type & team, double & update ) {
-      update += 1.0 / team.team_size() * team.league_rank();
-    });
+  template <class... Args>
+  static void AddLambdaTeam(void*, Args... args) {
+    AddReturnArgument(
+        args..., KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team,
+                               double& update) {
+          update += 1.0 / team.team_size() * team.league_rank();
+        });
   }
 
-  template< class ... Args >
-  static void AddLambdaRange( Kokkos::InvalidType, Args... args ) {}
+  template <class... Args>
+  static void AddLambdaRange(Kokkos::InvalidType, Args... args) {}
 
-  template< class ... Args >
-  static void AddLambdaTeam( Kokkos::InvalidType, Args... args ) {}
+  template <class... Args>
+  static void AddLambdaTeam(Kokkos::InvalidType, Args... args) {}
 
-  template< int ISTEAM, class ... Args >
-  static void AddFunctor( Args... args ) {
-    Kokkos::View< double > result_view( "FunctorView" );
-    auto h_r = Kokkos::create_mirror_view( result_view );
-    Test::ReduceCombinatorical::FunctorScalar< ISTEAM > functor( result_view );
+  template <int ISTEAM, class... Args>
+  static void AddFunctor(Args... args) {
+    Kokkos::View<double> result_view("FunctorView");
+    auto h_r = Kokkos::create_mirror_view(result_view);
+    Test::ReduceCombinatorical::FunctorScalar<ISTEAM> functor(result_view);
     double expected_result = 1000.0 * 999.0 / 2.0;
 
-    AddReturnArgument( args..., functor );
-    AddReturnArgument( args..., Test::ReduceCombinatorical::FunctorScalar< ISTEAM >( result_view ) );
-    AddReturnArgument( args..., Test::ReduceCombinatorical::FunctorScalarInit< ISTEAM >( result_view ) );
-    AddReturnArgument( args..., Test::ReduceCombinatorical::FunctorScalarJoin< ISTEAM >( result_view ) );
-    AddReturnArgument( args..., Test::ReduceCombinatorical::FunctorScalarJoinInit< ISTEAM >( result_view ) );
+    AddReturnArgument(args..., functor);
+    AddReturnArgument(
+        args...,
+        Test::ReduceCombinatorical::FunctorScalar<ISTEAM>(result_view));
+    AddReturnArgument(
+        args...,
+        Test::ReduceCombinatorical::FunctorScalarInit<ISTEAM>(result_view));
+    AddReturnArgument(
+        args...,
+        Test::ReduceCombinatorical::FunctorScalarJoin<ISTEAM>(result_view));
+    AddReturnArgument(
+        args...,
+        Test::ReduceCombinatorical::FunctorScalarJoinInit<ISTEAM>(result_view));
 
     h_r() = 0;
-    Kokkos::deep_copy( result_view, h_r );
-    CallParallelReduce( args..., Test::ReduceCombinatorical::FunctorScalarFinal< ISTEAM >( result_view ) );
+    Kokkos::deep_copy(result_view, h_r);
+    CallParallelReduce(
+        args...,
+        Test::ReduceCombinatorical::FunctorScalarFinal<ISTEAM>(result_view));
     Kokkos::fence();
-    Kokkos::deep_copy( h_r, result_view );
-    ASSERT_EQ( expected_result, h_r() );
+    Kokkos::deep_copy(h_r, result_view);
+    ASSERT_EQ(expected_result, h_r());
 
     h_r() = 0;
-    Kokkos::deep_copy( result_view, h_r );
-    CallParallelReduce( args..., Test::ReduceCombinatorical::FunctorScalarJoinFinal< ISTEAM >( result_view ) );
+    Kokkos::deep_copy(result_view, h_r);
+    CallParallelReduce(
+        args..., Test::ReduceCombinatorical::FunctorScalarJoinFinal<ISTEAM>(
+                     result_view));
     Kokkos::fence();
-    Kokkos::deep_copy( h_r, result_view );
-    ASSERT_EQ( expected_result, h_r() );
+    Kokkos::deep_copy(h_r, result_view);
+    ASSERT_EQ(expected_result, h_r());
 
     h_r() = 0;
-    Kokkos::deep_copy( result_view, h_r );
-    CallParallelReduce( args..., Test::ReduceCombinatorical::FunctorScalarJoinFinalInit< ISTEAM >( result_view ) );
+    Kokkos::deep_copy(result_view, h_r);
+    CallParallelReduce(
+        args..., Test::ReduceCombinatorical::FunctorScalarJoinFinalInit<ISTEAM>(
+                     result_view));
     Kokkos::fence();
-    Kokkos::deep_copy( h_r, result_view );
-    ASSERT_EQ( expected_result, h_r() );
+    Kokkos::deep_copy(h_r, result_view);
+    ASSERT_EQ(expected_result, h_r());
   }
 
-  template< class ... Args >
-  static void AddFunctorLambdaRange( Args... args ) {
-    AddFunctor< 0, Args... >( args... );
+  template <class... Args>
+  static void AddFunctorLambdaRange(Args... args) {
+    AddFunctor<0, Args...>(args...);
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-    AddLambdaRange( typename std::conditional< std::is_same<ExecSpace, Kokkos::DefaultExecutionSpace>::value, void*, Kokkos::InvalidType >::type(), args... );
+    AddLambdaRange(
+        typename std::conditional<
+            std::is_same<ExecSpace, Kokkos::DefaultExecutionSpace>::value,
+            void*, Kokkos::InvalidType>::type(),
+        args...);
 #endif
   }
 
-  template< class ... Args >
-  static void AddFunctorLambdaTeam( Args... args ) {
-    AddFunctor< 1, Args... >( args... );
+  template <class... Args>
+  static void AddFunctorLambdaTeam(Args... args) {
+    AddFunctor<1, Args...>(args...);
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-    AddLambdaTeam( typename std::conditional< std::is_same<ExecSpace, Kokkos::DefaultExecutionSpace>::value, void*, Kokkos::InvalidType >::type(), args... );
+    AddLambdaTeam(
+        typename std::conditional<
+            std::is_same<ExecSpace, Kokkos::DefaultExecutionSpace>::value,
+            void*, Kokkos::InvalidType>::type(),
+        args...);
 #endif
   }
 
-  template< class ... Args >
-  static void AddPolicy_1( Args... args ) {
+  template <class... Args>
+  static void AddPolicy_1(Args... args) {
     int N = 1000;
-    Kokkos::RangePolicy< ExecSpace > policy( 0, N );
+    Kokkos::RangePolicy<ExecSpace> policy(0, N);
 
-    AddFunctorLambdaRange( args..., 1000 );
-    AddFunctorLambdaRange( args..., N );
-    AddFunctorLambdaRange( args..., policy );
+    AddFunctorLambdaRange(args..., 1000);
+    AddFunctorLambdaRange(args..., N);
+    AddFunctorLambdaRange(args..., policy);
   }
 
-  template< class ... Args >
-  static void AddPolicy_2( Args... args ) {
+  template <class... Args>
+  static void AddPolicy_2(Args... args) {
     int N = 1000;
-    Kokkos::RangePolicy< ExecSpace > policy( 0, N );
-
-    AddFunctorLambdaRange( args..., Kokkos::RangePolicy< ExecSpace >( 0, N ) );
-    AddFunctorLambdaRange( args..., Kokkos::RangePolicy< ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >( 0, N ) );
-    AddFunctorLambdaRange( args..., Kokkos::RangePolicy< ExecSpace, Kokkos::Schedule<Kokkos::Static> >( 0, N ).set_chunk_size( 10 ) );
-    AddFunctorLambdaRange( args..., Kokkos::RangePolicy< ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >( 0, N ).set_chunk_size( 10 ) );
-
-  }
-
-  template< class ... Args >
-  static void AddPolicy_3( Args... args ) {
+    Kokkos::RangePolicy<ExecSpace> policy(0, N);
+
+    AddFunctorLambdaRange(args..., Kokkos::RangePolicy<ExecSpace>(0, N));
+    AddFunctorLambdaRange(
+        args...,
+        Kokkos::RangePolicy<ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >(0,
+                                                                           N));
+    AddFunctorLambdaRange(
+        args...,
+        Kokkos::RangePolicy<ExecSpace, Kokkos::Schedule<Kokkos::Static> >(0, N)
+            .set_chunk_size(10));
+    AddFunctorLambdaRange(
+        args...,
+        Kokkos::RangePolicy<ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >(0, N)
+            .set_chunk_size(10));
+  }
+
+  template <class... Args>
+  static void AddPolicy_3(Args... args) {
     int N = 1000;
-    Kokkos::RangePolicy< ExecSpace > policy( 0, N );
-
-    AddFunctorLambdaTeam( args..., Kokkos::TeamPolicy< ExecSpace >( N, Kokkos::AUTO ) );
-    AddFunctorLambdaTeam( args..., Kokkos::TeamPolicy< ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >( N, Kokkos::AUTO ) );
-    AddFunctorLambdaTeam( args..., Kokkos::TeamPolicy< ExecSpace, Kokkos::Schedule<Kokkos::Static> >( N, Kokkos::AUTO ).set_chunk_size( 10 ) );
-    AddFunctorLambdaTeam( args..., Kokkos::TeamPolicy< ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >( N, Kokkos::AUTO ).set_chunk_size( 10 ) );
-  }
-
-  static void execute_a1() {
-    AddPolicy_1();
-  }
+    Kokkos::RangePolicy<ExecSpace> policy(0, N);
+
+    AddFunctorLambdaTeam(args...,
+                         Kokkos::TeamPolicy<ExecSpace>(N, Kokkos::AUTO));
+    AddFunctorLambdaTeam(
+        args...,
+        Kokkos::TeamPolicy<ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >(
+            N, Kokkos::AUTO));
+    AddFunctorLambdaTeam(
+        args...,
+        Kokkos::TeamPolicy<ExecSpace, Kokkos::Schedule<Kokkos::Static> >(
+            N, Kokkos::AUTO)
+            .set_chunk_size(10));
+    AddFunctorLambdaTeam(
+        args...,
+        Kokkos::TeamPolicy<ExecSpace, Kokkos::Schedule<Kokkos::Dynamic> >(
+            N, Kokkos::AUTO)
+            .set_chunk_size(10));
+  }
+
+  static void execute_a1() { AddPolicy_1(); }
 
   static void execute_b1() {
-    std::string s( "Std::String" );
-    AddPolicy_1( s.c_str() );
-    AddPolicy_1( "Char Constant" );
+    std::string s("Std::String");
+    AddPolicy_1(s.c_str());
+    AddPolicy_1("Char Constant");
   }
 
   static void execute_c1() {
-    std::string s( "Std::String" );
-    AddPolicy_1( s );
+    std::string s("Std::String");
+    AddPolicy_1(s);
   }
 
-  static void execute_a2() {
-    AddPolicy_2();
-  }
+  static void execute_a2() { AddPolicy_2(); }
 
   static void execute_b2() {
-    std::string s( "Std::String" );
-    AddPolicy_2( s.c_str() );
-    AddPolicy_2( "Char Constant" );
+    std::string s("Std::String");
+    AddPolicy_2(s.c_str());
+    AddPolicy_2("Char Constant");
   }
 
   static void execute_c2() {
-    std::string s( "Std::String" );
-    AddPolicy_2( s );
+    std::string s("Std::String");
+    AddPolicy_2(s);
   }
 
-  static void execute_a3() {
-    AddPolicy_1();
-  }
+  static void execute_a3() { AddPolicy_1(); }
 
   static void execute_b3() {
-    std::string s( "Std::String" );
-    AddPolicy_1( s.c_str() );
-    AddPolicy_1( "Char Constant" );
+    std::string s("Std::String");
+    AddPolicy_1(s.c_str());
+    AddPolicy_1("Char Constant");
   }
 
   static void execute_c3() {
-    std::string s( "Std::String" );
-    AddPolicy_1( s );
+    std::string s("Std::String");
+    AddPolicy_1(s);
   }
-
 };
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReduceDeviceView.hpp b/lib/kokkos/core/unit_test/TestReduceDeviceView.hpp
index d55c5449bcf1ff844dcb94bb2f6e39f068a63cee..d0562a2aa0b67582d62807c3740b90dd951d0e38 100644
--- a/lib/kokkos/core/unit_test/TestReduceDeviceView.hpp
+++ b/lib/kokkos/core/unit_test/TestReduceDeviceView.hpp
@@ -1,131 +1,133 @@
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 
 namespace Test {
 namespace {
 
 struct TestIsAsynchFunctor {
-  Kokkos::View<double,TEST_EXECSPACE> atomic_test;
-  TestIsAsynchFunctor(Kokkos::View<double,TEST_EXECSPACE> atomic_test_):atomic_test(atomic_test_){}
+  Kokkos::View<double, TEST_EXECSPACE> atomic_test;
+  TestIsAsynchFunctor(Kokkos::View<double, TEST_EXECSPACE> atomic_test_)
+      : atomic_test(atomic_test_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(const int) const {
-    Kokkos::atomic_add(&atomic_test(),1.0);
-  }
+  void operator()(const int) const { Kokkos::atomic_add(&atomic_test(), 1.0); }
 };
 
-template<class PolicyType, class ReduceFunctor>
-void test_reduce_device_view(int64_t N, PolicyType policy, ReduceFunctor functor) {
-
-     using ExecSpace = TEST_EXECSPACE;
-     
-     Kokkos::View<int64_t,TEST_EXECSPACE> result("Result");
-     Kokkos::View<double,TEST_EXECSPACE> atomic_test("Atomic");
-     int64_t reducer_result, view_result, scalar_result;
-
-     
-     Kokkos::Timer timer;     
-
-     // Establish whether execspace is asynchronous
-     Kokkos::parallel_for("Test::ReduceDeviceView::TestIsAsynch",Kokkos::RangePolicy<TEST_EXECSPACE>(0,1000000),
-       TestIsAsynchFunctor(atomic_test));
-     double time0 = timer.seconds();
-     timer.reset();
-     typename ExecSpace::execution_space().fence();
-     double time_fence0 = timer.seconds(); 
-     Kokkos::deep_copy(result,0);
-     timer.reset();
-     bool is_async = time0<time_fence0;
-
-     // Test Reducer 
-
-     Kokkos::parallel_reduce("Test::ReduceDeviceView::TestReducer",policy, functor, Kokkos::Sum<int64_t,TEST_EXECSPACE>(result));
-     double time1 = timer.seconds();
-     // Check whether it was asyncronous
-     timer.reset();
-     typename ExecSpace::execution_space().fence();
-     double time_fence1 = timer.seconds();    
-     Kokkos::deep_copy(reducer_result,result);    
-     Kokkos::deep_copy(result,0);
-     ASSERT_EQ(N,reducer_result); 
-     timer.reset();
-     
-     
-     // Test View 
-     Kokkos::parallel_reduce("Test::ReduceDeviceView::TestView",policy, functor, result);
-     double time2 = timer.seconds();
-     // Check whether it was asyncronous
-     timer.reset();
-     typename ExecSpace::execution_space().fence();
-     double time_fence2 = timer.seconds();    
-     Kokkos::deep_copy(view_result,result);    
-     Kokkos::deep_copy(result,0);
-     ASSERT_EQ(N,view_result); 
-     timer.reset();
-     
-     
-     // Test Scalar
-     Kokkos::parallel_reduce("Test::ReduceDeviceView::TestScalar",policy, functor, scalar_result);
-     double time3 = timer.seconds();
-
-     // Check whether it was asyncronous
-     timer.reset();
-     typename ExecSpace::execution_space().fence();
-     double time_fence3 = timer.seconds();
-
-     ASSERT_EQ(N,scalar_result); 
-     if(is_async) {
-       ASSERT_TRUE(time1<time_fence1);
-     }
-     if(is_async) {
-       ASSERT_TRUE(time2<time_fence2);
-       ASSERT_TRUE(time3>time_fence3);
-     }
+template <class PolicyType, class ReduceFunctor>
+void test_reduce_device_view(int64_t N, PolicyType policy,
+                             ReduceFunctor functor) {
+  using ExecSpace = TEST_EXECSPACE;
+
+  Kokkos::View<int64_t, TEST_EXECSPACE> result("Result");
+  Kokkos::View<double, TEST_EXECSPACE> atomic_test("Atomic");
+  int64_t reducer_result, view_result, scalar_result;
+
+  Kokkos::Timer timer;
+
+  // Establish whether execspace is asynchronous
+  Kokkos::parallel_for("Test::ReduceDeviceView::TestIsAsynch",
+                       Kokkos::RangePolicy<TEST_EXECSPACE>(0, 1000000),
+                       TestIsAsynchFunctor(atomic_test));
+  double time0 = timer.seconds();
+  timer.reset();
+  typename ExecSpace::execution_space().fence();
+  double time_fence0 = timer.seconds();
+  Kokkos::deep_copy(result, 0);
+  timer.reset();
+  bool is_async = time0 < time_fence0;
+
+  // Test Reducer
+
+  Kokkos::parallel_reduce("Test::ReduceDeviceView::TestReducer", policy,
+                          functor,
+                          Kokkos::Sum<int64_t, TEST_EXECSPACE>(result));
+  double time1 = timer.seconds();
+  // Check whether it was asyncronous
+  timer.reset();
+  typename ExecSpace::execution_space().fence();
+  double time_fence1 = timer.seconds();
+  Kokkos::deep_copy(reducer_result, result);
+  Kokkos::deep_copy(result, 0);
+  ASSERT_EQ(N, reducer_result);
+  timer.reset();
+
+  // Test View
+  Kokkos::parallel_reduce("Test::ReduceDeviceView::TestView", policy, functor,
+                          result);
+  double time2 = timer.seconds();
+  // Check whether it was asyncronous
+  timer.reset();
+  typename ExecSpace::execution_space().fence();
+  double time_fence2 = timer.seconds();
+  Kokkos::deep_copy(view_result, result);
+  Kokkos::deep_copy(result, 0);
+  ASSERT_EQ(N, view_result);
+  timer.reset();
+
+  // Test Scalar
+  Kokkos::parallel_reduce("Test::ReduceDeviceView::TestScalar", policy, functor,
+                          scalar_result);
+  double time3 = timer.seconds();
+
+  // Check whether it was asyncronous
+  timer.reset();
+  typename ExecSpace::execution_space().fence();
+  double time_fence3 = timer.seconds();
+
+  ASSERT_EQ(N, scalar_result);
+  if (is_async) {
+    ASSERT_TRUE(time1 < time_fence1);
+  }
+  if (is_async) {
+    ASSERT_TRUE(time2 < time_fence2);
+    ASSERT_TRUE(time3 > time_fence3);
   }
+}
 
 struct RangePolicyFunctor {
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int, int64_t& lsum) const {
-    lsum += 1;
-  }
+  void operator()(const int, int64_t& lsum) const { lsum += 1; }
 };
 
 struct MDRangePolicyFunctor {
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int, const int, const int, int64_t& lsum) const {
+  void operator()(const int, const int, const int, int64_t& lsum) const {
     lsum += 1;
   }
 };
 
 struct TeamPolicyFunctor {
   int M;
-  TeamPolicyFunctor(int M_):M(M_){}
+  TeamPolicyFunctor(int M_) : M(M_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type& team, int64_t& lsum) const {
-    for(int i=team.team_rank(); i<M; i+=team.team_size())
-      lsum += 1;
+  void operator()(const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type& team,
+                  int64_t& lsum) const {
+    for (int i = team.team_rank(); i < M; i += team.team_size()) lsum += 1;
   }
 };
 
-} // namespace
+}  // namespace
 
-TEST_F( TEST_CATEGORY, reduce_device_view_range_policy )
-{
-  int N=1000*1024*1024;
-  test_reduce_device_view(N,Kokkos::RangePolicy<TEST_EXECSPACE>(0,N),RangePolicyFunctor());
+TEST(TEST_CATEGORY, reduce_device_view_range_policy) {
+  int N = 1000 * 1024 * 1024;
+  test_reduce_device_view(N, Kokkos::RangePolicy<TEST_EXECSPACE>(0, N),
+                          RangePolicyFunctor());
 }
 
-TEST_F( TEST_CATEGORY, reduce_device_view_mdrange_policy )
-{
-  int N=1000*1024*1024;
-  test_reduce_device_view(N,Kokkos::MDRangePolicy<TEST_EXECSPACE,Kokkos::Rank<3>>({0,0,0},{1000,1024,1024}),MDRangePolicyFunctor());
+TEST(TEST_CATEGORY, reduce_device_view_mdrange_policy) {
+  int N = 1000 * 1024 * 1024;
+  test_reduce_device_view(
+      N,
+      Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<3>>(
+          {0, 0, 0}, {1000, 1024, 1024}),
+      MDRangePolicyFunctor());
 }
 
-TEST_F( TEST_CATEGORY, reduce_device_view_team_policy )
-{
-  int N=1000*1024*1024;
-  test_reduce_device_view(N,Kokkos::TeamPolicy<TEST_EXECSPACE>(1000*1024,Kokkos::AUTO),TeamPolicyFunctor(1024));
+TEST(TEST_CATEGORY, reduce_device_view_team_policy) {
+  int N = 1000 * 1024 * 1024;
+  test_reduce_device_view(
+      N, Kokkos::TeamPolicy<TEST_EXECSPACE>(1000 * 1024, Kokkos::AUTO),
+      TeamPolicyFunctor(1024));
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReducers.hpp b/lib/kokkos/core/unit_test/TestReducers.hpp
index 1d775744123e70f895d4598c733fae8fd6ca0450..04b4bd373f7a9416b3cd838b819a912c6487fb6d 100644
--- a/lib/kokkos/core/unit_test/TestReducers.hpp
+++ b/lib/kokkos/core/unit_test/TestReducers.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -48,451 +49,469 @@
 
 #include <Kokkos_Core.hpp>
 
-
 //--------------------------------------------------------------------------
 
 namespace Test {
 
 struct ReducerTag {};
 
-template< class Scalar, class ExecSpace = Kokkos::DefaultExecutionSpace >
+template <class Scalar, class ExecSpace = Kokkos::DefaultExecutionSpace>
 struct TestReducers {
   struct SumFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      value += values( i );
-    }
+    void operator()(const int& i, Scalar& value) const { value += values(i); }
   };
 
   struct ProdFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      value *= values( i );
-    }
+    void operator()(const int& i, Scalar& value) const { value *= values(i); }
   };
 
   struct MinFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      if ( values( i ) < value ) value = values( i );
+    void operator()(const int& i, Scalar& value) const {
+      if (values(i) < value) value = values(i);
     }
   };
 
   struct MaxFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      if ( values( i ) > value ) value = values( i );
+    void operator()(const int& i, Scalar& value) const {
+      if (values(i) > value) value = values(i);
     }
   };
 
   struct MinLocFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, typename Kokkos::MinLoc< Scalar, int >::value_type & value ) const {
-      if ( values( i ) < value.val ) {
-        value.val = values( i );
+    void operator()(
+        const int& i,
+        typename Kokkos::MinLoc<Scalar, int>::value_type& value) const {
+      if (values(i) < value.val) {
+        value.val = values(i);
         value.loc = i;
       }
     }
   };
 
   struct MaxLocFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, typename Kokkos::MaxLoc< Scalar, int >::value_type & value ) const {
-      if ( values( i ) > value.val ) {
-        value.val = values( i );
+    void operator()(
+        const int& i,
+        typename Kokkos::MaxLoc<Scalar, int>::value_type& value) const {
+      if (values(i) > value.val) {
+        value.val = values(i);
         value.loc = i;
       }
     }
   };
 
   struct MinMaxLocFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, typename Kokkos::MinMaxLoc< Scalar, int >::value_type & value ) const {
-      if ( values( i ) > value.max_val ) {
-        value.max_val = values( i );
+    void operator()(
+        const int& i,
+        typename Kokkos::MinMaxLoc<Scalar, int>::value_type& value) const {
+      if (values(i) > value.max_val) {
+        value.max_val = values(i);
         value.max_loc = i;
       }
 
-      if ( values( i ) < value.min_val ) {
-        value.min_val = values( i );
+      if (values(i) < value.min_val) {
+        value.min_val = values(i);
         value.min_loc = i;
       }
     }
   };
 
   struct BAndFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      value = value & values( i );
+    void operator()(const int& i, Scalar& value) const {
+      value = value & values(i);
     }
   };
 
   struct BOrFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      value = value | values( i );
+    void operator()(const int& i, Scalar& value) const {
+      value = value | values(i);
     }
   };
 
   struct LAndFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      value = value && values( i );
+    void operator()(const int& i, Scalar& value) const {
+      value = value && values(i);
     }
   };
 
   struct LOrFunctor {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int & i, Scalar & value ) const {
-      value = value || values( i );
+    void operator()(const int& i, Scalar& value) const {
+      value = value || values(i);
     }
   };
 
   struct SumFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      value += values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      value += values(i);
     }
   };
 
   struct ProdFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      value *= values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      value *= values(i);
     }
   };
 
   struct MinFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      if ( values( i ) < value ) value = values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      if (values(i) < value) value = values(i);
     }
   };
 
   struct MaxFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      if ( values( i ) > value ) value = values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      if (values(i) > value) value = values(i);
     }
   };
 
   struct MinLocFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, typename Kokkos::MinLoc< Scalar, int >::value_type & value ) const {
-      if ( values( i ) < value.val ) {
-        value.val = values( i );
+    void operator()(
+        const ReducerTag, const int& i,
+        typename Kokkos::MinLoc<Scalar, int>::value_type& value) const {
+      if (values(i) < value.val) {
+        value.val = values(i);
         value.loc = i;
       }
     }
   };
 
   struct MaxLocFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, typename Kokkos::MaxLoc< Scalar, int >::value_type & value ) const {
-      if ( values( i ) > value.val ) {
-        value.val = values( i );
+    void operator()(
+        const ReducerTag, const int& i,
+        typename Kokkos::MaxLoc<Scalar, int>::value_type& value) const {
+      if (values(i) > value.val) {
+        value.val = values(i);
         value.loc = i;
       }
     }
   };
 
   struct MinMaxLocFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, typename Kokkos::MinMaxLoc< Scalar, int >::value_type & value ) const {
-      if ( values( i ) > value.max_val ) {
-        value.max_val = values( i );
+    void operator()(
+        const ReducerTag, const int& i,
+        typename Kokkos::MinMaxLoc<Scalar, int>::value_type& value) const {
+      if (values(i) > value.max_val) {
+        value.max_val = values(i);
         value.max_loc = i;
       }
 
-      if ( values( i ) < value.min_val ) {
-        value.min_val = values( i );
+      if (values(i) < value.min_val) {
+        value.min_val = values(i);
         value.min_loc = i;
       }
     }
   };
 
   struct BAndFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      value = value & values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      value = value & values(i);
     }
   };
 
   struct BOrFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      value = value | values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      value = value | values(i);
     }
   };
 
   struct LAndFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      value = value && values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      value = value && values(i);
     }
   };
 
   struct LOrFunctorTag {
-    Kokkos::View< const Scalar*, ExecSpace > values;
+    Kokkos::View<const Scalar*, ExecSpace> values;
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const ReducerTag, const int & i, Scalar & value ) const {
-      value = value || values( i );
+    void operator()(const ReducerTag, const int& i, Scalar& value) const {
+      value = value || values(i);
     }
   };
-  static void test_sum( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
+  static void test_sum(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
     Scalar reference_sum = 0;
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 100 );
-      reference_sum += h_values( i );
+    for (int i = 0; i < N; i++) {
+      h_values(i) = (Scalar)(rand() % 100);
+      reference_sum += h_values(i);
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     SumFunctor f;
     f.values = values;
     SumFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = 0;
+    Scalar init  = 0;
 
     {
       Scalar sum_scalar = init;
-      Kokkos::Sum< Scalar > reducer_scalar( sum_scalar );
-      
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( sum_scalar, reference_sum );
-     
+      Kokkos::Sum<Scalar> reducer_scalar(sum_scalar);
+
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(sum_scalar, reference_sum);
+
       sum_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( sum_scalar, reference_sum );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(sum_scalar, reference_sum);
 
       Scalar sum_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( sum_scalar_view, reference_sum );
+      ASSERT_EQ(sum_scalar_view, reference_sum);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace> sum_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> sum_view("View");
       sum_view() = init;
-      Kokkos::Sum< Scalar > reducer_view( sum_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::Sum<Scalar> reducer_view(sum_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar sum_view_scalar = sum_view();
-      ASSERT_EQ( sum_view_scalar, reference_sum );
+      ASSERT_EQ(sum_view_scalar, reference_sum);
 
       Scalar sum_view_view = reducer_view.reference();
-      ASSERT_EQ( sum_view_view, reference_sum );
+      ASSERT_EQ(sum_view_view, reference_sum);
     }
   }
 
-  static void test_prod( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
+  static void test_prod(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values         = Kokkos::create_mirror_view(values);
     Scalar reference_prod = 1;
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 4 + 1 );
-      reference_prod *= h_values( i );
+    for (int i = 0; i < N; i++) {
+      h_values(i) = (Scalar)(rand() % 4 + 1);
+      reference_prod *= h_values(i);
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     ProdFunctor f;
     f.values = values;
     ProdFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = 1;
+    Scalar init  = 1;
 
     {
       Scalar prod_scalar = init;
-      Kokkos::Prod< Scalar > reducer_scalar( prod_scalar );
-   
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( prod_scalar, reference_prod );
-      
+      Kokkos::Prod<Scalar> reducer_scalar(prod_scalar);
+
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(prod_scalar, reference_prod);
+
       prod_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( prod_scalar, reference_prod );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(prod_scalar, reference_prod);
 
       Scalar prod_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( prod_scalar_view, reference_prod );
+      ASSERT_EQ(prod_scalar_view, reference_prod);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace > prod_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> prod_view("View");
       prod_view() = init;
-      Kokkos::Prod< Scalar > reducer_view( prod_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::Prod<Scalar> reducer_view(prod_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar prod_view_scalar = prod_view();
-      ASSERT_EQ( prod_view_scalar, reference_prod );
+      ASSERT_EQ(prod_view_scalar, reference_prod);
 
       Scalar prod_view_view = reducer_view.reference();
-      ASSERT_EQ( prod_view_view, reference_prod );
+      ASSERT_EQ(prod_view_view, reference_prod);
     }
   }
 
-  static void test_min( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
-    Scalar reference_min = std::numeric_limits< Scalar >::max();
+  static void test_min(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_min = std::numeric_limits<Scalar>::max();
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 100000 );
+    for (int i = 0; i < N; i++) {
+      h_values(i) = (Scalar)(rand() % 100000);
 
-      if ( h_values( i ) < reference_min ) reference_min = h_values( i );
+      if (h_values(i) < reference_min) reference_min = h_values(i);
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     MinFunctor f;
     f.values = values;
     MinFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = std::numeric_limits< Scalar >::max();
+    Scalar init  = std::numeric_limits<Scalar>::max();
 
     {
       Scalar min_scalar = init;
-      Kokkos::Min< Scalar > reducer_scalar( min_scalar );
-     
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( min_scalar, reference_min );
+      Kokkos::Min<Scalar> reducer_scalar(min_scalar);
+
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(min_scalar, reference_min);
 
       min_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( min_scalar, reference_min );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(min_scalar, reference_min);
 
       Scalar min_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( min_scalar_view, reference_min );
+      ASSERT_EQ(min_scalar_view, reference_min);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace > min_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> min_view("View");
       min_view() = init;
-      Kokkos::Min< Scalar > reducer_view( min_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::Min<Scalar> reducer_view(min_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar min_view_scalar = min_view();
-      ASSERT_EQ( min_view_scalar, reference_min );
+      ASSERT_EQ(min_view_scalar, reference_min);
 
       Scalar min_view_view = reducer_view.reference();
-      ASSERT_EQ( min_view_view, reference_min );
+      ASSERT_EQ(min_view_view, reference_min);
     }
   }
 
-  static void test_max( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
-    Scalar reference_max = std::numeric_limits< Scalar >::min();
+  static void test_max(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_max = std::numeric_limits<Scalar>::min();
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 100000 + 1 );
+    for (int i = 0; i < N; i++) {
+      h_values(i) = (Scalar)(rand() % 100000 + 1);
 
-      if ( h_values( i ) > reference_max ) reference_max = h_values( i );
+      if (h_values(i) > reference_max) reference_max = h_values(i);
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     MaxFunctor f;
     f.values = values;
     MaxFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = std::numeric_limits< Scalar >::min();
+    Scalar init  = std::numeric_limits<Scalar>::min();
 
     {
       Scalar max_scalar = init;
-      Kokkos::Max< Scalar > reducer_scalar( max_scalar );
+      Kokkos::Max<Scalar> reducer_scalar(max_scalar);
 
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( max_scalar, reference_max );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(max_scalar, reference_max);
 
       max_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( max_scalar, reference_max );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(max_scalar, reference_max);
 
       Scalar max_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( max_scalar_view, reference_max );
+      ASSERT_EQ(max_scalar_view, reference_max);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace > max_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> max_view("View");
       max_view() = init;
-      Kokkos::Max< Scalar > reducer_view( max_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::Max<Scalar> reducer_view(max_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar max_view_scalar = max_view();
-      ASSERT_EQ( max_view_scalar, reference_max );
+      ASSERT_EQ(max_view_scalar, reference_max);
 
       Scalar max_view_view = reducer_view.reference();
-      ASSERT_EQ( max_view_view, reference_max );
+      ASSERT_EQ(max_view_view, reference_max);
     }
   }
 
-  static void test_minloc( int N ) {
-    typedef typename Kokkos::MinLoc< Scalar, int >::value_type value_type;
+  static void test_minloc(int N) {
+    typedef typename Kokkos::MinLoc<Scalar, int>::value_type value_type;
 
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
-    Scalar reference_min = std::numeric_limits< Scalar >::max();
-    int reference_loc = -1;
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_min = std::numeric_limits<Scalar>::max();
+    int reference_loc    = -1;
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 100000 + 2 );
+    for (int i = 0; i < N; i++) {
+      h_values(i) = (Scalar)(rand() % 100000 + 2);
 
-      if ( h_values( i ) < reference_min ) {
-        reference_min = h_values( i );
+      if (h_values(i) < reference_min) {
+        reference_min = h_values(i);
         reference_loc = i;
-      }
-      else if ( h_values( i ) == reference_min ) {
+      } else if (h_values(i) == reference_min) {
         // Make min unique.
-        h_values( i ) += Scalar(1);
+        h_values(i) += Scalar(1);
       }
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     MinLocFunctor f;
     f.values = values;
@@ -501,59 +520,61 @@ struct TestReducers {
 
     {
       value_type min_scalar;
-      Kokkos::MinLoc< Scalar, int > reducer_scalar( min_scalar );
+      Kokkos::MinLoc<Scalar, int> reducer_scalar(min_scalar);
 
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( min_scalar.val, reference_min );
-      ASSERT_EQ( min_scalar.loc, reference_loc );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(min_scalar.val, reference_min);
+      ASSERT_EQ(min_scalar.loc, reference_loc);
 
       min_scalar = value_type();
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( min_scalar.val, reference_min );
-      ASSERT_EQ( min_scalar.loc, reference_loc );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(min_scalar.val, reference_min);
+      ASSERT_EQ(min_scalar.loc, reference_loc);
 
       value_type min_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( min_scalar_view.val, reference_min );
-      ASSERT_EQ( min_scalar_view.loc, reference_loc );
+      ASSERT_EQ(min_scalar_view.val, reference_min);
+      ASSERT_EQ(min_scalar_view.loc, reference_loc);
     }
 
     {
-      Kokkos::View< value_type, Kokkos::HostSpace > min_view( "View" );
-      Kokkos::MinLoc< Scalar, int > reducer_view( min_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::View<value_type, Kokkos::HostSpace> min_view("View");
+      Kokkos::MinLoc<Scalar, int> reducer_view(min_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       value_type min_view_scalar = min_view();
-      ASSERT_EQ( min_view_scalar.val, reference_min );
-      ASSERT_EQ( min_view_scalar.loc, reference_loc );
+      ASSERT_EQ(min_view_scalar.val, reference_min);
+      ASSERT_EQ(min_view_scalar.loc, reference_loc);
 
       value_type min_view_view = reducer_view.reference();
-      ASSERT_EQ( min_view_view.val, reference_min );
-      ASSERT_EQ( min_view_view.loc, reference_loc );
+      ASSERT_EQ(min_view_view.val, reference_min);
+      ASSERT_EQ(min_view_view.loc, reference_loc);
     }
   }
 
-  static void test_maxloc( int N ) {
-    typedef typename Kokkos::MaxLoc< Scalar, int >::value_type value_type;
+  static void test_maxloc(int N) {
+    typedef typename Kokkos::MaxLoc<Scalar, int>::value_type value_type;
 
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
-    Scalar reference_max = std::numeric_limits< Scalar >::min();
-    int reference_loc = -1;
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_max = std::numeric_limits<Scalar>::min();
+    int reference_loc    = -1;
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 100000 + 2 );
+    for (int i = 0; i < N; i++) {
+      h_values(i) = (Scalar)(rand() % 100000 + 2);
 
-      if ( h_values( i ) > reference_max ) {
-        reference_max = h_values( i );
+      if (h_values(i) > reference_max) {
+        reference_max = h_values(i);
         reference_loc = i;
-      }
-      else if ( h_values( i ) == reference_max ) {
+      } else if (h_values(i) == reference_max) {
         // Make max unique.
-        h_values( i ) -= Scalar(1);
+        h_values(i) -= Scalar(1);
       }
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     MaxLocFunctor f;
     f.values = values;
@@ -562,370 +583,386 @@ struct TestReducers {
 
     {
       value_type max_scalar;
-      Kokkos::MaxLoc< Scalar, int > reducer_scalar( max_scalar );
+      Kokkos::MaxLoc<Scalar, int> reducer_scalar(max_scalar);
 
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( max_scalar.val, reference_max );
-      ASSERT_EQ( max_scalar.loc, reference_loc );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(max_scalar.val, reference_max);
+      ASSERT_EQ(max_scalar.loc, reference_loc);
 
       max_scalar = value_type();
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( max_scalar.val, reference_max );
-      ASSERT_EQ( max_scalar.loc, reference_loc );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(max_scalar.val, reference_max);
+      ASSERT_EQ(max_scalar.loc, reference_loc);
 
       value_type max_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( max_scalar_view.val, reference_max );
-      ASSERT_EQ( max_scalar_view.loc, reference_loc );
+      ASSERT_EQ(max_scalar_view.val, reference_max);
+      ASSERT_EQ(max_scalar_view.loc, reference_loc);
     }
 
     {
-      Kokkos::View< value_type, Kokkos::HostSpace > max_view( "View" );
-      Kokkos::MaxLoc< Scalar, int > reducer_view( max_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::View<value_type, Kokkos::HostSpace> max_view("View");
+      Kokkos::MaxLoc<Scalar, int> reducer_view(max_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       value_type max_view_scalar = max_view();
-      ASSERT_EQ( max_view_scalar.val, reference_max );
-      ASSERT_EQ( max_view_scalar.loc, reference_loc );
+      ASSERT_EQ(max_view_scalar.val, reference_max);
+      ASSERT_EQ(max_view_scalar.loc, reference_loc);
 
       value_type max_view_view = reducer_view.reference();
-      ASSERT_EQ( max_view_view.val, reference_max );
-      ASSERT_EQ( max_view_view.loc, reference_loc );
+      ASSERT_EQ(max_view_view.val, reference_max);
+      ASSERT_EQ(max_view_view.loc, reference_loc);
     }
   }
 
-  static void test_minmaxloc( int N ) {
-     typedef typename Kokkos::MinMaxLoc< Scalar, int >::value_type value_type;
-
-     Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-     auto h_values = Kokkos::create_mirror_view( values );
-     Scalar reference_max = std::numeric_limits< Scalar >::min();
-     Scalar reference_min = std::numeric_limits< Scalar >::max();
-     int reference_minloc = -1;
-     int reference_maxloc = -1;
-
-     for ( int i = 0; i < N; i++ ) {
-       h_values( i ) = (Scalar) ( rand() % 100000 + 2);
-     }
-
-     for ( int i = 0; i < N; i++ ) {
-       if ( h_values( i ) > reference_max ) {
-         reference_max = h_values( i );
-         reference_maxloc = i;
-       }
-       else if ( h_values( i ) == reference_max ) {
-         // Make max unique.
-         h_values( i ) -= Scalar(1);
-       }
-     }
-
-     for ( int i = 0; i < N; i++ ) {
-       if ( h_values( i ) < reference_min ) {
-         reference_min = h_values( i );
-         reference_minloc = i;
-       }
-       else if ( h_values( i ) == reference_min ) {
-         // Make min unique.
-         h_values( i ) += Scalar(1);
-       }
-     }
-
-     Kokkos::deep_copy( values, h_values );
-
-     MinMaxLocFunctor f;
-     f.values = values;
-     MinMaxLocFunctorTag f_tag;
-     f_tag.values = values;
-
-     {
-       value_type minmax_scalar;
-       Kokkos::MinMaxLoc< Scalar, int > reducer_scalar( minmax_scalar );
-
-       Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-       ASSERT_EQ( minmax_scalar.min_val, reference_min );
-
-       for ( int i = 0; i < N; i++ ) {
-         if ( ( i == minmax_scalar.min_loc ) && ( h_values( i ) == reference_min ) ) {
-           reference_minloc = i;
-         }
-       }
-
-       ASSERT_EQ( minmax_scalar.min_loc, reference_minloc );
-       ASSERT_EQ( minmax_scalar.max_val, reference_max );
-
-       for ( int i = 0; i < N; i++ ) {
-         if ( ( i == minmax_scalar.max_loc ) && ( h_values( i ) == reference_max ) ) {
-           reference_maxloc = i;
-         }
-       }
-
-       ASSERT_EQ( minmax_scalar.max_loc, reference_maxloc );
-
-       minmax_scalar = value_type();
-       Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-       ASSERT_EQ( minmax_scalar.min_val, reference_min );
-
-       for ( int i = 0; i < N; i++ ) {
-         if ( ( i == minmax_scalar.min_loc ) && ( h_values( i ) == reference_min ) ) {
-           reference_minloc = i;
-         }
-       }
-
-       ASSERT_EQ( minmax_scalar.min_loc, reference_minloc );
-       ASSERT_EQ( minmax_scalar.max_val, reference_max );
-
-       for ( int i = 0; i < N; i++ ) {
-         if ( ( i == minmax_scalar.max_loc ) && ( h_values( i ) == reference_max ) ) {
-           reference_maxloc = i;
-         }
-       }
-
-       ASSERT_EQ( minmax_scalar.max_loc, reference_maxloc );
-
-       value_type minmax_scalar_view = reducer_scalar.reference();
-       ASSERT_EQ( minmax_scalar_view.min_val, reference_min );
-       ASSERT_EQ( minmax_scalar_view.min_loc, reference_minloc );
-       ASSERT_EQ( minmax_scalar_view.max_val, reference_max );
-       ASSERT_EQ( minmax_scalar_view.max_loc, reference_maxloc );
-     }
-
-     {
-       Kokkos::View< value_type, Kokkos::HostSpace > minmax_view( "View" );
-       Kokkos::MinMaxLoc< Scalar, int > reducer_view( minmax_view );
-       Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
-       Kokkos::fence();
-
-       value_type minmax_view_scalar = minmax_view();
-       ASSERT_EQ( minmax_view_scalar.min_val, reference_min );
-       ASSERT_EQ( minmax_view_scalar.min_loc, reference_minloc );
-       ASSERT_EQ( minmax_view_scalar.max_val, reference_max );
-       ASSERT_EQ( minmax_view_scalar.max_loc, reference_maxloc );
-
-       value_type minmax_view_view = reducer_view.reference();
-       ASSERT_EQ( minmax_view_view.min_val, reference_min );
-       ASSERT_EQ( minmax_view_view.min_loc, reference_minloc );
-       ASSERT_EQ( minmax_view_view.max_val, reference_max );
-       ASSERT_EQ( minmax_view_view.max_loc, reference_maxloc );
-     }
-   }
-
-  static void test_BAnd( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
-    Scalar reference_band = Scalar() | ( ~Scalar() );
-
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 100000 + 1 );
-      reference_band = reference_band & h_values( i );
-    }
-    Kokkos::deep_copy( values, h_values );
+  static void test_minmaxloc(int N) {
+    typedef typename Kokkos::MinMaxLoc<Scalar, int>::value_type value_type;
+
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_max = std::numeric_limits<Scalar>::min();
+    Scalar reference_min = std::numeric_limits<Scalar>::max();
+    int reference_minloc = -1;
+    int reference_maxloc = -1;
+
+    for (int i = 0; i < N; i++) {
+      h_values(i) = (Scalar)(rand() % 100000 + 2);
+    }
+
+    for (int i = 0; i < N; i++) {
+      if (h_values(i) > reference_max) {
+        reference_max    = h_values(i);
+        reference_maxloc = i;
+      } else if (h_values(i) == reference_max) {
+        // Make max unique.
+        h_values(i) -= Scalar(1);
+      }
+    }
+
+    for (int i = 0; i < N; i++) {
+      if (h_values(i) < reference_min) {
+        reference_min    = h_values(i);
+        reference_minloc = i;
+      } else if (h_values(i) == reference_min) {
+        // Make min unique.
+        h_values(i) += Scalar(1);
+      }
+    }
+
+    Kokkos::deep_copy(values, h_values);
+
+    MinMaxLocFunctor f;
+    f.values = values;
+    MinMaxLocFunctorTag f_tag;
+    f_tag.values = values;
+
+    {
+      value_type minmax_scalar;
+      Kokkos::MinMaxLoc<Scalar, int> reducer_scalar(minmax_scalar);
+
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(minmax_scalar.min_val, reference_min);
+
+      for (int i = 0; i < N; i++) {
+        if ((i == minmax_scalar.min_loc) && (h_values(i) == reference_min)) {
+          reference_minloc = i;
+        }
+      }
+
+      ASSERT_EQ(minmax_scalar.min_loc, reference_minloc);
+      ASSERT_EQ(minmax_scalar.max_val, reference_max);
+
+      for (int i = 0; i < N; i++) {
+        if ((i == minmax_scalar.max_loc) && (h_values(i) == reference_max)) {
+          reference_maxloc = i;
+        }
+      }
+
+      ASSERT_EQ(minmax_scalar.max_loc, reference_maxloc);
+
+      minmax_scalar = value_type();
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(minmax_scalar.min_val, reference_min);
+
+      for (int i = 0; i < N; i++) {
+        if ((i == minmax_scalar.min_loc) && (h_values(i) == reference_min)) {
+          reference_minloc = i;
+        }
+      }
+
+      ASSERT_EQ(minmax_scalar.min_loc, reference_minloc);
+      ASSERT_EQ(minmax_scalar.max_val, reference_max);
+
+      for (int i = 0; i < N; i++) {
+        if ((i == minmax_scalar.max_loc) && (h_values(i) == reference_max)) {
+          reference_maxloc = i;
+        }
+      }
+
+      ASSERT_EQ(minmax_scalar.max_loc, reference_maxloc);
+
+      value_type minmax_scalar_view = reducer_scalar.reference();
+      ASSERT_EQ(minmax_scalar_view.min_val, reference_min);
+      ASSERT_EQ(minmax_scalar_view.min_loc, reference_minloc);
+      ASSERT_EQ(minmax_scalar_view.max_val, reference_max);
+      ASSERT_EQ(minmax_scalar_view.max_loc, reference_maxloc);
+    }
+
+    {
+      Kokkos::View<value_type, Kokkos::HostSpace> minmax_view("View");
+      Kokkos::MinMaxLoc<Scalar, int> reducer_view(minmax_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
+      Kokkos::fence();
+
+      value_type minmax_view_scalar = minmax_view();
+      ASSERT_EQ(minmax_view_scalar.min_val, reference_min);
+      ASSERT_EQ(minmax_view_scalar.min_loc, reference_minloc);
+      ASSERT_EQ(minmax_view_scalar.max_val, reference_max);
+      ASSERT_EQ(minmax_view_scalar.max_loc, reference_maxloc);
+
+      value_type minmax_view_view = reducer_view.reference();
+      ASSERT_EQ(minmax_view_view.min_val, reference_min);
+      ASSERT_EQ(minmax_view_view.min_loc, reference_minloc);
+      ASSERT_EQ(minmax_view_view.max_val, reference_max);
+      ASSERT_EQ(minmax_view_view.max_loc, reference_maxloc);
+    }
+  }
+
+  static void test_BAnd(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values         = Kokkos::create_mirror_view(values);
+    Scalar reference_band = Scalar() | (~Scalar());
+
+    for (int i = 0; i < N; i++) {
+      h_values(i)    = (Scalar)(rand() % 100000 + 1);
+      reference_band = reference_band & h_values(i);
+    }
+    Kokkos::deep_copy(values, h_values);
 
     BAndFunctor f;
     f.values = values;
     BAndFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = Scalar() | ( ~Scalar() );
+    Scalar init  = Scalar() | (~Scalar());
 
     {
       Scalar band_scalar = init;
-      Kokkos::BAnd< Scalar > reducer_scalar( band_scalar );
+      Kokkos::BAnd<Scalar> reducer_scalar(band_scalar);
 
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( band_scalar, reference_band );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(band_scalar, reference_band);
 
       band_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( band_scalar, reference_band );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(band_scalar, reference_band);
 
       Scalar band_scalar_view = reducer_scalar.reference();
 
-      ASSERT_EQ( band_scalar_view, reference_band );
+      ASSERT_EQ(band_scalar_view, reference_band);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace > band_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> band_view("View");
       band_view() = init;
-      Kokkos::BAnd< Scalar > reducer_view( band_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::BAnd<Scalar> reducer_view(band_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar band_view_scalar = band_view();
-      ASSERT_EQ( band_view_scalar, reference_band );
+      ASSERT_EQ(band_view_scalar, reference_band);
 
       Scalar band_view_view = reducer_view.reference();
-      ASSERT_EQ( band_view_view, reference_band );
+      ASSERT_EQ(band_view_view, reference_band);
     }
   }
 
-  static void test_BOr( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
-    Scalar reference_bor = Scalar() & ( ~Scalar() );
+  static void test_BOr(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_bor = Scalar() & (~Scalar());
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( ( rand() % 100000 + 1 ) * 2 );
-      reference_bor = reference_bor | h_values( i );
+    for (int i = 0; i < N; i++) {
+      h_values(i)   = (Scalar)((rand() % 100000 + 1) * 2);
+      reference_bor = reference_bor | h_values(i);
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     BOrFunctor f;
     f.values = values;
     BOrFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = Scalar() & ( ~Scalar() );
+    Scalar init  = Scalar() & (~Scalar());
 
     {
       Scalar bor_scalar = init;
-      Kokkos::BOr< Scalar > reducer_scalar( bor_scalar );
+      Kokkos::BOr<Scalar> reducer_scalar(bor_scalar);
 
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( bor_scalar, reference_bor );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(bor_scalar, reference_bor);
 
       bor_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( bor_scalar, reference_bor );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(bor_scalar, reference_bor);
 
       Scalar bor_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( bor_scalar_view, reference_bor );
+      ASSERT_EQ(bor_scalar_view, reference_bor);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace > bor_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> bor_view("View");
       bor_view() = init;
-      Kokkos::BOr< Scalar > reducer_view( bor_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::BOr<Scalar> reducer_view(bor_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar bor_view_scalar = bor_view();
-      ASSERT_EQ( bor_view_scalar, reference_bor );
+      ASSERT_EQ(bor_view_scalar, reference_bor);
 
       Scalar bor_view_view = reducer_view.reference();
-      ASSERT_EQ( bor_view_view, reference_bor );
+      ASSERT_EQ(bor_view_view, reference_bor);
     }
   }
 
-  static void test_LAnd( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
+  static void test_LAnd(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values         = Kokkos::create_mirror_view(values);
     Scalar reference_land = 1;
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 2 );
-      reference_land = reference_land && h_values( i );
+    for (int i = 0; i < N; i++) {
+      h_values(i)    = (Scalar)(rand() % 2);
+      reference_land = reference_land && h_values(i);
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     LAndFunctor f;
     f.values = values;
     LAndFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = 1;
+    Scalar init  = 1;
 
     {
       Scalar land_scalar = init;
-      Kokkos::LAnd< Scalar > reducer_scalar( land_scalar );
+      Kokkos::LAnd<Scalar> reducer_scalar(land_scalar);
 
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( land_scalar, reference_land );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(land_scalar, reference_land);
 
       land_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( land_scalar, reference_land );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(land_scalar, reference_land);
 
       Scalar land_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( land_scalar_view, reference_land );
+      ASSERT_EQ(land_scalar_view, reference_land);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace > land_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> land_view("View");
       land_view() = init;
-      Kokkos::LAnd< Scalar > reducer_view( land_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::LAnd<Scalar> reducer_view(land_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar land_view_scalar = land_view();
-      ASSERT_EQ( land_view_scalar, reference_land );
+      ASSERT_EQ(land_view_scalar, reference_land);
 
       Scalar land_view_view = reducer_view.reference();
-      ASSERT_EQ( land_view_view, reference_land );
+      ASSERT_EQ(land_view_view, reference_land);
     }
   }
 
-  static void test_LOr( int N ) {
-    Kokkos::View< Scalar*, ExecSpace > values( "Values", N );
-    auto h_values = Kokkos::create_mirror_view( values );
+  static void test_LOr(int N) {
+    Kokkos::View<Scalar*, ExecSpace> values("Values", N);
+    auto h_values        = Kokkos::create_mirror_view(values);
     Scalar reference_lor = 0;
 
-    for ( int i = 0; i < N; i++ ) {
-      h_values( i ) = (Scalar) ( rand() % 2 );
-      reference_lor = reference_lor || h_values( i );
+    for (int i = 0; i < N; i++) {
+      h_values(i)   = (Scalar)(rand() % 2);
+      reference_lor = reference_lor || h_values(i);
     }
-    Kokkos::deep_copy( values, h_values );
+    Kokkos::deep_copy(values, h_values);
 
     LOrFunctor f;
     f.values = values;
     LOrFunctorTag f_tag;
     f_tag.values = values;
-    Scalar init = 0;
+    Scalar init  = 0;
 
     {
       Scalar lor_scalar = init;
-      Kokkos::LOr< Scalar > reducer_scalar( lor_scalar );
+      Kokkos::LOr<Scalar> reducer_scalar(lor_scalar);
 
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_scalar );
-      ASSERT_EQ( lor_scalar, reference_lor );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_scalar);
+      ASSERT_EQ(lor_scalar, reference_lor);
 
       lor_scalar = init;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace , ReducerTag >( 0, N ), f_tag, reducer_scalar );
-      ASSERT_EQ( lor_scalar, reference_lor );
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, ReducerTag>(0, N),
+                              f_tag, reducer_scalar);
+      ASSERT_EQ(lor_scalar, reference_lor);
 
       Scalar lor_scalar_view = reducer_scalar.reference();
-      ASSERT_EQ( lor_scalar_view, reference_lor );
+      ASSERT_EQ(lor_scalar_view, reference_lor);
     }
 
     {
-      Kokkos::View< Scalar, Kokkos::HostSpace > lor_view( "View" );
+      Kokkos::View<Scalar, Kokkos::HostSpace> lor_view("View");
       lor_view() = init;
-      Kokkos::LOr< Scalar > reducer_view( lor_view );
-      Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, N ), f, reducer_view );
+      Kokkos::LOr<Scalar> reducer_view(lor_view);
+      Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, N), f,
+                              reducer_view);
       Kokkos::fence();
 
       Scalar lor_view_scalar = lor_view();
-      ASSERT_EQ( lor_view_scalar, reference_lor );
+      ASSERT_EQ(lor_view_scalar, reference_lor);
 
       Scalar lor_view_view = reducer_view.reference();
-      ASSERT_EQ( lor_view_view, reference_lor );
+      ASSERT_EQ(lor_view_view, reference_lor);
     }
   }
 
   static void execute_float() {
-    test_sum( 10001 );
-    test_prod( 35 );
-    test_min( 10003 );
-    test_minloc( 10003 );
-    test_max( 10007 );
-    test_maxloc( 10007 );
-    test_minmaxloc( 10007 );
+    test_sum(10001);
+    test_prod(35);
+    test_min(10003);
+    test_minloc(10003);
+    test_max(10007);
+    test_maxloc(10007);
+    test_minmaxloc(10007);
   }
 
   static void execute_integer() {
-    test_sum( 10001 );
-    test_prod( 35 );
-    test_min( 10003 );
-    test_minloc( 10003 );
-    test_max( 10007 );
-    test_maxloc( 10007 );
-    test_minmaxloc( 10007 );
-    test_BAnd( 35 );
-    test_BOr( 35 );
-    test_LAnd( 35 );
-    test_LOr( 35 );
+    test_sum(10001);
+    test_prod(35);
+    test_min(10003);
+    test_minloc(10003);
+    test_max(10007);
+    test_maxloc(10007);
+    test_minmaxloc(10007);
+    test_BAnd(35);
+    test_BOr(35);
+    test_LAnd(35);
+    test_LOr(35);
   }
 
   static void execute_basic() {
-    test_sum( 10001 );
-    test_prod( 35 );
+    test_sum(10001);
+    test_prod(35);
   }
 };
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReducers_a.hpp b/lib/kokkos/core/unit_test/TestReducers_a.hpp
index cfa2b626d1d383a184dc26caba5efecfeda238cc..4efc4f645064c7e01f501101ff9b42ca8e686309 100644
--- a/lib/kokkos/core/unit_test/TestReducers_a.hpp
+++ b/lib/kokkos/core/unit_test/TestReducers_a.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,9 +45,8 @@
 #include <TestReducers.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY, reducers_int )
-{
-  TestReducers< int, TEST_EXECSPACE >::execute_integer();
+TEST(TEST_CATEGORY, reducers_int) {
+  TestReducers<int, TEST_EXECSPACE>::execute_integer();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReducers_b.hpp b/lib/kokkos/core/unit_test/TestReducers_b.hpp
index 9f32f049bd576e7be92f03bc3a670af3d91d6bb3..57aa0f3b7661659acd04ccdb8fe171954e258eb9 100644
--- a/lib/kokkos/core/unit_test/TestReducers_b.hpp
+++ b/lib/kokkos/core/unit_test/TestReducers_b.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,8 +45,7 @@
 #include <TestReducers.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY, reducers_size_t )
-{
-  TestReducers< size_t, TEST_EXECSPACE >::execute_integer();
+TEST(TEST_CATEGORY, reducers_size_t) {
+  TestReducers<size_t, TEST_EXECSPACE>::execute_integer();
 }
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReducers_c.hpp b/lib/kokkos/core/unit_test/TestReducers_c.hpp
index 8248906c6a3327d2ed22046cb4b576fe00b41e2b..d1353b1f647e43c698adf994240be1086a9a5da3 100644
--- a/lib/kokkos/core/unit_test/TestReducers_c.hpp
+++ b/lib/kokkos/core/unit_test/TestReducers_c.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,8 +45,7 @@
 #include <TestReducers.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY, reducers_double )
-{
-  TestReducers< double, TEST_EXECSPACE >::execute_float();
+TEST(TEST_CATEGORY, reducers_double) {
+  TestReducers<double, TEST_EXECSPACE>::execute_float();
 }
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestReducers_d.hpp b/lib/kokkos/core/unit_test/TestReducers_d.hpp
index 33132092ff96683c7ad4e35156d290894b717602..2dc8ae5b5a459740e6e0421ad4f46ce9c0107160 100644
--- a/lib/kokkos/core/unit_test/TestReducers_d.hpp
+++ b/lib/kokkos/core/unit_test/TestReducers_d.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,10 +45,8 @@
 #include <TestReducers.hpp>
 
 namespace Test {
-TEST_F( TEST_CATEGORY, reducers_complex_double )
-{
-  TestReducers< Kokkos::complex<double>, TEST_EXECSPACE >::execute_basic();
+TEST(TEST_CATEGORY, reducers_complex_double) {
+  TestReducers<Kokkos::complex<double>, TEST_EXECSPACE>::execute_basic();
 }
 
-
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestResize.hpp b/lib/kokkos/core/unit_test/TestResize.hpp
index d62bc68b31d77583b16f4cf0dfce6394f5f099b8..14d1295538132ad83a31d8214fd75b9464c4f7e7 100644
--- a/lib/kokkos/core/unit_test/TestResize.hpp
+++ b/lib/kokkos/core/unit_test/TestResize.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -40,101 +41,361 @@
 // ************************************************************************
 //@HEADER
 */
-#ifndef TESTVIEWSUBVIEW_HPP_
-#define TESTVIEWSUBVIEW_HPP_
+#ifndef TESTRESIZE_HPP_
+#define TESTRESIZE_HPP_
 
 #include <gtest/gtest.h>
 #include <Kokkos_Core.hpp>
 
 namespace TestViewResize {
 
-template<class DeviceType>
-void testResize ()
-{
-  const int sizes[8] = {2, 3, 4, 5, 6, 7, 8, 9};
+struct Default {};
+struct WithoutInitializing {};
+
+template <typename View, typename... Args>
+inline void resize_dispatch(Default, View& v, Args&&... args) {
+  Kokkos::resize(v, std::forward<Args>(args)...);
+}
+
+template <typename View, typename... Args>
+inline void resize_dispatch(WithoutInitializing, View& v, Args&&... args) {
+  Kokkos::resize(Kokkos::WithoutInitializing, v, std::forward<Args>(args)...);
+}
+
+template <class DeviceType, class Tag = Default>
+void impl_testResize() {
+  const size_t sizes[8] = {2, 3, 4, 5, 6, 7, 8, 9};
 
   // Check #904 fix (no reallocation if dimensions didn't change).
   {
     typedef Kokkos::View<int*, DeviceType> view_type;
-    view_type view_1d ("view_1d", sizes[0]);
-    const int* oldPointer = view_1d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_1d, sizes[0]);
-    const int* newPointer = view_1d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_1d("view_1d", sizes[0]);
+    const int* oldPointer = view_1d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_1d, sizes[0]);
+    const int* newPointer = view_1d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  {
+    typedef Kokkos::View<int**, DeviceType> view_type;
+    view_type view_2d("view_2d", sizes[0], sizes[1]);
+    const int* oldPointer = view_2d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_2d, sizes[0], sizes[1]);
+    const int* newPointer = view_2d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  {
+    typedef Kokkos::View<int***, DeviceType> view_type;
+    view_type view_3d("view_3d", sizes[0], sizes[1], sizes[2]);
+    const int* oldPointer = view_3d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_3d, sizes[0], sizes[1], sizes[2]);
+    const int* newPointer = view_3d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  {
+    typedef Kokkos::View<int****, DeviceType> view_type;
+    view_type view_4d("view_4d", sizes[0], sizes[1], sizes[2], sizes[3]);
+    const int* oldPointer = view_4d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_4d, sizes[0], sizes[1], sizes[2], sizes[3]);
+    const int* newPointer = view_4d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  {
+    typedef Kokkos::View<int*****, DeviceType> view_type;
+    view_type view_5d("view_5d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4]);
+    const int* oldPointer = view_5d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_5d, sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4]);
+    const int* newPointer = view_5d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  {
+    typedef Kokkos::View<int******, DeviceType> view_type;
+    view_type view_6d("view_6d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4], sizes[5]);
+    const int* oldPointer = view_6d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_6d, sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4], sizes[5]);
+    const int* newPointer = view_6d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  {
+    typedef Kokkos::View<int*******, DeviceType> view_type;
+    view_type view_7d("view_7d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4], sizes[5], sizes[6]);
+    const int* oldPointer = view_7d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_7d, sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4], sizes[5], sizes[6]);
+    const int* newPointer = view_7d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  {
+    typedef Kokkos::View<int********, DeviceType> view_type;
+    view_type view_8d("view_8d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4], sizes[5], sizes[6], sizes[7]);
+    const int* oldPointer = view_8d.data();
+    EXPECT_TRUE(oldPointer != NULL);
+    resize_dispatch(Tag{}, view_8d, sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4], sizes[5], sizes[6], sizes[7]);
+    const int* newPointer = view_8d.data();
+    EXPECT_TRUE(oldPointer == newPointer);
+  }
+  // Resize without initialization: check if data preserved
+  {
+    typedef Kokkos::View<int*, DeviceType> view_type;
+    view_type view_1d("view_1d", sizes[0]);
+    typename view_type::HostMirror h_view_1d_old =
+        Kokkos::create_mirror(view_1d);
+    Kokkos::deep_copy(view_1d, 111);
+    Kokkos::deep_copy(h_view_1d_old, view_1d);
+    resize_dispatch(Tag{}, view_1d, 2 * sizes[0]);
+    EXPECT_TRUE(view_1d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_1d =
+        Kokkos::create_mirror_view(view_1d);
+    Kokkos::deep_copy(h_view_1d, view_1d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      if (h_view_1d(i0) != h_view_1d_old(i0)) {
+        test = false;
+        break;
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
   {
     typedef Kokkos::View<int**, DeviceType> view_type;
-    view_type view_2d ("view_2d", sizes[0], sizes[1]);
-    const int* oldPointer = view_2d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_2d, sizes[0], sizes[1]);
-    const int* newPointer = view_2d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_2d("view_2d", sizes[0], sizes[1]);
+    typename view_type::HostMirror h_view_2d_old =
+        Kokkos::create_mirror(view_2d);
+    Kokkos::deep_copy(view_2d, 222);
+    Kokkos::deep_copy(h_view_2d_old, view_2d);
+    resize_dispatch(Tag{}, view_2d, 2 * sizes[0], sizes[1]);
+    EXPECT_TRUE(view_2d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_2d =
+        Kokkos::create_mirror_view(view_2d);
+    Kokkos::deep_copy(h_view_2d, view_2d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      for (size_t i1 = 0; i1 < sizes[1]; ++i1) {
+        if (h_view_2d(i0, i1) != h_view_2d_old(i0, i1)) {
+          test = false;
+          break;
+        }
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
   {
     typedef Kokkos::View<int***, DeviceType> view_type;
-    view_type view_3d ("view_3d", sizes[0], sizes[1], sizes[2]);
-    const int* oldPointer = view_3d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_3d, sizes[0], sizes[1], sizes[2]);
-    const int* newPointer = view_3d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_3d("view_3d", sizes[0], sizes[1], sizes[2]);
+    typename view_type::HostMirror h_view_3d_old =
+        Kokkos::create_mirror(view_3d);
+    Kokkos::deep_copy(view_3d, 333);
+    Kokkos::deep_copy(h_view_3d_old, view_3d);
+    resize_dispatch(Tag{}, view_3d, 2 * sizes[0], sizes[1], sizes[2]);
+    EXPECT_TRUE(view_3d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_3d =
+        Kokkos::create_mirror_view(view_3d);
+    Kokkos::deep_copy(h_view_3d, view_3d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      for (size_t i1 = 0; i1 < sizes[1]; ++i1) {
+        for (size_t i2 = 0; i2 < sizes[2]; ++i2) {
+          if (h_view_3d(i0, i1, i2) != h_view_3d_old(i0, i1, i2)) {
+            test = false;
+            break;
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
   {
     typedef Kokkos::View<int****, DeviceType> view_type;
-    view_type view_4d ("view_4d", sizes[0], sizes[1], sizes[2], sizes[3]);
-    const int* oldPointer = view_4d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_4d, sizes[0], sizes[1], sizes[2], sizes[3]);
-    const int* newPointer = view_4d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_4d("view_4d", sizes[0], sizes[1], sizes[2], sizes[3]);
+    typename view_type::HostMirror h_view_4d_old =
+        Kokkos::create_mirror(view_4d);
+    Kokkos::deep_copy(view_4d, 444);
+    Kokkos::deep_copy(h_view_4d_old, view_4d);
+    resize_dispatch(Tag{}, view_4d, 2 * sizes[0], sizes[1], sizes[2], sizes[3]);
+    EXPECT_TRUE(view_4d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_4d =
+        Kokkos::create_mirror_view(view_4d);
+    Kokkos::deep_copy(h_view_4d, view_4d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      for (size_t i1 = 0; i1 < sizes[1]; ++i1) {
+        for (size_t i2 = 0; i2 < sizes[2]; ++i2) {
+          for (size_t i3 = 0; i3 < sizes[3]; ++i3) {
+            if (h_view_4d(i0, i1, i2, i3) != h_view_4d_old(i0, i1, i2, i3)) {
+              test = false;
+              break;
+            }
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
   {
     typedef Kokkos::View<int*****, DeviceType> view_type;
-    view_type view_5d ("view_5d", sizes[0], sizes[1], sizes[2], sizes[3],
-                       sizes[4]);
-    const int* oldPointer = view_5d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_5d, sizes[0], sizes[1], sizes[2], sizes[3], sizes[4]);
-    const int* newPointer = view_5d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_5d("view_5d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4]);
+    typename view_type::HostMirror h_view_5d_old =
+        Kokkos::create_mirror(view_5d);
+    Kokkos::deep_copy(view_5d, 555);
+    Kokkos::deep_copy(h_view_5d_old, view_5d);
+    resize_dispatch(Tag{}, view_5d, 2 * sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4]);
+    EXPECT_TRUE(view_5d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_5d =
+        Kokkos::create_mirror_view(view_5d);
+    Kokkos::deep_copy(h_view_5d, view_5d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      for (size_t i1 = 0; i1 < sizes[1]; ++i1) {
+        for (size_t i2 = 0; i2 < sizes[2]; ++i2) {
+          for (size_t i3 = 0; i3 < sizes[3]; ++i3) {
+            for (size_t i4 = 0; i4 < sizes[4]; ++i4) {
+              if (h_view_5d(i0, i1, i2, i3, i4) !=
+                  h_view_5d_old(i0, i1, i2, i3, i4)) {
+                test = false;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
   {
     typedef Kokkos::View<int******, DeviceType> view_type;
-    view_type view_6d ("view_6d", sizes[0], sizes[1], sizes[2], sizes[3],
-                       sizes[4], sizes[5]);
-    const int* oldPointer = view_6d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_6d, sizes[0], sizes[1], sizes[2], sizes[3], sizes[4],
-                    sizes[5]);
-    const int* newPointer = view_6d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_6d("view_6d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4], sizes[5]);
+    typename view_type::HostMirror h_view_6d_old =
+        Kokkos::create_mirror(view_6d);
+    Kokkos::deep_copy(view_6d, 666);
+    Kokkos::deep_copy(h_view_6d_old, view_6d);
+    resize_dispatch(Tag{}, view_6d, 2 * sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4], sizes[5]);
+    EXPECT_TRUE(view_6d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_6d =
+        Kokkos::create_mirror_view(view_6d);
+    Kokkos::deep_copy(h_view_6d, view_6d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      for (size_t i1 = 0; i1 < sizes[1]; ++i1) {
+        for (size_t i2 = 0; i2 < sizes[2]; ++i2) {
+          for (size_t i3 = 0; i3 < sizes[3]; ++i3) {
+            for (size_t i4 = 0; i4 < sizes[4]; ++i4) {
+              for (size_t i5 = 0; i5 < sizes[5]; ++i5) {
+                if (h_view_6d(i0, i1, i2, i3, i4, i5) !=
+                    h_view_6d_old(i0, i1, i2, i3, i4, i5)) {
+                  test = false;
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
   {
     typedef Kokkos::View<int*******, DeviceType> view_type;
-    view_type view_7d ("view_7d", sizes[0], sizes[1], sizes[2], sizes[3],
-                       sizes[4], sizes[5], sizes[6]);
-    const int* oldPointer = view_7d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_7d, sizes[0], sizes[1], sizes[2], sizes[3], sizes[4],
-                    sizes[5], sizes[6]);
-    const int* newPointer = view_7d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_7d("view_7d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4], sizes[5], sizes[6]);
+    typename view_type::HostMirror h_view_7d_old =
+        Kokkos::create_mirror(view_7d);
+    Kokkos::deep_copy(view_7d, 777);
+    Kokkos::deep_copy(h_view_7d_old, view_7d);
+    resize_dispatch(Tag{}, view_7d, 2 * sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4], sizes[5], sizes[6]);
+    EXPECT_TRUE(view_7d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_7d =
+        Kokkos::create_mirror_view(view_7d);
+    Kokkos::deep_copy(h_view_7d, view_7d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      for (size_t i1 = 0; i1 < sizes[1]; ++i1) {
+        for (size_t i2 = 0; i2 < sizes[2]; ++i2) {
+          for (size_t i3 = 0; i3 < sizes[3]; ++i3) {
+            for (size_t i4 = 0; i4 < sizes[4]; ++i4) {
+              for (size_t i5 = 0; i5 < sizes[5]; ++i5) {
+                for (size_t i6 = 0; i6 < sizes[6]; ++i6) {
+                  if (h_view_7d(i0, i1, i2, i3, i4, i5, i6) !=
+                      h_view_7d_old(i0, i1, i2, i3, i4, i5, i6)) {
+                    test = false;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
   {
     typedef Kokkos::View<int********, DeviceType> view_type;
-    view_type view_8d ("view_8d", sizes[0], sizes[1], sizes[2], sizes[3],
-                       sizes[4], sizes[5], sizes[6], sizes[7]);
-    const int* oldPointer = view_8d.data ();
-    EXPECT_TRUE( oldPointer != NULL );
-    Kokkos::resize (view_8d, sizes[0], sizes[1], sizes[2], sizes[3], sizes[4],
-                    sizes[5], sizes[6], sizes[7]);
-    const int* newPointer = view_8d.data ();
-    EXPECT_TRUE( oldPointer == newPointer );
+    view_type view_8d("view_8d", sizes[0], sizes[1], sizes[2], sizes[3],
+                      sizes[4], sizes[5], sizes[6], sizes[7]);
+    typename view_type::HostMirror h_view_8d_old =
+        Kokkos::create_mirror(view_8d);
+    Kokkos::deep_copy(view_8d, 888);
+    Kokkos::deep_copy(h_view_8d_old, view_8d);
+    resize_dispatch(Tag{}, view_8d, 2 * sizes[0], sizes[1], sizes[2], sizes[3],
+                    sizes[4], sizes[5], sizes[6], sizes[7]);
+    EXPECT_TRUE(view_8d.extent(0) == 2 * sizes[0]);
+    typename view_type::HostMirror h_view_8d =
+        Kokkos::create_mirror_view(view_8d);
+    Kokkos::deep_copy(h_view_8d, view_8d);
+    bool test = true;
+    for (size_t i0 = 0; i0 < sizes[0]; ++i0) {
+      for (size_t i1 = 0; i1 < sizes[1]; ++i1) {
+        for (size_t i2 = 0; i2 < sizes[2]; ++i2) {
+          for (size_t i3 = 0; i3 < sizes[3]; ++i3) {
+            for (size_t i4 = 0; i4 < sizes[4]; ++i4) {
+              for (size_t i5 = 0; i5 < sizes[5]; ++i5) {
+                for (size_t i6 = 0; i6 < sizes[6]; ++i6) {
+                  for (size_t i7 = 0; i7 < sizes[7]; ++i7) {
+                    if (h_view_8d(i0, i1, i2, i3, i4, i5, i6, i7) !=
+                        h_view_8d_old(i0, i1, i2, i3, i4, i5, i6, i7)) {
+                      test = false;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(test == true);
   }
 }
 
-} // namespace TestViewSubview
+template <class DeviceType>
+void testResize() {
+  {
+    impl_testResize<DeviceType>();  // with data initialization
+  }
+  {
+    impl_testResize<DeviceType,
+                    WithoutInitializing>();  // without data initialization
+  }
+}
 
-#endif // TESTVIEWSUBVIEW_HPP_
+}  // namespace TestViewResize
+#endif  // TESTRESIZE_HPP_
diff --git a/lib/kokkos/core/unit_test/TestScan.hpp b/lib/kokkos/core/unit_test/TestScan.hpp
index eaebb254a73036880aa182fd7d72e2a3df05d7a2..483f1868802c95601954ca6d06f5681916eda32d 100644
--- a/lib/kokkos/core/unit_test/TestScan.hpp
+++ b/lib/kokkos/core/unit_test/TestScan.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,70 +47,72 @@
 
 namespace Test {
 
-template< class Device, class WorkSpec = size_t >
+template <class Device, class WorkSpec = size_t>
 struct TestScan {
-  typedef  Device    execution_space;
-  typedef  long int  value_type;
+  typedef Device execution_space;
+  typedef long int value_type;
 
-  Kokkos::View< int, Device, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
+  Kokkos::View<int, Device, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int iwork, value_type & update, const bool final_pass ) const
-  {
-    const value_type n = iwork + 1;
-    const value_type imbalance = ( ( 1000 <= n ) && ( 0 == n % 1000 ) ) ? 1000 : 0;
+  void operator()(const int iwork, value_type& update,
+                  const bool final_pass) const {
+    const value_type n         = iwork + 1;
+    const value_type imbalance = ((1000 <= n) && (0 == n % 1000)) ? 1000 : 0;
 
     // Insert an artificial load imbalance
 
-    for ( value_type i = 0; i < imbalance; ++i ) { ++update; }
+    for (value_type i = 0; i < imbalance; ++i) {
+      ++update;
+    }
 
     update += n - imbalance;
 
-    if ( final_pass ) {
-      const value_type answer = n & 1 ? ( n * ( ( n + 1 ) / 2 ) ) : ( ( n / 2 ) * ( n + 1 ) );
+    if (final_pass) {
+      const value_type answer =
+          n & 1 ? (n * ((n + 1) / 2)) : ((n / 2) * (n + 1));
 
-      if ( answer != update ) {
+      if (answer != update) {
         int fail = errors()++;
 
-        if ( fail < 20 ) {
-          printf( "TestScan(%d,%ld) != %ld\n", iwork, update, answer );
+        if (fail < 20) {
+          printf("TestScan(%d,%ld) != %ld\n", iwork, update, answer);
         }
       }
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & update ) const { update = 0; }
+  void init(value_type& update) const { update = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile       value_type & update,
-             volatile const value_type & input ) const
-  { update += input; }
-
-  TestScan( const WorkSpec & N )
-  {
-    Kokkos::View< int, Device > errors_a( "Errors" );
-    Kokkos::deep_copy( errors_a, 0 );
+  void join(volatile value_type& update,
+            volatile const value_type& input) const {
+    update += input;
+  }
+
+  TestScan(const WorkSpec& N) {
+    Kokkos::View<int, Device> errors_a("Errors");
+    Kokkos::deep_copy(errors_a, 0);
     errors = errors_a;
 
-    Kokkos::parallel_scan( N , *this );
+    Kokkos::parallel_scan(N, *this);
 
     long long int total = 0;
-    Kokkos::parallel_scan( N, *this, total );
+    Kokkos::parallel_scan(N, *this, total);
 
-    run_check( size_t( ( N+1 )*N/2 ), size_t( total ) );
+    run_check(size_t((N + 1) * N / 2), size_t(total));
     check_error();
   }
 
-  TestScan( const WorkSpec & Start , const WorkSpec & N )
-  {
-    typedef Kokkos::RangePolicy< execution_space > exec_policy ;
+  TestScan(const WorkSpec& Start, const WorkSpec& N) {
+    typedef Kokkos::RangePolicy<execution_space> exec_policy;
 
-    Kokkos::View< int, Device > errors_a( "Errors" );
-    Kokkos::deep_copy( errors_a, 0 );
+    Kokkos::View<int, Device> errors_a("Errors");
+    Kokkos::deep_copy(errors_a, 0);
     errors = errors_a;
-    
-    Kokkos::parallel_scan( exec_policy( Start , N ) , *this );
+
+    Kokkos::parallel_scan(exec_policy(Start, N), *this);
     Kokkos::fence();
 
     check_error();
@@ -118,36 +121,32 @@ struct TestScan {
   void check_error() {
     int total_errors;
     Kokkos::deep_copy(total_errors, errors);
-    ASSERT_EQ(total_errors,0);
+    ASSERT_EQ(total_errors, 0);
   }
 
-  static void test_range( const WorkSpec & begin, const WorkSpec & end )
-  {
-    for ( WorkSpec i = begin; i < end; ++i ) {
-      (void) TestScan( i );
+  static void test_range(const WorkSpec& begin, const WorkSpec& end) {
+    for (WorkSpec i = begin; i < end; ++i) {
+      (void)TestScan(i);
     }
   }
 
-  void run_check( const size_t & expected, const size_t & actual )
-  { 
-    ASSERT_EQ( expected, actual ); 
+  void run_check(const size_t& expected, const size_t& actual) {
+    ASSERT_EQ(expected, actual);
   }
-
 };
 
-TEST_F( TEST_CATEGORY, scan )
-{
-  TestScan< TEST_EXECSPACE >::test_range( 1, 1000 );
-  TestScan< TEST_EXECSPACE >( 0 );
-  TestScan< TEST_EXECSPACE >( 100000 );
-  TestScan< TEST_EXECSPACE >( 10000000 );
+TEST(TEST_CATEGORY, scan) {
+  TestScan<TEST_EXECSPACE>::test_range(1, 1000);
+  TestScan<TEST_EXECSPACE>(0);
+  TestScan<TEST_EXECSPACE>(100000);
+  TestScan<TEST_EXECSPACE>(10000000);
   TEST_EXECSPACE().fence();
 }
 
-
-/*TEST_F( TEST_CATEGORY, scan_small )
+/*TEST( TEST_CATEGORY, scan_small )
 {
-  typedef TestScan< TEST_EXECSPACE, Kokkos::Impl::ThreadsExecUseScanSmall > TestScanFunctor;
+  typedef TestScan< TEST_EXECSPACE, Kokkos::Impl::ThreadsExecUseScanSmall >
+TestScanFunctor;
 
   for ( int i = 0; i < 1000; ++i ) {
     TestScanFunctor( 10 );
@@ -159,5 +158,4 @@ TEST_F( TEST_CATEGORY, scan )
   TEST_EXECSPACE().fence();
 }*/
 
-
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestSharedAlloc.hpp b/lib/kokkos/core/unit_test/TestSharedAlloc.hpp
index c475fe55dc3291bdf7959b7673297ab6f7508fee..d284b7d61eed0a3b147c29ef26744606c82ceb6a 100644
--- a/lib/kokkos/core/unit_test/TestSharedAlloc.hpp
+++ b/lib/kokkos/core/unit_test/TestSharedAlloc.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -54,71 +55,71 @@
 namespace Test {
 
 struct SharedAllocDestroy {
-  volatile int * count;
+  volatile int* count;
 
   SharedAllocDestroy() = default;
-  SharedAllocDestroy( int * arg ) : count( arg ) {}
+  SharedAllocDestroy(int* arg) : count(arg) {}
 
-  void destroy_shared_allocation()
-  {
-    Kokkos::atomic_increment( count );
-  }
+  void destroy_shared_allocation() { Kokkos::atomic_increment(count); }
 };
 
-template< class MemorySpace, class ExecutionSpace >
-void test_shared_alloc()
-{
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
-  typedef const Kokkos::Impl::SharedAllocationHeader                               Header;
-  typedef Kokkos::Impl::SharedAllocationTracker                                    Tracker;
-  typedef Kokkos::Impl::SharedAllocationRecord< void, void >                       RecordBase;
-  typedef Kokkos::Impl::SharedAllocationRecord< MemorySpace, void >                RecordMemS;
-  typedef Kokkos::Impl::SharedAllocationRecord< MemorySpace, SharedAllocDestroy >  RecordFull;
+template <class MemorySpace, class ExecutionSpace>
+void test_shared_alloc() {
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
+  typedef const Kokkos::Impl::SharedAllocationHeader Header;
+  typedef Kokkos::Impl::SharedAllocationTracker Tracker;
+  typedef Kokkos::Impl::SharedAllocationRecord<void, void> RecordBase;
+  typedef Kokkos::Impl::SharedAllocationRecord<MemorySpace, void> RecordMemS;
+  typedef Kokkos::Impl::SharedAllocationRecord<MemorySpace, SharedAllocDestroy>
+      RecordFull;
 
-  static_assert( sizeof( Tracker ) == sizeof( int* ), "SharedAllocationTracker has wrong size!" );
+  static_assert(sizeof(Tracker) == sizeof(int*),
+                "SharedAllocationTracker has wrong size!");
 
   MemorySpace s;
 
-  const size_t N = 1200;
+  const size_t N    = 1200;
   const size_t size = 8;
 
-  RecordMemS * rarray[ N ];
-  Header     * harray[ N ];
+  RecordMemS* rarray[N];
+  Header* harray[N];
 
-  RecordMemS ** const r = rarray;
-  Header     ** const h = harray;
+  RecordMemS** const r = rarray;
+  Header** const h     = harray;
 
-  Kokkos::RangePolicy< ExecutionSpace > range( 0, N );
+  Kokkos::RangePolicy<ExecutionSpace> range(0, N);
 
   {
     // Since always executed on host space, leave [=]
-    Kokkos::parallel_for( range, [=] ( size_t i ) {
+    Kokkos::parallel_for(range, [=](size_t i) {
       char name[64];
-      sprintf( name, "test_%.2d", int( i ) );
+      sprintf(name, "test_%.2d", int(i));
 
-      r[i] = RecordMemS::allocate( s, name, size * ( i + 1 ) );
-      h[i] = Header::get_header( r[i]->data() );
+      r[i] = RecordMemS::allocate(s, name, size * (i + 1));
+      h[i] = Header::get_header(r[i]->data());
 
-      ASSERT_EQ( r[i]->use_count(), 0 );
+      ASSERT_EQ(r[i]->use_count(), 0);
 
-      for ( size_t j = 0; j < ( i / 10 ) + 1; ++j ) RecordBase::increment( r[i] );
+      for (size_t j = 0; j < (i / 10) + 1; ++j) RecordBase::increment(r[i]);
 
-      ASSERT_EQ( r[i]->use_count(), ( i / 10 ) + 1 );
-      ASSERT_EQ( r[i], RecordMemS::get_record( r[i]->data() ) );
+      ASSERT_EQ(r[i]->use_count(), (i / 10) + 1);
+      ASSERT_EQ(r[i], RecordMemS::get_record(r[i]->data()));
     });
 
     Kokkos::fence();
 
 #ifdef KOKKOS_DEBUG
-    // Sanity check for the whole set of allocation records to which this record belongs.
-    RecordBase::is_sane( r[0] );
+    // Sanity check for the whole set of allocation records to which this record
+    // belongs.
+    RecordBase::is_sane(r[0]);
     // RecordMemS::print_records( std::cout, s, true );
 #endif
 
-    Kokkos::parallel_for( range, [=] ( size_t i ) {
-      while ( 0 != ( r[i] = static_cast< RecordMemS * >( RecordBase::decrement( r[i] ) ) ) ) {
+    Kokkos::parallel_for(range, [=](size_t i) {
+      while (0 !=
+             (r[i] = static_cast<RecordMemS*>(RecordBase::decrement(r[i])))) {
 #ifdef KOKKOS_DEBUG
-        if ( r[i]->use_count() == 1 ) RecordBase::is_sane( r[i] );
+        if (r[i]->use_count() == 1) RecordBase::is_sane(r[i]);
 #endif
       }
     });
@@ -128,101 +129,102 @@ void test_shared_alloc()
 
   {
     int destroy_count = 0;
-    SharedAllocDestroy counter( &destroy_count );
+    SharedAllocDestroy counter(&destroy_count);
 
-    Kokkos::parallel_for( range, [=] ( size_t i ) {
+    Kokkos::parallel_for(range, [=](size_t i) {
       char name[64];
-      sprintf( name, "test_%.2d", int( i ) );
+      sprintf(name, "test_%.2d", int(i));
 
-      RecordFull * rec = RecordFull::allocate( s, name, size * ( i + 1 ) );
+      RecordFull* rec = RecordFull::allocate(s, name, size * (i + 1));
 
       rec->m_destroy = counter;
 
       r[i] = rec;
-      h[i] = Header::get_header( r[i]->data() );
+      h[i] = Header::get_header(r[i]->data());
 
-      ASSERT_EQ( r[i]->use_count(), 0 );
+      ASSERT_EQ(r[i]->use_count(), 0);
 
-      for ( size_t j = 0; j < ( i / 10 ) + 1; ++j ) RecordBase::increment( r[i] );
+      for (size_t j = 0; j < (i / 10) + 1; ++j) RecordBase::increment(r[i]);
 
-      ASSERT_EQ( r[i]->use_count(), ( i / 10 ) + 1 );
-      ASSERT_EQ( r[i], RecordMemS::get_record( r[i]->data() ) );
+      ASSERT_EQ(r[i]->use_count(), (i / 10) + 1);
+      ASSERT_EQ(r[i], RecordMemS::get_record(r[i]->data()));
     });
 
     Kokkos::fence();
 
 #ifdef KOKKOS_DEBUG
-    RecordBase::is_sane( r[0] );
+    RecordBase::is_sane(r[0]);
 #endif
 
-    Kokkos::parallel_for( range, [=] ( size_t i ) {
-      while ( 0 != ( r[i] = static_cast< RecordMemS * >( RecordBase::decrement( r[i] ) ) ) ) {
+    Kokkos::parallel_for(range, [=](size_t i) {
+      while (0 !=
+             (r[i] = static_cast<RecordMemS*>(RecordBase::decrement(r[i])))) {
 #ifdef KOKKOS_DEBUG
-        if ( r[i]->use_count() == 1 ) RecordBase::is_sane( r[i] );
+        if (r[i]->use_count() == 1) RecordBase::is_sane(r[i]);
 #endif
       }
     });
 
     Kokkos::fence();
 
-    ASSERT_EQ( destroy_count, int( N ) );
+    ASSERT_EQ(destroy_count, int(N));
   }
 
   {
     int destroy_count = 0;
 
     {
-      RecordFull * rec = RecordFull::allocate( s, "test", size );
+      RecordFull* rec = RecordFull::allocate(s, "test", size);
 
       // ... Construction of the allocated { rec->data(), rec->size() }
 
       // Copy destruction function object into the allocation record.
-      rec->m_destroy = SharedAllocDestroy( & destroy_count );
+      rec->m_destroy = SharedAllocDestroy(&destroy_count);
 
-      ASSERT_EQ( rec->use_count(), 0 );
+      ASSERT_EQ(rec->use_count(), 0);
 
       // Start tracking, increments the use count from 0 to 1.
       Tracker track;
 
-      track.assign_allocated_record_to_uninitialized( rec );
+      track.assign_allocated_record_to_uninitialized(rec);
 
-      ASSERT_EQ( rec->use_count(), 1 );
-      ASSERT_EQ( track.use_count(), 1 );
+      ASSERT_EQ(rec->use_count(), 1);
+      ASSERT_EQ(track.use_count(), 1);
 
       // Verify construction / destruction increment.
-      for ( size_t i = 0; i < N; ++i ) {
-        ASSERT_EQ( rec->use_count(), 1 );
+      for (size_t i = 0; i < N; ++i) {
+        ASSERT_EQ(rec->use_count(), 1);
 
         {
           Tracker local_tracker;
-          local_tracker.assign_allocated_record_to_uninitialized( rec );
-          ASSERT_EQ( rec->use_count(), 2 );
-          ASSERT_EQ( local_tracker.use_count(), 2 );
+          local_tracker.assign_allocated_record_to_uninitialized(rec);
+          ASSERT_EQ(rec->use_count(), 2);
+          ASSERT_EQ(local_tracker.use_count(), 2);
         }
 
-        ASSERT_EQ( rec->use_count(), 1 );
-        ASSERT_EQ( track.use_count(), 1 );
+        ASSERT_EQ(rec->use_count(), 1);
+        ASSERT_EQ(track.use_count(), 1);
       }
 
-      Kokkos::parallel_for( range, [=] ( size_t ) {
+      Kokkos::parallel_for(range, [=](size_t) {
         Tracker local_tracker;
-        local_tracker.assign_allocated_record_to_uninitialized( rec );
-        ASSERT_GT( rec->use_count(), 1 );
+        local_tracker.assign_allocated_record_to_uninitialized(rec);
+        ASSERT_GT(rec->use_count(), 1);
       });
 
       Kokkos::fence();
 
-      ASSERT_EQ( rec->use_count(), 1 );
-      ASSERT_EQ( track.use_count(), 1 );
+      ASSERT_EQ(rec->use_count(), 1);
+      ASSERT_EQ(track.use_count(), 1);
 
-      // Destruction of 'track' object deallocates the 'rec' and invokes the destroy function object.
+      // Destruction of 'track' object deallocates the 'rec' and invokes the
+      // destroy function object.
     }
 
-    ASSERT_EQ( destroy_count, 1 );
+    ASSERT_EQ(destroy_count, 1);
   }
 
 #endif /* #if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST ) */
-
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/example/feint/feint_fwd.hpp b/lib/kokkos/core/unit_test/TestStackTrace.cpp
similarity index 69%
rename from lib/kokkos/example/feint/feint_fwd.hpp
rename to lib/kokkos/core/unit_test/TestStackTrace.cpp
index cc969ae572cce07890a8a0012ec4c707d3186c14..76ab7e3ebe56292125214b07fb09ea20a4abd0c4 100644
--- a/lib/kokkos/example/feint/feint_fwd.hpp
+++ b/lib/kokkos/core/unit_test/TestStackTrace.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,25 +37,24 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
-#ifndef KOKKOS_EXAMPLE_FEINT_FWD_HPP
-#define KOKKOS_EXAMPLE_FEINT_FWD_HPP
+#include <iostream>
+#include "Kokkos_Core.hpp"
 
-namespace Kokkos {
-namespace Example {
+#include <impl/Kokkos_Stacktrace.hpp>
 
-template < class Device , bool UseAtomic >
-void feint(
-  const unsigned global_elem_nx = 100 ,
-  const unsigned global_elem_ny = 115 ,
-  const unsigned global_elem_nz = 130 );
+namespace Test {
 
-} /* namespace Example */
-} /* namespace Kokkos */
+void my_fancy_handler() {
+  std::cerr << "I am the custom std::terminate handler." << std::endl;
+  std::abort();
+}
 
-#endif /* #ifndef KOKKOS_EXAMPLE_FEINT_FWD_HPP */
+}  // namespace Test
 
+#include <TestStackTrace.hpp>
+#include "UnitTestMainInit.cpp"
diff --git a/lib/kokkos/core/unit_test/TestStackTrace.hpp b/lib/kokkos/core/unit_test/TestStackTrace.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..284332f3f85e87b9f8fc030084ecc78448da4e38
--- /dev/null
+++ b/lib/kokkos/core/unit_test/TestStackTrace.hpp
@@ -0,0 +1,169 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+#include <iostream>
+#include <gtest/gtest.h>
+#include "Kokkos_Core.hpp"
+
+#include <impl/Kokkos_Stacktrace.hpp>
+
+namespace Test {
+
+void stacktrace_test_f0(std::ostream& out);
+
+int stacktrace_test_f1(std::ostream& out);
+
+void stacktrace_test_f2(std::ostream& out);
+
+int stacktrace_test_f3(std::ostream& out, const int level);
+
+void stacktrace_test_f4();
+
+void my_fancy_handler();
+
+void test_stacktrace(bool bTerminate, bool bCustom = true) {
+  stacktrace_test_f1(std::cout);
+  bool bDynamic = false;
+  {
+    std::stringstream sstream;
+    Kokkos::Impl::print_saved_stacktrace(sstream);
+    std::string foutput = sstream.str();
+
+    bDynamic = std::string::npos != foutput.find("stacktrace");
+
+    if (bDynamic) {
+      printf("test_f1: %s \n", foutput.c_str());
+      ASSERT_TRUE(std::string::npos != foutput.find("stacktrace_test_f1"));
+      for (auto x : {"stacktrace_test_f0", "stacktrace_test_f2",
+                     "stacktrace_test_f3", "stacktrace_test_f4"}) {
+        ASSERT_TRUE(std::string::npos == foutput.find(x));
+      }
+    }
+  }
+
+  {
+    std::stringstream sstream;
+    Kokkos::Impl::print_demangled_saved_stacktrace(sstream);
+
+    if (bDynamic) {
+      std::string foutput = sstream.str();
+      printf("demangled test_f1: %s \n", foutput.c_str());
+      ASSERT_TRUE(std::string::npos !=
+                  foutput.find("Test::stacktrace_test_f1"));
+      for (auto x : {"stacktrace_test_f0", "stacktrace_test_f2",
+                     "stacktrace_test_f3", "stacktrace_test_f4"}) {
+        ASSERT_TRUE(std::string::npos == foutput.find(x));
+      }
+    }
+  }
+
+  int val = stacktrace_test_f3(std::cout, 4);
+
+  // Don't remove this, otherwise the compiler will optimize away call sequences
+  // via
+  printf("StackTrace f3(std::cout, 4) returned: %i\n", val);
+
+  // TODO test by making sure that f3 and f1, but no other functions,
+  // appear in the stack trace, and that f3 appears 5 times.
+  // Fix that f3 doesn't show up when compiling with -O3
+  {
+    std::stringstream sstream;
+    Kokkos::Impl::print_saved_stacktrace(sstream);
+
+    if (bDynamic) {
+      std::string foutput = sstream.str();
+      printf("test_f3: %s \n", foutput.c_str());
+      for (auto x : {"stacktrace_test_f1", "stacktrace_test_f3"}) {
+        ASSERT_TRUE(std::string::npos != foutput.find(x));
+      }
+    }
+    // TODO make sure stacktrace_test_f2/4 don't show up
+    // TODO make sure stacktrace_test_f3 shows up 5 times
+  }
+
+  {
+    std::stringstream sstream;
+    Kokkos::Impl::print_demangled_saved_stacktrace(sstream);
+
+    if (bDynamic) {
+      std::string foutput = sstream.str();
+      printf("demangled test_f3: %s \n", foutput.c_str());
+      for (auto x : {"stacktrace_test_f1", "stacktrace_test_f3"}) {
+        ASSERT_TRUE(std::string::npos != foutput.find(x));
+      }
+    }
+
+    // TODO make sure stacktrace_test_f2/4 don't show up
+    // TODO make sure stacktrace_test_f3 shows up 5 times
+  }
+  std::cout << "Test setting std::terminate handler that prints "
+               "the last saved stack trace"
+            << std::endl;
+
+  stacktrace_test_f4();
+
+  if (bCustom) {
+    Kokkos::Impl::set_kokkos_terminate_handler(my_fancy_handler);
+  } else {
+    Kokkos::Impl::set_kokkos_terminate_handler();
+  }
+
+  // TODO test that this prints "Oh noes!" and the correct stacktrace.
+  if (bTerminate) {
+    std::terminate();
+  }
+}
+
+TEST(defaultdevicetype, stacktrace_normal) { test_stacktrace(false); }
+
+TEST(defaultdevicetype_DeathTest, stacktrace_terminate) {
+  ASSERT_DEATH({ test_stacktrace(true); },
+               "I am the custom std::terminate handler.");
+}
+
+TEST(defaultdevicetype_DeathTest, stacktrace_generic_term) {
+  ASSERT_DEATH({ test_stacktrace(true, false); },
+               "Kokkos observes that std::terminate has been called");
+}
+
+}  // namespace Test
diff --git a/lib/kokkos/example/feint/feint_openmp.cpp b/lib/kokkos/core/unit_test/TestStackTrace_f0.cpp
similarity index 67%
rename from lib/kokkos/example/feint/feint_openmp.cpp
rename to lib/kokkos/core/unit_test/TestStackTrace_f0.cpp
index 8c7e0b6a08364541bc926e32585591baca1de449..1514600f7d1f300cfaa076790e3f3e4dbfe52e0d 100644
--- a/lib/kokkos/example/feint/feint_openmp.cpp
+++ b/lib/kokkos/core/unit_test/TestStackTrace_f0.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,32 +37,18 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
-#include <Kokkos_Core.hpp>
-
-#ifdef KOKKOS_ENABLE_OPENMP
-
-#include <feint.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-template void feint<Kokkos::OpenMP,false>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
+#include <iostream>
+#include "Kokkos_Core.hpp"
 
-template void feint<Kokkos::OpenMP,true>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
+#include <impl/Kokkos_Stacktrace.hpp>
 
-} /* namespace Example */
-} /* namespace Kokkos */
+namespace Test {
 
-#endif
+void stacktrace_test_f0(std::ostream& out) { out << "Top of f0" << std::endl; }
 
+}  // namespace Test
diff --git a/lib/kokkos/example/fixture/TestFixture.cpp b/lib/kokkos/core/unit_test/TestStackTrace_f1.cpp
similarity index 69%
rename from lib/kokkos/example/fixture/TestFixture.cpp
rename to lib/kokkos/core/unit_test/TestStackTrace_f1.cpp
index b83d40588f0cea5652ad8811f367e3f97b594e23..b10c574c9bd0d7f8a82ff2fa3ead8b5204cf179f 100644
--- a/lib/kokkos/example/fixture/TestFixture.cpp
+++ b/lib/kokkos/core/unit_test/TestStackTrace_f1.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,27 +37,27 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
-#include <Kokkos_Core.hpp>
-#include <TestFixture.hpp>
+#include <iostream>
+#include "Kokkos_Core.hpp"
 
-namespace Kokkos {
-namespace Example {
+#include <impl/Kokkos_Stacktrace.hpp>
 
-template void test_fixture< Kokkos::HostSpace::execution_space >();
+namespace Test {
 
-#if defined( KOKKOS_ENABLE_CUDA )
-template void test_fixture<Kokkos::Cuda>();
-#endif
+void stacktrace_test_f0(std::ostream& out);
 
-#if defined( KOKKOS_ENABLE_ROCM )
-template void test_fixture<Kokkos::Experimental::ROCm>();
-#endif
+int stacktrace_test_f1(std::ostream& out) {
+  out << "Top of f1" << std::endl;
+  stacktrace_test_f0(out);
+  Kokkos::Impl::save_stacktrace();
+  stacktrace_test_f0(out);
 
-} /* namespace Example */
-} /* namespace Kokkos */
+  return 42;
+}
 
+}  // namespace Test
diff --git a/lib/kokkos/example/feint/feint_serial.cpp b/lib/kokkos/core/unit_test/TestStackTrace_f2.cpp
similarity index 67%
rename from lib/kokkos/example/feint/feint_serial.cpp
rename to lib/kokkos/core/unit_test/TestStackTrace_f2.cpp
index e70a05032d9671f69c32b81d7735fc2bcc239b17..23c1895e6946b2ef45caf7ed8d5a30e808089290 100644
--- a/lib/kokkos/example/feint/feint_serial.cpp
+++ b/lib/kokkos/core/unit_test/TestStackTrace_f2.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,32 +37,24 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
 
-#include <Kokkos_Core.hpp>
-
-#ifdef KOKKOS_ENABLE_SERIAL
-
-#include <feint.hpp>
-
-namespace Kokkos {
-namespace Example {
+#include <iostream>
+#include "Kokkos_Core.hpp"
 
-template void feint<Kokkos::Serial,false>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
+#include <impl/Kokkos_Stacktrace.hpp>
 
-template void feint<Kokkos::Serial,true>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
+namespace Test {
 
-} /* namespace Example */
-} /* namespace Kokkos */
+int stacktrace_test_f1(std::ostream& out);
 
-#endif
+void stacktrace_test_f2(std::ostream& out) {
+  out << "Top of f2" << std::endl;
+  const int result = stacktrace_test_f1(out);
+  out << "f2: f1 returned " << result << std::endl;
+}
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestStackTrace_f3.cpp b/lib/kokkos/core/unit_test/TestStackTrace_f3.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac004243f11e52c21d15bd04a6f246148e2962d2
--- /dev/null
+++ b/lib/kokkos/core/unit_test/TestStackTrace_f3.cpp
@@ -0,0 +1,62 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <iostream>
+#include "Kokkos_Core.hpp"
+
+#include <impl/Kokkos_Stacktrace.hpp>
+
+namespace Test {
+
+int stacktrace_test_f1(std::ostream& out);
+
+int stacktrace_test_f3(std::ostream& out, const int level) {
+  out << "Top of f3" << std::endl;
+  if (level <= 0) {
+    return stacktrace_test_f1(out);
+  } else {
+    return stacktrace_test_f3(out, level - 1) + 17;
+  }
+}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestStackTrace_f4.cpp b/lib/kokkos/core/unit_test/TestStackTrace_f4.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..afae98a2a8fe70f1d0d9fa49709646bb70b9ce18
--- /dev/null
+++ b/lib/kokkos/core/unit_test/TestStackTrace_f4.cpp
@@ -0,0 +1,53 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <iostream>
+#include "Kokkos_Core.hpp"
+
+#include <impl/Kokkos_Stacktrace.hpp>
+
+namespace Test {
+
+void stacktrace_test_f4() { Kokkos::Impl::save_stacktrace(); }
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestTaskScheduler.hpp b/lib/kokkos/core/unit_test/TestTaskScheduler.hpp
index 361e8da9e1501537f6766fc71c6e91d212721d97..9f593a00fdac800b1ecd4b67efb479d4fbea5c23 100644
--- a/lib/kokkos/core/unit_test/TestTaskScheduler.hpp
+++ b/lib/kokkos/core/unit_test/TestTaskScheduler.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,14 +46,13 @@
 #define KOKKOS_UNITTEST_TASKSCHEDULER_HPP
 
 #include <Kokkos_Macros.hpp>
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 #include <Kokkos_Core.hpp>
 #include <impl/Kokkos_FixedBufferMemoryPool.hpp>
 #include <cstdio>
 #include <iostream>
 #include <cmath>
 
-
 //==============================================================================
 // <editor-fold desc="TestFib"> {{{1
 
@@ -60,113 +60,103 @@ namespace TestTaskScheduler {
 
 namespace {
 
-inline
-long eval_fib( long n )
-{
+inline long eval_fib(long n) {
   constexpr long mask = 0x03;
 
-  long fib[4] = { 0, 1, 1, 2 };
+  long fib[4] = {0, 1, 1, 2};
 
-  for ( long i = 2; i <= n; ++i ) {
-    fib[ i & mask ] = fib[ ( i - 1 ) & mask ] + fib[ ( i - 2 ) & mask ];
+  for (long i = 2; i <= n; ++i) {
+    fib[i & mask] = fib[(i - 1) & mask] + fib[(i - 2) & mask];
   }
 
-  return fib[ n & mask ];
+  return fib[n & mask];
 }
 
-}
+}  // namespace
 
-template< typename Scheduler >
-struct TestFib
-{
-  using sched_type = Scheduler;
-  using future_type = Kokkos::BasicFuture< long, Scheduler >;
-  using value_type = long;
+template <typename Scheduler>
+struct TestFib {
+  using sched_type  = Scheduler;
+  using future_type = Kokkos::BasicFuture<long, Scheduler>;
+  using value_type  = long;
 
   future_type fib_m1;
   future_type fib_m2;
   const value_type n;
 
   KOKKOS_INLINE_FUNCTION
-  TestFib( const value_type arg_n )
-    : fib_m1(), fib_m2(), n( arg_n ) {}
+  TestFib(const value_type arg_n) : fib_m1(), fib_m2(), n(arg_n) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename sched_type::member_type & member, value_type & result )
-  {
+  void operator()(typename sched_type::member_type& member,
+                  value_type& result) {
 #if 0
     printf( "\nTestFib(%ld) %d %d\n", n, int( !fib_m1.is_null() ), int( !fib_m2.is_null() ) );
 #endif
 
     auto& sched = member.scheduler();
 
-    if ( n < 2 ) {
+    if (n < 2) {
       result = n;
-    }
-    else if ( !fib_m2.is_null() && !fib_m1.is_null() ) {
+    } else if (!fib_m2.is_null() && !fib_m1.is_null()) {
       result = fib_m1.get() + fib_m2.get();
-    }
-    else {
+    } else {
       // Spawn new children and respawn myself to sum their results.
       // Spawn lower value at higher priority as it has a shorter
       // path to completion.
 
-      fib_m2 = Kokkos::task_spawn( Kokkos::TaskSingle( sched, Kokkos::TaskPriority::High )
-                                 , TestFib( n - 2 ) );
+      fib_m2 = Kokkos::task_spawn(
+          Kokkos::TaskSingle(sched, Kokkos::TaskPriority::High),
+          TestFib(n - 2));
 
-      fib_m1 = Kokkos::task_spawn( Kokkos::TaskSingle( sched )
-                                 , TestFib( n - 1 ) );
+      fib_m1 = Kokkos::task_spawn(Kokkos::TaskSingle(sched), TestFib(n - 1));
 
-      Kokkos::BasicFuture<void, Scheduler> dep[] = { fib_m1, fib_m2 };
-      Kokkos::BasicFuture<void, Scheduler> fib_all = sched.when_all( dep, 2 );
+      Kokkos::BasicFuture<void, Scheduler> dep[]   = {fib_m1, fib_m2};
+      Kokkos::BasicFuture<void, Scheduler> fib_all = sched.when_all(dep, 2);
 
-      if ( !fib_m2.is_null() && !fib_m1.is_null() && !fib_all.is_null() ) {
+      if (!fib_m2.is_null() && !fib_m1.is_null() && !fib_all.is_null()) {
         // High priority to retire this branch.
-        Kokkos::respawn( this, fib_all, Kokkos::TaskPriority::High );
-      }
-      else {
+        Kokkos::respawn(this, fib_all, Kokkos::TaskPriority::High);
+      } else {
 #if 1
-        printf( "TestFib(%ld) insufficient memory alloc_capacity(%d) task_max(%d) task_accum(%ld)\n"
-               , n
-               , 0 //sched.allocation_capacity()
-               , 0 //sched.allocated_task_count_max()
-               , 0l //sched.allocated_task_count_accum()
-               );
+        printf(
+            "TestFib(%ld) insufficient memory alloc_capacity(%d) task_max(%d) "
+            "task_accum(%ld)\n",
+            n, 0  // sched.allocation_capacity()
+            ,
+            0  // sched.allocated_task_count_max()
+            ,
+            0l  // sched.allocated_task_count_accum()
+        );
 #endif
 
-        Kokkos::abort( "TestFib insufficient memory" );
-
+        Kokkos::abort("TestFib insufficient memory");
       }
     }
   }
 
-  static void run( int i, size_t MemoryCapacity = 16000 )
-  {
+  static void run(int i, size_t MemoryCapacity = 16000) {
     typedef typename sched_type::memory_space memory_space;
 
-    enum { MinBlockSize   =   64 };
-    enum { MaxBlockSize   = 1024 };
+    enum { MinBlockSize = 64 };
+    enum { MaxBlockSize = 1024 };
     enum { SuperBlockSize = 4096 };
 
-    sched_type root_sched( memory_space()
-                         , MemoryCapacity
-                         , MinBlockSize
-                         , std::min(size_t(MaxBlockSize),MemoryCapacity)
-                         , std::min(size_t(SuperBlockSize),MemoryCapacity) );
+    sched_type root_sched(memory_space(), MemoryCapacity, MinBlockSize,
+                          std::min(size_t(MaxBlockSize), MemoryCapacity),
+                          std::min(size_t(SuperBlockSize), MemoryCapacity));
 
     {
-      future_type f = Kokkos::host_spawn( Kokkos::TaskSingle( root_sched )
-                                        , TestFib( i ) );
+      future_type f =
+          Kokkos::host_spawn(Kokkos::TaskSingle(root_sched), TestFib(i));
 
-      Kokkos::wait( root_sched );
+      Kokkos::wait(root_sched);
 
-      ASSERT_EQ( eval_fib( i ), f.get() );
+      ASSERT_EQ(eval_fib(i), f.get());
     }
 
     ASSERT_EQ(root_sched.queue().allocation_count(), 0);
 
-
-
 #if 0
     fprintf( stdout, "\nTestFib::run(%d) spawn_size(%d) when_all_size(%d) alloc_capacity(%d) task_max(%d) task_accum(%ld)\n"
            , i
@@ -181,7 +171,7 @@ struct TestFib
   }
 };
 
-} // namespace TestTaskScheduler
+}  // namespace TestTaskScheduler
 
 // </editor-fold> end TestFib }}}1
 //==============================================================================
@@ -193,83 +183,73 @@ struct TestFib
 
 namespace TestTaskScheduler {
 
-template< class Scheduler >
+template <class Scheduler>
 struct TestTaskDependence {
-  typedef Scheduler  sched_type;
-  typedef Kokkos::BasicFuture< void, Scheduler > future_type;
-  typedef Kokkos::View< long, typename sched_type::execution_space >     accum_type;
-  typedef void                            value_type;
+  typedef Scheduler sched_type;
+  typedef Kokkos::BasicFuture<void, Scheduler> future_type;
+  typedef Kokkos::View<long, typename sched_type::execution_space> accum_type;
+  typedef void value_type;
 
-  accum_type  m_accum;
-  long        m_count;
+  accum_type m_accum;
+  long m_count;
 
   KOKKOS_INLINE_FUNCTION
-  TestTaskDependence( long n
-                    , const accum_type & arg_accum )
-    : m_accum( arg_accum )
-    , m_count( n ) {}
+  TestTaskDependence(long n, const accum_type& arg_accum)
+      : m_accum(arg_accum), m_count(n) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename sched_type::member_type & member )
-  {
+  void operator()(typename sched_type::member_type& member) {
     auto& sched = member.scheduler();
     enum { CHUNK = 8 };
     const int n = CHUNK < m_count ? CHUNK : m_count;
 
-    if ( 1 < m_count ) {
+    if (1 < m_count) {
+      const int increment = (m_count + n - 1) / n;
 
-      const int increment = ( m_count + n - 1 ) / n;
+      future_type f = sched.when_all(n, [this, &member, increment](int i) {
+        const long inc   = increment;
+        const long begin = i * inc;
+        const long count = begin + inc < m_count ? inc : m_count - begin;
 
-      future_type f =
-        sched.when_all( n , [this,&member,increment]( int i ) {
-          const long inc   = increment ;
-          const long begin = i * inc ;
-          const long count = begin + inc < m_count ? inc : m_count - begin ;
-
-          return Kokkos::task_spawn
-            ( Kokkos::TaskSingle( member.scheduler() )
-            , TestTaskDependence( count, m_accum ) );
-        });
+        return Kokkos::task_spawn(Kokkos::TaskSingle(member.scheduler()),
+                                  TestTaskDependence(count, m_accum));
+      });
 
       m_count = 0;
 
-      Kokkos::respawn( this, f );
-    }
-    else if ( 1 == m_count ) {
-      Kokkos::atomic_increment( & m_accum() );
+      Kokkos::respawn(this, f);
+    } else if (1 == m_count) {
+      Kokkos::atomic_increment(&m_accum());
     }
   }
 
-  static void run( int n )
-  {
+  static void run(int n) {
     typedef typename sched_type::memory_space memory_space;
 
     enum { MemoryCapacity = 16000 };
-    enum { MinBlockSize   =   64 };
-    enum { MaxBlockSize   = 1024 };
+    enum { MinBlockSize = 64 };
+    enum { MaxBlockSize = 1024 };
     enum { SuperBlockSize = 4096 };
 
-    sched_type sched( memory_space()
-                    , MemoryCapacity
-                    , MinBlockSize
-                    , MaxBlockSize
-                    , SuperBlockSize );
+    sched_type sched(memory_space(), MemoryCapacity, MinBlockSize, MaxBlockSize,
+                     SuperBlockSize);
 
-    accum_type accum( "accum" );
+    accum_type accum("accum");
 
-    typename accum_type::HostMirror host_accum = Kokkos::create_mirror_view( accum );
+    typename accum_type::HostMirror host_accum =
+        Kokkos::create_mirror_view(accum);
 
-    Kokkos::host_spawn( Kokkos::TaskSingle( sched ), TestTaskDependence( n, accum ) );
+    Kokkos::host_spawn(Kokkos::TaskSingle(sched), TestTaskDependence(n, accum));
 
-    Kokkos::wait( sched );
+    Kokkos::wait(sched);
 
-    Kokkos::deep_copy( host_accum, accum );
+    Kokkos::deep_copy(host_accum, accum);
 
-    ASSERT_EQ( host_accum(), n );
+    ASSERT_EQ(host_accum(), n);
   }
 };
 
-} // namespace TestTaskScheduler
+}  // namespace TestTaskScheduler
 
 // </editor-fold> end TestTaskDependence }}}1
 //==============================================================================
@@ -278,114 +258,107 @@ struct TestTaskDependence {
 
 namespace TestTaskScheduler {
 
-template< class Scheduler >
+template <class Scheduler>
 struct TestTaskTeam {
-  //enum { SPAN = 8 };
+  // enum { SPAN = 8 };
   enum { SPAN = 33 };
-  //enum { SPAN = 1 };
+  // enum { SPAN = 1 };
 
-  typedef void                                value_type;
-  using sched_type = Scheduler;
+  typedef void value_type;
+  using sched_type  = Scheduler;
   using future_type = Kokkos::BasicFuture<void, sched_type>;
-  using ExecSpace = typename sched_type::execution_space;
-  typedef Kokkos::View< long*, ExecSpace >    view_type;
+  using ExecSpace   = typename sched_type::execution_space;
+  typedef Kokkos::View<long*, ExecSpace> view_type;
 
-  future_type  future;
+  future_type future;
 
-  view_type   parfor_result;
-  view_type   parreduce_check;
-  view_type   parscan_result;
-  view_type   parscan_check;
-  const long  nvalue;
+  view_type parfor_result;
+  view_type parreduce_check;
+  view_type parscan_result;
+  view_type parscan_check;
+  const long nvalue;
 
   KOKKOS_INLINE_FUNCTION
-  TestTaskTeam( const view_type  & arg_parfor_result
-              , const view_type  & arg_parreduce_check
-              , const view_type  & arg_parscan_result
-              , const view_type  & arg_parscan_check
-              , const long         arg_nvalue )
-    : future()
-    , parfor_result( arg_parfor_result )
-    , parreduce_check( arg_parreduce_check )
-    , parscan_result( arg_parscan_result )
-    , parscan_check( arg_parscan_check )
-    , nvalue( arg_nvalue ) {}
+  TestTaskTeam(const view_type& arg_parfor_result,
+               const view_type& arg_parreduce_check,
+               const view_type& arg_parscan_result,
+               const view_type& arg_parscan_check, const long arg_nvalue)
+      : future(),
+        parfor_result(arg_parfor_result),
+        parreduce_check(arg_parreduce_check),
+        parscan_result(arg_parscan_result),
+        parscan_check(arg_parscan_check),
+        nvalue(arg_nvalue) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename sched_type::member_type & member )
-  {
-    auto& sched = member.scheduler();
-    const long end   = nvalue + 1;
+  void operator()(typename sched_type::member_type& member) {
+    auto& sched    = member.scheduler();
+    const long end = nvalue + 1;
     // begin = max(end - SPAN, 0);
     const long begin = 0 < end - SPAN ? end - SPAN : 0;
 
-    if ( 0 < begin && future.is_null() ) {
-      if ( member.team_rank() == 0 ) {
-        future = Kokkos::task_spawn( Kokkos::TaskTeam( sched )
-                                   , TestTaskTeam( parfor_result
-                                                 , parreduce_check
-                                                 , parscan_result
-                                                 , parscan_check
-                                                 , begin - 1 )
-                                   );
-
-        #if !defined(__HCC_ACCELERATOR__) && !defined(__CUDA_ARCH__)
-        assert( !future.is_null() );
-        #endif
-
-        Kokkos::respawn( this, future );
+    if (0 < begin && future.is_null()) {
+      if (member.team_rank() == 0) {
+        future = Kokkos::task_spawn(
+            Kokkos::TaskTeam(sched),
+            TestTaskTeam(parfor_result, parreduce_check, parscan_result,
+                         parscan_check, begin - 1));
+
+#if !defined(__HCC_ACCELERATOR__) && !defined(__CUDA_ARCH__)
+        assert(!future.is_null());
+#endif
+
+        Kokkos::respawn(this, future);
       }
 
       return;
     }
 
-    Kokkos::parallel_for( Kokkos::TeamThreadRange( member, begin, end )
-                        , [&] ( int i ) { parfor_result[i] = i; }
-                        );
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(member, begin, end),
+                         [&](int i) { parfor_result[i] = i; });
 
     // Test parallel_reduce without join.
 
-    long tot = 0;
-    long expected = ( begin + end - 1 ) * ( end - begin ) * 0.5;
+    long tot      = 0;
+    long expected = (begin + end - 1) * (end - begin) * 0.5;
 
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( member, begin, end )
-                           , [&] ( int i, long & res ) { res += parfor_result[i]; }
-                           , tot
-                           );
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(member, begin, end),
+        [&](int i, long& res) { res += parfor_result[i]; }, tot);
 
-    Kokkos::parallel_for( Kokkos::TeamThreadRange( member, begin, end )
-                        , [&] ( int i ) { parreduce_check[i] = expected - tot; }
-                        );
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(member, begin, end),
+                         [&](int i) { parreduce_check[i] = expected - tot; });
 
     // Test parallel_reduce with join.
 
     tot = 0;
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( member, begin, end )
-                           , [&] ( int i, long & res ) { res += parfor_result[i]; }
-                           , Kokkos::Sum<long>( tot )
-                           );
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(member, begin, end),
+        [&](int i, long& res) { res += parfor_result[i]; },
+        Kokkos::Sum<long>(tot));
 
-    Kokkos::parallel_for( Kokkos::TeamThreadRange( member, begin, end )
-                        , [&] ( int i ) { parreduce_check[i] += expected - tot; }
-                        );
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(member, begin, end),
+                         [&](int i) { parreduce_check[i] += expected - tot; });
 
     // Test parallel_scan.
 
     // Exclusive scan.
-    Kokkos::parallel_scan<long>( Kokkos::TeamThreadRange( member, begin, end )
-                               , [&] ( int i, long & val, const bool final )
-    {
-      if ( final ) { parscan_result[i] = val; }
+    Kokkos::parallel_scan<long>(Kokkos::TeamThreadRange(member, begin, end),
+                                [&](int i, long& val, const bool final) {
+                                  if (final) {
+                                    parscan_result[i] = val;
+                                  }
 
-      val += i;
-    });
+                                  val += i;
+                                });
 
     // Wait for 'parscan_result' before testing it.
     member.team_barrier();
 
-    if ( member.team_rank() == 0 ) {
-      for ( long i = begin; i < end; ++i ) {
-        parscan_check[i] = ( i * ( i - 1 ) - begin * ( begin - 1 ) ) * 0.5 - parscan_result[i];
+    if (member.team_rank() == 0) {
+      for (long i = begin; i < end; ++i) {
+        parscan_check[i] =
+            (i * (i - 1) - begin * (begin - 1)) * 0.5 - parscan_result[i];
       }
     }
 
@@ -393,394 +366,355 @@ struct TestTaskTeam {
     member.team_barrier();
 
     // Inclusive scan.
-    Kokkos::parallel_scan<long>( Kokkos::TeamThreadRange( member, begin, end )
-                               , [&] ( int i, long & val, const bool final )
-    {
-      val += i;
+    Kokkos::parallel_scan<long>(Kokkos::TeamThreadRange(member, begin, end),
+                                [&](int i, long& val, const bool final) {
+                                  val += i;
 
-      if ( final ) { parscan_result[i] = val; }
-    });
+                                  if (final) {
+                                    parscan_result[i] = val;
+                                  }
+                                });
 
     // Wait for 'parscan_result' before testing it.
     member.team_barrier();
 
-    if ( member.team_rank() == 0 ) {
-      for ( long i = begin; i < end; ++i ) {
-        parscan_check[i] += ( i * ( i + 1 ) - begin * ( begin - 1 ) ) * 0.5 - parscan_result[i];
+    if (member.team_rank() == 0) {
+      for (long i = begin; i < end; ++i) {
+        parscan_check[i] +=
+            (i * (i + 1) - begin * (begin - 1)) * 0.5 - parscan_result[i];
       }
     }
 
     // ThreadVectorRange check.
-/*
-    long result = 0;
-    expected = ( begin + end - 1 ) * ( end - begin ) * 0.5;
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( member, 0, 1 )
-                           , [&] ( const int i, long & outerUpdate )
-    {
-      long sum_j = 0.0;
+    /*
+        long result = 0;
+        expected = ( begin + end - 1 ) * ( end - begin ) * 0.5;
+        Kokkos::parallel_reduce( Kokkos::TeamThreadRange( member, 0, 1 )
+                               , [&] ( const int i, long & outerUpdate )
+        {
+          long sum_j = 0.0;
+
+          Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( member, end -
+       begin ) , [&] ( const int j, long & innerUpdate )
+          {
+            innerUpdate += begin + j;
+          }, sum_j );
+
+          outerUpdate += sum_j;
+        }, result );
+
+        Kokkos::parallel_for( Kokkos::TeamThreadRange( member, begin, end )
+                            , [&] ( int i )
+        {
+          parreduce_check[i] += result - expected;
+        });
+    */
+  }
 
-      Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( member, end - begin )
-                             , [&] ( const int j, long & innerUpdate )
-      {
-        innerUpdate += begin + j;
-      }, sum_j );
+  static void run(long n) {
+    const unsigned memory_capacity = 400000;
 
-      outerUpdate += sum_j;
-    }, result );
+    enum { MinBlockSize = 64 };
+    enum { MaxBlockSize = 1024 };
+    enum { SuperBlockSize = 4096 };
 
-    Kokkos::parallel_for( Kokkos::TeamThreadRange( member, begin, end )
-                        , [&] ( int i )
-    {
-      parreduce_check[i] += result - expected;
-    });
-*/
+    sched_type root_sched(typename sched_type::memory_space(), memory_capacity,
+                          MinBlockSize, MaxBlockSize, SuperBlockSize);
 
-  }
+    view_type root_parfor_result("parfor_result", n + 1);
+    view_type root_parreduce_check("parreduce_check", n + 1);
+    view_type root_parscan_result("parscan_result", n + 1);
+    view_type root_parscan_check("parscan_check", n + 1);
 
-  static void run( long n )
-  {
-    const unsigned memory_capacity = 400000;
+    typename view_type::HostMirror host_parfor_result =
+        Kokkos::create_mirror_view(root_parfor_result);
+    typename view_type::HostMirror host_parreduce_check =
+        Kokkos::create_mirror_view(root_parreduce_check);
+    typename view_type::HostMirror host_parscan_result =
+        Kokkos::create_mirror_view(root_parscan_result);
+    typename view_type::HostMirror host_parscan_check =
+        Kokkos::create_mirror_view(root_parscan_check);
 
-    enum { MinBlockSize   =   64 };
-    enum { MaxBlockSize   = 1024 };
-    enum { SuperBlockSize = 4096 };
+    future_type f = Kokkos::host_spawn(
+        Kokkos::TaskTeam(root_sched),
+        TestTaskTeam(root_parfor_result, root_parreduce_check,
+                     root_parscan_result, root_parscan_check, n));
+
+    Kokkos::wait(root_sched);
+
+    Kokkos::deep_copy(host_parfor_result, root_parfor_result);
+    Kokkos::deep_copy(host_parreduce_check, root_parreduce_check);
+    Kokkos::deep_copy(host_parscan_result, root_parscan_result);
+    Kokkos::deep_copy(host_parscan_check, root_parscan_check);
 
-    sched_type root_sched( typename sched_type::memory_space()
-                         , memory_capacity
-                         , MinBlockSize
-                         , MaxBlockSize
-                         , SuperBlockSize );
-
-    view_type root_parfor_result( "parfor_result", n + 1 );
-    view_type root_parreduce_check( "parreduce_check", n + 1 );
-    view_type root_parscan_result( "parscan_result", n + 1 );
-    view_type root_parscan_check( "parscan_check", n + 1 );
-
-    typename view_type::HostMirror
-      host_parfor_result = Kokkos::create_mirror_view( root_parfor_result );
-    typename view_type::HostMirror
-      host_parreduce_check = Kokkos::create_mirror_view( root_parreduce_check );
-    typename view_type::HostMirror
-      host_parscan_result = Kokkos::create_mirror_view( root_parscan_result );
-    typename view_type::HostMirror
-      host_parscan_check = Kokkos::create_mirror_view( root_parscan_check );
-
-    future_type f = Kokkos::host_spawn( Kokkos::TaskTeam( root_sched )
-                                      , TestTaskTeam( root_parfor_result
-                                                    , root_parreduce_check
-                                                    , root_parscan_result
-                                                    , root_parscan_check
-                                                    , n )
-                                      );
-
-    Kokkos::wait( root_sched );
-
-    Kokkos::deep_copy( host_parfor_result, root_parfor_result );
-    Kokkos::deep_copy( host_parreduce_check, root_parreduce_check );
-    Kokkos::deep_copy( host_parscan_result, root_parscan_result );
-    Kokkos::deep_copy( host_parscan_check, root_parscan_check );
-
-    long error_count = 0 ;
-
-    for ( long i = 0; i <= n; ++i ) {
+    long error_count = 0;
+
+    for (long i = 0; i <= n; ++i) {
       const long answer = i;
 
-      if ( host_parfor_result( i ) != answer ) {
-        ++error_count ;
-        std::cerr << "TestTaskTeam::run ERROR parallel_for result(" << i << ") = "
-                  << host_parfor_result( i ) << " != " << answer << std::endl;
+      if (host_parfor_result(i) != answer) {
+        ++error_count;
+        std::cerr << "TestTaskTeam::run ERROR parallel_for result(" << i
+                  << ") = " << host_parfor_result(i) << " != " << answer
+                  << std::endl;
       }
 
-      if ( host_parreduce_check( i ) != 0 ) {
-        ++error_count ;
-        std::cerr << "TestTaskTeam::run ERROR parallel_reduce check(" << i << ") = "
-                  << host_parreduce_check( i ) << " != 0" << std::endl;
+      if (host_parreduce_check(i) != 0) {
+        ++error_count;
+        std::cerr << "TestTaskTeam::run ERROR parallel_reduce check(" << i
+                  << ") = " << host_parreduce_check(i) << " != 0" << std::endl;
       }
 
-      if ( host_parscan_check( i ) != 0 ) {
-        ++error_count ;
-        std::cerr << "TestTaskTeam::run ERROR parallel_scan check(" << i << ") = "
-                  << host_parscan_check( i ) << " != 0" << std::endl;
+      if (host_parscan_check(i) != 0) {
+        ++error_count;
+        std::cerr << "TestTaskTeam::run ERROR parallel_scan check(" << i
+                  << ") = " << host_parscan_check(i) << " != 0" << std::endl;
       }
     }
 
-    ASSERT_EQ( 0L , error_count );
+    ASSERT_EQ(0L, error_count);
   }
 };
 
-template< class Scheduler >
+template <class Scheduler>
 struct TestTaskTeamValue {
   enum { SPAN = 8 };
 
-  typedef long                                     value_type;
-  using sched_type = Scheduler;
-  using future_type = Kokkos::BasicFuture< value_type, sched_type >;
-  using ExecSpace = typename sched_type::execution_space;
-  typedef Kokkos::View< long*, ExecSpace >         view_type;
+  typedef long value_type;
+  using sched_type  = Scheduler;
+  using future_type = Kokkos::BasicFuture<value_type, sched_type>;
+  using ExecSpace   = typename sched_type::execution_space;
+  typedef Kokkos::View<long*, ExecSpace> view_type;
 
-  future_type  future;
+  future_type future;
 
-  view_type   result;
-  const long  nvalue;
+  view_type result;
+  const long nvalue;
 
   KOKKOS_INLINE_FUNCTION
-  TestTaskTeamValue( const view_type  & arg_result
-                   , const long         arg_nvalue )
-    : future()
-    , result( arg_result )
-    , nvalue( arg_nvalue ) {}
+  TestTaskTeamValue(const view_type& arg_result, const long arg_nvalue)
+      : future(), result(arg_result), nvalue(arg_nvalue) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename sched_type::member_type const & member
-                 , value_type & final )
-  {
+  void operator()(typename sched_type::member_type const& member,
+                  value_type& final) {
     const long end   = nvalue + 1;
     const long begin = 0 < end - SPAN ? end - SPAN : 0;
 
     auto& sched = member.scheduler();
 
-    if ( 0 < begin && future.is_null() ) {
-      if ( member.team_rank() == 0 ) {
-        future = sched.task_spawn( TestTaskTeamValue( result, begin - 1 )
-                                 , Kokkos::TaskTeam );
+    if (0 < begin && future.is_null()) {
+      if (member.team_rank() == 0) {
+        future = sched.task_spawn(TestTaskTeamValue(result, begin - 1),
+                                  Kokkos::TaskTeam);
 
-        #if !defined(__HCC_ACCELERATOR__) && !defined(__CUDA_ARCH__)
-        assert( !future.is_null() );
-        #endif
+#if !defined(__HCC_ACCELERATOR__) && !defined(__CUDA_ARCH__)
+        assert(!future.is_null());
+#endif
 
-        sched.respawn( this , future );
+        sched.respawn(this, future);
       }
 
       return;
     }
 
-    Kokkos::parallel_for( Kokkos::TeamThreadRange( member, begin, end )
-                        , [&] ( int i ) { result[i] = i + 1; }
-                        );
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(member, begin, end),
+                         [&](int i) { result[i] = i + 1; });
 
-    if ( member.team_rank() == 0 ) {
+    if (member.team_rank() == 0) {
       final = result[nvalue];
     }
 
     Kokkos::memory_fence();
   }
 
-  static void run( long n )
-  {
+  static void run(long n) {
     const unsigned memory_capacity = 100000;
 
-    enum { MinBlockSize   =   64 };
-    enum { MaxBlockSize   = 1024 };
+    enum { MinBlockSize = 64 };
+    enum { MaxBlockSize = 1024 };
     enum { SuperBlockSize = 4096 };
 
-    sched_type root_sched( typename sched_type::memory_space()
-                         , memory_capacity
-                         , MinBlockSize
-                         , MaxBlockSize
-                         , SuperBlockSize );
+    sched_type root_sched(typename sched_type::memory_space(), memory_capacity,
+                          MinBlockSize, MaxBlockSize, SuperBlockSize);
 
-    view_type root_result( "result", n + 1 );
+    view_type root_result("result", n + 1);
 
-    typename view_type::HostMirror host_result = Kokkos::create_mirror_view( root_result );
+    typename view_type::HostMirror host_result =
+        Kokkos::create_mirror_view(root_result);
 
-    future_type fv = root_sched.host_spawn( TestTaskTeamValue( root_result, n )
-                                          , Kokkos::TaskTeam );
+    future_type fv = root_sched.host_spawn(TestTaskTeamValue(root_result, n),
+                                           Kokkos::TaskTeam);
 
-    Kokkos::wait( root_sched );
+    Kokkos::wait(root_sched);
 
-    Kokkos::deep_copy( host_result, root_result );
+    Kokkos::deep_copy(host_result, root_result);
 
-    if ( fv.get() != n + 1 ) {
-      std::cerr << "TestTaskTeamValue ERROR future = "
-                << fv.get() << " != " << n + 1 << std::endl;
+    if (fv.get() != n + 1) {
+      std::cerr << "TestTaskTeamValue ERROR future = " << fv.get()
+                << " != " << n + 1 << std::endl;
     }
 
-    for ( long i = 0; i <= n; ++i ) {
+    for (long i = 0; i <= n; ++i) {
       const long answer = i + 1;
 
-      if ( host_result( i ) != answer ) {
-        std::cerr << "TestTaskTeamValue ERROR result(" << i << ") = "
-                  << host_result( i ) << " != " << answer << std::endl;
+      if (host_result(i) != answer) {
+        std::cerr << "TestTaskTeamValue ERROR result(" << i
+                  << ") = " << host_result(i) << " != " << answer << std::endl;
       }
     }
   }
 };
 
-} // namespace TestTaskScheduler
+}  // namespace TestTaskScheduler
 
 //----------------------------------------------------------------------------
 
 namespace TestTaskScheduler {
 
-template< class Scheduler >
+template <class Scheduler>
 struct TestTaskSpawnWithPool {
-  using sched_type = Scheduler;
+  using sched_type  = Scheduler;
   using future_type = Kokkos::BasicFuture<void, sched_type>;
-  typedef void                            value_type;
+  typedef void value_type;
   using Space = typename sched_type::execution_space;
 
-  int  m_count ;
-  Kokkos::MemoryPool<Space> m_pool ;
+  int m_count;
+  Kokkos::MemoryPool<Space> m_pool;
 
   KOKKOS_INLINE_FUNCTION
-  TestTaskSpawnWithPool(
-    const int & arg_count,
-    const Kokkos::MemoryPool<Space> & arg_pool
-  )
-    : m_count( arg_count )
-    , m_pool( arg_pool )
-    {}
+  TestTaskSpawnWithPool(const int& arg_count,
+                        const Kokkos::MemoryPool<Space>& arg_pool)
+      : m_count(arg_count), m_pool(arg_pool) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename sched_type::member_type & member )
-  {
-    if ( m_count ) {
-      Kokkos::task_spawn( Kokkos::TaskSingle( member.scheduler() ) , TestTaskSpawnWithPool( m_count - 1, m_pool ) );
+  void operator()(typename sched_type::member_type& member) {
+    if (m_count) {
+      Kokkos::task_spawn(Kokkos::TaskSingle(member.scheduler()),
+                         TestTaskSpawnWithPool(m_count - 1, m_pool));
     }
   }
 
-  static void run()
-  {
+  static void run() {
     typedef typename sched_type::memory_space memory_space;
 
     enum { MemoryCapacity = 16000 };
-    enum { MinBlockSize   =   64 };
-    enum { MaxBlockSize   = 1024 };
+    enum { MinBlockSize = 64 };
+    enum { MaxBlockSize = 1024 };
     enum { SuperBlockSize = 4096 };
 
-    sched_type sched( memory_space()
-                    , MemoryCapacity
-                    , MinBlockSize
-                    , MaxBlockSize
-                    , SuperBlockSize );
+    sched_type sched(memory_space(), MemoryCapacity, MinBlockSize, MaxBlockSize,
+                     SuperBlockSize);
 
     using other_memory_space = typename Space::memory_space;
     Kokkos::MemoryPool<Space> pool(other_memory_space(), 10000, 100, 200, 1000);
-    auto f = Kokkos::host_spawn( Kokkos::TaskSingle( sched ), TestTaskSpawnWithPool( 3, pool ) );
+    auto f = Kokkos::host_spawn(Kokkos::TaskSingle(sched),
+                                TestTaskSpawnWithPool(3, pool));
 
-    Kokkos::wait( sched );
+    Kokkos::wait(sched);
   }
 };
 
-}
+}  // namespace TestTaskScheduler
 
 //----------------------------------------------------------------------------
 
 namespace TestTaskScheduler {
 
-template< class Scheduler >
+template <class Scheduler>
 struct TestTaskCtorsDevice {
-  using sched_type = Scheduler;
+  using sched_type  = Scheduler;
   using future_type = Kokkos::BasicFuture<void, sched_type>;
-  using value_type = void;
-  using Space = typename sched_type::execution_space;
+  using value_type  = void;
+  using Space       = typename sched_type::execution_space;
 
   int m_count;
 
   KOKKOS_INLINE_FUNCTION
-  TestTaskCtorsDevice(const int & arg_count) : m_count(arg_count) { }
+  TestTaskCtorsDevice(const int& arg_count) : m_count(arg_count) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(typename sched_type::member_type& member )
-  {
+  void operator()(typename sched_type::member_type& member) {
     // Note: Default construction on the device is not allowed
-    if(m_count == 4) {
-      Kokkos::task_spawn(
-        Kokkos::TaskSingle(member.scheduler()),
-        TestTaskCtorsDevice(m_count - 1)
-      );
-    }
-    else if(m_count == 3) {
-      sched_type s = member.scheduler(); // move construct
-      s = member.scheduler(); // move assignment
-      Kokkos::task_spawn(
-        Kokkos::TaskSingle(s),
-        TestTaskCtorsDevice(m_count - 1)
-      );
-    }
-    else if(m_count == 2) {
-      sched_type s3 = member.scheduler(); // move construct from member.scheduler();
-      Kokkos::task_spawn(
-        Kokkos::TaskSingle(s3),
-        TestTaskCtorsDevice(m_count - 1)
-      );
-    }
-    else if(m_count == 1) {
-      sched_type s = member.scheduler(); // move construct from member.scheduler();
-      sched_type s2 = s; // copy construct from s
-      Kokkos::task_spawn(
-        Kokkos::TaskSingle(s2),
-        TestTaskCtorsDevice(m_count - 1)
-      );
+    if (m_count == 4) {
+      Kokkos::task_spawn(Kokkos::TaskSingle(member.scheduler()),
+                         TestTaskCtorsDevice(m_count - 1));
+    } else if (m_count == 3) {
+      sched_type s = member.scheduler();  // move construct
+      s            = member.scheduler();  // move assignment
+      Kokkos::task_spawn(Kokkos::TaskSingle(s),
+                         TestTaskCtorsDevice(m_count - 1));
+    } else if (m_count == 2) {
+      sched_type s3 =
+          member.scheduler();  // move construct from member.scheduler();
+      Kokkos::task_spawn(Kokkos::TaskSingle(s3),
+                         TestTaskCtorsDevice(m_count - 1));
+    } else if (m_count == 1) {
+      sched_type s =
+          member.scheduler();  // move construct from member.scheduler();
+      sched_type s2 = s;       // copy construct from s
+      Kokkos::task_spawn(Kokkos::TaskSingle(s2),
+                         TestTaskCtorsDevice(m_count - 1));
     }
   }
 
-  static void run()
-  {
+  static void run() {
     using memory_space = typename sched_type::memory_space;
 
     enum { MemoryCapacity = 16000 };
-    enum { MinBlockSize   =   64 };
-    enum { MaxBlockSize   = 1024 };
+    enum { MinBlockSize = 64 };
+    enum { MaxBlockSize = 1024 };
     enum { SuperBlockSize = 4096 };
 
-    sched_type sched(
-      memory_space(), MemoryCapacity, MinBlockSize, MaxBlockSize, SuperBlockSize
-    );
+    sched_type sched(memory_space(), MemoryCapacity, MinBlockSize, MaxBlockSize,
+                     SuperBlockSize);
 
-    auto f = Kokkos::host_spawn(
-      Kokkos::TaskSingle(sched),
-      TestTaskCtorsDevice(4)
-    );
+    auto f =
+        Kokkos::host_spawn(Kokkos::TaskSingle(sched), TestTaskCtorsDevice(4));
 
     Kokkos::wait(sched);
 
     // TODO assertions and sanity checks
-
   }
 };
 
-}
+}  // namespace TestTaskScheduler
 
 //----------------------------------------------------------------------------
 
-
 namespace TestTaskScheduler {
 
-template<class Scheduler>
+template <class Scheduler>
 struct TestMultipleDependence {
-
-  using sched_type = Scheduler;
-  using future_bool = Kokkos::BasicFuture<bool, sched_type>;
-  using future_int = Kokkos::BasicFuture<int, sched_type>;
-  using value_type = bool;
+  using sched_type      = Scheduler;
+  using future_bool     = Kokkos::BasicFuture<bool, sched_type>;
+  using future_int      = Kokkos::BasicFuture<int, sched_type>;
+  using value_type      = bool;
   using execution_space = typename sched_type::execution_space;
 
   enum : int { NPerDepth = 6 };
   enum : int { NFanout = 3 };
 
-  // xlC doesn't like incomplete aggregate constructors, so we have do do this manually:
+  // xlC doesn't like incomplete aggregate constructors, so we have do do this
+  // manually:
   KOKKOS_INLINE_FUNCTION
   TestMultipleDependence(int depth, int max_depth)
-    : m_depth(depth),
-      m_max_depth(max_depth),
-      m_dep()
-  { 
-    // gcc 4.8 has an internal compile error when I give the initializer in the class, so I have do do it here
-    for(int i = 0; i < NPerDepth; ++i) {
+      : m_depth(depth), m_max_depth(max_depth), m_dep() {
+    // gcc 4.8 has an internal compile error when I give the initializer in the
+    // class, so I have do do it here
+    for (int i = 0; i < NPerDepth; ++i) {
       m_result_futures[i] = future_bool();
     }
   }
 
-  // xlC doesn't like incomplete aggregate constructors, so we have do do this manually:
+  // xlC doesn't like incomplete aggregate constructors, so we have do do this
+  // manually:
   KOKKOS_INLINE_FUNCTION
   TestMultipleDependence(int depth, int max_depth, future_int dep)
-    : m_depth(depth),
-      m_max_depth(max_depth),
-      m_dep(dep)
-  { 
-    // gcc 4.8 has an internal compile error when I give the initializer in the class, so I have do do it here
-    for(int i = 0; i < NPerDepth; ++i) {
+      : m_depth(depth), m_max_depth(max_depth), m_dep(dep) {
+    // gcc 4.8 has an internal compile error when I give the initializer in the
+    // class, so I have do do it here
+    for (int i = 0; i < NPerDepth; ++i) {
       m_result_futures[i] = future_bool();
     }
   }
@@ -790,18 +724,17 @@ struct TestMultipleDependence {
   future_int m_dep;
   future_bool m_result_futures[NPerDepth];
 
-
   struct TestCheckReady {
-     future_int m_dep;
-     using value_type = bool;
-     KOKKOS_INLINE_FUNCTION
-     void operator()(typename Scheduler::member_type&, bool& value) {
-       // if it was "transiently" ready, this could be false even if we made it a dependence of this task
-       value = m_dep.is_ready();
-       return;
-     }
+    future_int m_dep;
+    using value_type = bool;
+    KOKKOS_INLINE_FUNCTION
+    void operator()(typename Scheduler::member_type&, bool& value) {
+      // if it was "transiently" ready, this could be false even if we made it a
+      // dependence of this task
+      value = m_dep.is_ready();
+      return;
+    }
   };
-     
 
   struct TestComputeValue {
     using value_type = int;
@@ -809,7 +742,7 @@ struct TestMultipleDependence {
     void operator()(typename Scheduler::member_type&, int& result) {
       double value = 0;
       // keep this one busy for a while
-      for(int i = 0; i < 10000; ++i) {
+      for (int i = 0; i < 10000; ++i) {
         value += i * i / 7.138 / value;
       }
       // Do something irrelevant
@@ -818,40 +751,40 @@ struct TestMultipleDependence {
     }
   };
 
-
   KOKKOS_INLINE_FUNCTION
-  void operator()(typename sched_type::member_type & member, bool& value)
-  {
-    if(m_result_futures[0].is_null()) {
+  void operator()(typename sched_type::member_type& member, bool& value) {
+    if (m_result_futures[0].is_null()) {
       if (m_depth == 0) {
         // Spawn one expensive task at the root
-        m_dep = Kokkos::task_spawn(Kokkos::TaskSingle(member.scheduler()), TestComputeValue{});
+        m_dep = Kokkos::task_spawn(Kokkos::TaskSingle(member.scheduler()),
+                                   TestComputeValue{});
       }
 
       // Then check for it to be ready in a whole bunch of other tasks that race
       int n_checkers = NPerDepth;
-      if(m_depth < m_max_depth) {
+      if (m_depth < m_max_depth) {
         n_checkers -= NFanout;
-        for(int i = n_checkers; i < NPerDepth; ++i) {
-          m_result_futures[i] = Kokkos::task_spawn(Kokkos::TaskSingle(member.scheduler()),
-            TestMultipleDependence<Scheduler>(m_depth + 1, m_max_depth, m_dep)
-          );
+        for (int i = n_checkers; i < NPerDepth; ++i) {
+          m_result_futures[i] =
+              Kokkos::task_spawn(Kokkos::TaskSingle(member.scheduler()),
+                                 TestMultipleDependence<Scheduler>(
+                                     m_depth + 1, m_max_depth, m_dep));
         }
       }
 
-      for(int i = 0; i < n_checkers; ++i) {
-        m_result_futures[i] = member.scheduler().spawn(Kokkos::TaskSingle(m_dep), TestCheckReady{m_dep});
+      for (int i = 0; i < n_checkers; ++i) {
+        m_result_futures[i] = member.scheduler().spawn(
+            Kokkos::TaskSingle(m_dep), TestCheckReady{m_dep});
       }
       auto done = member.scheduler().when_all(m_result_futures, NPerDepth);
       Kokkos::respawn(this, done);
 
       return;
-    }
-    else {
+    } else {
       value = true;
-      for(int i = 0; i < NPerDepth; ++i) {
+      for (int i = 0; i < NPerDepth; ++i) {
         value = value && !m_result_futures[i].is_null();
-        if(value) {
+        if (value) {
           value = value && m_result_futures[i].get();
         }
       }
@@ -859,35 +792,31 @@ struct TestMultipleDependence {
     }
   }
 
-  static void run(int depth)
-  {
+  static void run(int depth) {
     typedef typename sched_type::memory_space memory_space;
 
     enum { MemoryCapacity = 1 << 30 };
-    enum { MinBlockSize   =   64 };
-    enum { MaxBlockSize   = 1024 };
+    enum { MinBlockSize = 64 };
+    enum { MaxBlockSize = 1024 };
     enum { SuperBlockSize = 4096 };
 
-    sched_type sched( memory_space()
-                    , MemoryCapacity
-                    , MinBlockSize
-                    , MaxBlockSize
-                    , SuperBlockSize );
-
-    auto f = Kokkos::host_spawn( Kokkos::TaskSingle( sched ), TestMultipleDependence<Scheduler>( 0, depth )  );
+    sched_type sched(memory_space(), MemoryCapacity, MinBlockSize, MaxBlockSize,
+                     SuperBlockSize);
 
-    Kokkos::wait( sched );
+    auto f = Kokkos::host_spawn(Kokkos::TaskSingle(sched),
+                                TestMultipleDependence<Scheduler>(0, depth));
 
-    ASSERT_TRUE( f.get() );
+    Kokkos::wait(sched);
 
+    ASSERT_TRUE(f.get());
   }
 };
 
-}
+}  // namespace TestTaskScheduler
 
 //----------------------------------------------------------------------------
 
-#define KOKKOS_PP_CAT_IMPL(x, y) x ## y
+#define KOKKOS_PP_CAT_IMPL(x, y) x##y
 #define KOKKOS_TEST_WITH_SUFFIX(x, y) KOKKOS_PP_CAT_IMPL(x, y)
 
 #define TEST_SCHEDULER_SUFFIX _deprecated
@@ -902,7 +831,6 @@ struct TestMultipleDependence {
 #undef TEST_SCHEDULER
 #undef TEST_SCHEDULER_SUFFIX
 
-
 #define TEST_SCHEDULER_SUFFIX _single
 #define TEST_SCHEDULER Kokkos::TaskScheduler<TEST_EXECSPACE>
 #include "TestTaskScheduler_single.hpp"
@@ -915,7 +843,6 @@ struct TestMultipleDependence {
 #undef TEST_SCHEDULER
 #undef TEST_SCHEDULER_SUFFIX
 
-
 #define TEST_SCHEDULER_SUFFIX _chase_lev
 #define TEST_SCHEDULER Kokkos::ChaseLevTaskScheduler<TEST_EXECSPACE>
 #include "TestTaskScheduler_single.hpp"
@@ -924,39 +851,41 @@ struct TestMultipleDependence {
 
 #if 0
 #define TEST_SCHEDULER_SUFFIX _fixed_mempool
-#define TEST_SCHEDULER \
-      Kokkos::SimpleTaskScheduler< \
-        TEST_EXECSPACE, \
-        Kokkos::Impl::SingleTaskQueue< \
-          TEST_EXECSPACE, \
-          Kokkos::Impl::default_tasking_memory_space_for_execution_space_t<TEST_EXECSPACE>, \
-          Kokkos::Impl::TaskQueueTraitsLockBased, \
-          Kokkos::Impl::FixedBlockSizeMemoryPool< \
-            Kokkos::Device<TEST_EXECSPACE, Kokkos::Impl::default_tasking_memory_space_for_execution_space_t<TEST_EXECSPACE>>, \
-            128, \
-            16 \
-          > \
-        > \
-      >
+#define TEST_SCHEDULER                                                      \
+  Kokkos::SimpleTaskScheduler<                                              \
+      TEST_EXECSPACE,                                                       \
+      Kokkos::Impl::SingleTaskQueue<                                        \
+          TEST_EXECSPACE,                                                   \
+          Kokkos::Impl::default_tasking_memory_space_for_execution_space_t< \
+              TEST_EXECSPACE>,                                              \
+          Kokkos::Impl::TaskQueueTraitsLockBased,                           \
+          Kokkos::Impl::FixedBlockSizeMemoryPool<                           \
+              Kokkos::Device<                                               \
+                  TEST_EXECSPACE,                                           \
+                  Kokkos::Impl::                                            \
+                      default_tasking_memory_space_for_execution_space_t<   \
+                          TEST_EXECSPACE>>,                                 \
+              128, 16>>>
 #include "TestTaskScheduler_single.hpp"
 #undef TEST_SCHEDULER
 #undef TEST_SCHEDULER_SUFFIX
 
 #define TEST_SCHEDULER_SUFFIX _fixed_mempool_multiple
-#define TEST_SCHEDULER \
-      Kokkos::SimpleTaskScheduler< \
-        TEST_EXECSPACE, \
-        Kokkos::Impl::MultipleTaskQueue< \
-          TEST_EXECSPACE, \
-          Kokkos::Impl::default_tasking_memory_space_for_execution_space_t<TEST_EXECSPACE>, \
-          Kokkos::Impl::TaskQueueTraitsLockBased, \
-          Kokkos::Impl::FixedBlockSizeMemoryPool< \
-            Kokkos::Device<TEST_EXECSPACE, Kokkos::Impl::default_tasking_memory_space_for_execution_space_t<TEST_EXECSPACE>>, \
-            128, \
-            16 \
-          > \
-        > \
-      >
+#define TEST_SCHEDULER                                                      \
+  Kokkos::SimpleTaskScheduler<                                              \
+      TEST_EXECSPACE,                                                       \
+      Kokkos::Impl::MultipleTaskQueue<                                      \
+          TEST_EXECSPACE,                                                   \
+          Kokkos::Impl::default_tasking_memory_space_for_execution_space_t< \
+              TEST_EXECSPACE>,                                              \
+          Kokkos::Impl::TaskQueueTraitsLockBased,                           \
+          Kokkos::Impl::FixedBlockSizeMemoryPool<                           \
+              Kokkos::Device<                                               \
+                  TEST_EXECSPACE,                                           \
+                  Kokkos::Impl::                                            \
+                      default_tasking_memory_space_for_execution_space_t<   \
+                          TEST_EXECSPACE>>,                                 \
+              128, 16>>>
 #include "TestTaskScheduler_single.hpp"
 #undef TEST_SCHEDULER
 #undef TEST_SCHEDULER_SUFFIX
@@ -965,6 +894,5 @@ struct TestMultipleDependence {
 #undef KOKKOS_TEST_WITH_SUFFIX
 #undef KOKKOS_PP_CAT_IMPL
 
-#endif // #if defined( KOKKOS_ENABLE_TASKDAG )
-#endif // #ifndef KOKKOS_UNITTEST_TASKSCHEDULER_HPP
-
+#endif  // #if defined( KOKKOS_ENABLE_TASKDAG )
+#endif  // #ifndef KOKKOS_UNITTEST_TASKSCHEDULER_HPP
diff --git a/lib/kokkos/core/unit_test/TestTaskScheduler_single.hpp b/lib/kokkos/core/unit_test/TestTaskScheduler_single.hpp
index 6ac9a6d74038dba76007f9a6e6c1d62f177abf44..c5d05382f8f26cd6c55d02a53ae4f3c16c45bf50 100644
--- a/lib/kokkos/core/unit_test/TestTaskScheduler_single.hpp
+++ b/lib/kokkos/core/unit_test/TestTaskScheduler_single.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,50 +44,49 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_fib, TEST_SCHEDULER_SUFFIX) )
-{
-  const int N = 27 ;
-  for ( int i = 0; i < N; ++i ) {
-    TestTaskScheduler::TestFib< TEST_SCHEDULER >::run( i , ( i + 1 ) * ( i + 1 ) * 64000 );
+TEST(TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_fib, TEST_SCHEDULER_SUFFIX)) {
+  const int N = 27;
+  for (int i = 0; i < N; ++i) {
+    TestTaskScheduler::TestFib<TEST_SCHEDULER>::run(i,
+                                                    (i + 1) * (i + 1) * 64000);
   }
 }
 
-TEST_F( TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_depend, TEST_SCHEDULER_SUFFIX) )
-{
-  for ( int i = 0; i < 25; ++i ) {
-    TestTaskScheduler::TestTaskDependence< TEST_SCHEDULER >::run( i );
+TEST(TEST_CATEGORY,
+     KOKKOS_TEST_WITH_SUFFIX(task_depend, TEST_SCHEDULER_SUFFIX)) {
+  for (int i = 0; i < 25; ++i) {
+    TestTaskScheduler::TestTaskDependence<TEST_SCHEDULER>::run(i);
   }
 }
 
-TEST_F( TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_team, TEST_SCHEDULER_SUFFIX) )
-{
-  TestTaskScheduler::TestTaskTeam< TEST_SCHEDULER >::run( 1000 );
-  //TestTaskScheduler::TestTaskTeamValue< TEST_EXECSPACE >::run( 1000 ); // Put back after testing.
+TEST(TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_team, TEST_SCHEDULER_SUFFIX)) {
+  TestTaskScheduler::TestTaskTeam<TEST_SCHEDULER>::run(1000);
+  // TestTaskScheduler::TestTaskTeamValue< TEST_EXECSPACE >::run( 1000 ); // Put
+  // back after testing.
 }
 
-TEST_F( TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_with_mempool, TEST_SCHEDULER_SUFFIX) )
-{
+TEST(TEST_CATEGORY,
+     KOKKOS_TEST_WITH_SUFFIX(task_with_mempool, TEST_SCHEDULER_SUFFIX)) {
   TestTaskScheduler::TestTaskSpawnWithPool<TEST_SCHEDULER>::run();
 }
 
-TEST_F( TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_multiple_depend, TEST_SCHEDULER_SUFFIX) )
-{
-  for ( int i = 2; i < 6; ++i ) {
-    TestTaskScheduler::TestMultipleDependence<TEST_SCHEDULER>::run( i );
+TEST(TEST_CATEGORY,
+     KOKKOS_TEST_WITH_SUFFIX(task_multiple_depend, TEST_SCHEDULER_SUFFIX)) {
+  for (int i = 2; i < 6; ++i) {
+    TestTaskScheduler::TestMultipleDependence<TEST_SCHEDULER>::run(i);
   }
 }
 
-TEST_F( TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_scheduler_ctors, TEST_SCHEDULER_SUFFIX) )
-{
+TEST(TEST_CATEGORY,
+     KOKKOS_TEST_WITH_SUFFIX(task_scheduler_ctors, TEST_SCHEDULER_SUFFIX)) {
   TEST_SCHEDULER sched;
   TEST_SCHEDULER sched2 = sched;
-  sched = sched2;
+  sched                 = sched2;
 }
 
-TEST_F( TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_scheduer_ctors_device, TEST_SCHEDULER_SUFFIX) )
-{
+TEST(TEST_CATEGORY, KOKKOS_TEST_WITH_SUFFIX(task_scheduer_ctors_device,
+                                            TEST_SCHEDULER_SUFFIX)) {
   TestTaskScheduler::TestTaskCtorsDevice<TEST_SCHEDULER>::run();
 }
 
-
-} // end namespace Test
\ No newline at end of file
+}  // end namespace Test
diff --git a/lib/kokkos/core/unit_test/TestTeam.hpp b/lib/kokkos/core/unit_test/TestTeam.hpp
index ff3977637ca66e02beef86ba339c0216bb505a00..e19c1c160d2625e09dc820a13dcef592b6d9ade1 100644
--- a/lib/kokkos/core/unit_test/TestTeam.hpp
+++ b/lib/kokkos/core/unit_test/TestTeam.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,38 +53,43 @@ namespace Test {
 
 namespace {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct TestTeamPolicy {
-  typedef typename Kokkos::TeamPolicy< ScheduleType,  ExecSpace >::member_type team_member;
-  typedef Kokkos::View< int**, ExecSpace > view_type;
+  typedef typename Kokkos::TeamPolicy<ScheduleType, ExecSpace>::member_type
+      team_member;
+  typedef Kokkos::View<int **, ExecSpace> view_type;
 
   view_type m_flags;
 
-  TestTeamPolicy( const size_t league_size )
-    : m_flags( Kokkos::ViewAllocateWithoutInitializing( "flags" ),
-               Kokkos::TeamPolicy< ScheduleType,  ExecSpace >(1,1).team_size_max( *this, Kokkos::ParallelReduceTag() ),
-               league_size ) {}
+  TestTeamPolicy(const size_t league_size)
+      : m_flags(Kokkos::ViewAllocateWithoutInitializing("flags"),
+                Kokkos::TeamPolicy<ScheduleType, ExecSpace>(1, 1).team_size_max(
+                    *this, Kokkos::ParallelReduceTag()),
+                league_size) {}
 
   struct VerifyInitTag {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_member & member ) const
-  {
-    const int tid = member.team_rank() + member.team_size() * member.league_rank();
-
-    m_flags( member.team_rank(), member.league_rank() ) = tid;
-    static_assert((std::is_same<typename team_member::execution_space,ExecSpace>::value),"TeamMember::execution_space is not the same as TeamPolicy<>::execution_space");
+  void operator()(const team_member &member) const {
+    const int tid =
+        member.team_rank() + member.team_size() * member.league_rank();
+
+    m_flags(member.team_rank(), member.league_rank()) = tid;
+    static_assert(
+        (std::is_same<typename team_member::execution_space, ExecSpace>::value),
+        "TeamMember::execution_space is not the same as "
+        "TeamPolicy<>::execution_space");
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const VerifyInitTag &, const team_member & member ) const
-  {
-    const int tid = member.team_rank() + member.team_size() * member.league_rank();
-
-    if ( tid != m_flags( member.team_rank(), member.league_rank() ) ) {
-      printf( "TestTeamPolicy member(%d,%d) error %d != %d\n",
-               member.league_rank(), member.team_rank(),
-               tid, m_flags( member.team_rank(), member.league_rank() ) );
+  void operator()(const VerifyInitTag &, const team_member &member) const {
+    const int tid =
+        member.team_rank() + member.team_size() * member.league_rank();
+
+    if (tid != m_flags(member.team_rank(), member.league_rank())) {
+      printf("TestTeamPolicy member(%d,%d) error %d != %d\n",
+             member.league_rank(), member.team_rank(), tid,
+             m_flags(member.team_rank(), member.league_rank()));
     }
   }
 
@@ -94,34 +100,39 @@ struct TestTeamPolicy {
   struct NoOpTag {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const NoOpTag &, const team_member & member ) const {}
-
+  void operator()(const NoOpTag &, const team_member &member) const {}
 
   static void test_small_league_size() {
-    int bs = 8; // batch size (number of elements per batch)
-    int ns = 16; // total number of "problems" to process
+    int bs = 8;   // batch size (number of elements per batch)
+    int ns = 16;  // total number of "problems" to process
 
     // Calculate total scratch memory space size.
-    const int level = 0;
-    int mem_size = 960;
+    const int level     = 0;
+    int mem_size        = 960;
     const int num_teams = ns / bs;
-    Kokkos::TeamPolicy< ExecSpace, NoOpTag > policy( num_teams, Kokkos::AUTO() );
+    Kokkos::TeamPolicy<ExecSpace, NoOpTag> policy(num_teams, Kokkos::AUTO());
 
-    Kokkos::parallel_for( policy.set_scratch_size( level, Kokkos::PerTeam( mem_size ), Kokkos::PerThread( 0 ) ),
-                          TestTeamPolicy() );
+    Kokkos::parallel_for(
+        policy.set_scratch_size(level, Kokkos::PerTeam(mem_size),
+                                Kokkos::PerThread(0)),
+        TestTeamPolicy());
   }
 
-  static void test_for( const size_t league_size )
-  {
-    TestTeamPolicy functor( league_size );
-    typedef Kokkos::TeamPolicy< ScheduleType,  ExecSpace > policy_type;
-    typedef Kokkos::TeamPolicy< ScheduleType,  ExecSpace, VerifyInitTag > policy_type_init;
+  static void test_for(const size_t league_size) {
+    TestTeamPolicy functor(league_size);
+    typedef Kokkos::TeamPolicy<ScheduleType, ExecSpace> policy_type;
+    typedef Kokkos::TeamPolicy<ScheduleType, ExecSpace, VerifyInitTag>
+        policy_type_init;
 
-    const int team_size = policy_type(league_size,1).team_size_max( functor, Kokkos::ParallelForTag() );
-    const int team_size_init = policy_type_init(league_size,1).team_size_max( functor, Kokkos::ParallelForTag() );
+    const int team_size = policy_type(league_size, 1)
+                              .team_size_max(functor, Kokkos::ParallelForTag());
+    const int team_size_init =
+        policy_type_init(league_size, 1)
+            .team_size_max(functor, Kokkos::ParallelForTag());
 
-    Kokkos::parallel_for( policy_type( league_size, team_size ), functor );
-    Kokkos::parallel_for( policy_type_init( league_size, team_size_init ), functor );
+    Kokkos::parallel_for(policy_type(league_size, team_size), functor);
+    Kokkos::parallel_for(policy_type_init(league_size, team_size_init),
+                         functor);
 
     test_small_league_size();
   }
@@ -131,53 +142,56 @@ struct TestTeamPolicy {
   typedef long value_type;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_member & member, value_type & update ) const
-  {
+  void operator()(const team_member &member, value_type &update) const {
     update += member.team_rank() + member.team_size() * member.league_rank();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const ReduceTag &, const team_member & member, value_type & update ) const
-  {
-    update += 1 + member.team_rank() + member.team_size() * member.league_rank();
+  void operator()(const ReduceTag &, const team_member &member,
+                  value_type &update) const {
+    update +=
+        1 + member.team_rank() + member.team_size() * member.league_rank();
   }
 
-  static void test_reduce( const size_t league_size )
-  {
-    TestTeamPolicy functor( league_size );
+  static void test_reduce(const size_t league_size) {
+    TestTeamPolicy functor(league_size);
 
-    typedef Kokkos::TeamPolicy< ScheduleType,  ExecSpace > policy_type;
-    typedef Kokkos::TeamPolicy< ScheduleType,  ExecSpace, ReduceTag > policy_type_reduce;
+    typedef Kokkos::TeamPolicy<ScheduleType, ExecSpace> policy_type;
+    typedef Kokkos::TeamPolicy<ScheduleType, ExecSpace, ReduceTag>
+        policy_type_reduce;
 
-    const int team_size = policy_type_reduce(league_size,1).team_size_max( functor, Kokkos::ParallelReduceTag() );
+    const int team_size =
+        policy_type_reduce(league_size, 1)
+            .team_size_max(functor, Kokkos::ParallelReduceTag());
 
     const long N = team_size * league_size;
 
     long total = 0;
 
-    Kokkos::parallel_reduce( policy_type( league_size, team_size ), functor, total );
-    ASSERT_EQ( size_t( ( N - 1 ) * ( N ) ) / 2, size_t( total ) );
+    Kokkos::parallel_reduce(policy_type(league_size, team_size), functor,
+                            total);
+    ASSERT_EQ(size_t((N - 1) * (N)) / 2, size_t(total));
 
-    Kokkos::parallel_reduce( policy_type_reduce( league_size, team_size ), functor, total );
-    ASSERT_EQ( ( size_t( N ) * size_t( N + 1 ) ) / 2, size_t( total ) );
+    Kokkos::parallel_reduce(policy_type_reduce(league_size, team_size), functor,
+                            total);
+    ASSERT_EQ((size_t(N) * size_t(N + 1)) / 2, size_t(total));
   }
 };
 
-} // namespace
+}  // namespace
 
-} // namespace Test
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
 
 namespace Test {
 
-template< typename ScalarType, class DeviceType, class ScheduleType >
-class ReduceTeamFunctor
-{
-public:
-  typedef DeviceType                                           execution_space;
-  typedef Kokkos::TeamPolicy< ScheduleType, execution_space >  policy_type;
-  typedef typename execution_space::size_type                  size_type;
+template <typename ScalarType, class DeviceType, class ScheduleType>
+class ReduceTeamFunctor {
+ public:
+  typedef DeviceType execution_space;
+  typedef Kokkos::TeamPolicy<ScheduleType, execution_space> policy_type;
+  typedef typename execution_space::size_type size_type;
 
   struct value_type {
     ScalarType value[3];
@@ -186,38 +200,37 @@ public:
   const size_type nwork;
 
   KOKKOS_INLINE_FUNCTION
-  ReduceTeamFunctor( const size_type & arg_nwork ) : nwork( arg_nwork ) {}
+  ReduceTeamFunctor(const size_type &arg_nwork) : nwork(arg_nwork) {}
 
   KOKKOS_INLINE_FUNCTION
-  ReduceTeamFunctor( const ReduceTeamFunctor & rhs ) : nwork( rhs.nwork ) {}
+  ReduceTeamFunctor(const ReduceTeamFunctor &rhs) : nwork(rhs.nwork) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & dst ) const
-  {
+  void init(value_type &dst) const {
     dst.value[0] = 0;
     dst.value[1] = 0;
     dst.value[2] = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & dst, const volatile value_type & src ) const
-  {
+  void join(volatile value_type &dst, const volatile value_type &src) const {
     dst.value[0] += src.value[0];
     dst.value[1] += src.value[1];
     dst.value[2] += src.value[2];
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const typename policy_type::member_type ind, value_type & dst ) const
-  {
-    const int thread_rank = ind.team_rank() + ind.team_size() * ind.league_rank();
+  void operator()(const typename policy_type::member_type ind,
+                  value_type &dst) const {
+    const int thread_rank =
+        ind.team_rank() + ind.team_size() * ind.league_rank();
     const int thread_size = ind.team_size() * ind.league_size();
-    const int chunk = ( nwork + thread_size - 1 ) / thread_size;
+    const int chunk       = (nwork + thread_size - 1) / thread_size;
 
-    size_type iwork = chunk * thread_rank;
+    size_type iwork           = chunk * thread_rank;
     const size_type iwork_end = iwork + chunk < nwork ? iwork + chunk : nwork;
 
-    for ( ; iwork < iwork_end; ++iwork ) {
+    for (; iwork < iwork_end; ++iwork) {
       dst.value[0] += 1;
       dst.value[1] += iwork + 1;
       dst.value[2] += nwork - iwork;
@@ -225,248 +238,248 @@ public:
   }
 };
 
-} // namespace Test
+}  // namespace Test
 
 namespace {
 
-template< typename ScalarType, class DeviceType, class ScheduleType >
-class TestReduceTeam
-{
-public:
-  typedef DeviceType                                            execution_space;
-  typedef Kokkos::TeamPolicy< ScheduleType,  execution_space >  policy_type;
-  typedef typename execution_space::size_type                   size_type;
+template <typename ScalarType, class DeviceType, class ScheduleType>
+class TestReduceTeam {
+ public:
+  typedef DeviceType execution_space;
+  typedef Kokkos::TeamPolicy<ScheduleType, execution_space> policy_type;
+  typedef typename execution_space::size_type size_type;
 
-  TestReduceTeam( const size_type & nwork ) { run_test( nwork ); }
+  TestReduceTeam(const size_type &nwork) { run_test(nwork); }
 
-  void run_test( const size_type & nwork )
-  {
-    typedef Test::ReduceTeamFunctor< ScalarType, execution_space, ScheduleType> functor_type;
+  void run_test(const size_type &nwork) {
+    typedef Test::ReduceTeamFunctor<ScalarType, execution_space, ScheduleType>
+        functor_type;
     typedef typename functor_type::value_type value_type;
-    typedef Kokkos::View< value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged > result_type;
+    typedef Kokkos::View<value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+        result_type;
 
     enum { Count = 3 };
     enum { Repeat = 100 };
 
-    value_type result[ Repeat ];
+    value_type result[Repeat];
 
-    const unsigned long nw   = nwork;
-    const unsigned long nsum = nw % 2 ? nw * ( ( nw + 1 ) / 2 )
-                                      : ( nw / 2 ) * ( nw + 1 );
+    const unsigned long nw = nwork;
+    const unsigned long nsum =
+        nw % 2 ? nw * ((nw + 1) / 2) : (nw / 2) * (nw + 1);
 
-    policy_type team_exec( nw, 1 );
+    policy_type team_exec(nw, 1);
 
-    const unsigned team_size   = team_exec.team_size_recommended( functor_type( nwork ), Kokkos::ParallelReduceTag() );
-    const unsigned league_size = ( nwork + team_size - 1 ) / team_size;
+    const unsigned team_size = team_exec.team_size_recommended(
+        functor_type(nwork), Kokkos::ParallelReduceTag());
+    const unsigned league_size = (nwork + team_size - 1) / team_size;
 
-    team_exec = policy_type( league_size, team_size );
+    team_exec = policy_type(league_size, team_size);
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      result_type tmp( & result[i] );
-      Kokkos::parallel_reduce( team_exec, functor_type( nwork ), tmp );
+    for (unsigned i = 0; i < Repeat; ++i) {
+      result_type tmp(&result[i]);
+      Kokkos::parallel_reduce(team_exec, functor_type(nwork), tmp);
     }
 
     execution_space().fence();
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
-      for ( unsigned j = 0; j < Count; ++j ) {
+    for (unsigned i = 0; i < Repeat; ++i) {
+      for (unsigned j = 0; j < Count; ++j) {
         const unsigned long correct = 0 == j % 3 ? nw : nsum;
-        ASSERT_EQ( (ScalarType) correct, result[i].value[j] );
+        ASSERT_EQ((ScalarType)correct, result[i].value[j]);
       }
     }
   }
 };
 
-} // namespace
+}  // namespace
 
 /*--------------------------------------------------------------------------*/
 
 namespace Test {
 
-template< class DeviceType, class ScheduleType >
-class ScanTeamFunctor
-{
-public:
-  typedef DeviceType                                            execution_space;
-  typedef Kokkos::TeamPolicy< ScheduleType,  execution_space >  policy_type;
-  typedef long int                                              value_type;
+template <class DeviceType, class ScheduleType>
+class ScanTeamFunctor {
+ public:
+  typedef DeviceType execution_space;
+  typedef Kokkos::TeamPolicy<ScheduleType, execution_space> policy_type;
+  typedef long int value_type;
 
-  Kokkos::View< value_type, execution_space > accum;
-  Kokkos::View< value_type, execution_space > total;
+  Kokkos::View<value_type, execution_space> accum;
+  Kokkos::View<value_type, execution_space> total;
 
-  ScanTeamFunctor() : accum( "accum" ), total( "total" ) {}
+  ScanTeamFunctor() : accum("accum"), total("total") {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & error ) const { error = 0; }
+  void init(value_type &error) const { error = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  void join( value_type volatile & error, value_type volatile const & input ) const
-  { if ( input ) error = 1; }
+  void join(value_type volatile &error,
+            value_type volatile const &input) const {
+    if (input) error = 1;
+  }
 
   struct JoinMax {
     typedef long int value_type;
 
     KOKKOS_INLINE_FUNCTION
-    void join( value_type volatile & dst, value_type volatile const & input ) const
-    { if ( dst < input ) dst = input; }
+    void join(value_type volatile &dst,
+              value_type volatile const &input) const {
+      if (dst < input) dst = input;
+    }
   };
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const typename policy_type::member_type ind, value_type & error ) const
-  {
-    if ( 0 == ind.league_rank() && 0 == ind.team_rank() ) {
+  void operator()(const typename policy_type::member_type ind,
+                  value_type &error) const {
+    if (0 == ind.league_rank() && 0 == ind.team_rank()) {
       const long int thread_count = ind.league_size() * ind.team_size();
-      total() = ( thread_count * ( thread_count + 1 ) ) / 2;
+      total()                     = (thread_count * (thread_count + 1)) / 2;
     }
 
     // Team max:
-    int long m = (long int) ( ind.league_rank() + ind.team_rank() );
-    ind.team_reduce(  Kokkos::Max<int long>(m) );
-
-    if ( m != ind.league_rank() + ( ind.team_size() - 1 ) ) {
-      printf( "ScanTeamFunctor[%d.%d of %d.%d] reduce_max_answer(%ld) != reduce_max(%ld)\n",
-               ind.league_rank(), ind.team_rank(),
-               ind.league_size(), ind.team_size(),
-               (long int) ( ind.league_rank() + ( ind.team_size() - 1 ) ), m );
+    int long m = (long int)(ind.league_rank() + ind.team_rank());
+    ind.team_reduce(Kokkos::Max<int long>(m));
+
+    if (m != ind.league_rank() + (ind.team_size() - 1)) {
+      printf(
+          "ScanTeamFunctor[%d.%d of %d.%d] reduce_max_answer(%ld) != "
+          "reduce_max(%ld)\n",
+          ind.league_rank(), ind.team_rank(), ind.league_size(),
+          ind.team_size(),
+          (long int)(ind.league_rank() + (ind.team_size() - 1)), m);
     }
 
     // Scan:
-    const long int answer =
-      ( ind.league_rank() + 1 ) * ind.team_rank() + ( ind.team_rank() * ( ind.team_rank() + 1 ) ) / 2;
+    const long int answer = (ind.league_rank() + 1) * ind.team_rank() +
+                            (ind.team_rank() * (ind.team_rank() + 1)) / 2;
 
     const long int result =
-      ind.team_scan( ind.league_rank() + 1 + ind.team_rank() + 1 );
+        ind.team_scan(ind.league_rank() + 1 + ind.team_rank() + 1);
 
     const long int result2 =
-      ind.team_scan( ind.league_rank() + 1 + ind.team_rank() + 1 );
+        ind.team_scan(ind.league_rank() + 1 + ind.team_rank() + 1);
 
-    if ( answer != result || answer != result2 ) {
-      printf( "ScanTeamFunctor[%d.%d of %d.%d] answer(%ld) != scan_first(%ld) or scan_second(%ld)\n",
-              ind.league_rank(), ind.team_rank(),
-              ind.league_size(), ind.team_size(),
-              answer, result, result2 );
+    if (answer != result || answer != result2) {
+      printf(
+          "ScanTeamFunctor[%d.%d of %d.%d] answer(%ld) != scan_first(%ld) or "
+          "scan_second(%ld)\n",
+          ind.league_rank(), ind.team_rank(), ind.league_size(),
+          ind.team_size(), answer, result, result2);
 
       error = 1;
     }
 
-    const long int thread_rank = ind.team_rank() +
-                                 ind.team_size() * ind.league_rank();
-    ind.team_scan( 1 + thread_rank, accum.data() );
+    const long int thread_rank =
+        ind.team_rank() + ind.team_size() * ind.league_rank();
+    ind.team_scan(1 + thread_rank, accum.data());
   }
 };
 
-template< class DeviceType, class ScheduleType >
-class TestScanTeam
-{
-public:
-  typedef DeviceType                                            execution_space;
-  typedef long int                                              value_type;
-  typedef Kokkos::TeamPolicy< ScheduleType,  execution_space >  policy_type;
-  typedef Test::ScanTeamFunctor<DeviceType, ScheduleType>       functor_type;
+template <class DeviceType, class ScheduleType>
+class TestScanTeam {
+ public:
+  typedef DeviceType execution_space;
+  typedef long int value_type;
+  typedef Kokkos::TeamPolicy<ScheduleType, execution_space> policy_type;
+  typedef Test::ScanTeamFunctor<DeviceType, ScheduleType> functor_type;
 
-  TestScanTeam( const size_t nteam ) { run_test( nteam ); }
+  TestScanTeam(const size_t nteam) { run_test(nteam); }
 
-  void run_test( const size_t nteam )
-  {
-    typedef Kokkos::View< long int, Kokkos::HostSpace, Kokkos::MemoryUnmanaged >  result_type;
+  void run_test(const size_t nteam) {
+    typedef Kokkos::View<long int, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+        result_type;
 
     const unsigned REPEAT = 100000;
     unsigned Repeat;
 
-    if ( nteam == 0 ) {
+    if (nteam == 0) {
       Repeat = 1;
-    }
-    else {
-      Repeat = ( REPEAT + nteam - 1 ) / nteam; // Error here.
+    } else {
+      Repeat = (REPEAT + nteam - 1) / nteam;  // Error here.
     }
 
     functor_type functor;
 
-    policy_type team_exec( nteam, 1);
-    team_exec = policy_type(nteam, team_exec.team_size_max(functor, Kokkos::ParallelReduceTag()));
+    policy_type team_exec(nteam, 1);
+    team_exec = policy_type(
+        nteam, team_exec.team_size_max(functor, Kokkos::ParallelReduceTag()));
 
-    for ( unsigned i = 0; i < Repeat; ++i ) {
+    for (unsigned i = 0; i < Repeat; ++i) {
       long int accum = 0;
       long int total = 0;
       long int error = 0;
-      Kokkos::deep_copy( functor.accum, total );
+      Kokkos::deep_copy(functor.accum, total);
 
-      Kokkos::parallel_reduce( team_exec, functor, result_type( & error ) );
+      Kokkos::parallel_reduce(team_exec, functor, result_type(&error));
       DeviceType().fence();
 
-      Kokkos::deep_copy( accum, functor.accum );
-      Kokkos::deep_copy( total, functor.total );
+      Kokkos::deep_copy(accum, functor.accum);
+      Kokkos::deep_copy(total, functor.total);
 
-      ASSERT_EQ( error, 0 );
-      ASSERT_EQ( total, accum );
+      ASSERT_EQ(error, 0);
+      ASSERT_EQ(total, accum);
     }
 
     execution_space().fence();
   }
 };
 
-} // namespace Test
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
 
 namespace Test {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct SharedTeamFunctor {
-
-  typedef ExecSpace                                             execution_space;
-  typedef int                                                   value_type;
-  typedef Kokkos::TeamPolicy< ScheduleType,  execution_space >  policy_type;
+  typedef ExecSpace execution_space;
+  typedef int value_type;
+  typedef Kokkos::TeamPolicy<ScheduleType, execution_space> policy_type;
 
   enum { SHARED_COUNT = 1000 };
 
-  typedef typename ExecSpace::scratch_memory_space  shmem_space;
+  typedef typename ExecSpace::scratch_memory_space shmem_space;
 
   // TBD: MemoryUnmanaged should be the default for shared memory space.
-  typedef Kokkos::View< int*, shmem_space, Kokkos::MemoryUnmanaged > shared_int_array_type;
+  typedef Kokkos::View<int *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int_array_type;
 
   // Tell how much shared memory will be required by this functor.
-  inline
-  unsigned team_shmem_size( int team_size ) const
-  {
-    return shared_int_array_type::shmem_size( SHARED_COUNT ) +
-           shared_int_array_type::shmem_size( SHARED_COUNT );
+  inline unsigned team_shmem_size(int team_size) const {
+    return shared_int_array_type::shmem_size(SHARED_COUNT) +
+           shared_int_array_type::shmem_size(SHARED_COUNT);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const typename policy_type::member_type & ind, value_type & update ) const
-  {
-    const shared_int_array_type shared_A( ind.team_shmem(), SHARED_COUNT );
-    const shared_int_array_type shared_B( ind.team_shmem(), SHARED_COUNT );
-
-    if ( ( shared_A.data() == nullptr && SHARED_COUNT > 0 ) ||
-         ( shared_B.data() == nullptr && SHARED_COUNT > 0 ) )
-    {
-      printf ("member( %d/%d , %d/%d ) Failed to allocate shared memory of size %lu\n"
-             , ind.league_rank()
-             , ind.league_size()
-             , ind.team_rank()
-             , ind.team_size()
-             , static_cast<unsigned long>( SHARED_COUNT )
-             );
-
-      ++update; // Failure to allocate is an error.
-    }
-    else {
-      for ( int i = ind.team_rank(); i < SHARED_COUNT; i += ind.team_size() ) {
+  void operator()(const typename policy_type::member_type &ind,
+                  value_type &update) const {
+    const shared_int_array_type shared_A(ind.team_shmem(), SHARED_COUNT);
+    const shared_int_array_type shared_B(ind.team_shmem(), SHARED_COUNT);
+
+    if ((shared_A.data() == nullptr && SHARED_COUNT > 0) ||
+        (shared_B.data() == nullptr && SHARED_COUNT > 0)) {
+      printf(
+          "member( %d/%d , %d/%d ) Failed to allocate shared memory of size "
+          "%lu\n",
+          ind.league_rank(), ind.league_size(), ind.team_rank(),
+          ind.team_size(), static_cast<unsigned long>(SHARED_COUNT));
+
+      ++update;  // Failure to allocate is an error.
+    } else {
+      for (int i = ind.team_rank(); i < SHARED_COUNT; i += ind.team_size()) {
         shared_A[i] = i + ind.league_rank();
         shared_B[i] = 2 * i + ind.league_rank();
       }
 
       ind.team_barrier();
 
-      if ( ind.team_rank() + 1 == ind.team_size() ) {
-        for ( int i = 0; i < SHARED_COUNT; ++i ) {
-          if ( shared_A[i] != i + ind.league_rank() ) {
+      if (ind.team_rank() + 1 == ind.team_size()) {
+        for (int i = 0; i < SHARED_COUNT; ++i) {
+          if (shared_A[i] != i + ind.league_rank()) {
             ++update;
           }
 
-          if ( shared_B[i] != 2 * i + ind.league_rank() ) {
+          if (shared_B[i] != 2 * i + ind.league_rank()) {
             ++update;
           }
         }
@@ -475,120 +488,130 @@ struct SharedTeamFunctor {
   }
 };
 
-} // namespace Test
+}  // namespace Test
 
 namespace {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct TestSharedTeam {
   TestSharedTeam() { run(); }
 
-  void run()
-  {
+  void run() {
     typedef Test::SharedTeamFunctor<ExecSpace, ScheduleType> Functor;
-    typedef Kokkos::View< typename Functor::value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged > result_type;
+    typedef Kokkos::View<typename Functor::value_type, Kokkos::HostSpace,
+                         Kokkos::MemoryUnmanaged>
+        result_type;
 
-    const size_t team_size = Kokkos::TeamPolicy< ScheduleType, ExecSpace >(8192, 1).team_size_max( Functor(),
-        Kokkos::ParallelReduceTag() );
+    const size_t team_size =
+        Kokkos::TeamPolicy<ScheduleType, ExecSpace>(8192, 1).team_size_max(
+            Functor(), Kokkos::ParallelReduceTag());
 
-    Kokkos::TeamPolicy< ScheduleType, ExecSpace > team_exec( 8192 / team_size, team_size );
+    Kokkos::TeamPolicy<ScheduleType, ExecSpace> team_exec(8192 / team_size,
+                                                          team_size);
 
     typename Functor::value_type error_count = 0;
 
-    Kokkos::parallel_reduce( team_exec, Functor(), result_type( & error_count ) );
+    Kokkos::parallel_reduce(team_exec, Functor(), result_type(&error_count));
     Kokkos::fence();
 
-    ASSERT_EQ( error_count, 0 );
+    ASSERT_EQ(error_count, 0);
   }
 };
 
-} // namespace
+}  // namespace
 
 namespace Test {
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-template< class MemorySpace, class ExecSpace, class ScheduleType >
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+template <class MemorySpace, class ExecSpace, class ScheduleType>
 struct TestLambdaSharedTeam {
   TestLambdaSharedTeam() { run(); }
 
-  void run()
-  {
-    typedef Test::SharedTeamFunctor< ExecSpace, ScheduleType > Functor;
-    //typedef Kokkos::View< typename Functor::value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged > result_type;
-    typedef Kokkos::View< typename Functor::value_type, MemorySpace, Kokkos::MemoryUnmanaged > result_type;
+  void run() {
+    typedef Test::SharedTeamFunctor<ExecSpace, ScheduleType> Functor;
+    // typedef Kokkos::View< typename Functor::value_type, Kokkos::HostSpace,
+    // Kokkos::MemoryUnmanaged > result_type;
+    typedef Kokkos::View<typename Functor::value_type, MemorySpace,
+                         Kokkos::MemoryUnmanaged>
+        result_type;
 
     typedef typename ExecSpace::scratch_memory_space shmem_space;
 
     // TBD: MemoryUnmanaged should be the default for shared memory space.
-    typedef Kokkos::View< int*, shmem_space, Kokkos::MemoryUnmanaged > shared_int_array_type;
+    typedef Kokkos::View<int *, shmem_space, Kokkos::MemoryUnmanaged>
+        shared_int_array_type;
 
     const int SHARED_COUNT = 1000;
-    int team_size = 1;
+    int team_size          = 1;
 
 #ifdef KOKKOS_ENABLE_CUDA
-    if ( std::is_same< ExecSpace, Kokkos::Cuda >::value ) team_size = 128;
+    if (std::is_same<ExecSpace, Kokkos::Cuda>::value) team_size = 128;
 #endif
 
-    Kokkos::TeamPolicy< ScheduleType,  ExecSpace > team_exec( 8192 / team_size, team_size );
-    team_exec = team_exec.set_scratch_size( 0, Kokkos::PerTeam( SHARED_COUNT * 2 * sizeof( int ) ) );
+    Kokkos::TeamPolicy<ScheduleType, ExecSpace> team_exec(8192 / team_size,
+                                                          team_size);
+    team_exec = team_exec.set_scratch_size(
+        0, Kokkos::PerTeam(SHARED_COUNT * 2 * sizeof(int)));
 
     typename Functor::value_type error_count = 0;
 
-    Kokkos::parallel_reduce( team_exec, KOKKOS_LAMBDA
-        ( const typename Kokkos::TeamPolicy< ScheduleType,  ExecSpace >::member_type & ind, int & update )
-    {
-      const shared_int_array_type shared_A( ind.team_shmem(), SHARED_COUNT );
-      const shared_int_array_type shared_B( ind.team_shmem(), SHARED_COUNT );
-
-      if ( ( shared_A.data () == nullptr && SHARED_COUNT > 0 ) ||
-           ( shared_B.data () == nullptr && SHARED_COUNT > 0 ) )
-      {
-        printf( "Failed to allocate shared memory of size %lu\n",
-                static_cast<unsigned long>( SHARED_COUNT ) );
-
-        ++update; // Failure to allocate is an error.
-      }
-      else {
-        for ( int i = ind.team_rank(); i < SHARED_COUNT; i += ind.team_size() ) {
-          shared_A[i] = i + ind.league_rank();
-          shared_B[i] = 2 * i + ind.league_rank();
-        }
+    Kokkos::parallel_reduce(
+        team_exec,
+        KOKKOS_LAMBDA(
+            const typename Kokkos::TeamPolicy<ScheduleType,
+                                              ExecSpace>::member_type &ind,
+            int &update) {
+          const shared_int_array_type shared_A(ind.team_shmem(), SHARED_COUNT);
+          const shared_int_array_type shared_B(ind.team_shmem(), SHARED_COUNT);
+
+          if ((shared_A.data() == nullptr && SHARED_COUNT > 0) ||
+              (shared_B.data() == nullptr && SHARED_COUNT > 0)) {
+            printf("Failed to allocate shared memory of size %lu\n",
+                   static_cast<unsigned long>(SHARED_COUNT));
+
+            ++update;  // Failure to allocate is an error.
+          } else {
+            for (int i = ind.team_rank(); i < SHARED_COUNT;
+                 i += ind.team_size()) {
+              shared_A[i] = i + ind.league_rank();
+              shared_B[i] = 2 * i + ind.league_rank();
+            }
 
-        ind.team_barrier();
+            ind.team_barrier();
 
-        if ( ind.team_rank() + 1 == ind.team_size() ) {
-          for ( int i = 0; i < SHARED_COUNT; ++i ) {
-            if ( shared_A[i] != i + ind.league_rank() ) {
-              ++update;
-            }
+            if (ind.team_rank() + 1 == ind.team_size()) {
+              for (int i = 0; i < SHARED_COUNT; ++i) {
+                if (shared_A[i] != i + ind.league_rank()) {
+                  ++update;
+                }
 
-            if ( shared_B[i] != 2 * i + ind.league_rank() ) {
-              ++update;
+                if (shared_B[i] != 2 * i + ind.league_rank()) {
+                  ++update;
+                }
+              }
             }
           }
-        }
-      }
-    }, result_type( & error_count ) );
+        },
+        result_type(&error_count));
 
     Kokkos::fence();
 
-    ASSERT_EQ( error_count, 0 );
+    ASSERT_EQ(error_count, 0);
   }
 };
 #endif
 #endif
 
-} // namespace Test
+}  // namespace Test
 
 namespace Test {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct ScratchTeamFunctor {
-
-  typedef ExecSpace                                            execution_space;
-  typedef int                                                  value_type;
-  typedef Kokkos::TeamPolicy< ScheduleType, execution_space >  policy_type;
+  typedef ExecSpace execution_space;
+  typedef int value_type;
+  typedef Kokkos::TeamPolicy<ScheduleType, execution_space> policy_type;
 
   enum { SHARED_TEAM_COUNT = 100 };
   enum { SHARED_THREAD_COUNT = 10 };
@@ -596,54 +619,58 @@ struct ScratchTeamFunctor {
   typedef typename ExecSpace::scratch_memory_space shmem_space;
 
   // TBD: MemoryUnmanaged should be the default for shared memory space.
-  typedef Kokkos::View< size_t*, shmem_space, Kokkos::MemoryUnmanaged > shared_int_array_type;
+  typedef Kokkos::View<size_t *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int_array_type;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const typename policy_type::member_type & ind, value_type & update ) const
-  {
-    const shared_int_array_type scratch_ptr( ind.team_scratch( 1 ), 3 * ind.team_size() );
-    const shared_int_array_type scratch_A( ind.team_scratch( 1 ), SHARED_TEAM_COUNT );
-    const shared_int_array_type scratch_B( ind.thread_scratch( 1 ), SHARED_THREAD_COUNT );
-
-    if ( ( scratch_ptr.data() == nullptr ) ||
-         ( scratch_A.  data() == nullptr && SHARED_TEAM_COUNT > 0 ) ||
-         ( scratch_B.  data() == nullptr && SHARED_THREAD_COUNT > 0 ) )
-    {
-      printf( "Failed to allocate shared memory of size %lu\n",
-              static_cast<unsigned long>( SHARED_TEAM_COUNT ) );
-
-      ++update; // Failure to allocate is an error.
-    }
-    else {
-      Kokkos::parallel_for( Kokkos::TeamThreadRange( ind, 0, (int) SHARED_TEAM_COUNT ), [&] ( const int & i ) {
-        scratch_A[i] = i + ind.league_rank();
-      });
-
-      for ( int i = 0; i < SHARED_THREAD_COUNT; i++ ) {
+  void operator()(const typename policy_type::member_type &ind,
+                  value_type &update) const {
+    const shared_int_array_type scratch_ptr(ind.team_scratch(1),
+                                            3 * ind.team_size());
+    const shared_int_array_type scratch_A(ind.team_scratch(1),
+                                          SHARED_TEAM_COUNT);
+    const shared_int_array_type scratch_B(ind.thread_scratch(1),
+                                          SHARED_THREAD_COUNT);
+
+    if ((scratch_ptr.data() == nullptr) ||
+        (scratch_A.data() == nullptr && SHARED_TEAM_COUNT > 0) ||
+        (scratch_B.data() == nullptr && SHARED_THREAD_COUNT > 0)) {
+      printf("Failed to allocate shared memory of size %lu\n",
+             static_cast<unsigned long>(SHARED_TEAM_COUNT));
+
+      ++update;  // Failure to allocate is an error.
+    } else {
+      Kokkos::parallel_for(
+          Kokkos::TeamThreadRange(ind, 0, (int)SHARED_TEAM_COUNT),
+          [&](const int &i) { scratch_A[i] = i + ind.league_rank(); });
+
+      for (int i = 0; i < SHARED_THREAD_COUNT; i++) {
         scratch_B[i] = 10000 * ind.league_rank() + 100 * ind.team_rank() + i;
       }
 
-      scratch_ptr[ind.team_rank()] = (size_t) scratch_A.data();
-      scratch_ptr[ind.team_rank() + ind.team_size()] = (size_t) scratch_B.data();
+      scratch_ptr[ind.team_rank()]                   = (size_t)scratch_A.data();
+      scratch_ptr[ind.team_rank() + ind.team_size()] = (size_t)scratch_B.data();
 
       ind.team_barrier();
 
-      for ( int i = 0; i < SHARED_TEAM_COUNT; i++ ) {
-        if ( scratch_A[i] != size_t( i + ind.league_rank() ) ) ++update;
+      for (int i = 0; i < SHARED_TEAM_COUNT; i++) {
+        if (scratch_A[i] != size_t(i + ind.league_rank())) ++update;
       }
 
-      for ( int i = 0; i < ind.team_size(); i++ ) {
-        if ( scratch_ptr[0] != scratch_ptr[i] ) ++update;
+      for (int i = 0; i < ind.team_size(); i++) {
+        if (scratch_ptr[0] != scratch_ptr[i]) ++update;
       }
 
-      if ( scratch_ptr[1 + ind.team_size()] - scratch_ptr[0 + ind.team_size()] < SHARED_THREAD_COUNT * sizeof( size_t ) ) {
+      if (scratch_ptr[1 + ind.team_size()] - scratch_ptr[0 + ind.team_size()] <
+          SHARED_THREAD_COUNT * sizeof(size_t)) {
         ++update;
       }
 
-      for ( int i = 1; i < ind.team_size(); i++ ) {
-        if ( ( scratch_ptr[i + ind.team_size()] - scratch_ptr[i - 1 + ind.team_size()] ) !=
-             ( scratch_ptr[1 + ind.team_size()] - scratch_ptr[0 + ind.team_size()] ) )
-        {
+      for (int i = 1; i < ind.team_size(); i++) {
+        if ((scratch_ptr[i + ind.team_size()] -
+             scratch_ptr[i - 1 + ind.team_size()]) !=
+            (scratch_ptr[1 + ind.team_size()] -
+             scratch_ptr[0 + ind.team_size()])) {
           ++update;
         }
       }
@@ -651,129 +678,164 @@ struct ScratchTeamFunctor {
   }
 };
 
-} // namespace Test
+}  // namespace Test
 
 namespace {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct TestScratchTeam {
   TestScratchTeam() { run(); }
 
-  void run()
-  {
+  void run() {
     typedef Test::ScratchTeamFunctor<ExecSpace, ScheduleType> Functor;
-    typedef Kokkos::View< typename Functor::value_type, Kokkos::HostSpace, Kokkos::MemoryUnmanaged >  result_type;
-    typedef Kokkos::TeamPolicy< ScheduleType,  ExecSpace > p_type;
-
+    typedef Kokkos::View<typename Functor::value_type, Kokkos::HostSpace,
+                         Kokkos::MemoryUnmanaged>
+        result_type;
+    typedef Kokkos::TeamPolicy<ScheduleType, ExecSpace> p_type;
 
     typename Functor::value_type error_count = 0;
 
-    int thread_scratch_size = Functor::shared_int_array_type::shmem_size( Functor::SHARED_THREAD_COUNT );
+    int thread_scratch_size = Functor::shared_int_array_type::shmem_size(
+        Functor::SHARED_THREAD_COUNT);
 
-    p_type team_exec = p_type(8192,1).set_scratch_size( 1, Kokkos::PerTeam( Functor::shared_int_array_type::shmem_size( Functor::SHARED_TEAM_COUNT ) ),
-                                                           Kokkos::PerThread( thread_scratch_size + 3*sizeof(int)));
+    p_type team_exec = p_type(8192, 1).set_scratch_size(
+        1,
+        Kokkos::PerTeam(Functor::shared_int_array_type::shmem_size(
+            Functor::SHARED_TEAM_COUNT)),
+        Kokkos::PerThread(thread_scratch_size + 3 * sizeof(int)));
 
-    const size_t team_size = team_exec.team_size_max( Functor(), Kokkos::ParallelReduceTag() );
+    const size_t team_size =
+        team_exec.team_size_max(Functor(), Kokkos::ParallelReduceTag());
 
-    int team_scratch_size   = Functor::shared_int_array_type::shmem_size( Functor::SHARED_TEAM_COUNT ) +
-                              Functor::shared_int_array_type::shmem_size( 3 * team_size );
+    int team_scratch_size =
+        Functor::shared_int_array_type::shmem_size(Functor::SHARED_TEAM_COUNT) +
+        Functor::shared_int_array_type::shmem_size(3 * team_size);
 
-    team_exec = p_type(8192 / team_size, team_size );
+    team_exec = p_type(8192 / team_size, team_size);
 
-    Kokkos::parallel_reduce( team_exec.set_scratch_size( 1, Kokkos::PerTeam( team_scratch_size ),
-                                                         Kokkos::PerThread( thread_scratch_size ) ),
-                             Functor(), result_type( & error_count ) );
+    Kokkos::parallel_reduce(
+        team_exec.set_scratch_size(1, Kokkos::PerTeam(team_scratch_size),
+                                   Kokkos::PerThread(thread_scratch_size)),
+        Functor(), result_type(&error_count));
     Kokkos::fence();
-    ASSERT_EQ( error_count, 0 );
+    ASSERT_EQ(error_count, 0);
   }
 };
 
-} // namespace
+}  // namespace
 
 namespace Test {
 
-template< class ExecSpace >
-KOKKOS_INLINE_FUNCTION
-int test_team_mulit_level_scratch_loop_body( const typename Kokkos::TeamPolicy<ExecSpace>::member_type& team ) {
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > a_team1( team.team_scratch( 0 ), 128 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > a_thread1( team.thread_scratch( 0 ), 16 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > a_team2( team.team_scratch( 0 ), 128 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > a_thread2( team.thread_scratch( 0 ), 16 );
-
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > b_team1( team.team_scratch( 1 ), 128000 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > b_thread1( team.thread_scratch( 1 ), 16000 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > b_team2( team.team_scratch( 1 ), 128000 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > b_thread2( team.thread_scratch( 1 ), 16000 );
-
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > a_team3( team.team_scratch( 0 ), 128 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > a_thread3( team.thread_scratch( 0 ), 16 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > b_team3( team.team_scratch( 1 ), 128000 );
-  Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> > b_thread3( team.thread_scratch( 1 ), 16000 );
-
-  // The explicit types for 0 and 128 are here to test TeamThreadRange accepting different
-  // types for begin and end.
-  Kokkos::parallel_for( Kokkos::TeamThreadRange( team, int( 0 ), unsigned( 128 ) ), [&] ( const int & i )
-  {
-    a_team1( i ) = 1000000 + i + team.league_rank() * 100000;
-    a_team2( i ) = 2000000 + i + team.league_rank() * 100000;
-    a_team3( i ) = 3000000 + i + team.league_rank() * 100000;
-  });
+template <class ExecSpace>
+KOKKOS_INLINE_FUNCTION int test_team_mulit_level_scratch_loop_body(
+    const typename Kokkos::TeamPolicy<ExecSpace>::member_type &team) {
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      a_team1(team.team_scratch(0), 128);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      a_thread1(team.thread_scratch(0), 16);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      a_team2(team.team_scratch(0), 128);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      a_thread2(team.thread_scratch(0), 16);
+
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      b_team1(team.team_scratch(1), 128000);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      b_thread1(team.thread_scratch(1), 16000);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      b_team2(team.team_scratch(1), 128000);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      b_thread2(team.thread_scratch(1), 16000);
+
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      a_team3(team.team_scratch(0), 128);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      a_thread3(team.thread_scratch(0), 16);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      b_team3(team.team_scratch(1), 128000);
+  Kokkos::View<double *, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+      b_thread3(team.thread_scratch(1), 16000);
+
+  // The explicit types for 0 and 128 are here to test TeamThreadRange accepting
+  // different types for begin and end.
+  Kokkos::parallel_for(Kokkos::TeamThreadRange(team, int(0), unsigned(128)),
+                       [&](const int &i) {
+                         a_team1(i) = 1000000 + i + team.league_rank() * 100000;
+                         a_team2(i) = 2000000 + i + team.league_rank() * 100000;
+                         a_team3(i) = 3000000 + i + team.league_rank() * 100000;
+                       });
   team.team_barrier();
 
-  Kokkos::parallel_for( Kokkos::ThreadVectorRange( team, 16 ), [&] ( const int & i )
-  {
-    a_thread1( i ) = 1000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000;
-    a_thread2( i ) = 2000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000;
-    a_thread3( i ) = 3000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000;
+  Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, 16), [&](const int &i) {
+    a_thread1(i) = 1000000 + 100000 * team.team_rank() + 16 - i +
+                   team.league_rank() * 100000;
+    a_thread2(i) = 2000000 + 100000 * team.team_rank() + 16 - i +
+                   team.league_rank() * 100000;
+    a_thread3(i) = 3000000 + 100000 * team.team_rank() + 16 - i +
+                   team.league_rank() * 100000;
   });
 
-  Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 0, 128000 ), [&] ( const int & i )
-  {
-    b_team1( i ) = 1000000 + i + team.league_rank() * 100000;
-    b_team2( i ) = 2000000 + i + team.league_rank() * 100000;
-    b_team3( i ) = 3000000 + i + team.league_rank() * 100000;
-  });
+  Kokkos::parallel_for(Kokkos::TeamThreadRange(team, 0, 128000),
+                       [&](const int &i) {
+                         b_team1(i) = 1000000 + i + team.league_rank() * 100000;
+                         b_team2(i) = 2000000 + i + team.league_rank() * 100000;
+                         b_team3(i) = 3000000 + i + team.league_rank() * 100000;
+                       });
   team.team_barrier();
 
-  Kokkos::parallel_for( Kokkos::ThreadVectorRange( team, 16000 ), [&] ( const int & i )
-  {
-    b_thread1( i ) = 1000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000;
-    b_thread2( i ) = 2000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000;
-    b_thread3( i ) = 3000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000;
-  });
+  Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, 16000),
+                       [&](const int &i) {
+                         b_thread1(i) = 1000000 + 100000 * team.team_rank() +
+                                        16 - i + team.league_rank() * 100000;
+                         b_thread2(i) = 2000000 + 100000 * team.team_rank() +
+                                        16 - i + team.league_rank() * 100000;
+                         b_thread3(i) = 3000000 + 100000 * team.team_rank() +
+                                        16 - i + team.league_rank() * 100000;
+                       });
 
   team.team_barrier();
 
   int error = 0;
-  Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 0, 128 ), [&] ( const int & i )
-  {
-    if ( a_team1( i ) != 1000000 + i + team.league_rank() * 100000 ) error++;
-    if ( a_team2( i ) != 2000000 + i + team.league_rank() * 100000 ) error++;
-    if ( a_team3( i ) != 3000000 + i + team.league_rank() * 100000 ) error++;
-  });
+  Kokkos::parallel_for(
+      Kokkos::TeamThreadRange(team, 0, 128), [&](const int &i) {
+        if (a_team1(i) != 1000000 + i + team.league_rank() * 100000) error++;
+        if (a_team2(i) != 2000000 + i + team.league_rank() * 100000) error++;
+        if (a_team3(i) != 3000000 + i + team.league_rank() * 100000) error++;
+      });
   team.team_barrier();
 
-  Kokkos::parallel_for( Kokkos::ThreadVectorRange( team, 16 ), [&] ( const int & i )
-  {
-    if ( a_thread1( i ) != 1000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000 ) error++;
-    if ( a_thread2( i ) != 2000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000 ) error++;
-    if ( a_thread3( i ) != 3000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000 ) error++;
+  Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, 16), [&](const int &i) {
+    if (a_thread1(i) != 1000000 + 100000 * team.team_rank() + 16 - i +
+                            team.league_rank() * 100000)
+      error++;
+    if (a_thread2(i) != 2000000 + 100000 * team.team_rank() + 16 - i +
+                            team.league_rank() * 100000)
+      error++;
+    if (a_thread3(i) != 3000000 + 100000 * team.team_rank() + 16 - i +
+                            team.league_rank() * 100000)
+      error++;
   });
 
-  Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 0, 128000 ), [&] ( const int & i )
-  {
-    if ( b_team1( i ) != 1000000 + i + team.league_rank() * 100000 ) error++;
-    if ( b_team2( i ) != 2000000 + i + team.league_rank() * 100000 ) error++;
-    if ( b_team3( i ) != 3000000 + i + team.league_rank() * 100000 ) error++;
-  });
+  Kokkos::parallel_for(
+      Kokkos::TeamThreadRange(team, 0, 128000), [&](const int &i) {
+        if (b_team1(i) != 1000000 + i + team.league_rank() * 100000) error++;
+        if (b_team2(i) != 2000000 + i + team.league_rank() * 100000) error++;
+        if (b_team3(i) != 3000000 + i + team.league_rank() * 100000) error++;
+      });
   team.team_barrier();
 
-  Kokkos::parallel_for( Kokkos::ThreadVectorRange( team, 16000 ), [&] ( const int & i )
-  {
-    if ( b_thread1( i ) != 1000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000 ) error++;
-    if ( b_thread2( i ) != 2000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000 ) error++;
-    if ( b_thread3( i ) != 3000000 + 100000 * team.team_rank() + 16 - i + team.league_rank() * 100000 ) error++;
-  });
+  Kokkos::parallel_for(
+      Kokkos::ThreadVectorRange(team, 16000), [&](const int &i) {
+        if (b_thread1(i) != 1000000 + 100000 * team.team_rank() + 16 - i +
+                                team.league_rank() * 100000)
+          error++;
+        if (b_thread2(i) != 2000000 + 100000 * team.team_rank() + 16 - i +
+                                team.league_rank() * 100000)
+          error++;
+        if (b_thread3(i) != 3000000 + 100000 * team.team_rank() + 16 - i +
+                                team.league_rank() * 100000)
+          error++;
+      });
 
   return error;
 }
@@ -781,217 +843,293 @@ int test_team_mulit_level_scratch_loop_body( const typename Kokkos::TeamPolicy<E
 struct TagReduce {};
 struct TagFor {};
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct ClassNoShmemSizeFunction {
-  typedef typename Kokkos::TeamPolicy< ExecSpace, ScheduleType >::member_type member_type;
+  typedef typename Kokkos::TeamPolicy<ExecSpace, ScheduleType>::member_type
+      member_type;
 
-  Kokkos::View< int, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
+  Kokkos::View<int, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagFor &, const member_type & team ) const {
-    int error = test_team_mulit_level_scratch_loop_body< ExecSpace >( team );
+  void operator()(const TagFor &, const member_type &team) const {
+    int error = test_team_mulit_level_scratch_loop_body<ExecSpace>(team);
     errors() += error;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const TagReduce &, const member_type & team, int & error ) const {
-    error += test_team_mulit_level_scratch_loop_body< ExecSpace >( team );
+  void operator()(const TagReduce &, const member_type &team,
+                  int &error) const {
+    error += test_team_mulit_level_scratch_loop_body<ExecSpace>(team);
   }
 
   void run() {
-    Kokkos::View< int, ExecSpace > d_errors = Kokkos::View< int, ExecSpace >( "Errors" );
+    Kokkos::View<int, ExecSpace> d_errors =
+        Kokkos::View<int, ExecSpace>("Errors");
     errors = d_errors;
 
-    const int per_team0 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 128 );
-    const int per_thread0 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 16 );
-
-    const int per_team1 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 128000 );
-    const int per_thread1 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 16000 );
+    const int per_team0 =
+        3 *
+        Kokkos::View<double *, ExecSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(128);
+    const int per_thread0 =
+        3 *
+        Kokkos::View<double *, ExecSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(16);
+
+    const int per_team1 =
+        3 * Kokkos::View<
+                double *, ExecSpace,
+                Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(128000);
+    const int per_thread1 =
+        3 * Kokkos::View<
+                double *, ExecSpace,
+                Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(16000);
 
     int team_size = 8;
-    if(team_size > ExecSpace::concurrency())
+    if (team_size > ExecSpace::concurrency())
       team_size = ExecSpace::concurrency();
     {
-      Kokkos::TeamPolicy< TagFor, ExecSpace, ScheduleType > policy( 10, team_size, 16 );
-
-      Kokkos::parallel_for( policy.set_scratch_size( 0, Kokkos::PerTeam( per_team0 ), Kokkos::PerThread( per_thread0 ) ).set_scratch_size( 1, Kokkos::PerTeam( per_team1 ), Kokkos::PerThread( per_thread1 ) ), *this );
+      Kokkos::TeamPolicy<TagFor, ExecSpace, ScheduleType> policy(10, team_size,
+                                                                 16);
+
+      Kokkos::parallel_for(
+          policy
+              .set_scratch_size(0, Kokkos::PerTeam(per_team0),
+                                Kokkos::PerThread(per_thread0))
+              .set_scratch_size(1, Kokkos::PerTeam(per_team1),
+                                Kokkos::PerThread(per_thread1)),
+          *this);
       Kokkos::fence();
 
-      typename Kokkos::View< int, ExecSpace >::HostMirror h_errors = Kokkos::create_mirror_view( d_errors );
-      Kokkos::deep_copy( h_errors, d_errors );
-      ASSERT_EQ( h_errors(), 0 );
+      typename Kokkos::View<int, ExecSpace>::HostMirror h_errors =
+          Kokkos::create_mirror_view(d_errors);
+      Kokkos::deep_copy(h_errors, d_errors);
+      ASSERT_EQ(h_errors(), 0);
     }
 
     {
       int error = 0;
-      Kokkos::TeamPolicy< TagReduce, ExecSpace, ScheduleType > policy( 10, team_size, 16 );
-
-      Kokkos::parallel_reduce( policy.set_scratch_size( 0, Kokkos::PerTeam( per_team0 ), Kokkos::PerThread( per_thread0 ) ).set_scratch_size( 1, Kokkos::PerTeam( per_team1 ), Kokkos::PerThread( per_thread1 ) ), *this, error );
-
-      ASSERT_EQ( error, 0 );
+      Kokkos::TeamPolicy<TagReduce, ExecSpace, ScheduleType> policy(
+          10, team_size, 16);
+
+      Kokkos::parallel_reduce(
+          policy
+              .set_scratch_size(0, Kokkos::PerTeam(per_team0),
+                                Kokkos::PerThread(per_thread0))
+              .set_scratch_size(1, Kokkos::PerTeam(per_team1),
+                                Kokkos::PerThread(per_thread1)),
+          *this, error);
+
+      ASSERT_EQ(error, 0);
     }
   };
 };
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct ClassWithShmemSizeFunction {
-  typedef typename Kokkos::TeamPolicy< ExecSpace, ScheduleType >::member_type member_type;
+  typedef typename Kokkos::TeamPolicy<ExecSpace, ScheduleType>::member_type
+      member_type;
 
-  Kokkos::View< int, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
+  Kokkos::View<int, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagFor &, const member_type & team ) const {
-    int error = test_team_mulit_level_scratch_loop_body< ExecSpace >( team );
+  void operator()(const TagFor &, const member_type &team) const {
+    int error = test_team_mulit_level_scratch_loop_body<ExecSpace>(team);
     errors() += error;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const TagReduce &, const member_type & team, int & error ) const {
-    error += test_team_mulit_level_scratch_loop_body< ExecSpace >( team );
+  void operator()(const TagReduce &, const member_type &team,
+                  int &error) const {
+    error += test_team_mulit_level_scratch_loop_body<ExecSpace>(team);
   }
 
   void run() {
-    Kokkos::View< int, ExecSpace > d_errors = Kokkos::View< int, ExecSpace >( "Errors" );
+    Kokkos::View<int, ExecSpace> d_errors =
+        Kokkos::View<int, ExecSpace>("Errors");
     errors = d_errors;
 
-    const int per_team1 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 128000 );
-    const int per_thread1 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 16000 );
+    const int per_team1 =
+        3 * Kokkos::View<
+                double *, ExecSpace,
+                Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(128000);
+    const int per_thread1 =
+        3 * Kokkos::View<
+                double *, ExecSpace,
+                Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(16000);
 
     int team_size = 8;
-    if(team_size > ExecSpace::concurrency())
+    if (team_size > ExecSpace::concurrency())
       team_size = ExecSpace::concurrency();
 
     {
-      Kokkos::TeamPolicy< TagFor, ExecSpace, ScheduleType > policy( 10, team_size, 16 );
+      Kokkos::TeamPolicy<TagFor, ExecSpace, ScheduleType> policy(10, team_size,
+                                                                 16);
 
-      Kokkos::parallel_for( policy.set_scratch_size( 1, Kokkos::PerTeam( per_team1 ),
-                                                     Kokkos::PerThread( per_thread1 ) ),
-                            *this );
+      Kokkos::parallel_for(
+          policy.set_scratch_size(1, Kokkos::PerTeam(per_team1),
+                                  Kokkos::PerThread(per_thread1)),
+          *this);
       Kokkos::fence();
 
-      typename Kokkos::View< int, ExecSpace >::HostMirror h_errors = Kokkos::create_mirror_view( d_errors );
-      Kokkos::deep_copy( h_errors, d_errors );
-      ASSERT_EQ( h_errors(), 0 );
+      typename Kokkos::View<int, ExecSpace>::HostMirror h_errors =
+          Kokkos::create_mirror_view(d_errors);
+      Kokkos::deep_copy(h_errors, d_errors);
+      ASSERT_EQ(h_errors(), 0);
     }
 
     {
       int error = 0;
-      Kokkos::TeamPolicy< TagReduce, ExecSpace, ScheduleType > policy( 10, team_size, 16 );
+      Kokkos::TeamPolicy<TagReduce, ExecSpace, ScheduleType> policy(
+          10, team_size, 16);
 
-      Kokkos::parallel_reduce( policy.set_scratch_size( 1, Kokkos::PerTeam( per_team1 ),
-                                                        Kokkos::PerThread( per_thread1 ) ),
-                               *this, error );
+      Kokkos::parallel_reduce(
+          policy.set_scratch_size(1, Kokkos::PerTeam(per_team1),
+                                  Kokkos::PerThread(per_thread1)),
+          *this, error);
 
-      ASSERT_EQ( error, 0 );
+      ASSERT_EQ(error, 0);
     }
   };
 
-  unsigned team_shmem_size( int team_size ) const {
-    const int per_team0 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 128 );
-    const int per_thread0 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 16 );
+  unsigned team_shmem_size(int team_size) const {
+    const int per_team0 =
+        3 *
+        Kokkos::View<double *, ExecSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(128);
+    const int per_thread0 =
+        3 *
+        Kokkos::View<double *, ExecSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(16);
     return per_team0 + team_size * per_thread0;
   }
 };
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 void test_team_mulit_level_scratch_test_lambda() {
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-  Kokkos::View< int, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
-  Kokkos::View< int, ExecSpace > d_errors( "Errors" );
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+  Kokkos::View<int, ExecSpace, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
+  Kokkos::View<int, ExecSpace> d_errors("Errors");
   errors = d_errors;
 
-  const int per_team0 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 128 );
-  const int per_thread0 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 16 );
-
-  const int per_team1 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 128000 );
-  const int per_thread1 = 3 * Kokkos::View< double*, ExecSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size( 16000 );
+  const int per_team0 =
+      3 *
+      Kokkos::View<double *, ExecSpace,
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(128);
+  const int per_thread0 =
+      3 *
+      Kokkos::View<double *, ExecSpace,
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(16);
+
+  const int per_team1 =
+      3 * Kokkos::View<
+              double *, ExecSpace,
+              Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(128000);
+  const int per_thread1 =
+      3 *
+      Kokkos::View<double *, ExecSpace,
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >::shmem_size(16000);
 
   int team_size = 8;
-  if(team_size > ExecSpace::concurrency())
+  if (team_size > ExecSpace::concurrency())
     team_size = ExecSpace::concurrency();
 
-  Kokkos::TeamPolicy< ExecSpace, ScheduleType > policy( 10, team_size, 16 );
-
-  Kokkos::parallel_for( policy.set_scratch_size( 0, Kokkos::PerTeam( per_team0 ), Kokkos::PerThread( per_thread0 ) ).set_scratch_size( 1, Kokkos::PerTeam( per_team1 ), Kokkos::PerThread( per_thread1 ) ),
-                        KOKKOS_LAMBDA ( const typename Kokkos::TeamPolicy< ExecSpace >::member_type & team )
-  {
-    int error = test_team_mulit_level_scratch_loop_body< ExecSpace >( team );
-    errors() += error;
-  });
+  Kokkos::TeamPolicy<ExecSpace, ScheduleType> policy(10, team_size, 16);
+
+  Kokkos::parallel_for(
+      policy
+          .set_scratch_size(0, Kokkos::PerTeam(per_team0),
+                            Kokkos::PerThread(per_thread0))
+          .set_scratch_size(1, Kokkos::PerTeam(per_team1),
+                            Kokkos::PerThread(per_thread1)),
+      KOKKOS_LAMBDA(
+          const typename Kokkos::TeamPolicy<ExecSpace>::member_type &team) {
+        int error = test_team_mulit_level_scratch_loop_body<ExecSpace>(team);
+        errors() += error;
+      });
   Kokkos::fence();
 
-  typename Kokkos::View< int, ExecSpace >::HostMirror h_errors = Kokkos::create_mirror_view( errors );
-  Kokkos::deep_copy( h_errors, d_errors );
-  ASSERT_EQ( h_errors(), 0 );
+  typename Kokkos::View<int, ExecSpace>::HostMirror h_errors =
+      Kokkos::create_mirror_view(errors);
+  Kokkos::deep_copy(h_errors, d_errors);
+  ASSERT_EQ(h_errors(), 0);
 
   int error = 0;
-  Kokkos::parallel_reduce( policy.set_scratch_size( 0, Kokkos::PerTeam( per_team0 ), Kokkos::PerThread( per_thread0 ) ).set_scratch_size( 1, Kokkos::PerTeam( per_team1 ), Kokkos::PerThread( per_thread1 ) ),
-                           KOKKOS_LAMBDA ( const typename Kokkos::TeamPolicy< ExecSpace >::member_type & team, int & count )
-  {
-    count += test_team_mulit_level_scratch_loop_body< ExecSpace >( team );
-  }, error );
-  ASSERT_EQ( error, 0 );
+  Kokkos::parallel_reduce(
+      policy
+          .set_scratch_size(0, Kokkos::PerTeam(per_team0),
+                            Kokkos::PerThread(per_thread0))
+          .set_scratch_size(1, Kokkos::PerTeam(per_team1),
+                            Kokkos::PerThread(per_thread1)),
+      KOKKOS_LAMBDA(
+          const typename Kokkos::TeamPolicy<ExecSpace>::member_type &team,
+          int &count) {
+        count += test_team_mulit_level_scratch_loop_body<ExecSpace>(team);
+      },
+      error);
+  ASSERT_EQ(error, 0);
 #endif
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
 
 namespace {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct TestMultiLevelScratchTeam {
   TestMultiLevelScratchTeam() { run(); }
 
-  void run()
-  {
+  void run() {
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-    Test::test_team_mulit_level_scratch_test_lambda< ExecSpace, ScheduleType >();
+    Test::test_team_mulit_level_scratch_test_lambda<ExecSpace, ScheduleType>();
 #endif
-    Test::ClassNoShmemSizeFunction< ExecSpace, ScheduleType > c1;
+    Test::ClassNoShmemSizeFunction<ExecSpace, ScheduleType> c1;
     c1.run();
 
-    Test::ClassWithShmemSizeFunction< ExecSpace, ScheduleType > c2;
+    Test::ClassWithShmemSizeFunction<ExecSpace, ScheduleType> c2;
     c2.run();
   }
 };
 
-} // namespace
+}  // namespace
 
 namespace Test {
 
-template< class ExecSpace >
+template <class ExecSpace>
 struct TestShmemSize {
   TestShmemSize() { run(); }
 
-  void run()
-  {
-    typedef Kokkos::View< long***, ExecSpace > view_type;
+  void run() {
+    typedef Kokkos::View<long ***, ExecSpace> view_type;
 
     size_t d1 = 5;
     size_t d2 = 6;
     size_t d3 = 7;
 
-    size_t size = view_type::shmem_size( d1, d2, d3 );
+    size_t size = view_type::shmem_size(d1, d2, d3);
 
-    ASSERT_EQ( size, (d1 * d2 * d3 + 1)* sizeof( long ) );
+    ASSERT_EQ(size, (d1 * d2 * d3 + 1) * sizeof(long));
 
     test_layout_stride();
   }
 
-  void test_layout_stride()
-  {
-    int rank = 3;
-    int order[3] = {2, 0, 1};
+  void test_layout_stride() {
+    int rank       = 3;
+    int order[3]   = {2, 0, 1};
     int extents[3] = {100, 10, 3};
-    auto s1 = Kokkos::View<double***, Kokkos::LayoutStride, ExecSpace>::shmem_size(Kokkos::LayoutStride::order_dimensions(rank, order, extents));
-    auto s2 = Kokkos::View<double***, Kokkos::LayoutRight, ExecSpace>::shmem_size(extents[0], extents[1], extents[2]);
+    auto s1 =
+        Kokkos::View<double ***, Kokkos::LayoutStride, ExecSpace>::shmem_size(
+            Kokkos::LayoutStride::order_dimensions(rank, order, extents));
+    auto s2 =
+        Kokkos::View<double ***, Kokkos::LayoutRight, ExecSpace>::shmem_size(
+            extents[0], extents[1], extents[2]);
     ASSERT_EQ(s1, s2);
   }
 };
 
-} // namespace Test
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
 
@@ -999,38 +1137,39 @@ namespace Test {
 
 namespace {
 
-template< class ExecSpace, class ScheduleType >
+template <class ExecSpace, class ScheduleType>
 struct TestTeamBroadcast {
-  typedef typename Kokkos::TeamPolicy< ScheduleType,  ExecSpace >::member_type team_member;
+  typedef typename Kokkos::TeamPolicy<ScheduleType, ExecSpace>::member_type
+      team_member;
 
-  TestTeamBroadcast( const size_t league_size ) {}
+  TestTeamBroadcast(const size_t league_size) {}
 
   struct BroadcastTag {};
 
   typedef long value_type;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const team_member &teamMember, value_type &update ) const
-  {
+  void operator()(const team_member &teamMember, value_type &update) const {
     int lid = teamMember.league_rank();
     int tid = teamMember.team_rank();
     int ts  = teamMember.team_size();
 
     value_type parUpdate = 0;
     value_type value     = tid * 3 + 1;
-	
-    teamMember.team_broadcast(value, lid%ts); 
 
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( teamMember, ts ), [&] ( const int j, value_type &teamUpdate ) {
-      teamUpdate += value;
-    }, parUpdate );
+    teamMember.team_broadcast(value, lid % ts);
 
-    if ( teamMember.team_rank() == 0 ) update += parUpdate;
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(teamMember, ts),
+        [&](const int j, value_type &teamUpdate) { teamUpdate += value; },
+        parUpdate);
+
+    if (teamMember.team_rank() == 0) update += parUpdate;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const BroadcastTag &, const team_member &teamMember, value_type &update ) const
-  {
+  void operator()(const BroadcastTag &, const team_member &teamMember,
+                  value_type &update) const {
     int lid = teamMember.league_rank();
     int tid = teamMember.team_rank();
     int ts  = teamMember.team_size();
@@ -1038,77 +1177,97 @@ struct TestTeamBroadcast {
     value_type parUpdate = 0;
     value_type value     = tid * 3 + 1;
 
-    teamMember.team_broadcast([&] (value_type & var) { var*=2; }, value, lid%ts);
-    
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( teamMember, ts ), [&] ( const int j, value_type &teamUpdate ) {
-      teamUpdate += value;
-    }, parUpdate );
+    teamMember.team_broadcast([&](value_type &var) { var *= 2; }, value,
+                              lid % ts);
+
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(teamMember, ts),
+        [&](const int j, value_type &teamUpdate) { teamUpdate += value; },
+        parUpdate);
 
-    if ( teamMember.team_rank() == 0 ) update += parUpdate;
+    if (teamMember.team_rank() == 0) update += parUpdate;
   }
 
-  static void test_teambroadcast( const size_t league_size )
-  {
-    TestTeamBroadcast functor( league_size );
+  static void test_teambroadcast(const size_t league_size) {
+    TestTeamBroadcast functor(league_size);
 
-    typedef Kokkos::TeamPolicy< ScheduleType, ExecSpace > policy_type;
-    typedef Kokkos::TeamPolicy< ScheduleType, ExecSpace, BroadcastTag > policy_type_f;
+    typedef Kokkos::TeamPolicy<ScheduleType, ExecSpace> policy_type;
+    typedef Kokkos::TeamPolicy<ScheduleType, ExecSpace, BroadcastTag>
+        policy_type_f;
 
-    const int team_size = policy_type_f(league_size,1).team_size_max( functor, Kokkos::ParallelReduceTag() ); //printf("team_size=%d\n",team_size);
+    const int team_size =
+        policy_type_f(league_size, 1)
+            .team_size_max(
+                functor,
+                Kokkos::
+                    ParallelReduceTag());  // printf("team_size=%d\n",team_size);
 
-    //team_broadcast with value
+    // team_broadcast with value
     long total = 0;
 
-    Kokkos::parallel_reduce( policy_type( league_size, team_size ), functor, total );
-    
+    Kokkos::parallel_reduce(policy_type(league_size, team_size), functor,
+                            total);
+
     value_type expected_result = 0;
-    for (unsigned int i=0; i<league_size; i++){
-      value_type val  = ((i%team_size)*3+1)*team_size;
-      expected_result+= val;
+    for (unsigned int i = 0; i < league_size; i++) {
+      value_type val = ((i % team_size) * 3 + 1) * team_size;
+      expected_result += val;
     }
-    ASSERT_EQ( size_t( expected_result ), size_t( total ) ); //printf("team_broadcast with value -- expected_result=%d, total=%d\n",expected_result, total);
+    ASSERT_EQ(size_t(expected_result),
+              size_t(total));  // printf("team_broadcast with value --
+                               // expected_result=%d,
+                               // total=%d\n",expected_result, total);
 
-    //team_broadcast with function object
+    // team_broadcast with function object
     total = 0;
 
-    Kokkos::parallel_reduce( policy_type_f( league_size, team_size ), functor, total );
+    Kokkos::parallel_reduce(policy_type_f(league_size, team_size), functor,
+                            total);
 
     expected_result = 0;
-    for (unsigned int i=0; i<league_size; i++){
-      value_type val  = ((i%team_size)*3+1)*2*team_size;
-      expected_result+= val;
+    for (unsigned int i = 0; i < league_size; i++) {
+      value_type val = ((i % team_size) * 3 + 1) * 2 * team_size;
+      expected_result += val;
     }
-    ASSERT_EQ( size_t( expected_result ), size_t( total ) ); //printf("team_broadcast with function object -- expected_result=%d, total=%d\n",expected_result, total);
+    ASSERT_EQ(size_t(expected_result),
+              size_t(total));  // printf("team_broadcast with function object --
+                               // expected_result=%d,
+                               // total=%d\n",expected_result, total);
   }
 };
 
-template<class ExecSpace>
+template <class ExecSpace>
 struct TestScratchAlignment {
   struct TestScalar {
-    double x,y,z;
+    double x, y, z;
   };
   TestScratchAlignment() {
     test(true);
     test(false);
   }
-  typedef Kokkos::View<TestScalar*,typename ExecSpace::scratch_memory_space> ScratchView;
-  typedef Kokkos::View<int*,typename ExecSpace::scratch_memory_space> ScratchViewInt;
+  typedef Kokkos::View<TestScalar *, typename ExecSpace::scratch_memory_space>
+      ScratchView;
+  typedef Kokkos::View<int *, typename ExecSpace::scratch_memory_space>
+      ScratchViewInt;
   void test(bool allocate_small) {
     int shmem_size = ScratchView::shmem_size(11);
-    if(allocate_small) shmem_size += ScratchViewInt::shmem_size(1);
-    Kokkos::parallel_for(Kokkos::TeamPolicy<ExecSpace>(1,1).set_scratch_size(0,Kokkos::PerTeam(shmem_size)),
-     KOKKOS_LAMBDA (const typename Kokkos::TeamPolicy<ExecSpace>::member_type& team) {
-     if(allocate_small) ScratchViewInt p(team.team_scratch(0),1);
-     ScratchView a(team.team_scratch(0),11);
-     if(ptrdiff_t(a.data())%sizeof(TestScalar)!=0)
-       Kokkos::abort("Error: invalid scratch view alignment\n");
-    });
+    if (allocate_small) shmem_size += ScratchViewInt::shmem_size(1);
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecSpace>(1, 1).set_scratch_size(
+            0, Kokkos::PerTeam(shmem_size)),
+        KOKKOS_LAMBDA(
+            const typename Kokkos::TeamPolicy<ExecSpace>::member_type &team) {
+          if (allocate_small) ScratchViewInt p(team.team_scratch(0), 1);
+          ScratchView a(team.team_scratch(0), 11);
+          if (ptrdiff_t(a.data()) % sizeof(TestScalar) != 0)
+            Kokkos::abort("Error: invalid scratch view alignment\n");
+        });
     Kokkos::fence();
   }
 };
 
-} // namespace
+}  // namespace
 
-} // namespace Test
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
diff --git a/lib/kokkos/core/unit_test/TestTeamTeamSize.hpp b/lib/kokkos/core/unit_test/TestTeamTeamSize.hpp
index f9d5add5d089a0f76f7e5150361b2a9747cb2263..4a9b7c41a4adba60f304aeffa79e13c09645c5eb 100644
--- a/lib/kokkos/core/unit_test/TestTeamTeamSize.hpp
+++ b/lib/kokkos/core/unit_test/TestTeamTeamSize.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,96 +52,172 @@
 namespace Test {
 
 namespace {
-  template<class T,int N>
-  class MyArray {
-  public:
-    T values[N];
-    KOKKOS_INLINE_FUNCTION
-    void operator+= (const MyArray& src) { for(int i=0; i<N; i++) values[i] += src.values[i]; }
-    KOKKOS_INLINE_FUNCTION
-    void operator=  (const MyArray& src) { for(int i=0; i<N; i++) values[i] =  src.values[i]; }
-    KOKKOS_INLINE_FUNCTION
-    void operator+= (const volatile MyArray& src) volatile { for(int i=0; i<N; i++) values[i] += src.values[i]; }
-    KOKKOS_INLINE_FUNCTION
-    void operator=  (const volatile MyArray& src) volatile { for(int i=0; i<N; i++) values[i] =  src.values[i]; }
-  };
-
-  template<class T,int N, class PolicyType, int S>
-  struct FunctorFor {
-    double static_array[S];
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const typename PolicyType::member_type& team) const {
-    }
-  };
-  template<class T,int N, class PolicyType, int S>
-  struct FunctorReduce {
-    double static_array[S];
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const typename PolicyType::member_type& team, MyArray<T,N>& lval) const {
-      for(int j=0; j<N; j++)
-        lval.values[j] += 1 + lval.values[0];
-    }
-  };
-}
+template <class T, int N>
+class MyArray {
+ public:
+  T values[N];
+  KOKKOS_INLINE_FUNCTION
+  void operator+=(const MyArray& src) {
+    for (int i = 0; i < N; i++) values[i] += src.values[i];
+  }
+  KOKKOS_INLINE_FUNCTION
+  void operator=(const MyArray& src) {
+    for (int i = 0; i < N; i++) values[i] = src.values[i];
+  }
+  KOKKOS_INLINE_FUNCTION
+  void operator+=(const volatile MyArray& src) volatile {
+    for (int i = 0; i < N; i++) values[i] += src.values[i];
+  }
+  KOKKOS_INLINE_FUNCTION
+  void operator=(const volatile MyArray& src) volatile {
+    for (int i = 0; i < N; i++) values[i] = src.values[i];
+  }
+};
 
+template <class T, int N, class PolicyType, int S>
+struct FunctorFor {
+  double static_array[S];
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const typename PolicyType::member_type& team) const {}
+};
+template <class T, int N, class PolicyType, int S>
+struct FunctorReduce {
+  double static_array[S];
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const typename PolicyType::member_type& team,
+                  MyArray<T, N>& lval) const {
+    for (int j = 0; j < N; j++) lval.values[j] += 1 + lval.values[0];
+  }
+};
+}  // namespace
 
 typedef Kokkos::TeamPolicy<TEST_EXECSPACE> policy_type;
-typedef Kokkos::TeamPolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<128,8> > policy_type_128_8;
-typedef Kokkos::TeamPolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<1024,2> > policy_type_1024_2;
+typedef Kokkos::TeamPolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<128, 8> >
+    policy_type_128_8;
+typedef Kokkos::TeamPolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<1024, 2> >
+    policy_type_1024_2;
 
-template<class T, int N, class PolicyType, int S>
+template <class T, int N, class PolicyType, int S>
 void test_team_policy_max_recommended_static_size(int scratch_size) {
-  PolicyType p = PolicyType(10000, Kokkos::AUTO, 4).set_scratch_size(0,Kokkos::PerTeam(scratch_size));
-  int team_size_max_for = p.team_size_max(FunctorFor<T,N,PolicyType,S>(),Kokkos::ParallelForTag());
-  int team_size_rec_for = p.team_size_recommended(FunctorFor<T,N,PolicyType,S>(),Kokkos::ParallelForTag());
-  int team_size_max_reduce = p.team_size_max(FunctorReduce<T,N,PolicyType,S>(),Kokkos::ParallelReduceTag());
-  int team_size_rec_reduce = p.team_size_recommended(FunctorReduce<T,N,PolicyType,S>(),Kokkos::ParallelReduceTag());
-
-  ASSERT_TRUE( team_size_max_for >= team_size_rec_for );
-  ASSERT_TRUE( team_size_max_reduce >= team_size_rec_reduce );
-  ASSERT_TRUE( team_size_max_for >= team_size_max_reduce );
-
-  Kokkos::parallel_for(PolicyType(10000, team_size_max_for, 4).set_scratch_size(0,Kokkos::PerTeam(scratch_size)),
-                       FunctorFor<T,N,PolicyType,S>());
-  Kokkos::parallel_for(PolicyType(10000, team_size_rec_for, 4).set_scratch_size(0,Kokkos::PerTeam(scratch_size)),
-                       FunctorFor<T,N,PolicyType,S>());
-  MyArray<T,N> val;
-  Kokkos::parallel_reduce(PolicyType(10000, team_size_max_reduce, 4).set_scratch_size(0,Kokkos::PerTeam(scratch_size)),
-                       FunctorReduce<T,N,PolicyType,S>(),val);
-  Kokkos::parallel_reduce(PolicyType(10000, team_size_rec_reduce, 4).set_scratch_size(0,Kokkos::PerTeam(scratch_size)),
-                       FunctorReduce<T,N,PolicyType,S>(),val);
+  PolicyType p = PolicyType(10000, Kokkos::AUTO, 4)
+                     .set_scratch_size(0, Kokkos::PerTeam(scratch_size));
+  int team_size_max_for = p.team_size_max(FunctorFor<T, N, PolicyType, S>(),
+                                          Kokkos::ParallelForTag());
+  int team_size_rec_for = p.team_size_recommended(
+      FunctorFor<T, N, PolicyType, S>(), Kokkos::ParallelForTag());
+  int team_size_max_reduce = p.team_size_max(
+      FunctorReduce<T, N, PolicyType, S>(), Kokkos::ParallelReduceTag());
+  int team_size_rec_reduce = p.team_size_recommended(
+      FunctorReduce<T, N, PolicyType, S>(), Kokkos::ParallelReduceTag());
+
+  ASSERT_TRUE(team_size_max_for >= team_size_rec_for);
+  ASSERT_TRUE(team_size_max_reduce >= team_size_rec_reduce);
+  ASSERT_TRUE(team_size_max_for >= team_size_max_reduce);
+
+  Kokkos::parallel_for(PolicyType(10000, team_size_max_for, 4)
+                           .set_scratch_size(0, Kokkos::PerTeam(scratch_size)),
+                       FunctorFor<T, N, PolicyType, S>());
+  Kokkos::parallel_for(PolicyType(10000, team_size_rec_for, 4)
+                           .set_scratch_size(0, Kokkos::PerTeam(scratch_size)),
+                       FunctorFor<T, N, PolicyType, S>());
+  MyArray<T, N> val;
+  Kokkos::parallel_reduce(
+      PolicyType(10000, team_size_max_reduce, 4)
+          .set_scratch_size(0, Kokkos::PerTeam(scratch_size)),
+      FunctorReduce<T, N, PolicyType, S>(), val);
+  Kokkos::parallel_reduce(
+      PolicyType(10000, team_size_rec_reduce, 4)
+          .set_scratch_size(0, Kokkos::PerTeam(scratch_size)),
+      FunctorReduce<T, N, PolicyType, S>(), val);
   Kokkos::fence();
 }
 
-template<class T, int N, class PolicyType>
+template <class T, int N, class PolicyType>
 void test_team_policy_max_recommended(int scratch_size) {
-  test_team_policy_max_recommended_static_size<T,N,PolicyType,1>(scratch_size);
-  test_team_policy_max_recommended_static_size<T,N,PolicyType,1000>(scratch_size);
+  test_team_policy_max_recommended_static_size<T, N, PolicyType, 1>(
+      scratch_size);
+  test_team_policy_max_recommended_static_size<T, N, PolicyType, 1000>(
+      scratch_size);
 }
 
-TEST_F( TEST_CATEGORY, team_policy_max_recommended )
-{
+TEST(TEST_CATEGORY, team_policy_max_recommended) {
   int max_scratch_size = policy_type::scratch_size_max(0);
-  test_team_policy_max_recommended<double,2,policy_type>(0);
-  test_team_policy_max_recommended<double,2,policy_type>(max_scratch_size/3);
-  test_team_policy_max_recommended<double,2,policy_type>(max_scratch_size);
-  test_team_policy_max_recommended<double,2,policy_type_128_8>(0);
-  test_team_policy_max_recommended<double,2,policy_type_128_8>(max_scratch_size/3/8);
-  test_team_policy_max_recommended<double,2,policy_type_128_8>(max_scratch_size/8);
-  test_team_policy_max_recommended<double,2,policy_type_1024_2>(0);
-  test_team_policy_max_recommended<double,2,policy_type_1024_2>(max_scratch_size/3/2);
-  test_team_policy_max_recommended<double,2,policy_type_1024_2>(max_scratch_size/2);
-
-  test_team_policy_max_recommended<double,16,policy_type>(0);
-  test_team_policy_max_recommended<double,16,policy_type>(max_scratch_size/3);
-  test_team_policy_max_recommended<double,16,policy_type>(max_scratch_size);
-  test_team_policy_max_recommended<double,16,policy_type_128_8>(0);
-  test_team_policy_max_recommended<double,16,policy_type_128_8>(max_scratch_size/3/8);
-  test_team_policy_max_recommended<double,16,policy_type_128_8>(max_scratch_size/8);
-  test_team_policy_max_recommended<double,16,policy_type_1024_2>(0);
-  test_team_policy_max_recommended<double,16,policy_type_1024_2>(max_scratch_size/3/2);
-  test_team_policy_max_recommended<double,16,policy_type_1024_2>(max_scratch_size/2);
+  test_team_policy_max_recommended<double, 2, policy_type>(0);
+  test_team_policy_max_recommended<double, 2, policy_type>(max_scratch_size /
+                                                           3);
+  test_team_policy_max_recommended<double, 2, policy_type>(max_scratch_size);
+  test_team_policy_max_recommended<double, 2, policy_type_128_8>(0);
+  test_team_policy_max_recommended<double, 2, policy_type_128_8>(
+      max_scratch_size / 3 / 8);
+  test_team_policy_max_recommended<double, 2, policy_type_128_8>(
+      max_scratch_size / 8);
+  test_team_policy_max_recommended<double, 2, policy_type_1024_2>(0);
+  test_team_policy_max_recommended<double, 2, policy_type_1024_2>(
+      max_scratch_size / 3 / 2);
+  test_team_policy_max_recommended<double, 2, policy_type_1024_2>(
+      max_scratch_size / 2);
+
+  test_team_policy_max_recommended<double, 16, policy_type>(0);
+  test_team_policy_max_recommended<double, 16, policy_type>(max_scratch_size /
+                                                            3);
+  test_team_policy_max_recommended<double, 16, policy_type>(max_scratch_size);
+  test_team_policy_max_recommended<double, 16, policy_type_128_8>(0);
+  test_team_policy_max_recommended<double, 16, policy_type_128_8>(
+      max_scratch_size / 3 / 8);
+  test_team_policy_max_recommended<double, 16, policy_type_128_8>(
+      max_scratch_size / 8);
+  test_team_policy_max_recommended<double, 16, policy_type_1024_2>(0);
+  test_team_policy_max_recommended<double, 16, policy_type_1024_2>(
+      max_scratch_size / 3 / 2);
+  test_team_policy_max_recommended<double, 16, policy_type_1024_2>(
+      max_scratch_size / 2);
 }
 
+template <typename TeamHandleType, typename ReducerValueType>
+struct PrintFunctor1 {
+  KOKKOS_INLINE_FUNCTION void operator()(const TeamHandleType& team,
+                                         ReducerValueType&) const {
+    printf("Test %i %i\n", int(team.league_rank()), int(team.team_rank()));
+  }
+};
+
+template <typename TeamHandleType, typename ReducerValueType>
+struct PrintFunctor2 {
+  KOKKOS_INLINE_FUNCTION void operator()(const TeamHandleType& team,
+                                         ReducerValueType& teamVal) const {
+    printf("Test %i %i\n", int(team.league_rank()), int(team.team_rank()));
+    teamVal += 1;
+  }
+};
+
+TEST(TEST_CATEGORY, team_policy_max_scalar_without_plus_equal_k) {
+  using ExecSpace           = Kokkos::DefaultExecutionSpace;
+  using ReducerType         = Kokkos::MinMax<double, Kokkos::HostSpace>;
+  using ReducerValueType    = typename ReducerType::value_type;
+  using DynamicScheduleType = Kokkos::Schedule<Kokkos::Dynamic>;
+  using TeamPolicyType = Kokkos::TeamPolicy<ExecSpace, DynamicScheduleType>;
+  using TeamHandleType = typename TeamPolicyType::member_type;
+
+  static constexpr int num_teams = 17;
+  ReducerValueType val;
+  ReducerType reducer(val);
+
+  TeamPolicyType p(num_teams, Kokkos::AUTO);
+  PrintFunctor1<TeamHandleType, ReducerValueType> f1;
+  const int max_team_size =
+      p.team_size_max(f1, reducer, Kokkos::ParallelReduceTag());
+
+  const int recommended_team_size =
+      p.team_size_recommended(f1, reducer, Kokkos::ParallelReduceTag());
+
+  printf("Max TeamSize: %i Recommended TeamSize: %i\n", max_team_size,
+         recommended_team_size);
+
+  Kokkos::parallel_reduce(p, f1, reducer);
+  double sum;
+  Kokkos::parallel_reduce(TeamPolicyType(num_teams, Kokkos::AUTO),
+                          PrintFunctor2<TeamHandleType, double>{}, sum);
+  printf("Sum: %lf\n", sum);
+}
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestTeamVector.hpp b/lib/kokkos/core/unit_test/TestTeamVector.hpp
index 46f2c98e37ea2ebe3d07ea82082cdb7ff4dcbf8d..4cf0ceaf475561e2afff33e198e0ebc59fa02a45 100644
--- a/lib/kokkos/core/unit_test/TestTeamVector.hpp
+++ b/lib/kokkos/core/unit_test/TestTeamVector.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,66 +58,66 @@ struct my_complex {
 
   KOKKOS_INLINE_FUNCTION
   my_complex() {
-    re = 0.0;
-    im = 0.0;
+    re    = 0.0;
+    im    = 0.0;
     dummy = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex( const my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex(const my_complex &src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex &operator=(const my_complex &src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const volatile my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex &operator=(const volatile my_complex &src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  volatile my_complex & operator=( const my_complex & src ) volatile {
-    re = src.re;
-    im = src.im;
+  volatile my_complex &operator=(const my_complex &src) volatile {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  volatile my_complex & operator=( const volatile my_complex & src ) volatile {
-    re = src.re;
-    im = src.im;
+  volatile my_complex &operator=(const volatile my_complex &src) volatile {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex( const volatile my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex(const volatile my_complex &src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex( const double & val ) {
-    re = val;
-    im = 0.0;
+  my_complex(const double &val) {
+    re    = val;
+    im    = 0.0;
     dummy = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator+=( const my_complex & src ) {
+  my_complex &operator+=(const my_complex &src) {
     re += src.re;
     im += src.im;
     dummy += src.dummy;
@@ -124,14 +125,14 @@ struct my_complex {
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator+=( const volatile my_complex & src ) volatile {
+  void operator+=(const volatile my_complex &src) volatile {
     re += src.re;
     im += src.im;
     dummy += src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex operator +( const my_complex & src ) {
+  my_complex operator+(const my_complex &src) {
     my_complex tmp = *this;
     tmp.re += src.re;
     tmp.im += src.im;
@@ -140,7 +141,7 @@ struct my_complex {
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex operator+( const volatile my_complex & src ) volatile {
+  my_complex operator+(const volatile my_complex &src) volatile {
     my_complex tmp = *this;
     tmp.re += src.re;
     tmp.im += src.im;
@@ -149,130 +150,133 @@ struct my_complex {
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator*=( const my_complex & src ) {
+  my_complex &operator*=(const my_complex &src) {
     double re_tmp = re * src.re - im * src.im;
     double im_tmp = re * src.im + im * src.re;
-    re = re_tmp;
-    im = im_tmp;
+    re            = re_tmp;
+    im            = im_tmp;
     dummy *= src.dummy;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator*=( const volatile my_complex & src ) volatile {
+  void operator*=(const volatile my_complex &src) volatile {
     double re_tmp = re * src.re - im * src.im;
     double im_tmp = re * src.im + im * src.re;
-    re = re_tmp;
-    im = im_tmp;
+    re            = re_tmp;
+    im            = im_tmp;
     dummy *= src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator==( const my_complex & src ) {
-    return ( re == src.re ) && ( im == src.im ) && ( dummy == src.dummy );
+  bool operator==(const my_complex &src) {
+    return (re == src.re) && (im == src.im) && (dummy == src.dummy);
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator!=( const my_complex & src ) {
-    return ( re != src.re ) || ( im != src.im ) || ( dummy != src.dummy );
+  bool operator!=(const my_complex &src) {
+    return (re != src.re) || (im != src.im) || (dummy != src.dummy);
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator!=( const double & val ) {
-    return ( re != val ) || ( im != 0 ) || ( dummy != 0 );
+  bool operator!=(const double &val) {
+    return (re != val) || (im != 0) || (dummy != 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const int & val ) {
-    re = val;
-    im = 0.0;
+  my_complex &operator=(const int &val) {
+    re    = val;
+    im    = 0.0;
     dummy = 0;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const double & val ) {
-    re = val;
-    im = 0.0;
+  my_complex &operator=(const double &val) {
+    re    = val;
+    im    = 0.0;
     dummy = 0;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  operator double() {
-    return re;
-  }
+  operator double() { return re; }
 };
-}
+}  // namespace TestTeamVector
 
 namespace Kokkos {
-template<>
-struct reduction_identity<TestTeamVector::my_complex > {
+template <>
+struct reduction_identity<TestTeamVector::my_complex> {
   typedef reduction_identity<double> t_red_ident;
-  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVector::my_complex sum()
-      {return TestTeamVector::my_complex(t_red_ident::sum());}
-  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVector::my_complex prod()
-      {return TestTeamVector::my_complex(t_red_ident::prod());}
+  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVector::my_complex sum() {
+    return TestTeamVector::my_complex(t_red_ident::sum());
+  }
+  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVector::my_complex prod() {
+    return TestTeamVector::my_complex(t_red_ident::prod());
+  }
 };
-}
+}  // namespace Kokkos
 
 namespace TestTeamVector {
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_team_for {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_team_for( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_team_for(Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_int;
-  unsigned team_shmem_size( int team_size ) const { return shared_int::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_int::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     typedef typename shmem_space::size_type size_type;
     const size_type shmemSize = team.team_size() * 13;
-    shared_int values = shared_int( team.team_shmem(), shmemSize );
+    shared_int values         = shared_int(team.team_shmem(), shmemSize);
 
-    if ( values.data() == nullptr || values.extent(0) < shmemSize ) {
-      printf( "FAILED to allocate shared memory of size %u\n",
-              static_cast<unsigned int>( shmemSize ) );
-    }
-    else {
+    if (values.data() == nullptr || values.extent(0) < shmemSize) {
+      printf("FAILED to allocate shared memory of size %u\n",
+             static_cast<unsigned int>(shmemSize));
+    } else {
       // Initialize shared memory.
-      values( team.team_rank() ) = 0;
+      values(team.team_rank()) = 0;
 
       // Accumulate value into per thread shared memory.
       // This is non blocking.
-      Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i )
-      {
-        values( team.team_rank() ) += i - team.league_rank() + team.league_size() + team.team_size();
+      Kokkos::parallel_for(Kokkos::TeamThreadRange(team, 131), [&](int i) {
+        values(team.team_rank()) +=
+            i - team.league_rank() + team.league_size() + team.team_size();
       });
 
       // Wait for all memory to be written.
       team.team_barrier();
 
       // One thread per team executes the comparison.
-      Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-      {
-        Scalar test = 0;
+      Kokkos::single(Kokkos::PerTeam(team), [&]() {
+        Scalar test  = 0;
         Scalar value = 0;
 
-        for ( int i = 0; i < 131; ++i ) {
-          test += i - team.league_rank() + team.league_size() + team.team_size();
+        for (int i = 0; i < 131; ++i) {
+          test +=
+              i - team.league_rank() + team.league_size() + team.team_size();
         }
 
-        for ( int i = 0; i < team.team_size(); ++i ) {
-          value += values( i );
+        for (int i = 0; i < team.team_size(); ++i) {
+          value += values(i);
         }
 
-        if ( test != value ) {
-          printf ( "FAILED team_parallel_for %i %i %f %f\n",
-                   team.league_rank(), team.team_rank(),
-                   static_cast<double>( test ), static_cast<double>( value ) );
+        if (test != value) {
+          printf("FAILED team_parallel_for %i %i %f %f\n", team.league_rank(),
+                 team.team_rank(), static_cast<double>(test),
+                 static_cast<double>(value));
           flag() = 1;
         }
       });
@@ -280,58 +284,69 @@ struct functor_team_for {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_team_reduce {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_team_reduce( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_team_reduce(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_scalar_t;
-  unsigned team_shmem_size( int team_size ) const { return shared_scalar_t::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_scalar_t;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_scalar_t::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     Scalar value = Scalar();
-    shared_scalar_t shared_value(team.team_scratch(0),1);
-
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    }, value );
-    
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    }, shared_value(0) );
+    shared_scalar_t shared_value(team.team_scratch(0), 1);
+
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(team, 131),
+        [&](int i, Scalar &val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        value);
+
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(team, 131),
+        [&](int i, Scalar &val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        shared_value(0));
 
     team.team_barrier();
 
-    Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerTeam(team), [&]() {
       Scalar test = 0;
 
-      for ( int i = 0; i < 131; ++i ) {
+      for (int i = 0; i < 131; ++i) {
         test += i - team.league_rank() + team.league_size() + team.team_size();
       }
 
-      if ( test != value ) {
-        if ( team.league_rank() == 0 ) {
-          printf( "FAILED team_parallel_reduce %i %i %lf %lf %lu\n",
-                  team.league_rank(), team.team_rank(),
-                  static_cast<double>( test ), static_cast<double>( value ), sizeof( Scalar ) );
+      if (test != value) {
+        if (team.league_rank() == 0) {
+          printf("FAILED team_parallel_reduce %i %i %lf %lf %lu\n",
+                 team.league_rank(), team.team_rank(),
+                 static_cast<double>(test), static_cast<double>(value),
+                 sizeof(Scalar));
         }
 
         flag() = 1;
       }
-      if ( test != shared_value(0) ) {
-        if ( team.league_rank() == 0 ) {
-          printf( "FAILED team_parallel_reduce with shared result %i %i %lf %lf %lu\n",
-                  team.league_rank(), team.team_rank(),
-                  static_cast<double>( test ), static_cast<double>( shared_value(0) ), sizeof( Scalar ) );
+      if (test != shared_value(0)) {
+        if (team.league_rank() == 0) {
+          printf(
+              "FAILED team_parallel_reduce with shared result %i %i %lf %lf "
+              "%lu\n",
+              team.league_rank(), team.team_rank(), static_cast<double>(test),
+              static_cast<double>(shared_value(0)), sizeof(Scalar));
         }
 
         flag() = 1;
@@ -340,59 +355,65 @@ struct functor_team_reduce {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_team_reduce_reducer {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_team_reduce_reducer( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_team_reduce_reducer(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_scalar_t;
-  unsigned team_shmem_size( int team_size ) const { return shared_scalar_t::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_scalar_t;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_scalar_t::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     Scalar value = 0;
-    shared_scalar_t shared_value(team.team_scratch(0),1);
-
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    },
-      Kokkos::Sum<Scalar>(value)
-    );
-    
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    },
-      Kokkos::Sum<Scalar>(shared_value(0))
-    );
+    shared_scalar_t shared_value(team.team_scratch(0), 1);
+
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(team, 131),
+        [&](int i, Scalar &val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        Kokkos::Sum<Scalar>(value));
+
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(team, 131),
+        [&](int i, Scalar &val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        Kokkos::Sum<Scalar>(shared_value(0)));
 
     team.team_barrier();
 
-    Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerTeam(team), [&]() {
       Scalar test = 0;
 
-      for ( int i = 0; i < 131; ++i ) {
+      for (int i = 0; i < 131; ++i) {
         test += i - team.league_rank() + team.league_size() + team.team_size();
       }
 
-      if ( test != value ) {
-        printf( "FAILED team_vector_parallel_reduce_reducer %i %i %lf %lf\n",
-                team.league_rank(), team.team_rank(),
-                static_cast<double>( test ), static_cast<double>( value ) );
+      if (test != value) {
+        printf("FAILED team_vector_parallel_reduce_reducer %i %i %lf %lf\n",
+               team.league_rank(), team.team_rank(), static_cast<double>(test),
+               static_cast<double>(value));
 
         flag() = 1;
       }
-      if ( test != shared_value(0) ) {
-        printf( "FAILED team_vector_parallel_reduce_reducer shared value %i %i %lf %lf\n",
-                team.league_rank(), team.team_rank(),
-                static_cast<double>( test ), static_cast<double>( shared_value(0) ) );
+      if (test != shared_value(0)) {
+        printf(
+            "FAILED team_vector_parallel_reduce_reducer shared value %i %i %lf "
+            "%lf\n",
+            team.league_rank(), team.team_rank(), static_cast<double>(test),
+            static_cast<double>(shared_value(0)));
 
         flag() = 1;
       }
@@ -400,65 +421,66 @@ struct functor_team_reduce_reducer {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_team_vector_for {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_team_vector_for( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_team_vector_for(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_int;
-  unsigned team_shmem_size( int team_size ) const { return shared_int::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_int::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     typedef typename shared_int::size_type size_type;
 
     const size_type shmemSize = team.team_size() * 13;
-    shared_int values = shared_int( team.team_shmem(), shmemSize );
+    shared_int values         = shared_int(team.team_shmem(), shmemSize);
 
-    if ( values.data() == nullptr || values.extent(0) < shmemSize ) {
-      printf( "FAILED to allocate shared memory of size %u\n",
-              static_cast<unsigned int>( shmemSize ) );
-    }
-    else {
+    if (values.data() == nullptr || values.extent(0) < shmemSize) {
+      printf("FAILED to allocate shared memory of size %u\n",
+             static_cast<unsigned int>(shmemSize));
+    } else {
       team.team_barrier();
 
-      Kokkos::single( Kokkos::PerThread( team ), [&] ()
-      {
-        values( team.team_rank() ) = 0;
-      });
+      Kokkos::single(Kokkos::PerThread(team),
+                     [&]() { values(team.team_rank()) = 0; });
 
-      Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i )
-      {
-        Kokkos::single( Kokkos::PerThread( team ), [&] ()
-        {
-          values( team.team_rank() ) += i - team.league_rank() + team.league_size() + team.team_size();
+      Kokkos::parallel_for(Kokkos::TeamThreadRange(team, 131), [&](int i) {
+        Kokkos::single(Kokkos::PerThread(team), [&]() {
+          values(team.team_rank()) +=
+              i - team.league_rank() + team.league_size() + team.team_size();
         });
       });
 
       team.team_barrier();
 
-      Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-      {
-        Scalar test = 0;
+      Kokkos::single(Kokkos::PerTeam(team), [&]() {
+        Scalar test  = 0;
         Scalar value = 0;
 
-        for ( int i = 0; i < 131; ++i ) {
-          test += i - team.league_rank() + team.league_size() + team.team_size();
+        for (int i = 0; i < 131; ++i) {
+          test +=
+              i - team.league_rank() + team.league_size() + team.team_size();
         }
 
-        for ( int i = 0; i < team.team_size(); ++i ) {
-          value += values( i );
+        for (int i = 0; i < team.team_size(); ++i) {
+          value += values(i);
         }
 
-        if ( test != value ) {
-          printf( "FAILED team_vector_parallel_for %i %i %f %f\n",
-                  team.league_rank(), team.team_rank(),
-                  static_cast<double>( test ), static_cast<double>( value ) );
+        if (test != value) {
+          printf("FAILED team_vector_parallel_for %i %i %f %f\n",
+                 team.league_rank(), team.team_rank(),
+                 static_cast<double>(test), static_cast<double>(value));
 
           flag() = 1;
         }
@@ -467,42 +489,49 @@ struct functor_team_vector_for {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_team_vector_reduce {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
-  functor_team_vector_reduce( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
+  functor_team_vector_reduce(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_int;
-  unsigned team_shmem_size( int team_size ) const { return shared_int::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_int::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     Scalar value = Scalar();
 
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    }, value );
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(team, 131),
+        [&](int i, Scalar &val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        value);
 
     team.team_barrier();
 
-    Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerTeam(team), [&]() {
       Scalar test = 0;
 
-      for ( int i = 0; i < 131; ++i ) {
+      for (int i = 0; i < 131; ++i) {
         test += i - team.league_rank() + team.league_size() + team.team_size();
       }
 
-      if ( test != value ) {
-        if ( team.league_rank() == 0 ) {
-          printf( "FAILED team_vector_parallel_reduce %i %i %f %f %lu\n",
-                  team.league_rank(), team.team_rank(),
-                  static_cast<double>( test ), static_cast<double>( value ), sizeof( Scalar ) );
+      if (test != value) {
+        if (team.league_rank() == 0) {
+          printf("FAILED team_vector_parallel_reduce %i %i %f %f %lu\n",
+                 team.league_rank(), team.team_rank(),
+                 static_cast<double>(test), static_cast<double>(value),
+                 sizeof(Scalar));
         }
 
         flag() = 1;
@@ -511,44 +540,48 @@ struct functor_team_vector_reduce {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_team_vector_reduce_reducer {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_team_vector_reduce_reducer( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_team_vector_reduce_reducer(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_int;
-  unsigned team_shmem_size( int team_size ) const { return shared_int::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_int::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     Scalar value = 0;
 
-    Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    },
-      Kokkos::Sum<Scalar>(value)
-    );
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(team, 131),
+        [&](int i, Scalar &val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        Kokkos::Sum<Scalar>(value));
 
     team.team_barrier();
 
-    Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerTeam(team), [&]() {
       Scalar test = 0;
 
-      for ( int i = 0; i < 131; ++i ) {
-         test += i - team.league_rank() + team.league_size() + team.team_size();
+      for (int i = 0; i < 131; ++i) {
+        test += i - team.league_rank() + team.league_size() + team.team_size();
       }
 
-      if ( test != value ) {
-        printf( "FAILED team_vector_parallel_reduce_reducer %i %i %f %f\n",
-                team.league_rank(), team.team_rank(),
-                static_cast<double>( test ), static_cast<double>( value ) );
+      if (test != value) {
+        printf("FAILED team_vector_parallel_reduce_reducer %i %i %f %f\n",
+               team.league_rank(), team.team_rank(), static_cast<double>(test),
+               static_cast<double>(value));
 
         flag() = 1;
       }
@@ -556,93 +589,97 @@ struct functor_team_vector_reduce_reducer {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_vec_single {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
   int nStart;
   int nEnd;
 
-  functor_vec_single( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_, const int start_, const int end_ ) : 
-                           flag( flag_ ), nStart(start_), nEnd(end_) {}
+  functor_vec_single(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_,
+      const int start_, const int end_)
+      : flag(flag_), nStart(start_), nEnd(end_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     // Warning: this test case intentionally violates permissible semantics.
     // It is not valid to get references to members of the enclosing region
     // inside a parallel_for and write to it.
     Scalar value = 0;
 
-    Kokkos::parallel_for( Kokkos::ThreadVectorRange( team, nStart, nEnd ), [&] ( int i )
-    {
-      value = i; // This write is violating Kokkos semantics for nested parallelism.
-    });
+    Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, nStart, nEnd),
+                         [&](int i) {
+                           value = i;  // This write is violating Kokkos
+                                       // semantics for nested parallelism.
+                         });
 
-    Kokkos::single( Kokkos::PerThread( team ), [&] ( Scalar & val )
-    {
-      val = 1;
-    }, value );
+    Kokkos::single(
+        Kokkos::PerThread(team), [&](Scalar &val) { val = 1; }, value);
 
     Scalar value2 = 0;
-    Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( team, nStart, nEnd ), [&] ( int i, Scalar & val )
-    {
-      val += value;
-    }, value2 );
+    Kokkos::parallel_reduce(
+        Kokkos::ThreadVectorRange(team, nStart, nEnd),
+        [&](int i, Scalar &val) { val += value; }, value2);
 
-    if ( value2 != ( value * (nEnd-nStart) ) ) {
-      printf( "FAILED vector_single broadcast %i %i %f %f\n",
-              team.league_rank(), team.team_rank(), (double) value2, (double) value );
+    if (value2 != (value * (nEnd - nStart))) {
+      printf("FAILED vector_single broadcast %i %i %f %f\n", team.league_rank(),
+             team.team_rank(), (double)value2, (double)value);
 
       flag() = 1;
     }
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_vec_for {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_vec_for( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_vec_for(Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_int;
-  unsigned team_shmem_size( int team_size ) const { return shared_int::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar *, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_int::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
+    shared_int values = shared_int(team.team_shmem(), team.team_size() * 13);
 
-    shared_int values = shared_int( team.team_shmem(), team.team_size() * 13 );
-
-    if ( values.data() == nullptr || values.extent(0) < (unsigned) team.team_size() * 13 ) {
-      printf( "FAILED to allocate memory of size %i\n", static_cast<int>( team.team_size() * 13 ) );
+    if (values.data() == nullptr ||
+        values.extent(0) < (unsigned)team.team_size() * 13) {
+      printf("FAILED to allocate memory of size %i\n",
+             static_cast<int>(team.team_size() * 13));
       flag() = 1;
-    }
-    else {
-      Kokkos::parallel_for( Kokkos::ThreadVectorRange( team, 13 ), [&] ( int i )
-      {
-        values( 13 * team.team_rank() + i ) =
-          i - team.team_rank() - team.league_rank() + team.league_size() + team.team_size();
+    } else {
+      Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, 13), [&](int i) {
+        values(13 * team.team_rank() + i) =
+            i - team.team_rank() - team.league_rank() + team.league_size() +
+            team.team_size();
       });
 
-      Kokkos::single( Kokkos::PerThread( team ), [&] ()
-      {
-        Scalar test = 0;
+      Kokkos::single(Kokkos::PerThread(team), [&]() {
+        Scalar test  = 0;
         Scalar value = 0;
 
-        for ( int i = 0; i < 13; ++i ) {
-          test += i - team.team_rank() - team.league_rank() + team.league_size() + team.team_size();
-          value += values( 13 * team.team_rank() + i );
+        for (int i = 0; i < 13; ++i) {
+          test += i - team.team_rank() - team.league_rank() +
+                  team.league_size() + team.team_size();
+          value += values(13 * team.team_rank() + i);
         }
 
-        if ( test != value ) {
-          printf( "FAILED vector_par_for %i %i %f %f\n",
-                  team.league_rank(), team.team_rank(),
-                  static_cast<double>( test ), static_cast<double>( value ) );
+        if (test != value) {
+          printf("FAILED vector_par_for %i %i %f %f\n", team.league_rank(),
+                 team.team_rank(), static_cast<double>(test),
+                 static_cast<double>(value));
 
           flag() = 1;
         }
@@ -651,34 +688,33 @@ struct functor_vec_for {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_vec_red {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_vec_red( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_vec_red(Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     Scalar value = 0;
 
     // When no reducer is given the default is summation.
-    Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( team, 13 ), [&] ( int i, Scalar & val )
-    {
-      val += i;
-    }, value );
+    Kokkos::parallel_reduce(
+        Kokkos::ThreadVectorRange(team, 13),
+        [&](int i, Scalar &val) { val += i; }, value);
 
-    Kokkos::single( Kokkos::PerThread( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerThread(team), [&]() {
       Scalar test = 0;
 
-      for ( int i = 0; i < 13; i++ ) test += i;
+      for (int i = 0; i < 13; i++) test += i;
 
-      if ( test != value ) {
-        printf( "FAILED vector_par_reduce %i %i %f %f\n",
-                team.league_rank(), team.team_rank(), (double) test, (double) value );
+      if (test != value) {
+        printf("FAILED vector_par_reduce %i %i %f %f\n", team.league_rank(),
+               team.team_rank(), (double)test, (double)value);
 
         flag() = 1;
       }
@@ -686,37 +722,38 @@ struct functor_vec_red {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_vec_red_reducer {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_vec_red_reducer( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_vec_red_reducer(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     // Must initialize to the identity value for the reduce operation
     // for this test:
     //   ( identity, operation ) = ( 1 , *= )
     Scalar value = 1;
 
-    Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( team, 13 ), [&] ( int i, Scalar & val )
-    {
-      val *= ( i % 5 + 1 );
-    }, Kokkos::Prod<Scalar>(value)
-    );
+    Kokkos::parallel_reduce(
+        Kokkos::ThreadVectorRange(team, 13),
+        [&](int i, Scalar &val) { val *= (i % 5 + 1); },
+        Kokkos::Prod<Scalar>(value));
 
-    Kokkos::single( Kokkos::PerThread( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerThread(team), [&]() {
       Scalar test = 1;
 
-      for ( int i = 0; i < 13; i++ ) test *= ( i % 5 + 1 );
+      for (int i = 0; i < 13; i++) test *= (i % 5 + 1);
 
-      if ( test != value ) {
-        printf( "FAILED vector_par_reduce_reducer %i %i %f %f\n",
-                team.league_rank(), team.team_rank(), (double) test, (double) value );
+      if (test != value) {
+        printf("FAILED vector_par_reduce_reducer %i %i %f %f\n",
+               team.league_rank(), team.team_rank(), (double)test,
+               (double)value);
 
         flag() = 1;
       }
@@ -724,288 +761,296 @@ struct functor_vec_red_reducer {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_vec_scan {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
-  functor_vec_scan( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
+  functor_vec_scan(Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
-    Kokkos::parallel_scan( Kokkos::ThreadVectorRange( team, 13 ), [&] ( int i, Scalar & val, bool final )
-    {
-      val += i;
-
-      if ( final ) {
-        Scalar test = 0;
-        for ( int k = 0; k <= i; k++ ) test += k;
-
-        if ( test != val ) {
-          printf( "FAILED vector_par_scan %i %i %f %f\n",
-                  team.league_rank(), team.team_rank(), (double) test, (double) val );
-
-          flag() = 1;
-        }
-      }
-    });
+  void operator()(typename policy_type::member_type team) const {
+    Kokkos::parallel_scan(Kokkos::ThreadVectorRange(team, 13),
+                          [&](int i, Scalar &val, bool final) {
+                            val += i;
+
+                            if (final) {
+                              Scalar test = 0;
+                              for (int k = 0; k <= i; k++) test += k;
+
+                              if (test != val) {
+                                printf("FAILED vector_par_scan %i %i %f %f\n",
+                                       team.league_rank(), team.team_rank(),
+                                       (double)test, (double)val);
+
+                                flag() = 1;
+                              }
+                            }
+                          });
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_reduce {
   typedef double value_type;
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
-  functor_reduce( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
+  functor_reduce(Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team, double & sum ) const {
+  void operator()(typename policy_type::member_type team, double &sum) const {
     sum += team.league_rank() * 100 + team.thread_rank();
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
-bool test_scalar( int nteams, int team_size, int test ) {
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > d_flag( "flag" );
-  typename Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace >::HostMirror h_flag( "h_flag" );
+template <typename Scalar, class ExecutionSpace>
+bool test_scalar(int nteams, int team_size, int test) {
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> d_flag("flag");
+  typename Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace>::HostMirror
+      h_flag("h_flag");
   h_flag() = 0;
-  Kokkos::deep_copy( d_flag, h_flag );
-
-  if ( test == 0 ) {
-    Kokkos::parallel_for( std::string( "A" ), Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_vec_red< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 1 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_vec_red_reducer< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 2 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_vec_scan< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 3 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_vec_for< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 4 ) {
-    Kokkos::parallel_for( "B", Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_vec_single< Scalar, ExecutionSpace >( d_flag, 0, 13 ) );
-  }
-  else if ( test == 5 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size ),
-                          functor_team_for< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 6 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size ),
-                          functor_team_reduce< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 7 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size ),
-                          functor_team_reduce_reducer< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 8 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_team_vector_for< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 9 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_team_vector_reduce< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 10 ) {
-    Kokkos::parallel_for( Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_team_vector_reduce_reducer< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 11 ) {
-    Kokkos::parallel_for( "B", Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_vec_single< Scalar, ExecutionSpace >( d_flag, 4, 13 ) );
+  Kokkos::deep_copy(d_flag, h_flag);
+
+  if (test == 0) {
+    Kokkos::parallel_for(
+        std::string("A"),
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_vec_red<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 1) {
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_vec_red_reducer<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 2) {
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_vec_scan<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 3) {
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_vec_for<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 4) {
+    Kokkos::parallel_for(
+        "B", Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_vec_single<Scalar, ExecutionSpace>(d_flag, 0, 13));
+  } else if (test == 5) {
+    Kokkos::parallel_for(Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size),
+                         functor_team_for<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 6) {
+    Kokkos::parallel_for(Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size),
+                         functor_team_reduce<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 7) {
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size),
+        functor_team_reduce_reducer<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 8) {
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_team_vector_for<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 9) {
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_team_vector_reduce<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 10) {
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_team_vector_reduce_reducer<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 11) {
+    Kokkos::parallel_for(
+        "B", Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_vec_single<Scalar, ExecutionSpace>(d_flag, 4, 13));
   }
 
-  Kokkos::deep_copy( h_flag, d_flag );
+  Kokkos::deep_copy(h_flag, d_flag);
 
-  return ( h_flag() == 0 );
+  return (h_flag() == 0);
 }
 
-template< class ExecutionSpace >
-bool Test( int test ) {
+template <class ExecutionSpace>
+bool Test(int test) {
   bool passed = true;
 
   int team_size = 33;
-  if( team_size > int(ExecutionSpace::concurrency()))
+  if (team_size > int(ExecutionSpace::concurrency()))
     team_size = int(ExecutionSpace::concurrency());
-  passed = passed && test_scalar< int, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< long long int, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< float, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< double, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< my_complex, ExecutionSpace >( 317, team_size, test );
+  passed = passed && test_scalar<int, ExecutionSpace>(317, team_size, test);
+  passed = passed &&
+           test_scalar<long long int, ExecutionSpace>(317, team_size, test);
+  passed = passed && test_scalar<float, ExecutionSpace>(317, team_size, test);
+  passed = passed && test_scalar<double, ExecutionSpace>(317, team_size, test);
+  passed =
+      passed && test_scalar<my_complex, ExecutionSpace>(317, team_size, test);
 
   return passed;
 }
 
-} // namespace TestTeamVector
+}  // namespace TestTeamVector
 
 namespace Test {
 
 // Computes y^T*A*x
 // ( modified from kokkos-tutorials/GTC2016/Exercises/ThreeLevelPar )
 
-#if ( ! defined( KOKKOS_ENABLE_CUDA ) ) || (defined( KOKKOS_ENABLE_CUDA_LAMBDA ) && (8000 <= CUDA_VERSION))
-template< typename ScalarType, class DeviceType >
-class TestTripleNestedReduce
-{
-public:
+#if (!defined(KOKKOS_ENABLE_CUDA)) || \
+    (defined(KOKKOS_ENABLE_CUDA_LAMBDA) && (8000 <= CUDA_VERSION))
+template <typename ScalarType, class DeviceType>
+class TestTripleNestedReduce {
+ public:
   typedef DeviceType execution_space;
   typedef typename execution_space::size_type size_type;
 
-  TestTripleNestedReduce( const size_type & nrows, const size_type & ncols
-                        , const size_type & team_size, const size_type & vector_length )
-  {
-    run_test( nrows, ncols, team_size, vector_length );
+  TestTripleNestedReduce(const size_type &nrows, const size_type &ncols,
+                         const size_type &team_size,
+                         const size_type &vector_length) {
+    run_test(nrows, ncols, team_size, vector_length);
   }
 
-  void run_test( const size_type & nrows, const size_type & ncols
-               , size_type team_size, const size_type & vector_length )
-  {
-    if( team_size > size_type(DeviceType::execution_space::concurrency()))
+  void run_test(const size_type &nrows, const size_type &ncols,
+                size_type team_size, const size_type &vector_length) {
+    if (team_size > size_type(DeviceType::execution_space::concurrency()))
       team_size = size_type(DeviceType::execution_space::concurrency());
 
 #ifdef KOKKOS_ENABLE_HPX
     team_size = 1;
-    if (!std::is_same<execution_space, Kokkos::Experimental::HPX>::value)
-    {
-        team_size = 1;
+    if (!std::is_same<execution_space, Kokkos::Experimental::HPX>::value) {
+      team_size = 1;
     }
 #endif
 
-    //typedef Kokkos::LayoutLeft Layout;
+    // typedef Kokkos::LayoutLeft Layout;
     typedef Kokkos::LayoutRight Layout;
 
-    typedef Kokkos::View< ScalarType*, DeviceType >            ViewVector;
-    typedef Kokkos::View< ScalarType**, Layout, DeviceType >   ViewMatrix;
+    typedef Kokkos::View<ScalarType *, DeviceType> ViewVector;
+    typedef Kokkos::View<ScalarType **, Layout, DeviceType> ViewMatrix;
 
-    ViewVector y( "y", nrows );
-    ViewVector x( "x", ncols );
-    ViewMatrix A( "A", nrows, ncols );
+    ViewVector y("y", nrows);
+    ViewVector x("x", ncols);
+    ViewMatrix A("A", nrows, ncols);
 
     typedef Kokkos::RangePolicy<DeviceType> range_policy;
 
     // Initialize y vector.
-    Kokkos::parallel_for( range_policy( 0, nrows ), KOKKOS_LAMBDA ( const int i ) { y( i ) = 1; } );
+    Kokkos::parallel_for(
+        range_policy(0, nrows), KOKKOS_LAMBDA(const int i) { y(i) = 1; });
 
     // Initialize x vector.
-    Kokkos::parallel_for( range_policy( 0, ncols ), KOKKOS_LAMBDA ( const int i ) { x( i ) = 1; } );
+    Kokkos::parallel_for(
+        range_policy(0, ncols), KOKKOS_LAMBDA(const int i) { x(i) = 1; });
     Kokkos::fence();
 
-    typedef Kokkos::TeamPolicy< DeviceType >                        team_policy;
-    typedef typename Kokkos::TeamPolicy< DeviceType >::member_type  member_type;
+    typedef Kokkos::TeamPolicy<DeviceType> team_policy;
+    typedef typename Kokkos::TeamPolicy<DeviceType>::member_type member_type;
 
     // Initialize A matrix, note 2D indexing computation.
-    Kokkos::parallel_for( team_policy( nrows, Kokkos::AUTO ), KOKKOS_LAMBDA ( const member_type & teamMember ) {
-      const int j = teamMember.league_rank();
-      Kokkos::parallel_for( Kokkos::TeamThreadRange( teamMember, ncols ), [&] ( const int i ) {
-        A( j, i ) = 1;
-      } );
-    } );
+    Kokkos::parallel_for(
+        team_policy(nrows, Kokkos::AUTO),
+        KOKKOS_LAMBDA(const member_type &teamMember) {
+          const int j = teamMember.league_rank();
+          Kokkos::parallel_for(Kokkos::TeamThreadRange(teamMember, ncols),
+                               [&](const int i) { A(j, i) = 1; });
+        });
     Kokkos::fence();
 
     // Three level parallelism kernel to force caching of vector x.
     ScalarType result = 0.0;
-    int chunk_size = 128;
-    Kokkos::parallel_reduce( team_policy( nrows / chunk_size, team_size, vector_length ),
-                             KOKKOS_LAMBDA ( const member_type & teamMember, double & update ) {
-      const int row_start = teamMember.league_rank() * chunk_size;
-      const int row_end   = row_start + chunk_size;
-      Kokkos::parallel_for( Kokkos::TeamThreadRange( teamMember, row_start, row_end ), [&] ( const int i ) {
-        ScalarType sum_i = 0.0;
-        Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( teamMember, ncols ), [&] ( const int j, ScalarType &innerUpdate ) {
-          innerUpdate += A( i, j ) * x( j );
-        }, sum_i );
-        Kokkos::single( Kokkos::PerThread( teamMember ), [&] () {
-          update += y( i ) * sum_i;
-        } );
-      } );
-    }, result );
+    int chunk_size    = 128;
+    Kokkos::parallel_reduce(
+        team_policy(nrows / chunk_size, team_size, vector_length),
+        KOKKOS_LAMBDA(const member_type &teamMember, double &update) {
+          const int row_start = teamMember.league_rank() * chunk_size;
+          const int row_end   = row_start + chunk_size;
+          Kokkos::parallel_for(
+              Kokkos::TeamThreadRange(teamMember, row_start, row_end),
+              [&](const int i) {
+                ScalarType sum_i = 0.0;
+                Kokkos::parallel_reduce(
+                    Kokkos::ThreadVectorRange(teamMember, ncols),
+                    [&](const int j, ScalarType &innerUpdate) {
+                      innerUpdate += A(i, j) * x(j);
+                    },
+                    sum_i);
+                Kokkos::single(Kokkos::PerThread(teamMember),
+                               [&]() { update += y(i) * sum_i; });
+              });
+        },
+        result);
     Kokkos::fence();
 
-    const ScalarType solution = (ScalarType) nrows * (ScalarType) ncols;
-    if ( int64_t(solution) != int64_t(result) ) {
-      printf( "  TestTripleNestedReduce failed solution(%" PRId64 ") != result(%" PRId64 "),"
-              " nrows(%" PRId32 ") ncols(%" PRId32 ") league_size(%" PRId32 ") team_size(%" PRId32 ")\n"
-            , int64_t(solution)
-            , int64_t(result)
-            , int32_t(nrows)
-            , int32_t(ncols)
-            , int32_t(nrows/chunk_size)
-            , int32_t(team_size)
-            );
+    const ScalarType solution = (ScalarType)nrows * (ScalarType)ncols;
+    if (int64_t(solution) != int64_t(result)) {
+      printf("  TestTripleNestedReduce failed solution(%" PRId64
+             ") != result(%" PRId64
+             "),"
+             " nrows(%" PRId32 ") ncols(%" PRId32 ") league_size(%" PRId32
+             ") team_size(%" PRId32 ")\n",
+             int64_t(solution), int64_t(result), int32_t(nrows), int32_t(ncols),
+             int32_t(nrows / chunk_size), int32_t(team_size));
     }
 
-    ASSERT_EQ( solution, result );
+    ASSERT_EQ(solution, result);
   }
 };
 
-#else // #if ( ! defined( KOKKOS_ENABLE_CUDA ) ) || defined( KOKKOS_ENABLE_CUDA_LAMBDA )
+#else  // #if ( ! defined( KOKKOS_ENABLE_CUDA ) ) || defined(
+       // KOKKOS_ENABLE_CUDA_LAMBDA )
 
-template< typename ScalarType, class DeviceType >
-class TestTripleNestedReduce
-{
-public:
+template <typename ScalarType, class DeviceType>
+class TestTripleNestedReduce {
+ public:
   typedef DeviceType execution_space;
   typedef typename execution_space::size_type size_type;
 
-  TestTripleNestedReduce( const size_type &, const size_type
-                        , const size_type &, const size_type )
-  {}
+  TestTripleNestedReduce(const size_type &, const size_type, const size_type &,
+                         const size_type) {}
 };
 
 #endif
-        
+
 #if !defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-TEST_F( TEST_CATEGORY, team_vector )
-{
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 0 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 1 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 2 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 3 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 4 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 5 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 6 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 7 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 8 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 9 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 10 ) ) );
-  ASSERT_TRUE( ( TestTeamVector::Test< TEST_EXECSPACE >( 11 ) ) );
+TEST(TEST_CATEGORY, team_vector) {
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(0)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(1)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(2)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(3)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(4)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(5)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(6)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(7)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(8)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(9)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(10)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(11)));
 }
 #endif
 
 #if !defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-TEST_F( TEST_CATEGORY, triple_nested_parallelism )
-{
+TEST(TEST_CATEGORY, triple_nested_parallelism) {
 // With KOKKOS_DEBUG enabled, the functor uses too many registers to run
-// with a team size of 32 on GPUs, 16 is the max possible (at least on a K80 GPU)
-// See https://github.com/kokkos/kokkos/issues/1513
+// with a team size of 32 on GPUs, 16 is the max possible (at least on a K80
+// GPU) See https://github.com/kokkos/kokkos/issues/1513
 #if defined(KOKKOS_ENABLE_DEBUG) && defined(KOKKOS_ENABLE_CUDA)
   if (!std::is_same<TEST_EXECSPACE, Kokkos::Cuda>::value) {
 #endif
-#ifdef KOKKOS_ENABLE_ROCM // ROCm doesn't support TeamSize 32x32
-  if (!std::is_same<TEST_EXECSPACE, Kokkos::Experimental::ROCm>::value)
+#ifdef KOKKOS_ENABLE_ROCM  // ROCm doesn't support TeamSize 32x32
+    if (!std::is_same<TEST_EXECSPACE, Kokkos::Experimental::ROCm>::value)
 #endif
-  TestTripleNestedReduce< double, TEST_EXECSPACE >( 8192, 2048, 32, 32 );
-  TestTripleNestedReduce< double, TEST_EXECSPACE >( 8192, 2048, 32, 16 );
+      TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 32, 32);
+    TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 32, 16);
 #if defined(KOKKOS_ENABLE_DEBUG) && defined(KOKKOS_ENABLE_CUDA)
   }
 #endif
-  TestTripleNestedReduce< double, TEST_EXECSPACE >( 8192, 2048, 16, 16 );
-  TestTripleNestedReduce< double, TEST_EXECSPACE >( 8192, 2048, 16, 33 );
-  TestTripleNestedReduce< double, TEST_EXECSPACE >( 8192, 2048, 16, 19 );
-#ifdef KOKKOS_ENABLE_ROCM // ROCm doesn't support team sizes not powers of two
+  TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 16, 16);
+  TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 16, 33);
+  TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 16, 19);
+#ifdef KOKKOS_ENABLE_ROCM  // ROCm doesn't support team sizes not powers of two
   if (!std::is_same<TEST_EXECSPACE, Kokkos::Experimental::ROCm>::value)
 #endif
-  TestTripleNestedReduce< double, TEST_EXECSPACE >( 8192, 2048, 7, 16 );
+    TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 7, 16);
 }
 #endif
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestTeamVectorRange.hpp b/lib/kokkos/core/unit_test/TestTeamVectorRange.hpp
index 86c8dab3ff8120a1a4930a62bcf71e1000632264..71351c19815ce994110e83aa64abb97aa7cd7b5e 100644
--- a/lib/kokkos/core/unit_test/TestTeamVectorRange.hpp
+++ b/lib/kokkos/core/unit_test/TestTeamVectorRange.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -57,66 +58,66 @@ struct my_complex {
 
   KOKKOS_INLINE_FUNCTION
   my_complex() {
-    re = 0.0;
-    im = 0.0;
+    re    = 0.0;
+    im    = 0.0;
     dummy = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex( const my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex(const my_complex& src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex& operator=(const my_complex& src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const volatile my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex& operator=(const volatile my_complex& src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  volatile my_complex & operator=( const my_complex & src ) volatile {
-    re = src.re;
-    im = src.im;
+  volatile my_complex& operator=(const my_complex& src) volatile {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  volatile my_complex & operator=( const volatile my_complex & src ) volatile {
-    re = src.re;
-    im = src.im;
+  volatile my_complex& operator=(const volatile my_complex& src) volatile {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
-    return *this ;
+    return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex( const volatile my_complex & src ) {
-    re = src.re;
-    im = src.im;
+  my_complex(const volatile my_complex& src) {
+    re    = src.re;
+    im    = src.im;
     dummy = src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex( const double & val ) {
-    re = val;
-    im = 0.0;
+  my_complex(const double& val) {
+    re    = val;
+    im    = 0.0;
     dummy = 0;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator+=( const my_complex & src ) {
+  my_complex& operator+=(const my_complex& src) {
     re += src.re;
     im += src.im;
     dummy += src.dummy;
@@ -124,14 +125,14 @@ struct my_complex {
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator+=( const volatile my_complex & src ) volatile {
+  void operator+=(const volatile my_complex& src) volatile {
     re += src.re;
     im += src.im;
     dummy += src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex operator +( const my_complex & src ) {
+  my_complex operator+(const my_complex& src) {
     my_complex tmp = *this;
     tmp.re += src.re;
     tmp.im += src.im;
@@ -140,7 +141,7 @@ struct my_complex {
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex operator+( const volatile my_complex & src ) volatile {
+  my_complex operator+(const volatile my_complex& src) volatile {
     my_complex tmp = *this;
     tmp.re += src.re;
     tmp.im += src.im;
@@ -149,134 +150,137 @@ struct my_complex {
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator*=( const my_complex & src ) {
+  my_complex& operator*=(const my_complex& src) {
     double re_tmp = re * src.re - im * src.im;
     double im_tmp = re * src.im + im * src.re;
-    re = re_tmp;
-    im = im_tmp;
+    re            = re_tmp;
+    im            = im_tmp;
     dummy *= src.dummy;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator*=( const volatile my_complex & src ) volatile {
+  void operator*=(const volatile my_complex& src) volatile {
     double re_tmp = re * src.re - im * src.im;
     double im_tmp = re * src.im + im * src.re;
-    re = re_tmp;
-    im = im_tmp;
+    re            = re_tmp;
+    im            = im_tmp;
     dummy *= src.dummy;
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator==( const my_complex & src ) {
-    return ( re == src.re ) && ( im == src.im ) && ( dummy == src.dummy );
+  bool operator==(const my_complex& src) {
+    return (re == src.re) && (im == src.im) && (dummy == src.dummy);
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator!=( const my_complex & src ) {
-    return ( re != src.re ) || ( im != src.im ) || ( dummy != src.dummy );
+  bool operator!=(const my_complex& src) {
+    return (re != src.re) || (im != src.im) || (dummy != src.dummy);
   }
 
   KOKKOS_INLINE_FUNCTION
-  bool operator!=( const double & val ) {
-    return ( re != val ) || ( im != 0 ) || ( dummy != 0 );
+  bool operator!=(const double& val) {
+    return (re != val) || (im != 0) || (dummy != 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const int & val ) {
-    re = val;
-    im = 0.0;
+  my_complex& operator=(const int& val) {
+    re    = val;
+    im    = 0.0;
     dummy = 0;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  my_complex & operator=( const double & val ) {
-    re = val;
-    im = 0.0;
+  my_complex& operator=(const double& val) {
+    re    = val;
+    im    = 0.0;
     dummy = 0;
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  operator double() {
-    return re;
-  }
+  operator double() { return re; }
 };
-}
+}  // namespace TestTeamVectorRange
 
 namespace Kokkos {
-template<>
-struct reduction_identity<TestTeamVectorRange::my_complex > {
+template <>
+struct reduction_identity<TestTeamVectorRange::my_complex> {
   typedef reduction_identity<double> t_red_ident;
-  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVectorRange::my_complex sum()
-      {return TestTeamVectorRange::my_complex(t_red_ident::sum());}
-  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVectorRange::my_complex prod()
-      {return TestTeamVectorRange::my_complex(t_red_ident::prod());}
+  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVectorRange::my_complex sum() {
+    return TestTeamVectorRange::my_complex(t_red_ident::sum());
+  }
+  KOKKOS_FORCEINLINE_FUNCTION static TestTeamVectorRange::my_complex prod() {
+    return TestTeamVectorRange::my_complex(t_red_ident::prod());
+  }
 };
-}
+}  // namespace Kokkos
 
 namespace TestTeamVectorRange {
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_teamvector_for {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_teamvector_for( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_teamvector_for(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_int;
-  unsigned team_shmem_size( int team_size ) const { return shared_int::shmem_size(131); }
+  typedef Kokkos::View<Scalar*, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_int;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_int::shmem_size(131);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     typedef typename shmem_space::size_type size_type;
     const size_type shmemSize = 131;
-    shared_int values = shared_int( team.team_shmem(), shmemSize );
+    shared_int values         = shared_int(team.team_shmem(), shmemSize);
 
-    if ( values.data() == nullptr || values.extent(0) < shmemSize ) {
-      printf( "FAILED to allocate shared memory of size %u\n",
-              static_cast<unsigned int>( shmemSize ) );
-    }
-    else {
+    if (values.data() == nullptr || values.extent(0) < shmemSize) {
+      printf("FAILED to allocate shared memory of size %u\n",
+             static_cast<unsigned int>(shmemSize));
+    } else {
       // Initialize shared memory.
-      Kokkos::parallel_for( Kokkos::TeamVectorRange( team, 131 ), [&] ( int i ) {
-        values( i ) = 0;
-      });
+      Kokkos::parallel_for(Kokkos::TeamVectorRange(team, 131),
+                           [&](int i) { values(i) = 0; });
       // Wait for all memory to be written.
       team.team_barrier();
 
       // Accumulate value into per thread shared memory.
       // This is non blocking.
-      Kokkos::parallel_for( Kokkos::TeamVectorRange( team, 131 ), [&] ( int i )
-      {
-        values( i ) += i - team.league_rank() + team.league_size() + team.team_size();
+      Kokkos::parallel_for(Kokkos::TeamVectorRange(team, 131), [&](int i) {
+        values(i) +=
+            i - team.league_rank() + team.league_size() + team.team_size();
       });
 
       // Wait for all memory to be written.
       team.team_barrier();
 
       // One thread per team executes the comparison.
-      Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-      {
-        Scalar test = 0;
+      Kokkos::single(Kokkos::PerTeam(team), [&]() {
+        Scalar test  = 0;
         Scalar value = 0;
 
-        for ( int i = 0; i < 131; ++i ) {
-          test += i - team.league_rank() + team.league_size() + team.team_size();
+        for (int i = 0; i < 131; ++i) {
+          test +=
+              i - team.league_rank() + team.league_size() + team.team_size();
         }
 
-        for ( int i = 0; i < 131; ++i ) {
-          value += values( i );
+        for (int i = 0; i < 131; ++i) {
+          value += values(i);
         }
 
-        if ( test != value ) {
-          printf ( "FAILED teamvector_parallel_for %i %i %f %f\n",
-                   team.league_rank(), team.team_rank(),
-                   static_cast<double>( test ), static_cast<double>( value ) );
+        if (test != value) {
+          printf("FAILED teamvector_parallel_for %i %i %f %f\n",
+                 team.league_rank(), team.team_rank(),
+                 static_cast<double>(test), static_cast<double>(value));
           flag() = 1;
         }
       });
@@ -284,64 +288,77 @@ struct functor_teamvector_for {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_teamvector_reduce {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_teamvector_reduce( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_teamvector_reduce(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_scalar_t;
-  unsigned team_shmem_size( int team_size ) const { return shared_scalar_t::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar*, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_scalar_t;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_scalar_t::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     Scalar value = Scalar();
-    shared_scalar_t shared_value(team.team_scratch(0),1);
+    shared_scalar_t shared_value(team.team_scratch(0), 1);
 
-    Kokkos::parallel_reduce( Kokkos::TeamVectorRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    }, shared_value(0) );
+    Kokkos::parallel_reduce(
+        Kokkos::TeamVectorRange(team, 131),
+        [&](int i, Scalar& val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        shared_value(0));
 
     team.team_barrier();
-    Kokkos::parallel_reduce( Kokkos::TeamVectorRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    }, value );
-    
-//    Kokkos::parallel_reduce( Kokkos::TeamVectorRange( team, 131 ), [&] ( int i, Scalar & val )
-//    {
-//      val += i - team.league_rank() + team.league_size() + team.team_size();
-//    }, shared_value(0) );
+    Kokkos::parallel_reduce(
+        Kokkos::TeamVectorRange(team, 131),
+        [&](int i, Scalar& val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        value);
+
+    //    Kokkos::parallel_reduce( Kokkos::TeamVectorRange( team, 131 ), [&] (
+    //    int i, Scalar & val )
+    //    {
+    //      val += i - team.league_rank() + team.league_size() +
+    //      team.team_size();
+    //    }, shared_value(0) );
 
     team.team_barrier();
 
-    Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerTeam(team), [&]() {
       Scalar test = 0;
 
-      for ( int i = 0; i < 131; ++i ) {
+      for (int i = 0; i < 131; ++i) {
         test += i - team.league_rank() + team.league_size() + team.team_size();
       }
 
-      if ( test != value ) {
-        if ( team.league_rank() == 0 ) {
-          printf( "FAILED teamvector_parallel_reduce %i %i %lf %lf %lu\n",
-                  team.league_rank(), team.team_rank(),
-                  static_cast<double>( test ), static_cast<double>( value ), sizeof( Scalar ) );
+      if (test != value) {
+        if (team.league_rank() == 0) {
+          printf("FAILED teamvector_parallel_reduce %i %i %lf %lf %lu\n",
+                 team.league_rank(), team.team_rank(),
+                 static_cast<double>(test), static_cast<double>(value),
+                 sizeof(Scalar));
         }
 
         flag() = 1;
       }
-      if ( test != shared_value(0) ) {
-        if ( team.league_rank() == 0 ) {
-          printf( "FAILED teamvector_parallel_reduce with shared result %i %i %lf %lf %lu\n",
-                  team.league_rank(), team.team_rank(),
-                  static_cast<double>( test ), static_cast<double>( shared_value(0) ), sizeof( Scalar ) );
+      if (test != shared_value(0)) {
+        if (team.league_rank() == 0) {
+          printf(
+              "FAILED teamvector_parallel_reduce with shared result %i %i %lf "
+              "%lf %lu\n",
+              team.league_rank(), team.team_rank(), static_cast<double>(test),
+              static_cast<double>(shared_value(0)), sizeof(Scalar));
         }
 
         flag() = 1;
@@ -350,59 +367,65 @@ struct functor_teamvector_reduce {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
+template <typename Scalar, class ExecutionSpace>
 struct functor_teamvector_reduce_reducer {
-  typedef Kokkos::TeamPolicy< ExecutionSpace > policy_type;
+  typedef Kokkos::TeamPolicy<ExecutionSpace> policy_type;
   typedef ExecutionSpace execution_space;
 
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag;
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag;
 
-  functor_teamvector_reduce_reducer( Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > flag_ ) : flag( flag_ ) {}
+  functor_teamvector_reduce_reducer(
+      Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> flag_)
+      : flag(flag_) {}
 
   typedef typename ExecutionSpace::scratch_memory_space shmem_space;
-  typedef Kokkos::View< Scalar*, shmem_space, Kokkos::MemoryUnmanaged > shared_scalar_t;
-  unsigned team_shmem_size( int team_size ) const { return shared_scalar_t::shmem_size(team_size*13); }
+  typedef Kokkos::View<Scalar*, shmem_space, Kokkos::MemoryUnmanaged>
+      shared_scalar_t;
+  unsigned team_shmem_size(int team_size) const {
+    return shared_scalar_t::shmem_size(team_size * 13);
+  }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( typename policy_type::member_type team ) const {
+  void operator()(typename policy_type::member_type team) const {
     Scalar value = 0;
-    shared_scalar_t shared_value(team.team_scratch(0),1);
-
-    Kokkos::parallel_reduce( Kokkos::TeamVectorRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    },
-      Kokkos::Sum<Scalar>(value)
-    );
-    
-    Kokkos::parallel_reduce( Kokkos::TeamVectorRange( team, 131 ), [&] ( int i, Scalar & val )
-    {
-      val += i - team.league_rank() + team.league_size() + team.team_size();
-    },
-      Kokkos::Sum<Scalar>(shared_value(0))
-    );
+    shared_scalar_t shared_value(team.team_scratch(0), 1);
+
+    Kokkos::parallel_reduce(
+        Kokkos::TeamVectorRange(team, 131),
+        [&](int i, Scalar& val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        Kokkos::Sum<Scalar>(value));
+
+    Kokkos::parallel_reduce(
+        Kokkos::TeamVectorRange(team, 131),
+        [&](int i, Scalar& val) {
+          val += i - team.league_rank() + team.league_size() + team.team_size();
+        },
+        Kokkos::Sum<Scalar>(shared_value(0)));
 
     team.team_barrier();
 
-    Kokkos::single( Kokkos::PerTeam( team ), [&] ()
-    {
+    Kokkos::single(Kokkos::PerTeam(team), [&]() {
       Scalar test = 0;
 
-      for ( int i = 0; i < 131; ++i ) {
+      for (int i = 0; i < 131; ++i) {
         test += i - team.league_rank() + team.league_size() + team.team_size();
       }
 
-      if ( test != value ) {
-        printf( "FAILED teamvector_parallel_reduce_reducer %i %i %lf %lf\n",
-                team.league_rank(), team.team_rank(),
-                static_cast<double>( test ), static_cast<double>( value ) );
+      if (test != value) {
+        printf("FAILED teamvector_parallel_reduce_reducer %i %i %lf %lf\n",
+               team.league_rank(), team.team_rank(), static_cast<double>(test),
+               static_cast<double>(value));
 
         flag() = 1;
       }
-      if ( test != shared_value(0) ) {
-        printf( "FAILED teamvector_parallel_reduce_reducer shared value %i %i %lf %lf\n",
-                team.league_rank(), team.team_rank(),
-                static_cast<double>( test ), static_cast<double>( shared_value(0) ) );
+      if (test != shared_value(0)) {
+        printf(
+            "FAILED teamvector_parallel_reduce_reducer shared value %i %i %lf "
+            "%lf\n",
+            team.league_rank(), team.team_rank(), static_cast<double>(test),
+            static_cast<double>(shared_value(0)));
 
         flag() = 1;
       }
@@ -410,55 +433,61 @@ struct functor_teamvector_reduce_reducer {
   }
 };
 
-template< typename Scalar, class ExecutionSpace >
-bool test_scalar( int nteams, int team_size, int test ) {
-  Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace > d_flag( "flag" );
-  typename Kokkos::View< int, Kokkos::LayoutLeft, ExecutionSpace >::HostMirror h_flag( "h_flag" );
+template <typename Scalar, class ExecutionSpace>
+bool test_scalar(int nteams, int team_size, int test) {
+  Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace> d_flag("flag");
+  typename Kokkos::View<int, Kokkos::LayoutLeft, ExecutionSpace>::HostMirror
+      h_flag("h_flag");
   h_flag() = 0;
-  Kokkos::deep_copy( d_flag, h_flag );
-
-  if ( test == 0 ) {
-    Kokkos::parallel_for( "Test::TeamVectorFor", Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_teamvector_for< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 1 ) {
-    Kokkos::parallel_for( "Test::TeamVectorReduce", Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_teamvector_reduce< Scalar, ExecutionSpace >( d_flag ) );
-  }
-  else if ( test == 2 ) {
-    Kokkos::parallel_for( "Test::TeamVectorReduceReducer", Kokkos::TeamPolicy< ExecutionSpace >( nteams, team_size, 8 ),
-                          functor_teamvector_reduce_reducer< Scalar, ExecutionSpace >( d_flag ) );
+  Kokkos::deep_copy(d_flag, h_flag);
+
+  if (test == 0) {
+    Kokkos::parallel_for(
+        "Test::TeamVectorFor",
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_teamvector_for<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 1) {
+    Kokkos::parallel_for(
+        "Test::TeamVectorReduce",
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_teamvector_reduce<Scalar, ExecutionSpace>(d_flag));
+  } else if (test == 2) {
+    Kokkos::parallel_for(
+        "Test::TeamVectorReduceReducer",
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_teamvector_reduce_reducer<Scalar, ExecutionSpace>(d_flag));
   }
 
-  Kokkos::deep_copy( h_flag, d_flag );
+  Kokkos::deep_copy(h_flag, d_flag);
 
-  return ( h_flag() == 0 );
+  return (h_flag() == 0);
 }
 
-template< class ExecutionSpace >
-bool Test( int test ) {
+template <class ExecutionSpace>
+bool Test(int test) {
   bool passed = true;
 
   int team_size = 33;
-  if( team_size > int(ExecutionSpace::concurrency()))
+  if (team_size > int(ExecutionSpace::concurrency()))
     team_size = int(ExecutionSpace::concurrency());
-  passed = passed && test_scalar< int, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< long long int, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< float, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< double, ExecutionSpace >( 317, team_size, test );
-  passed = passed && test_scalar< my_complex, ExecutionSpace >( 317, team_size, test );
+  passed = passed && test_scalar<int, ExecutionSpace>(317, team_size, test);
+  passed = passed &&
+           test_scalar<long long int, ExecutionSpace>(317, team_size, test);
+  passed = passed && test_scalar<float, ExecutionSpace>(317, team_size, test);
+  passed = passed && test_scalar<double, ExecutionSpace>(317, team_size, test);
+  passed =
+      passed && test_scalar<my_complex, ExecutionSpace>(317, team_size, test);
 
   return passed;
 }
 
-} // namespace TestTeamVectorRange
+}  // namespace TestTeamVectorRange
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_teamvector_range )
-{
-  ASSERT_TRUE( ( TestTeamVectorRange::Test< TEST_EXECSPACE >( 0 ) ) );
-  ASSERT_TRUE( ( TestTeamVectorRange::Test< TEST_EXECSPACE >( 1 ) ) );
-  ASSERT_TRUE( ( TestTeamVectorRange::Test< TEST_EXECSPACE >( 2 ) ) );
-}
+TEST(TEST_CATEGORY, team_teamvector_range) {
+  ASSERT_TRUE((TestTeamVectorRange::Test<TEST_EXECSPACE>(0)));
+  ASSERT_TRUE((TestTeamVectorRange::Test<TEST_EXECSPACE>(1)));
+  ASSERT_TRUE((TestTeamVectorRange::Test<TEST_EXECSPACE>(2)));
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestTemplateMetaFunctions.hpp b/lib/kokkos/core/unit_test/TestTemplateMetaFunctions.hpp
index ac32aeb0bedf79bde394d26770c26dd4a5b47dd0..1e25d46dfebed595eb43fa4a0dc0abde7c3952b2 100644
--- a/lib/kokkos/core/unit_test/TestTemplateMetaFunctions.hpp
+++ b/lib/kokkos/core/unit_test/TestTemplateMetaFunctions.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,170 +48,168 @@
 
 namespace {
 
-template< class Scalar, class ExecutionSpace >
+template <class Scalar, class ExecutionSpace>
 struct SumPlain {
   typedef ExecutionSpace execution_space;
-  typedef typename Kokkos::View< Scalar*, execution_space > type;
+  typedef typename Kokkos::View<Scalar*, execution_space> type;
 
   type view;
 
-  SumPlain( type view_ ) : view( view_ ) {}
+  SumPlain(type view_) : view(view_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( int i, Scalar & val ) {
-    val += Scalar();
-  }
+  void operator()(int i, Scalar& val) { val += Scalar(); }
 };
 
-template< class Scalar, class ExecutionSpace >
+template <class Scalar, class ExecutionSpace>
 struct SumInitJoinFinalValueType {
   typedef ExecutionSpace execution_space;
-  typedef typename Kokkos::View< Scalar*, execution_space > type;
+  typedef typename Kokkos::View<Scalar*, execution_space> type;
   typedef Scalar value_type;
 
   type view;
 
-  SumInitJoinFinalValueType( type view_ ) : view( view_ ) {}
+  SumInitJoinFinalValueType(type view_) : view(view_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type & val ) const {
-    val = value_type();
-  }
+  void init(value_type& val) const { val = value_type(); }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & val, volatile value_type & src ) const {
+  void join(volatile value_type& val, volatile value_type& src) const {
     val += src;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i, value_type & val ) const {
-    val += value_type();
-  }
+  void operator()(int i, value_type& val) const { val += value_type(); }
 };
 
-template< class Scalar, class ExecutionSpace >
+template <class Scalar, class ExecutionSpace>
 struct SumInitJoinFinalValueType2 {
   typedef ExecutionSpace execution_space;
-  typedef typename Kokkos::View< Scalar*, execution_space > type;
+  typedef typename Kokkos::View<Scalar*, execution_space> type;
   typedef Scalar value_type;
 
   type view;
 
-  SumInitJoinFinalValueType2( type view_ ) : view( view_ ) {}
+  SumInitJoinFinalValueType2(type view_) : view(view_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( volatile value_type & val ) const {
-    val = value_type();
-  }
+  void init(volatile value_type& val) const { val = value_type(); }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & val, const volatile value_type & src ) const {
+  void join(volatile value_type& val, const volatile value_type& src) const {
     val += src;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i, value_type & val ) const {
-    val += value_type();
-  }
+  void operator()(int i, value_type& val) const { val += value_type(); }
 };
 
-template< class Scalar, class ExecutionSpace >
+template <class Scalar, class ExecutionSpace>
 struct SumInitJoinFinalValueTypeArray {
   typedef ExecutionSpace execution_space;
-  typedef typename Kokkos::View< Scalar*, execution_space > type;
+  typedef typename Kokkos::View<Scalar*, execution_space> type;
   typedef Scalar value_type[];
 
   type view;
   int n;
 
-  SumInitJoinFinalValueTypeArray( type view_, int n_ ) : view( view_ ), n( n_ ) {}
+  SumInitJoinFinalValueTypeArray(type view_, int n_) : view(view_), n(n_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( value_type val ) const {
-    for ( int k = 0; k < n; k++ ) {
+  void init(value_type val) const {
+    for (int k = 0; k < n; k++) {
       val[k] = 0;
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type val, const volatile value_type src ) const {
-    for ( int k = 0; k < n; k++ ) {
+  void join(volatile value_type val, const volatile value_type src) const {
+    for (int k = 0; k < n; k++) {
       val[k] += src[k];
     }
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i, value_type val ) const {
-    for ( int k = 0; k < n; k++ ) {
+  void operator()(int i, value_type val) const {
+    for (int k = 0; k < n; k++) {
       val[k] += k * i;
     }
   }
 };
 
-template< class Scalar, class ExecutionSpace >
+template <class Scalar, class ExecutionSpace>
 struct SumWrongInitJoinFinalValueType {
   typedef ExecutionSpace execution_space;
-  typedef typename Kokkos::View< Scalar*, execution_space > type;
+  typedef typename Kokkos::View<Scalar*, execution_space> type;
   typedef Scalar value_type;
 
   type view;
 
-  SumWrongInitJoinFinalValueType( type view_ ) : view( view_ ) {}
+  SumWrongInitJoinFinalValueType(type view_) : view(view_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void init( double & val ) const {
-    val = double();
-  }
+  void init(double& val) const { val = double(); }
 
   KOKKOS_INLINE_FUNCTION
-  void join( volatile value_type & val, const value_type & src ) const {
+  void join(volatile value_type& val, const value_type& src) const {
     val += src;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i, value_type & val ) const {
-    val += value_type();
-  }
+  void operator()(int i, value_type& val) const { val += value_type(); }
 };
 
-template< class Scalar, class ExecutionSpace >
+template <class Scalar, class ExecutionSpace>
 void TestTemplateMetaFunctions() {
-  typedef typename Kokkos::View< Scalar*, ExecutionSpace > type;
-  type a( "A", 100 );
-/*
-  int sum_plain_has_init_arg = Kokkos::Impl::FunctorHasInit< SumPlain<Scalar, ExecutionSpace>, Scalar & >::value;
-  ASSERT_EQ( sum_plain_has_init_arg, 0 );
-  int sum_initjoinfinalvaluetype_has_init_arg = Kokkos::Impl::FunctorHasInit< SumInitJoinFinalValueType<Scalar, ExecutionSpace>, Scalar >::value;
-  ASSERT_EQ( sum_initjoinfinalvaluetype_has_init_arg, 1 );
-  int sum_initjoinfinalvaluetype_has_init_arg2 = Kokkos::Impl::FunctorHasInit< SumInitJoinFinalValueType2<Scalar,ExecutionSpace>, Scalar >::value;
-  ASSERT_EQ( sum_initjoinfinalvaluetype_has_init_arg2, 1 );
-  int sum_wronginitjoinfinalvaluetype_has_init_arg = Kokkos::Impl::FunctorHasInit< SumWrongInitJoinFinalValueType<Scalar, ExecutionSpace>, Scalar >::value;
-  ASSERT_EQ( sum_wronginitjoinfinalvaluetype_has_init_arg, 0 );
-
-  //int sum_initjoinfinalvaluetypearray_has_init_arg = Kokkos::Impl::FunctorHasInit< SumInitJoinFinalValueTypeArray<Scalar, ExecutionSpace>, Scalar[] >::value;
-  //ASSERT_EQ( sum_initjoinfinalvaluetypearray_has_init_arg, 1 );
-
-  //printf( "Values Init: %i %i %i\n", sum_plain_has_init_arg, sum_initjoinfinalvaluetype_has_init_arg, sum_wronginitjoinfinalvaluetype_has_init_arg );
-
-  int sum_plain_has_join_arg = Kokkos::Impl::FunctorHasJoin< SumPlain<Scalar, ExecutionSpace>, Scalar >::value;
-  ASSERT_EQ( sum_plain_has_join_arg, 0 );
-  int sum_initjoinfinalvaluetype_has_join_arg = Kokkos::Impl::FunctorHasJoin< SumInitJoinFinalValueType<Scalar, ExecutionSpace>, Scalar >::value;
-  ASSERT_EQ( sum_initjoinfinalvaluetype_has_join_arg, 1 );
-  int sum_initjoinfinalvaluetype_has_join_arg2 = Kokkos::Impl::FunctorHasJoin< SumInitJoinFinalValueType2<Scalar, ExecutionSpace>, Scalar >::value;
-  ASSERT_EQ( sum_initjoinfinalvaluetype_has_join_arg2, 1 );
-  int sum_wronginitjoinfinalvaluetype_has_join_arg = Kokkos::Impl::FunctorHasJoin< SumWrongInitJoinFinalValueType<Scalar, ExecutionSpace>, Scalar >::value;
-  ASSERT_EQ( sum_wronginitjoinfinalvaluetype_has_join_arg, 0 );
-
-  //printf( "Values Join: %i %i %i\n", sum_plain_has_join_arg, sum_initjoinfinalvaluetype_has_join_arg, sum_wronginitjoinfinalvaluetype_has_join_arg );
-*/
+  typedef typename Kokkos::View<Scalar*, ExecutionSpace> type;
+  type a("A", 100);
+  /*
+    int sum_plain_has_init_arg = Kokkos::Impl::FunctorHasInit< SumPlain<Scalar,
+    ExecutionSpace>, Scalar & >::value; ASSERT_EQ( sum_plain_has_init_arg, 0 );
+    int sum_initjoinfinalvaluetype_has_init_arg = Kokkos::Impl::FunctorHasInit<
+    SumInitJoinFinalValueType<Scalar, ExecutionSpace>, Scalar >::value;
+    ASSERT_EQ( sum_initjoinfinalvaluetype_has_init_arg, 1 );
+    int sum_initjoinfinalvaluetype_has_init_arg2 = Kokkos::Impl::FunctorHasInit<
+    SumInitJoinFinalValueType2<Scalar,ExecutionSpace>, Scalar >::value;
+    ASSERT_EQ( sum_initjoinfinalvaluetype_has_init_arg2, 1 );
+    int sum_wronginitjoinfinalvaluetype_has_init_arg =
+    Kokkos::Impl::FunctorHasInit< SumWrongInitJoinFinalValueType<Scalar,
+    ExecutionSpace>, Scalar >::value; ASSERT_EQ(
+    sum_wronginitjoinfinalvaluetype_has_init_arg, 0 );
+
+    //int sum_initjoinfinalvaluetypearray_has_init_arg =
+    Kokkos::Impl::FunctorHasInit< SumInitJoinFinalValueTypeArray<Scalar,
+    ExecutionSpace>, Scalar[] >::value;
+    //ASSERT_EQ( sum_initjoinfinalvaluetypearray_has_init_arg, 1 );
+
+    //printf( "Values Init: %i %i %i\n", sum_plain_has_init_arg,
+    sum_initjoinfinalvaluetype_has_init_arg,
+    sum_wronginitjoinfinalvaluetype_has_init_arg );
+
+    int sum_plain_has_join_arg = Kokkos::Impl::FunctorHasJoin< SumPlain<Scalar,
+    ExecutionSpace>, Scalar >::value; ASSERT_EQ( sum_plain_has_join_arg, 0 );
+    int sum_initjoinfinalvaluetype_has_join_arg = Kokkos::Impl::FunctorHasJoin<
+    SumInitJoinFinalValueType<Scalar, ExecutionSpace>, Scalar >::value;
+    ASSERT_EQ( sum_initjoinfinalvaluetype_has_join_arg, 1 );
+    int sum_initjoinfinalvaluetype_has_join_arg2 = Kokkos::Impl::FunctorHasJoin<
+    SumInitJoinFinalValueType2<Scalar, ExecutionSpace>, Scalar >::value;
+    ASSERT_EQ( sum_initjoinfinalvaluetype_has_join_arg2, 1 );
+    int sum_wronginitjoinfinalvaluetype_has_join_arg =
+    Kokkos::Impl::FunctorHasJoin< SumWrongInitJoinFinalValueType<Scalar,
+    ExecutionSpace>, Scalar >::value; ASSERT_EQ(
+    sum_wronginitjoinfinalvaluetype_has_join_arg, 0 );
+
+    //printf( "Values Join: %i %i %i\n", sum_plain_has_join_arg,
+    sum_initjoinfinalvaluetype_has_join_arg,
+    sum_wronginitjoinfinalvaluetype_has_join_arg );
+  */
 }
 
-} // namespace
+}  // namespace
 
 namespace Test {
-TEST_F( TEST_CATEGORY, template_meta_functions )
-{
-  TestTemplateMetaFunctions< int, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, template_meta_functions) {
+  TestTemplateMetaFunctions<int, TEST_EXECSPACE>();
 }
-}
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestTile.hpp b/lib/kokkos/core/unit_test/TestTile.hpp
index a58755dc9bb1c7c05f9d6d8c83af395a8cd5d7ae..9e916ef3136594d1ef9bf6c7656eb082d898632b 100644
--- a/lib/kokkos/core/unit_test/TestTile.hpp
+++ b/lib/kokkos/core/unit_test/TestTile.hpp
@@ -1,10 +1,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +23,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,68 +51,71 @@
 
 namespace TestTile {
 
-template < typename Device, typename TileLayout >
-struct ReduceTileErrors
-{
+template <typename Device, typename TileLayout>
+struct ReduceTileErrors {
   typedef Device execution_space;
-  typedef Kokkos::View< ptrdiff_t**, TileLayout, Device >  array_type;
-  typedef Kokkos::View< ptrdiff_t[ TileLayout::N0 ][ TileLayout::N1 ], Kokkos::LayoutLeft, Device >  tile_type;
+  typedef Kokkos::View<ptrdiff_t**, TileLayout, Device> array_type;
+  typedef Kokkos::View<ptrdiff_t[TileLayout::N0][TileLayout::N1],
+                       Kokkos::LayoutLeft, Device>
+      tile_type;
   typedef ptrdiff_t value_type;
 
   array_type m_array;
 
-  ReduceTileErrors( array_type a ) : m_array( a ) {}
+  ReduceTileErrors(array_type a) : m_array(a) {}
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & errors ) { errors = 0; }
+  static void init(value_type& errors) { errors = 0; }
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & errors,
-                    const volatile value_type & src_errors )
-  {
+  static void join(volatile value_type& errors,
+                   const volatile value_type& src_errors) {
     errors += src_errors;
   }
 
   // Initialize.
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_t iwork ) const
-  {
+  void operator()(size_t iwork) const {
     const size_t i = iwork % m_array.extent(0);
     const size_t j = iwork / m_array.extent(0);
 
-    if ( j < m_array.extent(1) ) {
-      m_array( i, j ) = &m_array( i, j ) - &m_array( 0, 0 );
+    if (j < m_array.extent(1)) {
+      m_array(i, j) = &m_array(i, j) - &m_array(0, 0);
 
-      //printf( "m_array(%d, %d) = %d\n", int( i ), int( j ), int( m_array( i, j ) ) );
+      // printf( "m_array(%d, %d) = %d\n", int( i ), int( j ), int( m_array( i,
+      // j ) ) );
     }
   }
 
   // Verify:
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_t iwork, value_type & errors ) const
-  {
-    const size_t tile_dim0 = ( m_array.extent(0) + TileLayout::N0 - 1 ) / TileLayout::N0;
-    const size_t tile_dim1 = ( m_array.extent(1) + TileLayout::N1 - 1 ) / TileLayout::N1;
+  void operator()(size_t iwork, value_type& errors) const {
+    const size_t tile_dim0 =
+        (m_array.extent(0) + TileLayout::N0 - 1) / TileLayout::N0;
+    const size_t tile_dim1 =
+        (m_array.extent(1) + TileLayout::N1 - 1) / TileLayout::N1;
 
     const size_t itile = iwork % tile_dim0;
     const size_t jtile = iwork / tile_dim0;
 
-    if ( jtile < tile_dim1 ) {
-      tile_type tile = Kokkos::tile_subview( m_array, itile, jtile );
+    if (jtile < tile_dim1) {
+      tile_type tile = Kokkos::tile_subview(m_array, itile, jtile);
 
-      if ( tile( 0, 0 ) != ptrdiff_t( ( itile + jtile * tile_dim0 ) * TileLayout::N0 * TileLayout::N1 ) ) {
+      if (tile(0, 0) != ptrdiff_t((itile + jtile * tile_dim0) * TileLayout::N0 *
+                                  TileLayout::N1)) {
         ++errors;
-      }
-      else {
-        for ( size_t j = 0; j < size_t( TileLayout::N1 ); ++j ) {
-          for ( size_t i = 0; i < size_t( TileLayout::N0 ); ++i ) {
+      } else {
+        for (size_t j = 0; j < size_t(TileLayout::N1); ++j) {
+          for (size_t i = 0; i < size_t(TileLayout::N0); ++i) {
             const size_t iglobal = i + itile * TileLayout::N0;
             const size_t jglobal = j + jtile * TileLayout::N1;
 
-            if ( iglobal < m_array.extent(0) && jglobal < m_array.extent(1) ) {
-              if ( tile( i, j ) != ptrdiff_t( tile( 0, 0 ) + i + j * TileLayout::N0 ) ) ++errors;
+            if (iglobal < m_array.extent(0) && jglobal < m_array.extent(1)) {
+              if (tile(i, j) != ptrdiff_t(tile(0, 0) + i + j * TileLayout::N0))
+                ++errors;
 
-              //printf( "tile(%d, %d)(%d, %d) = %d\n", int( itile ), int( jtile ), int( i ), int( j ), int( tile( i, j ) ) );
+              // printf( "tile(%d, %d)(%d, %d) = %d\n", int( itile ), int( jtile
+              // ), int( i ), int( j ), int( tile( i, j ) ) );
             }
           }
         }
@@ -120,57 +124,58 @@ struct ReduceTileErrors
   }
 };
 
-template< class Space, unsigned N0, unsigned N1 >
-void test( const size_t dim0, const size_t dim1 )
-{
-  typedef Kokkos::LayoutTileLeft< N0, N1 >  array_layout;
-  typedef ReduceTileErrors< Space, array_layout > functor_type;
+template <class Space, unsigned N0, unsigned N1>
+void test(const size_t dim0, const size_t dim1) {
+  typedef Kokkos::LayoutTileLeft<N0, N1> array_layout;
+  typedef ReduceTileErrors<Space, array_layout> functor_type;
 
-  const size_t tile_dim0 = ( dim0 + N0 - 1 ) / N0;
-  const size_t tile_dim1 = ( dim1 + N1 - 1 ) / N1;
+  const size_t tile_dim0 = (dim0 + N0 - 1) / N0;
+  const size_t tile_dim1 = (dim1 + N1 - 1) / N1;
 
-  typename functor_type::array_type array( "", dim0, dim1 );
+  typename functor_type::array_type array("", dim0, dim1);
 
-  Kokkos::parallel_for( Kokkos::RangePolicy< Space, size_t >( 0, dim0 * dim1 ), functor_type( array ) );
+  Kokkos::parallel_for(Kokkos::RangePolicy<Space, size_t>(0, dim0 * dim1),
+                       functor_type(array));
 
   ptrdiff_t error = 0;
 
-  Kokkos::parallel_reduce( Kokkos::RangePolicy< Space, size_t >( 0, tile_dim0 * tile_dim1 ), functor_type( array ), error );
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<Space, size_t>(0, tile_dim0 * tile_dim1),
+      functor_type(array), error);
 
-  EXPECT_EQ( error, ptrdiff_t( 0 ) );
+  EXPECT_EQ(error, ptrdiff_t(0));
 }
 
-} // namespace TestTile
+}  // namespace TestTile
 
 namespace Test {
-TEST_F( TEST_CATEGORY, tile_layout )
-{
-  TestTile::test< TEST_EXECSPACE, 1, 1 >( 1, 1 );
-  TestTile::test< TEST_EXECSPACE, 1, 1 >( 2, 3 );
-  TestTile::test< TEST_EXECSPACE, 1, 1 >( 9, 10 );
-
-  TestTile::test< TEST_EXECSPACE, 2, 2 >( 1, 1 );
-  TestTile::test< TEST_EXECSPACE, 2, 2 >( 2, 3 );
-  TestTile::test< TEST_EXECSPACE, 2, 2 >( 4, 4 );
-  TestTile::test< TEST_EXECSPACE, 2, 2 >( 9, 9 );
-
-  TestTile::test< TEST_EXECSPACE, 2, 4 >( 9, 9 );
-  TestTile::test< TEST_EXECSPACE, 4, 2 >( 9, 9 );
-
-  TestTile::test< TEST_EXECSPACE, 4, 4 >( 1, 1 );
-  TestTile::test< TEST_EXECSPACE, 4, 4 >( 4, 4 );
-  TestTile::test< TEST_EXECSPACE, 4, 4 >( 9, 9 );
-  TestTile::test< TEST_EXECSPACE, 4, 4 >( 9, 11 );
-
-  TestTile::test< TEST_EXECSPACE, 8, 8 >( 1, 1 );
-  TestTile::test< TEST_EXECSPACE, 8, 8 >( 4, 4 );
-  TestTile::test< TEST_EXECSPACE, 8, 8 >( 9, 9 );
-  TestTile::test< TEST_EXECSPACE, 8, 8 >( 9, 11 );
+TEST(TEST_CATEGORY, tile_layout) {
+  TestTile::test<TEST_EXECSPACE, 1, 1>(1, 1);
+  TestTile::test<TEST_EXECSPACE, 1, 1>(2, 3);
+  TestTile::test<TEST_EXECSPACE, 1, 1>(9, 10);
+
+  TestTile::test<TEST_EXECSPACE, 2, 2>(1, 1);
+  TestTile::test<TEST_EXECSPACE, 2, 2>(2, 3);
+  TestTile::test<TEST_EXECSPACE, 2, 2>(4, 4);
+  TestTile::test<TEST_EXECSPACE, 2, 2>(9, 9);
+
+  TestTile::test<TEST_EXECSPACE, 2, 4>(9, 9);
+  TestTile::test<TEST_EXECSPACE, 4, 2>(9, 9);
+
+  TestTile::test<TEST_EXECSPACE, 4, 4>(1, 1);
+  TestTile::test<TEST_EXECSPACE, 4, 4>(4, 4);
+  TestTile::test<TEST_EXECSPACE, 4, 4>(9, 9);
+  TestTile::test<TEST_EXECSPACE, 4, 4>(9, 11);
+
+  TestTile::test<TEST_EXECSPACE, 8, 8>(1, 1);
+  TestTile::test<TEST_EXECSPACE, 8, 8>(4, 4);
+  TestTile::test<TEST_EXECSPACE, 8, 8>(9, 9);
+  TestTile::test<TEST_EXECSPACE, 8, 8>(9, 11);
 }
 
-}
+}  // namespace Test
 
-#endif // KOKKOS_ENABLE_DEPRECATED_CODE
+#endif  // KOKKOS_ENABLE_DEPRECATED_CODE
 //=====================================================================
 
-#endif //TEST_TILE_HPP
+#endif  // TEST_TILE_HPP
diff --git a/lib/kokkos/core/unit_test/TestUniqueToken.hpp b/lib/kokkos/core/unit_test/TestUniqueToken.hpp
index 5c8324c63d7fb0f3699be4130b962136c4dc2afc..c85ba1afc31daa989f525270df7de8c8466db99f 100644
--- a/lib/kokkos/core/unit_test/TestUniqueToken.hpp
+++ b/lib/kokkos/core/unit_test/TestUniqueToken.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,92 +48,87 @@
 
 namespace Test {
 
-template< class Space >
-class TestUniqueToken
-{
-public:
-  typedef typename Space::execution_space  execution_space;
-  typedef Kokkos::View< int * , execution_space > view_type ;
+template <class Space>
+class TestUniqueToken {
+ public:
+  typedef typename Space::execution_space execution_space;
+  typedef Kokkos::View<int*, execution_space> view_type;
 
-  Kokkos::Experimental::UniqueToken< execution_space , Kokkos::Experimental::UniqueTokenScope::Global > tokens ;
+  Kokkos::Experimental::UniqueToken<
+      execution_space, Kokkos::Experimental::UniqueTokenScope::Global>
+      tokens;
 
-  view_type verify ;
-  view_type counts ;
-  view_type errors ;
+  view_type verify;
+  view_type counts;
+  view_type errors;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( long ) const
-  {
+  void operator()(long) const {
     const int32_t t = tokens.acquire();
 
-    bool ok = true ;
+    bool ok = true;
 
-    ok = ok && 0 <= t ;
+    ok = ok && 0 <= t;
     ok = ok && t < tokens.size();
-    ok = ok && 0 == Kokkos::atomic_fetch_add( & verify(t) , 1 );
+    ok = ok && 0 == Kokkos::atomic_fetch_add(&verify(t), 1);
 
-    Kokkos::atomic_fetch_add( & counts(t) , 1 );
+    Kokkos::atomic_fetch_add(&counts(t), 1);
 
-    ok = ok && 1 == Kokkos::atomic_fetch_add( & verify(t) , -1 );
+    ok = ok && 1 == Kokkos::atomic_fetch_add(&verify(t), -1);
 
-    if ( ! ok ) { Kokkos::atomic_fetch_add( & errors(0) , 1 ) ; }
+    if (!ok) {
+      Kokkos::atomic_fetch_add(&errors(0), 1);
+    }
 
     tokens.release(t);
   }
 
   TestUniqueToken()
-    : tokens( execution_space() )
-    , verify( "TestUniqueTokenVerify" , tokens.size() )
-    , counts( "TestUniqueTokenCounts" , tokens.size() )
-    , errors( "TestUniqueTokenErrors" , 1 )
-    {}
+      : tokens(execution_space()),
+        verify("TestUniqueTokenVerify", tokens.size()),
+        counts("TestUniqueTokenCounts", tokens.size()),
+        errors("TestUniqueTokenErrors", 1) {}
 
-  static void run()
-    {
-      using policy = Kokkos::RangePolicy<execution_space> ;
+  static void run() {
+    using policy = Kokkos::RangePolicy<execution_space>;
 
-      TestUniqueToken self ;
+    TestUniqueToken self;
 
-      {
-        const int duplicate = 100 ;
-        const long n = duplicate * self.tokens.size();
+    {
+      const int duplicate = 100;
+      const long n        = duplicate * self.tokens.size();
 
-        Kokkos::parallel_for( policy(0,n) , self );
-        Kokkos::parallel_for( policy(0,n) , self );
-        Kokkos::parallel_for( policy(0,n) , self );
-        Kokkos::fence();
-      }
+      Kokkos::parallel_for(policy(0, n), self);
+      Kokkos::parallel_for(policy(0, n), self);
+      Kokkos::parallel_for(policy(0, n), self);
+      Kokkos::fence();
+    }
 
-      typename view_type::HostMirror host_counts =
-        Kokkos::create_mirror_view( self.counts );
+    typename view_type::HostMirror host_counts =
+        Kokkos::create_mirror_view(self.counts);
 
-      Kokkos::deep_copy( host_counts , self.counts );
+    Kokkos::deep_copy(host_counts, self.counts);
 
-      int32_t max = 0 ;
+    int32_t max = 0;
 
-      {
-        const long n = host_counts.extent(0);
-        for ( long i = 0 ; i < n ; ++i ) {
-          if ( max < host_counts[i] ) max = host_counts[i] ;
-        }
+    {
+      const long n = host_counts.extent(0);
+      for (long i = 0; i < n; ++i) {
+        if (max < host_counts[i]) max = host_counts[i];
       }
+    }
 
-      std::cout << "TestUniqueToken max reuse = " << max << std::endl ;
+    std::cout << "TestUniqueToken max reuse = " << max << std::endl;
 
-      typename view_type::HostMirror host_errors =
-        Kokkos::create_mirror_view( self.errors );
+    typename view_type::HostMirror host_errors =
+        Kokkos::create_mirror_view(self.errors);
 
-      Kokkos::deep_copy( host_errors , self.errors );
+    Kokkos::deep_copy(host_errors, self.errors);
 
-      ASSERT_EQ( host_errors(0) , 0 );
-    }
+    ASSERT_EQ(host_errors(0), 0);
+  }
 };
 
+TEST(TEST_CATEGORY, unique_token) { TestUniqueToken<TEST_EXECSPACE>::run(); }
 
-TEST_F( TEST_CATEGORY, unique_token )
-{
-  TestUniqueToken< TEST_EXECSPACE >::run();
-}
-
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestUtilities.hpp b/lib/kokkos/core/unit_test/TestUtilities.hpp
index f3deabad032ae2bbb8a7798d57ee052c3ee7d4a6..f5f027a555276f771ce37c664518ca504e178fe8 100644
--- a/lib/kokkos/core/unit_test/TestUtilities.hpp
+++ b/lib/kokkos/core/unit_test/TestUtilities.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,251 +52,305 @@
 
 namespace Test {
 
-inline
-void test_utilities()
-{
+inline void test_utilities() {
   using namespace Kokkos::Impl;
 
   {
-    using i = integer_sequence< int >;
-    using j = make_integer_sequence< int, 0 >;
+    using i = integer_sequence<int>;
+    using j = make_integer_sequence<int, 0>;
 
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 0u, "Error: integer_sequence.size()" );
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 0u, "Error: integer_sequence.size()");
   }
 
   {
-    using i = integer_sequence< int, 0 >;
-    using j = make_integer_sequence< int, 1 >;
+    using i = integer_sequence<int, 0>;
+    using j = make_integer_sequence<int, 1>;
 
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 1u, "Error: integer_sequence.size()" );
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 1u, "Error: integer_sequence.size()");
 
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
 
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1 >;
-    using j = make_integer_sequence< int, 2 >;
+    using i = integer_sequence<int, 0, 1>;
+    using j = make_integer_sequence<int, 2>;
 
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 2u, "Error: integer_sequence.size()" );
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 2u, "Error: integer_sequence.size()");
 
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
 
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2 >;
-    using j = make_integer_sequence< int, 3 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 3u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2>;
+    using j = make_integer_sequence<int, 3>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 3u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2, 3 >;
-    using j = make_integer_sequence< int, 4 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 4u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2, 3>;
+    using j = make_integer_sequence<int, 4>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 4u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<3, i>::value == 3,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2, 3, 4 >;
-    using j = make_integer_sequence< int, 5 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 5u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2, 3, 4>;
+    using j = make_integer_sequence<int, 5>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 5u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<3, i>::value == 3,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<4, i>::value == 4,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2, 3, 4, 5 >;
-    using j = make_integer_sequence< int, 6 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 6u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2, 3, 4, 5>;
+    using j = make_integer_sequence<int, 6>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 6u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<3, i>::value == 3,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<4, i>::value == 4,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<5, i>::value == 5,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6 >;
-    using j = make_integer_sequence< int, 7 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 7u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2, 3, 4, 5, 6>;
+    using j = make_integer_sequence<int, 7>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 7u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<3, i>::value == 3,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<4, i>::value == 4,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<5, i>::value == 5,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<6, i>::value == 6,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6, 7 >;
-    using j = make_integer_sequence< int, 8 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 8u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 7, i >::value == 7, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 7, i{} ) == 7, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2, 3, 4, 5, 6, 7>;
+    using j = make_integer_sequence<int, 8>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 8u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<3, i>::value == 3,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<4, i>::value == 4,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<5, i>::value == 5,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<6, i>::value == 6,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<7, i>::value == 7,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(7, i{}) == 7, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6, 7, 8 >;
-    using j = make_integer_sequence< int, 9 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 9u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 7, i >::value == 7, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 8, i >::value == 8, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 7, i{} ) == 7, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 8, i{} ) == 8, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2, 3, 4, 5, 6, 7, 8>;
+    using j = make_integer_sequence<int, 9>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 9u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<3, i>::value == 3,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<4, i>::value == 4,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<5, i>::value == 5,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<6, i>::value == 6,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<7, i>::value == 7,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<8, i>::value == 8,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(7, i{}) == 7, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(8, i{}) == 8, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 >;
-    using j = make_integer_sequence< int, 10 >;
-
-    static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
-    static_assert( i::size() == 10u, "Error: integer_sequence.size()" );
-
-    static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 7, i >::value == 7, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 8, i >::value == 8, "Error: integer_sequence_at" );
-    static_assert( integer_sequence_at< 9, i >::value == 9, "Error: integer_sequence_at" );
-
-    static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 7, i{} ) == 7, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 8, i{} ) == 8, "Error: at(unsigned, integer_sequence)" );
-    static_assert( at( 9, i{} ) == 9, "Error: at(unsigned, integer_sequence)" );
+    using i = integer_sequence<int, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9>;
+    using j = make_integer_sequence<int, 10>;
+
+    static_assert(std::is_same<i, j>::value, "Error: make_integer_sequence");
+    static_assert(i::size() == 10u, "Error: integer_sequence.size()");
+
+    static_assert(integer_sequence_at<0, i>::value == 0,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<1, i>::value == 1,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<2, i>::value == 2,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<3, i>::value == 3,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<4, i>::value == 4,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<5, i>::value == 5,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<6, i>::value == 6,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<7, i>::value == 7,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<8, i>::value == 8,
+                  "Error: integer_sequence_at");
+    static_assert(integer_sequence_at<9, i>::value == 9,
+                  "Error: integer_sequence_at");
+
+    static_assert(at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(7, i{}) == 7, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(8, i{}) == 8, "Error: at(unsigned, integer_sequence)");
+    static_assert(at(9, i{}) == 9, "Error: at(unsigned, integer_sequence)");
   }
 
   {
-    using i = make_integer_sequence< int, 5 >;
-    using r = reverse_integer_sequence< i >;
-    using gr = integer_sequence< int, 4, 3, 2, 1, 0 >;
+    using i  = make_integer_sequence<int, 5>;
+    using r  = reverse_integer_sequence<i>;
+    using gr = integer_sequence<int, 4, 3, 2, 1, 0>;
 
-    static_assert( std::is_same< r, gr >::value, "Error: reverse_integer_sequence" );
+    static_assert(std::is_same<r, gr>::value,
+                  "Error: reverse_integer_sequence");
   }
 
   {
-    using s = make_integer_sequence< int, 10 >;
-    using e = exclusive_scan_integer_sequence< s >;
-    using i = inclusive_scan_integer_sequence< s >;
+    using s = make_integer_sequence<int, 10>;
+    using e = exclusive_scan_integer_sequence<s>;
+    using i = inclusive_scan_integer_sequence<s>;
 
-    using ge = integer_sequence< int, 0, 0, 1, 3, 6, 10, 15, 21, 28, 36 >;
-    using gi = integer_sequence< int, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45 >;
+    using ge = integer_sequence<int, 0, 0, 1, 3, 6, 10, 15, 21, 28, 36>;
+    using gi = integer_sequence<int, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45>;
 
-    static_assert( e::value == 45, "Error: scan value" );
-    static_assert( i::value == 45, "Error: scan value" );
+    static_assert(e::value == 45, "Error: scan value");
+    static_assert(i::value == 45, "Error: scan value");
 
-    static_assert( std::is_same< e::type, ge >::value, "Error: exclusive_scan" );
-    static_assert( std::is_same< i::type, gi >::value, "Error: inclusive_scan" );
+    static_assert(std::is_same<e::type, ge>::value, "Error: exclusive_scan");
+    static_assert(std::is_same<i::type, gi>::value, "Error: inclusive_scan");
   }
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewAPI.hpp b/lib/kokkos/core/unit_test/TestViewAPI.hpp
index e332bebff082e7169104c6e48e9fa068a9cd617f..36d158d643b5c5e2dbc3b24b24bcbe3edd165b8a 100644
--- a/lib/kokkos/core/unit_test/TestViewAPI.hpp
+++ b/lib/kokkos/core/unit_test/TestViewAPI.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,1054 +51,1075 @@
 
 namespace Test {
 
-template< class T, class ... P >
-size_t allocation_count( const Kokkos::View< T, P... > & view )
-{
+template <class T, class... P>
+size_t allocation_count(const Kokkos::View<T, P...> &view) {
   const size_t card  = view.size();
   const size_t alloc = view.span();
 
-  const int memory_span = Kokkos::View< int* >::required_allocation_size( 100 );
+  const int memory_span = Kokkos::View<int *>::required_allocation_size(100);
 
-  return ( card <= alloc && memory_span == 400 ) ? alloc : 0;
+  return (card <= alloc && memory_span == 400) ? alloc : 0;
 }
 
 /*--------------------------------------------------------------------------*/
 
-template< typename T, class DeviceType >
-struct TestViewOperator
-{
-  typedef typename DeviceType::execution_space  execution_space;
+template <typename T, class DeviceType>
+struct TestViewOperator {
+  typedef typename DeviceType::execution_space execution_space;
 
   enum { N = 1000 };
   enum { D = 3 };
 
-  typedef Kokkos::View< T*[D], execution_space > view_type;
+  typedef Kokkos::View<T * [D], execution_space> view_type;
 
   const view_type v1;
   const view_type v2;
 
-  TestViewOperator()
-    : v1( "v1", N )
-    , v2( "v2", N )
-    {}
+  TestViewOperator() : v1("v1", N), v2("v2", N) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned i ) const
-  {
+  void operator()(const unsigned i) const {
     const unsigned X = 0;
     const unsigned Y = 1;
     const unsigned Z = 2;
 
-    v2( i, X ) = v1( i, X );
-    v2( i, Y ) = v1( i, Y );
-    v2( i, Z ) = v1( i, Z );
+    v2(i, X) = v1(i, X);
+    v2(i, Y) = v1(i, Y);
+    v2(i, Z) = v1(i, Z);
   }
 };
 
 /*--------------------------------------------------------------------------*/
 
-template< class DataType,
-          class DeviceType,
-          unsigned Rank = Kokkos::ViewTraits< DataType >::rank >
+template <class DataType, class DeviceType,
+          unsigned Rank = Kokkos::ViewTraits<DataType>::rank>
 struct TestViewOperator_LeftAndRight;
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 8 >
-{
-  typedef typename DeviceType::execution_space    execution_space;
-  typedef typename DeviceType::memory_space       memory_space;
-  typedef typename execution_space::size_type     size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 8> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutStride, execution_space > stride_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutStride, execution_space>
+      stride_view;
 
-  left_view    left;
-  right_view   right;
-  stride_view  left_stride;
-  stride_view  right_stride;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
+      : left("left"),
+        right("right"),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
+
+  void testit() {
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
+  void operator()(const size_type, value_type &update) const {
     long offset = -1;
 
-    for ( unsigned i7 = 0; i7 < unsigned( left.extent(7) ); ++i7 )
-    for ( unsigned i6 = 0; i6 < unsigned( left.extent(6) ); ++i6 )
-    for ( unsigned i5 = 0; i5 < unsigned( left.extent(5) ); ++i5 )
-    for ( unsigned i4 = 0; i4 < unsigned( left.extent(4) ); ++i4 )
-    for ( unsigned i3 = 0; i3 < unsigned( left.extent(3) ); ++i3 )
-    for ( unsigned i2 = 0; i2 < unsigned( left.extent(2) ); ++i2 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3, i4, i5, i6, i7 ) -
-                     & left(  0,  0,  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1; }
-      offset = j;
-
-      if ( & left( i0, i1, i2, i3, i4, i5, i6, i7 ) !=
-           & left_stride( i0, i1, i2, i3, i4, i5, i6, i7 ) ) {
-        update |= 4;
-      }
-    }
+    for (unsigned i7 = 0; i7 < unsigned(left.extent(7)); ++i7)
+      for (unsigned i6 = 0; i6 < unsigned(left.extent(6)); ++i6)
+        for (unsigned i5 = 0; i5 < unsigned(left.extent(5)); ++i5)
+          for (unsigned i4 = 0; i4 < unsigned(left.extent(4)); ++i4)
+            for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+              for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+                for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+                  for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+                    const long j = &left(i0, i1, i2, i3, i4, i5, i6, i7) -
+                                   &left(0, 0, 0, 0, 0, 0, 0, 0);
+                    if (j <= offset || left_alloc <= j) {
+                      update |= 1;
+                    }
+                    offset = j;
+
+                    if (&left(i0, i1, i2, i3, i4, i5, i6, i7) !=
+                        &left_stride(i0, i1, i2, i3, i4, i5, i6, i7)) {
+                      update |= 4;
+                    }
+                  }
 
     offset = -1;
 
-    for ( unsigned i0 = 0; i0 < unsigned( right.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( right.extent(1) ); ++i1 )
-    for ( unsigned i2 = 0; i2 < unsigned( right.extent(2) ); ++i2 )
-    for ( unsigned i3 = 0; i3 < unsigned( right.extent(3) ); ++i3 )
-    for ( unsigned i4 = 0; i4 < unsigned( right.extent(4) ); ++i4 )
-    for ( unsigned i5 = 0; i5 < unsigned( right.extent(5) ); ++i5 )
-    for ( unsigned i6 = 0; i6 < unsigned( right.extent(6) ); ++i6 )
-    for ( unsigned i7 = 0; i7 < unsigned( right.extent(7) ); ++i7 )
-    {
-      const long j = & right( i0, i1, i2, i3, i4, i5, i6, i7 ) -
-                     & right(  0,  0,  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2; }
-      offset = j;
-
-      if ( & right( i0, i1, i2, i3, i4, i5, i6, i7 ) !=
-           & right_stride( i0, i1, i2, i3, i4, i5, i6, i7 ) ) {
-        update |= 8;
-      }
-    }
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3)
+            for (unsigned i4 = 0; i4 < unsigned(right.extent(4)); ++i4)
+              for (unsigned i5 = 0; i5 < unsigned(right.extent(5)); ++i5)
+                for (unsigned i6 = 0; i6 < unsigned(right.extent(6)); ++i6)
+                  for (unsigned i7 = 0; i7 < unsigned(right.extent(7)); ++i7) {
+                    const long j = &right(i0, i1, i2, i3, i4, i5, i6, i7) -
+                                   &right(0, 0, 0, 0, 0, 0, 0, 0);
+                    if (j <= offset || right_alloc <= j) {
+                      update |= 2;
+                    }
+                    offset = j;
+
+                    if (&right(i0, i1, i2, i3, i4, i5, i6, i7) !=
+                        &right_stride(i0, i1, i2, i3, i4, i5, i6, i7)) {
+                      update |= 8;
+                    }
+                  }
   }
 };
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 7 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 7> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  left_view    left;
-  right_view   right;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
+      : left("left"),
+        right("right"),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
+  void testit() {
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
+  void operator()(const size_type, value_type &update) const {
     long offset = -1;
 
-    for ( unsigned i6 = 0; i6 < unsigned( left.extent(6) ); ++i6 )
-    for ( unsigned i5 = 0; i5 < unsigned( left.extent(5) ); ++i5 )
-    for ( unsigned i4 = 0; i4 < unsigned( left.extent(4) ); ++i4 )
-    for ( unsigned i3 = 0; i3 < unsigned( left.extent(3) ); ++i3 )
-    for ( unsigned i2 = 0; i2 < unsigned( left.extent(2) ); ++i2 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3, i4, i5, i6 ) -
-                     & left(  0,  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1; }
-      offset = j;
-    }
+    for (unsigned i6 = 0; i6 < unsigned(left.extent(6)); ++i6)
+      for (unsigned i5 = 0; i5 < unsigned(left.extent(5)); ++i5)
+        for (unsigned i4 = 0; i4 < unsigned(left.extent(4)); ++i4)
+          for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+            for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+              for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+                for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+                  const long j = &left(i0, i1, i2, i3, i4, i5, i6) -
+                                 &left(0, 0, 0, 0, 0, 0, 0);
+                  if (j <= offset || left_alloc <= j) {
+                    update |= 1;
+                  }
+                  offset = j;
+                }
 
     offset = -1;
 
-    for ( unsigned i0 = 0; i0 < unsigned( right.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( right.extent(1) ); ++i1 )
-    for ( unsigned i2 = 0; i2 < unsigned( right.extent(2) ); ++i2 )
-    for ( unsigned i3 = 0; i3 < unsigned( right.extent(3) ); ++i3 )
-    for ( unsigned i4 = 0; i4 < unsigned( right.extent(4) ); ++i4 )
-    for ( unsigned i5 = 0; i5 < unsigned( right.extent(5) ); ++i5 )
-    for ( unsigned i6 = 0; i6 < unsigned( right.extent(6) ); ++i6 )
-    {
-      const long j = & right( i0, i1, i2, i3, i4, i5, i6 ) -
-                     & right(  0,  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2; }
-      offset = j;
-    }
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3)
+            for (unsigned i4 = 0; i4 < unsigned(right.extent(4)); ++i4)
+              for (unsigned i5 = 0; i5 < unsigned(right.extent(5)); ++i5)
+                for (unsigned i6 = 0; i6 < unsigned(right.extent(6)); ++i6) {
+                  const long j = &right(i0, i1, i2, i3, i4, i5, i6) -
+                                 &right(0, 0, 0, 0, 0, 0, 0);
+                  if (j <= offset || right_alloc <= j) {
+                    update |= 2;
+                  }
+                  offset = j;
+                }
   }
 };
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 6 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 6> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  left_view    left;
-  right_view   right;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
+      : left("left"),
+        right("right"),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
+  void testit() {
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
+  void operator()(const size_type, value_type &update) const {
     long offset = -1;
 
-    for ( unsigned i5 = 0; i5 < unsigned( left.extent(5) ); ++i5 )
-    for ( unsigned i4 = 0; i4 < unsigned( left.extent(4) ); ++i4 )
-    for ( unsigned i3 = 0; i3 < unsigned( left.extent(3) ); ++i3 )
-    for ( unsigned i2 = 0; i2 < unsigned( left.extent(2) ); ++i2 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3, i4, i5 ) -
-                     & left(  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1; }
-      offset = j;
-    }
+    for (unsigned i5 = 0; i5 < unsigned(left.extent(5)); ++i5)
+      for (unsigned i4 = 0; i4 < unsigned(left.extent(4)); ++i4)
+        for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+          for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+            for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+              for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+                const long j =
+                    &left(i0, i1, i2, i3, i4, i5) - &left(0, 0, 0, 0, 0, 0);
+                if (j <= offset || left_alloc <= j) {
+                  update |= 1;
+                }
+                offset = j;
+              }
 
     offset = -1;
 
-    for ( unsigned i0 = 0; i0 < unsigned( right.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( right.extent(1) ); ++i1 )
-    for ( unsigned i2 = 0; i2 < unsigned( right.extent(2) ); ++i2 )
-    for ( unsigned i3 = 0; i3 < unsigned( right.extent(3) ); ++i3 )
-    for ( unsigned i4 = 0; i4 < unsigned( right.extent(4) ); ++i4 )
-    for ( unsigned i5 = 0; i5 < unsigned( right.extent(5) ); ++i5 )
-    {
-      const long j = & right( i0, i1, i2, i3, i4, i5 ) -
-                     & right(  0,  0,  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2; }
-      offset = j;
-    }
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3)
+            for (unsigned i4 = 0; i4 < unsigned(right.extent(4)); ++i4)
+              for (unsigned i5 = 0; i5 < unsigned(right.extent(5)); ++i5) {
+                const long j =
+                    &right(i0, i1, i2, i3, i4, i5) - &right(0, 0, 0, 0, 0, 0);
+                if (j <= offset || right_alloc <= j) {
+                  update |= 2;
+                }
+                offset = j;
+              }
   }
 };
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 5 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 5> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutStride, execution_space > stride_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutStride, execution_space>
+      stride_view;
 
-  left_view    left;
-  right_view   right;
-  stride_view  left_stride;
-  stride_view  right_stride;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
-
+      : left("left"),
+        right("right"),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
+
+  void testit() {
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
+  void operator()(const size_type, value_type &update) const {
     long offset = -1;
 
-    for ( unsigned i4 = 0; i4 < unsigned( left.extent(4) ); ++i4 )
-    for ( unsigned i3 = 0; i3 < unsigned( left.extent(3) ); ++i3 )
-    for ( unsigned i2 = 0; i2 < unsigned( left.extent(2) ); ++i2 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3, i4 ) -
-                     & left(  0,  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1; }
-      offset = j;
-
-      if ( & left( i0, i1, i2, i3, i4 ) !=
-           & left_stride( i0, i1, i2, i3, i4 ) ) { update |= 4; }
-    }
+    for (unsigned i4 = 0; i4 < unsigned(left.extent(4)); ++i4)
+      for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+        for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+          for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+            for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+              const long j = &left(i0, i1, i2, i3, i4) - &left(0, 0, 0, 0, 0);
+              if (j <= offset || left_alloc <= j) {
+                update |= 1;
+              }
+              offset = j;
+
+              if (&left(i0, i1, i2, i3, i4) !=
+                  &left_stride(i0, i1, i2, i3, i4)) {
+                update |= 4;
+              }
+            }
 
     offset = -1;
 
-    for ( unsigned i0 = 0; i0 < unsigned( right.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( right.extent(1) ); ++i1 )
-    for ( unsigned i2 = 0; i2 < unsigned( right.extent(2) ); ++i2 )
-    for ( unsigned i3 = 0; i3 < unsigned( right.extent(3) ); ++i3 )
-    for ( unsigned i4 = 0; i4 < unsigned( right.extent(4) ); ++i4 )
-    {
-      const long j = & right( i0, i1, i2, i3, i4 ) -
-                     & right(  0,  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2; }
-      offset = j;
-
-      if ( & right( i0, i1, i2, i3, i4 ) !=
-           & right_stride( i0, i1, i2, i3, i4 ) ) { update |= 8; }
-    }
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3)
+            for (unsigned i4 = 0; i4 < unsigned(right.extent(4)); ++i4) {
+              const long j = &right(i0, i1, i2, i3, i4) - &right(0, 0, 0, 0, 0);
+              if (j <= offset || right_alloc <= j) {
+                update |= 2;
+              }
+              offset = j;
+
+              if (&right(i0, i1, i2, i3, i4) !=
+                  &right_stride(i0, i1, i2, i3, i4)) {
+                update |= 8;
+              }
+            }
   }
 };
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 4 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 4> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  left_view    left;
-  right_view   right;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
+      : left("left"),
+        right("right"),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
+  void testit() {
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
+  void operator()(const size_type, value_type &update) const {
     long offset = -1;
 
-    for ( unsigned i3 = 0; i3 < unsigned( left.extent(3) ); ++i3 )
-    for ( unsigned i2 = 0; i2 < unsigned( left.extent(2) ); ++i2 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
-      const long j = & left( i0, i1, i2, i3 ) -
-                     & left(  0,  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1; }
-      offset = j;
-    }
+    for (unsigned i3 = 0; i3 < unsigned(left.extent(3)); ++i3)
+      for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+        for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+          for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+            const long j = &left(i0, i1, i2, i3) - &left(0, 0, 0, 0);
+            if (j <= offset || left_alloc <= j) {
+              update |= 1;
+            }
+            offset = j;
+          }
 
     offset = -1;
 
-    for ( unsigned i0 = 0; i0 < unsigned( right.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( right.extent(1) ); ++i1 )
-    for ( unsigned i2 = 0; i2 < unsigned( right.extent(2) ); ++i2 )
-    for ( unsigned i3 = 0; i3 < unsigned( right.extent(3) ); ++i3 )
-    {
-      const long j = & right( i0, i1, i2, i3 ) -
-                     & right(  0,  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2; }
-      offset = j;
-    }
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2)
+          for (unsigned i3 = 0; i3 < unsigned(right.extent(3)); ++i3) {
+            const long j = &right(i0, i1, i2, i3) - &right(0, 0, 0, 0);
+            if (j <= offset || right_alloc <= j) {
+              update |= 2;
+            }
+            offset = j;
+          }
   }
 };
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 3 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 3> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutStride, execution_space > stride_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutStride, execution_space>
+      stride_view;
 
-  left_view    left;
-  right_view   right;
-  stride_view  left_stride;
-  stride_view  right_stride;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  std::string( "left" ) )
-    , right( std::string( "right" ) )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
-
+      : left(std::string("left")),
+        right(std::string("right")),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
+
+  void testit() {
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
+  void operator()(const size_type, value_type &update) const {
     long offset = -1;
 
-    for ( unsigned i2 = 0; i2 < unsigned( left.extent(2) ); ++i2 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
-      const long j = & left( i0, i1, i2 ) -
-                     & left(  0,  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1; }
-      offset = j;
+    for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2)
+      for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+        for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+          const long j = &left(i0, i1, i2) - &left(0, 0, 0);
+          if (j <= offset || left_alloc <= j) {
+            update |= 1;
+          }
+          offset = j;
 
-      if ( & left( i0, i1, i2 ) != & left_stride( i0, i1, i2 ) ) { update |= 4; }
-    }
+          if (&left(i0, i1, i2) != &left_stride(i0, i1, i2)) {
+            update |= 4;
+          }
+        }
 
     offset = -1;
 
-    for ( unsigned i0 = 0; i0 < unsigned( right.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( right.extent(1) ); ++i1 )
-    for ( unsigned i2 = 0; i2 < unsigned( right.extent(2) ); ++i2 )
-    {
-      const long j = & right( i0, i1, i2 ) -
-                     & right(  0,  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2; }
-      offset = j;
-
-      if ( & right( i0, i1, i2 ) != & right_stride( i0, i1, i2 ) ) { update |= 8; }
-    }
-
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i2 = 0; i2 < unsigned( left.extent(2) ); ++i2 )
-    {
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(right.extent(2)); ++i2) {
+          const long j = &right(i0, i1, i2) - &right(0, 0, 0);
+          if (j <= offset || right_alloc <= j) {
+            update |= 2;
+          }
+          offset = j;
+
+          if (&right(i0, i1, i2) != &right_stride(i0, i1, i2)) {
+            update |= 8;
+          }
+        }
+
+    for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+        for (unsigned i2 = 0; i2 < unsigned(left.extent(2)); ++i2) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-        if ( & left( i0, i1, i2 )  != & left( i0, i1, i2, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-        if ( & right( i0, i1, i2 ) != & right( i0, i1, i2, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+          if (&left(i0, i1, i2) != &left(i0, i1, i2, 0, 0, 0, 0, 0)) {
+            update |= 3;
+          }
+          if (&right(i0, i1, i2) != &right(i0, i1, i2, 0, 0, 0, 0, 0)) {
+            update |= 3;
+          }
 #else
-        if ( & left( i0, i1, i2 )  != & left.access( i0, i1, i2, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-        if ( & right( i0, i1, i2 ) != & right.access( i0, i1, i2, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+          if (&left(i0, i1, i2) != &left.access(i0, i1, i2, 0, 0, 0, 0, 0)) {
+            update |= 3;
+          }
+          if (&right(i0, i1, i2) != &right.access(i0, i1, i2, 0, 0, 0, 0, 0)) {
+            update |= 3;
+          }
 #endif
-    }
+        }
   }
 };
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 2 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 2> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
 
-  left_view    left;
-  right_view   right;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
+      : left("left"),
+        right("right"),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
 
+  void testit() {
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
+  void operator()(const size_type, value_type &update) const {
     long offset = -1;
 
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
-      const long j = & left( i0, i1 ) -
-                     & left(  0,  0 );
-      if ( j <= offset || left_alloc <= j ) { update |= 1; }
-      offset = j;
-    }
+    for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1)
+      for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
+        const long j = &left(i0, i1) - &left(0, 0);
+        if (j <= offset || left_alloc <= j) {
+          update |= 1;
+        }
+        offset = j;
+      }
 
     offset = -1;
 
-    for ( unsigned i0 = 0; i0 < unsigned( right.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( right.extent(1) ); ++i1 )
-    {
-      const long j = & right( i0, i1 ) -
-                     & right(  0,  0 );
-      if ( j <= offset || right_alloc <= j ) { update |= 2; }
-      offset = j;
-    }
+    for (unsigned i0 = 0; i0 < unsigned(right.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(right.extent(1)); ++i1) {
+        const long j = &right(i0, i1) - &right(0, 0);
+        if (j <= offset || right_alloc <= j) {
+          update |= 2;
+        }
+        offset = j;
+      }
 
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    for ( unsigned i1 = 0; i1 < unsigned( left.extent(1) ); ++i1 )
-    {
+    for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0)
+      for (unsigned i1 = 0; i1 < unsigned(left.extent(1)); ++i1) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      if ( & left( i0, i1 )  != & left( i0, i1, 0, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-      if ( & right( i0, i1 ) != & right( i0, i1, 0, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+        if (&left(i0, i1) != &left(i0, i1, 0, 0, 0, 0, 0, 0)) {
+          update |= 3;
+        }
+        if (&right(i0, i1) != &right(i0, i1, 0, 0, 0, 0, 0, 0)) {
+          update |= 3;
+        }
 #else
-      if ( & left( i0, i1 )  != & left.access( i0, i1, 0, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-      if ( & right( i0, i1 ) != & right.access( i0, i1, 0, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+        if (&left(i0, i1) != &left.access(i0, i1, 0, 0, 0, 0, 0, 0)) {
+          update |= 3;
+        }
+        if (&right(i0, i1) != &right.access(i0, i1, 0, 0, 0, 0, 0, 0)) {
+          update |= 3;
+        }
 #endif
-    }
+      }
   }
 };
 
-template< class DataType, class DeviceType >
-struct TestViewOperator_LeftAndRight< DataType, DeviceType, 1 >
-{
-  typedef typename DeviceType::execution_space  execution_space;
-  typedef typename DeviceType::memory_space     memory_space;
-  typedef typename execution_space::size_type   size_type;
+template <class DataType, class DeviceType>
+struct TestViewOperator_LeftAndRight<DataType, DeviceType, 1> {
+  typedef typename DeviceType::execution_space execution_space;
+  typedef typename DeviceType::memory_space memory_space;
+  typedef typename execution_space::size_type size_type;
 
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & input )
-  { update |= input; }
+  static void join(volatile value_type &update,
+                   const volatile value_type &input) {
+    update |= input;
+  }
 
   KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0; }
+  static void init(value_type &update) { update = 0; }
 
-  typedef Kokkos::View< DataType, Kokkos::LayoutLeft, execution_space > left_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutRight, execution_space > right_view;
-  typedef Kokkos::View< DataType, Kokkos::LayoutStride, execution_space > stride_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutLeft, execution_space> left_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutRight, execution_space>
+      right_view;
+  typedef Kokkos::View<DataType, Kokkos::LayoutStride, execution_space>
+      stride_view;
 
-  left_view    left;
-  right_view   right;
-  stride_view  left_stride;
-  stride_view  right_stride;
-  long         left_alloc;
-  long         right_alloc;
+  left_view left;
+  right_view right;
+  stride_view left_stride;
+  stride_view right_stride;
+  long left_alloc;
+  long right_alloc;
 
   TestViewOperator_LeftAndRight()
-    : left(  "left" )
-    , right( "right" )
-    , left_stride( left )
-    , right_stride( right )
-    , left_alloc( allocation_count( left ) )
-    , right_alloc( allocation_count( right ) )
-    {}
-
-  void testit()
-  {
+      : left("left"),
+        right("right"),
+        left_stride(left),
+        right_stride(right),
+        left_alloc(allocation_count(left)),
+        right_alloc(allocation_count(right)) {}
+
+  void testit() {
     TestViewOperator_LeftAndRight driver;
 
     int error_flag = 0;
 
-    Kokkos::parallel_reduce( 1, *this, error_flag );
+    Kokkos::parallel_reduce(1, *this, error_flag);
 
-    ASSERT_EQ( error_flag, 0 );
+    ASSERT_EQ(error_flag, 0);
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type, value_type & update ) const
-  {
-    for ( unsigned i0 = 0; i0 < unsigned( left.extent(0) ); ++i0 )
-    {
+  void operator()(const size_type, value_type &update) const {
+    for (unsigned i0 = 0; i0 < unsigned(left.extent(0)); ++i0) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      if ( & left( i0 )  != & left( i0, 0, 0, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-      if ( & right( i0 ) != & right( i0, 0, 0, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+      if (&left(i0) != &left(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
+      if (&right(i0) != &right(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
 #else
-      if ( & left( i0 )  != & left.access( i0, 0, 0, 0, 0, 0, 0, 0 ) )  { update |= 3; }
-      if ( & right( i0 ) != & right.access( i0, 0, 0, 0, 0, 0, 0, 0 ) ) { update |= 3; }
+      if (&left(i0) != &left.access(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
+      if (&right(i0) != &right.access(i0, 0, 0, 0, 0, 0, 0, 0)) {
+        update |= 3;
+      }
 #endif
-      if ( & left( i0 )  != & left_stride( i0 ) ) { update |= 4; }
-      if ( & right( i0 ) != & right_stride( i0 ) ) { update |= 8; }
+      if (&left(i0) != &left_stride(i0)) {
+        update |= 4;
+      }
+      if (&right(i0) != &right_stride(i0)) {
+        update |= 8;
+      }
     }
   }
 };
 
-template< class Layout, class DeviceType >
-struct TestViewMirror
-{
-  template< class MemoryTraits >
+template <class Layout, class DeviceType>
+struct TestViewMirror {
+  template <class MemoryTraits>
   void static test_mirror() {
-    Kokkos::View< double*, Layout, Kokkos::HostSpace > a_org( "A", 1000 );
-    Kokkos::View< double*, Layout, Kokkos::HostSpace, MemoryTraits > a_h = a_org;
-    auto a_h2 = Kokkos::create_mirror( Kokkos::HostSpace(), a_h );
-    auto a_d = Kokkos::create_mirror( DeviceType(), a_h );
+    Kokkos::View<double *, Layout, Kokkos::HostSpace> a_org("A", 1000);
+    Kokkos::View<double *, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
+    auto a_h2 = Kokkos::create_mirror(Kokkos::HostSpace(), a_h);
+    auto a_d  = Kokkos::create_mirror(DeviceType(), a_h);
 
-    int equal_ptr_h_h2 = ( a_h.data()  == a_h2.data() ) ? 1 : 0;
-    int equal_ptr_h_d  = ( a_h.data()  ==  a_d.data() ) ? 1 : 0;
-    int equal_ptr_h2_d = ( a_h2.data() ==  a_d.data() ) ? 1 : 0;
+    int equal_ptr_h_h2 = (a_h.data() == a_h2.data()) ? 1 : 0;
+    int equal_ptr_h_d  = (a_h.data() == a_d.data()) ? 1 : 0;
+    int equal_ptr_h2_d = (a_h2.data() == a_d.data()) ? 1 : 0;
 
-    ASSERT_EQ( equal_ptr_h_h2, 0 );
-    ASSERT_EQ( equal_ptr_h_d, 0 );
-    ASSERT_EQ( equal_ptr_h2_d, 0 );
+    ASSERT_EQ(equal_ptr_h_h2, 0);
+    ASSERT_EQ(equal_ptr_h_d, 0);
+    ASSERT_EQ(equal_ptr_h2_d, 0);
 
-    ASSERT_EQ( a_h.extent(0), a_h2.extent(0) );
-    ASSERT_EQ( a_h.extent(0), a_d .extent(0) );
+    ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+    ASSERT_EQ(a_h.extent(0), a_d.extent(0));
   }
 
-  template< class MemoryTraits >
+  template <class MemoryTraits>
   void static test_mirror_view() {
-    Kokkos::View< double*, Layout, Kokkos::HostSpace > a_org( "A", 1000 );
-    Kokkos::View< double*, Layout, Kokkos::HostSpace, MemoryTraits > a_h = a_org;
-    auto a_h2 = Kokkos::create_mirror_view( Kokkos::HostSpace(), a_h );
-    auto a_d = Kokkos::create_mirror_view( DeviceType(), a_h );
-
-    int equal_ptr_h_h2 = a_h.data()  == a_h2.data() ? 1 : 0;
-    int equal_ptr_h_d  = a_h.data()  ==  a_d.data() ? 1 : 0;
-    int equal_ptr_h2_d = a_h2.data() ==  a_d.data() ? 1 : 0;
-
-    int is_same_memspace = std::is_same< Kokkos::HostSpace, typename DeviceType::memory_space >::value ? 1 : 0;
-    ASSERT_EQ( equal_ptr_h_h2, 1 );
-    ASSERT_EQ( equal_ptr_h_d, is_same_memspace );
-    ASSERT_EQ( equal_ptr_h2_d, is_same_memspace );
-
-    ASSERT_EQ( a_h.extent(0), a_h2.extent(0) );
-    ASSERT_EQ( a_h.extent(0), a_d .extent(0) );
+    Kokkos::View<double *, Layout, Kokkos::HostSpace> a_org("A", 1000);
+    Kokkos::View<double *, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
+    auto a_h2 = Kokkos::create_mirror_view(Kokkos::HostSpace(), a_h);
+    auto a_d  = Kokkos::create_mirror_view(DeviceType(), a_h);
+
+    int equal_ptr_h_h2 = a_h.data() == a_h2.data() ? 1 : 0;
+    int equal_ptr_h_d  = a_h.data() == a_d.data() ? 1 : 0;
+    int equal_ptr_h2_d = a_h2.data() == a_d.data() ? 1 : 0;
+
+    int is_same_memspace =
+        std::is_same<Kokkos::HostSpace,
+                     typename DeviceType::memory_space>::value
+            ? 1
+            : 0;
+    ASSERT_EQ(equal_ptr_h_h2, 1);
+    ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
+    ASSERT_EQ(equal_ptr_h2_d, is_same_memspace);
+
+    ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+    ASSERT_EQ(a_h.extent(0), a_d.extent(0));
   }
 
-  template< class MemoryTraits >
+  template <class MemoryTraits>
   void static test_mirror_copy() {
-    Kokkos::View< double*, Layout, Kokkos::HostSpace > a_org( "A", 10 );
-    a_org(5) = 42.0;
-    Kokkos::View< double*, Layout, Kokkos::HostSpace, MemoryTraits > a_h = a_org;
-    auto a_h2 = Kokkos::create_mirror_view_and_copy( Kokkos::HostSpace(), a_h );
-    auto a_d = Kokkos::create_mirror_view_and_copy( DeviceType(), a_h );
-    auto a_h3 = Kokkos::create_mirror_view_and_copy( Kokkos::HostSpace(), a_d );
-
-    int equal_ptr_h_h2 = a_h.data()  == a_h2.data() ? 1 : 0;
-    int equal_ptr_h_d  = a_h.data()  ==  a_d.data() ? 1 : 0;
-    int equal_ptr_h2_d = a_h2.data() ==  a_d.data() ? 1 : 0;
-    int equal_ptr_h3_d = a_h3.data() ==  a_d.data() ? 1 : 0;
-
-    int is_same_memspace = std::is_same< Kokkos::HostSpace, typename DeviceType::memory_space >::value ? 1 : 0;
-    ASSERT_EQ( equal_ptr_h_h2, 1 );
-    ASSERT_EQ( equal_ptr_h_d, is_same_memspace );
-    ASSERT_EQ( equal_ptr_h2_d, is_same_memspace );
-    ASSERT_EQ( equal_ptr_h3_d, is_same_memspace );
-
-    ASSERT_EQ( a_h.extent(0), a_h3.extent(0) );
-    ASSERT_EQ( a_h.extent(0), a_h2.extent(0) );
-    ASSERT_EQ( a_h.extent(0), a_d .extent(0) );
-    ASSERT_EQ( a_org(5), a_h3(5) );
+    Kokkos::View<double *, Layout, Kokkos::HostSpace> a_org("A", 10);
+    a_org(5)                                                            = 42.0;
+    Kokkos::View<double *, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
+    auto a_h2 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), a_h);
+    auto a_d  = Kokkos::create_mirror_view_and_copy(DeviceType(), a_h);
+    auto a_h3 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), a_d);
+
+    int equal_ptr_h_h2 = a_h.data() == a_h2.data() ? 1 : 0;
+    int equal_ptr_h_d  = a_h.data() == a_d.data() ? 1 : 0;
+    int equal_ptr_h2_d = a_h2.data() == a_d.data() ? 1 : 0;
+    int equal_ptr_h3_d = a_h3.data() == a_d.data() ? 1 : 0;
+
+    int is_same_memspace =
+        std::is_same<Kokkos::HostSpace,
+                     typename DeviceType::memory_space>::value
+            ? 1
+            : 0;
+    ASSERT_EQ(equal_ptr_h_h2, 1);
+    ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
+    ASSERT_EQ(equal_ptr_h2_d, is_same_memspace);
+    ASSERT_EQ(equal_ptr_h3_d, is_same_memspace);
+
+    ASSERT_EQ(a_h.extent(0), a_h3.extent(0));
+    ASSERT_EQ(a_h.extent(0), a_h2.extent(0));
+    ASSERT_EQ(a_h.extent(0), a_d.extent(0));
+    ASSERT_EQ(a_org(5), a_h3(5));
   }
 
-  template< class MemoryTraits, class Space >
+  template <class MemoryTraits, class Space>
   struct CopyUnInit {
-    typedef typename Kokkos::Impl::MirrorViewType<Space, double*, Layout, Kokkos::HostSpace, MemoryTraits>::view_type mirror_view_type;
+    typedef typename Kokkos::Impl::MirrorViewType<
+        Space, double *, Layout, Kokkos::HostSpace, MemoryTraits>::view_type
+        mirror_view_type;
 
     mirror_view_type a_d;
 
     KOKKOS_INLINE_FUNCTION
-    CopyUnInit( mirror_view_type & a_d_ ) : a_d(a_d_) {
-    }
+    CopyUnInit(mirror_view_type &a_d_) : a_d(a_d_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator() (const typename Space::size_type i) const {
-       a_d(i) = (double)(10-i);
+    void operator()(const typename Space::size_type i) const {
+      a_d(i) = (double)(10 - i);
     }
-    
   };
 
-  template< class MemoryTraits >
+  template <class MemoryTraits>
   void static test_mirror_no_initialize() {
-    Kokkos::View< double*, Layout, Kokkos::HostSpace > a_org( "A", 10 );
-    Kokkos::View< double*, Layout, Kokkos::HostSpace, MemoryTraits > a_h = a_org;
+    Kokkos::View<double *, Layout, Kokkos::HostSpace> a_org("A", 10);
+    Kokkos::View<double *, Layout, Kokkos::HostSpace, MemoryTraits> a_h = a_org;
 
-    for (int i = 0; i < 10; i++)
-    {
-       a_h(i) = (double)i;   
+    for (int i = 0; i < 10; i++) {
+      a_h(i) = (double)i;
     }
-    auto a_d = Kokkos::create_mirror_view( DeviceType(), a_h, Kokkos::WithoutInitializing );
-    
+    auto a_d = Kokkos::create_mirror_view(DeviceType(), a_h,
+                                          Kokkos::WithoutInitializing);
+
     int equal_ptr_h_d = (a_h.data() == a_d.data()) ? 1 : 0;
-    constexpr int is_same_memspace = std::is_same< Kokkos::HostSpace, typename DeviceType::memory_space >::value ? 1 : 0;
-    
-    ASSERT_EQ( equal_ptr_h_d, is_same_memspace);
+    constexpr int is_same_memspace =
+        std::is_same<Kokkos::HostSpace,
+                     typename DeviceType::memory_space>::value
+            ? 1
+            : 0;
 
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename DeviceType::execution_space >( 0, int(10)), CopyUnInit< MemoryTraits, DeviceType >(a_d));
+    ASSERT_EQ(equal_ptr_h_d, is_same_memspace);
 
-    Kokkos::deep_copy( a_h, a_d );
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<typename DeviceType::execution_space>(0, int(10)),
+        CopyUnInit<MemoryTraits, DeviceType>(a_d));
 
-    for (int i = 0; i < 10; i++)
-    {
-       ASSERT_EQ(a_h(i), (double)(10-i));
+    Kokkos::deep_copy(a_h, a_d);
+
+    for (int i = 0; i < 10; i++) {
+      ASSERT_EQ(a_h(i), (double)(10 - i));
     }
   }
 
   void static testit() {
-    test_mirror< Kokkos::MemoryTraits<0> >();
-    test_mirror< Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
-    test_mirror_view< Kokkos::MemoryTraits<0> >();
-    test_mirror_view< Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
-    test_mirror_copy< Kokkos::MemoryTraits<0> >();
-    test_mirror_copy< Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
-    test_mirror_no_initialize< Kokkos::MemoryTraits<0> >();
-    test_mirror_no_initialize< Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
+    test_mirror<Kokkos::MemoryTraits<0> >();
+    test_mirror<Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
+    test_mirror_view<Kokkos::MemoryTraits<0> >();
+    test_mirror_view<Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
+    test_mirror_copy<Kokkos::MemoryTraits<0> >();
+    test_mirror_copy<Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
+    test_mirror_no_initialize<Kokkos::MemoryTraits<0> >();
+    test_mirror_no_initialize<Kokkos::MemoryTraits<Kokkos::Unmanaged> >();
   }
 };
 
 /*--------------------------------------------------------------------------*/
 
-template< typename T, class DeviceType >
-class TestViewAPI
-{
-public:
+template <typename T, class DeviceType>
+class TestViewAPI {
+ public:
   typedef DeviceType device;
 
-  enum { N0 = 1000,
-         N1 = 3,
-         N2 = 5,
-         N3 = 7 };
-
-  typedef Kokkos::View< T, device > dView0;
-  typedef Kokkos::View< T*, device > dView1;
-  typedef Kokkos::View< T*[N1], device > dView2;
-  typedef Kokkos::View< T*[N1][N2], device > dView3;
-  typedef Kokkos::View< T*[N1][N2][N3], device > dView4;
-  typedef Kokkos::View< const T*[N1][N2][N3], device > const_dView4;
-  typedef Kokkos::View< T****, device, Kokkos::MemoryUnmanaged > dView4_unmanaged;
+  enum { N0 = 1000, N1 = 3, N2 = 5, N3 = 7 };
+
+  typedef Kokkos::View<T, device> dView0;
+  typedef Kokkos::View<T *, device> dView1;
+  typedef Kokkos::View<T * [N1], device> dView2;
+  typedef Kokkos::View<T * [N1][N2], device> dView3;
+  typedef Kokkos::View<T * [N1][N2][N3], device> dView4;
+  typedef Kokkos::View<const T * [N1][N2][N3], device> const_dView4;
+  typedef Kokkos::View<T ****, device, Kokkos::MemoryUnmanaged>
+      dView4_unmanaged;
   typedef typename dView0::host_mirror_space host;
 
-  TestViewAPI()
-  {
-  }
+  TestViewAPI() {}
 
   static void run_test_view_operator_a() {
-    {TestViewOperator< T, device > f; Kokkos::parallel_for(int(N0),f); Kokkos::fence();}
+    {
+      TestViewOperator<T, device> f;
+      Kokkos::parallel_for(int(N0), f);
+      Kokkos::fence();
+    }
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
-    TestViewOperator_LeftAndRight< int[2][3][4][2][3][4], device >f6; f6.testit();
-    TestViewOperator_LeftAndRight< int[2][3][4][2][3], device >f5; f5.testit();
-    TestViewOperator_LeftAndRight< int[2][3][4][2], device >f4; f4.testit();
-    TestViewOperator_LeftAndRight< int[2][3][4], device >f3; f3.testit();
-    TestViewOperator_LeftAndRight< int[2][3], device >f2; f2.testit();
-    TestViewOperator_LeftAndRight< int[2], device >f1; f1.testit();
+    TestViewOperator_LeftAndRight<int[2][3][4][2][3][4], device> f6;
+    f6.testit();
+    TestViewOperator_LeftAndRight<int[2][3][4][2][3], device> f5;
+    f5.testit();
+    TestViewOperator_LeftAndRight<int[2][3][4][2], device> f4;
+    f4.testit();
+    TestViewOperator_LeftAndRight<int[2][3][4], device> f3;
+    f3.testit();
+    TestViewOperator_LeftAndRight<int[2][3], device> f2;
+    f2.testit();
+    TestViewOperator_LeftAndRight<int[2], device> f1;
+    f1.testit();
 #endif
   }
 
   static void run_test_view_operator_b() {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
-    TestViewOperator_LeftAndRight< int[2][3][4][2][3][4][2], device > f7; f7.testit();
+    TestViewOperator_LeftAndRight<int[2][3][4][2][3][4][2], device> f7;
+    f7.testit();
 #endif
   }
 
   static void run_test_view_operator_c() {
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
-    TestViewOperator_LeftAndRight< int[2][3][4][2][3][4][2][3], device > f8; f8.testit();
+    TestViewOperator_LeftAndRight<int[2][3][4][2][3][4][2][3], device> f8;
+    f8.testit();
 #endif
   }
 
-  static void run_test_mirror()
-  {
-    typedef Kokkos::View< int, host > view_type;
+  static void run_test_mirror() {
+    typedef Kokkos::View<int, host> view_type;
     typedef typename view_type::HostMirror mirror_type;
 
-    static_assert( std::is_same< typename view_type::memory_space, typename mirror_type::memory_space >::value, "" );
+    static_assert(std::is_same<typename view_type::memory_space,
+                               typename mirror_type::memory_space>::value,
+                  "");
 
-    view_type a( "a" );
-    mirror_type am = Kokkos::create_mirror_view( a );
-    mirror_type ax = Kokkos::create_mirror( a );
-    ASSERT_EQ( & a(), & am() );
+    view_type a("a");
+    mirror_type am = Kokkos::create_mirror_view(a);
+    mirror_type ax = Kokkos::create_mirror(a);
+    ASSERT_EQ(&a(), &am());
 
-    TestViewMirror< Kokkos::LayoutLeft, device >::testit();
-    TestViewMirror< Kokkos::LayoutRight, device >::testit();
+    TestViewMirror<Kokkos::LayoutLeft, device>::testit();
+    TestViewMirror<Kokkos::LayoutRight, device>::testit();
   }
 
-  static void run_test_scalar()
-  {
-    typedef typename dView0::HostMirror  hView0;
+  static void run_test_scalar() {
+    typedef typename dView0::HostMirror hView0;
 
     dView0 dx, dy;
     hView0 hx, hy;
 
-    dx = dView0( "dx" );
-    dy = dView0( "dy" );
+    dx = dView0("dx");
+    dy = dView0("dy");
 
-    hx = Kokkos::create_mirror( dx );
-    hy = Kokkos::create_mirror( dy );
+    hx = Kokkos::create_mirror(dx);
+    hy = Kokkos::create_mirror(dy);
 
     hx() = 1;
 
-    Kokkos::deep_copy( dx, hx );
-    Kokkos::deep_copy( dy, dx );
-    Kokkos::deep_copy( hy, dy );
+    Kokkos::deep_copy(dx, hx);
+    Kokkos::deep_copy(dy, dx);
+    Kokkos::deep_copy(hy, dy);
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
-    ASSERT_EQ( hx(), hy() );
+    ASSERT_EQ(hx(), hy());
 #endif
   }
 
-  static void run_test()
-  {
+  static void run_test() {
     // mfh 14 Feb 2014: This test doesn't actually create instances of
     // these types.  In order to avoid "declared but unused typedef"
     // warnings, we declare empty instances of these types, with the
     // usual "(void)" marker to avoid compiler warnings for unused
     // variables.
 
-    typedef typename dView0::HostMirror  hView0;
-    typedef typename dView1::HostMirror  hView1;
-    typedef typename dView2::HostMirror  hView2;
-    typedef typename dView3::HostMirror  hView3;
-    typedef typename dView4::HostMirror  hView4;
+    typedef typename dView0::HostMirror hView0;
+    typedef typename dView1::HostMirror hView1;
+    typedef typename dView2::HostMirror hView2;
+    typedef typename dView3::HostMirror hView3;
+    typedef typename dView4::HostMirror hView4;
 
     {
       hView0 thing;
-      (void) thing;
+      (void)thing;
     }
     {
       hView1 thing;
-      (void) thing;
+      (void)thing;
     }
     {
       hView2 thing;
-      (void) thing;
+      (void)thing;
     }
     {
       hView3 thing;
-      (void) thing;
+      (void)thing;
     }
     {
       hView4 thing;
-      (void) thing;
+      (void)thing;
     }
 
     dView4 dx, dy, dz;
     hView4 hx, hy, hz;
 
-    ASSERT_TRUE( dx.data() == 0 );
-    ASSERT_TRUE( dy.data() == 0 );
-    ASSERT_TRUE( dz.data() == 0 );
-    ASSERT_TRUE( hx.data() == 0 );
-    ASSERT_TRUE( hy.data() == 0 );
-    ASSERT_TRUE( hz.data() == 0 );
-    ASSERT_EQ( dx.extent(0), 0u );
-    ASSERT_EQ( dy.extent(0), 0u );
-    ASSERT_EQ( dz.extent(0), 0u );
-    ASSERT_EQ( hx.extent(0), 0u );
-    ASSERT_EQ( hy.extent(0), 0u );
-    ASSERT_EQ( hz.extent(0), 0u );
-    ASSERT_EQ( dx.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( dy.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( dz.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( hx.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( hy.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( hz.extent(1), unsigned( N1 ) );
-
-    dx = dView4( "dx", N0 );
-    dy = dView4( "dy", N0 );
-
-    ASSERT_EQ( dx.use_count(), size_t( 1 ) );
+    ASSERT_TRUE(dx.data() == 0);
+    ASSERT_TRUE(dy.data() == 0);
+    ASSERT_TRUE(dz.data() == 0);
+    ASSERT_TRUE(hx.data() == 0);
+    ASSERT_TRUE(hy.data() == 0);
+    ASSERT_TRUE(hz.data() == 0);
+    ASSERT_EQ(dx.extent(0), 0u);
+    ASSERT_EQ(dy.extent(0), 0u);
+    ASSERT_EQ(dz.extent(0), 0u);
+    ASSERT_EQ(hx.extent(0), 0u);
+    ASSERT_EQ(hy.extent(0), 0u);
+    ASSERT_EQ(hz.extent(0), 0u);
+    ASSERT_EQ(dx.extent(1), unsigned(N1));
+    ASSERT_EQ(dy.extent(1), unsigned(N1));
+    ASSERT_EQ(dz.extent(1), unsigned(N1));
+    ASSERT_EQ(hx.extent(1), unsigned(N1));
+    ASSERT_EQ(hy.extent(1), unsigned(N1));
+    ASSERT_EQ(hz.extent(1), unsigned(N1));
+
+    dx = dView4("dx", N0);
+    dy = dView4("dy", N0);
+
+    ASSERT_EQ(dx.use_count(), size_t(1));
 
     dView4_unmanaged unmanaged_dx = dx;
-    ASSERT_EQ( dx.use_count(), size_t( 1 ) );
+    ASSERT_EQ(dx.use_count(), size_t(1));
 
-    dView4_unmanaged unmanaged_from_ptr_dx = dView4_unmanaged( dx.data(),
-                                                               dx.extent(0),
-                                                               dx.extent(1),
-                                                               dx.extent(2),
-                                                               dx.extent(3) );
+    dView4_unmanaged unmanaged_from_ptr_dx = dView4_unmanaged(
+        dx.data(), dx.extent(0), dx.extent(1), dx.extent(2), dx.extent(3));
 
     {
       // Destruction of this view should be harmless.
 
-      const_dView4 unmanaged_from_ptr_const_dx( dx.data(),
-                                                dx.extent(0)
+      const_dView4 unmanaged_from_ptr_const_dx(dx.data(), dx.extent(0)
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-                                                ,dx.extent(1),
-                                                dx.extent(2),
-                                                dx.extent(3)
+                                                              ,
+                                               dx.extent(1), dx.extent(2),
+                                               dx.extent(3)
 #endif
-                                                );
+      );
     }
 
     const_dView4 const_dx = dx;
-    ASSERT_EQ( dx.use_count(), size_t( 2 ) );
+    ASSERT_EQ(dx.use_count(), size_t(2));
 
     {
       const_dView4 const_dx2;
       const_dx2 = const_dx;
-      ASSERT_EQ( dx.use_count(), size_t( 3 ) );
+      ASSERT_EQ(dx.use_count(), size_t(3));
 
       const_dx2 = dy;
-      ASSERT_EQ( dx.use_count(), size_t( 2 ) );
+      ASSERT_EQ(dx.use_count(), size_t(2));
 
-      const_dView4 const_dx3( dx );
-      ASSERT_EQ( dx.use_count(), size_t( 3 ) );
+      const_dView4 const_dx3(dx);
+      ASSERT_EQ(dx.use_count(), size_t(3));
 
-      dView4_unmanaged dx4_unmanaged( dx );
-      ASSERT_EQ( dx.use_count(), size_t( 3 ) );
+      dView4_unmanaged dx4_unmanaged(dx);
+      ASSERT_EQ(dx.use_count(), size_t(3));
     }
 
-    ASSERT_EQ( dx.use_count(), size_t( 2 ) );
+    ASSERT_EQ(dx.use_count(), size_t(2));
 
-    ASSERT_FALSE( dx.data() == 0 );
-    ASSERT_FALSE( const_dx.data() == 0 );
-    ASSERT_FALSE( unmanaged_dx.data() == 0 );
-    ASSERT_FALSE( unmanaged_from_ptr_dx.data() == 0 );
-    ASSERT_FALSE( dy.data() == 0 );
-    ASSERT_NE( dx, dy );
+    ASSERT_FALSE(dx.data() == 0);
+    ASSERT_FALSE(const_dx.data() == 0);
+    ASSERT_FALSE(unmanaged_dx.data() == 0);
+    ASSERT_FALSE(unmanaged_from_ptr_dx.data() == 0);
+    ASSERT_FALSE(dy.data() == 0);
+    ASSERT_NE(dx, dy);
 
-    ASSERT_EQ( dx.extent(0), unsigned( N0 ) );
-    ASSERT_EQ( dx.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( dx.extent(2), unsigned( N2 ) );
-    ASSERT_EQ( dx.extent(3), unsigned( N3 ) );
+    ASSERT_EQ(dx.extent(0), unsigned(N0));
+    ASSERT_EQ(dx.extent(1), unsigned(N1));
+    ASSERT_EQ(dx.extent(2), unsigned(N2));
+    ASSERT_EQ(dx.extent(3), unsigned(N3));
 
-    ASSERT_EQ( dy.extent(0), unsigned( N0 ) );
-    ASSERT_EQ( dy.extent(1), unsigned( N1 ) );
-    ASSERT_EQ( dy.extent(2), unsigned( N2 ) );
-    ASSERT_EQ( dy.extent(3), unsigned( N3 ) );
+    ASSERT_EQ(dy.extent(0), unsigned(N0));
+    ASSERT_EQ(dy.extent(1), unsigned(N1));
+    ASSERT_EQ(dy.extent(2), unsigned(N2));
+    ASSERT_EQ(dy.extent(3), unsigned(N3));
 
-    ASSERT_EQ( unmanaged_from_ptr_dx.span(), unsigned( N0 ) * unsigned( N1 ) * unsigned( N2 ) * unsigned( N3 ) );
+    ASSERT_EQ(unmanaged_from_ptr_dx.span(),
+              unsigned(N0) * unsigned(N1) * unsigned(N2) * unsigned(N3));
 #ifdef KOKKOS_ENABLE_OPENMPTARGET
-return;
+    return;
 #endif
-    hx = Kokkos::create_mirror( dx );
-    hy = Kokkos::create_mirror( dy );
+    hx = Kokkos::create_mirror(dx);
+    hy = Kokkos::create_mirror(dy);
 
     // T v1 = hx();       // Generates compile error as intended.
     // T v2 = hx( 0, 0 ); // Generates compile error as intended.
@@ -1107,332 +1129,349 @@ return;
     {
       size_t count = 0;
 
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < hx.extent(1); ++i1 )
-      for ( size_t i2 = 0; i2 < hx.extent(2); ++i2 )
-      for ( size_t i3 = 0; i3 < hx.extent(3); ++i3 )
-      {
-        hx( ip, i1, i2, i3 ) = ++count;
-      }
-
-      Kokkos::deep_copy( typename hView4::execution_space(), dx, hx );
-      Kokkos::deep_copy( typename hView4::execution_space(), dy, dx );
-      Kokkos::deep_copy( typename hView4::execution_space(), hy, dy );
-
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < N1; ++i1 )
-      for ( size_t i2 = 0; i2 < N2; ++i2 )
-      for ( size_t i3 = 0; i3 < N3; ++i3 )
-      {
-        ASSERT_EQ( hx( ip, i1, i2, i3 ), hy( ip, i1, i2, i3 ) );
-      }
-
-      Kokkos::deep_copy( typename hView4::execution_space(), dx, T( 0 ) );
-      Kokkos::deep_copy( typename hView4::execution_space(), hx, dx );
-
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < N1; ++i1 )
-      for ( size_t i2 = 0; i2 < N2; ++i2 )
-      for ( size_t i3 = 0; i3 < N3; ++i3 )
-      {
-        ASSERT_EQ( hx( ip, i1, i2, i3 ), T( 0 ) );
-      }
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < hx.extent(1); ++i1)
+          for (size_t i2 = 0; i2 < hx.extent(2); ++i2)
+            for (size_t i3 = 0; i3 < hx.extent(3); ++i3) {
+              hx(ip, i1, i2, i3) = ++count;
+            }
+
+      Kokkos::deep_copy(typename hView4::execution_space(), dx, hx);
+      Kokkos::deep_copy(typename hView4::execution_space(), dy, dx);
+      Kokkos::deep_copy(typename hView4::execution_space(), hy, dy);
+
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < N1; ++i1)
+          for (size_t i2 = 0; i2 < N2; ++i2)
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              ASSERT_EQ(hx(ip, i1, i2, i3), hy(ip, i1, i2, i3));
+            }
+
+      Kokkos::deep_copy(typename hView4::execution_space(), dx, T(0));
+      Kokkos::deep_copy(typename hView4::execution_space(), hx, dx);
+
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < N1; ++i1)
+          for (size_t i2 = 0; i2 < N2; ++i2)
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              ASSERT_EQ(hx(ip, i1, i2, i3), T(0));
+            }
     }
 
     // Testing with asynchronous deep copy with respect to host.
     {
       size_t count = 0;
 
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < hx.extent(1); ++i1 )
-      for ( size_t i2 = 0; i2 < hx.extent(2); ++i2 )
-      for ( size_t i3 = 0; i3 < hx.extent(3); ++i3 )
-      {
-        hx( ip, i1, i2, i3 ) = ++count;
-      }
-
-      Kokkos::deep_copy( typename dView4::execution_space(), dx, hx );
-      Kokkos::deep_copy( typename dView4::execution_space(), dy, dx );
-      Kokkos::deep_copy( typename dView4::execution_space(), hy, dy );
-
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < N1; ++i1 )
-      for ( size_t i2 = 0; i2 < N2; ++i2 )
-      for ( size_t i3 = 0; i3 < N3; ++i3 )
-      {
-        ASSERT_EQ( hx( ip, i1, i2, i3 ), hy( ip, i1, i2, i3 ) );
-      }
-
-      Kokkos::deep_copy( typename dView4::execution_space(), dx, T( 0 ) );
-      Kokkos::deep_copy( typename dView4::execution_space(), hx, dx );
-
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < N1; ++i1 )
-      for ( size_t i2 = 0; i2 < N2; ++i2 )
-      for ( size_t i3 = 0; i3 < N3; ++i3 )
-      {
-        ASSERT_EQ( hx( ip, i1, i2, i3 ), T( 0 ) );
-      }
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < hx.extent(1); ++i1)
+          for (size_t i2 = 0; i2 < hx.extent(2); ++i2)
+            for (size_t i3 = 0; i3 < hx.extent(3); ++i3) {
+              hx(ip, i1, i2, i3) = ++count;
+            }
+
+      Kokkos::deep_copy(typename dView4::execution_space(), dx, hx);
+      Kokkos::deep_copy(typename dView4::execution_space(), dy, dx);
+      Kokkos::deep_copy(typename dView4::execution_space(), hy, dy);
+
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < N1; ++i1)
+          for (size_t i2 = 0; i2 < N2; ++i2)
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              ASSERT_EQ(hx(ip, i1, i2, i3), hy(ip, i1, i2, i3));
+            }
+
+      Kokkos::deep_copy(typename dView4::execution_space(), dx, T(0));
+      Kokkos::deep_copy(typename dView4::execution_space(), hx, dx);
+
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < N1; ++i1)
+          for (size_t i2 = 0; i2 < N2; ++i2)
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              ASSERT_EQ(hx(ip, i1, i2, i3), T(0));
+            }
     }
 
     // Testing with synchronous deep copy.
     {
       size_t count = 0;
 
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < hx.extent(1); ++i1 )
-      for ( size_t i2 = 0; i2 < hx.extent(2); ++i2 )
-      for ( size_t i3 = 0; i3 < hx.extent(3); ++i3 )
-      {
-        hx( ip, i1, i2, i3 ) = ++count;
-      }
-
-      Kokkos::deep_copy( dx, hx );
-      Kokkos::deep_copy( dy, dx );
-      Kokkos::deep_copy( hy, dy );
-
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < N1; ++i1 )
-      for ( size_t i2 = 0; i2 < N2; ++i2 )
-      for ( size_t i3 = 0; i3 < N3; ++i3 )
-      {
-        ASSERT_EQ( hx( ip, i1, i2, i3 ), hy( ip, i1, i2, i3 ) );
-      }
-
-      Kokkos::deep_copy( dx, T( 0 ) );
-      Kokkos::deep_copy( hx, dx );
-
-      for ( size_t ip = 0; ip < N0; ++ip )
-      for ( size_t i1 = 0; i1 < N1; ++i1 )
-      for ( size_t i2 = 0; i2 < N2; ++i2 )
-      for ( size_t i3 = 0; i3 < N3; ++i3 )
-      {
-        ASSERT_EQ( hx( ip, i1, i2, i3 ), T( 0 ) );
-      }
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < hx.extent(1); ++i1)
+          for (size_t i2 = 0; i2 < hx.extent(2); ++i2)
+            for (size_t i3 = 0; i3 < hx.extent(3); ++i3) {
+              hx(ip, i1, i2, i3) = ++count;
+            }
+
+      Kokkos::deep_copy(dx, hx);
+      Kokkos::deep_copy(dy, dx);
+      Kokkos::deep_copy(hy, dy);
+
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < N1; ++i1)
+          for (size_t i2 = 0; i2 < N2; ++i2)
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              ASSERT_EQ(hx(ip, i1, i2, i3), hy(ip, i1, i2, i3));
+            }
+
+      Kokkos::deep_copy(dx, T(0));
+      Kokkos::deep_copy(hx, dx);
+
+      for (size_t ip = 0; ip < N0; ++ip)
+        for (size_t i1 = 0; i1 < N1; ++i1)
+          for (size_t i2 = 0; i2 < N2; ++i2)
+            for (size_t i3 = 0; i3 < N3; ++i3) {
+              ASSERT_EQ(hx(ip, i1, i2, i3), T(0));
+            }
     }
 
     dz = dx;
-    ASSERT_EQ( dx, dz );
-    ASSERT_NE( dy, dz );
+    ASSERT_EQ(dx, dz);
+    ASSERT_NE(dy, dz);
 
     dz = dy;
-    ASSERT_EQ( dy, dz );
-    ASSERT_NE( dx, dz );
+    ASSERT_EQ(dy, dz);
+    ASSERT_NE(dx, dz);
 
     dx = dView4();
-    ASSERT_TRUE( dx.data() == 0 );
-    ASSERT_FALSE( dy.data() == 0 );
-    ASSERT_FALSE( dz.data() == 0 );
+    ASSERT_TRUE(dx.data() == 0);
+    ASSERT_FALSE(dy.data() == 0);
+    ASSERT_FALSE(dz.data() == 0);
 
     dy = dView4();
-    ASSERT_TRUE( dx.data() == 0 );
-    ASSERT_TRUE( dy.data() == 0 );
-    ASSERT_FALSE( dz.data() == 0 );
+    ASSERT_TRUE(dx.data() == 0);
+    ASSERT_TRUE(dy.data() == 0);
+    ASSERT_FALSE(dz.data() == 0);
 
     dz = dView4();
-    ASSERT_TRUE( dx.data() == 0 );
-    ASSERT_TRUE( dy.data() == 0 );
-    ASSERT_TRUE( dz.data() == 0 );
+    ASSERT_TRUE(dx.data() == 0);
+    ASSERT_TRUE(dy.data() == 0);
+    ASSERT_TRUE(dz.data() == 0);
   }
 
   static void run_test_deep_copy_empty() {
     // Check Deep Copy of LayoutLeft to LayoutRight
     {
-      Kokkos::View<double*,Kokkos::LayoutLeft> dll("dll",10);
-      Kokkos::View<double*,Kokkos::LayoutRight,Kokkos::HostSpace> hlr("hlr",10);
-      Kokkos::deep_copy(dll,hlr);
-      Kokkos::deep_copy(hlr,dll);
+      Kokkos::View<double *, Kokkos::LayoutLeft> dll("dll", 10);
+      Kokkos::View<double *, Kokkos::LayoutRight, Kokkos::HostSpace> hlr("hlr",
+                                                                         10);
+      Kokkos::deep_copy(dll, hlr);
+      Kokkos::deep_copy(hlr, dll);
     }
 
     // Check Deep Copy of two empty 1D views
     {
-      Kokkos::View<double*> d;
-      Kokkos::View<double*,Kokkos::HostSpace> h;
-      Kokkos::deep_copy(d,h);
-      Kokkos::deep_copy(h,d);
+      Kokkos::View<double *> d;
+      Kokkos::View<double *, Kokkos::HostSpace> h;
+      Kokkos::deep_copy(d, h);
+      Kokkos::deep_copy(h, d);
     }
 
     // Check Deep Copy of two empty 2D views
     {
-      Kokkos::View<double*[3],Kokkos::LayoutRight> d;
-      Kokkos::View<double*[3],Kokkos::LayoutRight,Kokkos::HostSpace> h;
-      Kokkos::deep_copy(d,h);
-      Kokkos::deep_copy(h,d);
+      Kokkos::View<double * [3], Kokkos::LayoutRight> d;
+      Kokkos::View<double * [3], Kokkos::LayoutRight, Kokkos::HostSpace> h;
+      Kokkos::deep_copy(d, h);
+      Kokkos::deep_copy(h, d);
     }
   }
 
   typedef T DataType[2];
 
-  static void
-  check_auto_conversion_to_const(
-     const Kokkos::View< const DataType, device > & arg_const,
-     const Kokkos::View< DataType, device > & arg )
-  {
-    ASSERT_TRUE( arg_const == arg );
+  static void check_auto_conversion_to_const(
+      const Kokkos::View<const DataType, device> &arg_const,
+      const Kokkos::View<DataType, device> &arg) {
+    ASSERT_TRUE(arg_const == arg);
   }
 
-  static void run_test_const()
-  {
-    typedef Kokkos::View< DataType, device > typeX;
-    typedef Kokkos::View< const DataType, device > const_typeX;
-    typedef Kokkos::View< const DataType, device, Kokkos::MemoryRandomAccess > const_typeR;
+  static void run_test_const() {
+    typedef Kokkos::View<DataType, device> typeX;
+    typedef Kokkos::View<const DataType, device> const_typeX;
+    typedef Kokkos::View<const DataType, device, Kokkos::MemoryRandomAccess>
+        const_typeR;
 
-    typeX x( "X" );
+    typeX x("X");
     const_typeX xc = x;
     const_typeR xr = x;
 
-    ASSERT_TRUE( xc == x );
-    ASSERT_TRUE( x == xc );
+    ASSERT_TRUE(xc == x);
+    ASSERT_TRUE(x == xc);
 
     // For CUDA the constant random access View does not return
     // an lvalue reference due to retrieving through texture cache
     // therefore not allowed to query the underlying pointer.
-#if defined( KOKKOS_ENABLE_CUDA )
-    if ( !std::is_same< typename device::execution_space, Kokkos::Cuda >::value )
+#if defined(KOKKOS_ENABLE_CUDA)
+    if (!std::is_same<typename device::execution_space, Kokkos::Cuda>::value)
 #endif
     {
-      ASSERT_TRUE( x.data() == xr.data() );
+      ASSERT_TRUE(x.data() == xr.data());
     }
 
     // typeX xf = xc; // Setting non-const from const must not compile.
 
-    check_auto_conversion_to_const( x, x );
+    check_auto_conversion_to_const(x, x);
   }
 
-  static void run_test_subview()
-  {
-    typedef Kokkos::View< const T, device > sView;
+  static void run_test_subview() {
+    typedef Kokkos::View<const T, device> sView;
 
-    dView0 d0( "d0" );
-    dView1 d1( "d1", N0 );
-    dView2 d2( "d2", N0 );
-    dView3 d3( "d3", N0 );
-    dView4 d4( "d4", N0 );
+    dView0 d0("d0");
+    dView1 d1("d1", N0);
+    dView2 d2("d2", N0);
+    dView3 d3("d3", N0);
+    dView4 d4("d4", N0);
 
     sView s0 = d0;
-    sView s1 = Kokkos::subview( d1, 1 );
-    sView s2 = Kokkos::subview( d2, 1, 1 );
-    sView s3 = Kokkos::subview( d3, 1, 1, 1 );
-    sView s4 = Kokkos::subview( d4, 1, 1, 1, 1 );
+    sView s1 = Kokkos::subview(d1, 1);
+    sView s2 = Kokkos::subview(d2, 1, 1);
+    sView s3 = Kokkos::subview(d3, 1, 1, 1);
+    sView s4 = Kokkos::subview(d4, 1, 1, 1, 1);
   }
 
-  static void run_test_subview_strided()
-  {
-    typedef Kokkos::View< int ****, Kokkos::LayoutLeft , host >  view_left_4;
-    typedef Kokkos::View< int ****, Kokkos::LayoutRight, host >  view_right_4;
-    typedef Kokkos::View< int **  , Kokkos::LayoutLeft , host >  view_left_2;
-    typedef Kokkos::View< int **  , Kokkos::LayoutRight, host >  view_right_2;
-
-    typedef Kokkos::View< int * ,  Kokkos::LayoutStride, host >  view_stride_1;
-    typedef Kokkos::View< int **,  Kokkos::LayoutStride, host >  view_stride_2;
-
-    view_left_2  xl2( "xl2", 100, 200 );
-    view_right_2 xr2( "xr2", 100, 200 );
-    view_stride_1 yl1 = Kokkos::subview( xl2, 0, Kokkos::ALL() );
-    view_stride_1 yl2 = Kokkos::subview( xl2, 1, Kokkos::ALL() );
-    view_stride_1 yr1 = Kokkos::subview( xr2, 0, Kokkos::ALL() );
-    view_stride_1 yr2 = Kokkos::subview( xr2, 1, Kokkos::ALL() );
-
-    ASSERT_EQ( yl1.extent(0), xl2.extent(1) );
-    ASSERT_EQ( yl2.extent(0), xl2.extent(1) );
-    ASSERT_EQ( yr1.extent(0), xr2.extent(1) );
-    ASSERT_EQ( yr2.extent(0), xr2.extent(1) );
-
-    ASSERT_EQ( & yl1( 0 ) - & xl2( 0, 0 ), 0 );
-    ASSERT_EQ( & yl2( 0 ) - & xl2( 1, 0 ), 0 );
-    ASSERT_EQ( & yr1( 0 ) - & xr2( 0, 0 ), 0 );
-    ASSERT_EQ( & yr2( 0 ) - & xr2( 1, 0 ), 0 );
-
-    view_left_4 xl4( "xl4", 10, 20, 30, 40 );
-    view_right_4 xr4( "xr4", 10, 20, 30, 40 );
-
-    view_stride_2 yl4 = Kokkos::subview( xl4, 1, Kokkos::ALL(), 2, Kokkos::ALL() );
-    view_stride_2 yr4 = Kokkos::subview( xr4, 1, Kokkos::ALL(), 2, Kokkos::ALL() );
-
-    ASSERT_EQ( yl4.extent(0), xl4.extent(1) );
-    ASSERT_EQ( yl4.extent(1), xl4.extent(3) );
-    ASSERT_EQ( yr4.extent(0), xr4.extent(1) );
-    ASSERT_EQ( yr4.extent(1), xr4.extent(3) );
-
-    ASSERT_EQ( & yl4( 4, 4 ) - & xl4( 1, 4, 2, 4 ), 0 );
-    ASSERT_EQ( & yr4( 4, 4 ) - & xr4( 1, 4, 2, 4 ), 0 );
+  static void run_test_subview_strided() {
+    typedef Kokkos::View<int ****, Kokkos::LayoutLeft, host> view_left_4;
+    typedef Kokkos::View<int ****, Kokkos::LayoutRight, host> view_right_4;
+    typedef Kokkos::View<int **, Kokkos::LayoutLeft, host> view_left_2;
+    typedef Kokkos::View<int **, Kokkos::LayoutRight, host> view_right_2;
+
+    typedef Kokkos::View<int *, Kokkos::LayoutStride, host> view_stride_1;
+    typedef Kokkos::View<int **, Kokkos::LayoutStride, host> view_stride_2;
+
+    view_left_2 xl2("xl2", 100, 200);
+    view_right_2 xr2("xr2", 100, 200);
+    view_stride_1 yl1 = Kokkos::subview(xl2, 0, Kokkos::ALL());
+    view_stride_1 yl2 = Kokkos::subview(xl2, 1, Kokkos::ALL());
+    view_stride_1 yr1 = Kokkos::subview(xr2, 0, Kokkos::ALL());
+    view_stride_1 yr2 = Kokkos::subview(xr2, 1, Kokkos::ALL());
+
+    ASSERT_EQ(yl1.extent(0), xl2.extent(1));
+    ASSERT_EQ(yl2.extent(0), xl2.extent(1));
+    ASSERT_EQ(yr1.extent(0), xr2.extent(1));
+    ASSERT_EQ(yr2.extent(0), xr2.extent(1));
+
+    ASSERT_EQ(&yl1(0) - &xl2(0, 0), 0);
+    ASSERT_EQ(&yl2(0) - &xl2(1, 0), 0);
+    ASSERT_EQ(&yr1(0) - &xr2(0, 0), 0);
+    ASSERT_EQ(&yr2(0) - &xr2(1, 0), 0);
+
+    view_left_4 xl4("xl4", 10, 20, 30, 40);
+    view_right_4 xr4("xr4", 10, 20, 30, 40);
+
+    view_stride_2 yl4 =
+        Kokkos::subview(xl4, 1, Kokkos::ALL(), 2, Kokkos::ALL());
+    view_stride_2 yr4 =
+        Kokkos::subview(xr4, 1, Kokkos::ALL(), 2, Kokkos::ALL());
+
+    ASSERT_EQ(yl4.extent(0), xl4.extent(1));
+    ASSERT_EQ(yl4.extent(1), xl4.extent(3));
+    ASSERT_EQ(yr4.extent(0), xr4.extent(1));
+    ASSERT_EQ(yr4.extent(1), xr4.extent(3));
+
+    ASSERT_EQ(&yl4(4, 4) - &xl4(1, 4, 2, 4), 0);
+    ASSERT_EQ(&yr4(4, 4) - &xr4(1, 4, 2, 4), 0);
   }
 
-  static void run_test_vector()
-  {
+  static void run_test_vector() {
     static const unsigned Length = 1000, Count = 8;
 
-    typedef Kokkos::View< T*,  Kokkos::LayoutLeft, host > vector_type;
-    typedef Kokkos::View< T**, Kokkos::LayoutLeft, host > multivector_type;
+    typedef Kokkos::View<T *, Kokkos::LayoutLeft, host> vector_type;
+    typedef Kokkos::View<T **, Kokkos::LayoutLeft, host> multivector_type;
+
+    typedef Kokkos::View<T *, Kokkos::LayoutRight, host> vector_right_type;
+    typedef Kokkos::View<T **, Kokkos::LayoutRight, host>
+        multivector_right_type;
 
-    typedef Kokkos::View< T*,  Kokkos::LayoutRight, host > vector_right_type;
-    typedef Kokkos::View< T**, Kokkos::LayoutRight, host > multivector_right_type;
+    typedef Kokkos::View<const T *, Kokkos::LayoutRight, host>
+        const_vector_right_type;
+    typedef Kokkos::View<const T *, Kokkos::LayoutLeft, host> const_vector_type;
+    typedef Kokkos::View<const T **, Kokkos::LayoutLeft, host>
+        const_multivector_type;
 
-    typedef Kokkos::View< const T*,  Kokkos::LayoutRight, host > const_vector_right_type;
-    typedef Kokkos::View< const T*,  Kokkos::LayoutLeft,  host > const_vector_type;
-    typedef Kokkos::View< const T**, Kokkos::LayoutLeft,  host > const_multivector_type;
+    multivector_type mv = multivector_type("mv", Length, Count);
+    multivector_right_type mv_right =
+        multivector_right_type("mv", Length, Count);
 
-    multivector_type mv = multivector_type( "mv", Length, Count );
-    multivector_right_type mv_right = multivector_right_type( "mv", Length, Count );
+    vector_type v1 = Kokkos::subview(mv, Kokkos::ALL(), 0);
+    vector_type v2 = Kokkos::subview(mv, Kokkos::ALL(), 1);
+    vector_type v3 = Kokkos::subview(mv, Kokkos::ALL(), 2);
 
-    vector_type v1 = Kokkos::subview( mv, Kokkos::ALL(), 0 );
-    vector_type v2 = Kokkos::subview( mv, Kokkos::ALL(), 1 );
-    vector_type v3 = Kokkos::subview( mv, Kokkos::ALL(), 2 );
+    vector_type rv1 = Kokkos::subview(mv_right, 0, Kokkos::ALL());
+    vector_type rv2 = Kokkos::subview(mv_right, 1, Kokkos::ALL());
+    vector_type rv3 = Kokkos::subview(mv_right, 2, Kokkos::ALL());
 
-    vector_type rv1 = Kokkos::subview( mv_right, 0, Kokkos::ALL() );
-    vector_type rv2 = Kokkos::subview( mv_right, 1, Kokkos::ALL() );
-    vector_type rv3 = Kokkos::subview( mv_right, 2, Kokkos::ALL() );
+    multivector_type mv1 =
+        Kokkos::subview(mv, std::make_pair(1, 998), std::make_pair(2, 5));
 
-    multivector_type mv1 = Kokkos::subview( mv, std::make_pair( 1, 998 ),
-                                                std::make_pair( 2, 5 ) );
+    multivector_right_type mvr1 =
+        Kokkos::subview(mv_right, std::make_pair(1, 998), std::make_pair(2, 5));
 
-    multivector_right_type mvr1 = Kokkos::subview( mv_right, std::make_pair( 1, 998 ),
-                                                             std::make_pair( 2, 5 ) );
+    const_vector_type cv1 = Kokkos::subview(mv, Kokkos::ALL(), 0);
+    const_vector_type cv2 = Kokkos::subview(mv, Kokkos::ALL(), 1);
+    const_vector_type cv3 = Kokkos::subview(mv, Kokkos::ALL(), 2);
 
-    const_vector_type cv1 = Kokkos::subview( mv, Kokkos::ALL(), 0 );
-    const_vector_type cv2 = Kokkos::subview( mv, Kokkos::ALL(), 1 );
-    const_vector_type cv3 = Kokkos::subview( mv, Kokkos::ALL(), 2 );
+    vector_right_type vr1 = Kokkos::subview(mv, Kokkos::ALL(), 0);
+    vector_right_type vr2 = Kokkos::subview(mv, Kokkos::ALL(), 1);
+    vector_right_type vr3 = Kokkos::subview(mv, Kokkos::ALL(), 2);
 
-    vector_right_type vr1 = Kokkos::subview( mv, Kokkos::ALL(), 0 );
-    vector_right_type vr2 = Kokkos::subview( mv, Kokkos::ALL(), 1 );
-    vector_right_type vr3 = Kokkos::subview( mv, Kokkos::ALL(), 2 );
+    const_vector_right_type cvr1 = Kokkos::subview(mv, Kokkos::ALL(), 0);
+    const_vector_right_type cvr2 = Kokkos::subview(mv, Kokkos::ALL(), 1);
+    const_vector_right_type cvr3 = Kokkos::subview(mv, Kokkos::ALL(), 2);
 
-    const_vector_right_type cvr1 = Kokkos::subview( mv, Kokkos::ALL(), 0 );
-    const_vector_right_type cvr2 = Kokkos::subview( mv, Kokkos::ALL(), 1 );
-    const_vector_right_type cvr3 = Kokkos::subview( mv, Kokkos::ALL(), 2 );
+    ASSERT_TRUE(&v1[0] == &v1(0));
+    ASSERT_TRUE(&v1[0] == &mv(0, 0));
+    ASSERT_TRUE(&v2[0] == &mv(0, 1));
+    ASSERT_TRUE(&v3[0] == &mv(0, 2));
 
-    ASSERT_TRUE( & v1[0] == & v1( 0 ) );
-    ASSERT_TRUE( & v1[0] == & mv( 0, 0 ) );
-    ASSERT_TRUE( & v2[0] == & mv( 0, 1 ) );
-    ASSERT_TRUE( & v3[0] == & mv( 0, 2 ) );
+    ASSERT_TRUE(&cv1[0] == &mv(0, 0));
+    ASSERT_TRUE(&cv2[0] == &mv(0, 1));
+    ASSERT_TRUE(&cv3[0] == &mv(0, 2));
 
-    ASSERT_TRUE( & cv1[0] == & mv( 0, 0 ) );
-    ASSERT_TRUE( & cv2[0] == & mv( 0, 1 ) );
-    ASSERT_TRUE( & cv3[0] == & mv( 0, 2 ) );
+    ASSERT_TRUE(&vr1[0] == &mv(0, 0));
+    ASSERT_TRUE(&vr2[0] == &mv(0, 1));
+    ASSERT_TRUE(&vr3[0] == &mv(0, 2));
 
-    ASSERT_TRUE( & vr1[0] == & mv( 0, 0 ) );
-    ASSERT_TRUE( & vr2[0] == & mv( 0, 1 ) );
-    ASSERT_TRUE( & vr3[0] == & mv( 0, 2 ) );
+    ASSERT_TRUE(&cvr1[0] == &mv(0, 0));
+    ASSERT_TRUE(&cvr2[0] == &mv(0, 1));
+    ASSERT_TRUE(&cvr3[0] == &mv(0, 2));
 
-    ASSERT_TRUE( & cvr1[0] == & mv( 0, 0 ) );
-    ASSERT_TRUE( & cvr2[0] == & mv( 0, 1 ) );
-    ASSERT_TRUE( & cvr3[0] == & mv( 0, 2 ) );
+    ASSERT_TRUE(&mv1(0, 0) == &mv(1, 2));
+    ASSERT_TRUE(&mv1(1, 1) == &mv(2, 3));
+    ASSERT_TRUE(&mv1(3, 2) == &mv(4, 4));
+    ASSERT_TRUE(&mvr1(0, 0) == &mv_right(1, 2));
+    ASSERT_TRUE(&mvr1(1, 1) == &mv_right(2, 3));
+    ASSERT_TRUE(&mvr1(3, 2) == &mv_right(4, 4));
 
-    ASSERT_TRUE( & mv1( 0, 0 ) == & mv( 1, 2 ) );
-    ASSERT_TRUE( & mv1( 1, 1 ) == & mv( 2, 3 ) );
-    ASSERT_TRUE( & mv1( 3, 2 ) == & mv( 4, 4 ) );
-    ASSERT_TRUE( & mvr1( 0, 0 ) == & mv_right( 1, 2 ) );
-    ASSERT_TRUE( & mvr1( 1, 1 ) == & mv_right( 2, 3 ) );
-    ASSERT_TRUE( & mvr1( 3, 2 ) == & mv_right( 4, 4 ) );
+    const_vector_type c_cv1(v1);
+    typename vector_type::const_type c_cv2(v2);
+    typename const_vector_type::const_type c_ccv2(v2);
 
-    const_vector_type c_cv1( v1 );
-    typename vector_type::const_type c_cv2( v2 );
-    typename const_vector_type::const_type c_ccv2( v2 );
+    const_multivector_type cmv(mv);
+    typename multivector_type::const_type cmvX(cmv);
+    typename const_multivector_type::const_type ccmvX(cmv);
+  }
 
-    const_multivector_type cmv( mv );
-    typename multivector_type::const_type cmvX( cmv );
-    typename const_multivector_type::const_type ccmvX( cmv );
+  static void run_test_error() {
+    auto alloc_size = std::numeric_limits<size_t>::max() - 42;
+    try {
+      auto should_always_fail = dView1("hello_world_failure", alloc_size);
+    } catch (std::runtime_error const &error) {
+      // TODO once we remove the conversion to std::runtime_error, catch the
+      //      appropriate Kokkos error here
+      std::string msg = error.what();
+      ASSERT_PRED_FORMAT2(::testing::IsSubstring, "hello_world_failure", msg);
+      ASSERT_PRED_FORMAT2(::testing::IsSubstring,
+                          typename device::memory_space{}.name(), msg);
+      // Can't figure out how to make assertions either/or, so we'll just use
+      // an if statement here for now.  Test failure message will be a bit
+      // misleading, but developers should figure out what's going on pretty
+      // quickly.
+      if (msg.find("is not a valid size") != std::string::npos) {
+        ASSERT_PRED_FORMAT2(::testing::IsSubstring, "is not a valid size", msg);
+      } else {
+        // Otherwise, there has to be some sort of "insufficient memory" error
+        ASSERT_PRED_FORMAT2(::testing::IsSubstring, "insufficient memory", msg);
+      }
+    }
   }
 };
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewAPI_a.hpp b/lib/kokkos/core/unit_test/TestViewAPI_a.hpp
index ba74331c51a65cdd5a51017089353e6fa3d9ce2f..048ba51c17001a0a65027922c7132eb239d5b8ea 100644
--- a/lib/kokkos/core/unit_test/TestViewAPI_a.hpp
+++ b/lib/kokkos/core/unit_test/TestViewAPI_a.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,13 +42,12 @@
 //@HEADER
 */
 
-#include<TestViewAPI.hpp>
+#include <TestViewAPI.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_api_a )
-{
-  TestViewAPI< double, TEST_EXECSPACE >::run_test();
+TEST(TEST_CATEGORY, view_api_a) {
+  TestViewAPI<double, TEST_EXECSPACE>::run_test();
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewAPI_b.hpp b/lib/kokkos/core/unit_test/TestViewAPI_b.hpp
index 03b41db516512b9cb7359fcc66155ec6e79a1e8a..ad9069e397138957dd00d6326bee392876f22aec 100644
--- a/lib/kokkos/core/unit_test/TestViewAPI_b.hpp
+++ b/lib/kokkos/core/unit_test/TestViewAPI_b.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,15 +42,14 @@
 //@HEADER
 */
 
-#include<TestViewAPI.hpp>
+#include <TestViewAPI.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_api_b )
-{
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_view_operator_a();
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_mirror();
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_scalar();
+TEST(TEST_CATEGORY, view_api_b) {
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_view_operator_a();
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_mirror();
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_scalar();
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewAPI_c.hpp b/lib/kokkos/core/unit_test/TestViewAPI_c.hpp
index d34ae6340e65750ccd6cd32cef9e3ea06f225cd6..a70792dc623b63bb8aa1a84fec93ca413ffa94a1 100644
--- a/lib/kokkos/core/unit_test/TestViewAPI_c.hpp
+++ b/lib/kokkos/core/unit_test/TestViewAPI_c.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,14 +42,13 @@
 //@HEADER
 */
 
-#include<TestViewAPI.hpp>
+#include <TestViewAPI.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_api_c )
-{
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_deep_copy_empty();
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_view_operator_b();
+TEST(TEST_CATEGORY, view_api_c) {
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_deep_copy_empty();
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_view_operator_b();
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewAPI_d.hpp b/lib/kokkos/core/unit_test/TestViewAPI_d.hpp
index 38e10381f296c5f134c3f61c915594dd2f7c5b6f..ecb65804b7900d773e0018f4763a0a3d60aa566b 100644
--- a/lib/kokkos/core/unit_test/TestViewAPI_d.hpp
+++ b/lib/kokkos/core/unit_test/TestViewAPI_d.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,17 +42,20 @@
 //@HEADER
 */
 
-#include<TestViewAPI.hpp>
+#include <TestViewAPI.hpp>
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_api_d )
-{
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_const();
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_subview();
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_subview_strided();
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_vector();
-  TestViewAPI< double, TEST_EXECSPACE >::run_test_view_operator_c();
+TEST(TEST_CATEGORY, view_api_d) {
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_const();
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_subview();
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_subview_strided();
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_vector();
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_view_operator_c();
 }
 
+TEST(TEST_CATEGORY, view_allocation_error) {
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_error();
 }
+
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewAPI_e.hpp b/lib/kokkos/core/unit_test/TestViewAPI_e.hpp
index 76815dc11243a8d4793b11ebc3b5325c41c8f0e7..e433535236d819be39cc21a6980caba54a8d1158 100644
--- a/lib/kokkos/core/unit_test/TestViewAPI_e.hpp
+++ b/lib/kokkos/core/unit_test/TestViewAPI_e.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,70 +51,68 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_remap )
-{
+TEST(TEST_CATEGORY, view_remap) {
   enum { N0 = 3, N1 = 2, N2 = 8, N3 = 9 };
 
-  #ifdef KOKKOS_ENABLE_CUDA
-    #define EXECSPACE std::conditional<std::is_same<TEST_EXECSPACE,Kokkos::Cuda>::value,Kokkos::CudaHostPinnedSpace,TEST_EXECSPACE>::type
-  #else
-    #ifdef KOKKOS_ENABLE_ROCM
-      #define EXECSPACE std::conditional<std::is_same<TEST_EXECSPACE,Kokkos::Experimental::ROCm>::value,Kokkos::Experimental::ROCmHostPinnedSpace,TEST_EXECSPACE>::type
-    #else
-      #if defined(KOKKOS_ENABLE_OPENMPTARGET)
-        #define EXECSPACE Kokkos::HostSpace
-      #else
-        #define EXECSPACE TEST_EXECSPACE
-      #endif
-    #endif
-  #endif
-
-  typedef Kokkos::View< double*[N1][N2][N3],
-                        Kokkos::LayoutRight,
-                        EXECSPACE > output_type;
-
-  typedef Kokkos::View< int**[N2][N3],
-                        Kokkos::LayoutLeft,
-                        EXECSPACE > input_type;
-
-  typedef Kokkos::View< int*[N0][N2][N3],
-                        Kokkos::LayoutLeft,
-                        EXECSPACE > diff_type;
-
-  output_type output( "output", N0 );
-  input_type  input ( "input", N0, N1 );
-  diff_type   diff  ( "diff", N0 );
+#ifdef KOKKOS_ENABLE_CUDA
+#define EXECSPACE                                                     \
+  std::conditional<std::is_same<TEST_EXECSPACE, Kokkos::Cuda>::value, \
+                   Kokkos::CudaHostPinnedSpace, TEST_EXECSPACE>::type
+#else
+#ifdef KOKKOS_ENABLE_ROCM
+#define EXECSPACE                                                      \
+  std::conditional<                                                    \
+      std::is_same<TEST_EXECSPACE, Kokkos::Experimental::ROCm>::value, \
+      Kokkos::Experimental::ROCmHostPinnedSpace, TEST_EXECSPACE>::type
+#else
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+#define EXECSPACE Kokkos::HostSpace
+#else
+#define EXECSPACE TEST_EXECSPACE
+#endif
+#endif
+#endif
+
+  typedef Kokkos::View<double * [N1][N2][N3], Kokkos::LayoutRight, EXECSPACE>
+      output_type;
+
+  typedef Kokkos::View<int* * [N2][N3], Kokkos::LayoutLeft, EXECSPACE>
+      input_type;
+
+  typedef Kokkos::View<int * [N0][N2][N3], Kokkos::LayoutLeft, EXECSPACE>
+      diff_type;
+
+  output_type output("output", N0);
+  input_type input("input", N0, N1);
+  diff_type diff("diff", N0);
 
   Kokkos::fence();
   int value = 0;
 
-  for ( size_t i3 = 0; i3 < N3; ++i3 )
-  for ( size_t i2 = 0; i2 < N2; ++i2 )
-  for ( size_t i1 = 0; i1 < N1; ++i1 )
-  for ( size_t i0 = 0; i0 < N0; ++i0 )
-  {
-    input( i0, i1, i2, i3 ) = ++value;
-  }
+  for (size_t i3 = 0; i3 < N3; ++i3)
+    for (size_t i2 = 0; i2 < N2; ++i2)
+      for (size_t i1 = 0; i1 < N1; ++i1)
+        for (size_t i0 = 0; i0 < N0; ++i0) {
+          input(i0, i1, i2, i3) = ++value;
+        }
 
   Kokkos::fence();
   // Kokkos::deep_copy( diff, input ); // Throw with incompatible shape.
-  Kokkos::deep_copy( output, input );
+  Kokkos::deep_copy(output, input);
   Kokkos::fence();
 
   value = 0;
 
-  for ( size_t i3 = 0; i3 < N3; ++i3 )
-  for ( size_t i2 = 0; i2 < N2; ++i2 )
-  for ( size_t i1 = 0; i1 < N1; ++i1 )
-  for ( size_t i0 = 0; i0 < N0; ++i0 )
-  {
-    ++value;
-    ASSERT_EQ( value, ( (int) output( i0, i1, i2, i3 ) ) );
-  }
+  for (size_t i3 = 0; i3 < N3; ++i3)
+    for (size_t i2 = 0; i2 < N2; ++i2)
+      for (size_t i1 = 0; i1 < N1; ++i1)
+        for (size_t i0 = 0; i0 < N0; ++i0) {
+          ++value;
+          ASSERT_EQ(value, ((int)output(i0, i1, i2, i3)));
+        }
 }
 
-TEST_F( TEST_CATEGORY, view_mirror_nonconst )
-{
+TEST(TEST_CATEGORY, view_mirror_nonconst) {
   Kokkos::View<int*, TEST_EXECSPACE> d_view("d_view", 10);
   Kokkos::View<const int*, TEST_EXECSPACE> d_view_const = d_view;
   auto h_view = Kokkos::create_mirror(d_view_const);
@@ -122,9 +121,10 @@ TEST_F( TEST_CATEGORY, view_mirror_nonconst )
   Kokkos::deep_copy(h_view2, d_view_const);
 }
 
-template <typename DataType, typename ... Extents>
-void test_left_stride(Extents ... extents) {
-  using view_type = Kokkos::View<DataType, Kokkos::LayoutLeft, Kokkos::HostSpace>;
+template <typename DataType, typename... Extents>
+void test_left_stride(Extents... extents) {
+  using view_type =
+      Kokkos::View<DataType, Kokkos::LayoutLeft, Kokkos::HostSpace>;
   view_type view("view", extents...);
   size_t expected_stride = 1;
   size_t all_strides[view_type::rank + 1];
@@ -136,9 +136,10 @@ void test_left_stride(Extents ... extents) {
   }
 }
 
-template <typename DataType, typename ... Extents>
-void test_right_stride(Extents ... extents) {
-  using view_type = Kokkos::View<DataType, Kokkos::LayoutRight, Kokkos::HostSpace>;
+template <typename DataType, typename... Extents>
+void test_right_stride(Extents... extents) {
+  using view_type =
+      Kokkos::View<DataType, Kokkos::LayoutRight, Kokkos::HostSpace>;
   view_type view("view", extents...);
   size_t expected_stride = 1;
   size_t all_strides[view_type::rank + 1];
@@ -151,14 +152,13 @@ void test_right_stride(Extents ... extents) {
   }
 }
 
-template <typename DataType, typename ... Extents>
-void test_stride(Extents ... extents) {
+template <typename DataType, typename... Extents>
+void test_stride(Extents... extents) {
   test_right_stride<DataType>(extents...);
   test_left_stride<DataType>(extents...);
 }
 
-TEST_F( TEST_CATEGORY, view_stride_method )
-{
+TEST(TEST_CATEGORY, view_stride_method) {
   test_stride<double[3]>();
   test_stride<double*>(3);
   test_stride<double[3][7][13]>();
@@ -178,69 +178,65 @@ inline void test_anonymous_space() {
   Kokkos::View<int*, Kokkos::AnonymousSpace> host_anon_assign_view = host_view;
   for (int i = 0; i < 10; ++i) {
     host_anon_stat_view(i) = host_anon_dyn_view(i) = 142;
-    host_anon_assign_view(i) = 142;
+    host_anon_assign_view(i)                       = 142;
   }
   Kokkos::View<int**, Kokkos::LayoutRight, ExecSpace> d_view("d_view", 100, 10);
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-  Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, int>(0, 100), KOKKOS_LAMBDA(int i) {
-    int* ptr = &(d_view(i, 0));
-    Kokkos::View<int[10], Kokkos::AnonymousSpace> d_anon_stat_view(ptr);
-    Kokkos::View<int*, Kokkos::AnonymousSpace> d_anon_dyn_view(ptr, 10);
-    auto sub = Kokkos::subview(d_view, i, Kokkos::ALL());
-    Kokkos::View<int*, Kokkos::AnonymousSpace> d_anon_assign_view = sub;
-    for (int j = 0; j < 10; ++j) {
-      d_anon_stat_view(j) = 50;
-      d_anon_assign_view(j) += 50;
-      d_anon_dyn_view(j) += 42;
-    }
-  });
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecSpace, int>(0, 100), KOKKOS_LAMBDA(int i) {
+        int* ptr = &(d_view(i, 0));
+        Kokkos::View<int[10], Kokkos::AnonymousSpace> d_anon_stat_view(ptr);
+        Kokkos::View<int*, Kokkos::AnonymousSpace> d_anon_dyn_view(ptr, 10);
+        auto sub = Kokkos::subview(d_view, i, Kokkos::ALL());
+        Kokkos::View<int*, Kokkos::AnonymousSpace> d_anon_assign_view = sub;
+        for (int j = 0; j < 10; ++j) {
+          d_anon_stat_view(j) = 50;
+          d_anon_assign_view(j) += 50;
+          d_anon_dyn_view(j) += 42;
+        }
+      });
   Kokkos::fence();
 #endif
 }
 
-TEST_F( TEST_CATEGORY, anonymous_space )
-{
-  test_anonymous_space();
-}
+TEST(TEST_CATEGORY, anonymous_space) { test_anonymous_space(); }
 
-template<class ExecSpace>
+template <class ExecSpace>
 struct TestViewOverloadResolution {
   // Overload based on value_type and rank
-  static int foo(Kokkos::View<const double**,ExecSpace> a) {
-    return 1;
-  }
-  static int foo(Kokkos::View<const int**,ExecSpace> a) {
-    return 2;
-  }
-  static int foo(Kokkos::View<const double***,ExecSpace> a) {
-    return 3;
-  }
+  static int foo(Kokkos::View<const double**, ExecSpace> a) { return 1; }
+  static int foo(Kokkos::View<const int**, ExecSpace> a) { return 2; }
+  static int foo(Kokkos::View<const double***, ExecSpace> a) { return 3; }
 
   // Overload based on compile time dimensions
-  static int bar(Kokkos::View<double*[3],ExecSpace> a) {
-    return 4;
-  }
-  static int bar(Kokkos::View<double*[4],ExecSpace> a) {
-    return 5;
-  }
+  static int bar(Kokkos::View<double * [3], ExecSpace> a) { return 4; }
+  static int bar(Kokkos::View<double * [4], ExecSpace> a) { return 5; }
 
   static void test_function_overload() {
-    Kokkos::View<double**, typename ExecSpace::execution_space::array_layout, ExecSpace> a("A",10,3);
+    Kokkos::View<double**, typename ExecSpace::execution_space::array_layout,
+                 ExecSpace>
+        a("A", 10, 3);
     int data_type_1 = foo(a);
-    int data_type_3 = foo(Kokkos::View<const double**, typename ExecSpace::execution_space::array_layout, ExecSpace>(a));
-    Kokkos::View<double***, typename ExecSpace::execution_space::array_layout, ExecSpace> b("B",10,3,4);
+    int data_type_3 =
+        foo(Kokkos::View<const double**,
+                         typename ExecSpace::execution_space::array_layout,
+                         ExecSpace>(a));
+    Kokkos::View<double***, typename ExecSpace::execution_space::array_layout,
+                 ExecSpace>
+        b("B", 10, 3, 4);
     int data_type_2 = foo(b);
-    Kokkos::View<double*[3], typename ExecSpace::execution_space::array_layout, ExecSpace> c(a);
+    Kokkos::View<double * [3],
+                 typename ExecSpace::execution_space::array_layout, ExecSpace>
+        c(a);
     int static_extent = bar(c);
-    ASSERT_EQ(1,data_type_1);
-    ASSERT_EQ(3,data_type_2);
-    ASSERT_EQ(1,data_type_3);
-    ASSERT_EQ(4,static_extent);
+    ASSERT_EQ(1, data_type_1);
+    ASSERT_EQ(3, data_type_2);
+    ASSERT_EQ(1, data_type_3);
+    ASSERT_EQ(4, static_extent);
   }
 };
 
-TEST_F( TEST_CATEGORY, view_overload_resolution )
-{
+TEST(TEST_CATEGORY, view_overload_resolution) {
   TestViewOverloadResolution<TEST_EXECSPACE>::test_function_overload();
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewCopy.hpp b/lib/kokkos/core/unit_test/TestViewCopy.hpp
index ddcd0ae5ba1ce64d60458711871912f4661f2655..27018e7f7ba70706fc60325ccfda0142322eb9d8 100644
--- a/lib/kokkos/core/unit_test/TestViewCopy.hpp
+++ b/lib/kokkos/core/unit_test/TestViewCopy.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,111 +52,122 @@ namespace Test {
 
 namespace {
 
-template < typename ExecSpace >
+template <typename ExecSpace>
 struct TestViewCopy {
-
   using InExecSpace = ExecSpace;
 
-  static void test_view_copy(const int dim0, const int dim1, const int dim2)
-  {
-#if defined( KOKKOS_ENABLE_CUDA ) || defined( KOKKOS_ENABLE_ROCM )
-   // ExecSpace = CudaUVM, CudaHostPinned
-   // This test will fail at runtime with an illegal memory access if something goes wrong
-   // Test 1: deep_copy from host_mirror_space to ExecSpace and ExecSpace back to host_mirror_space
-   {
-    typedef Kokkos::View<double****,InExecSpace> Rank4ViewType;
-    Rank4ViewType view_4;
-    view_4 = Rank4ViewType("view_4", dim0, dim1, dim2, dim2);
-
-    typedef typename Kokkos::Impl::is_space<InExecSpace>::host_mirror_space::execution_space host_space_type;
-    Kokkos::View<double**,Kokkos::LayoutLeft,host_space_type> srcView("srcView", dim2, dim2);
-
-    // Strided dst view
-    auto dstView = Kokkos::subview(view_4, 0, 0, Kokkos::ALL(), Kokkos::ALL());
-
-    // host_mirror_space to ExecSpace
-    Kokkos::deep_copy( dstView, srcView );
-    Kokkos::fence();
-
-    // ExecSpace to host_mirror_space 
-    Kokkos::deep_copy( srcView, dstView );
-    Kokkos::fence();
-   }
-
-   // Test 2: deep_copy from Cuda to ExecSpace and ExecSpace back to Cuda
-   {
-    typedef Kokkos::View<double****,InExecSpace> Rank4ViewType;
-    Rank4ViewType view_4;
-    view_4 = Rank4ViewType("view_4", dim0, dim1, dim2, dim2);
-
-#if defined( KOKKOS_ENABLE_CUDA )
-    typedef typename std::conditional<
-        Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,typename InExecSpace::memory_space>::accessible,
-        Kokkos::CudaSpace,
-        InExecSpace>::type space_type;
+  static void test_view_copy(const int dim0, const int dim1, const int dim2) {
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_ROCM)
+    // ExecSpace = CudaUVM, CudaHostPinned
+    // This test will fail at runtime with an illegal memory access if something
+    // goes wrong Test 1: deep_copy from host_mirror_space to ExecSpace and
+    // ExecSpace back to host_mirror_space
+    {
+      typedef Kokkos::View<double****, InExecSpace> Rank4ViewType;
+      Rank4ViewType view_4;
+      view_4 = Rank4ViewType("view_4", dim0, dim1, dim2, dim2);
+
+      typedef typename Kokkos::Impl::is_space<
+          InExecSpace>::host_mirror_space::execution_space host_space_type;
+      Kokkos::View<double**, Kokkos::LayoutLeft, host_space_type> srcView(
+          "srcView", dim2, dim2);
+
+      // Strided dst view
+      auto dstView =
+          Kokkos::subview(view_4, 0, 0, Kokkos::ALL(), Kokkos::ALL());
+
+      // host_mirror_space to ExecSpace
+      Kokkos::deep_copy(dstView, srcView);
+      Kokkos::fence();
+
+      // ExecSpace to host_mirror_space
+      Kokkos::deep_copy(srcView, dstView);
+      Kokkos::fence();
+    }
+
+    // Test 2: deep_copy from Cuda to ExecSpace and ExecSpace back to Cuda
+    {
+      typedef Kokkos::View<double****, InExecSpace> Rank4ViewType;
+      Rank4ViewType view_4;
+      view_4 = Rank4ViewType("view_4", dim0, dim1, dim2, dim2);
+
+#if defined(KOKKOS_ENABLE_CUDA)
+      typedef typename std::conditional<
+          Kokkos::Impl::MemorySpaceAccess<
+              Kokkos::CudaSpace,
+              typename InExecSpace::memory_space>::accessible,
+          Kokkos::CudaSpace, InExecSpace>::type space_type;
 #endif
-#if defined( KOKKOS_ENABLE_ROCM )
-    typedef typename std::conditional<
-        Kokkos::Impl::MemorySpaceAccess<Kokkos::ROCmSpace,typename InExecSpace::memory_space>::accessible,
-        Kokkos::ROCmSpace,
-        InExecSpace>::type space_type;
+#if defined(KOKKOS_ENABLE_ROCM)
+      typedef typename std::conditional<
+          Kokkos::Impl::MemorySpaceAccess<
+              Kokkos::ROCmSpace,
+              typename InExecSpace::memory_space>::accessible,
+          Kokkos::ROCmSpace, InExecSpace>::type space_type;
 #endif
-    Kokkos::View<double**,Kokkos::LayoutLeft,space_type> srcView("srcView", dim2, dim2);
-
-    // Strided dst view
-    auto dstView = Kokkos::subview(view_4, 0, 0, Kokkos::ALL(), Kokkos::ALL());
-
-    // Cuda to ExecSpace
-    Kokkos::deep_copy( dstView, srcView );
-    Kokkos::fence();
-
-    // ExecSpace to Cuda
-    Kokkos::deep_copy( srcView, dstView );
-    Kokkos::fence();
-   }
-
-   // Test 3: deep_copy from host_space to ExecSpace and ExecSpace back to host_space
-   {
-    typedef Kokkos::View<double****,InExecSpace> Rank4ViewType;
-    Rank4ViewType view_4;
-    view_4 = Rank4ViewType("view_4", dim0, dim1, dim2, dim2);
-
-    typedef Kokkos::HostSpace host_space_type;
-    Kokkos::View<double**,Kokkos::LayoutLeft,host_space_type> srcView("srcView", dim2, dim2);
-
-    // Strided dst view
-    auto dstView = Kokkos::subview(view_4, 0, 0, Kokkos::ALL(), Kokkos::ALL());
-
-    // host_space to ExecSpace
-    Kokkos::deep_copy( dstView, srcView );
-    Kokkos::fence();
-
-    // ExecSpace to host_space 
-    Kokkos::deep_copy( srcView, dstView );
-    Kokkos::fence();
-   }
+      Kokkos::View<double**, Kokkos::LayoutLeft, space_type> srcView(
+          "srcView", dim2, dim2);
+
+      // Strided dst view
+      auto dstView =
+          Kokkos::subview(view_4, 0, 0, Kokkos::ALL(), Kokkos::ALL());
+
+      // Cuda to ExecSpace
+      Kokkos::deep_copy(dstView, srcView);
+      Kokkos::fence();
+
+      // ExecSpace to Cuda
+      Kokkos::deep_copy(srcView, dstView);
+      Kokkos::fence();
+    }
+
+    // Test 3: deep_copy from host_space to ExecSpace and ExecSpace back to
+    // host_space
+    {
+      typedef Kokkos::View<double****, InExecSpace> Rank4ViewType;
+      Rank4ViewType view_4;
+      view_4 = Rank4ViewType("view_4", dim0, dim1, dim2, dim2);
+
+      typedef Kokkos::HostSpace host_space_type;
+      Kokkos::View<double**, Kokkos::LayoutLeft, host_space_type> srcView(
+          "srcView", dim2, dim2);
+
+      // Strided dst view
+      auto dstView =
+          Kokkos::subview(view_4, 0, 0, Kokkos::ALL(), Kokkos::ALL());
+
+      // host_space to ExecSpace
+      Kokkos::deep_copy(dstView, srcView);
+      Kokkos::fence();
+
+      // ExecSpace to host_space
+      Kokkos::deep_copy(srcView, dstView);
+      Kokkos::fence();
+    }
 #endif
-  } // end test_view_copy
+  }  // end test_view_copy
 
-}; // end struct
+};  // end struct
 
-} // namespace
+}  // namespace
 
-TEST_F( TEST_CATEGORY , view_copy_tests ) {
-  //Only include this file to be compiled with CudaUVM and CudaHostPinned
-  TestViewCopy< TEST_EXECSPACE >::test_view_copy(4,2,3);
-  TestViewCopy< TEST_EXECSPACE >::test_view_copy(4,2,0);
+TEST(TEST_CATEGORY, view_copy_tests) {
+  // Only include this file to be compiled with CudaUVM and CudaHostPinned
+  TestViewCopy<TEST_EXECSPACE>::test_view_copy(4, 2, 3);
+  TestViewCopy<TEST_EXECSPACE>::test_view_copy(4, 2, 0);
 }
 
-TEST_F( TEST_CATEGORY , view_copy_degenerated ) {
-  //Only include this file to be compiled with CudaUVM and CudaHostPinned
+TEST(TEST_CATEGORY, view_copy_degenerated) {
+  // Only include this file to be compiled with CudaUVM and CudaHostPinned
   Kokkos::View<int*, Kokkos::MemoryTraits<Kokkos::Unmanaged>> v_um_def_1;
-  Kokkos::View<int*, Kokkos::MemoryTraits<Kokkos::Unmanaged>> v_um_1( reinterpret_cast<int*>(-1), 0 );
+  Kokkos::View<int*, Kokkos::MemoryTraits<Kokkos::Unmanaged>> v_um_1(
+      reinterpret_cast<int*>(-1), 0);
   Kokkos::View<int*> v_m_def_1;
   Kokkos::View<int*> v_m_1("v_m_1", 0);
 
   Kokkos::View<int*, Kokkos::MemoryTraits<Kokkos::Unmanaged>> v_um_def_2;
-  Kokkos::View<int*, Kokkos::MemoryTraits<Kokkos::Unmanaged>> v_um_2( reinterpret_cast<int*>(-1), 0 );
+  Kokkos::View<int*, Kokkos::MemoryTraits<Kokkos::Unmanaged>> v_um_2(
+      reinterpret_cast<int*>(-1), 0);
   Kokkos::View<int*> v_m_def_2;
   Kokkos::View<int*> v_m_2("v_m_2", 0);
 
@@ -180,4 +192,4 @@ TEST_F( TEST_CATEGORY , view_copy_degenerated ) {
   Kokkos::deep_copy(v_m_1, v_m_2);
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewCtorPropEmbeddedDim.hpp b/lib/kokkos/core/unit_test/TestViewCtorPropEmbeddedDim.hpp
index 7730be2e1d79faaf477b5980134530f334b38f36..30701b3a4e289dcd1cc6522c9da0c327b8b9382d 100644
--- a/lib/kokkos/core/unit_test/TestViewCtorPropEmbeddedDim.hpp
+++ b/lib/kokkos/core/unit_test/TestViewCtorPropEmbeddedDim.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -54,61 +55,59 @@ namespace Test {
 
 namespace {
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestViewCtorProp_EmbeddedDim {
+  using ViewIntType    = typename Kokkos::View<int**, ExecSpace>;
+  using ViewDoubleType = typename Kokkos::View<double*, ExecSpace>;
 
-  using ViewIntType     = typename Kokkos::View< int**, ExecSpace >;
-  using ViewDoubleType     = typename Kokkos::View< double*, ExecSpace >;
-
-  // Cuda 7.0 has issues with using a lambda in parallel_for to initialize the view - replace with this functor
-  template < class ViewType >
+  // Cuda 7.0 has issues with using a lambda in parallel_for to initialize the
+  // view - replace with this functor
+  template <class ViewType>
   struct Functor {
-
     ViewType v;
 
-    Functor( const ViewType & v_ ) : v(v_) {}
+    Functor(const ViewType& v_) : v(v_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator()( const int i ) const {
-      v(i) = i;
-    }
-
+    void operator()(const int i) const { v(i) = i; }
   };
 
-
-  static void test_vcpt( const int N0, const int N1 )
-  {
-
+  static void test_vcpt(const int N0, const int N1) {
     // Create views to test
     {
-      using VIT = typename TestViewCtorProp_EmbeddedDim::ViewIntType ;
-      using VDT = typename TestViewCtorProp_EmbeddedDim::ViewDoubleType ;
+      using VIT = typename TestViewCtorProp_EmbeddedDim::ViewIntType;
+      using VDT = typename TestViewCtorProp_EmbeddedDim::ViewDoubleType;
 
       VIT vi1("vi1", N0, N1);
       VDT vd1("vd1", N0);
 
-      // TEST: Test for common type between two views, one with type double, other with type int
-      // Deduce common value_type and construct a view with that type
+      // TEST: Test for common type between two views, one with type double,
+      // other with type int Deduce common value_type and construct a view with
+      // that type
       {
         // Two views
         auto view_alloc_arg = Kokkos::common_view_alloc_prop(vi1, vd1);
-        typedef typename decltype( view_alloc_arg )::value_type                    CommonViewValueType;
-        typedef typename Kokkos::View< CommonViewValueType*, ExecSpace >  CVT;
-        typedef typename CVT::HostMirror                                           HostCVT;
-
-        // Construct View using the common type; for case of specialization, an 'embedded_dim' would be stored by view_alloc_arg
-        CVT cv1( Kokkos::view_alloc( "cv1", view_alloc_arg ), N0*N1 );
-
-        Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace >(0, N0*N1), 
-          Functor<CVT>(cv1)
-        );
-
-        HostCVT hcv1 = Kokkos::create_mirror_view( cv1 );
-        Kokkos::deep_copy( hcv1, cv1 );
-
-        ASSERT_EQ( (std::is_same< CommonViewValueType, double >::value) , true ) ;
-        ASSERT_EQ( (std::is_same< typename decltype(view_alloc_arg)::scalar_array_type, CommonViewValueType>::value) , true ) ;
-      #if 0
+        typedef
+            typename decltype(view_alloc_arg)::value_type CommonViewValueType;
+        typedef typename Kokkos::View<CommonViewValueType*, ExecSpace> CVT;
+        typedef typename CVT::HostMirror HostCVT;
+
+        // Construct View using the common type; for case of specialization, an
+        // 'embedded_dim' would be stored by view_alloc_arg
+        CVT cv1(Kokkos::view_alloc("cv1", view_alloc_arg), N0 * N1);
+
+        Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, N0 * N1),
+                             Functor<CVT>(cv1));
+
+        HostCVT hcv1 = Kokkos::create_mirror_view(cv1);
+        Kokkos::deep_copy(hcv1, cv1);
+
+        ASSERT_EQ((std::is_same<CommonViewValueType, double>::value), true);
+        ASSERT_EQ(
+            (std::is_same<typename decltype(view_alloc_arg)::scalar_array_type,
+                          CommonViewValueType>::value),
+            true);
+#if 0
       // debug output
       for ( int i = 0; i < N0*N1; ++i ) {
         printf(" Output check: hcv1(%d) = %lf\n ", i, hcv1(i) );
@@ -123,39 +122,39 @@ struct TestViewCtorProp_EmbeddedDim {
         printf("WRONG common value_type\n");
       }
       // end debug output
-      #endif
+#endif
       }
 
       {
         // Single view
         auto view_alloc_arg = Kokkos::common_view_alloc_prop(vi1);
-        typedef typename decltype( view_alloc_arg )::value_type                    CommonViewValueType;
-        typedef typename Kokkos::View< CommonViewValueType*, ExecSpace >  CVT;
-        typedef typename CVT::HostMirror                                           HostCVT;
+        typedef
+            typename decltype(view_alloc_arg)::value_type CommonViewValueType;
+        typedef typename Kokkos::View<CommonViewValueType*, ExecSpace> CVT;
+        typedef typename CVT::HostMirror HostCVT;
 
-        // Construct View using the common type; for case of specialization, an 'embedded_dim' would be stored by view_alloc_arg
-        CVT cv1( Kokkos::view_alloc( "cv1", view_alloc_arg ), N0*N1 );
+        // Construct View using the common type; for case of specialization, an
+        // 'embedded_dim' would be stored by view_alloc_arg
+        CVT cv1(Kokkos::view_alloc("cv1", view_alloc_arg), N0 * N1);
 
-        Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace >(0, N0*N1), 
-          Functor<CVT>(cv1)
-        );
+        Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, N0 * N1),
+                             Functor<CVT>(cv1));
 
-        HostCVT hcv1 = Kokkos::create_mirror_view( cv1 );
-        Kokkos::deep_copy( hcv1, cv1 );
+        HostCVT hcv1 = Kokkos::create_mirror_view(cv1);
+        Kokkos::deep_copy(hcv1, cv1);
 
-        ASSERT_EQ( (std::is_same< CommonViewValueType, int>::value) , true ) ;
+        ASSERT_EQ((std::is_same<CommonViewValueType, int>::value), true);
       }
-
     }
 
-  } // end test_vcpt
+  }  // end test_vcpt
 
-}; // end struct
+};  // end struct
 
-} // namespace
+}  // namespace
 
-TEST_F( TEST_CATEGORY , viewctorprop_embedded_dim ) {
-  TestViewCtorProp_EmbeddedDim< TEST_EXECSPACE >::test_vcpt( 2, 3 );
+TEST(TEST_CATEGORY, viewctorprop_embedded_dim) {
+  TestViewCtorProp_EmbeddedDim<TEST_EXECSPACE>::test_vcpt(2, 3);
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewLayoutStrideAssignment.hpp b/lib/kokkos/core/unit_test/TestViewLayoutStrideAssignment.hpp
index 3185fa54739e2668a031ca09c232b55d3805f7e6..5e373dbbc913be77decd59214c54e4d3f87b979c 100644
--- a/lib/kokkos/core/unit_test/TestViewLayoutStrideAssignment.hpp
+++ b/lib/kokkos/core/unit_test/TestViewLayoutStrideAssignment.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -52,689 +53,870 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY , view_layoutstride_left_to_layoutleft_assignment )
-{
-  typedef TEST_EXECSPACE exec_space ;
+TEST(TEST_CATEGORY, view_layoutstride_left_to_layoutleft_assignment) {
+  typedef TEST_EXECSPACE exec_space;
 
   auto t = time(0);
-  srand(t);// Use current time as seed for random generator
-  printf("view_layoutstride_left_to_layoutleft_assignment: srand(%lu)\n",size_t(t));
+  srand(t);  // Use current time as seed for random generator
+  printf("view_layoutstride_left_to_layoutleft_assignment: srand(%lu)\n",
+         size_t(t));
 
-  { // Assignment of rank-1 LayoutLeft = LayoutStride
-    int ndims = 1;
-    int dims [] = {10};
-    int order [] = {0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-1 LayoutLeft = LayoutStride
+    int ndims   = 1;
+    int dims[]  = {10};
+    int order[] = {0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                layout);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space>::HostMirror h_src =
+        Kokkos::create_mirror_view(src);
 
-    Kokkos::deep_copy( src, h_src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::View<double*, Kokkos::LayoutLeft, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
+
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-2 LayoutLeft = LayoutStride
-    int ndims = 2;
-    int dims [] = {10,9};
-    int order [] = {0,1};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);  
-  
-    Kokkos::View< double**, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-2 LayoutLeft = LayoutStride
+    int ndims   = 2;
+    int dims[]  = {10, 9};
+    int order[] = {0, 1};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double**, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                 layout);
+
+    Kokkos::View<double**, Kokkos::LayoutStride, exec_space>::HostMirror h_src =
+        Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double**, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::View<double**, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::View< double**, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double**, Kokkos::LayoutLeft, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-3 LayoutLeft = LayoutStride
-    int ndims = 3;
-    int dims [] = {10,9,8};
-    int order [] = {0,1,2};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double***, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-3 LayoutLeft = LayoutStride
+    int ndims   = 3;
+    int dims[]  = {10, 9, 8};
+    int order[] = {0, 1, 2};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double***, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::View<double***, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    Kokkos::deep_copy( src, h_src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::View< double***, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double***, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double***, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::View<double***, Kokkos::LayoutLeft, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
+
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-4 LayoutLeft = LayoutStride
-    int ndims = 4;
-    int dims [] = {10,9,8,7};
-    int order [] = {0,1,2,3};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-4 LayoutLeft = LayoutStride
+    int ndims   = 4;
+    int dims[]  = {10, 9, 8, 7};
+    int order[] = {0, 1, 2, 3};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double****, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double****, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::View<double****, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::View< double****, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double****, Kokkos::LayoutLeft, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-5 LayoutLeft = LayoutStride
-    int ndims = 5;
-    int dims [] = {10,9,8,7,6};
-    int order [] = {0,1,2,3,4};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-5 LayoutLeft = LayoutStride
+    int ndims   = 5;
+    int dims[]  = {10, 9, 8, 7, 6};
+    int order[] = {0, 1, 2, 3, 4};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::View<double*****, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    Kokkos::deep_copy( src, h_src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::View< double*****, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double*****, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*****, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::View<double*****, Kokkos::LayoutLeft, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
+
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-6 LayoutLeft = LayoutStride
-    int ndims = 6;
-    int dims [] = {10,9,8,7,6,5};
-    int order [] = {0,1,2,3,4,5};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-6 LayoutLeft = LayoutStride
+    int ndims   = 6;
+    int dims[]  = {10, 9, 8, 7, 6, 5};
+    int order[] = {0, 1, 2, 3, 4, 5};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double******, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double******, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::View<double******, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::View< double******, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double******, Kokkos::LayoutLeft, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-7 LayoutLeft = LayoutStride
-    int ndims = 7;
-    int dims [] = {10,9,8,7,6,5,4};
-    int order [] = {0,1,2,3,4,5,6};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-7 LayoutLeft = LayoutStride
+    int ndims   = 7;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4};
+    int order[] = {0, 1, 2, 3, 4, 5, 6};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::View<double*******, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    Kokkos::deep_copy( src, h_src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::View< double*******, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double*******, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*******, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::View<double*******, Kokkos::LayoutLeft, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
+
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-8 LayoutLeft = LayoutStride
-    int ndims = 8;
-    int dims [] = {10,9,8,7,6,5,4,3};
-    int order [] = {0,1,2,3,4,5,6,7};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double********, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-8 LayoutLeft = LayoutStride
+    int ndims   = 8;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4, 3};
+    int order[] = {0, 1, 2, 3, 4, 5, 6, 7};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double********, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double********, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double********, Kokkos::LayoutLeft, exec_space > dst = src;
+    Kokkos::View<double********, Kokkos::LayoutLeft, exec_space> dst = src;
 
-    Kokkos::View< double********, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double********, Kokkos::LayoutLeft, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-
 }
 
-TEST_F( TEST_CATEGORY , view_layoutstride_right_to_layoutright_assignment )
-{
-  typedef TEST_EXECSPACE exec_space ;
+TEST(TEST_CATEGORY, view_layoutstride_right_to_layoutright_assignment) {
+  typedef TEST_EXECSPACE exec_space;
 
   auto t = time(0);
-  srand(t);// Use current time as seed for random generator
-  printf("view_layoutstride_right_to_layoutright_assignment: srand(%lu)\n",size_t(t));
+  srand(t);  // Use current time as seed for random generator
+  printf("view_layoutstride_right_to_layoutright_assignment: srand(%lu)\n",
+         size_t(t));
+
+  {  // Assignment of rank-1 LayoutRight = LayoutStride
+    int ndims   = 1;
+    int dims[]  = {10};
+    int order[] = {0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                layout);
 
-  { // Assignment of rank-1 LayoutRight = LayoutStride
-    int ndims = 1;
-    int dims [] = {10};
-    int order [] = {0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space>::HostMirror h_src =
+        Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double*, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::View<double*, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::View< double*, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*, Kokkos::LayoutRight, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-2 LayoutRight = LayoutStride
-    int ndims = 2;
-    int dims [] = {10,9};
-    int order [] = {1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double**, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-2 LayoutRight = LayoutStride
+    int ndims   = 2;
+    int dims[]  = {10, 9};
+    int order[] = {1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double**, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                 layout);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::View<double**, Kokkos::LayoutStride, exec_space>::HostMirror h_src =
+        Kokkos::create_mirror_view(src);
 
-    Kokkos::deep_copy( src, h_src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::View< double**, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double**, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double**, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::View<double**, Kokkos::LayoutRight, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
+
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-3 LayoutRight = LayoutStride
-    int ndims = 3;
-    int dims [] = {10,9,8};
-    int order [] = {2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double***, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-3 LayoutRight = LayoutStride
+    int ndims   = 3;
+    int dims[]  = {10, 9, 8};
+    int order[] = {2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double***, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double***, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double***, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::View<double***, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::View< double***, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double***, Kokkos::LayoutRight, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-4 LayoutRight = LayoutStride
-    int ndims = 4;
-    int dims [] = {10,9,8,7};
-    int order [] = {3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-4 LayoutRight = LayoutStride
+    int ndims   = 4;
+    int dims[]  = {10, 9, 8, 7};
+    int order[] = {3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::View<double****, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    Kokkos::deep_copy( src, h_src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::View< double****, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double****, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double****, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::View<double****, Kokkos::LayoutRight, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
+
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-5 LayoutRight = LayoutStride
-    int ndims = 5;
-    int dims [] = {10,9,8,7,6};
-    int order [] = {4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-5 LayoutRight = LayoutStride
+    int ndims   = 5;
+    int dims[]  = {10, 9, 8, 7, 6};
+    int order[] = {4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double*****, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double*****, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::View<double*****, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::View< double*****, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*****, Kokkos::LayoutRight, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-6 LayoutRight = LayoutStride
-    int ndims = 6;
-    int dims [] = {10,9,8,7,6,5};
-    int order [] = {5,4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-6 LayoutRight = LayoutStride
+    int ndims   = 6;
+    int dims[]  = {10, 9, 8, 7, 6, 5};
+    int order[] = {5, 4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double******, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double******, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::View<double******, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::View< double******, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double******, Kokkos::LayoutRight, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-7 LayoutRight = LayoutStride
-    int ndims = 7;
-    int dims [] = {10,9,8,7,6,5,4};
-    int order [] = {6,5,4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-7 LayoutRight = LayoutStride
+    int ndims   = 7;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4};
+    int order[] = {6, 5, 4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::View<double*******, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    Kokkos::deep_copy( src, h_src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::View< double*******, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double*******, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*******, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::View<double*******, Kokkos::LayoutRight, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
+
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-8 LayoutRight = LayoutStride
-    int ndims = 8;
-    int dims [] = {10,9,8,7,6,5,4,3};
-    int order [] = {7,6,5,4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double********, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+  {  // Assignment of rank-8 LayoutRight = LayoutStride
+    int ndims   = 8;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4, 3};
+    int order[] = {7, 6, 5, 4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double********, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double********, Kokkos::LayoutStride, exec_space>::HostMirror
+        h_src = Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::View< double********, Kokkos::LayoutRight, exec_space > dst = src;
+    Kokkos::View<double********, Kokkos::LayoutRight, exec_space> dst = src;
 
-    Kokkos::View< double********, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double********, Kokkos::LayoutRight, exec_space>::HostMirror
+        h_dst = Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-
 }
 
-TEST_F( TEST_CATEGORY , view_layoutstride_right_to_layoutleft_assignment )
-{
-  typedef TEST_EXECSPACE exec_space ;
+TEST(TEST_CATEGORY_DEATH, view_layoutstride_right_to_layoutleft_assignment) {
+  typedef TEST_EXECSPACE exec_space;
 
   auto t = time(0);
-  srand(t);// Use current time as seed for random generator
-  printf("view_layoutstride_right_to_layoutleft_assignment: srand(%lu)\n",size_t(t));
+  srand(t);  // Use current time as seed for random generator
+  printf("view_layoutstride_right_to_layoutleft_assignment: srand(%lu)\n",
+         size_t(t));
+
+  {  // Assignment of rank-1 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 1;
+    int dims[]  = {10};
+    int order[] = {0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                layout);
 
-  { // Assignment of rank-1 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 1;
-    int dims [] = {10};
-    int order [] = {0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space>::HostMirror h_src =
+        Kokkos::create_mirror_view(src);
 
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    Kokkos::deep_copy(src, h_src);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::View<double*, Kokkos::LayoutLeft, exec_space> dst;
 
-    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space > dst;
-    
     dst = src;
 
-    Kokkos::View< double*, Kokkos::LayoutLeft, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*, Kokkos::LayoutLeft, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-2 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 2;
-    int dims [] = {10,9};
-    int order [] = {1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-2 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 2;
+    int dims[]  = {10, 9};
+    int order[] = {1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double**, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                 layout);
 
-    Kokkos::View< double**, Kokkos::LayoutLeft, exec_space > dst;
+    Kokkos::View<double**, Kokkos::LayoutLeft, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-3 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 3;
-    int dims [] = {10,9,8};
-    int order [] = {2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double***, Kokkos::LayoutLeft, exec_space > dst;
+  {  // Assignment of rank-3 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 3;
+    int dims[]  = {10, 9, 8};
+    int order[] = {2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double***, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double***, Kokkos::LayoutLeft, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-4 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 4;
-    int dims [] = {10,9,8,7};
-    int order [] = {3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-4 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 4;
+    int dims[]  = {10, 9, 8, 7};
+    int order[] = {3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    Kokkos::View< double****, Kokkos::LayoutLeft, exec_space > dst;
+    Kokkos::View<double****, Kokkos::LayoutLeft, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-5 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 5;
-    int dims [] = {10,9,8,7,6};
-    int order [] = {4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*****, Kokkos::LayoutLeft, exec_space > dst;
+  {  // Assignment of rank-5 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 5;
+    int dims[]  = {10, 9, 8, 7, 6};
+    int order[] = {4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double*****, Kokkos::LayoutLeft, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-6 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 6;
-    int dims [] = {10,9,8,7,6,5};
-    int order [] = {5,4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double******, Kokkos::LayoutLeft, exec_space > dst;
+  {  // Assignment of rank-6 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 6;
+    int dims[]  = {10, 9, 8, 7, 6, 5};
+    int order[] = {5, 4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double******, Kokkos::LayoutLeft, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-7 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 7;
-    int dims [] = {10,9,8,7,6,5,4};
-    int order [] = {6,5,4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-7 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 7;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4};
+    int order[] = {6, 5, 4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    Kokkos::View< double*******, Kokkos::LayoutLeft, exec_space > dst;
+    Kokkos::View<double*******, Kokkos::LayoutLeft, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-8 LayoutLeft = LayoutStride (LayoutRight compatible)
-    int ndims = 8;
-    int dims [] = {10,9,8,7,6,5,4,3};
-    int order [] = {7,6,5,4,3,2,1,0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-8 LayoutLeft = LayoutStride (LayoutRight compatible)
+    int ndims   = 8;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4, 3};
+    int order[] = {7, 6, 5, 4, 3, 2, 1, 0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double********, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    Kokkos::View< double********, Kokkos::LayoutLeft, exec_space > dst;
+    Kokkos::View<double********, Kokkos::LayoutLeft, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-
 }
 
-TEST_F( TEST_CATEGORY , view_layoutstride_left_to_layoutright_assignment )
-{
-  typedef TEST_EXECSPACE exec_space ;
+TEST(TEST_CATEGORY_DEATH, view_layoutstride_left_to_layoutright_assignment) {
+  typedef TEST_EXECSPACE exec_space;
 
   auto t = time(0);
-  srand(t);// Use current time as seed for random generator
-  printf("view_layoutstride_left_to_layoutright_assignment: srand(%lu)\n",size_t(t));
+  srand(t);  // Use current time as seed for random generator
+  printf("view_layoutstride_left_to_layoutright_assignment: srand(%lu)\n",
+         size_t(t));
 
-  { // Assignment of rank-1 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 1;
-    int dims [] = {10};
-    int order [] = {0};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-1 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 1;
+    int dims[]  = {10};
+    int order[] = {0};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                layout);
 
-    Kokkos::View< double*, Kokkos::LayoutStride, exec_space >::HostMirror h_src = Kokkos::create_mirror_view( src );
+    Kokkos::View<double*, Kokkos::LayoutStride, exec_space>::HostMirror h_src =
+        Kokkos::create_mirror_view(src);
 
-    for(size_t i=0; i<src.span(); i++) h_src.data()[i] = (double)rand() / RAND_MAX * (100);
+    for (size_t i = 0; i < src.span(); i++)
+      h_src.data()[i] = (double)rand() / RAND_MAX * (100);
 
-    Kokkos::deep_copy( src, h_src );
+    Kokkos::deep_copy(src, h_src);
+
+    Kokkos::View<double*, Kokkos::LayoutRight, exec_space> dst;
 
-    Kokkos::View< double*, Kokkos::LayoutRight, exec_space > dst;
-    
     dst = src;
 
-    Kokkos::View< double*, Kokkos::LayoutRight, exec_space >::HostMirror h_dst = Kokkos::create_mirror_view( dst );
+    Kokkos::View<double*, Kokkos::LayoutRight, exec_space>::HostMirror h_dst =
+        Kokkos::create_mirror_view(dst);
 
-    Kokkos::deep_copy( h_dst, dst );
+    Kokkos::deep_copy(h_dst, dst);
 
     bool test = true;
-    for(size_t i=0; i<src.span();i++){
-      if (h_src.data()[i]!=h_dst.data()[i]) {test = false;break;}
+    for (size_t i = 0; i < src.span(); i++) {
+      if (h_src.data()[i] != h_dst.data()[i]) {
+        test = false;
+        break;
+      }
     }
-    ASSERT_EQ( dst.span(), src.span() );
-    ASSERT_EQ( test, true );
+    ASSERT_EQ(dst.span(), src.span());
+    ASSERT_EQ(test, true);
   }
-  { // Assignment of rank-2 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 2;
-    int dims [] = {10,9};
-    int order [] = {0,1};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double**, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-2 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 2;
+    int dims[]  = {10, 9};
+    int order[] = {0, 1};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double**, Kokkos::LayoutStride, exec_space> src("LayoutStride",
+                                                                 layout);
 
-    Kokkos::View< double**, Kokkos::LayoutRight, exec_space > dst;
+    Kokkos::View<double**, Kokkos::LayoutRight, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-3 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 3;
-    int dims [] = {10,9,8};
-    int order [] = {0,1,2};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double***, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double***, Kokkos::LayoutRight, exec_space > dst;
+  {  // Assignment of rank-3 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 3;
+    int dims[]  = {10, 9, 8};
+    int order[] = {0, 1, 2};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double***, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
+
+    Kokkos::View<double***, Kokkos::LayoutRight, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-4 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 4;
-    int dims [] = {10,9,8,7};
-    int order [] = {0,1,2,3};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-4 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 4;
+    int dims[]  = {10, 9, 8, 7};
+    int order[] = {0, 1, 2, 3};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    Kokkos::View< double****, Kokkos::LayoutRight, exec_space > dst;
+    Kokkos::View<double****, Kokkos::LayoutRight, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-5 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 5;
-    int dims [] = {10,9,8,7,6};
-    int order [] = {0,1,2,3,4};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*****, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double*****, Kokkos::LayoutRight, exec_space > dst;
+  {  // Assignment of rank-5 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 5;
+    int dims[]  = {10, 9, 8, 7, 6};
+    int order[] = {0, 1, 2, 3, 4};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*****, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
-  }
-  { // Assignment of rank-6 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 6;
-    int dims [] = {10,9,8,7,6,5};
-    int order [] = {0,1,2,3,4,5};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
-	
-    Kokkos::View< double******, Kokkos::LayoutRight, exec_space > dst;
+    Kokkos::View<double*****, Kokkos::LayoutRight, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-7 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 7;
-    int dims [] = {10,9,8,7,6,5,4};
-    int order [] = {0,1,2,3,4,5,6};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double*******, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-6 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 6;
+    int dims[]  = {10, 9, 8, 7, 6, 5};
+    int order[] = {0, 1, 2, 3, 4, 5};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    Kokkos::View< double*******, Kokkos::LayoutRight, exec_space > dst;
+    Kokkos::View<double******, Kokkos::LayoutRight, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
-  { // Assignment of rank-8 LayoutRight = LayoutStride (LayoutLeft compatible)
-    int ndims = 8;
-    int dims [] = {10,9,8,7,6,5,4,3};
-    int order [] = {0,1,2,3,4,5,6,7};
-    Kokkos::LayoutStride layout = Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
-    Kokkos::View< double********, Kokkos::LayoutStride, exec_space > src("LayoutStride", layout);
+  {  // Assignment of rank-7 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 7;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4};
+    int order[] = {0, 1, 2, 3, 4, 5, 6};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double*******, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-    Kokkos::View< double********, Kokkos::LayoutRight, exec_space > dst;
+    Kokkos::View<double*******, Kokkos::LayoutRight, exec_space> dst;
 
     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-    ASSERT_DEATH({dst=src;}, "View assignment must have compatible layouts");
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
   }
+  {  // Assignment of rank-8 LayoutRight = LayoutStride (LayoutLeft compatible)
+    int ndims   = 8;
+    int dims[]  = {10, 9, 8, 7, 6, 5, 4, 3};
+    int order[] = {0, 1, 2, 3, 4, 5, 6, 7};
+    Kokkos::LayoutStride layout =
+        Kokkos::LayoutStride::order_dimensions(ndims, order, dims);
+    Kokkos::View<double********, Kokkos::LayoutStride, exec_space> src(
+        "LayoutStride", layout);
 
-}
+    Kokkos::View<double********, Kokkos::LayoutRight, exec_space> dst;
 
+    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+    ASSERT_DEATH({ dst = src; },
+                 "View assignment must have compatible layouts");
+  }
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewLayoutTiled.hpp b/lib/kokkos/core/unit_test/TestViewLayoutTiled.hpp
index e765e8b06d3575a438d1d894cd0f995f3e1da3b3..2526a3e7e3cc627733d062615c7cbc8c04c5d9f2 100644
--- a/lib/kokkos/core/unit_test/TestViewLayoutTiled.hpp
+++ b/lib/kokkos/core/unit_test/TestViewLayoutTiled.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -56,9 +57,8 @@ namespace Test {
 #ifndef KOKKOS_ENABLE_DEPRECATED_CODE
 namespace {
 
-template <typename ExecSpace >
+template <typename ExecSpace>
 struct TestViewLayoutTiled {
-
   typedef double Scalar;
 
   static constexpr int T0 = 2;
@@ -71,939 +71,1372 @@ struct TestViewLayoutTiled {
   static constexpr int T7 = 2;
 
   // Rank 2
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Left, T0, T1>   LayoutLL_2D_2x4;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Left, T0, T1>  LayoutRL_2D_2x4;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Right, T0, T1>  LayoutLR_2D_2x4;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Right, T0, T1> LayoutRR_2D_2x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
+                                            Kokkos::Iterate::Left, T0, T1>
+      LayoutLL_2D_2x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
+                                            Kokkos::Iterate::Left, T0, T1>
+      LayoutRL_2D_2x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
+                                            Kokkos::Iterate::Right, T0, T1>
+      LayoutLR_2D_2x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
+                                            Kokkos::Iterate::Right, T0, T1>
+      LayoutRR_2D_2x4;
 
   // Rank 3
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Left, T0, T1, T2>   LayoutLL_3D_2x4x4;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Left, T0, T1, T2>  LayoutRL_3D_2x4x4;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Right, T0, T1, T2>  LayoutLR_3D_2x4x4;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Right, T0, T1, T2> LayoutRR_3D_2x4x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
+                                            Kokkos::Iterate::Left, T0, T1, T2>
+      LayoutLL_3D_2x4x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
+                                            Kokkos::Iterate::Left, T0, T1, T2>
+      LayoutRL_3D_2x4x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
+                                            Kokkos::Iterate::Right, T0, T1, T2>
+      LayoutLR_3D_2x4x4;
+  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
+                                            Kokkos::Iterate::Right, T0, T1, T2>
+      LayoutRR_3D_2x4x4;
 
   // Rank 4
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Left, T0, T1, T2, T3>   LayoutLL_4D_2x4x4x2;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Left, T0, T1, T2, T3>  LayoutRL_4D_2x4x4x2;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left, Kokkos::Iterate::Right, T0, T1, T2, T3>  LayoutLR_4D_2x4x4x2;
-  typedef Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right, Kokkos::Iterate::Right, T0, T1, T2, T3> LayoutRR_4D_2x4x4x2;
-
-
-  static void test_view_layout_tiled_2d( const int N0, const int N1 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-    const int FT = T0*T1;
-
-    const int NT0 = int( std::ceil( N0 / T0 ) );
-    const int NT1 = int( std::ceil( N1 / T1 ) );
+  typedef Kokkos::Experimental::LayoutTiled<
+      Kokkos::Iterate::Left, Kokkos::Iterate::Left, T0, T1, T2, T3>
+      LayoutLL_4D_2x4x4x2;
+  typedef Kokkos::Experimental::LayoutTiled<
+      Kokkos::Iterate::Right, Kokkos::Iterate::Left, T0, T1, T2, T3>
+      LayoutRL_4D_2x4x4x2;
+  typedef Kokkos::Experimental::LayoutTiled<
+      Kokkos::Iterate::Left, Kokkos::Iterate::Right, T0, T1, T2, T3>
+      LayoutLR_4D_2x4x4x2;
+  typedef Kokkos::Experimental::LayoutTiled<
+      Kokkos::Iterate::Right, Kokkos::Iterate::Right, T0, T1, T2, T3>
+      LayoutRR_4D_2x4x4x2;
+
+  static void test_view_layout_tiled_2d(const int N0, const int N1) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+    const int FT = T0 * T1;
+
+    const int NT0 = int(std::ceil(N0 / T0));
+    const int NT1 = int(std::ceil(N1 / T1));
     // Test create_mirror_view, deep_copy
     // Create LL View
     {
-      typedef typename Kokkos::View< Scalar**, LayoutLL_2D_2x4, ExecSpace > ViewType;
+      typedef typename Kokkos::View<Scalar**, LayoutLL_2D_2x4, ExecSpace>
+          ViewType;
       ViewType v("v", N0, N1);
 
       typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
 
       // Initialize host-view
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          hv(ti*T0 + i, tj*T1+j) = ( ti + tj*NT0 )*FT + ( i + j*T0 );
-        } }
-      } }
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              hv(ti * T0 + i, tj * T1 + j) =
+                  (ti + tj * NT0) * FT + (i + j * T0);
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(v, hv);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Left>, ExecSpace > mdrangepolicy( {0,0}, {NT0, NT1}, {T0,T1} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Left>,
+          ExecSpace>
+          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 2 LL", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int ti, const int tj) {
-          for ( int j = 0; j < T1; ++j ) {
-          for ( int i = 0; i < T0; ++i ) {
-            if ( (ti*T0 + i < N0) && (tj*T1 + j < N1) ) { v(ti*T0 + i, tj*T1+j) += 1; }
-          } }
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 2 LL", mdrangepolicy,
+          KOKKOS_LAMBDA(const int ti, const int tj) {
+            for (int j = 0; j < T1; ++j) {
+              for (int i = 0; i < T0; ++i) {
+                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
+                  v(ti * T0 + i, tj * T1 + j) += 1;
+                }
+              }
+            }
+          });
 
       Kokkos::deep_copy(hv, v);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( hv, ti, tj );
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j) != hv(ti*T0+i, tj*T1+j) ) { ++counter_subview; }
-          if ( tile_subview(i,j) != (( ti + tj*NT0 )*FT + ( i + j*T0 ) + 1 )) { ++counter_inc; }
-        } }
-      } }
+      long counter_inc     = 0;
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
+                ++counter_subview;
+              }
+              if (tile_subview(i, j) !=
+                  ((ti + tj * NT0) * FT + (i + j * T0) + 1)) {
+                ++counter_inc;
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
     }
 
     // Create RL View
     {
-      typedef typename Kokkos::View< Scalar**, LayoutRL_2D_2x4, ExecSpace > ViewType;
-      Kokkos::View< Scalar**, LayoutRL_2D_2x4, ExecSpace > v("v", N0, N1);
+      typedef typename Kokkos::View<Scalar**, LayoutRL_2D_2x4, ExecSpace>
+          ViewType;
+      Kokkos::View<Scalar**, LayoutRL_2D_2x4, ExecSpace> v("v", N0, N1);
 
       typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
 
       // Initialize host-view
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          hv(ti*T0 + i, tj*T1+j) = ( ti*NT1 + tj )*FT + ( i + j*T0 );
-        } }
-      } }
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              hv(ti * T0 + i, tj * T1 + j) =
+                  (ti * NT1 + tj) * FT + (i + j * T0);
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(v, hv);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<2, Kokkos::Iterate::Right, Kokkos::Iterate::Left>, ExecSpace > mdrangepolicy( {0,0}, {NT0, NT1}, {T0,T1} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<2, Kokkos::Iterate::Right, Kokkos::Iterate::Left>,
+          ExecSpace>
+          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 2 RL", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int ti, const int tj) {
-          for ( int j = 0; j < T1; ++j ) {
-          for ( int i = 0; i < T0; ++i ) {
-            if ( (ti*T0 + i < N0) && (tj*T1 + j < N1) ) { v(ti*T0 + i, tj*T1+j) += 1; }
-          } }
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 2 RL", mdrangepolicy,
+          KOKKOS_LAMBDA(const int ti, const int tj) {
+            for (int j = 0; j < T1; ++j) {
+              for (int i = 0; i < T0; ++i) {
+                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
+                  v(ti * T0 + i, tj * T1 + j) += 1;
+                }
+              }
+            }
+          });
 
       Kokkos::deep_copy(hv, v);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        auto tile_subview = Kokkos::tile_subview( hv, ti, tj );
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j) != hv(ti*T0+i, tj*T1+j) ) { ++counter_subview; }
-          if ( tile_subview(i,j) != (( ti*NT1 + tj )*FT + ( i + j*T0 ) + 1 )) { ++counter_inc; }
-        } }
-      } }
+      long counter_inc     = 0;
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
+                ++counter_subview;
+              }
+              if (tile_subview(i, j) !=
+                  ((ti * NT1 + tj) * FT + (i + j * T0) + 1)) {
+                ++counter_inc;
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create LR View
     {
-      typedef typename Kokkos::View< Scalar**, LayoutLR_2D_2x4, ExecSpace > ViewType;
-      Kokkos::View< Scalar**, LayoutLR_2D_2x4, ExecSpace > v("v", N0, N1);
+      typedef typename Kokkos::View<Scalar**, LayoutLR_2D_2x4, ExecSpace>
+          ViewType;
+      Kokkos::View<Scalar**, LayoutLR_2D_2x4, ExecSpace> v("v", N0, N1);
 
       typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
 
       // Initialize host-view
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          hv(ti*T0 + i, tj*T1+j) = ( ti + tj*NT0 )*FT + ( i*T1 + j );
-        } }
-      } }
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              hv(ti * T0 + i, tj * T1 + j) =
+                  (ti + tj * NT0) * FT + (i * T1 + j);
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(v, hv);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Right>, ExecSpace > mdrangepolicy( {0,0}, {NT0, NT1}, {T0,T1} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
+          ExecSpace>
+          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 2 LR", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int ti, const int tj) {
-          for ( int j = 0; j < T1; ++j ) {
-          for ( int i = 0; i < T0; ++i ) {
-            if ( (ti*T0 + i < N0) && (tj*T1 + j < N1) ) { v(ti*T0 + i, tj*T1+j) += 1; }
-          } }
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 2 LR", mdrangepolicy,
+          KOKKOS_LAMBDA(const int ti, const int tj) {
+            for (int j = 0; j < T1; ++j) {
+              for (int i = 0; i < T0; ++i) {
+                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
+                  v(ti * T0 + i, tj * T1 + j) += 1;
+                }
+              }
+            }
+          });
 
       Kokkos::deep_copy(hv, v);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( hv, ti, tj );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          if ( tile_subview(i,j) != hv(ti*T0+i, tj*T1+j) ) { ++counter_subview; }
-          if ( tile_subview(i,j) != ( ( ti + tj*NT0 )*FT + ( i*T1 + j ) + 1 ) ) { ++counter_inc; }
-        } }
-      } }
+      long counter_inc     = 0;
+
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
+                ++counter_subview;
+              }
+              if (tile_subview(i, j) !=
+                  ((ti + tj * NT0) * FT + (i * T1 + j) + 1)) {
+                ++counter_inc;
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create RR View
     {
-      typedef typename Kokkos::View< Scalar**, LayoutRR_2D_2x4, ExecSpace > ViewType;
-      Kokkos::View< Scalar**, LayoutRR_2D_2x4, ExecSpace > v("v", N0, N1);
+      typedef typename Kokkos::View<Scalar**, LayoutRR_2D_2x4, ExecSpace>
+          ViewType;
+      Kokkos::View<Scalar**, LayoutRR_2D_2x4, ExecSpace> v("v", N0, N1);
 
       typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
 
       // Initialize host-view
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          hv(ti*T0 + i, tj*T1+j) = ( ti*NT1 + tj )*FT + ( i*T1 + j );
-        } }
-      } }
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              hv(ti * T0 + i, tj * T1 + j) =
+                  (ti * NT1 + tj) * FT + (i * T1 + j);
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(v, hv);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Right>, ExecSpace > mdrangepolicy( {0,0}, {NT0, NT1}, {T0,T1} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
+          ExecSpace>
+          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 2 LR", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int ti, const int tj) {
-          for ( int j = 0; j < T1; ++j ) {
-          for ( int i = 0; i < T0; ++i ) {
-            if ( (ti*T0 + i < N0) && (tj*T1 + j < N1) ) { v(ti*T0 + i, tj*T1+j) += 1; }
-          } }
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 2 LR", mdrangepolicy,
+          KOKKOS_LAMBDA(const int ti, const int tj) {
+            for (int j = 0; j < T1; ++j) {
+              for (int i = 0; i < T0; ++i) {
+                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
+                  v(ti * T0 + i, tj * T1 + j) += 1;
+                }
+              }
+            }
+          });
 
       Kokkos::deep_copy(hv, v);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        auto tile_subview = Kokkos::tile_subview( hv, ti, tj );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          if ( tile_subview(i,j) != hv(ti*T0+i, tj*T1+j) ) { ++counter_subview; }
-          if ( tile_subview(i,j) != ( ( ti*NT1 + tj )*FT + ( i*T1 + j ) + 1 ) ) { ++counter_inc; }
-        } }
-      } }
+      long counter_inc     = 0;
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
+                ++counter_subview;
+              }
+              if (tile_subview(i, j) !=
+                  ((ti * NT1 + tj) * FT + (i * T1 + j) + 1)) {
+                ++counter_inc;
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 #endif
 #endif
-  } // end test_view_layout_tiled_2d
-
+  }  // end test_view_layout_tiled_2d
 
-  static void test_view_layout_tiled_3d( const int N0, const int N1, const int N2 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
+  static void test_view_layout_tiled_3d(const int N0, const int N1,
+                                        const int N2) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
 
-    const int FT = T0*T1*T2;
+    const int FT = T0 * T1 * T2;
 
-    const int NT0 = int( std::ceil( N0 / T0 ) );
-    const int NT1 = int( std::ceil( N1 / T1 ) );
-    const int NT2 = int( std::ceil( N2 / T2 ) );
+    const int NT0 = int(std::ceil(N0 / T0));
+    const int NT1 = int(std::ceil(N1 / T1));
+    const int NT2 = int(std::ceil(N2 / T2));
 
     // Create LL View
     {
-      typedef Kokkos::View< Scalar***, LayoutLL_3D_2x4x4, ExecSpace > ViewType;
-      Kokkos::View< Scalar***, LayoutLL_3D_2x4x4, ExecSpace > dv("dv", N0, N1, N2);
+      typedef Kokkos::View<Scalar***, LayoutLL_3D_2x4x4, ExecSpace> ViewType;
+      Kokkos::View<Scalar***, LayoutLL_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
+                                                               N2);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti + tj*NT0 + tk*N0*N1 )*FT + ( i + j*T0 + k*T0*T1 );
-        } } }
-      } } }
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti + tj * NT0 + tk * N0 * N1) * FT +
+                      (i + j * T0 + k * T0 * T1);
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Left>, ExecSpace > mdrangepolicy( {0,0,0}, {N0,N1,N2}, {T0,T1,T2} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Left>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 3 LL", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k) {
-          dv(i,j,k) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 3 LL", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k) {
+            dv(i, j, k) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k) != ( ( ti + tj*NT0 + tk*N0*N1 )*FT + ( i + j*T0 + k*T0*T1 ) +  1 ) ) { ++counter_inc; }
-        } } }
-      } } }
+      long counter_inc     = 0;
+
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter_subview;
+                  }
+                  if (tile_subview(i, j, k) !=
+                      ((ti + tj * NT0 + tk * N0 * N1) * FT +
+                       (i + j * T0 + k * T0 * T1) + 1)) {
+                    ++counter_inc;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create RL View
     {
-      typedef Kokkos::View< Scalar***, LayoutRL_3D_2x4x4, ExecSpace > ViewType;
-      Kokkos::View< Scalar***, LayoutRL_3D_2x4x4, ExecSpace > dv("dv", N0, N1, N2);
+      typedef Kokkos::View<Scalar***, LayoutRL_3D_2x4x4, ExecSpace> ViewType;
+      Kokkos::View<Scalar***, LayoutRL_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
+                                                               N2);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i + j*T0 + k*T0*T1 );
-        } } }
-      } } }
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                      (i + j * T0 + k * T0 * T1);
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<3, Kokkos::Iterate::Right, Kokkos::Iterate::Left>, ExecSpace > mdrangepolicy( {0,0,0}, {N0,N1,N2}, {T0,T1,T2} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, Kokkos::Iterate::Right, Kokkos::Iterate::Left>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 3 RL", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k) {
-          dv(i,j,k) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 3 RL", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k) {
+            dv(i, j, k) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k) != ( ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i + j*T0 + k*T0*T1 ) + 1 ) ) { ++counter_inc; }
-        } } }
-      } } }
+      long counter_inc     = 0;
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter_subview;
+                  }
+                  if (tile_subview(i, j, k) !=
+                      ((ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                       (i + j * T0 + k * T0 * T1) + 1)) {
+                    ++counter_inc;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create LR View
     {
-      typedef Kokkos::View< Scalar***, LayoutLR_3D_2x4x4, ExecSpace > ViewType;
-      Kokkos::View< Scalar***, LayoutLR_3D_2x4x4, ExecSpace > dv("dv", N0, N1, N2);
+      typedef Kokkos::View<Scalar***, LayoutLR_3D_2x4x4, ExecSpace> ViewType;
+      Kokkos::View<Scalar***, LayoutLR_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
+                                                               N2);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti + tj*NT0 + tk*NT0*NT1 )*FT + ( i*T1*T2 + j*T2 + k );
-        } } }
-      } } }
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti + tj * NT0 + tk * NT0 * NT1) * FT +
+                      (i * T1 * T2 + j * T2 + k);
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Right>, ExecSpace > mdrangepolicy( {0,0,0}, {N0,N1,N2}, {T0,T1,T2} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 3 LR", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k) {
-          dv(i,j,k) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 3 LR", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k) {
+            dv(i, j, k) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k) != ( ( ti + tj*NT0 + tk*NT0*NT1 )*FT + ( i*T1*T2 + j*T2 + k ) + 1 ) ) { ++counter_inc; }
-        } } }
-      } } }
+      long counter_inc     = 0;
+
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter_subview;
+                  }
+                  if (tile_subview(i, j, k) !=
+                      ((ti + tj * NT0 + tk * NT0 * NT1) * FT +
+                       (i * T1 * T2 + j * T2 + k) + 1)) {
+                    ++counter_inc;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create RR View
     {
-      typedef Kokkos::View< Scalar***, LayoutRR_3D_2x4x4, ExecSpace > ViewType;
-      Kokkos::View< Scalar***, LayoutRR_3D_2x4x4, ExecSpace > dv("dv", N0, N1, N2);
+      typedef Kokkos::View<Scalar***, LayoutRR_3D_2x4x4, ExecSpace> ViewType;
+      Kokkos::View<Scalar***, LayoutRR_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
+                                                               N2);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i*T1*T2 + j*T2 + k );
-        } } }
-      } } }
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                      (i * T1 * T2 + j * T2 + k);
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<3, Kokkos::Iterate::Right, Kokkos::Iterate::Right>, ExecSpace > mdrangepolicy( {0,0,0}, {N0,N1,N2}, {T0,T1,T2} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<3, Kokkos::Iterate::Right, Kokkos::Iterate::Right>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 3 RR", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k) {
-          dv(i,j,k) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 3 RR", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k) {
+            dv(i, j, k) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k) != ( ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i*T1*T2 + j*T2 + k ) + 1 ) ) { ++counter_inc; }
-        } } }
-      } } }
+      long counter_inc     = 0;
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter_subview;
+                  }
+                  if (tile_subview(i, j, k) !=
+                      ((ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                       (i * T1 * T2 + j * T2 + k) + 1)) {
+                    ++counter_inc;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 #endif
 #endif
-  } // end test_view_layout_tiled_3d
+  }  // end test_view_layout_tiled_3d
 
+  static void test_view_layout_tiled_4d(const int N0, const int N1,
+                                        const int N2, const int N3) {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+    const int FT = T0 * T1 * T2 * T3;
 
-  static void test_view_layout_tiled_4d( const int N0, const int N1, const int N2, const int N3 )
-  {
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-    const int FT = T0*T1*T2*T3;
-
-    const int NT0 = int( std::ceil( N0 / T0 ) );
-    const int NT1 = int( std::ceil( N1 / T1 ) );
-    const int NT2 = int( std::ceil( N2 / T2 ) );
-    const int NT3 = int( std::ceil( N3 / T3 ) );
+    const int NT0 = int(std::ceil(N0 / T0));
+    const int NT1 = int(std::ceil(N1 / T1));
+    const int NT2 = int(std::ceil(N2 / T2));
+    const int NT3 = int(std::ceil(N3 / T3));
 
     // Create LL View
     {
-      typedef Kokkos::View< Scalar****, LayoutLL_4D_2x4x4x2, ExecSpace > ViewType;
-      Kokkos::View< Scalar****, LayoutLL_4D_2x4x4x2, ExecSpace > dv("dv", N0, N1, N2, N3);
+      typedef Kokkos::View<Scalar****, LayoutLL_4D_2x4x4x2, ExecSpace> ViewType;
+      Kokkos::View<Scalar****, LayoutLL_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
+                                                                  N2, N3);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti + tj*NT0 + tk*N0*N1 + tl*N0*N1*N2 )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 );
-        } } } }
-      } } } }
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti + tj * NT0 + tk * N0 * N1 + tl * N0 * N1 * N2) *
+                              FT +
+                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<4, Kokkos::Iterate::Left, Kokkos::Iterate::Left>, ExecSpace > mdrangepolicy( {0,0,0,0}, {N0,N1,N2,N3}, {T0,T1,T2,T3} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<4, Kokkos::Iterate::Left, Kokkos::Iterate::Left>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 4 LL", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k, const int l) {
-          dv(i,j,k,l) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 4 LL", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
+            dv(i, j, k, l) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k,l) != ( ( ti + tj*NT0 + tk*N0*N1 + tl*N0*N1*N2 )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 ) + 1 ) ) { ++counter_inc; }
-        } } } }
-      } } } }
+      long counter_inc     = 0;
+
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter_subview;
+                      }
+                      if (tile_subview(i, j, k, l) !=
+                          ((ti + tj * NT0 + tk * N0 * N1 + tl * N0 * N1 * N2) *
+                               FT +
+                           (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2) + 1)) {
+                        ++counter_inc;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create RL View
     {
-      typedef Kokkos::View< Scalar****, LayoutRL_4D_2x4x4x2, ExecSpace > ViewType;
-      Kokkos::View< Scalar****, LayoutRL_4D_2x4x4x2, ExecSpace > dv("dv", N0, N1, N2, N3);
+      typedef Kokkos::View<Scalar****, LayoutRL_4D_2x4x4x2, ExecSpace> ViewType;
+      Kokkos::View<Scalar****, LayoutRL_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
+                                                                  N2, N3);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti*NT1*NT2*N3 + tj*NT2*N3 + tk*N3 + tl )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 );
-        } } } }
-      } } } }
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 + tl) *
+                              FT +
+                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<4, Kokkos::Iterate::Right, Kokkos::Iterate::Left>, ExecSpace > mdrangepolicy( {0,0,0,0}, {N0,N1,N2,N3}, {T0,T1,T2,T3} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<4, Kokkos::Iterate::Right, Kokkos::Iterate::Left>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 4 RL", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k, const int l) {
-          dv(i,j,k,l) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 4 RL", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
+            dv(i, j, k, l) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k,l) != ( ( ti*NT1*NT2*N3 + tj*NT2*N3 + tk*N3 + tl )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 ) + 1 ) ) { ++counter_inc; }
-        } } } }
-      } } } }
+      long counter_inc     = 0;
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter_subview;
+                      }
+                      if (tile_subview(i, j, k, l) !=
+                          ((ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 +
+                            tl) *
+                               FT +
+                           (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2) + 1)) {
+                        ++counter_inc;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create LR View
     {
-      typedef Kokkos::View< Scalar****, LayoutLR_4D_2x4x4x2, ExecSpace > ViewType;
-      Kokkos::View< Scalar****, LayoutLR_4D_2x4x4x2, ExecSpace > dv("dv", N0, N1, N2, N3);
+      typedef Kokkos::View<Scalar****, LayoutLR_4D_2x4x4x2, ExecSpace> ViewType;
+      Kokkos::View<Scalar****, LayoutLR_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
+                                                                  N2, N3);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti + tj*NT0 + tk*NT0*NT1 + tl*NT0*NT1*NT2 )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l );
-        } } } }
-      } } } }
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti + tj * NT0 + tk * NT0 * NT1 +
+                           tl * NT0 * NT1 * NT2) *
+                              FT +
+                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<4, Kokkos::Iterate::Left, Kokkos::Iterate::Right>, ExecSpace > mdrangepolicy( {0,0,0,0}, {N0,N1,N2,N3}, {T0,T1,T2,T3} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<4, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 4 LR", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k, const int l) {
-          dv(i,j,k,l) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 4 LR", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
+            dv(i, j, k, l) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k,l) != ( ( ti + tj*NT0 + tk*NT0*NT1 + tl*NT0*NT1*NT2 )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l ) + 1 ) ) { ++counter_inc; }
-        } } } }
-      } } } }
+      long counter_inc     = 0;
+
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter_subview;
+                      }
+                      if (tile_subview(i, j, k, l) !=
+                          ((ti + tj * NT0 + tk * NT0 * NT1 +
+                            tl * NT0 * NT1 * NT2) *
+                               FT +
+                           (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l) + 1)) {
+                        ++counter_inc;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 
     // Create RR View
     {
-      typedef Kokkos::View< Scalar****, LayoutRR_4D_2x4x4x2, ExecSpace > ViewType;
-      Kokkos::View< Scalar****, LayoutRR_4D_2x4x4x2, ExecSpace > dv("dv", N0, N1, N2, N3);
+      typedef Kokkos::View<Scalar****, LayoutRR_4D_2x4x4x2, ExecSpace> ViewType;
+      Kokkos::View<Scalar****, LayoutRR_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
+                                                                  N2, N3);
 
       typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
 
       // Initialize on host
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti*NT1*NT2*NT3 + tj*NT2*NT3 + tk*NT3 + tl )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l );
-        } } } }
-      } } } }
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
+                           tl) *
+                              FT +
+                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
 
       // copy to device
       Kokkos::deep_copy(dv, v);
 
-      Kokkos::MDRangePolicy< Kokkos::Rank<4, Kokkos::Iterate::Right, Kokkos::Iterate::Right>, ExecSpace > mdrangepolicy( {0,0,0,0}, {N0,N1,N2,N3}, {T0,T1,T2,T3} );
+      Kokkos::MDRangePolicy<
+          Kokkos::Rank<4, Kokkos::Iterate::Right, Kokkos::Iterate::Right>,
+          ExecSpace>
+          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
 
       // iterate by tile
-      Kokkos::parallel_for( "ViewTile rank 4 RR", mdrangepolicy, 
-        KOKKOS_LAMBDA (const int i, const int j, const int k, const int l) {
-          dv(i,j,k,l) += 1;
-        });
+      Kokkos::parallel_for(
+          "ViewTile rank 4 RR", mdrangepolicy,
+          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
+            dv(i, j, k, l) += 1;
+          });
 
       Kokkos::deep_copy(v, dv);
 
       long counter_subview = 0;
-      long counter_inc = 0;
-
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter_subview; }
-          if ( tile_subview(i,j,k,l) != ( ( ti*NT1*NT2*NT3 + tj*NT2*NT3 + tk*NT3 + tl )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l ) + 1 ) ) { ++counter_inc; }
-        } } } }
-      } } } }
+      long counter_inc     = 0;
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter_subview;
+                      }
+                      if (tile_subview(i, j, k, l) !=
+                          ((ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
+                            tl) *
+                               FT +
+                           (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l) + 1)) {
+                        ++counter_inc;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       ASSERT_EQ(counter_subview, long(0));
       ASSERT_EQ(counter_inc, long(0));
-    } // end scope
+    }  // end scope
 #endif
 #endif
-  } // end test_view_layout_tiled_4d
-
+  }  // end test_view_layout_tiled_4d
 
-  static void test_view_layout_tiled_subtile_2d( const int N0, const int N1 )
-  {
-    const int FT = T0*T1;
+  static void test_view_layout_tiled_subtile_2d(const int N0, const int N1) {
+    const int FT = T0 * T1;
 
-    const int NT0 = int( std::ceil( N0 / T0 ) );
-    const int NT1 = int( std::ceil( N1 / T1 ) );
+    const int NT0 = int(std::ceil(N0 / T0));
+    const int NT1 = int(std::ceil(N1 / T1));
 
     // Counter to check for errors at the end
     long counter[4] = {0};
 
     // Create LL View
     {
-      Kokkos::View< Scalar**, LayoutLL_2D_2x4, Kokkos::HostSpace > v("v", N0, N1);
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j) = ( ti + tj*NT0 )*FT + ( i + j*T0 );
-        } }
-      } }
-
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj );
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j) != v(ti*T0+i, tj*T1+j) ) { ++counter[0]; }
+      Kokkos::View<Scalar**, LayoutLL_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              v(ti * T0 + i, tj * T1 + j) = (ti + tj * NT0) * FT + (i + j * T0);
+            }
+          }
+        }
+      }
+
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
+                ++counter[0];
+              }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1 = " << ti*T0 + i << "," << tj*T1 + j << std::endl;
-          std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << "," << j << "  v = " << v(ti*T0 + i, tj*T1+j) << "  flat idx = " << ( ti + tj*NT0 )*FT + ( i + j*T0 ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j) << std::endl;
+              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
+                        << std::endl;
+              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
+                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
+                        << "  flat idx = "
+                        << (ti + tj * NT0) * FT + (i + j * T0) << std::endl;
+              std::cout << "subview_tile output = " << tile_subview(i, j)
+                        << std::endl;
 #endif
-        } }
-      } }
-    } // end scope
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create RL View
     {
-      Kokkos::View< Scalar**, LayoutRL_2D_2x4, Kokkos::HostSpace > v("v", N0, N1);
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j) = ( ti*NT1 + tj )*FT + ( i + j*T0 );
-        } }
-      } }
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj );
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j) != v(ti*T0+i, tj*T1+j) ) { ++counter[1]; }
+      Kokkos::View<Scalar**, LayoutRL_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              v(ti * T0 + i, tj * T1 + j) = (ti * NT1 + tj) * FT + (i + j * T0);
+            }
+          }
+        }
+      }
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
+          for (int j = 0; j < T1; ++j) {
+            for (int i = 0; i < T0; ++i) {
+              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
+                ++counter[1];
+              }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1 = " << ti*T0 + i << "," << tj*T1 + j << std::endl;
-          std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << "," << j << "  v = " << v(ti*T0 + i, tj*T1+j) << "  flat idx = " << ( ti*NT1 + tj )*FT + ( i + j*T0 ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j) << std::endl;
+              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
+                        << std::endl;
+              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
+                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
+                        << "  flat idx = "
+                        << (ti * NT1 + tj) * FT + (i + j * T0) << std::endl;
+              std::cout << "subview_tile output = " << tile_subview(i, j)
+                        << std::endl;
 #endif
-        } }
-      } }
-    } // end scope
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create LR View
     {
-      Kokkos::View< Scalar**, LayoutLR_2D_2x4, Kokkos::HostSpace > v("v", N0, N1);
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          v(ti*T0 + i, tj*T1+j) = ( ti + tj*NT0 )*FT + ( i*T1 + j );
-        } }
-      } }
-
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          if ( tile_subview(i,j) != v(ti*T0+i, tj*T1+j) ) { ++counter[2]; }
+      Kokkos::View<Scalar**, LayoutLR_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              v(ti * T0 + i, tj * T1 + j) = (ti + tj * NT0) * FT + (i * T1 + j);
+            }
+          }
+        }
+      }
+
+      for (int tj = 0; tj < NT1; ++tj) {
+        for (int ti = 0; ti < NT0; ++ti) {
+          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
+                ++counter[2];
+              }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1 = " << ti*T0 + i << "," << tj*T1 + j << std::endl;
-          std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << "," << j << "  v = " << v(ti*T0 + i, tj*T1+j) << "  flat idx = " << ( ti + tj*NT0 )*FT + ( i*T1 + j ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j) << std::endl;
+              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
+                        << std::endl;
+              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
+                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
+                        << "  flat idx = "
+                        << (ti + tj * NT0) * FT + (i * T1 + j) << std::endl;
+              std::cout << "subview_tile output = " << tile_subview(i, j)
+                        << std::endl;
 #endif
-        } }
-      } }
-    } // end scope
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create RR View
     {
-      Kokkos::View< Scalar**, LayoutRR_2D_2x4, Kokkos::HostSpace > v("v", N0, N1);
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          v(ti*T0 + i, tj*T1+j) = ( ti*NT1 + tj )*FT + ( i*T1 + j );
-        } }
-      } }
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-          if ( tile_subview(i,j) != v(ti*T0+i, tj*T1+j) ) { ++counter[3]; }
+      Kokkos::View<Scalar**, LayoutRR_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              v(ti * T0 + i, tj * T1 + j) = (ti * NT1 + tj) * FT + (i * T1 + j);
+            }
+          }
+        }
+      }
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
+          for (int i = 0; i < T0; ++i) {
+            for (int j = 0; j < T1; ++j) {
+              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
+                ++counter[3];
+              }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1 = " << ti*T0 + i << "," << tj*T1 + j << std::endl;
-          std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << "," << j << "  v = " << v(ti*T0 + i, tj*T1+j) << "  flat idx = " << ( ti*NT1 + tj )*FT + ( i*T1 + j ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
+                        << std::endl;
+              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
+                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
+                        << "  flat idx = "
+                        << (ti * NT1 + tj) * FT + (i * T1 + j) << std::endl;
+              std::cout << "subview_tile output = " << tile_subview(i, j)
+                        << std::endl;
+              std::cout << "subview tile rank = " << Kokkos::rank(tile_subview)
+                        << std::endl;
 #endif
-        } }
-      } }
-    } // end scope
+            }
+          }
+        }
+      }
+    }  // end scope
 
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
     std::cout << "subview_tile vs view errors:\n"
-      << " LL: " << counter[0]
-      << " RL: " << counter[1]
-      << " LR: " << counter[2]
-      << " RR: " << counter[3] 
-      << std::endl;
+              << " LL: " << counter[0] << " RL: " << counter[1]
+              << " LR: " << counter[2] << " RR: " << counter[3] << std::endl;
 #endif
 
     ASSERT_EQ(counter[0], long(0));
     ASSERT_EQ(counter[1], long(0));
     ASSERT_EQ(counter[2], long(0));
     ASSERT_EQ(counter[3], long(0));
-  } // end test_view_layout_tiled_subtile_2d
-
+  }  // end test_view_layout_tiled_subtile_2d
 
-  static void test_view_layout_tiled_subtile_3d( const int N0, const int N1, const int N2 )
-  {
+  static void test_view_layout_tiled_subtile_3d(const int N0, const int N1,
+                                                const int N2) {
+    const int FT = T0 * T1 * T2;
 
-    const int FT = T0*T1*T2;
-
-    const int NT0 = int( std::ceil( N0 / T0 ) );
-    const int NT1 = int( std::ceil( N1 / T1 ) );
-    const int NT2 = int( std::ceil( N2 / T2 ) );
+    const int NT0 = int(std::ceil(N0 / T0));
+    const int NT1 = int(std::ceil(N1 / T1));
+    const int NT2 = int(std::ceil(N2 / T2));
 
     // Counter to check for errors at the end
     long counter[4] = {0};
     // Create LL View
     {
-      Kokkos::View< Scalar***, LayoutLL_3D_2x4x4, Kokkos::HostSpace > v("v", N0, N1, N2);
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti + tj*NT0 + tk*N0*N1 )*FT + ( i + j*T0 + k*T0*T1 );
-        } } }
-      } } }
-
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter[0]; }
+      Kokkos::View<Scalar***, LayoutLL_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
+                                                                      N1, N2);
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti + tj * NT0 + tk * N0 * N1) * FT +
+                      (i + j * T0 + k * T0 * T1);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter[0];
+                  }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << std::endl;
-          std::cout << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk << "," << i << "," << j << "," << k << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k) << "  flat idx = " << ( ti + tj*NT0 + tk*N0*N1 )*FT + ( i + j*T0 + k*T0*T1 ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
+                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
+                  std::cout
+                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
+                      << "," << i << "," << j << "," << k
+                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
+                      << "  flat idx = "
+                      << (ti + tj * NT0 + tk * N0 * N1) * FT +
+                             (i + j * T0 + k * T0 * T1)
+                      << std::endl;
+                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
+                            << std::endl;
+                  std::cout
+                      << "subview tile rank = " << Kokkos::rank(tile_subview)
+                      << std::endl;
 #endif
-        } } }
-      } } }
-    } // end scope
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create RL View
     {
-      Kokkos::View< Scalar***, LayoutRL_3D_2x4x4, Kokkos::HostSpace > v("v", N0, N1, N2);
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i + j*T0 + k*T0*T1 );
-        } } }
-      } } }
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter[1]; }
+      Kokkos::View<Scalar***, LayoutRL_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
+                                                                      N1, N2);
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                      (i + j * T0 + k * T0 * T1);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int k = 0; k < T2; ++k) {
+              for (int j = 0; j < T1; ++j) {
+                for (int i = 0; i < T0; ++i) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter[1];
+                  }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << std::endl;
-          std::cout << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk << "," << i << "," << j << "," << k << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k) << "  flat idx = " << ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i + j*T0 + k*T0*T1 ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k) << std::endl;
+                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
+                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
+                  std::cout
+                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
+                      << "," << i << "," << j << "," << k
+                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
+                      << "  flat idx = "
+                      << (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                             (i + j * T0 + k * T0 * T1)
+                      << std::endl;
+                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
+                            << std::endl;
 #endif
-        } } }
-      } } }
-    } // end scope
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create LR View
     {
-      Kokkos::View< Scalar***, LayoutLR_3D_2x4x4, Kokkos::HostSpace > v("v", N0, N1, N2);
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti + tj*NT0 + tk*NT0*NT1 )*FT + ( i*T1*T2 + j*T2 + k );
-        } } }
-      } } }
-
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter[2]; }
+      Kokkos::View<Scalar***, LayoutLR_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
+                                                                      N1, N2);
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti + tj * NT0 + tk * NT0 * NT1) * FT +
+                      (i * T1 * T2 + j * T2 + k);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int tk = 0; tk < NT2; ++tk) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int ti = 0; ti < NT0; ++ti) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter[2];
+                  }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << std::endl;
-          std::cout << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk << "," << i << "," << j << "," << k << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k) << "  flat idx = " << ( ti + tj*NT0 + tk*NT0*NT1 )*FT + ( i*T1*T2 + j*T2 + k ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
+                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
+                  std::cout
+                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
+                      << "," << i << "," << j << "," << k
+                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
+                      << "  flat idx = "
+                      << (ti + tj * NT0 + tk * NT0 * NT1) * FT +
+                             (i * T1 * T2 + j * T2 + k)
+                      << std::endl;
+                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
+                            << std::endl;
+                  std::cout
+                      << "subview tile rank = " << Kokkos::rank(tile_subview)
+                      << std::endl;
 #endif
-        } } }
-      } } }
-    } // end scope
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create RR View
     {
-      Kokkos::View< Scalar***, LayoutRR_3D_2x4x4, Kokkos::HostSpace > v("v", N0, N1, N2);
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k) = ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i*T1*T2 + j*T2 + k );
-        } } }
-      } } }
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-          if ( tile_subview(i,j,k) != v(ti*T0+i, tj*T1+j, tk*T2+k) ) { ++counter[3]; }
+      Kokkos::View<Scalar***, LayoutRR_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
+                                                                      N1, N2);
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
+                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                      (i * T1 * T2 + j * T2 + k);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
+            for (int i = 0; i < T0; ++i) {
+              for (int j = 0; j < T1; ++j) {
+                for (int k = 0; k < T2; ++k) {
+                  if (tile_subview(i, j, k) !=
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
+                    ++counter[3];
+                  }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << std::endl;
-          std::cout << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk << "," << i << "," << j << "," << k << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k) << "  flat idx = " << ( ti*NT1*NT2 + tj*NT2 + tk )*FT + ( i*T1*T2 + j*T2 + k ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
+                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
+                  std::cout
+                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
+                      << "," << i << "," << j << "," << k
+                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
+                      << "  flat idx = "
+                      << (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
+                             (i * T1 * T2 + j * T2 + k)
+                      << std::endl;
+                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
+                            << std::endl;
+                  std::cout
+                      << "subview tile rank = " << Kokkos::rank(tile_subview)
+                      << std::endl;
 #endif
-        } } }
-      } } }
-    } // end scope
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
     std::cout << "subview_tile vs view errors:\n"
-      << " LL: " << counter[0]
-      << " RL: " << counter[1]
-      << " LR: " << counter[2]
-      << " RR: " << counter[3] 
-      << std::endl;
+              << " LL: " << counter[0] << " RL: " << counter[1]
+              << " LR: " << counter[2] << " RR: " << counter[3] << std::endl;
 #endif
 
     ASSERT_EQ(counter[0], long(0));
@@ -1011,179 +1444,307 @@ struct TestViewLayoutTiled {
     ASSERT_EQ(counter[2], long(0));
     ASSERT_EQ(counter[3], long(0));
 
-  } // end test_view_layout_tiled_subtile_3d
-
+  }  // end test_view_layout_tiled_subtile_3d
 
-  static void test_view_layout_tiled_subtile_4d( const int N0, const int N1, const int N2, const int N3 )
-  {
-    const int FT = T0*T1*T2*T3;
+  static void test_view_layout_tiled_subtile_4d(const int N0, const int N1,
+                                                const int N2, const int N3) {
+    const int FT = T0 * T1 * T2 * T3;
 
-    const int NT0 = int( std::ceil( N0 / T0 ) );
-    const int NT1 = int( std::ceil( N1 / T1 ) );
-    const int NT2 = int( std::ceil( N2 / T2 ) );
-    const int NT3 = int( std::ceil( N3 / T3 ) );
+    const int NT0 = int(std::ceil(N0 / T0));
+    const int NT1 = int(std::ceil(N1 / T1));
+    const int NT2 = int(std::ceil(N2 / T2));
+    const int NT3 = int(std::ceil(N3 / T3));
 
     // Counter to check for errors at the end
     long counter[4] = {0};
     // Create LL View
     {
-      Kokkos::View< Scalar****, LayoutLL_4D_2x4x4x2, Kokkos::HostSpace > v("v", N0, N1, N2, N3);
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti + tj*NT0 + tk*N0*N1 + tl*N0*N1*N2 )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 );
-        } } } }
-      } } } }
-
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter[0]; }
+      Kokkos::View<Scalar****, LayoutLL_4D_2x4x4x2, Kokkos::HostSpace> v(
+          "v", N0, N1, N2, N3);
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti + tj * NT0 + tk * N0 * N1 + tl * N0 * N1 * N2) *
+                              FT +
+                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter[0];
+                      }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2,idx3 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << "," << tl*T3 + l<< std::endl;
-          std::cout << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk << "," << tl << ","
-          << "  i,j,k,l: " <<  i << "," << j << "," << k << "," << l
-          << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) 
-          << "  flat idx = " << ( ti + tj*NT0 + tk*N0*N1 + tl*N0*N1*N2 )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k,l) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
+                                << "," << tj * T1 + j << "," << tk * T2 + k
+                                << "," << tl * T3 + l << std::endl;
+                      std::cout
+                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
+                          << "," << tl << ","
+                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
+                          << l << "  v = "
+                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                               tl * T3 + l)
+                          << "  flat idx = "
+                          << (ti + tj * NT0 + tk * N0 * N1 +
+                              tl * N0 * N1 * N2) *
+                                     FT +
+                                 (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2)
+                          << std::endl;
+                      std::cout << "subview_tile output = "
+                                << tile_subview(i, j, k, l) << std::endl;
+                      std::cout << "subview tile rank = "
+                                << Kokkos::rank(tile_subview) << std::endl;
 #endif
-        } } } }
-      } } } }
-    } // end scope
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create RL View
     {
-      Kokkos::View< Scalar****, LayoutRL_4D_2x4x4x2, Kokkos::HostSpace > v("v", N0, N1, N2, N3);
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti*NT1*NT2*N3 + tj*NT2*N3 + tk*N3 + tl )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 );
-        } } } }
-      } } } }
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int l = 0; l < T3; ++l ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int i = 0; i < T0; ++i ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter[1]; }
+      Kokkos::View<Scalar****, LayoutRL_4D_2x4x4x2, Kokkos::HostSpace> v(
+          "v", N0, N1, N2, N3);
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 + tl) *
+                              FT +
+                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int l = 0; l < T3; ++l) {
+                for (int k = 0; k < T2; ++k) {
+                  for (int j = 0; j < T1; ++j) {
+                    for (int i = 0; i < T0; ++i) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter[1];
+                      }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2,idx3 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << "," << tl*T3 + l<< std::endl;
-          std::cout << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk << "," << tl << ","
-          << "  i,j,k,l: " <<  i << "," << j << "," << k << "," << l
-          << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) 
-          << "  flat idx = " << ( ti*NT1*NT2*N3 + tj*NT2*N3 + tk*N3 + tl )*FT + ( i + j*T0 + k*T0*T1 + l*T0*T1*T2 ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k,l) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
+                                << "," << tj * T1 + j << "," << tk * T2 + k
+                                << "," << tl * T3 + l << std::endl;
+                      std::cout
+                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
+                          << "," << tl << ","
+                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
+                          << l << "  v = "
+                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                               tl * T3 + l)
+                          << "  flat idx = "
+                          << (ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 +
+                              tl) * FT +
+                                 (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2)
+                          << std::endl;
+                      std::cout << "subview_tile output = "
+                                << tile_subview(i, j, k, l) << std::endl;
+                      std::cout << "subview tile rank = "
+                                << Kokkos::rank(tile_subview) << std::endl;
 #endif
-        } } } }
-      } } } }
-    } // end scope
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create LR View
     {
-      Kokkos::View< Scalar****, LayoutLR_4D_2x4x4x2, Kokkos::HostSpace > v("v", N0, N1, N2, N3);
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti + tj*NT0 + tk*NT0*NT1 + tl*NT0*NT1*NT2 )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l );
-        } } } }
-      } } } }
-
-      for ( int tl = 0; tl < NT3; ++tl ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int ti = 0; ti < NT0; ++ti ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter[2]; }
+      Kokkos::View<Scalar****, LayoutLR_4D_2x4x4x2, Kokkos::HostSpace> v(
+          "v", N0, N1, N2, N3);
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti + tj * NT0 + tk * NT0 * NT1 +
+                           tl * NT0 * NT1 * NT2) *
+                              FT +
+                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int tl = 0; tl < NT3; ++tl) {
+        for (int tk = 0; tk < NT2; ++tk) {
+          for (int tj = 0; tj < NT1; ++tj) {
+            for (int ti = 0; ti < NT0; ++ti) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter[2];
+                      }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2,idx3 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << "," << tl*T3 + l<< std::endl;
-          std::cout << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk << "," << tl << ","
-          << "  i,j,k,l: " <<  i << "," << j << "," << k << "," << l
-          << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) 
-          << "  flat idx = " << ( ti + tj*NT0 + tk*NT0*NT1 + tl*NT0*NT1*NT2 )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k,l) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
+                                << "," << tj * T1 + j << "," << tk * T2 + k
+                                << "," << tl * T3 + l << std::endl;
+                      std::cout
+                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
+                          << "," << tl << ","
+                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
+                          << l << "  v = "
+                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                               tl * T3 + l)
+                          << "  flat idx = "
+                          << (ti + tj * NT0 + tk * NT0 * NT1 +
+                              tl * NT0 * NT1 * NT2) *
+                                     FT +
+                                 (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l)
+                          << std::endl;
+                      std::cout << "subview_tile output = "
+                                << tile_subview(i, j, k, l) << std::endl;
+                      std::cout << "subview tile rank = "
+                                << Kokkos::rank(tile_subview) << std::endl;
 #endif
-        } } } }
-      } } } }
-    } // end scope
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
     // Create RR View
     {
-      Kokkos::View< Scalar****, LayoutRR_4D_2x4x4x2, Kokkos::HostSpace > v("v", N0, N1, N2, N3);
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) = ( ti*NT1*NT2*NT3 + tj*NT2*NT3 + tk*NT3 + tl )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l );
-        } } } }
-      } } } }
-
-      for ( int ti = 0; ti < NT0; ++ti ) {
-      for ( int tj = 0; tj < NT1; ++tj ) {
-      for ( int tk = 0; tk < NT2; ++tk ) {
-      for ( int tl = 0; tl < NT3; ++tl ) {
-        auto tile_subview = Kokkos::tile_subview( v, ti, tj, tk, tl );
-        for ( int i = 0; i < T0; ++i ) {
-        for ( int j = 0; j < T1; ++j ) {
-        for ( int k = 0; k < T2; ++k ) {
-        for ( int l = 0; l < T3; ++l ) {
-          if ( tile_subview(i,j,k,l) != v(ti*T0+i, tj*T1+j, tk*T2+k, tl*T3 + l) ) { ++counter[3]; }
+      Kokkos::View<Scalar****, LayoutRR_4D_2x4x4x2, Kokkos::HostSpace> v(
+          "v", N0, N1, N2, N3);
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
+                          (ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
+                           tl) *
+                              FT +
+                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      for (int ti = 0; ti < NT0; ++ti) {
+        for (int tj = 0; tj < NT1; ++tj) {
+          for (int tk = 0; tk < NT2; ++tk) {
+            for (int tl = 0; tl < NT3; ++tl) {
+              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
+              for (int i = 0; i < T0; ++i) {
+                for (int j = 0; j < T1; ++j) {
+                  for (int k = 0; k < T2; ++k) {
+                    for (int l = 0; l < T3; ++l) {
+                      if (tile_subview(i, j, k, l) !=
+                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                            tl * T3 + l)) {
+                        ++counter[3];
+                      }
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-          std::cout << "idx0,idx1,idx2,idx3 = " << ti*T0 + i << "," << tj*T1 + j << "," << tk*T2 + k << "," << tl*T3 + l<< std::endl;
-          std::cout << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk << "," << tl << ","
-          << "  i,j,k,l: " <<  i << "," << j << "," << k << "," << l
-          << "  v = " << v(ti*T0 + i, tj*T1+j, tk*T2 + k, tl*T3 + l) 
-          << "  flat idx = " << ( ti*NT1*NT2*NT3 + tj*NT2*NT3 + tk*NT3 + tl )*FT + ( i*T1*T2*T3 + j*T2*T3 + k*T3 + l ) << std::endl;
-          std::cout << "subview_tile output = " << tile_subview(i,j,k,l) << std::endl;
-          std::cout << "subview tile rank = " << Kokkos::rank(tile_subview) << std::endl;
+                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
+                                << "," << tj * T1 + j << "," << tk * T2 + k
+                                << "," << tl * T3 + l << std::endl;
+                      std::cout
+                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
+                          << "," << tl << ","
+                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
+                          << l << "  v = "
+                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
+                               tl * T3 + l)
+                          << "  flat idx = "
+                          << (ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
+                              tl) * FT +
+                                 (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l)
+                          << std::endl;
+                      std::cout << "subview_tile output = "
+                                << tile_subview(i, j, k, l) << std::endl;
+                      std::cout << "subview tile rank = "
+                                << Kokkos::rank(tile_subview) << std::endl;
 #endif
-        } } } }
-      } } } }
-    } // end scope
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }  // end scope
 
 #ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
     std::cout << "subview_tile vs view errors:\n"
-      << " LL: " << counter[0]
-      << " RL: " << counter[1]
-      << " LR: " << counter[2]
-      << " RR: " << counter[3] 
-      << std::endl;
+              << " LL: " << counter[0] << " RL: " << counter[1]
+              << " LR: " << counter[2] << " RR: " << counter[3] << std::endl;
 #endif
 
     ASSERT_EQ(counter[0], long(0));
@@ -1191,25 +1752,29 @@ struct TestViewLayoutTiled {
     ASSERT_EQ(counter[2], long(0));
     ASSERT_EQ(counter[3], long(0));
 
-  } // end test_view_layout_tiled_subtile_4d
+  }  // end test_view_layout_tiled_subtile_4d
 
-}; // end TestViewLayoutTiled struct
+};  // end TestViewLayoutTiled struct
 
-} // namespace
+}  // namespace
 
-TEST_F( TEST_CATEGORY , view_layouttiled) {
-  // These two examples are iterating by tile, then within a tile - not by extents
-  // If N# is not a power of two, but want to iterate by tile then within a tile, need to check that mapped index is within extent
-  TestViewLayoutTiled< TEST_EXECSPACE >::test_view_layout_tiled_2d( 4, 12 );
-  TestViewLayoutTiled< TEST_EXECSPACE >::test_view_layout_tiled_3d( 4, 12, 16 );
-  TestViewLayoutTiled< TEST_EXECSPACE >::test_view_layout_tiled_4d( 4, 12, 16, 12 );
+TEST(TEST_CATEGORY, view_layouttiled) {
+  // These two examples are iterating by tile, then within a tile - not by
+  // extents If N# is not a power of two, but want to iterate by tile then
+  // within a tile, need to check that mapped index is within extent
+  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_2d(4, 12);
+  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_3d(4, 12, 16);
+  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_4d(4, 12, 16, 12);
 }
-TEST_F( TEST_CATEGORY , view_layouttiled_subtile) {
-  // These two examples are iterating by tile, then within a tile - not by extents
-  // If N# is not a power of two, but want to iterate by tile then within a tile, need to check that mapped index is within extent
-  TestViewLayoutTiled< TEST_EXECSPACE >::test_view_layout_tiled_subtile_2d( 4, 12 );
-  TestViewLayoutTiled< TEST_EXECSPACE >::test_view_layout_tiled_subtile_3d( 4, 12, 16 );
-  TestViewLayoutTiled< TEST_EXECSPACE >::test_view_layout_tiled_subtile_4d( 4, 12, 16, 12 );
+TEST(TEST_CATEGORY, view_layouttiled_subtile) {
+  // These two examples are iterating by tile, then within a tile - not by
+  // extents If N# is not a power of two, but want to iterate by tile then
+  // within a tile, need to check that mapped index is within extent
+  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_subtile_2d(4, 12);
+  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_subtile_3d(4, 12,
+                                                                         16);
+  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_subtile_4d(
+      4, 12, 16, 12);
 }
 #endif
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewMapping_a.hpp b/lib/kokkos/core/unit_test/TestViewMapping_a.hpp
index 69247902cd092db8c354998194c7bcc82799c04f..5e27cc5e51fac77c2f69e827f6ff2dc8f27d09c3 100644
--- a/lib/kokkos/core/unit_test/TestViewMapping_a.hpp
+++ b/lib/kokkos/core/unit_test/TestViewMapping_a.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,222 +52,224 @@
 
 namespace Test {
 
-template< class Space >
-void test_view_mapping()
-{
+template <class Space>
+void test_view_mapping() {
   typedef typename Space::execution_space ExecSpace;
 
-  typedef Kokkos::Impl::ViewDimension<>  dim_0;
-  typedef Kokkos::Impl::ViewDimension< 2 > dim_s2;
-  typedef Kokkos::Impl::ViewDimension< 2, 3 > dim_s2_s3;
-  typedef Kokkos::Impl::ViewDimension< 2, 3, 4 > dim_s2_s3_s4;
+  typedef Kokkos::Impl::ViewDimension<> dim_0;
+  typedef Kokkos::Impl::ViewDimension<2> dim_s2;
+  typedef Kokkos::Impl::ViewDimension<2, 3> dim_s2_s3;
+  typedef Kokkos::Impl::ViewDimension<2, 3, 4> dim_s2_s3_s4;
 
-  typedef Kokkos::Impl::ViewDimension< 0 > dim_s0;
-  typedef Kokkos::Impl::ViewDimension< 0, 3 > dim_s0_s3;
-  typedef Kokkos::Impl::ViewDimension< 0, 3, 4 > dim_s0_s3_s4;
+  typedef Kokkos::Impl::ViewDimension<0> dim_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 3> dim_s0_s3;
+  typedef Kokkos::Impl::ViewDimension<0, 3, 4> dim_s0_s3_s4;
 
-  typedef Kokkos::Impl::ViewDimension< 0, 0 > dim_s0_s0;
-  typedef Kokkos::Impl::ViewDimension< 0, 0, 4 > dim_s0_s0_s4;
+  typedef Kokkos::Impl::ViewDimension<0, 0> dim_s0_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 0, 4> dim_s0_s0_s4;
 
-  typedef Kokkos::Impl::ViewDimension< 0, 0, 0 > dim_s0_s0_s0;
-  typedef Kokkos::Impl::ViewDimension< 0, 0, 0, 0 > dim_s0_s0_s0_s0;
-  typedef Kokkos::Impl::ViewDimension< 0, 0, 0, 0, 0 > dim_s0_s0_s0_s0_s0;
-  typedef Kokkos::Impl::ViewDimension< 0, 0, 0, 0, 0, 0 > dim_s0_s0_s0_s0_s0_s0;
-  typedef Kokkos::Impl::ViewDimension< 0, 0, 0, 0, 0, 0, 0 > dim_s0_s0_s0_s0_s0_s0_s0;
-  typedef Kokkos::Impl::ViewDimension< 0, 0, 0, 0, 0, 0, 0, 0 > dim_s0_s0_s0_s0_s0_s0_s0_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 0, 0> dim_s0_s0_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 0, 0, 0> dim_s0_s0_s0_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 0, 0, 0, 0> dim_s0_s0_s0_s0_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 0, 0, 0, 0, 0> dim_s0_s0_s0_s0_s0_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 0, 0, 0, 0, 0, 0>
+      dim_s0_s0_s0_s0_s0_s0_s0;
+  typedef Kokkos::Impl::ViewDimension<0, 0, 0, 0, 0, 0, 0, 0>
+      dim_s0_s0_s0_s0_s0_s0_s0_s0;
 
   // Fully static dimensions should not be larger than an int.
-  ASSERT_LE( sizeof( dim_0 ), sizeof( int ) );
-  ASSERT_LE( sizeof( dim_s2 ), sizeof( int ) );
-  ASSERT_LE( sizeof( dim_s2_s3 ), sizeof( int ) );
-  ASSERT_LE( sizeof( dim_s2_s3_s4 ), sizeof( int ) );
+  ASSERT_LE(sizeof(dim_0), sizeof(int));
+  ASSERT_LE(sizeof(dim_s2), sizeof(int));
+  ASSERT_LE(sizeof(dim_s2_s3), sizeof(int));
+  ASSERT_LE(sizeof(dim_s2_s3_s4), sizeof(int));
 
   // Rank 1 is size_t.
-  ASSERT_EQ( sizeof( dim_s0 ), sizeof( size_t ) );
-  ASSERT_EQ( sizeof( dim_s0_s3 ), sizeof( size_t ) );
-  ASSERT_EQ( sizeof( dim_s0_s3_s4 ), sizeof( size_t ) );
+  ASSERT_EQ(sizeof(dim_s0), sizeof(size_t));
+  ASSERT_EQ(sizeof(dim_s0_s3), sizeof(size_t));
+  ASSERT_EQ(sizeof(dim_s0_s3_s4), sizeof(size_t));
 
   // Allow for padding.
-  ASSERT_LE( sizeof( dim_s0_s0 ), 2 * sizeof( size_t ) );
-  ASSERT_LE( sizeof( dim_s0_s0_s4 ), 2 * sizeof( size_t ) );
-
-  ASSERT_LE( sizeof( dim_s0_s0_s0 ), 4 * sizeof( size_t ) );
-  ASSERT_EQ( sizeof( dim_s0_s0_s0_s0 ), 4 * sizeof( unsigned ) );
-  ASSERT_LE( sizeof( dim_s0_s0_s0_s0_s0 ), 6 * sizeof( unsigned ) );
-  ASSERT_EQ( sizeof( dim_s0_s0_s0_s0_s0_s0 ), 6 * sizeof( unsigned ) );
-  ASSERT_LE( sizeof( dim_s0_s0_s0_s0_s0_s0_s0 ), 8 * sizeof( unsigned ) );
-  ASSERT_EQ( sizeof( dim_s0_s0_s0_s0_s0_s0_s0_s0 ), 8 * sizeof( unsigned ) );
-
-  static_assert( int( dim_0::rank ) == int( 0 ), "" );
-  static_assert( int( dim_0::rank_dynamic ) == int( 0 ), "" );
-  static_assert( int( dim_0::ArgN0 ) == 1, "" );
-  static_assert( int( dim_0::ArgN1 ) == 1, "" );
-  static_assert( int( dim_0::ArgN2 ) == 1, "" );
-
-  static_assert( int( dim_s2::rank ) == int( 1 ), "" );
-  static_assert( int( dim_s2::rank_dynamic ) == int( 0 ), "" );
-  static_assert( int( dim_s2::ArgN0 ) == 2, "" );
-  static_assert( int( dim_s2::ArgN1 ) == 1, "" );
-
-  static_assert( int( dim_s2_s3::rank ) == int( 2 ), "" );
-  static_assert( int( dim_s2_s3::rank_dynamic ) == int( 0 ), "" );
-  static_assert( int( dim_s2_s3::ArgN0 ) == 2, "" );
-  static_assert( int( dim_s2_s3::ArgN1 ) == 3, "" );
-  static_assert( int( dim_s2_s3::ArgN2 ) == 1, "" );
-
-  static_assert( int( dim_s2_s3_s4::rank ) == int( 3 ), "" );
-  static_assert( int( dim_s2_s3_s4::rank_dynamic ) == int( 0 ), "" );
-  static_assert( int( dim_s2_s3_s4::ArgN0 ) == 2, "" );
-  static_assert( int( dim_s2_s3_s4::ArgN1 ) == 3, "" );
-  static_assert( int( dim_s2_s3_s4::ArgN2 ) == 4, "" );
-  static_assert( int( dim_s2_s3_s4::ArgN3 ) == 1, "" );
-
-  static_assert( int( dim_s0::rank ) == int( 1 ), "" );
-  static_assert( int( dim_s0::rank_dynamic ) == int( 1 ), "" );
-
-  static_assert( int( dim_s0_s3::rank ) == int( 2 ), "" );
-  static_assert( int( dim_s0_s3::rank_dynamic ) == int( 1 ), "" );
-  static_assert( int( dim_s0_s3::ArgN0 ) == 0, "" );
-  static_assert( int( dim_s0_s3::ArgN1 ) == 3, "" );
-
-  static_assert( int( dim_s0_s3_s4::rank ) == int( 3 ), "" );
-  static_assert( int( dim_s0_s3_s4::rank_dynamic ) == int( 1 ), "" );
-  static_assert( int( dim_s0_s3_s4::ArgN0 ) == 0, "" );
-  static_assert( int( dim_s0_s3_s4::ArgN1 ) == 3, "" );
-  static_assert( int( dim_s0_s3_s4::ArgN2 ) == 4, "" );
-
-  static_assert( int( dim_s0_s0_s4::rank ) == int( 3 ), "" );
-  static_assert( int( dim_s0_s0_s4::rank_dynamic ) == int( 2 ), "" );
-  static_assert( int( dim_s0_s0_s4::ArgN0 ) == 0, "" );
-  static_assert( int( dim_s0_s0_s4::ArgN1 ) == 0, "" );
-  static_assert( int( dim_s0_s0_s4::ArgN2 ) == 4, "" );
-
-  static_assert( int( dim_s0_s0_s0::rank ) == int( 3 ), "" );
-  static_assert( int( dim_s0_s0_s0::rank_dynamic ) == int( 3 ), "" );
-
-  static_assert( int( dim_s0_s0_s0_s0::rank ) == int( 4 ), "" );
-  static_assert( int( dim_s0_s0_s0_s0::rank_dynamic ) == int( 4 ), "" );
-
-  static_assert( int( dim_s0_s0_s0_s0_s0::rank ) == int( 5 ), "" );
-  static_assert( int( dim_s0_s0_s0_s0_s0::rank_dynamic ) == int( 5 ), "" );
-
-  static_assert( int( dim_s0_s0_s0_s0_s0_s0::rank ) == int( 6 ), "" );
-  static_assert( int( dim_s0_s0_s0_s0_s0_s0::rank_dynamic ) == int( 6 ), "" );
-
-  static_assert( int( dim_s0_s0_s0_s0_s0_s0_s0::rank ) == int( 7 ), "" );
-  static_assert( int( dim_s0_s0_s0_s0_s0_s0_s0::rank_dynamic ) == int( 7 ), "" );
-
-  static_assert( int( dim_s0_s0_s0_s0_s0_s0_s0_s0::rank ) == int( 8 ), "" );
-  static_assert( int( dim_s0_s0_s0_s0_s0_s0_s0_s0::rank_dynamic ) == int( 8 ), "" );
-
-  dim_s0          d1( 2, 3, 4, 5, 6, 7, 8, 9 );
-  dim_s0_s0       d2( 2, 3, 4, 5, 6, 7, 8, 9 );
-  dim_s0_s0_s0    d3( 2, 3, 4, 5, 6, 7, 8, 9 );
-  dim_s0_s0_s0_s0 d4( 2, 3, 4, 5, 6, 7, 8, 9 );
-
-  ASSERT_EQ( d1.N0, 2 );
-  ASSERT_EQ( d2.N0, 2 );
-  ASSERT_EQ( d3.N0, 2 );
-  ASSERT_EQ( d4.N0, 2 );
-
-  ASSERT_EQ( d1.N1, 1 );
-  ASSERT_EQ( d2.N1, 3 );
-  ASSERT_EQ( d3.N1, 3 );
-  ASSERT_EQ( d4.N1, 3 );
-
-  ASSERT_EQ( d1.N2, 1 );
-  ASSERT_EQ( d2.N2, 1 );
-  ASSERT_EQ( d3.N2, 4 );
-  ASSERT_EQ( d4.N2, 4 );
-
-  ASSERT_EQ( d1.N3, 1 );
-  ASSERT_EQ( d2.N3, 1 );
-  ASSERT_EQ( d3.N3, 1 );
-  ASSERT_EQ( d4.N3, 5 );
+  ASSERT_LE(sizeof(dim_s0_s0), 2 * sizeof(size_t));
+  ASSERT_LE(sizeof(dim_s0_s0_s4), 2 * sizeof(size_t));
+
+  ASSERT_LE(sizeof(dim_s0_s0_s0), 4 * sizeof(size_t));
+  ASSERT_EQ(sizeof(dim_s0_s0_s0_s0), 4 * sizeof(unsigned));
+  ASSERT_LE(sizeof(dim_s0_s0_s0_s0_s0), 6 * sizeof(unsigned));
+  ASSERT_EQ(sizeof(dim_s0_s0_s0_s0_s0_s0), 6 * sizeof(unsigned));
+  ASSERT_LE(sizeof(dim_s0_s0_s0_s0_s0_s0_s0), 8 * sizeof(unsigned));
+  ASSERT_EQ(sizeof(dim_s0_s0_s0_s0_s0_s0_s0_s0), 8 * sizeof(unsigned));
+
+  static_assert(int(dim_0::rank) == int(0), "");
+  static_assert(int(dim_0::rank_dynamic) == int(0), "");
+  static_assert(int(dim_0::ArgN0) == 1, "");
+  static_assert(int(dim_0::ArgN1) == 1, "");
+  static_assert(int(dim_0::ArgN2) == 1, "");
+
+  static_assert(int(dim_s2::rank) == int(1), "");
+  static_assert(int(dim_s2::rank_dynamic) == int(0), "");
+  static_assert(int(dim_s2::ArgN0) == 2, "");
+  static_assert(int(dim_s2::ArgN1) == 1, "");
+
+  static_assert(int(dim_s2_s3::rank) == int(2), "");
+  static_assert(int(dim_s2_s3::rank_dynamic) == int(0), "");
+  static_assert(int(dim_s2_s3::ArgN0) == 2, "");
+  static_assert(int(dim_s2_s3::ArgN1) == 3, "");
+  static_assert(int(dim_s2_s3::ArgN2) == 1, "");
+
+  static_assert(int(dim_s2_s3_s4::rank) == int(3), "");
+  static_assert(int(dim_s2_s3_s4::rank_dynamic) == int(0), "");
+  static_assert(int(dim_s2_s3_s4::ArgN0) == 2, "");
+  static_assert(int(dim_s2_s3_s4::ArgN1) == 3, "");
+  static_assert(int(dim_s2_s3_s4::ArgN2) == 4, "");
+  static_assert(int(dim_s2_s3_s4::ArgN3) == 1, "");
+
+  static_assert(int(dim_s0::rank) == int(1), "");
+  static_assert(int(dim_s0::rank_dynamic) == int(1), "");
+
+  static_assert(int(dim_s0_s3::rank) == int(2), "");
+  static_assert(int(dim_s0_s3::rank_dynamic) == int(1), "");
+  static_assert(int(dim_s0_s3::ArgN0) == 0, "");
+  static_assert(int(dim_s0_s3::ArgN1) == 3, "");
+
+  static_assert(int(dim_s0_s3_s4::rank) == int(3), "");
+  static_assert(int(dim_s0_s3_s4::rank_dynamic) == int(1), "");
+  static_assert(int(dim_s0_s3_s4::ArgN0) == 0, "");
+  static_assert(int(dim_s0_s3_s4::ArgN1) == 3, "");
+  static_assert(int(dim_s0_s3_s4::ArgN2) == 4, "");
+
+  static_assert(int(dim_s0_s0_s4::rank) == int(3), "");
+  static_assert(int(dim_s0_s0_s4::rank_dynamic) == int(2), "");
+  static_assert(int(dim_s0_s0_s4::ArgN0) == 0, "");
+  static_assert(int(dim_s0_s0_s4::ArgN1) == 0, "");
+  static_assert(int(dim_s0_s0_s4::ArgN2) == 4, "");
+
+  static_assert(int(dim_s0_s0_s0::rank) == int(3), "");
+  static_assert(int(dim_s0_s0_s0::rank_dynamic) == int(3), "");
+
+  static_assert(int(dim_s0_s0_s0_s0::rank) == int(4), "");
+  static_assert(int(dim_s0_s0_s0_s0::rank_dynamic) == int(4), "");
+
+  static_assert(int(dim_s0_s0_s0_s0_s0::rank) == int(5), "");
+  static_assert(int(dim_s0_s0_s0_s0_s0::rank_dynamic) == int(5), "");
+
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0::rank) == int(6), "");
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(6), "");
+
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0::rank) == int(7), "");
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(7), "");
+
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0_s0::rank) == int(8), "");
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(8), "");
+
+  dim_s0 d1(2, 3, 4, 5, 6, 7, 8, 9);
+  dim_s0_s0 d2(2, 3, 4, 5, 6, 7, 8, 9);
+  dim_s0_s0_s0 d3(2, 3, 4, 5, 6, 7, 8, 9);
+  dim_s0_s0_s0_s0 d4(2, 3, 4, 5, 6, 7, 8, 9);
+
+  ASSERT_EQ(d1.N0, 2);
+  ASSERT_EQ(d2.N0, 2);
+  ASSERT_EQ(d3.N0, 2);
+  ASSERT_EQ(d4.N0, 2);
+
+  ASSERT_EQ(d1.N1, 1);
+  ASSERT_EQ(d2.N1, 3);
+  ASSERT_EQ(d3.N1, 3);
+  ASSERT_EQ(d4.N1, 3);
+
+  ASSERT_EQ(d1.N2, 1);
+  ASSERT_EQ(d2.N2, 1);
+  ASSERT_EQ(d3.N2, 4);
+  ASSERT_EQ(d4.N2, 4);
+
+  ASSERT_EQ(d1.N3, 1);
+  ASSERT_EQ(d2.N3, 1);
+  ASSERT_EQ(d3.N3, 1);
+  ASSERT_EQ(d4.N3, 5);
 
   //----------------------------------------
 
-  typedef Kokkos::Impl::ViewOffset< dim_s0_s0_s0, Kokkos::LayoutStride > stride_s0_s0_s0;
+  typedef Kokkos::Impl::ViewOffset<dim_s0_s0_s0, Kokkos::LayoutStride>
+      stride_s0_s0_s0;
 
   //----------------------------------------
   // Static dimension.
   {
-    typedef Kokkos::Impl::ViewOffset< dim_s2_s3_s4, Kokkos::LayoutLeft > left_s2_s3_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s2_s3_s4, Kokkos::LayoutLeft>
+        left_s2_s3_s4;
 
-    ASSERT_EQ( sizeof( left_s2_s3_s4 ), sizeof( dim_s2_s3_s4 ) );
+    ASSERT_EQ(sizeof(left_s2_s3_s4), sizeof(dim_s2_s3_s4));
 
     left_s2_s3_s4 off3;
 
-    stride_s0_s0_s0 stride3( off3 );
+    stride_s0_s0_s0 stride3(off3);
 
-    ASSERT_EQ( off3.stride_0(), 1 );
-    ASSERT_EQ( off3.stride_1(), 2 );
-    ASSERT_EQ( off3.stride_2(), 6 );
-    ASSERT_EQ( off3.span(), 24 );
+    ASSERT_EQ(off3.stride_0(), 1);
+    ASSERT_EQ(off3.stride_1(), 2);
+    ASSERT_EQ(off3.stride_2(), 6);
+    ASSERT_EQ(off3.span(), 24);
 
-    ASSERT_EQ( off3.stride_0(), stride3.stride_0() );
-    ASSERT_EQ( off3.stride_1(), stride3.stride_1() );
-    ASSERT_EQ( off3.stride_2(), stride3.stride_2() );
-    ASSERT_EQ( off3.span(), stride3.span() );
+    ASSERT_EQ(off3.stride_0(), stride3.stride_0());
+    ASSERT_EQ(off3.stride_1(), stride3.stride_1());
+    ASSERT_EQ(off3.stride_2(), stride3.stride_2());
+    ASSERT_EQ(off3.span(), stride3.span());
 
     int offset = 0;
 
-    for ( int k = 0; k < 4; ++k )
-    for ( int j = 0; j < 3; ++j )
-    for ( int i = 0; i < 2; ++i, ++offset )
-    {
-      ASSERT_EQ( off3( i, j, k ), offset );
-      ASSERT_EQ( stride3( i, j, k ), off3( i, j, k ) );
-    }
+    for (int k = 0; k < 4; ++k)
+      for (int j = 0; j < 3; ++j)
+        for (int i = 0; i < 2; ++i, ++offset) {
+          ASSERT_EQ(off3(i, j, k), offset);
+          ASSERT_EQ(stride3(i, j, k), off3(i, j, k));
+        }
   }
 
   //----------------------------------------
   // Small dimension is unpadded.
   {
-    typedef Kokkos::Impl::ViewOffset< dim_s0_s0_s4, Kokkos::LayoutLeft > left_s0_s0_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s0_s0_s4, Kokkos::LayoutLeft>
+        left_s0_s0_s4;
 
-    left_s0_s0_s4 dyn_off3( std::integral_constant< unsigned, sizeof( int ) >()
-                          , Kokkos::LayoutLeft( 2, 3, 0, 0, 0, 0, 0, 0 ) );
+    left_s0_s0_s4 dyn_off3(std::integral_constant<unsigned, sizeof(int)>(),
+                           Kokkos::LayoutLeft(2, 3, 0, 0, 0, 0, 0, 0));
 
-    stride_s0_s0_s0  stride3( dyn_off3 );
+    stride_s0_s0_s0 stride3(dyn_off3);
 
-    ASSERT_EQ( dyn_off3.m_dim.rank, 3 );
-    ASSERT_EQ( dyn_off3.m_dim.N0, 2 );
-    ASSERT_EQ( dyn_off3.m_dim.N1, 3 );
-    ASSERT_EQ( dyn_off3.m_dim.N2, 4 );
-    ASSERT_EQ( dyn_off3.m_dim.N3, 1 );
-    ASSERT_EQ( dyn_off3.size(), 2 * 3 * 4 );
+    ASSERT_EQ(dyn_off3.m_dim.rank, 3);
+    ASSERT_EQ(dyn_off3.m_dim.N0, 2);
+    ASSERT_EQ(dyn_off3.m_dim.N1, 3);
+    ASSERT_EQ(dyn_off3.m_dim.N2, 4);
+    ASSERT_EQ(dyn_off3.m_dim.N3, 1);
+    ASSERT_EQ(dyn_off3.size(), 2 * 3 * 4);
 
     const Kokkos::LayoutLeft layout = dyn_off3.layout();
 
-    ASSERT_EQ( layout.dimension[0], 2 );
-    ASSERT_EQ( layout.dimension[1], 3 );
-    ASSERT_EQ( layout.dimension[2], 4 );
-    ASSERT_EQ( layout.dimension[3], 1 );
-    ASSERT_EQ( layout.dimension[4], 1 );
-    ASSERT_EQ( layout.dimension[5], 1 );
-    ASSERT_EQ( layout.dimension[6], 1 );
-    ASSERT_EQ( layout.dimension[7], 1 );
-
-    ASSERT_EQ( stride3.m_dim.rank, 3 );
-    ASSERT_EQ( stride3.m_dim.N0, 2 );
-    ASSERT_EQ( stride3.m_dim.N1, 3 );
-    ASSERT_EQ( stride3.m_dim.N2, 4 );
-    ASSERT_EQ( stride3.m_dim.N3, 1 );
-    ASSERT_EQ( stride3.size(), 2 * 3 * 4 );
+    ASSERT_EQ(layout.dimension[0], 2);
+    ASSERT_EQ(layout.dimension[1], 3);
+    ASSERT_EQ(layout.dimension[2], 4);
+    ASSERT_EQ(layout.dimension[3], 1);
+    ASSERT_EQ(layout.dimension[4], 1);
+    ASSERT_EQ(layout.dimension[5], 1);
+    ASSERT_EQ(layout.dimension[6], 1);
+    ASSERT_EQ(layout.dimension[7], 1);
+
+    ASSERT_EQ(stride3.m_dim.rank, 3);
+    ASSERT_EQ(stride3.m_dim.N0, 2);
+    ASSERT_EQ(stride3.m_dim.N1, 3);
+    ASSERT_EQ(stride3.m_dim.N2, 4);
+    ASSERT_EQ(stride3.m_dim.N3, 1);
+    ASSERT_EQ(stride3.size(), 2 * 3 * 4);
 
     int offset = 0;
 
-    for ( int k = 0; k < 4; ++k )
-    for ( int j = 0; j < 3; ++j )
-    for ( int i = 0; i < 2; ++i, ++offset )
-    {
-      ASSERT_EQ( offset, dyn_off3( i, j, k ) );
-      ASSERT_EQ( stride3( i, j, k ), dyn_off3( i, j, k ) );
-    }
+    for (int k = 0; k < 4; ++k)
+      for (int j = 0; j < 3; ++j)
+        for (int i = 0; i < 2; ++i, ++offset) {
+          ASSERT_EQ(offset, dyn_off3(i, j, k));
+          ASSERT_EQ(stride3(i, j, k), dyn_off3(i, j, k));
+        }
 
-    ASSERT_EQ( dyn_off3.span(), offset );
-    ASSERT_EQ( stride3.span(), dyn_off3.span() );
+    ASSERT_EQ(dyn_off3.span(), offset);
+    ASSERT_EQ(stride3.span(), dyn_off3.span());
   }
 
   //----------------------------------------
@@ -275,114 +278,114 @@ void test_view_mapping()
     constexpr int N0 = 2000;
     constexpr int N1 = 300;
 
-    typedef Kokkos::Impl::ViewOffset< dim_s0_s0_s4, Kokkos::LayoutLeft > left_s0_s0_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s0_s0_s4, Kokkos::LayoutLeft>
+        left_s0_s0_s4;
 
-    left_s0_s0_s4 dyn_off3( std::integral_constant< unsigned, sizeof( int ) >()
-                          , Kokkos::LayoutLeft( N0, N1, 0, 0, 0, 0, 0, 0 ) );
+    left_s0_s0_s4 dyn_off3(std::integral_constant<unsigned, sizeof(int)>(),
+                           Kokkos::LayoutLeft(N0, N1, 0, 0, 0, 0, 0, 0));
 
-    stride_s0_s0_s0  stride3( dyn_off3 );
+    stride_s0_s0_s0 stride3(dyn_off3);
 
-    ASSERT_EQ( dyn_off3.m_dim.rank, 3 );
-    ASSERT_EQ( dyn_off3.m_dim.N0, N0 );
-    ASSERT_EQ( dyn_off3.m_dim.N1, N1 );
-    ASSERT_EQ( dyn_off3.m_dim.N2, 4 );
-    ASSERT_EQ( dyn_off3.m_dim.N3, 1 );
-    ASSERT_EQ( dyn_off3.size(), N0 * N1 * 4 );
+    ASSERT_EQ(dyn_off3.m_dim.rank, 3);
+    ASSERT_EQ(dyn_off3.m_dim.N0, N0);
+    ASSERT_EQ(dyn_off3.m_dim.N1, N1);
+    ASSERT_EQ(dyn_off3.m_dim.N2, 4);
+    ASSERT_EQ(dyn_off3.m_dim.N3, 1);
+    ASSERT_EQ(dyn_off3.size(), N0 * N1 * 4);
 
-    ASSERT_EQ( stride3.m_dim.rank, 3 );
-    ASSERT_EQ( stride3.m_dim.N0, N0 );
-    ASSERT_EQ( stride3.m_dim.N1, N1 );
-    ASSERT_EQ( stride3.m_dim.N2, 4 );
-    ASSERT_EQ( stride3.m_dim.N3, 1 );
-    ASSERT_EQ( stride3.size(), N0 * N1 * 4 );
-    ASSERT_EQ( stride3.span(), dyn_off3.span() );
+    ASSERT_EQ(stride3.m_dim.rank, 3);
+    ASSERT_EQ(stride3.m_dim.N0, N0);
+    ASSERT_EQ(stride3.m_dim.N1, N1);
+    ASSERT_EQ(stride3.m_dim.N2, 4);
+    ASSERT_EQ(stride3.m_dim.N3, 1);
+    ASSERT_EQ(stride3.size(), N0 * N1 * 4);
+    ASSERT_EQ(stride3.span(), dyn_off3.span());
 
     int offset = 0;
 
-    for ( int k = 0; k < 4; ++k )
-    for ( int j = 0; j < N1; ++j )
-    for ( int i = 0; i < N0; ++i )
-    {
-      ASSERT_LE( offset, dyn_off3( i, j, k ) );
-      ASSERT_EQ( stride3( i, j, k ), dyn_off3( i, j, k ) );
-      offset = dyn_off3( i, j, k ) + 1;
-    }
+    for (int k = 0; k < 4; ++k)
+      for (int j = 0; j < N1; ++j)
+        for (int i = 0; i < N0; ++i) {
+          ASSERT_LE(offset, dyn_off3(i, j, k));
+          ASSERT_EQ(stride3(i, j, k), dyn_off3(i, j, k));
+          offset = dyn_off3(i, j, k) + 1;
+        }
 
-    ASSERT_LE( offset, dyn_off3.span() );
+    ASSERT_LE(offset, dyn_off3.span());
   }
 
   //----------------------------------------
   // Static dimension.
   {
-    typedef Kokkos::Impl::ViewOffset< dim_s2_s3_s4, Kokkos::LayoutRight > right_s2_s3_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s2_s3_s4, Kokkos::LayoutRight>
+        right_s2_s3_s4;
 
-    ASSERT_EQ( sizeof( right_s2_s3_s4 ), sizeof( dim_s2_s3_s4 ) );
+    ASSERT_EQ(sizeof(right_s2_s3_s4), sizeof(dim_s2_s3_s4));
 
     right_s2_s3_s4 off3;
 
-    stride_s0_s0_s0  stride3( off3 );
+    stride_s0_s0_s0 stride3(off3);
 
-    ASSERT_EQ( off3.stride_0(), 12 );
-    ASSERT_EQ( off3.stride_1(), 4 );
-    ASSERT_EQ( off3.stride_2(), 1 );
+    ASSERT_EQ(off3.stride_0(), 12);
+    ASSERT_EQ(off3.stride_1(), 4);
+    ASSERT_EQ(off3.stride_2(), 1);
 
-    ASSERT_EQ( off3.dimension_0(), stride3.dimension_0() );
-    ASSERT_EQ( off3.dimension_1(), stride3.dimension_1() );
-    ASSERT_EQ( off3.dimension_2(), stride3.dimension_2() );
-    ASSERT_EQ( off3.stride_0(), stride3.stride_0() );
-    ASSERT_EQ( off3.stride_1(), stride3.stride_1() );
-    ASSERT_EQ( off3.stride_2(), stride3.stride_2() );
-    ASSERT_EQ( off3.span(), stride3.span() );
+    ASSERT_EQ(off3.dimension_0(), stride3.dimension_0());
+    ASSERT_EQ(off3.dimension_1(), stride3.dimension_1());
+    ASSERT_EQ(off3.dimension_2(), stride3.dimension_2());
+    ASSERT_EQ(off3.stride_0(), stride3.stride_0());
+    ASSERT_EQ(off3.stride_1(), stride3.stride_1());
+    ASSERT_EQ(off3.stride_2(), stride3.stride_2());
+    ASSERT_EQ(off3.span(), stride3.span());
 
     int offset = 0;
 
-    for ( int i = 0; i < 2; ++i )
-    for ( int j = 0; j < 3; ++j )
-    for ( int k = 0; k < 4; ++k, ++offset )
-    {
-      ASSERT_EQ( off3( i, j, k ), offset );
-      ASSERT_EQ( off3( i, j, k ), stride3( i, j, k ) );
-    }
+    for (int i = 0; i < 2; ++i)
+      for (int j = 0; j < 3; ++j)
+        for (int k = 0; k < 4; ++k, ++offset) {
+          ASSERT_EQ(off3(i, j, k), offset);
+          ASSERT_EQ(off3(i, j, k), stride3(i, j, k));
+        }
 
-    ASSERT_EQ( off3.span(), offset );
+    ASSERT_EQ(off3.span(), offset);
   }
 
   //----------------------------------------
   // Small dimension is unpadded.
   {
-    typedef Kokkos::Impl::ViewOffset< dim_s0_s0_s4, Kokkos::LayoutRight > right_s0_s0_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s0_s0_s4, Kokkos::LayoutRight>
+        right_s0_s0_s4;
 
-    right_s0_s0_s4 dyn_off3( std::integral_constant< unsigned, sizeof( int ) >()
-                           , Kokkos::LayoutRight( 2, 3, 0, 0, 0, 0, 0, 0 ) );
+    right_s0_s0_s4 dyn_off3(std::integral_constant<unsigned, sizeof(int)>(),
+                            Kokkos::LayoutRight(2, 3, 0, 0, 0, 0, 0, 0));
 
-    stride_s0_s0_s0  stride3( dyn_off3 );
+    stride_s0_s0_s0 stride3(dyn_off3);
 
-    ASSERT_EQ( dyn_off3.m_dim.rank, 3 );
-    ASSERT_EQ( dyn_off3.m_dim.N0, 2 );
-    ASSERT_EQ( dyn_off3.m_dim.N1, 3 );
-    ASSERT_EQ( dyn_off3.m_dim.N2, 4 );
-    ASSERT_EQ( dyn_off3.m_dim.N3, 1 );
-    ASSERT_EQ( dyn_off3.size(), 2 * 3 * 4 );
+    ASSERT_EQ(dyn_off3.m_dim.rank, 3);
+    ASSERT_EQ(dyn_off3.m_dim.N0, 2);
+    ASSERT_EQ(dyn_off3.m_dim.N1, 3);
+    ASSERT_EQ(dyn_off3.m_dim.N2, 4);
+    ASSERT_EQ(dyn_off3.m_dim.N3, 1);
+    ASSERT_EQ(dyn_off3.size(), 2 * 3 * 4);
 
-    ASSERT_EQ( dyn_off3.dimension_0(), stride3.dimension_0() );
-    ASSERT_EQ( dyn_off3.dimension_1(), stride3.dimension_1() );
-    ASSERT_EQ( dyn_off3.dimension_2(), stride3.dimension_2() );
-    ASSERT_EQ( dyn_off3.stride_0(), stride3.stride_0() );
-    ASSERT_EQ( dyn_off3.stride_1(), stride3.stride_1() );
-    ASSERT_EQ( dyn_off3.stride_2(), stride3.stride_2() );
-    ASSERT_EQ( dyn_off3.span(), stride3.span() );
+    ASSERT_EQ(dyn_off3.dimension_0(), stride3.dimension_0());
+    ASSERT_EQ(dyn_off3.dimension_1(), stride3.dimension_1());
+    ASSERT_EQ(dyn_off3.dimension_2(), stride3.dimension_2());
+    ASSERT_EQ(dyn_off3.stride_0(), stride3.stride_0());
+    ASSERT_EQ(dyn_off3.stride_1(), stride3.stride_1());
+    ASSERT_EQ(dyn_off3.stride_2(), stride3.stride_2());
+    ASSERT_EQ(dyn_off3.span(), stride3.span());
 
     int offset = 0;
 
-    for ( int i = 0; i < 2; ++i )
-    for ( int j = 0; j < 3; ++j )
-    for ( int k = 0; k < 4; ++k, ++offset )
-    {
-      ASSERT_EQ( offset, dyn_off3( i, j, k ) );
-      ASSERT_EQ( dyn_off3( i, j, k ), stride3( i, j, k ) );
-    }
+    for (int i = 0; i < 2; ++i)
+      for (int j = 0; j < 3; ++j)
+        for (int k = 0; k < 4; ++k, ++offset) {
+          ASSERT_EQ(offset, dyn_off3(i, j, k));
+          ASSERT_EQ(dyn_off3(i, j, k), stride3(i, j, k));
+        }
 
-    ASSERT_EQ( dyn_off3.span(), offset );
+    ASSERT_EQ(dyn_off3.span(), offset);
   }
 
   //----------------------------------------
@@ -391,74 +394,71 @@ void test_view_mapping()
     constexpr int N0 = 2000;
     constexpr int N1 = 300;
 
-    typedef Kokkos::Impl::ViewOffset< dim_s0_s0_s4, Kokkos::LayoutRight > right_s0_s0_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s0_s0_s4, Kokkos::LayoutRight>
+        right_s0_s0_s4;
 
-    right_s0_s0_s4 dyn_off3( std::integral_constant< unsigned, sizeof( int ) >()
-                           , Kokkos::LayoutRight( N0, N1, 0, 0, 0, 0, 0, 0 ) );
+    right_s0_s0_s4 dyn_off3(std::integral_constant<unsigned, sizeof(int)>(),
+                            Kokkos::LayoutRight(N0, N1, 0, 0, 0, 0, 0, 0));
 
-    stride_s0_s0_s0  stride3( dyn_off3 );
+    stride_s0_s0_s0 stride3(dyn_off3);
 
-    ASSERT_EQ( dyn_off3.m_dim.rank, 3 );
-    ASSERT_EQ( dyn_off3.m_dim.N0, N0 );
-    ASSERT_EQ( dyn_off3.m_dim.N1, N1 );
-    ASSERT_EQ( dyn_off3.m_dim.N2, 4 );
-    ASSERT_EQ( dyn_off3.m_dim.N3, 1 );
-    ASSERT_EQ( dyn_off3.size(), N0 * N1 * 4 );
+    ASSERT_EQ(dyn_off3.m_dim.rank, 3);
+    ASSERT_EQ(dyn_off3.m_dim.N0, N0);
+    ASSERT_EQ(dyn_off3.m_dim.N1, N1);
+    ASSERT_EQ(dyn_off3.m_dim.N2, 4);
+    ASSERT_EQ(dyn_off3.m_dim.N3, 1);
+    ASSERT_EQ(dyn_off3.size(), N0 * N1 * 4);
 
-    ASSERT_EQ( dyn_off3.dimension_0(), stride3.dimension_0() );
-    ASSERT_EQ( dyn_off3.dimension_1(), stride3.dimension_1() );
-    ASSERT_EQ( dyn_off3.dimension_2(), stride3.dimension_2() );
-    ASSERT_EQ( dyn_off3.stride_0(), stride3.stride_0() );
-    ASSERT_EQ( dyn_off3.stride_1(), stride3.stride_1() );
-    ASSERT_EQ( dyn_off3.stride_2(), stride3.stride_2() );
-    ASSERT_EQ( dyn_off3.span(), stride3.span() );
+    ASSERT_EQ(dyn_off3.dimension_0(), stride3.dimension_0());
+    ASSERT_EQ(dyn_off3.dimension_1(), stride3.dimension_1());
+    ASSERT_EQ(dyn_off3.dimension_2(), stride3.dimension_2());
+    ASSERT_EQ(dyn_off3.stride_0(), stride3.stride_0());
+    ASSERT_EQ(dyn_off3.stride_1(), stride3.stride_1());
+    ASSERT_EQ(dyn_off3.stride_2(), stride3.stride_2());
+    ASSERT_EQ(dyn_off3.span(), stride3.span());
 
     int offset = 0;
 
-    for ( int i = 0; i < N0; ++i )
-    for ( int j = 0; j < N1; ++j )
-    for ( int k = 0; k < 4; ++k )
-    {
-      ASSERT_LE( offset, dyn_off3( i, j, k ) );
-      ASSERT_EQ( dyn_off3( i, j, k ), stride3( i, j, k ) );
-      offset = dyn_off3( i, j, k ) + 1;
-    }
+    for (int i = 0; i < N0; ++i)
+      for (int j = 0; j < N1; ++j)
+        for (int k = 0; k < 4; ++k) {
+          ASSERT_LE(offset, dyn_off3(i, j, k));
+          ASSERT_EQ(dyn_off3(i, j, k), stride3(i, j, k));
+          offset = dyn_off3(i, j, k) + 1;
+        }
 
-    ASSERT_LE( offset, dyn_off3.span() );
+    ASSERT_LE(offset, dyn_off3.span());
   }
 
   //----------------------------------------
   // Subview.
   {
     // Mapping rank 4 to rank 3
-    typedef Kokkos::Impl::SubviewExtents< 4, 3 > SubviewExtents;
+    typedef Kokkos::Impl::SubviewExtents<4, 3> SubviewExtents;
 
     constexpr int N0 = 1000;
     constexpr int N1 = 2000;
     constexpr int N2 = 3000;
     constexpr int N3 = 4000;
 
-    Kokkos::Impl::ViewDimension< N0, N1, N2, N3 > dim;
+    Kokkos::Impl::ViewDimension<N0, N1, N2, N3> dim;
 
-    SubviewExtents tmp( dim
-                      , N0 / 2
-                      , Kokkos::ALL
-                      , std::pair< int, int >( N2 / 4, 10 + N2 / 4 )
-                      , Kokkos::pair< int, int >( N3 / 4, 20 + N3 / 4 )
-                      );
+    SubviewExtents tmp(dim, N0 / 2, Kokkos::ALL,
+                       std::pair<int, int>(N2 / 4, 10 + N2 / 4),
+                       Kokkos::pair<int, int>(N3 / 4, 20 + N3 / 4));
 
-    ASSERT_EQ( tmp.domain_offset( 0 ), N0 / 2 );
-    ASSERT_EQ( tmp.domain_offset( 1 ), 0 );
-    ASSERT_EQ( tmp.domain_offset( 2 ), N2 / 4 );
-    ASSERT_EQ( tmp.domain_offset( 3 ), N3 / 4 );
+    ASSERT_EQ(tmp.domain_offset(0), N0 / 2);
+    ASSERT_EQ(tmp.domain_offset(1), 0);
+    ASSERT_EQ(tmp.domain_offset(2), N2 / 4);
+    ASSERT_EQ(tmp.domain_offset(3), N3 / 4);
 
-    ASSERT_EQ( tmp.range_index( 0 ), 1 );
-    ASSERT_EQ( tmp.range_index( 1 ), 2 );
-    ASSERT_EQ( tmp.range_index( 2 ), 3 );
+    ASSERT_EQ(tmp.range_index(0), 1);
+    ASSERT_EQ(tmp.range_index(1), 2);
+    ASSERT_EQ(tmp.range_index(2), 3);
 
-    ASSERT_EQ( tmp.range_extent( 0 ), N1 );
-    ASSERT_EQ( tmp.range_extent( 1 ), 10 );
-    ASSERT_EQ( tmp.range_extent( 2 ), 20 );
+    ASSERT_EQ(tmp.range_extent(0), N1);
+    ASSERT_EQ(tmp.range_extent(1), 10);
+    ASSERT_EQ(tmp.range_extent(2), 20);
   }
 
   {
@@ -469,36 +469,33 @@ void test_view_mapping()
     constexpr int sub_N1 = 200;
     constexpr int sub_N2 = 4;
 
-    typedef Kokkos::Impl::ViewOffset< dim_s0_s0_s4, Kokkos::LayoutLeft > left_s0_s0_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s0_s0_s4, Kokkos::LayoutLeft>
+        left_s0_s0_s4;
 
-    left_s0_s0_s4 dyn_off3( std::integral_constant< unsigned, sizeof( int ) >()
-                          , Kokkos::LayoutLeft( N0, N1, 0, 0, 0, 0, 0, 0 ) );
+    left_s0_s0_s4 dyn_off3(std::integral_constant<unsigned, sizeof(int)>(),
+                           Kokkos::LayoutLeft(N0, N1, 0, 0, 0, 0, 0, 0));
 
-    Kokkos::Impl::SubviewExtents< 3, 3 >
-      sub( dyn_off3.m_dim
-         , Kokkos::pair< int, int >( 0, sub_N0 )
-         , Kokkos::pair< int, int >( 0, sub_N1 )
-         , Kokkos::pair< int, int >( 0, sub_N2 )
-         );
+    Kokkos::Impl::SubviewExtents<3, 3> sub(
+        dyn_off3.m_dim, Kokkos::pair<int, int>(0, sub_N0),
+        Kokkos::pair<int, int>(0, sub_N1), Kokkos::pair<int, int>(0, sub_N2));
 
-    stride_s0_s0_s0  stride3( dyn_off3, sub );
+    stride_s0_s0_s0 stride3(dyn_off3, sub);
 
-    ASSERT_EQ( stride3.dimension_0(), sub_N0 );
-    ASSERT_EQ( stride3.dimension_1(), sub_N1 );
-    ASSERT_EQ( stride3.dimension_2(), sub_N2 );
-    ASSERT_EQ( stride3.size(), sub_N0 * sub_N1 * sub_N2 );
+    ASSERT_EQ(stride3.dimension_0(), sub_N0);
+    ASSERT_EQ(stride3.dimension_1(), sub_N1);
+    ASSERT_EQ(stride3.dimension_2(), sub_N2);
+    ASSERT_EQ(stride3.size(), sub_N0 * sub_N1 * sub_N2);
 
-    ASSERT_EQ( dyn_off3.stride_0(), stride3.stride_0() );
-    ASSERT_EQ( dyn_off3.stride_1(), stride3.stride_1() );
-    ASSERT_EQ( dyn_off3.stride_2(), stride3.stride_2() );
-    ASSERT_GE( dyn_off3.span()    , stride3.span() );
+    ASSERT_EQ(dyn_off3.stride_0(), stride3.stride_0());
+    ASSERT_EQ(dyn_off3.stride_1(), stride3.stride_1());
+    ASSERT_EQ(dyn_off3.stride_2(), stride3.stride_2());
+    ASSERT_GE(dyn_off3.span(), stride3.span());
 
-    for ( int k = 0; k < sub_N2; ++k )
-    for ( int j = 0; j < sub_N1; ++j )
-    for ( int i = 0; i < sub_N0; ++i )
-    {
-      ASSERT_EQ( stride3( i, j, k ), dyn_off3( i, j, k ) );
-    }
+    for (int k = 0; k < sub_N2; ++k)
+      for (int j = 0; j < sub_N1; ++j)
+        for (int i = 0; i < sub_N0; ++i) {
+          ASSERT_EQ(stride3(i, j, k), dyn_off3(i, j, k));
+        }
   }
 
   {
@@ -509,36 +506,33 @@ void test_view_mapping()
     constexpr int sub_N1 = 200;
     constexpr int sub_N2 = 4;
 
-    typedef Kokkos::Impl::ViewOffset< dim_s0_s0_s4, Kokkos::LayoutRight > right_s0_s0_s4;
+    typedef Kokkos::Impl::ViewOffset<dim_s0_s0_s4, Kokkos::LayoutRight>
+        right_s0_s0_s4;
 
-    right_s0_s0_s4 dyn_off3( std::integral_constant< unsigned, sizeof( int ) >()
-                           , Kokkos::LayoutRight( N0, N1, 0, 0, 0, 0, 0, 0 ) );
+    right_s0_s0_s4 dyn_off3(std::integral_constant<unsigned, sizeof(int)>(),
+                            Kokkos::LayoutRight(N0, N1, 0, 0, 0, 0, 0, 0));
 
-    Kokkos::Impl::SubviewExtents< 3, 3 >
-      sub( dyn_off3.m_dim
-         , Kokkos::pair< int, int >( 0, sub_N0 )
-         , Kokkos::pair< int, int >( 0, sub_N1 )
-         , Kokkos::pair< int, int >( 0, sub_N2 )
-         );
+    Kokkos::Impl::SubviewExtents<3, 3> sub(
+        dyn_off3.m_dim, Kokkos::pair<int, int>(0, sub_N0),
+        Kokkos::pair<int, int>(0, sub_N1), Kokkos::pair<int, int>(0, sub_N2));
 
-    stride_s0_s0_s0  stride3( dyn_off3, sub );
+    stride_s0_s0_s0 stride3(dyn_off3, sub);
 
-    ASSERT_EQ( stride3.dimension_0(), sub_N0 );
-    ASSERT_EQ( stride3.dimension_1(), sub_N1 );
-    ASSERT_EQ( stride3.dimension_2(), sub_N2 );
-    ASSERT_EQ( stride3.size(), sub_N0 * sub_N1 * sub_N2 );
+    ASSERT_EQ(stride3.dimension_0(), sub_N0);
+    ASSERT_EQ(stride3.dimension_1(), sub_N1);
+    ASSERT_EQ(stride3.dimension_2(), sub_N2);
+    ASSERT_EQ(stride3.size(), sub_N0 * sub_N1 * sub_N2);
 
-    ASSERT_EQ( dyn_off3.stride_0(), stride3.stride_0() );
-    ASSERT_EQ( dyn_off3.stride_1(), stride3.stride_1() );
-    ASSERT_EQ( dyn_off3.stride_2(), stride3.stride_2() );
-    ASSERT_GE( dyn_off3.span()    , stride3.span() );
+    ASSERT_EQ(dyn_off3.stride_0(), stride3.stride_0());
+    ASSERT_EQ(dyn_off3.stride_1(), stride3.stride_1());
+    ASSERT_EQ(dyn_off3.stride_2(), stride3.stride_2());
+    ASSERT_GE(dyn_off3.span(), stride3.span());
 
-    for ( int i = 0; i < sub_N0; ++i )
-    for ( int j = 0; j < sub_N1; ++j )
-    for ( int k = 0; k < sub_N2; ++k )
-    {
-      ASSERT_EQ( stride3( i, j, k ), dyn_off3( i, j, k ) );
-    }
+    for (int i = 0; i < sub_N0; ++i)
+      for (int j = 0; j < sub_N1; ++j)
+        for (int k = 0; k < sub_N2; ++k) {
+          ASSERT_EQ(stride3(i, j, k), dyn_off3(i, j, k));
+        }
   }
 
   //----------------------------------------
@@ -546,55 +540,69 @@ void test_view_mapping()
   {
     using namespace Kokkos::Impl;
 
-    static_assert( rank_dynamic<>::value == 0, "" );
-    static_assert( rank_dynamic< 1 >::value == 0, "" );
-    static_assert( rank_dynamic< 0 >::value == 1, "" );
-    static_assert( rank_dynamic< 0, 1 >::value == 1, "" );
-    static_assert( rank_dynamic< 0, 0, 1 >::value == 2, "" );
+    static_assert(rank_dynamic<>::value == 0, "");
+    static_assert(rank_dynamic<1>::value == 0, "");
+    static_assert(rank_dynamic<0>::value == 1, "");
+    static_assert(rank_dynamic<0, 1>::value == 1, "");
+    static_assert(rank_dynamic<0, 0, 1>::value == 2, "");
   }
 
   {
     using namespace Kokkos::Impl;
 
-    typedef ViewArrayAnalysis< int[] >                 a_int_r1;
-    typedef ViewArrayAnalysis< int**[4][5][6] >        a_int_r5;
-    typedef ViewArrayAnalysis< const int[] >           a_const_int_r1;
-    typedef ViewArrayAnalysis< const int**[4][5][6] >  a_const_int_r5;
-
-    static_assert( a_int_r1::dimension::rank == 1, "" );
-    static_assert( a_int_r1::dimension::rank_dynamic == 1, "" );
-    static_assert( a_int_r5::dimension::ArgN0 == 0, "" );
-    static_assert( a_int_r5::dimension::ArgN1 == 0, "" );
-    static_assert( a_int_r5::dimension::ArgN2 == 4, "" );
-    static_assert( a_int_r5::dimension::ArgN3 == 5, "" );
-    static_assert( a_int_r5::dimension::ArgN4 == 6, "" );
-    static_assert( a_int_r5::dimension::ArgN5 == 1, "" );
-
-    static_assert( std::is_same< typename a_int_r1::dimension, ViewDimension<0> >::value, "" );
-    static_assert( std::is_same< typename a_int_r1::non_const_value_type, int >::value, "" );
-
-    static_assert( a_const_int_r1::dimension::rank == 1, "" );
-    static_assert( a_const_int_r1::dimension::rank_dynamic == 1, "" );
-    static_assert( std::is_same< typename a_const_int_r1::dimension, ViewDimension<0> >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::non_const_value_type, int >::value, "" );
-
-    static_assert( a_const_int_r5::dimension::rank == 5, "" );
-    static_assert( a_const_int_r5::dimension::rank_dynamic == 2, "" );
-
-    static_assert( a_const_int_r5::dimension::ArgN0 == 0, "" );
-    static_assert( a_const_int_r5::dimension::ArgN1 == 0, "" );
-    static_assert( a_const_int_r5::dimension::ArgN2 == 4, "" );
-    static_assert( a_const_int_r5::dimension::ArgN3 == 5, "" );
-    static_assert( a_const_int_r5::dimension::ArgN4 == 6, "" );
-    static_assert( a_const_int_r5::dimension::ArgN5 == 1, "" );
-
-    static_assert( std::is_same< typename a_const_int_r5::dimension, ViewDimension<0, 0, 4, 5, 6> >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r5::non_const_value_type, int >::value, "" );
-
-    static_assert( a_int_r5::dimension::rank == 5, "" );
-    static_assert( a_int_r5::dimension::rank_dynamic == 2, "" );
-    static_assert( std::is_same< typename a_int_r5::dimension, ViewDimension<0, 0, 4, 5, 6> >::value, "" );
-    static_assert( std::is_same< typename a_int_r5::non_const_value_type, int >::value, "" );
+    typedef ViewArrayAnalysis<int[]> a_int_r1;
+    typedef ViewArrayAnalysis<int* * [4][5][6]> a_int_r5;
+    typedef ViewArrayAnalysis<const int[]> a_const_int_r1;
+    typedef ViewArrayAnalysis<const int* * [4][5][6]> a_const_int_r5;
+
+    static_assert(a_int_r1::dimension::rank == 1, "");
+    static_assert(a_int_r1::dimension::rank_dynamic == 1, "");
+    static_assert(a_int_r5::dimension::ArgN0 == 0, "");
+    static_assert(a_int_r5::dimension::ArgN1 == 0, "");
+    static_assert(a_int_r5::dimension::ArgN2 == 4, "");
+    static_assert(a_int_r5::dimension::ArgN3 == 5, "");
+    static_assert(a_int_r5::dimension::ArgN4 == 6, "");
+    static_assert(a_int_r5::dimension::ArgN5 == 1, "");
+
+    static_assert(
+        std::is_same<typename a_int_r1::dimension, ViewDimension<0> >::value,
+        "");
+    static_assert(
+        std::is_same<typename a_int_r1::non_const_value_type, int>::value, "");
+
+    static_assert(a_const_int_r1::dimension::rank == 1, "");
+    static_assert(a_const_int_r1::dimension::rank_dynamic == 1, "");
+    static_assert(std::is_same<typename a_const_int_r1::dimension,
+                               ViewDimension<0> >::value,
+                  "");
+    static_assert(
+        std::is_same<typename a_const_int_r1::non_const_value_type, int>::value,
+        "");
+
+    static_assert(a_const_int_r5::dimension::rank == 5, "");
+    static_assert(a_const_int_r5::dimension::rank_dynamic == 2, "");
+
+    static_assert(a_const_int_r5::dimension::ArgN0 == 0, "");
+    static_assert(a_const_int_r5::dimension::ArgN1 == 0, "");
+    static_assert(a_const_int_r5::dimension::ArgN2 == 4, "");
+    static_assert(a_const_int_r5::dimension::ArgN3 == 5, "");
+    static_assert(a_const_int_r5::dimension::ArgN4 == 6, "");
+    static_assert(a_const_int_r5::dimension::ArgN5 == 1, "");
+
+    static_assert(std::is_same<typename a_const_int_r5::dimension,
+                               ViewDimension<0, 0, 4, 5, 6> >::value,
+                  "");
+    static_assert(
+        std::is_same<typename a_const_int_r5::non_const_value_type, int>::value,
+        "");
+
+    static_assert(a_int_r5::dimension::rank == 5, "");
+    static_assert(a_int_r5::dimension::rank_dynamic == 2, "");
+    static_assert(std::is_same<typename a_int_r5::dimension,
+                               ViewDimension<0, 0, 4, 5, 6> >::value,
+                  "");
+    static_assert(
+        std::is_same<typename a_int_r5::non_const_value_type, int>::value, "");
   }
 
   {
@@ -603,53 +611,94 @@ void test_view_mapping()
     typedef int t_i4[4];
 
     // Dimensions of t_i4 are appended to the multdimensional array.
-    typedef ViewArrayAnalysis< t_i4 ***[3] > a_int_r5;
-
-    static_assert( a_int_r5::dimension::rank == 5, "" );
-    static_assert( a_int_r5::dimension::rank_dynamic == 3, "" );
-    static_assert( a_int_r5::dimension::ArgN0 == 0, "" );
-    static_assert( a_int_r5::dimension::ArgN1 == 0, "" );
-    static_assert( a_int_r5::dimension::ArgN2 == 0, "" );
-    static_assert( a_int_r5::dimension::ArgN3 == 3, "" );
-    static_assert( a_int_r5::dimension::ArgN4 == 4, "" );
-    static_assert( std::is_same< typename a_int_r5::non_const_value_type, int >::value, "" );
+    typedef ViewArrayAnalysis<t_i4** * [3]> a_int_r5;
+
+    static_assert(a_int_r5::dimension::rank == 5, "");
+    static_assert(a_int_r5::dimension::rank_dynamic == 3, "");
+    static_assert(a_int_r5::dimension::ArgN0 == 0, "");
+    static_assert(a_int_r5::dimension::ArgN1 == 0, "");
+    static_assert(a_int_r5::dimension::ArgN2 == 0, "");
+    static_assert(a_int_r5::dimension::ArgN3 == 3, "");
+    static_assert(a_int_r5::dimension::ArgN4 == 4, "");
+    static_assert(
+        std::is_same<typename a_int_r5::non_const_value_type, int>::value, "");
   }
 
   {
     using namespace Kokkos::Impl;
 
-    typedef ViewDataAnalysis< const int[], void >  a_const_int_r1;
-
-    static_assert( std::is_same< typename a_const_int_r1::specialize, void >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::dimension, Kokkos::Impl::ViewDimension<0> >::value, "" );
-
-    static_assert( std::is_same< typename a_const_int_r1::type, const int * >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::value_type, const int >::value, "" );
-
-    static_assert( std::is_same< typename a_const_int_r1::scalar_array_type, const int * >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::const_type, const int * >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::const_value_type, const int >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::const_scalar_array_type, const int * >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::non_const_type, int * >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r1::non_const_value_type, int >::value, "" );
-
-    typedef ViewDataAnalysis< const int**[4], void >  a_const_int_r3;
-
-    static_assert( std::is_same< typename a_const_int_r3::specialize, void >::value, "" );
-
-    static_assert( std::is_same< typename a_const_int_r3::dimension, Kokkos::Impl::ViewDimension<0, 0, 4> >::value, "" );
-
-    static_assert( std::is_same< typename a_const_int_r3::type, const int**[4] >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::value_type, const int >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::scalar_array_type, const int**[4] >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::const_type, const int**[4] >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::const_value_type, const int >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::const_scalar_array_type, const int**[4] >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::non_const_type, int**[4] >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::non_const_value_type, int >::value, "" );
-    static_assert( std::is_same< typename a_const_int_r3::non_const_scalar_array_type, int**[4] >::value, "" );
-
-    // std::cout << "typeid( const int**[4] ).name() = " << typeid( const int**[4] ).name() << std::endl;
+    typedef ViewDataAnalysis<const int[], void> a_const_int_r1;
+
+    static_assert(
+        std::is_same<typename a_const_int_r1::specialize, void>::value, "");
+    static_assert(std::is_same<typename a_const_int_r1::dimension,
+                               Kokkos::Impl::ViewDimension<0> >::value,
+                  "");
+
+    static_assert(
+        std::is_same<typename a_const_int_r1::type, const int*>::value, "");
+    static_assert(
+        std::is_same<typename a_const_int_r1::value_type, const int>::value,
+        "");
+
+    static_assert(std::is_same<typename a_const_int_r1::scalar_array_type,
+                               const int*>::value,
+                  "");
+    static_assert(
+        std::is_same<typename a_const_int_r1::const_type, const int*>::value,
+        "");
+    static_assert(std::is_same<typename a_const_int_r1::const_value_type,
+                               const int>::value,
+                  "");
+    static_assert(std::is_same<typename a_const_int_r1::const_scalar_array_type,
+                               const int*>::value,
+                  "");
+    static_assert(
+        std::is_same<typename a_const_int_r1::non_const_type, int*>::value, "");
+    static_assert(
+        std::is_same<typename a_const_int_r1::non_const_value_type, int>::value,
+        "");
+
+    typedef ViewDataAnalysis<const int* * [4], void> a_const_int_r3;
+
+    static_assert(
+        std::is_same<typename a_const_int_r3::specialize, void>::value, "");
+
+    static_assert(std::is_same<typename a_const_int_r3::dimension,
+                               Kokkos::Impl::ViewDimension<0, 0, 4> >::value,
+                  "");
+
+    static_assert(
+        std::is_same<typename a_const_int_r3::type, const int* * [4]>::value,
+        "");
+    static_assert(
+        std::is_same<typename a_const_int_r3::value_type, const int>::value,
+        "");
+    static_assert(std::is_same<typename a_const_int_r3::scalar_array_type,
+                               const int* * [4]>::value,
+                  "");
+    static_assert(std::is_same<typename a_const_int_r3::const_type,
+                               const int* * [4]>::value,
+                  "");
+    static_assert(std::is_same<typename a_const_int_r3::const_value_type,
+                               const int>::value,
+                  "");
+    static_assert(std::is_same<typename a_const_int_r3::const_scalar_array_type,
+                               const int* * [4]>::value,
+                  "");
+    static_assert(std::is_same<typename a_const_int_r3::non_const_type,
+                               int* * [4]>::value,
+                  "");
+    static_assert(
+        std::is_same<typename a_const_int_r3::non_const_value_type, int>::value,
+        "");
+    static_assert(
+        std::is_same<typename a_const_int_r3::non_const_scalar_array_type,
+                     int* * [4]>::value,
+        "");
+
+    // std::cout << "typeid( const int**[4] ).name() = " << typeid( const
+    // int**[4] ).name() << std::endl;
   }
 
   //----------------------------------------
@@ -657,393 +706,398 @@ void test_view_mapping()
   {
     constexpr int N = 10;
 
-    typedef Kokkos::View< int*, Space >        T;
-    typedef Kokkos::View< const int*, Space >  C;
+    typedef Kokkos::View<int*, Space> T;
+    typedef Kokkos::View<const int*, Space> C;
 
     int data[N];
 
-    T vr1( data, N ); // View of non-const.
-    C cr1( vr1 );     // View of const from view of non-const.
-    C cr2( (const int *) data, N );
+    T vr1(data, N);  // View of non-const.
+    C cr1(vr1);      // View of const from view of non-const.
+    C cr2((const int*)data, N);
 
     // Generate static_assert error:
     // T tmp( cr1 );
 
-    ASSERT_EQ( vr1.span(), N );
-    ASSERT_EQ( cr1.span(), N );
-    ASSERT_EQ( vr1.data(), & data[0] );
-    ASSERT_EQ( cr1.data(), & data[0] );
+    ASSERT_EQ(vr1.span(), N);
+    ASSERT_EQ(cr1.span(), N);
+    ASSERT_EQ(vr1.data(), &data[0]);
+    ASSERT_EQ(cr1.data(), &data[0]);
 
-    ASSERT_TRUE( ( std::is_same< typename T::data_type          , int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::const_data_type    , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::non_const_data_type, int* >::value ) );
+    ASSERT_TRUE((std::is_same<typename T::data_type, int*>::value));
+    ASSERT_TRUE((std::is_same<typename T::const_data_type, const int*>::value));
+    ASSERT_TRUE((std::is_same<typename T::non_const_data_type, int*>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename T::scalar_array_type          , int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::const_scalar_array_type    , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::non_const_scalar_array_type, int* >::value ) );
+    ASSERT_TRUE((std::is_same<typename T::scalar_array_type, int*>::value));
+    ASSERT_TRUE(
+        (std::is_same<typename T::const_scalar_array_type, const int*>::value));
+    ASSERT_TRUE(
+        (std::is_same<typename T::non_const_scalar_array_type, int*>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename T::value_type          , int >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::const_value_type    , const int >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::non_const_value_type, int >::value ) );
+    ASSERT_TRUE((std::is_same<typename T::value_type, int>::value));
+    ASSERT_TRUE((std::is_same<typename T::const_value_type, const int>::value));
+    ASSERT_TRUE((std::is_same<typename T::non_const_value_type, int>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename T::memory_space, typename Space::memory_space >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::reference_type, int & >::value ) );
+    ASSERT_TRUE((std::is_same<typename T::memory_space,
+                              typename Space::memory_space>::value));
+    ASSERT_TRUE((std::is_same<typename T::reference_type, int&>::value));
 
-    ASSERT_EQ( T::Rank, 1 );
+    ASSERT_EQ(T::Rank, 1);
 
-    ASSERT_TRUE( ( std::is_same< typename C::data_type          , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename C::const_data_type    , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename C::non_const_data_type, int* >::value ) );
+    ASSERT_TRUE((std::is_same<typename C::data_type, const int*>::value));
+    ASSERT_TRUE((std::is_same<typename C::const_data_type, const int*>::value));
+    ASSERT_TRUE((std::is_same<typename C::non_const_data_type, int*>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename C::scalar_array_type          , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename C::const_scalar_array_type    , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename C::non_const_scalar_array_type, int* >::value ) );
+    ASSERT_TRUE(
+        (std::is_same<typename C::scalar_array_type, const int*>::value));
+    ASSERT_TRUE(
+        (std::is_same<typename C::const_scalar_array_type, const int*>::value));
+    ASSERT_TRUE(
+        (std::is_same<typename C::non_const_scalar_array_type, int*>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename C::value_type          , const int >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename C::const_value_type    , const int >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename C::non_const_value_type, int >::value ) );
+    ASSERT_TRUE((std::is_same<typename C::value_type, const int>::value));
+    ASSERT_TRUE((std::is_same<typename C::const_value_type, const int>::value));
+    ASSERT_TRUE((std::is_same<typename C::non_const_value_type, int>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename C::memory_space, typename Space::memory_space >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename C::reference_type, const int & >::value ) );
+    ASSERT_TRUE((std::is_same<typename C::memory_space,
+                              typename Space::memory_space>::value));
+    ASSERT_TRUE((std::is_same<typename C::reference_type, const int&>::value));
 
-    ASSERT_EQ( C::Rank, 1 );
+    ASSERT_EQ(C::Rank, 1);
 
-    ASSERT_EQ( vr1.extent(0), N );
+    ASSERT_EQ(vr1.extent(0), N);
 
-    if ( Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, typename Space::memory_space >::accessible ) {
-      for ( int i = 0; i < N; ++i ) data[i] = i + 1;
-      for ( int i = 0; i < N; ++i ) ASSERT_EQ( vr1[i], i + 1 );
-      for ( int i = 0; i < N; ++i ) ASSERT_EQ( cr1[i], i + 1 );
+    if (Kokkos::Impl::SpaceAccessibility<
+            Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+      for (int i = 0; i < N; ++i) data[i] = i + 1;
+      for (int i = 0; i < N; ++i) ASSERT_EQ(vr1[i], i + 1);
+      for (int i = 0; i < N; ++i) ASSERT_EQ(cr1[i], i + 1);
 
       {
-        T tmp( vr1 );
+        T tmp(vr1);
 
-        for ( int i = 0; i < N; ++i ) ASSERT_EQ( tmp[i], i + 1 );
-        for ( int i = 0; i < N; ++i ) vr1( i ) = i + 2;
-        for ( int i = 0; i < N; ++i ) ASSERT_EQ( tmp[i], i + 2 );
+        for (int i = 0; i < N; ++i) ASSERT_EQ(tmp[i], i + 1);
+        for (int i = 0; i < N; ++i) vr1(i) = i + 2;
+        for (int i = 0; i < N; ++i) ASSERT_EQ(tmp[i], i + 2);
       }
 
-      for ( int i = 0; i < N; ++i ) ASSERT_EQ( vr1[i], i + 2 );
+      for (int i = 0; i < N; ++i) ASSERT_EQ(vr1[i], i + 2);
     }
   }
 
   {
     constexpr int N = 10;
-    typedef Kokkos::View< int*, Space >        T;
-    typedef Kokkos::View< const int*, Space >  C;
+    typedef Kokkos::View<int*, Space> T;
+    typedef Kokkos::View<const int*, Space> C;
 
-    T vr1( "vr1", N );
-    C cr1( vr1 );
+    T vr1("vr1", N);
+    C cr1(vr1);
 
-    ASSERT_TRUE( ( std::is_same< typename T::data_type          , int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::const_data_type    , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::non_const_data_type, int* >::value ) );
+    ASSERT_TRUE((std::is_same<typename T::data_type, int*>::value));
+    ASSERT_TRUE((std::is_same<typename T::const_data_type, const int*>::value));
+    ASSERT_TRUE((std::is_same<typename T::non_const_data_type, int*>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename T::scalar_array_type          , int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::const_scalar_array_type    , const int* >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::non_const_scalar_array_type, int* >::value ) );
+    ASSERT_TRUE((std::is_same<typename T::scalar_array_type, int*>::value));
+    ASSERT_TRUE(
+        (std::is_same<typename T::const_scalar_array_type, const int*>::value));
+    ASSERT_TRUE(
+        (std::is_same<typename T::non_const_scalar_array_type, int*>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename T::value_type          , int >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::const_value_type    , const int >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::non_const_value_type, int >::value ) );
+    ASSERT_TRUE((std::is_same<typename T::value_type, int>::value));
+    ASSERT_TRUE((std::is_same<typename T::const_value_type, const int>::value));
+    ASSERT_TRUE((std::is_same<typename T::non_const_value_type, int>::value));
 
-    ASSERT_TRUE( ( std::is_same< typename T::memory_space, typename Space::memory_space >::value ) );
-    ASSERT_TRUE( ( std::is_same< typename T::reference_type, int & >::value ) );
-    ASSERT_EQ( T::Rank, 1 );
+    ASSERT_TRUE((std::is_same<typename T::memory_space,
+                              typename Space::memory_space>::value));
+    ASSERT_TRUE((std::is_same<typename T::reference_type, int&>::value));
+    ASSERT_EQ(T::Rank, 1);
 
-    ASSERT_EQ( vr1.extent(0), N );
+    ASSERT_EQ(vr1.extent(0), N);
 
-    if ( Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, typename Space::memory_space >::accessible ) {
-      for ( int i = 0; i < N; ++i ) vr1( i ) = i + 1;
-      for ( int i = 0; i < N; ++i ) ASSERT_EQ( vr1[i], i + 1 );
-      for ( int i = 0; i < N; ++i ) ASSERT_EQ( cr1[i], i + 1 );
+    if (Kokkos::Impl::SpaceAccessibility<
+            Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+      for (int i = 0; i < N; ++i) vr1(i) = i + 1;
+      for (int i = 0; i < N; ++i) ASSERT_EQ(vr1[i], i + 1);
+      for (int i = 0; i < N; ++i) ASSERT_EQ(cr1[i], i + 1);
 
       {
-        T tmp( vr1 );
-        for ( int i = 0; i < N; ++i ) ASSERT_EQ( tmp[i], i + 1 );
-        for ( int i = 0; i < N; ++i ) vr1( i ) = i + 2;
-        for ( int i = 0; i < N; ++i ) ASSERT_EQ( tmp[i], i + 2 );
+        T tmp(vr1);
+        for (int i = 0; i < N; ++i) ASSERT_EQ(tmp[i], i + 1);
+        for (int i = 0; i < N; ++i) vr1(i) = i + 2;
+        for (int i = 0; i < N; ++i) ASSERT_EQ(tmp[i], i + 2);
       }
 
-      for ( int i = 0; i < N; ++i ) ASSERT_EQ( vr1[i], i + 2 );
+      for (int i = 0; i < N; ++i) ASSERT_EQ(vr1[i], i + 2);
     }
   }
 
   // Testing proper handling of zero-length allocations.
   {
     constexpr int N = 0;
-    typedef Kokkos::View< int*, Space >        T;
-    typedef Kokkos::View< const int*, Space >  C;
+    typedef Kokkos::View<int*, Space> T;
+    typedef Kokkos::View<const int*, Space> C;
 
-    T vr1( "vr1", N );
-    C cr1( vr1 );
+    T vr1("vr1", N);
+    C cr1(vr1);
 
-    ASSERT_EQ( vr1.extent(0), 0 );
-    ASSERT_EQ( cr1.extent(0), 0 );
+    ASSERT_EQ(vr1.extent(0), 0);
+    ASSERT_EQ(cr1.extent(0), 0);
   }
 
   // Testing using space instance for allocation.
-  // The execution space of the memory space must be available for view data initialization.
-  if ( std::is_same< ExecSpace, typename ExecSpace::memory_space::execution_space >::value ) {
-
+  // The execution space of the memory space must be available for view data
+  // initialization.
+  if (std::is_same<ExecSpace,
+                   typename ExecSpace::memory_space::execution_space>::value) {
     using namespace Kokkos;
 
-    typedef typename ExecSpace::memory_space  memory_space;
-    typedef View< int*, memory_space >        V;
+    typedef typename ExecSpace::memory_space memory_space;
+    typedef View<int*, memory_space> V;
 
     constexpr int N = 10;
 
     memory_space mem_space;
 
-    V v( "v", N );
-    V va( view_alloc(), N );
-    V vb( view_alloc( "vb" ), N );
-    V vc( view_alloc( "vc", AllowPadding ), N );
-    V vd( view_alloc( "vd", WithoutInitializing ), N );
-    V ve( view_alloc( "ve", WithoutInitializing, AllowPadding ), N );
-    V vf( view_alloc( "vf", mem_space, WithoutInitializing, AllowPadding ), N );
-    V vg( view_alloc( mem_space, "vg", WithoutInitializing, AllowPadding ), N );
-    V vh( view_alloc( WithoutInitializing, AllowPadding ), N );
-    V vi( view_alloc( WithoutInitializing ), N );
-    V vj( view_alloc( std::string( "vj" ), AllowPadding ), N );
-    V vk( view_alloc( mem_space, std::string( "vk" ), AllowPadding ), N );
+    V v("v", N);
+    V va(view_alloc(), N);
+    V vb(view_alloc("vb"), N);
+    V vc(view_alloc("vc", AllowPadding), N);
+    V vd(view_alloc("vd", WithoutInitializing), N);
+    V ve(view_alloc("ve", WithoutInitializing, AllowPadding), N);
+    V vf(view_alloc("vf", mem_space, WithoutInitializing, AllowPadding), N);
+    V vg(view_alloc(mem_space, "vg", WithoutInitializing, AllowPadding), N);
+    V vh(view_alloc(WithoutInitializing, AllowPadding), N);
+    V vi(view_alloc(WithoutInitializing), N);
+    V vj(view_alloc(std::string("vj"), AllowPadding), N);
+    V vk(view_alloc(mem_space, std::string("vk"), AllowPadding), N);
   }
 
   {
-    typedef Kokkos::ViewTraits< int***, Kokkos::LayoutStride, ExecSpace >           traits_t;
-    typedef Kokkos::Impl::ViewDimension< 0, 0, 0 >                    dims_t;
-    typedef Kokkos::Impl::ViewOffset< dims_t, Kokkos::LayoutStride >  offset_t;
+    typedef Kokkos::ViewTraits<int***, Kokkos::LayoutStride, ExecSpace>
+        traits_t;
+    typedef Kokkos::Impl::ViewDimension<0, 0, 0> dims_t;
+    typedef Kokkos::Impl::ViewOffset<dims_t, Kokkos::LayoutStride> offset_t;
 
     Kokkos::LayoutStride stride;
 
     stride.dimension[0] = 3;
     stride.dimension[1] = 4;
     stride.dimension[2] = 5;
-    stride.stride[0] = 4;
-    stride.stride[1] = 1;
-    stride.stride[2] = 12;
+    stride.stride[0]    = 4;
+    stride.stride[1]    = 1;
+    stride.stride[2]    = 12;
 
-    const offset_t offset( std::integral_constant< unsigned, 0 >(), stride );
+    const offset_t offset(std::integral_constant<unsigned, 0>(), stride);
 
-    ASSERT_EQ( offset.dimension_0(), 3 );
-    ASSERT_EQ( offset.dimension_1(), 4 );
-    ASSERT_EQ( offset.dimension_2(), 5 );
+    ASSERT_EQ(offset.dimension_0(), 3);
+    ASSERT_EQ(offset.dimension_1(), 4);
+    ASSERT_EQ(offset.dimension_2(), 5);
 
-    ASSERT_EQ( offset.stride_0(), 4 );
-    ASSERT_EQ( offset.stride_1(), 1 );
-    ASSERT_EQ( offset.stride_2(), 12 );
+    ASSERT_EQ(offset.stride_0(), 4);
+    ASSERT_EQ(offset.stride_1(), 1);
+    ASSERT_EQ(offset.stride_2(), 12);
 
-    ASSERT_EQ( offset.span(), 60 );
-    ASSERT_TRUE( offset.span_is_contiguous() );
+    ASSERT_EQ(offset.span(), 60);
+    ASSERT_TRUE(offset.span_is_contiguous());
 
-    Kokkos::Impl::ViewMapping< traits_t, void >
-      v( Kokkos::Impl::ViewCtorProp< int* >( (int*) 0 ), stride );
+    Kokkos::Impl::ViewMapping<traits_t, void> v(
+        Kokkos::Impl::ViewCtorProp<int*>((int*)0), stride);
   }
 
   {
-    typedef Kokkos::View< int**, Space > V;
+    typedef Kokkos::View<int**, Space> V;
     typedef typename V::HostMirror M;
-    typedef typename Kokkos::View< int**, Space >::array_layout layout_type;
+    typedef typename Kokkos::View<int**, Space>::array_layout layout_type;
 
     constexpr int N0 = 10;
     constexpr int N1 = 11;
 
-    V a( "a", N0, N1 );
-    M b = Kokkos::create_mirror( a );
-    M c = Kokkos::create_mirror_view( a );
+    V a("a", N0, N1);
+    M b = Kokkos::create_mirror(a);
+    M c = Kokkos::create_mirror_view(a);
     M d;
 
-    for ( int i0 = 0; i0 < N0; ++i0 )
-    for ( int i1 = 0; i1 < N1; ++i1 )
-    {
-      b( i0, i1 ) = 1 + i0 + i1 * N0;
-    }
-
-    Kokkos::deep_copy( a, b );
-    Kokkos::deep_copy( c, a );
-
-    for ( int i0 = 0; i0 < N0; ++i0 )
-    for ( int i1 = 0; i1 < N1; ++i1 )
-    {
-      ASSERT_EQ( b( i0, i1 ), c( i0, i1 ) );
-    }
+    for (int i0 = 0; i0 < N0; ++i0)
+      for (int i1 = 0; i1 < N1; ++i1) {
+        b(i0, i1) = 1 + i0 + i1 * N0;
+      }
 
-    Kokkos::resize( b, 5, 6 );
+    Kokkos::deep_copy(a, b);
+    Kokkos::deep_copy(c, a);
 
-    for ( int i0 = 0; i0 < 5; ++i0 )
-    for ( int i1 = 0; i1 < 6; ++i1 )
-    {
-      int val = 1 + i0 + i1 * N0;
-      ASSERT_EQ( b( i0, i1 ), c( i0, i1 ) );
-      ASSERT_EQ( b( i0, i1 ), val );
-    }
+    for (int i0 = 0; i0 < N0; ++i0)
+      for (int i1 = 0; i1 < N1; ++i1) {
+        ASSERT_EQ(b(i0, i1), c(i0, i1));
+      }
 
-    Kokkos::realloc( c, 5, 6 );
-    Kokkos::realloc( d, 5, 6 );
+    Kokkos::resize(b, 5, 6);
 
-    ASSERT_EQ( b.extent(0), 5 );
-    ASSERT_EQ( b.extent(1), 6 );
-    ASSERT_EQ( c.extent(0), 5 );
-    ASSERT_EQ( c.extent(1), 6 );
-    ASSERT_EQ( d.extent(0), 5 );
-    ASSERT_EQ( d.extent(1), 6 );
+    for (int i0 = 0; i0 < 5; ++i0)
+      for (int i1 = 0; i1 < 6; ++i1) {
+        int val = 1 + i0 + i1 * N0;
+        ASSERT_EQ(b(i0, i1), c(i0, i1));
+        ASSERT_EQ(b(i0, i1), val);
+      }
 
-    layout_type layout( 7, 8 );
-    Kokkos::resize( b, layout );
-    for ( int i0 = 0; i0 < 7; ++i0 )
-    for ( int i1 = 6; i1 < 8; ++i1 )
-    {
-      b( i0, i1 ) = 1 + i0 + i1 * N0;
-    }
+    Kokkos::realloc(c, 5, 6);
+    Kokkos::realloc(d, 5, 6);
+
+    ASSERT_EQ(b.extent(0), 5);
+    ASSERT_EQ(b.extent(1), 6);
+    ASSERT_EQ(c.extent(0), 5);
+    ASSERT_EQ(c.extent(1), 6);
+    ASSERT_EQ(d.extent(0), 5);
+    ASSERT_EQ(d.extent(1), 6);
+
+    layout_type layout(7, 8);
+    Kokkos::resize(b, layout);
+    for (int i0 = 0; i0 < 7; ++i0)
+      for (int i1 = 6; i1 < 8; ++i1) {
+        b(i0, i1) = 1 + i0 + i1 * N0;
+      }
 
-    for ( int i0 = 5; i0 < 7; ++i0 )
-    for ( int i1 = 0; i1 < 8; ++i1 )
-    {
-      b( i0, i1 ) = 1 + i0 + i1 * N0;
-    }
+    for (int i0 = 5; i0 < 7; ++i0)
+      for (int i1 = 0; i1 < 8; ++i1) {
+        b(i0, i1) = 1 + i0 + i1 * N0;
+      }
 
-    for ( int i0 = 0; i0 < 7; ++i0 )
-    for ( int i1 = 0; i1 < 8; ++i1 )
-    {
-       int val = 1 + i0 + i1 * N0;
-       ASSERT_EQ( b( i0, i1 ), val );
-    }
+    for (int i0 = 0; i0 < 7; ++i0)
+      for (int i1 = 0; i1 < 8; ++i1) {
+        int val = 1 + i0 + i1 * N0;
+        ASSERT_EQ(b(i0, i1), val);
+      }
 
-    Kokkos::realloc( c, layout );
-    Kokkos::realloc( d, layout );
+    Kokkos::realloc(c, layout);
+    Kokkos::realloc(d, layout);
 
-    ASSERT_EQ( b.extent(0), 7 );
-    ASSERT_EQ( b.extent(1), 8 );
-    ASSERT_EQ( c.extent(0), 7 );
-    ASSERT_EQ( c.extent(1), 8 );
-    ASSERT_EQ( d.extent(0), 7 );
-    ASSERT_EQ( d.extent(1), 8 );
+    ASSERT_EQ(b.extent(0), 7);
+    ASSERT_EQ(b.extent(1), 8);
+    ASSERT_EQ(c.extent(0), 7);
+    ASSERT_EQ(c.extent(1), 8);
+    ASSERT_EQ(d.extent(0), 7);
+    ASSERT_EQ(d.extent(1), 8);
   }
 
   {
-    typedef Kokkos::View< int**, Kokkos::LayoutStride, Space > V;
+    typedef Kokkos::View<int**, Kokkos::LayoutStride, Space> V;
     typedef typename V::HostMirror M;
-    typedef typename Kokkos::View< int**, Kokkos::LayoutStride, Space >::array_layout layout_type;
+    typedef
+        typename Kokkos::View<int**, Kokkos::LayoutStride, Space>::array_layout
+            layout_type;
 
     constexpr int N0 = 10;
     constexpr int N1 = 11;
 
-    const int dimensions[] = { N0, N1 };
-    const int order[] = { 1, 0 };
+    const int dimensions[] = {N0, N1};
+    const int order[]      = {1, 0};
 
-    V a( "a", Kokkos::LayoutStride::order_dimensions( 2, order, dimensions ) );
-    M b = Kokkos::create_mirror( a );
-    M c = Kokkos::create_mirror_view( a );
+    V a("a", Kokkos::LayoutStride::order_dimensions(2, order, dimensions));
+    M b = Kokkos::create_mirror(a);
+    M c = Kokkos::create_mirror_view(a);
     M d;
 
-    for ( int i0 = 0; i0 < N0; ++i0 )
-    for ( int i1 = 0; i1 < N1; ++i1 )
-    {
-      b( i0, i1 ) = 1 + i0 + i1 * N0;
-    }
-
-    Kokkos::deep_copy( a, b );
-    Kokkos::deep_copy( c, a );
+    for (int i0 = 0; i0 < N0; ++i0)
+      for (int i1 = 0; i1 < N1; ++i1) {
+        b(i0, i1) = 1 + i0 + i1 * N0;
+      }
 
-    for ( int i0 = 0; i0 < N0; ++i0 )
-    for ( int i1 = 0; i1 < N1; ++i1 )
-    {
-      ASSERT_EQ( b( i0, i1 ), c( i0, i1 ) );
-    }
+    Kokkos::deep_copy(a, b);
+    Kokkos::deep_copy(c, a);
 
-    const int dimensions2[] = { 7, 8 };
-    const int order2[] = { 1, 0 };
-    layout_type layout = layout_type::order_dimensions( 2, order2, dimensions2 );
-    Kokkos::resize( b, layout );
+    for (int i0 = 0; i0 < N0; ++i0)
+      for (int i1 = 0; i1 < N1; ++i1) {
+        ASSERT_EQ(b(i0, i1), c(i0, i1));
+      }
 
-    for ( int i0 = 0; i0 < 7; ++i0 )
-    for ( int i1 = 0; i1 < 8; ++i1 )
-    {
-       int val = 1 + i0 + i1 * N0;
-       ASSERT_EQ( b( i0, i1 ), c( i0, i1 ) );
-       ASSERT_EQ( b( i0, i1 ), val );
-    }
+    const int dimensions2[] = {7, 8};
+    const int order2[]      = {1, 0};
+    layout_type layout = layout_type::order_dimensions(2, order2, dimensions2);
+    Kokkos::resize(b, layout);
 
-    Kokkos::realloc( c, layout );
-    Kokkos::realloc( d, layout );
+    for (int i0 = 0; i0 < 7; ++i0)
+      for (int i1 = 0; i1 < 8; ++i1) {
+        int val = 1 + i0 + i1 * N0;
+        ASSERT_EQ(b(i0, i1), c(i0, i1));
+        ASSERT_EQ(b(i0, i1), val);
+      }
 
-    ASSERT_EQ( b.extent(0), 7 );
-    ASSERT_EQ( b.extent(1), 8 );
-    ASSERT_EQ( c.extent(0), 7 );
-    ASSERT_EQ( c.extent(1), 8 );
-    ASSERT_EQ( d.extent(0), 7 );
-    ASSERT_EQ( d.extent(1), 8 );
+    Kokkos::realloc(c, layout);
+    Kokkos::realloc(d, layout);
 
+    ASSERT_EQ(b.extent(0), 7);
+    ASSERT_EQ(b.extent(1), 8);
+    ASSERT_EQ(c.extent(0), 7);
+    ASSERT_EQ(c.extent(1), 8);
+    ASSERT_EQ(d.extent(0), 7);
+    ASSERT_EQ(d.extent(1), 8);
   }
 
   {
-    typedef Kokkos::View< int*, Space > V;
-    typedef Kokkos::View< int*, Space, Kokkos::MemoryUnmanaged > U;
+    typedef Kokkos::View<int*, Space> V;
+    typedef Kokkos::View<int*, Space, Kokkos::MemoryUnmanaged> U;
 
-    V a( "a", 10 );
+    V a("a", 10);
 
-    ASSERT_EQ( a.use_count(), 1 );
+    ASSERT_EQ(a.use_count(), 1);
 
     V b = a;
 
-    ASSERT_EQ( a.use_count(), 2 );
-    ASSERT_EQ( b.use_count(), 2 );
+    ASSERT_EQ(a.use_count(), 2);
+    ASSERT_EQ(b.use_count(), 2);
 
     {
-      U c = b; // 'c' is compile-time unmanaged.
+      U c = b;  // 'c' is compile-time unmanaged.
 
-      ASSERT_EQ( a.use_count(), 2 );
-      ASSERT_EQ( b.use_count(), 2 );
-      ASSERT_EQ( c.use_count(), 2 );
+      ASSERT_EQ(a.use_count(), 2);
+      ASSERT_EQ(b.use_count(), 2);
+      ASSERT_EQ(c.use_count(), 2);
 
-      V d = c; // 'd' is run-time unmanaged.
+      V d = c;  // 'd' is run-time unmanaged.
 
-      ASSERT_EQ( a.use_count(), 2 );
-      ASSERT_EQ( b.use_count(), 2 );
-      ASSERT_EQ( c.use_count(), 2 );
-      ASSERT_EQ( d.use_count(), 2 );
+      ASSERT_EQ(a.use_count(), 2);
+      ASSERT_EQ(b.use_count(), 2);
+      ASSERT_EQ(c.use_count(), 2);
+      ASSERT_EQ(d.use_count(), 2);
     }
 
-    ASSERT_EQ( a.use_count(), 2 );
-    ASSERT_EQ( b.use_count(), 2 );
+    ASSERT_EQ(a.use_count(), 2);
+    ASSERT_EQ(b.use_count(), 2);
 
     b = V();
 
-    ASSERT_EQ( a.use_count(), 1 );
-    ASSERT_EQ( b.use_count(), 0 );
+    ASSERT_EQ(a.use_count(), 1);
+    ASSERT_EQ(b.use_count(), 0);
 
-// TODO: a.use_count() and x.use_count() are 0 with the asynchronous HPX backend. Why?
-#if !defined( KOKKOS_ENABLE_CUDA_LAMBDA ) && !defined( KOKKOS_ENABLE_ROCM ) && \
-    !(defined( KOKKOS_ENABLE_HPX ) && defined( KOKKOS_ENABLE_HPX_ASYNC_DISPATCH ))
+// TODO: a.use_count() and x.use_count() are 0 with the asynchronous HPX
+// backend. Why?
+#if !defined(KOKKOS_ENABLE_CUDA_LAMBDA) && !defined(KOKKOS_ENABLE_ROCM) && \
+    !(defined(KOKKOS_ENABLE_HPX) && defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH))
     // Cannot launch host lambda when CUDA lambda is enabled.
 
-    typedef typename Kokkos::Impl::HostMirror< Space >::Space::execution_space host_exec_space;
-
-    Kokkos::parallel_for( Kokkos::RangePolicy< host_exec_space >( 0, 10 ), KOKKOS_LAMBDA ( int ) {
-      // 'a' is captured by copy, and the capture mechanism converts 'a' to an
-      // unmanaged copy.  When the parallel dispatch accepts a move for the
-      // lambda, this count should become 1.
- 
-      ASSERT_EQ( a.use_count(), 2 );
-      V x = a;
-      ASSERT_EQ( a.use_count(), 2 );
-      ASSERT_EQ( x.use_count(), 2 );
-    });
-#endif // #if !defined( KOKKOS_ENABLE_CUDA_LAMBDA )
+    typedef typename Kokkos::Impl::HostMirror<Space>::Space::execution_space
+        host_exec_space;
+
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<host_exec_space>(0, 10), KOKKOS_LAMBDA(int) {
+          // 'a' is captured by copy, and the capture mechanism converts 'a' to
+          // an unmanaged copy.  When the parallel dispatch accepts a move for
+          // the lambda, this count should become 1.
+
+          ASSERT_EQ(a.use_count(), 2);
+          V x = a;
+          ASSERT_EQ(a.use_count(), 2);
+          ASSERT_EQ(x.use_count(), 2);
+        });
+#endif  // #if !defined( KOKKOS_ENABLE_CUDA_LAMBDA )
   }
 }
 
-TEST_F( TEST_CATEGORY , view_mapping )
-{
-   test_view_mapping< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, view_mapping) { test_view_mapping<TEST_EXECSPACE>(); }
 /*--------------------------------------------------------------------------*/
 
-template< class ViewType >
+template <class ViewType>
 struct TestViewMapOperator {
-
-  static_assert( ViewType::reference_type_is_lvalue_reference
-               , "Test only valid for lvalue reference type" );
+  static_assert(ViewType::reference_type_is_lvalue_reference,
+                "Test only valid for lvalue reference type");
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
   const ViewType v;
@@ -1052,12 +1106,12 @@ struct TestViewMapOperator {
 #endif
 
   KOKKOS_INLINE_FUNCTION
-  void test_left( size_t i0, long & error_count ) const
-  {
+  void test_left(size_t i0, long& error_count) const {
 #ifdef KOKKOS_ENABLE_DEPPRECATED_CODE
-    typename ViewType::value_type * const base_ptr = & v( 0, 0, 0, 0, 0, 0, 0, 0 );
+    typename ViewType::value_type* const base_ptr = &v(0, 0, 0, 0, 0, 0, 0, 0);
 #else
-    typename ViewType::value_type * const base_ptr = & v.access( 0, 0, 0, 0, 0, 0, 0, 0 );
+    typename ViewType::value_type* const base_ptr =
+        &v.access(0, 0, 0, 0, 0, 0, 0, 0);
 #endif
     const size_t n1 = v.extent(1);
     const size_t n2 = v.extent(2);
@@ -1069,33 +1123,33 @@ struct TestViewMapOperator {
 
     long offset = 0;
 
-    for ( size_t i7 = 0; i7 < n7; ++i7 )
-    for ( size_t i6 = 0; i6 < n6; ++i6 )
-    for ( size_t i5 = 0; i5 < n5; ++i5 )
-    for ( size_t i4 = 0; i4 < n4; ++i4 )
-    for ( size_t i3 = 0; i3 < n3; ++i3 )
-    for ( size_t i2 = 0; i2 < n2; ++i2 )
-    for ( size_t i1 = 0; i1 < n1; ++i1 )
-    {
+    for (size_t i7 = 0; i7 < n7; ++i7)
+      for (size_t i6 = 0; i6 < n6; ++i6)
+        for (size_t i5 = 0; i5 < n5; ++i5)
+          for (size_t i4 = 0; i4 < n4; ++i4)
+            for (size_t i3 = 0; i3 < n3; ++i3)
+              for (size_t i2 = 0; i2 < n2; ++i2)
+                for (size_t i1 = 0; i1 < n1; ++i1) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-        const long d = & v( i0, i1, i2, i3, i4, i5, i6, i7 ) - base_ptr;
+                  const long d = &v(i0, i1, i2, i3, i4, i5, i6, i7) - base_ptr;
 #else
-        const long d = & v.access( i0, i1, i2, i3, i4, i5, i6, i7 ) - base_ptr;
+                  const long d =
+                      &v.access(i0, i1, i2, i3, i4, i5, i6, i7) - base_ptr;
 #endif
-        if ( d < offset ) ++error_count;
-      offset = d;
-    }
+                  if (d < offset) ++error_count;
+                  offset = d;
+                }
 
-    if ( v.span() <= size_t( offset ) ) ++error_count;
+    if (v.span() <= size_t(offset)) ++error_count;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void test_right( size_t i0, long & error_count ) const
-  {
+  void test_right(size_t i0, long& error_count) const {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-    typename ViewType::value_type * const base_ptr = & v( 0, 0, 0, 0, 0, 0, 0, 0 );
+    typename ViewType::value_type* const base_ptr = &v(0, 0, 0, 0, 0, 0, 0, 0);
 #else
-    typename ViewType::value_type * const base_ptr = & v.access( 0, 0, 0, 0, 0, 0, 0, 0 );
+    typename ViewType::value_type* const base_ptr =
+        &v.access(0, 0, 0, 0, 0, 0, 0, 0);
 #endif
     const size_t n1 = v.extent(1);
     const size_t n2 = v.extent(2);
@@ -1107,34 +1161,34 @@ struct TestViewMapOperator {
 
     long offset = 0;
 
-    for ( size_t i1 = 0; i1 < n1; ++i1 )
-    for ( size_t i2 = 0; i2 < n2; ++i2 )
-    for ( size_t i3 = 0; i3 < n3; ++i3 )
-    for ( size_t i4 = 0; i4 < n4; ++i4 )
-    for ( size_t i5 = 0; i5 < n5; ++i5 )
-    for ( size_t i6 = 0; i6 < n6; ++i6 )
-    for ( size_t i7 = 0; i7 < n7; ++i7 )
-    {
+    for (size_t i1 = 0; i1 < n1; ++i1)
+      for (size_t i2 = 0; i2 < n2; ++i2)
+        for (size_t i3 = 0; i3 < n3; ++i3)
+          for (size_t i4 = 0; i4 < n4; ++i4)
+            for (size_t i5 = 0; i5 < n5; ++i5)
+              for (size_t i6 = 0; i6 < n6; ++i6)
+                for (size_t i7 = 0; i7 < n7; ++i7) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-        const long d = & v( i0, i1, i2, i3, i4, i5, i6, i7 ) - base_ptr;
+                  const long d = &v(i0, i1, i2, i3, i4, i5, i6, i7) - base_ptr;
 #else
-        const long d = & v.access( i0, i1, i2, i3, i4, i5, i6, i7 ) - base_ptr;
+                  const long d =
+                      &v.access(i0, i1, i2, i3, i4, i5, i6, i7) - base_ptr;
 #endif
-        if ( d < offset ) ++error_count;
-      offset = d;
-    }
+                  if (d < offset) ++error_count;
+                  offset = d;
+                }
 
-    if ( v.span() <= size_t( offset ) ) ++error_count;
+    if (v.span() <= size_t(offset)) ++error_count;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( size_t i, long & error_count ) const
-  {
-    if ( std::is_same< typename ViewType::array_layout, Kokkos::LayoutLeft >::value ) {
-      test_left( i, error_count );
-    }
-    else if ( std::is_same< typename ViewType::array_layout, Kokkos::LayoutRight >::value ) {
-      test_right( i, error_count );
+  void operator()(size_t i, long& error_count) const {
+    if (std::is_same<typename ViewType::array_layout,
+                     Kokkos::LayoutLeft>::value) {
+      test_left(i, error_count);
+    } else if (std::is_same<typename ViewType::array_layout,
+                            Kokkos::LayoutRight>::value) {
+      test_right(i, error_count);
     }
   }
 
@@ -1148,111 +1202,148 @@ struct TestViewMapOperator {
   enum { N7 = 3 };
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  TestViewMapOperator() : v( "Test", N0, N1, N2, N3, N4, N5, N6, N7 ) {}
+  TestViewMapOperator() : v("Test", N0, N1, N2, N3, N4, N5, N6, N7) {}
 
- #else
+#else
   TestViewMapOperator() {
-
     const size_t dyn_rank = v.rank_dynamic;
     const std::string label("Test");
-    switch(dyn_rank) {
-      case 0:
-        v = ViewType(label);
-        break;
-      case 1:
-        v = ViewType(label, N0);
-        break;
-      case 2:
-        v = ViewType(label, N0, N1);
-        break;
-      case 3:
-        v = ViewType(label, N0, N1, N2);
-        break;
-      case 4:
-        v = ViewType(label, N0, N1, N2, N3);
-        break;
-      case 5:
-        v = ViewType(label, N0, N1, N2, N3, N4);
-        break;
-      case 6:
-        v = ViewType(label, N0, N1, N2, N3, N4, N5);
-        break;
-      case 7:
-        v = ViewType(label, N0, N1, N2, N3, N4, N5, N6);
-        break;
+    switch (dyn_rank) {
+      case 0: v = ViewType(label); break;
+      case 1: v = ViewType(label, N0); break;
+      case 2: v = ViewType(label, N0, N1); break;
+      case 3: v = ViewType(label, N0, N1, N2); break;
+      case 4: v = ViewType(label, N0, N1, N2, N3); break;
+      case 5: v = ViewType(label, N0, N1, N2, N3, N4); break;
+      case 6: v = ViewType(label, N0, N1, N2, N3, N4, N5); break;
+      case 7: v = ViewType(label, N0, N1, N2, N3, N4, N5, N6); break;
       case 8:
-      default:
-        v = ViewType(label, N0, N1, N2, N3, N4, N5, N6, N7);
-
+      default: v = ViewType(label, N0, N1, N2, N3, N4, N5, N6, N7);
     }
-
   }
 
-
 #endif
-  void run()
-  {
-    ASSERT_EQ( v.extent(0), ( 0 < ViewType::rank ? TestViewMapOperator<ViewType>::N0 : 1 ) );
-    ASSERT_EQ( v.extent(1), ( 1 < ViewType::rank ? TestViewMapOperator<ViewType>::N1 : 1 ) );
-    ASSERT_EQ( v.extent(2), ( 2 < ViewType::rank ? TestViewMapOperator<ViewType>::N2 : 1 ) );
-    ASSERT_EQ( v.extent(3), ( 3 < ViewType::rank ? TestViewMapOperator<ViewType>::N3 : 1 ) );
-    ASSERT_EQ( v.extent(4), ( 4 < ViewType::rank ? TestViewMapOperator<ViewType>::N4 : 1 ) );
-    ASSERT_EQ( v.extent(5), ( 5 < ViewType::rank ? TestViewMapOperator<ViewType>::N5 : 1 ) );
-    ASSERT_EQ( v.extent(6), ( 6 < ViewType::rank ? TestViewMapOperator<ViewType>::N6 : 1 ) );
-    ASSERT_EQ( v.extent(7), ( 7 < ViewType::rank ? TestViewMapOperator<ViewType>::N7 : 1 ) );
-
-    ASSERT_LE( v.extent(0) *
-               v.extent(1) *
-               v.extent(2) *
-               v.extent(3) *
-               v.extent(4) *
-               v.extent(5) *
-               v.extent(6) *
-               v.extent(7)
-             , v.span() );
+  void run() {
+    ASSERT_EQ(v.extent(0),
+              (0 < ViewType::rank ? TestViewMapOperator<ViewType>::N0 : 1));
+    ASSERT_EQ(v.extent(1),
+              (1 < ViewType::rank ? TestViewMapOperator<ViewType>::N1 : 1));
+    ASSERT_EQ(v.extent(2),
+              (2 < ViewType::rank ? TestViewMapOperator<ViewType>::N2 : 1));
+    ASSERT_EQ(v.extent(3),
+              (3 < ViewType::rank ? TestViewMapOperator<ViewType>::N3 : 1));
+    ASSERT_EQ(v.extent(4),
+              (4 < ViewType::rank ? TestViewMapOperator<ViewType>::N4 : 1));
+    ASSERT_EQ(v.extent(5),
+              (5 < ViewType::rank ? TestViewMapOperator<ViewType>::N5 : 1));
+    ASSERT_EQ(v.extent(6),
+              (6 < ViewType::rank ? TestViewMapOperator<ViewType>::N6 : 1));
+    ASSERT_EQ(v.extent(7),
+              (7 < ViewType::rank ? TestViewMapOperator<ViewType>::N7 : 1));
+
+    ASSERT_LE(v.extent(0) * v.extent(1) * v.extent(2) * v.extent(3) *
+                  v.extent(4) * v.extent(5) * v.extent(6) * v.extent(7),
+              v.span());
 
     long error_count;
-    Kokkos::RangePolicy< typename ViewType::execution_space > range( 0, v.extent(0) );
-    Kokkos::parallel_reduce( range, *this, error_count );
-    ASSERT_EQ( 0, error_count );
-}
+    Kokkos::RangePolicy<typename ViewType::execution_space> range(0,
+                                                                  v.extent(0));
+    Kokkos::parallel_reduce(range, *this, error_count);
+    ASSERT_EQ(0, error_count);
+  }
 };
 
-template< class Space >
-void test_view_mapping_operator()
-{
+template <class Space>
+void test_view_mapping_operator() {
   typedef typename Space::execution_space ExecSpace;
 
-  { TestViewMapOperator< Kokkos::View<int, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int*, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int**, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int***, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int****, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int*****, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int******, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int*******, Kokkos::LayoutLeft, ExecSpace> > f; f.run(); }
-
-  { TestViewMapOperator< Kokkos::View<int, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int*, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int**, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int***, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int****, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int*****, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int******, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-  { TestViewMapOperator< Kokkos::View<int*******, Kokkos::LayoutRight, ExecSpace> > f; f.run(); }
-}
+  {
+    TestViewMapOperator<Kokkos::View<int, Kokkos::LayoutLeft, ExecSpace> > f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int*, Kokkos::LayoutLeft, ExecSpace> > f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int**, Kokkos::LayoutLeft, ExecSpace> > f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int***, Kokkos::LayoutLeft, ExecSpace> > f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int****, Kokkos::LayoutLeft, ExecSpace> >
+        f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int*****, Kokkos::LayoutLeft, ExecSpace> >
+        f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int******, Kokkos::LayoutLeft, ExecSpace> >
+        f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<
+        Kokkos::View<int*******, Kokkos::LayoutLeft, ExecSpace> >
+        f;
+    f.run();
+  }
 
-TEST_F( TEST_CATEGORY , view_mapping_operator )
-{
-  test_view_mapping_operator< TEST_EXECSPACE >();
+  {
+    TestViewMapOperator<Kokkos::View<int, Kokkos::LayoutRight, ExecSpace> > f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int*, Kokkos::LayoutRight, ExecSpace> > f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int**, Kokkos::LayoutRight, ExecSpace> > f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int***, Kokkos::LayoutRight, ExecSpace> >
+        f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int****, Kokkos::LayoutRight, ExecSpace> >
+        f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<Kokkos::View<int*****, Kokkos::LayoutRight, ExecSpace> >
+        f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<
+        Kokkos::View<int******, Kokkos::LayoutRight, ExecSpace> >
+        f;
+    f.run();
+  }
+  {
+    TestViewMapOperator<
+        Kokkos::View<int*******, Kokkos::LayoutRight, ExecSpace> >
+        f;
+    f.run();
+  }
 }
 
-TEST_F( TEST_CATEGORY , static_extent )
-{
-  using T = Kokkos::View<double*[2][3]>;
-  ASSERT_EQ( T::static_extent(1), 2 );
-  ASSERT_EQ( T::static_extent(2), 3 );
+TEST(TEST_CATEGORY, view_mapping_operator) {
+  test_view_mapping_operator<TEST_EXECSPACE>();
 }
 
+TEST(TEST_CATEGORY, static_extent) {
+  using T = Kokkos::View<double * [2][3]>;
+  ASSERT_EQ(T::static_extent(1), 2);
+  ASSERT_EQ(T::static_extent(2), 3);
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewMapping_b.hpp b/lib/kokkos/core/unit_test/TestViewMapping_b.hpp
index 36fc0461a4fb837ae1f988799e463ac4efbb1749..63ec635323bd537ce7a2670a5d1b550b9bc58e1f 100644
--- a/lib/kokkos/core/unit_test/TestViewMapping_b.hpp
+++ b/lib/kokkos/core/unit_test/TestViewMapping_b.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,208 +54,206 @@ namespace Test {
 
 /*--------------------------------------------------------------------------*/
 
-template< class Space >
+template <class Space>
 struct TestViewMappingAtomic {
   typedef typename Space::execution_space ExecSpace;
-  typedef typename Space::memory_space    MemSpace;
+  typedef typename Space::memory_space MemSpace;
 
-  typedef Kokkos::MemoryTraits< Kokkos::Atomic >  mem_trait;
+  typedef Kokkos::MemoryTraits<Kokkos::Atomic> mem_trait;
 
-  typedef Kokkos::View< int *, ExecSpace > T;
-  typedef Kokkos::View< int *, ExecSpace, mem_trait >  T_atom;
+  typedef Kokkos::View<int *, ExecSpace> T;
+  typedef Kokkos::View<int *, ExecSpace, mem_trait> T_atom;
 
-  T      x;
+  T x;
   T_atom x_atom;
 
-  enum { N = 100000};
+  enum { N = 100000 };
 
   struct TagInit {};
   struct TagUpdate {};
   struct TagVerify {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagInit &, const int i ) const
-  { x( i ) = i; }
+  void operator()(const TagInit &, const int i) const { x(i) = i; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagUpdate &, const int i ) const
-  { x_atom( i % 2 ) += 1; }
+  void operator()(const TagUpdate &, const int i) const { x_atom(i % 2) += 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagVerify &, const int i, long & error_count ) const
-  {
-     if ( i < 2 ) { if ( x( i ) != int( i + N / 2 ) ) ++error_count; }
-     else         { if ( x( i ) != int( i ) ) ++error_count; }
+  void operator()(const TagVerify &, const int i, long &error_count) const {
+    if (i < 2) {
+      if (x(i) != int(i + N / 2)) ++error_count;
+    } else {
+      if (x(i) != int(i)) ++error_count;
+    }
   }
 
-  TestViewMappingAtomic()
-    : x( "x", N )
-    , x_atom( x )
-    {}
+  TestViewMappingAtomic() : x("x", N), x_atom(x) {}
 
   void run() {
+    ASSERT_TRUE(T::reference_type_is_lvalue_reference);
+    ASSERT_FALSE(T_atom::reference_type_is_lvalue_reference);
 
-    ASSERT_TRUE( T::reference_type_is_lvalue_reference );
-    ASSERT_FALSE( T_atom::reference_type_is_lvalue_reference );
-
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, TagInit >  ( 0, N ), *this );
-    Kokkos::parallel_for( Kokkos::RangePolicy< ExecSpace, TagUpdate >( 0, N ), *this );
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, TagInit>(0, N), *this);
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, TagUpdate>(0, N),
+                         *this);
 
     long error_count = -1;
 
-    Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace, TagVerify >( 0, N ), *this, error_count );
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, TagVerify>(0, N),
+                            *this, error_count);
 
-    ASSERT_EQ( 0, error_count );
+    ASSERT_EQ(0, error_count);
 
-    typename T_atom::HostMirror x_host = Kokkos::create_mirror_view( x );
-    Kokkos::deep_copy( x_host, x );
+    typename T_atom::HostMirror x_host = Kokkos::create_mirror_view(x);
+    Kokkos::deep_copy(x_host, x);
 
     error_count = -1;
 
-    Kokkos::parallel_reduce( Kokkos::RangePolicy< Kokkos::DefaultHostExecutionSpace, TagVerify >( 0, N ), 
-      [=] ( const TagVerify &, const int i, long & tmp_error_count )
-    {
-      if ( i < 2 ) {
-        if ( x_host( i ) != int( i + N / 2 ) ) ++tmp_error_count ;
-      }
-      else {
-        if ( x_host( i ) != int( i ) ) ++tmp_error_count ;
-      }
-    }, error_count);
-
-    ASSERT_EQ( 0 , error_count );
-    Kokkos::deep_copy( x, x_host );
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<Kokkos::DefaultHostExecutionSpace, TagVerify>(0, N),
+        [=](const TagVerify &, const int i, long &tmp_error_count) {
+          if (i < 2) {
+            if (x_host(i) != int(i + N / 2)) ++tmp_error_count;
+          } else {
+            if (x_host(i) != int(i)) ++tmp_error_count;
+          }
+        },
+        error_count);
+
+    ASSERT_EQ(0, error_count);
+    Kokkos::deep_copy(x, x_host);
   }
 };
 
-TEST_F( TEST_CATEGORY , view_mapping_atomic )
-{
-  TestViewMappingAtomic< TEST_EXECSPACE > f;
+TEST(TEST_CATEGORY, view_mapping_atomic) {
+  TestViewMappingAtomic<TEST_EXECSPACE> f;
   f.run();
 }
 
-}
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
 
 namespace Test {
 
 struct MappingClassValueType {
-    KOKKOS_INLINE_FUNCTION
-    MappingClassValueType() 
-    {
+  KOKKOS_INLINE_FUNCTION
+  MappingClassValueType() {
 #if 0
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
       printf( "TestViewMappingClassValue construct on Cuda\n" );
-#elif defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
       printf( "TestViewMappingClassValue construct on Host\n" );
 #else
       printf( "TestViewMappingClassValue construct unknown\n" );
 #endif
 #endif
-    }
-    KOKKOS_INLINE_FUNCTION
-    ~MappingClassValueType()
-    {
+  }
+  KOKKOS_INLINE_FUNCTION
+  ~MappingClassValueType() {
 #if 0
-#if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA )
+#if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
       printf( "TestViewMappingClassValue destruct on Cuda\n" );
-#elif defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
+#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
       printf( "TestViewMappingClassValue destruct on Host\n" );
 #else
       printf( "TestViewMappingClassValue destruct unknown\n" );
 #endif
 #endif
-    }
-  };
+  }
+};
 
-template< class Space >
-void test_view_mapping_class_value()
-{
+template <class Space>
+void test_view_mapping_class_value() {
   typedef typename Space::execution_space ExecSpace;
 
   ExecSpace().fence();
   {
-    Kokkos::View< MappingClassValueType, ExecSpace > a( "a" );
+    Kokkos::View<MappingClassValueType, ExecSpace> a("a");
     ExecSpace().fence();
   }
   ExecSpace().fence();
 }
 
-TEST_F( TEST_CATEGORY , view_mapping_class_value )
-{
-  test_view_mapping_class_value< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_mapping_class_value) {
+  test_view_mapping_class_value<TEST_EXECSPACE>();
 }
 
-}
+}  // namespace Test
 
 /*--------------------------------------------------------------------------*/
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY , view_mapping_assignable )
-{
-  typedef TEST_EXECSPACE exec_space ;
+TEST(TEST_CATEGORY, view_mapping_assignable) {
+  typedef TEST_EXECSPACE exec_space;
 
-  { // Assignment of rank-0 Left = Right
-    typedef Kokkos::ViewTraits<int,Kokkos::LayoutLeft, exec_space> dst_traits ;
-    typedef Kokkos::ViewTraits<int,Kokkos::LayoutRight,exec_space> src_traits ;
-    typedef Kokkos::Impl::ViewMapping<dst_traits,src_traits,void> mapping ;
-    static_assert( mapping::is_assignable , "" );
+  {  // Assignment of rank-0 Left = Right
+    typedef Kokkos::ViewTraits<int, Kokkos::LayoutLeft, exec_space> dst_traits;
+    typedef Kokkos::ViewTraits<int, Kokkos::LayoutRight, exec_space> src_traits;
+    typedef Kokkos::Impl::ViewMapping<dst_traits, src_traits, void> mapping;
+    static_assert(mapping::is_assignable, "");
 
-    Kokkos::View<int,Kokkos::LayoutRight,exec_space> src ;
-    Kokkos::View<int,Kokkos::LayoutLeft,exec_space> dst( src );
-    dst = src ;
+    Kokkos::View<int, Kokkos::LayoutRight, exec_space> src;
+    Kokkos::View<int, Kokkos::LayoutLeft, exec_space> dst(src);
+    dst = src;
   }
 
-  { // Assignment of rank-0 Right = Left
-    typedef Kokkos::ViewTraits<int,Kokkos::LayoutRight,exec_space> dst_traits ;
-    typedef Kokkos::ViewTraits<int,Kokkos::LayoutLeft, exec_space> src_traits ;
-    typedef Kokkos::Impl::ViewMapping<dst_traits,src_traits,void> mapping ;
-    static_assert( mapping::is_assignable , "" );
+  {  // Assignment of rank-0 Right = Left
+    typedef Kokkos::ViewTraits<int, Kokkos::LayoutRight, exec_space> dst_traits;
+    typedef Kokkos::ViewTraits<int, Kokkos::LayoutLeft, exec_space> src_traits;
+    typedef Kokkos::Impl::ViewMapping<dst_traits, src_traits, void> mapping;
+    static_assert(mapping::is_assignable, "");
 
-    Kokkos::View<int,Kokkos::LayoutLeft,exec_space> src ;
-    Kokkos::View<int,Kokkos::LayoutRight,exec_space> dst( src );
-    dst = src ;
+    Kokkos::View<int, Kokkos::LayoutLeft, exec_space> src;
+    Kokkos::View<int, Kokkos::LayoutRight, exec_space> dst(src);
+    dst = src;
   }
 
-  { // Assignment of rank-1 Left = Right
-    typedef Kokkos::ViewTraits<int*,Kokkos::LayoutLeft, exec_space> dst_traits ;
-    typedef Kokkos::ViewTraits<int*,Kokkos::LayoutRight,exec_space> src_traits ;
-    typedef Kokkos::Impl::ViewMapping<dst_traits,src_traits,void> mapping ;
-    static_assert( mapping::is_assignable , "" );
-
-    Kokkos::View<int*,Kokkos::LayoutRight,exec_space> src ;
-    Kokkos::View<int*,Kokkos::LayoutLeft,exec_space> dst( src );
-    dst = src ;
+  {  // Assignment of rank-1 Left = Right
+    typedef Kokkos::ViewTraits<int *, Kokkos::LayoutLeft, exec_space>
+        dst_traits;
+    typedef Kokkos::ViewTraits<int *, Kokkos::LayoutRight, exec_space>
+        src_traits;
+    typedef Kokkos::Impl::ViewMapping<dst_traits, src_traits, void> mapping;
+    static_assert(mapping::is_assignable, "");
+
+    Kokkos::View<int *, Kokkos::LayoutRight, exec_space> src;
+    Kokkos::View<int *, Kokkos::LayoutLeft, exec_space> dst(src);
+    dst = src;
   }
 
-  { // Assignment of rank-1 Right = Left
-    typedef Kokkos::ViewTraits<int*,Kokkos::LayoutRight,exec_space> dst_traits ;
-    typedef Kokkos::ViewTraits<int*,Kokkos::LayoutLeft, exec_space> src_traits ;
-    typedef Kokkos::Impl::ViewMapping<dst_traits,src_traits,void> mapping ;
-    static_assert( mapping::is_assignable , "" );
-
-    Kokkos::View<int*,Kokkos::LayoutLeft,exec_space> src ;
-    Kokkos::View<int*,Kokkos::LayoutRight,exec_space> dst( src );
-    dst = src ;
+  {  // Assignment of rank-1 Right = Left
+    typedef Kokkos::ViewTraits<int *, Kokkos::LayoutRight, exec_space>
+        dst_traits;
+    typedef Kokkos::ViewTraits<int *, Kokkos::LayoutLeft, exec_space>
+        src_traits;
+    typedef Kokkos::Impl::ViewMapping<dst_traits, src_traits, void> mapping;
+    static_assert(mapping::is_assignable, "");
+
+    Kokkos::View<int *, Kokkos::LayoutLeft, exec_space> src;
+    Kokkos::View<int *, Kokkos::LayoutRight, exec_space> dst(src);
+    dst = src;
   }
 
-  { // Assignment of rank-2 Left = Right
-    typedef Kokkos::ViewTraits<int**,Kokkos::LayoutLeft, exec_space> dst_traits ;
-    typedef Kokkos::ViewTraits<int**,Kokkos::LayoutRight,exec_space> src_traits ;
-    typedef Kokkos::Impl::ViewMapping<dst_traits,src_traits,void> mapping ;
-    static_assert( ! mapping::is_assignable , "" );
+  {  // Assignment of rank-2 Left = Right
+    typedef Kokkos::ViewTraits<int **, Kokkos::LayoutLeft, exec_space>
+        dst_traits;
+    typedef Kokkos::ViewTraits<int **, Kokkos::LayoutRight, exec_space>
+        src_traits;
+    typedef Kokkos::Impl::ViewMapping<dst_traits, src_traits, void> mapping;
+    static_assert(!mapping::is_assignable, "");
   }
 
-  { // Assignment of rank-2 Right = Left
-    typedef Kokkos::ViewTraits<int**,Kokkos::LayoutRight,exec_space> dst_traits ;
-    typedef Kokkos::ViewTraits<int**,Kokkos::LayoutLeft, exec_space> src_traits ;
-    typedef Kokkos::Impl::ViewMapping<dst_traits,src_traits,void> mapping ;
-    static_assert( ! mapping::is_assignable , "" );
+  {  // Assignment of rank-2 Right = Left
+    typedef Kokkos::ViewTraits<int **, Kokkos::LayoutRight, exec_space>
+        dst_traits;
+    typedef Kokkos::ViewTraits<int **, Kokkos::LayoutLeft, exec_space>
+        src_traits;
+    typedef Kokkos::Impl::ViewMapping<dst_traits, src_traits, void> mapping;
+    static_assert(!mapping::is_assignable, "");
   }
-
-}
-
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewMapping_subview.hpp b/lib/kokkos/core/unit_test/TestViewMapping_subview.hpp
index 62bd582871a71bd26277c183873843767724e16f..d5e9ce7de1d0062fec0208235818e770e3be94f7 100644
--- a/lib/kokkos/core/unit_test/TestViewMapping_subview.hpp
+++ b/lib/kokkos/core/unit_test/TestViewMapping_subview.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -51,46 +52,51 @@
 
 namespace Test {
 
-template< class Space >
-struct TestViewMappingSubview
-{
+template <class Space>
+struct TestViewMappingSubview {
   typedef typename Space::execution_space ExecSpace;
-  typedef typename Space::memory_space    MemSpace;
+  typedef typename Space::memory_space MemSpace;
 
-  typedef Kokkos::pair< int, int > range;
+  typedef Kokkos::pair<int, int> range;
 
   enum { AN = 10 };
-  typedef Kokkos::View< int*, ExecSpace >  AT;
-  typedef Kokkos::View< const int*, ExecSpace >  ACT;
-  typedef Kokkos::Subview< AT, range >  AS;
+  typedef Kokkos::View<int*, ExecSpace> AT;
+  typedef Kokkos::View<const int*, ExecSpace> ACT;
+  typedef Kokkos::Subview<AT, range> AS;
 
   enum { BN0 = 10, BN1 = 11, BN2 = 12 };
-  typedef Kokkos::View< int***, ExecSpace >  BT;
-  typedef Kokkos::Subview< BT, range, range, range >  BS;
+  typedef Kokkos::View<int***, ExecSpace> BT;
+  typedef Kokkos::Subview<BT, range, range, range> BS;
 
   enum { CN0 = 10, CN1 = 11, CN2 = 12 };
-  typedef Kokkos::View< int***[13][14], ExecSpace >  CT;
-  typedef Kokkos::Subview< CT, range, range, range, int, int >  CS;
+  typedef Kokkos::View<int** * [13][14], ExecSpace> CT;
+  typedef Kokkos::Subview<CT, range, range, range, int, int> CS;
 
   enum { DN0 = 10, DN1 = 11, DN2 = 12, DN3 = 13, DN4 = 14 };
-  typedef Kokkos::View< int***[DN3][DN4], ExecSpace >  DT;
-  typedef Kokkos::Subview< DT, int, range, range, range, int >  DS;
-
-  typedef Kokkos::View< int***[13][14], Kokkos::LayoutLeft, ExecSpace >  DLT;
-  typedef Kokkos::Subview< DLT, range, int, int, int, int >  DLS1;
-
-  #if !defined(KOKKOS_IMPL_CUDA_VERSION_9_WORKAROUND)
-  static_assert( DLS1::rank == 1 && std::is_same< typename DLS1::array_layout, Kokkos::LayoutLeft >::value
-               , "Subview layout error for rank 1 subview of left-most range of LayoutLeft" );
-  #endif
-
-  typedef Kokkos::View< int***[13][14], Kokkos::LayoutRight, ExecSpace >  DRT;
-  typedef Kokkos::Subview< DRT, int, int, int, int, range >  DRS1;
-
-  #if !defined(KOKKOS_IMPL_CUDA_VERSION_9_WORKAROUND)
-  static_assert( DRS1::rank == 1 && std::is_same< typename DRS1::array_layout, Kokkos::LayoutRight >::value
-               , "Subview layout error for rank 1 subview of right-most range of LayoutRight" );
-  #endif
+  typedef Kokkos::View<int** * [DN3][DN4], ExecSpace> DT;
+  typedef Kokkos::Subview<DT, int, range, range, range, int> DS;
+
+  typedef Kokkos::View<int** * [13][14], Kokkos::LayoutLeft, ExecSpace> DLT;
+  typedef Kokkos::Subview<DLT, range, int, int, int, int> DLS1;
+
+#if !defined(KOKKOS_IMPL_CUDA_VERSION_9_WORKAROUND)
+  static_assert(
+      DLS1::rank == 1 &&
+          std::is_same<typename DLS1::array_layout, Kokkos::LayoutLeft>::value,
+      "Subview layout error for rank 1 subview of left-most range of "
+      "LayoutLeft");
+#endif
+
+  typedef Kokkos::View<int** * [13][14], Kokkos::LayoutRight, ExecSpace> DRT;
+  typedef Kokkos::Subview<DRT, int, int, int, int, range> DRS1;
+
+#if !defined(KOKKOS_IMPL_CUDA_VERSION_9_WORKAROUND)
+  static_assert(
+      DRS1::rank == 1 &&
+          std::is_same<typename DRS1::array_layout, Kokkos::LayoutRight>::value,
+      "Subview layout error for rank 1 subview of right-most range of "
+      "LayoutRight");
+#endif
 
   AT Aa;
   AS Ab;
@@ -103,113 +109,102 @@ struct TestViewMappingSubview
   DS Db;
 
   TestViewMappingSubview()
-    : Aa( "Aa", AN )
-    , Ab( Kokkos::subview( Aa, std::pair< int, int >( 1, AN - 1 ) ) )
-    , Ac( Aa, std::pair< int, int >( 1, AN - 1 ) )
-    , Ba( "Ba", BN0, BN1, BN2 )
-    , Bb( Kokkos::subview( Ba
-                                        , std::pair< int, int >( 1, BN0 - 1 )
-                                        , std::pair< int, int >( 1, BN1 - 1 )
-                                        , std::pair< int, int >( 1, BN2 - 1 )
-                                        ) )
-    , Ca( "Ca", CN0, CN1, CN2 )
-    , Cb( Kokkos::subview( Ca
-                                        , std::pair< int, int >( 1, CN0 - 1 )
-                                        , std::pair< int, int >( 1, CN1 - 1 )
-                                        , std::pair< int, int >( 1, CN2 - 1 )
-                                        , 1
-                                        , 2
-                                        ) )
-    , Da( "Da", DN0, DN1, DN2 )
-    , Db( Kokkos::subview( Da
-                                        , 1
-                                        , std::pair< int, int >( 1, DN1 - 1 )
-                                        , std::pair< int, int >( 1, DN2 - 1 )
-                                        , std::pair< int, int >( 1, DN3 - 1 )
-                                        , 2
-                                        ) )
-    {}
+      : Aa("Aa", AN),
+        Ab(Kokkos::subview(Aa, std::pair<int, int>(1, AN - 1))),
+        Ac(Aa, std::pair<int, int>(1, AN - 1)),
+        Ba("Ba", BN0, BN1, BN2),
+        Bb(Kokkos::subview(Ba, std::pair<int, int>(1, BN0 - 1),
+                           std::pair<int, int>(1, BN1 - 1),
+                           std::pair<int, int>(1, BN2 - 1))),
+        Ca("Ca", CN0, CN1, CN2),
+        Cb(Kokkos::subview(Ca, std::pair<int, int>(1, CN0 - 1),
+                           std::pair<int, int>(1, CN1 - 1),
+                           std::pair<int, int>(1, CN2 - 1), 1, 2)),
+        Da("Da", DN0, DN1, DN2),
+        Db(Kokkos::subview(Da, 1, std::pair<int, int>(1, DN1 - 1),
+                           std::pair<int, int>(1, DN2 - 1),
+                           std::pair<int, int>(1, DN3 - 1), 2)) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int, long & error_count ) const
-  {
-    auto Ad = Kokkos::subview< Kokkos::MemoryUnmanaged >( Aa, Kokkos::pair< int, int >( 1, AN - 1 ) );
-
-    for ( int i = 1; i < AN - 1; ++i ) if( & Aa[i] != & Ab[i - 1] ) ++error_count;
-    for ( int i = 1; i < AN - 1; ++i ) if( & Aa[i] != & Ac[i - 1] ) ++error_count;
-    for ( int i = 1; i < AN - 1; ++i ) if( & Aa[i] != & Ad[i - 1] ) ++error_count;
-
-    for ( int i2 = 1; i2 < BN2 - 1; ++i2 )
-    for ( int i1 = 1; i1 < BN1 - 1; ++i1 )
-    for ( int i0 = 1; i0 < BN0 - 1; ++i0 )
-    {
-      if ( & Ba( i0, i1, i2 ) != & Bb( i0 - 1, i1 - 1, i2 - 1 ) ) ++error_count;
-    }
-
-    for ( int i2 = 1; i2 < CN2 - 1; ++i2 )
-    for ( int i1 = 1; i1 < CN1 - 1; ++i1 )
-    for ( int i0 = 1; i0 < CN0 - 1; ++i0 )
-    {
-      if ( & Ca( i0, i1, i2, 1, 2 ) != & Cb( i0 - 1, i1 - 1, i2 - 1 ) ) ++error_count;
-    }
-
-    for ( int i2 = 1; i2 < DN3 - 1; ++i2 )
-    for ( int i1 = 1; i1 < DN2 - 1; ++i1 )
-    for ( int i0 = 1; i0 < DN1 - 1; ++i0 )
-    {
-      if ( & Da( 1, i0, i1, i2, 2 ) != & Db( i0 - 1, i1 - 1, i2 - 1 ) ) ++error_count;
-    }
+  void operator()(const int, long& error_count) const {
+    auto Ad = Kokkos::subview<Kokkos::MemoryUnmanaged>(
+        Aa, Kokkos::pair<int, int>(1, AN - 1));
+
+    for (int i = 1; i < AN - 1; ++i)
+      if (&Aa[i] != &Ab[i - 1]) ++error_count;
+    for (int i = 1; i < AN - 1; ++i)
+      if (&Aa[i] != &Ac[i - 1]) ++error_count;
+    for (int i = 1; i < AN - 1; ++i)
+      if (&Aa[i] != &Ad[i - 1]) ++error_count;
+
+    for (int i2 = 1; i2 < BN2 - 1; ++i2)
+      for (int i1 = 1; i1 < BN1 - 1; ++i1)
+        for (int i0 = 1; i0 < BN0 - 1; ++i0) {
+          if (&Ba(i0, i1, i2) != &Bb(i0 - 1, i1 - 1, i2 - 1)) ++error_count;
+        }
+
+    for (int i2 = 1; i2 < CN2 - 1; ++i2)
+      for (int i1 = 1; i1 < CN1 - 1; ++i1)
+        for (int i0 = 1; i0 < CN0 - 1; ++i0) {
+          if (&Ca(i0, i1, i2, 1, 2) != &Cb(i0 - 1, i1 - 1, i2 - 1))
+            ++error_count;
+        }
+
+    for (int i2 = 1; i2 < DN3 - 1; ++i2)
+      for (int i1 = 1; i1 < DN2 - 1; ++i1)
+        for (int i0 = 1; i0 < DN1 - 1; ++i0) {
+          if (&Da(1, i0, i1, i2, 2) != &Db(i0 - 1, i1 - 1, i2 - 1))
+            ++error_count;
+        }
   }
 
-  void run()
-  {
-
-    TestViewMappingSubview< ExecSpace > self;
-
-    ASSERT_EQ( Aa.extent(0), AN );
-    ASSERT_EQ( Ab.extent(0), AN - 2 );
-    ASSERT_EQ( Ac.extent(0), AN - 2 );
-    ASSERT_EQ( Ba.extent(0), BN0 );
-    ASSERT_EQ( Ba.extent(1), BN1 );
-    ASSERT_EQ( Ba.extent(2), BN2 );
-    ASSERT_EQ( Bb.extent(0), BN0 - 2 );
-    ASSERT_EQ( Bb.extent(1), BN1 - 2 );
-    ASSERT_EQ( Bb.extent(2), BN2 - 2 );
-
-    ASSERT_EQ( Ca.extent(0), CN0 );
-    ASSERT_EQ( Ca.extent(1), CN1 );
-    ASSERT_EQ( Ca.extent(2), CN2 );
-    ASSERT_EQ( Ca.extent(3), 13 ); 
-    ASSERT_EQ( Ca.extent(4), 14 );
-    ASSERT_EQ( Cb.extent(0), CN0 - 2 );
-    ASSERT_EQ( Cb.extent(1), CN1 - 2 );
-    ASSERT_EQ( Cb.extent(2), CN2 - 2 );
-
-    ASSERT_EQ( Da.extent(0), DN0 );
-    ASSERT_EQ( Da.extent(1), DN1 );
-    ASSERT_EQ( Da.extent(2), DN2 );
-    ASSERT_EQ( Da.extent(3), DN3 );
-    ASSERT_EQ( Da.extent(4), DN4 );
-
-    ASSERT_EQ( Db.extent(0), DN1 - 2 );
-    ASSERT_EQ( Db.extent(1), DN2 - 2 );
-    ASSERT_EQ( Db.extent(2), DN3 - 2 );
-
-    ASSERT_EQ( Da.stride_1(), Db.stride_0() );
-    ASSERT_EQ( Da.stride_2(), Db.stride_1() );
-    ASSERT_EQ( Da.stride_3(), Db.stride_2() );
+  void run() {
+    TestViewMappingSubview<ExecSpace> self;
+
+    ASSERT_EQ(Aa.extent(0), AN);
+    ASSERT_EQ(Ab.extent(0), AN - 2);
+    ASSERT_EQ(Ac.extent(0), AN - 2);
+    ASSERT_EQ(Ba.extent(0), BN0);
+    ASSERT_EQ(Ba.extent(1), BN1);
+    ASSERT_EQ(Ba.extent(2), BN2);
+    ASSERT_EQ(Bb.extent(0), BN0 - 2);
+    ASSERT_EQ(Bb.extent(1), BN1 - 2);
+    ASSERT_EQ(Bb.extent(2), BN2 - 2);
+
+    ASSERT_EQ(Ca.extent(0), CN0);
+    ASSERT_EQ(Ca.extent(1), CN1);
+    ASSERT_EQ(Ca.extent(2), CN2);
+    ASSERT_EQ(Ca.extent(3), 13);
+    ASSERT_EQ(Ca.extent(4), 14);
+    ASSERT_EQ(Cb.extent(0), CN0 - 2);
+    ASSERT_EQ(Cb.extent(1), CN1 - 2);
+    ASSERT_EQ(Cb.extent(2), CN2 - 2);
+
+    ASSERT_EQ(Da.extent(0), DN0);
+    ASSERT_EQ(Da.extent(1), DN1);
+    ASSERT_EQ(Da.extent(2), DN2);
+    ASSERT_EQ(Da.extent(3), DN3);
+    ASSERT_EQ(Da.extent(4), DN4);
+
+    ASSERT_EQ(Db.extent(0), DN1 - 2);
+    ASSERT_EQ(Db.extent(1), DN2 - 2);
+    ASSERT_EQ(Db.extent(2), DN3 - 2);
+
+    ASSERT_EQ(Da.stride_1(), Db.stride_0());
+    ASSERT_EQ(Da.stride_2(), Db.stride_1());
+    ASSERT_EQ(Da.stride_3(), Db.stride_2());
 
     long error_count = -1;
-    Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace >( 0, 1 ), *this, error_count );
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace>(0, 1), *this,
+                            error_count);
 
-    ASSERT_EQ( error_count, 0 );
+    ASSERT_EQ(error_count, 0);
   }
 };
 
-TEST_F( TEST_CATEGORY , view_mapping_subview )
-{
-  TestViewMappingSubview< TEST_EXECSPACE > f;
+TEST(TEST_CATEGORY, view_mapping_subview) {
+  TestViewMappingSubview<TEST_EXECSPACE> f;
   f.run();
 }
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewOfClass.hpp b/lib/kokkos/core/unit_test/TestViewOfClass.hpp
index 7198b4c1400a0a9792192ea6b0642d89b456ee17..634f1da73008e60fc9c761de25655a928879383a 100644
--- a/lib/kokkos/core/unit_test/TestViewOfClass.hpp
+++ b/lib/kokkos/core/unit_test/TestViewOfClass.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,77 +51,69 @@
 
 namespace Test {
 
-template< class Space >
+template <class Space>
 struct NestedView {
-  Kokkos::View< int*, Space > member;
+  Kokkos::View<int *, Space> member;
 
-public:
+ public:
   KOKKOS_INLINE_FUNCTION
   NestedView() : member() {}
 
   KOKKOS_INLINE_FUNCTION
-  NestedView & operator=( const Kokkos::View< int*, Space > & lhs )
-  {
+  NestedView &operator=(const Kokkos::View<int *, Space> &lhs) {
     member = lhs;
-    if ( member.extent(0) ) Kokkos::atomic_add( & member( 0 ), 1 );
+    if (member.extent(0)) Kokkos::atomic_add(&member(0), 1);
     return *this;
   }
 
   KOKKOS_INLINE_FUNCTION
-  ~NestedView()
-  {
-    if ( member.extent(0) ) {
-      Kokkos::atomic_add( & member( 0 ), -1 );
+  ~NestedView() {
+    if (member.extent(0)) {
+      Kokkos::atomic_add(&member(0), -1);
     }
   }
 };
 
-template< class Space >
+template <class Space>
 struct NestedViewFunctor {
+  Kokkos::View<NestedView<Space> *, Space> nested;
+  Kokkos::View<int *, Space> array;
 
-  Kokkos::View< NestedView<Space> *, Space > nested;
-  Kokkos::View< int*, Space >                array;
-
-  NestedViewFunctor(
-    const Kokkos::View< NestedView<Space> *, Space > & arg_nested,
-    const Kokkos::View< int*, Space >                & arg_array )
-  : nested( arg_nested )
-  , array(  arg_array )
-  {}
+  NestedViewFunctor(const Kokkos::View<NestedView<Space> *, Space> &arg_nested,
+                    const Kokkos::View<int *, Space> &arg_array)
+      : nested(arg_nested), array(arg_array) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int i ) const { nested[i] = array; }
+  void operator()(int i) const { nested[i] = array; }
 };
 
-template< class Space >
-void view_nested_view()
-{
-  Kokkos::View< int*, Space > tracking( "tracking", 1 );
+template <class Space>
+void view_nested_view() {
+  Kokkos::View<int *, Space> tracking("tracking", 1);
 
-  typename Kokkos::View< int*, Space >::HostMirror host_tracking = Kokkos::create_mirror( tracking );
+  typename Kokkos::View<int *, Space>::HostMirror host_tracking =
+      Kokkos::create_mirror(tracking);
 
   {
-    Kokkos::View< NestedView<Space> *, Space > a( "a_nested_view", 2 );
-
-    Kokkos::parallel_for( Kokkos::RangePolicy< Space >( 0, 2 ), NestedViewFunctor< Space >( a, tracking ) );
-    Kokkos::deep_copy( host_tracking, tracking );
-    ASSERT_EQ( 2, host_tracking( 0 ) );
-
-    Kokkos::View< NestedView<Space> *, Space > b( "b_nested_view", 2 );
-    Kokkos::parallel_for( Kokkos::RangePolicy< Space >( 0, 2 ), NestedViewFunctor< Space >( b, tracking ) );
-    Kokkos::deep_copy( host_tracking, tracking );
-    ASSERT_EQ( 4, host_tracking( 0 ) );
-
+    Kokkos::View<NestedView<Space> *, Space> a("a_nested_view", 2);
+
+    Kokkos::parallel_for(Kokkos::RangePolicy<Space>(0, 2),
+                         NestedViewFunctor<Space>(a, tracking));
+    Kokkos::deep_copy(host_tracking, tracking);
+    ASSERT_EQ(2, host_tracking(0));
+
+    Kokkos::View<NestedView<Space> *, Space> b("b_nested_view", 2);
+    Kokkos::parallel_for(Kokkos::RangePolicy<Space>(0, 2),
+                         NestedViewFunctor<Space>(b, tracking));
+    Kokkos::deep_copy(host_tracking, tracking);
+    ASSERT_EQ(4, host_tracking(0));
   }
 
-  Kokkos::deep_copy( host_tracking, tracking );
+  Kokkos::deep_copy(host_tracking, tracking);
 
-  ASSERT_EQ( 0, host_tracking( 0 ) );
+  ASSERT_EQ(0, host_tracking(0));
 }
 
-TEST_F( TEST_CATEGORY, view_nested_view )
-{
-  view_nested_view< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, view_nested_view) { view_nested_view<TEST_EXECSPACE>(); }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewResize.hpp b/lib/kokkos/core/unit_test/TestViewResize.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0f1e5188c8b5e2165dcc55983abd2a54115103fd
--- /dev/null
+++ b/lib/kokkos/core/unit_test/TestViewResize.hpp
@@ -0,0 +1,58 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+#ifndef TESTVIEWRESIZE_HPP_
+#define TESTVIEWRESIZE_HPP_
+
+#include <gtest/gtest.h>
+#include "TestResize.hpp"
+
+namespace Test {
+
+TEST(TEST_CATEGORY, view_resize) {
+  typedef TEST_EXECSPACE ExecSpace;
+  TestViewResize::testResize<ExecSpace>();
+}
+
+}  // namespace Test
+#endif  // TESTVIEWRESIZE_HPP_
diff --git a/lib/kokkos/core/unit_test/TestViewSpaceAssign.hpp b/lib/kokkos/core/unit_test/TestViewSpaceAssign.hpp
index ecec47d7ba179d5434aaa8dd4b2a9512de3c480e..d1dfb7c512f03a6183fbc617486a29af0ffee59a 100644
--- a/lib/kokkos/core/unit_test/TestViewSpaceAssign.hpp
+++ b/lib/kokkos/core/unit_test/TestViewSpaceAssign.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,27 +51,26 @@
 
 namespace Test {
 
-template< typename SpaceDst, typename SpaceSrc >
-void view_space_assign()
-{
-  Kokkos::View< double*, SpaceDst > a =
-    Kokkos::View< double*, SpaceSrc >( "a", 1 );
+template <typename SpaceDst, typename SpaceSrc>
+void view_space_assign() {
+  Kokkos::View<double*, SpaceDst> a = Kokkos::View<double*, SpaceSrc>("a", 1);
 
-  Kokkos::View< double*, Kokkos::LayoutLeft, SpaceDst > b =
-    Kokkos::View< double*, Kokkos::LayoutLeft, SpaceSrc >( "b", 1 );
+  Kokkos::View<double*, Kokkos::LayoutLeft, SpaceDst> b =
+      Kokkos::View<double*, Kokkos::LayoutLeft, SpaceSrc>("b", 1);
 
-  Kokkos::View< double*, Kokkos::LayoutRight, SpaceDst > c =
-    Kokkos::View< double*, Kokkos::LayoutRight, SpaceSrc >( "c", 1 );
+  Kokkos::View<double*, Kokkos::LayoutRight, SpaceDst> c =
+      Kokkos::View<double*, Kokkos::LayoutRight, SpaceSrc>("c", 1);
 
-  Kokkos::View< double*, SpaceDst, Kokkos::MemoryRandomAccess > d =
-    Kokkos::View< double*, SpaceSrc >( "d", 1 );
+  Kokkos::View<double*, SpaceDst, Kokkos::MemoryRandomAccess> d =
+      Kokkos::View<double*, SpaceSrc>("d", 1);
 
-  Kokkos::View< double*, Kokkos::LayoutLeft, SpaceDst, Kokkos::MemoryRandomAccess > e =
-    Kokkos::View< double*, Kokkos::LayoutLeft, SpaceSrc >( "e", 1 );
+  Kokkos::View<double*, Kokkos::LayoutLeft, SpaceDst,
+               Kokkos::MemoryRandomAccess>
+      e = Kokkos::View<double*, Kokkos::LayoutLeft, SpaceSrc>("e", 1);
 
   // Rank-one layout can assign:
-  Kokkos::View< double*, Kokkos::LayoutRight, SpaceDst > f =
-  Kokkos::View< double*, Kokkos::LayoutLeft, SpaceSrc >( "f", 1 );
+  Kokkos::View<double*, Kokkos::LayoutRight, SpaceDst> f =
+      Kokkos::View<double*, Kokkos::LayoutLeft, SpaceSrc>("f", 1);
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestViewSubview.hpp b/lib/kokkos/core/unit_test/TestViewSubview.hpp
index bffc77181f14ff0f272950628f1154ae8edb88f0..48be58c2e994441c86703221d9192dc8f3fea9eb 100644
--- a/lib/kokkos/core/unit_test/TestViewSubview.hpp
+++ b/lib/kokkos/core/unit_test/TestViewSubview.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -67,43 +68,29 @@ struct static_assert_predicate_true_impl;
 
 template <template <class...> class predicate, class... message, class... args>
 struct static_assert_predicate_true_impl<
-  typename std::enable_if<predicate<args...>::type::value>::type,
-  predicate,
-  static_predicate_message<message...>,
-  args...
-> {
+    typename std::enable_if<predicate<args...>::type::value>::type, predicate,
+    static_predicate_message<message...>, args...> {
   using type = int;
 };
 
 template <template <class...> class predicate, class... message, class... args>
 struct static_assert_predicate_true_impl<
-  typename std::enable_if<!predicate<args...>::type::value>::type,
-  predicate,
-  static_predicate_message<message...>,
-  args...
->
-{
-  using type = typename _kokkos____________________static_test_failure_____<message...>::type;
+    typename std::enable_if<!predicate<args...>::type::value>::type, predicate,
+    static_predicate_message<message...>, args...> {
+  using type = typename _kokkos____________________static_test_failure_____<
+      message...>::type;
 };
 
 template <template <class...> class predicate, class... args>
 struct static_assert_predicate_true
-  : static_assert_predicate_true_impl<void,
-      predicate, static_predicate_message<>,
-      args...
-    >
-{ };
+    : static_assert_predicate_true_impl<void, predicate,
+                                        static_predicate_message<>, args...> {};
 
 template <template <class...> class predicate, class... message, class... args>
 struct static_assert_predicate_true<
-  predicate, static_predicate_message<message...>,
-  args...
->
-  : static_assert_predicate_true_impl<void,
-      predicate, static_predicate_message<message...>,
-      args...
-    >
-{ };
+    predicate, static_predicate_message<message...>, args...>
+    : static_assert_predicate_true_impl<
+          void, predicate, static_predicate_message<message...>, args...> {};
 
 //------------------------------------------------------------------------------
 
@@ -111,48 +98,40 @@ struct static_assert_predicate_true<
 struct _kokkos__________types_should_be_the_same_____expected_type__ {};
 struct _kokkos__________actual_type_was__ {};
 template <class Expected, class Actual>
-struct static_expect_same
-{
-  using type =
-    typename static_assert_predicate_true<
+struct static_expect_same {
+  using type = typename static_assert_predicate_true<
       std::is_same,
       static_predicate_message<
-        _kokkos__________types_should_be_the_same_____expected_type__,
-        Expected,
-        _kokkos__________actual_type_was__,
-        Actual
-      >,
-      Expected, Actual
-    >::type;
+          _kokkos__________types_should_be_the_same_____expected_type__,
+          Expected, _kokkos__________actual_type_was__, Actual>,
+      Expected, Actual>::type;
 };
 
 //------------------------------------------------------------------------------
 
-
 namespace TestViewSubview {
 
-template< class Layout, class Space >
+template <class Layout, class Space>
 struct getView {
-  static
-    Kokkos::View< double**, Layout, Space > get( int n, int m ) {
-      return Kokkos::View< double**, Layout, Space >( "G", n, m );
+  static Kokkos::View<double**, Layout, Space> get(int n, int m) {
+    return Kokkos::View<double**, Layout, Space>("G", n, m);
   }
 };
 
-template< class Space >
-struct getView< Kokkos::LayoutStride, Space > {
-  static
-    Kokkos::View< double**, Kokkos::LayoutStride, Space > get( int n, int m ) {
-      const int rank = 2;
-      const int order[] = { 0, 1 };
-      const unsigned dim[] = { unsigned( n ), unsigned( m ) };
-      Kokkos::LayoutStride stride = Kokkos::LayoutStride::order_dimensions( rank, order, dim );
-
-      return Kokkos::View< double**, Kokkos::LayoutStride, Space >( "G", stride );
+template <class Space>
+struct getView<Kokkos::LayoutStride, Space> {
+  static Kokkos::View<double**, Kokkos::LayoutStride, Space> get(int n, int m) {
+    const int rank       = 2;
+    const int order[]    = {0, 1};
+    const unsigned dim[] = {unsigned(n), unsigned(m)};
+    Kokkos::LayoutStride stride =
+        Kokkos::LayoutStride::order_dimensions(rank, order, dim);
+
+    return Kokkos::View<double**, Kokkos::LayoutStride, Space>("G", stride);
   }
 };
 
-template< class ViewType, class Space >
+template <class ViewType, class Space>
 struct fill_1D {
   typedef typename Space::execution_space execution_space;
   typedef typename ViewType::size_type size_type;
@@ -160,13 +139,13 @@ struct fill_1D {
   ViewType a;
   double val;
 
-  fill_1D( ViewType a_, double val_ ) : a( a_ ), val( val_ ) {}
+  fill_1D(ViewType a_, double val_) : a(a_), val(val_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i ) const { a( i ) = val; }
+  void operator()(const int i) const { a(i) = val; }
 };
 
-template< class ViewType, class Space >
+template <class ViewType, class Space>
 struct fill_2D {
   typedef typename Space::execution_space execution_space;
   typedef typename ViewType::size_type size_type;
@@ -174,562 +153,603 @@ struct fill_2D {
   ViewType a;
   double val;
 
-  fill_2D( ViewType a_, double val_ ) : a( a_ ), val( val_ ) {}
+  fill_2D(ViewType a_, double val_) : a(a_), val(val_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int i ) const
-  {
-    for ( int j = 0; j < static_cast< int >( a.extent(1) ); j++ ) {
-      a( i, j ) = val;
+  void operator()(const int i) const {
+    for (int j = 0; j < static_cast<int>(a.extent(1)); j++) {
+      a(i, j) = val;
     }
   }
 };
 
-template< class Layout, class Space >
-void test_auto_1d ()
-{
-  typedef Kokkos::View< double**, Layout, Space > mv_type;
+template <class Layout, class Space>
+void test_auto_1d() {
+  typedef Kokkos::View<double**, Layout, Space> mv_type;
   typedef typename mv_type::size_type size_type;
 
   const double ZERO = 0.0;
-  const double ONE = 1.0;
-  const double TWO = 2.0;
+  const double ONE  = 1.0;
+  const double TWO  = 2.0;
 
   const size_type numRows = 10;
   const size_type numCols = 3;
 
-  mv_type X = getView< Layout, Space >::get( numRows, numCols );
-  typename mv_type::HostMirror X_h = Kokkos::create_mirror_view( X );
+  mv_type X = getView<Layout, Space>::get(numRows, numCols);
+  typename mv_type::HostMirror X_h = Kokkos::create_mirror_view(X);
 
-  fill_2D< mv_type, Space > f1( X, ONE );
-  Kokkos::parallel_for( X.extent(0), f1 );
+  fill_2D<mv_type, Space> f1(X, ONE);
+  Kokkos::parallel_for(X.extent(0), f1);
   Kokkos::fence();
-  Kokkos::deep_copy( X_h, X );
-  for ( size_type j = 0; j < numCols; ++j ) {
-    for ( size_type i = 0; i < numRows; ++i ) {
-      ASSERT_TRUE( X_h( i, j ) == ONE );
+  Kokkos::deep_copy(X_h, X);
+  for (size_type j = 0; j < numCols; ++j) {
+    for (size_type i = 0; i < numRows; ++i) {
+      ASSERT_TRUE(X_h(i, j) == ONE);
     }
   }
 
-  fill_2D< mv_type, Space > f2( X, 0.0 );
-  Kokkos::parallel_for( X.extent(0), f2 );
+  fill_2D<mv_type, Space> f2(X, 0.0);
+  Kokkos::parallel_for(X.extent(0), f2);
   Kokkos::fence();
-  Kokkos::deep_copy( X_h, X );
-  for ( size_type j = 0; j < numCols; ++j ) {
-    for ( size_type i = 0; i < numRows; ++i ) {
-      ASSERT_TRUE( X_h( i, j ) == ZERO );
+  Kokkos::deep_copy(X_h, X);
+  for (size_type j = 0; j < numCols; ++j) {
+    for (size_type i = 0; i < numRows; ++i) {
+      ASSERT_TRUE(X_h(i, j) == ZERO);
     }
   }
 
-  fill_2D< mv_type, Space > f3( X, TWO );
-  Kokkos::parallel_for( X.extent(0), f3 );
+  fill_2D<mv_type, Space> f3(X, TWO);
+  Kokkos::parallel_for(X.extent(0), f3);
   Kokkos::fence();
-  Kokkos::deep_copy( X_h, X );
-  for ( size_type j = 0; j < numCols; ++j ) {
-    for ( size_type i = 0; i < numRows; ++i ) {
-      ASSERT_TRUE( X_h( i, j ) == TWO );
+  Kokkos::deep_copy(X_h, X);
+  for (size_type j = 0; j < numCols; ++j) {
+    for (size_type i = 0; i < numRows; ++i) {
+      ASSERT_TRUE(X_h(i, j) == TWO);
     }
   }
 
-  for ( size_type j = 0; j < numCols; ++j ) {
-    auto X_j = Kokkos::subview( X, Kokkos::ALL, j );
+  for (size_type j = 0; j < numCols; ++j) {
+    auto X_j = Kokkos::subview(X, Kokkos::ALL, j);
 
-    fill_1D< decltype( X_j ), Space > f4( X_j, ZERO );
-    Kokkos::parallel_for( X_j.extent(0), f4 );
+    fill_1D<decltype(X_j), Space> f4(X_j, ZERO);
+    Kokkos::parallel_for(X_j.extent(0), f4);
     Kokkos::fence();
-    Kokkos::deep_copy( X_h, X );
-    for ( size_type i = 0; i < numRows; ++i ) {
-      ASSERT_TRUE( X_h( i, j ) == ZERO );
+    Kokkos::deep_copy(X_h, X);
+    for (size_type i = 0; i < numRows; ++i) {
+      ASSERT_TRUE(X_h(i, j) == ZERO);
     }
 
-    for ( size_type jj = 0; jj < numCols; ++jj ) {
-      auto X_jj = Kokkos::subview ( X, Kokkos::ALL, jj );
-      fill_1D< decltype( X_jj ), Space > f5( X_jj, ONE );
-      Kokkos::parallel_for( X_jj.extent(0), f5 );
+    for (size_type jj = 0; jj < numCols; ++jj) {
+      auto X_jj = Kokkos::subview(X, Kokkos::ALL, jj);
+      fill_1D<decltype(X_jj), Space> f5(X_jj, ONE);
+      Kokkos::parallel_for(X_jj.extent(0), f5);
       Kokkos::fence();
-      Kokkos::deep_copy( X_h, X );
-      for ( size_type i = 0; i < numRows; ++i ) {
-        ASSERT_TRUE( X_h( i, jj ) == ONE );
+      Kokkos::deep_copy(X_h, X);
+      for (size_type i = 0; i < numRows; ++i) {
+        ASSERT_TRUE(X_h(i, jj) == ONE);
       }
     }
   }
 }
 
-template< class LD, class LS, class Space >
-void test_1d_strided_assignment_impl( bool a, bool b, bool c, bool d, int n, int m ) {
-  Kokkos::View< double**, LS, Space > l2d( "l2d", n, m );
+template <class LD, class LS, class Space>
+void test_1d_strided_assignment_impl(bool a, bool b, bool c, bool d, int n,
+                                     int m) {
+  Kokkos::View<double**, LS, Space> l2d("l2d", n, m);
 
   int col = n > 2 ? 2 : 0;
   int row = m > 2 ? 2 : 0;
 
-  if ( Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, typename Space::memory_space >::accessible ) {
-    if ( a ) {
-      Kokkos::View< double*, LD, Space > l1da = Kokkos::subview( l2d, Kokkos::ALL, row );
-      ASSERT_TRUE( & l1da( 0 ) == & l2d( 0, row ) );
-      if ( n > 1 ) {
-        ASSERT_TRUE( & l1da( 1 ) == & l2d( 1, row ) );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    if (a) {
+      Kokkos::View<double*, LD, Space> l1da =
+          Kokkos::subview(l2d, Kokkos::ALL, row);
+      ASSERT_TRUE(&l1da(0) == &l2d(0, row));
+      if (n > 1) {
+        ASSERT_TRUE(&l1da(1) == &l2d(1, row));
       }
     }
 
-    if ( b && n > 13 ) {
-      Kokkos::View< double*, LD, Space > l1db = Kokkos::subview( l2d, std::pair< unsigned, unsigned >( 2, 13 ), row );
-      ASSERT_TRUE( & l1db( 0 ) == & l2d( 2, row ) );
-      ASSERT_TRUE( & l1db( 1 ) == & l2d( 3, row ) );
+    if (b && n > 13) {
+      Kokkos::View<double*, LD, Space> l1db =
+          Kokkos::subview(l2d, std::pair<unsigned, unsigned>(2, 13), row);
+      ASSERT_TRUE(&l1db(0) == &l2d(2, row));
+      ASSERT_TRUE(&l1db(1) == &l2d(3, row));
     }
 
-    if ( c ) {
-      Kokkos::View< double*, LD, Space > l1dc = Kokkos::subview( l2d, col, Kokkos::ALL );
-      ASSERT_TRUE( & l1dc( 0 ) == & l2d( col, 0 ) );
-      if( m > 1 ) {
-        ASSERT_TRUE( & l1dc( 1 ) == & l2d( col, 1 ) );
+    if (c) {
+      Kokkos::View<double*, LD, Space> l1dc =
+          Kokkos::subview(l2d, col, Kokkos::ALL);
+      ASSERT_TRUE(&l1dc(0) == &l2d(col, 0));
+      if (m > 1) {
+        ASSERT_TRUE(&l1dc(1) == &l2d(col, 1));
       }
     }
 
-    if ( d && m > 13 ) {
-      Kokkos::View< double*, LD, Space > l1dd = Kokkos::subview( l2d, col, std::pair< unsigned, unsigned >( 2, 13 ) );
-      ASSERT_TRUE( & l1dd( 0 ) == & l2d( col, 2 ) );
-      ASSERT_TRUE( & l1dd( 1 ) == & l2d( col, 3 ) );
+    if (d && m > 13) {
+      Kokkos::View<double*, LD, Space> l1dd =
+          Kokkos::subview(l2d, col, std::pair<unsigned, unsigned>(2, 13));
+      ASSERT_TRUE(&l1dd(0) == &l2d(col, 2));
+      ASSERT_TRUE(&l1dd(1) == &l2d(col, 3));
     }
   }
-
 }
 
-template< class Space >
+template <class Space>
 void test_1d_strided_assignment() {
-  test_1d_strided_assignment_impl< Kokkos::LayoutStride, Kokkos::LayoutLeft, Space >( true, true, true, true, 17, 3 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutStride, Kokkos::LayoutRight, Space >( true, true, true, true, 17, 3 );
-
-  test_1d_strided_assignment_impl< Kokkos::LayoutLeft, Kokkos::LayoutLeft, Space >( true, true, false, false, 17, 3 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutRight, Kokkos::LayoutLeft, Space >( true, true, false, false, 17, 3 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutLeft, Kokkos::LayoutRight, Space >( false, false, true, true, 17, 3 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutRight, Kokkos::LayoutRight, Space >( false, false, true, true, 17, 3 );
-
-  test_1d_strided_assignment_impl< Kokkos::LayoutLeft, Kokkos::LayoutLeft, Space >( true, true, false, false, 17, 1 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutLeft, Kokkos::LayoutLeft, Space >( true, true, true, true, 1, 17 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutRight, Kokkos::LayoutLeft, Space >( true, true, true, true, 1, 17 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutRight, Kokkos::LayoutLeft, Space >( true, true, false, false, 17, 1 );
-
-  test_1d_strided_assignment_impl< Kokkos::LayoutLeft, Kokkos::LayoutRight, Space >( true, true, true, true, 17, 1 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutLeft, Kokkos::LayoutRight, Space >( false, false, true, true, 1, 17 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutRight, Kokkos::LayoutRight, Space >( false, false, true, true, 1, 17 );
-  test_1d_strided_assignment_impl< Kokkos::LayoutRight, Kokkos::LayoutRight, Space >( true, true, true, true, 17, 1 );
+  test_1d_strided_assignment_impl<Kokkos::LayoutStride, Kokkos::LayoutLeft,
+                                  Space>(true, true, true, true, 17, 3);
+  test_1d_strided_assignment_impl<Kokkos::LayoutStride, Kokkos::LayoutRight,
+                                  Space>(true, true, true, true, 17, 3);
+
+  test_1d_strided_assignment_impl<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                  Space>(true, true, false, false, 17, 3);
+  test_1d_strided_assignment_impl<Kokkos::LayoutRight, Kokkos::LayoutLeft,
+                                  Space>(true, true, false, false, 17, 3);
+  test_1d_strided_assignment_impl<Kokkos::LayoutLeft, Kokkos::LayoutRight,
+                                  Space>(false, false, true, true, 17, 3);
+  test_1d_strided_assignment_impl<Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                  Space>(false, false, true, true, 17, 3);
+
+  test_1d_strided_assignment_impl<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                  Space>(true, true, false, false, 17, 1);
+  test_1d_strided_assignment_impl<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                  Space>(true, true, true, true, 1, 17);
+  test_1d_strided_assignment_impl<Kokkos::LayoutRight, Kokkos::LayoutLeft,
+                                  Space>(true, true, true, true, 1, 17);
+  test_1d_strided_assignment_impl<Kokkos::LayoutRight, Kokkos::LayoutLeft,
+                                  Space>(true, true, false, false, 17, 1);
+
+  test_1d_strided_assignment_impl<Kokkos::LayoutLeft, Kokkos::LayoutRight,
+                                  Space>(true, true, true, true, 17, 1);
+  test_1d_strided_assignment_impl<Kokkos::LayoutLeft, Kokkos::LayoutRight,
+                                  Space>(false, false, true, true, 1, 17);
+  test_1d_strided_assignment_impl<Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                  Space>(false, false, true, true, 1, 17);
+  test_1d_strided_assignment_impl<Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                  Space>(true, true, true, true, 17, 1);
 }
 
-template< class Space >
-void test_left_0()
-{
-  typedef Kokkos::View< int [2][3][4][5][2][3][4][5], Kokkos::LayoutLeft, Space > view_static_8_type;
+template <class Space>
+void test_left_0() {
+  typedef Kokkos::View<int[2][3][4][5][2][3][4][5], Kokkos::LayoutLeft, Space>
+      view_static_8_type;
 
-  if ( Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, typename Space::memory_space >::accessible ) {
-    view_static_8_type x_static_8( "x_static_left_8" );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    view_static_8_type x_static_8("x_static_left_8");
 
-    ASSERT_TRUE( x_static_8.span_is_contiguous() );
+    ASSERT_TRUE(x_static_8.span_is_contiguous());
 
-    Kokkos::View< int, Kokkos::LayoutLeft, Space > x0 = Kokkos::subview( x_static_8, 0, 0, 0, 0, 0, 0, 0, 0 );
+    Kokkos::View<int, Kokkos::LayoutLeft, Space> x0 =
+        Kokkos::subview(x_static_8, 0, 0, 0, 0, 0, 0, 0, 0);
 
-    ASSERT_TRUE( x0.span_is_contiguous() );
-    ASSERT_TRUE( & x0() == & x_static_8( 0, 0, 0, 0, 0, 0, 0, 0 ) );
+    ASSERT_TRUE(x0.span_is_contiguous());
+    ASSERT_TRUE(&x0() == &x_static_8(0, 0, 0, 0, 0, 0, 0, 0));
 
-    Kokkos::View< int*, Kokkos::LayoutLeft, Space > x1 =
-      Kokkos::subview( x_static_8, Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3, 0, 1, 2, 3 );
+    Kokkos::View<int*, Kokkos::LayoutLeft, Space> x1 = Kokkos::subview(
+        x_static_8, Kokkos::pair<int, int>(0, 2), 1, 2, 3, 0, 1, 2, 3);
 
-    ASSERT_TRUE( x1.span_is_contiguous() );
-    ASSERT_TRUE( & x1( 0 ) == & x_static_8( 0, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & x1( 1 ) == & x_static_8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
+    ASSERT_TRUE(x1.span_is_contiguous());
+    ASSERT_TRUE(&x1(0) == &x_static_8(0, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&x1(1) == &x_static_8(1, 1, 2, 3, 0, 1, 2, 3));
 
-    Kokkos::View< int**, Kokkos::LayoutLeft, Space > x2 =
-      Kokkos::subview( x_static_8, Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3
-                                 , Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3 );
+    Kokkos::View<int**, Kokkos::LayoutLeft, Space> x2 =
+        Kokkos::subview(x_static_8, Kokkos::pair<int, int>(0, 2), 1, 2, 3,
+                        Kokkos::pair<int, int>(0, 2), 1, 2, 3);
 
-    ASSERT_TRUE( ! x2.span_is_contiguous() );
-    ASSERT_TRUE( & x2( 0, 0 ) == & x_static_8( 0, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & x2( 1, 0 ) == & x_static_8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & x2( 0, 1 ) == & x_static_8( 0, 1, 2, 3, 1, 1, 2, 3 ) );
-    ASSERT_TRUE( & x2( 1, 1 ) == & x_static_8( 1, 1, 2, 3, 1, 1, 2, 3 ) );
+    ASSERT_TRUE(!x2.span_is_contiguous());
+    ASSERT_TRUE(&x2(0, 0) == &x_static_8(0, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&x2(1, 0) == &x_static_8(1, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&x2(0, 1) == &x_static_8(0, 1, 2, 3, 1, 1, 2, 3));
+    ASSERT_TRUE(&x2(1, 1) == &x_static_8(1, 1, 2, 3, 1, 1, 2, 3));
 
     // Kokkos::View< int**, Kokkos::LayoutLeft, Space > error_2 =
-    Kokkos::View< int**, Kokkos::LayoutStride, Space > sx2 =
-      Kokkos::subview( x_static_8, 1, Kokkos::pair< int, int >( 0, 2 ), 2, 3
-                                    , Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3 );
-
-    ASSERT_TRUE( ! sx2.span_is_contiguous() );
-    ASSERT_TRUE( & sx2( 0, 0 ) == & x_static_8( 1, 0, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 0 ) == & x_static_8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 0, 1 ) == & x_static_8( 1, 0, 2, 3, 1, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 1 ) == & x_static_8( 1, 1, 2, 3, 1, 1, 2, 3 ) );
-
-    Kokkos::View< int****, Kokkos::LayoutStride, Space > sx4 =
-      Kokkos::subview( x_static_8, 0, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                                 , 1, Kokkos::pair< int, int >( 1, 3 ) /* of [5] */
-                                 , 1, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                                 , 2, Kokkos::pair< int, int >( 2, 4 ) /* of [5] */
-                     );
-
-    ASSERT_TRUE( ! sx4.span_is_contiguous() );
-
-    for ( int i0 = 0; i0 < (int) sx4.extent(0); ++i0 )
-    for ( int i1 = 0; i1 < (int) sx4.extent(1); ++i1 )
-    for ( int i2 = 0; i2 < (int) sx4.extent(2); ++i2 )
-    for ( int i3 = 0; i3 < (int) sx4.extent(3); ++i3 )
-    {
-      ASSERT_TRUE( & sx4( i0, i1, i2, i3 ) == & x_static_8( 0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3 ) );
-    }
+    Kokkos::View<int**, Kokkos::LayoutStride, Space> sx2 =
+        Kokkos::subview(x_static_8, 1, Kokkos::pair<int, int>(0, 2), 2, 3,
+                        Kokkos::pair<int, int>(0, 2), 1, 2, 3);
+
+    ASSERT_TRUE(!sx2.span_is_contiguous());
+    ASSERT_TRUE(&sx2(0, 0) == &x_static_8(1, 0, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 0) == &x_static_8(1, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(0, 1) == &x_static_8(1, 0, 2, 3, 1, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 1) == &x_static_8(1, 1, 2, 3, 1, 1, 2, 3));
+
+    Kokkos::View<int****, Kokkos::LayoutStride, Space> sx4 =
+        Kokkos::subview(x_static_8, 0, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        1, Kokkos::pair<int, int>(1, 3) /* of [5] */
+                        ,
+                        1, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        2, Kokkos::pair<int, int>(2, 4) /* of [5] */
+        );
+
+    ASSERT_TRUE(!sx4.span_is_contiguous());
+
+    for (int i0 = 0; i0 < (int)sx4.extent(0); ++i0)
+      for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
+        for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
+          for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
+            ASSERT_TRUE(&sx4(i0, i1, i2, i3) == &x_static_8(0, 0 + i0, 1,
+                                                            1 + i1, 1, 0 + i2,
+                                                            2, 2 + i3));
+          }
   }
 }
 
-template< class Space >
-void test_left_1()
-{
-  typedef Kokkos::View< int ****[2][3][4][5], Kokkos::LayoutLeft, Space > view_type;
+template <class Space>
+void test_left_1() {
+  typedef Kokkos::View<int*** * [2][3][4][5], Kokkos::LayoutLeft, Space>
+      view_type;
 
-  if ( Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, typename Space::memory_space >::accessible ) {
-    view_type x8( "x_left_8", 2, 3, 4, 5 );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    view_type x8("x_left_8", 2, 3, 4, 5);
 
-    ASSERT_TRUE( x8.span_is_contiguous() );
+    ASSERT_TRUE(x8.span_is_contiguous());
 
-    Kokkos::View< int, Kokkos::LayoutLeft, Space > x0 = Kokkos::subview( x8, 0, 0, 0, 0, 0, 0, 0, 0 );
+    Kokkos::View<int, Kokkos::LayoutLeft, Space> x0 =
+        Kokkos::subview(x8, 0, 0, 0, 0, 0, 0, 0, 0);
 
-    ASSERT_TRUE( x0.span_is_contiguous() );
-    ASSERT_TRUE( & x0() == & x8( 0, 0, 0, 0, 0, 0, 0, 0 ) );
+    ASSERT_TRUE(x0.span_is_contiguous());
+    ASSERT_TRUE(&x0() == &x8(0, 0, 0, 0, 0, 0, 0, 0));
 
-    Kokkos::View< int*, Kokkos::LayoutLeft, Space > x1 =
-      Kokkos::subview( x8, Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3, 0, 1, 2, 3 );
+    Kokkos::View<int*, Kokkos::LayoutLeft, Space> x1 =
+        Kokkos::subview(x8, Kokkos::pair<int, int>(0, 2), 1, 2, 3, 0, 1, 2, 3);
 
-    ASSERT_TRUE( x1.span_is_contiguous() );
-    ASSERT_TRUE( & x1( 0 ) == & x8( 0, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & x1( 1 ) == & x8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
+    ASSERT_TRUE(x1.span_is_contiguous());
+    ASSERT_TRUE(&x1(0) == &x8(0, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&x1(1) == &x8(1, 1, 2, 3, 0, 1, 2, 3));
 
-    Kokkos::View< int**, Kokkos::LayoutLeft, Space > x2 =
-      Kokkos::subview( x8, Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3
-                         , Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3 );
+    Kokkos::View<int**, Kokkos::LayoutLeft, Space> x2 =
+        Kokkos::subview(x8, Kokkos::pair<int, int>(0, 2), 1, 2, 3,
+                        Kokkos::pair<int, int>(0, 2), 1, 2, 3);
 
-    ASSERT_TRUE( ! x2.span_is_contiguous() );
-    ASSERT_TRUE( & x2( 0, 0 ) == & x8( 0, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & x2( 1, 0 ) == & x8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & x2( 0, 1 ) == & x8( 0, 1, 2, 3, 1, 1, 2, 3 ) );
-    ASSERT_TRUE( & x2( 1, 1 ) == & x8( 1, 1, 2, 3, 1, 1, 2, 3 ) );
+    ASSERT_TRUE(!x2.span_is_contiguous());
+    ASSERT_TRUE(&x2(0, 0) == &x8(0, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&x2(1, 0) == &x8(1, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&x2(0, 1) == &x8(0, 1, 2, 3, 1, 1, 2, 3));
+    ASSERT_TRUE(&x2(1, 1) == &x8(1, 1, 2, 3, 1, 1, 2, 3));
 
     // Kokkos::View< int**, Kokkos::LayoutLeft, Space > error_2 =
-    Kokkos::View< int**, Kokkos::LayoutStride, Space > sx2 =
-      Kokkos::subview( x8, 1, Kokkos::pair< int, int >( 0, 2 ), 2, 3
-                            , Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3 );
-
-    ASSERT_TRUE( ! sx2.span_is_contiguous() );
-    ASSERT_TRUE( & sx2( 0, 0 ) == & x8( 1, 0, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 0 ) == & x8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 0, 1 ) == & x8( 1, 0, 2, 3, 1, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 1 ) == & x8( 1, 1, 2, 3, 1, 1, 2, 3 ) );
-
-    Kokkos::View< int****, Kokkos::LayoutStride, Space > sx4 =
-      Kokkos::subview( x8, 0, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                         , 1, Kokkos::pair< int, int >( 1, 3 ) /* of [5] */
-                         , 1, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                         , 2, Kokkos::pair< int, int >( 2, 4 ) /* of [5] */
-                     );
-
-    ASSERT_TRUE( ! sx4.span_is_contiguous() );
-
-    for ( int i0 = 0; i0 < (int) sx4.extent(0); ++i0 )
-    for ( int i1 = 0; i1 < (int) sx4.extent(1); ++i1 )
-    for ( int i2 = 0; i2 < (int) sx4.extent(2); ++i2 )
-    for ( int i3 = 0; i3 < (int) sx4.extent(3); ++i3 )
-    {
-      ASSERT_TRUE( & sx4( i0, i1, i2, i3 ) == & x8( 0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3 ) );
-    }
+    Kokkos::View<int**, Kokkos::LayoutStride, Space> sx2 =
+        Kokkos::subview(x8, 1, Kokkos::pair<int, int>(0, 2), 2, 3,
+                        Kokkos::pair<int, int>(0, 2), 1, 2, 3);
+
+    ASSERT_TRUE(!sx2.span_is_contiguous());
+    ASSERT_TRUE(&sx2(0, 0) == &x8(1, 0, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 0) == &x8(1, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(0, 1) == &x8(1, 0, 2, 3, 1, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 1) == &x8(1, 1, 2, 3, 1, 1, 2, 3));
+
+    Kokkos::View<int****, Kokkos::LayoutStride, Space> sx4 =
+        Kokkos::subview(x8, 0, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        1, Kokkos::pair<int, int>(1, 3) /* of [5] */
+                        ,
+                        1, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        2, Kokkos::pair<int, int>(2, 4) /* of [5] */
+        );
+
+    ASSERT_TRUE(!sx4.span_is_contiguous());
+
+    for (int i0 = 0; i0 < (int)sx4.extent(0); ++i0)
+      for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
+        for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
+          for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
+            ASSERT_TRUE(&sx4(i0, i1, i2, i3) ==
+                        &x8(0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3));
+          }
   }
 }
 
-template< class Space >
-void test_left_2()
-{
-  typedef Kokkos::View< int ****, Kokkos::LayoutLeft, Space > view_type;
+template <class Space>
+void test_left_2() {
+  typedef Kokkos::View<int****, Kokkos::LayoutLeft, Space> view_type;
 
-  if ( Kokkos::Impl::SpaceAccessibility<Kokkos::HostSpace, typename Space::memory_space>::accessible ) {
-    view_type x4( "x4", 2, 3, 4, 5 );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    view_type x4("x4", 2, 3, 4, 5);
 
-    ASSERT_TRUE( x4.span_is_contiguous() );
+    ASSERT_TRUE(x4.span_is_contiguous());
 
-    Kokkos::View< int, Kokkos::LayoutLeft, Space > x0 = Kokkos::subview( x4, 0, 0, 0, 0 );
+    Kokkos::View<int, Kokkos::LayoutLeft, Space> x0 =
+        Kokkos::subview(x4, 0, 0, 0, 0);
 
-    ASSERT_TRUE( x0.span_is_contiguous() );
-    ASSERT_TRUE( & x0() == & x4( 0, 0, 0, 0 ) );
+    ASSERT_TRUE(x0.span_is_contiguous());
+    ASSERT_TRUE(&x0() == &x4(0, 0, 0, 0));
 
-    Kokkos::View< int*, Kokkos::LayoutLeft, Space > x1 =
-      Kokkos::subview( x4, Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3 );
+    Kokkos::View<int*, Kokkos::LayoutLeft, Space> x1 =
+        Kokkos::subview(x4, Kokkos::pair<int, int>(0, 2), 1, 2, 3);
 
-    ASSERT_TRUE( x1.span_is_contiguous() );
-    ASSERT_TRUE( & x1( 0 ) == & x4( 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & x1( 1 ) == & x4( 1, 1, 2, 3 ) );
+    ASSERT_TRUE(x1.span_is_contiguous());
+    ASSERT_TRUE(&x1(0) == &x4(0, 1, 2, 3));
+    ASSERT_TRUE(&x1(1) == &x4(1, 1, 2, 3));
 
-    Kokkos::View< int**, Kokkos::LayoutLeft, Space > x2 =
-      Kokkos::subview( x4, Kokkos::pair< int, int >( 0, 2 ), 1
-                         , Kokkos::pair< int, int >( 1, 3 ), 2 );
+    Kokkos::View<int**, Kokkos::LayoutLeft, Space> x2 = Kokkos::subview(
+        x4, Kokkos::pair<int, int>(0, 2), 1, Kokkos::pair<int, int>(1, 3), 2);
 
-    ASSERT_TRUE( ! x2.span_is_contiguous() );
-    ASSERT_TRUE( & x2( 0, 0 ) == & x4( 0, 1, 1, 2 ) );
-    ASSERT_TRUE( & x2( 1, 0 ) == & x4( 1, 1, 1, 2 ) );
-    ASSERT_TRUE( & x2( 0, 1 ) == & x4( 0, 1, 2, 2 ) );
-    ASSERT_TRUE( & x2( 1, 1 ) == & x4( 1, 1, 2, 2 ) );
+    ASSERT_TRUE(!x2.span_is_contiguous());
+    ASSERT_TRUE(&x2(0, 0) == &x4(0, 1, 1, 2));
+    ASSERT_TRUE(&x2(1, 0) == &x4(1, 1, 1, 2));
+    ASSERT_TRUE(&x2(0, 1) == &x4(0, 1, 2, 2));
+    ASSERT_TRUE(&x2(1, 1) == &x4(1, 1, 2, 2));
 
     // Kokkos::View< int**, Kokkos::LayoutLeft, Space > error_2 =
-    Kokkos::View< int**, Kokkos::LayoutStride, Space > sx2 =
-      Kokkos::subview( x4, 1, Kokkos::pair< int, int >( 0, 2 )
-                         , 2, Kokkos::pair< int, int >( 1, 4 ) );
-
-    ASSERT_TRUE( ! sx2.span_is_contiguous() );
-    ASSERT_TRUE( & sx2( 0, 0 ) == & x4( 1, 0, 2, 1 ) );
-    ASSERT_TRUE( & sx2( 1, 0 ) == & x4( 1, 1, 2, 1 ) );
-    ASSERT_TRUE( & sx2( 0, 1 ) == & x4( 1, 0, 2, 2 ) );
-    ASSERT_TRUE( & sx2( 1, 1 ) == & x4( 1, 1, 2, 2 ) );
-    ASSERT_TRUE( & sx2( 0, 2 ) == & x4( 1, 0, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 2 ) == & x4( 1, 1, 2, 3 ) );
-
-    Kokkos::View< int****, Kokkos::LayoutStride, Space > sx4 =
-      Kokkos::subview( x4, Kokkos::pair< int, int >( 1, 2 ) /* of [2] */
-                         , Kokkos::pair< int, int >( 1, 3 ) /* of [3] */
-                         , Kokkos::pair< int, int >( 0, 4 ) /* of [4] */
-                         , Kokkos::pair< int, int >( 2, 4 ) /* of [5] */
-                     );
-
-    ASSERT_TRUE( ! sx4.span_is_contiguous() );
-
-    for ( int i0 = 0; i0 < (int) sx4.extent(0); ++i0 )
-    for ( int i1 = 0; i1 < (int) sx4.extent(1); ++i1 )
-    for ( int i2 = 0; i2 < (int) sx4.extent(2); ++i2 )
-    for ( int i3 = 0; i3 < (int) sx4.extent(3); ++i3 )
-    {
-      ASSERT_TRUE( & sx4( i0, i1, i2, i3 ) == & x4( 1 + i0, 1 + i1, 0 + i2, 2 + i3 ) );
-    }
+    Kokkos::View<int**, Kokkos::LayoutStride, Space> sx2 = Kokkos::subview(
+        x4, 1, Kokkos::pair<int, int>(0, 2), 2, Kokkos::pair<int, int>(1, 4));
+
+    ASSERT_TRUE(!sx2.span_is_contiguous());
+    ASSERT_TRUE(&sx2(0, 0) == &x4(1, 0, 2, 1));
+    ASSERT_TRUE(&sx2(1, 0) == &x4(1, 1, 2, 1));
+    ASSERT_TRUE(&sx2(0, 1) == &x4(1, 0, 2, 2));
+    ASSERT_TRUE(&sx2(1, 1) == &x4(1, 1, 2, 2));
+    ASSERT_TRUE(&sx2(0, 2) == &x4(1, 0, 2, 3));
+    ASSERT_TRUE(&sx2(1, 2) == &x4(1, 1, 2, 3));
+
+    Kokkos::View<int****, Kokkos::LayoutStride, Space> sx4 =
+        Kokkos::subview(x4, Kokkos::pair<int, int>(1, 2) /* of [2] */
+                        ,
+                        Kokkos::pair<int, int>(1, 3) /* of [3] */
+                        ,
+                        Kokkos::pair<int, int>(0, 4) /* of [4] */
+                        ,
+                        Kokkos::pair<int, int>(2, 4) /* of [5] */
+        );
+
+    ASSERT_TRUE(!sx4.span_is_contiguous());
+
+    for (int i0 = 0; i0 < (int)sx4.extent(0); ++i0)
+      for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
+        for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
+          for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
+            ASSERT_TRUE(&sx4(i0, i1, i2, i3) ==
+                        &x4(1 + i0, 1 + i1, 0 + i2, 2 + i3));
+          }
   }
 }
 
-template< class Space >
-void test_left_3()
-{
-  typedef Kokkos::View< int **, Kokkos::LayoutLeft, Space > view_type;
+template <class Space>
+void test_left_3() {
+  typedef Kokkos::View<int**, Kokkos::LayoutLeft, Space> view_type;
 
-  if ( Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, typename Space::memory_space >::accessible ) {
-    view_type xm( "x4", 10, 5 );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    view_type xm("x4", 10, 5);
 
-    ASSERT_TRUE( xm.span_is_contiguous() );
+    ASSERT_TRUE(xm.span_is_contiguous());
 
-    Kokkos::View< int, Kokkos::LayoutLeft, Space > x0 = Kokkos::subview( xm, 5, 3 );
+    Kokkos::View<int, Kokkos::LayoutLeft, Space> x0 = Kokkos::subview(xm, 5, 3);
 
-    ASSERT_TRUE( x0.span_is_contiguous() );
-    ASSERT_TRUE( & x0() == & xm( 5, 3 ) );
+    ASSERT_TRUE(x0.span_is_contiguous());
+    ASSERT_TRUE(&x0() == &xm(5, 3));
 
-    Kokkos::View< int*, Kokkos::LayoutLeft, Space > x1 = Kokkos::subview( xm, Kokkos::ALL, 3 );
+    Kokkos::View<int*, Kokkos::LayoutLeft, Space> x1 =
+        Kokkos::subview(xm, Kokkos::ALL, 3);
 
-    ASSERT_TRUE( x1.span_is_contiguous() );
-    for ( int i = 0; i < int( xm.extent(0) ); ++i ) {
-      ASSERT_TRUE( & x1( i ) == & xm( i, 3 ) );
+    ASSERT_TRUE(x1.span_is_contiguous());
+    for (int i = 0; i < int(xm.extent(0)); ++i) {
+      ASSERT_TRUE(&x1(i) == &xm(i, 3));
     }
 
-    Kokkos::View< int**, Kokkos::LayoutLeft, Space > x2 =
-      Kokkos::subview( xm, Kokkos::pair< int, int >( 1, 9 ), Kokkos::ALL );
+    Kokkos::View<int**, Kokkos::LayoutLeft, Space> x2 =
+        Kokkos::subview(xm, Kokkos::pair<int, int>(1, 9), Kokkos::ALL);
 
-    ASSERT_TRUE( ! x2.span_is_contiguous() );
-    for ( int j = 0; j < int( x2.extent(1) ); ++j )
-    for ( int i = 0; i < int( x2.extent(0) ); ++i )
-    {
-      ASSERT_TRUE( & x2( i, j ) == & xm( 1 + i, j ) );
-    }
+    ASSERT_TRUE(!x2.span_is_contiguous());
+    for (int j = 0; j < int(x2.extent(1)); ++j)
+      for (int i = 0; i < int(x2.extent(0)); ++i) {
+        ASSERT_TRUE(&x2(i, j) == &xm(1 + i, j));
+      }
 
-    Kokkos::View< int**, Kokkos::LayoutLeft, Space > x2c =
-      Kokkos::subview( xm, Kokkos::ALL, std::pair< int, int >( 2, 4 ) );
+    Kokkos::View<int**, Kokkos::LayoutLeft, Space> x2c =
+        Kokkos::subview(xm, Kokkos::ALL, std::pair<int, int>(2, 4));
 
-    ASSERT_TRUE( x2c.span_is_contiguous() );
-    for ( int j = 0; j < int( x2c.extent(1) ); ++j )
-    for ( int i = 0; i < int( x2c.extent(0) ); ++i )
-    {
-      ASSERT_TRUE( & x2c( i, j ) == & xm( i, 2 + j ) );
-    }
+    ASSERT_TRUE(x2c.span_is_contiguous());
+    for (int j = 0; j < int(x2c.extent(1)); ++j)
+      for (int i = 0; i < int(x2c.extent(0)); ++i) {
+        ASSERT_TRUE(&x2c(i, j) == &xm(i, 2 + j));
+      }
 
-    Kokkos::View< int**, Kokkos::LayoutLeft, Space > x2_n1 =
-      Kokkos::subview( xm, std::pair< int, int >( 1, 1 ), Kokkos::ALL );
+    Kokkos::View<int**, Kokkos::LayoutLeft, Space> x2_n1 =
+        Kokkos::subview(xm, std::pair<int, int>(1, 1), Kokkos::ALL);
 
-    ASSERT_TRUE( x2_n1.extent(0) == 0 );
-    ASSERT_TRUE( x2_n1.extent(1) == xm.extent(1) );
+    ASSERT_TRUE(x2_n1.extent(0) == 0);
+    ASSERT_TRUE(x2_n1.extent(1) == xm.extent(1));
 
-    Kokkos::View< int**, Kokkos::LayoutLeft, Space > x2_n2 =
-      Kokkos::subview( xm, Kokkos::ALL, std::pair< int, int >( 1, 1 ) );
+    Kokkos::View<int**, Kokkos::LayoutLeft, Space> x2_n2 =
+        Kokkos::subview(xm, Kokkos::ALL, std::pair<int, int>(1, 1));
 
-    ASSERT_TRUE( x2_n2.extent(0) == xm.extent(0) );
-    ASSERT_TRUE( x2_n2.extent(1) == 0 );
+    ASSERT_TRUE(x2_n2.extent(0) == xm.extent(0));
+    ASSERT_TRUE(x2_n2.extent(1) == 0);
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< class Space >
-void test_right_0()
-{
-  typedef Kokkos::View< int [2][3][4][5][2][3][4][5], Kokkos::LayoutRight, Space > view_static_8_type;
+template <class Space>
+void test_right_0() {
+  typedef Kokkos::View<int[2][3][4][5][2][3][4][5], Kokkos::LayoutRight, Space>
+      view_static_8_type;
 
-  if ( Kokkos::Impl::SpaceAccessibility<Kokkos::HostSpace, typename Space::memory_space>::accessible ) {
-    view_static_8_type x_static_8( "x_static_right_8" );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    view_static_8_type x_static_8("x_static_right_8");
 
-    Kokkos::View< int, Kokkos::LayoutRight, Space > x0 = Kokkos::subview( x_static_8, 0, 0, 0, 0, 0, 0, 0, 0 );
+    Kokkos::View<int, Kokkos::LayoutRight, Space> x0 =
+        Kokkos::subview(x_static_8, 0, 0, 0, 0, 0, 0, 0, 0);
 
-    ASSERT_TRUE( & x0() == & x_static_8( 0, 0, 0, 0, 0, 0, 0, 0 ) );
+    ASSERT_TRUE(&x0() == &x_static_8(0, 0, 0, 0, 0, 0, 0, 0));
 
-    Kokkos::View< int*, Kokkos::LayoutRight, Space > x1 =
-      Kokkos::subview( x_static_8, 0, 1, 2, 3, 0, 1, 2, Kokkos::pair< int, int >( 1, 3 ) );
+    Kokkos::View<int*, Kokkos::LayoutRight, Space> x1 = Kokkos::subview(
+        x_static_8, 0, 1, 2, 3, 0, 1, 2, Kokkos::pair<int, int>(1, 3));
 
-    ASSERT_TRUE( x1.extent(0) == 2 );
-    ASSERT_TRUE( & x1( 0 ) == & x_static_8( 0, 1, 2, 3, 0, 1, 2, 1 ) );
-    ASSERT_TRUE( & x1( 1 ) == & x_static_8( 0, 1, 2, 3, 0, 1, 2, 2 ) );
+    ASSERT_TRUE(x1.extent(0) == 2);
+    ASSERT_TRUE(&x1(0) == &x_static_8(0, 1, 2, 3, 0, 1, 2, 1));
+    ASSERT_TRUE(&x1(1) == &x_static_8(0, 1, 2, 3, 0, 1, 2, 2));
 
-    Kokkos::View< int**, Kokkos::LayoutRight, Space > x2 =
-      Kokkos::subview( x_static_8, 0, 1, 2, Kokkos::pair< int, int >( 1, 3 )
-                                 , 0, 1, 2, Kokkos::pair< int, int >( 1, 3 ) );
+    Kokkos::View<int**, Kokkos::LayoutRight, Space> x2 =
+        Kokkos::subview(x_static_8, 0, 1, 2, Kokkos::pair<int, int>(1, 3), 0, 1,
+                        2, Kokkos::pair<int, int>(1, 3));
 
-    ASSERT_TRUE( x2.extent(0) == 2 );
-    ASSERT_TRUE( x2.extent(1) == 2 );
-    ASSERT_TRUE( & x2( 0, 0 ) == & x_static_8( 0, 1, 2, 1, 0, 1, 2, 1 ) );
-    ASSERT_TRUE( & x2( 1, 0 ) == & x_static_8( 0, 1, 2, 2, 0, 1, 2, 1 ) );
-    ASSERT_TRUE( & x2( 0, 1 ) == & x_static_8( 0, 1, 2, 1, 0, 1, 2, 2 ) );
-    ASSERT_TRUE( & x2( 1, 1 ) == & x_static_8( 0, 1, 2, 2, 0, 1, 2, 2 ) );
+    ASSERT_TRUE(x2.extent(0) == 2);
+    ASSERT_TRUE(x2.extent(1) == 2);
+    ASSERT_TRUE(&x2(0, 0) == &x_static_8(0, 1, 2, 1, 0, 1, 2, 1));
+    ASSERT_TRUE(&x2(1, 0) == &x_static_8(0, 1, 2, 2, 0, 1, 2, 1));
+    ASSERT_TRUE(&x2(0, 1) == &x_static_8(0, 1, 2, 1, 0, 1, 2, 2));
+    ASSERT_TRUE(&x2(1, 1) == &x_static_8(0, 1, 2, 2, 0, 1, 2, 2));
 
     // Kokkos::View< int**, Kokkos::LayoutRight, Space > error_2 =
-    Kokkos::View< int**, Kokkos::LayoutStride, Space > sx2 =
-      Kokkos::subview( x_static_8, 1, Kokkos::pair< int, int >( 0, 2 ), 2, 3
-                                    , Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3 );
-
-    ASSERT_TRUE( sx2.extent(0) == 2 );
-    ASSERT_TRUE( sx2.extent(1) == 2 );
-    ASSERT_TRUE( & sx2( 0, 0 ) == & x_static_8( 1, 0, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 0 ) == & x_static_8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 0, 1 ) == & x_static_8( 1, 0, 2, 3, 1, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 1 ) == & x_static_8( 1, 1, 2, 3, 1, 1, 2, 3 ) );
-
-    Kokkos::View< int****, Kokkos::LayoutStride, Space > sx4 =
-      Kokkos::subview( x_static_8, 0, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                                 , 1, Kokkos::pair< int, int >( 1, 3 ) /* of [5] */
-                                 , 1, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                                 , 2, Kokkos::pair< int, int >( 2, 4 ) /* of [5] */
-                     );
-
-    ASSERT_TRUE( sx4.extent(0) == 2 );
-    ASSERT_TRUE( sx4.extent(1) == 2 );
-    ASSERT_TRUE( sx4.extent(2) == 2 );
-    ASSERT_TRUE( sx4.extent(3) == 2 );
-    for ( int i0 = 0; i0 < (int) sx4.extent(0); ++i0 )
-    for ( int i1 = 0; i1 < (int) sx4.extent(1); ++i1 )
-    for ( int i2 = 0; i2 < (int) sx4.extent(2); ++i2 )
-    for ( int i3 = 0; i3 < (int) sx4.extent(3); ++i3 )
-    {
-      ASSERT_TRUE( & sx4( i0, i1, i2, i3 ) == & x_static_8( 0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3 ) );
-    }
+    Kokkos::View<int**, Kokkos::LayoutStride, Space> sx2 =
+        Kokkos::subview(x_static_8, 1, Kokkos::pair<int, int>(0, 2), 2, 3,
+                        Kokkos::pair<int, int>(0, 2), 1, 2, 3);
+
+    ASSERT_TRUE(sx2.extent(0) == 2);
+    ASSERT_TRUE(sx2.extent(1) == 2);
+    ASSERT_TRUE(&sx2(0, 0) == &x_static_8(1, 0, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 0) == &x_static_8(1, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(0, 1) == &x_static_8(1, 0, 2, 3, 1, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 1) == &x_static_8(1, 1, 2, 3, 1, 1, 2, 3));
+
+    Kokkos::View<int****, Kokkos::LayoutStride, Space> sx4 =
+        Kokkos::subview(x_static_8, 0, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        1, Kokkos::pair<int, int>(1, 3) /* of [5] */
+                        ,
+                        1, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        2, Kokkos::pair<int, int>(2, 4) /* of [5] */
+        );
+
+    ASSERT_TRUE(sx4.extent(0) == 2);
+    ASSERT_TRUE(sx4.extent(1) == 2);
+    ASSERT_TRUE(sx4.extent(2) == 2);
+    ASSERT_TRUE(sx4.extent(3) == 2);
+    for (int i0 = 0; i0 < (int)sx4.extent(0); ++i0)
+      for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
+        for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
+          for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
+            ASSERT_TRUE(&sx4(i0, i1, i2, i3) == &x_static_8(0, 0 + i0, 1,
+                                                            1 + i1, 1, 0 + i2,
+                                                            2, 2 + i3));
+          }
   }
 }
 
-template< class Space >
-void test_right_1()
-{
-  typedef Kokkos::View< int ****[2][3][4][5], Kokkos::LayoutRight, Space > view_type;
+template <class Space>
+void test_right_1() {
+  typedef Kokkos::View<int*** * [2][3][4][5], Kokkos::LayoutRight, Space>
+      view_type;
 
-  if ( Kokkos::Impl::SpaceAccessibility<Kokkos::HostSpace, typename Space::memory_space>::accessible ) {
-    view_type x8( "x_right_8", 2, 3, 4, 5 );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    view_type x8("x_right_8", 2, 3, 4, 5);
 
-    Kokkos::View< int, Kokkos::LayoutRight, Space > x0 = Kokkos::subview( x8, 0, 0, 0, 0, 0, 0, 0, 0 );
+    Kokkos::View<int, Kokkos::LayoutRight, Space> x0 =
+        Kokkos::subview(x8, 0, 0, 0, 0, 0, 0, 0, 0);
 
-    ASSERT_TRUE( & x0() == & x8( 0, 0, 0, 0, 0, 0, 0, 0 ) );
+    ASSERT_TRUE(&x0() == &x8(0, 0, 0, 0, 0, 0, 0, 0));
 
-    Kokkos::View< int*, Kokkos::LayoutRight, Space > x1 =
-      Kokkos::subview( x8, 0, 1, 2, 3, 0, 1, 2, Kokkos::pair< int, int >( 1, 3 ) );
+    Kokkos::View<int*, Kokkos::LayoutRight, Space> x1 =
+        Kokkos::subview(x8, 0, 1, 2, 3, 0, 1, 2, Kokkos::pair<int, int>(1, 3));
 
-    ASSERT_TRUE( & x1( 0 ) == & x8( 0, 1, 2, 3, 0, 1, 2, 1 ) );
-    ASSERT_TRUE( & x1( 1 ) == & x8( 0, 1, 2, 3, 0, 1, 2, 2 ) );
+    ASSERT_TRUE(&x1(0) == &x8(0, 1, 2, 3, 0, 1, 2, 1));
+    ASSERT_TRUE(&x1(1) == &x8(0, 1, 2, 3, 0, 1, 2, 2));
 
-    Kokkos::View< int**, Kokkos::LayoutRight, Space > x2 =
-      Kokkos::subview( x8, 0, 1, 2, Kokkos::pair< int, int >( 1, 3 )
-                         , 0, 1, 2, Kokkos::pair< int, int >( 1, 3 ) );
+    Kokkos::View<int**, Kokkos::LayoutRight, Space> x2 =
+        Kokkos::subview(x8, 0, 1, 2, Kokkos::pair<int, int>(1, 3), 0, 1, 2,
+                        Kokkos::pair<int, int>(1, 3));
 
-    ASSERT_TRUE( & x2( 0, 0 ) == & x8( 0, 1, 2, 1, 0, 1, 2, 1 ) );
-    ASSERT_TRUE( & x2( 1, 0 ) == & x8( 0, 1, 2, 2, 0, 1, 2, 1 ) );
-    ASSERT_TRUE( & x2( 0, 1 ) == & x8( 0, 1, 2, 1, 0, 1, 2, 2 ) );
-    ASSERT_TRUE( & x2( 1, 1 ) == & x8( 0, 1, 2, 2, 0, 1, 2, 2 ) );
+    ASSERT_TRUE(&x2(0, 0) == &x8(0, 1, 2, 1, 0, 1, 2, 1));
+    ASSERT_TRUE(&x2(1, 0) == &x8(0, 1, 2, 2, 0, 1, 2, 1));
+    ASSERT_TRUE(&x2(0, 1) == &x8(0, 1, 2, 1, 0, 1, 2, 2));
+    ASSERT_TRUE(&x2(1, 1) == &x8(0, 1, 2, 2, 0, 1, 2, 2));
 
     // Kokkos::View< int**, Kokkos::LayoutRight, Space > error_2 =
-    Kokkos::View< int**, Kokkos::LayoutStride, Space > sx2 =
-      Kokkos::subview( x8, 1, Kokkos::pair< int, int >( 0, 2 ), 2, 3
-                            , Kokkos::pair< int, int >( 0, 2 ), 1, 2, 3 );
-
-    ASSERT_TRUE( & sx2( 0, 0 ) == & x8( 1, 0, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 0 ) == & x8( 1, 1, 2, 3, 0, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 0, 1 ) == & x8( 1, 0, 2, 3, 1, 1, 2, 3 ) );
-    ASSERT_TRUE( & sx2( 1, 1 ) == & x8( 1, 1, 2, 3, 1, 1, 2, 3 ) );
-
-    Kokkos::View< int****, Kokkos::LayoutStride, Space > sx4 =
-      Kokkos::subview( x8, 0, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                         , 1, Kokkos::pair< int, int >( 1, 3 ) /* of [5] */
-                         , 1, Kokkos::pair< int, int >( 0, 2 ) /* of [3] */
-                         , 2, Kokkos::pair< int, int >( 2, 4 ) /* of [5] */
-                     );
-
-    for ( int i0 = 0; i0 < (int) sx4.extent(0); ++i0 )
-    for ( int i1 = 0; i1 < (int) sx4.extent(1); ++i1 )
-    for ( int i2 = 0; i2 < (int) sx4.extent(2); ++i2 )
-    for ( int i3 = 0; i3 < (int) sx4.extent(3); ++i3 )
-    {
-      ASSERT_TRUE( & sx4( i0, i1, i2, i3 ) == & x8( 0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3 ) );
-    }
+    Kokkos::View<int**, Kokkos::LayoutStride, Space> sx2 =
+        Kokkos::subview(x8, 1, Kokkos::pair<int, int>(0, 2), 2, 3,
+                        Kokkos::pair<int, int>(0, 2), 1, 2, 3);
+
+    ASSERT_TRUE(&sx2(0, 0) == &x8(1, 0, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 0) == &x8(1, 1, 2, 3, 0, 1, 2, 3));
+    ASSERT_TRUE(&sx2(0, 1) == &x8(1, 0, 2, 3, 1, 1, 2, 3));
+    ASSERT_TRUE(&sx2(1, 1) == &x8(1, 1, 2, 3, 1, 1, 2, 3));
+
+    Kokkos::View<int****, Kokkos::LayoutStride, Space> sx4 =
+        Kokkos::subview(x8, 0, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        1, Kokkos::pair<int, int>(1, 3) /* of [5] */
+                        ,
+                        1, Kokkos::pair<int, int>(0, 2) /* of [3] */
+                        ,
+                        2, Kokkos::pair<int, int>(2, 4) /* of [5] */
+        );
+
+    for (int i0 = 0; i0 < (int)sx4.extent(0); ++i0)
+      for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
+        for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
+          for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
+            ASSERT_TRUE(&sx4(i0, i1, i2, i3) ==
+                        &x8(0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3));
+          }
   }
 }
 
-template< class Space >
-void test_right_3()
-{
-  typedef Kokkos::View< int **, Kokkos::LayoutRight, Space > view_type;
+template <class Space>
+void test_right_3() {
+  typedef Kokkos::View<int**, Kokkos::LayoutRight, Space> view_type;
 
-  if ( Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, typename Space::memory_space >::accessible ) {
-    view_type xm( "x4", 10, 5 );
+  if (Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, typename Space::memory_space>::accessible) {
+    view_type xm("x4", 10, 5);
 
-    ASSERT_TRUE( xm.span_is_contiguous() );
+    ASSERT_TRUE(xm.span_is_contiguous());
 
-    Kokkos::View< int, Kokkos::LayoutRight, Space > x0 = Kokkos::subview( xm, 5, 3 );
+    Kokkos::View<int, Kokkos::LayoutRight, Space> x0 =
+        Kokkos::subview(xm, 5, 3);
 
-    ASSERT_TRUE( x0.span_is_contiguous() );
-    ASSERT_TRUE( & x0() == & xm( 5, 3 ) );
+    ASSERT_TRUE(x0.span_is_contiguous());
+    ASSERT_TRUE(&x0() == &xm(5, 3));
 
-    Kokkos::View< int*, Kokkos::LayoutRight, Space > x1 = Kokkos::subview( xm, 3, Kokkos::ALL );
+    Kokkos::View<int*, Kokkos::LayoutRight, Space> x1 =
+        Kokkos::subview(xm, 3, Kokkos::ALL);
 
-    ASSERT_TRUE( x1.span_is_contiguous() );
-    for ( int i = 0; i < int( xm.extent(1) ); ++i ) {
-      ASSERT_TRUE( & x1( i ) == & xm( 3, i ) );
+    ASSERT_TRUE(x1.span_is_contiguous());
+    for (int i = 0; i < int(xm.extent(1)); ++i) {
+      ASSERT_TRUE(&x1(i) == &xm(3, i));
     }
 
-    Kokkos::View< int**, Kokkos::LayoutRight, Space > x2c =
-      Kokkos::subview( xm, Kokkos::pair< int, int >( 1, 9 ), Kokkos::ALL );
+    Kokkos::View<int**, Kokkos::LayoutRight, Space> x2c =
+        Kokkos::subview(xm, Kokkos::pair<int, int>(1, 9), Kokkos::ALL);
 
-    ASSERT_TRUE( x2c.span_is_contiguous() );
-    for ( int j = 0; j < int( x2c.extent(1) ); ++j )
-    for ( int i = 0; i < int( x2c.extent(0) ); ++i ) {
-      ASSERT_TRUE( & x2c( i, j ) == & xm( 1 + i, j ) );
-    }
+    ASSERT_TRUE(x2c.span_is_contiguous());
+    for (int j = 0; j < int(x2c.extent(1)); ++j)
+      for (int i = 0; i < int(x2c.extent(0)); ++i) {
+        ASSERT_TRUE(&x2c(i, j) == &xm(1 + i, j));
+      }
 
-    Kokkos::View< int**, Kokkos::LayoutRight, Space > x2 =
-      Kokkos::subview( xm, Kokkos::ALL, std::pair< int, int >( 2, 4 ) );
+    Kokkos::View<int**, Kokkos::LayoutRight, Space> x2 =
+        Kokkos::subview(xm, Kokkos::ALL, std::pair<int, int>(2, 4));
 
-    ASSERT_TRUE( ! x2.span_is_contiguous() );
-    for ( int j = 0; j < int( x2.extent(1) ); ++j )
-    for ( int i = 0; i < int( x2.extent(0) ); ++i )
-    {
-      ASSERT_TRUE( & x2( i, j ) == & xm( i, 2 + j ) );
-    }
+    ASSERT_TRUE(!x2.span_is_contiguous());
+    for (int j = 0; j < int(x2.extent(1)); ++j)
+      for (int i = 0; i < int(x2.extent(0)); ++i) {
+        ASSERT_TRUE(&x2(i, j) == &xm(i, 2 + j));
+      }
 
-    Kokkos::View< int**, Kokkos::LayoutRight, Space > x2_n1 =
-      Kokkos::subview( xm, std::pair< int, int >( 1, 1 ), Kokkos::ALL );
+    Kokkos::View<int**, Kokkos::LayoutRight, Space> x2_n1 =
+        Kokkos::subview(xm, std::pair<int, int>(1, 1), Kokkos::ALL);
 
-    ASSERT_TRUE( x2_n1.extent(0) == 0 );
-    ASSERT_TRUE( x2_n1.extent(1) == xm.extent(1) );
+    ASSERT_TRUE(x2_n1.extent(0) == 0);
+    ASSERT_TRUE(x2_n1.extent(1) == xm.extent(1));
 
-    Kokkos::View< int**, Kokkos::LayoutRight, Space > x2_n2 =
-      Kokkos::subview( xm, Kokkos::ALL, std::pair< int, int >( 1, 1 ) );
+    Kokkos::View<int**, Kokkos::LayoutRight, Space> x2_n2 =
+        Kokkos::subview(xm, Kokkos::ALL, std::pair<int, int>(1, 1));
 
-    ASSERT_TRUE( x2_n2.extent(0) == xm.extent(0) );
-    ASSERT_TRUE( x2_n2.extent(1) == 0 );
+    ASSERT_TRUE(x2_n2.extent(0) == xm.extent(0));
+    ASSERT_TRUE(x2_n2.extent(1) == 0);
   }
 }
 
@@ -741,676 +761,1177 @@ constexpr int N2 = 17;
 constexpr int N3 = 5;
 constexpr int N4 = 7;
 
-template< class SubView, class View >
-void test_Check1D( SubView a, View b, std::pair< int, int > range ) {
+template <class SubView, class View>
+void test_Check1D(SubView a, View b, std::pair<int, int> range) {
   int errors = 0;
 
-  for ( int i = 0; i < range.second - range.first; i++ ) {
-    if ( a( i ) != b( i + range.first ) ) errors++;
+  for (int i = 0; i < range.second - range.first; i++) {
+    if (a(i) != b(i + range.first)) errors++;
   }
 
-  if ( errors > 0 ) {
+  if (errors > 0) {
     std::cout << "Error Suviews test_Check1D: " << errors << std::endl;
   }
 
-  ASSERT_TRUE( errors == 0 );
+  ASSERT_TRUE(errors == 0);
 }
 
-template< class SubView, class View >
-void test_Check1D2D( SubView a, View b, int i0, std::pair< int, int > range ) {
+template <class SubView, class View>
+void test_Check1D2D(SubView a, View b, int i0, std::pair<int, int> range) {
   int errors = 0;
 
-  for ( int i1 = 0; i1 < range.second - range.first; i1++ ) {
-    if ( a( i1 ) != b( i0, i1 + range.first ) ) errors++;
+  for (int i1 = 0; i1 < range.second - range.first; i1++) {
+    if (a(i1) != b(i0, i1 + range.first)) errors++;
   }
 
-  if ( errors > 0 ) {
+  if (errors > 0) {
     std::cout << "Error Suviews test_Check1D2D: " << errors << std::endl;
   }
 
-  ASSERT_TRUE( errors == 0 );
+  ASSERT_TRUE(errors == 0);
 }
 
-template< class SubView, class View >
-void test_Check2D3D( SubView a, View b, int i0, std::pair< int, int > range1
-                   , std::pair< int, int > range2 )
-{
+template <class SubView, class View>
+void test_Check2D3D(SubView a, View b, int i0, std::pair<int, int> range1,
+                    std::pair<int, int> range2) {
   int errors = 0;
 
-  for ( int i1 = 0; i1 < range1.second - range1.first; i1++ ) {
-    for ( int i2 = 0; i2 < range2.second - range2.first; i2++ ) {
-      if ( a( i1, i2 ) != b( i0, i1 + range1.first, i2 + range2.first ) ) errors++;
+  for (int i1 = 0; i1 < range1.second - range1.first; i1++) {
+    for (int i2 = 0; i2 < range2.second - range2.first; i2++) {
+      if (a(i1, i2) != b(i0, i1 + range1.first, i2 + range2.first)) errors++;
     }
   }
 
-  if ( errors > 0 ) {
+  if (errors > 0) {
     std::cout << "Error Suviews test_Check2D3D: " << errors << std::endl;
   }
 
-  ASSERT_TRUE( errors == 0 );
+  ASSERT_TRUE(errors == 0);
 }
 
-template<class SubView, class View>
-void test_Check3D5D( SubView a, View b, int i0, int i1, std::pair< int, int > range2
-                   , std::pair< int, int > range3, std::pair< int, int > range4 )
-{
+template <class SubView, class View>
+void test_Check3D5D(SubView a, View b, int i0, int i1,
+                    std::pair<int, int> range2, std::pair<int, int> range3,
+                    std::pair<int, int> range4) {
   int errors = 0;
 
-  for ( int i2 = 0; i2 < range2.second - range2.first; i2++ ) {
-    for ( int i3 = 0; i3 < range3.second - range3.first; i3++ ) {
-      for ( int i4 = 0; i4 < range4.second - range4.first; i4++ ) {
-        if ( a( i2, i3, i4 ) != b( i0, i1, i2 + range2.first, i3 + range3.first, i4 + range4.first ) ) {
+  for (int i2 = 0; i2 < range2.second - range2.first; i2++) {
+    for (int i3 = 0; i3 < range3.second - range3.first; i3++) {
+      for (int i4 = 0; i4 < range4.second - range4.first; i4++) {
+        if (a(i2, i3, i4) != b(i0, i1, i2 + range2.first, i3 + range3.first,
+                               i4 + range4.first)) {
           errors++;
         }
       }
     }
   }
 
-  if ( errors > 0 ) {
+  if (errors > 0) {
     std::cout << "Error Suviews test_Check3D5D: " << errors << std::endl;
   }
 
-  ASSERT_TRUE( errors == 0 );
+  ASSERT_TRUE(errors == 0);
 }
 
-template< class Space, class LayoutSub, class Layout, class LayoutOrg, class MemTraits >
+template <class Space, class LayoutSub, class Layout, class LayoutOrg,
+          class MemTraits>
 void test_1d_assign_impl() {
-  { // Breaks.
-    Kokkos::View< int*, LayoutOrg, Space > a_org( "A", N0 );
-    Kokkos::View< int*, LayoutOrg, Space, MemTraits > a( a_org );
+  {  // Breaks.
+    Kokkos::View<int*, LayoutOrg, Space> a_org("A", N0);
+    Kokkos::View<int*, LayoutOrg, Space, MemTraits> a(a_org);
     Kokkos::fence();
-    for ( int i = 0; i < N0; i++ ) a_org( i ) = i;
+    for (int i = 0; i < N0; i++) a_org(i) = i;
 
-    Kokkos::View< int[N0], Layout, Space, MemTraits > a1( a );
+    Kokkos::View<int[N0], Layout, Space, MemTraits> a1(a);
     Kokkos::fence();
-    test_Check1D( a1, a, std::pair< int, int >( 0, N0 ) );
+    test_Check1D(a1, a, std::pair<int, int>(0, N0));
 
-    Kokkos::View< int[N0], LayoutSub, Space, MemTraits > a2( a1 );
+    Kokkos::View<int[N0], LayoutSub, Space, MemTraits> a2(a1);
     Kokkos::fence();
-    test_Check1D( a2, a, std::pair< int, int >( 0, N0 ) );
+    test_Check1D(a2, a, std::pair<int, int>(0, N0));
     a1 = a;
-    test_Check1D( a1, a, std::pair< int, int >( 0, N0 ) );
+    test_Check1D(a1, a, std::pair<int, int>(0, N0));
 
     // Runtime Fail expected.
-    //Kokkos::View< int[N1] > afail1( a );
+    // Kokkos::View< int[N1] > afail1( a );
 
     // Compile Time Fail expected.
-    //Kokkos::View< int[N1] > afail2( a1 );
+    // Kokkos::View< int[N1] > afail2( a1 );
   }
 
-  { // Works.
-    Kokkos::View< int[N0], LayoutOrg, Space, MemTraits > a( "A" );
-    Kokkos::View< int*, Layout, Space, MemTraits > a1( a );
+  {  // Works.
+    Kokkos::View<int[N0], LayoutOrg, Space, MemTraits> a("A");
+    Kokkos::View<int*, Layout, Space, MemTraits> a1(a);
     Kokkos::fence();
-    test_Check1D( a1, a, std::pair< int, int >( 0, N0 ) );
+    test_Check1D(a1, a, std::pair<int, int>(0, N0));
     a1 = a;
     Kokkos::fence();
-    test_Check1D( a1, a, std::pair< int, int >( 0, N0 ) );
+    test_Check1D(a1, a, std::pair<int, int>(0, N0));
   }
 }
 
-template< class Space, class Type, class TypeSub, class LayoutSub, class Layout, class LayoutOrg, class MemTraits >
+template <class Space, class Type, class TypeSub, class LayoutSub, class Layout,
+          class LayoutOrg, class MemTraits>
 void test_2d_subview_3d_impl_type() {
-  Kokkos::View< int***, LayoutOrg, Space > a_org( "A", N0, N1, N2 );
-  Kokkos::View< Type, Layout, Space, MemTraits > a( a_org );
+  Kokkos::View<int***, LayoutOrg, Space> a_org("A", N0, N1, N2);
+  Kokkos::View<Type, Layout, Space, MemTraits> a(a_org);
 
-  for ( int i0 = 0; i0 < N0; i0++ )
-  for ( int i1 = 0; i1 < N1; i1++ )
-  for ( int i2 = 0; i2 < N2; i2++ )
-  {
-    a_org( i0, i1, i2 ) = i0 * 1000000 + i1 * 1000 + i2;
-  }
+  for (int i0 = 0; i0 < N0; i0++)
+    for (int i1 = 0; i1 < N1; i1++)
+      for (int i2 = 0; i2 < N2; i2++) {
+        a_org(i0, i1, i2) = i0 * 1000000 + i1 * 1000 + i2;
+      }
 
-  Kokkos::View< TypeSub, LayoutSub, Space, MemTraits > a1;
-  a1 = Kokkos::subview( a, 3, Kokkos::ALL, Kokkos::ALL );
+  Kokkos::View<TypeSub, LayoutSub, Space, MemTraits> a1;
+  a1 = Kokkos::subview(a, 3, Kokkos::ALL, Kokkos::ALL);
   Kokkos::fence();
-  test_Check2D3D( a1, a, 3, std::pair< int, int >( 0, N1 ), std::pair< int, int >( 0, N2 ) );
+  test_Check2D3D(a1, a, 3, std::pair<int, int>(0, N1),
+                 std::pair<int, int>(0, N2));
 
-  Kokkos::View< TypeSub, LayoutSub, Space, MemTraits > a2( a, 3, Kokkos::ALL, Kokkos::ALL );
+  Kokkos::View<TypeSub, LayoutSub, Space, MemTraits> a2(a, 3, Kokkos::ALL,
+                                                        Kokkos::ALL);
   Kokkos::fence();
-  test_Check2D3D( a2, a, 3, std::pair< int, int >( 0, N1 ), std::pair< int, int >( 0, N2 ) );
+  test_Check2D3D(a2, a, 3, std::pair<int, int>(0, N1),
+                 std::pair<int, int>(0, N2));
 }
 
-template< class Space, class LayoutSub, class Layout, class LayoutOrg, class MemTraits >
+template <class Space, class LayoutSub, class Layout, class LayoutOrg,
+          class MemTraits>
 void test_2d_subview_3d_impl_layout() {
-  test_2d_subview_3d_impl_type< Space, int[N0][N1][N2], int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int[N0][N1][N2], int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int[N0][N1][N2], int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_2d_subview_3d_impl_type< Space, int*   [N1][N2], int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int*   [N1][N2], int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int*   [N1][N2], int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_2d_subview_3d_impl_type< Space, int**      [N2], int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int**      [N2], int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int**      [N2], int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_2d_subview_3d_impl_type< Space, int***         , int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int***         , int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, int***         , int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_2d_subview_3d_impl_type< Space, const int[N0][N1][N2], const int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int[N0][N1][N2], const int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int[N0][N1][N2], const int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_2d_subview_3d_impl_type< Space, const int*   [N1][N2], const int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int*   [N1][N2], const int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int*   [N1][N2], const int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_2d_subview_3d_impl_type< Space, const int**      [N2], const int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int**      [N2], const int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int**      [N2], const int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_2d_subview_3d_impl_type< Space, const int***         , const int[N1][N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int***         , const int*   [N2], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_2d_subview_3d_impl_type< Space, const int***         , const int**      , LayoutSub, Layout, LayoutOrg, MemTraits >();
+  test_2d_subview_3d_impl_type<Space, int[N0][N1][N2], int[N1][N2], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int[N0][N1][N2], int * [N2], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int[N0][N1][N2], int**, LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+
+  test_2d_subview_3d_impl_type<Space, int * [N1][N2], int[N1][N2], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int * [N1][N2], int * [N2], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int * [N1][N2], int**, LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+
+  test_2d_subview_3d_impl_type<Space, int* * [N2], int[N1][N2], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int* * [N2], int * [N2], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int* * [N2], int**, LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+
+  test_2d_subview_3d_impl_type<Space, int***, int[N1][N2], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int***, int * [N2], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, int***, int**, LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+
+  test_2d_subview_3d_impl_type<Space, const int[N0][N1][N2], const int[N1][N2],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int[N0][N1][N2], const int * [N2],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int[N0][N1][N2], const int**,
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+
+  test_2d_subview_3d_impl_type<Space, const int * [N1][N2], const int[N1][N2],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int * [N1][N2], const int * [N2],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int * [N1][N2], const int**,
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+
+  test_2d_subview_3d_impl_type<Space, const int* * [N2], const int[N1][N2],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int* * [N2], const int * [N2],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int* * [N2], const int**, LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+
+  test_2d_subview_3d_impl_type<Space, const int***, const int[N1][N2],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int***, const int * [N2], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_2d_subview_3d_impl_type<Space, const int***, const int**, LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
 }
 
-template< class Space, class Type, class TypeSub, class LayoutSub, class Layout, class LayoutOrg, class MemTraits >
+template <class Space, class Type, class TypeSub, class LayoutSub, class Layout,
+          class LayoutOrg, class MemTraits>
 void test_3d_subview_5d_impl_type() {
-  Kokkos::View< int*****, LayoutOrg, Space > a_org( "A", N0, N1, N2, N3, N4 );
-  Kokkos::View< Type, Layout, Space, MemTraits > a( a_org );
-
-  for ( int i0 = 0; i0 < N0; i0++ )
-  for ( int i1 = 0; i1 < N1; i1++ )
-  for ( int i2 = 0; i2 < N2; i2++ )
-  for ( int i3 = 0; i3 < N3; i3++ )
-  for ( int i4 = 0; i4 < N4; i4++ )
-  {
-    a_org( i0, i1, i2, i3, i4 ) = i0 * 1000000 + i1 * 10000 + i2 * 100 + i3 * 10 + i4;
-  }
-
-  Kokkos::View< TypeSub, LayoutSub, Space, MemTraits > a1;
-  a1 = Kokkos::subview( a, 3, 5, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL );
+  Kokkos::View<int*****, LayoutOrg, Space> a_org("A", N0, N1, N2, N3, N4);
+  Kokkos::View<Type, Layout, Space, MemTraits> a(a_org);
+
+  for (int i0 = 0; i0 < N0; i0++)
+    for (int i1 = 0; i1 < N1; i1++)
+      for (int i2 = 0; i2 < N2; i2++)
+        for (int i3 = 0; i3 < N3; i3++)
+          for (int i4 = 0; i4 < N4; i4++) {
+            a_org(i0, i1, i2, i3, i4) =
+                i0 * 1000000 + i1 * 10000 + i2 * 100 + i3 * 10 + i4;
+          }
+
+  Kokkos::View<TypeSub, LayoutSub, Space, MemTraits> a1;
+  a1 = Kokkos::subview(a, 3, 5, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL);
   Kokkos::fence();
-  test_Check3D5D( a1, a, 3, 5, std::pair< int, int >( 0, N2 ), std::pair< int, int >( 0, N3 ), std::pair< int, int >( 0, N4 ) );
+  test_Check3D5D(a1, a, 3, 5, std::pair<int, int>(0, N2),
+                 std::pair<int, int>(0, N3), std::pair<int, int>(0, N4));
 
-  Kokkos::View< TypeSub, LayoutSub, Space, MemTraits > a2( a, 3, 5, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL );
+  Kokkos::View<TypeSub, LayoutSub, Space, MemTraits> a2(
+      a, 3, 5, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL);
   Kokkos::fence();
-  test_Check3D5D( a2, a, 3, 5, std::pair< int, int >( 0, N2 ), std::pair< int, int >( 0, N3 ), std::pair< int, int >( 0, N4 ) );
+  test_Check3D5D(a2, a, 3, 5, std::pair<int, int>(0, N2),
+                 std::pair<int, int>(0, N3), std::pair<int, int>(0, N4));
 }
 
-template< class Space, class LayoutSub, class Layout, class LayoutOrg, class MemTraits >
+template <class Space, class LayoutSub, class Layout, class LayoutOrg,
+          class MemTraits>
 void test_3d_subview_5d_impl_layout() {
-  test_3d_subview_5d_impl_type< Space, int[N0][N1][N2][N3][N4], int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int[N0][N1][N2][N3][N4], int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int[N0][N1][N2][N3][N4], int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int[N0][N1][N2][N3][N4], int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, int*   [N1][N2][N3][N4], int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int*   [N1][N2][N3][N4], int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int*   [N1][N2][N3][N4], int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int*   [N1][N2][N3][N4], int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, int**      [N2][N3][N4], int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int**      [N2][N3][N4], int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int**      [N2][N3][N4], int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int**      [N2][N3][N4], int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, int***         [N3][N4], int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int***         [N3][N4], int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int***         [N3][N4], int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int***         [N3][N4], int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, int****            [N4], int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int****            [N4], int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int****            [N4], int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int****            [N4], int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, int*****               , int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int*****               , int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int*****               , int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, int*****               , int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, const int[N0][N1][N2][N3][N4], const int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int[N0][N1][N2][N3][N4], const int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int[N0][N1][N2][N3][N4], const int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int[N0][N1][N2][N3][N4], const int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, const int*   [N1][N2][N3][N4], const int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int*   [N1][N2][N3][N4], const int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int*   [N1][N2][N3][N4], const int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int*   [N1][N2][N3][N4], const int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, const int**      [N2][N3][N4], const int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int**      [N2][N3][N4], const int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int**      [N2][N3][N4], const int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int**      [N2][N3][N4], const int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, const int***         [N3][N4], const int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int***         [N3][N4], const int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int***         [N3][N4], const int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int***         [N3][N4], const int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, const int****            [N4], const int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int****            [N4], const int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int****            [N4], const int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int****            [N4], const int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
-
-  test_3d_subview_5d_impl_type< Space, const int*****               , const int[N2][N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int*****               , const int*   [N3][N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int*****               , const int**      [N4], LayoutSub, Layout, LayoutOrg, MemTraits >();
-  test_3d_subview_5d_impl_type< Space, const int*****               , const int***         , LayoutSub, Layout, LayoutOrg, MemTraits >();
+  test_3d_subview_5d_impl_type<Space, int[N0][N1][N2][N3][N4], int[N2][N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int[N0][N1][N2][N3][N4], int * [N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int[N0][N1][N2][N3][N4], int* * [N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int[N0][N1][N2][N3][N4], int***,
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, int * [N1][N2][N3][N4], int[N2][N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int * [N1][N2][N3][N4], int * [N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int * [N1][N2][N3][N4], int* * [N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int * [N1][N2][N3][N4], int***, LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, int* * [N2][N3][N4], int[N2][N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int* * [N2][N3][N4], int * [N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int* * [N2][N3][N4], int* * [N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int* * [N2][N3][N4], int***, LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, int** * [N3][N4], int[N2][N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int** * [N3][N4], int * [N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int** * [N3][N4], int* * [N4], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int** * [N3][N4], int***, LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, int*** * [N4], int[N2][N3][N4], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int*** * [N4], int * [N3][N4], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int*** * [N4], int* * [N4], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int*** * [N4], int***, LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, int*****, int[N2][N3][N4], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int*****, int * [N3][N4], LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int*****, int* * [N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, int*****, int***, LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, const int[N0][N1][N2][N3][N4],
+                               const int[N2][N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int[N0][N1][N2][N3][N4],
+                               const int * [N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int[N0][N1][N2][N3][N4],
+                               const int* * [N4], LayoutSub, Layout, LayoutOrg,
+                               MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int[N0][N1][N2][N3][N4],
+                               const int***, LayoutSub, Layout, LayoutOrg,
+                               MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, const int * [N1][N2][N3][N4],
+                               const int[N2][N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int * [N1][N2][N3][N4],
+                               const int * [N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int * [N1][N2][N3][N4],
+                               const int* * [N4], LayoutSub, Layout, LayoutOrg,
+                               MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int * [N1][N2][N3][N4],
+                               const int***, LayoutSub, Layout, LayoutOrg,
+                               MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, const int* * [N2][N3][N4],
+                               const int[N2][N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int* * [N2][N3][N4],
+                               const int * [N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int* * [N2][N3][N4],
+                               const int* * [N4], LayoutSub, Layout, LayoutOrg,
+                               MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int* * [N2][N3][N4], const int***,
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, const int** * [N3][N4],
+                               const int[N2][N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int** * [N3][N4],
+                               const int * [N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int** * [N3][N4], const int* * [N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int** * [N3][N4], const int***,
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, const int*** * [N4],
+                               const int[N2][N3][N4], LayoutSub, Layout,
+                               LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int*** * [N4], const int * [N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int*** * [N4], const int* * [N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int*** * [N4], const int***,
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+
+  test_3d_subview_5d_impl_type<Space, const int*****, const int[N2][N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int*****, const int * [N3][N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int*****, const int* * [N4],
+                               LayoutSub, Layout, LayoutOrg, MemTraits>();
+  test_3d_subview_5d_impl_type<Space, const int*****, const int***, LayoutSub,
+                               Layout, LayoutOrg, MemTraits>();
 }
 
-inline
-void test_subview_legal_args_right() {
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
+inline void test_subview_legal_args_right() {
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int, int>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, int>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
+                   Kokkos::Impl::ALL_t>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t>::value));
+
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int> >::value));
 }
 
-inline
-void test_subview_legal_args_left() {
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, int >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t >::value ) );
-
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 1, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
-  ASSERT_EQ( 0, (  Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t >::value ) );
-  ASSERT_EQ( 0, ( Kokkos::Impl::SubviewLegalArgsCompileTime< Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::pair<int, int>, Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value ) );
+inline void test_subview_legal_args_left() {
+  ASSERT_EQ(
+      1,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(
+      1,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, int>::value));
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int, int>::value));
+
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
+          Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, int>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t, int>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
+                   Kokkos::Impl::ALL_t>::value));
+
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t>::value));
+
+  ASSERT_EQ(
+      1,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
+          Kokkos::Impl::ALL_t, Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(
+      1,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
+          Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::pair<int, int> >::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
+                   Kokkos::pair<int, int>, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int> >::value));
 }
 
-} // namespace Impl
+}  // namespace Impl
 
-template< class Space, class MemTraits = void >
+template <class Space, class MemTraits = void>
 void test_1d_assign() {
-  Impl::test_1d_assign_impl< Space, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, MemTraits >();
-  //Impl::test_1d_assign_impl< Space, Kokkos::LayoutRight, Kokkos::LayoutLeft, Kokkos::LayoutLeft >();
-  Impl::test_1d_assign_impl< Space, Kokkos::LayoutStride, Kokkos::LayoutLeft, Kokkos::LayoutLeft, MemTraits >();
-  //Impl::test_1d_assign_impl< Space, Kokkos::LayoutLeft, Kokkos::LayoutRight, Kokkos::LayoutLeft >();
-  Impl::test_1d_assign_impl< Space, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, MemTraits >();
-  Impl::test_1d_assign_impl< Space, Kokkos::LayoutStride, Kokkos::LayoutRight, Kokkos::LayoutRight, MemTraits >();
-  //Impl::test_1d_assign_impl< Space, Kokkos::LayoutLeft, Kokkos::LayoutStride, Kokkos::LayoutLeft >();
-  //Impl::test_1d_assign_impl< Space, Kokkos::LayoutRight, Kokkos::LayoutStride, Kokkos::LayoutLeft >();
-  Impl::test_1d_assign_impl< Space, Kokkos::LayoutStride, Kokkos::LayoutStride, Kokkos::LayoutLeft, MemTraits >();
+  Impl::test_1d_assign_impl<Space, Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                            Kokkos::LayoutLeft, MemTraits>();
+  // Impl::test_1d_assign_impl< Space, Kokkos::LayoutRight, Kokkos::LayoutLeft,
+  // Kokkos::LayoutLeft >();
+  Impl::test_1d_assign_impl<Space, Kokkos::LayoutStride, Kokkos::LayoutLeft,
+                            Kokkos::LayoutLeft, MemTraits>();
+  // Impl::test_1d_assign_impl< Space, Kokkos::LayoutLeft, Kokkos::LayoutRight,
+  // Kokkos::LayoutLeft >();
+  Impl::test_1d_assign_impl<Space, Kokkos::LayoutRight, Kokkos::LayoutRight,
+                            Kokkos::LayoutRight, MemTraits>();
+  Impl::test_1d_assign_impl<Space, Kokkos::LayoutStride, Kokkos::LayoutRight,
+                            Kokkos::LayoutRight, MemTraits>();
+  // Impl::test_1d_assign_impl< Space, Kokkos::LayoutLeft, Kokkos::LayoutStride,
+  // Kokkos::LayoutLeft >(); Impl::test_1d_assign_impl< Space,
+  // Kokkos::LayoutRight, Kokkos::LayoutStride, Kokkos::LayoutLeft >();
+  Impl::test_1d_assign_impl<Space, Kokkos::LayoutStride, Kokkos::LayoutStride,
+                            Kokkos::LayoutLeft, MemTraits>();
 }
 
-template< class Space, class MemTraits = void >
+template <class Space, class MemTraits = void>
 void test_2d_subview_3d() {
-  Impl::test_2d_subview_3d_impl_layout< Space, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, MemTraits >();
-  Impl::test_2d_subview_3d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutRight, Kokkos::LayoutRight, MemTraits >();
-  Impl::test_2d_subview_3d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutStride, Kokkos::LayoutRight, MemTraits >();
-  Impl::test_2d_subview_3d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutLeft,  Kokkos::LayoutLeft,  MemTraits >();
-  Impl::test_2d_subview_3d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutStride, Kokkos::LayoutLeft,  MemTraits >();
+  Impl::test_2d_subview_3d_impl_layout<Space, Kokkos::LayoutRight,
+                                       Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                       MemTraits>();
+  Impl::test_2d_subview_3d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                       MemTraits>();
+  Impl::test_2d_subview_3d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutStride,
+                                       Kokkos::LayoutRight, MemTraits>();
+  Impl::test_2d_subview_3d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                       MemTraits>();
+  Impl::test_2d_subview_3d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutStride, Kokkos::LayoutLeft,
+                                       MemTraits>();
 }
 
-template< class Space, class MemTraits = void >
+template <class Space, class MemTraits = void>
 void test_3d_subview_5d_right() {
-  Impl::test_3d_subview_5d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutRight, Kokkos::LayoutRight, MemTraits >();
-  Impl::test_3d_subview_5d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutStride, Kokkos::LayoutRight, MemTraits >();
+  Impl::test_3d_subview_5d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutRight, Kokkos::LayoutRight,
+                                       MemTraits>();
+  Impl::test_3d_subview_5d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutStride,
+                                       Kokkos::LayoutRight, MemTraits>();
 }
 
-template< class Space, class MemTraits = void >
+template <class Space, class MemTraits = void>
 void test_3d_subview_5d_left() {
-  Impl::test_3d_subview_5d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutLeft,  Kokkos::LayoutLeft,  MemTraits >();
-  Impl::test_3d_subview_5d_impl_layout< Space, Kokkos::LayoutStride, Kokkos::LayoutStride, Kokkos::LayoutLeft,  MemTraits >();
+  Impl::test_3d_subview_5d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutLeft, Kokkos::LayoutLeft,
+                                       MemTraits>();
+  Impl::test_3d_subview_5d_impl_layout<Space, Kokkos::LayoutStride,
+                                       Kokkos::LayoutStride, Kokkos::LayoutLeft,
+                                       MemTraits>();
 }
 
 namespace Impl {
 
-template< class Layout, class Space >
+template <class Layout, class Space>
 struct FillView_3D {
-  Kokkos::View< int***, Layout, Space > a;
+  Kokkos::View<int***, Layout, Space> a;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & ii ) const
-  {
-    const int i = std::is_same< Layout, Kokkos::LayoutLeft >::value
-                ? ii % a.extent(0)
-                : ii / ( a.extent(1) * a.extent(2) );
+  void operator()(const int& ii) const {
+    const int i = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii % a.extent(0)
+                      : ii / (a.extent(1) * a.extent(2));
 
-    const int j = std::is_same< Layout, Kokkos::LayoutLeft >::value
-                ? ( ii / a.extent(0) ) % a.extent(1)
-                : ( ii / a.extent(2) ) % a.extent(1);
+    const int j = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? (ii / a.extent(0)) % a.extent(1)
+                      : (ii / a.extent(2)) % a.extent(1);
 
-    const int k = std::is_same< Layout, Kokkos::LayoutRight >::value
-                ? ii / ( a.extent(0) * a.extent(1) )
-                : ii % a.extent(2);
+    const int k = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii / (a.extent(0) * a.extent(1))
+                      : ii % a.extent(2);
 
-    a( i, j, k ) = 1000000 * i + 1000 * j + k;
+    a(i, j, k) = 1000000 * i + 1000 * j + k;
   }
 };
 
-template< class Layout, class Space >
+template <class Layout, class Space>
 struct FillView_4D {
-  Kokkos::View< int****, Layout, Space > a;
+  Kokkos::View<int****, Layout, Space> a;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & ii ) const {
-    const int i = std::is_same< Layout, Kokkos::LayoutLeft >::value
-              ? ii % a.extent(0)
-              : ii / ( a.extent(1) * a.extent(2) * a.extent(3) );
+  void operator()(const int& ii) const {
+    const int i = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii % a.extent(0)
+                      : ii / (a.extent(1) * a.extent(2) * a.extent(3));
 
-    const int j = std::is_same< Layout, Kokkos::LayoutLeft >::value
-              ? ( ii / a.extent(0) ) % a.extent(1)
-              : ( ii / ( a.extent(2) * a.extent(3) ) % a.extent(1) );
+    const int j = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? (ii / a.extent(0)) % a.extent(1)
+                      : (ii / (a.extent(2) * a.extent(3)) % a.extent(1));
 
-    const int k = std::is_same< Layout, Kokkos::LayoutRight >::value
-              ? ( ii / ( a.extent(0) * a.extent(1) ) ) % a.extent(2)
-              : ( ii / a.extent(3) ) % a.extent(2);
+    const int k = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? (ii / (a.extent(0) * a.extent(1))) % a.extent(2)
+                      : (ii / a.extent(3)) % a.extent(2);
 
-    const int l = std::is_same< Layout, Kokkos::LayoutRight >::value
-                ? ii / ( a.extent(0) * a.extent(1) * a.extent(2) )
-                : ii % a.extent(3);
+    const int l = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii / (a.extent(0) * a.extent(1) * a.extent(2))
+                      : ii % a.extent(3);
 
-    a( i, j, k, l ) = 1000000 * i + 10000 * j + 100 * k + l;
+    a(i, j, k, l) = 1000000 * i + 10000 * j + 100 * k + l;
   }
 };
 
-template< class Layout, class Space, class MemTraits >
+template <class Layout, class Space, class MemTraits>
 struct CheckSubviewCorrectness_3D_3D {
-  Kokkos::View< const int***, Layout, Space, MemTraits > a;
-  Kokkos::View< const int***, Layout, Space, MemTraits > b;
+  Kokkos::View<const int***, Layout, Space, MemTraits> a;
+  Kokkos::View<const int***, Layout, Space, MemTraits> b;
   int offset_0, offset_2;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & ii ) const
-  {
-    const int i = std::is_same< Layout, Kokkos::LayoutLeft >::value
-                ? ii % b.extent(0)
-                : ii / ( b.extent(1) * b.extent(2) );
-
-    const int j = std::is_same< Layout, Kokkos::LayoutLeft >::value
-                ? ( ii / b.extent(0) ) % b.extent(1)
-                : ( ii / b.extent(2) ) % b.extent(1);
-
-    const int k = std::is_same< Layout, Kokkos::LayoutRight >::value
-                ? ii / ( b.extent(0) * b.extent(1) )
-                : ii % b.extent(2);
-
-    if ( a( i + offset_0, j, k + offset_2 ) != b( i, j, k ) ) {
-      Kokkos::abort( "Error: check_subview_correctness 3D-3D (LayoutLeft -> LayoutLeft or LayoutRight -> LayoutRight)" );
+  void operator()(const int& ii) const {
+    const int i = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii % b.extent(0)
+                      : ii / (b.extent(1) * b.extent(2));
+
+    const int j = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? (ii / b.extent(0)) % b.extent(1)
+                      : (ii / b.extent(2)) % b.extent(1);
+
+    const int k = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii / (b.extent(0) * b.extent(1))
+                      : ii % b.extent(2);
+
+    if (a(i + offset_0, j, k + offset_2) != b(i, j, k)) {
+      Kokkos::abort(
+          "Error: check_subview_correctness 3D-3D (LayoutLeft -> LayoutLeft or "
+          "LayoutRight -> LayoutRight)");
     }
   }
 };
 
-template< class Layout, class Space, class MemTraits >
+template <class Layout, class Space, class MemTraits>
 struct CheckSubviewCorrectness_3D_4D {
-  Kokkos::View< const int****, Layout, Space, MemTraits > a;
-  Kokkos::View< const int***, Layout, Space, MemTraits > b;
+  Kokkos::View<const int****, Layout, Space, MemTraits> a;
+  Kokkos::View<const int***, Layout, Space, MemTraits> b;
   int offset_0, offset_2, index;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const int & ii ) const {
-    const int i = std::is_same< Layout, Kokkos::LayoutLeft >::value
-                ? ii % b.extent(0)
-                : ii / ( b.extent(1) * b.extent(2) );
+  void operator()(const int& ii) const {
+    const int i = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii % b.extent(0)
+                      : ii / (b.extent(1) * b.extent(2));
 
-    const int j = std::is_same< Layout, Kokkos::LayoutLeft >::value
-                ? ( ii / b.extent(0) ) % b.extent(1)
-                : ( ii / b.extent(2) ) % b.extent(1);
+    const int j = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? (ii / b.extent(0)) % b.extent(1)
+                      : (ii / b.extent(2)) % b.extent(1);
 
-    const int k = std::is_same< Layout, Kokkos::LayoutRight >::value
-                ? ii / ( b.extent(0) * b.extent(1) )
-                : ii % b.extent(2);
+    const int k = std::is_same<Layout, Kokkos::LayoutLeft>::value
+                      ? ii / (b.extent(0) * b.extent(1))
+                      : ii % b.extent(2);
 
     int i0, i1, i2, i3;
 
-    if ( std::is_same< Layout, Kokkos::LayoutLeft >::value ) {
+    if (std::is_same<Layout, Kokkos::LayoutLeft>::value) {
       i0 = i + offset_0;
       i1 = j;
       i2 = k + offset_2;
       i3 = index;
-    }
-    else {
+    } else {
       i0 = index;
       i1 = i + offset_0;
       i2 = j;
       i3 = k + offset_2;
     }
 
-    if ( a( i0, i1, i2, i3 ) != b( i, j, k ) ) {
-      Kokkos::abort( "Error: check_subview_correctness 3D-4D (LayoutLeft -> LayoutLeft or LayoutRight -> LayoutRight)" );
+    if (a(i0, i1, i2, i3) != b(i, j, k)) {
+      Kokkos::abort(
+          "Error: check_subview_correctness 3D-4D (LayoutLeft -> LayoutLeft or "
+          "LayoutRight -> LayoutRight)");
     }
   }
 };
 
-} // namespace Impl
+}  // namespace Impl
 
-template< class Space, class MemTraits = void >
+template <class Space, class MemTraits = void>
 void test_layoutleft_to_layoutleft() {
   Impl::test_subview_legal_args_left();
 
   {
-    Kokkos::View< int***, Kokkos::LayoutLeft, Space > a( "A", 100, 4, 3 );
-    Kokkos::View< int***, Kokkos::LayoutLeft, Space > b( a, Kokkos::pair< int, int >( 16, 32 ), Kokkos::ALL, Kokkos::ALL );
+    Kokkos::View<int***, Kokkos::LayoutLeft, Space> a("A", 100, 4, 3);
+    Kokkos::View<int***, Kokkos::LayoutLeft, Space> b(
+        a, Kokkos::pair<int, int>(16, 32), Kokkos::ALL, Kokkos::ALL);
 
-    Impl::FillView_3D< Kokkos::LayoutLeft, Space > fill;
+    Impl::FillView_3D<Kokkos::LayoutLeft, Space> fill;
     fill.a = a;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, a.extent( 0 ) * a.extent( 1 ) * a.extent( 2 ) ), fill );
-
-    Impl::CheckSubviewCorrectness_3D_3D< Kokkos::LayoutLeft, Space, MemTraits > check;
-    check.a = a;
-    check.b = b;
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, a.extent(0) * a.extent(1) * a.extent(2)),
+                         fill);
+
+    Impl::CheckSubviewCorrectness_3D_3D<Kokkos::LayoutLeft, Space, MemTraits>
+        check;
+    check.a        = a;
+    check.b        = b;
     check.offset_0 = 16;
     check.offset_2 = 0;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, b.extent( 0 ) * b.extent( 1 ) * b.extent( 2 ) ), check );
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, b.extent(0) * b.extent(1) * b.extent(2)),
+                         check);
     Kokkos::fence();
   }
 
   {
-    Kokkos::View< int***, Kokkos::LayoutLeft, Space > a( "A", 100, 4, 5 );
-    Kokkos::View< int***, Kokkos::LayoutLeft, Space > b( a, Kokkos::pair< int, int >( 16, 32 ), Kokkos::ALL, Kokkos::pair< int, int >( 1, 3 ) );
+    Kokkos::View<int***, Kokkos::LayoutLeft, Space> a("A", 100, 4, 5);
+    Kokkos::View<int***, Kokkos::LayoutLeft, Space> b(
+        a, Kokkos::pair<int, int>(16, 32), Kokkos::ALL,
+        Kokkos::pair<int, int>(1, 3));
 
     Impl::FillView_3D<Kokkos::LayoutLeft, Space> fill;
     fill.a = a;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, a.extent( 0 ) * a.extent( 1 ) * a.extent( 2 ) ), fill );
-
-    Impl::CheckSubviewCorrectness_3D_3D< Kokkos::LayoutLeft, Space, MemTraits > check;
-    check.a = a;
-    check.b = b;
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, a.extent(0) * a.extent(1) * a.extent(2)),
+                         fill);
+
+    Impl::CheckSubviewCorrectness_3D_3D<Kokkos::LayoutLeft, Space, MemTraits>
+        check;
+    check.a        = a;
+    check.b        = b;
     check.offset_0 = 16;
     check.offset_2 = 1;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, b.extent( 0 ) * b.extent( 1 ) * b.extent( 2 ) ), check );
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, b.extent(0) * b.extent(1) * b.extent(2)),
+                         check);
     Kokkos::fence();
   }
 
   {
-    Kokkos::View< int****, Kokkos::LayoutLeft, Space > a( "A", 100, 4, 5, 3 );
-    Kokkos::View< int***, Kokkos::LayoutLeft, Space > b( a, Kokkos::pair< int, int >( 16, 32 ), Kokkos::ALL, Kokkos::pair< int, int >( 1, 3 ), 1 );
+    Kokkos::View<int****, Kokkos::LayoutLeft, Space> a("A", 100, 4, 5, 3);
+    Kokkos::View<int***, Kokkos::LayoutLeft, Space> b(
+        a, Kokkos::pair<int, int>(16, 32), Kokkos::ALL,
+        Kokkos::pair<int, int>(1, 3), 1);
 
-    Impl::FillView_4D< Kokkos::LayoutLeft, Space > fill;
+    Impl::FillView_4D<Kokkos::LayoutLeft, Space> fill;
     fill.a = a;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, a.extent( 0 ) * a.extent( 1 ) * a.extent( 2 ) * a.extent( 3 ) ), fill );
-
-    Impl::CheckSubviewCorrectness_3D_4D< Kokkos::LayoutLeft, Space, MemTraits > check;
-    check.a = a;
-    check.b = b;
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<typename Space::execution_space>(
+            0, a.extent(0) * a.extent(1) * a.extent(2) * a.extent(3)),
+        fill);
+
+    Impl::CheckSubviewCorrectness_3D_4D<Kokkos::LayoutLeft, Space, MemTraits>
+        check;
+    check.a        = a;
+    check.b        = b;
     check.offset_0 = 16;
     check.offset_2 = 1;
-    check.index = 1;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, b.extent( 0 ) * b.extent( 1 ) * b.extent( 2 ) ), check );
+    check.index    = 1;
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, b.extent(0) * b.extent(1) * b.extent(2)),
+                         check);
     Kokkos::fence();
   }
 }
 
-template< class Space, class MemTraits = void >
+template <class Space, class MemTraits = void>
 void test_layoutright_to_layoutright() {
   Impl::test_subview_legal_args_right();
 
   {
-    Kokkos::View< int***, Kokkos::LayoutRight, Space > a( "A", 100, 4, 3 );
-    Kokkos::View< int***, Kokkos::LayoutRight, Space > b( a, Kokkos::pair< int, int >( 16, 32 ), Kokkos::ALL, Kokkos::ALL );
+    Kokkos::View<int***, Kokkos::LayoutRight, Space> a("A", 100, 4, 3);
+    Kokkos::View<int***, Kokkos::LayoutRight, Space> b(
+        a, Kokkos::pair<int, int>(16, 32), Kokkos::ALL, Kokkos::ALL);
 
     Impl::FillView_3D<Kokkos::LayoutRight, Space> fill;
     fill.a = a;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, a.extent( 0 ) * a.extent( 1 ) * a.extent( 2 ) ), fill );
-
-    Impl::CheckSubviewCorrectness_3D_3D< Kokkos::LayoutRight, Space, MemTraits > check;
-    check.a = a;
-    check.b = b;
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, a.extent(0) * a.extent(1) * a.extent(2)),
+                         fill);
+
+    Impl::CheckSubviewCorrectness_3D_3D<Kokkos::LayoutRight, Space, MemTraits>
+        check;
+    check.a        = a;
+    check.b        = b;
     check.offset_0 = 16;
     check.offset_2 = 0;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, b.extent( 0 ) * b.extent( 1 ) * b.extent( 2 ) ), check );
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, b.extent(0) * b.extent(1) * b.extent(2)),
+                         check);
     Kokkos::fence();
   }
 
   {
-    Kokkos::View< int****, Kokkos::LayoutRight, Space > a( "A", 3, 4, 5, 100 );
-    Kokkos::View< int***, Kokkos::LayoutRight, Space > b( a, 1, Kokkos::pair< int, int >( 1, 3 ), Kokkos::ALL, Kokkos::ALL );
+    Kokkos::View<int****, Kokkos::LayoutRight, Space> a("A", 3, 4, 5, 100);
+    Kokkos::View<int***, Kokkos::LayoutRight, Space> b(
+        a, 1, Kokkos::pair<int, int>(1, 3), Kokkos::ALL, Kokkos::ALL);
 
-    Impl::FillView_4D< Kokkos::LayoutRight, Space > fill;
+    Impl::FillView_4D<Kokkos::LayoutRight, Space> fill;
     fill.a = a;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, a.extent( 0 ) * a.extent( 1 ) * a.extent( 2 ) * a.extent( 3 ) ), fill );
-
-    Impl::CheckSubviewCorrectness_3D_4D< Kokkos::LayoutRight, Space, MemTraits > check;
-    check.a = a;
-    check.b = b;
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<typename Space::execution_space>(
+            0, a.extent(0) * a.extent(1) * a.extent(2) * a.extent(3)),
+        fill);
+
+    Impl::CheckSubviewCorrectness_3D_4D<Kokkos::LayoutRight, Space, MemTraits>
+        check;
+    check.a        = a;
+    check.b        = b;
     check.offset_0 = 1;
     check.offset_2 = 0;
-    check.index = 1;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename Space::execution_space >( 0, b.extent( 0 ) * b.extent( 1 ) * b.extent( 2 ) ), check );
+    check.index    = 1;
+    Kokkos::parallel_for(Kokkos::RangePolicy<typename Space::execution_space>(
+                             0, b.extent(0) * b.extent(1) * b.extent(2)),
+                         check);
     Kokkos::fence();
   }
 }
 
 //----------------------------------------------------------------------------
 
-template< class Space >
-struct TestUnmanagedSubviewReset
-{
-  Kokkos::View<int****,Space> a ;
+template <class Space>
+struct TestUnmanagedSubviewReset {
+  Kokkos::View<int****, Space> a;
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( int ) const noexcept
-    {
-      auto sub_a = Kokkos::subview(a,0,Kokkos::ALL,Kokkos::ALL,Kokkos::ALL);
-
-      for ( int i = 0 ; i < int(a.extent(0)) ; ++i ) {
-        sub_a.assign_data( & a(i,0,0,0) );
-        if ( & sub_a(1,1,1) != & a(i,1,1,1) ) {
-          Kokkos::abort("TestUnmanagedSubviewReset");
-        }
+  void operator()(int) const noexcept {
+    auto sub_a = Kokkos::subview(a, 0, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL);
+
+    for (int i = 0; i < int(a.extent(0)); ++i) {
+      sub_a.assign_data(&a(i, 0, 0, 0));
+      if (&sub_a(1, 1, 1) != &a(i, 1, 1, 1)) {
+        Kokkos::abort("TestUnmanagedSubviewReset");
       }
     }
+  }
 
-  TestUnmanagedSubviewReset()
-    : a( Kokkos::view_alloc() , 20 , 10 , 5 , 2 )
-    {}
+  TestUnmanagedSubviewReset() : a(Kokkos::view_alloc(), 20, 10, 5, 2) {}
 };
 
-template< class Space >
-void test_unmanaged_subview_reset()
-{
-  Kokkos::parallel_for
-    ( Kokkos::RangePolicy< typename Space::execution_space >(0,1)
-    , TestUnmanagedSubviewReset<Space>()
-    );
+template <class Space>
+void test_unmanaged_subview_reset() {
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<typename Space::execution_space>(0, 1),
+      TestUnmanagedSubviewReset<Space>());
 }
 
 //----------------------------------------------------------------------------
@@ -1419,120 +1940,134 @@ template <class T>
 struct get_view_type;
 
 template <class T, class... Args>
-struct get_view_type<
-  Kokkos::View<T, Args...>
-> {
+struct get_view_type<Kokkos::View<T, Args...> > {
   using type = T;
 };
 
 template <class T>
-struct ___________________________________TYPE_DISPLAY________________________________________;
-#define TYPE_DISPLAY(...) typename ___________________________________TYPE_DISPLAY________________________________________<__VA_ARGS__>::type notdefined;
+struct
+    ___________________________________TYPE_DISPLAY________________________________________;
+#define TYPE_DISPLAY(...)                                                                           \
+  typename ___________________________________TYPE_DISPLAY________________________________________< \
+      __VA_ARGS__>::type notdefined;
 
 template <class Space, class Layout>
-struct TestSubviewStaticSizes
-{
-  Kokkos::View<int*[10][5][2], Layout, Space> a;
+struct TestSubviewStaticSizes {
+  Kokkos::View<int * [10][5][2], Layout, Space> a;
+  Kokkos::View<int[6][7][8], Layout, Space> b;
 
   KOKKOS_INLINE_FUNCTION
-  int operator()() const noexcept
-  {
+  int operator()() const noexcept {
     /* Doesn't actually do anything; just static assertions */
 
     auto sub_a = Kokkos::subview(a, 0, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL);
     typename static_expect_same<
-      /* expected */ int[10][5][2],
-      /*  actual  */ typename get_view_type<decltype(sub_a)>::type
-    >::type test_1 = 0;
+        /* expected */ int[10][5][2],
+        /*  actual  */ typename get_view_type<decltype(sub_a)>::type>::type
+        test_1 = 0;
 
     auto sub_a_2 = Kokkos::subview(a, 0, 0, Kokkos::ALL, Kokkos::ALL);
     typename static_expect_same<
-      /* expected */ int[5][2],
-      /*  actual  */ typename get_view_type<decltype(sub_a_2)>::type
-    >::type test_2 = 0;
+        /* expected */ int[5][2],
+        /*  actual  */ typename get_view_type<decltype(sub_a_2)>::type>::type
+        test_2 = 0;
 
     auto sub_a_3 = Kokkos::subview(a, 0, 0, Kokkos::ALL, 0);
     typename static_expect_same<
-      /* expected */ int[5],
-      /*  actual  */ typename get_view_type<decltype(sub_a_3)>::type
-    >::type test_3 = 0;
+        /* expected */ int[5],
+        /*  actual  */ typename get_view_type<decltype(sub_a_3)>::type>::type
+        test_3 = 0;
 
     auto sub_a_4 = Kokkos::subview(a, Kokkos::ALL, 0, Kokkos::ALL, Kokkos::ALL);
     typename static_expect_same<
-      /* expected */ int*[5][2],
-      /*  actual  */ typename get_view_type<decltype(sub_a_4)>::type
-    >::type test_4 = 0;
-
-    // TODO we'll need to update this test once we allow interleaving of static and dynamic
-    auto sub_a_5 = Kokkos::subview(a, Kokkos::ALL, 0, Kokkos::ALL, Kokkos::make_pair(0, 1));
+        /* expected */ int * [5][2],
+        /*  actual  */ typename get_view_type<decltype(sub_a_4)>::type>::type
+        test_4 = 0;
+
+    // TODO we'll need to update this test once we allow interleaving of static
+    // and dynamic
+    auto sub_a_5 = Kokkos::subview(a, Kokkos::ALL, 0, Kokkos::ALL,
+                                   Kokkos::make_pair(0, 1));
     typename static_expect_same<
-      /* expected */ int***,
-      /*  actual  */ typename get_view_type<decltype(sub_a_5)>::type
-    >::type test_5 = 0;
+        /* expected */ int***,
+        /*  actual  */ typename get_view_type<decltype(sub_a_5)>::type>::type
+        test_5 = 0;
 
     auto sub_a_sub = Kokkos::subview(sub_a_5, 0, Kokkos::ALL, 0);
     typename static_expect_same<
-      /* expected */ int*,
-      /*  actual  */ typename get_view_type<decltype(sub_a_sub)>::type
-    >::type test_sub = 0;
+        /* expected */ int*,
+        /*  actual  */ typename get_view_type<decltype(sub_a_sub)>::type>::type
+        test_sub = 0;
 
-    auto sub_a_7 = Kokkos::subview(a, Kokkos::ALL, 0, Kokkos::make_pair(0, 1), Kokkos::ALL);
+    auto sub_a_7 = Kokkos::subview(a, Kokkos::ALL, 0, Kokkos::make_pair(0, 1),
+                                   Kokkos::ALL);
     typename static_expect_same<
-      /* expected */ int**[2],
-      /*  actual  */ typename get_view_type<decltype(sub_a_7)>::type
-    >::type test_7 = 0;
+        /* expected */ int* * [2],
+        /*  actual  */ typename get_view_type<decltype(sub_a_7)>::type>::type
+        test_7 = 0;
 
+    auto sub_a_8 =
+        Kokkos::subview(a, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL);
+    typename static_expect_same<
+        /* expected */ int * [10][5][2],
+        /*  actual  */ typename get_view_type<decltype(sub_a_8)>::type>::type
+        test_8 = 0;
 
-    return test_1 + test_2 + test_3 + test_4 + test_5 + test_sub + test_7;
+    auto sub_b = Kokkos::subview(b, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL);
+    typename static_expect_same<
+        /* expected */ int[6][7][8],
+        /*  actual  */ typename get_view_type<decltype(sub_b)>::type>::type
+        test_9 = 0;
+
+    auto sub_b_2 = Kokkos::subview(b, 0, Kokkos::ALL, Kokkos::ALL);
+    typename static_expect_same<
+        /* expected */ int[7][8],
+        /*  actual  */ typename get_view_type<decltype(sub_b_2)>::type>::type
+        test_10 = 0;
+
+    auto sub_b_3 =
+        Kokkos::subview(b, Kokkos::make_pair(2, 3), Kokkos::ALL, Kokkos::ALL);
+    typename static_expect_same<
+        /* expected */ int * [7][8],
+        /*  actual  */ typename get_view_type<decltype(sub_b_3)>::type>::type
+        test_11 = 0;
+
+    return test_1 + test_2 + test_3 + test_4 + test_5 + test_sub + test_7 +
+           test_8 + test_9 + test_10 + test_11;
   }
 
-  TestSubviewStaticSizes()
-    : a( Kokkos::view_alloc() , 20 )
-  {}
+  TestSubviewStaticSizes() : a(Kokkos::view_alloc(), 20), b() {}
 };
 
-
 template <class Space>
 struct TestExtentsStaticTests {
-
-  using test1 = typename
-    static_expect_same<
+  using test1 = typename static_expect_same<
       /* expected */
-      Kokkos::Experimental::Extents<
-        Kokkos::Experimental::dynamic_extent,
-        Kokkos::Experimental::dynamic_extent,
-        1, 2, 3
-      >,
+      Kokkos::Experimental::Extents<Kokkos::Experimental::dynamic_extent,
+                                    Kokkos::Experimental::dynamic_extent, 1, 2,
+                                    3>,
       /* actual */
-      typename Kokkos::Impl::ParseViewExtents<double**[1][2][3]>::type
-    >::type;
+      typename Kokkos::Impl::ParseViewExtents<double* * [1][2][3]>::type>::type;
 
-  using test2 = typename
-    static_expect_same<
+  using test2 = typename static_expect_same<
       /* expected */
       Kokkos::Experimental::Extents<1, 2, 3>,
       /* actual */
-      typename Kokkos::Impl::ParseViewExtents<double[1][2][3]>::type
-    >::type;
+      typename Kokkos::Impl::ParseViewExtents<double[1][2][3]>::type>::type;
 
-  using test3 = typename
-    static_expect_same<
+  using test3 = typename static_expect_same<
       /* expected */
       Kokkos::Experimental::Extents<3>,
       /* actual */
-      typename Kokkos::Impl::ParseViewExtents<double[3]>::type
-    >::type;
+      typename Kokkos::Impl::ParseViewExtents<double[3]>::type>::type;
 
-  using test4 = typename
-    static_expect_same<
+  using test4 = typename static_expect_same<
       /* expected */
       Kokkos::Experimental::Extents<>,
       /* actual */
-      typename Kokkos::Impl::ParseViewExtents<double>::type
-    >::type;
+      typename Kokkos::Impl::ParseViewExtents<double>::type>::type;
 };
 
-} // namespace TestViewSubview
+}  // namespace TestViewSubview
 
 #endif
-
diff --git a/lib/kokkos/core/unit_test/TestView_64bit.hpp b/lib/kokkos/core/unit_test/TestView_64bit.hpp
index e2cb2f6b69b5edb91b0e488cec5bdd303b4a37be..0b7b9d425aae0f7b27490000baefda62067f04c6 100644
--- a/lib/kokkos/core/unit_test/TestView_64bit.hpp
+++ b/lib/kokkos/core/unit_test/TestView_64bit.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,85 +42,93 @@
 //@HEADER
 */
 
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 
 namespace Test {
 
-template<class Device>
-void test_64bit(){
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-  int64_t N = 5000000000;
+template <class Device>
+void test_64bit() {
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+  int64_t N   = 5000000000;
   int64_t sum = 0;
   {
     Kokkos::parallel_reduce(
-      Kokkos::RangePolicy<typename Device::execution_space,Kokkos::IndexType<int64_t>>(0,N),
-      KOKKOS_LAMBDA(const int64_t& i, int64_t& lsum) {
-      lsum += 1;
-    },sum);
-    ASSERT_EQ(N,sum);
+        Kokkos::RangePolicy<typename Device::execution_space,
+                            Kokkos::IndexType<int64_t>>(0, N),
+        KOKKOS_LAMBDA(const int64_t& i, int64_t& lsum) { lsum += 1; }, sum);
+    ASSERT_EQ(N, sum);
   }
   {
-    Kokkos::View<char*,Device> a("A",N);
-    Kokkos::deep_copy(a,char(1));
+    Kokkos::View<char*, Device> a("A", N);
+    Kokkos::deep_copy(a, char(1));
     Kokkos::parallel_reduce(
-        Kokkos::RangePolicy<typename Device::execution_space,Kokkos::IndexType<int64_t>>(0,N),
+        Kokkos::RangePolicy<typename Device::execution_space,
+                            Kokkos::IndexType<int64_t>>(0, N),
         KOKKOS_LAMBDA(const int64_t& i, int64_t& lsum) {
-      lsum += int64_t(a(i));
-    },sum);
-    ASSERT_EQ(N,sum);
+          lsum += int64_t(a(i));
+        },
+        sum);
+    ASSERT_EQ(N, sum);
     Kokkos::parallel_for(
-        Kokkos::RangePolicy<typename Device::execution_space,Kokkos::IndexType<int64_t>>(0,N),
-        KOKKOS_LAMBDA(const int64_t& i) {
-      a(i) = 3;
-    });
+        Kokkos::RangePolicy<typename Device::execution_space,
+                            Kokkos::IndexType<int64_t>>(0, N),
+        KOKKOS_LAMBDA(const int64_t& i) { a(i) = 3; });
     Kokkos::parallel_reduce(
-        Kokkos::RangePolicy<typename Device::execution_space,Kokkos::IndexType<int64_t>>(0,N),
+        Kokkos::RangePolicy<typename Device::execution_space,
+                            Kokkos::IndexType<int64_t>>(0, N),
         KOKKOS_LAMBDA(const int64_t& i, int64_t& lsum) {
-      lsum += int64_t(a(i));
-    },sum);
-    ASSERT_EQ(N*3,sum);
+          lsum += int64_t(a(i));
+        },
+        sum);
+    ASSERT_EQ(N * 3, sum);
   }
   {
     int64_t N0 = 56925;
     int64_t N1 = 56927;
 
-    Kokkos::View<char**,Device> m("Matrix", N0,N1);
-    Kokkos::deep_copy(m,char(1));
+    Kokkos::View<char**, Device> m("Matrix", N0, N1);
+    Kokkos::deep_copy(m, char(1));
     Kokkos::parallel_reduce(
-        Kokkos::RangePolicy<typename Device::execution_space,Kokkos::IndexType<int64_t>>(0,N0*N1),
+        Kokkos::RangePolicy<typename Device::execution_space,
+                            Kokkos::IndexType<int64_t>>(0, N0 * N1),
         KOKKOS_LAMBDA(const int64_t& i, int64_t& lsum) {
-      lsum += int64_t(m(i%N0,i/N0));
-    },sum);
-    ASSERT_EQ(N0*N1,sum);
+          lsum += int64_t(m(i % N0, i / N0));
+        },
+        sum);
+    ASSERT_EQ(N0 * N1, sum);
     Kokkos::parallel_reduce(
-        Kokkos::MDRangePolicy<typename Device::execution_space,Kokkos::Rank<2>,Kokkos::IndexType<int64_t>>({0,0},{N0,N1}),
+        Kokkos::MDRangePolicy<typename Device::execution_space, Kokkos::Rank<2>,
+                              Kokkos::IndexType<int64_t>>({0, 0}, {N0, N1}),
         KOKKOS_LAMBDA(const int64_t& i0, const int64_t& i1, int64_t& lsum) {
-      lsum += int64_t(m(i0,i1));
-    },sum);
-    ASSERT_EQ(N0*N1,sum);
+          lsum += int64_t(m(i0, i1));
+        },
+        sum);
+    ASSERT_EQ(N0 * N1, sum);
   }
   {
-    int N0 = 1024*1024*1500;
+    int N0    = 1024 * 1024 * 1500;
     int64_t P = 1713091;
-    Kokkos::View<int*, Device> a("A",N0);
-    Kokkos::parallel_for("FillA",Kokkos::RangePolicy<typename Device::execution_space, Kokkos::IndexType<int>>(0,N0), KOKKOS_LAMBDA(const int& i) {
-      a(i) = i%P;
-    });
-    int64_t sum0=0;
-    Kokkos::parallel_reduce("FillA",Kokkos::RangePolicy<typename Device::execution_space, Kokkos::IndexType<int>>(0,N0), KOKKOS_LAMBDA(const int& i,int64_t& lsum) {
-      lsum += a(i);
-    },sum0);
-    int64_t expected = (P*(P-1)/2) * int64_t(N0/P) + (N0%P)*(N0%P-1)/2;
-    ASSERT_EQ(expected,sum0);
+    Kokkos::View<int*, Device> a("A", N0);
+    Kokkos::parallel_for(
+        "FillA",
+        Kokkos::RangePolicy<typename Device::execution_space,
+                            Kokkos::IndexType<int>>(0, N0),
+        KOKKOS_LAMBDA(const int& i) { a(i) = i % P; });
+    int64_t sum0 = 0;
+    Kokkos::parallel_reduce(
+        "FillA",
+        Kokkos::RangePolicy<typename Device::execution_space,
+                            Kokkos::IndexType<int>>(0, N0),
+        KOKKOS_LAMBDA(const int& i, int64_t& lsum) { lsum += a(i); }, sum0);
+    int64_t expected =
+        (P * (P - 1) / 2) * int64_t(N0 / P) + (N0 % P) * (N0 % P - 1) / 2;
+    ASSERT_EQ(expected, sum0);
   }
 #endif
 }
 
 #ifdef KOKKOS_ENABLE_LARGE_MEM_TESTS
-TEST_F( TEST_CATEGORY, view_64bit )
-{
-  test_64bit< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, view_64bit) { test_64bit<TEST_EXECSPACE>(); }
 #endif
 
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/TestWorkGraph.hpp b/lib/kokkos/core/unit_test/TestWorkGraph.hpp
index 331d79d72a60f29386ef1adc88dcf7ac7027d254..5483051645f4e66c694e94fbbf6b09dcfa672c10 100644
--- a/lib/kokkos/core/unit_test/TestWorkGraph.hpp
+++ b/lib/kokkos/core/unit_test/TestWorkGraph.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,47 +51,45 @@ namespace Test {
 
 namespace {
 
-/* This test is meant to be the WorkGraph equivalent of the Task DAG Scheduler test,
-   please see TestTaskScheduler.hpp for that test.
-   The algorithm computes the N-th fibonacci number as follows:
+/* This test is meant to be the WorkGraph equivalent of the Task DAG Scheduler
+   test, please see TestTaskScheduler.hpp for that test. The algorithm computes
+   the N-th fibonacci number as follows:
     - Each "task" or "work item" computes the i-th fibonacci number
     - If a task as (i < 2), it will record the known answer ahead of time.
     - If a task has (i >= 2), it will "spawn" two more tasks to compute
       the (i - 1) and (i - 2) fibonacci numbers.
       We do NOT do any de-duplication of these tasks.
-      De-duplication would result in only (N - 2) tasks which must be run in serial.
-      We allow duplicates both to increase the number of tasks and to increase the
-      amount of available parallelism.
+      De-duplication would result in only (N - 2) tasks which must be run in
+   serial. We allow duplicates both to increase the number of tasks and to
+   increase the amount of available parallelism.
  */
 
-template< class ExecSpace >
+template <class ExecSpace>
 struct TestWorkGraph {
-
   using MemorySpace = typename ExecSpace::memory_space;
-  using Policy = Kokkos::WorkGraphPolicy<std::int32_t, ExecSpace>;
-  using Graph = typename Policy::graph_type;
-  using RowMap = typename Graph::row_map_type;
-  using Entries = typename Graph::entries_type;
-  using Values = Kokkos::View<long*, MemorySpace>;
+  using Policy      = Kokkos::WorkGraphPolicy<std::int32_t, ExecSpace>;
+  using Graph       = typename Policy::graph_type;
+  using RowMap      = typename Graph::row_map_type;
+  using Entries     = typename Graph::entries_type;
+  using Values      = Kokkos::View<long*, MemorySpace>;
 
   long m_input;
   Graph m_graph;
   Graph m_transpose;
   Values m_values;
 
-  TestWorkGraph(long arg_input):m_input(arg_input) {
+  TestWorkGraph(long arg_input) : m_input(arg_input) {
     form_graph();
     transpose_crs(m_transpose, m_graph);
   }
 
-  inline
-  long full_fibonacci( long n ) {
+  inline long full_fibonacci(long n) {
     constexpr long mask = 0x03;
-    long fib[4] = { 0, 1, 1, 2 };
-    for ( long i = 2; i <= n; ++i ) {
-      fib[ i & mask ] = fib[ ( i - 1 ) & mask ] + fib[ ( i - 2 ) & mask ];
+    long fib[4]         = {0, 1, 1, 2};
+    for (long i = 2; i <= n; ++i) {
+      fib[i & mask] = fib[(i - 1) & mask] + fib[(i - 2) & mask];
     }
-    return fib[ n & mask ];
+    return fib[n & mask];
   }
 
   struct HostEntry {
@@ -99,31 +98,33 @@ struct TestWorkGraph {
   };
   std::vector<HostEntry> form_host_graph() {
     std::vector<HostEntry> g;
-    g.push_back({ m_input , -1 });
+    g.push_back({m_input, -1});
     for (std::int32_t i = 0; i < std::int32_t(g.size()); ++i) {
       auto e = g.at(std::size_t(i));
       if (e.input < 2) continue;
-      /* This part of the host graph formation is the equivalent of task spawning
-         in the Task DAG system. Notice how each task which is not a base case
-         spawns two more tasks, without any de-duplication */
-      g.push_back({ e.input - 1, i });
-      g.push_back({ e.input - 2, i });
+      /* This part of the host graph formation is the equivalent of task
+         spawning in the Task DAG system. Notice how each task which is not a
+         base case spawns two more tasks, without any de-duplication */
+      g.push_back({e.input - 1, i});
+      g.push_back({e.input - 2, i});
     }
     return g;
   }
 
   void form_graph() {
     auto hg = form_host_graph();
-    m_graph.row_map = RowMap("row_map", hg.size() + 1); // row map always has one more
-    m_graph.entries = Entries("entries", hg.size() - 1); // all but the first have a parent
+    m_graph.row_map =
+        RowMap("row_map", hg.size() + 1);  // row map always has one more
+    m_graph.entries =
+        Entries("entries", hg.size() - 1);  // all but the first have a parent
     m_values = Values("values", hg.size());
-    //printf("%zu work items\n", hg.size());
+    // printf("%zu work items\n", hg.size());
     auto h_row_map = Kokkos::create_mirror_view(m_graph.row_map);
     auto h_entries = Kokkos::create_mirror_view(m_graph.entries);
-    auto h_values = Kokkos::create_mirror_view(m_values);
-    h_row_map(0) = 0;
+    auto h_values  = Kokkos::create_mirror_view(m_values);
+    h_row_map(0)   = 0;
     for (std::int32_t i = 0; i < std::int32_t(hg.size()); ++i) {
-      auto& e = hg.at(std::size_t(i));
+      auto& e          = hg.at(std::size_t(i));
       h_row_map(i + 1) = i;
       if (e.input < 2) {
         h_values(i) = e.input;
@@ -139,10 +140,10 @@ struct TestWorkGraph {
   KOKKOS_INLINE_FUNCTION
   void operator()(std::int32_t i) const {
     auto begin = m_transpose.row_map(i);
-    auto end = m_transpose.row_map(i + 1);
+    auto end   = m_transpose.row_map(i + 1);
     for (auto j = begin; j < end; ++j) {
       auto k = m_transpose.entries(j);
-      m_values(i) += m_values( k );
+      m_values(i) += m_values(k);
     }
   }
 
@@ -151,22 +152,20 @@ struct TestWorkGraph {
     Kokkos::fence();
     auto h_values = Kokkos::create_mirror_view(m_values);
     Kokkos::deep_copy(h_values, m_values);
-    ASSERT_EQ( h_values(0), full_fibonacci(m_input) );
+    ASSERT_EQ(h_values(0), full_fibonacci(m_input));
   }
-
 };
 
-} // anonymous namespace
+}  // anonymous namespace
 
-TEST_F( TEST_CATEGORY, workgraph_fib )
-{
+TEST(TEST_CATEGORY, workgraph_fib) {
   int limit = 27;
-  for ( int i = 0; i < limit; ++i) {
-    TestWorkGraph< TEST_EXECSPACE > f(i);
+  for (int i = 0; i < limit; ++i) {
+    TestWorkGraph<TEST_EXECSPACE> f(i);
     f.test_for();
   }
-  //TestWorkGraph< TEST_EXECSPACE > f(2);
-  //f.test_for();
+  // TestWorkGraph< TEST_EXECSPACE > f(2);
+  // f.test_for();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/UnitTestMain.cpp b/lib/kokkos/core/unit_test/UnitTestMain.cpp
index 5f9091eced47c420c1055c4826dbc0025bd23ca2..a70409105f0b43a9fe07c102b626dce7cf803410 100644
--- a/lib/kokkos/core/unit_test/UnitTestMain.cpp
+++ b/lib/kokkos/core/unit_test/UnitTestMain.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,7 +45,7 @@
 #include <gtest/gtest.h>
 #include <cstdlib>
 
-int main( int argc, char *argv[] ) {
-  ::testing::InitGoogleTest( &argc, argv );
+int main(int argc, char *argv[]) {
+  ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
diff --git a/lib/kokkos/core/unit_test/UnitTestMainInit.cpp b/lib/kokkos/core/unit_test/UnitTestMainInit.cpp
index 82c8ee89958d1a320a66e6e9ad31163e359ed919..140ba418fdac4eda95ed362a9b5bf64e50676cc2 100644
--- a/lib/kokkos/core/unit_test/UnitTestMainInit.cpp
+++ b/lib/kokkos/core/unit_test/UnitTestMainInit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,11 +47,11 @@
 
 #include <Kokkos_Core.hpp>
 
-int main( int argc, char *argv[] ) {
-  Kokkos::initialize(argc,argv);
-  ::testing::InitGoogleTest( &argc, argv );
+int main(int argc, char *argv[]) {
+  Kokkos::initialize(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
 
-  int result =  RUN_ALL_TESTS();
+  int result = RUN_ALL_TESTS();
   Kokkos::finalize();
   return result;
 }
diff --git a/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook.cpp b/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook.cpp
index 97a7f9df26261e4a6bebfc421aa53ef98c683ed7..1b99691e6d13dc23c0cc94f653cd6b91c069c82d 100644
--- a/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook.cpp
+++ b/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,7 +48,7 @@
 #include <sstream>
 #include <Kokkos_Core.hpp>
 
-namespace { // (anonymous)
+namespace {  // (anonymous)
 
 // Output for the finalize hooks.  Use this to make sure that all the
 // hooks ran, and that they ran in the correct order.
@@ -58,7 +59,7 @@ const char hook2str[] = "Yea verily, I am Hook 2.";
 const char hook3str[] = "Indeed, I am Hook 3.";
 const char hook4str[] = "Last but not least, I am Hook 4.";
 
-} // namespace (anonymous)
+}  // namespace
 
 // Don't just have all the hooks print the same thing except for a
 // number.  Have them print different things, so we can detect
@@ -73,62 +74,52 @@ const char hook4str[] = "Last but not least, I am Hook 4.";
 //    unfortunately like to call "functor," even though this word
 //    means something different in other languages.
 
-void hook1 () {
-  hookOutput << hook1str << std::endl;
-}
+void hook1() { hookOutput << hook1str << std::endl; }
 
 struct Hook4 {
-  void operator () () const {
-    hookOutput << hook4str << std::endl;
-  }
+  void operator()() const { hookOutput << hook4str << std::endl; }
 };
 
-int main( int argc, char *argv[] ) {
+int main(int argc, char* argv[]) {
   using std::cout;
   using std::endl;
 
-  const std::string expectedOutput ([] {
-      std::ostringstream os;
-      os << hook4str << endl
-         << hook3str << endl
-         << hook2str << endl
-         << hook1str << endl;
-      return os.str();
-    }());
+  const std::string expectedOutput([] {
+    std::ostringstream os;
+    os << hook4str << endl
+       << hook3str << endl
+       << hook2str << endl
+       << hook1str << endl;
+    return os.str();
+  }());
 
   Kokkos::initialize(argc, argv);
 
-  Kokkos::push_finalize_hook(hook1); // plain old function
-  Kokkos::push_finalize_hook ([] {
-      hookOutput << hook2str << endl;
-    }); // lambda
-  std::function<void()> hook3 = [] {
-    hookOutput << hook3str << endl;
-  };
-  Kokkos::push_finalize_hook(hook3); // actual std::function
+  Kokkos::push_finalize_hook(hook1);  // plain old function
+  Kokkos::push_finalize_hook([] { hookOutput << hook2str << endl; });  // lambda
+  std::function<void()> hook3 = [] { hookOutput << hook3str << endl; };
+  Kokkos::push_finalize_hook(hook3);  // actual std::function
   Hook4 hook4;
-  Kokkos::push_finalize_hook(hook4); // function object instance
+  Kokkos::push_finalize_hook(hook4);  // function object instance
 
   // This should invoke the finalize hooks in reverse order.
   // Furthermore, it should not throw an exception.
   try {
     Kokkos::finalize();
-  }
-  catch (std::exception& e) {
+  } catch (std::exception& e) {
     cout << "FAILED: Kokkos::finalize threw an exception: " << e.what() << endl;
     return EXIT_FAILURE;
-  }
-  catch (...) {
+  } catch (...) {
     cout << "FAILED: Kokkos::finalize threw an exception whose base class "
-      "is not std::exception." << endl;
+            "is not std::exception."
+         << endl;
     return EXIT_FAILURE;
   }
 
   const bool success = (hookOutput.str() == expectedOutput);
   if (success) {
     cout << "SUCCESS" << endl;
-  }
-  else {
+  } else {
     cout << "FAILED:" << endl
          << "  Expected output:" << endl
          << expectedOutput << endl
diff --git a/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook_terminate.cpp b/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook_terminate.cpp
index 50b7a3f2850a1d8518c22aad064e5203d02c6a52..442310542be36bf40c495336d287d37812c9b83c 100644
--- a/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook_terminate.cpp
+++ b/lib/kokkos/core/unit_test/UnitTest_PushFinalizeHook_terminate.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -50,30 +51,28 @@
 // throws but does not catch an exception, make sure that
 // Kokkos::finalize calls std::terminate.
 
-namespace { // (anonymous)
+namespace {  // (anonymous)
 
 // If you change this, change CMakeLists.txt in this directory too!
 // I verified that changing this string makes the test fail.
-const char my_terminate_str[] = "PASSED: I am the custom std::terminate handler.";
+const char my_terminate_str[] =
+    "PASSED: I am the custom std::terminate handler.";
 
 // Tell compilers not to complain that this function doesn't return.
-[[ noreturn ]] void my_terminate_handler ()
-{
+[[noreturn]] void my_terminate_handler() {
   std::cerr << my_terminate_str << std::endl;
-  std::abort(); // terminate handlers normally would end by calling this
+  std::abort();  // terminate handlers normally would end by calling this
 }
 
-} // namespace (anonymous)
+}  // namespace
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
   // If std::terminate is called, it will call my_terminate_handler.
-  std::set_terminate (my_terminate_handler);
+  std::set_terminate(my_terminate_handler);
 
   Kokkos::initialize(argc, argv);
-  Kokkos::push_finalize_hook([] {
-      throw std::runtime_error ("I am an uncaught exception!");
-    });
+  Kokkos::push_finalize_hook(
+      [] { throw std::runtime_error("I am an uncaught exception!"); });
 
   // This should call std::terminate, which in turn will call
   // my_terminate_handler above.  That will print the message that
diff --git a/lib/kokkos/core/unit_test/config/cmaketest/CMakeLists.txt b/lib/kokkos/core/unit_test/config/cmaketest/CMakeLists.txt
index 54a4c4a74a19d0699f406f602a9930cc46674ab8..72fef0a3e81fc52f321f25476149e675aede9042 100644
--- a/lib/kokkos/core/unit_test/config/cmaketest/CMakeLists.txt
+++ b/lib/kokkos/core/unit_test/config/cmaketest/CMakeLists.txt
@@ -19,7 +19,6 @@ set(KOKKOS_CMAKEFILE kokkos_generated_settings.cmake)
 set(KOKKOS_INTERNAL_CONFIG_TMP KokkosCore_config.tmp)
 set(KOKKOS_CONFIG_HEADER KokkosCore_config.h)
 
-set(KOKKOS_CMAKE_VERBOSE False)
 include(${KOKKOS_SRCDIR}/cmake/kokkos_options.cmake)
 foreach(KOKKOS_DEV ${KOKKOS_DEVICES_LIST})
 # Do some initialization: Want to turn everything off for testing
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/CMakeLists.txt b/lib/kokkos/core/unit_test/configuration/test-code/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..49f36c086a421618756fa531b180da59608bd187
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/CMakeLists.txt
@@ -0,0 +1,44 @@
+# Kokkos requires CMake version 3.1 or higher and that you have the following
+# line with a version of 3.1 or higher as the first line of your project:
+#   cmake_minimum_required(VERSION 3.1)
+#
+# The other CMake commands required to build Kokkos as part of your application
+# are:
+#   add_subdirectory(path/to/kokkos)
+#   target_link_libraries(executable or library)
+#
+# If Kokkos is not a subdirectory of your project, you will also need to pass a
+# binary directory to add_subdirectory().  We had to pass the binary directory
+# for this example for that reason.  Note that target_link_libraries() can be
+# called on a target added by add_executable(), add_library(), or another
+# similar command.
+#
+# All the flags, etc. required to build using the Kokkos library are
+# transitively added to targets which depend on the library.
+#
+# The CMake variables CMAKE_CXX_STANDARD and CMAKE_CXX_EXTENSIONS are
+# respected.  We recommend that you set CMAKE_CXX_EXTENSIONS to OFF.
+# Otherwise, CMake defaults to using extensions for the C++ standard, and the
+# GNU extensions (-std=gnu++11) will be used for compilers that support it
+# instead of standard C++11 (-std=c++11).
+#
+# A bunch of build options are added as variables (all starting with KOKKOS_)
+# to the build.  Check them out using ccmake or the CMake GUI.
+#
+# Building this example:
+#   1. Create a build directory.
+#   2. cd /path/to/build/directory
+#   3. cmake /path/to/example
+#   4. make
+
+cmake_minimum_required(VERSION 3.10)
+project(Example CXX C Fortran)
+
+list(APPEND CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} -O3)
+
+add_subdirectory(${Example_SOURCE_DIR}/../../../.. ${Example_BINARY_DIR}/kokkos)
+
+include_directories(${Kokkos_INCLUDE_DIRS_RET})
+
+add_executable(test_cmake.exe main.cpp)
+target_link_libraries(test_cmake.exe kokkos)
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/Makefile b/lib/kokkos/core/unit_test/configuration/test-code/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..8ca5f34990b54700e7a29d4197d7f150f1ff0a81
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/Makefile
@@ -0,0 +1,46 @@
+KOKKOS_DEVICES=Serial
+KOKKOS_CUDA_OPTIONS=enable_lambda
+KOKKOS_ARCH = "SNB,Kepler35"
+
+
+MAKEFILE_PATH := $(subst Makefile,,$(abspath $(lastword $(MAKEFILE_LIST))))
+
+ifndef KOKKOS_PATH
+  KOKKOS_PATH = $(MAKEFILE_PATH)../../../..
+endif
+
+SRC = $(wildcard $(MAKEFILE_PATH)*.cpp)
+HEADERS = $(wildcard $(MAKEFILE_PATH)*.hpp)
+
+vpath %.cpp $(sort $(dir $(SRC)))
+
+default: build
+	echo "Start Build"
+
+CXX = g++
+EXE = test_config.exe
+
+CXXFLAGS ?= -O3 -g
+override CXXFLAGS += -I$(MAKEFILE_PATH)
+
+DEPFLAGS = -M
+LINK = ${CXX}
+LINKFLAGS =
+
+OBJ = $(notdir $(SRC:.cpp=.o))
+LIB =
+
+include $(KOKKOS_PATH)/Makefile.kokkos
+
+build: $(EXE)
+
+$(EXE): $(OBJ) $(KOKKOS_LINK_DEPENDS)
+	$(LINK) $(KOKKOS_LDFLAGS) $(LINKFLAGS) $(EXTRA_PATH) $(OBJ) $(KOKKOS_LIBS) $(LIB) -o $(EXE)
+
+clean: kokkos-clean
+	rm -f *.o *.cuda *.host
+
+# Compilation rules
+
+%.o:%.cpp $(KOKKOS_CPP_DEPENDS) $(HEADERS)
+	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $< -o $(notdir $@)
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/main.cpp b/lib/kokkos/core/unit_test/configuration/test-code/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d2f6de3a9f6cc70bf9d6ebb83d46780405a2b89
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/main.cpp
@@ -0,0 +1,6 @@
+#include <Kokkos_Core.hpp>
+
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
+  Kokkos::finalize();
+}
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/test_config.bash b/lib/kokkos/core/unit_test/configuration/test-code/test_config.bash
new file mode 100755
index 0000000000000000000000000000000000000000..0edb1139333372796fb45d93f5a365563830ad52
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/test_config.bash
@@ -0,0 +1,7 @@
+
+mkdir -p gnu-make
+mkdir -p cmake
+export KOKKOS_PATH=$1
+KOKKOS_PATH=$1
+${KOKKOS_PATH}/core/unit_test/configuration/test-code/test_config_device_list.bash
+
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/test_config_arch_list.bash b/lib/kokkos/core/unit_test/configuration/test-code/test_config_arch_list.bash
new file mode 100755
index 0000000000000000000000000000000000000000..696d345ff95ad4ea2a512fb0580480ad81848e7f
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/test_config_arch_list.bash
@@ -0,0 +1,45 @@
+
+# List of parallel device types 
+HostArch=(SNB HSW SKX KNL)
+DeviceArch=(Kepler35 Kepler37 Pascal60 Pascal61 Volta70)
+if [ ! -z "$KOKKOS_HOST_ARCH_TEST" ]; then
+  export KOKKOS_ARCH_TEST=1
+  HostArch=(WSM SNB HSW SKX WSM AMDAVX ARMv80 ARMv81 BDW KNC KNL BGQ Power7 Power8 Power9 Ryzen EPYC ARMv8_ThunderX ARMv8_ThunderX2)
+  DeviceArch=()
+fi
+
+if [ ! -z "$KOKKOS_DEVICE_ARCH_TEST" ]; then
+  export KOKKOS_ARCH_TEST=1
+  HostArch=(SNB)
+  DeviceArch=(Kepler30 Kepler32 Kepler35 Kepler37 Maxwell50 Maxwell52 Maxwell53 Pascal60 Pascal61 Volta70 Volta72)
+fi
+
+MakeDevices=$1
+CMakeDevices=$2
+
+SRC_DIR=${KOKKOS_PATH}/core/unit_test/configuration/test-code
+
+for harch in "${HostArch[@]}"
+do
+  harch_up=`echo $harch | tr a-z A-Z`
+  CMAKE_HARCH="-DKokkos_ARCH_${harch_up}=ON"
+
+  if [ "$harch" == "ARMv8_ThunderX2" ]; then
+    harch="ARMv8-TX2"
+  elif [ "$harch" == "ARMv8_ThunderX" ]; then
+    harch="ARMv8-ThunderX"
+  fi
+
+  if [ ! -z "$DeviceArch" ]
+  then
+    for darch in "${DeviceArch[@]}"
+    do
+      darch_up=`echo $darch | tr a-z A-Z`
+      CMAKE_DARCH="-DKokkos_ARCH_${darch_up}=ON"
+      ${SRC_DIR}/test_config_options_list.bash "$MakeDevices" "$CMakeDevices" "$harch,$darch" "${CMAKE_HARCH} ${CMAKE_DARCH}"
+    done
+  else
+    ${SRC_DIR}/test_config_options_list.bash "$MakeDevices" "$CMakeDevices" "$harch" "${CMAKE_HARCH}"
+  fi 
+done
+
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/test_config_device_list.bash b/lib/kokkos/core/unit_test/configuration/test-code/test_config_device_list.bash
new file mode 100755
index 0000000000000000000000000000000000000000..e96f567fe291d6a87a609759c76ebce63ddd726a
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/test_config_device_list.bash
@@ -0,0 +1,45 @@
+
+SRC_DIR=${KOKKOS_PATH}/core/unit_test/configuration/test-code
+# List of parallel device types 
+HostPDevices=(OpenMP Threads)
+if [ ! -z "$KOKKOS_ARCH_TEST" ]; then
+  HostPDevices=(OpenMP)
+fi
+
+if [ ! -z "$HPX_ROOT" ]
+then 
+  HostPDevices=(${HostPDevices[@]} HPX)
+fi
+
+if [ ! -z "$CUDA_ROOT" ]
+then
+  AccDevices=(${AccDevices[@]} Cuda)
+  export CXX=${KOKKOS_PATH}/bin/nvcc_wrapper
+fi
+if [ ! -z "$HIP_ROOT" ]
+then
+  AccDevices=(${AccDevices[@]} HIP)
+fi
+
+for hpdevice in "${HostPDevices[@]}"
+do
+  hpdevice_up=`echo $hpdevice | tr a-z A-Z`
+  CMAKE_HPDEVICE="-DKokkos_ENABLE_${hpdevice_up}=ON"
+
+  if [ ! -z "$AccDevices" ]
+  then
+    for accdevice in "${AccDevices[@]}"
+    do
+      accdevice_up=`echo $accdevice | tr a-z A-Z`
+      CMAKE_ACCDEVICE="-DKokkos_ENABLE_${accdevice_up}=ON"
+      ${SRC_DIR}/test_config_arch_list.bash "$hpdevice,$accdevice" "${CMAKE_HPDEVICE} ${CMAKE_ACCDEVICE}"
+      ${SRC_DIR}/test_config_arch_list.bash "$hpdevice,$accdevice,Serial" "${CMAKE_HPDEVICE} ${CMAKE_ACCDEVICE} -DKokkos_ENABLE_SERIAL=ON"
+    done
+  else
+    #no, I need to be able to specify this
+    #export CXX=g++
+    ${SRC_DIR}/test_config_arch_list.bash "$hpdevice" "${CMAKE_HPDEVICE}"
+    ${SRC_DIR}/test_config_arch_list.bash "$hpdevice,Serial" "${CMAKE_HPDEVICE} -DKokkos_ENABLE_SERIAL=ON"
+  fi 
+done
+
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/test_config_options_list.bash b/lib/kokkos/core/unit_test/configuration/test-code/test_config_options_list.bash
new file mode 100755
index 0000000000000000000000000000000000000000..1d72f28d235f35be12ee97bccbb81849ada86b37
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/test_config_options_list.bash
@@ -0,0 +1,49 @@
+SRC_DIR=${KOKKOS_PATH}/core/unit_test/configuration/test-code
+
+# List of parallel device types 
+Options=(deprecated_code aggressive_vectorization disable_profiling large_mem_tests)
+CudaOptions=(lambda relocatable_device_code uvm constexpr)
+
+if [ ! -z "$KOKKOS_ARCH_TEST" ]; then
+  Options=(disable_profiling)
+  CudaOptions=(uvm)
+fi
+
+MakeDevices=$1
+CMakeDevices=$2
+MakeArch=$3
+CMakeArch=$4
+
+for option in "${Options[@]}"
+do
+  option_up=`echo $option | tr a-z A-Z`
+  if [[ $option_up == *"DISABLE"* ]]; then
+    new_option_up=${option_up/DISABLE_/}
+    CMAKE_OPTION="-DKokkos_ENABLE_${new_option_up}=OFF"
+  else
+    CMAKE_OPTION="-DKokkos_ENABLE_${option_up}=ON"
+  fi
+
+  #Renaming options as GNU Make expects them
+  option=${option/deprecated_code/enable_deprecated_code}
+  option=${option/large_mem_tests/enable_large_mem_tests}
+
+  if [ ! -z $CudaOptions ]; then 
+    for cuda_option in "${CudaOptions[@]}"
+    do
+      cuda_option_up=`echo $cuda_option | tr a-z A-Z`
+      CMAKE_CUDA_OPTION="-DKokkos_ENABLE_CUDA_${cuda_option_up}=ON"
+
+      #Renaming options as GNU Make expects them
+      cuda_option=${cuda_option/lambda/enable_lambda}
+      cuda_option=${cuda_option/constexpr/enable_constexpr}
+      cuda_option=${cuda_option/relocatable_device_code/rdc}
+      cuda_option=${cuda_option/uvm/force_uvm}
+
+      ${SRC_DIR}/test_config_run.bash "$MakeDevices" "$CMakeDevices" "$MakeArch" "$CMakeArch" "KOKKOS_OPTIONS=$option KOKKOS_CUDA_OPTIONS=$cuda_option" "$CMAKE_OPTION $CMAKE_CUDA_OPTION"
+    done
+  else  
+    ${SRC_DIR}/test_config_run.bash "$MakeDevices" "$CMakeDevices" "$MakeArch" "$CMakeArch" "KOKKOS_OPTIONS=$option" "$CMAKE_OPTION"
+  fi
+done
+
diff --git a/lib/kokkos/core/unit_test/configuration/test-code/test_config_run.bash b/lib/kokkos/core/unit_test/configuration/test-code/test_config_run.bash
new file mode 100755
index 0000000000000000000000000000000000000000..4750c843c290ca37b9e533126843c4f14474e7c6
--- /dev/null
+++ b/lib/kokkos/core/unit_test/configuration/test-code/test_config_run.bash
@@ -0,0 +1,111 @@
+
+SRC_DIR=${KOKKOS_PATH}/core/unit_test/configuration/test-code
+
+# List of parallel device types 
+MakeDevices=$1
+CMakeDevices=$2
+MakeArch=$3
+CMakeArch=$4
+MakeOptions=$5
+CMakeOptions=$6
+
+cd gnu-make
+rm -rf *
+make -f ${SRC_DIR}/Makefile KOKKOS_DEVICES=$MakeDevices KOKKOS_ARCH=$MakeArch $MakeOptions CXX=$CXX KokkosCore_config.h &>out
+make -f ${SRC_DIR}/Makefile KOKKOS_DEVICES=$MakeDevices KOKKOS_ARCH=$MakeArch $MakeOptions CXX=$CXX print-cxx-flags &> cxxflags
+
+cd ../cmake
+rm -rf *
+cmake -DKokkos_SKIP_VALIDATION=ON \
+      -DCMAKE_CXX_COMPILER=$CXX \
+      $CMakeDevices \
+      $CMakeArch \
+      $CMakeOptions \
+      $SRC_DIR &> config_out
+cd ..
+grep define gnu-make/KokkosCore_config.h | sort -u &> make_config_defines
+grep define cmake/kokkos/KokkosCore_config.h | sort -u &> cmake_config_defines
+
+diff make_config_defines cmake_config_defines &> config_defines_diff
+diff_exists=`cat config_defines_diff | wc -l`
+if [ $diff_exists -gt 0 ]
+then
+  echo ""
+  echo ""
+  echo "Failed #define test"
+  echo Make: "make -f ${SRC_DIR}/Makefile KOKKOS_DEVICES=$MakeDevices KOKKOS_ARCH=$MakeArch $MakeOptions CXX=$CXX KokkosCore_config.h"
+  echo CMake: "cmake -DCMAKE_CXX_COMPILER=$CXX $CMakeDevices $CMakeArch $CMakeOptions $SRC_DIR"
+  cat config_defines_diff
+  echo "Sleeping for 3 seconds if you want to stop and explore..."
+  echo ""
+  sleep 3
+else
+  echo ""
+  echo ""
+  echo "Passed #define test"
+  echo Make: "make -f ${SRC_DIR}/Makefile KOKKOS_DEVICES=$MakeDevices KOKKOS_ARCH=$MakeArch $MakeOptions CXX=$CXX KokkosCore_config.h"
+  echo CMake: "cmake -DCMAKE_CXX_COMPILER=$CXX $CMakeDevices $CMakeArch $CMakeOptions $SRC_DIR"
+fi
+
+#find because it goes in different locations
+#grep out compiler warnings
+#head multiple matches
+#sed a bunch of stuff to clean up cmake garbage
+#awk trim whitespace
+#awk print each on new line
+#grep remove empty lines
+#grep don't consider -std flags in the comparison
+#sort and print unique flags
+find cmake/kokkos -name KokkosTargets.cmake -exec grep -h INTERFACE_COMPILE_OPTIONS {} \; \
+  | grep -v skew \
+  | head -n 1 \
+  | sed 's/INTERFACE_COMPILE_OPTIONS//g' \
+  | sed 's/;/ /g' \
+  | sed 's/"//g' \
+  | sed 's/\\$<\\$<//g' \
+  | sed 's/COMPILE_LANGUAGE:CXX>://g' \
+  | sed 's/> / /g' \
+  | sed 's/>$//g' \
+  | awk '{$1=$1;print}' \
+  | awk -v RS=" " '{print}' \
+  | grep -v -e '^$' \
+  | grep -v '\-std' \
+  | sort | uniq > cmake_cxx_flags
+
+#-I flags and -std= flags are not part of CMake's compile options
+#that's fine, let's ignore thse below
+#redundant lines - tail the last one
+#awk print each on new line
+#grep out blank lines
+#grep out include flags
+#grep out -std flags
+#sort and print unique flags
+tail -n 1 gnu-make/cxxflags \
+  | awk -v RS=" " '{print}' \
+  | grep -v -e '^$' \
+  | grep -v '\-I' \
+  | grep -v '\-std=' \
+  | grep -v 'gcc-toolchain' \
+  | sort | uniq > gnu_make_cxx_flags
+diff gnu_make_cxx_flags cmake_cxx_flags &> config_cxxflags_diff
+diff_exists=`cat config_cxxflags_diff | wc -l`
+
+if [ $diff_exists -gt 0 ]
+then
+  echo ""
+  echo ""
+  echo "Failed CXXFLAGS test"
+  echo Make: "make -f ${SRC_DIR}/Makefile KOKKOS_DEVICES=$MakeDevices KOKKOS_ARCH=$MakeArch $MakeOptions CXX=$CXX KokkosCore_config.h"
+  echo CMake: "cmake -DCMAKE_CXX_COMPILER=$CXX $CMakeDevices $CMakeArch $CMakeOptions $SRC_DIR"
+  cat config_cxxflags_diff
+  echo "Sleeping for 3 seconds if you want to stop and explore..."
+  echo ""
+  sleep 3
+else
+  echo ""
+  echo ""
+  echo "Passed CXXFLAGS test"
+  echo Make: "make -f ${SRC_DIR}/Makefile KOKKOS_DEVICES=$MakeDevices KOKKOS_ARCH=$MakeArch $MakeOptions CXX=$CXX KokkosCore_config.h"
+  echo CMake: "cmake -DCMAKE_CXX_COMPILER=$CXX $CMakeDevices $CMakeArch $CMakeOptions $SRC_DIR"
+fi
+
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_Category.hpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_Category.hpp
index 23c5eb4fe748a9ff9ac4d8b0f3b2c0b04c23c1d3..3f8ec6bacf209f9fe3fc0739170b359dfb986f36 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_Category.hpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,21 +47,10 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class cuda_hostpinned : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY cuda_hostpinned
-//#define TEST_EXECSPACE Kokkos::Device<Kokkos::Cuda,Kokkos::CudaHostPinnedSpace>
+#define TEST_CATEGORY_DEATH cuda_hostpinned_DeathTest
+//#define TEST_EXECSPACE
+// Kokkos::Device<Kokkos::Cuda,Kokkos::CudaHostPinnedSpace>
 #define TEST_EXECSPACE Kokkos::CudaHostPinnedSpace
 
 #endif
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_SharedAlloc.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_SharedAlloc.cpp
index 8a8a758e67cc03cb5d14f9327c73707685e45775..18780c09a7e42e5b99ea5498ebf54f9c54dec1af 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< TEST_EXECSPACE, Kokkos::DefaultHostExecutionSpace >();
+TEST(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<TEST_EXECSPACE, Kokkos::DefaultHostExecutionSpace>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_a.cpp
index 3b27b544a5244602d1d6cc7139840fc7c565cb4c..eeb9f3fa3a44ac2f992f95477098fb938cbaea1b 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_b.cpp
index 4b89d288c782ba31483f46e1c9576d756723ae25..04949cf5739e9ebff78acf5ed025adb8eaea1679 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_c.cpp
index 3f82f8f7784a798512d6ee7c4f8bbf790a7b34b7..bf259ef734130780ab84b874fec1ea927582559d 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_d.cpp
index 2fd2cfac8ed0ce57fe0e391aa5779cbacfb43601..84d81e3b41fc843522ef4f5a1969d9a4ae7b5131 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_e.cpp
index 924b6b48339f6d4f74ee4b67a252d5f7541b5dab..db9e990ae5a6738cbcfb100670709ee7ef65254b 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewCopy.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewCopy.cpp
index 37485923555d7bbb06181d94d3182548f664906c..04b43cf9ab3d6c8d919188e345d7f348476cd9a9 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewCopy.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewCopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_a.cpp
index 21ed986b7f0454570301b3f407c6e3d6f33e04f7..923f4df965c597d87b3f92abfa26b69dcd9a7f8b 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCudaHostPinned_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_b.cpp
index 3024cf6e41eb1889ac02e0fc8b5006601fffb96f..1efe65b21db58392bad6c7ef36b3808c763d3f81 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCudaHostPinned_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_subview.cpp
index 56c1ee013da0473cf74c0ec11c9aad693689bac1..9e1034c5b72b80592d647aae17fd35dd77faf8ba 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaHostPinned_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCudaHostPinned_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_Category.hpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_Category.hpp
index 36320ebd393b64974c2fc6eb2d41860a4d41b88a..ff53e5a719a7274e8d38b93259286e14bc44d27a 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_Category.hpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class cuda_uvm : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY cuda_uvm
+#define TEST_CATEGORY_DEATH cuda_uvm_DeathTest
 #define TEST_EXECSPACE Kokkos::CudaUVMSpace
 
 #endif
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_SharedAlloc.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_SharedAlloc.cpp
index 57a0848527056222c8fd63e521f2c4b4b1646b9a..81e43da34caca64de71cfbeafa69953c6d7c344a 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< TEST_EXECSPACE, Kokkos::DefaultHostExecutionSpace >();
+TEST(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<TEST_EXECSPACE, Kokkos::DefaultHostExecutionSpace>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_a.cpp
index cd535e605f4059d6f9f5fc060f80c7ffd0306bbd..3a48b2495e716bfd4b92bbf9a76ce91be399b4ea 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_b.cpp
index b3da2b581ec6d8fdefb552f43a73006ad597b080..7f0effb5e8d8a1538f656798a956f6edf967d5bd 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_c.cpp
index 2e53e7a81bf34affc6080d4b7174c8807fba3ac3..9d8cbf0c773f8c5ff293178cf7f9b3fc092a6fe1 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_d.cpp
index f9dea646f756843656404f7f143e8a3431195268..8d2b5268bf5394e76e0ea8db7e0bce9b04fbb383 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_e.cpp
index 5a8399c48467493915cb73086718ce4b3d59762a..5c11b2a322ca10a0251476babb82a7a1207253e4 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewCopy.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewCopy.cpp
index b0ea67a1b5cca4254728d0cdc627725caa54dd18..774bf010dce7dd740936145afc67b8363a77f883 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewCopy.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewCopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_a.cpp
index 5be4404c9e32294c2040ed7cc2ac7f40916badc0..aa9b513d7aab8033dfbe8595f8ae3ebe8c9ad2dc 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCudaUVM_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_b.cpp
index 2664c472e6b5157969dc12ba45570da3aa3deba2..f24e9ba4f1f0432eace053ca72b5ecf577c2d231 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCudaUVM_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_subview.cpp
index c08e00ba4900324bab6915d6c706941d3d296ae7..47b7d1f46cbab75ae8a6215fd72094472e7240c5 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCudaUVM_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCudaUVM_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexdouble.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexdouble.cpp
index 6fb9ad0628428e059f761706db372efb786e4578..813eb919c86ab975e93a36c4337d96a0c943e564 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexdouble.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexdouble.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_complexdouble.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_complexdouble.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexfloat.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexfloat.cpp
index 3170bbc5307a15b27a6cb0fba4ca0c0692e244f4..ea8447cb28fca4b7645e211c0b73b4796f628245 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexfloat.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_complexfloat.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_complexfloat.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_complexfloat.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_double.cpp
index 356d1d6ad85bffc216d4c0c6ea9009aeac418edd..008dcdcadbdbea24d94d87f6401758e4a83c6fbe 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_float.cpp
index 8866f21a11bbf694a92e850e36842020341b1bb1..3fde849b3f501814772371c5ecf2eec83f979bd0 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_int.cpp
index 5cc832ee391574dfa419565085e3724abdff54d9..8746add7b2a43c8ce0ea75f569979e67dc764f30 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longint.cpp
index cd12fba02b3fc65b21dbdeb9ca76af0c2a183143..9cd133b3b214b3852c796fb4c91a60e2d506d994 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longlongint.cpp
index 471e8d1765316717a41f9500b7fcd7aff453f971..658374ac60c8db59a85a8141af85d8c6a6df4457 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedint.cpp
index 1f6f94c2bcb5f1b127ad00b22aed6b9fa90d5615..7d79f589e39cc178ad4ae9c3d59d6a2a61a815e8 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedlongint.cpp
index d373c07c1d5861c775425018aea388baec26aa3f..29335d0f543e85702c9d61098f9394d8d3f3612e 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicViews.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicViews.cpp
index debbc10ea77b09d21cff090cd43ef088fbc5f394..56c5fe6f3e4b3e4ae7d33e644e3485bea55ecb2e 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicViews.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_AtomicViews.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestAtomicViews.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestAtomicViews.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Atomics.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Atomics.cpp
index 1875143f320438d77850ece2df73442ea58e1151..e68222ca3a10795acc3806e455a7c64a9dcc6c26 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCuda_Category.hpp>
 #include <TestAtomic.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Category.hpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Category.hpp
index 3e0d1424802f243ef9ec0098970e9d2d1be8fbb8..7e7b7c77e18808d78bfdf84d08b19675b0872a40 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Category.hpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class cuda : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY cuda
+#define TEST_CATEGORY_DEATH cuda_DeathTest
 #define TEST_EXECSPACE Kokkos::Cuda
 
 #endif
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Complex.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Complex.cpp
index 7c92f111fcc51e713b701d835d20ec3112d97ee4..af44310481f920e163b66130d1c2f8a577c46d4a 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Complex.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Complex.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Crs.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Crs.cpp
index 98f5e3793a91e07a498ed4de6b8841681275ea3d..2ae1ee1382e0a8a688fd957c392567e477ff8b5e 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Crs.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Crs.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_DebugPinUVMSpace.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_DebugPinUVMSpace.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4313cece0ca18ef120966230666eb16c847dc986
--- /dev/null
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_DebugPinUVMSpace.cpp
@@ -0,0 +1,131 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <Kokkos_Core.hpp>
+#include <cuda/TestCuda_Category.hpp>
+
+namespace Test {
+
+template <class View>
+struct CopyFunctor {
+  View a;
+  View b;
+
+  CopyFunctor(int N) : a(View("A", N)), b(View("B", N)) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i) const { a(i) = b(i); }
+
+  double time_copy(int R) {
+    Kokkos::parallel_for("CopyFunctor::time_copy", a.extent(0), *this);
+    Kokkos::fence();
+
+    Kokkos::Timer timer;
+    for (int r = 0; r < R; r++)
+      Kokkos::parallel_for("CopyFunctor::time_copy", a.extent(0), *this);
+    Kokkos::fence();
+    return timer.seconds();
+  }
+};
+
+TEST(cuda, debug_pin_um_to_host) {
+  double time_cuda_space;
+  double time_cuda_host_pinned_space;
+  double time_cuda_uvm_space_not_pinned_1;
+  double time_cuda_uvm_space_pinned;
+  double time_cuda_uvm_space_not_pinned_2;
+
+  int N = 10000000;
+  int R = 100;
+  {
+    CopyFunctor<Kokkos::View<int*, Kokkos::CudaSpace>> f(N);
+    time_cuda_space = f.time_copy(R);
+  }
+  {
+    CopyFunctor<Kokkos::View<int*, Kokkos::CudaHostPinnedSpace>> f(N);
+    time_cuda_host_pinned_space = f.time_copy(R);
+  }
+  {
+    CopyFunctor<Kokkos::View<int*, Kokkos::CudaUVMSpace>> f(N);
+    time_cuda_uvm_space_not_pinned_1 = f.time_copy(R);
+  }
+  {
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+    kokkos_impl_cuda_set_pin_uvm_to_host(true);
+#endif
+    CopyFunctor<Kokkos::View<int*, Kokkos::CudaUVMSpace>> f(N);
+    time_cuda_uvm_space_pinned = f.time_copy(R);
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+    kokkos_impl_cuda_set_pin_uvm_to_host(false);
+#endif
+  }
+  {
+    CopyFunctor<Kokkos::View<int*, Kokkos::CudaUVMSpace>> f(N);
+    time_cuda_uvm_space_not_pinned_2 = f.time_copy(R);
+  }
+  bool uvm_approx_cuda_1 =
+      time_cuda_uvm_space_not_pinned_1 < time_cuda_space * 2.0;
+  bool uvm_approx_cuda_2 =
+      time_cuda_uvm_space_not_pinned_2 < time_cuda_space * 2.0;
+  bool pinned_slower_cuda = time_cuda_host_pinned_space > time_cuda_space * 2.0;
+  bool uvm_pinned_slower_cuda =
+      time_cuda_uvm_space_pinned > time_cuda_space * 2.0;
+
+  bool passed = uvm_approx_cuda_1 && uvm_approx_cuda_2 && pinned_slower_cuda &&
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
+                uvm_pinned_slower_cuda;
+#else
+                !uvm_pinned_slower_cuda;
+#endif
+  if (!passed)
+    printf(
+        "Time CudaSpace: %lf CudaUVMSpace_1: %lf CudaUVMSpace_2: %lf "
+        "CudaPinnedHostSpace: %lf CudaUVMSpace_Pinned: %lf\n",
+        time_cuda_space, time_cuda_uvm_space_not_pinned_1,
+        time_cuda_uvm_space_not_pinned_2, time_cuda_host_pinned_space,
+        time_cuda_uvm_space_pinned);
+  ASSERT_TRUE(passed);
+}
+
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_DebugSerialExecution.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_DebugSerialExecution.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5472ef9fd169a5a43347e98519c8ab32e04ca5eb
--- /dev/null
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_DebugSerialExecution.cpp
@@ -0,0 +1,197 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <Kokkos_Core.hpp>
+#include <cuda/TestCuda_Category.hpp>
+
+namespace Test {
+
+using ViewType = Kokkos::View<double*>;
+
+struct TestForFunctor {
+  ViewType a;
+  ViewType b;
+
+  TestForFunctor(int N) : a(ViewType("A", N)), b(ViewType("B", N)) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i) const { a(i) = b(i); }
+
+  double time_par_for() {
+    Kokkos::Timer timer;
+    Kokkos::parallel_for("CudaDebugSerialExecution::par_for", a.extent(0),
+                         *this);
+    Kokkos::fence();
+    return timer.seconds();
+  }
+};
+
+struct TestRedFunctor {
+  ViewType a;
+  ViewType b;
+
+  TestRedFunctor(int N) : a(ViewType("A", N)), b(ViewType("B", N)) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i, double& val) const { val += a(i) * b(i); }
+
+  double time_par_red() {
+    Kokkos::Timer timer;
+    double dot;
+    Kokkos::parallel_reduce("CudaDebugSerialExecution::par_red", a.extent(0),
+                            *this, dot);
+    Kokkos::fence();
+    return timer.seconds();
+  }
+};
+
+struct TestScanFunctor {
+  ViewType a;
+  ViewType b;
+
+  TestScanFunctor(int N) : a(ViewType("A", N)), b(ViewType("B", N)) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i, double& val, bool final) const {
+    val += b(i);
+    if (final) a(i) = val;
+  }
+
+  double time_par_scan() {
+    Kokkos::Timer timer;
+    double dot;
+    Kokkos::parallel_scan("CudaDebugSerialExecution::par_scan", a.extent(0),
+                          *this, dot);
+    Kokkos::fence();
+    return timer.seconds();
+  }
+};
+
+TEST(cuda, debug_serial_execution) {
+  double time_par_for_1, time_par_for_2, time_par_for_serial;
+  double time_par_red_1, time_par_red_2, time_par_red_serial;
+  double time_par_scan_1, time_par_scan_2, time_par_scan_serial;
+
+  int N = 10000000;
+  {
+    TestForFunctor f(N);
+    f.time_par_for();
+    time_par_for_1 = f.time_par_for();
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    kokkos_impl_cuda_set_serial_execution(true);
+#endif
+    time_par_for_serial = f.time_par_for();
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    kokkos_impl_cuda_set_serial_execution(false);
+#endif
+    time_par_for_2 = f.time_par_for();
+
+    bool passed_par_for =
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+        (time_par_for_serial > time_par_for_1 * 20.0) &&
+        (time_par_for_serial > time_par_for_2 * 20.0);
+#else
+        (time_par_for_serial < time_par_for_1 * 2.0) &&
+        (time_par_for_serial < time_par_for_2 * 2.0);
+#endif
+    if (!passed_par_for)
+      printf("Time For1: %lf For2: %lf ForSerial: %lf\n", time_par_for_1,
+             time_par_for_2, time_par_for_serial);
+    ASSERT_TRUE(passed_par_for);
+  }
+  {
+    TestRedFunctor f(N);
+    f.time_par_red();
+    time_par_red_1 = f.time_par_red();
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    kokkos_impl_cuda_set_serial_execution(true);
+#endif
+    time_par_red_serial = f.time_par_red();
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    kokkos_impl_cuda_set_serial_execution(false);
+#endif
+    time_par_red_2 = f.time_par_red();
+
+    bool passed_par_red =
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+        (time_par_red_serial > time_par_red_1 * 2.0) &&
+        (time_par_red_serial > time_par_red_2 * 2.0);
+#else
+        (time_par_red_serial < time_par_red_1 * 2.0) &&
+        (time_par_red_serial < time_par_red_2 * 2.0);
+#endif
+    if (!passed_par_red)
+      printf("Time Red1: %lf Red2: %lf RedSerial: %lf\n", time_par_red_1,
+             time_par_red_2, time_par_red_serial);
+    ASSERT_TRUE(passed_par_red);
+  }
+  {
+    TestScanFunctor f(N);
+    f.time_par_scan();
+    time_par_scan_1 = f.time_par_scan();
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    kokkos_impl_cuda_set_serial_execution(true);
+#endif
+    time_par_scan_serial = f.time_par_scan();
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+    kokkos_impl_cuda_set_serial_execution(false);
+#endif
+    time_par_scan_2 = f.time_par_scan();
+
+    bool passed_par_scan =
+#ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
+        (time_par_scan_serial > time_par_scan_1 * 2.0) &&
+        (time_par_scan_serial > time_par_scan_2 * 2.0);
+#else
+        (time_par_scan_serial < time_par_scan_1 * 2.0) &&
+        (time_par_scan_serial < time_par_scan_2 * 2.0);
+#endif
+    if (!passed_par_scan)
+      printf("Time Scan1: %lf Scan2: %lf ScanSerial: %lf\n", time_par_scan_1,
+             time_par_scan_2, time_par_scan_serial);
+    ASSERT_TRUE(passed_par_scan);
+  }
+}
+
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_DeepCopyAlignment.cpp
index f28a6fcbe9e618eed1be4169fcc217d5b25bcca3..16793abe0824f6a7cafb4ecac4fa32dde6be00e8 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_DeepCopyAlignment.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_DeepCopyAlignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,6 @@
 */
 
 #include <cuda/TestCuda_Category.hpp>
-#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) 
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
 #include <TestDeepCopy.hpp>
 #endif
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_FunctorAnalysis.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_FunctorAnalysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..036806d8db4dad56efbf9189a7c54cfe5c8e390f
--- /dev/null
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_FunctorAnalysis.cpp
@@ -0,0 +1,47 @@
+
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <cuda/TestCuda_Category.hpp>
+#include <TestFunctorAnalysis.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Init.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Init.cpp
index 97e2867ddc05f8a4bb3197fca88c19b850b18d76..bc5f6cf9e838eab816041830e4f3514cb9fd06bb 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Init.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Init.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,7 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestInit.hpp>
-#include<TestCompilerMacros.hpp>
-#include<TestPolicyConstruction.hpp>
-
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestInit.hpp>
+#include <TestCompilerMacros.hpp>
+#include <TestPolicyConstruction.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Init.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Init.cpp
index 963a7194b3b89b17b18181d21597cfb7a38d968e..6073b9cd7eff97cf67122086031ff95c00304a8c 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Init.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Init.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,39 +48,38 @@
 namespace Test {
 
 __global__ void offset(int* p) {
-  int idx = blockIdx.x*blockDim.x + threadIdx.x;
-  if(idx<100) {
-    p[idx]+=idx;
+  int idx = blockIdx.x * blockDim.x + threadIdx.x;
+  if (idx < 100) {
+    p[idx] += idx;
   }
 }
 
-// Test whether allocations survive Kokkos initialize/finalize if done via Raw Cuda.
-TEST_F( cuda, raw_cuda_interop )
-{
+// Test whether allocations survive Kokkos initialize/finalize if done via Raw
+// Cuda.
+TEST(cuda, raw_cuda_interop) {
   int* p;
-  cudaMalloc(&p,sizeof(int)*100);
-  Kokkos::InitArguments arguments{-1,-1,-1, false};
+  cudaMalloc(&p, sizeof(int) * 100);
+  Kokkos::InitArguments arguments{-1, -1, -1, false};
   Kokkos::initialize(arguments);
 
-  Kokkos::View<int*,Kokkos::MemoryTraits<Kokkos::Unmanaged>>
-    v(p,100);
-  Kokkos::deep_copy(v,5);
+  Kokkos::View<int*, Kokkos::MemoryTraits<Kokkos::Unmanaged>> v(p, 100);
+  Kokkos::deep_copy(v, 5);
 
   Kokkos::finalize();
 
-  offset<<<100,64>>>(p);
-  CUDA_SAFE_CALL( cudaDeviceSynchronize());
+  offset<<<100, 64>>>(p);
+  CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
   int* h_p = new int[100];
-  cudaMemcpy( h_p , p , sizeof(int)*100 , cudaMemcpyDefault );
-  CUDA_SAFE_CALL( cudaDeviceSynchronize());
-  int64_t sum = 0;
+  cudaMemcpy(h_p, p, sizeof(int) * 100, cudaMemcpyDefault);
+  CUDA_SAFE_CALL(cudaDeviceSynchronize());
+  int64_t sum        = 0;
   int64_t sum_expect = 0;
-  for(int i=0; i<100; i++) {
+  for (int i = 0; i < 100; i++) {
     sum += h_p[i];
-    sum_expect += 5+i;
+    sum_expect += 5 + i;
   }
 
-  ASSERT_EQ(sum,sum_expect);
-}
+  ASSERT_EQ(sum, sum_expect);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Streams.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Streams.cpp
index 4969e27040ccfafde5a7c0ececbb8d51b25a705e..3753ad9aec1f0f6dba19aadd435391ede4c964da 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Streams.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_InterOp_Streams.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,134 +48,161 @@
 namespace Test {
 
 __global__ void offset_streams(int* p) {
-  int idx = blockIdx.x*blockDim.x + threadIdx.x;
-  if(idx<100) {
-    p[idx]+=idx;
+  int idx = blockIdx.x * blockDim.x + threadIdx.x;
+  if (idx < 100) {
+    p[idx] += idx;
   }
 }
 
 namespace {
-  struct FunctorRange {
-    Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a;
-    FunctorRange(Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a_):a(a_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const int i) const {
-      a(i)+=1;
-    }
-  };
-  struct FunctorRangeReduce {
-    Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a;
-    FunctorRangeReduce(Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a_):a(a_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const int i, int& lsum) const {
-      lsum += a(i);
-    }
-  };
-  struct FunctorMDRange {
-    Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a;
-    FunctorMDRange(Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a_):a(a_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const int i, const int j) const {
-      a(i*10+j)+=1;
-    }
-  };
-  struct FunctorMDRangeReduce {
-    Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a;
-    FunctorMDRangeReduce(Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a_):a(a_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const int i, const int j, int& lsum) const {
-      lsum += a(i*10+j);
-    }
-  };
-  struct FunctorTeam {
-    Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a;
-    FunctorTeam(Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a_):a(a_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const Kokkos::TeamPolicy<Kokkos::Cuda>::member_type& team) const {
-      int i = team.league_rank();
-      Kokkos::parallel_for(Kokkos::TeamThreadRange(team,10),[&](const int j){
-        a(i*10+j)+=1;
-      });
-    }
-  };
-
-  struct FunctorTeamReduce {
-    Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a;
-    FunctorTeamReduce(Kokkos::View<int*,Kokkos::CudaSpace,Kokkos::MemoryTraits<Kokkos::Unmanaged>> a_):a(a_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator() (const Kokkos::TeamPolicy<Kokkos::Cuda>::member_type& team, int& lsum) const {
-      int i = team.league_rank();
-      int team_sum;
-      Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,10),[&](const int j, int& tsum){
-        tsum += a(i*10+j);
-      },team_sum);
-      Kokkos::single(Kokkos::PerTeam(team),[&]() {
-        lsum += team_sum;
-      });
-    }
-  };
-}
+struct FunctorRange {
+  Kokkos::View<int*, Kokkos::CudaSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+      a;
+  FunctorRange(Kokkos::View<int*, Kokkos::CudaSpace,
+                            Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+                   a_)
+      : a(a_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int i) const { a(i) += 1; }
+};
+struct FunctorRangeReduce {
+  Kokkos::View<int*, Kokkos::CudaSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+      a;
+  FunctorRangeReduce(Kokkos::View<int*, Kokkos::CudaSpace,
+                                  Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+                         a_)
+      : a(a_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int i, int& lsum) const { lsum += a(i); }
+};
+struct FunctorMDRange {
+  Kokkos::View<int*, Kokkos::CudaSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+      a;
+  FunctorMDRange(Kokkos::View<int*, Kokkos::CudaSpace,
+                              Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+                     a_)
+      : a(a_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int i, const int j) const { a(i * 10 + j) += 1; }
+};
+struct FunctorMDRangeReduce {
+  Kokkos::View<int*, Kokkos::CudaSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+      a;
+  FunctorMDRangeReduce(Kokkos::View<int*, Kokkos::CudaSpace,
+                                    Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+                           a_)
+      : a(a_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int i, const int j, int& lsum) const {
+    lsum += a(i * 10 + j);
+  }
+};
+struct FunctorTeam {
+  Kokkos::View<int*, Kokkos::CudaSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+      a;
+  FunctorTeam(Kokkos::View<int*, Kokkos::CudaSpace,
+                           Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+                  a_)
+      : a(a_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(
+      const Kokkos::TeamPolicy<Kokkos::Cuda>::member_type& team) const {
+    int i = team.league_rank();
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(team, 10),
+                         [&](const int j) { a(i * 10 + j) += 1; });
+  }
+};
+
+struct FunctorTeamReduce {
+  Kokkos::View<int*, Kokkos::CudaSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+      a;
+  FunctorTeamReduce(Kokkos::View<int*, Kokkos::CudaSpace,
+                                 Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+                        a_)
+      : a(a_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const Kokkos::TeamPolicy<Kokkos::Cuda>::member_type& team,
+                  int& lsum) const {
+    int i = team.league_rank();
+    int team_sum;
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(team, 10),
+        [&](const int j, int& tsum) { tsum += a(i * 10 + j); }, team_sum);
+    Kokkos::single(Kokkos::PerTeam(team), [&]() { lsum += team_sum; });
+  }
+};
+}  // namespace
 
 // Test Interoperability with Cuda Streams
-TEST_F( cuda, raw_cuda_streams )
-{
+TEST(cuda, raw_cuda_streams) {
   cudaStream_t stream;
   cudaStreamCreate(&stream);
-  Kokkos::InitArguments arguments{-1,-1,-1, false};
+  Kokkos::InitArguments arguments{-1, -1, -1, false};
   Kokkos::initialize(arguments);
   int* p;
-  cudaMalloc(&p,sizeof(int)*100);
+  cudaMalloc(&p, sizeof(int) * 100);
 
   {
-  Kokkos::Cuda cuda0(stream);
-  Kokkos::View<int*,Kokkos::CudaSpace>
-    v(p,100);
-  Kokkos::deep_copy(cuda0,v,5);
-  int sum;
-
-  Kokkos::parallel_for("Test::cuda::raw_cuda_stream::Range",
-      Kokkos::RangePolicy<Kokkos::Cuda>(cuda0,0,100),FunctorRange(v));
-  Kokkos::parallel_reduce("Test::cuda::raw_cuda_stream::RangeReduce",
-      Kokkos::RangePolicy<Kokkos::Cuda,Kokkos::LaunchBounds<128,2>>(cuda0,0,100),FunctorRangeReduce(v),sum);
-  cuda0.fence();
-  ASSERT_EQ(600,sum);
-
-  Kokkos::parallel_for("Test::cuda::raw_cuda_stream::MDRange",
-      Kokkos::MDRangePolicy<Kokkos::Cuda,Kokkos::Rank<2>>(cuda0,{0,0},{10,10}),FunctorMDRange(v));
-  Kokkos::parallel_reduce("Test::cuda::raw_cuda_stream::MDRangeReduce",
-      Kokkos::MDRangePolicy<Kokkos::Cuda,Kokkos::Rank<2>,Kokkos::LaunchBounds<128,2>>(cuda0,{0,0},{10,10}),FunctorMDRangeReduce(v),sum);
-  cuda0.fence();
-  ASSERT_EQ(700,sum);
-
-  Kokkos::parallel_for("Test::cuda::raw_cuda_stream::Team",
-      Kokkos::TeamPolicy<Kokkos::Cuda>(cuda0,10,10),FunctorTeam(v));
-  Kokkos::parallel_reduce("Test::cuda::raw_cuda_stream::Team",
-      Kokkos::TeamPolicy<Kokkos::Cuda,Kokkos::LaunchBounds<128,2>>(cuda0,10,10),FunctorTeamReduce(v),sum);
-  cuda0.fence();
-  ASSERT_EQ(800,sum);
-
+    Kokkos::Cuda cuda0(stream);
+    Kokkos::View<int*, Kokkos::CudaSpace> v(p, 100);
+    Kokkos::deep_copy(cuda0, v, 5);
+    int sum;
+
+    Kokkos::parallel_for("Test::cuda::raw_cuda_stream::Range",
+                         Kokkos::RangePolicy<Kokkos::Cuda>(cuda0, 0, 100),
+                         FunctorRange(v));
+    Kokkos::parallel_reduce(
+        "Test::cuda::raw_cuda_stream::RangeReduce",
+        Kokkos::RangePolicy<Kokkos::Cuda, Kokkos::LaunchBounds<128, 2>>(cuda0,
+                                                                        0, 100),
+        FunctorRangeReduce(v), sum);
+    cuda0.fence();
+    ASSERT_EQ(600, sum);
+
+    Kokkos::parallel_for("Test::cuda::raw_cuda_stream::MDRange",
+                         Kokkos::MDRangePolicy<Kokkos::Cuda, Kokkos::Rank<2>>(
+                             cuda0, {0, 0}, {10, 10}),
+                         FunctorMDRange(v));
+    Kokkos::parallel_reduce("Test::cuda::raw_cuda_stream::MDRangeReduce",
+                            Kokkos::MDRangePolicy<Kokkos::Cuda, Kokkos::Rank<2>,
+                                                  Kokkos::LaunchBounds<128, 2>>(
+                                cuda0, {0, 0}, {10, 10}),
+                            FunctorMDRangeReduce(v), sum);
+    cuda0.fence();
+    ASSERT_EQ(700, sum);
+
+    Kokkos::parallel_for("Test::cuda::raw_cuda_stream::Team",
+                         Kokkos::TeamPolicy<Kokkos::Cuda>(cuda0, 10, 10),
+                         FunctorTeam(v));
+    Kokkos::parallel_reduce(
+        "Test::cuda::raw_cuda_stream::Team",
+        Kokkos::TeamPolicy<Kokkos::Cuda, Kokkos::LaunchBounds<128, 2>>(cuda0,
+                                                                       10, 10),
+        FunctorTeamReduce(v), sum);
+    cuda0.fence();
+    ASSERT_EQ(800, sum);
   }
   Kokkos::finalize();
-  offset_streams<<<100,64,0,stream>>>(p);
-  CUDA_SAFE_CALL( cudaDeviceSynchronize());
+  offset_streams<<<100, 64, 0, stream>>>(p);
+  CUDA_SAFE_CALL(cudaDeviceSynchronize());
   cudaStreamDestroy(stream);
 
   int* h_p = new int[100];
-  cudaMemcpy( h_p , p , sizeof(int)*100 , cudaMemcpyDefault );
-  CUDA_SAFE_CALL( cudaDeviceSynchronize());
-  int64_t sum = 0;
+  cudaMemcpy(h_p, p, sizeof(int) * 100, cudaMemcpyDefault);
+  CUDA_SAFE_CALL(cudaDeviceSynchronize());
+  int64_t sum        = 0;
   int64_t sum_expect = 0;
-  for(int i=0; i<100; i++) {
+  for (int i = 0; i < 100; i++) {
     sum += h_p[i];
-    sum_expect += 8+i;
+    sum_expect += 8 + i;
   }
 
-  ASSERT_EQ(sum,sum_expect);
-}
+  ASSERT_EQ(sum, sum_expect);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_LocalDeepCopy.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_LocalDeepCopy.cpp
index 1a9940ed70cfd5b9ce1841567884f69dc971d5ef..20e32ff3847382de6cff03a67e3a0b894d196f07 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_LocalDeepCopy.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_LocalDeepCopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCuda_Category.hpp>
 #include <TestLocalDeepCopy.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_a.cpp
index 8114a32b0f585fb10dc1e727d8afcd756ceec078..5e339b9a0e2af112208a7b3aede5ab4ad88d5f9a 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_b.cpp
index 9fb92b7e31044c8062f397f85be2bd4845b34639..16974ed264f313a3b6f1334e07ecd416a8ca5242 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_c.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_c.cpp
index bc3d62ee1b471a40134a0b4a1a44c279daefcc5a..ebc4dfee64eafdc7d03c5f13de9672b96aa27e6e 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_d.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_d.cpp
index 6d9069119a2cbfbe1e899343f81e1c36c124b6e3..2e7392613e63d411e01e49b3baf237f205b6e4e2 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_e.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_e.cpp
index 497ffbdccd0c85d853a75790af4f05c83a7246c5..92ec05a47b755716da1c69228ded9393c8035705 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Other.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Other.cpp
index 788e458eea8875fefc628b78afbe4311554fd21c..155226178743a6f2baaa8ad93cf2988ffb2e25b2 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Other.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Other.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,12 +43,12 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestTemplateMetaFunctions.hpp>
-#include<TestAggregate.hpp>
-#include<TestMemoryPool.hpp>
-#include<TestCXX11.hpp>
-#include<TestTile.hpp>
+#include <cuda/TestCuda_Category.hpp>
+#include <TestTemplateMetaFunctions.hpp>
+#include <TestAggregate.hpp>
+#include <TestMemoryPool.hpp>
+#include <TestCXX11.hpp>
+#include <TestTile.hpp>
 
-#include<TestViewCtorPropEmbeddedDim.hpp>
-#include<TestViewLayoutTiled.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
+#include <TestViewLayoutTiled.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_RangePolicy.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_RangePolicy.cpp
index b671929d848936fef5144f1602277c88a4a6d968..730978c35edf683548aa69f55c69fb828f2c4af5 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_RangePolicy.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_RangePolicy.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestRange.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestRange.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_a.cpp
index c26b8a63e214815aabae331a1340739a0f2617e8..ab4446f96439a36fe48348dcc2e5c0ddb386af47 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_b.cpp
index 17959930d3191a3c86e6aa6a5178378dd6b63771..4c7f1118213c3394fda8c2c8ddd118ba2d957c7b 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_c.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_c.cpp
index add28b5b2b563d9789aec565b335f78b8a9623f2..0e10c7093bc12ab20e67a502bcddbf331cdd9c04 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_c.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_d.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_d.cpp
index 5fb1c1f2e38d6697e68201f68b9dc1fff9718cbc..ba2ae62330798b77c69d38e169d2bd6124f15811 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_d.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Reducers_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions.cpp
index fe719c422ea094431b705135d853924f5e4417ba..afa361c48b916e2dd3733da3abb620677b728bd1 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions_DeviceView.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions_DeviceView.cpp
index 5b340901493c8cdd64779355b80e6fc2a3bbaa65..e2abf881a97f8a840e04a873e83c0d6fe0835f55 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions_DeviceView.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Reductions_DeviceView.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Scan.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Scan.cpp
index 57f9857a8723a19330cab94ed37a5892528d1f00..e8364464ee2d6734ea6f8c4b66639c8e4e25de94 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Scan.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Scan.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestScan.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestScan.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SharedAlloc.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SharedAlloc.cpp
index fc0b02505deb51841fc0507b02ce21c9246d32cd..a09ea3f1b8bce61f20f0edbfb85d919914cabc2b 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< Kokkos::CudaSpace, Kokkos::DefaultHostExecutionSpace >();
+TEST(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<Kokkos::CudaSpace, Kokkos::DefaultHostExecutionSpace>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Spaces.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Spaces.cpp
index afe18bdad4b0155eed54d5dc0723d2ef0a6640cb..800d589e94a044a41b92e9daa90285cda6e4e7cf 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Spaces.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Spaces.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,193 +47,244 @@
 
 namespace Test {
 
-__global__
-void test_abort()
-{
-  Kokkos::abort( "test_abort" );
-}
+__global__ void test_abort() { Kokkos::abort("test_abort"); }
 
-__global__
-void test_cuda_spaces_int_value( int * ptr )
-{
-  if ( *ptr == 42 ) { *ptr = 2 * 42; }
+__global__ void test_cuda_spaces_int_value(int *ptr) {
+  if (*ptr == 42) {
+    *ptr = 2 * 42;
+  }
 }
 
-TEST_F( cuda, space_access )
-{
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::HostSpace >::assignable, "" );
+TEST(cuda, space_access) {
+  static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                                Kokkos::HostSpace>::assignable,
+                "");
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::CudaHostPinnedSpace >::assignable, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                      Kokkos::CudaHostPinnedSpace>::assignable,
+      "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::CudaSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                                 Kokkos::CudaSpace>::assignable,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::CudaSpace >::accessible, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                                 Kokkos::CudaSpace>::accessible,
+                "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::CudaUVMSpace >::assignable, "" );
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                       Kokkos::CudaUVMSpace>::assignable,
+      "");
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::CudaUVMSpace >::accessible, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                      Kokkos::CudaUVMSpace>::accessible,
+      "");
 
   //--------------------------------------
 
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaSpace, Kokkos::CudaSpace >::assignable, "" );
+  static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                                Kokkos::CudaSpace>::assignable,
+                "");
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaSpace, Kokkos::CudaUVMSpace >::assignable, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                      Kokkos::CudaUVMSpace>::assignable,
+      "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaSpace, Kokkos::CudaHostPinnedSpace >::assignable, "" );
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                       Kokkos::CudaHostPinnedSpace>::assignable,
+      "");
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaSpace, Kokkos::CudaHostPinnedSpace >::accessible, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                      Kokkos::CudaHostPinnedSpace>::accessible,
+      "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaSpace, Kokkos::HostSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                                 Kokkos::HostSpace>::assignable,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaSpace, Kokkos::HostSpace >::accessible, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                                 Kokkos::HostSpace>::accessible,
+                "");
 
   //--------------------------------------
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace, Kokkos::CudaUVMSpace >::assignable, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                      Kokkos::CudaUVMSpace>::assignable,
+      "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace, Kokkos::CudaSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                                 Kokkos::CudaSpace>::assignable,
+                "");
 
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace, Kokkos::CudaSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                                Kokkos::CudaSpace>::accessible,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace, Kokkos::HostSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                                 Kokkos::HostSpace>::assignable,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace, Kokkos::HostSpace >::accessible, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                                 Kokkos::HostSpace>::accessible,
+                "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace, Kokkos::CudaHostPinnedSpace >::assignable, "" );
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                       Kokkos::CudaHostPinnedSpace>::assignable,
+      "");
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaUVMSpace, Kokkos::CudaHostPinnedSpace >::accessible, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                      Kokkos::CudaHostPinnedSpace>::accessible,
+      "");
 
   //--------------------------------------
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace, Kokkos::CudaHostPinnedSpace >::assignable, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                      Kokkos::CudaHostPinnedSpace>::assignable,
+      "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace, Kokkos::HostSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                                 Kokkos::HostSpace>::assignable,
+                "");
 
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace, Kokkos::HostSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                                Kokkos::HostSpace>::accessible,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace, Kokkos::CudaSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                                 Kokkos::CudaSpace>::assignable,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace, Kokkos::CudaSpace >::accessible, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                                 Kokkos::CudaSpace>::accessible,
+                "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace, Kokkos::CudaUVMSpace >::assignable, "" );
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                       Kokkos::CudaUVMSpace>::assignable,
+      "");
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::CudaHostPinnedSpace, Kokkos::CudaUVMSpace >::accessible, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                      Kokkos::CudaUVMSpace>::accessible,
+      "");
 
   //--------------------------------------
 
   static_assert(
-    ! Kokkos::Impl::SpaceAccessibility< Kokkos::Cuda, Kokkos::HostSpace >::accessible, "" );
+      !Kokkos::Impl::SpaceAccessibility<Kokkos::Cuda,
+                                        Kokkos::HostSpace>::accessible,
+      "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::Cuda, Kokkos::CudaSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<Kokkos::Cuda,
+                                                 Kokkos::CudaSpace>::accessible,
+                "");
 
   static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::Cuda, Kokkos::CudaUVMSpace >::accessible, "" );
+      Kokkos::Impl::SpaceAccessibility<Kokkos::Cuda,
+                                       Kokkos::CudaUVMSpace>::accessible,
+      "");
 
   static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::Cuda, Kokkos::CudaHostPinnedSpace >::accessible, "" );
+      Kokkos::Impl::SpaceAccessibility<Kokkos::Cuda,
+                                       Kokkos::CudaHostPinnedSpace>::accessible,
+      "");
 
   static_assert(
-    ! Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, Kokkos::CudaSpace >::accessible, "" );
+      !Kokkos::Impl::SpaceAccessibility<Kokkos::HostSpace,
+                                        Kokkos::CudaSpace>::accessible,
+      "");
 
   static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, Kokkos::CudaUVMSpace >::accessible, "" );
+      Kokkos::Impl::SpaceAccessibility<Kokkos::HostSpace,
+                                       Kokkos::CudaUVMSpace>::accessible,
+      "");
 
   static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, Kokkos::CudaHostPinnedSpace >::accessible, "" );
+      Kokkos::Impl::SpaceAccessibility<Kokkos::HostSpace,
+                                       Kokkos::CudaHostPinnedSpace>::accessible,
+      "");
 
-  static_assert(
-    std::is_same< Kokkos::Impl::HostMirror< Kokkos::CudaSpace >::Space
-                , Kokkos::HostSpace >::value, "" );
+  static_assert(std::is_same<Kokkos::Impl::HostMirror<Kokkos::CudaSpace>::Space,
+                             Kokkos::HostSpace>::value,
+                "");
 
   static_assert(
-    std::is_same< Kokkos::Impl::HostMirror< Kokkos::CudaUVMSpace >::Space
-                , Kokkos::Device< Kokkos::HostSpace::execution_space
-                                , Kokkos::CudaUVMSpace > >::value, "" );
+      std::is_same<Kokkos::Impl::HostMirror<Kokkos::CudaUVMSpace>::Space,
+                   Kokkos::Device<Kokkos::HostSpace::execution_space,
+                                  Kokkos::CudaUVMSpace>>::value,
+      "");
 
   static_assert(
-    std::is_same< Kokkos::Impl::HostMirror< Kokkos::CudaHostPinnedSpace >::Space
-                , Kokkos::CudaHostPinnedSpace >::value, "" );
+      std::is_same<Kokkos::Impl::HostMirror<Kokkos::CudaHostPinnedSpace>::Space,
+                   Kokkos::CudaHostPinnedSpace>::value,
+      "");
 
-  static_assert(
-    std::is_same< Kokkos::Device< Kokkos::HostSpace::execution_space
-                                , Kokkos::CudaUVMSpace >
-                , Kokkos::Device< Kokkos::HostSpace::execution_space
-                                , Kokkos::CudaUVMSpace > >::value, "" );
+  static_assert(std::is_same<Kokkos::Device<Kokkos::HostSpace::execution_space,
+                                            Kokkos::CudaUVMSpace>,
+                             Kokkos::Device<Kokkos::HostSpace::execution_space,
+                                            Kokkos::CudaUVMSpace>>::value,
+                "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility
-      < Kokkos::Impl::HostMirror< Kokkos::Cuda >::Space
-      , Kokkos::HostSpace
-      >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::Impl::HostMirror<Kokkos::Cuda>::Space,
+                    Kokkos::HostSpace>::accessible,
+                "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility
-      < Kokkos::Impl::HostMirror< Kokkos::CudaSpace >::Space
-      , Kokkos::HostSpace
-      >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::Impl::HostMirror<Kokkos::CudaSpace>::Space,
+                    Kokkos::HostSpace>::accessible,
+                "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility
-      < Kokkos::Impl::HostMirror< Kokkos::CudaUVMSpace >::Space
-      , Kokkos::HostSpace
-      >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::Impl::HostMirror<Kokkos::CudaUVMSpace>::Space,
+                    Kokkos::HostSpace>::accessible,
+                "");
 
   static_assert(
-    Kokkos::Impl::SpaceAccessibility
-      < Kokkos::Impl::HostMirror< Kokkos::CudaHostPinnedSpace >::Space
-      , Kokkos::HostSpace
-      >::accessible, "" );
+      Kokkos::Impl::SpaceAccessibility<
+          Kokkos::Impl::HostMirror<Kokkos::CudaHostPinnedSpace>::Space,
+          Kokkos::HostSpace>::accessible,
+      "");
+#ifdef KOKKOS_ENABLE_CUDA_UVM
+  using uvm_view = Kokkos::View<double *, Kokkos::CudaUVMSpace>;
+  static_assert(std::is_same<uvm_view::HostMirror::execution_space,
+                             Kokkos::DefaultHostExecutionSpace>::value,
+                "Verify HostMirror execution space is really a host space");
+#endif
 }
 
-TEST_F( cuda, uvm )
-{
-  if ( Kokkos::CudaUVMSpace::available() ) {
-    int * uvm_ptr = (int*) Kokkos::kokkos_malloc< Kokkos::CudaUVMSpace >( "uvm_ptr", sizeof( int ) );
+TEST(cuda, uvm) {
+  if (Kokkos::CudaUVMSpace::available()) {
+    int *uvm_ptr = (int *)Kokkos::kokkos_malloc<Kokkos::CudaUVMSpace>(
+        "uvm_ptr", sizeof(int));
 
     *uvm_ptr = 42;
 
     Kokkos::Cuda().fence();
-    test_cuda_spaces_int_value<<< 1, 1 >>>( uvm_ptr );
+    test_cuda_spaces_int_value<<<1, 1>>>(uvm_ptr);
     Kokkos::Cuda().fence();
 
-    EXPECT_EQ( *uvm_ptr, int( 2 * 42 ) );
+    EXPECT_EQ(*uvm_ptr, int(2 * 42));
 
-    Kokkos::kokkos_free< Kokkos::CudaUVMSpace >( uvm_ptr );
+    Kokkos::kokkos_free<Kokkos::CudaUVMSpace>(uvm_ptr);
   }
 }
 
 /* Removing UVM Allocs Test due to added time to complete overall unit test
- * The issue verified with this unit test appears to no longer be an 
+ * The issue verified with this unit test appears to no longer be an
  * problem.  Refer to github issue 1880 for more details
  *
-TEST_F( cuda, uvm_num_allocs )
+TEST( cuda, uvm_num_allocs )
 {
   // The max number of UVM allocations allowed is 65536.
   #define MAX_NUM_ALLOCS 65536
@@ -251,21 +303,22 @@ TEST_F( cuda, uvm_num_allocs )
           // Kokkos will throw a runtime exception if an attempt is made to
           // allocate more than the maximum number of uvm allocations.
 
-          // In this test, the max num of allocs occurs when i = MAX_NUM_ALLOCS - 1
+          // In this test, the max num of allocs occurs when i = MAX_NUM_ALLOCS
+- 1
           // since the 'outer' view counts as one UVM allocation, leaving
           // 65535 possible UVM allocations, that is 'i in [0, 65535)'.
 
           // The test will catch the exception thrown in this case and continue.
 
           if ( i == ( MAX_NUM_ALLOCS - 1 ) ) {
-            EXPECT_ANY_THROW( { view_allocs_test( i ) = view_type( "inner_view", 1 ); } );
+            EXPECT_ANY_THROW( { view_allocs_test( i ) = view_type( "inner_view",
+1 ); } );
           }
           else {
             if ( i < MAX_NUM_ALLOCS - 1000 ) {
-              EXPECT_NO_THROW( { view_allocs_test( i ) = view_type( "inner_view", 1 ); } );
-            } else { // This might or might not throw depending on compilation options.
-              try {
-                view_allocs_test( i ) = view_type( "inner_view", 1 );
+              EXPECT_NO_THROW( { view_allocs_test( i ) = view_type(
+"inner_view", 1 ); } ); } else { // This might or might not throw depending on
+compilation options. try { view_allocs_test( i ) = view_type( "inner_view", 1 );
               }
               catch ( ... ) {}
             }
@@ -294,11 +347,11 @@ TEST_F( cuda, uvm_num_allocs )
 }
 */
 
-template< class MemSpace, class ExecSpace >
+template <class MemSpace, class ExecSpace>
 struct TestViewCudaAccessible {
   enum { N = 1000 };
 
-  using V = Kokkos::View< double*, MemSpace >;
+  using V = Kokkos::View<double *, MemSpace>;
 
   V m_base;
 
@@ -306,46 +359,48 @@ struct TestViewCudaAccessible {
   struct TagTest {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagInit &, const int i ) const { m_base[i] = i + 1; }
+  void operator()(const TagInit &, const int i) const { m_base[i] = i + 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagTest &, const int i, long & error_count ) const
-  { if ( m_base[i] != i + 1 ) ++error_count; }
+  void operator()(const TagTest &, const int i, long &error_count) const {
+    if (m_base[i] != i + 1) ++error_count;
+  }
 
-  TestViewCudaAccessible()
-    : m_base( "base", N )
-    {}
+  TestViewCudaAccessible() : m_base("base", N) {}
 
-  static void run()
-  {
+  static void run() {
     TestViewCudaAccessible self;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename MemSpace::execution_space, TagInit >( 0, N ), self );
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<typename MemSpace::execution_space, TagInit>(0, N),
+        self);
     typename MemSpace::execution_space().fence();
 
     // Next access is a different execution space, must complete prior kernel.
     long error_count = -1;
-    Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace, TagTest >( 0, N ), self, error_count );
-    EXPECT_EQ( error_count, 0 );
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, TagTest>(0, N), self,
+                            error_count);
+    EXPECT_EQ(error_count, 0);
   }
 };
 
-TEST_F( cuda, impl_view_accessible )
-{
-  TestViewCudaAccessible< Kokkos::CudaSpace, Kokkos::Cuda >::run();
+TEST(cuda, impl_view_accessible) {
+  TestViewCudaAccessible<Kokkos::CudaSpace, Kokkos::Cuda>::run();
 
-  TestViewCudaAccessible< Kokkos::CudaUVMSpace, Kokkos::Cuda >::run();
-  TestViewCudaAccessible< Kokkos::CudaUVMSpace, Kokkos::HostSpace::execution_space >::run();
+  TestViewCudaAccessible<Kokkos::CudaUVMSpace, Kokkos::Cuda>::run();
+  TestViewCudaAccessible<Kokkos::CudaUVMSpace,
+                         Kokkos::HostSpace::execution_space>::run();
 
-  TestViewCudaAccessible< Kokkos::CudaHostPinnedSpace, Kokkos::Cuda >::run();
-  TestViewCudaAccessible< Kokkos::CudaHostPinnedSpace, Kokkos::HostSpace::execution_space >::run();
+  TestViewCudaAccessible<Kokkos::CudaHostPinnedSpace, Kokkos::Cuda>::run();
+  TestViewCudaAccessible<Kokkos::CudaHostPinnedSpace,
+                         Kokkos::HostSpace::execution_space>::run();
 }
 
-template< class MemSpace >
+template <class MemSpace>
 struct TestViewCudaTexture {
   enum { N = 1000 };
 
-  using V = Kokkos::View< double*, MemSpace >;
-  using T = Kokkos::View< const double*, MemSpace, Kokkos::MemoryRandomAccess >;
+  using V = Kokkos::View<double *, MemSpace>;
+  using T = Kokkos::View<const double *, MemSpace, Kokkos::MemoryRandomAccess>;
 
   V m_base;
   T m_tex;
@@ -354,38 +409,38 @@ struct TestViewCudaTexture {
   struct TagTest {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagInit &, const int i ) const { m_base[i] = i + 1; }
+  void operator()(const TagInit &, const int i) const { m_base[i] = i + 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagTest &, const int i, long & error_count ) const
-  { if ( m_tex[i] != i + 1 ) ++error_count; }
+  void operator()(const TagTest &, const int i, long &error_count) const {
+    if (m_tex[i] != i + 1) ++error_count;
+  }
 
-  TestViewCudaTexture()
-    : m_base( "base", N )
-    , m_tex( m_base )
-    {}
+  TestViewCudaTexture() : m_base("base", N), m_tex(m_base) {}
 
-  static void run()
-  {
-    EXPECT_TRUE( ( std::is_same< typename V::reference_type, double & >::value ) );
-    EXPECT_TRUE( ( std::is_same< typename T::reference_type, const double >::value ) );
+  static void run() {
+    EXPECT_TRUE((std::is_same<typename V::reference_type, double &>::value));
+    EXPECT_TRUE(
+        (std::is_same<typename T::reference_type, const double>::value));
 
-    EXPECT_TRUE(  V::reference_type_is_lvalue_reference ); // An ordinary view.
-    EXPECT_FALSE( T::reference_type_is_lvalue_reference ); // Texture fetch returns by value.
+    EXPECT_TRUE(V::reference_type_is_lvalue_reference);   // An ordinary view.
+    EXPECT_FALSE(T::reference_type_is_lvalue_reference);  // Texture fetch
+                                                          // returns by value.
 
     TestViewCudaTexture self;
-    Kokkos::parallel_for( Kokkos::RangePolicy< Kokkos::Cuda, TagInit >( 0, N ), self );
+    Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda, TagInit>(0, N),
+                         self);
 
     long error_count = -1;
-    Kokkos::parallel_reduce( Kokkos::RangePolicy< Kokkos::Cuda, TagTest >( 0, N ), self, error_count );
-    EXPECT_EQ( error_count, 0 );
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Kokkos::Cuda, TagTest>(0, N),
+                            self, error_count);
+    EXPECT_EQ(error_count, 0);
   }
 };
 
-TEST_F( cuda, impl_view_texture )
-{
-  TestViewCudaTexture< Kokkos::CudaSpace >::run();
-  TestViewCudaTexture< Kokkos::CudaUVMSpace >::run();
+TEST(cuda, impl_view_texture) {
+  TestViewCudaTexture<Kokkos::CudaSpace>::run();
+  TestViewCudaTexture<Kokkos::CudaUVMSpace>::run();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_a.cpp
index 81f83c105cec81d43943bfb2f19f07d6d8f0a2be..6ac2fa8f08386acf42348378522bdfe5ac143eb3 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,66 +47,56 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_left )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_left) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutLeft, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_right )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutRight, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_right) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutRight, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_stride )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutStride, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_stride) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutStride, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_assign_strided )
-{
-  TestViewSubview::test_1d_strided_assignment< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_assign_strided) {
+  TestViewSubview::test_1d_strided_assignment<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_0 )
-{
-  TestViewSubview::test_left_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_0) {
+  TestViewSubview::test_left_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_1 )
-{
-  TestViewSubview::test_left_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_1) {
+  TestViewSubview::test_left_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_2 )
-{
-  TestViewSubview::test_left_2< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_2) {
+  TestViewSubview::test_left_2<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_3 )
-{
-  TestViewSubview::test_left_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_3) {
+  TestViewSubview::test_left_3<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_0 )
-{
-  TestViewSubview::test_right_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_0) {
+  TestViewSubview::test_right_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_1 )
-{
-  TestViewSubview::test_right_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_1) {
+  TestViewSubview::test_right_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_3 )
-{
-  TestViewSubview::test_right_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_3) {
+  TestViewSubview::test_right_3<TEST_EXECSPACE>();
 }
 
-TEST_F(TEST_CATEGORY, view_static_tests)
-{
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutLeft>()();
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutRight>()();
+TEST(TEST_CATEGORY, view_static_tests) {
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutLeft>()();
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutRight>()();
   TestViewSubview::TestExtentsStaticTests<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_b.cpp
index a2018fc5c8f480bbe26266db432050b0b8fdb6a9..c53904559ce105f95486c43e1a6a2c97c9a46a70 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,18 +47,20 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_layoutleft_to_layoutleft )
-{
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutleft_to_layoutleft) {
+  TestViewSubview::test_layoutleft_to_layoutleft<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_layoutright_to_layoutright )
-{
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutright_to_layoutright) {
+  TestViewSubview::test_layoutright_to_layoutright<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c01.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c01.cpp
index 946de0e111db0b2983b1f9cce599a6864266a57c..2a1286281a33a743de6ef2c42ea764a439285d39 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_1d_assign) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c02.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c02.cpp
index 7a1c895583336dac104631ece45145aa3d3b59f6..d34a3ab59ea43d02c32cc8cc1de124589d6ad072 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_atomic )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_atomic) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE,
+                                  Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c03.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c03.cpp
index 8c27d66a835ce94948bc3c3b9a5226bb93e2f476..79235f96a4d1b33e2a79d43b892385247b005c79 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_randomaccess )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_randomaccess) {
+  TestViewSubview::test_1d_assign<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c04.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c04.cpp
index 704bab5a0d9a90d6c51cf5dcb11059d34aaa0b32..d0f5a7bc01811788afe2bb2d17c5075d631814e7 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c05.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c05.cpp
index 7510ba2afc607cfbaca569a028afcac9b7c79534..2ae07aa17806635ae8a7611d11b5b4a7fb27890d 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_atomic )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d_atomic) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE,
+                                      Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c06.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c06.cpp
index 0b580f7dcd57c40666cc526f53345fe8f828c125..973ecb57ecaf8b65e071a0afd2c1188cea11d761 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_randomaccess )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d_randomaccess) {
+  TestViewSubview::test_2d_subview_3d<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c07.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c07.cpp
index 5d8484c352ef803a57cfde8236a7edd348179560..268ffd9755ac2e6b4bb5be311b438823287d8f18 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left) {
+  TestViewSubview::test_3d_subview_5d_left<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c08.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c08.cpp
index e896470e85c8b044980b0b02f0caf03a01870523..37a5cc0af6a343f1dbef61f9d713034e1555fe74 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_atomic) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c09.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c09.cpp
index 61c8e0ff73d218620af1febe7700cbd8ccb3e0da..7a60168b97428f614de85aaa9609252edeb79e80 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c10.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c10.cpp
index 9ce886295fd18e0287016c69c643b9997788242a..705899567d68a5a019a9d8508c5934a3d5922886 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right) {
+  TestViewSubview::test_3d_subview_5d_right<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c11.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c11.cpp
index 8b49f3694697346effdb47af40230ff50ca50f2e..2a2c4ceb085d4eb78841125c65986f8534a89973 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_atomic) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c12.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c12.cpp
index 8132cb3469196cfd46f1d89dfb22cf7a5b00e0ee..747df8836ea9ad68fb00aa127bf53e2aeb9fcd16 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c13.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c13.cpp
index f397eb6b7b344adad1d4e954ed72cdbbb723fb13..3de6595f3adc504c1c4e25bcc49aa39a7c2b2b01 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c13.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_SubView_c13.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_test_unmanaged_subview_reset )
-{
-  TestViewSubview::test_unmanaged_subview_reset< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_test_unmanaged_subview_reset) {
+  TestViewSubview::test_unmanaged_subview_reset<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Task.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Task.cpp
index 3d93266981977e864ff050172cb90f624aafde34..e2591c9b127518b21e96be95a02297fa5696294a 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Task.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Task.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestTaskScheduler.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestTaskScheduler.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_Team.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_Team.cpp
index 3740683450d94192511701ab1a32b338d05271d9..93aae95baccc42fb9a7af94115e5226456770a1a 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_Team.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,46 +47,60 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_for )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 0 );
+TEST(TEST_CATEGORY, team_for) {
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      0);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      0);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 2 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      2);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      2);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 1000 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      1000);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      1000);
 }
 
-
-TEST_F( TEST_CATEGORY, team_reduce )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 1000 );
+TEST(TEST_CATEGORY, team_reduce) {
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(1000);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(1000);
 }
 
-TEST_F( TEST_CATEGORY, team_broadcast )
-{
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 0 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 0 );
+TEST(TEST_CATEGORY, team_broadcast) {
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(0);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(0);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 2 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 2 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(2);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(2);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 16 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 16 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(16);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(16);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 1000 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 1000 );
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::
+      test_teambroadcast(1000);
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::
+      test_teambroadcast(1000);
 }
 
-}
+}  // namespace Test
 
 #include <TestTeamVector.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamReductionScan.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamReductionScan.cpp
index eef8977da074cb83a31c067086725da3ce7aa631..4495108dc9b8f000987fe8b047e177512f5ee024 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamReductionScan.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamReductionScan.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,36 +48,36 @@
 namespace Test {
 
 #if !defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-TEST_F( TEST_CATEGORY, team_scan )
-{
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10000 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10000 );
+TEST(TEST_CATEGORY, team_scan) {
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10000);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10000);
 }
 #endif
 
-TEST_F( TEST_CATEGORY, team_long_reduce )
-{
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_long_reduce) {
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-TEST_F( TEST_CATEGORY, team_double_reduce )
-{
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_double_reduce) {
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamScratch.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamScratch.cpp
index dcb6896b8f67dfec67a0c3485140438d0607da73..858bf599b5e92eb98968adfe28692b3bee77153b 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamScratch.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamScratch.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,42 +47,36 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_shared_request )
-{
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_shared_request) {
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, team_scratch_request )
-{
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_scratch_request) {
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-TEST_F( TEST_CATEGORY, team_lambda_shared_request )
-{
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+TEST(TEST_CATEGORY, team_lambda_shared_request) {
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Static> >();
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, scratch_align) {
-  TestScratchAlignment< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, scratch_align) { TestScratchAlignment<TEST_EXECSPACE>(); }
 #endif
 #endif
 
-TEST_F( TEST_CATEGORY, shmem_size )
-{
-  TestShmemSize< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, shmem_size) { TestShmemSize<TEST_EXECSPACE>(); }
 
-TEST_F( TEST_CATEGORY, multi_level_scratch )
-{
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, multi_level_scratch) {
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Static> >();
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamTeamSize.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamTeamSize.cpp
index 7e61e0810b3a070a29bea04dc9bfbc9adc1a0b4f..1d60d272776728635a413bc275bfeede1edf2627 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamTeamSize.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamTeamSize.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamVectorRange.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamVectorRange.cpp
index af6ef9cfd126b14f1118dcf9b381657e5752abf9..f0b7496ed0dc802019f6277b84f4d783cc0243c6 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_TeamVectorRange.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_TeamVectorRange.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestTeamVectorRange.hpp>
-
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestTeamVectorRange.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_UniqueToken.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_UniqueToken.cpp
index a04ee57a96bef70fc275f1558c8b1e576e1d4df1..186e9e155d11fc09c8acf03b037d4bfe68771543 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_UniqueToken.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_UniqueToken.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestUniqueToken.hpp>
-
+#include <cuda/TestCuda_Category.hpp>
+#include <TestUniqueToken.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_a.cpp
index 2fb4e9e781efa4b221864cd04f07fb22c052463d..ed9089f4c5a7f2297b53292c171d87bf82b2f846 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_b.cpp
index 080002dab0caaf680a719b606f5289080e17bea9..1a905646287b23fe1523e7a9475fe8e4a1622763 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_c.cpp
index 536b24fb332aca85fb70bf538af2b61568c46dbf..0feca1b1ca856669a928c10933100b5f59ee92c1 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_d.cpp
index 5bcf5407d93db4af6f3db5e7f513797fa8f3e8f4..fd5ff1198019ced32105ec524175cfd8320920b6 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_e.cpp
index b2e00dba477ad5761e8a84ce63863f90cecc9112..a15bdbd8d3a756221b55739d76cd3591d212d051 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewLayoutStrideAssignment.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewLayoutStrideAssignment.cpp
index 2732cd4baa107c79f1b2743e0c057f1cec094b99..9b14ed7e8201c4017c511591de4c4491e4d20341 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewLayoutStrideAssignment.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewLayoutStrideAssignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCuda_Category.hpp>
 #include <TestViewLayoutStrideAssignment.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_a.cpp
index e8e3d18fc0a31632c7b2e0f539d381aea10bcf90..5eaa95a59b706d9b428918c247f84b268ac1fbd7 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCuda_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_b.cpp
index 0a3b6c0bebef58ffd7be6d26ea2463ef3407e8af..5cd8f6c395e4678d4ed74f9dfb3251cc67c5be25 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCuda_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_subview.cpp
index caddacb07b2de84bbf95de874dbeb2fb92fe9166..2f8888a055c4d8fce4907d1ea977d78287093976 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCuda_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewOfClass.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewOfClass.cpp
index c457098ed52f2737c04f69e3e1ac5162661e0e1e..86315de374dcce9f3625f0de5f6f60860b8ce4e5 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewOfClass.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewOfClass.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <cuda/TestCuda_Category.hpp>
 #include <TestViewOfClass.hpp>
-
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_ViewResize.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewResize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49b8b17dea8f46ea86206c4ac9a7cb791fee4261
--- /dev/null
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_ViewResize.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <cuda/TestCuda_Category.hpp>
+#include <TestViewResize.hpp>
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_View_64bit.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_View_64bit.cpp
index 1f5d6f697a6a1ebf3a20156a54a880555639e710..ead4c29be92a21eb85678986de4eba247fa0c9ae 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_View_64bit.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_View_64bit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/cuda/TestCuda_WorkGraph.cpp b/lib/kokkos/core/unit_test/cuda/TestCuda_WorkGraph.cpp
index c51f95810a6aff86aca67ef7fb4cdcffc68d4e48..0ae3a66195b2ec387302d23266543561cc850a8b 100644
--- a/lib/kokkos/core/unit_test/cuda/TestCuda_WorkGraph.cpp
+++ b/lib/kokkos/core/unit_test/cuda/TestCuda_WorkGraph.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,5 +42,5 @@
 //@HEADER
 */
 
-#include<cuda/TestCuda_Category.hpp>
-#include<TestWorkGraph.hpp>
+#include <cuda/TestCuda_Category.hpp>
+#include <TestWorkGraph.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType.cpp
index 515cd5412923fb3eb0269caa6c5f06cca1171e2f..02f3f7272a858b8224ad1bcf42b00b9b80665b47 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,27 +47,29 @@
 #include <Kokkos_Core.hpp>
 #include <default/TestDefaultDeviceType_Category.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, host_space_access )
-{
+TEST(TEST_CATEGORY, host_space_access) {
   typedef Kokkos::HostSpace::execution_space host_exec_space;
-  typedef Kokkos::Device< host_exec_space, Kokkos::HostSpace > device_space;
-  typedef Kokkos::Impl::HostMirror< Kokkos::DefaultExecutionSpace >::Space mirror_space;
+  typedef Kokkos::Device<host_exec_space, Kokkos::HostSpace> device_space;
+  typedef Kokkos::Impl::HostMirror<Kokkos::DefaultExecutionSpace>::Space
+      mirror_space;
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility< host_exec_space, Kokkos::HostSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<host_exec_space,
+                                                 Kokkos::HostSpace>::accessible,
+                "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility< device_space, Kokkos::HostSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<device_space,
+                                                 Kokkos::HostSpace>::accessible,
+                "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility< mirror_space, Kokkos::HostSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<mirror_space,
+                                                 Kokkos::HostSpace>::accessible,
+                "");
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_1.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_1.cpp
index 40a773b3b8fd18fb0a4cce396b4cc19400b9ad41..0f53cf8de7908d3e4dc046cc5c9624fe90e3cb76 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_1.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_1.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_01
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_10.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_10.cpp
index f12c4f62b25acbb44e1f7d58876884035c250d9f..c4691edd9b70428844462dd27627bc29618556c8 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_10.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_10.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_10
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_11.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_11.cpp
index c7ffd7b94e5675b28d519e5dc785ccfb55549b31..6d999e6cca50f8765f2216c72625b00942d24cab 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_11.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_11.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_11
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_12.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_12.cpp
index 24e2b152014a8308e1ef3eccaa44ad76d884f9d2..8b60a704af57c32af9cbf479e8b8475ffc69d543 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_12.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_12.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_12
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_13.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_13.cpp
index 7968c13b661cad0b54697e86626d166fe0949602..22af90b95225798b8fe4c5456df8fe5d43aa67d8 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_13.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_13.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_13
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_14.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_14.cpp
index ab0563c6dc03d45fc696ea538cb75d6288f1e576..cbe7aa34c7b48d892528b1e2139b03cd3e979470 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_14.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_14.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_14
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_15.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_15.cpp
index 70a8ca1727515910f5bae07703421e9e95e6ab42..8aefe0b77a277edcf8ef1ca52e7b0e520ebdf638 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_15.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_15.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_15
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_16.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_16.cpp
index 727c7a95eb9f949f6ecb0e910dc8ff009d6b8225..0023c903be9762a71077fa56c9ebf7852679051a 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_16.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_16.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_16
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_2.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_2.cpp
index 88fba34c50e93c2ddb8e730d50e08d853b44dba5..da3c5d381c0d97481874661f245fd3202039dea8 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_2.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_2.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_02
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_3.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_3.cpp
index b3562cc53d6b4cf2a4162b916d84f94e1ab482a6..ab55bf93aa91360fdce82248d8c282fc6aa6d32e 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_3.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_3.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_03
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_4.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_4.cpp
index 0d4983319cb565f2ba4283b910bd16cabc48253a..02b637d6cdc16953e84dce595675738b9b0e2ab4 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_4.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_4.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_04
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_5.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_5.cpp
index 026fb01f8870af1a2d24f59da17a5d419721ba71..0d6dbc52233d0b15618cd5c805cbab60ade6c034 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_5.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_5.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_05
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_6.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_6.cpp
index 937a13160e40f6ec4666a7f4cb7eb7dc62d8a8fc..148153944da29f710c8bd5829a50b1b3723bb44b 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_6.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_6.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_06
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_7.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_7.cpp
index 992c854c1a10224a09d897a917e309f654cd4763..d7366577e9e64e078d08cac819c28da3cd26115b 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_7.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_7.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_07
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_8.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_8.cpp
index 07a8b1cb7c2ea3fc515f2f403ad6401353d7f7a1..72404d4328335b901cd5e65b1ecfc6c375dcf714 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_8.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_8.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_08
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_9.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_9.cpp
index 4d8c05be2d7f486487d7f39357982361117b4b76..7e327677199a906ed0f48636e384d7a61af0c2e2 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_9.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeInit_9.cpp
@@ -1,2 +1,2 @@
 #define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_09
-#include<TestDefaultDeviceTypeInit.hpp>
+#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeResize.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeResize.cpp
index fd8224ce34669c18e9cc9cc7e39e620a0a09c303..df2bc44aa6dc97f979f323a82a9e7850f18ed25b 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeResize.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceTypeResize.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,12 +47,11 @@
 
 namespace Test {
 
-TEST( kokkosresize, host_space_access )
-{
+TEST(kokkosresize, host_space_access) {
   // Test with the default device type.
   using TestViewResize::testResize;
   typedef Kokkos::View<int*>::device_type device_type;
-  testResize<device_type> ();
+  testResize<device_type>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_Category.hpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_Category.hpp
index b7e3fa3b93b0a8e376da8b813a4bca02c3871a9a..57a0e0ee006460a59c71d5fbccfbd87c2c754653 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_Category.hpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,22 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class defaultdevicetype : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-  }
-
-  static void TearDownTestCase()
-  {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY defaultdevicetype
+#define TEST_CATEGORY_DEATH defaultdevicetype_DeathTest
 #define TEST_EXECSPACE Kokkos::DefaultExecutionSpace
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a1.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a1.cpp
index fc1a09d34f48d885a7ad33f92a1f60bf22bac696..a49ff677dee9e8b7df7d77dfb87c19b98e73a67b 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a1.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a1.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,19 +46,17 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-
-TEST_F( defaultdevicetype, reduce_instantiation_a1 )
-{
+TEST(defaultdevicetype, reduce_instantiation_a1) {
   TestReduceCombinatoricalInstantiation<>::execute_a1();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a2.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a2.cpp
index 75843fc5ac2edc86d2ac5c3ac35e7973811adec6..816ec60ec0f3383769b71a1deb5b712d48c096c5 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a2.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a2.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,19 +46,17 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-
-TEST_F( defaultdevicetype, reduce_instantiation_a2 )
-{
+TEST(defaultdevicetype, reduce_instantiation_a2) {
   TestReduceCombinatoricalInstantiation<>::execute_a2();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a3.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a3.cpp
index 9f1ca5f23a67f3540a5998341a505400fad385ca..49c98268fc2cdcf6ab742aab4b83cf0be167e3bb 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a3.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_a3.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,19 +46,17 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-
-TEST_F( defaultdevicetype, reduce_instantiation_a3 )
-{
+TEST(defaultdevicetype, reduce_instantiation_a3) {
   TestReduceCombinatoricalInstantiation<>::execute_a3();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b1.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b1.cpp
index 94604a7733629ecf364c3b5a2cf47b809fc09cf4..fae6a72e726bf8284192af5e5f8ecd10ff430e69 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b1.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b1.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,18 +46,17 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-TEST_F( defaultdevicetype, reduce_instantiation_b1 )
-{
+TEST(defaultdevicetype, reduce_instantiation_b1) {
   TestReduceCombinatoricalInstantiation<>::execute_b1();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b2.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b2.cpp
index 77ffa39f3b104c2a83eb1836ef89f481b2518a81..8a1d4eff2ad5ff8d84606b298b5b99fb268fc86d 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b2.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b2.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,18 +46,17 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-TEST_F( defaultdevicetype, reduce_instantiation_b2 )
-{
+TEST(defaultdevicetype, reduce_instantiation_b2) {
   TestReduceCombinatoricalInstantiation<>::execute_b2();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b3.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b3.cpp
index 9d86f6caa22399d57b07e7ca8383cb67625c1fb1..6a980c492a033e542625c4ba4b470ce0768be969 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b3.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_b3.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,18 +46,17 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-TEST_F( defaultdevicetype, reduce_instantiation_b3 )
-{
+TEST(defaultdevicetype, reduce_instantiation_b3) {
   TestReduceCombinatoricalInstantiation<>::execute_b3();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c1.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c1.cpp
index 17e49b1ee73bff001e86eccfee43f5acf112945d..2c807582b335017a9a7829e853bdfca7eeaddc34 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c1.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c1.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,20 +46,19 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
-#if !defined( KOKKOS_ENABLE_ROCM ) 
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
+#if !defined(KOKKOS_ENABLE_ROCM)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-TEST_F( defaultdevicetype, reduce_instantiation_c1 )
-{
+TEST(defaultdevicetype, reduce_instantiation_c1) {
   TestReduceCombinatoricalInstantiation<>::execute_c1();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c2.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c2.cpp
index 5af1e0e36197ffdf4d1108f49bde1926db922cff..f940810a5de6d94dab8aa23f710e864a231b596c 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c2.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c2.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,20 +46,19 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
-#if !defined( KOKKOS_ENABLE_ROCM ) 
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
+#if !defined(KOKKOS_ENABLE_ROCM)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-TEST_F( defaultdevicetype, reduce_instantiation_c2 )
-{
+TEST(defaultdevicetype, reduce_instantiation_c2) {
   TestReduceCombinatoricalInstantiation<>::execute_c2();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c3.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c3.cpp
index 0281754e586299dd745de084fc71a61d87781a1f..c03d84302439dbd19cf22fa9f595e0a3efd28947 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c3.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_c3.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,20 +46,19 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
-#if !defined( KOKKOS_ENABLE_ROCM ) 
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
+#if !defined(KOKKOS_ENABLE_ROCM)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestReduceCombinatorical.hpp>
 
 namespace Test {
 
-TEST_F( defaultdevicetype, reduce_instantiation_c3 )
-{
+TEST(defaultdevicetype, reduce_instantiation_c3) {
   TestReduceCombinatoricalInstantiation<>::execute_c3();
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
 #endif
diff --git a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_d.cpp b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_d.cpp
index 21a4df25ecdba28895a646b5c1772e3914e05cb2..3502e1762f3bbc8aa59cfd2bf55f006e80e9b0d8 100644
--- a/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_d.cpp
+++ b/lib/kokkos/core/unit_test/default/TestDefaultDeviceType_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,29 +46,25 @@
 
 #include <Kokkos_Core.hpp>
 
-#if !defined( KOKKOS_ENABLE_CUDA ) || defined( __CUDACC__ )
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
 
 #include <default/TestDefaultDeviceType_Category.hpp>
 #include <TestUtilities.hpp>
 
 namespace Test {
 
-TEST_F( defaultdevicetype, test_utilities )
-{
-  test_utilities();
-}
+TEST(defaultdevicetype, test_utilities) { test_utilities(); }
 
-TEST_F( defaultdevicetype, malloc )
-{
-  int* data = (int*) Kokkos::kokkos_malloc( 100 * sizeof( int ) );
-  ASSERT_NO_THROW( data = (int*) Kokkos::kokkos_realloc( data, 120 * sizeof( int ) ) );
-  Kokkos::kokkos_free( data );
+TEST(defaultdevicetype, malloc) {
+  int* data = (int*)Kokkos::kokkos_malloc(100 * sizeof(int));
+  ASSERT_NO_THROW(data = (int*)Kokkos::kokkos_realloc(data, 120 * sizeof(int)));
+  Kokkos::kokkos_free(data);
 
-  int* data2 = (int*) Kokkos::kokkos_malloc( 0 );
-  ASSERT_TRUE( data2 == NULL );
-  Kokkos::kokkos_free( data2 );
+  int* data2 = (int*)Kokkos::kokkos_malloc(0);
+  ASSERT_TRUE(data2 == NULL);
+  Kokkos::kokkos_free(data2);
 }
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_complexdouble.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_complexdouble.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..51007d7b69393c672624524371985ac039e3af0d
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_complexdouble.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_complexdouble.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_complexfloat.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_complexfloat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3bc35731278d57a681fa407849b4bab08f7f1e04
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_complexfloat.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_complexfloat.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_double.cpp
index 6f4d5de5c1d8fb672171b07c8238955871194eff..f0eb44759fbe99e1f84e80957b6490967867dda6 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_float.cpp
index 5b859989cb0128015e78436203b90297aa512f9b..38551eabb5c5bcdfc21fc1299efae7b77f82efa1 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_int.cpp
index 1e7b098322a32f4006ac36b00d474597774d21e1..3005c3691300c21e9445cf8dae43f98edb8df41f 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longint.cpp
index a6d76339f1f7a01138f667d569e669a8f4a1cc68..4bbc1e0713b65968755360446de2a480165e23fa 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longlongint.cpp
index e8907bb6484c89e39293f78a047b4efdf85addd3..9abc860c73043fb45f9abf4327cb80a0837f683c 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedint.cpp
index ce54e31f96f2129d34d8a299671d5d9c5c7c2de7..6195d493e3fa923dc09d559fc311ffe665977c60 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedlongint.cpp
index cb8193c9e82c81e822b3888c9626683abffbbef7..a488983ec763219fa97e6777e76a83f09cd0c98b 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicViews.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicViews.cpp
index 59f4b05d5fc90f5b07bef9c689b5cfc4a855d545..723f513d8eae71ad9cf9d00d8454c8a14245f23d 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicViews.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_AtomicViews.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestAtomicViews.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestAtomicViews.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Atomics.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Atomics.cpp
index c9301446b9694a601fb53619179acab8b49a9d90..71729e96174a2f46813d5a78c7e5ab9919a9e377 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <hpx/TestHPX_Category.hpp>
 #include <TestAtomic.hpp>
-
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Category.hpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Category.hpp
index 358b42d1aaaef441d40c957c06f4e92e2abbaffb..bbdcfba5c7af2e7cd5c1734b8427bd724f5e240b 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Category.hpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class hpx : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY hpx
+#define TEST_CATEGORY_DEATH hpx_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::HPX
 
 #endif
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Complex.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Complex.cpp
index 6edcda6c68202dec187af9b18381aa894cc7ba76..91de03dcc6789eea4a8ccff1d9d9dbd88fbad74c 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Complex.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Complex.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Crs.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Crs.cpp
index 33f4262b83fb0dd405eb4e9baa05a4532a04ec09..d82f449c8c173039628366e5feb11e2dfaf8b9d8 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Crs.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Crs.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_DeepCopyAlignment.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29e04eda1ea04596ea3a86f02137cf6f9570f5f1
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_DeepCopyAlignment.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestDeepCopy.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_FunctorAnalysis.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_FunctorAnalysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa66cb49f08059235f025bf0c7f80bb2b88bb1d3
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_FunctorAnalysis.cpp
@@ -0,0 +1,47 @@
+
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestFunctorAnalysis.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Init.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Init.cpp
index f7cf44128c489f6cfdb030a307726d0c900c2bdb..9a320c63735f72149884822879ca1add30ce0aab 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Init.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Init.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,7 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestInit.hpp>
-#include<TestCompilerMacros.hpp>
-#include<TestPolicyConstruction.hpp>
-
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestInit.hpp>
+#include <TestCompilerMacros.hpp>
+#include <TestPolicyConstruction.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_InterOp.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_InterOp.cpp
index 72e440c19e0ed5454b10cf4e08eea0b971a13cf6..872d1a0383802c90f99557c8ef51c57dd19be918 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_InterOp.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_InterOp.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,11 +47,11 @@
 
 namespace Test {
 
-// Test whether allocations survive Kokkos initialize/finalize if done via Raw Cuda.
-TEST_F( hpx, raw_hpx_interop )
-{
-  Kokkos::InitArguments arguments{-1,-1,-1, false};
+// Test whether allocations survive Kokkos initialize/finalize if done via Raw
+// Cuda.
+TEST(hpx, raw_hpx_interop) {
+  Kokkos::InitArguments arguments{-1, -1, -1, false};
   Kokkos::initialize(arguments);
   Kokkos::finalize();
 }
-}
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_LocalDeepCopy.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_LocalDeepCopy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da48849b998537a54cd10222683a1033e4f1d799
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_LocalDeepCopy.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestLocalDeepCopy.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_a.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_a.cpp
index 5410402e1dcf3b23271b6b8d8ea83a37bcaeb8d5..59f97ef34620d0ff44ac1a3226bfbef4d1ca9545 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_b.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_b.cpp
index be15ba1b8c5fb13e654dfefa1c6e3557de658aca..eb2c9a04ee03ae775b8f4b3fd61d57da7ee01663 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_c.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_c.cpp
index e0afafab75f0cc9aea9526a1b69529aeba0b3187..8cbe4d56e6811957db0cae0ee302939cac6821e1 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_d.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_d.cpp
index f9e0a0c8843d29191a9fff64ce006c18dacb6e82..0ee7e7f649366dd2e916178e14c8b7ba090d87a5 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_e.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_e.cpp
index 9fbbfb623813b2e070069d5d0efc6ac0c7817090..a731f97f25f34861d768567c2ba31ec8a2e1afb4 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Other.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Other.cpp
index 3f74ceb7e6e32d651433cc00cacbb8b9e03a0309..34153174bdaec511b8826b1858aa1058ae56c81c 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Other.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Other.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_RangePolicy.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_RangePolicy.cpp
index ee1124ec8a2c93bada2f28a4af71ac9518e62997..009f4cbbcbcb60336cd3d786f22050877d5e6dda 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_RangePolicy.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_RangePolicy.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestRange.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestRange.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_a.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_a.cpp
index 5fbe0ff9992da91588ce9edf0ede08f133f96d91..9c10dc0aa0c1c8ed2efc6f9011212a6defb99533 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_a.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_b.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_b.cpp
index d4ed60f1ac0b0440d8222ae79548bf9db6454caa..1b3bdb53ba3b47967e26b7cb182d83ece86fd851 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_b.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_c.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_c.cpp
index 87704c4404688701123627831149095779d8c49a..385b2ccf96679f1244e73b7758cfe5479df9ced4 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_c.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_d.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_d.cpp
index 86895358fb94293e0b6d546f529e3529c479206c..e5460792ea7bb7008196686bdad84de0d76f9791 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_d.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Reducers_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Reductions.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Reductions.cpp
index d8cf6f3da2d67f7f35e548523738f164b041881a..e10b1761a667ae75b65869315587d225c5409a70 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Reductions_DeviceView.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Reductions_DeviceView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7363c21b1d8a2bde43c728916dab8a3c51bf2775
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Reductions_DeviceView.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestReduceDeviceView.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Scan.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Scan.cpp
index 526cd990ce483ec015f3f5965a263fa3fb31cbee..66bd71db5a07b9fb99682edb3e775f04c34fec9b 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Scan.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Scan.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestScan.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestScan.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SharedAlloc.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SharedAlloc.cpp
index 417fd0ee5759939c87a763b1c71240290058a287..48a40aaaef66e14a8405b649b237a8eae706ec53 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< Kokkos::HostSpace, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<Kokkos::HostSpace, TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_a.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_a.cpp
index 8e2443b5a4debbf1871627d5dc6411141ade4a99..9f697c16edd8b6b347163cc18e990ddef59556be 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,59 +47,48 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_left )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_left) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutLeft, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_right )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutRight, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_right) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutRight, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_stride )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutStride, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_stride) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutStride, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_assign_strided )
-{
-  TestViewSubview::test_1d_strided_assignment< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_assign_strided) {
+  TestViewSubview::test_1d_strided_assignment<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_0 )
-{
-  TestViewSubview::test_left_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_0) {
+  TestViewSubview::test_left_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_1 )
-{
-  TestViewSubview::test_left_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_1) {
+  TestViewSubview::test_left_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_2 )
-{
-  TestViewSubview::test_left_2< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_2) {
+  TestViewSubview::test_left_2<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_3 )
-{
-  TestViewSubview::test_left_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_3) {
+  TestViewSubview::test_left_3<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_0 )
-{
-  TestViewSubview::test_right_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_0) {
+  TestViewSubview::test_right_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_1 )
-{
-  TestViewSubview::test_right_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_1) {
+  TestViewSubview::test_right_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_3 )
-{
-  TestViewSubview::test_right_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_3) {
+  TestViewSubview::test_right_3<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_b.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_b.cpp
index 5d25fcc2571b98822ac0c6ed55b088cef9e0b268..eb625fd832a4479a351c80388d3879cfde068189 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,18 +47,20 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_layoutleft_to_layoutleft )
-{
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutleft_to_layoutleft) {
+  TestViewSubview::test_layoutleft_to_layoutleft<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_layoutright_to_layoutright )
-{
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutright_to_layoutright) {
+  TestViewSubview::test_layoutright_to_layoutright<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c01.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c01.cpp
index 36d2ab1bdbfd2b6a63015843d847bde1c36058fb..7bd179ba6828fe06183d95533585f3ad33d4fb14 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_1d_assign) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c02.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c02.cpp
index 19e70fbfbac5ce40639bbe83fea4eabd4d730d82..b490503b3c6516c4f8939d715bffa1a4f8fd219b 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_atomic )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_atomic) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE,
+                                  Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c03.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c03.cpp
index 45b07e43b02e54b62c35d37dec708000ae805bc8..f36a25e8ee291d0966f632579ec045a280ed5b2c 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_randomaccess )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_randomaccess) {
+  TestViewSubview::test_1d_assign<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c04.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c04.cpp
index 484b02560823c50837af5664cc9973e2db25bf47..3bc96cd57e1342dee66a61bc761cd710673e6eb2 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c05.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c05.cpp
index cbfa024553b2c4cd4ea4883ac47fb1ba840c4e62..a102141b7d54aa2b2041182e51b99a612897e5bf 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( hpx, view_subview_2d_from_3d_atomic )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(hpx, view_subview_2d_from_3d_atomic) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE,
+                                      Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c06.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c06.cpp
index ba2f8e5693531af4aedd58c19cf495101870f66e..18ba861113c118b122b5d5efe42b12e7f42ed53f 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_randomaccess )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d_randomaccess) {
+  TestViewSubview::test_2d_subview_3d<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c07.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c07.cpp
index 3cabfebc617055335ac57ba098e6c28741b3a8c4..d1e136fdf5c94f13be68c0567f2627713c211399 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left) {
+  TestViewSubview::test_3d_subview_5d_left<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c08.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c08.cpp
index bc78ba83ebcb329ec66f07eb51e2ace136b1585d..6bee531a71035756fa2c04cd7fb0ddeacd38d8a2 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_atomic) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c09.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c09.cpp
index bb3381a9e827f7c8f5e110b805359875bc6ae8df..a9c88d0e759fc9527628ee6f7c7c6770a6aaa032 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c10.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c10.cpp
index 58ae45a7a0b8a6a8e300a4289f2d7eb84806cf7b..c2b9d4ffda506fce81449b4c8d0ece46c884f5c2 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right) {
+  TestViewSubview::test_3d_subview_5d_right<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c11.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c11.cpp
index 19649fbd5667e07cdb4738d02596d10a38285e5e..429564d91c50a36bc835bb947753376882831c81 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_atomic) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c12.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c12.cpp
index dc354dc21eb96320f9685b093ebb7961f69ad5d8..bb7f69b1f196941eda03c3323d3dc65c3f42a3a1 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c13.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c13.cpp
index 8b4955c4c7c7e60d478b062250be5bd554106a9d..6f1e2cd0aa2fdd5baabe7c26cc68d26b47ce4349 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c13.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_SubView_c13.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_test_unmanaged_subview_reset )
-{
-  TestViewSubview::test_unmanaged_subview_reset< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_test_unmanaged_subview_reset) {
+  TestViewSubview::test_unmanaged_subview_reset<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Task.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Task.cpp
index 754e059c57ac2d9f17fcc1f275a1a09367b3af08..4e059beef41dec1286db5062dd031e9d5e4084ef 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Task.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Task.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestTaskScheduler.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestTaskScheduler.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_Team.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_Team.cpp
index 9851133d0396202623630f83cb7a6ec1d33e961e..f5278971bcd72c814f9eb6e0e6dacd2f28923b83 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_Team.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,30 +47,37 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_for )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 0 );
+TEST(TEST_CATEGORY, team_for) {
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      0);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      0);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 2 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      2);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      2);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 1000 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      1000);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      1000);
 }
 
-
-TEST_F( TEST_CATEGORY, team_reduce )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 1000 );
-}
+TEST(TEST_CATEGORY, team_reduce) {
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(1000);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(1000);
 }
+}  // namespace Test
 
 #include <TestTeamVector.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_TeamReductionScan.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamReductionScan.cpp
index ea9e9087bab4df90029dc18a1e62851f5a965b8a..971e12f3ff3b0bbaaea364d00b7259f4972ac048 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_TeamReductionScan.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamReductionScan.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,36 +47,35 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, team_scan )
-{
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10000 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10000 );
+TEST(TEST_CATEGORY, team_scan) {
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10000);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10000);
 }
 
-TEST_F( TEST_CATEGORY, team_long_reduce )
-{
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_long_reduce) {
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-TEST_F( TEST_CATEGORY, team_double_reduce )
-{
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_double_reduce) {
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_TeamScratch.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamScratch.cpp
index d51d3804136c533e1c6041e276a2f99ae4f1b313..14cbfb8f417a3c1f060e99946d2a5e7257432bef 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_TeamScratch.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamScratch.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,38 +47,34 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_shared_request )
-{
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_shared_request) {
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, team_scratch_request )
-{
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_scratch_request) {
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-TEST_F( TEST_CATEGORY, team_lambda_shared_request )
-{
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+TEST(TEST_CATEGORY, team_lambda_shared_request) {
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Static> >();
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 #endif
 #endif
 
-TEST_F( TEST_CATEGORY, shmem_size )
-{
-  TestShmemSize< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, shmem_size) { TestShmemSize<TEST_EXECSPACE>(); }
 
-TEST_F( TEST_CATEGORY, multi_level_scratch )
-{
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, multi_level_scratch) {
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Static> >();
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_TeamTeamSize.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamTeamSize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..68577d065e910a787e198b172cbdf8d6269b7f7f
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamTeamSize.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestTeamTeamSize.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_TeamVectorRange.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamVectorRange.cpp
index 21f448f20a43c41f6ca1181454b18dd26bdd0f62..2bf586ec263158c01d9028d513c32af080cd5f89 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_TeamVectorRange.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_TeamVectorRange.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestTeamVectorRange.hpp>
-
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestTeamVectorRange.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_UniqueToken.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_UniqueToken.cpp
index 4f25782237851d12e1d2e2fff3dd38975c70e376..9e88419e776c6327f3e77d4bbd115fdab1e3e143 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_UniqueToken.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_UniqueToken.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestUniqueToken.hpp>
-
+#include <hpx/TestHPX_Category.hpp>
+#include <TestUniqueToken.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_a.cpp
index 198aaba0f7bcecce236295529bc2356279842e12..7342cfac8cb39fe515a8bb17a9c9df77cb76f93b 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_b.cpp
index bafc735664b8b76c4643d85d84b8f148ae6cebbb..82fd177ad213749669ba38ea3c64b26d899afe89 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_c.cpp
index 0397558645b9ad847c6a000edf3636bec8512004..e5d920de4e4d22bf5a587b3b4f2f36ebcc20f70b 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_d.cpp
index aec887189c35e4237aaec8cc21061c7ef188adfd..56bfb6ffccba1df91a1056550970458e4cbd6124 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_e.cpp
index 3cc3f0cddd3f9062da19c637769253cdd5a637d3..3dc492355b6c6c1eff8495e5d403cb1e070f955c 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewLayoutStrideAssignment.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewLayoutStrideAssignment.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb91b558ef2098314e9daf0ebe1939e08112b833
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewLayoutStrideAssignment.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestViewLayoutStrideAssignment.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_a.cpp
index 15b069f1123ed1198e0044a28b726406b932d96f..5ad3d97197070a071fe46a96981bb0d9e7aaa591 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <hpx/TestHPX_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_b.cpp
index c1ffc79db2d57bc36a2971f1c1db76917613acb9..10f49a93d208458d3ccc29aea83262b6108a6e7b 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <hpx/TestHPX_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_subview.cpp
index 1e6dd240ff6dc5b466d21dd04228508dd09c5f04..e79965acfea9ee9cfe4ea27142ef28dd9a22b0eb 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <hpx/TestHPX_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewOfClass.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewOfClass.cpp
index 525fa09bf387839dca5d12f5894f880f30174b66..cfc9ea23a93726d1539fd6cd2afe91b1413227bf 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewOfClass.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewOfClass.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <hpx/TestHPX_Category.hpp>
 #include <TestViewOfClass.hpp>
-
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_ViewResize.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewResize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cc14030dcd2eeb173bb097dea94e902ecfd608ee
--- /dev/null
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_ViewResize.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <hpx/TestHPX_Category.hpp>
+#include <TestViewResize.hpp>
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_View_64bit.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_View_64bit.cpp
index 18d08cedaa6462acac6ab70a8f6ae75281e196ac..8672c23d7bb5b11d986839456b0422b5312946e3 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_View_64bit.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_View_64bit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/hpx/TestHPX_WorkGraph.cpp b/lib/kokkos/core/unit_test/hpx/TestHPX_WorkGraph.cpp
index ca980b8a74732b2e5c2af175ab89b9852142f814..1e497b344b52ae9be66f115f657444fcf578b944 100644
--- a/lib/kokkos/core/unit_test/hpx/TestHPX_WorkGraph.cpp
+++ b/lib/kokkos/core/unit_test/hpx/TestHPX_WorkGraph.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,5 +42,5 @@
 //@HEADER
 */
 
-#include<hpx/TestHPX_Category.hpp>
-#include<TestWorkGraph.hpp>
+#include <hpx/TestHPX_Category.hpp>
+#include <TestWorkGraph.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP.hpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP.hpp
index 9fdf627001b3272ac172dbd85c49e88f0c44a30d..082657c28f738333040f8b11b2663bd4f960b3a3 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP.hpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -83,13 +84,12 @@
 namespace Test {
 
 class openmp : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
+ protected:
+  static void SetUpTestCase() {
     int threads_count = 0;
-    #pragma omp parallel
+#pragma omp parallel
     {
-      #pragma omp atomic
+#pragma omp atomic
       ++threads_count;
     }
 
@@ -97,18 +97,15 @@ protected:
       threads_count /= 2;
     }
 
-    Kokkos::OpenMP::initialize( threads_count );
-    Kokkos::print_configuration( std::cout, true );
+    Kokkos::OpenMP::initialize(threads_count);
+    Kokkos::print_configuration(std::cout, true);
 
-    srand( 10231 );
+    srand(10231);
   }
 
-  static void TearDownTestCase()
-  {
-    Kokkos::OpenMP::finalize();
-  }
+  static void TearDownTestCase() { Kokkos::OpenMP::finalize(); }
 };
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexdouble.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexdouble.cpp
index 8d38e398ca31cc18cbe57d5d8d7075f4cf798847..50514e3503f79fbaa6d0ba3e85dec9be1f6cb49f 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexdouble.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexdouble.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_complexdouble.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_complexdouble.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexfloat.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexfloat.cpp
index cbaf47683a9800356fbe86879ef8efe7c715ded5..a9decbad9930ca6d364f56df8b2fa1243e459b7e 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexfloat.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_complexfloat.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_complexfloat.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_complexfloat.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_double.cpp
index 234e0bb0074a4eeac4c9f8a3776558d001b41194..9de85e155b61eb1f6a03d02c6979dc2581fa09d5 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_float.cpp
index ce0950210d1c7892ff6a797bbe9a71ec78f6a390..8248ee68c0399505899a14db8da49a8674f34eb0 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_int.cpp
index fe68158c939acb4acc187a9ab285bbee05fe8dc2..524305f3a3449e0b61f07df8784d428d7ff1a845 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longint.cpp
index 9a8d881e241a85ea2d48f43686a605a9f107d309..06375942e02023dd834816024549a7727c0c9838 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longlongint.cpp
index 4418850e422c8d00c8558d6eb37e54c600a91c23..4e72e64335e3487bc525344b450c933dc82abb20 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedint.cpp
index 62afa02bb30f6988522d6ac9481c046e889452c6..485770898bce12be6b7245def54182b009a02e81 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedlongint.cpp
index 6afa317b637188351a128405d72a861dca05f1d9..c0922e78496877f5d9d9195f993788cf082a5dc1 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicViews.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicViews.cpp
index 6e7355ff59560771300d0ee12d63e656c22f1eb9..8b495b962b434efbc3a49e785afabb9e1657be00 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicViews.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_AtomicViews.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestAtomicViews.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestAtomicViews.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Atomics.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Atomics.cpp
index ea062b4c0a73df9727a894204f21db4f123feddc..123f6f1567f4e8b1792d53d883a8cd4a14209b1e 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestAtomic.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Category.hpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Category.hpp
index 96f35ddd18103d7cae5693d4046ed431c2f5c1d3..2cdb378e069cb8bbfc9c6e191c7eaa113423e365 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Category.hpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class openmp : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY openmp
+#define TEST_CATEGORY_DEATH openmp_DeathTest
 #define TEST_EXECSPACE Kokkos::OpenMP
 
 #endif
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Complex.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Complex.cpp
index 9040ea56369171fd2f4ea95faa4113b6053c7c1d..e702a2508f9d9e27a0f8469e7f7b0a2da25b15b4 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Complex.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Complex.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Crs.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Crs.cpp
index 1f97bb95d1c0ec1c0240a7eb668267c4b3588b33..49615f955e53faa5b1ab9b4d017fd64a99eae134 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Crs.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Crs.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_DeepCopyAlignment.cpp
index bd628e6958b4ffdf0fcda6aa3716894330b4cbc0..a15f5dcf1fc76f63f6bcbe89a5e63c1da8eef3de 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_DeepCopyAlignment.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_DeepCopyAlignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_FunctorAnalysis.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_FunctorAnalysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae4b1d0b2dc7c5d702c1481455ddc5a4b8b82e73
--- /dev/null
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_FunctorAnalysis.cpp
@@ -0,0 +1,47 @@
+
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestFunctorAnalysis.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Init.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Init.cpp
index 48c033a735d8e4ce2711751c871e121591902301..8c49b6692d079eac3abd03524d07023289fadeea 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Init.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Init.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,7 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestInit.hpp>
-#include<TestCompilerMacros.hpp>
-#include<TestPolicyConstruction.hpp>
-
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestInit.hpp>
+#include <TestCompilerMacros.hpp>
+#include <TestPolicyConstruction.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_InterOp.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_InterOp.cpp
index 148366bc0d2da9602dbee8ccec123e3d9cb27de4..083c94860ba7018f4418a8c2eff7112afbaaf063 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_InterOp.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_InterOp.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,44 +48,42 @@
 
 namespace Test {
 
-// Test whether allocations survive Kokkos initialize/finalize if done via Raw Cuda.
-TEST_F( openmp, raw_openmp_interop )
-{
+// Test whether allocations survive Kokkos initialize/finalize if done via Raw
+// Cuda.
+TEST(openmp, raw_openmp_interop) {
   int count = 0;
-  int num_threads,concurrency;
-  #pragma omp parallel
+  int num_threads, concurrency;
+#pragma omp parallel
   {
-    #pragma omp atomic
+#pragma omp atomic
     count++;
-    if(omp_get_thread_num()==0)
-      num_threads = omp_get_num_threads();
+    if (omp_get_thread_num() == 0) num_threads = omp_get_num_threads();
   }
 
-  ASSERT_EQ(count,num_threads);
+  ASSERT_EQ(count, num_threads);
 
-  Kokkos::InitArguments arguments{-1,-1,-1, false};
+  Kokkos::InitArguments arguments{-1, -1, -1, false};
   Kokkos::initialize(arguments);
 
   count = 0;
-  #pragma omp parallel
+#pragma omp parallel
   {
-    #pragma omp atomic
+#pragma omp atomic
     count++;
   }
 
   concurrency = Kokkos::OpenMP::concurrency();
-  ASSERT_EQ(count,concurrency);
+  ASSERT_EQ(count, concurrency);
 
   Kokkos::finalize();
 
   count = 0;
-  #pragma omp parallel
+#pragma omp parallel
   {
-    #pragma omp atomic
+#pragma omp atomic
     count++;
   }
 
-  ASSERT_EQ(count,concurrency);
-
-}
+  ASSERT_EQ(count, concurrency);
 }
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_LocalDeepCopy.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_LocalDeepCopy.cpp
index 8b135ad4a1edc1aa44707a59db5229ea5a750033..6670faf0c2ccc0a0afeb59dd9fca1f5b2388d032 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_LocalDeepCopy.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_LocalDeepCopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestLocalDeepCopy.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_a.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_a.cpp
index 40cb88c8c9b0d41cc16c3fdbf17ed7b84b034f11..6f421e1ac58429423753334979f3615a8b376a80 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_b.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_b.cpp
index 0c88b52076ab700ca6c2686ba4102152b0335a50..4119ed8a598aa7c7ca751989008d1766bd3667a8 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_c.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_c.cpp
index 372c84c86fe977c909253d2ad9531762882fdbe5..b1d5dd43d4e8fa6ed3167b3ee6345227b0f2343f 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_d.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_d.cpp
index 2e9725c0cd95aafe3b6bf304792549892c353907..52c807255d7806da7235a51595539ef7ab4c3139 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_e.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_e.cpp
index 343ff583b5de4d9c53b67412f36499923966d3b5..011579b55181eb793ae9e5f6ef3e37fc38fb33cc 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Other.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Other.cpp
index 0ddd67acf90965e9e414418d45b49ba0b3c3876c..6e7463a33fddcfb3ce8aba33fb7cfda6d44c7d03 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Other.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Other.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,22 +43,21 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestTemplateMetaFunctions.hpp>
-#include<TestAggregate.hpp>
-#include<TestMemoryPool.hpp>
-#include<TestCXX11.hpp>
-#include<TestTile.hpp>
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestTemplateMetaFunctions.hpp>
+#include <TestAggregate.hpp>
+#include <TestMemoryPool.hpp>
+#include <TestCXX11.hpp>
+#include <TestTile.hpp>
 
-#include<TestViewCtorPropEmbeddedDim.hpp>
-#include<TestViewLayoutTiled.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
+#include <TestViewLayoutTiled.hpp>
 
 #include <mutex>
 
 namespace Test {
 
-TEST_F( openmp, partition_master )
-{
+TEST(openmp, partition_master) {
   using Mutex = Kokkos::Experimental::MasterLock<Kokkos::OpenMP>;
 
   Mutex mtx;
@@ -73,13 +73,13 @@ TEST_F( openmp, partition_master )
 
     {
       std::unique_lock<Mutex> lock(mtx);
-      if ( Kokkos::OpenMP::in_parallel() ) {
+      if (Kokkos::OpenMP::in_parallel()) {
         ++errors;
       }
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-      if ( Kokkos::OpenMP::thread_pool_rank() != 0 )
+      if (Kokkos::OpenMP::thread_pool_rank() != 0)
 #else
-      if ( Kokkos::OpenMP::impl_thread_pool_rank() != 0 )
+      if (Kokkos::OpenMP::impl_thread_pool_rank() != 0)
 #endif
       {
         ++errors;
@@ -88,68 +88,67 @@ TEST_F( openmp, partition_master )
 
     {
       int local_errors = 0;
-      Kokkos::parallel_reduce( Kokkos::RangePolicy<Kokkos::OpenMP>(0,1000)
-                           , [pool_size]( const int , int & errs ) {
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<Kokkos::OpenMP>(0, 1000),
+          [pool_size](const int, int& errs) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-          if ( Kokkos::OpenMP::thread_pool_size() != pool_size )
+            if (Kokkos::OpenMP::thread_pool_size() != pool_size)
 #else
-          if ( Kokkos::OpenMP::impl_thread_pool_size() != pool_size )
+            if (Kokkos::OpenMP::impl_thread_pool_size() != pool_size)
 #endif
-          {
-            ++errs;
-          }
-        }
-        , local_errors
-      );
-      Kokkos::atomic_add( &errors, local_errors );
+            {
+              ++errs;
+            }
+          },
+          local_errors);
+      Kokkos::atomic_add(&errors, local_errors);
     }
 
-    Kokkos::Experimental::UniqueToken< Kokkos::OpenMP > token;
+    Kokkos::Experimental::UniqueToken<Kokkos::OpenMP> token;
 
-    Kokkos::View<int*, Kokkos::OpenMP> count( "",  token.size() );
+    Kokkos::View<int*, Kokkos::OpenMP> count("", token.size());
 
-    Kokkos::parallel_for( Kokkos::RangePolicy<Kokkos::OpenMP>(0,1000),
-        [=] ( const int ) {
-      int i = token.acquire();
-      ++count[i];
-      token.release(i);
-    });
+    Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::OpenMP>(0, 1000),
+                         [=](const int) {
+                           int i = token.acquire();
+                           ++count[i];
+                           token.release(i);
+                         });
 
-    Kokkos::View<int,Kokkos::OpenMP> sum ("");
-    Kokkos::parallel_for( Kokkos::RangePolicy<Kokkos::OpenMP>(0,token.size()),
-        [=] ( const int i ) {
-      Kokkos::atomic_add( sum.data(), count[i] );
-    });
+    Kokkos::View<int, Kokkos::OpenMP> sum("");
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<Kokkos::OpenMP>(0, token.size()),
+        [=](const int i) { Kokkos::atomic_add(sum.data(), count[i]); });
 
     if (sum() != 1000) {
-      Kokkos::atomic_add( &errors, 1 );
+      Kokkos::atomic_add(&errors, 1);
     }
   };
 
-  master(0,1);
+  master(0, 1);
 
-  ASSERT_EQ( errors, 0 );
+  ASSERT_EQ(errors, 0);
 
-  Kokkos::OpenMP::partition_master( master );
-  ASSERT_EQ( errors, 0 );
+  Kokkos::OpenMP::partition_master(master);
+  ASSERT_EQ(errors, 0);
 
-  Kokkos::OpenMP::partition_master( master, 4, 0 );
-  ASSERT_EQ( errors, 0 );
+  Kokkos::OpenMP::partition_master(master, 4, 0);
+  ASSERT_EQ(errors, 0);
 
-  Kokkos::OpenMP::partition_master( master, 0, 4 );
-  ASSERT_EQ( errors, 0 );
+  Kokkos::OpenMP::partition_master(master, 0, 4);
+  ASSERT_EQ(errors, 0);
 
-  Kokkos::OpenMP::partition_master( master, 2, 2 );
-  ASSERT_EQ( errors, 0 );
+  Kokkos::OpenMP::partition_master(master, 2, 2);
+  ASSERT_EQ(errors, 0);
 
-  Kokkos::OpenMP::partition_master( master, 8, 0 );
-  ASSERT_EQ( errors, 0 );
+  Kokkos::OpenMP::partition_master(master, 8, 0);
+  ASSERT_EQ(errors, 0);
 
-  Kokkos::OpenMP::partition_master( master, 0, 8 );
-  ASSERT_EQ( errors, 0 );
+  Kokkos::OpenMP::partition_master(master, 0, 8);
+  ASSERT_EQ(errors, 0);
 
-  Kokkos::OpenMP::partition_master( master, 8, 8 );
-  ASSERT_EQ( errors, 0 );
+  Kokkos::OpenMP::partition_master(master, 8, 8);
+  ASSERT_EQ(errors, 0);
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_RangePolicy.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_RangePolicy.cpp
index 4fd097c84d7e27508402aab1538323d89d3cd4c8..a19697393db7c0133a856001d76f92167b542134 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_RangePolicy.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_RangePolicy.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestRange.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestRange.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_a.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_a.cpp
index 61537ac9349022b86abc441f34e615f447bf53c5..539720c7a1cf25cfd9819e2848a66b798c5ddee9 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_a.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_b.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_b.cpp
index 686e5a02dbd83aa06029411d71dd825f0cdb2d6d..e4a7b029c2905244c783efccdf59065030341296 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_b.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_c.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_c.cpp
index 1bed6ce9a7fbc84d01f2fe4c911dcd43538573bf..62f3a1c962a3af06b145b6d30339004f7c2c2641 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_c.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_d.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_d.cpp
index 12c7cdd8f23b5c6136025dd44a17bd18f4162baa..c8a34e5438363b70ad00f7f7d93cbbb9a7d80607 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_d.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reducers_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions.cpp
index c4554f2c4e061c8627d2fd492f1611f77710d81c..1eb20ea09e09c3f7ac73bd0701d6c390e4dd79f3 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions_DeviceView.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions_DeviceView.cpp
index 99fe5842cb8c179cc4153092bba86cecf8aaa2aa..bd3a0595788e6ae93f8a3d8d0dcdf795ee6a5a53 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions_DeviceView.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Reductions_DeviceView.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Scan.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Scan.cpp
index 04a38163a49da8e47da374d8302380525916d94e..f8c58ecfdd326385f25f554e1c1c00d1c4f46132 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Scan.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Scan.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestScan.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestScan.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SharedAlloc.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SharedAlloc.cpp
index 82e9cf6e33360a497888624c657f3d835d4b25dc..8e386391a83605dc25bfea3573a941d6fd2d57a1 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< Kokkos::HostSpace, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<Kokkos::HostSpace, TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_a.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_a.cpp
index 8cea3a76cfbf36ad5467a333dde00b554c735278..a12095720ecfbf3d5ec4ba137142bab58b531516 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,66 +47,56 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_left )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_left) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutLeft, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_right )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutRight, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_right) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutRight, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_stride )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutStride, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_stride) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutStride, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_assign_strided )
-{
-  TestViewSubview::test_1d_strided_assignment< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_assign_strided) {
+  TestViewSubview::test_1d_strided_assignment<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_0 )
-{
-  TestViewSubview::test_left_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_0) {
+  TestViewSubview::test_left_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_1 )
-{
-  TestViewSubview::test_left_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_1) {
+  TestViewSubview::test_left_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_2 )
-{
-  TestViewSubview::test_left_2< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_2) {
+  TestViewSubview::test_left_2<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_3 )
-{
-  TestViewSubview::test_left_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_3) {
+  TestViewSubview::test_left_3<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_0 )
-{
-  TestViewSubview::test_right_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_0) {
+  TestViewSubview::test_right_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_1 )
-{
-  TestViewSubview::test_right_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_1) {
+  TestViewSubview::test_right_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_3 )
-{
-  TestViewSubview::test_right_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_3) {
+  TestViewSubview::test_right_3<TEST_EXECSPACE>();
 }
 
-TEST_F(TEST_CATEGORY, view_static_tests)
-{
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutLeft>()();
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutRight>()();
+TEST(TEST_CATEGORY, view_static_tests) {
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutLeft>()();
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutRight>()();
   TestViewSubview::TestExtentsStaticTests<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_b.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_b.cpp
index 3bf63b641ae440cf75c114e908099ba087c990a3..fc34c149f28129ddf9984680e05258e40392e31c 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,18 +47,20 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_layoutleft_to_layoutleft )
-{
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutleft_to_layoutleft) {
+  TestViewSubview::test_layoutleft_to_layoutleft<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_layoutright_to_layoutright )
-{
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutright_to_layoutright) {
+  TestViewSubview::test_layoutright_to_layoutright<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c01.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c01.cpp
index 676ef18a38c31ec643df42992395ea9253896c03..402072b680775adc662574cc8a0765d7b164b897 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_1d_assign) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c02.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c02.cpp
index f1af02c73ad01e240e9a0c7d64fda8282b3e3967..9aba989f59449d24cf7e6006bfeea4f749cf86c9 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_atomic )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_atomic) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE,
+                                  Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c03.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c03.cpp
index b5dc8b4f84e644d7f722826d91a1a42f6d7ae261..49db066f44328547e92fd5d256770284b4cb4947 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_randomaccess )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_randomaccess) {
+  TestViewSubview::test_1d_assign<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c04.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c04.cpp
index 7c008a6bb223d9ed6ae52919c7aa12f72ddaefca..a4112f4420215ec39d028a2bb5274b5a8287641d 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c05.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c05.cpp
index 4f43cbc8770ec518dfed29f43acd2a84405253a1..691ddbb9615b50d88405920b79f88aaf7827a4da 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( openmp, view_subview_2d_from_3d_atomic )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(openmp, view_subview_2d_from_3d_atomic) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE,
+                                      Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c06.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c06.cpp
index fbb55ee7c75f1a2322d9f24f4ce97fbb128c4423..b65b1e228cf6157aea5d016e8e61fd6c0142fe7e 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_randomaccess )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d_randomaccess) {
+  TestViewSubview::test_2d_subview_3d<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c07.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c07.cpp
index 503997cfcae2d1c111915c571b219de8657c95e9..1b81dc9450ef1215e5ec28b4630f41b5d0d3adb7 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left) {
+  TestViewSubview::test_3d_subview_5d_left<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c08.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c08.cpp
index 34133feb1b4ddb2870ca253a841b081bdfd3af6c..5dd92f1c0273a1e4f23d106c02770794ebf96b2b 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_atomic) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c09.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c09.cpp
index d70cb0bd2577cc3ae0f07030e4d707df2e9b9c0a..9216956ede0f5afe2b5613e9383d3da0a4ac13ff 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c10.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c10.cpp
index 72bbb2c36bde850ad6169c6dd640477bc48fe76e..b8252d3cb73cd0e5bdfd9f9cf3b6c8cc3b8e5f1d 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right) {
+  TestViewSubview::test_3d_subview_5d_right<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c11.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c11.cpp
index f715f70e771de71f618262f90c0b5d0c1c0fa3c1..4b9485357e54e19fbf0ed0a671bedf187dba4905 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_atomic) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c12.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c12.cpp
index c93581112a1339f5422508d4f3761e7626a2c1a8..c1a7250eb7a7e6d4bb1a6763dde5ffea2cc87d74 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c13.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c13.cpp
index 594c62d1453beba6fe5098d6fad48f0150e26d16..ab9f668e65ecf449937d2c75653d0c88f95df209 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c13.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_SubView_c13.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_test_unmanaged_subview_reset )
-{
-  TestViewSubview::test_unmanaged_subview_reset< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_test_unmanaged_subview_reset) {
+  TestViewSubview::test_unmanaged_subview_reset<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Task.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Task.cpp
index 95a6cbdf9b68fc29f8e53c1189167baeb848e039..5e67a34710f1219eb0a13d90b686faa7c6938321 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Task.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Task.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestTaskScheduler.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestTaskScheduler.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Team.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Team.cpp
index e5b900ac5836e5708e83a58a7fd5016e6700fd73..c389ebac3736e683b5234132e0535254ae377433 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_Team.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,45 +47,59 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_for )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 0 );
+TEST(TEST_CATEGORY, team_for) {
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      0);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      0);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 2 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      2);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      2);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 1000 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      1000);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      1000);
 }
 
-
-TEST_F( TEST_CATEGORY, team_reduce )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 1000 );
+TEST(TEST_CATEGORY, team_reduce) {
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(1000);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(1000);
 }
 
-TEST_F( TEST_CATEGORY, team_broadcast )
-{
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 0 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 0 );
+TEST(TEST_CATEGORY, team_broadcast) {
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(0);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(0);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 2 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 2 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(2);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(2);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 16 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 16 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(16);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(16);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 1000 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 1000 );
-}
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::
+      test_teambroadcast(1000);
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::
+      test_teambroadcast(1000);
 }
+}  // namespace Test
 
 #include <TestTeamVector.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamReductionScan.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamReductionScan.cpp
index 482005c8838a59a4e8f14ab1f36b7daed8f0331d..f6f386032bbbf899654163b849c43d7a32251b05 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamReductionScan.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamReductionScan.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,36 +47,35 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, team_scan )
-{
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10000 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10000 );
+TEST(TEST_CATEGORY, team_scan) {
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10000);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10000);
 }
 
-TEST_F( TEST_CATEGORY, team_long_reduce )
-{
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_long_reduce) {
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-TEST_F( TEST_CATEGORY, team_double_reduce )
-{
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_double_reduce) {
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamScratch.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamScratch.cpp
index 64d757533983eeb1893703ea9ebb6a856de8aa2a..5c283a622643e2f2cab160cdb91a5a4275e77fef 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamScratch.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamScratch.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,41 +47,35 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_shared_request )
-{
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_shared_request) {
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, team_scratch_request )
-{
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_scratch_request) {
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-TEST_F( TEST_CATEGORY, team_lambda_shared_request )
-{
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
-}
-TEST_F( TEST_CATEGORY, scratch_align) {
-  TestScratchAlignment< TEST_EXECSPACE >();
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+TEST(TEST_CATEGORY, team_lambda_shared_request) {
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Static> >();
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Dynamic> >();
 }
+TEST(TEST_CATEGORY, scratch_align) { TestScratchAlignment<TEST_EXECSPACE>(); }
 #endif
 #endif
 
-TEST_F( TEST_CATEGORY, shmem_size )
-{
-  TestShmemSize< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, shmem_size) { TestShmemSize<TEST_EXECSPACE>(); }
 
-TEST_F( TEST_CATEGORY, multi_level_scratch )
-{
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, multi_level_scratch) {
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Static> >();
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamTeamSize.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamTeamSize.cpp
index a98728f02c53b9d49022ab35e6cdf0a6b4309aab..df935a0ad18ab7a979067a7661318294b046732b 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamTeamSize.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamTeamSize.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestTeamTeamSize.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamVectorRange.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamVectorRange.cpp
index eff8c731822d1354992dde830c105bbd667042e7..9fe7a0c0ca574face5ee32b8939c7ab6f6a4f4d5 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamVectorRange.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_TeamVectorRange.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestTeamVectorRange.hpp>
-
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestTeamVectorRange.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_UniqueToken.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_UniqueToken.cpp
index 473ec73a2f3cc860b386d13dd9f8e969c6aca9fc..eed863e5f9d283614409b079e3f3d8d1288269ef 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_UniqueToken.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_UniqueToken.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestUniqueToken.hpp>
-
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestUniqueToken.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_a.cpp
index a7a441c8ecfcef021b26f15fe9a9b80ce4428d94..f0066d82dce31061a508221bd74f84fa3d294513 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_b.cpp
index 97aaee46ea590cedb1a4a2b495c3e7b4f2d5df6e..d9eb1b9053898f084df5605f822601fa76787e57 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_c.cpp
index 6fcbdd319d69b9e4927b270d1f004854619c2143..ecdb7318fa3a05db9669fffe168fd1f176272fac 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_d.cpp
index dbfcd9ff28f2e32501043c9d172f9033ef2d7e12..4a9a6513c1b79270c56cbda3ba9804923f83dd57 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_e.cpp
index 2e8134aac448571f9a8b42dc39f1371bd3958eb5..e5ddee77d84571d1125d3ae5ef19b79f22bf3e79 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewLayoutStrideAssignment.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewLayoutStrideAssignment.cpp
index 81b296d15db472869dfb9d2c7c3573a70894f75e..90e90139c19ade97ad627627d1efc63e77034c0f 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewLayoutStrideAssignment.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewLayoutStrideAssignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestViewLayoutStrideAssignment.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_a.cpp
index 781dabeeed5420c8eb3ddae65e90634a0bd3e87a..0f2dd07e5bee9877827e8d20776316cd2561a8e8 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_b.cpp
index 910d043fb38d0b28ba2c3582d4dd366ac059bd95..13be940425492fca7050cfaf42549659a93e5e23 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_subview.cpp
index 900e760979e3df2815ee9c40ffcacdd089613e0d..47250070b5cb860cb9cae9d0cdacb85aa52e22d3 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewOfClass.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewOfClass.cpp
index 87a49902f438fe677f78190b16cb6216bd647346..78315c45aa43645d59ecfe16bb645f0eb243f7e6 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewOfClass.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewOfClass.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmp/TestOpenMP_Category.hpp>
 #include <TestViewOfClass.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewResize.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewResize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cacd2b3e80d2230eaf7cd5d23ca27ce973b35fc5
--- /dev/null
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_ViewResize.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestViewResize.hpp>
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_View_64bit.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_View_64bit.cpp
index a1afbaba72d0748eac8b8c88d1784eb128154cd4..80f52abafb4b7da9f6704a0400ef198d062fd488 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_View_64bit.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_View_64bit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmp/TestOpenMP_WorkGraph.cpp b/lib/kokkos/core/unit_test/openmp/TestOpenMP_WorkGraph.cpp
index 916257e2036dd9f400e85b4196c7243fe630ba42..f76f612f2c83a5e6839ac0f3977d696c2eccadb4 100644
--- a/lib/kokkos/core/unit_test/openmp/TestOpenMP_WorkGraph.cpp
+++ b/lib/kokkos/core/unit_test/openmp/TestOpenMP_WorkGraph.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,5 +42,5 @@
 //@HEADER
 */
 
-#include<openmp/TestOpenMP_Category.hpp>
-#include<TestWorkGraph.hpp>
+#include <openmp/TestOpenMP_Category.hpp>
+#include <TestWorkGraph.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget.hpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget.hpp
index 3ebbf5204cd814479cb735e36d5011b0f02f7005..0e9ad3e24ff72ef09a82ee5486440eab5d4192ae 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget.hpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -70,7 +71,7 @@
 //#include <TestAggregate.hpp>
 //#include <TestCompilerMacros.hpp>
 
-//TODO enable task scheduler tests for openmptarget
+// TODO enable task scheduler tests for openmptarget
 //#include <TestTaskScheduler.hpp>
 
 //#include <TestMemoryPool.hpp>
@@ -84,28 +85,26 @@
 namespace Test {
 
 class openmptarget : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-    const unsigned numa_count       = Kokkos::hwloc::get_available_numa_count();
-    const unsigned cores_per_numa   = Kokkos::hwloc::get_available_cores_per_numa();
-    const unsigned openmptarget_per_core = Kokkos::hwloc::get_available_openmptarget_per_core();
+ protected:
+  static void SetUpTestCase() {
+    const unsigned numa_count = Kokkos::hwloc::get_available_numa_count();
+    const unsigned cores_per_numa =
+        Kokkos::hwloc::get_available_cores_per_numa();
+    const unsigned openmptarget_per_core =
+        Kokkos::hwloc::get_available_openmptarget_per_core();
 
     unsigned openmptarget_count = 0;
 
-    openmptarget_count = std::max( 1u, numa_count )
-                  * std::max( 2u, cores_per_numa * openmptarget_per_core );
+    openmptarget_count = std::max(1u, numa_count) *
+                         std::max(2u, cores_per_numa * openmptarget_per_core);
 
-    Kokkos::OpenMPTarget::initialize( openmptarget_count );
-    Kokkos::print_configuration( std::cout, true /* detailed */ );
+    Kokkos::OpenMPTarget::initialize(openmptarget_count);
+    Kokkos::print_configuration(std::cout, true /* detailed */);
   }
 
-  static void TearDownTestCase()
-  {
-    Kokkos::OpenMPTarget::finalize();
-  }
+  static void TearDownTestCase() { Kokkos::OpenMPTarget::finalize(); }
 };
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexdouble.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexdouble.cpp
index b2096073d018b6e635bedd53cc370cf67d4c31e9..e323124a64235e8041d13d04635bcf69437f621d 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexdouble.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexdouble.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_complexdouble.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_complexdouble.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexfloat.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexfloat.cpp
index da4d5d3c7701c90e1c54566e4149220bc95f6651..c45d6fd5d11f88530ed910a52b9e76aa0f5555d8 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexfloat.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_complexfloat.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_complexfloat.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_complexfloat.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_double.cpp
index 27589459243f5805b68e213407876eb838c52ca1..54d4670e0818155dc56c6ac04e3bf461e538323e 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_float.cpp
index 737ef3d3b56111f2fa72b5be5c4e1b5405c03f3e..399bf0fcace2b4f5c6f95c92ed43b68421886ebf 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_int.cpp
index 01d2310c4101acb5f54a139d8adbe0f978ab8968..6091ff0f7686a319e77acc5d26c3b082ff785a03 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longint.cpp
index de5c0882f7cdbf5b6a3e855732dbc6d6b3d169e1..b877ff011dbebbce53eeebe98ac004308ecd086d 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longlongint.cpp
index 9ca025a40a74a4cce89f3c9e04d930f1f9066cd3..8234e356f21b2f943d3246f0843e5d16c2802fb8 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedint.cpp
index 12158f128c862e1305f624e4fbc31e3361d1ae9d..86cfac901cfd0c05e199c511275238db1665fec1 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedlongint.cpp
index a06d4099d80f63732abc264898c7c113d92b705c..fe5c3f085bd6ef2312fdde084ef4c75e70051753 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicViews.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicViews.cpp
index a9232540e888e7b2c79769b372e496e37854d8d6..b38c7cafb248bc56d6df9ab7a45de28a2532ac0f 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicViews.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_AtomicViews.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestAtomicViews.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestAtomicViews.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Atomics.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Atomics.cpp
index 8285bc97f71a8a41973a719d9846e80f52e61dd0..1bcbd3a625fa0679b1a7766be0f6a2df4cca900c 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmptarget/TestOpenMPTarget_Category.hpp>
 #include <TestAtomic.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Category.hpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Category.hpp
index 263e6075242b3c5ee7a4588cdba9a8a3e855d66b..58aa0cc782080e255264d57b5f9838fb60ab83cd 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Category.hpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class openmptarget : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY openmptarget
+#define TEST_CATEGORY_DEATH openmptarget_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::OpenMPTarget
 
 #endif
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Complex.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Complex.cpp
index 5d0525f1b05fe10b1ea05a8b0f7e323ec830c3e6..5e62bc85be42d24dd2a92deb991e2582c9192663 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Complex.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Complex.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_DeepCopyAlignment.cpp
index 62af98a7312ad33fce0a4b57a06edc610b0b088f..01885d0d828c86df889eea60548721492af57a6c 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_DeepCopyAlignment.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_DeepCopyAlignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Init.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Init.cpp
index 957bfe359a623d3f386a6b6c9a8b6a20807e051e..ebcbbb3aefb70ac87a72be206e1a1a576c330f0f 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Init.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Init.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,7 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestInit.hpp>
-#include<TestCompilerMacros.hpp>
-#include<TestPolicyConstruction.hpp>
-
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestInit.hpp>
+#include <TestCompilerMacros.hpp>
+#include <TestPolicyConstruction.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_a.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_a.cpp
index 9b0a1f26c6afa49f60f6e4735e8c35cd90fc6739..4f4f8b06c522c668170a5919ab88bcfacf2e6d79 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_b.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_b.cpp
index 05b5ad4566ce8adc0427a1ab7dc03c07aa7525f8..1032d8221026d188778f77046f4da26ae1b170df 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_c.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_c.cpp
index 14a9d8ad61979a1099b5fcfb524abcf773eefd4a..59d165ab4716080569efc3ad54e13b9ea2c7c6e3 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_d.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_d.cpp
index 003314440350931d5a4260ad53008e4322788df7..49603de6f41865585752e145dfb6458313a18f8e 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_e.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_e.cpp
index 4098d8c7ea3aaaeeb9e91f799f6fef97186c345e..dd6d96630bf0a0972fa7c942ca987046abf6d95a 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Other.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Other.cpp
index fce37dd719ac3ea76303fe6e955ac2bccb18ed59..aba91aee2b3c49297878399d9129354294e3d209 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Other.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Other.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,9 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestTemplateMetaFunctions.hpp>
-#include<TestAggregate.hpp>
-#include<TestMemoryPool.hpp>
-#include<TestCXX11.hpp>
-#include<TestTile.hpp>
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestTemplateMetaFunctions.hpp>
+#include <TestAggregate.hpp>
+#include <TestMemoryPool.hpp>
+#include <TestCXX11.hpp>
+#include <TestTile.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_RangePolicy.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_RangePolicy.cpp
index 4fea6a32b4745d082b4254c1ce74b468f82ac909..d9a5bac68f89161de1d4b3a6e0f83e74dad69b09 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_RangePolicy.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_RangePolicy.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestRange.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestRange.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_a.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_a.cpp
index bee82e63170f7d95d97b366f2429ba58ed5f7dc7..311c7a93b484e73073af8ea5ff43fa952e8d8c53 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_a.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_b.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_b.cpp
index 1ac4db8406b307df0453c0575084a092793dddc8..d5f6b8bc4dcd5d8f35c7a455bd44048e6defd4fd 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_b.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_c.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_c.cpp
index f2c0f0d1dccf341f8a0e4e108c9a13b34dc73159..e421033e0644be58af5253c9c54cd275310b78f5 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_c.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_d.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_d.cpp
index 079c05320d7333dc247e3c2b5c2a1e09b22079d4..ec30e97d3b53a83b00d25759c841892cd3198c62 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_d.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reducers_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reductions.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reductions.cpp
index 1052fea30175f25decbcf66c6ad27c9a1a94cebf..af1d06f0c1a59215ec86a78f72f63be63893cabd 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Scan.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Scan.cpp
index 56fc1a00a529b8650039d7ca42b2f93389629d13..50cc88914f304eeb0866872c22fdeae6ad2643b5 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Scan.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Scan.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<openmptarget/TestOpenMPTarget_Category.hpp>
-#include<TestScan.hpp>
-
+#include <openmptarget/TestOpenMPTarget_Category.hpp>
+#include <TestScan.hpp>
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SharedAlloc.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SharedAlloc.cpp
index e3e8ac281455f32a2f0b54dded26811d9ee729a3..aa0d9cfe27d9260761c6e6c327afc196f2237091 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,9 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< Kokkos::Experimental::OpenMPTargetSpace, Kokkos::DefaultHostExecutionSpace >();
+TEST_F(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<Kokkos::Experimental::OpenMPTargetSpace,
+                    Kokkos::DefaultHostExecutionSpace>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_a.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_a.cpp
index 7a273446a52bcd6f63ea88f307e2ca7836966313..6f6255af87a4c0a8940138404e2f84d10e29cce3 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,66 +47,56 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_left )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_auto_1d_left) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutLeft, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_right )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutRight, TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_auto_1d_right) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutRight, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_stride )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutStride, TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_auto_1d_stride) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutStride, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_assign_strided )
-{
-  TestViewSubview::test_1d_strided_assignment< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_assign_strided) {
+  TestViewSubview::test_1d_strided_assignment<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_0 )
-{
-  TestViewSubview::test_left_0< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_0) {
+  TestViewSubview::test_left_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_1 )
-{
-  TestViewSubview::test_left_1< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_1) {
+  TestViewSubview::test_left_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_2 )
-{
-  TestViewSubview::test_left_2< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_2) {
+  TestViewSubview::test_left_2<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_3 )
-{
-  TestViewSubview::test_left_3< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_3) {
+  TestViewSubview::test_left_3<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_0 )
-{
-  TestViewSubview::test_right_0< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_right_0) {
+  TestViewSubview::test_right_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_1 )
-{
-  TestViewSubview::test_right_1< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_right_1) {
+  TestViewSubview::test_right_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_3 )
-{
-  TestViewSubview::test_right_3< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_right_3) {
+  TestViewSubview::test_right_3<TEST_EXECSPACE>();
 }
 
-TEST_F(TEST_CATEGORY, view_static_tests)
-{
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutLeft>()();
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutRight>()();
+TEST_F(TEST_CATEGORY, view_static_tests) {
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutLeft>()();
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutRight>()();
   TestViewSubview::TestExtentsStaticTests<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_b.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_b.cpp
index 5b84bc623fbb0e8325c9d1335704aba462e9162e..7f0751e6cb4aacd2eb532f1d4e048a0e6bae5b78 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,18 +47,20 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_layoutleft_to_layoutleft )
-{
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_layoutleft_to_layoutleft) {
+  TestViewSubview::test_layoutleft_to_layoutleft<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_layoutright_to_layoutright )
-{
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_layoutright_to_layoutright) {
+  TestViewSubview::test_layoutright_to_layoutright<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c01.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c01.cpp
index 8b8d3fd5e75ed38fca7968bcce231a9de2feeeae..953c383bf98d0936a215065242e61b86fcb3c586 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_1d_assign) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c02.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c02.cpp
index bb1d02436769a61fb2ba6ac73e03390a93ba63af..3a6245e258173d49ab59bbdc1b88ce2e4d086775 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_atomic )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(TEST_CATEGORY, view_subview_1d_assign_atomic) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE,
+                                  Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c03.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c03.cpp
index ec31b3688e6c4018970f865faf03d5dbdbb56f36..e9e912dd0e7d8e16ad2e15554596b00a74131260 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_randomaccess )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_1d_assign_randomaccess) {
+  TestViewSubview::test_1d_assign<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c04.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c04.cpp
index c1db2cf0ec44bd069024e6fcc5d00a63c71e705e..0c5b9c8c019f5e28d81a2c9c06e0feac577bda5d 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_2d_from_3d) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c05.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c05.cpp
index a4d30f68b80a68ba4431db610c99e6ad104fdc4c..0e11c637e615eb3847d0391488af578ea7d398d4 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( openmptarget, view_subview_2d_from_3d_atomic )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(openmptarget, view_subview_2d_from_3d_atomic) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE,
+                                      Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c06.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c06.cpp
index 34b4dfb4092f84614a0cc4bfa3ba2b29a3b9dfef..e9a30a1835ac50df52bd3498e1ee4b14682f6ea7 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_randomaccess )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_2d_from_3d_randomaccess) {
+  TestViewSubview::test_2d_subview_3d<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c07.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c07.cpp
index 50ac0b06acbe83438df054153545b30ffdf14ac4..7d230d7e8547eed11866497c51a310622721d77d 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_left) {
+  TestViewSubview::test_3d_subview_5d_left<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c08.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c08.cpp
index 5da4797472cc8d3c7e19f67c102abc5a575844d3..e0b1f17a9869f5b872a3e737ce01de57de4eddc4 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_left_atomic) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c09.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c09.cpp
index 9041e5121dc7782aa9e6a2133bc2cf36f9aa3725..0b5d94b5274bba68f040429253fb1a484d2884e8 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c10.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c10.cpp
index 3887d2b70820002469900f2e6bf7cdb15b544eec..da2605da03ad63f495fd856c623549965045bf92 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_right) {
+  TestViewSubview::test_3d_subview_5d_right<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c11.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c11.cpp
index 4e36841887ee074b9bcb13c934b2d3cfecb4a17c..3aa927190c7bb1de77f78f2d62fb334c0397284f 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_right_atomic) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c12.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c12.cpp
index dc33f1e0a924e66fc6ab23a287e2a7079de17209..dde0db7dd84f22b53dbe8f94d1bd89af316d1810 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Team.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Team.cpp
index 4eef325ea1ef0f0684a3f1d3cdf1d66621295e46..f2d063c25f94479b0c8ecfe6f649e053ea9508dd 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Team.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,30 +47,37 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_for )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 0 );
+TEST_F(TEST_CATEGORY, team_for) {
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      0);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      0);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 2 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      2);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      2);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 1000 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      1000);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      1000);
 }
 
-
-TEST_F( TEST_CATEGORY, team_reduce )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 1000 );
-}
+TEST_F(TEST_CATEGORY, team_reduce) {
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(1000);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(1000);
 }
+}  // namespace Test
 
 #include <TestTeamVector.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamReductionScan.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamReductionScan.cpp
index b8ea6ce7aea1fa1ffd85a5a9cd15886d0b6885d6..233fd9d86171c9104584e63b8c5ef75d6c7be10f 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamReductionScan.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamReductionScan.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,36 +47,35 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, team_scan )
-{
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10000 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10000 );
+TEST_F(TEST_CATEGORY, team_scan) {
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10000);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10000);
 }
 
-TEST_F( TEST_CATEGORY, team_long_reduce )
-{
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST_F(TEST_CATEGORY, team_long_reduce) {
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-TEST_F( TEST_CATEGORY, team_double_reduce )
-{
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST_F(TEST_CATEGORY, team_double_reduce) {
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamScratch.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamScratch.cpp
index f13bfd2dcbec815696ec5c688ef4507cae14701f..b0a75432d76f5bee0563ac44ae7a3a6de4850628 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamScratch.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_TeamScratch.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,38 +47,34 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_shared_request )
-{
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST_F(TEST_CATEGORY, team_shared_request) {
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, team_scratch_request )
-{
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST_F(TEST_CATEGORY, team_scratch_request) {
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-TEST_F( TEST_CATEGORY, team_lambda_shared_request )
-{
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+TEST_F(TEST_CATEGORY, team_lambda_shared_request) {
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Static> >();
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 #endif
 #endif
 
-TEST_F( TEST_CATEGORY, shmem_size )
-{
-  TestShmemSize< TEST_EXECSPACE >();
-}
+TEST_F(TEST_CATEGORY, shmem_size) { TestShmemSize<TEST_EXECSPACE>(); }
 
-TEST_F( TEST_CATEGORY, multi_level_scratch )
-{
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST_F(TEST_CATEGORY, multi_level_scratch) {
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Static> >();
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_a.cpp
index afa9631a884d9879801943e7ed6e535b3c6ca9c5..697c374b88cac91da5d19627b4343cf17b68c1a7 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_b.cpp
index bb5272d2ce7671f69cce7a3633455fd882a9d64a..5290d9e7b8e8836d1f8e618e7212aa1ac5561427 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_c.cpp
index bc34437c0e3ff17820e8fcacd18acd6a577360ef..b882c5e4230469a90636ceec5a1576bf98f2c9c2 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_d.cpp
index 48478f52ad060692f9d7e00204ff111c2f4d253b..7f85ddbc5a5c79485f0128a13bf23f8bf61f5331 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_e.cpp
index 27f9702ff22fdbf8b37c81947efa52dcf51c4459..ff9d7fe2bc60c2fa43855dd6b57e1da5f915e784 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_a.cpp
index b9a84fdc1fe7b0110a3c589a2d573224fb19ea18..bbacbeda7abedeff4f6a1c13a7436012bac827ac 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmptarget/TestOpenMPTarget_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_b.cpp
index a749270ed1637569113aef6bfe70534c1c483ae6..87ce96359850c7f0cb4cc32f7d1240083660507b 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmptarget/TestOpenMPTarget_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_subview.cpp
index 5dc6517529c7fd2de52cfa277d13cc8fa98c99ae..b187afe400d68cd449ef6dfb36870f5ad6f0076b 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmptarget/TestOpenMPTarget_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewOfClass.cpp b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewOfClass.cpp
index 9d7c49ee46e9d0c8c88e6206eb2bba58743ca24b..c2b40a3020866e1f9d26b54284c1cf8489f8ae8e 100644
--- a/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewOfClass.cpp
+++ b/lib/kokkos/core/unit_test/openmptarget/TestOpenMPTarget_ViewOfClass.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <openmptarget/TestOpenMPTarget_Category.hpp>
 #include <TestViewOfClass.hpp>
-
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexdouble.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexdouble.cpp
index f579ff2e5a322bd464cc20b7489bc0c86626df96..9c6589539a981e6c9eceea5713d7775e490713bb 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexdouble.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexdouble.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_complexdouble.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_complexdouble.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexfloat.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexfloat.cpp
index c5d1ab922c7a196f00d58cff7ec97da2c6d6306f..1163da7285d45cc56b9920fb48b0220920b4a9eb 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexfloat.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_complexfloat.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_complexfloat.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_complexfloat.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_double.cpp
index 88b50511d98bb9406e29d95827682ef30357d447..aee8ccde7fc79335591ebd22860f97ae0553dacf 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_float.cpp
index 683c210ffb906c766e8a46d2232d45c60d943005..0bfa8d43d6aa9a12d26813781c2d796e70cfc77b 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_int.cpp
index 0fd097b765e83a51bc95e89956e2ac5bec39f7c8..8900daf81ea5aaa6482d87a5106d6a0d11b9403e 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longint.cpp
index 6bf510e383f5799938e6e67a718808d886f1d68f..9dcff9231284beda7f3ab416628d2a94afd40fa3 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longlongint.cpp
index c230e5176dd03d5c179bef04ba9b6a98397ed758..0f5a0b7df744d4658cab72b199159136b6ab4e90 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedint.cpp
index 7f4a2bcdd05348760d0c510eaa089a4dae43e344..eee44e84a322f20c9d1c149d54731ad9a6671f08 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedlongint.cpp
index be953718ee13ef79481cd63a6d597db1a988d74e..9379a6efa87e2b12dc85f57b1296ff529b47df67 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_a.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_a.cpp
index c628c7b8c4dd65375ae67bdccd97a771f086caee..7067d841e3e3458a5d9828846b2b8602098d46cb 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_b.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_b.cpp
index 578b3179445f9ec313104e23b3641ea51d082f45..1f4ba9c984f6e0ee7fc24293793a80f0b2f74b0e 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_c.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_c.cpp
index 2bfa00b55a80e4e31a63a7f42d51b5d35ecbaa05..37b4671d0553339a98090f6c3b4c36f77d6b6f74 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_d.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_d.cpp
index 6e167b343dcc589354f29128d298eb6f57f5ac34..2bd1fbbfd512b06204ca940c6cd816a10e44ca8a 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_e.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_e.cpp
index 1045fa1191ec3e47291e5d4237f0526bc4b9db58..659dd23d7fd03e9ad8a86fa22250c90002ed2d99 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<qthreads/TestQqthreads_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <qthreads/TestQqthreads_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_a.cpp
index 1b99fda819851ccd92670c700fff6ccbd556a4a4..4339c1b5a020b17aec80ad9cc4dafec5f92e28c4 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_b.cpp
index 2f8ab0e1c1c98d53d4d8705c6995c704e33bbfd5..bcbef94ab7ee63c11d8fc8dbe35c64ea8e528380 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_c.cpp
index dd5f532c1032e71e751c506bd2b2b3f3523e2c4e..21c9fd890cf8240e5f21c565ef78f8eb3d7463fe 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_d.cpp
index 11076b82bdaebf8e3dcc7e483af92ba04e8c6da9..ef4bddc57253cfc1f14397f2adfd116e57e97f7b 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_e.cpp
index a81e0b0062ba8c8304f43d87554a32b46b8d0322..bba5916a5ab99d29181670aca118b708aae58248 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQqthreads_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads.hpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads.hpp
index 989ea48ce679c43c108296c6ce6dde9a42302d95..c45433d77d4f2b34102f8bc8092745e4e9e6c86d 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads.hpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -82,28 +83,27 @@
 namespace Test {
 
 class qthreads : public ::testing::Test {
-protected:
-  static void SetUpTestCase()
-  {
-    const unsigned numa_count       = Kokkos::hwloc::get_available_numa_count();
-    const unsigned cores_per_numa   = Kokkos::hwloc::get_available_cores_per_numa();
-    const unsigned threads_per_core = Kokkos::hwloc::get_available_threads_per_core();
+ protected:
+  static void SetUpTestCase() {
+    const unsigned numa_count = Kokkos::hwloc::get_available_numa_count();
+    const unsigned cores_per_numa =
+        Kokkos::hwloc::get_available_cores_per_numa();
+    const unsigned threads_per_core =
+        Kokkos::hwloc::get_available_threads_per_core();
 
-    const unsigned threads_count = std::max( 1u, numa_count ) *
-                                   std::max( 2u, ( cores_per_numa * threads_per_core ) / 2 );
+    const unsigned threads_count =
+        std::max(1u, numa_count) *
+        std::max(2u, (cores_per_numa * threads_per_core) / 2);
 
-    Kokkos::Qthreads::initialize( threads_count );
-    Kokkos::print_configuration( std::cout, true );
+    Kokkos::Qthreads::initialize(threads_count);
+    Kokkos::print_configuration(std::cout, true);
 
-    srand( 10231 );
+    srand(10231);
   }
 
-  static void TearDownTestCase()
-  {
-    Kokkos::Qthreads::finalize();
-  }
+  static void TearDownTestCase() { Kokkos::Qthreads::finalize(); }
 };
 
-} // namespace Test
+}  // namespace Test
 
 #endif
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Atomics.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Atomics.cpp
index 199dbdcb9c47b9f596c78efee8acd58f177e6745..5642bad262f5d19972c0d22432ccf5dd65cb18bc 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,8 +46,7 @@
 
 namespace Test {
 
-TEST_F( qthreads, atomics )
-{
+TEST_F(qthreads, atomics) {
 #if 0
   const int loop_count = 1e4;
 
@@ -88,8 +88,7 @@ TEST_F( qthreads, atomics )
 #endif
 }
 
-TEST_F( qthreads, atomic_operations )
-{
+TEST_F(qthreads, atomic_operations) {
 #if 0
   const int start = 1; // Avoid zero for division.
   const int end = 11;
@@ -169,8 +168,7 @@ TEST_F( qthreads, atomic_operations )
 #endif
 }
 
-TEST_F( qthreads, atomic_views_integral )
-{
+TEST_F(qthreads, atomic_views_integral) {
 #if 0
   const long length = 1000000;
 
@@ -188,8 +186,7 @@ TEST_F( qthreads, atomic_views_integral )
 #endif
 }
 
-TEST_F( qthreads, atomic_views_nonintegral )
-{
+TEST_F(qthreads, atomic_views_nonintegral) {
 #if 0
   const long length = 1000000;
 
@@ -203,11 +200,10 @@ TEST_F( qthreads, atomic_views_nonintegral )
 #endif
 }
 
-TEST_F( qthreads, atomic_view_api )
-{
+TEST_F(qthreads, atomic_view_api) {
 #if 0
   TestAtomicViews::TestAtomicViewAPI< int, Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Category.hpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Category.hpp
index fdbb88a97961859918cef693b5a556e0376940ca..fc0a08870044a6b6949f4928efca4e24a457ab84 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Category.hpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class qthreads : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY qthreads
+#define TEST_CATEGORY_DEATH qthreads_DeathTest
 #define TEST_EXECSPACE Kokkos::Qthreads
 
 #endif
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Complex.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Complex.cpp
index 799b8454f8d8922bd5a509ed819d3f3adda57c26..09e1ca3e24c0b18bb6734cc5dd7627370e399c4e 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Complex.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Complex.cpp
@@ -1,3 +1,2 @@
-#include<qthreads/TestQthreads_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <qthreads/TestQthreads_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_DeepCopyAlignment.cpp
index 22d9dbb2f10cfd823023ed52561cc44885812ba5..edfaa08d29ec24ae5bde5f799f1bc647fb928dff 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_DeepCopyAlignment.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_DeepCopyAlignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Other.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Other.cpp
index a4c1ec227835eb581a4d5a73e116feeeea425f6c..7d5461661319cd67365650062407f0f35da7f321 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Other.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Other.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,29 +46,23 @@
 
 namespace Test {
 
-TEST_F( qthreads, init )
-{
-  ;
-}
+TEST_F(qthreads, init) { ; }
 
-TEST_F( qthreads, md_range )
-{
+TEST_F(qthreads, md_range) {
 #if 0
   TestMDRange_2D< Kokkos::Qthreads >::test_for2( 100, 100 );
   TestMDRange_3D< Kokkos::Qthreads >::test_for3( 100, 100, 100 );
 #endif
 }
 
-TEST_F( qthreads, policy_construction )
-{
+TEST_F(qthreads, policy_construction) {
 #if 0
   TestRangePolicyConstruction< Kokkos::Qthreads >();
   TestTeamPolicyConstruction< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, range_tag )
-{
+TEST_F(qthreads, range_tag) {
 #if 0
   TestRange< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
   TestRange< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
@@ -99,8 +94,7 @@ TEST_F( qthreads, range_tag )
 
 //----------------------------------------------------------------------------
 
-TEST_F( qthreads, compiler_macros )
-{
+TEST_F(qthreads, compiler_macros) {
 #if 0
   ASSERT_TRUE( ( TestCompilerMacros::Test< Kokkos::Qthreads >() ) );
 #endif
@@ -108,8 +102,7 @@ TEST_F( qthreads, compiler_macros )
 
 //----------------------------------------------------------------------------
 
-TEST_F( qthreads, memory_pool )
-{
+TEST_F(qthreads, memory_pool) {
 #if 0
 
 #endif
@@ -117,10 +110,9 @@ TEST_F( qthreads, memory_pool )
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_ENABLE_TASKDAG )
+#if defined(KOKKOS_ENABLE_TASKDAG)
 
-TEST_F( qthreads, task_fib )
-{
+TEST_F(qthreads, task_fib) {
 #if 0
   const int N = 24 ; // 25 triggers tbd bug on Cuda/Pascal
   for ( int i = 0; i < N; ++i ) {
@@ -129,8 +121,7 @@ TEST_F( qthreads, task_fib )
 #endif
 }
 
-TEST_F( qthreads, task_depend )
-{
+TEST_F(qthreads, task_depend) {
 #if 0
   for ( int i = 0; i < 25; ++i ) {
     TestTaskScheduler::TestTaskDependence< Kokkos::Qthreads >::run( i );
@@ -138,22 +129,20 @@ TEST_F( qthreads, task_depend )
 #endif
 }
 
-TEST_F( qthreads, task_team )
-{
+TEST_F(qthreads, task_team) {
 #if 0
   TestTaskScheduler::TestTaskTeam< Kokkos::Qthreads >::run( 1000 );
   //TestTaskScheduler::TestTaskTeamValue< Kokkos::Qthreads >::run( 1000 ); // Put back after testing.
 #endif
 }
 
-#endif // #if defined( KOKKOS_ENABLE_TASKDAG )
+#endif  // #if defined( KOKKOS_ENABLE_TASKDAG )
 
 //----------------------------------------------------------------------------
 
-#if defined( KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS )
+#if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_QTHREADS)
 
-TEST_F( qthreads, cxx11 )
-{
+TEST_F(qthreads, cxx11) {
 #if 0
   if ( std::is_same< Kokkos::DefaultExecutionSpace, Kokkos::Qthreads >::value ) {
     ASSERT_TRUE( ( TestCXX11::Test< Kokkos::Qthreads >( 1 ) ) );
@@ -166,8 +155,7 @@ TEST_F( qthreads, cxx11 )
 
 #endif
 
-TEST_F( qthreads, tile_layout )
-{
+TEST_F(qthreads, tile_layout) {
 #if 0
   TestTile::test< Kokkos::Qthreads, 1, 1 >( 1, 1 );
   TestTile::test< Kokkos::Qthreads, 1, 1 >( 2, 3 );
@@ -193,8 +181,7 @@ TEST_F( qthreads, tile_layout )
 #endif
 }
 
-TEST_F( qthreads, dispatch )
-{
+TEST_F(qthreads, dispatch) {
 #if 0
   const int repeat = 100;
   for ( int i = 0; i < repeat; ++i ) {
@@ -206,4 +193,4 @@ TEST_F( qthreads, dispatch )
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Reductions.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Reductions.cpp
index 6b8e001720880a215bd3470e3287f1e7bfd0e2e8..9e60ad123f638c85e27bbbaa3b721c3383bf4333 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,24 +46,21 @@
 
 namespace Test {
 
-TEST_F( qthreads, long_reduce )
-{
+TEST_F(qthreads, long_reduce) {
 #if 0
   TestReduce< long, Kokkos::Qthreads >( 0 );
   TestReduce< long, Kokkos::Qthreads >( 1000000 );
 #endif
 }
 
-TEST_F( qthreads, double_reduce )
-{
+TEST_F(qthreads, double_reduce) {
 #if 0
   TestReduce< double, Kokkos::Qthreads >( 0 );
   TestReduce< double, Kokkos::Qthreads >( 1000000 );
 #endif
 }
 
-TEST_F( qthreads, reducers )
-{
+TEST_F(qthreads, reducers) {
 #if 0
   TestReducers< int, Kokkos::Qthreads >::execute_integer();
   TestReducers< size_t, Kokkos::Qthreads >::execute_integer();
@@ -71,32 +69,28 @@ TEST_F( qthreads, reducers )
 #endif
 }
 
-TEST_F( qthreads, long_reduce_dynamic )
-{
+TEST_F(qthreads, long_reduce_dynamic) {
 #if 0
   TestReduceDynamic< long, Kokkos::Qthreads >( 0 );
   TestReduceDynamic< long, Kokkos::Qthreads >( 1000000 );
 #endif
 }
 
-TEST_F( qthreads, double_reduce_dynamic )
-{
+TEST_F(qthreads, double_reduce_dynamic) {
 #if 0
   TestReduceDynamic< double, Kokkos::Qthreads >( 0 );
   TestReduceDynamic< double, Kokkos::Qthreads >( 1000000 );
 #endif
 }
 
-TEST_F( qthreads, long_reduce_dynamic_view )
-{
+TEST_F(qthreads, long_reduce_dynamic_view) {
 #if 0
   TestReduceDynamicView< long, Kokkos::Qthreads >( 0 );
   TestReduceDynamicView< long, Kokkos::Qthreads >( 1000000 );
 #endif
 }
 
-TEST_F( qthreads, scan )
-{
+TEST_F(qthreads, scan) {
 #if 0
   TestScan< Kokkos::Qthreads >::test_range( 1, 1000 );
   TestScan< Kokkos::Qthreads >( 0 );
@@ -106,8 +100,7 @@ TEST_F( qthreads, scan )
 #endif
 }
 
-TEST_F( qthreads, scan_small )
-{
+TEST_F(qthreads, scan_small) {
 #if 0
   typedef TestScan< Kokkos::Qthreads, Kokkos::Impl::QthreadsExecUseScanSmall > TestScanFunctor;
 
@@ -122,8 +115,7 @@ TEST_F( qthreads, scan_small )
 #endif
 }
 
-TEST_F( qthreads, team_scan )
-{
+TEST_F(qthreads, team_scan) {
 #if 0
   TestScanTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >( 0 );
   TestScanTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
@@ -134,8 +126,7 @@ TEST_F( qthreads, team_scan )
 #endif
 }
 
-TEST_F( qthreads, team_long_reduce )
-{
+TEST_F(qthreads, team_long_reduce) {
 #if 0
   TestReduceTeam< long, Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >( 0 );
   TestReduceTeam< long, Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
@@ -146,8 +137,7 @@ TEST_F( qthreads, team_long_reduce )
 #endif
 }
 
-TEST_F( qthreads, team_double_reduce )
-{
+TEST_F(qthreads, team_double_reduce) {
 #if 0
   TestReduceTeam< double, Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >( 0 );
   TestReduceTeam< double, Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
@@ -158,11 +148,10 @@ TEST_F( qthreads, team_double_reduce )
 #endif
 }
 
-TEST_F( qthreads, reduction_deduction )
-{
+TEST_F(qthreads, reduction_deduction) {
 #if 0
   TestCXX11::test_reduction_deduction< Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_a.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_a.cpp
index 8fdee75d86b1c479b5cd4a97a84c892ff74c4971..f3d3396520a171a9aa47828ac3d4527a3bd15fea 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,81 +46,70 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_auto_1d_left )
-{
+TEST_F(qthreads, view_subview_auto_1d_left) {
 #if 0
   TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_auto_1d_right )
-{
+TEST_F(qthreads, view_subview_auto_1d_right) {
 #if 0
   TestViewSubview::test_auto_1d< Kokkos::LayoutRight, Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_auto_1d_stride )
-{
+TEST_F(qthreads, view_subview_auto_1d_stride) {
 #if 0
   TestViewSubview::test_auto_1d< Kokkos::LayoutStride, Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_assign_strided )
-{
+TEST_F(qthreads, view_subview_assign_strided) {
 #if 0
   TestViewSubview::test_1d_strided_assignment< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_left_0 )
-{
+TEST_F(qthreads, view_subview_left_0) {
 #if 0
   TestViewSubview::test_left_0< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_left_1 )
-{
+TEST_F(qthreads, view_subview_left_1) {
 #if 0
   TestViewSubview::test_left_1< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_left_2 )
-{
+TEST_F(qthreads, view_subview_left_2) {
 #if 0
   TestViewSubview::test_left_2< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_left_3 )
-{
+TEST_F(qthreads, view_subview_left_3) {
 #if 0
   TestViewSubview::test_left_3< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_right_0 )
-{
+TEST_F(qthreads, view_subview_right_0) {
 #if 0
   TestViewSubview::test_right_0< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_right_1 )
-{
+TEST_F(qthreads, view_subview_right_1) {
 #if 0
   TestViewSubview::test_right_1< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_subview_right_3 )
-{
+TEST_F(qthreads, view_subview_right_3) {
 #if 0
   TestViewSubview::test_right_3< Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_b.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_b.cpp
index e32a42461bb78b37a5796eb4d4a2ca69819024a5..6ef5dc4cf124674fe0126301db5f744221eddc15 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,8 +46,7 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_layoutleft_to_layoutleft )
-{
+TEST_F(qthreads, view_subview_layoutleft_to_layoutleft) {
 #if 0
   TestViewSubview::test_layoutleft_to_layoutleft< Kokkos::Qthreads >();
   TestViewSubview::test_layoutleft_to_layoutleft< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::Atomic> >();
@@ -54,8 +54,7 @@ TEST_F( qthreads, view_subview_layoutleft_to_layoutleft )
 #endif
 }
 
-TEST_F( qthreads, view_subview_layoutright_to_layoutright )
-{
+TEST_F(qthreads, view_subview_layoutright_to_layoutright) {
 #if 0
   TestViewSubview::test_layoutright_to_layoutright< Kokkos::Qthreads >();
   TestViewSubview::test_layoutright_to_layoutright< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::Atomic> >();
@@ -63,4 +62,4 @@ TEST_F( qthreads, view_subview_layoutright_to_layoutright )
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c01.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c01.cpp
index a0ada2859d126858435ce0286b606890934056b4..1f560c24f687133b7fde206ad3bddd341a6fef1f 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_1d_assign )
-{
+TEST_F(qthreads, view_subview_1d_assign) {
 #if 0
   TestViewSubview::test_1d_assign< Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c02.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c02.cpp
index 1b0e09811347b63a515c643b8ac123e85e34997e..e4065d22b271ad988271ee89cbba0e4faa142f50 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_1d_assign_atomic )
-{
+TEST_F(qthreads, view_subview_1d_assign_atomic) {
 #if 0
   TestViewSubview::test_1d_assign< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c03.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c03.cpp
index 2062fbeaf023286c0d18857421f2a0948408087a..89b68ae42c1eaca3819121013165a23b25d8f7be 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_1d_assign_randomaccess )
-{
+TEST_F(qthreads, view_subview_1d_assign_randomaccess) {
 #if 0
   TestViewSubview::test_1d_assign< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c04.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c04.cpp
index 07b84de90e30fbe1422deaeb6e6b5349e7c600d1..0ee4d6887c9b82d27820f7f560f220e361768693 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_2d_from_3d )
-{
+TEST_F(qthreads, view_subview_2d_from_3d) {
 #if 0
   TestViewSubview::test_2d_subview_3d< Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c05.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c05.cpp
index 4d5d2a9915aafe02382b181ff75c70f774a2ba4c..1e6b6736621dc44ec1c08b1619ec92e0f16c0bf8 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_2d_from_3d_atomic )
-{
+TEST_F(qthreads, view_subview_2d_from_3d_atomic) {
 #if 0
   TestViewSubview::test_2d_subview_3d< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c06.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c06.cpp
index 4330f00a6242a3aefe7a89c23eff6b81f5b6eb4d..b2ef924f875f04d051fe788d12400025db83056b 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_2d_from_3d_randomaccess )
-{
+TEST_F(qthreads, view_subview_2d_from_3d_randomaccess) {
 #if 0
   TestViewSubview::test_2d_subview_3d< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c07.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c07.cpp
index 154f5de69481574a9bd304593dc89b08c25a1cf4..5857f67d19dbcd4e43cda0372d0f60bb5b591b75 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_3d_from_5d_left )
-{
+TEST_F(qthreads, view_subview_3d_from_5d_left) {
 #if 0
   TestViewSubview::test_3d_subview_5d_left< Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c08.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c08.cpp
index 66832558de433055f4e8a74b106cfb591143d6cf..0bc591c128f9b67db57a265fbee1315d6a14ccc0 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_3d_from_5d_left_atomic )
-{
+TEST_F(qthreads, view_subview_3d_from_5d_left_atomic) {
 #if 0
   TestViewSubview::test_3d_subview_5d_left< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c09.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c09.cpp
index 5305ce1defe448030894dcb3e7dc9a0a56012b66..45d878fcea3d4e90acbad7893cdca72c992788c4 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_3d_from_5d_left_randomaccess )
-{
+TEST_F(qthreads, view_subview_3d_from_5d_left_randomaccess) {
 #if 0
   TestViewSubview::test_3d_subview_5d_left< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c10.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c10.cpp
index 039414a6813b28bda02f277b7d9b1322ddb7edf5..e42c464020d9efab7f6b5a8c60d963aaa44604bd 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_3d_from_5d_right )
-{
+TEST_F(qthreads, view_subview_3d_from_5d_right) {
 #if 0
   TestViewSubview::test_3d_subview_5d_right< Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c11.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c11.cpp
index 05dcde77e2219158f1a6789bbf6f2a2c8271b92e..6bfd19ad65a7284a51557b4f5c3394ac89501c3b 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_3d_from_5d_right_atomic )
-{
+TEST_F(qthreads, view_subview_3d_from_5d_right_atomic) {
 #if 0
   TestViewSubview::test_3d_subview_5d_right< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c12.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c12.cpp
index 58d79d609d1e13432ad63f36f7f20df0ac3a0cd5..9b6896d3eebbad2db8c434af53716b71767a0ab7 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_subview_3d_from_5d_right_randomaccess )
-{
+TEST_F(qthreads, view_subview_3d_from_5d_right_randomaccess) {
 #if 0
   TestViewSubview::test_3d_subview_5d_right< Kokkos::Qthreads, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c13.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c13.cpp
index 347c4a5b86a8b52c821f74a77adbbf1b08ba7817..e03190d5146c988729d44aaf5688cf700a856e33 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c13.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_SubView_c13.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,11 +46,10 @@
 
 namespace Test {
 
-TEST_F( qthreads, view_test_unmanaged_subview_reset )
-{
+TEST_F(qthreads, view_test_unmanaged_subview_reset) {
 #if 0
   TestViewSubview::test_unmanaged_subview_reset< TEST_EXECSPACE >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Team.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Team.cpp
index 2b0d397804cf7c77144992b6c60bdde0921f0107..6a4d9323a7148e38dd26b8c6c2a273973724091a 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_Team.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,8 +46,7 @@
 
 namespace Test {
 
-TEST_F( qthreads, team_tag )
-{
+TEST_F(qthreads, team_tag) {
 #if 0
   TestTeamPolicy< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
   TestTeamPolicy< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
@@ -65,25 +65,22 @@ TEST_F( qthreads, team_tag )
 #endif
 }
 
-TEST_F( qthreads, team_shared_request )
-{
+TEST_F(qthreads, team_shared_request) {
 #if 0
   TestSharedTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >();
   TestSharedTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Dynamic> >();
 #endif
 }
 
-TEST_F( qthreads, team_scratch_request )
-{
+TEST_F(qthreads, team_scratch_request) {
 #if 0
   TestScratchTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >();
   TestScratchTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Dynamic> >();
 #endif
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-TEST_F( qthreads, team_lambda_shared_request )
-{
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+TEST_F(qthreads, team_lambda_shared_request) {
 #if 0
   TestLambdaSharedTeam< Kokkos::HostSpace, Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >();
   TestLambdaSharedTeam< Kokkos::HostSpace, Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Dynamic> >();
@@ -91,23 +88,20 @@ TEST_F( qthreads, team_lambda_shared_request )
 }
 #endif
 
-TEST_F( qthreads, shmem_size )
-{
+TEST_F(qthreads, shmem_size) {
 #if 0
   TestShmemSize< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, multi_level_scratch )
-{
+TEST_F(qthreads, multi_level_scratch) {
 #if 0
   TestMultiLevelScratchTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Static> >();
   TestMultiLevelScratchTeam< Kokkos::Qthreads, Kokkos::Schedule<Kokkos::Dynamic> >();
 #endif
 }
 
-TEST_F( qthreads, team_vector )
-{
+TEST_F(qthreads, team_vector) {
 #if 0
   ASSERT_TRUE( ( TestTeamVector::Test< Kokkos::Qthreads >( 0 ) ) );
   ASSERT_TRUE( ( TestTeamVector::Test< Kokkos::Qthreads >( 1 ) ) );
@@ -124,14 +118,13 @@ TEST_F( qthreads, team_vector )
 }
 
 #ifdef KOKKOS_COMPILER_GNU
-#if ( KOKKOS_COMPILER_GNU == 472 )
+#if (KOKKOS_COMPILER_GNU == 472)
 #define SKIP_TEST
 #endif
 #endif
 
 #ifndef SKIP_TEST
-TEST_F( qthreads, triple_nested_parallelism )
-{
+TEST_F(qthreads, triple_nested_parallelism) {
 #if 0
   TestTripleNestedReduce< double, Kokkos::Qthreads >( 8192, 2048, 32, 32 );
   TestTripleNestedReduce< double, Kokkos::Qthreads >( 8192, 2048, 32, 16 );
@@ -140,4 +133,4 @@ TEST_F( qthreads, triple_nested_parallelism )
 }
 #endif
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_a.cpp
index a68049e79d19a92a015dc8936bc9c94ace1f17f5..fad6473d204c2c8837ea553fe3d6c116c2122325 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,12 +46,11 @@
 
 namespace Test {
 
-TEST_F( qthreads, impl_view_mapping_a )
-{
+TEST_F(qthreads, impl_view_mapping_a) {
 #if 0
   test_view_mapping< Kokkos::Qthreads >();
   test_view_mapping_operator< Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_b.cpp
index 3bfd1763b8179ded3bb080e8570da7339d32be52..b37937369a6df295d96e5e5e9e1fa7ef52995797 100644
--- a/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/qthreads/TestQthreads_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,37 +46,32 @@
 
 namespace Test {
 
-TEST_F( qthreads, impl_shared_alloc )
-{
+TEST_F(qthreads, impl_shared_alloc) {
 #if 0
   test_shared_alloc< Kokkos::HostSpace, Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, impl_view_mapping_b )
-{
+TEST_F(qthreads, impl_view_mapping_b) {
 #if 0
   test_view_mapping_subview< Kokkos::Qthreads >();
   TestViewMappingAtomic< Kokkos::Qthreads >::run();
 #endif
 }
 
-TEST_F( qthreads, view_api )
-{
+TEST_F(qthreads, view_api) {
 #if 0
   TestViewAPI< double, Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_nested_view )
-{
+TEST_F(qthreads, view_nested_view) {
 #if 0
   ::Test::view_nested_view< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, view_remap )
-{
+TEST_F(qthreads, view_remap) {
 #if 0
   enum { N0 = 3, N1 = 2, N2 = 8, N3 = 9 };
 
@@ -121,18 +117,16 @@ TEST_F( qthreads, view_remap )
 #endif
 }
 
-TEST_F( qthreads, view_aggregate )
-{
+TEST_F(qthreads, view_aggregate) {
 #if 0
   TestViewAggregate< Kokkos::Qthreads >();
 #endif
 }
 
-TEST_F( qthreads, template_meta_functions )
-{
+TEST_F(qthreads, template_meta_functions) {
 #if 0
   TestTemplateMetaFunctions< int, Kokkos::Qthreads >();
 #endif
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_Category.hpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_Category.hpp
index 208de62e0736c738160c46d013940658c6b7ade6..fc74d52b44caa8dfd49cc7d1e48f6cae4e01cdee 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_Category.hpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class rocm_hostpinned : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY rocm_hostpinned
+#define TEST_CATEGORY_DEATH rocm_hostpinned_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::ROCmHostPinnedSpace
 
 #endif
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_SharedAlloc.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_SharedAlloc.cpp
index de058aaead45a2b5564e9380183221624b3b318d..091cd74991229d18c649f6ec9c5b23cd4cbf9d48 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< TEST_EXECSPACE, Kokkos::DefaultHostExecutionSpace >();
+TEST_F(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<TEST_EXECSPACE, Kokkos::DefaultHostExecutionSpace>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_a.cpp
index 611f99c2dc60f402b80226567fb31b7a93799cdb..b3cce0daf66cd10ed231a65c07d72bd25127f2ff 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_b.cpp
index 4a391406b767d5454537cfba38c91d114279e456..edebed6961ad1b481a9e203314c92bebce6ba0e4 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_c.cpp
index e121ba68ed1e1e0fbe23b91e3d74973a0c8716b4..e2ffbd16a358e25a5a9921f5bad3e34370e8184d 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_d.cpp
index 00eb98dc4833f830c8a26bbb705b31c3c147c906..c88b1ecd3d6b7798bfcb949ff9cb355b2bee0a8b 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_e.cpp
index c62ec627d0f5ca70c0752ddf1f6b93084f2a6f88..216f72bd6bdd6a70c70904401f9c74f984cc1154 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewCopy.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewCopy.cpp
index 4636691d993db5257dd024f23fff81c527c0d67f..197c4c6794f19d42745c556235b66bcfe5e62d00 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewCopy.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewCopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_a.cpp
index 1e44f51778c3c034fa8c46089533f8c1a054b0f3..d1cb384b10c6dfe34e0bb3a74d9b1ff8df96db34 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCmHostPinned_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_b.cpp
index a5d68a0c6174e9de302cc813d526e4bab1d6f5c3..cde6d74509f1c4cd48d27bb9140984776600a2af 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCmHostPinned_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_subview.cpp
index ef9b8e3702913774614b0ba8f09c3b556c907f95..77deaedde3471ac2935df1b6e723690cb447ce14 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCmHostPinned_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_View_64bit.cpp b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_View_64bit.cpp
index d304f53cf7b4ce5e91eb8d931c5b741e5f5ed3cc..e21aeafe7b3796031c81fae54601ec0c60fc2232 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_View_64bit.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCmHostPinned_View_64bit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_double.cpp
index d5d97a45840507230a83dbbdddf1b796d7654596..98bda062780353211a9a204b25709d39484ddb7c 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_float.cpp
index c7aef83a2cad237e07b0b269da0a81e2f2dffd23..c8f85dccf28955ddcce4c6d60a3bd6c3b654fc3f 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_int.cpp
index 282741f2242b42ebee55eb2f7b61269ff6b9c866..83d36857ec44e2529480f3ad6b7938615da42dbf 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longint.cpp
index cd179d8bedac4abf42d806492b768a369e0bfce6..a0e02160f51b20c32d4dcdd5290488d64bf62e52 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longlongint.cpp
index 636d51a4b13cd5f53328ffd444e48445a2d17691..d7dac704e774dfe6e622188a5c725c8f17e82033 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedint.cpp
index f10ddde877308ced64d7c1b7100bcbd1fe1b1358..b3c4cf271b021cfa4a4fdcf757a91cbfc338c15c 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedlongint.cpp
index 4e9bd8a86ed39e7dc4ce3ab579acdb0d252d1e8c..0e6873ed4422bd59a8f77d29b842a195e6c03220 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicViews.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicViews.cpp
index 385fbe8bbbf1b8549f8a87dbc53a21b6981427f6..393562b88e858a12e13485939a3dbd1fc17f6c52 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicViews.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_AtomicViews.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestAtomicViews.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestAtomicViews.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Atomics.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Atomics.cpp
index a7cbc3de2f19ec25f0733a03c2bd8a310dcab4a5..2de70cd9ffbe92c38d475c32f70b69d65ed53768 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCm_Category.hpp>
 #include <TestAtomic.hpp>
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Category.hpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Category.hpp
index d520bbc5a7c827f78c3ac33e46bbfaf7e1c757e9..f89b18f498ac0ef7a16fb73e9b34a61d8503d715 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Category.hpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class rocm : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY rocm
+#define TEST_CATEGORY_DEATH rocm_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::ROCm
 
 #endif
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Complex.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Complex.cpp
index 5488925a5d6eea1617e026ca19929732b55a9edf..0e9e92addcc881849005f031863f97af6a3ee57e 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Complex.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Complex.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Crs.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Crs.cpp
index 05a90da83bc7343f1d2c2fd7486914aecdc82e7c..7dc9f71b7aafab8a8b6d282cf1d5f44d6aa3b0d2 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Crs.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Crs.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestCrs.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestCrs.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_DeepCopyAlignment.cpp
index 85fd89fb2650dee720c855cfd1db5ce05910d57c..e31c219802fa09b9c66cfd3c0ad59965fd84babd 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_DeepCopyAlignment.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_DeepCopyAlignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Init.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Init.cpp
index a1d47810bfbb02aeb4ae796595b4c2f3f33a53b8..d3a4addc19d632a77d6cf16ae3d302359fb96f5a 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Init.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Init.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,7 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestInit.hpp>
-#include<TestCompilerMacros.hpp>
-#include<TestPolicyConstruction.hpp>
-
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestInit.hpp>
+#include <TestCompilerMacros.hpp>
+#include <TestPolicyConstruction.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_a.cpp
index 23edcbcc3122eb2a094f2cf6a51b477fc2eca340..13b1b73852b36dc95bda468bc5c06e0fb2c259bc 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,13 +43,12 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange.hpp>
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange.hpp>
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_5d_reduce ) {
-  TestMDRange_5D< TEST_EXECSPACE >::test_reduce5( 100, 10, 10, 10, 5 );
-}
-
+TEST_F(TEST_CATEGORY, mdrange_5d_reduce) {
+  TestMDRange_5D<TEST_EXECSPACE>::test_reduce5(100, 10, 10, 10, 5);
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_b.cpp
index 5f02e893a93190a3d992c7e464a2afc1bb0a8c55..9181caaaf5ec7b6ff4c59364ce760aa535402180 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,13 +43,12 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange.hpp>
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange.hpp>
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_6d_reduce ) {
-  TestMDRange_6D< TEST_EXECSPACE >::test_reduce6( 10, 10, 10, 10, 10, 5 );
-}
-
+TEST_F(TEST_CATEGORY, mdrange_6d_reduce) {
+  TestMDRange_6D<TEST_EXECSPACE>::test_reduce6(10, 10, 10, 10, 10, 5);
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_c.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_c.cpp
index 6a84962d1673d520005c96451ca48c95b130a288..e9cdb6fe94a511a85f3569bd73ba6250e0cc6e3b 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_c.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,13 +43,12 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange.hpp>
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange.hpp>
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_2d_reduce ) {
-  TestMDRange_2D< TEST_EXECSPACE >::test_reduce2( 100, 100 );
-}
-
+TEST_F(TEST_CATEGORY, mdrange_2d_reduce) {
+  TestMDRange_2D<TEST_EXECSPACE>::test_reduce2(100, 100);
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_d.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_d.cpp
index c6c6ba29184b268dd0bd749c018c7bb096fedacf..ecff8c39b4b6c585ead8664a727d7c5f5c911f91 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_d.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,13 +43,12 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange.hpp>
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange.hpp>
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_3d_reduce ) {
-  TestMDRange_3D< TEST_EXECSPACE >::test_reduce3( 100, 100, 5 );
-}
-
+TEST_F(TEST_CATEGORY, mdrange_3d_reduce) {
+  TestMDRange_3D<TEST_EXECSPACE>::test_reduce3(100, 100, 5);
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_e.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_e.cpp
index 6afd8b8ecedfd99c8ce52a8b7006c88950f39b8b..a773ca17b8b935b14ede37a82e25fa0e585e6a8f 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_e.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRangeReduce_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,13 +43,12 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange.hpp>
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange.hpp>
 namespace Test {
 
-TEST_F( TEST_CATEGORY , mdrange_4d_reduce ) {
-  TestMDRange_4D< TEST_EXECSPACE >::test_reduce4( 100, 100, 10, 5 );
-}
-
+TEST_F(TEST_CATEGORY, mdrange_4d_reduce) {
+  TestMDRange_4D<TEST_EXECSPACE>::test_reduce4(100, 100, 10, 5);
 }
 
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_a.cpp
index 66d6de3bd569853a316d7fca2cbbaf1659815ac2..8f3c6544bee3370a16b6258a5788f11b50449614 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_b.cpp
index 6eb4a9eee3d1784f9c0bf522d5a1f7a147b9ca3d..40efabf2a5dab7341570b9c028f47828b74cd0f7 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_c.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_c.cpp
index 2d604dfbc700196aa79ae04c7cbdccd78a11e2bf..63c02857d63afb50c439df58d4eabc17a4988756 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_d.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_d.cpp
index 75f02c9f0da98c6f5037d4f06bf206e90bd7a9e6..ff559b66f052796d896ecc236e71e7385b2c1c77 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_e.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_e.cpp
index b56167d746c1c03316d5b0ebe047d0beeabd5201..57c383d11a3e0342e21e13108780887db736b978 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Other.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Other.cpp
index 3396265b0fb5444b1044264ad126d1098fbfca4d..b6240a1b5a9d51555621c0e963d2239ebb951b10 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Other.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Other.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,11 +43,11 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestTemplateMetaFunctions.hpp>
-#include<TestAggregate.hpp>
-//include<TestMemoryPool.hpp>
-#include<TestCXX11.hpp>
-#include<TestTile.hpp>
+#include <rocm/TestROCm_Category.hpp>
+#include <TestTemplateMetaFunctions.hpp>
+#include <TestAggregate.hpp>
+// include<TestMemoryPool.hpp>
+#include <TestCXX11.hpp>
+#include <TestTile.hpp>
 
-#include<TestViewCtorPropEmbeddedDim.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_RangePolicy.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_RangePolicy.cpp
index dd390a0a3df271961c3b2ea650b2f77629e1f31d..bd85458b6c94f1bdadc539c70a8cc33838a391b5 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_RangePolicy.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_RangePolicy.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestRange.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestRange.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_a.cpp
index 14a199a71374f63f1030bbfc54eba5bd8ac4f55d..28cffad683183e0048892190cb38195b84d36533 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_b.cpp
index 9f809eabbfc264b71a996d6b86bfd9ef29c7e518..0efece4d0d0abadffe5abc4f248f4dd592facf0c 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_c.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_c.cpp
index f0cdb520f5282f19d0f210f24e1beac35cc1fec8..929bf35a1b0fdd0b1e491ffa8d2e0c9ebbb7b8e5 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_c.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_d.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_d.cpp
index b8ad8897c90d2949233f87bf9968b98396145d85..4a63aa02483379dd9bf771f8d387035b176c2f86 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_d.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Reducers_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Reductions.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Reductions.cpp
index 70d6ee7382d64f204ebfab798ebe625a23b96df2..6b79b959278e3bb737d2e1301a187e9153cb1ea9 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Scan.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Scan.cpp
index f13a98331140cd3e1abcfa867741d566ac4ff8c5..7987447253181eded56d566b9f64f627b5ca7bf4 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Scan.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Scan.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<rocm/TestROCm_Category.hpp>
-#include<TestScan.hpp>
-
+#include <rocm/TestROCm_Category.hpp>
+#include <TestScan.hpp>
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SharedAlloc.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SharedAlloc.cpp
index c2c68d021c806787c8d75e5f45ffe21ac6681e7d..041d0a82bc9b98787dc5dcb6f44767d7b6158681 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,9 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< Kokkos::Experimental::ROCmSpace, Kokkos::DefaultHostExecutionSpace >();
+TEST_F(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<Kokkos::Experimental::ROCmSpace,
+                    Kokkos::DefaultHostExecutionSpace>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Spaces.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Spaces.cpp
index 637cdd9a7f40257a0a30983a34ad3fccde9cef9c..fe84da59161baf503b12b2b0b32305f9551a01aa 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Spaces.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Spaces.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -47,114 +48,151 @@
 namespace Test {
 
 KOKKOS_INLINE_FUNCTION
-void test_abort()
-{
-  Kokkos::abort( "test_abort" );
-}
+void test_abort() { Kokkos::abort("test_abort"); }
 
 KOKKOS_INLINE_FUNCTION
-void test_rocm_spaces_int_value( int * ptr )
-{
-  if ( *ptr == 42 ) { *ptr = 2 * 42; }
+void test_rocm_spaces_int_value(int *ptr) {
+  if (*ptr == 42) {
+    *ptr = 2 * 42;
+  }
 }
 
-TEST_F( rocm, space_access )
-{
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::HostSpace >::assignable, "" );
+TEST_F(rocm, space_access) {
+  static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                                Kokkos::HostSpace>::assignable,
+                "");
 
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace >::assignable, "" );
+  static_assert(Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::HostSpace,
+                    Kokkos::Experimental::ROCmHostPinnedSpace>::assignable,
+                "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace >::assignable, "" );
+      !Kokkos::Impl::MemorySpaceAccess<
+          Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace>::assignable,
+      "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace >::accessible, "" );
+      !Kokkos::Impl::MemorySpaceAccess<
+          Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace>::accessible,
+      "");
 
   //--------------------------------------
 
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCmSpace >::assignable, "" );
+  static_assert(Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::Experimental::ROCmSpace,
+                    Kokkos::Experimental::ROCmSpace>::assignable,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCmHostPinnedSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::Experimental::ROCmSpace,
+                    Kokkos::Experimental::ROCmHostPinnedSpace>::assignable,
+                "");
 
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCmHostPinnedSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::Experimental::ROCmSpace,
+                    Kokkos::Experimental::ROCmHostPinnedSpace>::accessible,
+                "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmSpace, Kokkos::HostSpace >::assignable, "" );
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::ROCmSpace,
+                                       Kokkos::HostSpace>::assignable,
+      "");
 
   static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmSpace, Kokkos::HostSpace >::accessible, "" );
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::ROCmSpace,
+                                       Kokkos::HostSpace>::accessible,
+      "");
 
   //--------------------------------------
 
-  static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace, Kokkos::Experimental::ROCmHostPinnedSpace >::assignable, "" );
+  static_assert(Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::Experimental::ROCmHostPinnedSpace,
+                    Kokkos::Experimental::ROCmHostPinnedSpace>::assignable,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace, Kokkos::HostSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::Experimental::ROCmHostPinnedSpace,
+                    Kokkos::HostSpace>::assignable,
+                "");
 
   static_assert(
-    Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace, Kokkos::HostSpace >::accessible, "" );
+      Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::ROCmHostPinnedSpace,
+                                      Kokkos::HostSpace>::accessible,
+      "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace, Kokkos::Experimental::ROCmSpace >::assignable, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::Experimental::ROCmHostPinnedSpace,
+                    Kokkos::Experimental::ROCmSpace>::assignable,
+                "");
 
-  static_assert(
-    ! Kokkos::Impl::MemorySpaceAccess< Kokkos::Experimental::ROCmHostPinnedSpace, Kokkos::Experimental::ROCmSpace >::accessible, "" );
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<
+                    Kokkos::Experimental::ROCmHostPinnedSpace,
+                    Kokkos::Experimental::ROCmSpace>::accessible,
+                "");
 
   //--------------------------------------
 
   static_assert(
-    ! Kokkos::Impl::SpaceAccessibility< Kokkos::Experimental::ROCm, Kokkos::HostSpace >::accessible, "" );
+      !Kokkos::Impl::SpaceAccessibility<Kokkos::Experimental::ROCm,
+                                        Kokkos::HostSpace>::accessible,
+      "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::Experimental::ROCm, Kokkos::Experimental::ROCmSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::Experimental::ROCm,
+                    Kokkos::Experimental::ROCmSpace>::accessible,
+                "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::Experimental::ROCm, Kokkos::Experimental::ROCmHostPinnedSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::Experimental::ROCm,
+                    Kokkos::Experimental::ROCmHostPinnedSpace>::accessible,
+                "");
 
   static_assert(
-    ! Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace >::accessible, "" );
+      !Kokkos::Impl::SpaceAccessibility<
+          Kokkos::HostSpace, Kokkos::Experimental::ROCmSpace>::accessible,
+      "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility< Kokkos::HostSpace, Kokkos::Experimental::ROCmHostPinnedSpace >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::HostSpace,
+                    Kokkos::Experimental::ROCmHostPinnedSpace>::accessible,
+                "");
 
   static_assert(
-    std::is_same< Kokkos::Impl::HostMirror< Kokkos::Experimental::ROCmSpace >::Space
-                , Kokkos::HostSpace >::value, "" );
+      std::is_same<
+          Kokkos::Impl::HostMirror<Kokkos::Experimental::ROCmSpace>::Space,
+          Kokkos::HostSpace>::value,
+      "");
 
   static_assert(
-    std::is_same< Kokkos::Impl::HostMirror< Kokkos::Experimental::ROCmHostPinnedSpace >::Space
-                , Kokkos::Experimental::ROCmHostPinnedSpace >::value, "" );
+      std::is_same<Kokkos::Impl::HostMirror<
+                       Kokkos::Experimental::ROCmHostPinnedSpace>::Space,
+                   Kokkos::Experimental::ROCmHostPinnedSpace>::value,
+      "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility
-      < Kokkos::Impl::HostMirror< Kokkos::Experimental::ROCm >::Space
-      , Kokkos::HostSpace
-      >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::Impl::HostMirror<Kokkos::Experimental::ROCm>::Space,
+                    Kokkos::HostSpace>::accessible,
+                "");
 
   static_assert(
-    Kokkos::Impl::SpaceAccessibility
-      < Kokkos::Impl::HostMirror< Kokkos::Experimental::ROCmSpace >::Space
-      , Kokkos::HostSpace
-      >::accessible, "" );
+      Kokkos::Impl::SpaceAccessibility<
+          Kokkos::Impl::HostMirror<Kokkos::Experimental::ROCmSpace>::Space,
+          Kokkos::HostSpace>::accessible,
+      "");
 
-  static_assert(
-    Kokkos::Impl::SpaceAccessibility
-      < Kokkos::Impl::HostMirror< Kokkos::Experimental::ROCmHostPinnedSpace >::Space
-      , Kokkos::HostSpace
-      >::accessible, "" );
+  static_assert(Kokkos::Impl::SpaceAccessibility<
+                    Kokkos::Impl::HostMirror<
+                        Kokkos::Experimental::ROCmHostPinnedSpace>::Space,
+                    Kokkos::HostSpace>::accessible,
+                "");
 }
 
-template< class MemSpace, class ExecSpace >
+template <class MemSpace, class ExecSpace>
 struct TestViewROCmAccessible {
   enum { N = 1000 };
 
-  using V = Kokkos::View< double*, MemSpace >;
+  using V = Kokkos::View<double *, MemSpace>;
 
   V m_base;
 
@@ -162,35 +200,38 @@ struct TestViewROCmAccessible {
   struct TagTest {};
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagInit &, const int i ) const { m_base[i] = i + 1; }
+  void operator()(const TagInit &, const int i) const { m_base[i] = i + 1; }
 
   KOKKOS_INLINE_FUNCTION
-  void operator()( const TagTest &, const int i, long & error_count ) const
-  { if ( m_base[i] != i + 1 ) ++error_count; }
+  void operator()(const TagTest &, const int i, long &error_count) const {
+    if (m_base[i] != i + 1) ++error_count;
+  }
 
-  TestViewROCmAccessible()
-    : m_base( "base", N )
-    {}
+  TestViewROCmAccessible() : m_base("base", N) {}
 
-  static void run()
-  {
+  static void run() {
     TestViewROCmAccessible self;
-    Kokkos::parallel_for( Kokkos::RangePolicy< typename MemSpace::execution_space, TagInit >( 0, N ), self );
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<typename MemSpace::execution_space, TagInit>(0, N),
+        self);
     typename MemSpace::execution_space().fence();
 
     // Next access is a different execution space, must complete prior kernel.
     long error_count = -1;
-    Kokkos::parallel_reduce( Kokkos::RangePolicy< ExecSpace, TagTest >( 0, N ), self, error_count );
-    EXPECT_EQ( error_count, 0 );
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<ExecSpace, TagTest>(0, N), self,
+                            error_count);
+    EXPECT_EQ(error_count, 0);
   }
 };
 
-TEST_F( rocm, impl_view_accessible )
-{
-  TestViewROCmAccessible< Kokkos::Experimental::ROCmSpace, Kokkos::Experimental::ROCm >::run();
+TEST_F(rocm, impl_view_accessible) {
+  TestViewROCmAccessible<Kokkos::Experimental::ROCmSpace,
+                         Kokkos::Experimental::ROCm>::run();
 
-  TestViewROCmAccessible< Kokkos::Experimental::ROCmHostPinnedSpace, Kokkos::Experimental::ROCm >::run();
-  TestViewROCmAccessible< Kokkos::Experimental::ROCmHostPinnedSpace, Kokkos::HostSpace::execution_space >::run();
+  TestViewROCmAccessible<Kokkos::Experimental::ROCmHostPinnedSpace,
+                         Kokkos::Experimental::ROCm>::run();
+  TestViewROCmAccessible<Kokkos::Experimental::ROCmHostPinnedSpace,
+                         Kokkos::HostSpace::execution_space>::run();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_a.cpp
index 4d7e1a8ef2a8b319e15f0a3dd88497a001f2af38..f766921ffbc4e5be11f06aabc1d4f4e4fd02d544 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,66 +47,56 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_left )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_auto_1d_left) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutLeft, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_right )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutRight, TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_auto_1d_right) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutRight, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_stride )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutStride, TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_auto_1d_stride) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutStride, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_assign_strided )
-{
-  TestViewSubview::test_1d_strided_assignment< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_assign_strided) {
+  TestViewSubview::test_1d_strided_assignment<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_0 )
-{
-  TestViewSubview::test_left_0< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_0) {
+  TestViewSubview::test_left_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_1 )
-{
-  TestViewSubview::test_left_1< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_1) {
+  TestViewSubview::test_left_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_2 )
-{
-  TestViewSubview::test_left_2< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_2) {
+  TestViewSubview::test_left_2<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_3 )
-{
-  TestViewSubview::test_left_3< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_left_3) {
+  TestViewSubview::test_left_3<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_0 )
-{
-  TestViewSubview::test_right_0< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_right_0) {
+  TestViewSubview::test_right_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_1 )
-{
-  TestViewSubview::test_right_1< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_right_1) {
+  TestViewSubview::test_right_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_3 )
-{
-  TestViewSubview::test_right_3< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_right_3) {
+  TestViewSubview::test_right_3<TEST_EXECSPACE>();
 }
 
-TEST_F(TEST_CATEGORY, view_static_tests)
-{
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutLeft>()();
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutRight>()();
+TEST_F(TEST_CATEGORY, view_static_tests) {
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutLeft>()();
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutRight>()();
   TestViewSubview::TestExtentsStaticTests<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_b.cpp
index 5b64dbf2140c592e43496c84c018411b6e310595..798ff06b7e5015285d42f5c95c839a981efb2b9f 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,18 +47,20 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_layoutleft_to_layoutleft )
-{
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_layoutleft_to_layoutleft) {
+  TestViewSubview::test_layoutleft_to_layoutleft<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_layoutright_to_layoutright )
-{
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_layoutright_to_layoutright) {
+  TestViewSubview::test_layoutright_to_layoutright<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c01.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c01.cpp
index b3fb40ec4a76d6ce125b2f136e255b99bfc4dd73..b70923027dc2a7d110c1f56489170811ebb9dca3 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_1d_assign) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c02.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c02.cpp
index aef28e022b3fb4f7db3f816b9cbb79a6bff6fdad..e28dfed7f20b913b872a8eac68ca96688e51eca0 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_atomic )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(TEST_CATEGORY, view_subview_1d_assign_atomic) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE,
+                                  Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c03.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c03.cpp
index d6e6329a757db4f50d6b8383d0ecd709a89b77a9..bd8afc4724cc95d0b560877805934a2346cfc1da 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_randomaccess )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_1d_assign_randomaccess) {
+  TestViewSubview::test_1d_assign<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c04.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c04.cpp
index f91820e258865717b896c0cd590bfe1532a2c919..f2c5c3674c5447c9e2ada8255ad493cc8e70464b 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_2d_from_3d) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c05.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c05.cpp
index 9580d5c4f7b069a10b03d3977e1329a8a6fbdfe5..43ef57350de2795c59ac1b5bd5cd8180015da007 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_atomic )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(TEST_CATEGORY, view_subview_2d_from_3d_atomic) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE,
+                                      Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c06.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c06.cpp
index 68a2a556cd59446a9a1e0a2b8398aab09228c542..985c228436df55af52ef5afc42534f7a3b211bca 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_randomaccess )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_2d_from_3d_randomaccess) {
+  TestViewSubview::test_2d_subview_3d<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c07.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c07.cpp
index 9f3a6d9369e7409ddc08d855aba3d1f1e9b8b07f..1ddcec5709680b173b680be68594dffaeb613488 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_left) {
+  TestViewSubview::test_3d_subview_5d_left<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c08.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c08.cpp
index a9433418786c6ff3081272e91626666d54b1a932..a641bdbdfb77f36c5d511d71130fd909f3ca6df1 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_left_atomic) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c09.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c09.cpp
index aea1d4945c636751ab488c47da4d5edb92da114b..bc2a2d5995554fa15eec18834fb5161671288c1a 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c10.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c10.cpp
index 83d0d0a66a1a6600979e51d6a4da53bcf8a570ee..59f3bb22d8beb84edca4d1221e983d44c7e3edfc 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_right) {
+  TestViewSubview::test_3d_subview_5d_right<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c11.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c11.cpp
index 643eada263ed12793dbeb7e89d26f16a396e33aa..29c6f181fdd4ef3941ca7823288a70accc563bd7 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_right_atomic) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c12.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c12.cpp
index 9d46a556b7ab5cf07c2b0a07ce0f2ca35e2716a2..4fcdcc39786267cd383e893cc28d940a6391bb50 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST_F(TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c13.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c13.cpp
index 03b39972a3912ba77c014187d86beb91b5e9a1a9..f8d52f243d1137ce7a0668faa90b6438806f502a 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c13.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_SubView_c13.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_test_unmanaged_subview_reset )
-{
-  TestViewSubview::test_unmanaged_subview_reset< TEST_EXECSPACE >();
+TEST_F(TEST_CATEGORY, view_test_unmanaged_subview_reset) {
+  TestViewSubview::test_unmanaged_subview_reset<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_Team.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_Team.cpp
index 4f35ab77d35c18d8ebe0d1c14bf5722408e089c5..85aeb6637cffc4e41cd8dbbe8c540f43fc0d277b 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_Team.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,30 +47,37 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_for )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 0 );
+TEST_F(TEST_CATEGORY, team_for) {
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      0);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      0);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 2 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      2);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      2);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 1000 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      1000);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      1000);
 }
 
-
-TEST_F( TEST_CATEGORY, team_reduce )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 1000 );
-}
+TEST_F(TEST_CATEGORY, team_reduce) {
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(1000);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(1000);
 }
+}  // namespace Test
 
 #include <TestTeamVector.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_TeamReductionScan.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_TeamReductionScan.cpp
index 57887450e2abca8ac93ca70cfc6acf6b0aac14f7..b82fbf911cd23dea73cde992ac53accc403a2c91 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_TeamReductionScan.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_TeamReductionScan.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,35 +47,35 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_scan )
-{
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10000 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10000 );
+TEST_F(TEST_CATEGORY, team_scan) {
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10000);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10000);
 }
 
-TEST_F( TEST_CATEGORY, team_long_reduce )
-{
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST_F(TEST_CATEGORY, team_long_reduce) {
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-TEST_F( TEST_CATEGORY, team_double_reduce )
-{
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST_F(TEST_CATEGORY, team_double_reduce) {
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_TeamScratch.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_TeamScratch.cpp
index c7255919d9a3910c9381a9e6a4d5594bfc2e1f6d..8ec583c23aa7932488d7b13b93ee42ec4ea8fddd 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_TeamScratch.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_TeamScratch.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,42 +47,36 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_shared_request )
-{
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST_F(TEST_CATEGORY, team_shared_request) {
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, team_scratch_request )
-{
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST_F(TEST_CATEGORY, team_scratch_request) {
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_ROCM) || ( 8000 <= ROCM_VERSION )
-TEST_F( TEST_CATEGORY, team_lambda_shared_request )
-{
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_ROCM) || (8000 <= ROCM_VERSION)
+TEST_F(TEST_CATEGORY, team_lambda_shared_request) {
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Static> >();
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, scratch_align) {
-  TestScratchAlignment< TEST_EXECSPACE >();
-}
+TEST_F(TEST_CATEGORY, scratch_align) { TestScratchAlignment<TEST_EXECSPACE>(); }
 #endif
 #endif
 
-TEST_F( TEST_CATEGORY, shmem_size )
-{
-  TestShmemSize< TEST_EXECSPACE >();
-}
+TEST_F(TEST_CATEGORY, shmem_size) { TestShmemSize<TEST_EXECSPACE>(); }
 
-TEST_F( TEST_CATEGORY, multi_level_scratch )
-{
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST_F(TEST_CATEGORY, multi_level_scratch) {
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Static> >();
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_TeamTeamSize.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_TeamTeamSize.cpp
index 583e01fcb66eab7c3eea6d4d2eb874835f79a284..3ddbe901b858fbf1c6cc230ad22a6a290810caaf 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_TeamTeamSize.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_TeamTeamSize.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_a.cpp
index d0a7caad732c9ac88add2d9f48050f47d3b1251c..5740dedf3227022cb9f376c4e50770c222598e97 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_b.cpp
index cef3ad606423184b9f858d2a7764d33dcbe27609..775908043fc8f069b12027cdb3535c4a4f353cbd 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_c.cpp
index 624fda5a771c494f9d7ab14d2aa8203ff0f08bad..bf28aff30234c0fe4dd0f29f43431327d99e4f9a 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_d.cpp
index fbb169828c2f22b67c4d972b7db1b6db79472292..3dabcdfabbae928afc25e76debd4439c05662df8 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_e.cpp
index 1a9f993e7eb71f163ae4569bb9f5b8094f5d9b19..45633ebab992e7bbf896cc493af3d254d6d1becf 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_a.cpp
index 1d79e6a63d57f99385686d948c10a43bd324b566..0ecaacaea70297a50679a76a94d3964b609c214b 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCm_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_b.cpp
index 15bf92affe3d42dfd0ad6c5327def1e8dbf55344..7af6e2ff4e7b67e984675b146da316f77ad950dc 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCm_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_subview.cpp
index 7e35355215bd48188dff435184c8741148651ca5..f8f2e40979ca2ea647634f10d0073879534c524c 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCm_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewOfClass.cpp b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewOfClass.cpp
index c03385b64e779bb79b3c3526cc28611ecab9474c..2f917ac6122b4627f0f02b9a0f85f29f7020498c 100644
--- a/lib/kokkos/core/unit_test/rocm/TestROCm_ViewOfClass.cpp
+++ b/lib/kokkos/core/unit_test/rocm/TestROCm_ViewOfClass.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <rocm/TestROCm_Category.hpp>
 #include <TestViewOfClass.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexdouble.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexdouble.cpp
index e7354cb1165bde4267791d1f41ed494bcfb25e25..fc26bb578ab6b0d3b3f9d5f4991c18ea8f40faab 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexdouble.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexdouble.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_complexdouble.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_complexdouble.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexfloat.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexfloat.cpp
index 50227db29fdd648ec3cdf43708e66982b62893b1..db5a4a000c8b513261359283387193d66c82eb71 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexfloat.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_complexfloat.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_complexfloat.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_complexfloat.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_double.cpp
index da515c8567cfcf5d6720a2042774bbc9a7cdcb7c..2ce675afd995e1c7e1e4eccf5dcf60854c752a72 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_float.cpp
index ae914b6f5e560f4fe30bf484ac9dba1d2fda035f..328bc37f7927627e002f4fe797908b44baa0b1d9 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_int.cpp
index 403d9931295ad642feefb41f0c08150ef2060368..5da7f7c3f21366067b58439fe62d38c48621fb3f 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longint.cpp
index e4fbadc8f5a5a4d88827e73fcb21b7558251bf96..12cfb1d34a8900419436820e4cf659e996e955d4 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longlongint.cpp
index 80207758019fbf0640083c443ff4becc227b33c5..884a75e176f404cca55f755d6d404d3c229f8e7b 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedint.cpp
index af5a1979ee4bfdc7a4fca4778794ac571656b4e3..771730d708a313280ca37ad8a036f8a7946fb997 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedlongint.cpp
index 8a06e4a2aa72716162efc4be7aca061ac4cfdb1e..7eeea84f73e5c9bc91998f2183b5c2bd12d04888 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicViews.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicViews.cpp
index a03c74a00826de3eae80bc9694a7350e07adb81d..be0b58d33c342e5bad2b554f1468dfe20a875d31 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_AtomicViews.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_AtomicViews.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestAtomicViews.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestAtomicViews.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Atomics.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Atomics.cpp
index 398ab10ccff423ca03fe3a1e0d10b2ffe9395aee..88e3d0b9251bc03b7f6b3b7593456f4a99489719 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <serial/TestSerial_Category.hpp>
 #include <TestAtomic.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Category.hpp b/lib/kokkos/core/unit_test/serial/TestSerial_Category.hpp
index 858b6692863c966cf40a6ffdcf2cc98a0e1f28db..0989af7f51b657a4053d9e63a65cfd02247ce0cc 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Category.hpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class serial : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY serial
+#define TEST_CATEGORY_DEATH serial_DeathTest
 #define TEST_EXECSPACE Kokkos::Serial
 
 #endif
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Complex.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Complex.cpp
index fa9eacd2b33e6d76cbaf549e0a4650ef2ad41c0c..f0cce7a72969c531449b01277c5427de91792638 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Complex.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Complex.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Crs.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Crs.cpp
index 367c1028a8deceae575fd26ef752673b30f7b010..cac55fe01e336af0b83c394601894e8cc04e5af4 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Crs.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Crs.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_DeepCopyAlignment.cpp
index 8280b49fe225f001ea98edbf60f100a075c2b35e..812a4fd9971e0b9d38e63bb741e986112b320444 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_DeepCopyAlignment.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_DeepCopyAlignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_FunctorAnalysis.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_FunctorAnalysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..403bdb922d6ea984c6eba317debdc33f97767aaf
--- /dev/null
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_FunctorAnalysis.cpp
@@ -0,0 +1,47 @@
+
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <serial/TestSerial_Category.hpp>
+#include <TestFunctorAnalysis.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Init.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Init.cpp
index ccadb041ce134da319840211eddeab93ea2133bd..2cda827a56bfec4843afc1ebc273e576caeacda6 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Init.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Init.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,7 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestInit.hpp>
-#include<TestCompilerMacros.hpp>
-#include<TestPolicyConstruction.hpp>
-
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestInit.hpp>
+#include <TestCompilerMacros.hpp>
+#include <TestPolicyConstruction.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_LocalDeepCopy.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_LocalDeepCopy.cpp
index a7cbcc171e44ca729390b7c1e10e88d02c1a8b91..809473487a09a7b07959589bcada46b7d41a63e2 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_LocalDeepCopy.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_LocalDeepCopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <serial/TestSerial_Category.hpp>
 #include <TestLocalDeepCopy.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_a.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_a.cpp
index a09ac9c2a6f83fa0c748d77b427543e1e740c593..863c910067878c763c9cfa1fe03db9cd723b6d08 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_b.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_b.cpp
index 3f46e0e64a6afc374a24b98914ed763bce84158f..defe86f109801a323de2d659fa7142d06722a6ec 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_c.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_c.cpp
index 9a1363b805b8a1849a140b5506af5d4fb2532234..30f7af2bc6f049e97d432774b722029115a7882f 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_d.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_d.cpp
index f6f5d0f92ba32804db977d89da95f48697a4edcf..c9341ccb5cf0ff6387c4da8acd62ab20613dd75b 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_e.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_e.cpp
index 601b19468ffbc51b4b98ae1cc6e677e25df42b00..ad12bb26cbccedb8b2e8ee5e0bcb04b872717834 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Other.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Other.cpp
index 26a218c5c19742d6dc0124c56f39422ef3884a1b..ea4ac4e4cbe304116a2e4d1429d3cb2e31b77319 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Other.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Other.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,12 +43,12 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestTemplateMetaFunctions.hpp>
-#include<TestAggregate.hpp>
-#include<TestMemoryPool.hpp>
-#include<TestCXX11.hpp>
-#include<TestTile.hpp>
+#include <serial/TestSerial_Category.hpp>
+#include <TestTemplateMetaFunctions.hpp>
+#include <TestAggregate.hpp>
+#include <TestMemoryPool.hpp>
+#include <TestCXX11.hpp>
+#include <TestTile.hpp>
 
-#include<TestViewCtorPropEmbeddedDim.hpp>
-#include<TestViewLayoutTiled.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
+#include <TestViewLayoutTiled.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_RangePolicy.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_RangePolicy.cpp
index 5740eb74fc6a12fc4e516e0b60555776bf3e8967..f92daad51e60400c65ce4efb20e5a7430d28c5f5 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_RangePolicy.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_RangePolicy.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestRange.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestRange.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_a.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_a.cpp
index 2c65bb9bdb6df8c0dbbe21ca997a7b86e1a767ad..2dc48e98e31c31a20eb73775c7c165d051c3857c 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_a.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_b.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_b.cpp
index f1fa8140102d3a09677a2b5c6c7c3405ed7bdf41..2cd85bee1c3f93ed0a7ab4dac03d5513325aaeff 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_b.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_c.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_c.cpp
index 4730a273026403280eb6f363a1d338fef5c12a5e..979ea8b410a520914aadc6e98b3a4e3c22656183 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_c.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_d.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_d.cpp
index 26ea6f7e2442f5ac997a49973024788ac05074a9..a6bdb8129d60d3a448ec60c878b19f2652838f48 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_d.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Reducers_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Reductions.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Reductions.cpp
index acec0edd6e93ced02a5a7ddd57f51237a568f350..a5961fbdf6e0d78beef5f8fd8b1a101f4239a41d 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Reductions_DeviceView.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Reductions_DeviceView.cpp
index 1c20670c285cc066895e6e3e5443d6f0b897fc56..6e6c47024ea322c543e4ca09d3e3271f6619b4bd 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Reductions_DeviceView.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Reductions_DeviceView.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Scan.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Scan.cpp
index 23ca25d48c2d6143b36aa3a7fb2f49a9d5fb2dbb..287c05e17abbf34b4573d97385f3d77c82142ec5 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Scan.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Scan.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestScan.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestScan.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SharedAlloc.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SharedAlloc.cpp
index 348ce654285924933e5547a6d93042a17a3c6736..1b5f2f2dd89edcd361a25a3a364491ad81f3e6d1 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< Kokkos::HostSpace, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<Kokkos::HostSpace, TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_a.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_a.cpp
index 6ca6b92f05e2875698e9b51414b42e7087adfd5a..b2a33a7bdc7c14b09f90d9339973edd970dd0d49 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,66 +47,56 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_left )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_left) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutLeft, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_right )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutRight, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_right) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutRight, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_stride )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutStride, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_stride) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutStride, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_assign_strided )
-{
-  TestViewSubview::test_1d_strided_assignment< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_assign_strided) {
+  TestViewSubview::test_1d_strided_assignment<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_0 )
-{
-  TestViewSubview::test_left_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_0) {
+  TestViewSubview::test_left_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_1 )
-{
-  TestViewSubview::test_left_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_1) {
+  TestViewSubview::test_left_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_2 )
-{
-  TestViewSubview::test_left_2< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_2) {
+  TestViewSubview::test_left_2<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_3 )
-{
-  TestViewSubview::test_left_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_3) {
+  TestViewSubview::test_left_3<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_0 )
-{
-  TestViewSubview::test_right_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_0) {
+  TestViewSubview::test_right_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_1 )
-{
-  TestViewSubview::test_right_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_1) {
+  TestViewSubview::test_right_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_3 )
-{
-  TestViewSubview::test_right_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_3) {
+  TestViewSubview::test_right_3<TEST_EXECSPACE>();
 }
 
-TEST_F(TEST_CATEGORY, view_static_tests)
-{
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutLeft>()();
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutRight>()();
+TEST(TEST_CATEGORY, view_static_tests) {
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutLeft>()();
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutRight>()();
   TestViewSubview::TestExtentsStaticTests<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_b.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_b.cpp
index b6869f95f19bb8a31a1cc6e6159e8d5cd6d5820f..5ea7c7e91ad95465e2fd196aa6d49c1ec7ffaae9 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,18 +47,20 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_layoutleft_to_layoutleft )
-{
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutleft_to_layoutleft) {
+  TestViewSubview::test_layoutleft_to_layoutleft<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_layoutright_to_layoutright )
-{
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutright_to_layoutright) {
+  TestViewSubview::test_layoutright_to_layoutright<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c01.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c01.cpp
index 395880493fe0cafb1b07149cb90d43d227269e57..bced0bf2e6b9bbfafa74d7b8437edea78ddc5915 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_1d_assign) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c02.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c02.cpp
index 5bb21aba7b178cf0810ddc19b5850ae61affb2f7..d2a3d035b848484ff780f52e1eef3a6db29ca8c7 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_atomic )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_atomic) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE,
+                                  Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c03.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c03.cpp
index 7f112ea326aec41dededeb0d4180a0583897509d..7b531b9f7278448d03e4976921581943c9300b0c 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_randomaccess )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_randomaccess) {
+  TestViewSubview::test_1d_assign<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c04.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c04.cpp
index fdcc3b90fa11f49720a67e433da2a5fa1c54b2e3..215fa645b1e0cb89b4f372a058d01bbc11854b48 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c05.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c05.cpp
index 4df5e8508b7a404d868f764b41b2a36709788314..4e066f945a7832251cd65b7f72fca68801ca9f1d 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( serial, view_subview_2d_from_3d_atomic )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(serial, view_subview_2d_from_3d_atomic) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE,
+                                      Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c06.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c06.cpp
index 1e715eccf6cae574cbd9a2c83effc35adabc58ab..803fa75aa8f308eace516a9087e8539eba3cb43a 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_randomaccess )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d_randomaccess) {
+  TestViewSubview::test_2d_subview_3d<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c07.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c07.cpp
index a5189fc7d86acef945910b10a3826c9e2b1a5492..6bf64ba06f10ff1a44c69528cfd09363ae59e8fc 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left) {
+  TestViewSubview::test_3d_subview_5d_left<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c08.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c08.cpp
index 96ae5d7374d8f87083027062ddd8e7daf23a5bc0..691fe1a965e27826f88d44cc19ca2f55167f03dc 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_atomic) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c09.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c09.cpp
index f4d716540a59ed45e0d15f0ffd04c94b5ca13c0e..cfbe075c83de224db672b50c2124702de9714800 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c10.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c10.cpp
index e393e5d4d380eab7833f1ad693b291b06556c7fd..1886532123b3eabc5afc780d1fefd5a7b3c59235 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right) {
+  TestViewSubview::test_3d_subview_5d_right<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c11.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c11.cpp
index e9ea9a601067d9f7d2faf632efd56743dbadc64e..264d919e25bac0a0019d785055361b8ff96fd475 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_atomic) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c12.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c12.cpp
index 01b57903cf87883a236f84ca6573094bea40cb64..53dd79c1ed7351576ee768b58fc256b135161537 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c13.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c13.cpp
index f50d28b251dc18816fba30c6efde6437f4c2e559..a0b1f36a00a4d0bd8fc83a8b03ecfb17b345f420 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c13.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_SubView_c13.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_test_unmanaged_subview_reset )
-{
-  TestViewSubview::test_unmanaged_subview_reset< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_test_unmanaged_subview_reset) {
+  TestViewSubview::test_unmanaged_subview_reset<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Task.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Task.cpp
index d2d748d942a596cb8542100f691230a2ee7da6ab..02f686e069dcd09e52c3a56cdd3d8cb8b0cde3d1 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Task.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Task.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestTaskScheduler.hpp>
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestTaskScheduler.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_Team.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_Team.cpp
index 47d02f70010649a0ebcd5b9ff543f1a6979370ef..e85ea86f3f68a2d372d25ad8b777f890d18750cc 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_Team.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,45 +47,59 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_for )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 0 );
+TEST(TEST_CATEGORY, team_for) {
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      0);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      0);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 2 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      2);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      2);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 1000 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      1000);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      1000);
 }
 
-
-TEST_F( TEST_CATEGORY, team_reduce )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 1000 );
+TEST(TEST_CATEGORY, team_reduce) {
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(1000);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(1000);
 }
 
-TEST_F( TEST_CATEGORY, team_broadcast )
-{
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 0 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 0 );
+TEST(TEST_CATEGORY, team_broadcast) {
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(0);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(0);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 2 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 2 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(2);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(2);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 16 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 16 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(16);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(16);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 1000 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 1000 );
-}
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::
+      test_teambroadcast(1000);
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::
+      test_teambroadcast(1000);
 }
+}  // namespace Test
 
 #include <TestTeamVector.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_TeamReductionScan.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_TeamReductionScan.cpp
index e626beaeb6158e684055b437746df0658abb7872..29f77d35aa27ec4494371c0cd85a3db28b7dcc90 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_TeamReductionScan.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_TeamReductionScan.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,36 +47,35 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, team_scan )
-{
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10000 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10000 );
+TEST(TEST_CATEGORY, team_scan) {
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10000);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10000);
 }
 
-TEST_F( TEST_CATEGORY, team_long_reduce )
-{
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_long_reduce) {
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-TEST_F( TEST_CATEGORY, team_double_reduce )
-{
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_double_reduce) {
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_TeamScratch.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_TeamScratch.cpp
index 029999ab724c2de6fb058ef851c45672f17fc150..e70b3e34d61e6c474bd3a4f0a5c73c1155445a29 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_TeamScratch.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_TeamScratch.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,42 +47,36 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_shared_request )
-{
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_shared_request) {
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, team_scratch_request )
-{
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_scratch_request) {
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-TEST_F( TEST_CATEGORY, team_lambda_shared_request )
-{
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+TEST(TEST_CATEGORY, team_lambda_shared_request) {
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Static> >();
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, scratch_align) {
-  TestScratchAlignment< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, scratch_align) { TestScratchAlignment<TEST_EXECSPACE>(); }
 #endif
 #endif
 
-TEST_F( TEST_CATEGORY, shmem_size )
-{
-  TestShmemSize< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, shmem_size) { TestShmemSize<TEST_EXECSPACE>(); }
 
-TEST_F( TEST_CATEGORY, multi_level_scratch )
-{
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, multi_level_scratch) {
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Static> >();
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_TeamTeamSize.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_TeamTeamSize.cpp
index 53451b30c9150a43058e596cf7b84d922e02e25d..82f90b13b7c39e889b45d15bbe347489cc6f3f6d 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_TeamTeamSize.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_TeamTeamSize.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_TeamVectorRange.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_TeamVectorRange.cpp
index f8d8328f780d3e85eb49462b2e02a28f36d1586e..a41f71c95b18ac7c4865e258b60061cf0cd12e5f 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_TeamVectorRange.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_TeamVectorRange.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestTeamVectorRange.hpp>
-
-
+#include <serial/TestSerial_Category.hpp>
+#include <TestTeamVectorRange.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_UniqueToken.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_UniqueToken.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..859918a7a66dce5e053e7f83e189a8c9eacd5f54
--- /dev/null
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_UniqueToken.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <serial/TestSerial_Category.hpp>
+#include <TestUniqueToken.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_a.cpp
index e29363456ac5cc0c80a317b39d19942a6b5a6b59..872944f8869cd4374ccbb698e175fbc41d112671 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_b.cpp
index 09c0049d6bfd128c7697d173b097c8540a64e632..2a63f94faa3e65c72c6b7009f285df1df2c48b3f 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_c.cpp
index fdf7f5387203da2a720fe8671f8136595dfef8ce..f4420ae77341681de72373e43e2aa9c20bcdd067 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_d.cpp
index 6380a28db518cd5deda31420774ecb8dfe4f144f..ede25aa6e577559f90333491266796796ba44430 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_e.cpp
index 5082729789c769b6845815c852d21ec5178efaf3..eca9c3f9f2c836e18ce192438d6b93e2dc7a1b8b 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -44,4 +45,3 @@
 #include <serial/TestSerial_Category.hpp>
 #include <TestViewAPI_e.hpp>
 #include <TestViewCopy.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewLayoutStrideAssignment.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewLayoutStrideAssignment.cpp
index 64c5b642d89684c50de597002c75a7f2a7c04104..37c3126c5069199098fafe39b691c6fa8de89e00 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewLayoutStrideAssignment.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewLayoutStrideAssignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <serial/TestSerial_Category.hpp>
 #include <TestViewLayoutStrideAssignment.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_a.cpp
index f9f89d714c2c247fac2228faf39d7f8f39dbe834..431485a3154402ed69f9f52bd71177e9170bd234 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <serial/TestSerial_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_b.cpp
index 69024441ac6c8f06f9de23ba027687b5d00c0cf5..1e5ce94322e3c619aeb94b144cba225666db9bdc 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <serial/TestSerial_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_subview.cpp
index d7fb364291a95e831bbe1127b43e041e849e550c..9178b054c5abeeab2841d4c638c874b34f9e54e7 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <serial/TestSerial_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewOfClass.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewOfClass.cpp
index d3e10238df2bbbd8e4ebc0c6fb7740930deba769..a3813eaffb46910db49f4c72feb5fc57f7a667a4 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_ViewOfClass.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewOfClass.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <serial/TestSerial_Category.hpp>
 #include <TestViewOfClass.hpp>
-
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_ViewResize.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_ViewResize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..46f1deb1e10160024d695e2f713b1dd3a6519ffb
--- /dev/null
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_ViewResize.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <serial/TestSerial_Category.hpp>
+#include <TestViewResize.hpp>
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_View_64bit.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_View_64bit.cpp
index ac2edde25f558325f8c67b00146db1d297c3cbd7..98e836db022868864aa15de507c10e39e417012f 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_View_64bit.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_View_64bit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/serial/TestSerial_WorkGraph.cpp b/lib/kokkos/core/unit_test/serial/TestSerial_WorkGraph.cpp
index 80925cb9dfa5e7fde94a55b0bb06cb57de2989c6..1192e1fa928d47947ac3c0c5c91f5ab52dff9a41 100644
--- a/lib/kokkos/core/unit_test/serial/TestSerial_WorkGraph.cpp
+++ b/lib/kokkos/core/unit_test/serial/TestSerial_WorkGraph.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,5 +42,5 @@
 //@HEADER
 */
 
-#include<serial/TestSerial_Category.hpp>
-#include<TestWorkGraph.hpp>
+#include <serial/TestSerial_Category.hpp>
+#include <TestWorkGraph.hpp>
diff --git a/lib/kokkos/core/unit_test/standalone/Makefile b/lib/kokkos/core/unit_test/standalone/Makefile
index f8a75616c5bdd4cd3ba672dd36d293049486149f..c910cc5fd182a4861fa3c73b18ef4f2fc43ef44e 100644
--- a/lib/kokkos/core/unit_test/standalone/Makefile
+++ b/lib/kokkos/core/unit_test/standalone/Makefile
@@ -1,4 +1,4 @@
-KOKKOS_DEVICES=Cuda
+KOKKOS_DEVICES=OpenMP
 KOKKOS_CUDA_OPTIONS=enable_lambda
 KOKKOS_ARCH = "SNB,Kepler35"
 
@@ -9,6 +9,7 @@ ifndef KOKKOS_PATH
 endif
 
 SRC = $(wildcard $(MAKEFILE_PATH)*.cpp)
+SRC += $(MAKEFILE_PATH)/../TestStackTrace.cpp
 HEADERS = $(wildcard $(MAKEFILE_PATH)*.hpp)
 HEADERS = $(wildcard $(MAKEFILE_PATH)/../*.hpp)
 
@@ -25,13 +26,13 @@ CXX = g++
 EXE = test.host
 endif
 
-CXXFLAGS ?= -O3 -g
+CXXFLAGS ?= -O0 -g -rdynamic
 override CXXFLAGS += -I$(MAKEFILE_PATH) -I$(KOKKOS_PATH)/core/unit_test -I$(KOKKOS_PATH)/tpls/gtest -DTESTFILE=$(TESTFILE)
 #SRC += $(KOKKOS_PATH)/tpls/gtest/gtest/gtest-all.cc
 
 DEPFLAGS = -M
 LINK = ${CXX}
-LINKFLAGS =
+LINKFLAGS = -rdynamic
 
 OBJ = $(notdir $(SRC:.cpp=.o))
 LIB =
diff --git a/lib/kokkos/core/unit_test/standalone/UnitTestMainInit.cpp b/lib/kokkos/core/unit_test/standalone/UnitTestMainInit.cpp
index 6de5fc7736eca83e808071a289f076a6e5e3c215..8f8bac7b23cff25099dc0b2c29f58dc53faecc73 100644
--- a/lib/kokkos/core/unit_test/standalone/UnitTestMainInit.cpp
+++ b/lib/kokkos/core/unit_test/standalone/UnitTestMainInit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -65,14 +66,14 @@
 #ifdef KOKKOS_ENABLE_SERIAL
 #include <serial/TestSerial_Category.hpp>
 #endif
-#endif 
-#include <TestReduceDeviceView.hpp>
+#endif
+#include <TestStackTrace.hpp>
 
-int main( int argc, char *argv[] ) {
-  Kokkos::initialize(argc,argv);
-  ::testing::InitGoogleTest( &argc, argv );
+int main(int argc, char *argv[]) {
+  Kokkos::initialize(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
 
-  int result =  RUN_ALL_TESTS();
+  int result = RUN_ALL_TESTS();
   Kokkos::finalize();
   return result;
 }
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexdouble.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexdouble.cpp
index 5201cbdbdbae9812571affe71efea48fc9eefd55..7fe140573ebdab27ab807569aee84208b051c7ea 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexdouble.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexdouble.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_complexdouble.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_complexdouble.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexfloat.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexfloat.cpp
index bede254243a513bcc459787199774744cfd75a5f..7cac4fa6b8274aebcc4449ad86154d526b583f34 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexfloat.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_complexfloat.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_complexfloat.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_complexfloat.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_double.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_double.cpp
index 14e19100134173e2b2d8af34d1a9b663aa9a93b3..c6136e9d270e63a02626273e33720d36af4683f3 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_double.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_double.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_double.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_double.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_float.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_float.cpp
index f42040e17685e80cc4fadcacae1d37d41459d133..e3bca7e3c6c652e9f2cfe5a41b454a4deb239b2a 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_float.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_float.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_float.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_float.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_int.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_int.cpp
index 0ee8adddecedbb1d750e3d041bd36edf5d7f6d3a..0acc4c5435c1480f7be436a90524c54cba7262dd 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_int.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_int.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_int.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_int.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longint.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longint.cpp
index 4fb86162d71f650ba9c0e4bb14d3eb248f5511ba..ffd2e17d0cca7d6b150b9b4594e792ceb8b4e580 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longint.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_longint.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_longint.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longlongint.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longlongint.cpp
index b4633210cdc8d9331b9ec3cffa67925d7aab56b2..8c73b8fc2210f81f2c78e3c29a4f8808add57ea1 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longlongint.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_longlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_longlongint.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_longlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedint.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedint.cpp
index 9261e43f30b862ffcf362aaecce0f1309c15e7ee..5b304f138fecf70f5629e5269de1e592297cdb7e 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedint.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_unsignedint.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_unsignedint.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedlongint.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedlongint.cpp
index 1cd6da3d9ef22eac3762f504b2f779ca01981232..06f99f54e5a112ea20ec98b6e5e3121a95f3ba2d 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedlongint.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicOperations_unsignedlongint.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,6 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicOperations_unsignedlongint.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicOperations_unsignedlongint.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicViews.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicViews.cpp
index d71baf8fc2c129d54b034b7e62f5db859b8a69cc..1625434483f0638c03c9c37c94c2ec8b14822bc9 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_AtomicViews.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_AtomicViews.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestAtomicViews.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestAtomicViews.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Atomics.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Atomics.cpp
index 350a8d90fd995e67d424f311dcc7c1176b8c8bd5..84b3a1782cc16581144f3d37686061e34ef0ef78 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Atomics.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Atomics.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestAtomic.hpp>
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Category.hpp b/lib/kokkos/core/unit_test/threads/TestThreads_Category.hpp
index c4d0ed6da2958ed239e96ed4d5c64369d85e4fab..800772b42dd0d3523d3e9243917ae005665e0bed 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Category.hpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Category.hpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,20 +47,8 @@
 
 #include <gtest/gtest.h>
 
-namespace Test {
-
-class threads : public ::testing::Test {
-protected:
-  static void SetUpTestCase() {
-  }
-
-  static void TearDownTestCase() {
-  }
-};
-
-} // namespace Test
-
 #define TEST_CATEGORY threads
+#define TEST_CATEGORY_DEATH threads_DeathTest
 #define TEST_EXECSPACE Kokkos::Threads
 
 #endif
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Complex.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Complex.cpp
index a19aaea9ea6b3238410932201b7b919bce157f95..1322a4170cfb302e7f4a4c94db49723f5b357275 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Complex.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Complex.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestComplex.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestComplex.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Crs.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Crs.cpp
index f5a1de15fabd565f04d317dbb3190ec3d30ca858..61468d8744bf2bbee555e8142c14f4a9ad63a99b 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Crs.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Crs.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,5 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestCrs.hpp>
+#include <threads/TestThreads_Category.hpp>
+#include <TestCrs.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_DeepCopyAlignment.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_DeepCopyAlignment.cpp
index e0f76af4e9bd930fb09caac200b4dc357d1b2d0a..8013087d6db0b68029fa5fe78f1147584f9c505a 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_DeepCopyAlignment.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_DeepCopyAlignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_FunctorAnalysis.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_FunctorAnalysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5dd1cdde169c335047b3346e6d8b77582b66cbfe
--- /dev/null
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_FunctorAnalysis.cpp
@@ -0,0 +1,47 @@
+
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <threads/TestThreads_Category.hpp>
+#include <TestFunctorAnalysis.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Init.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Init.cpp
index 39ded8fae0acb59f8a9da29a3f430e7fdc2bf345..8a3300929315edb375739dd87c39c44969de3131 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Init.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Init.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,9 +43,7 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestInit.hpp>
-#include<TestCompilerMacros.hpp>
-#include<TestPolicyConstruction.hpp>
-
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestInit.hpp>
+#include <TestCompilerMacros.hpp>
+#include <TestPolicyConstruction.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_LocalDeepCopy.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_LocalDeepCopy.cpp
index cd0aad7f2e9db3dbc2f7012e2efed917fed5a1a5..32735603a1a888e6fcf6b8e47d889cf192105bd5 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_LocalDeepCopy.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_LocalDeepCopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestLocalDeepCopy.hpp>
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_a.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_a.cpp
index 1ed47faad86a2aae9be865a71d3fb8dfbf7b23e0..3d0ee343065725b96e1e6e00775c89a39188cf67 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_a.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_a.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestMDRange_a.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestMDRange_a.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_b.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_b.cpp
index 3dccfbf43266943bf27f3d4a345bc92752bc7b49..0fa4fcf6283e79fedb4e78d6b775539b5665f5eb 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_b.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_b.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestMDRange_b.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestMDRange_b.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_c.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_c.cpp
index 6b709a893efe076b4594fb62c7d8bfd2f8093bf3..0b21cda75cac34517b8cee68dde0093ae7399d5b 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_c.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_c.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestMDRange_c.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestMDRange_c.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_d.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_d.cpp
index 9cdfec1556e35b58895b31f77315491e5c560c95..04bc98b040f4745d61ed0a95db5d72dd4d465fa3 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_d.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_d.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestMDRange_d.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestMDRange_d.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_e.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_e.cpp
index 1c4cbe7eb9bb010552e112cf2bb2dbea16fc7b7d..5267ae847a22d1ab6bae599160a709dd4d726671 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_e.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_MDRange_e.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestMDRange_e.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestMDRange_e.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Other.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Other.cpp
index 13786aa4a6729813e714eca23cf2cfbe12280b63..01a07896b32341e9cb94b9c15f558672b5ebda6c 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Other.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Other.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,12 +43,12 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestTemplateMetaFunctions.hpp>
-#include<TestAggregate.hpp>
-#include<TestMemoryPool.hpp>
-#include<TestCXX11.hpp>
-#include<TestTile.hpp>
+#include <threads/TestThreads_Category.hpp>
+#include <TestTemplateMetaFunctions.hpp>
+#include <TestAggregate.hpp>
+#include <TestMemoryPool.hpp>
+#include <TestCXX11.hpp>
+#include <TestTile.hpp>
 
-#include<TestViewCtorPropEmbeddedDim.hpp>
-#include<TestViewLayoutTiled.hpp>
+#include <TestViewCtorPropEmbeddedDim.hpp>
+#include <TestViewLayoutTiled.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_RangePolicy.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_RangePolicy.cpp
index 7404cae78688ebd0277f9462c46a019872d690e7..785469346a37e1bc00cf005b068921fbdf668c38 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_RangePolicy.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_RangePolicy.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestRange.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestRange.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_a.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_a.cpp
index 6dcf1c8adfb8274c0bdce51f899b93c551104a19..8b79d74e8ca3c8482aa5c40c9c7904910d484a0a 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_a.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_b.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_b.cpp
index 1893c3d5fbd4eea48fe4d3551fc11bad06f5794f..b556c439484ab11bc3169bd63ad68af360294826 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_b.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_c.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_c.cpp
index 799de270680b8d0cef490fe37a48cc3a2f7792d2..e2c23030a2d2d27f72707b49b97868e3555d87dc 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_c.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_d.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_d.cpp
index 696ae7221f385523c0ce1b9e8e057a7847ed9ecd..aa37b6eb56f480c402e2e54f7b2543c3577580f7 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_d.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Reducers_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Reductions.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Reductions.cpp
index 33788b9ca5e443d7c0f97d27f1eb7417e43ab4fc..9384590dcb1dab954904a448132991969b28d0e6 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Reductions.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Reductions.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Reductions_DeviceView.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Reductions_DeviceView.cpp
index 28f4b7d579d9d3701cdbd59a76be8ae9f8e10e97..e5ebb6e8a2b239f28195e8a3a1d2b17e862c15b2 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Reductions_DeviceView.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Reductions_DeviceView.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Scan.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Scan.cpp
index 9d9583e9658453e62135a9befe0ff8ea820c2a3e..12648bf305f195b386a1ff6cd0a8127a584ec12a 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Scan.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Scan.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,6 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestScan.hpp>
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestScan.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SharedAlloc.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SharedAlloc.cpp
index a028728ecb85d27b6b9ff331620509dfce11bcaa..837334c9996dc0291879d3b1782c10e9fdc36b45 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SharedAlloc.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SharedAlloc.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,10 +47,8 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, impl_shared_alloc )
-{
-  test_shared_alloc< Kokkos::HostSpace, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, impl_shared_alloc) {
+  test_shared_alloc<Kokkos::HostSpace, TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_a.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_a.cpp
index 983a6ddb668d7e484b7ea5304581aa8234d32024..7298d4cde37f902eefabd68ac6b5e380397e76cf 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_a.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,66 +47,56 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_left )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutLeft, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_left) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutLeft, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_right )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutRight, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_right) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutRight, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_auto_1d_stride )
-{
-  TestViewSubview::test_auto_1d< Kokkos::LayoutStride, TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_auto_1d_stride) {
+  TestViewSubview::test_auto_1d<Kokkos::LayoutStride, TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_assign_strided )
-{
-  TestViewSubview::test_1d_strided_assignment< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_assign_strided) {
+  TestViewSubview::test_1d_strided_assignment<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_0 )
-{
-  TestViewSubview::test_left_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_0) {
+  TestViewSubview::test_left_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_1 )
-{
-  TestViewSubview::test_left_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_1) {
+  TestViewSubview::test_left_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_2 )
-{
-  TestViewSubview::test_left_2< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_2) {
+  TestViewSubview::test_left_2<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_left_3 )
-{
-  TestViewSubview::test_left_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_left_3) {
+  TestViewSubview::test_left_3<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_0 )
-{
-  TestViewSubview::test_right_0< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_0) {
+  TestViewSubview::test_right_0<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_1 )
-{
-  TestViewSubview::test_right_1< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_1) {
+  TestViewSubview::test_right_1<TEST_EXECSPACE>();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_right_3 )
-{
-  TestViewSubview::test_right_3< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_right_3) {
+  TestViewSubview::test_right_3<TEST_EXECSPACE>();
 }
 
-TEST_F(TEST_CATEGORY, view_static_tests)
-{
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutLeft>()();
-  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE, Kokkos::LayoutRight>()();
+TEST(TEST_CATEGORY, view_static_tests) {
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutLeft>()();
+  TestViewSubview::TestSubviewStaticSizes<TEST_EXECSPACE,
+                                          Kokkos::LayoutRight>()();
   TestViewSubview::TestExtentsStaticTests<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_b.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_b.cpp
index ab1aa3df4fecb19bc6f962f2f8f79012292097b6..a6f22a08289384fe7ffeb9f299fa24501d8c8b60 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_b.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,18 +47,20 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_layoutleft_to_layoutleft )
-{
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutleft_to_layoutleft< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutleft_to_layoutleft) {
+  TestViewSubview::test_layoutleft_to_layoutleft<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutleft_to_layoutleft<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-TEST_F( TEST_CATEGORY, view_subview_layoutright_to_layoutright )
-{
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
-  TestViewSubview::test_layoutright_to_layoutright< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_layoutright_to_layoutright) {
+  TestViewSubview::test_layoutright_to_layoutright<TEST_EXECSPACE>();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+  TestViewSubview::test_layoutright_to_layoutright<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c01.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c01.cpp
index 3000d4c717f4b0519ab30563d3546b75753713be..a568569b45ffa4fd73f0bdad76f713359ec0578c 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c01.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c01.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_1d_assign) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c02.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c02.cpp
index 84f1907576e0064ffc77f6082c44ee8eff145efc..3ea141576daae05dc2df57919cef946697e24159 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c02.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c02.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_atomic )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_atomic) {
+  TestViewSubview::test_1d_assign<TEST_EXECSPACE,
+                                  Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c03.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c03.cpp
index 8076ecf1f93b8aebefcc58379bc26a1fe46129e5..eaaf11f1bc6a41a45e9a1b7ed29777bc38176732 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c03.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c03.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_1d_assign_randomaccess )
-{
-  TestViewSubview::test_1d_assign< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_1d_assign_randomaccess) {
+  TestViewSubview::test_1d_assign<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c04.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c04.cpp
index bd354fa1f247bb8090618cd56802abb630a972c9..5a5a7962c5c6914a272b08705fb3be1c2749de1c 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c04.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c04.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c05.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c05.cpp
index 88286df275e8d424f952748f57119ccc2ebf42e5..3ab975ebc40563cfd9b1ca4f5f56dfaecc803c09 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c05.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c05.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( threads, view_subview_2d_from_3d_atomic )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(threads, view_subview_2d_from_3d_atomic) {
+  TestViewSubview::test_2d_subview_3d<TEST_EXECSPACE,
+                                      Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c06.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c06.cpp
index 12c3bbcbde9cedc6e3aaaacd9b05119167f74b25..bcc9c11ad5b64a32e3537e524829bc46bb854df7 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c06.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c06.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_2d_from_3d_randomaccess )
-{
-  TestViewSubview::test_2d_subview_3d< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_2d_from_3d_randomaccess) {
+  TestViewSubview::test_2d_subview_3d<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c07.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c07.cpp
index 17a0804dd67611af9c88d99dda499f346157e8b7..2b07bd5d69ce8d4e8bd3a0bdeaa048a57b0c8bae 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c07.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c07.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left) {
+  TestViewSubview::test_3d_subview_5d_left<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c08.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c08.cpp
index 76b9dc39944e0ad0286b193fa4ebb68d13ed6a1a..02f68015ae0e1cd54c7355d7b84586fdd30e76aa 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c08.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c08.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_atomic) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c09.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c09.cpp
index efa1f516cb9817f58aeaa1128ddc10c59aa24428..cd8fbe8bb3d4018fd94c3fd458e41dadf9bd57ed 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c09.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c09.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_left< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_left_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_left<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c10.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c10.cpp
index 90f56d257314576868d7ab2821574fcac68174fa..6f0995bc58f3753e63bd0f9479d08cdcbf65666b 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c10.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c10.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right) {
+  TestViewSubview::test_3d_subview_5d_right<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c11.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c11.cpp
index 35f4994ba2e502fd7ac3d957989bd5ce832a6e8f..7ba93d051bb7c88f5f1f7944b6ab92cf5846525a 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c11.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c11.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_atomic )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_atomic) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Atomic> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c12.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c12.cpp
index 05b5dc2cc59c1e7800405106814dc2fd16fdbb3f..91b7d67aa7771cee0722a46e42b8e81f86f3f009 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c12.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c12.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,9 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess )
-{
-  TestViewSubview::test_3d_subview_5d_right< TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
+TEST(TEST_CATEGORY, view_subview_3d_from_5d_right_randomaccess) {
+  TestViewSubview::test_3d_subview_5d_right<
+      TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::RandomAccess> >();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c13.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c13.cpp
index 50cd7cecd9ba660e5a59b738a7f3904a90c079d9..4814f206d1edff89136d02cbf1875fc5738f8114 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c13.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_SubView_c13.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,9 +47,8 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, view_test_unmanaged_subview_reset )
-{
-  TestViewSubview::test_unmanaged_subview_reset< TEST_EXECSPACE >();
+TEST(TEST_CATEGORY, view_test_unmanaged_subview_reset) {
+  TestViewSubview::test_unmanaged_subview_reset<TEST_EXECSPACE>();
 }
 
-} // namespace Test
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_Team.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_Team.cpp
index 63d2509355d3742c7389811e7e3839871ca1f261..b931c5cb61a84984d917dc91d5e0d960c8756b13 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_Team.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_Team.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,45 +47,59 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_for )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 0 );
+TEST(TEST_CATEGORY, team_for) {
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      0);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      0);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 2 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      2);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      2);
 
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for( 1000 );
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_for(
+      1000);
+  TestTeamPolicy<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_for(
+      1000);
 }
 
-
-TEST_F( TEST_CATEGORY, team_reduce )
-{
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 0 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 2 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_reduce( 1000 );
-  TestTeamPolicy< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce( 1000 );
+TEST(TEST_CATEGORY, team_reduce) {
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(0);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(2);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Static> >::test_reduce(1000);
+  TestTeamPolicy<TEST_EXECSPACE,
+                 Kokkos::Schedule<Kokkos::Dynamic> >::test_reduce(1000);
 }
 
-TEST_F( TEST_CATEGORY, team_broadcast )
-{
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 0 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 0 );
+TEST(TEST_CATEGORY, team_broadcast) {
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(0);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(0);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 2 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 2 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(2);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(2);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 16 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 16 );
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast(16);
+  TestTeamBroadcast<TEST_EXECSPACE,
+                    Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast(16);
 
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::test_teambroadcast( 1000 );
-  TestTeamBroadcast< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::test_teambroadcast( 1000 );
-}
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >::
+      test_teambroadcast(1000);
+  TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >::
+      test_teambroadcast(1000);
 }
+}  // namespace Test
 
 #include <TestTeamVector.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_TeamReductionScan.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_TeamReductionScan.cpp
index 1df976f10dfb4ddab0c493ae4a6fad84e338ac1c..2c382c80aeff86dd214fc10c3329354c388e046b 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_TeamReductionScan.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_TeamReductionScan.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,36 +47,35 @@
 
 namespace Test {
 
-
-TEST_F( TEST_CATEGORY, team_scan )
-{
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 10000 );
-  TestScanTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 10000 );
+TEST(TEST_CATEGORY, team_scan) {
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(10000);
+  TestScanTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(10000);
 }
 
-TEST_F( TEST_CATEGORY, team_long_reduce )
-{
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_long_reduce) {
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<long, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-TEST_F( TEST_CATEGORY, team_double_reduce )
-{
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 0 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 3 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >( 100000 );
-  TestReduceTeam< double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >( 100000 );
+TEST(TEST_CATEGORY, team_double_reduce) {
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(0);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(3);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >(
+      100000);
+  TestReduceTeam<double, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >(
+      100000);
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_TeamScratch.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_TeamScratch.cpp
index d171195798441f8815a4c79630d34381fd4365a4..d793a9050fd0023f42a71b2d9626b7d20de22568 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_TeamScratch.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_TeamScratch.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -46,42 +47,36 @@
 
 namespace Test {
 
-TEST_F( TEST_CATEGORY, team_shared_request )
-{
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestSharedTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_shared_request) {
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestSharedTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, team_scratch_request )
-{
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, team_scratch_request) {
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
+  TestScratchTeam<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA )
-#if !defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )
-TEST_F( TEST_CATEGORY, team_lambda_shared_request )
-{
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestLambdaSharedTeam< Kokkos::HostSpace, TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION)
+TEST(TEST_CATEGORY, team_lambda_shared_request) {
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Static> >();
+  TestLambdaSharedTeam<Kokkos::HostSpace, TEST_EXECSPACE,
+                       Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-TEST_F( TEST_CATEGORY, scratch_align) {
-  TestScratchAlignment< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, scratch_align) { TestScratchAlignment<TEST_EXECSPACE>(); }
 #endif
 #endif
 
-TEST_F( TEST_CATEGORY, shmem_size )
-{
-  TestShmemSize< TEST_EXECSPACE >();
-}
+TEST(TEST_CATEGORY, shmem_size) { TestShmemSize<TEST_EXECSPACE>(); }
 
-TEST_F( TEST_CATEGORY, multi_level_scratch )
-{
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> >();
-  TestMultiLevelScratchTeam< TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> >();
+TEST(TEST_CATEGORY, multi_level_scratch) {
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Static> >();
+  TestMultiLevelScratchTeam<TEST_EXECSPACE,
+                            Kokkos::Schedule<Kokkos::Dynamic> >();
 }
 
-} // namespace Test
-
+}  // namespace Test
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_TeamTeamSize.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_TeamTeamSize.cpp
index b1cf4ec8752b3cf21d1336300f4f777f13b2b788..d5e16dcbd30d3cc63595ab3c95ef4668ae6593a0 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_TeamTeamSize.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_TeamTeamSize.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,5 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestTeamTeamSize.hpp>
-
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_TeamVectorRange.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_TeamVectorRange.cpp
index 62b0d666cec1c878cbb5cbee4a9d6cc3df57101d..4e216d75d0f0ef10b69993fc6a2eb01621370738 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_TeamVectorRange.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_TeamVectorRange.cpp
@@ -3,10 +3,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -24,10 +25,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -42,7 +43,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestTeamVectorRange.hpp>
-
-
+#include <threads/TestThreads_Category.hpp>
+#include <TestTeamVectorRange.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_UniqueToken.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_UniqueToken.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8391af88a454826106001ae1bc2e1c54bf5e8c8
--- /dev/null
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_UniqueToken.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <threads/TestThreads_Category.hpp>
+#include <TestUniqueToken.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_a.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_a.cpp
index 9b8ce446823312443b5dc3b2a81afef3db41fb7d..91bbd2d16a442ce6ac43aa239a1c3146776dd5f1 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_a.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_b.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_b.cpp
index 454ec901789134bd1b3366fee7ec1da78a351dbb..aaee8e5795af4f0056eba551e5bfa3bacd3827ef 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_b.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_c.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_c.cpp
index c63ad3cff671bf76c339ad2265821371b24ad9c0..074344d12768ed0a4bf05b2761dd46d62126117a 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_c.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_c.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_d.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_d.cpp
index 2b31591569d9bd4d85afe1f60f8e90c6530d9c93..995bb5666585b333f4d4ba1309565565b4def506 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_d.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_d.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_e.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_e.cpp
index 616a92349656e4357a4a694be2af99d3588bc4f6..879f075db2c415758ac423d517de4f491a041b7a 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_e.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewAPI_e.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewLayoutStrideAssignment.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewLayoutStrideAssignment.cpp
index 5ddd07108b54c2a92436d42a16ddc8cf5d17c857..0b54784d959248992444cfc526f0d7c27bd42ebf 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewLayoutStrideAssignment.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewLayoutStrideAssignment.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestViewLayoutStrideAssignment.hpp>
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_a.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_a.cpp
index d67f376fc609aa24d5d5ed8526bdafb83d033f19..22f849a0c91687397b84d0a6855a43a5f1e86a17 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_a.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_a.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestViewMapping_a.hpp>
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_b.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_b.cpp
index 49c7f6d3d75714bab5689a9b44ea39a82186aa82..d18b9b899e4acbb33a97919ff1e2b1d62b30a74f 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_b.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_b.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestViewMapping_b.hpp>
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_subview.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_subview.cpp
index 6c4f14873e040eebf0378c04597652c0589364e7..3e9ce21027fa8179dd231bd34a7615819eb5bfb6 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_subview.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewMapping_subview.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestViewMapping_subview.hpp>
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewOfClass.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewOfClass.cpp
index d9a9c17feaec5af5bce08b3e1eed40ee6e92f102..3018023cb5046fbda8bc1e9233a93e8ab7704997 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_ViewOfClass.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewOfClass.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -43,4 +44,3 @@
 
 #include <threads/TestThreads_Category.hpp>
 #include <TestViewOfClass.hpp>
-
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_ViewResize.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_ViewResize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a143e3f4dfe3a24810fab305c870a3db7a4b6246
--- /dev/null
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_ViewResize.cpp
@@ -0,0 +1,46 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#include <threads/TestThreads_Category.hpp>
+#include <TestViewResize.hpp>
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_View_64bit.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_View_64bit.cpp
index 5c2d727a4a85d349e48ed57ed60d53799648d334..b347b441ef0d7de0c4b0bc8bbef57783effbb9f7 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_View_64bit.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_View_64bit.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
diff --git a/lib/kokkos/core/unit_test/threads/TestThreads_WorkGraph.cpp b/lib/kokkos/core/unit_test/threads/TestThreads_WorkGraph.cpp
index e7801d1179c70b6ba5c760fcfac68fbbc6131a07..1ebc7d896a240f55d7ac49c9a29e455d9aa3bf4d 100644
--- a/lib/kokkos/core/unit_test/threads/TestThreads_WorkGraph.cpp
+++ b/lib/kokkos/core/unit_test/threads/TestThreads_WorkGraph.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -41,5 +42,5 @@
 //@HEADER
 */
 
-#include<threads/TestThreads_Category.hpp>
-#include<TestWorkGraph.hpp>
+#include <threads/TestThreads_Category.hpp>
+#include <TestWorkGraph.hpp>
diff --git a/lib/kokkos/example/CMakeLists.txt b/lib/kokkos/example/CMakeLists.txt
index 3809cc2ea57a26ba1b3003a2e706fee912ccabc9..c7d60995463701f1df28c36e7cc40f15ea507e5f 100644
--- a/lib/kokkos/example/CMakeLists.txt
+++ b/lib/kokkos/example/CMakeLists.txt
@@ -2,19 +2,19 @@
 
 # Subpackage name must match what appears in kokkos/cmake/Dependencies.cmake
 #
-TRIBITS_SUBPACKAGE(Example)
+#KOKKOS_SUBPACKAGE(Example)
 
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(query_device)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(fixture)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(feint)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(fenl)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(multi_fem)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(md_skeleton)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(global_2_local_ids)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(grow_array)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(sort_array)
-if(NOT Kokkos_ENABLE_Cuda)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(tutorial)
-endif()
-TRIBITS_SUBPACKAGE_POSTPROCESS()
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(query_device)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(fixture)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(feint)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(fenl)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(multi_fem)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(md_skeleton)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(global_2_local_ids)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(grow_array)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(sort_array)
+#if(NOT Kokkos_ENABLE_CUDA)
+#KOKKOS_ADD_EXAMPLE_DIRECTORIES(tutorial)
+#endif()
+#KOKKOS_SUBPACKAGE_POSTPROCESS()
 
diff --git a/lib/kokkos/example/cmake_build/CMakeLists.txt b/lib/kokkos/example/build_cmake_in_tree/CMakeLists.txt
similarity index 100%
rename from lib/kokkos/example/cmake_build/CMakeLists.txt
rename to lib/kokkos/example/build_cmake_in_tree/CMakeLists.txt
diff --git a/lib/kokkos/example/cmake_build/cmake_example.cpp b/lib/kokkos/example/build_cmake_in_tree/cmake_example.cpp
similarity index 85%
rename from lib/kokkos/example/cmake_build/cmake_example.cpp
rename to lib/kokkos/example/build_cmake_in_tree/cmake_example.cpp
index a73b65abf05239328ac6f6c5b98ce3d8b0b53733..c6bbaeca8181a9d02edffd5b68df88677352a7a6 100644
--- a/lib/kokkos/example/cmake_build/cmake_example.cpp
+++ b/lib/kokkos/example/build_cmake_in_tree/cmake_example.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -65,9 +66,9 @@ int main(int argc, char* argv[]) {
 
   // Compute the number of even integers from 0 to n-1, in parallel.
   long count = 0;
-  Kokkos::parallel_reduce(n, KOKKOS_LAMBDA (const long i, long& lcount) {
-    lcount += (i % 2) == 0;
-  }, count);
+  Kokkos::parallel_reduce(
+      n, KOKKOS_LAMBDA(const long i, long& lcount) { lcount += (i % 2) == 0; },
+      count);
 
   double count_time = timer.seconds();
   printf("  Parallel: %ld    %10.6f\n", count, count_time);
diff --git a/lib/kokkos/example/cmake_build/foo.f b/lib/kokkos/example/build_cmake_in_tree/foo.f
similarity index 100%
rename from lib/kokkos/example/cmake_build/foo.f
rename to lib/kokkos/example/build_cmake_in_tree/foo.f
diff --git a/lib/kokkos/example/build_cmake_installed/CMakeLists.txt b/lib/kokkos/example/build_cmake_installed/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7fdb94d4546522cf9902cd7f8e27b9566eb88cce
--- /dev/null
+++ b/lib/kokkos/example/build_cmake_installed/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Kokkos requires CMake version 3.1 or higher and that you have the following
+# line with a version of 3.1 or higher as the first line of your project:
+#   cmake_minimum_required(VERSION 3.1)
+#
+# The other CMake commands required to build Kokkos as part of your application
+# are:
+#   add_subdirectory(path/to/kokkos)
+#   target_link_libraries(executable or library)
+#
+# If Kokkos is not a subdirectory of your project, you will also need to pass a
+# binary directory to add_subdirectory().  We had to pass the binary directory
+# for this example for that reason.  Note that target_link_libraries() can be
+# called on a target added by add_executable(), add_library(), or another
+# similar command.
+#
+# All the flags, etc. required to build using the Kokkos library are
+# transitively added to targets which depend on the library.
+#
+# The CMake variables CMAKE_CXX_STANDARD and CMAKE_CXX_EXTENSIONS are
+# respected.  We recommend that you set CMAKE_CXX_EXTENSIONS to OFF.
+# Otherwise, CMake defaults to using extensions for the C++ standard, and the
+# GNU extensions (-std=gnu++11) will be used for compilers that support it
+# instead of standard C++11 (-std=c++11).
+#
+# A bunch of build options are added as variables (all starting with KOKKOS_)
+# to the build.  Check them out using ccmake or the CMake GUI.
+#
+# Building this example:
+#   1. Create a build directory.
+#   2. cd /path/to/build/directory
+#   3. cmake /path/to/example
+#   4. make
+
+cmake_minimum_required(VERSION 3.12)
+project(Example CXX C Fortran)
+
+list(APPEND CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} -O3)
+
+find_package(Kokkos)
+
+add_executable(example cmake_example.cpp foo.f)
+target_link_libraries(example Kokkos::kokkos)
diff --git a/lib/kokkos/example/feint/main.cpp b/lib/kokkos/example/build_cmake_installed/cmake_example.cpp
similarity index 55%
rename from lib/kokkos/example/feint/main.cpp
rename to lib/kokkos/example/build_cmake_installed/cmake_example.cpp
index df61f3e266f830cc1e64b308ea5909b5f75a7f14..c6bbaeca8181a9d02edffd5b68df88677352a7a6 100644
--- a/lib/kokkos/example/feint/main.cpp
+++ b/lib/kokkos/example/build_cmake_installed/cmake_example.cpp
@@ -1,10 +1,12 @@
+/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -22,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -38,23 +40,53 @@
 //
 // ************************************************************************
 //@HEADER
-
-#include <utility>
-#include <iostream>
+*/
 
 #include <Kokkos_Core.hpp>
+#include <cstdio>
+
+extern "C" void print_fortran_();
 
-#include <feint_fwd.hpp>
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
+  Kokkos::DefaultExecutionSpace::print_configuration(std::cout);
 
-int main(int argc, char* argv[])
-{
-  Kokkos::initialize(argc,argv);
-  {
-    std::cout << "feint< " << Kokkos::DefaultExecutionSpace::name() << " , NotUsingAtomic >" << std::endl ;
-    Kokkos::Example::feint< Kokkos::DefaultExecutionSpace , false >();
-    std::cout << "feint< " << Kokkos::DefaultExecutionSpace::name() << " , UsingAtomic >" << std::endl ;
-    Kokkos::Example::feint< Kokkos::DefaultExecutionSpace , true >();
+  if (argc < 2) {
+    fprintf(stderr, "Usage: %s [<kokkos_options>] <size>\n", argv[0]);
+    Kokkos::finalize();
+    exit(1);
   }
+
+  const long n = strtol(argv[1], NULL, 10);
+
+  printf("Number of even integers from 0 to %ld\n", n - 1);
+
+  Kokkos::Timer timer;
+  timer.reset();
+
+  // Compute the number of even integers from 0 to n-1, in parallel.
+  long count = 0;
+  Kokkos::parallel_reduce(
+      n, KOKKOS_LAMBDA(const long i, long& lcount) { lcount += (i % 2) == 0; },
+      count);
+
+  double count_time = timer.seconds();
+  printf("  Parallel: %ld    %10.6f\n", count, count_time);
+
+  timer.reset();
+
+  // Compare to a sequential loop.
+  long seq_count = 0;
+  for (long i = 0; i < n; ++i) {
+    seq_count += (i % 2) == 0;
+  }
+
+  count_time = timer.seconds();
+  printf("Sequential: %ld    %10.6f\n", seq_count, count_time);
+
+  print_fortran_();
+
   Kokkos::finalize();
-}
 
+  return (count == seq_count) ? 0 : -1;
+}
diff --git a/lib/kokkos/example/build_cmake_installed/foo.f b/lib/kokkos/example/build_cmake_installed/foo.f
new file mode 100644
index 0000000000000000000000000000000000000000..e618455283b65602d98a5de00c8dc2abc6b0f8c2
--- /dev/null
+++ b/lib/kokkos/example/build_cmake_installed/foo.f
@@ -0,0 +1,4 @@
+        FUNCTION print_fortran()
+          PRINT *, 'Hello World from Fortran'
+          RETURN
+        END
diff --git a/lib/kokkos/example/common/VectorImport.hpp b/lib/kokkos/example/common/VectorImport.hpp
deleted file mode 100644
index dd35bd568712f7b3b44cda6c47cf5e4cd027d6d5..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/common/VectorImport.hpp
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_VECTORIMPORT_HPP
-#define KOKKOS_VECTORIMPORT_HPP
-
-#include <utility>
-#include <limits>
-#include <iostream>
-#include <sstream>
-#include <stdexcept>
-
-#include <Kokkos_Core.hpp>
-
-#include <WrapMPI.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-template< class CommMessageType , class CommIdentType , class VectorType >
-struct VectorImport ;
-
-} // namespace Example
-} // namespace Kokkos
-
-#if ! defined( KOKKOS_ENABLE_MPI )
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-template< class CommMessageType , class CommIdentType , class VectorType >
-struct VectorImport {
-
-  const MPI_Comm comm ;
-  const unsigned count_owned ;
-  const unsigned count_receive ;
-
-  VectorImport( MPI_Comm arg_comm ,
-                const CommMessageType & ,
-                const CommMessageType & ,
-                const CommIdentType   & ,
-                const unsigned arg_count_owned ,
-                const unsigned arg_count_receive )
-    : comm( arg_comm )
-    , count_owned( arg_count_owned )
-    , count_receive( arg_count_receive )
-    {}
-
-  inline
-  void operator()( const VectorType & ) const {}
-};
-
-
-} // namespace Example
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#else /* defined( KOKKOS_ENABLE_MPI ) */
-
-namespace Kokkos {
-namespace Example {
-
-template< class CommMessageType , class CommIdentType , class VectorType >
-class VectorImport {
-private:
-
-  // rank == 1 or array_layout == LayoutRight
-  static_assert(
-             ( VectorType::rank == 1 ) ||
-             std::is_same< typename VectorType::array_layout , Kokkos::LayoutRight >::value,
-             "Kokkos::Example::VectorImport Assert Fail: rank != 1 or array_layout != LayoutRight" );
-
-  typedef typename VectorType::HostMirror HostVectorType ;
-
-  enum { ReceiveInPlace =
-    std::is_same< typename VectorType::memory_space ,
-                           typename HostVectorType::memory_space >::value };
-
-  const CommMessageType  recv_msg ;
-  const CommMessageType  send_msg ;
-  const CommIdentType    send_nodeid ;
-  VectorType             send_buffer ;
-  HostVectorType         host_send_buffer ;
-  HostVectorType         host_recv_buffer ;
-  unsigned               chunk ;
-
-public:
-
-  const MPI_Comm         comm ;
-  const unsigned         count_owned ;
-  const unsigned         count_receive ;
-
-  struct Pack {
-    typedef typename VectorType::execution_space execution_space ;
-    const CommIdentType  index ;
-    const VectorType     source ;
-    const VectorType     buffer ;
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()( const unsigned i ) const
-      { buffer( i ) = source( index(i) ); }
-
-    Pack( const CommIdentType  & arg_index ,
-          const VectorType     & arg_source ,
-          const VectorType     & arg_buffer )
-      : index( arg_index )
-      , source( arg_source )
-      , buffer( arg_buffer )
-    {
-      Kokkos::parallel_for( index.dimension_0() , *this );
-      execution_space().fence();
-    }
-  };
-
-  VectorImport( MPI_Comm arg_comm ,
-                const CommMessageType & arg_recv_msg ,
-                const CommMessageType & arg_send_msg ,
-                const CommIdentType   & arg_send_nodeid ,
-                const unsigned arg_count_owned ,
-                const unsigned arg_count_receive )
-    : recv_msg( arg_recv_msg )
-    , send_msg( arg_send_msg )
-    , send_nodeid( arg_send_nodeid )
-    , send_buffer()
-    , host_send_buffer()
-    , host_recv_buffer()
-    , comm( arg_comm )
-    , count_owned( arg_count_owned )
-    , count_receive( arg_count_receive )
-    {
-      if ( ! ReceiveInPlace ) {
-        host_recv_buffer = HostVectorType("recv_buffer",count_receive);
-      }
-
-      unsigned send_count = 0 ;
-      for ( unsigned i = 0 ; i < send_msg.dimension_0() ; ++i ) { send_count += send_msg(i,1); }
-      send_buffer      = VectorType("send_buffer",send_count);
-      host_send_buffer = Kokkos::create_mirror_view( send_buffer );
-    }
-
-  inline
-  void operator()( const VectorType & v ) const
-  {
-    typedef typename VectorType::value_type  scalar_type ;
-
-    const int mpi_tag = 42 ;
-    const unsigned chunk = v.dimension_1();
-
-    // Subvector for receives
-    const std::pair<unsigned,unsigned> recv_range( count_owned , count_owned + count_receive );
-    const VectorType recv_vector = Kokkos::subview( v , recv_range );
-
-    std::vector< MPI_Request > recv_request( recv_msg.dimension_0() , MPI_REQUEST_NULL );
-
-    { // Post receives
-      scalar_type * ptr =
-        ReceiveInPlace ? recv_vector.ptr_on_device() : host_recv_buffer.ptr_on_device();
-
-      for ( size_t i = 0 ; i < recv_msg.dimension_0() ; ++i ) {
-        const int proc  = recv_msg(i,0);
-        const int count = recv_msg(i,1) * chunk ;
-
-        MPI_Irecv( ptr , count * sizeof(scalar_type) , MPI_BYTE ,
-                   proc , mpi_tag , comm , & recv_request[i] );
-
-        ptr += count ;
-      }
-    }
-
-    MPI_Barrier( comm );
-
-    { // Pack and send 
-      const Pack pack( send_nodeid , v , send_buffer );
-
-      Kokkos::deep_copy( host_send_buffer , send_buffer );
-
-      scalar_type * ptr = host_send_buffer.ptr_on_device();
-
-      for ( size_t i = 0 ; i < send_msg.dimension_0() ; ++i ) {
-        const int proc  = send_msg(i,0);
-        const int count = send_msg(i,1) * chunk ;
-
-        // MPI_Ssend blocks until
-        // (1) a receive is matched for the message and
-        // (2) the send buffer can be re-used.
-        //
-        // It is suggested that MPI_Ssend will have the best performance:
-        // http://www.mcs.anl.gov/research/projects/mpi/sendmode.html .
-
-        MPI_Ssend( ptr ,
-                   count * sizeof(scalar_type) , MPI_BYTE ,
-                   proc , mpi_tag , comm );
-
-        ptr += count ;
-      }
-    }
-
-    // Wait for receives and verify:
-
-    for ( size_t i = 0 ; i < recv_msg.dimension_0() ; ++i ) {
-      MPI_Status recv_status ;
-      int recv_which = 0 ;
-      int recv_size  = 0 ;
-
-      MPI_Waitany( recv_msg.dimension_0() , & recv_request[0] , & recv_which , & recv_status );
-
-      const int recv_proc = recv_status.MPI_SOURCE ;
-
-      MPI_Get_count( & recv_status , MPI_BYTE , & recv_size );
-
-      // Verify message properly received:
-
-      const int  expected_proc = recv_msg(recv_which,0);
-      const int  expected_size = recv_msg(recv_which,1) * chunk * sizeof(scalar_type);
-
-      if ( ( expected_proc != recv_proc ) ||
-           ( expected_size != recv_size ) ) {
-
-        int local_rank  = 0 ;
-
-        MPI_Comm_rank( comm , & local_rank );
-
-        std::ostringstream msg ;
-        msg << "VectorImport error:"
-            << " P" << local_rank
-            << " received from P" << recv_proc
-            << " size "     << recv_size
-            << " expected " << expected_size
-            << " from P"    << expected_proc ;
-        throw std::runtime_error( msg.str() );
-      }
-    }
-
-    // Copy received data to device memory.
-
-    if ( ! ReceiveInPlace ) { Kokkos::deep_copy( recv_vector , host_recv_buffer ); }
-  }
-};
-
-} // namespace Example
-} // namespace Kokkos
-
-#endif
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_VECTORIMPORT_HPP */
-
-
diff --git a/lib/kokkos/example/common/WrapMPI.hpp b/lib/kokkos/example/common/WrapMPI.hpp
deleted file mode 100644
index cad2bb5cdfe0d094fed6a6ac83977ef3e1e104da..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/common/WrapMPI.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_WRAP_MPI
-#define KOKKOS_EXAMPLE_WRAP_MPI
-
-#include <Kokkos_Macros.hpp>
-#include <string>
-
-#if defined( KOKKOS_ENABLE_MPI )
-
-#include <mpi.h>
-
-namespace Kokkos {
-namespace Example {
-
-inline
-double all_reduce( double value , MPI_Comm comm )
-{
-  double local = value ;
-  MPI_Allreduce( & local , & value , 1 , MPI_DOUBLE , MPI_SUM , comm );
-  return value ;
-}
-
-inline
-double all_reduce_max( double value , MPI_Comm comm )
-{
-  double local = value ;
-  MPI_Allreduce( & local , & value , 1 , MPI_DOUBLE , MPI_MAX , comm );
-  return value ;
-}
-
-} // namespace Example
-} // namespace Kokkos
-
-#elif ! defined( KOKKOS_ENABLE_MPI )
-
-/* Wrap the the MPI_Comm type and heavily used MPI functions
- * to reduce the number of '#if defined( KOKKOS_ENABLE_MPI )'
- * blocks which have to be sprinkled throughout the examples.
- */
-
-typedef int MPI_Comm ;
-
-inline int MPI_Comm_size( MPI_Comm , int * size ) { *size = 1 ; return 0 ; }
-inline int MPI_Comm_rank( MPI_Comm , int * rank ) { *rank = 0 ; return 0 ; }
-inline int MPI_Barrier( MPI_Comm ) { return 0; }
-
-namespace Kokkos {
-namespace Example {
-
-inline
-double all_reduce( double value , MPI_Comm ) { return value ; }
-
-inline
-double all_reduce_max( double value , MPI_Comm ) { return value ; }
-
-} // namespace Example
-} // namespace Kokkos
-
-#endif /* ! defined( KOKKOS_ENABLE_MPI ) */
-#endif /* #ifndef KOKKOS_EXAMPLE_WRAP_MPI */
-
diff --git a/lib/kokkos/example/feint/CMakeLists.txt b/lib/kokkos/example/feint/CMakeLists.txt
deleted file mode 100644
index 0018b9f9f538de77ce776daaa267a037714387ad..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../common)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../fixture)
-
-SET(SOURCES "")
-
-FILE(GLOB SOURCES *.cpp)
-
-LIST( APPEND SOURCES ../fixture/BoxElemPart.cpp)
-
-TRIBITS_ADD_EXECUTABLE(
-  feint
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  )
-
diff --git a/lib/kokkos/example/feint/ElemFunctor.hpp b/lib/kokkos/example/feint/ElemFunctor.hpp
deleted file mode 100644
index eebe777d98004f9441c50d1a3aef20db47aae9a4..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/ElemFunctor.hpp
+++ /dev/null
@@ -1,485 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_FEINT_FUNCTORS_HPP
-#define KOKKOS_EXAMPLE_FEINT_FUNCTORS_HPP
-
-#include <cstdio>
-#include <Kokkos_Core.hpp>
-#include <BoxElemFixture.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-/** \brief  Numerically integrate a function on a finite element mesh and
- *          project the integrated values to nodes.
- */
-template< class FixtureType ,
-          class FunctionType ,
-          bool PerformScatterAddWithAtomic >
-struct FiniteElementIntegration ;
-
-// Specialized for an 'Example::BoxElemFixture' finite element mesh
-template< class Device , BoxElemPart::ElemOrder ElemOrder , class GridMap ,
-          class FunctionType ,
-          bool PerformScatterAddWithAtomic >
-struct FiniteElementIntegration<
-  Kokkos::Example::BoxElemFixture< Device , ElemOrder , GridMap > ,
-  FunctionType ,
-  PerformScatterAddWithAtomic >
-{
-  // Element mesh types:
-  typedef Kokkos::Example::BoxElemFixture< Device , ElemOrder >
-    BoxFixtureType ;
-
-  typedef Kokkos::Example::HexElement_Data< BoxFixtureType::ElemNode >
-    HexElemDataType ;
-
-  enum { ElemNodeCount    = HexElemDataType::element_node_count  };
-  enum { IntegrationCount = HexElemDataType::integration_count };
-  enum { ValueCount       = FunctionType::value_count };
-
-  // Dictionary of view types:
-  typedef View<int*,                              Device> ElemErrorType ;
-  typedef View<double*[ElemNodeCount][ValueCount],Device> ElemValueType ;
-  typedef View<double*[ValueCount],               Device> NodeValueType ;
-
-  // Data members for this Functor:
-  const HexElemDataType  m_hex_elem_data ; ///< Master element
-  const BoxFixtureType   m_box_fixture ;   ///< Unstructured mesh data
-  const FunctionType     m_function ;      ///< Function to integrate
-  const ElemErrorType    m_elem_error ;    ///< Flags for element errors
-  const ElemValueType    m_elem_integral ; ///< Per-element quantities
-  const NodeValueType    m_node_lumped ;   ///< Quantities lumped to nodes
-
-  //----------------------------------------
-
-  FiniteElementIntegration(
-    const BoxFixtureType & box_fixture ,
-    const FunctionType   & function )
-    : m_hex_elem_data()
-    , m_box_fixture( box_fixture ) // Shallow copy of the mesh fixture
-    , m_function( function )
-    , m_elem_error(    "elem_error"    , box_fixture.elem_count() )
-    , m_elem_integral( "elem_integral" , box_fixture.elem_count() )
-    , m_node_lumped(   "node_lumped"   , box_fixture.node_count() )
-    {}
-
-  //----------------------------------------
-  // Device for parallel dispatch.
-  typedef typename Device::execution_space execution_space;
-
-  // Value type for global parallel reduction.
-  struct value_type {
-    double value[ ValueCount ]; ///< Integrated quantitie
-    int    error ;              ///< Element inversion flag
-  };
-
-  //----------------------------------------
-  // Transform element interpolation function gradients and
-  // compute determinant of spatial jacobian.
-  KOKKOS_INLINE_FUNCTION
-  float transform_gradients(
-    const float  grad[][  ElemNodeCount ] , // Gradient of bases master element
-    const double coord[][ ElemNodeCount ] ,
-          float  dpsi[][  ElemNodeCount ] ) const
-  {
-    enum { TensorDim = 9 };
-    enum { j11 = 0 , j12 = 1 , j13 = 2 ,
-           j21 = 3 , j22 = 4 , j23 = 5 ,
-           j31 = 6 , j32 = 7 , j33 = 8 };
-
-    // Temporary for jacobian accumulation is double for summation accuracy.
-    double J[ TensorDim ] = { 0, 0, 0,  0, 0, 0,  0, 0, 0 };
-
-    for( int i = 0; i < ElemNodeCount ; ++i ) {
-      J[j11] += grad[0][i] * coord[0][i] ;
-      J[j12] += grad[0][i] * coord[1][i] ;
-      J[j13] += grad[0][i] * coord[2][i] ;
-
-      J[j21] += grad[1][i] * coord[0][i] ;
-      J[j22] += grad[1][i] * coord[1][i] ;
-      J[j23] += grad[1][i] * coord[2][i] ;
-
-      J[j31] += grad[2][i] * coord[0][i] ;
-      J[j32] += grad[2][i] * coord[1][i] ;
-      J[j33] += grad[2][i] * coord[2][i] ;
-    }
-
-    // Inverse jacobian, compute as double and store as float.
-    float invJ[ TensorDim ] = {
-      float( J[j22] * J[j33] - J[j23] * J[j32] ) ,
-      float( J[j13] * J[j32] - J[j12] * J[j33] ) ,
-      float( J[j12] * J[j23] - J[j13] * J[j22] ) ,
-
-      float( J[j23] * J[j31] - J[j21] * J[j33] ) ,
-      float( J[j11] * J[j33] - J[j13] * J[j31] ) ,
-      float( J[j13] * J[j21] - J[j11] * J[j23] ) ,
-
-      float( J[j21] * J[j32] - J[j22] * J[j31] ) ,
-      float( J[j12] * J[j31] - J[j11] * J[j32] ) ,
-      float( J[j11] * J[j22] - J[j12] * J[j21] ) };
-
-    const float detJ = J[j11] * invJ[j11] +
-                       J[j21] * invJ[j12] +
-                       J[j31] * invJ[j13] ;
-
-    {
-      const float detJinv = 1.0 / detJ ;
-      for ( int i = 0 ; i < TensorDim ; ++i ) { invJ[i] *= detJinv ; }
-    }
-
-    // Transform gradients:
-    for ( int i = 0; i < ElemNodeCount ; ++i ) {
-      dpsi[0][i] = grad[0][i] * invJ[j11] +
-                   grad[1][i] * invJ[j12] +
-                   grad[2][i] * invJ[j13];
-      dpsi[1][i] = grad[0][i] * invJ[j21] +
-                   grad[1][i] * invJ[j22] +
-                   grad[2][i] * invJ[j23];
-      dpsi[2][i] = grad[0][i] * invJ[j31] +
-                   grad[1][i] * invJ[j32] +
-                   grad[2][i] * invJ[j33];
-    }
-
-    return detJ ;
-  }
-
-  // Functor's function called for each element in the mesh
-  // to numerically integrate the function and add element quantities
-  // to the global integral.
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const int ielem , value_type & update ) const
-  {
-    // Local temporaries for gathering nodal data.
-    double node_coord[3][ ElemNodeCount ];
-
-    int inode[ ElemNodeCount ] ;
-
-    // Gather indices of element's node from global memory to local memory.
-    for ( int i = 0 ; i < ElemNodeCount ; ++i ) {
-      inode[i] = m_box_fixture.elem_node( ielem , i );
-    }
-
-    // Gather coordinates of element's nodes from global memory to local memory.
-    for ( int i = 0 ; i < ElemNodeCount ; ++i ) {
-      node_coord[0][i] = m_box_fixture.node_coord( inode[i] , 0 );
-      node_coord[1][i] = m_box_fixture.node_coord( inode[i] , 1 );
-      node_coord[2][i] = m_box_fixture.node_coord( inode[i] , 2 );
-    }
-
-    // Local temporary to accumulate numerical integration
-    // of vector valued function.
-    double accum[ ValueCount ];
-
-    for ( int j = 0 ; j < ValueCount ; ++j ) { accum[j] = 0 ; }
-
-    int error = 0 ;
-
-    // Numerical integration loop for this element:
-    for ( int k = 0 ; k < IntegrationCount ; ++k ) {
-
-      // Integration point in space as interpolated from nodal coordinates:
-      double point[3] = { 0 , 0 , 0 };
-      for ( int i = 0 ; i < ElemNodeCount ; ++i ) {
-        point[0] += node_coord[0][i] * m_hex_elem_data.values[k][i] ;
-        point[1] += node_coord[1][i] * m_hex_elem_data.values[k][i] ;
-        point[2] += node_coord[2][i] * m_hex_elem_data.values[k][i] ;
-      }
-
-      // Example function vector value at cubature point:
-      double val_at_pt[ ValueCount ];
-      m_function( point , val_at_pt );
-
-      // Temporary array for transformed element basis functions' gradient.
-      // Not used in this example, but computed anyway by the more general
-      // deformation function.
-      float dpsi[3][ ElemNodeCount ];
-
-      // Compute deformation jacobian, transform basis function gradient,
-      // and return determinant of deformation jacobian.
-      float detJ = transform_gradients( m_hex_elem_data.gradients[k] ,
-                                        node_coord , dpsi );
-
-      // Check for inverted spatial jacobian
-      if ( detJ <= 0 ) { error = 1 ; detJ = 0 ; }
-
-      // Integration weight.
-      const float w = m_hex_elem_data.weights[k] * detJ ;
-
-      // Cubature of function.
-      for ( int j = 0 ; j < ValueCount ; ++j ) {
-        accum[j] += val_at_pt[j] * w ;
-      }
-    }
-
-    m_elem_error(ielem) = error ;
-
-
-    // Element contribution to global integral:
-
-    if ( error ) { update.error = 1 ; }
-
-    for ( int j = 0 ; j < ValueCount ; ++j ) { update.value[j] += accum[j] ; }
-
-    // Element-node quantity for lumping to nodes:
-    for ( int i = 0 ; i < ElemNodeCount ; ++i ) {
-      for ( int j = 0 ; j < ValueCount ; ++j ) {
-        // Save element's integral apportionment to nodes to global memory
-        m_elem_integral( ielem , i , j ) = accum[j] / ElemNodeCount ;
-      }
-    }
-
-    if ( PerformScatterAddWithAtomic ) {
-      // Option to immediately scatter-add the integrated quantities to nodes.
-      // This is a race condition as two or more threads could attempt
-      // concurrent update of nodal values.  The atomic_fetch_add (+=)
-      // function guarantees that the summation will occur correctly;
-      // however, there can be no guarantee for the order of summation.
-      // Due to non-associativity of floating point arithmetic the result
-      // is non-deterministic within bounds of floating point round-off.
-
-      for ( int i = 0 ; i < ElemNodeCount ; ++i ) {
-        for ( int j = 0 ; j < ValueCount ; ++j ) {
-          Kokkos::atomic_fetch_add( & m_node_lumped( inode[i] , j ) ,
-                                    m_elem_integral( ielem , i , j ) );
-        }
-      }
-    }
-  }
-  //--------------------------------------------------------------------------
-
-  // Initialization of the global reduction value.
-  KOKKOS_INLINE_FUNCTION
-  void init( value_type & update ) const
-  {
-    for ( int j = 0 ; j < ValueCount ; ++j ) update.value[j] = 0 ;
-    update.error = 0 ;
-  }
-
-  // Join two contributions to global reduction value.
-  KOKKOS_INLINE_FUNCTION
-  void join( volatile       value_type & update ,
-             volatile const value_type & input ) const
-  {
-    for ( int j = 0 ; j < ValueCount ; ++j ) update.value[j] += input.value[j] ;
-    if ( input.error ) update.error = 1 ;
-  }
-};
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-template< class ViewElemNode ,
-          class ViewNodeScan ,
-          class ViewNodeElem >
-void map_node_to_elem( const ViewElemNode & elem_node ,
-                       const ViewNodeScan & node_scan ,
-                       const ViewNodeElem & node_elem );
-
-/** \brief  Functor to gather-sum elements' per-node quantities
- *          to element nodes.  Gather-sum is thread safe and
- *          does not require atomic updates.
- */
-template< class ViewNodeValue ,
-          class ViewElemValue ,
-          bool  AlreadyUsedAtomic >
-struct LumpElemToNode {
-
-  typedef typename ViewElemValue::execution_space execution_space ;
-
-  // In this example we know that the ViewElemValue
-  // array specification is < double*[nNode][nValue] >
-
-  enum { value_count = ViewElemValue::dimension::N2 };
-
-  ViewNodeValue             m_node_value ; ///< Integrated values at nodes
-  ViewElemValue             m_elem_value ; ///< Values apportioned to nodes
-  View<int*,   execution_space> m_node_scan ;  ///< Offsets for nodes->element
-  View<int*[2],execution_space> m_node_elem ;  ///< Node->element connectivity
-
-  // Only allocate node->element connectivity if have
-  // not already used atomic updates for the nodes.
-  template< class ViewElemNode >
-  LumpElemToNode( const ViewNodeValue & node_value ,
-                  const ViewElemValue & elem_value ,
-                  const ViewElemNode  & elem_node )
-    : m_node_value( node_value )
-    , m_elem_value( elem_value )
-    , m_node_scan( "node_scan" ,
-                   AlreadyUsedAtomic ? 0 : node_value.extent(0) + 1 )
-    , m_node_elem( "node_elem" ,
-                   AlreadyUsedAtomic ? 0 : elem_node.extent(0) *
-                                           elem_node.extent(1) )
-    {
-      if ( ! AlreadyUsedAtomic ) {
-        map_node_to_elem( elem_node , m_node_scan , m_node_elem );
-      }
-    }
-
-  //----------------------------------------
-
-  struct value_type { double value[ value_count ]; };
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const int inode , value_type & update ) const
-  {
-    if ( ! AlreadyUsedAtomic ) {
-      // Sum element quantities to a local variable.
-      value_type local ;
-      for ( int j = 0 ; j < value_count ; ++j ) { local.value[j] = 0 ; }
-
-      {
-        // nodes' element ids span [i,end)
-        int i = m_node_scan(inode);
-        const int end = m_node_scan(inode+1);
-
-        for ( ; i < end ; ++i ) {
-          // element #ielem , local node #ielem_node is this node:
-          const int ielem      = m_node_elem(i,0);
-          const int ielem_node = m_node_elem(i,1);
-          // Sum the vector-values quantity
-          for ( int j = 0 ; j < value_count ; ++j ) {
-            local.value[j] += m_elem_value( ielem , ielem_node , j );
-          }
-        }
-      }
-
-      // Assign nodal quantity (no race condition).
-      // Sum global value.
-      for ( int j = 0 ; j < value_count ; ++j ) {
-        m_node_value( inode , j ) = local.value[j] ;
-        update.value[j] += local.value[j] ;
-      }
-    }
-    else {
-      // Already used atomic update of the nodal quantity,
-      // query and sum the value.
-      for ( int j = 0 ; j < value_count ; ++j ) {
-        update.value[j] += m_node_value( inode , j );
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void init( value_type & update ) const
-    { for ( int j = 0 ; j < value_count ; ++j ) { update.value[j] = 0 ; } }
-
-  KOKKOS_INLINE_FUNCTION
-  void join( volatile       value_type & update ,
-             volatile const value_type & input ) const
-    {
-      for ( int j = 0 ; j < value_count ; ++j ) {
-        update.value[j] += input.value[j] ;
-      }
-    }
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-template< class ViewElemNode ,
-          class ViewNodeScan ,
-          class ViewNodeElem >
-void map_node_to_elem( const ViewElemNode & elem_node ,
-                       const ViewNodeScan & node_scan ,
-                       const ViewNodeElem & node_elem )
-{
-  typedef typename ViewElemNode::host_mirror_space host_mirror_space ;
-
-  const typename ViewElemNode::HostMirror host_elem_node =
-    Kokkos::create_mirror_view(elem_node);
-
-  const typename ViewNodeScan::HostMirror host_node_scan =
-    Kokkos::create_mirror_view(node_scan);
-
-  const typename ViewNodeElem::HostMirror host_node_elem =
-    Kokkos::create_mirror_view(node_elem);
-
-  const int elem_count      = host_elem_node.extent(0);
-  const int elem_node_count = host_elem_node.extent(1);
-  const int node_count      = host_node_scan.extent(0) - 1 ;
-
-  const View<int*, host_mirror_space >
-    node_elem_count( "node_elem_count" , node_count );
-
-  Kokkos::deep_copy( host_elem_node , elem_node );
-
-  for ( int i = 0 ; i < elem_count ; ++i ) {
-    for ( int j = 0 ; j < elem_node_count ; ++j ) {
-      ++node_elem_count( host_elem_node(i,j) );
-    }
-  }
-
-  for ( int i = 0 ; i < node_count ; ++i ) {
-    host_node_scan(i+1) += host_node_scan(i) + node_elem_count(i);
-    node_elem_count(i) = 0 ;
-  }
-
-  for ( int i = 0 ; i < elem_count ; ++i ) {
-    for ( int j = 0 ; j < elem_node_count ; ++j ) {
-      const int inode  = host_elem_node(i,j);
-      const int offset = host_node_scan(inode) + node_elem_count(inode);
-
-      host_node_elem( offset , 0 ) = i ;
-      host_node_elem( offset , 1 ) = j ;
-
-      ++node_elem_count(inode);
-    }
-  }
-
-  Kokkos::deep_copy( node_scan , host_node_scan );
-  Kokkos::deep_copy( node_elem , host_node_elem );
-}
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #ifndef KOKKOS_EXAMPLE_FEINT_FUNCTORS_HPP */
-
diff --git a/lib/kokkos/example/feint/Makefile b/lib/kokkos/example/feint/Makefile
deleted file mode 100644
index 61ddb3e2764b59082ec027d43f0a7d634b27e2a5..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/Makefile
+++ /dev/null
@@ -1,71 +0,0 @@
-KOKKOS_PATH = ../..
-KOKKOS_SRC_PATH = ${KOKKOS_PATH}
-vpath %.cpp ${KOKKOS_SRC_PATH}/example/fixture ${KOKKOS_SRC_PATH}/example/feint
-
-EXAMPLE_HEADERS = $(wildcard $(KOKKOS_SRC_PATH)/example/common/*.hpp ${KOKKOS_SRC_PATH}/example/fixture/*.hpp ${KOKKOS_SRC_PATH}/example/feint/*.hpp)
-
-default: build_all
-	echo "End Build"
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-else
-  CXX = g++
-endif
-
-CXXFLAGS = -O3
-LINK ?= $(CXX)
-LDFLAGS ?= 
-
-include $(KOKKOS_PATH)/Makefile.kokkos        
-
-KOKKOS_CXXFLAGS +=	\
-	-I${KOKKOS_SRC_PATH}/example/common	\
-	-I${KOKKOS_SRC_PATH}/example/fixture	\
-	-I${KOKKOS_SRC_PATH}/example/feint
-
-EXE_EXAMPLE_FEINT = KokkosExample_Feint
-OBJ_EXAMPLE_FEINT = BoxElemPart.o main.o
-
-ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
-  OBJ_EXAMPLE_FEINT += feint_serial.o
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
-  OBJ_EXAMPLE_FEINT += feint_cuda.o
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_ROCM), 1)
-  OBJ_EXAMPLE_FEINT += feint_rocm.o
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
-  OBJ_EXAMPLE_FEINT += feint_threads.o
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
-  OBJ_EXAMPLE_FEINT += feint_openmp.o
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
-  OBJ_EXAMPLE_FEINT += feint_hpx.o
-endif
-
-TARGETS = $(EXE_EXAMPLE_FEINT)
-
-#TEST_TARGETS =
-
-$(EXE_EXAMPLE_FEINT) : $(OBJ_EXAMPLE_FEINT) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LDFLAGS) $(EXTRA_PATH) $(OBJ_EXAMPLE_FEINT) $(KOKKOS_LIBS) $(LIB) -o $(EXE_EXAMPLE_FEINT)
-
-build_all : $(TARGETS)
-
-test : build_all
-
-clean: kokkos-clean
-	rm -f *.o $(TARGETS)
-
-# Compilation rules
-
-%.o:%.cpp $(KOKKOS_CPP_DEPENDS) $(EXAMPLE_HEADERS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
diff --git a/lib/kokkos/example/feint/feint.hpp b/lib/kokkos/example/feint/feint.hpp
deleted file mode 100644
index 1be8762a85bd74e789ebadc7b810a5cddfb73183..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/feint.hpp
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_FEINT_HPP
-#define KOKKOS_EXAMPLE_FEINT_HPP
-
-#include <iostream>
-#include <BoxElemFixture.hpp>
-#include <ElemFunctor.hpp>
-#include <feint_fwd.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-/** \brief  Vector valued function to numerically integrate.
- *
- *  F(X) = { 1 , x , y , z , x*y , y*z , z*x , x*y*z }
- *
- *  Integrates on a unit cube to:
- *    { 1 , 1/2 , 1/2 , 1/2 , 1/4 , 1/4 , 1/4 , 1/8 }
- */
-struct MyFunctionType {
-
-  enum { value_count = 8 };
-
-  // Evaluate function at coordinate.
-  template< typename CoordType , typename ValueType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const CoordType point[] , ValueType value[] ) const
-    {
-      value[0] = 1 ;
-      value[1] = point[0] ;
-      value[2] = point[1] ;
-      value[3] = point[2] ;
-      value[4] = point[0] * point[1] ;
-      value[5] = point[1] * point[2] ;
-      value[6] = point[2] * point[0] ;
-      value[7] = point[0] * point[1] * point[2] ;
-    }
-};
-
-template < class Device , bool UseAtomic >
-void feint(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz )
-{
-  //----------------------------------------
-  // Create the unstructured finite element mesh box fixture on the device:
-
-  typedef Kokkos::Example::
-    BoxElemFixture< Device , Kokkos::Example::BoxElemPart::ElemLinear >
-    // BoxElemFixture< Device , Kokkos::Example::BoxElemPart::ElemQuadratic >
-      BoxFixtureType ;
-
-  // MPI distributed parallel domain decomposition of the fixture.
-  // Either by element (DecomposeElem) or by node (DecomposeNode)
-  // with ghosted elements.
-
-  static const Kokkos::Example::BoxElemPart::Decompose
-    decompose = Kokkos::Example::BoxElemPart:: DecomposeElem ;
-    // decompose = Kokkos::Example::BoxElemPart:: DecomposeNode ;
-
-  // Not using MPI in this example.
-  const unsigned mpi_rank = 0 ;
-  const unsigned mpi_size = 1 ;
-
-  const BoxFixtureType fixture( decompose , mpi_size , mpi_rank ,
-                                global_elem_nx ,
-                                global_elem_ny ,
-                                global_elem_nz );
-
-  //----------------------------------------
-  // Create and execute the numerical integration functor on the device:
-
-  typedef Kokkos::Example::
-    FiniteElementIntegration< BoxFixtureType , MyFunctionType , UseAtomic >
-      FeintType ;
-
-  const FeintType feint( fixture , MyFunctionType() );
-
-  typename FeintType::value_type elem_integral ;
-
-  // A reduction for the global integral:
-  Kokkos::parallel_reduce( fixture.elem_count() , feint , elem_integral );
-
-  if ( elem_integral.error ) {
-    std::cout << "An element had a spatial jacobian error" << std::endl ;
-    return ;
-  }
-
-  std::cout << "Elem integral =" ;
-  for ( int i = 0 ; i < MyFunctionType::value_count ; ++i ) {
-    std::cout << " " << elem_integral.value[i] ;
-  }
-  std::cout << std::endl ;
- 
-  //----------------------------------------
-  // Create and execute the nodal lumped value projection and reduction functor:
-
-  typedef Kokkos::Example::
-    LumpElemToNode< typename FeintType::NodeValueType ,
-                    typename FeintType::ElemValueType ,
-                    UseAtomic > LumpType ;
-
-  const LumpType lump( feint.m_node_lumped ,
-                       feint.m_elem_integral ,
-                       fixture.elem_node() );
-
-  typename LumpType ::value_type node_sum ;
-
-  Kokkos::parallel_reduce( fixture.node_count() , lump , node_sum );
-
-  std::cout << "Node lumped sum =" ;
-  for ( int i = 0 ; i < MyFunctionType::value_count ; ++i ) {
-    std::cout << " " << node_sum.value[i] ;
-  }
-  std::cout << std::endl ;
-}
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #ifndef KOKKOS_EXAMPLE_FEINT_HPP */
-
diff --git a/lib/kokkos/example/feint/feint_cuda.cpp b/lib/kokkos/example/feint/feint_cuda.cpp
deleted file mode 100644
index c2f4a68e42aabef38d03761b2af01ebec043cfe0..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/feint_cuda.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <Kokkos_Core.hpp>
-
-#if defined( KOKKOS_ENABLE_CUDA )
-
-#include <feint.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-template void feint<Kokkos::Cuda,false>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-template void feint<Kokkos::Cuda,true>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif
-
diff --git a/lib/kokkos/example/feint/feint_hpx.cpp b/lib/kokkos/example/feint/feint_hpx.cpp
deleted file mode 100644
index 12e1a5af4e5ae237309cca85f181af180be3bf60..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/feint_hpx.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include <Kokkos_Core.hpp>
-
-#if defined(KOKKOS_ENABLE_HPX)
-
-#include <feint.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-template void feint<Kokkos::Experimental::HPX, false>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-template void feint<Kokkos::Experimental::HPX, true>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #if defined( KOKKOS_ENABLE_HPX ) */
-
diff --git a/lib/kokkos/example/feint/feint_rocm.cpp b/lib/kokkos/example/feint/feint_rocm.cpp
deleted file mode 100644
index 65debe44d11e3ff3b51031326f9ca061985a9017..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/feint_rocm.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <Kokkos_Core.hpp>
-
-#if defined( KOKKOS_ENABLE_ROCM )
-
-#include <feint.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-template void feint<Kokkos::Experimental::ROCm,false>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-template void feint<Kokkos::Experimental::ROCm,true>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif
-
diff --git a/lib/kokkos/example/feint/feint_threads.cpp b/lib/kokkos/example/feint/feint_threads.cpp
deleted file mode 100644
index 560dbf8874ed670840529878ffd4948f42404c6a..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/feint/feint_threads.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include <Kokkos_Core.hpp>
-
-#if defined( KOKKOS_ENABLE_THREADS )
-
-#include <feint.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-template void feint< Kokkos::Threads ,false>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-template void feint< Kokkos::Threads ,true>(
-  const unsigned global_elem_nx ,
-  const unsigned global_elem_ny ,
-  const unsigned global_elem_nz );
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #if defined( KOKKOS_ENABLE_THREADS ) */
-
diff --git a/lib/kokkos/example/fenl/CGSolve.hpp b/lib/kokkos/example/fenl/CGSolve.hpp
deleted file mode 100644
index 276c18e4d7f14aa8f55715e6e5ea8599e4a572eb..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/CGSolve.hpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_CG_SOLVE
-#define KOKKOS_EXAMPLE_CG_SOLVE
-
-#include <cmath>
-#include <limits>
-#include <Kokkos_Core.hpp>
-#include <impl/Kokkos_Timer.hpp>
-
-#include <WrapMPI.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-template< typename ValueType , class Space >
-struct CrsMatrix {
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  typedef Kokkos::StaticCrsGraph< unsigned , Space , void , unsigned , void >  StaticCrsGraphType ;
-#else
-  typedef Kokkos::StaticCrsGraph< unsigned , Space , void , void , unsigned >  StaticCrsGraphType ;
-#endif
-  typedef View< ValueType * , Space > coeff_type ;
-
-  StaticCrsGraphType  graph ;
-  coeff_type          coeff ;
-
-  CrsMatrix() : graph(), coeff() {}
-
-  CrsMatrix( const StaticCrsGraphType & arg_graph )
-    : graph( arg_graph )
-    , coeff( "crs_matrix_coeff" , arg_graph.entries.extent(0) )
-    {}
-};
-
-template< typename MScalar 
-        , typename VScalar
-        , class Space >
-struct Multiply {
-
-  const Example::CrsMatrix< MScalar , Space >    m_A ;
-  const Kokkos::View< const VScalar * , Space > m_x ;
-  const Kokkos::View<       VScalar * , Space > m_y ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const int iRow ) const
-    {
-      const int iEntryBegin = m_A.graph.row_map[iRow];
-      const int iEntryEnd   = m_A.graph.row_map[iRow+1];
-
-      double sum = 0 ;
-
-      for ( int iEntry = iEntryBegin ; iEntry < iEntryEnd ; ++iEntry ) {
-        sum += m_A.coeff(iEntry) * m_x( m_A.graph.entries(iEntry) );
-      }
-
-      m_y(iRow) = sum ;
-    }
-
-  Multiply( const View<       VScalar * , Space > & y 
-          , const CrsMatrix< MScalar , Space >    & A 
-          , const View< const VScalar * , Space > & x 
-          )
-  : m_A( A ), m_x( x ), m_y( y )
-  {}
-};
-
-template< typename MScalar
-        , typename VScalar
-        , class Space >
-inline
-void multiply( const int nrow
-             , const Kokkos::View< VScalar * , Space >    & y
-             , const Example::CrsMatrix< MScalar , Space > & A
-             , const Kokkos::View< VScalar * , Space >    & x
-             )
-{
-  Kokkos::parallel_for( Kokkos::RangePolicy<Space>(0,nrow), Multiply<MScalar,VScalar,Space>( y , A , x ) );
-}
-
-template< typename ValueType , class Space >
-struct WAXPBY {
-  const Kokkos::View< const ValueType * , Space >  m_x ;
-  const Kokkos::View< const ValueType * , Space >  m_y ;
-  const Kokkos::View<       ValueType * , Space >  m_w ;
-  const double m_alpha ;
-  const double m_beta ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const int i ) const
-    { m_w(i) = m_alpha * m_x(i) + m_beta * m_y(i); }
-
-  WAXPBY( const View< ValueType * , Space >  & arg_w
-        , const double arg_alpha
-        , const View< ValueType * , Space >  & arg_x
-        , const double arg_beta
-        , const View< ValueType * , Space >  & arg_y
-        )
-    : m_x( arg_x )
-    , m_y( arg_y )
-    , m_w( arg_w )
-    , m_alpha( arg_alpha )
-    , m_beta( arg_beta )
-    {}
-};
-
-template< typename VScalar , class Space >
-void waxpby( const int n
-           , const Kokkos::View< VScalar * , Space > & arg_w
-           , const double                      arg_alpha
-           , const Kokkos::View< VScalar * , Space > & arg_x
-           , const double                      arg_beta
-           , const Kokkos::View< VScalar * , Space > & arg_y
-           )
-{
-  Kokkos::parallel_for( Kokkos::RangePolicy<Space>(0,n), WAXPBY<VScalar,Space>(arg_w,arg_alpha,arg_x,arg_beta,arg_y) );
-}
-
-template< typename VScalar , class Space >
-struct Dot {
-  typedef double value_type ;
-
-  const Kokkos::View< const VScalar * , Space >  m_x ;
-  const Kokkos::View< const VScalar * , Space >  m_y ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const int i , value_type & update ) const
-    { update += m_x(i) * m_y(i); }
-
-  Dot( const Kokkos::View< VScalar * , Space >  & arg_x
-     , const Kokkos::View< VScalar * , Space >  & arg_y
-     )
-    : m_x(arg_x), m_y(arg_y) {}
-};
-
-template< typename VScalar , class Space >
-double dot( const int n
-          , const Kokkos::View< VScalar * , Space > & arg_x
-          , const Kokkos::View< VScalar * , Space > & arg_y
-          )
-{
-  double result = 0 ;
-  Kokkos::parallel_reduce( Kokkos::RangePolicy<Space>(0,n) , Dot<VScalar,Space>( arg_x , arg_y ) , result );
-  return result ;
-}
-
-} // namespace Example
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-struct CGSolveResult {
-  size_t  iteration ;
-  double  iter_time ;
-  double  matvec_time ;
-  double  norm_res ;
-};
-
-template< class ImportType
-        , typename MScalar
-        , typename VScalar
-        , class Space
-        >
-inline
-void cgsolve( const ImportType & import
-            , const CrsMatrix< MScalar , Space >      & A
-            , const Kokkos::View< VScalar * , Space > & b
-            , const Kokkos::View< VScalar * , Space > & x
-            , const size_t  maximum_iteration = 200
-            , const double  tolerance = std::numeric_limits<double>::epsilon()
-            , CGSolveResult * result = 0
-            )
-{
-  typedef View< VScalar * , Space >  VectorType ;
-
-  const size_t count_owned = import.count_owned ;
-  const size_t count_total = import.count_owned + import.count_receive;
-
-  size_t  iteration = 0 ;
-  double  iter_time = 0 ;
-  double  matvec_time = 0 ;
-  double  norm_res = 0 ;
-
-  // Need input vector to matvec to be owned + received
-  VectorType pAll ( "cg::p" , count_total );
-
-  VectorType p = Kokkos::subview( pAll , std::pair<size_t,size_t>(0,count_owned) );
-  VectorType r ( "cg::r" , count_owned );
-  VectorType Ap( "cg::Ap", count_owned );
-
-  /* r = b - A * x ; */
-
-  /* p  = x       */  Kokkos::deep_copy( p , x );
-  /* import p     */  import( pAll );
-  /* Ap = A * p   */  multiply( count_owned , Ap , A , pAll );
-  /* r = b - Ap   */  waxpby( count_owned , r , 1.0 , b , -1.0 , Ap );
-  /* p  = r       */  Kokkos::deep_copy( p , r );
-
-  double old_rdot = Kokkos::Example::all_reduce( dot( count_owned , r , r ) , import.comm );
-
-  norm_res  = std::sqrt( old_rdot );
-  iteration = 0 ;
-
-  Kokkos::Timer wall_clock ;
-  Kokkos::Timer timer;
-
-  while ( tolerance < norm_res && iteration < maximum_iteration ) {
-
-    /* pAp_dot = dot( p , Ap = A * p ) */
-
-    timer.reset();
-    /* import p    */  import( pAll );
-    /* Ap = A * p  */  multiply( count_owned , Ap , A , pAll );
-    Space().fence();
-    matvec_time += timer.seconds();
-
-    const double pAp_dot = Kokkos::Example::all_reduce( dot( count_owned , p , Ap ) , import.comm );
-    const double alpha   = old_rdot / pAp_dot ;
-
-    /* x +=  alpha * p ;  */ waxpby( count_owned , x ,  alpha, p  , 1.0 , x );
-    /* r += -alpha * Ap ; */ waxpby( count_owned , r , -alpha, Ap , 1.0 , r );
-
-    const double r_dot = Kokkos::Example::all_reduce( dot( count_owned , r , r ) , import.comm );
-    const double beta  = r_dot / old_rdot ;
-
-    /* p = r + beta * p ; */ waxpby( count_owned , p , 1.0 , r , beta , p );
-
-    norm_res = std::sqrt( old_rdot = r_dot );
-
-    ++iteration ;
-  }
-
-  Space().fence();
-  iter_time = wall_clock.seconds();
-
-  if ( 0 != result ) {
-    result->iteration   = iteration ;
-    result->iter_time   = iter_time ;
-    result->matvec_time = matvec_time ;
-    result->norm_res    = norm_res ;
-  }
-}
-
-} // namespace Example
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_EXAMPLE_CG_SOLVE */
-
-
diff --git a/lib/kokkos/example/fenl/CMakeLists.txt b/lib/kokkos/example/fenl/CMakeLists.txt
deleted file mode 100644
index 150656b16e13d4977c6ea975b87a785103cc7d48..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../common)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../fixture)
-
-SET(SOURCES "")
-
-FILE( GLOB SOURCES *.cpp )
-
-LIST( APPEND SOURCES ../fixture/BoxElemPart.cpp )
-
-TRIBITS_ADD_EXECUTABLE(
-  fenl
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  )
diff --git a/lib/kokkos/example/fenl/Makefile b/lib/kokkos/example/fenl/Makefile
deleted file mode 100644
index 24a0e61c18c4ce9efa1568534cfb4ad8bfccde9a..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/Makefile
+++ /dev/null
@@ -1,50 +0,0 @@
-KOKKOS_PATH ?= ../..
-
-MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-SRC_DIR := $(dir $(MAKEFILE_PATH))
-
-vpath %.cpp ${SRC_DIR}/../fixture ${SRC_DIR}
-
-EXAMPLE_HEADERS = $(wildcard $(SRC_DIR)/../common/*.hpp ${SRC_DIR}/../fixture/*.hpp ${SRC_DIR}/*.hpp)
-
-default: build_all
-	echo "End Build"
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-else
-  CXX = g++
-endif
-
-CXXFLAGS = -O3
-LINK ?= $(CXX)
-LDFLAGS ?=
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-
-KOKKOS_CXXFLAGS +=	\
-	-I${SRC_DIR}/../common	\
-	-I${SRC_DIR}/../fixture	\
-	-I${SRC_DIR}
-
-EXE_EXAMPLE_FENL = KokkosExample_Fenl
-OBJ_EXAMPLE_FENL = BoxElemPart.o main.o fenl.o
-
-TARGETS = $(EXE_EXAMPLE_FENL)
-
-#TEST_TARGETS =
-
-$(EXE_EXAMPLE_FENL) : $(OBJ_EXAMPLE_FENL) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LDFLAGS) $(EXTRA_PATH) $(OBJ_EXAMPLE_FENL) $(KOKKOS_LIBS) $(LIB) -o $(EXE_EXAMPLE_FENL)
-
-build_all : $(TARGETS)
-
-test : build_all
-
-clean: kokkos-clean
-	rm -f *.o $(TARGETS)
-
-# Compilation rules
-
-%.o:%.cpp $(KOKKOS_CPP_DEPENDS) $(EXAMPLE_HEADERS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
diff --git a/lib/kokkos/example/fenl/fenl.cpp b/lib/kokkos/example/fenl/fenl.cpp
deleted file mode 100644
index 77c51ab55107ef77d4e5c7a459620790f404e2fa..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/fenl.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
-// ************************************************************************
-//
-//   Kokkos: Manycore Performance-Portable Multidimensional Arrays
-//              Copyright (2012) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-*/
-
-#include <HexElement.hpp>
-#include <fenl_impl.hpp>
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-#if defined( KOKKOS_ENABLE_THREADS )
-
-template
-Perf fenl< Kokkos::Threads , Kokkos::Example::BoxElemPart::ElemLinear >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-
-template
-Perf fenl< Kokkos::Threads , Kokkos::Example::BoxElemPart::ElemQuadratic >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-#endif
-
-
-#if defined (KOKKOS_ENABLE_OPENMP)
-
-template
-Perf fenl< Kokkos::OpenMP , Kokkos::Example::BoxElemPart::ElemLinear >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-
-template
-Perf fenl< Kokkos::OpenMP , Kokkos::Example::BoxElemPart::ElemQuadratic >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-#endif
-
-
-#if defined (KOKKOS_ENABLE_HPX)
-
-template
-Perf fenl< Kokkos::Experimental::HPX , Kokkos::Example::BoxElemPart::ElemLinear >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-
-template
-Perf fenl< Kokkos::Experimental::HPX , Kokkos::Example::BoxElemPart::ElemQuadratic >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-#endif
-
-#if defined (KOKKOS_ENABLE_SERIAL)
-
-template
-Perf fenl< Kokkos::Serial , Kokkos::Example::BoxElemPart::ElemLinear >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-
-template
-Perf fenl< Kokkos::Serial , Kokkos::Example::BoxElemPart::ElemQuadratic >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-#endif
-
-#if defined( KOKKOS_ENABLE_CUDA )
-
-template
-Perf fenl< Kokkos::Cuda , Kokkos::Example::BoxElemPart::ElemLinear >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-
-template
-Perf fenl< Kokkos::Cuda , Kokkos::Example::BoxElemPart::ElemQuadratic >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-#endif
-
-#if defined( KOKKOS_ENABLE_ROCM )
-
-template
-Perf fenl< Kokkos::Experimental::ROCm , Kokkos::Example::BoxElemPart::ElemLinear >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-
-template
-Perf fenl< Kokkos::Experimental::ROCm , Kokkos::Example::BoxElemPart::ElemQuadratic >(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-#endif
-
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos */
-
diff --git a/lib/kokkos/example/fenl/fenl.hpp b/lib/kokkos/example/fenl/fenl.hpp
deleted file mode 100644
index f97a4c76b38ce3b9aa1528cd6665ce44e672ea67..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/fenl.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_FENL_HPP
-#define KOKKOS_EXAMPLE_FENL_HPP
-
-#include <cstdlib>
-#include <BoxElemPart.hpp>
-#include <WrapMPI.hpp>
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-struct Perf {
-  size_t global_elem_count ;
-  size_t global_node_count ;
-  size_t newton_iter_count ;
-  size_t cg_iter_count ;
-  double map_ratio ;
-  double fill_node_set ;
-  double scan_node_count ;
-  double fill_graph_entries ;
-  double sort_graph_entries ;
-  double fill_element_graph ;
-  double create_sparse_matrix ;
-  double fill_time ;
-  double bc_time ;
-  double matvec_time ;
-  double cg_time ;
-  double newton_residual ;
-  double error_max ;
-
-};
-
-template < class Device , BoxElemPart::ElemOrder ElemOrder >
-Perf fenl(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int global_elems[] );
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #ifndef KOKKOS_EXAMPLE_FENL_HPP */
-
diff --git a/lib/kokkos/example/fenl/fenl_functors.hpp b/lib/kokkos/example/fenl/fenl_functors.hpp
deleted file mode 100644
index 538f009a3fb96c4c177da4c78a569ecd842590dc..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/fenl_functors.hpp
+++ /dev/null
@@ -1,1173 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_FENLFUNCTORS_HPP
-#define KOKKOS_EXAMPLE_FENLFUNCTORS_HPP
-
-#include <cstdio>
-
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <cstdlib>
-#include <cmath>
-#include <limits>
-
-#include <Kokkos_Pair.hpp>
-#include <Kokkos_UnorderedMap.hpp>
-
-#include <impl/Kokkos_Timer.hpp>
-
-#include <BoxElemFixture.hpp>
-#include <HexElement.hpp>
-#include <CGSolve.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-template< class ElemNodeIdView , class CrsGraphType , unsigned ElemNode >
-class NodeNodeGraph {
-public:
-
-  typedef typename ElemNodeIdView::execution_space  execution_space ;
-  typedef pair<unsigned,unsigned> key_type ;
-
-  typedef Kokkos::UnorderedMap< key_type, void , execution_space >  SetType ;
-  typedef typename CrsGraphType::row_map_type::non_const_type       RowMapType ;
-  typedef Kokkos::View< unsigned ,  execution_space >               UnsignedValue ;
-
-  // Static dimensions of 0 generate compiler warnings or errors.
-  typedef Kokkos::View< unsigned*[ElemNode][ElemNode] , execution_space >
-    ElemGraphType ;
-
-  struct TagFillNodeSet {};
-  struct TagScanNodeCount {};
-  struct TagFillGraphEntries {};
-  struct TagSortGraphEntries {};
-  struct TagFillElementGraph {};
-
-private:
-
-  enum PhaseType { FILL_NODE_SET ,
-                   SCAN_NODE_COUNT ,
-                   FILL_GRAPH_ENTRIES ,
-                   SORT_GRAPH_ENTRIES ,
-                   FILL_ELEMENT_GRAPH };
-
-  const unsigned        node_count ;
-  const ElemNodeIdView  elem_node_id ;
-  UnsignedValue         row_total ;
-  RowMapType            row_count ;
-  RowMapType            row_map ;
-  SetType               node_node_set ;
-  PhaseType             phase ;
-
-public:
-
-  CrsGraphType          graph ;
-  ElemGraphType         elem_graph ;
-
-  struct Times
-  {
-    double ratio;
-    double fill_node_set;
-    double scan_node_count;
-    double fill_graph_entries;
-    double sort_graph_entries;
-    double fill_element_graph;
-  };
-
-  NodeNodeGraph( const ElemNodeIdView & arg_elem_node_id ,
-                 const unsigned         arg_node_count,
-                 Times & results
-               )
-    : node_count(arg_node_count)
-    , elem_node_id( arg_elem_node_id )
-    , row_total( "row_total" )
-    , row_count(Kokkos::ViewAllocateWithoutInitializing("row_count") , node_count ) // will deep_copy to 0 inside loop
-    , row_map( "graph_row_map" , node_count + 1 )
-    , node_node_set()
-    , phase( FILL_NODE_SET )
-    , graph()
-    , elem_graph()
-   {
-      //--------------------------------
-      // Guess at capacity required for the map:
-
-      Kokkos::Timer wall_clock ;
-
-      wall_clock.reset();
-      phase = FILL_NODE_SET ;
-
-      // upper bound on the capacity
-      size_t set_capacity = (28ull * node_count) / 2;
-      unsigned failed_insert_count = 0 ;
-
-      do {
-        // Zero the row count to restart the fill
-        Kokkos::deep_copy( row_count , 0u );
-
-        node_node_set = SetType( ( set_capacity += failed_insert_count ) );
-
-        // May be larger that requested:
-        set_capacity = node_node_set.capacity();
-
-        Kokkos::parallel_reduce( Kokkos::RangePolicy<execution_space,TagFillNodeSet>(0,elem_node_id.extent(0))
-                               , *this
-                               , failed_insert_count );
-
-      } while ( failed_insert_count );
-
-      execution_space().fence();
-      results.ratio = (double)node_node_set.size() / (double)node_node_set.capacity();
-      results.fill_node_set = wall_clock.seconds();
-      //--------------------------------
-
-      wall_clock.reset();
-      phase = SCAN_NODE_COUNT ;
-
-      // Exclusive scan of row_count into row_map
-      // including the final total in the 'node_count + 1' position.
-      // Zero the 'row_count' values.
-      Kokkos::parallel_scan( node_count , *this );
-
-      // Zero the row count for the fill:
-      Kokkos::deep_copy( row_count , 0u );
-
-      unsigned graph_entry_count = 0 ;
-
-      Kokkos::deep_copy( graph_entry_count , row_total );
-
-      // Assign graph's row_map and allocate graph's entries
-      graph.row_map = row_map ;
-      graph.entries = typename CrsGraphType::entries_type( "graph_entries" , graph_entry_count );
-
-      //--------------------------------
-      // Fill graph's entries from the (node,node) set.
-
-      execution_space().fence();
-      results.scan_node_count = wall_clock.seconds();
-
-      wall_clock.reset();
-      phase = FILL_GRAPH_ENTRIES ;
-      Kokkos::parallel_for( node_node_set.capacity() , *this );
-
-      execution_space().fence();
-      results.fill_graph_entries = wall_clock.seconds();
-
-      //--------------------------------
-      // Done with the temporary sets and arrays
-      wall_clock.reset();
-      phase = SORT_GRAPH_ENTRIES ;
-
-      row_total = UnsignedValue();
-      row_count = RowMapType();
-      row_map   = RowMapType();
-      node_node_set.clear();
-
-      //--------------------------------
-
-      Kokkos::parallel_for( node_count , *this );
-
-      execution_space().fence();
-      results.sort_graph_entries = wall_clock.seconds();
-
-      //--------------------------------
-      // Element-to-graph mapping:
-      wall_clock.reset();
-      phase = FILL_ELEMENT_GRAPH ;
-      elem_graph = ElemGraphType("elem_graph", elem_node_id.extent(0) );
-      Kokkos::parallel_for( elem_node_id.extent(0) , *this );
-
-      execution_space().fence();
-      results.fill_element_graph = wall_clock.seconds();
-    }
-
-  //------------------------------------
-  // parallel_for: create map and count row length
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const TagFillNodeSet & , unsigned ielem , unsigned & count ) const
-  {
-    // Loop over element's (row_local_node,col_local_node) pairs:
-    for ( unsigned row_local_node = 0 ; row_local_node < elem_node_id.extent(1) ; ++row_local_node ) {
-
-      const unsigned row_node = elem_node_id( ielem , row_local_node );
-
-      for ( unsigned col_local_node = row_local_node ; col_local_node < elem_node_id.extent(1) ; ++col_local_node ) {
-
-        const unsigned col_node = elem_node_id( ielem , col_local_node );
-
-        // If either node is locally owned then insert the pair into the unordered map:
-
-        if ( row_node < row_count.extent(0) || col_node < row_count.extent(0) ) {
-
-          const key_type key = (row_node < col_node) ? make_pair( row_node, col_node ) : make_pair( col_node, row_node ) ;
-
-          const typename SetType::insert_result result = node_node_set.insert( key );
-
-          // A successful insert: the first time this pair was added
-          if ( result.success() ) {
-
-            // If row node is owned then increment count
-            if ( row_node < row_count.extent(0) ) { atomic_fetch_add( & row_count( row_node ) , 1 ); }
-
-            // If column node is owned and not equal to row node then increment count
-            if ( col_node < row_count.extent(0) && col_node != row_node ) { atomic_fetch_add( & row_count( col_node ) , 1 ); }
-          }
-          else if ( result.failed() ) {
-            ++count ;
-          }
-        }
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void fill_graph_entries( const unsigned iset ) const
-  {
-    if ( node_node_set.valid_at(iset) ) {
-      // Add each entry to the graph entries.
-
-      const key_type key = node_node_set.key_at(iset) ;
-      const unsigned row_node = key.first ;
-      const unsigned col_node = key.second ;
-
-      if ( row_node < row_count.extent(0) ) {
-        const unsigned offset = graph.row_map( row_node ) + atomic_fetch_add( & row_count( row_node ) , 1 );
-        graph.entries( offset ) = col_node ;
-      }
-
-      if ( col_node < row_count.extent(0) && col_node != row_node ) {
-        const unsigned offset = graph.row_map( col_node ) + atomic_fetch_add( & row_count( col_node ) , 1 );
-        graph.entries( offset ) = row_node ;
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void sort_graph_entries( const unsigned irow ) const
-  {
-    const unsigned row_beg = graph.row_map( irow );
-    const unsigned row_end = graph.row_map( irow + 1 );
-    for ( unsigned i = row_beg + 1 ; i < row_end ; ++i ) {
-      const unsigned col = graph.entries(i);
-      unsigned j = i ;
-      for ( ; row_beg < j && col < graph.entries(j-1) ; --j ) {
-        graph.entries(j) = graph.entries(j-1);
-      }
-      graph.entries(j) = col ;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void fill_elem_graph_map( const unsigned ielem ) const
-  {
-    for ( unsigned row_local_node = 0 ; row_local_node < elem_node_id.extent(1) ; ++row_local_node ) {
-
-      const unsigned row_node = elem_node_id( ielem , row_local_node );
-
-      for ( unsigned col_local_node = 0 ; col_local_node < elem_node_id.extent(1) ; ++col_local_node ) {
-
-        const unsigned col_node = elem_node_id( ielem , col_local_node );
-
-        unsigned entry = ~0u ;
-
-        if ( row_node + 1 < graph.row_map.extent(0) ) {
-
-          const unsigned entry_end = graph.row_map( row_node + 1 );
-
-          entry = graph.row_map( row_node );
-
-          for ( ; entry < entry_end && graph.entries(entry) != col_node ; ++entry );
-
-          if ( entry == entry_end ) entry = ~0u ;
-        }
-
-        elem_graph( ielem , row_local_node , col_local_node ) = entry ;
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned iwork ) const
-  {
-/*
-    if ( phase == FILL_NODE_SET ) {
-      operator()( TagFillNodeSet() , iwork );
-    }
-    else */
-    if ( phase == FILL_GRAPH_ENTRIES ) {
-      fill_graph_entries( iwork );
-    }
-    else if ( phase == SORT_GRAPH_ENTRIES ) {
-      sort_graph_entries( iwork );
-    }
-    else if ( phase == FILL_ELEMENT_GRAPH ) {
-      fill_elem_graph_map( iwork );
-    }
-  }
-
-  //------------------------------------
-  // parallel_scan: row offsets
-
-  typedef unsigned value_type ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned irow , unsigned & update , const bool final ) const
-  {
-    // exclusive scan
-    if ( final ) { row_map( irow ) = update ; }
-
-    update += row_count( irow );
-
-    if ( final ) {
-      if ( irow + 1 == row_count.extent(0) ) {
-        row_map( irow + 1 ) = update ;
-        row_total()         = update ;
-      }
-    }
-  }
-
-  // For the reduce phase:
-  KOKKOS_INLINE_FUNCTION
-  void init( const TagFillNodeSet & , unsigned & update ) const { update = 0 ; }
-
-  KOKKOS_INLINE_FUNCTION
-  void join( const TagFillNodeSet &
-           , volatile       unsigned & update
-           , volatile const unsigned & input ) const { update += input ; }
-
-  // For the scan phase::
-  KOKKOS_INLINE_FUNCTION
-  void init( unsigned & update ) const { update = 0 ; }
-
-  KOKKOS_INLINE_FUNCTION
-  void join( volatile       unsigned & update
-           , volatile const unsigned & input ) const { update += input ; }
-
-  //------------------------------------
-};
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos  */
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-template< class ElemCompType >
-class NodeElemGatherFill {
-public:
-
-  typedef typename ElemCompType::execution_space         execution_space ;
-  typedef typename ElemCompType::vector_type         vector_type ;
-  typedef typename ElemCompType::sparse_matrix_type  sparse_matrix_type ;
-  typedef typename ElemCompType::elem_node_type      elem_node_type ;
-  typedef typename ElemCompType::elem_vectors_type   elem_vectors_type ;
-  typedef typename ElemCompType::elem_matrices_type  elem_matrices_type ;
-  typedef typename ElemCompType::elem_graph_type     elem_graph_type ;
-
-  static const unsigned ElemNodeCount = ElemCompType::ElemNodeCount ;
-
-  //------------------------------------
-
-private:
-
-  typedef Kokkos::StaticCrsGraph< unsigned[2] , execution_space >  CrsGraphType ;
-  typedef typename CrsGraphType::row_map_type::non_const_type  RowMapType ;
-  typedef Kokkos::View< unsigned ,  execution_space >              UnsignedValue ;
-
-  enum PhaseType { FILL_NODE_COUNT ,
-                   SCAN_NODE_COUNT ,
-                   FILL_GRAPH_ENTRIES ,
-                   SORT_GRAPH_ENTRIES ,
-                   GATHER_FILL };
-
-  const elem_node_type  elem_node_id ;
-  const elem_graph_type elem_graph ;
-  UnsignedValue         row_total ;
-  RowMapType            row_count ;
-  RowMapType            row_map ;
-  CrsGraphType          graph ;
-  vector_type           residual ;
-  sparse_matrix_type    jacobian ;
-  elem_vectors_type     elem_residual ;
-  elem_matrices_type    elem_jacobian ;
-  PhaseType             phase ;
-
-public:
-
-  NodeElemGatherFill()
-    : elem_node_id()
-    , elem_graph()
-    , row_total()
-    , row_count()
-    , row_map()
-    , graph()
-    , residual()
-    , jacobian()
-    , elem_residual()
-    , elem_jacobian()
-    , phase( FILL_NODE_COUNT )
-    {}
-
-  NodeElemGatherFill( const NodeElemGatherFill & rhs )
-    : elem_node_id(  rhs.elem_node_id )
-    , elem_graph(    rhs.elem_graph )
-    , row_total(     rhs.row_total )
-    , row_count(     rhs.row_count )
-    , row_map(       rhs.row_map )
-    , graph(         rhs.graph )
-    , residual(      rhs.residual )
-    , jacobian(      rhs.jacobian )
-    , elem_residual( rhs.elem_residual )
-    , elem_jacobian( rhs.elem_jacobian )
-    , phase(         rhs.phase )
-    {}
-
-  NodeElemGatherFill( const elem_node_type     & arg_elem_node_id ,
-                      const elem_graph_type    & arg_elem_graph ,
-                      const vector_type        & arg_residual ,
-                      const sparse_matrix_type & arg_jacobian ,
-                      const elem_vectors_type  & arg_elem_residual ,
-                      const elem_matrices_type & arg_elem_jacobian )
-    : elem_node_id( arg_elem_node_id )
-    , elem_graph( arg_elem_graph )
-    , row_total( "row_total" )
-    , row_count( "row_count" , arg_residual.extent(0) )
-    , row_map( "graph_row_map" , arg_residual.extent(0) + 1 )
-    , graph()
-    , residual( arg_residual )
-    , jacobian( arg_jacobian )
-    , elem_residual( arg_elem_residual )
-    , elem_jacobian( arg_elem_jacobian )
-    , phase( FILL_NODE_COUNT )
-    {
-      //--------------------------------
-      // Count node->element relations
-
-      phase = FILL_NODE_COUNT ;
-
-      Kokkos::parallel_for( elem_node_id.extent(0) , *this );
-
-      //--------------------------------
-
-      phase = SCAN_NODE_COUNT ;
-
-      // Exclusive scan of row_count into row_map
-      // including the final total in the 'node_count + 1' position.
-      // Zero the 'row_count' values.
-      Kokkos::parallel_scan( residual.extent(0) , *this );
-
-      // Zero the row count for the fill:
-      Kokkos::deep_copy( row_count , typename RowMapType::value_type(0) );
-
-      unsigned graph_entry_count = 0 ;
-
-      Kokkos::deep_copy( graph_entry_count , row_total );
-
-      // Assign graph's row_map and allocate graph's entries
-      graph.row_map = row_map ;
-
-      typedef typename CrsGraphType::entries_type graph_entries_type ;
-
-      graph.entries = graph_entries_type( "graph_entries" , graph_entry_count );
-
-      //--------------------------------
-      // Fill graph's entries from the (node,node) set.
-
-      phase = FILL_GRAPH_ENTRIES ;
-
-      Kokkos::deep_copy( row_count , 0u );
-      Kokkos::parallel_for( elem_node_id.extent(0) , *this );
-
-      execution_space().fence();
-
-      //--------------------------------
-      // Done with the temporary sets and arrays
-
-      row_total = UnsignedValue();
-      row_count = RowMapType();
-      row_map   = RowMapType();
-
-      //--------------------------------
-
-      phase = SORT_GRAPH_ENTRIES ;
-      Kokkos::parallel_for( residual.extent(0) , *this );
-
-      execution_space().fence();
-
-      phase = GATHER_FILL ;
-    }
-
-  void apply() const
-  {
-    Kokkos::parallel_for( residual.extent(0) , *this );
-  }
-
-  //------------------------------------
-  //------------------------------------
-  // parallel_for: Count node->element pairs
-
-  KOKKOS_INLINE_FUNCTION
-  void fill_node_count( const unsigned ielem ) const
-  {
-    for ( unsigned row_local_node = 0 ; row_local_node < elem_node_id.extent(1) ; ++row_local_node ) {
-
-      const unsigned row_node = elem_node_id( ielem , row_local_node );
-
-      if ( row_node < row_count.extent(0) ) {
-        atomic_fetch_add( & row_count( row_node ) , 1 );
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void fill_graph_entries( const unsigned ielem ) const
-  {
-    for ( unsigned row_local_node = 0 ; row_local_node < elem_node_id.extent(1) ; ++row_local_node ) {
-
-      const unsigned row_node = elem_node_id( ielem , row_local_node );
-
-      if ( row_node < row_count.extent(0) ) {
-
-        const unsigned offset = graph.row_map( row_node ) + atomic_fetch_add( & row_count( row_node ) , 1 );
-
-        graph.entries( offset , 0 ) = ielem ;
-        graph.entries( offset , 1 ) = row_local_node ;
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void sort_graph_entries( const unsigned irow ) const
-  {
-    const unsigned row_beg = graph.row_map( irow );
-    const unsigned row_end = graph.row_map( irow + 1 );
-    for ( unsigned i = row_beg + 1 ; i < row_end ; ++i ) {
-      const unsigned elem  = graph.entries(i,0);
-      const unsigned local = graph.entries(i,1);
-      unsigned j = i ;
-      for ( ; row_beg < j && elem < graph.entries(j-1,0) ; --j ) {
-        graph.entries(j,0) = graph.entries(j-1,0);
-        graph.entries(j,1) = graph.entries(j-1,1);
-      }
-      graph.entries(j,0) = elem ;
-      graph.entries(j,1) = local ;
-    }
-  }
-
-  //------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void gather_fill( const unsigned irow ) const
-  {
-    const unsigned node_elem_begin = graph.row_map(irow);
-    const unsigned node_elem_end   = graph.row_map(irow+1);
-
-    //  for each element that a node belongs to
-
-    for ( unsigned i = node_elem_begin ; i < node_elem_end ; i++ ) {
-
-      const unsigned elem_id   = graph.entries( i, 0);
-      const unsigned row_index = graph.entries( i, 1);
-
-      residual(irow) += elem_residual(elem_id, row_index);
-
-      //  for each node in a particular related element
-      //  gather the contents of the element stiffness
-      //  matrix that belong in irow
-
-      for ( unsigned j = 0 ; j < ElemNodeCount ; ++j ) {
-        const unsigned A_index = elem_graph( elem_id , row_index , j );
-
-        jacobian.coeff( A_index ) += elem_jacobian( elem_id, row_index, j );
-      }
-    }
-  }
-
-  //------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned iwork ) const
-  {
-    if ( phase == FILL_NODE_COUNT ) {
-      fill_node_count( iwork );
-    }
-    else if ( phase == FILL_GRAPH_ENTRIES ) {
-      fill_graph_entries( iwork );
-    }
-    else if ( phase == SORT_GRAPH_ENTRIES ) {
-      sort_graph_entries( iwork );
-    }
-    else if ( phase == GATHER_FILL ) {
-      gather_fill( iwork );
-    }
-  }
-
-  //------------------------------------
-  // parallel_scan: row offsets
-
-  typedef unsigned value_type ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned irow , unsigned & update , const bool final ) const
-  {
-    // exclusive scan
-    if ( final ) { row_map( irow ) = update ; }
-
-    update += row_count( irow );
-
-    if ( final ) {
-      if ( irow + 1 == row_count.extent(0) ) {
-        row_map( irow + 1 ) = update ;
-        row_total()         = update ;
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void init( unsigned & update ) const { update = 0 ; }
-
-  KOKKOS_INLINE_FUNCTION
-  void join( volatile unsigned & update , const volatile unsigned & input ) const { update += input ; }
-};
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos  */
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-template< class FiniteElementMeshType , class SparseMatrixType >
-class ElementComputation ;
-
-
-template< class ExecSpace , BoxElemPart::ElemOrder Order , class CoordinateMap , typename ScalarType >
-class ElementComputation<
-  Kokkos::Example::BoxElemFixture< ExecSpace , Order , CoordinateMap > ,
-  Kokkos::Example::CrsMatrix< ScalarType , ExecSpace > >
-{
-public:
-
-  typedef Kokkos::Example::BoxElemFixture< ExecSpace, Order, CoordinateMap >  mesh_type ;
-  typedef Kokkos::Example::HexElement_Data< mesh_type::ElemNode >             element_data_type ;
-
-  typedef Kokkos::Example::CrsMatrix< ScalarType , ExecSpace >  sparse_matrix_type ;
-  typedef typename sparse_matrix_type::StaticCrsGraphType       sparse_graph_type ;
-
-  typedef ExecSpace   execution_space ;
-  typedef ScalarType  scalar_type ;
-
-  static const unsigned SpatialDim       = element_data_type::spatial_dimension ;
-  static const unsigned TensorDim        = SpatialDim * SpatialDim ;
-  static const unsigned ElemNodeCount    = element_data_type::element_node_count ;
-  static const unsigned FunctionCount    = element_data_type::function_count ;
-  static const unsigned IntegrationCount = element_data_type::integration_count ;
-
-  //------------------------------------
-
-  typedef typename mesh_type::node_coord_type                                      node_coord_type ;
-  typedef typename mesh_type::elem_node_type                                       elem_node_type ;
-  typedef Kokkos::View< scalar_type*[FunctionCount][FunctionCount] , execution_space > elem_matrices_type ;
-  typedef Kokkos::View< scalar_type*[FunctionCount] ,                execution_space > elem_vectors_type ;
-  typedef Kokkos::View< scalar_type* ,                               execution_space > vector_type ;
-
-  typedef typename NodeNodeGraph< elem_node_type , sparse_graph_type , ElemNodeCount >::ElemGraphType elem_graph_type ;
-
-  //------------------------------------
-
-
-  //------------------------------------
-  // Computational data:
-
-  const element_data_type   elem_data ;
-  const elem_node_type      elem_node_ids ;
-  const node_coord_type     node_coords ;
-  const elem_graph_type     elem_graph ;
-  const elem_matrices_type  elem_jacobians ;
-  const elem_vectors_type   elem_residuals ;
-  const vector_type         solution ;
-  const vector_type         residual ;
-  const sparse_matrix_type  jacobian ;
-  const scalar_type         coeff_K ;
-
-  ElementComputation( const ElementComputation & rhs )
-    : elem_data()
-    , elem_node_ids( rhs.elem_node_ids )
-    , node_coords(   rhs.node_coords )
-    , elem_graph(    rhs.elem_graph )
-    , elem_jacobians( rhs.elem_jacobians )
-    , elem_residuals( rhs.elem_residuals )
-    , solution( rhs.solution )
-    , residual( rhs.residual )
-    , jacobian( rhs.jacobian )
-    , coeff_K( rhs.coeff_K )
-    {}
-
-  // If the element->sparse_matrix graph is provided then perform atomic updates
-  // Otherwise fill per-element contributions for subequent gather-add into a residual and jacobian.
-  ElementComputation( const mesh_type          & arg_mesh ,
-	              const scalar_type          arg_coeff_K ,
-                      const vector_type        & arg_solution ,
-                      const elem_graph_type    & arg_elem_graph ,
-                      const sparse_matrix_type & arg_jacobian ,
-                      const vector_type        & arg_residual )
-    : elem_data()
-    , elem_node_ids( arg_mesh.elem_node() )
-    , node_coords(   arg_mesh.node_coord() )
-    , elem_graph(    arg_elem_graph )
-    , elem_jacobians()
-    , elem_residuals()
-    , solution( arg_solution )
-    , residual( arg_residual )
-    , jacobian( arg_jacobian )
-    , coeff_K( arg_coeff_K )
-    {}
-
-  ElementComputation( const mesh_type    & arg_mesh ,
-	              const scalar_type    arg_coeff_K ,
-                      const vector_type  & arg_solution )
-    : elem_data()
-    , elem_node_ids( arg_mesh.elem_node() )
-    , node_coords(   arg_mesh.node_coord() )
-    , elem_graph()
-    , elem_jacobians( "elem_jacobians" , arg_mesh.elem_count() )
-    , elem_residuals( "elem_residuals" , arg_mesh.elem_count() )
-    , solution( arg_solution )
-    , residual()
-    , jacobian()
-    , coeff_K( arg_coeff_K )
-    {}
-
-  //------------------------------------
-
-  void apply() const
-  {
-    parallel_for( elem_node_ids.extent(0) , *this );
-  }
-
-  //------------------------------------
-
-  static const unsigned FLOPS_transform_gradients =
-     /* Jacobian */           FunctionCount * TensorDim * 2 +
-     /* Inverse jacobian */   TensorDim * 6 + 6 +
-     /* Gradient transform */ FunctionCount * 15 ;
-
-  KOKKOS_INLINE_FUNCTION
-  float transform_gradients(
-    const float grad[][ FunctionCount ] , // Gradient of bases master element
-    const double x[] ,
-    const double y[] ,
-    const double z[] ,
-    float dpsidx[] ,
-    float dpsidy[] ,
-    float dpsidz[] ) const
-  {
-    enum { j11 = 0 , j12 = 1 , j13 = 2 ,
-           j21 = 3 , j22 = 4 , j23 = 5 ,
-           j31 = 6 , j32 = 7 , j33 = 8 };
-
-    // Jacobian accumulation:
-
-    double J[ TensorDim ] = { 0, 0, 0,  0, 0, 0,  0, 0, 0 };
-
-    for( unsigned i = 0; i < FunctionCount ; ++i ) {
-      const double x1 = x[i] ;
-      const double x2 = y[i] ;
-      const double x3 = z[i] ;
-
-      const float g1 = grad[0][i] ;
-      const float g2 = grad[1][i] ;
-      const float g3 = grad[2][i] ;
-
-      J[j11] += g1 * x1 ;
-      J[j12] += g1 * x2 ;
-      J[j13] += g1 * x3 ;
-
-      J[j21] += g2 * x1 ;
-      J[j22] += g2 * x2 ;
-      J[j23] += g2 * x3 ;
-
-      J[j31] += g3 * x1 ;
-      J[j32] += g3 * x2 ;
-      J[j33] += g3 * x3 ;
-    }
-
-    // Inverse jacobian:
-
-    float invJ[ TensorDim ] = {
-      static_cast<float>( J[j22] * J[j33] - J[j23] * J[j32] ) ,
-      static_cast<float>( J[j13] * J[j32] - J[j12] * J[j33] ) ,
-      static_cast<float>( J[j12] * J[j23] - J[j13] * J[j22] ) ,
-
-      static_cast<float>( J[j23] * J[j31] - J[j21] * J[j33] ) ,
-      static_cast<float>( J[j11] * J[j33] - J[j13] * J[j31] ) ,
-      static_cast<float>( J[j13] * J[j21] - J[j11] * J[j23] ) ,
-
-      static_cast<float>( J[j21] * J[j32] - J[j22] * J[j31] ) ,
-      static_cast<float>( J[j12] * J[j31] - J[j11] * J[j32] ) ,
-      static_cast<float>( J[j11] * J[j22] - J[j12] * J[j21] ) };
-
-    const float detJ = J[j11] * invJ[j11] +
-                       J[j21] * invJ[j12] +
-                       J[j31] * invJ[j13] ;
-
-    const float detJinv = 1.0 / detJ ;
-
-    for ( unsigned i = 0 ; i < TensorDim ; ++i ) { invJ[i] *= detJinv ; }
-
-    // Transform gradients:
-
-    for( unsigned i = 0; i < FunctionCount ; ++i ) {
-      const float g0 = grad[0][i];
-      const float g1 = grad[1][i];
-      const float g2 = grad[2][i];
-
-      dpsidx[i] = g0 * invJ[j11] + g1 * invJ[j12] + g2 * invJ[j13];
-      dpsidy[i] = g0 * invJ[j21] + g1 * invJ[j22] + g2 * invJ[j23];
-      dpsidz[i] = g0 * invJ[j31] + g1 * invJ[j32] + g2 * invJ[j33];
-    }
-
-    return detJ ;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void contributeResidualJacobian(
-    const float coeff_k ,
-    const double dof_values[] ,
-    const float dpsidx[] ,
-    const float dpsidy[] ,
-    const float dpsidz[] ,
-    const float detJ ,
-    const float integ_weight ,
-    const float bases_vals[] ,
-    double elem_res[] ,
-    double elem_mat[][ FunctionCount ] ) const
-  {
-    double value_at_pt = 0 ;
-    double gradx_at_pt = 0 ;
-    double grady_at_pt = 0 ;
-    double gradz_at_pt = 0 ;
-
-    for ( unsigned m = 0 ; m < FunctionCount ; m++ ) {
-      value_at_pt += dof_values[m] * bases_vals[m] ;
-      gradx_at_pt += dof_values[m] * dpsidx[m] ;
-      grady_at_pt += dof_values[m] * dpsidy[m] ;
-      gradz_at_pt += dof_values[m] * dpsidz[m] ;
-    }
-
-    const scalar_type k_detJ_weight = coeff_k        * detJ * integ_weight ;
-    const double res_val = value_at_pt * value_at_pt * detJ * integ_weight ;
-    const double mat_val = 2.0 * value_at_pt         * detJ * integ_weight ;
-
-    // $$ R_i = \int_{\Omega} \nabla \phi_i \cdot (k \nabla T) + \phi_i T^2 d \Omega $$
-    // $$ J_{i,j} = \frac{\partial R_i}{\partial T_j} = \int_{\Omega} k \nabla \phi_i \cdot \nabla \phi_j + 2 \phi_i \phi_j T d \Omega $$
-
-    for ( unsigned m = 0; m < FunctionCount; ++m) {
-      double * const mat = elem_mat[m] ;
-      const float bases_val_m = bases_vals[m];
-      const float dpsidx_m    = dpsidx[m] ;
-      const float dpsidy_m    = dpsidy[m] ;
-      const float dpsidz_m    = dpsidz[m] ;
-
-      elem_res[m] += k_detJ_weight * ( dpsidx_m * gradx_at_pt +
-                                       dpsidy_m * grady_at_pt +
-                                       dpsidz_m * gradz_at_pt ) +
-                     res_val * bases_val_m ;
-
-      for( unsigned n = 0; n < FunctionCount; n++) {
-
-        mat[n] += k_detJ_weight * ( dpsidx_m * dpsidx[n] +
-                                    dpsidy_m * dpsidy[n] +
-                                    dpsidz_m * dpsidz[n] ) +
-                  mat_val * bases_val_m * bases_vals[n];
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned ielem ) const
-  {
-    // Gather nodal coordinates and solution vector:
-
-    double x[ FunctionCount ] ;
-    double y[ FunctionCount ] ;
-    double z[ FunctionCount ] ;
-    double val[ FunctionCount ] ;
-    unsigned node_index[ ElemNodeCount ];
-
-    for ( unsigned i = 0 ; i < ElemNodeCount ; ++i ) {
-      const unsigned ni = elem_node_ids( ielem , i );
-
-      node_index[i] = ni ;
-
-      x[i] = node_coords( ni , 0 );
-      y[i] = node_coords( ni , 1 );
-      z[i] = node_coords( ni , 2 );
-
-      val[i] = solution( ni );
-    }
-
-
-    double elem_vec[ FunctionCount ] ;
-    double elem_mat[ FunctionCount ][ FunctionCount ] ;
-
-    for( unsigned i = 0; i < FunctionCount ; i++ ) {
-      elem_vec[i] = 0 ;
-      for( unsigned j = 0; j < FunctionCount ; j++){
-        elem_mat[i][j] = 0 ;
-      }
-    }
-
-
-    for ( unsigned i = 0 ; i < IntegrationCount ; ++i ) {
-      float dpsidx[ FunctionCount ] ;
-      float dpsidy[ FunctionCount ] ;
-      float dpsidz[ FunctionCount ] ;
-
-      const float detJ =
-        transform_gradients( elem_data.gradients[i] , x , y , z ,
-                             dpsidx , dpsidy , dpsidz );
-
-      contributeResidualJacobian( coeff_K ,
-                                  val , dpsidx , dpsidy , dpsidz ,
-                                  detJ ,
-                                  elem_data.weights[i] ,
-                                  elem_data.values[i] ,
-                                  elem_vec , elem_mat );
-    }
-
-#if 0
-
-if ( 1 == ielem ) {
-  printf("ElemResidual { %f %f %f %f %f %f %f %f }\n",
-         elem_vec[0], elem_vec[1], elem_vec[2], elem_vec[3],
-         elem_vec[4], elem_vec[5], elem_vec[6], elem_vec[7]);
-
-  printf("ElemJacobian {\n");
-
-  for ( unsigned j = 0 ; j < FunctionCount ; ++j ) {
-  printf("  { %f %f %f %f %f %f %f %f }\n",
-         elem_mat[j][0], elem_mat[j][1], elem_mat[j][2], elem_mat[j][3],
-         elem_mat[j][4], elem_mat[j][5], elem_mat[j][6], elem_mat[j][7]);
-  }
-  printf("}\n");
-}
-
-#endif
-
-    if ( ! residual.extent(0) ) {
-      for( unsigned i = 0; i < FunctionCount ; i++){
-        elem_residuals(ielem, i) = elem_vec[i] ;
-        for( unsigned j = 0; j < FunctionCount ; j++){
-          elem_jacobians(ielem, i, j) = elem_mat[i][j] ;
-        }
-      }
-    }
-    else {
-      for( unsigned i = 0 ; i < FunctionCount ; i++ ) {
-        const unsigned row = node_index[i] ;
-        if ( row < residual.extent(0) ) {
-          atomic_fetch_add( & residual( row ) , elem_vec[i] );
-
-          for( unsigned j = 0 ; j < FunctionCount ; j++ ) {
-            const unsigned entry = elem_graph( ielem , i , j );
-            if ( entry != ~0u ) {
-              atomic_fetch_add( & jacobian.coeff( entry ) , elem_mat[i][j] );
-            }
-          }
-        }
-      }
-    }
-  }
-}; /* ElementComputation */
-
-//----------------------------------------------------------------------------
-
-template< class FixtureType , class SparseMatrixType >
-class DirichletComputation ;
-
-template< class ExecSpace , BoxElemPart::ElemOrder Order , class CoordinateMap , typename ScalarType >
-class DirichletComputation<
-  Kokkos::Example::BoxElemFixture< ExecSpace , Order , CoordinateMap > ,
-  Kokkos::Example::CrsMatrix< ScalarType , ExecSpace > >
-{
-public:
-
-  typedef Kokkos::Example::BoxElemFixture< ExecSpace, Order, CoordinateMap >  mesh_type ;
-  typedef typename mesh_type::node_coord_type                                 node_coord_type ;
-  typedef typename node_coord_type::value_type                                scalar_coord_type ;
-
-  typedef Kokkos::Example::CrsMatrix< ScalarType , ExecSpace >  sparse_matrix_type ;
-  typedef typename sparse_matrix_type::StaticCrsGraphType       sparse_graph_type ;
-
-  typedef ExecSpace   execution_space ;
-  typedef ScalarType  scalar_type ;
-
-  //------------------------------------
-
-  typedef Kokkos::View< scalar_type* , execution_space > vector_type ;
-
-  //------------------------------------
-  // Computational data:
-
-  const node_coord_type     node_coords ;
-  const vector_type         solution ;
-  const sparse_matrix_type  jacobian ;
-  const vector_type         residual ;
-  const scalar_type         bc_lower_value ;
-  const scalar_type         bc_upper_value ;
-  const scalar_coord_type   bc_lower_limit ;
-  const scalar_coord_type   bc_upper_limit ;
-  const unsigned            bc_plane ;
-  const unsigned            node_count ;
-        bool                init ;
-
-
-  DirichletComputation( const mesh_type          & arg_mesh ,
-                        const vector_type        & arg_solution ,
-                        const sparse_matrix_type & arg_jacobian ,
-                        const vector_type        & arg_residual ,
-                        const unsigned             arg_bc_plane ,
-                        const scalar_type          arg_bc_lower_value ,
-                        const scalar_type          arg_bc_upper_value )
-    : node_coords( arg_mesh.node_coord() )
-    , solution(    arg_solution )
-    , jacobian(    arg_jacobian )
-    , residual(    arg_residual )
-    , bc_lower_value( arg_bc_lower_value )
-    , bc_upper_value( arg_bc_upper_value )
-    , bc_lower_limit( std::numeric_limits<scalar_coord_type>::epsilon() )
-    , bc_upper_limit( scalar_coord_type(1) - std::numeric_limits<scalar_coord_type>::epsilon() )
-    , bc_plane(       arg_bc_plane )
-    , node_count( arg_mesh.node_count_owned() )
-    , init( false )
-    {
-      parallel_for( node_count , *this );
-      init = true ;
-    }
-
-  void apply() const
-  {
-    parallel_for( node_count , *this );
-  }
-
-  //------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned inode ) const
-  {
-    //  Apply dirichlet boundary condition on the Solution and Residual vectors.
-    //  To maintain the symmetry of the original global stiffness matrix,
-    //  zero out the columns that correspond to boundary conditions, and
-    //  update the residual vector accordingly
-
-    const unsigned iBeg = jacobian.graph.row_map[inode];
-    const unsigned iEnd = jacobian.graph.row_map[inode+1];
-
-    const scalar_coord_type c = node_coords(inode,bc_plane);
-    const bool bc_lower = c <= bc_lower_limit ;
-    const bool bc_upper = bc_upper_limit <= c ;
-
-    if ( ! init ) {
-      solution(inode) = bc_lower ? bc_lower_value : (
-                        bc_upper ? bc_upper_value : 0 );
-    }
-    else {
-      if ( bc_lower || bc_upper ) {
-
-        residual(inode) = 0 ;
-
-        //  zero each value on the row, and leave a one
-        //  on the diagonal
-
-        for( unsigned i = iBeg ; i < iEnd ; ++i ) {
-          jacobian.coeff(i) = int(inode) == int(jacobian.graph.entries(i)) ? 1 : 0 ;
-        }
-      }
-      else {
-
-        //  Find any columns that are boundary conditions.
-        //  Clear them and adjust the residual vector
-
-        for( unsigned i = iBeg ; i < iEnd ; ++i ) {
-          const unsigned       cnode = jacobian.graph.entries(i) ;
-          const scalar_coord_type cc = node_coords(cnode,bc_plane);
-
-          if ( ( cc <= bc_lower_limit ) || ( bc_upper_limit <= cc ) ) {
-            jacobian.coeff(i) = 0 ;
-          }
-        }
-      }
-    }
-  }
-};
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos  */
-
-//----------------------------------------------------------------------------
-
-/* A Cuda-specific specialization for the element computation functor. */
-#if defined( __CUDACC__ )
-// #include <NonlinearElement_Cuda.hpp>
-#endif
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_EXAMPLE_FENLFUNCTORS_HPP */
-
diff --git a/lib/kokkos/example/fenl/fenl_impl.hpp b/lib/kokkos/example/fenl/fenl_impl.hpp
deleted file mode 100644
index 4f756435c14b7ad56d616d539bd19fc32073d2d0..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/fenl_impl.hpp
+++ /dev/null
@@ -1,598 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_FENL_IMPL_HPP
-#define KOKKOS_EXAMPLE_FENL_IMPL_HPP
-
-#include <cmath>
-
-// Kokkos libraries' headers:
-
-#include <Kokkos_UnorderedMap.hpp>
-#include <Kokkos_StaticCrsGraph.hpp>
-#include <impl/Kokkos_Timer.hpp>
-
-// Examples headers:
-
-#include <BoxElemFixture.hpp>
-#include <VectorImport.hpp>
-#include <CGSolve.hpp>
-
-#include <fenl.hpp>
-#include <fenl_functors.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-inline
-double maximum( MPI_Comm comm , double local )
-{
-  double global = local ;
-#if defined( KOKKOS_ENABLE_MPI )
-  MPI_Allreduce( & local , & global , 1 , MPI_DOUBLE , MPI_MAX , comm );
-#endif
-  return global ;
-}
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos */
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-class ManufacturedSolution {
-public:
-
-  // Manufactured solution for one dimensional nonlinear PDE
-  //
-  //  -K T_zz + T^2 = 0 ; T(zmin) = T_zmin ; T(zmax) = T_zmax
-  //
-  //  Has an analytic solution of the form:
-  //
-  //    T(z) = ( a ( z - zmin ) + b )^(-2) where K = 1 / ( 6 a^2 )
-  //
-  //  Given T_0 and T_L compute K for this analytic solution.
-  //
-  //  Two analytic solutions:
-  //
-  //    Solution with singularity:
-  //    , a( ( 1.0 / sqrt(T_zmax) + 1.0 / sqrt(T_zmin) ) / ( zmax - zmin ) )
-  //    , b( -1.0 / sqrt(T_zmin) )
-  //
-  //    Solution without singularity:
-  //    , a( ( 1.0 / sqrt(T_zmax) - 1.0 / sqrt(T_zmin) ) / ( zmax - zmin ) )
-  //    , b( 1.0 / sqrt(T_zmin) )
-
-  const double zmin ;
-  const double zmax ;
-  const double T_zmin ;
-  const double T_zmax ;
-  const double a ;
-  const double b ;
-  const double K ;
-
-  ManufacturedSolution( const double arg_zmin ,
-                        const double arg_zmax ,
-                        const double arg_T_zmin ,
-                        const double arg_T_zmax )
-    : zmin( arg_zmin )
-    , zmax( arg_zmax )
-    , T_zmin( arg_T_zmin )
-    , T_zmax( arg_T_zmax )
-    , a( ( 1.0 / std::sqrt(T_zmax) - 1.0 / std::sqrt(T_zmin) ) / ( zmax - zmin ) )
-    , b( 1.0 / std::sqrt(T_zmin) )
-    , K( 1.0 / ( 6.0 * a * a ) )
-    {}
-
-  double operator()( const double z ) const
-  {
-    const double tmp = a * ( z - zmin ) + b ;
-    return 1.0 / ( tmp * tmp );
-  }
-};
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos */
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-namespace FENL {
-
-template < class Space , BoxElemPart::ElemOrder ElemOrder >
-Perf fenl(
-  MPI_Comm comm ,
-  const int use_print ,
-  const int use_trials ,
-  const int use_atomic ,
-  const int use_elems[] )
-{
-  typedef Kokkos::Example::BoxElemFixture< Space , ElemOrder > FixtureType ;
-
-  typedef Kokkos::Example::CrsMatrix< double , Space >
-    SparseMatrixType ;
-
-  typedef typename SparseMatrixType::StaticCrsGraphType
-    SparseGraphType ;
-
-  typedef Kokkos::Example::FENL::NodeNodeGraph< typename FixtureType::elem_node_type , SparseGraphType , FixtureType::ElemNode >
-     NodeNodeGraphType ;
-
-  typedef Kokkos::Example::FENL::ElementComputation< FixtureType , SparseMatrixType >
-    ElementComputationType ;
-
-  typedef Kokkos::Example::FENL::DirichletComputation< FixtureType , SparseMatrixType >
-    DirichletComputationType ;
-
-  typedef NodeElemGatherFill< ElementComputationType >
-    NodeElemGatherFillType ;
-
-  typedef typename ElementComputationType::vector_type VectorType ;
-
-  typedef Kokkos::Example::VectorImport<
-     typename FixtureType::comm_list_type ,
-     typename FixtureType::send_nodeid_type ,
-     VectorType > ImportType ;
-
-  //------------------------------------
-
-  const unsigned newton_iteration_limit     = 10 ;
-  const double   newton_iteration_tolerance = 1e-7 ;
-  const unsigned cg_iteration_limit         = 200 ;
-  const double   cg_iteration_tolerance     = 1e-7 ;
-
-  //------------------------------------
-
-  const int print_flag = use_print && std::is_same< Kokkos::HostSpace , typename Space::memory_space >::value ;
-
-  int comm_rank ;
-  int comm_size ;
-
-  MPI_Comm_rank( comm , & comm_rank );
-  MPI_Comm_size( comm , & comm_size );
-
-  // Decompose by node to avoid mpi-communication for assembly
-
-  const float bubble_x = 1.0 ;
-  const float bubble_y = 1.0 ;
-  const float bubble_z = 1.0 ;
-
-  const FixtureType fixture( BoxElemPart::DecomposeNode , comm_size , comm_rank ,
-                             use_elems[0] , use_elems[1] , use_elems[2] ,
-                             bubble_x , bubble_y , bubble_z );
-
-
-  {
-    int global_error = ! fixture.ok();
-
-#if defined( KOKKOS_ENABLE_MPI )
-    int local_error = global_error ;
-    global_error = 0 ;
-    MPI_Allreduce( & local_error , & global_error , 1 , MPI_INT , MPI_SUM , comm );
-#endif
-
-    if ( global_error ) {
-      throw std::runtime_error(std::string("Error generating finite element fixture"));
-    }
-  }
-
-  //------------------------------------
-
-  const ImportType comm_nodal_import(
-    comm ,
-    fixture.recv_node() ,
-    fixture.send_node() ,
-    fixture.send_nodeid() ,
-    fixture.node_count_owned() ,
-    fixture.node_count() - fixture.node_count_owned() );
-
-  //------------------------------------
-
-  const double bc_lower_value = 1 ;
-  const double bc_upper_value = 2 ;
-
-  const Kokkos::Example::FENL::ManufacturedSolution
-    manufactured_solution( 0 , 1 , bc_lower_value , bc_upper_value  );
-
-  //------------------------------------
-
-  for ( int k = 0 ; k < comm_size && use_print ; ++k ) {
-    if ( k == comm_rank ) {
-      typename FixtureType::node_grid_type::HostMirror
-        h_node_grid = Kokkos::create_mirror_view( fixture.node_grid() );
-
-      typename FixtureType::node_coord_type::HostMirror
-        h_node_coord = Kokkos::create_mirror_view( fixture.node_coord() );
-
-      typename FixtureType::elem_node_type::HostMirror
-        h_elem_node = Kokkos::create_mirror_view( fixture.elem_node() );
-
-      Kokkos::deep_copy( h_node_grid , fixture.node_grid() );
-      Kokkos::deep_copy( h_node_coord , fixture.node_coord() );
-      Kokkos::deep_copy( h_elem_node , fixture.elem_node() );
-
-      std::cout << "MPI[" << comm_rank << "]" << std::endl ;
-      std::cout << "Node grid {" ;
-      for ( unsigned inode = 0 ; inode < fixture.node_count() ; ++inode ) {
-        std::cout << " (" << h_node_grid(inode,0)
-                  << "," << h_node_grid(inode,1)
-                  << "," << h_node_grid(inode,2)
-                  << ")" ;
-      }
-      std::cout << " }" << std::endl ;
-
-      std::cout << "Node coord {" ;
-      for ( unsigned inode = 0 ; inode < fixture.node_count() ; ++inode ) {
-        std::cout << " (" << h_node_coord(inode,0)
-                  << "," << h_node_coord(inode,1)
-                  << "," << h_node_coord(inode,2)
-                  << ")" ;
-      }
-      std::cout << " }" << std::endl ;
-
-      std::cout << "Manufactured solution"
-                << " a[" << manufactured_solution.a << "]"
-                << " b[" << manufactured_solution.b << "]"
-                << " K[" << manufactured_solution.K << "]"
-                << " {" ;
-      for ( unsigned inode = 0 ; inode < fixture.node_count() ; ++inode ) {
-        std::cout << " " << manufactured_solution( h_node_coord( inode , 2 ) );
-      }
-      std::cout << " }" << std::endl ;
-
-      std::cout << "ElemNode {" << std::endl ;
-      for ( unsigned ielem = 0 ; ielem < fixture.elem_count() ; ++ielem ) {
-        std::cout << "  elem[" << ielem << "]{" ;
-        for ( unsigned inode = 0 ; inode < FixtureType::ElemNode ; ++inode ) {
-          std::cout << " " << h_elem_node(ielem,inode);
-        }
-        std::cout << " }{" ;
-        for ( unsigned inode = 0 ; inode < FixtureType::ElemNode ; ++inode ) {
-          std::cout << " (" << h_node_grid(h_elem_node(ielem,inode),0)
-                    << "," << h_node_grid(h_elem_node(ielem,inode),1)
-                    << "," << h_node_grid(h_elem_node(ielem,inode),2)
-                    << ")" ;
-        }
-        std::cout << " }" << std::endl ;
-      }
-      std::cout << "}" << std::endl ;
-    }
-    std::cout.flush();
-    MPI_Barrier( comm );
-  }
-
-  //------------------------------------
-
-  Kokkos::Timer wall_clock ;
-
-  Perf perf_stats = Perf() ;
-
-  for ( int itrial = 0 ; itrial < use_trials ; ++itrial ) {
-
-    Perf perf = Perf() ;
-
-    perf.global_elem_count = fixture.elem_count_global();
-    perf.global_node_count = fixture.node_count_global();
-
-    //----------------------------------
-    // Create the sparse matrix graph and element-to-graph map
-    // from the element->to->node identifier array.
-    // The graph only has rows for the owned nodes.
-
-    typename NodeNodeGraphType::Times graph_times;
-
-    const NodeNodeGraphType
-      mesh_to_graph( fixture.elem_node() , fixture.node_count_owned(), graph_times );
-
-    perf.map_ratio          = maximum(comm, graph_times.ratio);
-    perf.fill_node_set      = maximum(comm, graph_times.fill_node_set);
-    perf.scan_node_count    = maximum(comm, graph_times.scan_node_count);
-    perf.fill_graph_entries = maximum(comm, graph_times.fill_graph_entries);
-    perf.sort_graph_entries = maximum(comm, graph_times.sort_graph_entries);
-    perf.fill_element_graph = maximum(comm, graph_times.fill_element_graph);
-
-    wall_clock.reset();
-    // Create the sparse matrix from the graph:
-
-    SparseMatrixType jacobian( mesh_to_graph.graph );
-
-    Space().fence();
-
-    perf.create_sparse_matrix = maximum( comm , wall_clock.seconds() );
-
-    //----------------------------------
-
-    for ( int k = 0 ; k < comm_size && print_flag ; ++k ) {
-      if ( k == comm_rank ) {
-        const unsigned nrow = jacobian.graph.numRows();
-        std::cout << "MPI[" << comm_rank << "]" << std::endl ;
-        std::cout << "JacobianGraph {" << std::endl ;
-        for ( unsigned irow = 0 ; irow < nrow ; ++irow ) {
-          std::cout << "  row[" << irow << "]{" ;
-          const unsigned entry_end = jacobian.graph.row_map(irow+1);
-          for ( unsigned entry = jacobian.graph.row_map(irow) ; entry < entry_end ; ++entry ) {
-            std::cout << " " << jacobian.graph.entries(entry);
-          }
-          std::cout << " }" << std::endl ;
-        }
-        std::cout << "}" << std::endl ;
-
-        std::cout << "ElemGraph {" << std::endl ;
-        for ( unsigned ielem = 0 ; ielem < mesh_to_graph.elem_graph.extent(0) ; ++ielem ) {
-          std::cout << "  elem[" << ielem << "]{" ;
-          for ( unsigned irow = 0 ; irow < mesh_to_graph.elem_graph.extent(1) ; ++irow ) {
-            std::cout << " {" ;
-            for ( unsigned icol = 0 ; icol < mesh_to_graph.elem_graph.extent(2) ; ++icol ) {
-              std::cout << " " << mesh_to_graph.elem_graph(ielem,irow,icol);
-            }
-            std::cout << " }" ;
-          }
-          std::cout << " }" << std::endl ;
-        }
-        std::cout << "}" << std::endl ;
-      }
-      std::cout.flush();
-      MPI_Barrier( comm );
-    }
-
-    //----------------------------------
-
-    // Allocate solution vector for each node in the mesh and residual vector for each owned node
-    const VectorType nodal_solution( "nodal_solution" , fixture.node_count() );
-    const VectorType nodal_residual( "nodal_residual" , fixture.node_count_owned() );
-    const VectorType nodal_delta(    "nodal_delta" ,    fixture.node_count_owned() );
-
-    // Create element computation functor
-    const ElementComputationType elemcomp(
-      use_atomic ? ElementComputationType( fixture , manufactured_solution.K , nodal_solution ,
-                                           mesh_to_graph.elem_graph , jacobian , nodal_residual )
-                 : ElementComputationType( fixture , manufactured_solution.K , nodal_solution ) );
-
-    const NodeElemGatherFillType gatherfill(
-      use_atomic ? NodeElemGatherFillType()
-                 : NodeElemGatherFillType( fixture.elem_node() ,
-                                           mesh_to_graph.elem_graph ,
-                                           nodal_residual ,
-                                           jacobian ,
-                                           elemcomp.elem_residuals ,
-                                           elemcomp.elem_jacobians ) );
-
-    // Create boundary condition functor
-    const DirichletComputationType dirichlet(
-      fixture , nodal_solution , jacobian , nodal_residual ,
-      2 /* apply at 'z' ends */ ,
-      manufactured_solution.T_zmin ,
-      manufactured_solution.T_zmax );
-
-    //----------------------------------
-    // Nonlinear Newton iteration:
-
-    double residual_norm_init = 0 ;
-
-    for ( perf.newton_iter_count = 0 ;
-          perf.newton_iter_count < newton_iteration_limit ;
-          ++perf.newton_iter_count ) {
-
-      //--------------------------------
-
-      comm_nodal_import( nodal_solution );
-
-      //--------------------------------
-      // Element contributions to residual and jacobian
-
-      wall_clock.reset();
-
-      Kokkos::deep_copy( nodal_residual , double(0) );
-      Kokkos::deep_copy( jacobian.coeff , double(0) );
-
-      elemcomp.apply();
-
-      if ( ! use_atomic ) {
-        gatherfill.apply();
-      }
-
-      Space().fence();
-      perf.fill_time = maximum( comm , wall_clock.seconds() );
-
-      //--------------------------------
-      // Apply boundary conditions
-
-      wall_clock.reset();
-
-      dirichlet.apply();
-
-      Space().fence();
-      perf.bc_time = maximum( comm , wall_clock.seconds() );
-
-      //--------------------------------
-      // Evaluate convergence
-
-      const double residual_norm =
-        std::sqrt(
-          Kokkos::Example::all_reduce(
-            Kokkos::Example::dot( fixture.node_count_owned() , nodal_residual, nodal_residual ) , comm ) );
-
-      perf.newton_residual = residual_norm ;
-
-      if ( 0 == perf.newton_iter_count ) { residual_norm_init = residual_norm ; }
-
-      if ( residual_norm < residual_norm_init * newton_iteration_tolerance ) { break ; }
-
-      //--------------------------------
-      // Solve for nonlinear update
-
-      CGSolveResult cg_result ;
-
-      Kokkos::Example::cgsolve( comm_nodal_import
-                              , jacobian
-                              , nodal_residual
-                              , nodal_delta
-                              , cg_iteration_limit
-                              , cg_iteration_tolerance
-                              , & cg_result
-                              );
-
-      // Update solution vector
-
-      Kokkos::Example::waxpby( fixture.node_count_owned() , nodal_solution , -1.0 , nodal_delta , 1.0 , nodal_solution );
-
-      perf.cg_iter_count += cg_result.iteration ;
-      perf.matvec_time   += cg_result.matvec_time ;
-      perf.cg_time       += cg_result.iter_time ;
-
-      //--------------------------------
-
-      if ( print_flag ) {
-        const double delta_norm =
-          std::sqrt(
-            Kokkos::Example::all_reduce(
-              Kokkos::Example::dot( fixture.node_count_owned() , nodal_delta, nodal_delta ) , comm ) );
-
-        if ( 0 == comm_rank ) {
-          std::cout << "Newton iteration[" << perf.newton_iter_count << "]"
-                    << " residual[" << perf.newton_residual << "]"
-                    << " update[" << delta_norm << "]"
-                    << " cg_iteration[" << cg_result.iteration << "]"
-                    << " cg_residual[" << cg_result.norm_res << "]"
-                    << std::endl ;
-        }
-
-        for ( int k = 0 ; k < comm_size ; ++k ) {
-          if ( k == comm_rank ) {
-            const unsigned nrow = jacobian.graph.numRows();
-
-            std::cout << "MPI[" << comm_rank << "]" << std::endl ;
-            std::cout << "Residual {" ;
-            for ( unsigned irow = 0 ; irow < nrow ; ++irow ) {
-              std::cout << " " << nodal_residual(irow);
-            }
-            std::cout << " }" << std::endl ;
-
-            std::cout << "Delta {" ;
-            for ( unsigned irow = 0 ; irow < nrow ; ++irow ) {
-              std::cout << " " << nodal_delta(irow);
-            }
-            std::cout << " }" << std::endl ;
-
-            std::cout << "Solution {" ;
-            for ( unsigned irow = 0 ; irow < nrow ; ++irow ) {
-              std::cout << " " << nodal_solution(irow);
-            }
-            std::cout << " }" << std::endl ;
-
-            std::cout << "Jacobian[ "
-                      << jacobian.graph.numRows() << " x " << Kokkos::maximum_entry( jacobian.graph )
-                      << " ] {" << std::endl ;
-            for ( unsigned irow = 0 ; irow < nrow ; ++irow ) {
-              std::cout << "  {" ;
-              const unsigned entry_end = jacobian.graph.row_map(irow+1);
-              for ( unsigned entry = jacobian.graph.row_map(irow) ; entry < entry_end ; ++entry ) {
-                std::cout << " (" << jacobian.graph.entries(entry)
-                          << "," << jacobian.coeff(entry)
-                          << ")" ;
-              }
-              std::cout << " }" << std::endl ;
-            }
-            std::cout << "}" << std::endl ;
-          }
-          std::cout.flush();
-          MPI_Barrier( comm );
-        }
-      }
-      //--------------------------------
-    }
-
-    // Evaluate solution error
-
-    if ( 0 == itrial ) {
-      const typename FixtureType::node_coord_type::HostMirror
-        h_node_coord = Kokkos::create_mirror_view( fixture.node_coord() );
-
-      const typename VectorType::HostMirror
-        h_nodal_solution = Kokkos::create_mirror_view( nodal_solution );
-
-      Kokkos::deep_copy( h_node_coord , fixture.node_coord() );
-      Kokkos::deep_copy( h_nodal_solution , nodal_solution );
-
-      double error_max = 0 ;
-      for ( unsigned inode = 0 ; inode < fixture.node_count_owned() ; ++inode ) {
-        const double answer = manufactured_solution( h_node_coord( inode , 2 ) );
-        const double error = ( h_nodal_solution(inode) - answer ) / answer ;
-        if ( error_max < fabs( error ) ) { error_max = fabs( error ); }
-      }
-
-      perf.error_max = std::sqrt( Kokkos::Example::all_reduce_max( error_max , comm ) );
-
-      perf_stats = perf ;
-    }
-    else {
-      perf_stats.fill_node_set = std::min( perf_stats.fill_node_set , perf.fill_node_set );
-      perf_stats.scan_node_count = std::min( perf_stats.scan_node_count , perf.scan_node_count );
-      perf_stats.fill_graph_entries = std::min( perf_stats.fill_graph_entries , perf.fill_graph_entries );
-      perf_stats.sort_graph_entries = std::min( perf_stats.sort_graph_entries , perf.sort_graph_entries );
-      perf_stats.fill_element_graph = std::min( perf_stats.fill_element_graph , perf.fill_element_graph );
-      perf_stats.create_sparse_matrix = std::min( perf_stats.create_sparse_matrix , perf.create_sparse_matrix );
-      perf_stats.fill_time = std::min( perf_stats.fill_time , perf.fill_time );
-      perf_stats.bc_time = std::min( perf_stats.bc_time , perf.bc_time );
-      perf_stats.cg_time = std::min( perf_stats.cg_time , perf.cg_time );
-    }
-  }
-
-  return perf_stats ;
-}
-
-} /* namespace FENL */
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #ifndef KOKKOS_EXAMPLE_FENL_IMPL_HPP */
-
diff --git a/lib/kokkos/example/fenl/main.cpp b/lib/kokkos/example/fenl/main.cpp
deleted file mode 100644
index bd65e7683a8a11b7bf7013d3a575e488fc6c47d4..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fenl/main.cpp
+++ /dev/null
@@ -1,367 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-
-#include <cmath>
-
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-
-#include <utility>
-#include <string>
-#include <vector>
-#include <sstream>
-#include <iostream>
-#include <iomanip>
-
-#include <Kokkos_Core.hpp>
-
-#include <WrapMPI.hpp>
-#include <fenl.hpp>
-
-// For vtune
-#include <sys/types.h>
-#include <unistd.h>
-
-//----------------------------------------------------------------------------
-
-enum { CMD_USE_THREADS = 0
-     , CMD_USE_NUMA
-     , CMD_USE_CORE_PER_NUMA
-     , CMD_USE_CUDA
-     , CMD_USE_ROCM
-     , CMD_USE_OPENMP
-     , CMD_USE_HPX
-     , CMD_USE_CUDA_DEV
-     , CMD_USE_FIXTURE_X
-     , CMD_USE_FIXTURE_Y
-     , CMD_USE_FIXTURE_Z
-     , CMD_USE_FIXTURE_BEGIN
-     , CMD_USE_FIXTURE_END
-     , CMD_USE_FIXTURE_QUADRATIC
-     , CMD_USE_ATOMIC
-     , CMD_USE_TRIALS
-     , CMD_VTUNE
-     , CMD_PRINT
-     , CMD_ECHO
-     , CMD_ERROR
-     , CMD_COUNT };
-
-void print_cmdline( std::ostream & s , const int cmd[] )
-{
-  if ( cmd[ CMD_USE_THREADS ] ) {
-    s << " Threads(" << cmd[ CMD_USE_THREADS ]
-      << ") NUMA(" << cmd[ CMD_USE_NUMA ]
-      << ") CORE_PER_NUMA(" << cmd[ CMD_USE_CORE_PER_NUMA ]
-      << ")" ;
-  }
-  if ( cmd[ CMD_USE_OPENMP ] ) {
-    s << " OpenMP(" << cmd[ CMD_USE_OPENMP ]
-      << ") NUMA(" << cmd[ CMD_USE_NUMA ]
-      << ") CORE_PER_NUMA(" << cmd[ CMD_USE_CORE_PER_NUMA ]
-      << ")" ;
-  }
-  if ( cmd[ CMD_USE_HPX ] ) {
-    s << " HPX(" << cmd[ CMD_USE_HPX ]
-      << ")" ;
-  }
-  if ( cmd[ CMD_USE_FIXTURE_X ] ) {
-    s << " Fixture(" << cmd[ CMD_USE_FIXTURE_X ]
-      << "x" << cmd[ CMD_USE_FIXTURE_Y ]
-      << "x" << cmd[ CMD_USE_FIXTURE_Z ]
-      << ")" ;
-  }
-  if ( cmd[ CMD_USE_FIXTURE_BEGIN ] ) {
-    s << " Fixture( " << cmd[ CMD_USE_FIXTURE_BEGIN ]
-      << " .. " << cmd[ CMD_USE_FIXTURE_END ]
-      << " )" ;
-  }
-  if ( cmd[ CMD_USE_FIXTURE_QUADRATIC ] ) {
-    s << " Quadratic-Element" ;
-  }
-  if ( cmd[ CMD_USE_CUDA ] ) {
-    s << " CUDA(" << cmd[ CMD_USE_CUDA_DEV ] << ")" ;
-  }
-  if ( cmd[ CMD_USE_ROCM ] ) {
-    s << " ROCM" ;
-  }
-  if ( cmd[ CMD_USE_ATOMIC ] ) {
-    s << " ATOMIC" ;
-  }
-  if ( cmd[ CMD_USE_TRIALS ] ) {
-    s << " TRIALS(" << cmd[ CMD_USE_TRIALS ] << ")" ;
-  }
-  if ( cmd[ CMD_VTUNE ] ) {
-    s << " VTUNE" ;
-  }
-  if ( cmd[ CMD_PRINT ] ) {
-    s << " PRINT" ;
-  }
-  s << std::endl ;
-}
-
-void print_perf_value( std::ostream & s , const std::vector<size_t> & widths,  const Kokkos::Example::FENL::Perf & perf )
-{
-  int i=0;
-  s << std::setw(widths[i++]) << perf.global_elem_count << " ,";
-  s << std::setw(widths[i++]) << perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << perf.newton_iter_count << " ,";
-  s << std::setw(widths[i++]) << perf.cg_iter_count << " ,";
-  s << std::setw(widths[i++]) << perf.map_ratio << " ,";
-  s << std::setw(widths[i++]) << ( perf.fill_node_set * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( perf.scan_node_count * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( perf.fill_graph_entries * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( perf.sort_graph_entries * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( perf.fill_element_graph * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( perf.create_sparse_matrix * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( perf.fill_time * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( perf.bc_time * 1000.0 ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( ( perf.matvec_time * 1000.0 ) / perf.cg_iter_count ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i++]) << ( ( perf.cg_time * 1000.0 ) / perf.cg_iter_count ) / perf.global_node_count << " ,";
-  s << std::setw(widths[i])   << perf.error_max;
-  s << std::endl ;
-}
-
-template< class Device , Kokkos::Example::BoxElemPart::ElemOrder ElemOrder >
-void run( MPI_Comm comm , const int cmd[] )
-{
-  int comm_rank = 0 ;
-
-#if defined( KOKKOS_ENABLE_MPI )
-  MPI_Comm_rank( comm , & comm_rank );
-#else
-  comm = 0 ;
-#endif
-
-
-  if ( 0 == comm_rank ) {
-    if ( cmd[ CMD_USE_THREADS ] ) { std::cout << "THREADS , " << cmd[ CMD_USE_THREADS ] ; }
-    else if ( cmd[ CMD_USE_OPENMP ] ) { std::cout << "OPENMP , " << cmd[ CMD_USE_OPENMP ] ; }
-    else if ( cmd[ CMD_USE_HPX ] ) { std::cout << "HPX , " << cmd[ CMD_USE_HPX ] ; }
-    else if ( cmd[ CMD_USE_CUDA ] ) { std::cout << "CUDA" ; }
-    else if ( cmd[ CMD_USE_ROCM ] ) { std::cout << "ROCM" ; }
-
-    if ( cmd[ CMD_USE_FIXTURE_QUADRATIC ] ) { std::cout << " , QUADRATIC-ELEMENT" ; }
-    else { std::cout << " , LINEAR-ELEMENT" ; }
-
-    if ( cmd[ CMD_USE_ATOMIC ] ) { std::cout << " , USING ATOMICS" ; }
-  }
-
-  std::vector< std::pair<std::string,std::string> > headers;
-
-
-  headers.push_back(std::make_pair("ELEMS","count"));
-  headers.push_back(std::make_pair("NODES","count"));
-  headers.push_back(std::make_pair("NEWTON","iter"));
-  headers.push_back(std::make_pair("CG","iter"));
-  headers.push_back(std::make_pair("MAP_RATIO","ratio"));
-  headers.push_back(std::make_pair("SET_FILL/NODE","millisec"));
-  headers.push_back(std::make_pair("SCAN/NODE","millisec"));
-  headers.push_back(std::make_pair("GRAPH_FILL/NODE","millisec"));
-  headers.push_back(std::make_pair("SORT/NODE","millisec"));
-  headers.push_back(std::make_pair("ELEM_GRAPH_FILL/NODE","millisec"));
-  headers.push_back(std::make_pair("MATRIX_CREATE/NODE","millisec"));
-  headers.push_back(std::make_pair("MATRIX_FILL/NODE","millisec"));
-  headers.push_back(std::make_pair("BOUNDARY/NODE","millisec"));
-  headers.push_back(std::make_pair("MAT_VEC/ITER/ROW","millisec"));
-  headers.push_back(std::make_pair("CG/ITER/ROW","millisec"));
-  headers.push_back(std::make_pair("ERROR","ratio"));
-
-  // find print widths
-  size_t min_width = 10;
-  std::vector< size_t > widths(headers.size());
-  for (size_t i=0, ie=headers.size(); i<ie; ++i)
-    widths[i] = std::max(min_width, headers[i].first.size()+1);
-
-  // print column headers
-  if ( 0 == comm_rank ) {
-    std::cout << std::endl ;
-    for (size_t i=0; i<headers.size(); ++i)
-      std::cout << std::setw(widths[i]) << headers[i].first << " ,";
-    std::cout << "\b\b  " << std::endl;
-    for (size_t i=0; i<headers.size(); ++i)
-      std::cout << std::setw(widths[i]) << headers[i].second << " ,";
-    std::cout << "\b\b  " << std::endl;
-
-    std::cout << std::scientific;
-    std::cout.precision(3);
-  }
-
-  if ( cmd[ CMD_USE_FIXTURE_BEGIN ] ) {
-    for ( int i = cmd[CMD_USE_FIXTURE_BEGIN] ; i < cmd[CMD_USE_FIXTURE_END] * 2 ; i *= 2 ) {
-      int nelem[3] ;
-      nelem[0] = std::max( 1 , (int) cbrt( ((double) i) / 2.0 ) );
-      nelem[1] = 1 + nelem[0] ;
-      nelem[2] = 2 * nelem[0] ;
-
-      const Kokkos::Example::FENL::Perf perf =
-        cmd[ CMD_USE_FIXTURE_QUADRATIC ]
-        ? Kokkos::Example::FENL::fenl< Device , Kokkos::Example::BoxElemPart::ElemQuadratic >
-            ( comm , cmd[CMD_PRINT], cmd[CMD_USE_TRIALS], cmd[CMD_USE_ATOMIC], nelem )
-        : Kokkos::Example::FENL::fenl< Device , Kokkos::Example::BoxElemPart::ElemLinear >
-            ( comm , cmd[CMD_PRINT], cmd[CMD_USE_TRIALS], cmd[CMD_USE_ATOMIC], nelem )
-        ;
-
-      if ( 0 == comm_rank ) print_perf_value( std::cout , widths, perf );
-    }
-  }
-  else {
-    int nelem[3] = { cmd[ CMD_USE_FIXTURE_X ] ,
-                     cmd[ CMD_USE_FIXTURE_Y ] ,
-                     cmd[ CMD_USE_FIXTURE_Z ] };
-
-    const Kokkos::Example::FENL::Perf perf =
-      cmd[ CMD_USE_FIXTURE_QUADRATIC ]
-      ? Kokkos::Example::FENL::fenl< Device , Kokkos::Example::BoxElemPart::ElemQuadratic >
-          ( comm , cmd[CMD_PRINT], cmd[CMD_USE_TRIALS], cmd[CMD_USE_ATOMIC], nelem )
-      : Kokkos::Example::FENL::fenl< Device , Kokkos::Example::BoxElemPart::ElemLinear >
-          ( comm , cmd[CMD_PRINT], cmd[CMD_USE_TRIALS], cmd[CMD_USE_ATOMIC], nelem )
-      ;
-
-    if ( 0 == comm_rank ) print_perf_value( std::cout , widths, perf );
-  }
-}
-
-//----------------------------------------------------------------------------
-
-int main( int argc , char ** argv )
-{
-  int comm_rank = 0 ;
-
-#if defined( KOKKOS_ENABLE_MPI )
-  MPI_Init( & argc , & argv );
-  MPI_Comm comm = MPI_COMM_WORLD ;
-  MPI_Comm_rank( comm , & comm_rank );
-#else
-  MPI_Comm comm = 0 ;
-  (void) comm ; // suppress warning
-#endif
-
-  Kokkos::initialize(argc,argv);
-  int cmdline[ CMD_COUNT ] ;
-
-  for ( int i = 0 ; i < CMD_COUNT ; ++i ) cmdline[i] = 0 ;
-
-  if ( 0 == comm_rank ) {
-    for ( int i = 1 ; i < argc ; ++i ) {
-      if ( 0 == strcasecmp( argv[i] , "fixture" ) ) {
-        sscanf( argv[++i] , "%dx%dx%d" ,
-                cmdline + CMD_USE_FIXTURE_X ,
-                cmdline + CMD_USE_FIXTURE_Y ,
-                cmdline + CMD_USE_FIXTURE_Z );
-      }
-      else if ( 0 == strcasecmp( argv[i] , "fixture-range" ) ) {
-        sscanf( argv[++i] , "%d..%d" ,
-                cmdline + CMD_USE_FIXTURE_BEGIN ,
-                cmdline + CMD_USE_FIXTURE_END );
-      }
-      else if ( 0 == strcasecmp( argv[i] , "fixture-quadratic" ) ) {
-        cmdline[ CMD_USE_FIXTURE_QUADRATIC ] = 1 ;
-      }
-      else if ( 0 == strcasecmp( argv[i] , "atomic" ) ) {
-        cmdline[ CMD_USE_ATOMIC ] = 1 ;
-      }
-      else if ( 0 == strcasecmp( argv[i] , "trials" ) ) {
-        cmdline[ CMD_USE_TRIALS ] = atoi( argv[++i] ) ;
-      }
-      else if ( 0 == strcasecmp( argv[i] , "vtune" ) ) {
-        cmdline[ CMD_VTUNE ] = 1 ;
-      }
-      else if ( 0 == strcasecmp( argv[i] , "print" ) ) {
-        cmdline[ CMD_PRINT ] = 1 ;
-      }
-      else if ( 0 == strcasecmp( argv[i] , "echo" ) ) {
-        cmdline[ CMD_ECHO ] = 1 ;
-      }
-      else {
-        cmdline[ CMD_ERROR ] = 1 ;
-
-        std::cerr << "Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ;
-      }
-    }
-
-    if ( cmdline[ CMD_ECHO ] && 0 == comm_rank ) { print_cmdline( std::cout , cmdline ); }
-  }
-
-#if defined( KOKKOS_ENABLE_MPI )
-  MPI_Bcast( cmdline , CMD_COUNT , MPI_INT , 0 , comm );
-#endif
-
-  if ( cmdline[ CMD_VTUNE ] ) {
-    std::stringstream cmd;
-    pid_t my_os_pid=getpid();
-    const std::string vtune_loc =
-      "/usr/local/intel/vtune_amplifier_xe_2013/bin64/amplxe-cl";
-    const std::string output_dir = "./vtune/vtune.";
-    const int p_rank = comm_rank;
-    cmd << vtune_loc
-        << " -collect hotspots -result-dir " << output_dir << p_rank
-        << " -target-pid " << my_os_pid << " &";
-    if (p_rank == 0)
-      std::cout << cmd.str() << std::endl;
-    int error = system(cmd.str().c_str());
-    if(error) printf("System Call Result: %i\n",error);
-    error = system("sleep 10");
-    if(error) printf("System Call Result: %i\n",error);
-  }
-
-  if ( ! cmdline[ CMD_ERROR ] && ! cmdline[ CMD_ECHO ] ) {
-
-    if ( ! cmdline[ CMD_USE_TRIALS ] ) { cmdline[ CMD_USE_TRIALS ] = 1 ; }
-
-    if ( ! cmdline[ CMD_USE_FIXTURE_X ] && ! cmdline[ CMD_USE_FIXTURE_BEGIN ] ) {
-      cmdline[ CMD_USE_FIXTURE_X ] = 2 ;
-      cmdline[ CMD_USE_FIXTURE_Y ] = 2 ;
-      cmdline[ CMD_USE_FIXTURE_Z ] = 2 ;
-    }
-
-    run< Kokkos::DefaultExecutionSpace , Kokkos::Example::BoxElemPart::ElemLinear >( comm , cmdline );
-
-  }
-
-  Kokkos::finalize();
-#if defined( KOKKOS_ENABLE_MPI )
-  MPI_Finalize();
-#endif
-
-  return cmdline[ CMD_ERROR ] ? -1 : 0 ;
-}
-
diff --git a/lib/kokkos/example/fixture/BoxElemFixture.hpp b/lib/kokkos/example/fixture/BoxElemFixture.hpp
deleted file mode 100644
index be2f03a27d5f52c0fe9acf0b55f736779679562a..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/BoxElemFixture.hpp
+++ /dev/null
@@ -1,355 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_BOXELEMFIXTURE_HPP
-#define KOKKOS_EXAMPLE_BOXELEMFIXTURE_HPP
-
-#include <cstdio>
-#include <utility>
-
-#include <Kokkos_Core.hpp>
-
-#include <HexElement.hpp>
-#include <BoxElemPart.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-/** \brief  Map a grid onto a unit cube with smooth nonlinear grading
- *          of the map.
- */
-struct MapGridUnitCube {
-
-  const float m_a ;
-  const float m_b ;
-  const float m_c ;
-  const size_t m_max_x ;
-  const size_t m_max_y ;
-  const size_t m_max_z ;
-
-  MapGridUnitCube( const size_t grid_max_x ,
-                   const size_t grid_max_y ,
-                   const size_t grid_max_z ,
-                   const float bubble_x ,
-                   const float bubble_y ,
-                   const float bubble_z )
-    : m_a( bubble_x )
-    , m_b( bubble_y )
-    , m_c( bubble_z )
-    , m_max_x( grid_max_x )
-    , m_max_y( grid_max_y )
-    , m_max_z( grid_max_z )
-    {}
-
-  template< typename Scalar >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( int grid_x ,
-                   int grid_y ,
-                   int grid_z ,
-                   Scalar & coord_x ,
-                   Scalar & coord_y ,
-                   Scalar & coord_z ) const
-    {
-      // Map to a unit cube [0,1]^3
-
-      const double x = double(grid_x) / double(m_max_x);
-      const double y = double(grid_y) / double(m_max_y);
-      const double z = double(grid_z) / double(m_max_z);
-
-      coord_x = x + x * x * ( x - 1 ) * ( x - 1 ) * m_a ;
-      coord_y = y + y * y * ( y - 1 ) * ( y - 1 ) * m_b ;
-      coord_z = z + z * z * ( z - 1 ) * ( z - 1 ) * m_c ;
-    }
-};
-
-} // namespace Example
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-/** \brief  Generate a distributed unstructured finite element mesh
- *          from a partitioned NX*NY*NZ box of elements.
- *
- *  Order owned nodes first followed by off-process nodes
- *  grouped by owning process.
- */
-template< class Device ,
-          BoxElemPart::ElemOrder Order ,
-          class CoordinateMap = MapGridUnitCube >
-class BoxElemFixture {
-public:
-
-  typedef Device execution_space ;
-
-  enum { SpaceDim = 3 };
-  enum { ElemNode = Order == BoxElemPart::ElemLinear ? 8 :
-                    Order == BoxElemPart::ElemQuadratic ? 27 : 0 };
-
-private:
-
-  typedef Kokkos::Example::HexElement_TensorData< ElemNode > hex_data ;
-
-  Kokkos::Example::BoxElemPart m_box_part ;
-  CoordinateMap                m_coord_map ;
-
-  Kokkos::View< double *[SpaceDim] , Device > m_node_coord ;
-  Kokkos::View< size_t *[SpaceDim] , Device > m_node_grid ;
-  Kokkos::View< size_t *[ElemNode] , Device > m_elem_node ;
-  Kokkos::View< size_t *[2] ,        Device > m_recv_node ;
-  Kokkos::View< size_t *[2] ,        Device > m_send_node ;
-  Kokkos::View< size_t * ,           Device > m_send_node_id ;
-
-  unsigned char m_elem_node_local[ ElemNode ][4] ;
-
-public:
-
-  typedef Kokkos::View< const size_t  * [ElemNode], Device > elem_node_type ;
-  typedef Kokkos::View< const double  * [SpaceDim], Device > node_coord_type ;
-  typedef Kokkos::View< const size_t  * [SpaceDim], Device > node_grid_type ;
-  typedef Kokkos::View< const size_t  * [2] , Device > comm_list_type ;
-  typedef Kokkos::View< const size_t  *     , Device > send_nodeid_type ;
-
-  inline bool ok() const { return m_box_part.ok(); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t node_count() const { return m_node_grid.extent(0); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t node_count_owned() const { return m_box_part.owns_node_count(); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t node_count_global() const { return m_box_part.global_node_count(); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t elem_count() const { return m_elem_node.extent(0); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t elem_count_global() const { return m_box_part.global_elem_count(); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t elem_node_local( size_t inode , int k ) const
-    { return m_elem_node_local[inode][k] ; }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t node_grid( size_t inode , int iaxis ) const
-    { return m_node_grid(inode,iaxis); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t node_global_index( size_t local ) const
-    {
-      const size_t tmp_node_grid[SpaceDim] =
-        { m_node_grid(local,0) , m_node_grid(local,1) , m_node_grid(local,2) };
-      return m_box_part.global_node_id( tmp_node_grid );
-    }
-
-  KOKKOS_INLINE_FUNCTION
-  double node_coord( size_t inode , int iaxis ) const
-    { return m_node_coord(inode,iaxis); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t node_grid_max( int iaxis ) const
-    { return m_box_part.global_coord_max(iaxis); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t elem_node( size_t ielem , size_t inode ) const
-    { return m_elem_node(ielem,inode); }
-
-  elem_node_type   elem_node()   const { return m_elem_node ; }
-  node_coord_type  node_coord()  const { return m_node_coord ; }
-  node_grid_type   node_grid()   const { return m_node_grid ; }
-  comm_list_type   recv_node()   const { return m_recv_node ; }
-  comm_list_type   send_node()   const { return m_send_node ; }
-  send_nodeid_type send_nodeid() const { return m_send_node_id ; }
-
-  KOKKOS_INLINE_FUNCTION
-  BoxElemFixture( const BoxElemFixture & rhs )
-    : m_box_part(   rhs.m_box_part )
-    , m_coord_map(  rhs.m_coord_map )
-    , m_node_coord( rhs.m_node_coord )
-    , m_node_grid(  rhs.m_node_grid )
-    , m_elem_node(  rhs.m_elem_node )
-    , m_recv_node(  rhs.m_recv_node )
-    , m_send_node(  rhs.m_send_node )
-    , m_send_node_id( rhs.m_send_node_id )
-    {
-      for ( int i = 0 ; i < ElemNode ; ++i ) {
-        m_elem_node_local[i][0] = rhs.m_elem_node_local[i][0] ;
-        m_elem_node_local[i][1] = rhs.m_elem_node_local[i][1] ;
-        m_elem_node_local[i][2] = rhs.m_elem_node_local[i][2] ;
-        m_elem_node_local[i][3] = 0 ;
-      }
-    }
-
-  BoxElemFixture & operator = ( const BoxElemFixture & rhs )
-    {
-      m_box_part      = rhs.m_box_part ;
-      m_coord_map     = rhs.m_coord_map ;
-      m_node_coord    = rhs.m_node_coord ;
-      m_node_grid     = rhs.m_node_grid ;
-      m_elem_node     = rhs.m_elem_node ;
-      m_recv_node     = rhs.m_recv_node ;
-      m_send_node     = rhs.m_send_node ;
-      m_send_node_id  = rhs.m_send_node_id ;
-
-      for ( int i = 0 ; i < ElemNode ; ++i ) {
-        m_elem_node_local[i][0] = rhs.m_elem_node_local[i][0] ;
-        m_elem_node_local[i][1] = rhs.m_elem_node_local[i][1] ;
-        m_elem_node_local[i][2] = rhs.m_elem_node_local[i][2] ;
-        m_elem_node_local[i][3] = 0 ;
-      }
-      return *this ;
-    }
-
-  BoxElemFixture( const BoxElemPart::Decompose decompose ,
-                  const size_t global_size ,
-                  const size_t global_rank ,
-                  const size_t elem_nx ,
-                  const size_t elem_ny ,
-                  const size_t elem_nz ,
-                  const float bubble_x = 1.1f ,
-                  const float bubble_y = 1.2f ,
-                  const float bubble_z = 1.3f )
-  : m_box_part( Order , decompose , global_size , global_rank , elem_nx , elem_ny , elem_nz )
-  , m_coord_map( m_box_part.global_coord_max(0) ,
-                 m_box_part.global_coord_max(1) ,
-                 m_box_part.global_coord_max(2) ,
-                 bubble_x ,
-                 bubble_y ,
-                 bubble_z )
-  , m_node_coord( "fixture_node_coord" , m_box_part.uses_node_count() )
-  , m_node_grid(  "fixture_node_grid" , m_box_part.uses_node_count() )
-  , m_elem_node(  "fixture_elem_node" , m_box_part.uses_elem_count() )
-  , m_recv_node(  "fixture_recv_node" , m_box_part.recv_node_msg_count() )
-  , m_send_node(  "fixture_send_node" , m_box_part.send_node_msg_count() )
-  , m_send_node_id( "fixture_send_node_id" , m_box_part.send_node_id_count() )
-  {
-    {
-      const hex_data elem_data ;
-
-      for ( int i = 0 ; i < ElemNode ; ++i ) {
-        m_elem_node_local[i][0] = elem_data.eval_map[i][0] ;
-        m_elem_node_local[i][1] = elem_data.eval_map[i][1] ;
-        m_elem_node_local[i][2] = elem_data.eval_map[i][2] ;
-        m_elem_node_local[i][3] = 0 ;
-      }
-    }
-
-    const size_t nwork =
-      std::max( m_recv_node.extent(0) ,
-      std::max( m_send_node.extent(0) ,
-      std::max( m_send_node_id.extent(0) ,
-      std::max( m_node_grid.extent(0) ,
-                m_elem_node.extent(0) * m_elem_node.extent(1) ))));
-
-    Kokkos::parallel_for( nwork , *this );
-  }
-
-
-  // Initialization:
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( size_t i ) const
-  {
-    if ( i < m_elem_node.extent(0) * m_elem_node.extent(1) ) {
-
-      const size_t ielem = i / ElemNode ;
-      const size_t inode = i % ElemNode ;
-
-      size_t elem_grid[SpaceDim] ;
-      size_t tmp_node_grid[SpaceDim] ;
-
-      m_box_part.uses_elem_coord( ielem , elem_grid );
-
-      enum { elem_node_scale = Order == BoxElemPart::ElemLinear ? 1 :
-                               Order == BoxElemPart::ElemQuadratic ? 2 : 0 };
-
-      tmp_node_grid[0] = elem_node_scale * elem_grid[0] + m_elem_node_local[inode][0] ;
-      tmp_node_grid[1] = elem_node_scale * elem_grid[1] + m_elem_node_local[inode][1] ;
-      tmp_node_grid[2] = elem_node_scale * elem_grid[2] + m_elem_node_local[inode][2] ;
-
-      m_elem_node(ielem,inode) = m_box_part.local_node_id( tmp_node_grid );
-    }
-
-    if ( i < m_node_grid.extent(0) ) {
-      size_t tmp_node_grid[SpaceDim] ;
-      m_box_part.local_node_coord( i , tmp_node_grid );
-      m_node_grid(i,0) = tmp_node_grid[0] ;
-      m_node_grid(i,1) = tmp_node_grid[1] ;
-      m_node_grid(i,2) = tmp_node_grid[2] ;
-
-      m_coord_map( tmp_node_grid[0] ,
-                   tmp_node_grid[1] ,
-                   tmp_node_grid[2] ,
-                   m_node_coord(i,0) ,
-                   m_node_coord(i,1) ,
-                   m_node_coord(i,2) );
-    }
-
-    if ( i < m_recv_node.extent(0) ) {
-      m_recv_node(i,0) = m_box_part.recv_node_rank(i);
-      m_recv_node(i,1) = m_box_part.recv_node_count(i);
-    }
-
-    if ( i < m_send_node.extent(0) ) {
-      m_send_node(i,0) = m_box_part.send_node_rank(i);
-      m_send_node(i,1) = m_box_part.send_node_count(i);
-    }
-
-    if ( i < m_send_node_id.extent(0) ) {
-      m_send_node_id(i) = m_box_part.send_node_id(i);
-    }
-  }
-};
-
-} // namespace Example
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_EXAMPLE_BOXELEMFIXTURE_HPP */
-
diff --git a/lib/kokkos/example/fixture/BoxElemPart.cpp b/lib/kokkos/example/fixture/BoxElemPart.cpp
deleted file mode 100644
index 7b85936da7f01b61fc4e6223df986442d3631c97..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/BoxElemPart.cpp
+++ /dev/null
@@ -1,413 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <utility>
-#include <iostream>
-#include <sstream>
-#include <stdexcept>
-#include <limits>
-#include <BoxElemPart.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-void box_partition( const size_t global_size ,
-                    const size_t global_rank ,
-                    const size_t global_box[][2] ,
-                          size_t box[][2] )
-{
-  box[0][0] = global_box[0][0] ; box[0][1] = global_box[0][1] ;
-  box[1][0] = global_box[1][0] ; box[1][1] = global_box[1][1] ;
-  box[2][0] = global_box[2][0] ; box[2][1] = global_box[2][1] ;
-
-  size_t ip = 0 ;
-  size_t np = global_size ;
-
-  while ( 1 < np ) {
-
-    // P = [ ip + j * portion , ip + ( j + 1 ) * portion )
-
-    size_t jip , jup ;
-
-    {
-      const size_t part = ( 0 == ( np % 5 ) ) ? 5 : (
-                          ( 0 == ( np % 3 ) ) ? 3 : 2 );
-
-      const size_t portion = np / part ;
-
-      if ( 2 < part || global_rank < ip + portion ) {
-        jip = portion * size_t( double( global_rank - ip ) / double(portion) );
-        jup = jip + portion ;
-      }
-      else {
-        jip = portion ;
-        jup = np ;
-      }
-    }
-
-    // Choose axis with largest count:
-
-    const size_t nb[3] = {
-      box[0][1] - box[0][0] ,
-      box[1][1] - box[1][0] ,
-      box[2][1] - box[2][0] };
-
-    const int axis = nb[2] > nb[1] ? ( nb[2] > nb[0] ? 2 : 0 )
-                                        : ( nb[1] > nb[0] ? 1 : 0 );
-
-    box[ axis ][1] = box[ axis ][0] + size_t( double(nb[axis]) * ( double(jup) / double(np) ));
-    box[ axis ][0] = box[ axis ][0] + size_t( double(nb[axis]) * ( double(jip) / double(np) ));
-
-    np = jup - jip ;
-    ip = ip + jip ;
-  }
-}
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-void BoxElemPart::local( const size_t  rank ,
-                               size_t  uses_elem[][2] ,
-                               size_t  owns_node[][2] ,
-                               size_t  uses_node[][2] ) const
-{
-  if ( BoxElemPart::DecomposeElem == m_decompose ) {
-
-    Kokkos::Example::box_partition( m_global_size , rank , m_global_elem_box , uses_elem );
-
-    for ( int i = 0 ; i < 3 ; ++i ) {
-      owns_node[i][0] = uses_elem[i][0] ;
-      owns_node[i][1] = uses_elem[i][1] + ( m_global_elem_box[i][1] == uses_elem[i][1] ? 1 : 0 );
-    }
-  }
-  else {
-
-    const size_t global_vert[3][2] =
-      { { 0 , m_global_elem_box[0][1] + 1 },
-        { 0 , m_global_elem_box[1][1] + 1 },
-        { 0 , m_global_elem_box[2][1] + 1 } };
-
-    Kokkos::Example::box_partition( m_global_size , rank , global_vert , owns_node );
-
-    for ( int i = 0 ; i < 3 ; ++i ) {
-      uses_elem[i][0] = global_vert[i][0] == owns_node[i][0] ? owns_node[i][0] : owns_node[i][0] - 1 ;
-      uses_elem[i][1] = global_vert[i][1] == owns_node[i][1] ? owns_node[i][1] - 1 : owns_node[i][1] ;
-    }
-  }
-
-  for ( int i = 0 ; i < 3 ; ++i ) {
-    uses_node[i][0] = uses_elem[i][0] ;
-    uses_node[i][1] = uses_elem[i][1] + 1 ;
-  }
-
-  if ( BoxElemPart::ElemQuadratic == m_elem_order ) {
-    for ( int i = 0 ; i < 3 ; ++i ) {
-      owns_node[i][0] = 2 * owns_node[i][0] ;
-      uses_node[i][0] = 2 * uses_node[i][0] ;
-      owns_node[i][1] = 2 * owns_node[i][1] - 1 ;
-      uses_node[i][1] = 2 * uses_node[i][1] - 1 ;
-    }
-  }
-}
-
-BoxElemPart::BoxElemPart(
-  const BoxElemPart::ElemOrder elem_order ,
-  const BoxElemPart::Decompose decompose ,
-  const size_t global_size ,
-  const size_t global_rank ,
-  const size_t elem_nx ,
-  const size_t elem_ny ,
-  const size_t elem_nz )
-{
-  m_global_size = global_size ;
-  m_global_rank = global_rank ;
-  m_decompose   = decompose ;
-  m_elem_order  = elem_order ;
-
-  m_global_elem_box[0][0] = 0 ; m_global_elem_box[0][1] = elem_nx ;
-  m_global_elem_box[1][0] = 0 ; m_global_elem_box[1][1] = elem_ny ;
-  m_global_elem_box[2][0] = 0 ; m_global_elem_box[2][1] = elem_nz ;
-
-  m_global_node_box[0][0] = 0 ; m_global_node_box[0][1] = 0 ;
-  m_global_node_box[1][0] = 0 ; m_global_node_box[1][1] = 0 ;
-  m_global_node_box[2][0] = 0 ; m_global_node_box[2][1] = 0 ;
-
-  m_owns_node_count = 0 ;
-  m_send_node_count = 0 ;
-
-  m_ok = true ;
-
-  //----------------------------------------
-
-  if ( ElemLinear == elem_order ) {
-    m_global_node_box[0][1] = elem_nx + 1 ;
-    m_global_node_box[1][1] = elem_ny + 1 ;
-    m_global_node_box[2][1] = elem_nz + 1 ;
-  }
-  else if ( ElemQuadratic == elem_order ) {
-    m_global_node_box[0][1] = 2 * elem_nx + 1 ;
-    m_global_node_box[1][1] = 2 * elem_ny + 1 ;
-    m_global_node_box[2][1] = 2 * elem_nz + 1 ;
-  }
-
-  //----------------------------------------
-
-  local( m_global_rank , m_uses_elem_box , m_owns_node_box[0] , m_uses_node_box );
-
-  const size_t global_node_count_ = Kokkos::Example::box_count( m_global_node_box );
-  const size_t global_elem_count_ = Kokkos::Example::box_count( m_global_elem_box );
-
-  //----------------------------------------
-
-  size_t elem_count = Kokkos::Example::box_count( m_uses_elem_box );
-  size_t node_count = Kokkos::Example::box_count( m_owns_node_box[0] );
-
-  m_owns_node[0][0] = global_rank ;
-  m_owns_node[0][1] = node_count ;
-  m_owns_node_count = 1 ;
-  m_send_node_count = 0 ;
-
-  for ( size_t rr = 1 ; rr < m_global_size && m_ok ; ++rr ) {
-
-    const size_t rank = ( m_global_rank + rr ) % m_global_size ;
-
-    size_t elem_box[3][2] , o_node_box[3][2] , u_node_box[3][2] ;
-
-    // Boxes for process 'rank'
-    local( rank , elem_box , o_node_box , u_node_box );
-
-    // Box that this process uses but is owned by process 'rank'
-    Kokkos::Example::box_intersect( m_owns_node_box[ m_owns_node_count ] , m_uses_node_box , o_node_box );
-
-    m_owns_node[ m_owns_node_count ][1] = Kokkos::Example::box_count( m_owns_node_box[ m_owns_node_count ] );
-
-    if ( m_owns_node[ m_owns_node_count ][1] ) {
-
-      if ( ( PROC_NEIGH_MAX - 1 ) <= m_owns_node_count ) {
-        std::cout << "BoxElemPart exceeded maximum neighbor count" << std::endl ;
-        m_ok = false ;
-        break ;
-      }
-
-      m_owns_node[ m_owns_node_count ][0] = rank ;
-
-      ++m_owns_node_count ;
-    }
-
-    // Box that this process owns and is used by process 'rank'
-    Kokkos::Example::box_intersect( m_send_node_box[ m_send_node_count ] , m_owns_node_box[0] , u_node_box );
-
-    m_send_node[ m_send_node_count ][1] = Kokkos::Example::box_count( m_send_node_box[ m_send_node_count ] );
-
-    if ( m_send_node[ m_send_node_count ][1] ) {
-
-      if ( ( PROC_NEIGH_MAX - 1 ) <= m_send_node_count ) {
-        std::cout << "BoxElemPart exceeded maximum neighbor count" << std::endl ;
-        m_ok = false ;
-        break ;
-      }
-
-      m_send_node[ m_send_node_count ][0] = rank ;
-      ++m_send_node_count ;
-    }
-
-    // Error checking:
-
-    size_t test_box[3][2] ;
-
-    elem_count += Kokkos::Example::box_count( elem_box );
-    node_count += Kokkos::Example::box_count( o_node_box );
-
-    {
-      Kokkos::Example::box_intersect( test_box , m_owns_node_box[0] , o_node_box );
-
-      if ( Kokkos::Example::box_count( test_box ) ) {
-        std::cout << "Box partitioning error" << std::endl ;
-        std::cout << "owns_node[" << m_global_rank << "]{"
-                  << " [" << m_owns_node_box[0][0][0] << "," << m_owns_node_box[0][0][1] << ")"
-                  << " [" << m_owns_node_box[0][1][0] << "," << m_owns_node_box[0][1][1] << ")"
-                  << " [" << m_owns_node_box[0][2][0] << "," << m_owns_node_box[0][2][1] << ")"
-                  << "} intersects"
-                  << " owns_node[" << rank << "]{"
-                  << " [" << o_node_box[0][0] << "," << o_node_box[0][1] << ")"
-                  << " [" << o_node_box[1][0] << "," << o_node_box[1][1] << ")"
-                  << " [" << o_node_box[2][0] << "," << o_node_box[2][1] << ")"
-                  << "}" << std::endl ;
-        m_ok = false ;
-        break ;
-      }
-    }
-
-    if ( DecomposeElem == decompose ) {
-
-      Kokkos::Example::box_intersect( test_box , m_uses_elem_box , elem_box );
-
-      if ( Kokkos::Example::box_count( test_box ) ) {
-        std::cout << "Box partitioning error" << std::endl ;
-        std::cout << "ElemBox[" << m_global_rank << "]{"
-                  << " [" << m_uses_elem_box[0][0] << "," << m_uses_elem_box[0][1] << ")"
-                  << " [" << m_uses_elem_box[1][0] << "," << m_uses_elem_box[1][1] << ")"
-                  << " [" << m_uses_elem_box[2][0] << "," << m_uses_elem_box[2][1] << ")"
-                  << "} intersects"
-                  << " ElemBox[" << rank << "]{"
-                  << " [" << elem_box[0][0] << "," << elem_box[0][1] << ")"
-                  << " [" << elem_box[1][0] << "," << elem_box[1][1] << ")"
-                  << " [" << elem_box[2][0] << "," << elem_box[2][1] << ")"
-                  << "}" << std::endl ;
-        m_ok = false ;
-        break ;
-      }
-    }
-  }
-
-  // Sentinal values at the end of the owns and send lists:
-
-  m_owns_node[ m_owns_node_count ][0] = ~0u ;
-  m_owns_node[ m_owns_node_count ][1] = ~0u ;
-  m_owns_node_box[ m_owns_node_count ][0][0] = 0u ; m_owns_node_box[ m_owns_node_count ][0][0] = ~0u ;
-  m_owns_node_box[ m_owns_node_count ][1][0] = 0u ; m_owns_node_box[ m_owns_node_count ][1][0] = ~0u ;
-  m_owns_node_box[ m_owns_node_count ][2][0] = 0u ; m_owns_node_box[ m_owns_node_count ][2][0] = ~0u ;
-
-  m_send_node[ m_send_node_count ][0] = ~0u ;
-  m_send_node[ m_send_node_count ][1] = ~0u ;
-  m_send_node_box[ m_send_node_count ][0][0] = 0u ; m_send_node_box[ m_send_node_count ][0][0] = ~0u ;
-  m_send_node_box[ m_send_node_count ][1][0] = 0u ; m_send_node_box[ m_send_node_count ][1][0] = ~0u ;
-  m_send_node_box[ m_send_node_count ][2][0] = 0u ; m_send_node_box[ m_send_node_count ][2][0] = ~0u ;
-
-  {
-    size_t count = 0 ;
-    for ( size_t i = 0 ; i < m_owns_node_count ; ++i ) {
-      count += m_owns_node[i][1] ;
-    }
-    if ( count != Kokkos::Example::box_count( m_uses_node_box ) ) {
-      std::cout << "Node uses count = " << Kokkos::Example::box_count( m_uses_node_box )
-                << " error count = " << count << std::endl ;
-      m_ok = false ;
-    }
-  }
-
-  if ( global_node_count_ != node_count ) {
-    std::cout << "Node count = " << global_node_count_ << " overlap error count = " << node_count << std::endl ;
-    m_ok = false ;
-  }
-
-  if ( DecomposeElem == decompose && global_elem_count_ != elem_count ) {
-    std::cout << "Elem count = " << global_elem_count_ << " overlap error count = " << elem_count << std::endl ;
-    m_ok = false ;
-  }
-
-  if ( ! m_ok ) {
-    for ( int i = 0 ; i < 3 ; ++i ) { for ( int j = 0 ; j < 2 ; ++j ) {
-      m_global_elem_box[i][j] = 0 ;
-      m_global_node_box[i][j] = 0 ;
-      m_uses_elem_box[i][j] = 0 ;
-      m_uses_node_box[i][j] = 0 ;
-    }}
-    m_owns_node_count = 0 ;
-    m_send_node_count = 0 ;
-  }
-}
-
-void BoxElemPart::print( std::ostream & s ) const
-{
-  s << "BoxElemPart P[" << m_global_rank << ":" << m_global_size << "]"
-    << std::endl
-    << "  elem_box {"
-    << " [" << m_uses_elem_box[0][0] << "," << m_uses_elem_box[0][1] << ")"
-    << " [" << m_uses_elem_box[1][0] << "," << m_uses_elem_box[1][1] << ")"
-    << " [" << m_uses_elem_box[2][0] << "," << m_uses_elem_box[2][1] << ")"
-    << " } / {"
-    << " [" << m_global_elem_box[0][0] << "," << m_global_elem_box[0][1] << ")"
-    << " [" << m_global_elem_box[1][0] << "," << m_global_elem_box[1][1] << ")"
-    << " [" << m_global_elem_box[2][0] << "," << m_global_elem_box[2][1] << ")"
-    << " }"
-    << std::endl
-    << "  node_box {"
-    << " [" << m_owns_node_box[0][0][0] << "," << m_owns_node_box[0][0][1] << ")"
-    << " [" << m_owns_node_box[0][1][0] << "," << m_owns_node_box[0][1][1] << ")"
-    << " [" << m_owns_node_box[0][2][0] << "," << m_owns_node_box[0][2][1] << ")"
-    << " } / {"
-    << " [" << m_uses_node_box[0][0] << "," << m_uses_node_box[0][1] << ")"
-    << " [" << m_uses_node_box[1][0] << "," << m_uses_node_box[1][1] << ")"
-    << " [" << m_uses_node_box[2][0] << "," << m_uses_node_box[2][1] << ")"
-    << " } / {"
-    << " [" << m_global_node_box[0][0] << "," << m_global_node_box[0][1] << ")"
-    << " [" << m_global_node_box[1][0] << "," << m_global_node_box[1][1] << ")"
-    << " [" << m_global_node_box[2][0] << "," << m_global_node_box[2][1] << ")"
-    << " }"
-    << std::endl ;
-
-  for ( size_t i = 1 ; i < m_owns_node_count ; ++i ) {
-    s << "  P[" << m_owns_node[i][0] << "]"
-      << " recv node_box {"
-      << " [" << m_owns_node_box[i][0][0] << "," << m_owns_node_box[i][0][1] << ")"
-      << " [" << m_owns_node_box[i][1][0] << "," << m_owns_node_box[i][1][1] << ")"
-      << " [" << m_owns_node_box[i][2][0] << "," << m_owns_node_box[i][2][1] << ")"
-      << " }"
-      << std::endl ;
-  }
-
-  for ( size_t i = 0 ; i < m_send_node_count ; ++i ) {
-    s << "  P[" << m_send_node[i][0] << "]"
-      << " send node_box {"
-      << " [" << m_send_node_box[i][0][0] << "," << m_send_node_box[i][0][1] << ")"
-      << " [" << m_send_node_box[i][1][0] << "," << m_send_node_box[i][1][1] << ")"
-      << " [" << m_send_node_box[i][2][0] << "," << m_send_node_box[i][2][1] << ")"
-      << " }"
-      << std::endl ;
-  }
-}
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-//----------------------------------------------------------------------------
-
-
diff --git a/lib/kokkos/example/fixture/BoxElemPart.hpp b/lib/kokkos/example/fixture/BoxElemPart.hpp
deleted file mode 100644
index 6cd91c6f6f6e5b5063c8f819d9d0b71350a148d3..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/BoxElemPart.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_BOXELEMPART_HPP
-#define KOKKOS_BOXELEMPART_HPP
-
-#include <utility>
-#include <ostream>
-#include <Kokkos_Macros.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-KOKKOS_INLINE_FUNCTION
-void box_intersect( size_t box[][2] ,
-                    const size_t boxA[][2] ,
-                    const size_t boxB[][2] )
-{
-  for ( int i = 0 ; i < 3 ; ++i ) {
-    box[i][0] = boxA[i][0] > boxB[i][0] ? boxA[i][0] : boxB[i][0] ;
-    box[i][1] = boxA[i][1] < boxB[i][1] ? boxA[i][1] : boxB[i][1] ;
-    if ( box[i][0] > box[i][1] ) box[i][1] = box[i][0] ;
-  }
-}
-
-KOKKOS_INLINE_FUNCTION
-size_t box_count( const size_t box[][2] )
-{
-  return size_t( box[0][1] - box[0][0] ) *
-         size_t( box[1][1] - box[1][0] ) *
-         size_t( box[2][1] - box[2][0] );
-}
-
-KOKKOS_INLINE_FUNCTION
-void box_ghost_layer( const size_t global_box[][2] ,
-                      const size_t local_box[][2] ,
-                      const size_t ghost_layer ,
-                            size_t ghost_box[][2] )
-{
-  for ( int i = 0 ; i < 3 ; ++i ) {
-    ghost_box[i][0] = global_box[i][0] + ghost_layer > local_box[i][0] ? global_box[i][0] : local_box[i][0] - ghost_layer ;
-    ghost_box[i][1] = global_box[i][1] < local_box[i][1] + ghost_layer ? global_box[i][1] : local_box[i][1] + ghost_layer ;
-  }
-}
-
-void box_partition( const size_t global_size ,
-                    const size_t global_rank ,
-                    const size_t global_box[][2] ,
-                          size_t box[][2] );
-
-} // namespace Example
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Example {
-
-/** \brief Partition a box of hexahedral elements among subdomains.
- *
- *  Nodes are ordered locally as follows:
- *    { owned_by[ this_process ] ,
- *      owned_by[ neighbor_process[0] ] ,
- *      owned_by[ neighbor_process[1] ] ,
- *      owned_by[ neighbor_process[2] ] ,
- *      ... };
- */
-class BoxElemPart {
-public:
-
-  enum Decompose { DecomposeNode , DecomposeElem };
-  enum ElemOrder { ElemLinear , ElemQuadratic };
-
-  bool ok() const { return m_ok ; }
-
-  BoxElemPart( const ElemOrder elem_order ,
-               const Decompose decompose ,
-               const size_t global_size ,
-               const size_t global_rank ,
-               const size_t elem_nx ,
-               const size_t elem_ny ,
-               const size_t elem_nz );
-
-  KOKKOS_INLINE_FUNCTION
-  size_t global_elem_count() const
-    { return Kokkos::Example::box_count( m_global_elem_box ); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t global_node_count() const
-    { return Kokkos::Example::box_count( m_global_node_box ); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t uses_elem_count() const
-    { return Kokkos::Example::box_count( m_uses_elem_box ); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t owns_node_count() const
-    { return Kokkos::Example::box_count( m_owns_node_box[0] ); }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t uses_node_count() const
-    { return Kokkos::Example::box_count( m_uses_node_box ); }
-
-  //----------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  size_t uses_elem_offset( const size_t ix ,
-                           const size_t iy ,
-                           const size_t iz ) const
-  {
-    return size_t( ix - m_uses_elem_box[0][0] ) + size_t( m_uses_elem_box[0][1] - m_uses_elem_box[0][0] ) * (
-           size_t( iy - m_uses_elem_box[1][0] ) + size_t( m_uses_elem_box[1][1] - m_uses_elem_box[1][0] ) * (
-           size_t( iz - m_uses_elem_box[2][0] ) ) );
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void uses_elem_coord( size_t lid , size_t c[] ) const
-  {
-    const size_t nx = m_uses_elem_box[0][1] - m_uses_elem_box[0][0] ;
-    const size_t ny = m_uses_elem_box[1][1] - m_uses_elem_box[1][0] ;
-
-    c[0] = m_uses_elem_box[0][0] + lid % nx ; lid /= nx ;
-    c[1] = m_uses_elem_box[1][0] + lid % ny ; lid /= ny ;
-    c[2] = m_uses_elem_box[2][0] + lid ;
-  }
-
-  //----------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  size_t global_coord_max( size_t axis ) const
-  { return m_global_node_box[axis][1] - 1 ; }
-
-  //----------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void local_node_coord( size_t lid , size_t coord[] ) const
-  {
-    // Local id within an 'owns' block (has sentinal)
-    size_t j = 0 ;
-    while ( m_owns_node[j][1] <= lid ) { lid -= m_owns_node[j][1] ; ++j ; }
-
-    // Map to global coordinates:
-    const size_t nx = m_owns_node_box[j][0][1] - m_owns_node_box[j][0][0] ;
-    const size_t ny = m_owns_node_box[j][1][1] - m_owns_node_box[j][1][0] ;
-
-    coord[0] = m_owns_node_box[j][0][0] + lid % nx ; lid /= nx ;
-    coord[1] = m_owns_node_box[j][1][0] + lid % ny ; lid /= ny ;
-    coord[2] = m_owns_node_box[j][2][0] + lid ;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t local_node_id( const size_t c[] ) const
-  {
-    // Find which 'owns' block and accumulate the offset of this block:
-    size_t lid = 0 ;
-    size_t j = 0 ;
-    while ( ! ( m_owns_node_box[j][0][0] <= c[0] && c[0] < m_owns_node_box[j][0][1] &&
-                m_owns_node_box[j][1][0] <= c[1] && c[1] < m_owns_node_box[j][1][1] &&
-                m_owns_node_box[j][2][0] <= c[2] && c[2] < m_owns_node_box[j][2][1] ) ) {
-      
-      lid += m_owns_node[j][1] ;
-      ++j ;
-    }
-
-    // Map offset to the block plus offset within the block:
-    return lid +
-           size_t( c[0] - m_owns_node_box[j][0][0] ) + size_t( m_owns_node_box[j][0][1] - m_owns_node_box[j][0][0] ) * (
-           size_t( c[1] - m_owns_node_box[j][1][0] ) + size_t( m_owns_node_box[j][1][1] - m_owns_node_box[j][1][0] ) * (
-           size_t( c[2] - m_owns_node_box[j][2][0] ) ) );
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t global_node_id( const size_t c[] ) const
-  {
-    return size_t( c[0] - m_global_node_box[0][0] ) + size_t( m_global_node_box[0][1] - m_global_node_box[0][0] ) * (
-           size_t( c[1] - m_global_node_box[1][0] ) + size_t( m_global_node_box[1][1] - m_global_node_box[1][0] ) * (
-           size_t( c[2] - m_global_node_box[2][0] ) ) );
-  }
-
-  //----------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  size_t recv_node_msg_count() const { return m_owns_node_count - 1 ; }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t recv_node_rank(  size_t msg ) const { return m_owns_node[msg+1][0] ; }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t recv_node_count( size_t msg ) const { return m_owns_node[msg+1][1] ; }
-
-  //----------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  size_t send_node_msg_count() const { return m_send_node_count ; }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t send_node_rank(  size_t msg ) const { return m_send_node[msg][0] ; }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t send_node_count( size_t msg ) const { return m_send_node[msg][1] ; }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t send_node_id_count() const
-  {
-    size_t count = 0 ;
-    for ( size_t i = 0 ; i < m_send_node_count ; ++i ) {
-      count += m_send_node[i][1] ;
-    }
-    return count ;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  size_t send_node_id( size_t item ) const
-  {
-    // Find which send list this send item is in:
-    size_t j = 0 ;
-    while ( m_send_node[j][1] <= item ) { item -= m_send_node[j][1] ; ++j ; }
-
-    // Map to global coordinate:
-    const size_t nx = m_send_node_box[j][0][1] - m_send_node_box[j][0][0] ;
-    const size_t ny = m_send_node_box[j][1][1] - m_send_node_box[j][1][0] ;
-
-    size_t c[3] ;
-
-    c[0] = m_send_node_box[j][0][0] + item % nx ; item /= nx ;
-    c[1] = m_send_node_box[j][1][0] + item % ny ; item /= ny ;
-    c[2] = m_send_node_box[j][2][0] + item ;
-
-    // Map to local id:
-    return size_t( c[0] - m_owns_node_box[0][0][0] ) + size_t( m_owns_node_box[0][0][1] - m_owns_node_box[0][0][0] ) * (
-           size_t( c[1] - m_owns_node_box[0][1][0] ) + size_t( m_owns_node_box[0][1][1] - m_owns_node_box[0][1][0] ) * (
-           size_t( c[2] - m_owns_node_box[0][2][0] ) ) );
-  }
-
-  //----------------------------------------
-
-  void print( std::ostream & s ) const ;
-
-private:
-
-  // Maximum number of processes in a neighborhood, including this process
-  enum { PROC_NEIGH_MAX = 64 };
-
-  void local( const size_t  rank ,
-                    size_t  uses_elem[][2] ,
-                    size_t  owns_node[][2] ,
-                    size_t  uses_node[][2] ) const ;
-
-  size_t  m_global_size ;
-  size_t  m_global_rank ;
-
-  Decompose m_decompose ;
-  ElemOrder m_elem_order ;
-
-  size_t m_global_elem_box[3][2] ;
-  size_t m_global_node_box[3][2] ;
-  size_t m_uses_elem_box[3][2] ;
-  size_t m_uses_node_box[3][2] ;
-
-  // [ processor rank , count ]
-  size_t m_owns_node_box[ PROC_NEIGH_MAX ][3][2] ;
-  size_t m_owns_node[     PROC_NEIGH_MAX ][2] ;
-  size_t m_owns_node_count ;
-
-  size_t m_send_node_box[ PROC_NEIGH_MAX ][3][2] ;
-  size_t m_send_node[     PROC_NEIGH_MAX ][2] ;
-  size_t m_send_node_count ;
-
-  bool   m_ok ;
-};
-
-} // namespace Example
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_BOXELEMPART_HPP */
-
diff --git a/lib/kokkos/example/fixture/CMakeLists.txt b/lib/kokkos/example/fixture/CMakeLists.txt
deleted file mode 100644
index 298c54c5bb3e00bf5ecaf5ad18e53de2ba405272..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../common)
-
-SET(SOURCES_TEST Main.cpp TestFixture.cpp BoxElemPart.cpp )
-
-# Automatically picks up 'kokkosexample_fixture'
-TRIBITS_ADD_EXECUTABLE_AND_TEST(
-  TestFixture
-  SOURCES ${SOURCES_TEST}
-  )
-
diff --git a/lib/kokkos/example/fixture/HexElement.hpp b/lib/kokkos/example/fixture/HexElement.hpp
deleted file mode 100644
index 72bc45fd21d81018cdd6af3cdabb49a979bf4d46..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/HexElement.hpp
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_HEXELEMENT_HPP
-#define KOKKOS_HEXELEMENT_HPP
-
-namespace Kokkos {
-namespace Example {
-
-template< unsigned NodeCount >
-class HexElement_TensorData ;
-
-template< unsigned NodeCount , class Device >
-class HexElement_TensorEval ;
-
-//----------------------------------------------------------------------------
-/** \brief  Evaluate Hex element on interval [-1,1]^3 */
-template<>
-class HexElement_TensorData< 8 > {
-public:
-
-  static const unsigned element_node_count    = 8 ;
-  static const unsigned spatial_dimension     = 3 ;
-  static const unsigned integration_count_1d  = 2 ;
-  static const unsigned function_count_1d     = 2 ;
-
-  float values_1d [ function_count_1d ][ integration_count_1d ];
-  float derivs_1d [ function_count_1d ][ integration_count_1d ];
-  float weights_1d[ integration_count_1d ];
-
-  unsigned char eval_map[ element_node_count ][4] ;
-
-  static float eval_value_1d( const unsigned jf , const float x )
-  {
-    return 0 == jf ? 0.5 * ( 1.0 - x ) : (
-           1 == jf ? 0.5 * ( 1.0 + x ) : 0 );
-  }
-
-  static float eval_deriv_1d( const unsigned jf , const float )
-  {
-    return 0 == jf ? -0.5 : (
-           1 == jf ?  0.5 : 0 );
-  }
-
-  HexElement_TensorData()
-  {
-    const unsigned char tmp_map[ element_node_count ][ spatial_dimension ] =
-      { { 0 , 0 , 0 },
-        { 1 , 0 , 0 },
-        { 1 , 1 , 0 },
-        { 0 , 1 , 0 },
-        { 0 , 0 , 1 },
-        { 1 , 0 , 1 },
-        { 1 , 1 , 1 },
-        { 0 , 1 , 1 } };
-
-    weights_1d[0] = 1 ;
-    weights_1d[1] = 1 ;
-
-    const float points_1d[ integration_count_1d ] =
-      { -0.577350269 , 0.577350269 };
-
-    for ( unsigned i = 0 ; i < element_node_count ; ++i ) {
-      eval_map[i][0] = tmp_map[i][0];
-      eval_map[i][1] = tmp_map[i][1];
-      eval_map[i][2] = tmp_map[i][2];
-    }
-
-    for ( unsigned xp = 0 ; xp < integration_count_1d ; ++xp ) {
-    for ( unsigned xf = 0 ; xf < function_count_1d ; ++xf ) {
-      values_1d[xp][xf] = eval_value_1d( xf , points_1d[xp] );
-      derivs_1d[xp][xf] = eval_deriv_1d( xf , points_1d[xp] );
-    }}
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template<>
-class HexElement_TensorData< 27 > {
-public:
-
-  static const unsigned element_node_count    = 27 ;
-  static const unsigned spatial_dimension     = 3 ;
-  static const unsigned integration_count_1d  = 3 ;
-  static const unsigned function_count_1d     = 3 ;
-
-  float values_1d [ function_count_1d ][ integration_count_1d ];
-  float derivs_1d [ function_count_1d ][ integration_count_1d ];
-  float weights_1d[ integration_count_1d ];
-
-  unsigned char eval_map[ element_node_count ][4] ;
-
-  // sizeof(EvaluateElementHex) = 111 bytes =
-  //   sizeof(float) * 9 +
-  //   sizeof(float) * 9 +
-  //   sizeof(float) * 3 +
-  //   sizeof(char) * 27 
-
-  static float eval_value_1d( const unsigned jf , const float p )
-  {
-    return 0 == jf ? 0.5 * p * ( p - 1 ) : (
-           1 == jf ? 1.0 - p * p : (
-           2 == jf ? 0.5 * p * ( p + 1 ) : 0 ));
-  }
-
-  static float eval_deriv_1d( const unsigned jf , const float p )
-  {
-    return 0 == jf ? p - 0.5 : (
-           1 == jf ? -2.0 * p : (
-           2 == jf ? p + 0.5 : 0 ));
-  }
-
-  HexElement_TensorData()
-  {
-    const unsigned char tmp_map[ element_node_count ][ spatial_dimension ] =
-      { { 0 , 0 , 0 },
-        { 2 , 0 , 0 },
-        { 2 , 2 , 0 },
-        { 0 , 2 , 0 },
-        { 0 , 0 , 2 },
-        { 2 , 0 , 2 },
-        { 2 , 2 , 2 },
-        { 0 , 2 , 2 },
-        { 1 , 0 , 0 },
-        { 2 , 1 , 0 },
-        { 1 , 2 , 0 },
-        { 0 , 1 , 0 },
-        { 0 , 0 , 1 },
-        { 2 , 0 , 1 },
-        { 2 , 2 , 1 },
-        { 0 , 2 , 1 },
-        { 1 , 0 , 2 },
-        { 2 , 1 , 2 },
-        { 1 , 2 , 2 },
-        { 0 , 1 , 2 },
-        { 1 , 1 , 1 },
-        { 1 , 1 , 0 },
-        { 1 , 1 , 2 },
-        { 0 , 1 , 1 },
-        { 2 , 1 , 1 },
-        { 1 , 0 , 1 },
-        { 1 , 2 , 1 } };
-
-    // Interval [-1,1]
-
-    weights_1d[0] = 0.555555556 ;
-    weights_1d[1] = 0.888888889 ;
-    weights_1d[2] = 0.555555556 ;
-
-    const float points_1d[3] = { -0.774596669 ,
-                                  0.000000000 ,
-                                  0.774596669 };
-
-    for ( unsigned i = 0 ; i < element_node_count ; ++i ) {
-      eval_map[i][0] = tmp_map[i][0];
-      eval_map[i][1] = tmp_map[i][1];
-      eval_map[i][2] = tmp_map[i][2];
-    }
-
-    for ( unsigned xp = 0 ; xp < integration_count_1d ; ++xp ) {
-    for ( unsigned xf = 0 ; xf < function_count_1d ; ++xf ) {
-      values_1d[xp][xf] = eval_value_1d( xf , points_1d[xp] );
-      derivs_1d[xp][xf] = eval_deriv_1d( xf , points_1d[xp] );
-    }}
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< unsigned NodeCount >
-class HexElement_Data {
-public:
-  static const unsigned spatial_dimension   = 3 ;
-  static const unsigned element_node_count  = NodeCount ;
-  static const unsigned integration_count   = NodeCount ;
-  static const unsigned function_count      = NodeCount ;
-
-  float weights[   integration_count ] ;
-  float values[    integration_count ][ function_count ];
-  float gradients[ integration_count ][ spatial_dimension ][ function_count ];
-
-  HexElement_Data()
-  {
-    HexElement_TensorData< NodeCount > tensor_data ;
-
-    for ( unsigned ip = 0 ; ip < integration_count ; ++ip ) {
-
-      const unsigned ipx = tensor_data.eval_map[ip][0] ;
-      const unsigned ipy = tensor_data.eval_map[ip][1] ;
-      const unsigned ipz = tensor_data.eval_map[ip][2] ;
-
-      weights[ip] = tensor_data.weights_1d[ ipx ] *
-                    tensor_data.weights_1d[ ipy ] *
-                    tensor_data.weights_1d[ ipz ] ;
-
-      for ( unsigned jf = 0 ; jf < function_count ; ++jf ) {
-
-        const unsigned jfx = tensor_data.eval_map[jf][0] ;
-        const unsigned jfy = tensor_data.eval_map[jf][1] ;
-        const unsigned jfz = tensor_data.eval_map[jf][2] ;
-
-        values[ip][jf] = tensor_data.values_1d[ ipx ][ jfx ] *
-                         tensor_data.values_1d[ ipy ][ jfy ] *
-                         tensor_data.values_1d[ ipz ][ jfz ] ;
-
-        gradients[ip][0][jf] = tensor_data.derivs_1d[ ipx ][ jfx ] *
-                               tensor_data.values_1d[ ipy ][ jfy ] *
-                               tensor_data.values_1d[ ipz ][ jfz ] ;
-
-        gradients[ip][1][jf] = tensor_data.values_1d[ ipx ][ jfx ] *
-                               tensor_data.derivs_1d[ ipy ][ jfy ] *
-                               tensor_data.values_1d[ ipz ][ jfz ] ;
-
-        gradients[ip][2][jf] = tensor_data.values_1d[ ipx ][ jfx ] *
-                               tensor_data.values_1d[ ipy ][ jfy ] *
-                               tensor_data.derivs_1d[ ipz ][ jfz ] ;
-      }
-    }
-  }
-};
-
-//----------------------------------------------------------------------------
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #ifndef KOKKOS_HEXELEMENT_HPP */
-
-
diff --git a/lib/kokkos/example/fixture/Main.cpp b/lib/kokkos/example/fixture/Main.cpp
deleted file mode 100644
index 0979366f67303f6e9d2c4da32c04ecc37c1b2f51..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/Main.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-
-#include <utility>
-#include <iostream>
-
-#include <Kokkos_Core.hpp>
-
-#include <BoxElemPart.hpp>
-
-namespace Kokkos {
-namespace Example {
-template< class > void test_fixture();
-}
-}
-
-int test_box( const size_t global_size
-            , const size_t global_box[][2]
-            , const bool print_verbose )
-{
-  size_t global_count = 0 ;
-  size_t global_max = 0 ;
-  size_t global_min = Kokkos::Example::box_count( global_box );
-  size_t global_box_max[3][2] = { { 0 , 0 } , { 0 , 0 } , { 0 , 0 } };
-  size_t global_box_min[3][2] = { { 0 , global_box[0][1] } , { 0 , global_box[1][1] } , { 0 , global_box[2][1] } };
-  size_t intersect_error = 0 ;
-  size_t neighbor_max = 0 ;
-
-  for ( size_t global_rank = 0 ; global_rank < global_size ; ++global_rank ) {
-    size_t box[3][2] = { { 0 , global_box[0][1] } , { 0 , global_box[1][1] } , { 0 , global_box[2][1] } };
-    size_t ghost_box[3][2] ;
-    size_t neighbor_count = 0 ;
-
-    Kokkos::Example::box_partition( global_size , global_rank , global_box , box );
-
-    Kokkos::Example::box_ghost_layer( global_box , box , 1 , ghost_box );
-
-    {
-      const size_t n = Kokkos::Example::box_count( box );
-
-      for ( int i = 0 ; i < 3 ; ++i ) {
-        if ( ( box[i][1] - box[i][0] ) < ( global_box_min[i][1] - global_box_min[i][0] ) ) {
-          global_box_min[i][0] = box[i][0] ;
-          global_box_min[i][1] = box[i][1] ;
-        }
-        if ( ( box[i][1] - box[i][0] ) > ( global_box_max[i][1] - global_box_max[i][0] ) ) {
-          global_box_max[i][0] = box[i][0] ;
-          global_box_max[i][1] = box[i][1] ;
-        }
-      }
-
-      global_max = std::max( global_max , n );
-      global_min = std::min( global_min , n );
-      global_count += n ;
-    }
-
-    for ( size_t other_rank = 0 ; other_rank  < global_size ; ++other_rank ) {
-
-      if ( other_rank == global_rank ) continue ;
-
-      size_t other_box[3][2] = { { 0 , global_box[0][1] } , { 0 , global_box[1][1] } , { 0 , global_box[2][1] } };
-      size_t intersect_box[3][2] ;
-
-      Kokkos::Example::box_partition( global_size , other_rank , global_box , other_box );
-
-      Kokkos::Example::box_intersect( intersect_box , box , other_box );
-
-      const size_t n = Kokkos::Example::box_count( intersect_box );
-
-      intersect_error += n ;
-
-      Kokkos::Example::box_intersect( intersect_box , ghost_box , other_box );
-
-      neighbor_count += Kokkos::Example::box_count( intersect_box ) ? 1 : 0 ;
-
-      if ( n ) {
-        std::cout << "box partition intersection error" << std::endl ;
-        std::cout << "box = {"
-                  << " [ " << box[0][0] << " , " << box[0][1] << " )"
-                  << " [ " << box[1][0] << " , " << box[1][1] << " )"
-                  << " [ " << box[2][0] << " , " << box[2][1] << " )"
-                  << " }" << std::endl ;
-        std::cout << "other_box = {"
-                  << " [ " << other_box[0][0] << " , " << other_box[0][1] << " )"
-                  << " [ " << other_box[1][0] << " , " << other_box[1][1] << " )"
-                  << " [ " << other_box[2][0] << " , " << other_box[2][1] << " )"
-                  << " }" << std::endl ;
-        return 0 ;
-      }
-    }
-
-    neighbor_max = std::max( neighbor_max , neighbor_count );
-  }
-
-  if ( print_verbose ) {
-
-    std::cout << "global_part = " << global_size << std::endl ;
-    std::cout << "global_box  = { "
-              << " [ " << global_box[0][0] << " .. " << global_box[0][1] << " ) X"
-              << " [ " << global_box[1][0] << " .. " << global_box[1][1] << " ) X"
-              << " [ " << global_box[2][0] << " .. " << global_box[2][1] << " )"
-              << " }" << std::endl ;
-    std::cout << "count( global_box ) = " << Kokkos::Example::box_count( global_box ) << std::endl ;
-    std::cout << "sum partition( global_box ) = " << global_count << std::endl ;
-    std::cout << "avg partition( global_box ) = " << size_t( double(global_count) / double(global_size)) << std::endl ;
-    std::cout << "min partition( global_box ) = " << global_min << std::endl ;
-    std::cout << "min part X   ( global_box ) = [ " << global_box_min[0][0] << " .. " << global_box_min[0][1] << " )" << std::endl ;
-    std::cout << "min part Y   ( global_box ) = [ " << global_box_min[1][0] << " .. " << global_box_min[1][1] << " )" << std::endl ;
-    std::cout << "min part Z   ( global_box ) = [ " << global_box_min[2][0] << " .. " << global_box_min[2][1] << " )" << std::endl ;
-    std::cout << "max partition( global_box ) = " << global_max << std::endl ;
-    std::cout << "max part X   ( global_box ) = [ " << global_box_max[0][0] << " .. " << global_box_max[0][1] << " )" << std::endl ;
-    std::cout << "max part Y   ( global_box ) = [ " << global_box_max[1][0] << " .. " << global_box_max[1][1] << " )" << std::endl ;
-    std::cout << "max part Z   ( global_box ) = [ " << global_box_max[2][0] << " .. " << global_box_max[2][1] << " )" << std::endl ;
-    std::cout << "sum intersect( global_box ) = " << intersect_error << std::endl ;
-    std::cout << "max neighbor = " << neighbor_max << std::endl ;
-  }
-
-  return neighbor_max ;
-}
-
-void test_elem()
-{
-  const Kokkos::Example::BoxElemPart::Decompose
-    decompose = Kokkos::Example::BoxElemPart:: DecomposeElem ; // DecomposeElem | DecomposeNode ;
-  const size_t global_size = 256 ;
-  const size_t global_nx = 100 ;
-  const size_t global_ny = 120 ;
-  const size_t global_nz = 140 ;
-
-  double node_count_avg = 0 ;
-  size_t node_count_max = 0 ;
-  size_t node_count_min = ( global_nx + 1 ) * ( global_ny + 1 ) * ( global_nz + 1 );
-  double elem_count_avg = 0 ;
-  size_t elem_count_max = 0 ;
-  size_t elem_count_min = global_nx * global_ny * global_nz ;
-  double recv_count_avg = 0 ;
-  size_t recv_count_max = 0 ;
-  size_t recv_count_min = global_size ;
-  double send_count_avg = 0 ;
-  size_t send_count_max = 0 ;
-  size_t send_count_min = global_size ;
-
-  for ( size_t r = 0 ; r < global_size ; ++r ) {
-    const Kokkos::Example::BoxElemPart
-       fixture( Kokkos::Example::BoxElemPart::ElemLinear ,
-                decompose , global_size , r , global_nx , global_ny , global_nz );
-
-    // Print a sample:
-
-    // if ( r == global_size * 2 / 3 ) fixture.print( std::cout );
-
-    // Verify recv/send alignment:
-
-    {
-      size_t recv_lid = fixture.owns_node_count();
-
-      for ( size_t i = 0 ; i < fixture.recv_node_msg_count() ; ++i ) {
-        const size_t recv_rank  = fixture.recv_node_rank( i );
-        const size_t recv_count = fixture.recv_node_count( i );
-
-        const Kokkos::Example::BoxElemPart other_fixture(
-           Kokkos::Example::BoxElemPart::ElemLinear ,
-           decompose , global_size , recv_rank , global_nx , global_ny , global_nz );
-
-        size_t send_item = 0 ;
-
-        size_t j = 0 ;
-        while ( j < other_fixture.send_node_msg_count() && other_fixture.send_node_rank(j) != r ) {
-          send_item += other_fixture.send_node_count( j );
-           ++j ;
-        }
-
-        if ( recv_count != other_fixture.send_node_count(j) ) {
-          std::cout << "Error P[" << r << "].recv(" << recv_count << ") != "
-                    << "P[" << recv_rank << "].send(" << other_fixture.send_node_count(j) << ")"
-                    << std::endl ;
-        }
-        else {
-
-          for ( size_t k = 0 ; k < recv_count ; ++k , ++send_item , ++recv_lid ) {
-
-            const size_t send_lid = other_fixture.send_node_id( send_item );
-
-            size_t recv_coord[3] , send_coord[3] ;
-
-            fixture.local_node_coord( recv_lid , recv_coord );
-
-            other_fixture.local_node_coord( send_lid , send_coord );
-
-            if ( recv_coord[0] != send_coord[0] ||
-                 recv_coord[1] != send_coord[1] ||
-                 recv_coord[2] != send_coord[2] ) {
-              std::cout << "Error P[" << r << "].recv[" << recv_lid << "]{ "
-                        << recv_coord[0] << " , "
-                        << recv_coord[1] << " , "
-                        << recv_coord[2] << " } != "
-                        << "P[" << recv_rank << "].send[" << send_lid << "]{ "
-                        << send_coord[0] << " , "
-                        << send_coord[1] << " , "
-                        << send_coord[2] << " }"
-                        << std::endl ;
-            }
-          }
-        }
-      }
-    }
-
-    node_count_avg += fixture.owns_node_count();
-    elem_count_avg += fixture.uses_elem_count();
-    recv_count_avg += fixture.recv_node_msg_count();
-    send_count_avg += fixture.send_node_msg_count();
-
-    elem_count_min = std::min( (size_t) fixture.uses_elem_count() , elem_count_min );
-    elem_count_max = std::max( (size_t) fixture.uses_elem_count() , elem_count_max );
-    node_count_min = std::min( (size_t) fixture.owns_node_count() , node_count_min );
-    node_count_max = std::max( (size_t) fixture.owns_node_count() , node_count_max );
-
-    recv_count_max = std::max( (size_t) fixture.recv_node_msg_count() , recv_count_max );
-    recv_count_min = std::min( (size_t) fixture.recv_node_msg_count() , recv_count_min );
-    send_count_max = std::max( (size_t) fixture.send_node_msg_count() , send_count_max );
-    send_count_min = std::min( (size_t) fixture.send_node_msg_count() , send_count_min );
-  }
-
-  node_count_avg /= double(global_size);
-  elem_count_avg /= double(global_size);
-  recv_count_avg /= double(global_size);
-  send_count_avg /= double(global_size);
-
-  std::cout << "Elem min(" << elem_count_min << ") avg(" << elem_count_avg << ") max(" << elem_count_max << ") " << std::endl
-            << "Node min(" << node_count_min << ") avg(" << node_count_avg << ") max(" << node_count_max << ") " << std::endl
-            << "Recv min(" << recv_count_min << ") avg(" << recv_count_avg << ") max(" << recv_count_max << ") " << std::endl
-            << "Send min(" << send_count_min << ") avg(" << send_count_avg << ") max(" << send_count_max << ") " << std::endl
-            ;
-}
-
-int main(int argc, char* argv[])
-{
-  Kokkos::initialize(argc,argv);
-  for ( int i = 1 ; i <= 32 ; ++i ) {
-    const size_t global_size = 16 * i ;
-    const size_t global_box[3][2] = { { 0 , 65 } , { 0 , 65 } , { 0 , 65 } };
-    if ( 30 < test_box( global_size , global_box , false ) ) {
-      test_box( global_size , global_box , true );
-    }
-  }
-
-//  test_elem();
-
-  {
-    std::cout << "test_fixture< Host >" << std::endl ;
-    Kokkos::Example::test_fixture< Kokkos::DefaultHostExecutionSpace >();
-  }
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  {
-    std::cout << "test_fixture< Cuda >" << std::endl ;
-    Kokkos::Example::test_fixture< Kokkos::Cuda >();
-  }
-#endif
-
-#if defined( KOKKOS_ENABLE_ROCM )
-  {
-    std::cout << "test_fixture< ROCm >" << std::endl ;
-    Kokkos::Example::test_fixture< Kokkos::Experimental::ROCm >();
-  }
-#endif
-  Kokkos::finalize();
-}
-
diff --git a/lib/kokkos/example/fixture/Makefile b/lib/kokkos/example/fixture/Makefile
deleted file mode 100644
index 5e684e344056cde31aec46c2a088e39c1c3bc2f9..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/Makefile
+++ /dev/null
@@ -1,46 +0,0 @@
-KOKKOS_PATH = ../..
-KOKKOS_SRC_PATH = ${KOKKOS_PATH}
-vpath %.cpp ${KOKKOS_SRC_PATH}/example/fixture
-
-EXAMPLE_HEADERS = $(wildcard $(KOKKOS_SRC_PATH)/example/common/*.hpp ${KOKKOS_SRC_PATH}/example/fixture/*.hpp )
-
-default: build_all
-	echo "End Build"
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-else
-  CXX = g++
-endif
-
-CXXFLAGS = -O3
-LINK ?= $(CXX)
-LDFLAGS ?=
-
-include $(KOKKOS_PATH)/Makefile.kokkos        
-
-KOKKOS_CXXFLAGS +=	\
-	-I${KOKKOS_SRC_PATH}/example/common	\
-	-I${KOKKOS_SRC_PATH}/example/fixture
-
-EXE_EXAMPLE_FIXTURE = KokkosExample_Fixture
-OBJ_EXAMPLE_FIXTURE = Main.o TestFixture.o BoxElemPart.o
-
-TARGETS = $(EXE_EXAMPLE_FIXTURE)
-
-#TEST_TARGETS =
-
-$(EXE_EXAMPLE_FIXTURE) : $(OBJ_EXAMPLE_FIXTURE) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LDFLAGS) $(EXTRA_PATH) $(OBJ_EXAMPLE_FIXTURE) $(KOKKOS_LIBS) $(LIB) -o $(EXE_EXAMPLE_FIXTURE)
-
-build_all : $(TARGETS)
-
-test : build_all
-
-clean: kokkos-clean
-	rm -f *.o $(TARGETS)
-
-# Compilation rules
-
-%.o:%.cpp $(KOKKOS_CPP_DEPENDS) $(EXAMPLE_HEADERS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
diff --git a/lib/kokkos/example/fixture/TestFixture.hpp b/lib/kokkos/example/fixture/TestFixture.hpp
deleted file mode 100644
index 12297a2aaa959beb18bbec861f14f02a835c46a2..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/fixture/TestFixture.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXAMPLE_TESTFIXTURE_HPP
-#define KOKKOS_EXAMPLE_TESTFIXTURE_HPP
-
-#include <utility>
-#include <iostream>
-
-#include <Kokkos_Core.hpp>
-
-#include <BoxElemPart.hpp>
-#include <BoxElemFixture.hpp>
-
-namespace Kokkos {
-namespace Example {
-
-template< class Device >
-struct FixtureVerifyElemNodeCoord
-{
-  typedef Device execution_space ;
-
-  typedef struct { size_t success , error ; } value_type ;
-
-  typedef Kokkos::Example::BoxElemFixture< Device , Kokkos::Example::BoxElemPart::ElemLinear > FixtureType ;
-
-  FixtureType m_fixture ;
-
-  KOKKOS_INLINE_FUNCTION
-  void init( value_type & update ) const { update.success = update.error = 0 ; }
-
-  KOKKOS_INLINE_FUNCTION
-  void join( volatile       value_type & update ,
-             volatile const value_type & input ) const
-    {
-      update.success += input.success ;
-      update.error += input.error ;
-    }
-  
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( size_t ielem , value_type & update ) const
-  {
-    unsigned node_coord[ FixtureType::ElemNode ][3] ;
-
-    for ( unsigned i = 0 ; i < FixtureType::ElemNode ; ++i ) {
-      const unsigned node_id = m_fixture.elem_node(ielem,i);
-      node_coord[i][0] = m_fixture.node_grid(node_id,0);
-      node_coord[i][1] = m_fixture.node_grid(node_id,1);
-      node_coord[i][2] = m_fixture.node_grid(node_id,2);
-    }
-
-    int error = 0 ;
-    for ( unsigned i = 1 ; i < FixtureType::ElemNode ; ++i ) {
-      if ( node_coord[0][0] + m_fixture.elem_node_local(i,0) != node_coord[i][0] ||
-           node_coord[0][1] + m_fixture.elem_node_local(i,1) != node_coord[i][1] ||
-           node_coord[0][2] + m_fixture.elem_node_local(i,2) != node_coord[i][2] ) {
-        error = 1 ;
-      }
-    }
-
-    if ( error ) {
-      ++update.error ;
-    }
-    else {
-      ++update.success ;
-    }
-  }
-
-  FixtureVerifyElemNodeCoord( const FixtureType & f ) : m_fixture(f) {}
-};
-
-
-template< class Device >
-void test_fixture()
-{
-  typedef Kokkos::Example::BoxElemFixture< Device , Kokkos::Example::BoxElemPart::ElemLinear > FixtureType ;
-
-  const Kokkos::Example::BoxElemPart::Decompose
-    decompose = Kokkos::Example::BoxElemPart:: DecomposeElem ; // DecomposeElem | DecomposeNode ;
-
-  const unsigned global_size = 256 ;
-  const unsigned global_nx = 400 ;
-  const unsigned global_ny = 400 ;
-  const unsigned global_nz = 400 ;
-
-  for ( unsigned my_rank = 0 ; my_rank < global_size ; ++my_rank ) {
-
-    const FixtureType fixture( decompose , global_size , my_rank , global_nx , global_ny , global_nz );
-
-    // Verify grid coordinates of element's nodes
-    
-    typename FixtureVerifyElemNodeCoord<Device>::value_type result = { 0 , 0 };
-
-    Kokkos::parallel_reduce( fixture.elem_node().extent(0) , FixtureVerifyElemNodeCoord<Device>( fixture ) , result );
-
-    if ( result.error ) {
-      std::cout << "P[" << my_rank << ":" << global_size
-                << "] Fixture elem_node_coord"
-                << " success(" << result.success << ")"
-                << " error(" << result.error << ")"
-                << std::endl ;
-    }
-
-    // Check send/recv alignment
-
-
-  }
-}
-
-
-} /* namespace Example */
-} /* namespace Kokkos */
-
-#endif /* #ifndef KOKKOS_EXAMPLE_TESTFIXTURE_HPP */
-
diff --git a/lib/kokkos/example/global_2_local_ids/CMakeLists.txt b/lib/kokkos/example/global_2_local_ids/CMakeLists.txt
deleted file mode 100644
index 9f32fe580246233f0a5358b5d505abfdeebd0d14..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/global_2_local_ids/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-SET(SOURCES "")
-
-SET(SOURCES
-  G2L_Main.cpp 
-  )
-
-TRIBITS_ADD_EXECUTABLE(
-  global_2_local_ids
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  )
-
-
diff --git a/lib/kokkos/example/global_2_local_ids/G2L.hpp b/lib/kokkos/example/global_2_local_ids/G2L.hpp
deleted file mode 100644
index 9d40bd76281091d6a2b526b05df10fa024324b40..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/global_2_local_ids/G2L.hpp
+++ /dev/null
@@ -1,266 +0,0 @@
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-
-#ifndef KOKKOS_GLOBAL_TO_LOCAL_IDS_HPP
-#define KOKKOS_GLOBAL_TO_LOCAL_IDS_HPP
-
-#include <Kokkos_Core.hpp>
-
-#include <Kokkos_UnorderedMap.hpp>
-
-#include <vector>
-#include <algorithm>
-#include <iomanip>
-
-#include <impl/Kokkos_Timer.hpp>
-
-// This test will simulate global ids
-
-namespace G2L {
-
-static const unsigned begin_id_size = 256u;
-static const unsigned end_id_size = 1u << 25;
-static const unsigned id_step = 2u;
-
-//use to help generate global ids
-union helper
-{
-  uint32_t word;
-  uint8_t byte[4];
-};
-
-
-//generate a unique global id from the local id
-template <typename Device>
-struct generate_ids
-{
-  typedef Device execution_space;
-  typedef typename execution_space::size_type size_type;
-  typedef Kokkos::View<uint32_t*,execution_space> local_id_view;
-
-  local_id_view local_2_global;
-
-  generate_ids( local_id_view & ids)
-    : local_2_global(ids)
-  {
-    Kokkos::parallel_for(local_2_global.size(), *this);
-  }
-
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(size_type i) const
-  {
-
-    helper x = {static_cast<uint32_t>(i)};
-
-    // shuffle the bytes of i to create a unique, semi-random global_id
-    x.word = ~x.word;
-
-    uint8_t tmp = x.byte[3];
-    x.byte[3] = x.byte[1];
-    x.byte[1] = tmp;
-
-    tmp = x.byte[2];
-    x.byte[2] = x.byte[0];
-    x.byte[0] = tmp;
-
-    local_2_global[i] = x.word;
-  }
-
-};
-
-// fill a map of global_id -> local_id
-template <typename Device>
-struct fill_map
-{
-  typedef Device execution_space;
-  typedef typename execution_space::size_type size_type;
-  typedef Kokkos::View<const uint32_t*,execution_space, Kokkos::MemoryRandomAccess> local_id_view;
-  typedef Kokkos::UnorderedMap<uint32_t,size_type,execution_space> global_id_view;
-
-  global_id_view global_2_local;
-  local_id_view local_2_global;
-
-  fill_map( global_id_view gIds, local_id_view lIds)
-    : global_2_local(gIds) , local_2_global(lIds)
-  {
-    Kokkos::parallel_for(local_2_global.size(), *this);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(size_type i) const
-  {
-    global_2_local.insert( local_2_global[i], i);
-  }
-
-};
-
-// check that the global id is found and that it maps to the local id
-template <typename Device>
-struct find_test
-{
-  typedef Device execution_space;
-  typedef typename execution_space::size_type size_type;
-  typedef Kokkos::View<const uint32_t*,execution_space, Kokkos::MemoryRandomAccess> local_id_view;
-  typedef Kokkos::UnorderedMap<const uint32_t, const size_type,execution_space> global_id_view;
-
-  global_id_view global_2_local;
-  local_id_view local_2_global;
-
-  typedef size_t value_type;
-
-  find_test( global_id_view gIds, local_id_view lIds, value_type & num_errors)
-    : global_2_local(gIds) , local_2_global(lIds)
-  {
-    Kokkos::parallel_reduce(local_2_global.size(), *this, num_errors);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void init(value_type & v) const
-  { v = 0; }
-
-  KOKKOS_INLINE_FUNCTION
-  void join(volatile value_type & dst, volatile value_type const & src) const
-  { dst += src; }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(size_type i, value_type & num_errors) const
-  {
-    uint32_t index = global_2_local.find( local_2_global[i] );
-
-    if (  !global_2_local.valid_at(index)
-        || global_2_local.key_at(index) != local_2_global[i]
-        || global_2_local.value_at(index) != i)
-      ++num_errors;
-  }
-
-};
-
-// run test
-template <typename Device>
-size_t test_global_to_local_ids(unsigned num_ids, unsigned capacity, unsigned num_find_iterations)
-{
-
-  typedef Device execution_space;
-  typedef typename execution_space::size_type size_type;
-
-  typedef Kokkos::View<uint32_t*,execution_space> local_id_view;
-  typedef Kokkos::UnorderedMap<uint32_t,size_type,execution_space> global_id_view;
-
-  double elasped_time = 0;
-  Kokkos::Timer timer;
-
-  local_id_view local_2_global("local_ids", num_ids);
-  global_id_view global_2_local(capacity);
-
-  int shiftw = 15;
-
-  //create
-  elasped_time = timer.seconds();
-  std::cout << std::setw(shiftw) <<  "allocate: " <<  elasped_time << std::endl;
-  timer.reset();
-
-  // generate unique ids
-  {
-    generate_ids<Device> gen(local_2_global);
-  }
-
-  // generate
-  elasped_time = timer.seconds();
-  std::cout << std::setw(shiftw) << "generate: " <<  elasped_time << std::endl;
-  timer.reset();
-
-  {
-    fill_map<Device> fill(global_2_local, local_2_global);
-  }
-
-  // fill
-  elasped_time = timer.seconds();
-  std::cout << std::setw(shiftw) << "fill: " <<  elasped_time << std::endl;
-  timer.reset();
-
-
-  size_t num_errors = global_2_local.failed_insert();
-
-  if (num_errors == 0u) {
-    for (unsigned i=0; i<num_find_iterations; ++i)
-    {
-      find_test<Device> find(global_2_local, local_2_global,num_errors);
-    }
-
-    // find
-    elasped_time = timer.seconds();
-    std::cout << std::setw(shiftw) << "lookup: " <<  elasped_time << std::endl;
-  }
-  else {
-    std::cout << "    !!! Fill Failed !!!" << std::endl;
-  }
-
-  return num_errors;
-}
-
-template <typename Device>
-size_t run_test(unsigned num_ids, unsigned num_find_iterations)
-{
-  // expect to fail
-  unsigned capacity = (num_ids*2u)/3u;
-  std::cout << " 66% of needed capacity (should fail)" << std::endl;
-  test_global_to_local_ids<Device>(num_ids, capacity, num_find_iterations);
-
-  //should not fail
-  std::cout << " 100% of needed capacity" << std::endl;
-  capacity = num_ids;
-  size_t num_errors = test_global_to_local_ids<Device>(num_ids, capacity, num_find_iterations);
-
-  //should not fail
-  std::cout << " 150% of needed capacity" << std::endl;
-  capacity = (num_ids*3u)/2u;
-  num_errors += test_global_to_local_ids<Device>(num_ids, capacity, num_find_iterations);
-
-  return num_errors;
-}
-
-
-} // namespace G2L
-
-
-#endif //KOKKOS_GLOBAL_TO_LOCAL_IDS_HPP
-
diff --git a/lib/kokkos/example/global_2_local_ids/G2L_Main.cpp b/lib/kokkos/example/global_2_local_ids/G2L_Main.cpp
deleted file mode 100644
index c8318be9fcdeae7a9dcdcf6c87aaedffa3008944..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/global_2_local_ids/G2L_Main.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include <Kokkos_Core.hpp>
-
-#include <G2L.hpp>
-
-namespace G2L {
-
-size_t run_serial(unsigned num_ids, unsigned num_find_iterations)
-{
-#ifdef KOKKOS_ENABLE_SERIAL
-  std::cout << "Serial" << std::endl;
-  return run_test<Kokkos::Serial>(num_ids,num_find_iterations);
-#else
-  return 0;
-#endif // KOKKOS_ENABLE_SERIAL
-}
-
-size_t run_threads(unsigned num_ids, unsigned num_find_iterations)
-{
-#ifdef KOKKOS_ENABLE_THREADS
-  std::cout << "Threads" << std::endl;
-  return run_test<Kokkos::Threads>(num_ids,num_find_iterations);
-#else
-  return 0;
-#endif
-}
-
-size_t run_openmp(unsigned num_ids, unsigned num_find_iterations)
-{
-#ifdef KOKKOS_ENABLE_OPENMP
-  std::cout << "OpenMP" << std::endl;
-  return run_test<Kokkos::OpenMP>(num_ids,num_find_iterations);
-#else
-  return 0;
-#endif
-}
-
-size_t run_cuda(unsigned num_ids, unsigned num_find_iterations)
-{
-#ifdef KOKKOS_ENABLE_CUDA
-  std::cout << "Cuda" << std::endl;
-  return run_test<Kokkos::Cuda>(num_ids,num_find_iterations);
-#else
-  return 0;
-#endif
-}
-
-} // namespace G2L
-
-
-int main(int argc, char *argv[])
-{
-  unsigned num_ids = 100000;
-  unsigned num_find_iterations = 1000;
-
-  if (argc == 3) {
-    num_ids = atoi(argv[1]);
-    num_find_iterations = atoi(argv[2]);
-  }
-  else if (argc != 1) {
-    std::cout << argv[0] << " num_ids num_find_iterations" << std::endl;
-    return 0;
-  }
-
-
-  // query the topology of the host
-  unsigned threads_count = 4 ;
-
-  if (Kokkos::hwloc::available()) {
-    threads_count = Kokkos::hwloc::get_available_numa_count() *
-                    Kokkos::hwloc::get_available_cores_per_numa() *
-                    Kokkos::hwloc::get_available_threads_per_core();
-
-  }
-
-  std::cout << "Threads: " << threads_count << std::endl;
-  std::cout << "Number of ids: " << num_ids << std::endl;
-  std::cout << "Number of find iterations: " << num_find_iterations << std::endl;
-
-  size_t num_errors = 0;
-
-  num_errors += G2L::run_serial(num_ids,num_find_iterations);
-
-#ifdef KOKKOS_ENABLE_CUDA
-  Kokkos::HostSpace::execution_space::initialize(threads_count);
-  Kokkos::Cuda::initialize( Kokkos::Cuda::SelectDevice(0) );
-  num_errors += G2L::run_cuda(num_ids,num_find_iterations);
-  Kokkos::Cuda::finalize();
-  Kokkos::HostSpace::execution_space::finalize();
-#endif
-
-#ifdef KOKKOS_ENABLE_THREADS
-  Kokkos::Threads::initialize( threads_count );
-  num_errors += G2L::run_threads(num_ids,num_find_iterations);
-  Kokkos::Threads::finalize();
-#endif
-
-#ifdef KOKKOS_ENABLE_OPENMP
-  int num_threads = 0;
-  #pragma omp parallel
-  {
-    #pragma omp atomic
-    ++num_threads;
-  }
-  if( num_threads > 3 ) {
-    num_threads = std::max(4, num_threads/4);
-  }
-  Kokkos::OpenMP::initialize( num_threads );
-  num_errors += G2L::run_openmp(num_ids,num_find_iterations);
-  Kokkos::OpenMP::finalize();
-#endif
-
-
-  return num_errors;
-}
-
diff --git a/lib/kokkos/example/global_2_local_ids/Makefile b/lib/kokkos/example/global_2_local_ids/Makefile
deleted file mode 100644
index 42b376ec7c5cf73537bf2d49340ce1ca963e3ad1..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/global_2_local_ids/Makefile
+++ /dev/null
@@ -1,46 +0,0 @@
-KOKKOS_PATH ?= ../..
-
-MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-SRC_DIR := $(dir $(MAKEFILE_PATH))
-
-SRC = $(wildcard $(SRC_DIR)/*.cpp)
-OBJ = $(SRC:$(SRC_DIR)/%.cpp=%.o)
-
-#SRC = $(wildcard *.cpp)
-#OBJ = $(SRC:%.cpp=%.o)
-
-default: build
-	echo "Start Build"
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-  EXE = $(addsuffix .cuda, $(shell basename $(SRC_DIR)))
-else
-  CXX = g++
-  EXE = $(addsuffix .host, $(shell basename $(SRC_DIR)))
-endif
-
-CXXFLAGS = -O3 -I$(SRC_DIR)
-LINK ?= $(CXX)
-LDFLAGS ?=
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-
-DEPFLAGS = -M
-
-LIB =
-
-
-build: $(EXE)
-
-$(EXE): $(OBJ) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LINKFLAGS) $(EXTRA_PATH) $(OBJ) $(KOKKOS_LIBS) $(LIB) -o $(EXE)
-
-clean: 
-	rm -f *.a *.o *.cuda *.host
-
-# Compilation rules
-
-%.o:$(SRC_DIR)/%.cpp $(KOKKOS_CPP_DEPENDS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
-
diff --git a/lib/kokkos/example/grow_array/CMakeLists.txt b/lib/kokkos/example/grow_array/CMakeLists.txt
deleted file mode 100644
index d9ff17049290af181d4f693cf9936627b28d087e..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/grow_array/CMakeLists.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-SET(SOURCES "")
-
-FILE(GLOB SOURCES *.cpp)
-
-TRIBITS_ADD_EXECUTABLE(
-  grow_array
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  )
-
diff --git a/lib/kokkos/example/grow_array/Makefile b/lib/kokkos/example/grow_array/Makefile
deleted file mode 100644
index 42b376ec7c5cf73537bf2d49340ce1ca963e3ad1..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/grow_array/Makefile
+++ /dev/null
@@ -1,46 +0,0 @@
-KOKKOS_PATH ?= ../..
-
-MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-SRC_DIR := $(dir $(MAKEFILE_PATH))
-
-SRC = $(wildcard $(SRC_DIR)/*.cpp)
-OBJ = $(SRC:$(SRC_DIR)/%.cpp=%.o)
-
-#SRC = $(wildcard *.cpp)
-#OBJ = $(SRC:%.cpp=%.o)
-
-default: build
-	echo "Start Build"
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-  EXE = $(addsuffix .cuda, $(shell basename $(SRC_DIR)))
-else
-  CXX = g++
-  EXE = $(addsuffix .host, $(shell basename $(SRC_DIR)))
-endif
-
-CXXFLAGS = -O3 -I$(SRC_DIR)
-LINK ?= $(CXX)
-LDFLAGS ?=
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-
-DEPFLAGS = -M
-
-LIB =
-
-
-build: $(EXE)
-
-$(EXE): $(OBJ) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LINKFLAGS) $(EXTRA_PATH) $(OBJ) $(KOKKOS_LIBS) $(LIB) -o $(EXE)
-
-clean: 
-	rm -f *.a *.o *.cuda *.host
-
-# Compilation rules
-
-%.o:$(SRC_DIR)/%.cpp $(KOKKOS_CPP_DEPENDS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
-
diff --git a/lib/kokkos/example/grow_array/grow_array.hpp b/lib/kokkos/example/grow_array/grow_array.hpp
deleted file mode 100644
index f5d0698d821cb3097c29fa0911faf2deb604e0c6..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/grow_array/grow_array.hpp
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef EXAMPLE_GROW_ARRAY
-#define EXAMPLE_GROW_ARRAY
-
-#include <cstdlib>
-
-#include <Kokkos_Core.hpp>
-
-#include <algorithm>
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#include <thrust/device_ptr.h>
-#include <thrust/sort.h>
-#endif
-
-namespace Example {
-
-//----------------------------------------------------------------------------
-
-template< class ExecSpace >
-struct SortView {
-
-  template< typename ValueType >
-  SortView( const Kokkos::View<ValueType*,ExecSpace> v , int begin , int end )
-    {
-      std::sort( v.ptr_on_device() + begin , v.ptr_on_device() + end );
-    }
-};
-
-#if defined(KOKKOS_ENABLE_CUDA)
-template<>
-struct SortView< Kokkos::Cuda > {
-  template< typename ValueType >
-  SortView( const Kokkos::View<ValueType*,Kokkos::Cuda> v , int begin , int end )
-    {
-      thrust::sort( thrust::device_ptr<ValueType>( v.ptr_on_device() + begin )
-                  , thrust::device_ptr<ValueType>( v.ptr_on_device() + end ) );
-    }
-};
-#endif
-
-
-
-//----------------------------------------------------------------------------
-
-template< class ExecSpace >
-struct GrowArrayFunctor {
-
-  typedef ExecSpace  execution_space ;
-
-  enum { SHIFT = sizeof(int) == 8 ? 6 : 5 }; // 8 or 4 byte int
-  enum { MASK  = ( 1 << SHIFT ) - 1 };
-
-  const Kokkos::View<int*,ExecSpace>  m_search_flags ; // bit flags for values to append
-  const Kokkos::View<int*,ExecSpace>  m_search_array ; // array to append values
-  const Kokkos::View<int,ExecSpace>   m_search_count ; // offset
-  const int m_search_total ;
-  const int m_search_team_chunk ;
-
-  GrowArrayFunctor( int array_length , int search_length , int print = 1 )
-    : m_search_flags( "flags" , ( search_length + MASK ) >> SHIFT ) // One bit per search entry
-    , m_search_array( "array" , array_length )
-    , m_search_count( "count" )
-    , m_search_total( search_length )
-    , m_search_team_chunk( 2048 )
-    {}
-
-  KOKKOS_INLINE_FUNCTION
-  bool flag_is_set( const int index ) const
-    {
-      // 64 or 32 bit integer:
-
-      const int j = index >> SHIFT ; // which integer flag
-      const int k = 1 << ( index & MASK ); // which bit in that integer
-      const int s = ( j < int(m_search_flags.dimension_0()) ) && ( 0 != ( m_search_flags(j) & k ) );
-
-      return s ;
-    }
-
-  typedef typename Kokkos::TeamPolicy<ExecSpace>::member_type team_member ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const team_member & member ) const
-    {
-      enum { LOCAL_BUFFER_LENGTH = 16 };
-
-      int local_buffer[ LOCAL_BUFFER_LENGTH ] ;
-      int local_count = 0 ;
-
-      // Each team searches 'm_search_team_chunk' indices.
-      // The threads of a team must iterate together because all
-      // threads in the team must call 'team_scan' to prevent deadlock in the team.
-
-            int search_team_begin = member.league_rank() * m_search_team_chunk ;
-      const int search_team_end   = search_team_begin + m_search_team_chunk ;
-
-      int k = 0 ;
-
-      while ( search_team_begin < search_team_end ) {
-
-        // This iteration searches [ search_team_begin .. search_team_begin + member.team_size() ]
-        const int thread_search_index = search_team_begin + member.team_rank();
-
-        // If this thread's search index is in the range
-        // and the flag is set, push into this thread's local buffer.
-        if ( thread_search_index < m_search_total && flag_is_set(thread_search_index) ) {
-          local_buffer[ local_count ] = thread_search_index ;
-          ++local_count ;
-        }
-
-        // Move the team's search range forward
-        search_team_begin += member.team_size(); // Striding team by team size
-
-        // Count number of times a thread's buffer might have grown:
-        ++k ;
-
-        // Write buffer if end of search or a thread might have filled its buffer.
-        if ( k == LOCAL_BUFFER_LENGTH /* A thread in my team might have filled its buffer */ ||
-             ! ( search_team_begin < search_team_end ) /* Team is at the end of its search */ ) {
-
-          // Team's exclusive scan of threads' contributions, with global offset.
-          // This thread writes its buffer into [ team_offset .. team_offset + local_count )
-          const int team_offset = member.team_scan( local_count , & *m_search_count );
-
-          // Copy locally buffered entries into global array:
-          for ( int i = 0 ; i < local_count ; ++i ) {
-            m_search_array( team_offset + i ) = local_buffer[i] ;
-          }
-
-          k = 0 ;
-          local_count = 0 ;
-        }
-      }
-    }
-};
-
-
-template< class ExecSpace >
-void grow_array( int array_length , int search_length , int print = 1 )
-{
-  typedef GrowArrayFunctor< ExecSpace > FunctorType ;
-
-  FunctorType functor( array_length , search_length , print );
-
-  typename Kokkos::View<int,ExecSpace>::HostMirror  count = Kokkos::create_mirror_view( functor.m_search_count );
-  typename Kokkos::View<int*,ExecSpace>::HostMirror flags = Kokkos::create_mirror_view( functor.m_search_flags );
-
-  // Set at most 'array_length' random bits over the search length.
-  for ( int i = 0 ; i < array_length ; ++i ) {
-    // 'lrand48()' generates random number between [0..2^31]
-    // index = ( lrand48() * search_length ) / ( 2^31 )
-    const long int index = ( lrand48() * search_length ) >> 31 ;
-    // set the bit within the flags:
-    flags( index >> FunctorType::SHIFT ) |= ( 1 << ( index & FunctorType::MASK ) );
-  }
-
-  Kokkos::deep_copy( functor.m_search_flags , flags );
-
-  // Each team works on 'functor.m_search_team_chunk' span of the search_length
-  Kokkos::TeamPolicy< ExecSpace >
-    work( /* #teams */ ( search_length + functor.m_search_team_chunk - 1 ) / functor.m_search_team_chunk
-        , /* threads/team */ Kokkos::TeamPolicy< ExecSpace >::team_size_max( functor ) );
-
-  // Fill array:
-  Kokkos::parallel_for( work , functor );
-
-  // How much was filled:
-  Kokkos::deep_copy( count , functor.m_search_count );
-
-  // Sort array:
-  SortView< ExecSpace >( functor.m_search_array , 0 , *count );
-
-  // Mirror the results:
-  typename Kokkos::View<int*,ExecSpace>::HostMirror results = Kokkos::create_mirror_view( functor.m_search_array );
-  Kokkos::deep_copy( results , functor.m_search_array );
-
-  // Verify results:
-  int result_error_count = 0 ;
-  int flags_error_count = 0 ;
-  for ( int i = 0 ; i < *count ; ++i ) {
-    const int index = results(i);
-    const int entry = index >> FunctorType::SHIFT ;
-    const int bit   = 1 << ( index & FunctorType::MASK );
-    const bool flag = 0 != ( flags( entry ) & bit );
-    if ( ! flag ) {
-      if ( print ) std::cerr << "result( " << i << " : " << index << " )";
-      ++result_error_count ;
-    }
-    flags( entry ) &= ~bit ; // Clear that verified bit
-  }
-
-  for ( int i = 0 ; i < int(flags.dimension_0()) ; ++i ) {
-    // If any uncleared bits then an error
-    if ( flags(i) ) {
-      if ( print ) std::cerr << "flags( " << i << " : " << flags(i) << " )" ;
-      ++flags_error_count ;
-    }
-  }
-
-  if ( result_error_count || flags_error_count ) {
-    std::cerr << std::endl << "Example::GrowArrayFunctor( " << array_length
-              << " , " << search_length
-              << " ) result_error_count( " << result_error_count << " )"
-              << " ) flags_error_count( " << flags_error_count << " )"
-              << std::endl ;
-  }
-}
-
-
-} // namespace Example
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef EXAMPLE_GROW_ARRAY */
-
diff --git a/lib/kokkos/example/grow_array/main.cpp b/lib/kokkos/example/grow_array/main.cpp
deleted file mode 100644
index 598729459a4c3e3e2140488d0ce08c9894a61703..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/grow_array/main.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include <iostream>
-#include <sstream>
-
-#include <Kokkos_Core.hpp>
-
-#include <grow_array.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-int main( int argc , char ** argv )
-{
-  int num_threads = 4 ;
-  int use_numa = 1 ;
-  int use_core = 1 ;
-  int length_array  = 1000000 ;
-  int span_values = 100000000 ;
-
-
-  if ( Kokkos::hwloc::available() ) {
-    use_numa = Kokkos::hwloc::get_available_numa_count();
-    use_core = Kokkos::hwloc::get_available_cores_per_numa() - 1 ;
-    num_threads = use_numa * use_core * Kokkos::hwloc::get_available_threads_per_core();
-  }
-
-#if defined( KOKKOS_ENABLE_SERIAL )
-  {
-    std::cout << "Kokkos::Serial" << std::endl ;
-    // The Serial device accepts these arguments, though it may ignore them.
-    Kokkos::Serial::initialize( num_threads , use_numa , use_core );
-    Example::grow_array< Kokkos::Serial >( length_array , span_values );
-    Kokkos::Serial::finalize ();
-  }
-#endif // defined( KOKKOS_ENABLE_SERIAL )
-
-#if defined( KOKKOS_ENABLE_THREADS )
-  {
-    std::cout << "Kokkos::Threads" << std::endl ;
-    Kokkos::Threads::initialize( num_threads , use_numa , use_core );
-    Example::grow_array< Kokkos::Threads >( length_array , span_values );
-    Kokkos::Threads::finalize();
-  }
-#endif
-
-#if defined( KOKKOS_ENABLE_OPENMP )
-  {
-    std::cout << "Kokkos::OpenMP" << std::endl ;
-    Kokkos::OpenMP::initialize();
-    Example::grow_array< Kokkos::OpenMP >( length_array , span_values );
-    Kokkos::OpenMP::finalize();
-  }
-#endif
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  {
-    std::cout << "Kokkos::Cuda" << std::endl ;
-    Kokkos::HostSpace::execution_space::initialize(1);
-    Kokkos::Cuda::initialize();
-    Example::grow_array< Kokkos::Cuda >( length_array , span_values );
-    Kokkos::Cuda::finalize();
-    Kokkos::HostSpace::execution_space::finalize();
-  }
-#endif
-
-  return 0 ;
-}
-
diff --git a/lib/kokkos/example/make_buildlink/main.cpp b/lib/kokkos/example/make_buildlink/main.cpp
index c90def8d4f6e7a1f920ebc56da7ef78b488b0cb7..d963002034ec2d3b3ad3d521625386188f9448b0 100644
--- a/lib/kokkos/example/make_buildlink/main.cpp
+++ b/lib/kokkos/example/make_buildlink/main.cpp
@@ -1,14 +1,13 @@
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 
 int main(int argc, char* argv[]) {
-  Kokkos::initialize(argc,argv);
+  Kokkos::initialize(argc, argv);
   {
-     int N = (argc>1) ? atoi(argv[1]) : 10000;
-     int M = (argc>2) ? atoi(argv[2]) : 10000;
-     int R = (argc>3) ? atoi(argv[3]) : 10;
-     
-     printf("Called with: %i %i %i\n",N,M,R);    
+    int N = (argc > 1) ? atoi(argv[1]) : 10000;
+    int M = (argc > 2) ? atoi(argv[2]) : 10000;
+    int R = (argc > 3) ? atoi(argv[3]) : 10;
 
+    printf("Called with: %i %i %i\n", N, M, R);
   }
   Kokkos::finalize();
 }
diff --git a/lib/kokkos/example/md_skeleton/CMakeLists.txt b/lib/kokkos/example/md_skeleton/CMakeLists.txt
deleted file mode 100644
index 28412c37847deb211db5b6256a78a0e904d8dcaf..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-SET(SOURCES "")
-SET(LIBRARIES "")
-
-FILE(GLOB SOURCES *.cpp )
-
-TRIBITS_ADD_EXECUTABLE(
-  md_skeleton 
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  DEPLIBS ${LIBRARIES}
-  )
-
diff --git a/lib/kokkos/example/md_skeleton/Makefile b/lib/kokkos/example/md_skeleton/Makefile
deleted file mode 100644
index 42b376ec7c5cf73537bf2d49340ce1ca963e3ad1..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/Makefile
+++ /dev/null
@@ -1,46 +0,0 @@
-KOKKOS_PATH ?= ../..
-
-MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-SRC_DIR := $(dir $(MAKEFILE_PATH))
-
-SRC = $(wildcard $(SRC_DIR)/*.cpp)
-OBJ = $(SRC:$(SRC_DIR)/%.cpp=%.o)
-
-#SRC = $(wildcard *.cpp)
-#OBJ = $(SRC:%.cpp=%.o)
-
-default: build
-	echo "Start Build"
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-  EXE = $(addsuffix .cuda, $(shell basename $(SRC_DIR)))
-else
-  CXX = g++
-  EXE = $(addsuffix .host, $(shell basename $(SRC_DIR)))
-endif
-
-CXXFLAGS = -O3 -I$(SRC_DIR)
-LINK ?= $(CXX)
-LDFLAGS ?=
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-
-DEPFLAGS = -M
-
-LIB =
-
-
-build: $(EXE)
-
-$(EXE): $(OBJ) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LINKFLAGS) $(EXTRA_PATH) $(OBJ) $(KOKKOS_LIBS) $(LIB) -o $(EXE)
-
-clean: 
-	rm -f *.a *.o *.cuda *.host
-
-# Compilation rules
-
-%.o:$(SRC_DIR)/%.cpp $(KOKKOS_CPP_DEPENDS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
-
diff --git a/lib/kokkos/example/md_skeleton/README b/lib/kokkos/example/md_skeleton/README
deleted file mode 100644
index 1ce682b0a6ec64175587d70c593e39ba8d304d75..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/README
+++ /dev/null
@@ -1,3 +0,0 @@
-To build this example on a 2012-model Macbook Pro with NVIDIA Kepler GPU:
-
-./build.cuda_std g++_osx cuda_osx 30 opt
diff --git a/lib/kokkos/example/md_skeleton/force.cpp b/lib/kokkos/example/md_skeleton/force.cpp
deleted file mode 100644
index beb2dc8929d5e5d426156617cfcac7d7be88c070..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/force.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include <system.h>
-#include <cstdio>
-
-
-/* Simple Lennard Jones Force Kernel using neighborlists
- * Calculates for every pair of atoms (i,j) with distance smaller r_cut
- * f_ij = 4*epsilon * ( (sigma/r_ij)^12 - (sigma/r_ij)^6 )
- * where r_ij is the distance of atoms (i,j).
- * The force on atom i is the sum over f_ij:
- * f_i = sum_j (f_ij)
- * Neighborlists are used in order to pre calculate which atoms j are
- * close enough to i to be able to contribute. By choosing a larger neighbor
- * cutoff then the force cutoff, the neighbor list can be reused several times
- * (typically 10 - 100).
- */
-
-struct ForceFunctor {
-
-  typedef t_x_array::execution_space execution_space; //Device Type for running the kernel
-  typedef double2 value_type; // When energy calculation is requested return energy, and virial
-
-  t_x_array_randomread x;       //atom positions
-  t_f_array f;                  //atom forces
-  t_int_1d_const numneigh;      //number of neighbors per atom
-  t_neighbors_const neighbors;  //neighborlist
-  double cutforcesq;            //force cutoff
-  double epsilon;               //Potential parameter
-  double sigma6;                //Potential parameter
-
-
-  ForceFunctor(System s) {
-    x = s.d_x;
-    f = s.f;
-    numneigh = s.numneigh;
-    neighbors = s.neighbors;
-    cutforcesq = s.force_cutsq;
-    epsilon = 1.0;
-    sigma6 = 1.0;
-  }
-
-  /* Operator for not calculating energy and virial */
-
-  KOKKOS_INLINE_FUNCTION
-  void operator() (const int &i) const {
-    force<0>(i);
-  }
-
-  /* Operator for calculating energy and virial */
-
-  KOKKOS_INLINE_FUNCTION
-  void operator() (const int &i, double2 &energy_virial) const {
-    double2 ev = force<1>(i);
-    energy_virial.x += ev.x;
-    energy_virial.y += ev.y;
-  }
-
-  template<int EVFLAG>
-  KOKKOS_INLINE_FUNCTION
-  double2 force(const int &i) const
-  {
-    const int numneighs = numneigh[i];
-    const double xtmp = x(i, 0);
-    const double ytmp = x(i, 1);
-    const double ztmp = x(i, 2);
-    double fix = 0;
-    double fiy = 0;
-    double fiz = 0;
-    double energy = 0;
-    double virial = 0;
-
-    //pragma simd forces vectorization (ignoring the performance objections of the compiler)
-    //give hint to compiler that fix, fiy and fiz are used for reduction only
-
-  #ifdef USE_SIMD
-    #pragma simd reduction (+: fix,fiy,fiz,energy,virial)
-  #endif
-    for(int k = 0; k < numneighs; k++) {
-      const int j = neighbors(i, k);
-      const double delx = xtmp - x(j, 0);
-      const double dely = ytmp - x(j, 1);
-      const double delz = ztmp - x(j, 2);
-      const double rsq = delx * delx + dely * dely + delz * delz;
-
-      //if(i==0) printf("%i %i %lf %lf\n",i,j,rsq,cutforcesq);
-      if(rsq < cutforcesq) {
-        const double sr2 = 1.0 / rsq;
-        const double sr6 = sr2 * sr2 * sr2  * sigma6;
-        const double force = 48.0 * sr6 * (sr6 - 0.5) * sr2 * epsilon;
-        fix += delx * force;
-        fiy += dely * force;
-        fiz += delz * force;
-
-        if(EVFLAG) {
-          energy += sr6 * (sr6 - 1.0) * epsilon;
-          virial += delx * delx * force + dely * dely * force + delz * delz * force;
-        }
-      }
-    }
-
-    f(i, 0) += fix;
-    f(i, 1) += fiy;
-    f(i, 2) += fiz;
-
-    double2 energy_virial ;
-    energy_virial.x = 4.0 * energy ;
-    energy_virial.y = 0.5 * virial ;
-    return energy_virial;
-  }
-
-  /* init and join functions when doing the reduction to obtain energy and virial */
-
-  KOKKOS_FUNCTION
-  static void init(volatile value_type &update) {
-    update.x = update.y = 0;
-  }
-  KOKKOS_FUNCTION
-  static void join(volatile value_type &update ,
-                   const volatile value_type &source) {
-    update.x += source.x ;
-    update.y += source.y ;
-  }
-
-};
-
-
-/* Calling function */
-
-double2 force(System &s,int evflag) {
-
-  ForceFunctor f(s);
-
-  double2 ev ; ev.x = 0 ; ev.y = 0 ;
-  if(!evflag)
-    Kokkos::parallel_for(s.nlocal,f);
-  else
-    Kokkos::parallel_reduce(s.nlocal,f,ev);
-
-  execution_space().fence();
-  return ev;
-}
-
diff --git a/lib/kokkos/example/md_skeleton/main.cpp b/lib/kokkos/example/md_skeleton/main.cpp
deleted file mode 100644
index fe783b39cb75e0302cf723d368952b318ae33dda..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/main.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include <cstdio>
-#include <cstring>
-#include <cstdlib>
-#include "system.h"
-
-int create_system(System &system, int nx, int ny, int nz, double rho);
-int neigh_setup(System &system);
-int neigh_build(System &system);
-double2 force(System &system,int evflag);
-
-/* simple MD Skeleton which
- *   - constructs a simple FCC lattice,
- *   - computes a neighborlist
- *   - compute LJ-Force kernel a number of times
- */
-
-int main(int argc, char** argv) {
-
-  printf("Running MD Skeleton\n");
-  /* Thread numbers for Host */
-
-  int num_threads = 1;
-  int teams = 1;
-  int device = 0; // Default device for GPU runs
-
-  /* avoid unused variable warnings */
-  (void)num_threads;
-  (void)teams;
-  (void)device;
-
-  /* Default value for number of force calculations */
-
-  int iter = 100;
-
-  /* Default value for system size (4*nx*ny*nz atoms)
-   * nx, ny and nz are set to system_size if not specified on commandline */
-
-  int system_size = 20;
-  int nx = -1;
-  int ny = -1;
-  int nz = -1;
-
-  int neighbor_size = 1; // Default bin size for neighbor list construction
-
-  double rho = 0.8442; // Number density of the system
-  double delta = 0; // Scaling factor for random offsets of atom positions
-
-
-  /* read in command-line arguments */
-
-  for(int i = 0; i < argc; i++) {
-    if((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "--num_threads") == 0)) {
-      num_threads = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "--teams") == 0)) {
-      teams = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-d") == 0) || (strcmp(argv[i], "--device") == 0))  {
-      device = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "--delta") == 0)) {
-      delta = atof(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-i") == 0) || (strcmp(argv[i], "--iter") == 0))  {
-      iter = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-rho") == 0)) {
-      rho = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-s") == 0) || (strcmp(argv[i], "--size") == 0)) {
-      system_size = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-nx") == 0)) {
-      nx = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-ny") == 0)) {
-      ny = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-nz") == 0)) {
-      nz = atoi(argv[++i]);
-      continue;
-    }
-
-    if((strcmp(argv[i], "-b") == 0) || (strcmp(argv[i], "--neigh_bins") == 0))  {
-      neighbor_size = atoi(argv[++i]);
-      continue;
-    }
-  }
-
-  if( nx < 0 ) nx = system_size;
-  if( ny < 0 ) ny = system_size;
-  if( nz < 0 ) nz = system_size;
-
-  printf("-> Init Device\n");
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  Kokkos::HostSpace::execution_space::initialize(teams*num_threads);
-  Kokkos::Cuda::SelectDevice select_device(device);
-  Kokkos::Cuda::initialize(select_device);
-#elif defined( KOKKOS_ENABLE_OPENMP )
-  Kokkos::OpenMP::initialize(teams*num_threads);
-#elif defined( KOKKOS_ENABLE_THREADS )
-  Kokkos::Threads::initialize(teams*num_threads);
-#endif
-
-  System system;
-  system.neigh_cut = 2.8;
-  system.force_cut = 2.5;
-  system.force_cutsq = system.force_cut*system.force_cut;
-  system.delta = delta;
-
-  printf("-> Build system\n");
-  create_system(system,nx,ny,nz,rho);
-
-  printf("-> Created %i atoms and %i ghost atoms\n",system.nlocal,system.nghost);
-
-  system.nbinx = system.box.xprd/neighbor_size+1;
-  system.nbiny = system.box.yprd/neighbor_size+1;
-  system.nbinz = system.box.zprd/neighbor_size+1;
-
-
-  printf("-> Building Neighborlist\n");
-
-  neigh_setup(system);
-  neigh_build(system);
-
-  double2 ev = force(system,1);
-
-  printf("-> Calculate Energy: %f Virial: %f\n",ev.x,ev.y);
-
-  printf("-> Running %i force calculations\n",iter);
-
-  Kokkos::Timer timer;
-
-  for(int i=0;i<iter;i++) {
-    force(system,0);
-  }
-
-
-  double time = timer.seconds();
-  printf("Time: %e s for %i iterations with %i atoms\n",time,iter,system.nlocal);
-
-  execution_space::finalize();
-}
diff --git a/lib/kokkos/example/md_skeleton/neighbor.cpp b/lib/kokkos/example/md_skeleton/neighbor.cpp
deleted file mode 100644
index 60e33d31f79fae49f683432556867191d010d43a..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/neighbor.cpp
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <system.h>
-#include <cstdio>
-#include <Kokkos_Core.hpp>
-
-#define SMALL 1.0e-6
-#define FACTOR 0.999
-
-/* BinningFunctor puts atoms into bins of the simulation box
- * Neighborlists are then created by checking only distances of atoms
- * in adjacent bins. That makes neighborlist construction a O(N) operation.
- */
-
-struct BinningFunctor {
-  typedef t_int_2d::execution_space execution_space;
-
-  System s;
-
-  int atoms_per_bin;
-
-  BinningFunctor(System _s): s(_s) {
-    atoms_per_bin = s.bins.dimension_1();
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator() (const int &i) const
-  {
-    const int ibin = coord2bin(s.d_x(i, 0), s.d_x(i, 1), s.d_x(i, 2));
-
-    const int ac = Kokkos::atomic_fetch_add(&s.bincount[ibin], 1);
-
-    if(ac < atoms_per_bin) {
-      s.bins(ibin, ac) = i;
-    } else if(s.d_resize(0) < ac) {
-      s.d_resize(0) = ac;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  int coord2bin(double x, double y, double z) const
-  {
-    int ix, iy, iz;
-
-    if(x >= s.box.xprd)
-      ix = (int)((x - s.box.xprd) * s.bininvx) + s.nbinx - s.mbinxlo;
-    else if(x >= 0.0)
-      ix = (int)(x * s.bininvx) - s.mbinxlo;
-    else
-      ix = (int)(x * s.bininvx) - s.mbinxlo - 1;
-
-    if(y >= s.box.yprd)
-      iy = (int)((y - s.box.yprd) * s.bininvy) + s.nbiny - s.mbinylo;
-    else if(y >= 0.0)
-      iy = (int)(y * s.bininvy) - s.mbinylo;
-    else
-      iy = (int)(y * s.bininvy) - s.mbinylo - 1;
-
-    if(z >= s.box.zprd)
-      iz = (int)((z - s.box.zprd) * s.bininvz) + s.nbinz - s.mbinzlo;
-    else if(z >= 0.0)
-      iz = (int)(z * s.bininvz) - s.mbinzlo;
-    else
-      iz = (int)(z * s.bininvz) - s.mbinzlo - 1;
-
-    return (iz * s.mbiny * s.mbinx + iy * s.mbinx + ix + 1);
-  }
-};
-
-/* Build the actual neighborlist*/
-
-struct BuildFunctor {
-
-  typedef t_int_2d::execution_space execution_space;
-
-  System s;
-
-  int maxneighs;
-  BuildFunctor(System _s): s(_s) {
-    maxneighs = s.neighbors.dimension_1();
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator() (const int &i) const
-  {
-    int n = 0;
-
-    const t_int_1d_const_um bincount_c = s.bincount;
-
-    const double xtmp = s.d_x(i, 0);
-    const double ytmp = s.d_x(i, 1);
-    const double ztmp = s.d_x(i, 2);
-
-    const int ibin = coord2bin(xtmp, ytmp, ztmp);
-
-    // loop over all bins in neighborhood (includes ibin)
-    for(int k = 0; k < s.nstencil; k++) {
-      const int jbin = ibin + s.d_stencil[k];
-
-      // get subview of jbin
-      const t_int_1d_const_um loc_bin =
-          Kokkos::subview(s.bins,jbin,Kokkos::ALL());
-
-      if(ibin == jbin)
-        for(int m = 0; m < bincount_c[jbin]; m++) {
-          const int j = loc_bin[m];
-
-          //for same bin as atom i skip j if i==j
-          if (j == i) continue;
-
-          const double delx = xtmp - s.d_x(j, 0);
-          const double dely = ytmp - s.d_x(j, 1);
-          const double delz = ztmp - s.d_x(j, 2);
-          const double rsq = delx * delx + dely * dely + delz * delz;
-
-          if(rsq <= s.neigh_cutsq && n<maxneighs) s.neighbors(i,n++) = j;
-        }
-      else {
-        for(int m = 0; m < bincount_c[jbin]; m++) {
-          const int j = loc_bin[m];
-
-          const double delx = xtmp - s.d_x(j, 0);
-          const double dely = ytmp - s.d_x(j, 1);
-          const double delz = ztmp - s.d_x(j, 2);
-          const double rsq = delx * delx + dely * dely + delz * delz;
-
-          if(rsq <= s.neigh_cutsq && n<maxneighs) s.neighbors(i,n++) = j;
-        }
-      }
-    }
-
-    s.numneigh[i] = n;
-
-    if(n >= maxneighs) {
-      if(n >= s.d_resize(0)) s.d_resize(0) = n;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  int coord2bin(double x, double y, double z) const
-  {
-    int ix, iy, iz;
-
-    if(x >= s.box.xprd)
-      ix = (int)((x - s.box.xprd) * s.bininvx) + s.nbinx - s.mbinxlo;
-    else if(x >= 0.0)
-      ix = (int)(x * s.bininvx) - s.mbinxlo;
-    else
-      ix = (int)(x * s.bininvx) - s.mbinxlo - 1;
-
-    if(y >= s.box.yprd)
-      iy = (int)((y - s.box.yprd) * s.bininvy) + s.nbiny - s.mbinylo;
-    else if(y >= 0.0)
-      iy = (int)(y * s.bininvy) - s.mbinylo;
-    else
-      iy = (int)(y * s.bininvy) - s.mbinylo - 1;
-
-    if(z >= s.box.zprd)
-      iz = (int)((z - s.box.zprd) * s.bininvz) + s.nbinz - s.mbinzlo;
-    else if(z >= 0.0)
-      iz = (int)(z * s.bininvz) - s.mbinzlo;
-    else
-      iz = (int)(z * s.bininvz) - s.mbinzlo - 1;
-
-    return (iz * s.mbiny * s.mbinx + iy * s.mbinx + ix + 1);
-  }
-};
-
-/* Reset an array to zero */
-
-struct MemsetZeroFunctor {
-  typedef t_x_array::execution_space  execution_space ;
-  void* ptr;
-  KOKKOS_INLINE_FUNCTION void operator()(const int i) const {
-    ((int*)ptr)[i] = 0;
-  }
-};
-
-/* Calculate distance of two bins */
-
-double bindist(System &s, int i, int j, int k)
-{
-  double delx, dely, delz;
-
-  if(i > 0)
-    delx = (i - 1) * s.binsizex;
-  else if(i == 0)
-    delx = 0.0;
-  else
-    delx = (i + 1) * s.binsizex;
-
-  if(j > 0)
-    dely = (j - 1) * s.binsizey;
-  else if(j == 0)
-    dely = 0.0;
-  else
-    dely = (j + 1) * s.binsizey;
-
-  if(k > 0)
-    delz = (k - 1) * s.binsizez;
-  else if(k == 0)
-    delz = 0.0;
-  else
-    delz = (k + 1) * s.binsizez;
-
-  return (delx * delx + dely * dely + delz * delz);
-}
-
-/* Setup the neighborlist construction
- * Determine binsizes, a stencil for defining adjacency, etc.
- */
-
-void neigh_setup(System &s) {
-
-  s.neigh_cutsq = s.neigh_cut * s.neigh_cut;
-
-  /*
-  c bins must evenly divide into box size,
-  c   becoming larger than cutneigh if necessary
-  c binsize = 1/2 of cutoff is near optimal
-
-  if (flag == 0) {
-    nbinx = 2.0 * xprd / cutneigh;
-    nbiny = 2.0 * yprd / cutneigh;
-    nbinz = 2.0 * zprd / cutneigh;
-    if (nbinx == 0) nbinx = 1;
-    if (nbiny == 0) nbiny = 1;
-    if (nbinz == 0) nbinz = 1;
-  }
-  */
-
-  s.binsizex = s.box.xprd / s.nbinx;
-  s.binsizey = s.box.yprd / s.nbiny;
-  s.binsizez = s.box.zprd / s.nbinz;
-  s.bininvx = 1.0 / s.binsizex;
-  s.bininvy = 1.0 / s.binsizey;
-  s.bininvz = 1.0 / s.binsizez;
-
-  double coord = s.box.xlo - s.neigh_cut - SMALL * s.box.xprd;
-  s.mbinxlo = static_cast<int>(coord * s.bininvx);
-
-  if(coord < 0.0) s.mbinxlo = s.mbinxlo - 1;
-
-  coord = s.box.xhi + s.neigh_cut + SMALL * s.box.xprd;
-  int mbinxhi = static_cast<int>(coord * s.bininvx);
-
-  coord = s.box.ylo - s.neigh_cut - SMALL * s.box.yprd;
-  s.mbinylo = static_cast<int>(coord * s.bininvy);
-
-  if(coord < 0.0) s.mbinylo = s.mbinylo - 1;
-
-  coord = s.box.yhi + s.neigh_cut + SMALL * s.box.yprd;
-  int mbinyhi = static_cast<int>(coord * s.bininvy);
-
-  coord = s.box.zlo - s.neigh_cut - SMALL * s.box.zprd;
-  s.mbinzlo = static_cast<int>(coord * s.bininvz);
-
-  if(coord < 0.0) s.mbinzlo = s.mbinzlo - 1;
-
-  coord = s.box.zhi + s.neigh_cut + SMALL * s.box.zprd;
-  int mbinzhi = static_cast<int>(coord * s.bininvz);
-
-  /* extend bins by 1 in each direction to insure stencil coverage */
-
-  s.mbinxlo = s.mbinxlo - 1;
-  mbinxhi = mbinxhi + 1;
-  s.mbinx = mbinxhi - s.mbinxlo + 1;
-
-  s.mbinylo = s.mbinylo - 1;
-  mbinyhi = mbinyhi + 1;
-  s.mbiny = mbinyhi - s.mbinylo + 1;
-
-  s.mbinzlo = s.mbinzlo - 1;
-  mbinzhi = mbinzhi + 1;
-  s.mbinz = mbinzhi - s.mbinzlo + 1;
-
-  /*
-  compute bin stencil of all bins whose closest corner to central bin
-  is within neighbor cutoff
-  for partial Newton (newton = 0),
-  stencil is all surrounding bins including self
-  for full Newton (newton = 1),
-  stencil is bins to the "upper right" of central bin, does NOT include self
-  next(xyz) = how far the stencil could possibly extend
-  factor < 1.0 for special case of LJ benchmark so code will create
-  correct-size stencil when there are 3 bins for every 5 lattice spacings
-  */
-
-  int nextx = static_cast<int>(s.neigh_cut * s.bininvx);
-
-  if(nextx * s.binsizex < FACTOR * s.neigh_cut) nextx++;
-
-  int nexty = static_cast<int>(s.neigh_cut * s.bininvy);
-
-  if(nexty * s.binsizey < FACTOR * s.neigh_cut) nexty++;
-
-  int nextz = static_cast<int>(s.neigh_cut * s.bininvz);
-
-  if(nextz * s.binsizez < FACTOR * s.neigh_cut) nextz++;
-
-  int nmax = (2 * nextz + 1) * (2 * nexty + 1) * (2 * nextx + 1);
-  s.d_stencil = t_int_1d("stencil", nmax);
-  s.h_stencil = Kokkos::create_mirror_view(s.d_stencil);
-  s.nstencil = 0;
-  int kstart = -nextz;
-
-  for(int k = kstart; k <= nextz; k++) {
-    for(int j = -nexty; j <= nexty; j++) {
-      for(int i = -nextx; i <= nextx; i++) {
-        if(bindist(s,i, j, k) < s.neigh_cutsq) {
-          s.h_stencil(s.nstencil++) = k * s.mbiny * s.mbinx + j * s.mbinx + i;
-        }
-      }
-    }
-  }
-
-  /* Allocate neighbor arrays */
-
-  Kokkos::deep_copy(s.d_stencil, s.h_stencil);
-  s.mbins = s.mbinx * s.mbiny * s.mbinz;
-  s.bincount = t_int_1d("bincount", s.mbins);
-  s.bins = t_int_2d("bins", s.mbins, 8);
-
-  s.neighbors = t_neighbors("neighbors",s.natoms,80);
-  s.numneigh = t_int_1d("numneigh",s.natoms);
-  s.d_resize = t_int_scalar("resize");
-  s.h_resize = Kokkos::create_mirror_view(s.d_resize);
-}
-
-
-/* Build the neighborlist
- * This is a try and rerun algorithm for handling the case where the bins array
- * and the neighbors array are not big enough. So if one is too small, it will
- * reallocate and rerun the binnind algorithm or the neighborlist construction.
- */
-
-void neigh_build(System &s) {
-
-  /* Binning of atoms */
-
-  s.h_resize(0) = 1;
-
-  while(s.h_resize(0) > 0) {
-    s.h_resize(0) = 0;
-    Kokkos::deep_copy(s.d_resize, s.h_resize);
-
-    MemsetZeroFunctor f_zero;
-    f_zero.ptr = (void*) s.bincount.ptr_on_device();
-    Kokkos::parallel_for(s.mbins, f_zero);
-    execution_space().fence();
-
-    BinningFunctor f(s);
-    Kokkos::parallel_for(s.natoms, f);
-    execution_space().fence();
-
-    /* Check if bins was large enough, if nor reallocated and rerun */
-
-    deep_copy(s.h_resize, s.d_resize);
-
-    if(s.h_resize(0)) {
-      int atoms_per_bin = s.h_resize(0)+2;
-      s.bins = t_int_2d("bins", s.mbins, atoms_per_bin);
-    }
-  }
-
-  /* Neighborlist construction */
-
-  s.h_resize(0) = 1;
-
-  while(s.h_resize(0)) {
-    s.h_resize(0) = 0;
-
-    Kokkos::deep_copy(s.d_resize, s.h_resize);
-
-    BuildFunctor f(s);
-    Kokkos::parallel_for(s.nlocal, f);
-
-    execution_space().fence();
-
-    /* Check if neighbors was large enough, if nor reallocated and rerun */
-
-    deep_copy(s.h_resize, s.d_resize);
-
-    if(s.h_resize(0)) {
-      int maxneighs = s.h_resize(0) * 1.2;
-      s.neighbors = t_neighbors("neighbors", s.natoms, maxneighs);
-    }
-  }
-}
diff --git a/lib/kokkos/example/md_skeleton/setup.cpp b/lib/kokkos/example/md_skeleton/setup.cpp
deleted file mode 100644
index 52defbc4694c486a8fe2fce1aff47bdb12a0e649..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/setup.cpp
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <system.h>
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-/* initialize atoms on fcc lattice in parallel fashion */
-
-#define MAX(a,b) (a>b?a:b)
-#define MIN(a,b) (a<b?a:b)
-
-
-int create_system(System &system, int nx, int ny, int nz, double rho)
-{
-  /* Box Setup */
-
-  double lattice = pow((4.0 / rho), (1.0 / 3.0));
-  system.box.xprd = nx * lattice;
-  system.box.yprd = ny * lattice;
-  system.box.zprd = nz * lattice;
-  system.box.xlo = 0;
-  system.box.ylo = 0;
-  system.box.zlo = 0;
-  system.box.xhi = system.box.xprd;
-  system.box.yhi = system.box.yprd;
-  system.box.zhi = system.box.zprd;
-
-
-  int ghost_dist = int(system.neigh_cut/lattice) + 1;
-
-  /* total # of atoms */
-
-  system.nlocal = 4 * nx * ny * nz;
-  system.nghost = 4 * (nx + 2 * ghost_dist) *
-                      (ny + 2 * ghost_dist) *
-                      (nz + 2 * ghost_dist) -
-                      system.nlocal;
-  system.natoms = system.nlocal + system.nghost;
-
-  system.d_x = t_x_array("X",system.natoms);
-  system.h_x = Kokkos::create_mirror_view(system.d_x);
-  system.f = t_f_array("F",system.natoms);
-
-  /* determine loop bounds of lattice subsection that overlaps my sub-box
-     insure loop bounds do not exceed nx,ny,nz */
-
-  double alat = pow((4.0 / rho), (1.0 / 3.0));
-  int ilo = static_cast<int>(system.box.xlo / (0.5 * alat) - 1);
-  int ihi = static_cast<int>(system.box.xhi / (0.5 * alat) + 1);
-  int jlo = static_cast<int>(system.box.ylo / (0.5 * alat) - 1);
-  int jhi = static_cast<int>(system.box.yhi / (0.5 * alat) + 1);
-  int klo = static_cast<int>(system.box.zlo / (0.5 * alat) - 1);
-  int khi = static_cast<int>(system.box.zhi / (0.5 * alat) + 1);
-
-  ilo = MAX(ilo, 0);
-  ihi = MIN(ihi, 2 * nx - 1);
-  jlo = MAX(jlo, 0);
-  jhi = MIN(jhi, 2 * ny - 1);
-  klo = MAX(klo, 0);
-  khi = MIN(khi, 2 * nz - 1);
-
-
-
-  /* generates positions of atoms on fcc sublattice*/
-
-  srand(3718273);
-  /* create non-ghost atoms */
-  {
-    double xtmp, ytmp, ztmp;
-    int sx = 0;
-    int sy = 0;
-    int sz = 0;
-    int ox = 0;
-    int oy = 0;
-    int oz = 0;
-    int subboxdim = 8;
-
-    int n = 0;
-    int iflag = 0;
-
-    while(oz * subboxdim <= khi) {
-      const int k = oz * subboxdim + sz;
-      const int j = oy * subboxdim + sy;
-      const int i = ox * subboxdim + sx;
-
-      if(iflag) continue;
-
-      if(((i + j + k) % 2 == 0) &&
-          (i >= ilo) && (i <= ihi) &&
-          (j >= jlo) && (j <= jhi) &&
-          (k >= klo) && (k <= khi)) {
-
-        const int nold = n;
-        while(nold == n) {
-          xtmp = 0.5 * alat * i + system.delta/1000*(rand()%1000-500);
-          ytmp = 0.5 * alat * j + system.delta/1000*(rand()%1000-500);
-          ztmp = 0.5 * alat * k + system.delta/1000*(rand()%1000-500);
-
-          if(xtmp >= system.box.xlo && xtmp < system.box.xhi &&
-              ytmp >= system.box.ylo && ytmp < system.box.yhi &&
-              ztmp >= system.box.zlo && ztmp < system.box.zhi) {
-            system.h_x(n,0) = xtmp;
-            system.h_x(n,1) = ytmp;
-            system.h_x(n,2) = ztmp;
-            n++;
-          }
-        }
-      }
-
-      sx++;
-
-      if(sx == subboxdim) {
-        sx = 0;
-        sy++;
-      }
-
-      if(sy == subboxdim) {
-        sy = 0;
-        sz++;
-      }
-
-      if(sz == subboxdim) {
-        sz = 0;
-        ox++;
-      }
-
-      if(ox * subboxdim > ihi) {
-        ox = 0;
-        oy++;
-      }
-
-      if(oy * subboxdim > jhi) {
-        oy = 0;
-        oz++;
-      }
-    }
-
-    /* check that correct # of atoms were created */
-
-    if(system.nlocal != n) {
-      printf("Created incorrect # of atoms\n");
-
-      return 1;
-    }
-  }
-
-  /* create ghost atoms */
-
-  {
-    double xtmp, ytmp, ztmp;
-
-    int ilo_g = ilo - 2 * ghost_dist;
-    int jlo_g = jlo - 2 * ghost_dist;
-    int klo_g = klo - 2 * ghost_dist;
-    int ihi_g = ihi + 2 * ghost_dist;
-    int jhi_g = jhi + 2 * ghost_dist;
-    int khi_g = khi + 2 * ghost_dist;
-
-    int subboxdim = 8;
-    int sx = 0;
-    int sy = 0;
-    int sz = 0;
-    int ox = subboxdim * ilo_g;
-    int oy = subboxdim * jlo_g;
-    int oz = subboxdim * klo_g;
-
-    int n = system.nlocal;
-    int iflag = 0;
-
-
-    while(oz * subboxdim <= khi_g) {
-      const int k = oz * subboxdim + sz;
-      const int j = oy * subboxdim + sy;
-      const int i = ox * subboxdim + sx;
-
-      if(iflag) continue;
-
-      if(((i + j + k) % 2 == 0) &&
-          (i >= ilo_g) && (i <= ihi_g) &&
-          (j >= jlo_g) && (j <= jhi_g) &&
-          (k >= klo_g) && (k <= khi_g) &&
-          ((i < ilo) || (i > ihi) ||
-           (j < jlo) || (j > jhi) ||
-           (k < klo) || (k > khi))
-          ) {
-
-        xtmp = 0.5 * alat * i;
-        ytmp = 0.5 * alat * j;
-        ztmp = 0.5 * alat * k;
-
-        system.h_x(n,0) = xtmp + system.delta/1000*(rand()%1000-500);;
-        system.h_x(n,1) = ytmp + system.delta/1000*(rand()%1000-500);;
-        system.h_x(n,2) = ztmp + system.delta/1000*(rand()%1000-500);;
-        n++;
-      }
-
-      sx++;
-
-      if(sx == subboxdim) {
-        sx = 0;
-        sy++;
-      }
-
-      if(sy == subboxdim) {
-        sy = 0;
-        sz++;
-      }
-
-      if(sz == subboxdim) {
-        sz = 0;
-        ox++;
-        //printf("%i %i %i // %i %i %i\n",ox,oy,oz,i,j,k);
-      }
-
-      if(ox * subboxdim > ihi_g) {
-        ox = subboxdim * ilo_g;
-        oy++;
-      }
-
-      if(oy * subboxdim > jhi_g) {
-        oy = subboxdim * jlo_g;
-        oz++;
-      }
-    }
-  }
-
-  Kokkos::deep_copy(system.d_x,system.h_x);
-  return 0;
-}
-
diff --git a/lib/kokkos/example/md_skeleton/system.h b/lib/kokkos/example/md_skeleton/system.h
deleted file mode 100644
index 4a0708ed340fbdc4c372e64bee613e2db76567a8..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/system.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef SYSTEM_H_
-#define SYSTEM_H_
-
-#include <types.h>
-
-struct Box {
-  double xprd, yprd, zprd;
-  double xlo, xhi;
-  double ylo, yhi;
-  double zlo, zhi;
-};
-
-struct System {
-  Box box;
-
-  int natoms;
-  int nlocal;
-  int nghost;
-
-  t_x_array d_x;
-  t_x_array_host h_x;
-
-  t_f_array f;
-
-  t_neighbors neighbors;
-  t_int_1d numneigh;
-
-  double delta;
-
-  double neigh_cut,neigh_cutsq;
-
-  int mbins;
-  int nbinx,nbiny,nbinz;
-  int mbinx,mbiny,mbinz;
-  int mbinxlo,mbinylo,mbinzlo;
-  double binsizex,binsizey,binsizez;
-  double bininvx,bininvy,bininvz;
-
-  t_int_1d bincount;
-  t_int_2d bins;
-  t_int_scalar d_resize;
-  t_int_scalar_host h_resize;
-  t_int_1d d_stencil;
-  t_int_1d_host h_stencil;
-  int nstencil;
-
-  double force_cut,force_cutsq;
-};
-#endif
diff --git a/lib/kokkos/example/md_skeleton/types.h b/lib/kokkos/example/md_skeleton/types.h
deleted file mode 100644
index 71d8c9bca03c8f9ae4ab3672bb6cf2241f14f496..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/md_skeleton/types.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef TYPES_H_
-#define TYPES_H_
-
-/* Determine default device type and necessary includes */
-
-#include <Kokkos_Core.hpp>
-
-typedef Kokkos::DefaultExecutionSpace execution_space ;
-
-#if ! defined( KOKKOS_ENABLE_CUDA )
-  struct double2 {
-    double x, y;
-    KOKKOS_INLINE_FUNCTION
-    double2(double xinit, double yinit) {
-      x = xinit;
-      y = yinit;
-    }
-    KOKKOS_INLINE_FUNCTION
-    double2() {
-      x = 0.0;
-      y = 0.0;
-    }
-    KOKKOS_INLINE_FUNCTION
-    double2& operator += (const double2& src) {
-      x+=src.x;
-      y+=src.y;
-      return *this;
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    volatile double2& operator += (const volatile double2& src) volatile {
-      x+=src.x;
-      y+=src.y;
-      return *this;
-    }
-
-  };
-#endif
-
-#include <impl/Kokkos_Timer.hpp>
-
-/* Define types used throughout the code */
-
-//Position arrays
-typedef Kokkos::View<double*[3], Kokkos::LayoutRight, execution_space>                                   t_x_array ;
-typedef t_x_array::HostMirror                                                                        t_x_array_host ;
-typedef Kokkos::View<const double*[3], Kokkos::LayoutRight, execution_space>                             t_x_array_const ;
-typedef Kokkos::View<const double*[3], Kokkos::LayoutRight, execution_space, Kokkos::MemoryRandomAccess >  t_x_array_randomread ;
-
-//Force array
-typedef Kokkos::View<double*[3],  execution_space>                                                       t_f_array ;
-
-
-//Neighborlist
-typedef Kokkos::View<int**, execution_space >                                                            t_neighbors ;
-typedef Kokkos::View<const int**, execution_space >                                                      t_neighbors_const ;
-typedef Kokkos::View<int*, execution_space, Kokkos::MemoryUnmanaged >                                    t_neighbors_sub ;
-typedef Kokkos::View<const int*, execution_space, Kokkos::MemoryUnmanaged >                              t_neighbors_const_sub ;
-
-//1d int array
-typedef Kokkos::View<int*, execution_space >                                                             t_int_1d ;
-typedef t_int_1d::HostMirror                                                                         t_int_1d_host ;
-typedef Kokkos::View<const int*, execution_space >                                                       t_int_1d_const ;
-typedef Kokkos::View<int*, execution_space , Kokkos::MemoryUnmanaged>                                    t_int_1d_um ;
-typedef Kokkos::View<const int* , execution_space , Kokkos::MemoryUnmanaged>                             t_int_1d_const_um ;
-
-//2d int array
-typedef Kokkos::View<int**, Kokkos::LayoutRight, execution_space >                                       t_int_2d ;
-typedef t_int_2d::HostMirror                                                                         t_int_2d_host ;
-
-//Scalar ints
-typedef Kokkos::View<int[1], Kokkos::LayoutLeft, execution_space>                                        t_int_scalar ;
-typedef t_int_scalar::HostMirror                                                                     t_int_scalar_host ;
-
-#endif /* TYPES_H_ */
diff --git a/lib/kokkos/example/multi_fem/BoxMeshFixture.hpp b/lib/kokkos/example/multi_fem/BoxMeshFixture.hpp
deleted file mode 100644
index 6fbf1d5a0a05a7d76f45876ee943825383fae861..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/BoxMeshFixture.hpp
+++ /dev/null
@@ -1,610 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_BOXMESHFIXTURE_HPP
-#define KOKKOS_BOXMESHFIXTURE_HPP
-
-#include <cmath>
-#include <stdexcept>
-#include <sstream>
-
-#include <Kokkos_Core.hpp>
-#include <BoxMeshPartition.hpp>
-#include <FEMesh.hpp>
-#include <HexElement.hpp>
-
-//----------------------------------------------------------------------------
-
-struct FixtureElementHex8 {
-
-  static const unsigned element_node_count = 8 ;
-
-  HybridFEM::HexElement_TensorData< element_node_count > elem_data ;
-  BoxBoundsLinear box_bounds ;
-
-  FixtureElementHex8() : elem_data(), box_bounds() {}
-
-  static void create_node_boxes_from_vertex_boxes(
-    const BoxType                & vertex_box_global ,
-    const std::vector< BoxType > & vertex_box_parts ,
-          BoxType                & node_box_global ,
-          std::vector< BoxType > & node_box_parts )
-  {
-    node_box_global = vertex_box_global ;
-    node_box_parts  = vertex_box_parts  ;
-  }
-
-  void elem_to_node( const unsigned node_local , unsigned coord[] ) const
-  {
-    coord[0] += elem_data.eval_map[ node_local ][0] ;
-    coord[1] += elem_data.eval_map[ node_local ][1] ;
-    coord[2] += elem_data.eval_map[ node_local ][2] ;
-  }
-};
-
-struct FixtureElementHex27 {
-  static const unsigned element_node_count = 27 ;
-
-  HybridFEM::HexElement_TensorData< element_node_count > elem_data ;
-  BoxBoundsQuadratic box_bounds ;
-
-  FixtureElementHex27() : elem_data(), box_bounds() {}
-
-  static void create_node_boxes_from_vertex_boxes(
-    const BoxType                & vertex_box_global ,
-    const std::vector< BoxType > & vertex_box_parts ,
-          BoxType                & node_box_global ,
-          std::vector< BoxType > & node_box_parts )
-  {
-    node_box_global = vertex_box_global ;
-    node_box_parts  = vertex_box_parts  ;
-
-    node_box_global[0][1] = 2 * node_box_global[0][1] - 1 ;
-    node_box_global[1][1] = 2 * node_box_global[1][1] - 1 ;
-    node_box_global[2][1] = 2 * node_box_global[2][1] - 1 ;
-
-    for ( unsigned i = 0 ; i < vertex_box_parts.size() ; ++i ) {
-      node_box_parts[i][0][0] = 2 * node_box_parts[i][0][0] ;
-      node_box_parts[i][1][0] = 2 * node_box_parts[i][1][0] ;
-      node_box_parts[i][2][0] = 2 * node_box_parts[i][2][0] ;
-
-      node_box_parts[i][0][1] =
-        std::min( node_box_global[0][1] , 2 * node_box_parts[i][0][1] );
-      node_box_parts[i][1][1] =
-        std::min( node_box_global[1][1] , 2 * node_box_parts[i][1][1] );
-      node_box_parts[i][2][1] =
-        std::min( node_box_global[2][1] , 2 * node_box_parts[i][2][1] );
-    }
-  }
-
-  void elem_to_node( const unsigned node_local , unsigned coord[] ) const
-  {
-    coord[0] = 2 * coord[0] + elem_data.eval_map[ node_local ][0] ;
-    coord[1] = 2 * coord[1] + elem_data.eval_map[ node_local ][1] ;
-    coord[2] = 2 * coord[2] + elem_data.eval_map[ node_local ][2] ;
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class Device , class ElementSpec >
-struct BoxMeshFixture {
-
-  typedef Scalar  coordinate_scalar_type ;
-  typedef Device  execution_space ;
-
-  static const unsigned element_node_count = ElementSpec::element_node_count ;
-
-  typedef HybridFEM::FEMesh< coordinate_scalar_type ,
-                             element_node_count ,
-                             execution_space > FEMeshType ;
-
-  typedef typename FEMeshType::node_coords_type    node_coords_type ;
-  typedef typename FEMeshType::elem_node_ids_type  elem_node_ids_type ;
-  typedef typename FEMeshType::node_elem_ids_type  node_elem_ids_type ;
-
-
-  static void verify(
-    const typename FEMeshType::node_coords_type::HostMirror   & node_coords ,
-    const typename FEMeshType::elem_node_ids_type::HostMirror & elem_node_ids ,
-    const typename FEMeshType::node_elem_ids_type::HostMirror & node_elem_ids )
-  {
-    typedef typename FEMeshType::size_type         size_type ;
-    //typedef typename node_coords_type::value_type  coords_type ; // unused
-
-    const size_type node_count_total = node_coords.dimension_0();
-    const size_type elem_count_total = elem_node_ids.dimension_0();
-
-    const ElementSpec element ;
-
-    for ( size_type node_index = 0 ;
-                    node_index < node_count_total ; ++node_index ) {
-
-      for ( size_type
-              j = node_elem_ids.row_map[ node_index ] ;
-              j < node_elem_ids.row_map[ node_index + 1 ] ; ++j ) {
-
-        const size_type elem_index = node_elem_ids.entries(j,0);
-        const size_type node_local = node_elem_ids.entries(j,1);
-        const size_type en_id      = elem_node_ids(elem_index,node_local);
-
-        if ( node_index != en_id ) {
-          std::ostringstream msg ;
-          msg << "BoxMeshFixture node_elem_ids error"
-              << " : node_index(" << node_index
-              << ") entry(" << j
-              << ") elem_index(" << elem_index
-              << ") node_local(" << node_local
-              << ") elem_node_id(" << en_id
-              << ")" ;
-          throw std::runtime_error( msg.str() );
-        }
-      }
-    }
-
-    for ( size_type elem_index = 0 ;
-                    elem_index < elem_count_total; ++elem_index ) {
-
-      coordinate_scalar_type elem_node_coord[ element_node_count ][3] ;
-
-      for ( size_type nn = 0 ; nn < element_node_count ; ++nn ) {
-        const size_type node_index = elem_node_ids( elem_index , nn );
-
-        for ( size_type nc = 0 ; nc < 3 ; ++nc ) {
-          elem_node_coord[nn][nc] = node_coords( node_index , nc );
-        }
-      }
-
-
-      for ( size_type nn = 0 ; nn < element_node_count ; ++nn ) {
-
-        const unsigned ix = element.elem_data.eval_map[nn][0] ;
-        const unsigned iy = element.elem_data.eval_map[nn][1] ;
-        const unsigned iz = element.elem_data.eval_map[nn][2] ;
-
-        if ( elem_node_coord[nn][0] != elem_node_coord[0][0] + ix ||
-             elem_node_coord[nn][1] != elem_node_coord[0][1] + iy ||
-             elem_node_coord[nn][2] != elem_node_coord[0][2] + iz ) {
-
-          std::ostringstream msg ;
-          msg << "BoxMeshFixture elem_node_coord mapping failure { "
-              << elem_node_coord[nn][0] << " "
-              << elem_node_coord[nn][1] << " "
-              << elem_node_coord[nn][2] << " } != { "
-              << elem_node_coord[ 0][0] + ix << " "
-              << elem_node_coord[ 0][1] + iy << " "
-              << elem_node_coord[ 0][2] + iz
-              << " }" ;
-          throw std::runtime_error( msg.str() );
-        }
-      }
-    }
-  }
-
-  //------------------------------------
-  // Initialize element-node connectivity:
-  // Order elements that only depend on owned nodes first.
-  // These elements could be computed while waiting for
-  // received node data.
-
-  static void layout_elements_interior_exterior(
-    const BoxType                vertex_box_local_used ,
-    const BoxType                vertex_box_local_owned ,
-    const BoxType                node_box_local_used ,
-    const std::vector<size_t> &  node_used_id_map ,
-    const ElementSpec            element_fixture ,
-    const size_t                 elem_count_interior ,
-    const typename elem_node_ids_type::HostMirror elem_node_ids )
-  {
-    size_t elem_index_interior = 0 ;
-    size_t elem_index_boundary = elem_count_interior ;
-
-    for ( size_t iz = vertex_box_local_used[2][0] ;
-                 iz < vertex_box_local_used[2][1] - 1 ; ++iz ) {
-    for ( size_t iy = vertex_box_local_used[1][0] ;
-                 iy < vertex_box_local_used[1][1] - 1 ; ++iy ) {
-    for ( size_t ix = vertex_box_local_used[0][0] ;
-                 ix < vertex_box_local_used[0][1] - 1 ; ++ix ) {
-
-      size_t elem_index ;
-
-      // If lower and upper vertices are owned then element is interior
-      if ( contain( vertex_box_local_owned, ix,   iy,   iz ) &&
-           contain( vertex_box_local_owned, ix+1, iy+1, iz+1 ) ) {
-        elem_index = elem_index_interior++ ;
-      }
-      else {
-        elem_index = elem_index_boundary++ ;
-      }
-
-      for ( size_t nn = 0 ; nn < element_node_count ; ++nn ) {
-        unsigned coord[3] = { static_cast<unsigned>(ix) , static_cast<unsigned>(iy) , static_cast<unsigned>(iz) };
-
-        element_fixture.elem_to_node( nn , coord );
-
-        const size_t node_local_id =
-          box_map_id( node_box_local_used ,
-                      node_used_id_map ,
-                      coord[0] , coord[1] , coord[2] );
-
-        elem_node_ids( elem_index , nn ) = node_local_id ;
-      }
-    }}}
-  }
-
-  //------------------------------------
-  // Nested partitioning of elements by number of thread 'gangs'
-
-  static void layout_elements_partitioned(
-    const BoxType                vertex_box_local_used ,
-    const BoxType                /*vertex_box_local_owned*/ ,
-    const BoxType                node_box_local_used ,
-    const std::vector<size_t> &  node_used_id_map ,
-    const ElementSpec            element_fixture ,
-    const size_t                 thread_gang_count ,
-    const typename elem_node_ids_type::HostMirror elem_node_ids )
-  {
-    std::vector< BoxType > element_box_gangs( thread_gang_count );
-
-    BoxType element_box_local_used = vertex_box_local_used ;
-
-    element_box_local_used[0][1] -= 1 ;
-    element_box_local_used[1][1] -= 1 ;
-    element_box_local_used[2][1] -= 1 ;
-
-    box_partition_rcb( element_box_local_used , element_box_gangs );
-
-    size_t elem_index = 0 ;
-
-    for ( size_t ig = 0 ; ig < thread_gang_count ; ++ig ) {
-
-      const BoxType box = element_box_gangs[ig] ;
-
-      for ( size_t iz = box[2][0] ; iz < box[2][1] ; ++iz ) {
-      for ( size_t iy = box[1][0] ; iy < box[1][1] ; ++iy ) {
-      for ( size_t ix = box[0][0] ; ix < box[0][1] ; ++ix , ++elem_index ) {
-
-        for ( size_t nn = 0 ; nn < element_node_count ; ++nn ) {
-          unsigned coord[3] = { static_cast<unsigned>(ix) , static_cast<unsigned>(iy) , static_cast<unsigned>(iz) };
-
-          element_fixture.elem_to_node( nn , coord );
-
-          const size_t node_local_id =
-            box_map_id( node_box_local_used ,
-                        node_used_id_map ,
-                        coord[0] , coord[1] , coord[2] );
-
-          elem_node_ids( elem_index , nn ) = node_local_id ;
-        }
-      }}}
-    }
-  }
-
-  //------------------------------------
-
-  static FEMeshType create( const size_t proc_count ,
-                            const size_t proc_local ,
-                            const size_t gang_count ,
-                            const size_t elems_x ,
-                            const size_t elems_y ,
-                            const size_t elems_z ,
-                            const double x_coord_curve = 1 ,
-                            const double y_coord_curve = 1 ,
-                            const double z_coord_curve = 1 )
-  {
-    const size_t vertices_x = elems_x + 1 ;
-    const size_t vertices_y = elems_y + 1 ;
-    const size_t vertices_z = elems_z + 1 ;
-
-    const BoxBoundsLinear vertex_box_bounds ;
-    const ElementSpec element ;
-
-    // Partition based upon vertices:
-
-    BoxType vertex_box_global ;
-    std::vector< BoxType > vertex_box_parts( proc_count );
-
-    vertex_box_global[0][0] = 0 ; vertex_box_global[0][1] = vertices_x ;
-    vertex_box_global[1][0] = 0 ; vertex_box_global[1][1] = vertices_y ;
-    vertex_box_global[2][0] = 0 ; vertex_box_global[2][1] = vertices_z ;
-
-    box_partition_rcb( vertex_box_global , vertex_box_parts );
-
-    const BoxType vertex_box_local_owned = vertex_box_parts[ proc_local ];
-
-    // Determine interior and used vertices:
-
-    BoxType vertex_box_local_interior ;
-    BoxType vertex_box_local_used ;
-
-    vertex_box_bounds.apply( vertex_box_global ,
-                             vertex_box_local_owned ,
-                             vertex_box_local_interior ,
-                             vertex_box_local_used );
-
-    // Element counts:
-
-    const long local_elems_x =
-      ( vertex_box_local_used[0][1] - vertex_box_local_used[0][0] ) - 1 ;
-    const long local_elems_y =
-      ( vertex_box_local_used[1][1] - vertex_box_local_used[1][0] ) - 1 ;
-    const long local_elems_z =
-      ( vertex_box_local_used[2][1] - vertex_box_local_used[2][0] ) - 1 ;
-
-    const size_t elem_count_total = std::max( long(0) , local_elems_x ) *
-                                    std::max( long(0) , local_elems_y ) *
-                                    std::max( long(0) , local_elems_z );
-
-    const long interior_elems_x =
-      ( vertex_box_local_owned[0][1] - vertex_box_local_owned[0][0] ) - 1 ;
-    const long interior_elems_y =
-      ( vertex_box_local_owned[1][1] - vertex_box_local_owned[1][0] ) - 1 ;
-    const long interior_elems_z =
-      ( vertex_box_local_owned[2][1] - vertex_box_local_owned[2][0] ) - 1 ;
-
-    const size_t elem_count_interior = std::max( long(0) , interior_elems_x ) *
-                                       std::max( long(0) , interior_elems_y ) *
-                                       std::max( long(0) , interior_elems_z );
-
-    // Expand vertex boxes to node boxes:
-
-    BoxType node_box_global ;
-    BoxType node_box_local_used ;
-    std::vector< BoxType > node_box_parts ;
-
-    element.create_node_boxes_from_vertex_boxes(
-      vertex_box_global , vertex_box_parts ,
-      node_box_global , node_box_parts );
-
-    // Node communication maps:
-
-    size_t node_count_interior = 0 ;
-    size_t node_count_owned    = 0 ;
-    size_t node_count_total    = 0 ;
-    std::vector<size_t>                 node_used_id_map ;
-    std::vector<size_t>                 node_part_counts ;
-    std::vector< std::vector<size_t> >  node_send_map ;
-
-    box_partition_maps( node_box_global ,
-                        node_box_parts ,
-                        element.box_bounds ,
-                        proc_local ,
-                        node_box_local_used ,
-                        node_used_id_map ,
-                        node_count_interior ,
-                        node_count_owned ,
-                        node_count_total ,
-                        node_part_counts ,
-                        node_send_map );
-
-    size_t node_count_send = 0 ;
-    for ( size_t i = 0 ; i < node_send_map.size() ; ++i ) {
-      node_count_send += node_send_map[i].size();
-    }
-
-    size_t recv_msg_count = 0 ;
-    size_t send_msg_count = 0 ;
-    size_t send_count = 0 ;
-
-    for ( size_t i = 1 ; i < proc_count ; ++i ) {
-      if ( node_part_counts[i] ) ++recv_msg_count ;
-      if ( node_send_map[i].size() ) {
-        ++send_msg_count ;
-        send_count += node_send_map[i].size();
-      }
-    }
-
-    // Finite element mesh:
-
-    FEMeshType mesh ;
-
-    if ( node_count_total ) {
-      mesh.node_coords = node_coords_type( "node_coords", node_count_total );
-    }
-
-    if ( elem_count_total ) {
-      mesh.elem_node_ids =
-        elem_node_ids_type( "elem_node_ids", elem_count_total );
-    }
-
-    mesh.parallel_data_map.assign( node_count_interior ,
-                                   node_count_owned ,
-                                   node_count_total ,
-                                   recv_msg_count ,
-                                   send_msg_count ,
-                                   send_count );
-
-    typename node_coords_type::HostMirror node_coords =
-      Kokkos::create_mirror( mesh.node_coords );
-
-    typename elem_node_ids_type::HostMirror elem_node_ids =
-      Kokkos::create_mirror( mesh.elem_node_ids );
-
-    //------------------------------------
-    // set node coordinates to grid location for subsequent verification
-
-    for ( size_t iz = node_box_local_used[2][0] ;
-                 iz < node_box_local_used[2][1] ; ++iz ) {
-
-    for ( size_t iy = node_box_local_used[1][0] ;
-                 iy < node_box_local_used[1][1] ; ++iy ) {
-
-    for ( size_t ix = node_box_local_used[0][0] ;
-                 ix < node_box_local_used[0][1] ; ++ix ) {
-
-      const size_t node_local_id =
-        box_map_id( node_box_local_used , node_used_id_map , ix , iy , iz );
-
-      node_coords( node_local_id , 0 ) = ix ;
-      node_coords( node_local_id , 1 ) = iy ;
-      node_coords( node_local_id , 2 ) = iz ;
-    }}}
-
-    //------------------------------------
-    // Initialize element-node connectivity:
-
-    if ( 1 < gang_count ) {
-      layout_elements_partitioned( vertex_box_local_used ,
-                                   vertex_box_local_owned ,
-                                   node_box_local_used ,
-                                   node_used_id_map ,
-                                   element ,
-                                   gang_count ,
-                                   elem_node_ids );
-    }
-    else {
-      layout_elements_interior_exterior( vertex_box_local_used ,
-                                         vertex_box_local_owned ,
-                                         node_box_local_used ,
-                                         node_used_id_map ,
-                                         element ,
-                                         elem_count_interior ,
-                                         elem_node_ids );
-    }
-
-    //------------------------------------
-    // Populate node->element connectivity:
-
-    std::vector<size_t> node_elem_work( node_count_total , (size_t) 0 );
-
-    for ( size_t i = 0 ; i < elem_count_total ; ++i ) {
-      for ( size_t n = 0 ; n < element_node_count  ; ++n ) {
-        ++node_elem_work[ elem_node_ids(i,n) ];
-      }
-    }
-
-    mesh.node_elem_ids =
-      Kokkos::create_staticcrsgraph< node_elem_ids_type >( "node_elem_ids" , node_elem_work );
-
-    typename node_elem_ids_type::HostMirror
-      node_elem_ids = Kokkos::create_mirror( mesh.node_elem_ids );
-
-    for ( size_t i = 0 ; i < node_count_total ; ++i ) {
-      node_elem_work[i] = node_elem_ids.row_map[i];
-    }
-
-    // Looping in element order insures the list of elements
-    // is sorted by element index.
-
-    for ( size_t i = 0 ; i < elem_count_total ; ++i ) {
-      for ( size_t n = 0 ; n < element_node_count ; ++n ) {
-        const unsigned nid = elem_node_ids(i, n);
-        const unsigned j = node_elem_work[nid] ; ++node_elem_work[nid] ;
-
-        node_elem_ids.entries( j , 0 ) = i ;
-        node_elem_ids.entries( j , 1 ) = n ;
-      }
-    }
-    //------------------------------------
-    // Verify setup with node coordinates matching grid indices.
-    verify( node_coords , elem_node_ids , node_elem_ids );
-
-    //------------------------------------
-    // Scale node coordinates to problem extent with
-    // nonlinear mapping.
-    {
-      const double problem_extent[3] =
-        { static_cast<double>( vertex_box_global[0][1] - 1 ) ,
-          static_cast<double>( vertex_box_global[1][1] - 1 ) ,
-          static_cast<double>( vertex_box_global[2][1] - 1 ) };
-
-      const double grid_extent[3] =
-        { static_cast<double>( node_box_global[0][1] - 1 ) ,
-          static_cast<double>( node_box_global[1][1] - 1 ) ,
-          static_cast<double>( node_box_global[2][1] - 1 ) };
-
-      for ( size_t i = 0 ; i < node_count_total ; ++i ) {
-        const double x_unit = node_coords(i,0) / grid_extent[0] ;
-        const double y_unit = node_coords(i,1) / grid_extent[1] ;
-        const double z_unit = node_coords(i,2) / grid_extent[2] ;
-
-        node_coords(i,0) = coordinate_scalar_type( problem_extent[0] * std::pow( x_unit , x_coord_curve ) );
-        node_coords(i,1) = coordinate_scalar_type( problem_extent[1] * std::pow( y_unit , y_coord_curve ) );
-        node_coords(i,2) = coordinate_scalar_type( problem_extent[2] * std::pow( z_unit , z_coord_curve ) );
-      }
-    }
-
-    Kokkos::deep_copy( mesh.node_coords ,   node_coords );
-    Kokkos::deep_copy( mesh.elem_node_ids , elem_node_ids );
-    Kokkos::deep_copy( mesh.node_elem_ids.entries , node_elem_ids.entries );
-
-    //------------------------------------
-    // Communication lists:
-    {
-      recv_msg_count = 0 ;
-      send_msg_count = 0 ;
-      send_count = 0 ;
-
-      for ( size_t i = 1 ; i < proc_count ; ++i ) {
-
-        // Order sending starting with the local processor rank
-        // to try to smooth out the amount of messages simultaneously
-        // send to a particular processor.
-
-        const int proc = ( proc_local + i ) % proc_count ;
-        if ( node_part_counts[i] ) {
-          mesh.parallel_data_map.host_recv(recv_msg_count,0) = proc ;
-          mesh.parallel_data_map.host_recv(recv_msg_count,1) = node_part_counts[i] ;
-          ++recv_msg_count ;
-        }
-        if ( node_send_map[i].size() ) {
-          mesh.parallel_data_map.host_send(send_msg_count,0) = proc ;
-          mesh.parallel_data_map.host_send(send_msg_count,1) = node_send_map[i].size() ;
-          for ( size_t j = 0 ; j < node_send_map[i].size() ; ++j , ++send_count ) {
-            mesh.parallel_data_map.host_send_item(send_count) = node_send_map[i][j] - node_count_interior ;
-          }
-          ++send_msg_count ;
-        }
-      }
-    }
-
-    return mesh ;
-  }
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_BOXMESHFIXTURE_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/BoxMeshPartition.cpp b/lib/kokkos/example/multi_fem/BoxMeshPartition.cpp
deleted file mode 100644
index 99c93e5eb1a74929354a27299711a12725485a6c..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/BoxMeshPartition.cpp
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <iostream>
-#include <sstream>
-#include <stdexcept>
-#include <limits>
-#include <BoxMeshPartition.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace {
-
-void box_partition( size_t ip , size_t up ,
-                    const BoxType & box ,
-                    BoxType * const p_box )
-{
-  const size_t np = up - ip ;
-
-  if ( 1 == np ) {
-    p_box[ip] = box ;
-  }
-  else {
-    // Choose axis with largest count:
-
-    const size_t n0 = box[0][1] - box[0][0] ;
-    const size_t n1 = box[1][1] - box[1][0] ;
-    const size_t n2 = box[2][1] - box[2][0] ;
-
-    const size_t axis = n2 > n1 ? ( n2 > n0 ? 2 : ( n1 > n0 ? 1 : 0 ) ) :
-                                  ( n1 > n0 ? 1 : 0 );
-
-    const size_t n = box[ axis ][1] - box[ axis ][0] ;
-
-    if ( 0 == np % 3 ) {
-      const size_t np_part = np / 3 ; // exact
-
-      const size_t nbox_low = (size_t)(( (double) n ) * ( 1.0 / 3.0 ));
-      const size_t nbox_mid = (size_t)(( (double) n ) * ( 2.0 / 3.0 ));
-
-      BoxType dbox_low = box ; // P = [ip,ip+np/3) 
-      BoxType dbox_mid = box ; // P = [ip+np/3,ip+2*np/3) 
-      BoxType dbox_upp = box ; // P = [ip+2*np/3,ip+np) 
-
-      dbox_low[ axis ][1] = box[ axis ][0] + nbox_low ;
-      dbox_mid[ axis ][1] = box[ axis ][0] + nbox_mid ;
-
-      dbox_mid[ axis ][0] = dbox_low[ axis ][1];
-      dbox_upp[ axis ][0] = dbox_mid[ axis ][1];
-
-      box_partition( ip,           ip +   np_part, dbox_low , p_box );
-      box_partition( ip+  np_part, ip + 2*np_part, dbox_mid , p_box );
-      box_partition( ip+2*np_part, up,             dbox_upp , p_box );
-    }
-    else {
-      const size_t np_low = np / 2 ; /* Rounded down */
-      const size_t nbox_low = (size_t)
-        (((double)n) * ( ((double) np_low ) / ((double) np ) ));
-
-      BoxType dbox_low = box ;
-      BoxType dbox_upp = box ;
-
-      dbox_low[ axis ][1] = dbox_low[ axis ][0] + nbox_low ; 
-      dbox_upp[ axis ][0] = dbox_low[ axis ][1];
-
-      box_partition( ip, ip + np_low, dbox_low , p_box );
-      box_partition( ip + np_low, up, dbox_upp , p_box );
-    }
-  }
-}
-
-size_t box_map_offset( const BoxType & local_use ,
-                       const size_t global_i ,
-                       const size_t global_j ,
-                       const size_t global_k )
-
-{
-  const size_t max = std::numeric_limits<size_t>::max();
-
-  const size_t n[3] =
-    { local_use[0][1] - local_use[0][0] ,
-      local_use[1][1] - local_use[1][0] ,
-      local_use[2][1] - local_use[2][0] };
-
-  const size_t use[3] = {
-    ( global_i >= local_use[0][0] ? global_i - local_use[0][0] : max ) ,
-    ( global_j >= local_use[1][0] ? global_j - local_use[1][0] : max ) ,
-    ( global_k >= local_use[2][0] ? global_k - local_use[2][0] : max ) };
-
-  const size_t offset =
-    ( use[0] < n[0] && use[1] < n[1] && use[2] < n[2] ) ?
-    ( use[0] + n[0] * ( use[1] + n[1] * use[2] ) ) : max ;
-
-  if ( offset == max ) {
-    std::ostringstream msg ;
-    msg << "box_map_offset ERROR: "
-        << " use " << local_use
-        << " ( " << global_i
-        << " , " << global_j
-        << " , " << global_k
-        << " )" ;
-    throw std::runtime_error( msg.str() );
-  }
-
-  return offset ;
-}
-
-} // namespace
-
-//----------------------------------------------------------------------------
-
-void BoxBoundsLinear::apply(  const BoxType & box_global ,
-                              const BoxType & box_part ,
-                                    BoxType & box_interior ,
-                                    BoxType & box_use ) const
-{
-  const unsigned ghost = 1 ;
-
-  if ( 0 == count( box_part ) ) {
-    box_interior = box_part ;
-    box_use      = box_part ;
-  }
-  else {
-    for ( size_t i = 0 ; i < 3 ; ++i ) {
-
-      box_interior[i][0] =
-        ( box_part[i][0] == box_global[i][0] )      ? box_part[i][0] : (
-        ( box_part[i][0] + ghost < box_part[i][1] ) ? box_part[i][0] + ghost : 
-                                                      box_part[i][1] );
-
-      box_interior[i][1] =
-        ( box_part[i][1] == box_global[i][1] )      ? box_part[i][1] : (
-        ( box_part[i][0] + ghost < box_part[i][1] ) ? box_part[i][1] - ghost :
-                                                      box_part[i][0] );
-
-      box_use[i][0] = 
-        ( box_part[i][0] > ghost + box_global[i][0] ) ? box_part[i][0] - ghost :
-                                                        box_global[i][0] ;
-      box_use[i][1] = 
-        ( box_part[i][1] + ghost < box_global[i][1] ) ? box_part[i][1] + ghost :
-                                                        box_global[i][1] ;
-    }
-  }
-}
-
-void BoxBoundsQuadratic::apply( const BoxType & box_global ,
-                                const BoxType & box_part ,
-                                      BoxType & box_interior ,
-                                      BoxType & box_use ) const
-{
-  if ( 0 == count( box_part ) ) {
-    box_interior = box_part ;
-    box_use      = box_part ;
-  }
-  else {
-    for ( size_t i = 0 ; i < 3 ; ++i ) {
-      const bool odd = ( box_part[i][0] - box_global[i][0] ) & 01 ;
-
-      const unsigned ghost = odd ? 1 : 2 ;
-
-      box_interior[i][0] =
-        ( box_part[i][0] == box_global[i][0] )      ? box_part[i][0] : (
-        ( box_part[i][0] + ghost < box_part[i][1] ) ? box_part[i][0] + ghost : 
-                                                      box_part[i][1] );
-
-      box_interior[i][1] =
-        ( box_part[i][1] == box_global[i][1] )      ? box_part[i][1] : (
-        ( box_part[i][0] + ghost < box_part[i][1] ) ? box_part[i][1] - ghost :
-                                                      box_part[i][0] );
-
-      box_use[i][0] = 
-        ( box_part[i][0] > ghost + box_global[i][0] ) ? box_part[i][0] - ghost :
-                                                        box_global[i][0] ;
-      box_use[i][1] = 
-        ( box_part[i][1] + ghost < box_global[i][1] ) ? box_part[i][1] + ghost :
-                                                        box_global[i][1] ;
-    }
-  }
-}
-
-//----------------------------------------------------------------------------
-
-void box_partition_rcb( const BoxType        & root_box ,
-                        std::vector<BoxType> & part_boxes )
-{
-  const BoxBoundsLinear use_boxes ;
-
-  const size_t part_count = part_boxes.size();
-
-  box_partition( 0 , part_count , root_box , & part_boxes[0] );
-
-  // Verify partitioning
-
-  size_t total_cell = 0 ;
-
-  for ( size_t i = 0 ; i < part_count ; ++i ) {
-
-    total_cell += count( part_boxes[i] );
-
-    BoxType box_interior , box_use ;
-
-    use_boxes.apply( root_box , part_boxes[i] , box_interior , box_use );
-
-    if ( count( box_use ) < count( part_boxes[i] ) ||
-         count( part_boxes[i] ) < count( box_interior ) ||
-         part_boxes[i] != intersect( part_boxes[i] , box_use ) ||
-         box_interior  != intersect( part_boxes[i] , box_interior )) {
-
-      std::ostringstream msg ;
-
-      msg << "box_partition_rcb ERROR : "
-          << "part_boxes[" << i << "] = "
-          << part_boxes[i]
-          << " use " << box_use
-          << " interior " << box_interior
-          << std::endl 
-          << "  part ^ use " << intersect( part_boxes[i] , box_use )
-          << "  part ^ interior " << intersect( part_boxes[i] , box_interior );
-
-      throw std::runtime_error( msg.str() );
-    }
-
-    for ( size_t j = i + 1 ; j < part_count ; ++j ) {
-      const BoxType tmp = intersect( part_boxes[i] , part_boxes[j] );
-
-      if ( count( tmp ) ) {
-        throw std::runtime_error( std::string("box partition intersection") );
-      }
-    }
-  }
-
-  if ( total_cell != count( root_box ) ) {
-    throw std::runtime_error( std::string("box partition count") );
-  }
-}
-
-//----------------------------------------------------------------------------
-         
-size_t box_map_id( const BoxType & local_use ,
-                   const std::vector<size_t> & local_use_id_map ,
-                   const size_t global_i ,
-                   const size_t global_j ,
-                   const size_t global_k )
-
-{
-  const size_t offset =
-    box_map_offset( local_use , global_i , global_j , global_k );
-  return local_use_id_map[ offset ];
-}
-         
-//----------------------------------------------------------------------------
-
-void box_partition_maps( const BoxType              & root_box ,
-                         const std::vector<BoxType> & part_boxes ,
-                         const BoxBounds            & use_boxes ,
-                         const size_t          my_part ,
-                         BoxType             & my_use_box ,
-                         std::vector<size_t> & my_use_id_map ,
-                         size_t              & my_count_interior ,
-                         size_t              & my_count_owned ,
-                         size_t              & my_count_uses ,
-                         std::vector<size_t> & my_part_counts ,
-                         std::vector<std::vector<size_t> > & my_send_map )
-{
-  const size_t np = part_boxes.size();
-
-  if ( np <= my_part ) {
-    std::ostringstream msg ;
-    msg << "box_partition_maps ERROR : "
-        << " np(" << np << ") <= my_part(" << my_part << ")" ;
-    throw std::runtime_error( msg.str() );
-  }
-
-  const BoxType my_owned_box = part_boxes[my_part];
-  BoxType my_interior_box ;
-
-
-  use_boxes.apply( root_box, my_owned_box, my_interior_box, my_use_box );
-
-  my_count_interior = count( my_interior_box );
-  my_count_owned    = count( my_owned_box );
-  my_count_uses     = count( my_use_box );
-
-  my_use_id_map.assign( my_count_uses , std::numeric_limits<size_t>::max() );
-
-  // Order ids as { owned-interior , owned-parallel , received_{(p+i)%np} }
-
-  size_t offset_interior = 0 ;
-  size_t offset_parallel = my_count_interior ;
-
-  for ( size_t iz = my_owned_box[2][0] ; iz < my_owned_box[2][1] ; ++iz ) {
-  for ( size_t iy = my_owned_box[1][0] ; iy < my_owned_box[1][1] ; ++iy ) {
-  for ( size_t ix = my_owned_box[0][0] ; ix < my_owned_box[0][1] ; ++ix ) {
-    const size_t offset = box_map_offset( my_use_box , ix , iy , iz );
-    if ( contain( my_interior_box , ix , iy , iz ) ) {
-      my_use_id_map[ offset ] = offset_interior++ ;
-    }
-    else {
-      my_use_id_map[ offset ] = offset_parallel++ ;
-    }
-  }}}
-
-
-  my_part_counts.assign( np , (size_t) 0 );
-  my_send_map.assign( np , std::vector<size_t>() );
-
-  my_part_counts[0] = my_count_owned ;
-
-  for ( size_t i = 1 ; i < np ; ++i ) {
-
-    const size_t ip = ( my_part + i ) % np ;
-
-    const BoxType p_owned_box = part_boxes[ip];
-    BoxType p_use_box , p_interior_box ;
-    use_boxes.apply( root_box, p_owned_box, p_interior_box, p_use_box );
-
-    const BoxType recv_box = intersect( my_use_box , p_owned_box );
-    const BoxType send_box = intersect( my_owned_box , p_use_box );
-
-    if ( 0 != ( my_part_counts[i] = count( recv_box ) ) ) {
-      for ( size_t iz = recv_box[2][0] ; iz < recv_box[2][1] ; ++iz ) {
-      for ( size_t iy = recv_box[1][0] ; iy < recv_box[1][1] ; ++iy ) {
-      for ( size_t ix = recv_box[0][0] ; ix < recv_box[0][1] ; ++ix ) {
-        const size_t offset = box_map_offset( my_use_box , ix , iy , iz );
-        my_use_id_map[ offset ] = offset_parallel++ ;
-      }}}
-    }
-
-    if ( 0 != count( send_box ) ) {
-      for ( size_t iz = send_box[2][0] ; iz < send_box[2][1] ; ++iz ) {
-      for ( size_t iy = send_box[1][0] ; iy < send_box[1][1] ; ++iy ) {
-      for ( size_t ix = send_box[0][0] ; ix < send_box[0][1] ; ++ix ) {
-        const size_t offset = box_map_offset( my_use_box , ix , iy , iz );
-
-        my_send_map[ i ].push_back( my_use_id_map[ offset ] );
-      }}}
-    }
-  }
-}
-
-
diff --git a/lib/kokkos/example/multi_fem/BoxMeshPartition.hpp b/lib/kokkos/example/multi_fem/BoxMeshPartition.hpp
deleted file mode 100644
index ea5d1de0081994b9117b26655b9a8bfba2d4f851..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/BoxMeshPartition.hpp
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef BOXMESHPARTITION_HPP
-#define BOXMESHPARTITION_HPP
-
-#include <cstddef>
-#include <utility>
-#include <vector>
-#include <iostream>
-
-//----------------------------------------------------------------------------
-
-struct BoxType {
-  size_t data[3][2] ;
-
-  typedef size_t range_type[2] ;
-
-  inline
-  const range_type & operator[]( size_t i ) const { return data[i]; }
-
-  inline
-  range_type & operator[]( size_t i ) { return data[i]; }
-
-  inline
-  bool operator == ( const BoxType & rhs ) const
-  {
-    return data[0][0] == rhs.data[0][0] && data[0][1] == rhs.data[0][1] &&
-           data[1][0] == rhs.data[1][0] && data[1][1] == rhs.data[2][1] &&
-           data[2][0] == rhs.data[2][0] && data[2][1] == rhs.data[2][1] ;
-  }
-
-  inline
-  bool operator != ( const BoxType & rhs ) const
-  {
-    return data[0][0] != rhs.data[0][0] || data[0][1] != rhs.data[0][1] ||
-           data[1][0] != rhs.data[1][0] || data[1][1] != rhs.data[1][1] ||
-           data[2][0] != rhs.data[2][0] || data[2][1] != rhs.data[2][1] ;
-  }
-};
-
-inline
-size_t count( const BoxType & b )
-{
-  size_t n = 1 ;
-  for ( size_t i = 0 ; i < 3 ; ++i ) {
-    n *= b[i][1] > b[i][0] ? b[i][1] - b[i][0] : 0 ;
-  }
-  return n ;
-}
-
-inline
-bool contain( const BoxType & b , size_t i , size_t j , size_t k )
-{
-  return b[0][0] <= i && i < b[0][1] &&
-         b[1][0] <= j && j < b[1][1] &&
-         b[2][0] <= k && k < b[2][1] ;
-}
-
-inline
-BoxType intersect( const BoxType & x , const BoxType & y )
-{
-  BoxType z ;
-  for ( size_t i = 0 ; i < 3 ; ++i ) {
-    z[i][0] = std::max( x[i][0] , y[i][0] );    
-    z[i][1] = std::min( x[i][1] , y[i][1] );    
-  }
-
-  return z ;
-}
-
-inline
-std::ostream & operator << ( std::ostream & s , const BoxType & box )
-{
-  s << "{ "
-    << box[0][0] << " " << box[0][1] << " , "
-    << box[1][0] << " " << box[1][1] << " , "
-    << box[2][0] << " " << box[2][1] << " }" ;
-  return s ;
-}
-
-//----------------------------------------------------------------------------
-
-class BoxBounds {
-public:
-  /** \brief  Default bounds to one layer of ghosting */
-  virtual
-  void apply( const BoxType & box_global ,
-              const BoxType & box_part ,
-                    BoxType & box_interior ,
-                    BoxType & box_use ) const = 0 ;
-
-  virtual ~BoxBounds() {}
-  BoxBounds() {}
-};
-
-class BoxBoundsLinear : public BoxBounds
-{
-public:
-  /** \brief  Default bounds to one layer of ghosting */
-  virtual
-  void apply( const BoxType & box_global ,
-              const BoxType & box_part ,
-                    BoxType & box_interior ,
-                    BoxType & box_use ) const ;
-
-  virtual ~BoxBoundsLinear() {}
-  BoxBoundsLinear() {}
-};
-
-class BoxBoundsQuadratic : public BoxBounds {
-public:
-  /** \brief  Quadratic mesh: even ordinates have two layers,
-   *          odd ordinates have one layer.
-   */
-  virtual
-  void apply( const BoxType & box_global ,
-              const BoxType & box_part ,
-                    BoxType & box_interior ,
-                    BoxType & box_use ) const ;
-
-  virtual ~BoxBoundsQuadratic() {}
-  BoxBoundsQuadratic() {}
-};
-
-//----------------------------------------------------------------------------
-/* Partition box into part_boxes.size() sub-boxes */
-
-void box_partition_rcb( const BoxType        & root_box ,
-                        std::vector<BoxType> & part_boxes );
-
-//----------------------------------------------------------------------------
-/* Determine local id layout and communication maps for partitioned boxes.
- *
- *  Local ids are laid out as follows:
- *    { [ owned-interior ids not sent ] ,
- *      [ owned-boundary ids to be sent to other processes ] ,
- *      [ received ids from processor ( my_part + 1 ) % part_count ]
- *      [ received ids from processor ( my_part + 2 ) % part_count ]
- *      [ received ids from processor ( my_part + 3 ) % part_count ]
- *      ... };
- *
- *  This layout allows
- *  (1) received data to be copied into a contiguous block of memory
- *  (2) send data to be extracted from a contiguous block of memory.
- */
-void box_partition_maps(
-  const BoxType              & root_box ,   // [in] Global box
-  const std::vector<BoxType> & part_boxes , // [in] Partitioned boxes
-  const BoxBounds            & use_boxes ,  // [in] Ghost boundaries
-  const size_t          my_part ,           // [in] My local part
-  BoxType             & my_use_box ,        // [out] My used box with ghost
-  std::vector<size_t> & my_use_id_map ,     // [out] Local ordering map
-  size_t              & my_count_interior , // [out] How many interior
-  size_t              & my_count_owned ,    // [out] How many owned
-  size_t              & my_count_uses ,     // [out] How may used
-  std::vector<size_t> & my_part_counts ,    // [out] Partitioning of my_use_id_map
-  std::vector<std::vector<size_t> > & my_send_map ); // [out] Send id map
-
-/*  Mapping of cartesian coordinate to local id */
-size_t box_map_id( const BoxType             & my_use_box ,
-                   const std::vector<size_t> & my_use_id_map ,
-                   const size_t global_i ,
-                   const size_t global_j ,
-                   const size_t global_k );
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef BOXMESHPARTITION_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/CMakeLists.txt b/lib/kokkos/example/multi_fem/CMakeLists.txt
deleted file mode 100644
index e3a40bc26f0fb45a12d59ddcfa0f767c3988a6f9..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-SET(SOURCES "")
-
-FILE(GLOB SOURCES *.cpp)
-
-SET(LIBRARIES kokkoscore)
-
-TRIBITS_ADD_EXECUTABLE(
-  multi_fem
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  )
-
diff --git a/lib/kokkos/example/multi_fem/Explicit.hpp b/lib/kokkos/example/multi_fem/Explicit.hpp
deleted file mode 100644
index d3a7f159c0894a3dd8a28fff1fb847037864e5d7..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/Explicit.hpp
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef EXPLICIT_DRIVER_HPP
-#define EXPLICIT_DRIVER_HPP
-
-#include <sys/time.h>
-#include <iostream>
-#include <iomanip>
-#include <cstdlib>
-#include <cmath>
-
-#include <impl/Kokkos_Timer.hpp>
-
-#include <ExplicitFunctors.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace Explicit {
-
-struct PerformanceData {
-  double mesh_time ;
-  double init_time ;
-  double internal_force_time ;
-  double central_diff ;
-  double comm_time ;
-  size_t number_of_steps ;
-
-  PerformanceData()
-  : mesh_time(0)
-  , init_time(0)
-  , internal_force_time(0)
-  , central_diff(0)
-  , comm_time(0)
-  , number_of_steps(0)
-  {}
-
-  void best( const PerformanceData & rhs )
-  {
-    if ( rhs.mesh_time < mesh_time ) mesh_time = rhs.mesh_time ;
-    if ( rhs.init_time < init_time ) init_time = rhs.init_time ;
-    if ( rhs.internal_force_time < internal_force_time ) internal_force_time = rhs.internal_force_time ;
-    if ( rhs.central_diff < central_diff ) central_diff = rhs.central_diff ;
-    if ( rhs.comm_time < comm_time ) comm_time = rhs.comm_time ;
-  }
-};
-
-template< typename Scalar , class FixtureType >
-PerformanceData run( const typename FixtureType::FEMeshType & mesh ,
-                     const int global_max_x ,
-                     const int global_max_y ,
-                     const int global_max_z ,
-                     const int steps ,
-                     const int print_sample )
-{
-  typedef Scalar                              scalar_type ;
-  typedef FixtureType                         fixture_type ;
-  typedef typename fixture_type::execution_space  execution_space ;
-  //typedef typename fixture_type::FEMeshType   mesh_type ; // unused
-
-  enum { ElementNodeCount = fixture_type::element_node_count };
-
-  const int NumStates = 2;
-
-  const int total_num_steps = steps ;
-
-  const Scalar user_dt = 5.0e-6;
-  //const Scalar  end_time = 0.0050;
-
-  // element block parameters
-  const Scalar  lin_bulk_visc = 0.0;
-  const Scalar  quad_bulk_visc = 0.0;
-
-  // const Scalar  lin_bulk_visc = 0.06;
-  // const Scalar  quad_bulk_visc = 1.2;
-  // const Scalar  hg_stiffness = 0.0;
-  // const Scalar  hg_viscosity = 0.0;
-  // const Scalar  hg_stiffness = 0.03;
-  // const Scalar  hg_viscosity = 0.001;
-
-  // material properties
-  const Scalar youngs_modulus=1.0e6;
-  const Scalar poissons_ratio=0.0;
-  const Scalar  density = 8.0e-4;
-
-  const comm::Machine machine = mesh.parallel_data_map.machine ;
-
-  PerformanceData perf_data ;
-
-  Kokkos::Timer wall_clock ;
-
-  //------------------------------------
-  // Generate fields
-
-  typedef Fields< scalar_type , execution_space > fields_type ;
-
-  fields_type mesh_fields( mesh ,
-                           lin_bulk_visc ,
-                           quad_bulk_visc ,
-                           youngs_modulus ,
-                           poissons_ratio ,
-                           density );
-
-  typename fields_type::node_coords_type::HostMirror
-    model_coords_h = Kokkos::create_mirror( mesh_fields.model_coords );
-
-  typename fields_type::geom_state_array_type::HostMirror
-    displacement_h = Kokkos::create_mirror( mesh_fields.displacement );
-
-  typename fields_type::geom_state_array_type::HostMirror
-    velocity_h = Kokkos::create_mirror( mesh_fields.velocity );
-
-  Kokkos::deep_copy( model_coords_h , mesh_fields.model_coords );
-
-  //------------------------------------
-  // Initialization
-
-  initialize_element<Scalar,execution_space>::apply( mesh_fields );
-  initialize_node<   Scalar,execution_space>::apply( mesh_fields );
-
-  const Scalar x_bc = global_max_x ;
-
-  // Initial condition on velocity to initiate a pulse along the X axis
-  {
-    const unsigned X = 0;
-    for (int inode = 0; inode< mesh_fields.num_nodes; ++inode) {
-      if ( model_coords_h(inode,X) == 0) {
-        velocity_h(inode,X,0) = 1.0e3;
-        velocity_h(inode,X,1) = 1.0e3;
-      }
-    }
-  }
-
-  Kokkos::deep_copy( mesh_fields.velocity , velocity_h );
-
-  //--------------------------------------------------------------------------
-  // We will call a sequence of functions.  These functions have been
-  // grouped into several functors to balance the number of global memory
-  // accesses versus requiring too many registers or too much L1 cache.
-  // Global memory accees have read/write cost and memory subsystem contention cost.
-  //--------------------------------------------------------------------------
-
-  perf_data.init_time = comm::max( machine , wall_clock.seconds() );
-
-  // Parameters required for the internal force computations.
-
-  int current_state = 0;
-  int previous_state = 0;
-  int next_state = 0;
-
-  perf_data.number_of_steps = total_num_steps ;
-
-#if defined( KOKKOS_ENABLE_MPI )
-
-  typedef typename
-    fields_type::geom_state_array_type::value_type  comm_value_type ;
-
-  const unsigned comm_value_count = 6 ;
-
-  Kokkos::AsyncExchange< comm_value_type , execution_space ,
-                              Kokkos::ParallelDataMap >
-    comm_exchange( mesh.parallel_data_map , comm_value_count );
-
-#endif
-
-  for (int step = 0; step < total_num_steps; ++step) {
-
-    wall_clock.reset();
-
-    //------------------------------------------------------------------------
-#if defined( KOKKOS_ENABLE_MPI )
-    {
-      // Communicate "send" nodes' displacement and velocity next_state
-      // to the ghosted nodes.
-      // buffer packages: { { dx , dy , dz , vx , vy , vz }_node }
-
-      pack_state< Scalar , execution_space >
-        ::apply( comm_exchange.buffer() ,
-                 mesh.parallel_data_map.count_interior ,
-                 mesh.parallel_data_map.count_send ,
-                 mesh_fields , next_state );
-
-      comm_exchange.setup();
-
-      comm_exchange.send_receive();
-
-      unpack_state< Scalar , execution_space >
-        ::apply( mesh_fields , next_state ,
-                 comm_exchange.buffer() ,
-                 mesh.parallel_data_map.count_owned ,
-                 mesh.parallel_data_map.count_receive );
-
-      execution_space().fence();
-    }
-#endif
-
-    perf_data.comm_time += comm::max( machine , wall_clock.seconds() );
-
-    //------------------------------------------------------------------------
-    // rotate the states
-
-    previous_state = current_state;
-    current_state = next_state;
-    ++next_state;
-    next_state %= NumStates;
-
-    wall_clock.reset();
-
-    // First kernel 'grad_hgop' combines two functions:
-    // gradient, velocity gradient
-    grad< Scalar , execution_space >::apply( mesh_fields ,
-                                         current_state ,
-                                         previous_state );
-
-    // Combine tensor decomposition and rotation functions.
-    decomp_rotate< Scalar , execution_space >::apply( mesh_fields ,
-                                                  current_state ,
-                                                  previous_state );
-
-    internal_force< Scalar , execution_space >::apply( mesh_fields ,
-                                                   user_dt ,
-                                                   current_state );
-
-    execution_space().fence();
-
-    perf_data.internal_force_time +=
-      comm::max( machine , wall_clock.seconds() );
-
-    wall_clock.reset();
-
-    // Assembly of elements' contributions to nodal force into
-    // a nodal force vector.  Update the accelerations, velocities,
-    // displacements.
-    // The same pattern can be used for matrix-free residual computations.
-    nodal_step< Scalar , execution_space >::apply( mesh_fields ,
-                                               x_bc ,
-                                               current_state,
-                                               next_state );
-    execution_space().fence();
-
-    perf_data.central_diff +=
-      comm::max( machine , wall_clock.seconds() );
-
-    if ( print_sample && 0 == step % 100 ) {
-      Kokkos::deep_copy( displacement_h , mesh_fields.displacement );
-      Kokkos::deep_copy( velocity_h ,     mesh_fields.velocity );
-
-      if ( 1 == print_sample ) {
-
-        std::cout << "step " << step
-                  << " : displacement(*,0,0) =" ;
-        for ( int i = 0 ; i < mesh_fields.num_nodes_owned ; ++i ) {
-          if ( model_coords_h(i,1) == 0 && model_coords_h(i,2) == 0 ) {
-            std::cout << " " << displacement_h(i,0,next_state);
-          }
-        }
-        std::cout << std::endl ;
-
-        const float tol = 1.0e-6 ;
-        const int yb = global_max_y ;
-        const int zb = global_max_z ;
-        std::cout << "step " << step
-                  << " : displacement(*," << yb << "," << zb << ") =" ;
-        for ( int i = 0 ; i < mesh_fields.num_nodes_owned ; ++i ) {
-          if ( fabs( model_coords_h(i,1) - yb ) < tol &&
-               fabs( model_coords_h(i,2) - zb ) < tol ) {
-            std::cout << " " << displacement_h(i,0,next_state);
-          }
-        }
-        std::cout << std::endl ;
-      }
-      else if ( 2 == print_sample ) {
-
-        const float tol = 1.0e-6 ;
-        const int xb = global_max_x / 2 ;
-        const int yb = global_max_y / 2 ;
-        const int zb = global_max_z / 2 ;
-
-        for ( int i = 0 ; i < mesh_fields.num_nodes_owned ; ++i ) {
-          if ( fabs( model_coords_h(i,0) - xb ) < tol &&
-               fabs( model_coords_h(i,1) - yb ) < tol &&
-               fabs( model_coords_h(i,2) - zb ) < tol ) {
-            std::cout << "step " << step
-                      << " : displacement("
-                      << xb << "," << yb << "," << zb << ") = {"
-                      << std::setprecision(6)
-                      << " " << displacement_h(i,0,next_state)
-                      << std::setprecision(2)
-                      << " " << displacement_h(i,1,next_state)
-                      << std::setprecision(2)
-                      << " " << displacement_h(i,2,next_state)
-                      << " }" << std::endl ;
-          }
-        }
-      }
-    }
-  }
-
-  return perf_data ;
-}
-
-
-template <typename Scalar, typename Device>
-static void driver( const char * const label ,
-                    comm::Machine machine ,
-                    const int gang_count ,
-                    const int elem_count_beg ,
-                    const int elem_count_end ,
-                    const int runs )
-{
-  typedef Scalar              scalar_type ;
-  typedef Device              execution_space ;
-  typedef double              coordinate_scalar_type ;
-  typedef FixtureElementHex8  fixture_element_type ;
-
-  typedef BoxMeshFixture< coordinate_scalar_type ,
-                          execution_space ,
-                          fixture_element_type > fixture_type ;
-
-  typedef typename fixture_type::FEMeshType mesh_type ;
-
-  const size_t proc_count = comm::size( machine );
-  const size_t proc_rank  = comm::rank( machine );
-
-  const int space = 15 ;
-  const int steps = 1000 ;
-  const int print_sample = 0 ;
-
-  if ( comm::rank( machine ) == 0 ) {
-
-    std::cout << std::endl ;
-    std::cout << "\"MiniExplicitDynamics with Kokkos " << label
-              << " time_steps(" << steps << ")"
-              << "\"" << std::endl;
-    std::cout << std::left << std::setw(space) << "\"Element\" , ";
-    std::cout << std::left << std::setw(space) << "\"Node\" , ";
-    std::cout << std::left << std::setw(space) << "\"Initialize\" , ";
-    std::cout << std::left << std::setw(space) << "\"ElemForce\" , ";
-    std::cout << std::left << std::setw(space) << "\"NodeUpdate\" , ";
-    std::cout << std::left << std::setw(space) << "\"NodeComm\" , ";
-    std::cout << std::left << std::setw(space) << "\"Time/Elem\" , ";
-    std::cout << std::left << std::setw(space) << "\"Time/Node\"";
-
-    std::cout << std::endl;
-
-    std::cout << std::left << std::setw(space) << "\"count\" , ";
-    std::cout << std::left << std::setw(space) << "\"count\" , ";
-    std::cout << std::left << std::setw(space) << "\"microsec\" , ";
-    std::cout << std::left << std::setw(space) << "\"microsec\" , ";
-    std::cout << std::left << std::setw(space) << "\"microsec\" , ";
-    std::cout << std::left << std::setw(space) << "\"microsec\" , ";
-    std::cout << std::left << std::setw(space) << "\"microsec\" , ";
-    std::cout << std::left << std::setw(space) << "\"microsec\"";
-
-    std::cout << std::endl;
-  }
-
-  for(int i = elem_count_beg ; i < elem_count_end ; i *= 2 )
-  {
-    const int iz = std::max( 1 , (int) cbrt( ((double) i) / 2.0 ) );
-    const int iy = iz + 1 ;
-    const int ix = 2 * iy ;
-    const int nelem = ix * iy * iz ;
-    const int nnode = ( ix + 1 ) * ( iy + 1 ) * ( iz + 1 );
-
-    mesh_type mesh =
-      fixture_type::create( proc_count , proc_rank , gang_count ,
-                            ix , iy , iz );
-
-    mesh.parallel_data_map.machine = machine ;
-
-    PerformanceData perf , best ;
-
-    for(int j = 0; j < runs; j++){
-
-     perf = run<scalar_type,fixture_type>(mesh,ix,iy,iz,steps,print_sample);
-
-     if( j == 0 ) {
-       best = perf ;
-     }
-     else {
-       best.best( perf );
-     }
-   }
-
-   if ( comm::rank( machine ) == 0 ) {
-     double time_per_element =
-       ( best.internal_force_time ) / ( nelem * perf.number_of_steps );
-     double time_per_node =
-       ( best.comm_time + best.central_diff ) / ( nnode * perf.number_of_steps );
-
-   std::cout << std::setw(space-3) << nelem << " , "
-             << std::setw(space-3) << nnode << " , "
-             << std::setw(space-3) << best.number_of_steps << " , "
-             << std::setw(space-3) << best.init_time * 1000000 << " , "
-             << std::setw(space-3)
-             << ( best.internal_force_time * 1000000 ) / best.number_of_steps << " , "
-             << std::setw(space-3)
-             << ( best.central_diff * 1000000 ) / best.number_of_steps << " , "
-             << std::setw(space-3)
-             << ( best.comm_time * 1000000 ) / best.number_of_steps << " , "
-             << std::setw(space-3) << time_per_element * 1000000 << " , "
-             << std::setw(space-3) << time_per_node * 1000000
-             << std::endl ;
-    }
-  }
-}
-
-
-} // namespace Explicit
-
-#endif /* #ifndef EXPLICIT_DRIVER_HPP */
diff --git a/lib/kokkos/example/multi_fem/ExplicitFunctors.hpp b/lib/kokkos/example/multi_fem/ExplicitFunctors.hpp
deleted file mode 100644
index 764dca38dcff02b91282e262a6f6de24297270ca..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/ExplicitFunctors.hpp
+++ /dev/null
@@ -1,1471 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_EXPLICITFUNCTORS_HPP
-#define KOKKOS_EXPLICITFUNCTORS_HPP
-
-#include <cmath>
-#include <Kokkos_Core.hpp>
-#include <FEMesh.hpp>
-
-namespace Explicit {
-
-template<typename Scalar , class Device >
-struct Fields {
-
-  static const int NumStates     = 2 ;
-  static const int SpatialDim    = 3 ;
-  static const int ElemNodeCount = 8 ;
-
-  // Indices for full 3x3 tensor:
-
-  static const int K_F_XX = 0 ;
-  static const int K_F_YY = 1 ;
-  static const int K_F_ZZ = 2 ;
-  static const int K_F_XY = 3 ;
-  static const int K_F_YZ = 4 ;
-  static const int K_F_ZX = 5 ;
-  static const int K_F_YX = 6 ;
-  static const int K_F_ZY = 7 ;
-  static const int K_F_XZ = 8 ;
-
-  //  Indexes into a 3 by 3 symmetric tensor stored as a length 6 vector
-
-  static const int K_S_XX = 0 ;
-  static const int K_S_YY = 1 ;
-  static const int K_S_ZZ = 2 ;
-  static const int K_S_XY = 3 ;
-  static const int K_S_YZ = 4 ;
-  static const int K_S_ZX = 5 ;
-  static const int K_S_YX = 3 ;
-  static const int K_S_ZY = 4 ;
-  static const int K_S_XZ = 5 ;
-
-  //  Indexes into a 3 by 3 skew symmetric tensor stored as a length 3 vector
-
-  static const int K_V_XY = 0 ;
-  static const int K_V_YZ = 1 ;
-  static const int K_V_ZX = 2 ;
-
-
-  typedef Device                           execution_space ;
-  typedef typename execution_space::size_type  size_type ;
-
-  typedef HybridFEM::FEMesh<double,ElemNodeCount,execution_space>  FEMesh ;
-
-  typedef typename FEMesh::node_coords_type    node_coords_type ;
-  typedef typename FEMesh::elem_node_ids_type  elem_node_ids_type ;
-  typedef typename FEMesh::node_elem_ids_type  node_elem_ids_type ;
-  typedef typename Kokkos::ParallelDataMap   parallel_data_map ;
-
-  typedef Kokkos::View< double[][ SpatialDim ][ NumStates ] , execution_space > geom_state_array_type ;
-  typedef Kokkos::View< Scalar[][ SpatialDim ] , execution_space > geom_array_type ;
-  typedef Kokkos::View< Scalar[] ,               execution_space > array_type ;
-  typedef Kokkos::View< Scalar ,                 execution_space >  scalar_type ;
-
-  typedef Kokkos::View< Scalar[][  6 ] ,    execution_space >  elem_sym_tensor_type ;
-  typedef Kokkos::View< Scalar[][  9 ] ,    execution_space >  elem_tensor_type ;
-  typedef Kokkos::View< Scalar[][  9 ][ NumStates ] , execution_space >  elem_tensor_state_type ;
-  typedef Kokkos::View< Scalar[][ SpatialDim ][ ElemNodeCount ] , execution_space > elem_node_geom_type ;
-
-  // Parameters:
-  const int num_nodes ;
-  const int num_nodes_owned ;
-  const int num_elements ;
-
-  const Scalar  lin_bulk_visc;
-  const Scalar  quad_bulk_visc;
-  const Scalar  two_mu;
-  const Scalar  bulk_modulus;
-  const Scalar  density;
-
-  // Mesh:
-  const elem_node_ids_type  elem_node_connectivity ;
-  const node_elem_ids_type  node_elem_connectivity ;
-  const node_coords_type    model_coords ;
-
-  // Compute:
-  const scalar_type                dt ;
-  const scalar_type                prev_dt ;
-  const geom_state_array_type      displacement ;
-  const geom_state_array_type      velocity ;
-  const geom_array_type            acceleration ;
-  const geom_array_type            internal_force ;
-  const array_type                 nodal_mass ;
-  const array_type                 elem_mass ;
-  const array_type                 internal_energy ;
-  const elem_sym_tensor_type       stress_new ;
-  const elem_tensor_state_type     rotation ;
-  const elem_node_geom_type        element_force ;
-  const elem_tensor_type           vel_grad ;
-  const elem_sym_tensor_type       stretch ;
-  const elem_sym_tensor_type       rot_stretch ;
-
-  Fields(
-      const FEMesh & mesh,
-      Scalar arg_lin_bulk_visc,
-      Scalar arg_quad_bulk_visc,
-      Scalar youngs_modulus,
-      Scalar poissons_ratio,
-      Scalar arg_density )
-    : num_nodes(       mesh.parallel_data_map.count_owned +
-                       mesh.parallel_data_map.count_receive )
-    , num_nodes_owned( mesh.parallel_data_map.count_owned )
-    , num_elements(    mesh.elem_node_ids.dimension_0() )
-    , lin_bulk_visc(  arg_lin_bulk_visc )
-    , quad_bulk_visc( arg_quad_bulk_visc )
-    , two_mu(youngs_modulus/(1.0+poissons_ratio))
-    , bulk_modulus(youngs_modulus/(3*(1.0-2.0*poissons_ratio)))
-    , density(arg_density)
-
-    // mesh
-
-    , elem_node_connectivity( mesh.elem_node_ids ) // ( num_elements , ElemNodeCount )
-    , node_elem_connectivity( mesh.node_elem_ids ) // ( num_nodes , ... )
-    , model_coords(  mesh.node_coords )            // ( num_nodes , 3 )
-
-    // compute with input/output
-
-    , dt(              "dt" )
-    , prev_dt(         "prev_dt" )
-    , displacement(    "displacement" ,   num_nodes )
-    , velocity(        "velocity" ,       num_nodes )
-    , acceleration(    "acceleration" ,   num_nodes_owned )
-    , internal_force(  "internal_force" , num_nodes_owned )
-    , nodal_mass(      "nodal_mass" ,     num_nodes_owned )
-    , elem_mass(       "elem_mass" ,       num_elements )
-    , internal_energy( "internal_energy" , num_elements )
-    , stress_new(      "stress_new" ,      num_elements )
-
-    // temporary arrays
-
-    , rotation(      "rotation" ,  num_elements )
-    , element_force( "element_force" ,  num_elements )
-    , vel_grad(      "vel_grad" , num_elements )
-    , stretch(       "stretch" , num_elements )
-    , rot_stretch(   "rot_stretch" , num_elements )
-  { }
-};
-
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class DeviceType >
-KOKKOS_INLINE_FUNCTION
-Scalar dot8( const Scalar * a , const Scalar * b )
-{ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3] +
-         a[4] * b[4] + a[5] * b[5] + a[6] * b[6] + a[7] * b[7] ; }
-
-template< typename Scalar , class DeviceType >
-KOKKOS_INLINE_FUNCTION
-void comp_grad( const Scalar * const x ,
-                const Scalar * const y ,
-                const Scalar * const z,
-                Scalar * const grad_x ,
-                Scalar * const grad_y ,
-                Scalar * const grad_z )
-{
-  //  calc X difference vectors
-
-  Scalar R42=(x[3] - x[1]);
-  Scalar R52=(x[4] - x[1]);
-  Scalar R54=(x[4] - x[3]);
-
-  Scalar R63=(x[5] - x[2]);
-  Scalar R83=(x[7] - x[2]);
-  Scalar R86=(x[7] - x[5]);
-
-  Scalar R31=(x[2] - x[0]);
-  Scalar R61=(x[5] - x[0]);
-  Scalar R74=(x[6] - x[3]);
-
-  Scalar R72=(x[6] - x[1]);
-  Scalar R75=(x[6] - x[4]);
-  Scalar R81=(x[7] - x[0]);
-
-  Scalar t1=(R63 + R54);
-  Scalar t2=(R61 + R74);
-  Scalar t3=(R72 + R81);
-
-  Scalar t4 =(R86 + R42);
-  Scalar t5 =(R83 + R52);
-  Scalar t6 =(R75 + R31);
-
-  //  Calculate Y gradient from X and Z data
-
-  grad_y[0] = (z[1] *  t1) - (z[2] * R42) - (z[3] *  t5)  + (z[4] *  t4) + (z[5] * R52) - (z[7] * R54);
-  grad_y[1] = (z[2] *  t2) + (z[3] * R31) - (z[0] *  t1)  - (z[5] *  t6) + (z[6] * R63) - (z[4] * R61);
-  grad_y[2] = (z[3] *  t3) + (z[0] * R42) - (z[1] *  t2)  - (z[6] *  t4) + (z[7] * R74) - (z[5] * R72);
-  grad_y[3] = (z[0] *  t5) - (z[1] * R31) - (z[2] *  t3)  + (z[7] *  t6) + (z[4] * R81) - (z[6] * R83);
-  grad_y[4] = (z[5] *  t3) + (z[6] * R86) - (z[7] *  t2)  - (z[0] *  t4) - (z[3] * R81) + (z[1] * R61);
-  grad_y[5] = (z[6] *  t5) - (z[4] *  t3)  - (z[7] * R75) + (z[1] *  t6) - (z[0] * R52) + (z[2] * R72);
-  grad_y[6] = (z[7] *  t1) - (z[5] *  t5)  - (z[4] * R86) + (z[2] *  t4) - (z[1] * R63) + (z[3] * R83);
-  grad_y[7] = (z[4] *  t2) - (z[6] *  t1)  + (z[5] * R75) - (z[3] *  t6) - (z[2] * R74) + (z[0] * R54);
-
-  //   calc Z difference vectors
-
-  R42=(z[3] - z[1]);
-  R52=(z[4] - z[1]);
-  R54=(z[4] - z[3]);
-
-  R63=(z[5] - z[2]);
-  R83=(z[7] - z[2]);
-  R86=(z[7] - z[5]);
-
-  R31=(z[2] - z[0]);
-  R61=(z[5] - z[0]);
-  R74=(z[6] - z[3]);
-
-  R72=(z[6] - z[1]);
-  R75=(z[6] - z[4]);
-  R81=(z[7] - z[0]);
-
-  t1=(R63 + R54);
-  t2=(R61 + R74);
-  t3=(R72 + R81);
-
-  t4 =(R86 + R42);
-  t5 =(R83 + R52);
-  t6 =(R75 + R31);
-
-  //  Calculate X gradient from Y and Z data
-
-  grad_x[0] = (y[1] *  t1) - (y[2] * R42) - (y[3] *  t5) + (y[4] *  t4) + (y[5] * R52) - (y[7] * R54);
-  grad_x[1] = (y[2] *  t2) + (y[3] * R31) - (y[0] *  t1) - (y[5] *  t6) + (y[6] * R63) - (y[4] * R61);
-  grad_x[2] = (y[3] *  t3) + (y[0] * R42) - (y[1] *  t2) - (y[6] *  t4) + (y[7] * R74) - (y[5] * R72);
-  grad_x[3] = (y[0] *  t5) - (y[1] * R31) - (y[2] *  t3) + (y[7] *  t6) + (y[4] * R81) - (y[6] * R83);
-  grad_x[4] = (y[5] *  t3) + (y[6] * R86) - (y[7] *  t2) - (y[0] *  t4) - (y[3] * R81) + (y[1] * R61);
-  grad_x[5] = (y[6] *  t5) - (y[4] *  t3) - (y[7] * R75) + (y[1] *  t6) - (y[0] * R52) + (y[2] * R72);
-  grad_x[6] = (y[7] *  t1) - (y[5] *  t5) - (y[4] * R86) + (y[2] *  t4) - (y[1] * R63) + (y[3] * R83);
-  grad_x[7] = (y[4] *  t2) - (y[6] *  t1) + (y[5] * R75) - (y[3] *  t6) - (y[2] * R74) + (y[0] * R54);
-
-  //  calc Y difference vectors
-
-  R42=(y[3] - y[1]);
-  R52=(y[4] - y[1]);
-  R54=(y[4] - y[3]);
-
-  R63=(y[5] - y[2]);
-  R83=(y[7] - y[2]);
-  R86=(y[7] - y[5]);
-
-  R31=(y[2] - y[0]);
-  R61=(y[5] - y[0]);
-  R74=(y[6] - y[3]);
-
-  R72=(y[6] - y[1]);
-  R75=(y[6] - y[4]);
-  R81=(y[7] - y[0]);
-
-  t1=(R63 + R54);
-  t2=(R61 + R74);
-  t3=(R72 + R81);
-
-  t4 =(R86 + R42);
-  t5 =(R83 + R52);
-  t6 =(R75 + R31);
-
-  //  Calculate Z gradient from X and Y data
-
-  grad_z[0] = (x[1] *  t1) - (x[2] * R42) - (x[3] *  t5)  + (x[4] *  t4) + (x[5] * R52) - (x[7] * R54);
-  grad_z[1] = (x[2] *  t2) + (x[3] * R31) - (x[0] *  t1)  - (x[5] *  t6) + (x[6] * R63) - (x[4] * R61);
-  grad_z[2] = (x[3] *  t3) + (x[0] * R42) - (x[1] *  t2)  - (x[6] *  t4) + (x[7] * R74) - (x[5] * R72);
-  grad_z[3] = (x[0] *  t5) - (x[1] * R31) - (x[2] *  t3)  + (x[7] *  t6) + (x[4] * R81) - (x[6] * R83);
-  grad_z[4] = (x[5] *  t3) + (x[6] * R86) - (x[7] *  t2)  - (x[0] *  t4) - (x[3] * R81) + (x[1] * R61);
-  grad_z[5] = (x[6] *  t5) - (x[4] *  t3)  - (x[7] * R75) + (x[1] *  t6) - (x[0] * R52) + (x[2] * R72);
-  grad_z[6] = (x[7] *  t1) - (x[5] *  t5)  - (x[4] * R86) + (x[2] *  t4) - (x[1] * R63) + (x[3] * R83);
-  grad_z[7] = (x[4] *  t2) - (x[6] *  t1)  + (x[5] * R75) - (x[3] *  t6) - (x[2] * R74) + (x[0] * R54);
-}
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class DeviceType >
-struct initialize_element
-{
-  typedef DeviceType     execution_space ;
-
-  typedef Explicit::Fields< Scalar , execution_space > Fields ;
-
-  typename Fields::elem_node_ids_type      elem_node_connectivity ;
-  typename Fields::node_coords_type        model_coords ;
-  typename Fields::elem_sym_tensor_type    stretch ;
-  typename Fields::elem_tensor_state_type  rotation ;
-  typename Fields::array_type              elem_mass ;
-
-  const Scalar density ;
-
-  initialize_element( const Fields & mesh_fields )
-    : elem_node_connectivity( mesh_fields.elem_node_connectivity )
-    , model_coords(           mesh_fields.model_coords )
-    , stretch(                mesh_fields.stretch )
-    , rotation(               mesh_fields.rotation )
-    , elem_mass(              mesh_fields.elem_mass )
-    , density(                mesh_fields.density )
-    {}
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( int ielem )const
-  {
-    const int K_XX = 0 ;
-    const int K_YY = 1 ;
-    const int K_ZZ = 2 ;
-    const Scalar ONE12TH = 1.0 / 12.0 ;
-
-    Scalar x[ Fields::ElemNodeCount ];
-    Scalar y[ Fields::ElemNodeCount ];
-    Scalar z[ Fields::ElemNodeCount ];
-    Scalar grad_x[ Fields::ElemNodeCount ];
-    Scalar grad_y[ Fields::ElemNodeCount ];
-    Scalar grad_z[ Fields::ElemNodeCount ];
-
-    for ( int i = 0 ; i < Fields::ElemNodeCount ; ++i ) {
-      const int n = elem_node_connectivity( ielem , i );
-
-      x[i]  = model_coords( n , 0 );
-      y[i]  = model_coords( n , 1 );
-      z[i]  = model_coords( n , 2 );
-    }
-
-    comp_grad<Scalar,execution_space>( x, y, z, grad_x, grad_y, grad_z);
-
-    stretch(ielem,K_XX) = 1 ;
-    stretch(ielem,K_YY) = 1 ;
-    stretch(ielem,K_ZZ) = 1 ;
-
-    rotation(ielem,K_XX,0) = 1 ;
-    rotation(ielem,K_YY,0) = 1 ;
-    rotation(ielem,K_ZZ,0) = 1 ;
-
-    rotation(ielem,K_XX,1) = 1 ;
-    rotation(ielem,K_YY,1) = 1 ;
-    rotation(ielem,K_ZZ,1) = 1 ;
-
-    elem_mass(ielem) = ONE12TH * density *
-                                 dot8<Scalar,execution_space>( x , grad_x );
-  }
-
-  static void apply( const Fields & mesh_fields )
-  {
-    initialize_element op( mesh_fields );
-    Kokkos::parallel_for( mesh_fields.num_elements , op );
-  }
-};
-
-
-template<typename Scalar , class DeviceType >
-struct initialize_node
-{
-  typedef DeviceType     execution_space ;
-
-  typedef Explicit::Fields< Scalar , execution_space > Fields ;
-
-  typename Fields::node_elem_ids_type      node_elem_connectivity ;
-  typename Fields::array_type              nodal_mass ;
-  typename Fields::array_type              elem_mass ;
-
-  static const int ElemNodeCount = Fields::ElemNodeCount ;
-
-  initialize_node( const Fields & mesh_fields )
-    : node_elem_connectivity( mesh_fields.node_elem_connectivity )
-    , nodal_mass(             mesh_fields.nodal_mass )
-    , elem_mass(              mesh_fields.elem_mass )
-    {}
-
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( int inode )const
-  {
-    const int begin = node_elem_connectivity.row_map[inode];
-    const int end   = node_elem_connectivity.row_map[inode+1];
-
-    Scalar node_mass = 0;
-
-    for(int i = begin; i != end; ++i) {
-      const int elem_id = node_elem_connectivity.entries( i , 0 );
-      node_mass += elem_mass(elem_id);
-    }
-
-    nodal_mass(inode) = node_mass / ElemNodeCount ;
-  }
-
-  static void apply( const Fields & mesh_fields )
-  {
-    initialize_node op( mesh_fields );
-    Kokkos::parallel_for( mesh_fields.num_nodes_owned , op );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-
-template<typename Scalar, class DeviceType >
-struct grad
-{
-  typedef DeviceType execution_space ;
-
-  typedef Explicit::Fields< Scalar , execution_space >  Fields ;
-
-  static const int ElemNodeCount = Fields::ElemNodeCount ;
-
-  static const int K_F_XX = Fields::K_F_XX ;
-  static const int K_F_YY = Fields::K_F_YY ;
-  static const int K_F_ZZ = Fields::K_F_ZZ ;
-  static const int K_F_XY = Fields::K_F_XY ;
-  static const int K_F_YZ = Fields::K_F_YZ ;
-  static const int K_F_ZX = Fields::K_F_ZX ;
-  static const int K_F_YX = Fields::K_F_YX ;
-  static const int K_F_ZY = Fields::K_F_ZY ;
-  static const int K_F_XZ = Fields::K_F_XZ ;
-
-  // Global arrays used by this functor.
-
-  const typename Fields::elem_node_ids_type     elem_node_connectivity ;
-  const typename Fields::node_coords_type       model_coords ;
-  const typename Fields::geom_state_array_type  displacement ;
-  const typename Fields::geom_state_array_type  velocity ;
-  const typename Fields::elem_tensor_type       vel_grad ;
-  const typename Fields::scalar_type            dt ;
-
-  const int  current_state;
-  const int  previous_state;
-
-  // Constructor on the Host to populate this device functor.
-  // All array view copies are shallow.
-  grad( const Fields &  fields,
-        const int arg_current_state,
-        const int arg_previous_state)
-    : elem_node_connectivity( fields.elem_node_connectivity)
-    , model_coords( fields.model_coords)
-    , displacement( fields.displacement)
-    , velocity( fields.velocity)
-    , vel_grad( fields.vel_grad)
-    , dt(  fields.dt)
-    , current_state(arg_current_state)
-    , previous_state(arg_previous_state)
-    { }
-
-  //--------------------------------------------------------------------------
-
-    //   Calculate Velocity Gradients
-    KOKKOS_INLINE_FUNCTION
-    void v_grad(  int ielem,
-      Scalar * vx,       Scalar * vy,       Scalar * vz,
-      Scalar * grad_x,     Scalar * grad_y,     Scalar * grad_z,
-      Scalar inv_vol) const
-    {
-      const int K_F_XX = Fields::K_F_XX ;
-      const int K_F_YY = Fields::K_F_YY ;
-      const int K_F_ZZ = Fields::K_F_ZZ ;
-      const int K_F_XY = Fields::K_F_XY ;
-      const int K_F_YZ = Fields::K_F_YZ ;
-      const int K_F_ZX = Fields::K_F_ZX ;
-      const int K_F_YX = Fields::K_F_YX ;
-      const int K_F_ZY = Fields::K_F_ZY ;
-      const int K_F_XZ = Fields::K_F_XZ ;
-
-      vel_grad(ielem, K_F_XX) = inv_vol * dot8<Scalar,execution_space>( vx , grad_x );
-      vel_grad(ielem, K_F_YX) = inv_vol * dot8<Scalar,execution_space>( vy , grad_x );
-      vel_grad(ielem, K_F_ZX) = inv_vol * dot8<Scalar,execution_space>( vz , grad_x );
-
-      vel_grad(ielem, K_F_XY) = inv_vol * dot8<Scalar,execution_space>( vx , grad_y );
-      vel_grad(ielem, K_F_YY) = inv_vol * dot8<Scalar,execution_space>( vy , grad_y );
-      vel_grad(ielem, K_F_ZY) = inv_vol * dot8<Scalar,execution_space>( vz , grad_y );
-
-      vel_grad(ielem, K_F_XZ) = inv_vol * dot8<Scalar,execution_space>( vx , grad_z );
-      vel_grad(ielem, K_F_YZ) = inv_vol * dot8<Scalar,execution_space>( vy , grad_z );
-      vel_grad(ielem, K_F_ZZ) = inv_vol * dot8<Scalar,execution_space>( vz , grad_z );
-    }
-
-  //--------------------------------------------------------------------------
-  // Functor operator() which calls the three member functions.
-
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( int ielem )const
-  {
-    const int X = 0 ;
-    const int Y = 1 ;
-    const int Z = 2 ;
-    const Scalar dt_scale = -0.5 * dt();
-
-    //  declare and reuse local data for frequently accessed data to
-    //  reduce global memory reads and writes.
-
-    Scalar      x[8],      y[8],      z[8];
-    Scalar     vx[8],     vy[8],     vz[8];
-    Scalar grad_x[8], grad_y[8], grad_z[8];
-
-    // Read global velocity once and use many times
-    // via local registers / L1 cache.
-    //  store the velocity information in local memory before using,
-    //  so it can be returned for other functions to use
-
-    // Read global coordinates and velocity once and use many times
-    // via local registers / L1 cache.
-    // load X coordinate information and move by half time step
-
-    for ( int i = 0 ; i < ElemNodeCount ; ++i ) {
-      const int n = elem_node_connectivity( ielem , i );
-
-      vx[i] = velocity( n , X , current_state );
-      vy[i] = velocity( n , Y , current_state );
-      vz[i] = velocity( n , Z , current_state );
-
-      x[i]  = model_coords( n , X ) +
-              displacement( n , X , current_state ) +
-              dt_scale * vx[i];
-
-      y[i]  = model_coords( n , Y ) +
-              displacement( n , Y , current_state ) +
-              dt_scale * vy[i];
-
-      z[i]  = model_coords( n , Z ) +
-              displacement( n , Z , current_state ) +
-              dt_scale * vz[i];
-    }
-
-    comp_grad<Scalar,execution_space>( x, y, z, grad_x, grad_y, grad_z);
-
-    //  Calculate hexahedral volume from x model_coords and gradient information
-
-    const Scalar inv_vol = 1.0 / dot8<Scalar,execution_space>( x , grad_x );
-
-    v_grad(ielem, vx, vy, vz, grad_x, grad_y, grad_z, inv_vol);
-  }
-
-  static void apply( const Fields & fields ,
-                     const int arg_current_state ,
-                     const int arg_previous_state )
-  {
-    grad op( fields, arg_current_state , arg_previous_state );
-    Kokkos::parallel_for( fields.num_elements , op );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template<typename Scalar, class DeviceType >
-struct decomp_rotate
-{
-  typedef DeviceType execution_space ;
-
-  typedef Explicit::Fields< Scalar , execution_space >  Fields ;
-
-  static const int ElemNodeCount = Fields::ElemNodeCount ;
-
-  static const int K_F_XX = Fields::K_F_XX ;
-  static const int K_F_YY = Fields::K_F_YY ;
-  static const int K_F_ZZ = Fields::K_F_ZZ ;
-  static const int K_F_XY = Fields::K_F_XY ;
-  static const int K_F_YZ = Fields::K_F_YZ ;
-  static const int K_F_ZX = Fields::K_F_ZX ;
-  static const int K_F_YX = Fields::K_F_YX ;
-  static const int K_F_ZY = Fields::K_F_ZY ;
-  static const int K_F_XZ = Fields::K_F_XZ ;
-
-  static const int K_S_XX = Fields::K_S_XX ;
-  static const int K_S_YY = Fields::K_S_YY ;
-  static const int K_S_ZZ = Fields::K_S_ZZ ;
-  static const int K_S_XY = Fields::K_S_XY ;
-  static const int K_S_YZ = Fields::K_S_YZ ;
-  static const int K_S_ZX = Fields::K_S_ZX ;
-  static const int K_S_YX = Fields::K_S_YX ;
-  static const int K_S_ZY = Fields::K_S_ZY ;
-  static const int K_S_XZ = Fields::K_S_XZ ;
-
-  static const int K_V_XY = Fields::K_V_XY ;
-  static const int K_V_YZ = Fields::K_V_YZ ;
-  static const int K_V_ZX = Fields::K_V_ZX ;
-
-  // Global arrays used by this functor.
-
-  const typename Fields::elem_tensor_state_type     rotation ;
-  const typename Fields::elem_tensor_type           vel_grad ;
-  const typename Fields::elem_sym_tensor_type       stretch ;
-  const typename Fields::elem_sym_tensor_type       rot_stretch ;
-  const typename Fields::scalar_type                dt_value ;
-
-  const int  current_state;
-  const int  previous_state;
-
-  decomp_rotate( const Fields & mesh_fields ,
-                 const int arg_current_state,
-                 const int arg_previous_state)
-    : rotation(    mesh_fields.rotation )
-    , vel_grad(    mesh_fields.vel_grad )
-    , stretch(     mesh_fields.stretch )
-    , rot_stretch( mesh_fields.rot_stretch )
-    , dt_value(    mesh_fields.dt)
-    , current_state( arg_current_state)
-    , previous_state(arg_previous_state)
-    {}
-
-  static void apply( const Fields & mesh_fields ,
-                     const int arg_current_state ,
-                     const int arg_previous_state )
-  {
-    decomp_rotate op( mesh_fields , arg_current_state , arg_previous_state );
-    Kokkos::parallel_for( mesh_fields.num_elements , op );
-  }
-
-
-  KOKKOS_INLINE_FUNCTION
-  void additive_decomp(int ielem, Scalar * v_gr, Scalar * str_ten) const
-  {
-    //  In addition to calculating stretching_tensor,
-    //  use this as an opportunity to load global
-    //  variables into a local space
-
-    for ( int i = 0 ; i < 9 ; ++i ) {
-      v_gr[i] = vel_grad( ielem , i );
-    }
-
-    //
-    //  Symmetric part
-    //
-    str_ten[K_S_XX] = v_gr[K_F_XX];
-    str_ten[K_S_YY] = v_gr[K_F_YY];
-    str_ten[K_S_ZZ] = v_gr[K_F_ZZ];
-    str_ten[K_S_XY] = 0.5*(v_gr[K_F_XY] + v_gr[K_F_YX]);
-    str_ten[K_S_YZ] = 0.5*(v_gr[K_F_YZ] + v_gr[K_F_ZY]);
-    str_ten[K_S_ZX] = 0.5*(v_gr[K_F_ZX] + v_gr[K_F_XZ]);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void polar_decomp(int ielem, Scalar * v_gr, Scalar * str_ten, Scalar * str, Scalar * vort, Scalar * rot_old, Scalar * rot_new)const
-  {
-    const Scalar dt = dt_value();
-    const Scalar dt_half = 0.5 * dt;
-
-    //  Skew Symmetric part
-    vort[K_V_XY] = 0.5*(v_gr[K_F_XY] - v_gr[K_F_YX]);
-    vort[K_V_YZ] = 0.5*(v_gr[K_F_YZ] - v_gr[K_F_ZY]);
-    vort[K_V_ZX] = 0.5*(v_gr[K_F_ZX] - v_gr[K_F_XZ]);
-
-    //   calculate the rates of rotation via gauss elimination.
-    for ( int i = 0 ; i < 6 ; ++i ) {
-      str[i] = stretch(ielem, i);
-    }
-
-    Scalar z1 = str_ten[K_S_XY] * str[K_S_ZX] -
-                str_ten[K_S_ZX] * str[K_S_XY] +
-                str_ten[K_S_YY] * str[K_S_YZ] -
-                str_ten[K_S_YZ] * str[K_S_YY] +
-                str_ten[K_S_YZ] * str[K_S_ZZ] -
-                str_ten[K_S_ZZ] * str[K_S_YZ];
-
-    Scalar z2 = str_ten[K_S_ZX] * str[K_S_XX] -
-                str_ten[K_S_XX] * str[K_S_ZX] +
-                str_ten[K_S_YZ] * str[K_S_XY] -
-                str_ten[K_S_XY] * str[K_S_YZ] +
-                str_ten[K_S_ZZ] * str[K_S_ZX] -
-                str_ten[K_S_ZX] * str[K_S_ZZ];
-
-    Scalar z3 = str_ten[K_S_XX] * str[K_S_XY] -
-                str_ten[K_S_XY] * str[K_S_XX] +
-                str_ten[K_S_XY] * str[K_S_YY] -
-                str_ten[K_S_YY] * str[K_S_XY] +
-                str_ten[K_S_ZX] * str[K_S_YZ] -
-                str_ten[K_S_YZ] * str[K_S_ZX];
-
-  //   forward elimination
-    const Scalar a1inv = 1.0 / (str[K_S_YY] + str[K_S_ZZ]);
-
-    const Scalar a4BYa1 = -1 * str[K_S_XY] * a1inv;
-
-    const Scalar a2inv = 1.0 / (str[K_S_ZZ] + str[K_S_XX] + str[K_S_XY] * a4BYa1);
-
-    const Scalar a5 =  -str[K_S_YZ] + str[K_S_ZX] * a4BYa1;
-
-    z2 -= z1 * a4BYa1;
-    Scalar a6BYa1 = -1 * str[K_S_ZX] * a1inv;
-    const Scalar a5BYa2 = a5 * a2inv;
-    z3 -= z1 * a6BYa1 - z2 * a5BYa2;
-
-  //   backward substitution -
-    z3 /= (str[K_S_XX] + str[K_S_YY] + str[K_S_ZX] * a6BYa1 + a5 * a5BYa2);
-    z2 = (z2 - a5 * z3) * a2inv;
-    z1 = (z1*a1inv - a6BYa1 * z3 -a4BYa1 * z2);
-
-  //   calculate rotation rates - recall that spin_rate is an asymmetric tensor,
-  //   so compute spin rate vector as dual of spin rate tensor,
-  //   i.e   w_i = e_ijk * spin_rate_jk
-    z1 += vort[K_V_YZ];
-    z2 += vort[K_V_ZX];
-    z3 += vort[K_V_XY];
-
-  //   update rotation tensor:
-  //  1) premultiply old rotation tensor to get right-hand side.
-
-    for ( int i = 0 ; i < 9 ; ++i ) {
-      rot_old[i] = rotation(ielem, i, previous_state);
-    }
-
-    Scalar r_XX = rot_old[K_F_XX] + dt_half*( z3 * rot_old[K_F_YX] - z2 * rot_old[K_F_ZX] );
-    Scalar r_YX = rot_old[K_F_YX] + dt_half*( z1 * rot_old[K_F_ZX] - z3 * rot_old[K_F_XX] );
-    Scalar r_ZX = rot_old[K_F_ZX] + dt_half*( z2 * rot_old[K_F_XX] - z1 * rot_old[K_F_YX] );
-    Scalar r_XY = rot_old[K_F_XY] + dt_half*( z3 * rot_old[K_F_YY] - z2 * rot_old[K_F_ZY] );
-    Scalar r_YY = rot_old[K_F_YY] + dt_half*( z1 * rot_old[K_F_ZY] - z3 * rot_old[K_F_XY] );
-    Scalar r_ZY = rot_old[K_F_ZY] + dt_half*( z2 * rot_old[K_F_XY] - z1 * rot_old[K_F_YY] );
-    Scalar r_XZ = rot_old[K_F_XZ] + dt_half*( z3 * rot_old[K_F_YZ] - z2 * rot_old[K_F_ZZ] );
-    Scalar r_YZ = rot_old[K_F_YZ] + dt_half*( z1 * rot_old[K_F_ZZ] - z3 * rot_old[K_F_XZ] );
-    Scalar r_ZZ = rot_old[K_F_ZZ] + dt_half*( z2 * rot_old[K_F_XZ] - z1 * rot_old[K_F_YZ] );
-
-
-  //  2) solve for new rotation tensor via gauss elimination.
-  //   forward elimination -
-    Scalar a12 = - dt_half * z3;
-    Scalar a13 =   dt_half * z2;
-    Scalar b32 = - dt_half * z1;
-    Scalar a22inv = 1.0 / (1.0 + a12 * a12);
-
-    Scalar a13a12 = a13*a12;
-    Scalar a23 = b32 + a13a12;
-    r_YX += r_XX * a12;
-    r_YY += r_XY * a12;
-    r_YZ += r_XZ * a12;
-
-
-    b32 = (b32 - a13a12) * a22inv;
-    r_ZX += r_XX * a13 + r_YX * b32;
-    r_ZY += r_XY * a13 + r_YY * b32;
-    r_ZZ += r_XZ * a13 + r_YZ * b32;
-
-
-  //   backward substitution -
-    const Scalar a33inv = 1.0 / (1.0 + a13 * a13 + a23 * b32);
-
-    rot_new[K_F_ZX] = r_ZX * a33inv;
-    rot_new[K_F_ZY] = r_ZY * a33inv;
-    rot_new[K_F_ZZ] = r_ZZ * a33inv;
-    rot_new[K_F_YX] = ( r_YX - rot_new[K_F_ZX] * a23 ) * a22inv;
-    rot_new[K_F_YY] = ( r_YY - rot_new[K_F_ZY] * a23 ) * a22inv;
-    rot_new[K_F_YZ] = ( r_YZ - rot_new[K_F_ZZ] * a23 ) * a22inv;
-    rot_new[K_F_XX] = r_XX - rot_new[K_F_ZX] * a13 - rot_new[K_F_YX] * a12;
-    rot_new[K_F_XY] = r_XY - rot_new[K_F_ZY] * a13 - rot_new[K_F_YY] * a12;
-    rot_new[K_F_XZ] = r_XZ - rot_new[K_F_ZZ] * a13 - rot_new[K_F_YZ] * a12;
-
-    for ( int i = 0 ; i < 9 ; ++i ) {
-      rotation(ielem, i, current_state) = rot_new[i] ;
-    }
-
-  //   update stretch tensor in the new configuration -
-    const Scalar a1 = str_ten[K_S_XY] + vort[K_V_XY];
-    const Scalar a2 = str_ten[K_S_YZ] + vort[K_V_YZ];
-    const Scalar a3 = str_ten[K_S_ZX] + vort[K_V_ZX];
-    const Scalar b1 = str_ten[K_S_ZX] - vort[K_V_ZX];
-    const Scalar b2 = str_ten[K_S_XY] - vort[K_V_XY];
-    const Scalar b3 = str_ten[K_S_YZ] - vort[K_V_YZ];
-
-    const Scalar s_XX = str[K_S_XX];
-    const Scalar s_YY = str[K_S_YY];
-    const Scalar s_ZZ = str[K_S_ZZ];
-    const Scalar s_XY = str[K_S_XY];
-    const Scalar s_YZ = str[K_S_YZ];
-    const Scalar s_ZX = str[K_S_ZX];
-
-    str[K_S_XX] += dt * (str_ten[K_S_XX] * s_XX + ( a1 + z3 ) * s_XY + ( b1 - z2 ) * s_ZX);
-    str[K_S_YY] += dt * (str_ten[K_S_YY] * s_YY + ( a2 + z1 ) * s_YZ + ( b2 - z3 ) * s_XY);
-    str[K_S_ZZ] += dt * (str_ten[K_S_ZZ] * s_ZZ + ( a3 + z2 ) * s_ZX + ( b3 - z1 ) * s_YZ);
-    str[K_S_XY] += dt * (str_ten[K_S_XX] * s_XY + ( a1 )      * s_YY + ( b1      ) * s_YZ - z3 * s_XX + z1 * s_ZX);
-    str[K_S_YZ] += dt * (str_ten[K_S_YY] * s_YZ + ( a2 )      * s_ZZ + ( b2      ) * s_ZX - z1 * s_YY + z2 * s_XY);
-    str[K_S_ZX] += dt * (str_ten[K_S_ZZ] * s_ZX + ( a3 )      * s_XX + ( b3      ) * s_XY - z2 * s_ZZ + z3 * s_YZ);
-
-  }
-
-
-  KOKKOS_INLINE_FUNCTION
-  void rotate_tensor(int ielem, Scalar * str_ten, Scalar * str, Scalar * rot_new)const {
-
-    Scalar t[9];
-    Scalar rot_str[6]; // Rotated stretch
-
-    t[0] = str_ten[K_S_XX]*rot_new[K_F_XX] +
-           str_ten[K_S_XY]*rot_new[K_F_YX] +
-           str_ten[K_S_XZ]*rot_new[K_F_ZX];
-
-    t[1] = str_ten[K_S_YX]*rot_new[K_F_XX] +
-           str_ten[K_S_YY]*rot_new[K_F_YX] +
-           str_ten[K_S_YZ]*rot_new[K_F_ZX];
-
-    t[2] = str_ten[K_S_ZX]*rot_new[K_F_XX] +
-           str_ten[K_S_ZY]*rot_new[K_F_YX] +
-           str_ten[K_S_ZZ]*rot_new[K_F_ZX];
-
-    t[3] = str_ten[K_S_XX]*rot_new[K_F_XY] +
-           str_ten[K_S_XY]*rot_new[K_F_YY] +
-           str_ten[K_S_XZ]*rot_new[K_F_ZY];
-
-    t[4] = str_ten[K_S_YX]*rot_new[K_F_XY] +
-           str_ten[K_S_YY]*rot_new[K_F_YY] +
-           str_ten[K_S_YZ]*rot_new[K_F_ZY];
-
-    t[5] = str_ten[K_S_ZX]*rot_new[K_F_XY] +
-           str_ten[K_S_ZY]*rot_new[K_F_YY] +
-           str_ten[K_S_ZZ]*rot_new[K_F_ZY];
-
-    t[6] = str_ten[K_S_XX]*rot_new[K_F_XZ] +
-           str_ten[K_S_XY]*rot_new[K_F_YZ] +
-           str_ten[K_S_XZ]*rot_new[K_F_ZZ];
-
-    t[7] = str_ten[K_S_YX]*rot_new[K_F_XZ] +
-           str_ten[K_S_YY]*rot_new[K_F_YZ] +
-           str_ten[K_S_YZ]*rot_new[K_F_ZZ];
-
-    t[8] = str_ten[K_S_ZX]*rot_new[K_F_XZ] +
-           str_ten[K_S_ZY]*rot_new[K_F_YZ] +
-           str_ten[K_S_ZZ]*rot_new[K_F_ZZ];
-
-
-    rot_str[ K_S_XX ] = rot_new[K_F_XX] * t[0] +
-                        rot_new[K_F_YX] * t[1] +
-                        rot_new[K_F_ZX] * t[2];
-    rot_str[ K_S_YY ] = rot_new[K_F_XY] * t[3] +
-                        rot_new[K_F_YY] * t[4] +
-                        rot_new[K_F_ZY] * t[5];
-    rot_str[ K_S_ZZ ] = rot_new[K_F_XZ] * t[6] +
-                        rot_new[K_F_YZ] * t[7] +
-                        rot_new[K_F_ZZ] * t[8];
-
-    rot_str[ K_S_XY ] = rot_new[K_F_XX] * t[3] +
-                        rot_new[K_F_YX] * t[4] +
-                        rot_new[K_F_ZX] * t[5];
-    rot_str[ K_S_YZ ] = rot_new[K_F_XY] * t[6] +
-                        rot_new[K_F_YY] * t[7] +
-                        rot_new[K_F_ZY] * t[8];
-    rot_str[ K_S_ZX ] = rot_new[K_F_XZ] * t[0] +
-                        rot_new[K_F_YZ] * t[1] +
-                        rot_new[K_F_ZZ] * t[2];
-
-    for ( int i = 0 ; i < 6 ; ++i ) {
-      rot_stretch(ielem, i) = rot_str[i] ;
-    }
-
-    for ( int i = 0 ; i < 6 ; ++i ) {
-      stretch(ielem, i) = str[i] ;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( int ielem )const {
-
-    //   Local scratch space to avoid multiple
-    //   accesses to global memory.
-    Scalar str_ten[6]; // Stretching tensor
-    Scalar str[6];     // Stretch
-    Scalar rot_old[9]; // Rotation old
-    Scalar rot_new[9]; // Rotation new
-    Scalar vort[3];    // Vorticity
-    Scalar v_gr[9];    // Velocity gradient
-
-    additive_decomp(ielem, v_gr, str_ten);
-
-    polar_decomp(ielem, v_gr, str_ten, str, vort, rot_old, rot_new);
-
-    rotate_tensor(ielem, str_ten, str, rot_new);
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template<typename Scalar, class DeviceType >
-struct internal_force
-{
-  typedef DeviceType execution_space ;
-
-  typedef Explicit::Fields< Scalar , execution_space >  Fields ;
-
-  static const int ElemNodeCount = Fields::ElemNodeCount ;
-
-  static const int K_F_XX = Fields::K_F_XX ;
-  static const int K_F_YY = Fields::K_F_YY ;
-  static const int K_F_ZZ = Fields::K_F_ZZ ;
-  static const int K_F_XY = Fields::K_F_XY ;
-  static const int K_F_YZ = Fields::K_F_YZ ;
-  static const int K_F_ZX = Fields::K_F_ZX ;
-  static const int K_F_YX = Fields::K_F_YX ;
-  static const int K_F_ZY = Fields::K_F_ZY ;
-  static const int K_F_XZ = Fields::K_F_XZ ;
-
-  static const int K_S_XX = Fields::K_S_XX ;
-  static const int K_S_YY = Fields::K_S_YY ;
-  static const int K_S_ZZ = Fields::K_S_ZZ ;
-  static const int K_S_XY = Fields::K_S_XY ;
-  static const int K_S_YZ = Fields::K_S_YZ ;
-  static const int K_S_ZX = Fields::K_S_ZX ;
-  static const int K_S_YX = Fields::K_S_YX ;
-  static const int K_S_ZY = Fields::K_S_ZY ;
-  static const int K_S_XZ = Fields::K_S_XZ ;
-
-  //--------------------------------------------------------------------------
-  // Reduction:
-
-  typedef Scalar value_type;
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type &update) {
-    update = 1.0e32;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update,
-                    const volatile value_type & source )
-  {
-    update = update < source ? update : source;
-  }
-
-  // Final serial processing of reduction value:
-  KOKKOS_INLINE_FUNCTION
-  void final( value_type & result ) const
-  {
-    prev_dt() = dt() ;
-    dt() = result ;
-  };
-
-  //--------------------------------------------------------------------------
-
-  // Global arrays used by this functor.
-
-  const typename Fields::elem_node_ids_type      elem_node_connectivity ;
-  const typename Fields::node_coords_type        model_coords ;
-  const typename Fields::scalar_type             dt ;
-  const typename Fields::scalar_type             prev_dt ;
-  const typename Fields::geom_state_array_type   displacement ;
-  const typename Fields::geom_state_array_type   velocity ;
-  const typename Fields::array_type              elem_mass ;
-  const typename Fields::array_type              internal_energy ;
-  const typename Fields::elem_sym_tensor_type    stress_new ;
-  const typename Fields::elem_node_geom_type     element_force ;
-  const typename Fields::elem_tensor_state_type  rotation ;
-  const typename Fields::elem_sym_tensor_type    rot_stretch ;
-
-  const Scalar     two_mu;
-  const Scalar     bulk_modulus;
-  const Scalar     lin_bulk_visc;
-  const Scalar     quad_bulk_visc;
-  const Scalar     user_dt;
-  const int        current_state;
-
-  internal_force( const Fields & mesh_fields,
-                  const Scalar arg_user_dt,
-                  const int arg_current_state )
-    : elem_node_connectivity( mesh_fields.elem_node_connectivity )
-    , model_coords(           mesh_fields.model_coords )
-    , dt(                     mesh_fields.dt )
-    , prev_dt(                mesh_fields.prev_dt )
-    , displacement(           mesh_fields.displacement )
-    , velocity(               mesh_fields.velocity )
-    , elem_mass(              mesh_fields.elem_mass )
-    , internal_energy(        mesh_fields.internal_energy )
-    , stress_new(             mesh_fields.stress_new )
-    , element_force(          mesh_fields.element_force )
-    , rotation(               mesh_fields.rotation )
-    , rot_stretch(            mesh_fields.rot_stretch )
-    , two_mu(                 mesh_fields.two_mu )
-    , bulk_modulus(           mesh_fields.bulk_modulus )
-    , lin_bulk_visc(          mesh_fields.lin_bulk_visc )
-    , quad_bulk_visc(         mesh_fields.quad_bulk_visc )
-    , user_dt(       arg_user_dt )
-    , current_state( arg_current_state )
-  {}
-
-  static void apply( const Fields & mesh_fields ,
-                     const Scalar arg_user_dt,
-                     const int arg_current_state )
-  {
-    internal_force  op_force( mesh_fields , arg_user_dt , arg_current_state );
-
-    Kokkos::parallel_reduce( mesh_fields.num_elements, op_force );
-  }
-
-  //--------------------------------------------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void rotate_tensor_backward(int ielem ,
-    const Scalar * const s_n ,
-    Scalar * const rot_stress )const
-  {
-    const int rot_state = current_state ; // 1 ;
-
-    //   t : temporary variables
-    //   s_n : stress_new in local memory space
-    //   r_n : rotation_new in local memory space
-    Scalar t[9], r_n[9];
-
-    r_n[0] = rotation(ielem, 0, rot_state );
-    r_n[1] = rotation(ielem, 1, rot_state );
-    r_n[2] = rotation(ielem, 2, rot_state );
-    r_n[3] = rotation(ielem, 3, rot_state );
-    r_n[4] = rotation(ielem, 4, rot_state );
-    r_n[5] = rotation(ielem, 5, rot_state );
-    r_n[6] = rotation(ielem, 6, rot_state );
-    r_n[7] = rotation(ielem, 7, rot_state );
-    r_n[8] = rotation(ielem, 8, rot_state );
-
-    t[0] = s_n[K_S_XX]*r_n[K_F_XX]+ s_n[K_S_XY]*r_n[K_F_XY]+ s_n[K_S_XZ]*r_n[K_F_XZ];
-    t[1] = s_n[K_S_YX]*r_n[K_F_XX]+ s_n[K_S_YY]*r_n[K_F_XY]+ s_n[K_S_YZ]*r_n[K_F_XZ];
-    t[2] = s_n[K_S_ZX]*r_n[K_F_XX]+ s_n[K_S_ZY]*r_n[K_F_XY]+ s_n[K_S_ZZ]*r_n[K_F_XZ];
-    t[3] = s_n[K_S_XX]*r_n[K_F_YX]+ s_n[K_S_XY]*r_n[K_F_YY]+ s_n[K_S_XZ]*r_n[K_F_YZ];
-    t[4] = s_n[K_S_YX]*r_n[K_F_YX]+ s_n[K_S_YY]*r_n[K_F_YY]+ s_n[K_S_YZ]*r_n[K_F_YZ];
-    t[5] = s_n[K_S_ZX]*r_n[K_F_YX]+ s_n[K_S_ZY]*r_n[K_F_YY]+ s_n[K_S_ZZ]*r_n[K_F_YZ];
-    t[6] = s_n[K_S_XX]*r_n[K_F_ZX]+ s_n[K_S_XY]*r_n[K_F_ZY]+ s_n[K_S_XZ]*r_n[K_F_ZZ];
-    t[7] = s_n[K_S_YX]*r_n[K_F_ZX]+ s_n[K_S_YY]*r_n[K_F_ZY]+ s_n[K_S_YZ]*r_n[K_F_ZZ];
-    t[8] = s_n[K_S_ZX]*r_n[K_F_ZX]+ s_n[K_S_ZY]*r_n[K_F_ZY]+ s_n[K_S_ZZ]*r_n[K_F_ZZ];
-
-    rot_stress[ K_S_XX ] = r_n[K_F_XX]*t[0] + r_n[K_F_XY]*t[1] + r_n[K_F_XZ]*t[2];
-    rot_stress[ K_S_YY ] = r_n[K_F_YX]*t[3] + r_n[K_F_YY]*t[4] + r_n[K_F_YZ]*t[5];
-    rot_stress[ K_S_ZZ ] = r_n[K_F_ZX]*t[6] + r_n[K_F_ZY]*t[7] + r_n[K_F_ZZ]*t[8];
-
-    rot_stress[ K_S_XY ] = r_n[K_F_XX]*t[3] + r_n[K_F_XY]*t[4] + r_n[K_F_XZ]*t[5];
-    rot_stress[ K_S_YZ ] = r_n[K_F_YX]*t[6] + r_n[K_F_YY]*t[7] + r_n[K_F_YZ]*t[8];
-    rot_stress[ K_S_ZX ] = r_n[K_F_ZX]*t[0] + r_n[K_F_ZY]*t[1] + r_n[K_F_ZZ]*t[2];
-  }
-
-  //--------------------------------------------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void comp_force(int ielem,
-     const Scalar * const vx ,
-     const Scalar * const vy ,
-     const Scalar * const vz ,
-     const Scalar * const grad_x ,
-     const Scalar * const grad_y ,
-     const Scalar * const grad_z ,
-     Scalar * total_stress12th ) const
-  {
-    Scalar internal_energy_inc = 0 ;
-
-    for(int inode = 0; inode < 8; ++inode) {
-
-      const Scalar fx =
-        total_stress12th[K_S_XX] * grad_x[inode] +
-        total_stress12th[K_S_XY] * grad_y[inode] +
-        total_stress12th[K_S_XZ] * grad_z[inode] ;
-
-      element_force(ielem, 0, inode) = fx ;
-
-      const Scalar fy =
-        total_stress12th[K_S_YX] * grad_x[inode] +
-        total_stress12th[K_S_YY] * grad_y[inode] +
-        total_stress12th[K_S_YZ] * grad_z[inode] ;
-
-      element_force(ielem, 1, inode) = fy ;
-
-      const Scalar fz =
-        total_stress12th[K_S_ZX] * grad_x[inode] +
-        total_stress12th[K_S_ZY] * grad_y[inode] +
-        total_stress12th[K_S_ZZ] * grad_z[inode] ;
-
-      element_force(ielem, 2, inode) = fz ;
-
-      internal_energy_inc +=
-        fx * vx[inode] +
-        fy * vy[inode] +
-        fz * vz[inode] ;
-    }
-
-    internal_energy(ielem) = internal_energy_inc ;
-  }
-
-  //----------------------------------------------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void get_stress(int ielem , Scalar * const s_n ) const
-    {
-      const int kxx = 0;
-      const int kyy = 1;
-      const int kzz = 2;
-      const int kxy = 3;
-      const int kyz = 4;
-      const int kzx = 5;
-
-      const Scalar e = (rot_stretch(ielem,kxx)+rot_stretch(ielem,kyy)+rot_stretch(ielem,kzz))/3.0;
-
-      s_n[kxx] = stress_new(ielem,kxx) += dt() * (two_mu * (rot_stretch(ielem,kxx)-e)+3*bulk_modulus*e);
-      s_n[kyy] = stress_new(ielem,kyy) += dt() * (two_mu * (rot_stretch(ielem,kyy)-e)+3*bulk_modulus*e);
-      s_n[kzz] = stress_new(ielem,kzz) += dt() * (two_mu * (rot_stretch(ielem,kzz)-e)+3*bulk_modulus*e);
-
-      s_n[kxy] = stress_new(ielem,kxy) += dt() * two_mu * rot_stretch(ielem,kxy);
-      s_n[kyz] = stress_new(ielem,kyz) += dt() * two_mu * rot_stretch(ielem,kyz);
-      s_n[kzx] = stress_new(ielem,kzx) += dt() * two_mu * rot_stretch(ielem,kzx);
-    }
-
-  //----------------------------------------------------------------------------
-
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( int ielem, value_type & update )const
-  {
-    const Scalar ONE12TH = 1.0 / 12.0 ;
-
-    Scalar x[8], y[8], z[8] ;
-    Scalar vx[8], vy[8], vz[8];
-    Scalar grad_x[8], grad_y[8], grad_z[8];
-
-    // Position and velocity:
-
-    for ( int i = 0 ; i < ElemNodeCount ; ++i ) {
-      const int n = elem_node_connectivity(ielem,i);
-
-      x[i] = model_coords(n, 0) + displacement(n, 0, current_state) ;
-      y[i] = model_coords(n, 1) + displacement(n, 1, current_state) ;
-      z[i] = model_coords(n, 2) + displacement(n, 2, current_state) ;
-
-      vx[i] = velocity(n, 0, current_state);
-      vy[i] = velocity(n, 1, current_state);
-      vz[i] = velocity(n, 2, current_state);
-    }
-
-    // Gradient:
-
-    comp_grad<Scalar,execution_space>( x , y , z , grad_x , grad_y , grad_z );
-
-
-    const Scalar mid_vol = dot8<Scalar,execution_space>( x , grad_x );
-
-    const Scalar shr = two_mu ;
-    const Scalar dil = bulk_modulus + ((2.0*shr)/3.0);
-
-    const Scalar aspect = 6.0 * mid_vol /
-                          ( dot8<Scalar,execution_space>( grad_x , grad_x ) +
-                            dot8<Scalar,execution_space>( grad_y , grad_y ) +
-                            dot8<Scalar,execution_space>( grad_z , grad_z ) );
-
-    const Scalar dtrial = std::sqrt(elem_mass(ielem) * aspect / dil);
-    const Scalar traced = (rot_stretch(ielem, 0) + rot_stretch(ielem, 1) + rot_stretch(ielem, 2));
-
-    const Scalar eps = traced < 0 ? (lin_bulk_visc - quad_bulk_visc * traced * dtrial) : lin_bulk_visc ;
-
-    const Scalar bulkq = eps * dil * dtrial * traced;
-
-    Scalar cur_time_step = dtrial * ( std::sqrt( 1.0 + eps * eps) - eps);
-
-    // force fixed time step if input
-
-    cur_time_step = user_dt > 0 ? user_dt : cur_time_step;
-
-    update = update < cur_time_step ? update : cur_time_step;
-
-
-    Scalar s_n[ 6 ];
-
-    get_stress( ielem, s_n );
-
-    Scalar total_stress12th[6];
-
-    // Get rotated stress:
-
-    rotate_tensor_backward(ielem, s_n , total_stress12th );
-
-    total_stress12th[0] = ONE12TH*( total_stress12th[ 0 ] + bulkq );
-    total_stress12th[1] = ONE12TH*( total_stress12th[ 1 ] + bulkq );
-    total_stress12th[2] = ONE12TH*( total_stress12th[ 2 ] + bulkq );
-    total_stress12th[3] = ONE12TH*( total_stress12th[ 3 ] );
-    total_stress12th[4] = ONE12TH*( total_stress12th[ 4 ] );
-    total_stress12th[5] = ONE12TH*( total_stress12th[ 5 ] );
-
-    comp_force(ielem, vx, vy, vz,
-                      grad_x, grad_y, grad_z, total_stress12th);
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template<typename Scalar, class DeviceType >
-struct nodal_step
-{
-  typedef DeviceType     execution_space ;
-  typedef typename execution_space::size_type  size_type;
-
-  typedef Explicit::Fields< Scalar , execution_space >  Fields ;
-
-  const typename Fields::scalar_type            dt ;
-  const typename Fields::scalar_type            prev_dt ;
-  const typename Fields::node_elem_ids_type     node_elem_connectivity ;
-  const typename Fields::node_coords_type       model_coords ;
-  const typename Fields::array_type             nodal_mass ;
-  const typename Fields::geom_state_array_type  displacement ;
-  const typename Fields::geom_state_array_type  velocity ;
-  const typename Fields::geom_array_type        acceleration ;
-  const typename Fields::geom_array_type        internal_force ;
-  const typename Fields::elem_node_geom_type    element_force ;
-
-  const Scalar   x_bc;
-  const int      current_state;
-  const int      next_state;
-
-
-  nodal_step( const Fields  & mesh_fields ,
-              const Scalar    arg_x_bc,
-              const int       arg_current_state,
-              const int       arg_next_state)
-   : dt(       mesh_fields.dt )
-   , prev_dt(  mesh_fields.prev_dt )
-   , node_elem_connectivity( mesh_fields.node_elem_connectivity )
-   , model_coords(   mesh_fields.model_coords )
-   , nodal_mass(     mesh_fields.nodal_mass )
-   , displacement(   mesh_fields.displacement )
-   , velocity(       mesh_fields.velocity )
-   , acceleration(   mesh_fields.acceleration )
-   , internal_force( mesh_fields.internal_force )
-   , element_force(  mesh_fields.element_force )
-   , x_bc(          arg_x_bc )
-   , current_state( arg_current_state )
-   , next_state(    arg_next_state )
-   {
-        //std::cout << "finish_step dt: " << dt << std::endl;
-        //std::cout << "finish_step prev_dt: " << prev_dt << std::endl;
-   }
-
-  static void apply( const Fields  & mesh_fields ,
-                     const Scalar    arg_x_bc ,
-                     const int       arg_current_state ,
-                     const int       arg_next_state )
-  {
-    nodal_step op( mesh_fields, arg_x_bc, arg_current_state, arg_next_state );
-
-    // Only update the owned nodes:
-
-    Kokkos::parallel_for( mesh_fields.num_nodes_owned , op );
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int inode) const
-    {
-      // Getting count as per 'CSR-like' data structure
-      const int begin = node_elem_connectivity.row_map[inode];
-      const int end   = node_elem_connectivity.row_map[inode+1];
-
-      double local_force[] = {0.0, 0.0, 0.0};
-
-      // Gather-sum internal force from
-      // each element that a node is attached to.
-
-      for ( int i = begin; i < end ; ++i ){
-
-        //  node_elem_offset is a cumulative structure, so
-        //  node_elem_offset(inode) should be the index where
-        //  a particular row's elem_IDs begin
-        const int nelem = node_elem_connectivity.entries( i, 0);
-
-        //  find the row in an element's stiffness matrix
-        //  that corresponds to inode
-        const int elem_node_index = node_elem_connectivity.entries( i, 1);
-
-        local_force[0] += element_force(nelem, 0, elem_node_index);
-        local_force[1] += element_force(nelem, 1, elem_node_index);
-        local_force[2] += element_force(nelem, 2, elem_node_index);
-      }
-
-      internal_force(inode, 0) = local_force[0];
-      internal_force(inode, 1) = local_force[1];
-      internal_force(inode, 2) = local_force[2];
-
-      // Acceleration:
-
-      Scalar v_new[3];
-      Scalar a_current[3];
-
-      const Scalar tol = 1.0e-7;
-
-      // If not on the boundary then: a = F / m
-      if ( tol < fabs(model_coords(inode,0)-x_bc) ) {
-
-        const Scalar m = nodal_mass( inode );
-
-        acceleration(inode,0) = a_current[0] = -local_force[0] / m ;
-        acceleration(inode,1) = a_current[1] = -local_force[1] / m ;
-        acceleration(inode,2) = a_current[2] = -local_force[2] / m ;
-      }
-      else { //enforce fixed BC
-        acceleration(inode,0) = a_current[0] = 0;
-        acceleration(inode,1) = a_current[1] = 0;
-        acceleration(inode,2) = a_current[2] = 0;
-      }
-
-      // Central difference time integration:
-
-      const Scalar dt_disp = dt() ;
-      const Scalar dt_vel = ( dt() + prev_dt() ) / 2.0 ;
-
-      velocity(inode,0,next_state) = v_new[0] =
-        velocity(inode,0,current_state) + dt_vel * a_current[0];
-
-      velocity(inode,1,next_state) = v_new[1] =
-        velocity(inode,1,current_state) + dt_vel * a_current[1];
-
-      velocity(inode,2,next_state) = v_new[2] =
-        velocity(inode,2,current_state) + dt_vel * a_current[2];
-
-      displacement(inode,0,next_state) =
-        displacement(inode,0,current_state) + dt_disp * v_new[0];
-
-      displacement(inode,1,next_state) =
-        displacement(inode,1,current_state) + dt_disp * v_new[1];
-
-      displacement(inode,2,next_state) =
-        displacement(inode,2,current_state) + dt_disp * v_new[2];
-    }
-};
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class DeviceType >
-struct pack_state
-{
-  typedef DeviceType     execution_space ;
-  typedef typename execution_space::size_type  size_type ;
-
-  typedef Explicit::Fields< Scalar , execution_space >  Fields ;
-
-  typedef typename Fields::geom_state_array_type::value_type  value_type ;
-  typedef Kokkos::View< value_type* , execution_space >     buffer_type ;
-
-  static const unsigned value_count = 6 ;
-
-  const typename Fields::geom_state_array_type  displacement ;
-  const typename Fields::geom_state_array_type  velocity ;
-  const buffer_type  output ;
-  const size_type    inode_base ;
-  const size_type    state_next ;
-
-  pack_state( const buffer_type & arg_output ,
-              const Fields      & mesh_fields ,
-              const size_type     arg_begin ,
-              const size_type     arg_state )
-   : displacement( mesh_fields.displacement )
-   , velocity(     mesh_fields.velocity )
-   , output(       arg_output )
-   , inode_base(   arg_begin )
-   , state_next(   arg_state )
-   {}
-
-  static void apply( const buffer_type & arg_output ,
-                     const size_type     arg_begin ,
-                     const size_type     arg_count ,
-                     const Fields      & mesh_fields ,
-                     const size_type     arg_state )
-  {
-    pack_state op( arg_output , mesh_fields , arg_begin , arg_state );
-
-    Kokkos::parallel_for( arg_count , op );
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type i ) const
-  {
-    const size_type inode = inode_base + i ;
-
-    size_type j = i * value_count ;
-
-    output[j++] = displacement( inode , 0 , state_next );
-    output[j++] = displacement( inode , 1 , state_next );
-    output[j++] = displacement( inode , 2 , state_next );
-    output[j++] = velocity( inode , 0 , state_next );
-    output[j++] = velocity( inode , 1 , state_next );
-    output[j++] = velocity( inode , 2 , state_next );
-  }
-};
-
-template< typename Scalar , class DeviceType >
-struct unpack_state
-{
-  typedef DeviceType     execution_space ;
-  typedef typename execution_space::size_type  size_type ;
-
-  typedef Explicit::Fields< Scalar , execution_space >  Fields ;
-
-  typedef typename Fields::geom_state_array_type::value_type  value_type ;
-  typedef Kokkos::View< value_type* , execution_space >     buffer_type ;
-
-  static const unsigned value_count = 6 ;
-
-  const typename Fields::geom_state_array_type  displacement ;
-  const typename Fields::geom_state_array_type  velocity ;
-  const buffer_type  input ;
-  const size_type    inode_base ;
-  const size_type    state_next ;
-
-  unpack_state( const buffer_type & arg_input ,
-                const Fields      & mesh_fields ,
-                const size_type     arg_begin ,
-                const size_type     arg_state )
-   : displacement( mesh_fields.displacement )
-   , velocity(     mesh_fields.velocity )
-   , input(        arg_input )
-   , inode_base(   arg_begin )
-   , state_next(   arg_state )
-   {}
-
-  static void apply( const Fields      & mesh_fields ,
-                     const size_type     arg_state ,
-                     const buffer_type & arg_input ,
-                     const size_type     arg_begin ,
-                     const size_type     arg_count )
-  {
-    unpack_state op( arg_input , mesh_fields , arg_begin , arg_state );
-
-    Kokkos::parallel_for( arg_count , op );
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type i ) const
-  {
-    const size_type inode = inode_base + i ;
-
-    size_type j = i * value_count ;
-
-    displacement( inode , 0 , state_next ) = input[j++] ;
-    displacement( inode , 1 , state_next ) = input[j++] ;
-    displacement( inode , 2 , state_next ) = input[j++] ;
-    velocity( inode , 0 , state_next ) = input[j++] ;
-    velocity( inode , 1 , state_next ) = input[j++] ;
-    velocity( inode , 2 , state_next ) = input[j++] ;
-  }
-};
-
-} /* namespace Explicit */
-
-#endif /* #ifndef KOKKOS_EXPLICITFUNCTORS_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/FEMesh.hpp b/lib/kokkos/example/multi_fem/FEMesh.hpp
deleted file mode 100644
index e836cac43fb301f6afd45f985bf76e89180fb3f1..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/FEMesh.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_FEMESH_HPP
-#define KOKKOS_FEMESH_HPP
-
-#include <utility>
-#include <limits>
-#include <iostream>
-#include <sstream>
-#include <stdexcept>
-
-#include <Kokkos_Core.hpp>
-#include <Kokkos_StaticCrsGraph.hpp>
-
-#include <ParallelComm.hpp>
-#include <ParallelDataMap.hpp>
-
-namespace HybridFEM {
-
-//----------------------------------------------------------------------------
-/** \brief  Finite element mesh fixture for hybrid parallel performance tests.
- */
-template< typename CoordScalarType , unsigned ElemNodeCount , class Device >
-struct FEMesh {
-
-  typedef typename Device::size_type size_type ;
-
-  static const size_type element_node_count = ElemNodeCount ;
-
-  typedef Kokkos::View< CoordScalarType*[3] , Device >       node_coords_type ;
-  typedef Kokkos::View< size_type*[ElemNodeCount], Device >  elem_node_ids_type ;
-  typedef Kokkos::StaticCrsGraph< size_type[2] ,  Device >   node_elem_ids_type ;
-
-  node_coords_type         node_coords ;
-  elem_node_ids_type       elem_node_ids ;
-  node_elem_ids_type       node_elem_ids ;
-  Kokkos::ParallelDataMap  parallel_data_map ;
-};
-
-//----------------------------------------------------------------------------
-
-} /* namespace HybridFEM */
-
-#endif /* #ifndef KOKKOS_FEMESH_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/HexElement.hpp b/lib/kokkos/example/multi_fem/HexElement.hpp
deleted file mode 100644
index c1c045a29bf7e0e3660b21a4cf33677337d8bc9b..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/HexElement.hpp
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef ELEMENTHEX_HPP
-#define ELEMENTHEX_HPP
-
-namespace HybridFEM {
-
-template< unsigned NodeCount >
-class HexElement_TensorData ;
-
-template< unsigned NodeCount , class Device >
-class HexElement_TensorEval ;
-
-//----------------------------------------------------------------------------
-/** \brief  Evaluate Hex element on interval [-1,1]^3 */
-template<>
-class HexElement_TensorData< 8 > {
-public:
-
-  static const unsigned element_node_count    = 8 ;
-  static const unsigned spatial_dimension     = 3 ;
-  static const unsigned integration_count_1d  = 2 ;
-  static const unsigned function_count_1d     = 2 ;
-
-  float values_1d [ function_count_1d ][ integration_count_1d ];
-  float derivs_1d [ function_count_1d ][ integration_count_1d ];
-  float weights_1d[ integration_count_1d ];
-
-  unsigned char eval_map[ element_node_count ][4] ;
-
-  static float eval_value_1d( const unsigned jf , const float x )
-  {
-    return 0 == jf ? 0.5 * ( 1.0 - x ) : (
-           1 == jf ? 0.5 * ( 1.0 + x ) : 0 );
-  }
-
-  static float eval_deriv_1d( const unsigned jf , const float )
-  {
-    return 0 == jf ? -0.5 : (
-           1 == jf ?  0.5 : 0 );
-  }
-
-  HexElement_TensorData()
-  {
-    const unsigned char tmp_map[ element_node_count ][ spatial_dimension ] =
-      { { 0 , 0 , 0 },
-        { 1 , 0 , 0 },
-        { 1 , 1 , 0 },
-        { 0 , 1 , 0 },
-        { 0 , 0 , 1 },
-        { 1 , 0 , 1 },
-        { 1 , 1 , 1 },
-        { 0 , 1 , 1 } };
-
-    weights_1d[0] = 1 ;
-    weights_1d[1] = 1 ;
-
-    const float points_1d[ integration_count_1d ] =
-      { -0.577350269 , 0.577350269 };
-
-    for ( unsigned i = 0 ; i < element_node_count ; ++i ) {
-      eval_map[i][0] = tmp_map[i][0];
-      eval_map[i][1] = tmp_map[i][1];
-      eval_map[i][2] = tmp_map[i][2];
-    }
-
-    for ( unsigned xp = 0 ; xp < integration_count_1d ; ++xp ) {
-    for ( unsigned xf = 0 ; xf < function_count_1d ; ++xf ) {
-      values_1d[xp][xf] = eval_value_1d( xf , points_1d[xp] );
-      derivs_1d[xp][xf] = eval_deriv_1d( xf , points_1d[xp] );
-    }}
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template<>
-class HexElement_TensorData< 27 > {
-public:
-
-  static const unsigned element_node_count    = 27 ;
-  static const unsigned spatial_dimension     = 3 ;
-  static const unsigned integration_count_1d  = 3 ;
-  static const unsigned function_count_1d     = 3 ;
-
-  float values_1d [ function_count_1d ][ integration_count_1d ];
-  float derivs_1d [ function_count_1d ][ integration_count_1d ];
-  float weights_1d[ integration_count_1d ];
-
-  unsigned char eval_map[ element_node_count ][4] ;
-
-  // sizeof(EvaluateElementHex) = 111 bytes =
-  //   sizeof(float) * 9 +
-  //   sizeof(float) * 9 +
-  //   sizeof(float) * 3 +
-  //   sizeof(char) * 27 
-
-  static float eval_value_1d( const unsigned jf , const float p )
-  {
-    return 0 == jf ? 0.5 * p * ( p - 1 ) : (
-           1 == jf ? 1.0 - p * p : (
-           2 == jf ? 0.5 * p * ( p + 1 ) : 0 ));
-  }
-
-  static float eval_deriv_1d( const unsigned jf , const float p )
-  {
-    return 0 == jf ? p - 0.5 : (
-           1 == jf ? -2.0 * p : (
-           2 == jf ? p + 0.5 : 0 ));
-  }
-
-  HexElement_TensorData()
-  {
-    const unsigned char tmp_map[ element_node_count ][ spatial_dimension ] =
-      { { 0 , 0 , 0 },
-        { 2 , 0 , 0 },
-        { 2 , 2 , 0 },
-        { 0 , 2 , 0 },
-        { 0 , 0 , 2 },
-        { 2 , 0 , 2 },
-        { 2 , 2 , 2 },
-        { 0 , 2 , 2 },
-        { 1 , 0 , 0 },
-        { 2 , 1 , 0 },
-        { 1 , 2 , 0 },
-        { 0 , 1 , 0 },
-        { 0 , 0 , 1 },
-        { 2 , 0 , 1 },
-        { 2 , 2 , 1 },
-        { 0 , 2 , 1 },
-        { 1 , 0 , 2 },
-        { 2 , 1 , 2 },
-        { 1 , 2 , 2 },
-        { 0 , 1 , 2 },
-        { 1 , 1 , 1 },
-        { 1 , 1 , 0 },
-        { 1 , 1 , 2 },
-        { 0 , 1 , 1 },
-        { 2 , 1 , 1 },
-        { 1 , 0 , 1 },
-        { 1 , 2 , 1 } };
-
-    // Interval [-1,1]
-
-    weights_1d[0] = 0.555555556 ;
-    weights_1d[1] = 0.888888889 ;
-    weights_1d[2] = 0.555555556 ;
-
-    const float points_1d[3] = { -0.774596669 ,
-                                  0.000000000 ,
-                                  0.774596669 };
-
-    for ( unsigned i = 0 ; i < element_node_count ; ++i ) {
-      eval_map[i][0] = tmp_map[i][0];
-      eval_map[i][1] = tmp_map[i][1];
-      eval_map[i][2] = tmp_map[i][2];
-    }
-
-    for ( unsigned xp = 0 ; xp < integration_count_1d ; ++xp ) {
-    for ( unsigned xf = 0 ; xf < function_count_1d ; ++xf ) {
-      values_1d[xp][xf] = eval_value_1d( xf , points_1d[xp] );
-      derivs_1d[xp][xf] = eval_deriv_1d( xf , points_1d[xp] );
-    }}
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< unsigned NodeCount >
-class HexElement_Data {
-public:
-  static const unsigned spatial_dimension   = 3 ;
-  static const unsigned element_node_count  = NodeCount ;
-  static const unsigned integration_count   = NodeCount ;
-  static const unsigned function_count      = NodeCount ;
-
-  float weights[   integration_count ] ;
-  float values[    integration_count ][ function_count ];
-  float gradients[ integration_count ][ spatial_dimension ][ function_count ];
-
-  HexElement_Data()
-  {
-    HexElement_TensorData< NodeCount > tensor_data ;
-
-    for ( unsigned ip = 0 ; ip < integration_count ; ++ip ) {
-
-      const unsigned ipx = tensor_data.eval_map[ip][0] ;
-      const unsigned ipy = tensor_data.eval_map[ip][1] ;
-      const unsigned ipz = tensor_data.eval_map[ip][2] ;
-
-      weights[ip] = tensor_data.weights_1d[ ipx ] *
-                    tensor_data.weights_1d[ ipy ] *
-                    tensor_data.weights_1d[ ipz ] ;
-
-      for ( unsigned jf = 0 ; jf < function_count ; ++jf ) {
-
-        const unsigned jfx = tensor_data.eval_map[jf][0] ;
-        const unsigned jfy = tensor_data.eval_map[jf][1] ;
-        const unsigned jfz = tensor_data.eval_map[jf][2] ;
-
-        values[ip][jf] = tensor_data.values_1d[ ipx ][ jfx ] *
-                         tensor_data.values_1d[ ipy ][ jfy ] *
-                         tensor_data.values_1d[ ipz ][ jfz ] ;
-
-        gradients[ip][0][jf] = tensor_data.derivs_1d[ ipx ][ jfx ] *
-                               tensor_data.values_1d[ ipy ][ jfy ] *
-                               tensor_data.values_1d[ ipz ][ jfz ] ;
-
-        gradients[ip][1][jf] = tensor_data.values_1d[ ipx ][ jfx ] *
-                               tensor_data.derivs_1d[ ipy ][ jfy ] *
-                               tensor_data.values_1d[ ipz ][ jfz ] ;
-
-        gradients[ip][2][jf] = tensor_data.values_1d[ ipx ][ jfx ] *
-                               tensor_data.values_1d[ ipy ][ jfy ] *
-                               tensor_data.derivs_1d[ ipz ][ jfz ] ;
-      }
-    }
-  }
-};
-
-//----------------------------------------------------------------------------
-
-} /* namespace HybridFEM */
-
-#endif /* #ifndef ELEMENTHEX_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/HexExplicitFunctions.hpp b/lib/kokkos/example/multi_fem/HexExplicitFunctions.hpp
deleted file mode 100644
index 48f535f35b941c90339563040bbfc9491be0cf62..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/HexExplicitFunctions.hpp
+++ /dev/null
@@ -1,443 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_HEXEXPLICITFUNCTIONS_HPP
-#define KOKKOS_HEXEXPLICITFUNCTIONS_HPP
-
-#include <cmath>
-
-namespace Explicit {
-
-struct Hex8Functions
-{
-  static const unsigned SpatialDim    = 3 ;
-  static const unsigned ElemNodeCount = 8 ;
-
-  // Indices for full 3x3 tensor:
-
-  static const unsigned K_F_XX = 0 ;
-  static const unsigned K_F_YY = 1 ;
-  static const unsigned K_F_ZZ = 2 ;
-  static const unsigned K_F_XY = 3 ;
-  static const unsigned K_F_YZ = 4 ;
-  static const unsigned K_F_ZX = 5 ;
-  static const unsigned K_F_YX = 6 ;
-  static const unsigned K_F_ZY = 7 ;
-  static const unsigned K_F_XZ = 8 ;
-  static const unsigned K_F_SIZE = 9 ;
-
-  //  Indexes into a 3 by 3 symmetric tensor stored as a length 6 vector
-
-  static const unsigned K_S_XX = 0 ;
-  static const unsigned K_S_YY = 1 ;
-  static const unsigned K_S_ZZ = 2 ;
-  static const unsigned K_S_XY = 3 ;
-  static const unsigned K_S_YZ = 4 ;
-  static const unsigned K_S_ZX = 5 ;
-  static const unsigned K_S_YX = 3 ;
-  static const unsigned K_S_ZY = 4 ;
-  static const unsigned K_S_XZ = 5 ;
-  static const unsigned K_S_SIZE = 6 ;
-
-  //  Indexes into a 3 by 3 skew symmetric tensor stored as a length 3 vector
-
-  static const unsigned K_V_XY = 0 ;
-  static const unsigned K_V_YZ = 1 ;
-  static const unsigned K_V_ZX = 2 ;
-  static const unsigned K_V_SIZE = 3 ;
-
-  //--------------------------------------------------------------------------
-
-  template< typename ScalarA , typename ScalarB >
-  KOKKOS_INLINE_FUNCTION static
-  double dot8( const ScalarA * const a , const ScalarB * const b )
-  { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3] +
-           a[4] * b[4] + a[5] * b[5] + a[6] * b[6] + a[7] * b[7] ; }
-
-  //--------------------------------------------------------------------------
-
-  template< class ScalarPrecise ,
-            class ScalarCompact >
-  KOKKOS_INLINE_FUNCTION static
-  void grad( const ScalarPrecise x[] ,
-             const ScalarPrecise z[] ,
-                   ScalarCompact grad_y[] )
-  {
-    const ScalarCompact R42=(x[3] - x[1]);
-    const ScalarCompact R52=(x[4] - x[1]);
-    const ScalarCompact R54=(x[4] - x[3]);
-
-    const ScalarCompact R63=(x[5] - x[2]);
-    const ScalarCompact R83=(x[7] - x[2]);
-    const ScalarCompact R86=(x[7] - x[5]);
-
-    const ScalarCompact R31=(x[2] - x[0]);
-    const ScalarCompact R61=(x[5] - x[0]);
-    const ScalarCompact R74=(x[6] - x[3]);
-
-    const ScalarCompact R72=(x[6] - x[1]);
-    const ScalarCompact R75=(x[6] - x[4]);
-    const ScalarCompact R81=(x[7] - x[0]);
-
-    const ScalarCompact t1=(R63 + R54);
-    const ScalarCompact t2=(R61 + R74);
-    const ScalarCompact t3=(R72 + R81);
-
-    const ScalarCompact t4 =(R86 + R42);
-    const ScalarCompact t5 =(R83 + R52);
-    const ScalarCompact t6 =(R75 + R31);
-
-    //  Calculate Y gradient from X and Z data
-
-    grad_y[0] = (z[1] *  t1) - (z[2] * R42) - (z[3] *  t5)  + (z[4] *  t4) + (z[5] * R52) - (z[7] * R54);
-    grad_y[1] = (z[2] *  t2) + (z[3] * R31) - (z[0] *  t1)  - (z[5] *  t6) + (z[6] * R63) - (z[4] * R61);
-    grad_y[2] = (z[3] *  t3) + (z[0] * R42) - (z[1] *  t2)  - (z[6] *  t4) + (z[7] * R74) - (z[5] * R72);
-    grad_y[3] = (z[0] *  t5) - (z[1] * R31) - (z[2] *  t3)  + (z[7] *  t6) + (z[4] * R81) - (z[6] * R83);
-    grad_y[4] = (z[5] *  t3) + (z[6] * R86) - (z[7] *  t2)  - (z[0] *  t4) - (z[3] * R81) + (z[1] * R61);
-    grad_y[5] = (z[6] *  t5) - (z[4] *  t3)  - (z[7] * R75) + (z[1] *  t6) - (z[0] * R52) + (z[2] * R72);
-    grad_y[6] = (z[7] *  t1) - (z[5] *  t5)  - (z[4] * R86) + (z[2] *  t4) - (z[1] * R63) + (z[3] * R83);
-    grad_y[7] = (z[4] *  t2) - (z[6] *  t1)  + (z[5] * R75) - (z[3] *  t6) - (z[2] * R74) + (z[0] * R54);
-  }
-
-  template< class ScalarPrecise ,
-            class ScalarCompact >
-  static KOKKOS_INLINE_FUNCTION
-  void grad( const ScalarPrecise x[] ,
-             const ScalarPrecise y[] ,
-             const ScalarPrecise z[] ,
-                   ScalarCompact grad_x[] ,
-                   ScalarCompact grad_y[] ,
-                   ScalarCompact grad_z[] )
-  {
-    grad( x , z , grad_y );
-    grad( z , y , grad_x );
-    grad( y , x , grad_z );
-  }
-
-  //--------------------------------------------------------------------------
-
-  template< class ScalarPrecise ,
-            class ScalarCompact >
-  KOKKOS_INLINE_FUNCTION static
-  void polar_decomp( const float dt ,
-                     const ScalarCompact v_gr[] ,
-                           ScalarPrecise stretch[] /* INOUT */ ,
-                           ScalarCompact str_ten[] /* OUT */ ,
-                           ScalarCompact rot[]     /* OUT */ )
-  {
-    const float dt_half = 0.5 * dt;
-
-    ScalarCompact vort[ K_V_SIZE ];  // Vorticity
-
-    //  Symmetric part
-    str_ten[K_S_XX] = v_gr[K_F_XX];
-    str_ten[K_S_YY] = v_gr[K_F_YY];
-    str_ten[K_S_ZZ] = v_gr[K_F_ZZ];
-    str_ten[K_S_XY] = 0.5 * ( v_gr[K_F_XY] + v_gr[K_F_YX] );
-    str_ten[K_S_YZ] = 0.5 * ( v_gr[K_F_YZ] + v_gr[K_F_ZY] );
-    str_ten[K_S_ZX] = 0.5 * ( v_gr[K_F_ZX] + v_gr[K_F_XZ] );
-
-    //  Skew Symmetric part
-    vort[K_V_XY] = 0.5 * ( v_gr[K_F_XY] - v_gr[K_F_YX] );
-    vort[K_V_YZ] = 0.5 * ( v_gr[K_F_YZ] - v_gr[K_F_ZY] );
-    vort[K_V_ZX] = 0.5 * ( v_gr[K_F_ZX] - v_gr[K_F_XZ] );
-
-    //   calculate the rates of rotation via gauss elimination.
-
-    ScalarCompact z1 = str_ten[K_S_XY] * stretch[K_S_ZX] -
-                       str_ten[K_S_ZX] * stretch[K_S_XY] +
-                       str_ten[K_S_YY] * stretch[K_S_YZ] -
-                       str_ten[K_S_YZ] * stretch[K_S_YY] +
-                       str_ten[K_S_YZ] * stretch[K_S_ZZ] -
-                       str_ten[K_S_ZZ] * stretch[K_S_YZ];
-
-    ScalarCompact z2 = str_ten[K_S_ZX] * stretch[K_S_XX] -
-                       str_ten[K_S_XX] * stretch[K_S_ZX] +
-                       str_ten[K_S_YZ] * stretch[K_S_XY] -
-                       str_ten[K_S_XY] * stretch[K_S_YZ] +
-                       str_ten[K_S_ZZ] * stretch[K_S_ZX] -
-                       str_ten[K_S_ZX] * stretch[K_S_ZZ];
-
-    ScalarCompact z3 = str_ten[K_S_XX] * stretch[K_S_XY] -
-                       str_ten[K_S_XY] * stretch[K_S_XX] +
-                       str_ten[K_S_XY] * stretch[K_S_YY] -
-                       str_ten[K_S_YY] * stretch[K_S_XY] +
-                       str_ten[K_S_ZX] * stretch[K_S_YZ] -
-                       str_ten[K_S_YZ] * stretch[K_S_ZX];
-
-    {
-      //   forward elimination
-
-      const ScalarCompact a1inv  = 1.0 / (stretch[K_S_YY] + stretch[K_S_ZZ]);
-      const ScalarCompact a4BYa1 = -1 * stretch[K_S_XY] * a1inv;
-      const ScalarCompact a2inv  = 1.0 / (stretch[K_S_ZZ] + stretch[K_S_XX] + stretch[K_S_XY] * a4BYa1);
-
-     const ScalarCompact a5 =  -stretch[K_S_YZ] + stretch[K_S_ZX] * a4BYa1;
-
-      z2 -= z1 * a4BYa1;
-      const ScalarCompact a6BYa1 = -1 * stretch[K_S_ZX] * a1inv;
-      const ScalarCompact a5BYa2 = a5 * a2inv;
-      z3 -= z1 * a6BYa1 - z2 * a5BYa2;
-
-      //   backward substitution -
-
-      z3 /= (stretch[K_S_XX] + stretch[K_S_YY] + stretch[K_S_ZX] * a6BYa1 + a5 * a5BYa2);
-      z2 = (z2 - a5 * z3) * a2inv;
-      z1 = (z1*a1inv - a6BYa1 * z3 -a4BYa1 * z2);
-    }
-
-    //   calculate rotation rates - recall that spin_rate is an asymmetric tensor,
-    //   so compute spin rate vector as dual of spin rate tensor,
-    //   i.e   w_i = e_ijk * spin_rate_jk
-
-    z1 += vort[K_V_YZ];
-    z2 += vort[K_V_ZX];
-    z3 += vort[K_V_XY];
-
-    {
-      //   update rotation tensor:
-      //  1) premultiply old rotation tensor to get right-hand side.
-
-      ScalarCompact r_XX = rot[K_F_XX] + dt_half*( z3 * rot[K_F_YX] - z2 * rot[K_F_ZX] );
-      ScalarCompact r_YX = rot[K_F_YX] + dt_half*( z1 * rot[K_F_ZX] - z3 * rot[K_F_XX] );
-      ScalarCompact r_ZX = rot[K_F_ZX] + dt_half*( z2 * rot[K_F_XX] - z1 * rot[K_F_YX] );
-      ScalarCompact r_XY = rot[K_F_XY] + dt_half*( z3 * rot[K_F_YY] - z2 * rot[K_F_ZY] );
-      ScalarCompact r_YY = rot[K_F_YY] + dt_half*( z1 * rot[K_F_ZY] - z3 * rot[K_F_XY] );
-      ScalarCompact r_ZY = rot[K_F_ZY] + dt_half*( z2 * rot[K_F_XY] - z1 * rot[K_F_YY] );
-      ScalarCompact r_XZ = rot[K_F_XZ] + dt_half*( z3 * rot[K_F_YZ] - z2 * rot[K_F_ZZ] );
-      ScalarCompact r_YZ = rot[K_F_YZ] + dt_half*( z1 * rot[K_F_ZZ] - z3 * rot[K_F_XZ] );
-      ScalarCompact r_ZZ = rot[K_F_ZZ] + dt_half*( z2 * rot[K_F_XZ] - z1 * rot[K_F_YZ] );
-
-
-      //  2) solve for new rotation tensor via gauss elimination.
-      //   forward elimination -
-
-      const ScalarCompact a12 = - dt_half * z3;
-      const ScalarCompact a13 =   dt_half * z2;
-            ScalarCompact b32 = - dt_half * z1;
-      const ScalarCompact a22inv = 1.0 / (1.0 + a12 * a12);
-
-      const ScalarCompact a13a12 = a13*a12;
-      const ScalarCompact a23 = b32 + a13a12;
-
-      r_YX += r_XX * a12;
-      r_YY += r_XY * a12;
-      r_YZ += r_XZ * a12;
-
-      b32 = (b32 - a13a12) * a22inv;
-
-      r_ZX += r_XX * a13 + r_YX * b32;
-      r_ZY += r_XY * a13 + r_YY * b32;
-      r_ZZ += r_XZ * a13 + r_YZ * b32;
-
-      //   backward substitution -
-
-      const ScalarCompact a33inv = 1.0 / (1.0 + a13 * a13 + a23 * b32);
-
-      rot[K_F_ZX] = r_ZX * a33inv;
-      rot[K_F_ZY] = r_ZY * a33inv;
-      rot[K_F_ZZ] = r_ZZ * a33inv;
-      rot[K_F_YX] = ( r_YX - rot[K_F_ZX] * a23 ) * a22inv;
-      rot[K_F_YY] = ( r_YY - rot[K_F_ZY] * a23 ) * a22inv;
-      rot[K_F_YZ] = ( r_YZ - rot[K_F_ZZ] * a23 ) * a22inv;
-      rot[K_F_XX] = r_XX - rot[K_F_ZX] * a13 - rot[K_F_YX] * a12;
-      rot[K_F_XY] = r_XY - rot[K_F_ZY] * a13 - rot[K_F_YY] * a12;
-      rot[K_F_XZ] = r_XZ - rot[K_F_ZZ] * a13 - rot[K_F_YZ] * a12;
-    }
-
-    //   update stretch tensor in the new configuration -
-
-    const ScalarCompact a1 = str_ten[K_S_XY] + vort[K_V_XY];
-    const ScalarCompact a2 = str_ten[K_S_YZ] + vort[K_V_YZ];
-    const ScalarCompact a3 = str_ten[K_S_ZX] + vort[K_V_ZX];
-    const ScalarCompact b1 = str_ten[K_S_ZX] - vort[K_V_ZX];
-    const ScalarCompact b2 = str_ten[K_S_XY] - vort[K_V_XY];
-    const ScalarCompact b3 = str_ten[K_S_YZ] - vort[K_V_YZ];
-
-    const ScalarCompact s_XX = stretch[K_S_XX];
-    const ScalarCompact s_YY = stretch[K_S_YY];
-    const ScalarCompact s_ZZ = stretch[K_S_ZZ];
-    const ScalarCompact s_XY = stretch[K_S_XY];
-    const ScalarCompact s_YZ = stretch[K_S_YZ];
-    const ScalarCompact s_ZX = stretch[K_S_ZX];
-
-    stretch[K_S_XX] += dt * (str_ten[K_S_XX] * s_XX + ( a1 + z3 ) * s_XY + ( b1 - z2 ) * s_ZX);
-    stretch[K_S_YY] += dt * (str_ten[K_S_YY] * s_YY + ( a2 + z1 ) * s_YZ + ( b2 - z3 ) * s_XY);
-    stretch[K_S_ZZ] += dt * (str_ten[K_S_ZZ] * s_ZZ + ( a3 + z2 ) * s_ZX + ( b3 - z1 ) * s_YZ);
-    stretch[K_S_XY] += dt * (str_ten[K_S_XX] * s_XY + ( a1 )      * s_YY + ( b1      ) * s_YZ - z3 * s_XX + z1 * s_ZX);
-    stretch[K_S_YZ] += dt * (str_ten[K_S_YY] * s_YZ + ( a2 )      * s_ZZ + ( b2      ) * s_ZX - z1 * s_YY + z2 * s_XY);
-    stretch[K_S_ZX] += dt * (str_ten[K_S_ZZ] * s_ZX + ( a3 )      * s_XX + ( b3      ) * s_XY - z2 * s_ZZ + z3 * s_YZ);
-  }
-
-  //--------------------------------------------------------------------------
-
-  template< typename ScalarCompact >
-  static KOKKOS_INLINE_FUNCTION
-  void rotate_tensor( const ScalarCompact str_ten[] ,
-                      const ScalarCompact rot[] ,
-                            ScalarCompact rot_str[] )
-  {
-    ScalarCompact t[9];
-
-    t[0] = str_ten[K_S_XX]*rot[K_F_XX] + str_ten[K_S_XY]*rot[K_F_YX] + str_ten[K_S_XZ]*rot[K_F_ZX];
-    t[1] = str_ten[K_S_YX]*rot[K_F_XX] + str_ten[K_S_YY]*rot[K_F_YX] + str_ten[K_S_YZ]*rot[K_F_ZX];
-    t[2] = str_ten[K_S_ZX]*rot[K_F_XX] + str_ten[K_S_ZY]*rot[K_F_YX] + str_ten[K_S_ZZ]*rot[K_F_ZX];
-
-    t[3] = str_ten[K_S_XX]*rot[K_F_XY] + str_ten[K_S_XY]*rot[K_F_YY] + str_ten[K_S_XZ]*rot[K_F_ZY];
-    t[4] = str_ten[K_S_YX]*rot[K_F_XY] + str_ten[K_S_YY]*rot[K_F_YY] + str_ten[K_S_YZ]*rot[K_F_ZY];
-    t[5] = str_ten[K_S_ZX]*rot[K_F_XY] + str_ten[K_S_ZY]*rot[K_F_YY] + str_ten[K_S_ZZ]*rot[K_F_ZY];
-
-    t[6] = str_ten[K_S_XX]*rot[K_F_XZ] + str_ten[K_S_XY]*rot[K_F_YZ] + str_ten[K_S_XZ]*rot[K_F_ZZ];
-    t[7] = str_ten[K_S_YX]*rot[K_F_XZ] + str_ten[K_S_YY]*rot[K_F_YZ] + str_ten[K_S_YZ]*rot[K_F_ZZ];
-    t[8] = str_ten[K_S_ZX]*rot[K_F_XZ] + str_ten[K_S_ZY]*rot[K_F_YZ] + str_ten[K_S_ZZ]*rot[K_F_ZZ];
-
-
-    rot_str[ K_S_XX ] = rot[K_F_XX] * t[0] + rot[K_F_YX] * t[1] + rot[K_F_ZX] * t[2];
-    rot_str[ K_S_YY ] = rot[K_F_XY] * t[3] + rot[K_F_YY] * t[4] + rot[K_F_ZY] * t[5];
-    rot_str[ K_S_ZZ ] = rot[K_F_XZ] * t[6] + rot[K_F_YZ] * t[7] + rot[K_F_ZZ] * t[8];
-
-    rot_str[ K_S_XY ] = rot[K_F_XX] * t[3] + rot[K_F_YX] * t[4] + rot[K_F_ZX] * t[5];
-    rot_str[ K_S_YZ ] = rot[K_F_XY] * t[6] + rot[K_F_YY] * t[7] + rot[K_F_ZY] * t[8];
-    rot_str[ K_S_ZX ] = rot[K_F_XZ] * t[0] + rot[K_F_YZ] * t[1] + rot[K_F_ZZ] * t[2];
-  }
-
-  //--------------------------------------------------------------------------
-
-  template< class ScalarPrecise ,
-            class ScalarCompact >
-  static KOKKOS_INLINE_FUNCTION
-  void rotate_tensor_backward( const ScalarPrecise stress[] ,
-                               const ScalarCompact rot[] ,
-                                     ScalarCompact rot_stress[] )
-  {
-    ScalarCompact t[9] ;
-
-    t[0] = stress[K_S_XX]*rot[K_F_XX]+ stress[K_S_XY]*rot[K_F_XY]+ stress[K_S_XZ]*rot[K_F_XZ];
-    t[1] = stress[K_S_YX]*rot[K_F_XX]+ stress[K_S_YY]*rot[K_F_XY]+ stress[K_S_YZ]*rot[K_F_XZ];
-    t[2] = stress[K_S_ZX]*rot[K_F_XX]+ stress[K_S_ZY]*rot[K_F_XY]+ stress[K_S_ZZ]*rot[K_F_XZ];
-    t[3] = stress[K_S_XX]*rot[K_F_YX]+ stress[K_S_XY]*rot[K_F_YY]+ stress[K_S_XZ]*rot[K_F_YZ];
-    t[4] = stress[K_S_YX]*rot[K_F_YX]+ stress[K_S_YY]*rot[K_F_YY]+ stress[K_S_YZ]*rot[K_F_YZ];
-    t[5] = stress[K_S_ZX]*rot[K_F_YX]+ stress[K_S_ZY]*rot[K_F_YY]+ stress[K_S_ZZ]*rot[K_F_YZ];
-    t[6] = stress[K_S_XX]*rot[K_F_ZX]+ stress[K_S_XY]*rot[K_F_ZY]+ stress[K_S_XZ]*rot[K_F_ZZ];
-    t[7] = stress[K_S_YX]*rot[K_F_ZX]+ stress[K_S_YY]*rot[K_F_ZY]+ stress[K_S_YZ]*rot[K_F_ZZ];
-    t[8] = stress[K_S_ZX]*rot[K_F_ZX]+ stress[K_S_ZY]*rot[K_F_ZY]+ stress[K_S_ZZ]*rot[K_F_ZZ];
-
-    rot_stress[ K_S_XX ] = rot[K_F_XX]*t[0] + rot[K_F_XY]*t[1] + rot[K_F_XZ]*t[2];
-    rot_stress[ K_S_YY ] = rot[K_F_YX]*t[3] + rot[K_F_YY]*t[4] + rot[K_F_YZ]*t[5];
-    rot_stress[ K_S_ZZ ] = rot[K_F_ZX]*t[6] + rot[K_F_ZY]*t[7] + rot[K_F_ZZ]*t[8];
-
-    rot_stress[ K_S_XY ] = rot[K_F_XX]*t[3] + rot[K_F_XY]*t[4] + rot[K_F_XZ]*t[5];
-    rot_stress[ K_S_YZ ] = rot[K_F_YX]*t[6] + rot[K_F_YY]*t[7] + rot[K_F_YZ]*t[8];
-    rot_stress[ K_S_ZX ] = rot[K_F_ZX]*t[0] + rot[K_F_ZY]*t[1] + rot[K_F_ZZ]*t[2];
-  }
-
-  //--------------------------------------------------------------------------
-
-  template< class ScalarPrecise ,
-            class ScalarCompact >
-  KOKKOS_INLINE_FUNCTION static
-  void update_stress( const float dt ,
-                      const float two_mu ,
-                      const float bulk_modulus ,
-                      const ScalarCompact rot_str[] ,
-                            ScalarPrecise stress[] )
-  {
-    const ScalarCompact e = rot_str[ K_S_XX ] + rot_str[ K_S_YY ] + rot_str[ K_S_ZZ ] ;
-    const ScalarCompact eb = e * bulk_modulus ;
-    const ScalarCompact e3 = e / 3.0 ;
-
-    stress[K_S_XX] += dt * ( two_mu * ( rot_str[K_S_XX] - e3 ) + eb );
-    stress[K_S_YY] += dt * ( two_mu * ( rot_str[K_S_YY] - e3 ) + eb );
-    stress[K_S_ZZ] += dt * ( two_mu * ( rot_str[K_S_ZZ] - e3 ) + eb );
-
-    stress[K_S_XY] += dt * two_mu * rot_str[K_S_XY];
-    stress[K_S_YZ] += dt * two_mu * rot_str[K_S_YZ];
-    stress[K_S_ZX] += dt * two_mu * rot_str[K_S_ZX];
-  }
-
-  //--------------------------------------------------------------------------
-
-  template< class ScalarPrecise ,
-            class ScalarCompact >
-  static KOKKOS_INLINE_FUNCTION
-  void comp_force( const ScalarPrecise vx[] ,
-                   const ScalarPrecise vy[] ,
-                   const ScalarPrecise vz[] ,
-                   const ScalarCompact grad_x[] ,
-                   const ScalarCompact grad_y[] ,
-                   const ScalarCompact grad_z[] ,
-                   const ScalarCompact total_stress12th[] ,
-                         ScalarCompact force[][ SpatialDim ] ,
-                         ScalarCompact & energy )
-  {
-    ScalarPrecise internal_energy = 0 ;
-
-    for ( unsigned inode = 0; inode < ElemNodeCount ; ++inode ) {
-
-      force[inode][0] = total_stress12th[K_S_XX] * grad_x[inode] +
-                        total_stress12th[K_S_XY] * grad_y[inode] +
-                        total_stress12th[K_S_XZ] * grad_z[inode] ;
-
-      force[inode][1] = total_stress12th[K_S_YX] * grad_x[inode] +
-                        total_stress12th[K_S_YY] * grad_y[inode] +
-                        total_stress12th[K_S_YZ] * grad_z[inode] ;
-
-      force[inode][2] = total_stress12th[K_S_ZX] * grad_x[inode] +
-                        total_stress12th[K_S_ZY] * grad_y[inode] +
-                        total_stress12th[K_S_ZZ] * grad_z[inode] ;
-
-      internal_energy += force[inode][0] * vx[inode] +
-                         force[inode][1] * vy[inode] +
-                         force[inode][2] * vz[inode] ;
-    }
-
-    energy = internal_energy ;
-  }
-
-  //--------------------------------------------------------------------------
-};
-
-} // namespace Explicit
-
-#endif /* #ifndef KOKKOS_HEXEXPLICITFUNCTIONS_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/Implicit.hpp b/lib/kokkos/example/multi_fem/Implicit.hpp
deleted file mode 100644
index 7ca180bd2adc34ce72eabd8e2660a619654368bc..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/Implicit.hpp
+++ /dev/null
@@ -1,341 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef HYBRIDFEM_IMPLICIT_HPP
-#define HYBRIDFEM_IMPLICIT_HPP
-
-#include <utility>
-#include <iostream>
-#include <iomanip>
-
-#include <Kokkos_Core.hpp>
-#include <SparseLinearSystem.hpp>
-#include <SparseLinearSystemFill.hpp>
-#include <ImplicitFunctors.hpp>
-#include <FEMesh.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace HybridFEM {
-namespace Implicit {
-
-struct PerformanceData {
-  double mesh_time ;
-  double graph_time ;
-  double elem_time ;
-  double matrix_gather_fill_time ;
-  double matrix_boundary_condition_time ;
-  double cg_iteration_time ;
-
-  PerformanceData()
-    : mesh_time(0)
-    , graph_time(0)
-    , elem_time(0)
-    , matrix_gather_fill_time(0)
-    , matrix_boundary_condition_time(0)
-    , cg_iteration_time(0)
-    {}
-
-  void best( const PerformanceData & rhs )
-  {
-    mesh_time = std::min( mesh_time , rhs.mesh_time );
-    graph_time = std::min( graph_time , rhs.graph_time );
-    elem_time = std::min( elem_time , rhs.elem_time );
-    matrix_gather_fill_time = std::min( matrix_gather_fill_time , rhs.matrix_gather_fill_time );
-    matrix_boundary_condition_time = std::min( matrix_boundary_condition_time , rhs.matrix_boundary_condition_time );
-    cg_iteration_time = std::min( cg_iteration_time , rhs.cg_iteration_time );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class FixtureType >
-PerformanceData run( const typename FixtureType::FEMeshType & mesh ,
-                     const int , // global_max_x ,
-                     const int , // global_max_y ,
-                     const int global_max_z ,
-                     const bool print_sample )
-{
-  typedef Scalar                              scalar_type ;
-  typedef FixtureType                         fixture_type ;
-  typedef typename fixture_type::execution_space  execution_space;
-  //typedef typename execution_space::size_type     size_type ; // unused
-
-  typedef typename fixture_type::FEMeshType mesh_type ;
-  typedef typename fixture_type::coordinate_scalar_type coordinate_scalar_type ;
-
-  enum { ElementNodeCount = fixture_type::element_node_count };
-
-  const comm::Machine machine = mesh.parallel_data_map.machine ;
-
-  const size_t element_count = mesh.elem_node_ids.dimension_0();
-
-  const size_t iteration_limit = 200 ;
-  const double residual_tolerance = 1e-14 ;
-
-  size_t iteration_count = 0 ;
-  double residual_norm = 0 ;
-
-  PerformanceData perf_data ;
-
-  //------------------------------------
-  // Sparse linear system types:
-
-  typedef Kokkos::View< scalar_type* , execution_space >   vector_type ;
-  typedef Kokkos::CrsMatrix< scalar_type , execution_space >     matrix_type ;
-  typedef typename matrix_type::graph_type         matrix_graph_type ;
-  typedef typename matrix_type::coefficients_type  matrix_coefficients_type ;
-
-  typedef GraphFactory< matrix_graph_type , mesh_type > graph_factory ;
-
-  //------------------------------------
-  // Problem setup types:
-
-  typedef ElementComputation< scalar_type , scalar_type , execution_space > ElementFunctor ;
-  typedef DirichletBoundary< scalar_type , scalar_type , execution_space > BoundaryFunctor ;
-
-  typedef typename ElementFunctor::elem_matrices_type elem_matrices_type ;
-  typedef typename ElementFunctor::elem_vectors_type  elem_vectors_type ;
-
-  typedef GatherFill< matrix_type ,
-                      mesh_type ,
-                      elem_matrices_type ,
-                      elem_vectors_type > GatherFillFunctor ;
-
-  //------------------------------------
-
-  const scalar_type elem_coeff_K = 2 ;
-  const scalar_type elem_load_Q  = 1 ;
-
-  matrix_type linsys_matrix ;
-  vector_type linsys_rhs ;
-  vector_type linsys_solution ;
-
-  typename graph_factory::element_map_type element_map ;
-
-  Kokkos::Timer wall_clock ;
-
-  //------------------------------------
-  // Generate sparse matrix graph and element->graph map.
-
-  graph_factory::create( mesh , linsys_matrix.graph , element_map );
-
-  execution_space().fence();
-  perf_data.graph_time = comm::max( machine , wall_clock.seconds() );
-
-  //------------------------------------
-  // Allocate linear system coefficients and rhs:
-
-  const size_t local_owned_length =
-    linsys_matrix.graph.row_map.dimension_0() - 1 ;
-
-  linsys_matrix.coefficients =
-    matrix_coefficients_type( "coeff" , linsys_matrix.graph.entries.dimension_0() );
-
-  linsys_rhs      = vector_type( "rhs" , local_owned_length );
-  linsys_solution = vector_type( "solution" , local_owned_length );
-
-  //------------------------------------
-  // Fill linear system
-  {
-    elem_matrices_type elem_matrices ;
-    elem_vectors_type  elem_vectors ;
-
-    if ( element_count ) {
-      elem_matrices = elem_matrices_type( std::string("elem_matrices"), element_count );
-      elem_vectors  = elem_vectors_type ( std::string("elem_vectors"), element_count );
-    }
-
-    //------------------------------------
-    // Compute element matrices and vectors:
-
-    wall_clock.reset();
-
-    ElementFunctor::apply( mesh ,
-                           elem_matrices , elem_vectors ,
-                           elem_coeff_K , elem_load_Q );
-
-    execution_space().fence();
-    perf_data.elem_time = comm::max( machine , wall_clock.seconds() );
-
-    //------------------------------------
-    // Fill linear system coefficients:
-
-    wall_clock.reset();
-
-    GatherFillFunctor::apply( linsys_matrix , linsys_rhs ,
-               mesh , element_map , elem_matrices , elem_vectors );
-
-    execution_space().fence();
-    perf_data.matrix_gather_fill_time = comm::max( machine , wall_clock.seconds() );
-
-    // Apply boundary conditions:
-
-    wall_clock.reset();
-
-    BoundaryFunctor::apply( linsys_matrix , linsys_rhs , mesh ,
-                            0 , global_max_z , 0 , global_max_z );
-
-    execution_space().fence();
-    perf_data.matrix_boundary_condition_time = comm::max( machine , wall_clock.seconds() );
-  }
-
-  //------------------------------------
-  // Solve linear system
-
-  cgsolve( mesh.parallel_data_map ,
-           linsys_matrix , linsys_rhs , linsys_solution ,
-           iteration_count , residual_norm ,
-           perf_data.cg_iteration_time ,
-           iteration_limit , residual_tolerance );
-
-  //------------------------------------
-
-  if ( print_sample ) {
-
-    typename mesh_type::node_coords_type::HostMirror coords_h =
-      Kokkos::create_mirror( mesh.node_coords );
-
-    typename vector_type::HostMirror X_h =
-      Kokkos::create_mirror( linsys_solution );
-
-    Kokkos::deep_copy( coords_h , mesh.node_coords );
-    Kokkos::deep_copy( X_h , linsys_solution );
-
-    for ( size_t i = 0 ; i < mesh.parallel_data_map.count_owned ; ++i ) {
-      const coordinate_scalar_type x = coords_h(i,0);
-      const coordinate_scalar_type y = coords_h(i,1);
-      const coordinate_scalar_type z = coords_h(i,2);
-
-      if ( x <= 0 && y <= 0 ) {
-        std::cout << "  node( " << x << " " << y << " " << z << " ) = "
-                  << X_h(i) << std::endl ;
-      }
-    }
-  }
-
-  return perf_data ;
-}
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class Device >
-void driver( const char * const label ,
-             comm::Machine machine ,
-             const int gang_count ,
-             const int elem_count_beg ,
-             const int elem_count_end ,
-             const int runs )
-{
-  typedef Scalar              scalar_type ;
-  typedef Device              execution_space ;
-  typedef double              coordinate_scalar_type ;
-  typedef FixtureElementHex8  fixture_element_type ;
-
-  typedef BoxMeshFixture< coordinate_scalar_type ,
-                          execution_space ,
-                          fixture_element_type > fixture_type ;
-
-  typedef typename fixture_type::FEMeshType mesh_type ;
-
-  const size_t proc_count = comm::size( machine );
-  const size_t proc_rank  = comm::rank( machine );
-
-  if ( elem_count_beg == 0 || elem_count_end == 0 || runs == 0 ) return ;
-
-  if ( comm::rank( machine ) == 0 ) {
-    std::cout << std::endl ;
-    std::cout << "\"Kokkos::HybridFE::Implicit " << label << "\"" << std::endl;
-    std::cout << "\"Size\" ,  \"Graphing\" , \"Element\" , \"Fill\" ,   \"Boundary\" ,  \"CG-Iter\"" << std::endl
-              << "\"elems\" , \"millisec\" , \"millisec\" , \"millisec\" , \"millisec\" , \"millisec\"" << std::endl ;
-  }
-
-  for(int i = elem_count_beg ; i < elem_count_end ; i *= 2 )
-  {
-    const int ix = std::max( 1 , (int) cbrt( ((double) i) / 2.0 ) );
-    const int iy = ix + 1 ;
-    const int iz = 2 * iy ;
-    const int n  = ix * iy * iz ;
-
-    mesh_type mesh =
-      fixture_type::create( proc_count , proc_rank , gang_count ,
-                            ix , iy , iz );
-
-    mesh.parallel_data_map.machine = machine ;
-
-    PerformanceData perf_data , perf_best ;
-
-    for(int j = 0; j < runs; j++){
-
-     perf_data = run<scalar_type,fixture_type>(mesh,ix,iy,iz, false );
-
-     if( j == 0 ) {
-       perf_best = perf_data ;
-     }
-     else {
-       perf_best.best( perf_data );
-     }
-   }
-
-  if ( comm::rank( machine ) == 0 ) {
-
-     std::cout << std::setw(8) << n << " , "
-               << std::setw(10) << perf_best.graph_time * 1000 << " , "
-               << std::setw(10) << perf_best.elem_time * 1000 << " , "
-               << std::setw(10) << perf_best.matrix_gather_fill_time * 1000 << " , "
-               << std::setw(10) << perf_best.matrix_boundary_condition_time * 1000 << " , "
-               << std::setw(10) << perf_best.cg_iteration_time * 1000
-               << std::endl ;
-    }
-  }
-}
-
-//----------------------------------------------------------------------------
-
-} /* namespace Implicit */
-} /* namespace HybridFEM */
-
-
-#endif /* #ifndef HYBRIDFEM_IMPLICIT_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/ImplicitFunctors.hpp b/lib/kokkos/example/multi_fem/ImplicitFunctors.hpp
deleted file mode 100644
index 4855939bb878bd651eab086d5a9dd2d27ee68426..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/ImplicitFunctors.hpp
+++ /dev/null
@@ -1,585 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <cstdlib>
-#include <cmath>
-
-namespace HybridFEM {
-namespace Implicit {
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , unsigned Dim , unsigned N >
-struct TensorIntegration ;
-
-template<typename Scalar >
-struct TensorIntegration<Scalar,1,1> {
-  Scalar pts[1] ;
-  Scalar wts[1] ;
-
-  TensorIntegration() { pts[0] = 0 ; wts[0] = 2 ; }
-};
-
-template<typename Scalar >
-struct TensorIntegration<Scalar,1,2>
-{
-  Scalar pts[2] ;
-  Scalar wts[2] ;
-
-  TensorIntegration()
-  {
-    const Scalar x2 = 0.577350269 ;
-    pts[0] = -x2; wts[0] = 1.0;
-    pts[1] =  x2; wts[1] = 1.0;
-  }
-};
-
-template<typename Scalar >
-struct TensorIntegration<Scalar,1,3>
-{
-  Scalar pts[3] ;
-  Scalar wts[3] ;
-
-  TensorIntegration()
-  {
-    const Scalar x3 = 0.774596669 ;
-    const Scalar w1 = 0.555555556 ;
-    const Scalar w2 = 0.888888889 ;
-    pts[0] =  -x3 ;  wts[0] = w1 ;
-    pts[1] =    0 ;  wts[1] = w2 ;
-    pts[2] =   x3 ;  wts[2] = w1 ;
-  }
-};
-
-template< typename Scalar , unsigned Order >
-struct TensorIntegration<Scalar,3,Order>
-{
-  static const unsigned N = Order * Order * Order ;
-
-  Scalar pts[N][3] ;
-  Scalar wts[N];
-
-  TensorIntegration()
-  {
-    TensorIntegration<Scalar,1,Order> oneD ;
-
-    unsigned n = 0 ;
-    for ( unsigned k = 0 ; k < Order ; ++k ) {
-    for ( unsigned j = 0 ; j < Order ; ++j ) {
-    for ( unsigned i = 0 ; i < Order ; ++i , ++n ) {
-      pts[n][0] = oneD.pts[i] ;
-      pts[n][1] = oneD.pts[j] ;
-      pts[n][2] = oneD.pts[k] ;
-      wts[n] = oneD.wts[i] * oneD.wts[j] * oneD.wts[k] ;
-    }}}
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar >
-struct ShapeFunctionEvaluation {
-
-  static const unsigned FunctionCount = 8 ;
-  static const unsigned SpatialDimension = 3 ;
-  static const unsigned IntegrationOrder = 2 ;
-
-  typedef TensorIntegration< Scalar , SpatialDimension , IntegrationOrder > 
-    TensorIntegrationType ;
-
-  static const unsigned PointCount = TensorIntegrationType::N ;
-
-  Scalar value   [ PointCount ][ FunctionCount ] ;
-  Scalar gradient[ PointCount ][ FunctionCount * SpatialDimension ];
-  Scalar weight  [ PointCount ];
-
-  ShapeFunctionEvaluation()
-  {
-    const TensorIntegration< Scalar , SpatialDimension , IntegrationOrder > 
-      integration ;
-
-    const Scalar ONE8TH = 0.125 ;
-
-    for ( unsigned i = 0 ; i < PointCount ; ++i ) {
-
-      const Scalar u = 1.0 - integration.pts[i][0];
-      const Scalar v = 1.0 - integration.pts[i][1];
-      const Scalar w = 1.0 - integration.pts[i][2];
-
-      const Scalar up1 = 1.0 + integration.pts[i][0];
-      const Scalar vp1 = 1.0 + integration.pts[i][1];
-      const Scalar wp1 = 1.0 + integration.pts[i][2];
-
-      weight[i] = integration.wts[i] ;
-
-      // Vaues:
-      value[i][0] = ONE8TH *   u *   v *  w ;
-      value[i][1] = ONE8TH * up1 *   v *  w ;
-      value[i][2] = ONE8TH * up1 * vp1 *  w ;
-      value[i][3] = ONE8TH *   u * vp1 *  w ;
-
-      value[i][4] = ONE8TH *   u *   v *  wp1 ;
-      value[i][5] = ONE8TH * up1 *   v *  wp1 ;
-      value[i][6] = ONE8TH * up1 * vp1 *  wp1 ;
-      value[i][7] = ONE8TH *   u * vp1 *  wp1 ;
-
-      //fn 0 = u * v * w
-      gradient[i][ 0] = ONE8TH * -1  *  v  *  w  ;
-      gradient[i][ 1] = ONE8TH *  u  * -1  *  w  ;
-      gradient[i][ 2] = ONE8TH *  u  *  v  * -1  ;
-
-      //fn 1 = up1 * v * w
-      gradient[i][ 3] = ONE8TH *  1  *  v  *  w  ;
-      gradient[i][ 4] = ONE8TH * up1 * -1  *  w  ;
-      gradient[i][ 5] = ONE8TH * up1 *  v  * -1  ;
-
-      //fn 2 = up1 * vp1 * w
-      gradient[i][ 6] = ONE8TH *  1  * vp1 *  w ;
-      gradient[i][ 7] = ONE8TH * up1 *  1  *  w ;
-      gradient[i][ 8] = ONE8TH * up1 * vp1 * -1 ;
-
-      //fn 3 = u * vp1 * w
-      gradient[i][ 9] = ONE8TH * -1 * vp1 *  w ;
-      gradient[i][10] = ONE8TH *  u *  1  *  w ;
-      gradient[i][11] = ONE8TH *  u * vp1 * -1 ;
-
-      //fn 4 = u * v * wp1
-      gradient[i][12] = ONE8TH * -1  *  v  * wp1 ;
-      gradient[i][13] = ONE8TH *  u  * -1  * wp1 ;
-      gradient[i][14] = ONE8TH *  u  *  v  *  1  ;
-
-      //fn 5 = up1 * v * wp1
-      gradient[i][15] = ONE8TH *  1  *  v  * wp1 ;
-      gradient[i][16] = ONE8TH * up1 * -1  * wp1 ;
-      gradient[i][17] = ONE8TH * up1 *  v  *  1  ;
-
-      //fn 6 = up1 * vp1 * wp1
-      gradient[i][18] = ONE8TH *  1  * vp1 * wp1 ;
-      gradient[i][19] = ONE8TH * up1 *  1  * wp1 ;
-      gradient[i][20] = ONE8TH * up1 * vp1 *  1 ;
-
-      //fn 7 = u * vp1 * wp1
-      gradient[i][21] = ONE8TH * -1 * vp1 * wp1 ;
-      gradient[i][22] = ONE8TH *  u *  1  * wp1 ;
-      gradient[i][23] = ONE8TH *  u * vp1 *  1 ;
-    }
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarType , typename ScalarCoordType , class DeviceType >
-struct ElementComputation
-{
-  typedef DeviceType     execution_space;
-  typedef ScalarType              scalar_type ;
-  typedef typename execution_space::size_type  size_type ;
-
-  static const size_type ElementNodeCount = 8 ;
-
-  typedef FEMesh< ScalarCoordType , ElementNodeCount , execution_space > mesh_type ;
-  typedef Kokkos::View< scalar_type[][ElementNodeCount][ElementNodeCount] , execution_space > elem_matrices_type ;
-  typedef Kokkos::View< scalar_type[][ElementNodeCount] , execution_space > elem_vectors_type ;
-
-  typedef ShapeFunctionEvaluation< scalar_type > shape_function_data ;
-
-  static const unsigned SpatialDim    = shape_function_data::SpatialDimension ;
-  static const unsigned FunctionCount = shape_function_data::FunctionCount ;
-
-private:
-
-  const shape_function_data               shape_eval ;
-  typename mesh_type::elem_node_ids_type  elem_node_ids ;
-  typename mesh_type::node_coords_type    node_coords ;
-  elem_matrices_type                      element_matrices ;
-  elem_vectors_type                       element_vectors ;
-  scalar_type                             coeff_K ;
-  scalar_type                             coeff_Q ;
-
-  ElementComputation( const mesh_type   & arg_mesh ,
-                      const elem_matrices_type  & arg_element_matrices , 
-                      const elem_vectors_type   & arg_element_vectors ,
-                      const scalar_type   arg_coeff_K ,
-                      const scalar_type   arg_coeff_Q )
-  : shape_eval()
-  , elem_node_ids( arg_mesh.elem_node_ids )
-  , node_coords(   arg_mesh.node_coords )
-  , element_matrices( arg_element_matrices )
-  , element_vectors( arg_element_vectors )
-  , coeff_K( arg_coeff_K )
-  , coeff_Q( arg_coeff_Q )
-  {}
-
-public:
-
-  static void apply( const mesh_type  & mesh ,
-                     const elem_matrices_type & elem_matrices ,
-                     const elem_vectors_type  & elem_vectors ,
-                     const scalar_type  elem_coeff_K ,
-                     const scalar_type  elem_coeff_Q )
-  {
-    ElementComputation comp( mesh , elem_matrices , elem_vectors , elem_coeff_K , elem_coeff_Q );
-    const size_t elem_count = mesh.elem_node_ids.dimension_0();
-
-    parallel_for( elem_count , comp );
-  }
-
-  //------------------------------------
-
-  static const unsigned FLOPS_jacobian =
-    FunctionCount * SpatialDim * SpatialDim * 2 ;
-
-  KOKKOS_INLINE_FUNCTION
-  void jacobian( const ScalarCoordType * x, 
-                 const ScalarCoordType * y, 
-                 const ScalarCoordType * z, 
-                 const scalar_type * grad_vals, 
-                 scalar_type * J) const
-  {
-    int i_grad = 0 ;
-
-    for( unsigned i = 0; i < ElementNodeCount ; ++i , i_grad += SpatialDim ) {
-      const scalar_type g0 = grad_vals[ i_grad ];
-      const scalar_type g1 = grad_vals[ i_grad + 1 ];
-      const scalar_type g2 = grad_vals[ i_grad + 2 ];
-      const scalar_type x0 = x[i] ;
-      const scalar_type x1 = y[i] ;
-      const scalar_type x2 = z[i] ;
-
-      J[0] += g0 * x0 ;
-      J[1] += g0 * x1 ;
-      J[2] += g0 * x2 ;
-
-      J[3] += g1 * x0 ;
-      J[4] += g1 * x1 ;
-      J[5] += g1 * x2 ;
-
-      J[6] += g2 * x0 ;
-      J[7] += g2 * x1 ;
-      J[8] += g2 * x2 ;
-    }
-  }
-
-  //------------------------------------
-
-  static const unsigned FLOPS_inverse_and_det = 46 ;
-
-  KOKKOS_INLINE_FUNCTION
-  scalar_type inverse_and_determinant3x3( scalar_type * const J ) const
-  {
-    const scalar_type J00 = J[0];
-    const scalar_type J01 = J[1];
-    const scalar_type J02 = J[2];
-
-    const scalar_type J10 = J[3];
-    const scalar_type J11 = J[4];
-    const scalar_type J12 = J[5];
-
-    const scalar_type J20 = J[6];
-    const scalar_type J21 = J[7];
-    const scalar_type J22 = J[8];
-
-    const scalar_type term0 = J22*J11 - J21*J12;
-    const scalar_type term1 = J22*J01 - J21*J02;
-    const scalar_type term2 = J12*J01 - J11*J02;
-
-    const scalar_type detJ = J00*term0 - J10*term1 + J20*term2;
-    const scalar_type inv_detJ = 1.0/detJ;
-
-    J[0] =  term0*inv_detJ;
-    J[1] = -term1*inv_detJ;
-    J[2] =  term2*inv_detJ;
-
-    J[3] = -(J22*J10 - J20*J12)*inv_detJ;
-    J[4] =  (J22*J00 - J20*J02)*inv_detJ;
-    J[5] = -(J12*J00 - J10*J02)*inv_detJ;
-
-    J[6] =  (J21*J10 - J20*J11)*inv_detJ;
-    J[7] = -(J21*J00 - J20*J01)*inv_detJ;
-    J[8] =  (J11*J00 - J10*J01)*inv_detJ;
-
-    return detJ ;
-  }
-
-  //------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void matTransMat3x3_X_3xn( const scalar_type * A, int n,
-                             const scalar_type * B,
-                             scalar_type * C ) const
-  {
-    //A is 3x3, B is 3xn. So C is also 3xn.
-    //A,B,C are all assumed to be ordered such that columns are contiguous.
-
-    scalar_type * Cj = C;
-    const scalar_type * Bj = B;
-
-    for(int j=0; j<n; ++j) {
-      Cj[0] = A[0]*Bj[0] + A[1]*Bj[1] + A[2]*Bj[2];
-      Cj[1] = A[3]*Bj[0] + A[4]*Bj[1] + A[5]*Bj[2];
-      Cj[2] = A[6]*Bj[0] + A[7]*Bj[1] + A[8]*Bj[2];
-      Bj += 3;
-      Cj += 3;
-    }
-
-  }
-  //------------------------------------
-
-  static const unsigned FLOPS_contributeDiffusionMatrix = FunctionCount * ( 3 * 5 + FunctionCount * 7 ) ;
-
-  KOKKOS_INLINE_FUNCTION
-  void contributeDiffusionMatrix(
-    const scalar_type weight ,
-    const scalar_type grad_vals[] ,
-    const scalar_type invJ[] ,
-    scalar_type elem_mat[][8] ) const
-  {
-    scalar_type dpsidx[8], dpsidy[8], dpsidz[8];
-
-    int i_grad = 0 ;
-    for( unsigned i = 0; i < FunctionCount ; ++i , i_grad += 3 ) {
-      const scalar_type g0 = grad_vals[i_grad+0];
-      const scalar_type g1 = grad_vals[i_grad+1];
-      const scalar_type g2 = grad_vals[i_grad+2];
-
-      dpsidx[i] = g0 * invJ[0] + g1 * invJ[1] + g2 * invJ[2];
-      dpsidy[i] = g0 * invJ[3] + g1 * invJ[4] + g2 * invJ[5];
-      dpsidz[i] = g0 * invJ[6] + g1 * invJ[7] + g2 * invJ[8];
-    }
-
-    for( unsigned m = 0; m < FunctionCount; m++) {
-      for( unsigned n = 0; n < FunctionCount; n++) {
-
-        elem_mat[m][n] += weight * 
-          ((dpsidx[m] * dpsidx[n]) + 
-           (dpsidy[m] * dpsidy[n]) +
-           (dpsidz[m] * dpsidz[n]));            
-      }
-    }
-  }
-
-  //------------------------------------
-
-  static const unsigned FLOPS_contributeSourceVector = FunctionCount * 2 ;
-
-  KOKKOS_INLINE_FUNCTION
-  void contributeSourceVector( const scalar_type term ,
-                               const scalar_type psi[] ,
-                               scalar_type elem_vec[] ) const
-  {
-     for( unsigned i=0; i< FunctionCount ; ++i) {
-       elem_vec[i] += psi[i] * term ;
-     }
-  }
-
-
-  static const unsigned FLOPS_operator =
-           shape_function_data::PointCount * ( 3
-             + FLOPS_jacobian
-             + FLOPS_inverse_and_det
-             + FLOPS_contributeDiffusionMatrix
-             + FLOPS_contributeSourceVector ) ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( int ielem )const {
-
-    scalar_type elem_vec[8] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
-    scalar_type elem_mat[8][8] =
-      { { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
-        { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
-        { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
-        { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
-        { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
-        { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
-        { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
-        { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } };
-
-    ScalarCoordType x[8], y[8], z[8];
-
-    for ( int i = 0 ; i < 8 ; ++i ) {
-      const int node_index = elem_node_ids( ielem , i );
-      x[i] = node_coords( node_index , 0 );
-      y[i] = node_coords( node_index , 1 );
-      z[i] = node_coords( node_index , 2 );
-    }
-
-    // This loop could be parallelized; however,
-    // it would require additional per-thread temporaries
-    // of 'elem_vec' and 'elem_mat' which would
-    // consume more local memory and have to be reduced.
-
-    for ( unsigned i = 0 ; i < shape_function_data::PointCount ; ++i ) {
-
-      scalar_type J[SpatialDim*SpatialDim] = { 0, 0, 0,  0, 0, 0,  0, 0, 0 };
-
-      jacobian( x, y, z, shape_eval.gradient[i] , J );
-
-      // Overwrite J with its inverse to save scratch memory space.
-      const scalar_type detJ_w   = shape_eval.weight[i] * inverse_and_determinant3x3(J);
-      const scalar_type k_detJ_w = coeff_K * detJ_w ;
-      const scalar_type Q_detJ_w = coeff_Q * detJ_w ;
-
-      contributeDiffusionMatrix( k_detJ_w , shape_eval.gradient[i] , J , elem_mat );
-
-      contributeSourceVector( Q_detJ_w , shape_eval.value[i] , elem_vec );
-    }
-
-    for( size_type i=0; i< ElementNodeCount ; ++i) {
-      element_vectors(ielem, i) = elem_vec[i] ;
-    }
-
-    for( size_type i = 0; i < ElementNodeCount ; i++){
-      for( size_type j = 0; j < ElementNodeCount ; j++){
-        element_matrices(ielem, i, j) = elem_mat[i][j] ;
-      }
-    }
-  }
-}; /* ElementComputation */
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarType , typename ScalarCoordType , class DeviceType >
-struct DirichletBoundary
-{
-  typedef DeviceType     execution_space;
-  typedef typename execution_space::size_type  size_type ;
-
-  static const size_type ElementNodeCount = 8 ;
-
-  typedef Kokkos::CrsMatrix< ScalarType , execution_space >    matrix_type ;
-  typedef Kokkos::View< ScalarType[] , execution_space >  vector_type ;
-
-  typedef FEMesh< ScalarCoordType , ElementNodeCount , execution_space > mesh_type ;
-
-  typename mesh_type::node_coords_type node_coords ;
-  matrix_type     matrix ;
-  vector_type     rhs ;
-  ScalarCoordType bc_lower_z ;
-  ScalarCoordType bc_upper_z ;
-  ScalarType      bc_lower_value ;
-  ScalarType      bc_upper_value ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( size_type inode ) const
-  {
-    //  Apply a dirichlet boundary condition to 'irow'
-    //  to maintain the symmetry of the original 
-    //  global stiffness matrix, zero out the columns
-    //  that correspond to boundary conditions, and
-    //  adjust the load vector accordingly
-
-    const size_type iBeg = matrix.graph.row_map[inode];
-    const size_type iEnd = matrix.graph.row_map[inode+1];
-
-    const ScalarCoordType z = node_coords(inode,2);
-    const bool bc_lower = z <= bc_lower_z ;
-    const bool bc_upper = bc_upper_z <= z ;
-
-    if ( bc_lower || bc_upper ) {
-      const ScalarType bc_value = bc_lower ? bc_lower_value
-                                           : bc_upper_value ;
-
-      rhs(inode) = bc_value ; //  set the rhs vector
-
-      //  zero each value on the row, and leave a one
-      //  on the diagonal
-
-      for( size_type i = iBeg ; i < iEnd ; i++) {
-        matrix.coefficients(i) =
-          (int) inode == matrix.graph.entries(i) ? 1 : 0 ;
-      }
-    }
-    else {
-      //  Find any columns that are boundary conditions.
-      //  Clear them and adjust the load vector
-
-      for( size_type i = iBeg ; i < iEnd ; i++ ) {
-        const size_type cnode = matrix.graph.entries(i) ;
-
-        const ScalarCoordType zc = node_coords(cnode,2);
-        const bool c_bc_lower = zc <= bc_lower_z ;
-        const bool c_bc_upper = bc_upper_z <= zc ;
-
-        if ( c_bc_lower || c_bc_upper ) {
-
-          const ScalarType c_bc_value = c_bc_lower ? bc_lower_value
-                                                   : bc_upper_value ;
-
-          rhs( inode ) -= c_bc_value * matrix.coefficients(i);
-
-          matrix.coefficients(i) = 0 ;
-        }
-      }
-    }
-  }
-
-
-  static void apply( const matrix_type & linsys_matrix ,
-                     const vector_type & linsys_rhs ,
-                     const mesh_type   & mesh ,
-                     const ScalarCoordType  bc_lower_z ,
-                     const ScalarCoordType  bc_upper_z ,
-                     const ScalarType       bc_lower_value ,
-                     const ScalarType       bc_upper_value )
-  {
-    const size_t row_count = linsys_matrix.graph.row_map.dimension_0() - 1 ;
-    DirichletBoundary op ;
-    op.node_coords    = mesh.node_coords ;
-    op.matrix         = linsys_matrix ;
-    op.rhs            = linsys_rhs ;
-    op.bc_lower_z     = bc_lower_z ;
-    op.bc_upper_z     = bc_upper_z ;
-    op.bc_lower_value = bc_lower_value ;
-    op.bc_upper_value = bc_upper_value ;
-    parallel_for( row_count , op );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-} /* namespace Implicit */
-} /* namespace HybridFEM */
-
diff --git a/lib/kokkos/example/multi_fem/LinAlgBLAS.hpp b/lib/kokkos/example/multi_fem/LinAlgBLAS.hpp
deleted file mode 100644
index 5e2292b32af4ba8ea35f5e9c51b431f1c2a6a974..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/LinAlgBLAS.hpp
+++ /dev/null
@@ -1,567 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef USESCASES_LINALG_BLAS_HPP
-#define USESCASES_LINALG_BLAS_HPP
-
-#include <cmath>
-#include <utility>
-#include <ParallelComm.hpp>
-#include <Kokkos_Core.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template< class Scalar , class Layout , class DeviceType > struct Dot ;
-
-template< class Scalar , class Layout , class DeviceType > struct Dot1 ;
-
-template< typename ScalarA ,
-          typename ScalarY ,
-          class Layout , class Device >
-struct Scale ;
-
-template< typename ScalarA ,
-          typename ScalarY ,
-          class Layout , class Device >
-struct Fill ;
-
-template< typename ScalarA ,
-          typename ScalarX ,
-          typename ScalarY ,
-          class Layout , class Device >
-struct AXPY ;
-
-template< typename ScalarX ,
-          typename ScalarB ,
-          typename ScalarY ,
-          class Layout , class Device >
-struct XPBY ;
-
-template< typename ScalarA ,
-          typename ScalarX ,
-          typename ScalarB ,
-          typename ScalarY ,
-          typename ScalarW ,
-          class Layout , class Device >
-struct WAXPBY ;
-
-}
-}
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-#if defined( KOKKOS_ENABLE_MPI )
-
-template< typename ScalarX /* Allow mix of const and non-const */ ,
-          typename ScalarY /* Allow mix of const and non-const */ ,
-          class D>
-inline
-double dot( const size_t n ,
-            const View< ScalarX * , D > & x ,
-            const View< ScalarY * , D > & y ,
-            comm::Machine machine )
-{
-  double global_result = 0 ;
-  double local_result = 0 ;
-  using x_type = View<ScalarX*, D>;
-  using L = typename x_type::array_layout;
-
-  Impl::Dot< ScalarX , L , D >( n , x , y , local_result );
-
-  MPI_Allreduce( & local_result , & global_result , 1 ,
-                 MPI_DOUBLE , MPI_SUM , machine.mpi_comm );
-
-  return global_result ;
-}
-
-#else
-
-template< typename ScalarX /* Allow mix of const and non-const */ ,
-          typename ScalarY /* Allow mix of const and non-const */ ,
-          class D >
-inline
-double dot( const size_t n ,
-            const View< ScalarX * , D > & x ,
-            const View< ScalarY * , D > & y ,
-            comm::Machine )
-{
-  double global_result = 0 ;
-  using x_type = View<ScalarX*, D>;
-  using L = typename x_type::array_layout;
-
-  Impl::Dot< ScalarX , L , D >( n , x , y , global_result );
-
-  return global_result ;
-}
-
-#endif
-
-//----------------------------------------------------------------------------
-
-#if defined( KOKKOS_ENABLE_MPI )
-
-template< typename ScalarX /* Allow mix of const and non-const */ ,
-          class L , class D ,
-          class MX /* Allow any management type */ >
-inline
-double dot( const size_t n ,
-            const View< ScalarX * , L , D , MX > & x ,
-            comm::Machine machine )
-{
-  double global_result = 0 ;
-  double local_result = 0 ;
-
-  Impl::Dot1< ScalarX , L , D >( n , x , local_result );
-
-  MPI_Allreduce( & local_result , & global_result , 1 ,
-                 MPI_DOUBLE , MPI_SUM , machine.mpi_comm );
-
-  return global_result ;
-}
-
-#else
-
-template< typename ScalarX /* Allow mix of const and non-const */ ,
-          class D>
-inline
-double dot( const size_t n ,
-            const View< ScalarX * , D> & x ,
-            comm::Machine )
-{
-  double global_result = 0 ;
-  using x_type = View<ScalarX*, D>;
-  using L = typename x_type::array_layout;
-
-  Impl::Dot1< ScalarX , L , D >( n , x , global_result );
-
-  return global_result ;
-}
-
-#endif
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarX /* Allow mix of const and non-const */ ,
-          class D >
-inline
-double norm2( const size_t n ,
-              const View< ScalarX * , D > & x ,
-              comm::Machine machine )
-{
-  return std::sqrt( dot( n , x , machine ) );
-}
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarA ,
-          typename ScalarX ,
-          class L ,
-          class D ,
-          class MX >
-void scale( const size_t n ,
-            const ScalarA & alpha ,
-            const View< ScalarX * , L , D , MX > & x )
-{
-  Impl::Scale< ScalarA , ScalarX , L , D >( n , alpha , x );
-}
-
-template< typename ScalarA ,
-          typename ScalarX ,
-          class D >
-void fill( const size_t n ,
-           const ScalarA & alpha ,
-           const View< ScalarX * , D > & x )
-{
-  using x_type = View<ScalarX*, D>;
-  using L = typename x_type::array_layout;
-  Impl::Fill< ScalarA , ScalarX , L , D >( n , alpha , x );
-}
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarA ,
-          typename ScalarX ,
-          typename ScalarY ,
-          class D >
-void axpy( const size_t n ,
-           const ScalarA & alpha ,
-           const View< ScalarX *, D > & x ,
-           const View< ScalarY *, D > & y )
-{
-  using x_type = View<ScalarX*, D>;
-  using L = typename x_type::array_layout;
-  Impl::AXPY< ScalarA, ScalarX, ScalarY , L , D >( n, alpha, x, y );
-}
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarX ,
-          typename ScalarB ,
-          typename ScalarY ,
-          class D >
-void xpby( const size_t n ,
-           const View< ScalarX *, D > & x ,
-           const ScalarB & beta ,
-           const View< ScalarY *, D > & y )
-{
-  using x_type = View<ScalarX*, D>;
-  using L = typename x_type::array_layout;
-  Impl::XPBY< ScalarX, ScalarB, ScalarY , L , D >( n, x, beta, y );
-}
-
-//----------------------------------------------------------------------------
-// w = alpha * x + beta * y
-
-template< typename ScalarA ,
-          typename ScalarX ,
-          typename ScalarB ,
-          typename ScalarY ,
-          typename ScalarW ,
-          class D
-          >
-void waxpby( const size_t n ,
-             const ScalarA & alpha ,
-             const View< ScalarX * , D > & x ,
-             const ScalarB & beta ,
-             const View< ScalarY * , D > & y ,
-             const View< ScalarW * , D > & w )
-{
-  using x_type = typename std::decay<decltype(x)>::type;
-  using L = typename x_type::array_layout;
-  Impl::WAXPBY<ScalarA,ScalarX,ScalarB,ScalarY,ScalarW,L,D>
-    ( n , alpha , x , beta , y , w );
-}
-
-}
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template< typename Scalar , class L , class D >
-struct Dot
-{
-private:
-
-  typedef View< const Scalar*, L, D, MemoryUnmanaged >  vector_const_type ;
-
-  const vector_const_type x ;
-  const vector_const_type y ;
-
-public:
-
-  typedef typename vector_const_type::execution_space  execution_space ; // Manycore device
-  typedef double      value_type ;  // Reduction value
-
-  template< class ArgX , class ArgY >
-  inline
-  Dot( const size_t n , const ArgX & arg_x , const ArgY & arg_y , double & result )
-    : x( arg_x ), y( arg_y )
-  {
-    parallel_reduce( n , *this , result );
-  }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const iType & i , value_type & update ) const
-  { update += x(i) * y(i); }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & source )
-  { update += source;    }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0 ; }
-}; // Dot
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class L , class D >
-struct Dot1
-{
-private:
-
-  typedef View< const Scalar*, L, D , MemoryUnmanaged >  vector_const_type ;
-
-  const vector_const_type x ;
-
-public:
-
-  typedef typename vector_const_type::execution_space  execution_space ; // Manycore device
-  typedef double      value_type ;  // Reduction value
-
-  template< class ArgX >
-  inline
-  Dot1( const size_t n , const ArgX & arg_x , double & result )
-    : x( arg_x )
-  {
-    parallel_reduce( n , *this , result );
-  }
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const iType & i , value_type & update ) const
-  { update += x(i) * x(i) ; }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & source )
-  { update += source ; }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0 ; }
-}; // Dot
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-template < typename ScalarA ,
-           typename ScalarX ,
-           typename ScalarB ,
-           typename ScalarY ,
-           typename ScalarW ,
-           class L , class D >
-struct WAXPBY
-{
-private:
-
-  typedef View<       ScalarW *, L , D , MemoryUnmanaged > ViewW ;
-  typedef View< const ScalarX *, L , D , MemoryUnmanaged > ViewX ;
-  typedef View< const ScalarY *, L , D , MemoryUnmanaged > ViewY ;
-
-  const ViewW    w ;
-  const ViewX    x ;
-  const ViewY    y ;
-  const ScalarA  alpha ;
-  const ScalarB  beta ;
-
-public:
-
-  typedef typename ViewW::execution_space  execution_space ;
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const iType inode ) const
-  {
-    w(inode) = alpha * x(inode) + beta * y(inode);
-  }
-
-  template< class ArgX , class ArgY , class ArgW >
-  inline
-  WAXPBY( const size_t  n ,
-          const ScalarA & arg_alpha ,
-          const ArgX    & arg_x ,
-          const ScalarB & arg_beta ,
-          const ArgY    & arg_y ,
-          const ArgW    & arg_w )
-    : w( arg_w ), x( arg_x ), y( arg_y )
-    , alpha( arg_alpha ), beta( arg_beta )
-  {
-    parallel_for( n , *this );
-  }
-}; // WAXPBY
-
-//----------------------------------------------------------------------------
-
-template < typename ScalarB ,
-           typename ScalarW ,
-           class L , class D >
-struct Scale
-{
-private:
-
-  typedef View< ScalarW *, L , D , MemoryUnmanaged >  ViewW ;
-  const ViewW    w ;
-  const ScalarB  beta ;
-
-public:
-
-  typedef typename ViewW::execution_space  execution_space ;
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const iType & i ) const
-  { w(i) *= beta ; }
-
-  template< class ArgW >
-  inline
-  Scale( const size_t n , const ScalarB & arg_beta , const ArgW & arg_w )
-    : w( arg_w )
-    , beta( arg_beta )
-  {
-    parallel_for( n , *this );
-  }
-};
-
-template < typename ScalarB ,
-           typename ScalarW ,
-           class L , class D >
-struct Fill
-{
-private:
-
-  typedef View< ScalarW *, L , D , MemoryUnmanaged >  ViewW ;
-  const ViewW    w ;
-  const ScalarB  beta ;
-
-public:
-
-  typedef typename ViewW::execution_space  execution_space ;
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const iType & i ) const
-  { w(i) = beta ; }
-
-  template< class ArgW >
-  inline
-  Fill( const size_t n , const ScalarB & arg_beta , const ArgW & arg_w )
-    : w( arg_w )
-    , beta( arg_beta )
-  {
-    parallel_for( n , *this );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template < typename ScalarA ,
-           typename ScalarX ,
-           typename ScalarW ,
-           class L , class D >
-struct AXPY
-{
-private:
-
-  typedef View<       ScalarW *, L , D , MemoryUnmanaged >  ViewW ;
-  typedef View< const ScalarX *, L , D , MemoryUnmanaged >  ViewX ;
-
-  const ViewW    w ;
-  const ViewX    x ;
-  const ScalarA  alpha ;
-
-public:
-
-  typedef typename ViewW::execution_space  execution_space ;
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const iType & i ) const
-  { w(i) += alpha * x(i); }
-
-  template< class ArgX , class ArgW >
-  inline
-  AXPY( const size_t  n ,
-        const ScalarA & arg_alpha ,
-        const ArgX    & arg_x ,
-        const ArgW    & arg_w )
-    : w( arg_w ), x( arg_x )
-    , alpha( arg_alpha )
-  {
-    parallel_for( n , *this );
-  }
-}; // AXPY
-
-template< typename ScalarX ,
-          typename ScalarB ,
-          typename ScalarW ,
-          class L , class D >
-struct XPBY
-{
-private:
-
-  typedef View<       ScalarW *, L , D , MemoryUnmanaged >  ViewW ;
-  typedef View< const ScalarX *, L , D , MemoryUnmanaged >  ViewX ;
-
-  const ViewW    w ;
-  const ViewX    x ;
-  const ScalarB  beta ;
-
-public:
-
-  typedef typename ViewW::execution_space  execution_space ;
-
-  template< typename iType >
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const iType & i ) const
-  { w(i) = x(i) + beta * w(i); }
-
-  template< class ArgX , class ArgW >
-  inline
-  XPBY( const size_t  n ,
-        const ArgX    & arg_x ,
-        const ScalarB & arg_beta ,
-        const ArgW    & arg_w )
-    : w( arg_w ), x( arg_x )
-    , beta( arg_beta )
-  {
-    parallel_for( n , *this );
-  }
-}; // XPBY
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-} // namespace Impl
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef USESCASES_LINALG_BLAS_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/Makefile b/lib/kokkos/example/multi_fem/Makefile
deleted file mode 100644
index 4b114b56255f152206adee8dbc8979ae9015050f..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/Makefile
+++ /dev/null
@@ -1,49 +0,0 @@
-KOKKOS_PATH ?= ../..
-
-MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-SRC_DIR := $(dir $(MAKEFILE_PATH))
-
-SRC = $(wildcard $(SRC_DIR)/*.cpp)
-OBJ = $(SRC:$(SRC_DIR)/%.cpp=%.o)
-
-#SRC = $(wildcard *.cpp)
-#OBJ = $(SRC:%.cpp=%.o)
-
-default: build
-	echo "Start Build"
-
-CXXFLAGS = -O3 -I$(SRC_DIR)
-LDFLAGS ?=
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-  EXE = $(addsuffix .cuda, $(shell basename $(SRC_DIR)))
-  CXXFLAGS += -I$(SRC_DIR) -I$(CUDA_PATH) -O3
-  LDFLAGS += -L$(CUDA_PATH)/lib64 -lcusparse
-else
-  CXX = g++
-  EXE = $(addsuffix .host, $(shell basename $(SRC_DIR)))
-endif
-
-LINK ?= $(CXX)
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-
-DEPFLAGS = -M
-
-LIB =
-
-
-build: $(EXE)
-
-$(EXE): $(OBJ) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LINKFLAGS) $(EXTRA_PATH) $(OBJ) $(KOKKOS_LIBS) $(LIB) -o $(EXE)
-
-clean: 
-	rm -f *.a *.o *.cuda *.host
-
-# Compilation rules
-
-%.o:$(SRC_DIR)/%.cpp $(KOKKOS_CPP_DEPENDS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
-
diff --git a/lib/kokkos/example/multi_fem/Nonlinear.hpp b/lib/kokkos/example/multi_fem/Nonlinear.hpp
deleted file mode 100644
index f5e462cc4bddca09a574117f47afeb0c1608c876..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/Nonlinear.hpp
+++ /dev/null
@@ -1,573 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef HYBRIDFEM_NONLINEAR_HPP
-#define HYBRIDFEM_NONLINEAR_HPP
-
-#include <utility>
-#include <iostream>
-#include <iomanip>
-
-#include <Kokkos_Core.hpp>
-#include <SparseLinearSystem.hpp>
-#include <SparseLinearSystemFill.hpp>
-#include <NonlinearFunctors.hpp>
-
-#include <FEMesh.hpp>
-#include <HexElement.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace HybridFEM {
-namespace Nonlinear {
-
-struct PerformanceData {
-  double mesh_time ;
-  double graph_time ;
-  double elem_time ;
-  double matrix_gather_fill_time ;
-  double matrix_boundary_condition_time ;
-  double cg_iteration_time ;
-  size_t cg_iteration_count ;
-  size_t newton_iteration_count ;
-  double error_max ;
-
-  PerformanceData()
-    : mesh_time(0)
-    , graph_time(0)
-    , elem_time(0)
-    , matrix_gather_fill_time(0)
-    , matrix_boundary_condition_time(0)
-    , cg_iteration_time(0)
-    , cg_iteration_count(0)
-    , newton_iteration_count(0)
-    , error_max(0)
-    {}
-
-  void best( const PerformanceData & rhs )
-  {
-    mesh_time = std::min( mesh_time , rhs.mesh_time );
-    graph_time = std::min( graph_time , rhs.graph_time );
-    elem_time = std::min( elem_time , rhs.elem_time );
-    matrix_gather_fill_time = std::min( matrix_gather_fill_time , rhs.matrix_gather_fill_time );
-    matrix_boundary_condition_time = std::min( matrix_boundary_condition_time , rhs.matrix_boundary_condition_time );
-    cg_iteration_time = std::min( cg_iteration_time , rhs.cg_iteration_time );
-    cg_iteration_count = std::min( cg_iteration_count , rhs.cg_iteration_count );
-    newton_iteration_count = std::min( newton_iteration_count , rhs.newton_iteration_count );
-    error_max = std::min( error_max , rhs.error_max );
-  }
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-class ManufacturedSolution {
-public:
-
-  // Manufactured solution for one dimensional nonlinear PDE
-  //
-  //  -K T_zz + T^2 = 0 ; T(zmin) = T_zmin ; T(zmax) = T_zmax
-  //
-  //  Has an analytic solution of the form:
-  //
-  //    T(z) = ( a ( z - zmin ) + b )^(-2) where K = 1 / ( 6 a^2 )
-  //
-  //  Given T_0 and T_L compute K for this analytic solution.
-  //
-  //  Two analytic solutions:
-  //
-  //    Solution with singularity:
-  //    , a( ( 1.0 / sqrt(T_zmax) + 1.0 / sqrt(T_zmin) ) / ( zmax - zmin ) )
-  //    , b( -1.0 / sqrt(T_zmin) )
-  //
-  //    Solution without singularity:
-  //    , a( ( 1.0 / sqrt(T_zmax) - 1.0 / sqrt(T_zmin) ) / ( zmax - zmin ) )
-  //    , b( 1.0 / sqrt(T_zmin) )
-
-  const double zmin ;
-  const double zmax ;
-  const double T_zmin ;
-  const double T_zmax ;
-  const double a ;
-  const double b ;
-  const double K ;
-
-  ManufacturedSolution( const double arg_zmin ,
-                        const double arg_zmax ,
-                        const double arg_T_zmin ,
-                        const double arg_T_zmax )
-    : zmin( arg_zmin )
-    , zmax( arg_zmax )
-    , T_zmin( arg_T_zmin )
-    , T_zmax( arg_T_zmax )
-    , a( ( 1.0 / std::sqrt(T_zmax) - 1.0 / std::sqrt(T_zmin) ) / ( zmax - zmin ) )
-    , b( 1.0 / std::sqrt(T_zmin) )
-    , K( 1.0 / ( 6.0 * a * a ) )
-    {}
-
-  double operator()( const double z ) const
-  {
-    const double tmp = a * ( z - zmin ) + b ;
-    return 1.0 / ( tmp * tmp );
-  }
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class FixtureType >
-PerformanceData run( const typename FixtureType::FEMeshType & mesh ,
-                     const int , // global_max_x ,
-                     const int , // global_max_y ,
-                     const int global_max_z ,
-                     const bool print_error )
-{
-  typedef Scalar                              scalar_type ;
-  typedef FixtureType                         fixture_type ;
-  typedef typename fixture_type::execution_space  execution_space;
-  //typedef typename execution_space::size_type     size_type ; // unused
-
-  typedef typename fixture_type::FEMeshType mesh_type ;
-  typedef typename fixture_type::coordinate_scalar_type coordinate_scalar_type ;
-
-  enum { ElementNodeCount = fixture_type::element_node_count };
-
-  const comm::Machine machine = mesh.parallel_data_map.machine ;
-
-  const size_t element_count = mesh.elem_node_ids.dimension_0();
-
-  //------------------------------------
-  // The amount of nonlinearity is proportional to the ratio
-  // between T(zmax) and T(zmin).  For the manufactured solution
-  // 0 < T(zmin) and 0 < T(zmax)
-
-  const ManufacturedSolution
-    exact_solution( /* zmin */ 0 ,
-                    /* zmax */ global_max_z ,
-                    /* T(zmin) */ 1 ,
-                    /* T(zmax) */ 20 );
-
-  //-----------------------------------
-  // Convergence Criteria and perf data:
-
-  const size_t cg_iteration_limit = 200 ;
-  const double cg_tolerance = 1e-14 ;
-
-  const size_t newton_iteration_limit = 150 ;
-  const double newton_tolerance = 1e-14 ;
-
-  size_t cg_iteration_count_total = 0 ;
-  double cg_iteration_time = 0 ;
-
-  size_t newton_iteration_count = 0 ;
-  double residual_norm_init = 0 ;
-  double residual_norm = 0 ;
-
-  PerformanceData perf_data ;
-
-  //------------------------------------
-  // Sparse linear system types:
-
-  typedef Kokkos::View< scalar_type* , execution_space >     vector_type ;
-  typedef Kokkos::CrsMatrix< scalar_type , execution_space >  matrix_type ;
-  typedef typename matrix_type::graph_type                matrix_graph_type ;
-  typedef typename matrix_type::coefficients_type         matrix_coefficients_type ;
-
-  typedef GraphFactory< matrix_graph_type , mesh_type > graph_factory ;
-
-  //------------------------------------
-  // Problem setup types:
-
-  typedef ElementComputation < mesh_type , scalar_type > ElementFunctor ;
-  typedef DirichletSolution  < mesh_type , scalar_type > DirichletSolutionFunctor ;
-  typedef DirichletResidual  < mesh_type , scalar_type > DirichletResidualFunctor ;
-
-  typedef typename ElementFunctor::elem_matrices_type elem_matrices_type ;
-  typedef typename ElementFunctor::elem_vectors_type  elem_vectors_type ;
-
-  typedef GatherFill< matrix_type ,
-                      mesh_type ,
-                      elem_matrices_type ,
-                      elem_vectors_type > GatherFillFunctor ;
-
-  //------------------------------------
-
-  matrix_type jacobian ;
-  vector_type residual ;
-  vector_type delta ;
-  vector_type nodal_solution ;
-
-  typename graph_factory::element_map_type element_map ;
-
-  //------------------------------------
-  // Generate mesh and corresponding sparse matrix graph
-
-  Kokkos::Timer wall_clock ;
-
-  //------------------------------------
-  // Generate sparse matrix graph and element->graph map.
-
-  wall_clock.reset();
-
-  graph_factory::create( mesh , jacobian.graph , element_map );
-
-  execution_space().fence();
-
-  perf_data.graph_time = comm::max( machine , wall_clock.seconds() );
-
-  //------------------------------------
-  // Allocate linear system coefficients and rhs:
-
-  const size_t local_owned_length = jacobian.graph.row_map.dimension_0() - 1 ;
-  const size_t local_total_length = mesh.node_coords.dimension_0();
-
-  jacobian.coefficients =
-    matrix_coefficients_type( "jacobian_coeff" , jacobian.graph.entries.dimension_0() );
-
-  // Nonlinear residual for owned nodes:
-  residual = vector_type( "residual" , local_owned_length );
-
-  // Nonlinear solution for owned and ghosted nodes:
-  nodal_solution = vector_type( "solution" , local_total_length );
-
-  // Nonlinear solution update for owned nodes:
-  delta = vector_type( "delta" , local_owned_length );
-
-  //------------------------------------
-  // Allocation of arrays to fill the linear system
-
-  elem_matrices_type elem_matrices ; // Jacobian matrices
-  elem_vectors_type  elem_vectors ;  // Residual vectors
-
-  if ( element_count ) {
-    elem_matrices = elem_matrices_type( std::string("elem_matrices"), element_count );
-    elem_vectors = elem_vectors_type( std::string("elem_vectors"), element_count );
-  }
-
-  //------------------------------------
-  // For boundary condition set the correct values in the solution vector
-  //   The 'zmin' face is assigned to 'T_zmin'.
-  //   The 'zmax' face is assigned to 'T_zmax'.
-  //   The resulting solution is one dimensional along the 'Z' axis.
-
-  DirichletSolutionFunctor::apply( nodal_solution , mesh ,
-                                   exact_solution.zmin ,
-                                   exact_solution.zmax ,
-                                   exact_solution.T_zmin ,
-                                   exact_solution.T_zmax );
-
-  for(;;) { // Nonlinear loop
-
-#if defined( KOKKOS_ENABLE_MPI )
-
-    { //------------------------------------
-      // Import off-processor nodal solution values
-      // for residual and jacobian computations
-
-      Kokkos::AsyncExchange< typename vector_type::value_type , execution_space ,
-                                  Kokkos::ParallelDataMap >
-        exchange( mesh.parallel_data_map , 1 );
-
-      Kokkos::PackArray< vector_type >
-        ::pack( exchange.buffer() ,
-                mesh.parallel_data_map.count_interior ,
-                mesh.parallel_data_map.count_send ,
-                nodal_solution );
-
-      exchange.setup();
-
-      exchange.send_receive();
-
-      Kokkos::UnpackArray< vector_type >
-        ::unpack( nodal_solution , exchange.buffer() ,
-                  mesh.parallel_data_map.count_owned ,
-                  mesh.parallel_data_map.count_receive );
-    }
-
-#endif
-
-    //------------------------------------
-    // Compute element matrices and vectors:
-
-    wall_clock.reset();
-
-    ElementFunctor( mesh ,
-                    elem_matrices ,
-                    elem_vectors ,
-                    nodal_solution ,
-                    exact_solution.K );
-
-    execution_space().fence();
-    perf_data.elem_time += comm::max( machine , wall_clock.seconds() );
-
-    //------------------------------------
-    // Fill linear system coefficients:
-
-    wall_clock.reset();
-
-    fill( jacobian.coefficients.dimension_0(), 0 , jacobian.coefficients );
-    fill( residual.dimension_0() , 0 , residual );
-
-    GatherFillFunctor::apply( jacobian ,
-                              residual ,
-                              mesh ,
-                              element_map ,
-                              elem_matrices ,
-                              elem_vectors );
-
-    execution_space().fence();
-    perf_data.matrix_gather_fill_time += comm::max( machine , wall_clock.seconds() );
-
-    // Apply boundary conditions:
-
-    wall_clock.reset();
-
-    // Updates jacobian matrix to 1 on the diagonal, zero elsewhere,
-    // and 0 in the residual due to the solution vector having the correct value
-    DirichletResidualFunctor::apply( jacobian, residual, mesh ,
-                                     exact_solution.zmin ,
-                                     exact_solution.zmax );
-
-    execution_space().fence();
-    perf_data.matrix_boundary_condition_time +=
-      comm::max( machine , wall_clock.seconds() );
-
-    //------------------------------------
-    // Has the residual converged?
-
-    residual_norm = norm2( mesh.parallel_data_map.count_owned,
-                           residual,
-                           mesh.parallel_data_map.machine );
-
-    if ( 0 == newton_iteration_count ) {
-      residual_norm_init = residual_norm ;
-    }
-
-    if ( residual_norm / residual_norm_init < newton_tolerance ) {
-      break ;
-    }
-
-    //------------------------------------
-    // Solve linear system
-
-    size_t cg_iteration_count = 0 ;
-    double cg_residual_norm = 0 ;
-
-    cgsolve( mesh.parallel_data_map ,
-             jacobian , residual , delta ,
-             cg_iteration_count ,
-             cg_residual_norm ,
-             cg_iteration_time ,
-             cg_iteration_limit , cg_tolerance ) ;
-
-    perf_data.cg_iteration_time += cg_iteration_time ;
-    cg_iteration_count_total += cg_iteration_count ;
-
-    // Update non-linear solution with delta...
-    // delta is : - Dx = [Jacobian]^1 * Residual which is the negative update
-    // LaTeX:
-    // \vec {x}_{n+1} = \vec {x}_{n} - ( - \Delta \vec{x}_{n} )
-    // text:
-    // x[n+1] = x[n] + Dx
-
-    axpy( mesh.parallel_data_map.count_owned ,
-          -1.0, delta, nodal_solution);
-
-    ++newton_iteration_count ;
-
-    if ( newton_iteration_limit < newton_iteration_count ) {
-      break ;
-    }
-  };
-
-  if ( newton_iteration_count ) {
-    perf_data.elem_time /= newton_iteration_count ;
-    perf_data.matrix_gather_fill_time /= newton_iteration_count ;
-    perf_data.matrix_boundary_condition_time /= newton_iteration_count ;
-  }
-
-  if ( cg_iteration_count_total ) {
-    perf_data.cg_iteration_time /= cg_iteration_count_total ;
-  }
-
-  perf_data.newton_iteration_count = newton_iteration_count ;
-  perf_data.cg_iteration_count = cg_iteration_count_total ;
-
-  //------------------------------------
-
-  {
-    // For extracting the nodal solution and its coordinates:
-
-    typename mesh_type::node_coords_type::HostMirror node_coords_host =
-      Kokkos::create_mirror( mesh.node_coords );
-
-    typename vector_type::HostMirror nodal_solution_host =
-      Kokkos::create_mirror( nodal_solution );
-
-    Kokkos::deep_copy( node_coords_host , mesh.node_coords );
-    Kokkos::deep_copy( nodal_solution_host , nodal_solution );
-
-    double tmp = 0 ;
-
-    for ( size_t i = 0 ; i < mesh.parallel_data_map.count_owned ; ++i ) {
-      const coordinate_scalar_type x = node_coords_host(i,0);
-      const coordinate_scalar_type y = node_coords_host(i,1);
-      const coordinate_scalar_type z = node_coords_host(i,2);
-
-      const double Tx = exact_solution(z);
-      const double Ts = nodal_solution_host(i);
-      const double Te = std::abs( Tx - Ts ) / std::abs( Tx );
-
-      tmp = std::max( tmp , Te );
-
-      if ( print_error && 0.02 < Te ) {
-        std::cout << "  node( " << x << " " << y << " " << z << " ) = "
-                  << Ts << " != exact_solution " << Tx
-                  << std::endl ;
-      }
-    }
-    perf_data.error_max = comm::max( machine , tmp );
-  }
-
-  return perf_data ;
-}
-
-//----------------------------------------------------------------------------
-
-template< typename Scalar , class Device , class FixtureElement >
-void driver( const char * const label ,
-             comm::Machine machine ,
-             const int gang_count ,
-             const int elem_count_beg ,
-             const int elem_count_end ,
-             const int runs )
-{
-  typedef Scalar          scalar_type ;
-  typedef Device          execution_space ;
-  typedef double          coordinate_scalar_type ;
-  typedef FixtureElement  fixture_element_type ;
-
-  typedef BoxMeshFixture< coordinate_scalar_type ,
-                          execution_space ,
-                          fixture_element_type > fixture_type ;
-
-  typedef typename fixture_type::FEMeshType mesh_type ;
-
-  const size_t proc_count = comm::size( machine );
-  const size_t proc_rank  = comm::rank( machine );
-
-  if ( elem_count_beg == 0 || elem_count_end == 0 || runs == 0 ) return ;
-
-  if ( comm::rank( machine ) == 0 ) {
-    std::cout << std::endl ;
-    std::cout << "\"Kokkos::HybridFE::Nonlinear " << label << "\"" << std::endl;
-    std::cout
-      << "\"Size\" ,  \"Size\" ,  \"Graphing\" , \"Element\" ,  \"Fill\" ,     \"Boundary\" , \"CG-Iter\" , \"CG-Iter\" ,      \"Newton-Iter\" , \"Max-node-error\""
-      << std::endl
-      << "\"elems\" , \"nodes\" , \"millisec\" , \"millisec\" , \"millisec\" , \"millisec\" , \"millisec\" , \"total-count\" , \"total-count\" , \"ratio\""
-      << std::endl ;
-  }
-
-  const bool print_sample = 0 ;
-  const double x_curve = 1.0 ;
-  const double y_curve = 1.0 ;
-  const double z_curve = 0.8 ;
-
-  for(int i = elem_count_beg ; i < elem_count_end ; i *= 2 )
-  {
-    const int ix = std::max( 1 , (int) cbrt( ((double) i) / 2.0 ) );
-    const int iy = 1 + ix ;
-    const int iz = 2 * iy ;
-    const int global_elem_count = ix * iy * iz ;
-    const int global_node_count = ( 2 * ix + 1 ) *
-                                  ( 2 * iy + 1 ) *
-                                  ( 2 * iz + 1 );
-
-    mesh_type mesh =
-      fixture_type::create( proc_count , proc_rank , gang_count ,
-                            ix , iy , iz ,
-                            x_curve , y_curve , z_curve );
-
-    mesh.parallel_data_map.machine = machine ;
-
-
-    PerformanceData perf_data , perf_best ;
-
-    for(int j = 0; j < runs; j++){
-
-      perf_data = run<scalar_type,fixture_type>(mesh,ix,iy,iz, print_sample );
-
-      if( j == 0 ) {
-        perf_best = perf_data ;
-      }
-      else {
-        perf_best.best( perf_data );
-      }
-    }
-
-    if ( comm::rank( machine ) == 0 ) {
-
-      std::cout << std::setw(8) << global_elem_count << " , "
-                << std::setw(8) << global_node_count << " , "
-                << std::setw(10) << perf_best.graph_time * 1000 << " , "
-                << std::setw(10) << perf_best.elem_time * 1000 << " , "
-                << std::setw(10) << perf_best.matrix_gather_fill_time * 1000 << " , "
-                << std::setw(10) << perf_best.matrix_boundary_condition_time * 1000 << " , "
-                << std::setw(10) << perf_best.cg_iteration_time * 1000 << " , "
-                << std::setw(7) << perf_best.cg_iteration_count << " , "
-                << std::setw(3) << perf_best.newton_iteration_count << " , "
-                << std::setw(10) << perf_best.error_max
-                << std::endl ;
-    }
-  }
-}
-
-//----------------------------------------------------------------------------
-
-} /* namespace Nonlinear */
-} /* namespace HybridFEM */
-
-
-#endif /* #ifndef HYBRIDFEM_IMPLICIT_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/NonlinearElement_Cuda.hpp b/lib/kokkos/example/multi_fem/NonlinearElement_Cuda.hpp
deleted file mode 100644
index 2f6e94520477f214851664a9114df14e59145c8a..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/NonlinearElement_Cuda.hpp
+++ /dev/null
@@ -1,390 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-
-#include <cstdio>
-
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <cstdlib>
-#include <cmath>
-
-#include <Kokkos_Core.hpp>
-#include <HexElement.hpp>
-#include <FEMesh.hpp>
-
-namespace HybridFEM {
-namespace Nonlinear {
-
-template< class MeshType , typename ScalarType > struct ElementComputation ;
-
-//----------------------------------------------------------------------------
-
-template<>
-struct ElementComputation< FEMesh< double , 27 , Kokkos::Cuda > , double >
-{
-  typedef Kokkos::Cuda    execution_space ;
-
-  static const unsigned ElementNodeCount = 27 ;
-
-  typedef HexElement_Data< ElementNodeCount >                element_data_type ;
-  typedef FEMesh< double , ElementNodeCount , execution_space >  mesh_type ;
-
-  static const unsigned SpatialDim       = element_data_type::spatial_dimension ;
-  static const unsigned FunctionCount    = element_data_type::function_count ;
-  static const unsigned IntegrationCount = element_data_type::integration_count ;
-  static const unsigned TensorDim        = SpatialDim * SpatialDim ;
-
-  typedef Kokkos::View< double[][FunctionCount][FunctionCount] , execution_space > elem_matrices_type ;
-  typedef Kokkos::View< double[][FunctionCount] , execution_space > elem_vectors_type ;
-  typedef Kokkos::View< double[] , execution_space > value_vector_type ;
-
-private:
-
-  const element_data_type                       elem_data ;
-  const typename mesh_type::elem_node_ids_type  elem_node_ids ;
-  const typename mesh_type::node_coords_type    node_coords ;
-  const value_vector_type                       nodal_values ;
-  const elem_matrices_type                      element_matrices ;
-  const elem_vectors_type                       element_vectors ;
-  const float                                   coeff_K ;
-  const unsigned                                elem_count ;
-        unsigned                                invJacIndex[9][4] ;
-
-  static const unsigned j11 = 0 , j12 = 1 , j13 = 2 ,
-                        j21 = 3 , j22 = 4 , j23 = 5 ,
-                        j31 = 6 , j32 = 7 , j33 = 8 ;
-
-  // Can only handle up to 16 warps:
-  static const unsigned BlockDimX = 32 ;
-  static const unsigned BlockDimY = 7 ;
-
-  struct WorkSpace {
-    double sum[ BlockDimY ][ BlockDimX ];
-
-    double  value_at_integ[ IntegrationCount ];
-    double  gradx_at_integ[ IntegrationCount ];
-    double  grady_at_integ[ IntegrationCount ];
-    double  gradz_at_integ[ IntegrationCount ];
-
-    float  spaceJac[    BlockDimY ][ 9 ];
-    float  spaceInvJac[ BlockDimY ][ 9 ];
-
-    float  detJweight[ IntegrationCount ];
-
-    float  dpsidx[ FunctionCount ][ IntegrationCount ];
-    float  dpsidy[ FunctionCount ][ IntegrationCount ];
-    float  dpsidz[ FunctionCount ][ IntegrationCount ];
-  };
-
-public:
-
-  ElementComputation ( const mesh_type          & arg_mesh ,
-                       const elem_matrices_type & arg_element_matrices ,
-                       const elem_vectors_type  & arg_element_vectors ,
-                       const value_vector_type  & arg_nodal_values ,
-                       const float                arg_coeff_K )
-  : elem_data()
-  , elem_node_ids(    arg_mesh.elem_node_ids )
-  , node_coords(      arg_mesh.node_coords )
-  , nodal_values(     arg_nodal_values )
-  , element_matrices( arg_element_matrices )
-  , element_vectors(  arg_element_vectors )
-  , coeff_K(          arg_coeff_K )
-  , elem_count(       arg_mesh.elem_node_ids.dimension_0() )
-  {
-    const unsigned jInvJ[9][4] =
-     { { j22 , j33 , j23 , j32 } ,
-       { j13 , j32 , j12 , j33 } ,
-       { j12 , j23 , j13 , j22 } ,
-
-       { j23 , j31 , j21 , j33 } ,
-       { j11 , j33 , j13 , j31 } ,
-       { j13 , j21 , j11 , j23 } ,
-
-       { j21 , j32 , j22 , j31 } ,
-       { j12 , j31 , j11 , j32 } ,
-       { j11 , j22 , j12 , j21 } };
-
-    for ( unsigned i = 0 ; i < 9 ; ++i ) {
-    for ( unsigned j = 0 ; j < 4 ; ++j ) {
-      invJacIndex[i][j] = jInvJ[i][j] ;
-    }
-    }
-
-    const unsigned shmem = sizeof(WorkSpace);
-    const unsigned grid_max = 65535 ;
-    const unsigned grid_count = std::min( grid_max , elem_count );
-
-    // For compute capability 2.x up to 1024 threads per block
-    const dim3 block( BlockDimX , BlockDimY , 1 );
-    const dim3 grid( grid_count , 1 , 1 );
-
-    Kokkos::Impl::CudaParallelLaunch< ElementComputation >( *this , grid , block , shmem );
-  }
-
-public:
-
-  //------------------------------------
-  // Sum among the threadIdx.x
-
-  template< typename Type >
-  __device__ inline static
-  void sum_x( Type & result , const double value )
-  {
-    extern __shared__ WorkSpace work_data[] ;
-
-    volatile double * const base_sum =
-      & work_data->sum[ threadIdx.y ][ threadIdx.x ] ;
-
-    base_sum[ 0] = value ;
-
-    if ( threadIdx.x < 16 ) {
-      base_sum[0] += base_sum[16];
-      base_sum[0] += base_sum[ 8];
-      base_sum[0] += base_sum[ 4];
-      base_sum[0] += base_sum[ 2];
-      base_sum[0] += base_sum[ 1];
-    }
-
-    if ( 0 == threadIdx.x ) {
-      result = base_sum[0] ;
-    }
-  }
-
-  __device__ inline static
-  void sum_x_clear()
-  {
-    extern __shared__ WorkSpace work_data[] ;
-
-    work_data->sum[ threadIdx.y ][ threadIdx.x ] = 0 ;
-  }
-
-  //------------------------------------
-  //------------------------------------
-
-  __device__ inline
-  void evaluateFunctions( const unsigned ielem ) const
-  {
-    extern __shared__ WorkSpace work_data[] ;
-
-    // Each warp (threadIdx.y) computes an integration point
-    // Each thread is responsible for a node / function.
-
-    const unsigned iFunc = threadIdx.x ;
-    const bool     hasFunc = iFunc < FunctionCount ;
-
-    //------------------------------------
-    // Each warp gathers a different variable into 'elem_mat' shared memory.
-
-    if ( hasFunc ) {
-
-      const unsigned node = elem_node_ids( ielem , iFunc );
-
-      for ( unsigned iy = threadIdx.y ; iy < 4 ; iy += blockDim.y ) {
-      switch( iy ) {
-      case 0 : work_data->sum[0][iFunc] = node_coords(node,0); break ;
-      case 1 : work_data->sum[1][iFunc] = node_coords(node,1); break ;
-      case 2 : work_data->sum[2][iFunc] = node_coords(node,2); break ;
-      case 3 : work_data->sum[3][iFunc] = nodal_values(node); break ;
-      default: break ;
-      }
-      }
-    }
-
-    __syncthreads(); // Wait for all warps to finish gathering
-
-    // now get local 'const' copies in register space:
-
-    const double x       = work_data->sum[0][ iFunc ];
-    const double y       = work_data->sum[1][ iFunc ];
-    const double z       = work_data->sum[2][ iFunc ];
-    const double dof_val = work_data->sum[3][ iFunc ];
-
-    __syncthreads(); // Wait for all warps to finish extracting
-
-    sum_x_clear(); // Make sure summation scratch is zero
-
-    //------------------------------------
-    // Each warp is now on its own computing an integration point
-    // so no further explicit synchronizations are required.
-
-    if ( hasFunc ) {
-
-      float * const J    = work_data->spaceJac[    threadIdx.y ];
-      float * const invJ = work_data->spaceInvJac[ threadIdx.y ];
-
-      for ( unsigned iInt = threadIdx.y ;
-                     iInt < IntegrationCount ; iInt += blockDim.y ) {
-
-        const float val = elem_data.values[iInt][iFunc] ;
-        const float gx  = elem_data.gradients[iInt][0][iFunc] ;
-        const float gy  = elem_data.gradients[iInt][1][iFunc] ;
-        const float gz  = elem_data.gradients[iInt][2][iFunc] ;
-
-        sum_x( J[j11], gx * x );
-        sum_x( J[j12], gx * y );
-        sum_x( J[j13], gx * z );
-
-        sum_x( J[j21], gy * x );
-        sum_x( J[j22], gy * y );
-        sum_x( J[j23], gy * z );
-
-        sum_x( J[j31], gz * x );
-        sum_x( J[j32], gz * y );
-        sum_x( J[j33], gz * z );
-
-        // Inverse jacobian, only enough parallel work for 9 threads in the warp
-
-        if ( iFunc < TensorDim ) {
-
-          invJ[ iFunc ] =
-            J[ invJacIndex[iFunc][0] ] * J[ invJacIndex[iFunc][1] ] -
-            J[ invJacIndex[iFunc][2] ] * J[ invJacIndex[iFunc][3] ] ;
-
-          // Let all threads in the warp compute determinant into a register
-
-          const float detJ = J[j11] * invJ[j11] +
-                             J[j21] * invJ[j12] +
-                             J[j31] * invJ[j13] ;
-
-          invJ[ iFunc ] /= detJ ;
-
-          if ( 0 == iFunc ) {
-            work_data->detJweight[ iInt ] = detJ * elem_data.weights[ iInt ] ;
-          }
-        }
-
-        // Transform bases gradients and compute value and gradient
-
-        const float dx = gx * invJ[j11] + gy * invJ[j12] + gz * invJ[j13];
-        const float dy = gx * invJ[j21] + gy * invJ[j22] + gz * invJ[j23];
-        const float dz = gx * invJ[j31] + gy * invJ[j32] + gz * invJ[j33];
-
-        work_data->dpsidx[iFunc][iInt] = dx ;
-        work_data->dpsidy[iFunc][iInt] = dy ;
-        work_data->dpsidz[iFunc][iInt] = dz ;
-
-        sum_x( work_data->gradx_at_integ[iInt] , dof_val * dx );
-        sum_x( work_data->grady_at_integ[iInt] , dof_val * dy );
-        sum_x( work_data->gradz_at_integ[iInt] , dof_val * dz );
-        sum_x( work_data->value_at_integ[iInt] , dof_val * val );
-      }
-    }
-
-    __syncthreads(); // All shared data must be populated at return.
-  }
-
-  __device__ inline
-  void contributeResidualJacobian( const unsigned ielem ) const
-  {
-    extern __shared__ WorkSpace work_data[] ;
-
-    sum_x_clear(); // Make sure summation scratch is zero
-
-    // $$ R_i = \int_{\Omega} \nabla \phi_i \cdot (k \nabla T) + \phi_i T^2 d \Omega $$
-    // $$ J_{i,j} = \frac{\partial R_i}{\partial T_j} = \int_{\Omega} k \nabla \phi_i \cdot \nabla \phi_j + 2 \phi_i \phi_j T d \Omega $$
-
-    const unsigned iInt = threadIdx.x ;
-
-    if ( iInt < IntegrationCount ) {
-
-      const double value_at_integ = work_data->value_at_integ[ iInt ] ;
-      const double gradx_at_integ = work_data->gradx_at_integ[ iInt ] ;
-      const double grady_at_integ = work_data->grady_at_integ[ iInt ] ;
-      const double gradz_at_integ = work_data->gradz_at_integ[ iInt ] ;
-
-      const float detJweight     = work_data->detJweight[ iInt ] ;
-      const float coeff_K_detJweight = coeff_K * detJweight ;
-
-      for ( unsigned iRow = threadIdx.y ;
-                     iRow < FunctionCount ; iRow += blockDim.y ) {
-
-        const float value_row  = elem_data.values[ iInt ][ iRow ] * detJweight ;
-        const float dpsidx_row = work_data->dpsidx[ iRow ][ iInt ] * coeff_K_detJweight ;
-        const float dpsidy_row = work_data->dpsidy[ iRow ][ iInt ] * coeff_K_detJweight ;
-        const float dpsidz_row = work_data->dpsidz[ iRow ][ iInt ] * coeff_K_detJweight ;
-
-        const double res_del = dpsidx_row * gradx_at_integ +
-                               dpsidy_row * grady_at_integ +
-                               dpsidz_row * gradz_at_integ ;
-
-        const double res_val = value_at_integ * value_at_integ * value_row ;
-        const double jac_val_row = 2 * value_at_integ * value_row ;
-
-        sum_x( element_vectors( ielem , iRow ) , res_del + res_val );
-
-        for ( unsigned iCol = 0 ; iCol < FunctionCount ; ++iCol ) {
-
-          const float jac_del =
-            dpsidx_row * work_data->dpsidx[iCol][iInt] +
-            dpsidy_row * work_data->dpsidy[iCol][iInt] +
-            dpsidz_row * work_data->dpsidz[iCol][iInt] ;
-
-          const double jac_val =
-            jac_val_row * elem_data.values[ iInt ][ iCol ] ;
-
-          sum_x( element_matrices( ielem , iRow , iCol ) , jac_del + jac_val );
-        }
-      }
-    }
-
-    __syncthreads(); // All warps finish before refilling shared data
-  }
-
-  __device__ inline
-  void operator()(void) const
-  {
-    extern __shared__ WorkSpace work_data[] ;
-
-    for ( unsigned ielem = blockIdx.x ; ielem < elem_count ; ielem += gridDim.x ) {
-
-      evaluateFunctions( ielem );
-
-      contributeResidualJacobian( ielem );
-    }
-  }
-
-}; /* ElementComputation */
-
-} /* namespace Nonlinear */
-} /* namespace HybridFEM */
-
diff --git a/lib/kokkos/example/multi_fem/NonlinearFunctors.hpp b/lib/kokkos/example/multi_fem/NonlinearFunctors.hpp
deleted file mode 100644
index ef831a569878ae494590f09d59547c88083398b8..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/NonlinearFunctors.hpp
+++ /dev/null
@@ -1,482 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_NONLINEARFUNCTORS_HPP
-#define KOKKOS_NONLINEARFUNCTORS_HPP
-
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <cstdlib>
-#include <cmath>
-
-namespace HybridFEM {
-namespace Nonlinear {
-
-template< class MeshType , typename ScalarType > struct ElementComputation ;
-template< class MeshType , typename ScalarType > struct DirichletSolution ;
-template< class MeshType , typename ScalarType > struct DirichletResidual ;
-
-}
-}
-
-/* A Cuda-specific specialization for the element computation functor. */
-#if defined( __CUDACC__ )
-#include <NonlinearElement_Cuda.hpp>
-#endif
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace HybridFEM {
-namespace Nonlinear {
-
-template< typename ScalarCoordType , unsigned ElemNode , class DeviceType ,
-          typename ScalarType >
-struct ElementComputation<
-  FEMesh< ScalarCoordType , ElemNode , DeviceType > , ScalarType >
-{
-  typedef DeviceType  execution_space;
-  typedef ScalarType           scalar_type ;
-
-  static const unsigned ElementNodeCount = ElemNode ;
-
-  typedef FEMesh< ScalarCoordType , ElementNodeCount , execution_space > mesh_type ;
-
-  typedef HexElement_Data< ElementNodeCount > element_data_type ;
-
-  static const unsigned SpatialDim       = element_data_type::spatial_dimension ;
-  static const unsigned FunctionCount    = element_data_type::function_count ;
-  static const unsigned IntegrationCount = element_data_type::integration_count ;
-  static const unsigned TensorDim        = SpatialDim * SpatialDim ;
-
-  typedef Kokkos::View< scalar_type[][FunctionCount][FunctionCount] , execution_space > elem_matrices_type ;
-  typedef Kokkos::View< scalar_type[][FunctionCount] , execution_space > elem_vectors_type ;
-  typedef Kokkos::View< scalar_type[] , execution_space > value_vector_type ;
-
-
-private:
-
-  const element_data_type                 elem_data ;
-  typename mesh_type::elem_node_ids_type  elem_node_ids ;
-  typename mesh_type::node_coords_type    node_coords ;
-  value_vector_type                       nodal_values ;
-  elem_matrices_type                      element_matrices ;
-  elem_vectors_type                       element_vectors ;
-  scalar_type                             coeff_K ;
-
-public:
-
-  ElementComputation( const mesh_type   & arg_mesh ,
-                      const elem_matrices_type  & arg_element_matrices ,
-                      const elem_vectors_type   & arg_element_vectors ,
-                      const value_vector_type   & arg_nodal_values ,
-	              const scalar_type   arg_coeff_K )
-  : elem_data()
-  , elem_node_ids( arg_mesh.elem_node_ids )
-  , node_coords(   arg_mesh.node_coords )
-  , nodal_values(   arg_nodal_values )
-  , element_matrices( arg_element_matrices )
-  , element_vectors( arg_element_vectors )
-  , coeff_K( arg_coeff_K )
-  {
-    const size_t elem_count = arg_mesh.elem_node_ids.dimension_0();
-
-    parallel_for( elem_count , *this );
-  }
-
-  //------------------------------------
-
-  static const unsigned FLOPS_transform_gradients =
-     /* Jacobian */           FunctionCount * TensorDim * 2 +
-     /* Inverse jacobian */   TensorDim * 6 + 6 +
-     /* Gradient transform */ FunctionCount * 15 ;
-
-  KOKKOS_INLINE_FUNCTION
-  float transform_gradients(
-    const float grad[][ FunctionCount ] , // Gradient of bases master element
-    const double x[] ,
-    const double y[] ,
-    const double z[] ,
-    float dpsidx[] ,
-    float dpsidy[] ,
-    float dpsidz[] ) const
-  {
-    enum { j11 = 0 , j12 = 1 , j13 = 2 ,
-           j21 = 3 , j22 = 4 , j23 = 5 ,
-           j31 = 6 , j32 = 7 , j33 = 8 };
-
-    // Jacobian accumulation:
-
-    double J[ TensorDim ] = { 0, 0, 0,  0, 0, 0,  0, 0, 0 };
-
-    for( unsigned i = 0; i < FunctionCount ; ++i ) {
-      const double x1 = x[i] ;
-      const double x2 = y[i] ;
-      const double x3 = z[i] ;
-
-      const float g1 = grad[0][i] ;
-      const float g2 = grad[1][i] ;
-      const float g3 = grad[2][i] ;
-
-      J[j11] += g1 * x1 ;
-      J[j12] += g1 * x2 ;
-      J[j13] += g1 * x3 ;
-
-      J[j21] += g2 * x1 ;
-      J[j22] += g2 * x2 ;
-      J[j23] += g2 * x3 ;
-
-      J[j31] += g3 * x1 ;
-      J[j32] += g3 * x2 ;
-      J[j33] += g3 * x3 ;
-    }
-
-    // Inverse jacobian:
-
-    float invJ[ TensorDim ] = {
-      static_cast<float>( J[j22] * J[j33] - J[j23] * J[j32] ) ,
-      static_cast<float>( J[j13] * J[j32] - J[j12] * J[j33] ) ,
-      static_cast<float>( J[j12] * J[j23] - J[j13] * J[j22] ) ,
-
-      static_cast<float>( J[j23] * J[j31] - J[j21] * J[j33] ) ,
-      static_cast<float>( J[j11] * J[j33] - J[j13] * J[j31] ) ,
-      static_cast<float>( J[j13] * J[j21] - J[j11] * J[j23] ) ,
-
-      static_cast<float>( J[j21] * J[j32] - J[j22] * J[j31] ) ,
-      static_cast<float>( J[j12] * J[j31] - J[j11] * J[j32] ) ,
-      static_cast<float>( J[j11] * J[j22] - J[j12] * J[j21] ) };
-
-    const float detJ = J[j11] * invJ[j11] +
-                       J[j21] * invJ[j12] +
-                       J[j31] * invJ[j13] ;
-
-    const float detJinv = 1.0 / detJ ;
-
-    for ( unsigned i = 0 ; i < TensorDim ; ++i ) { invJ[i] *= detJinv ; }
-
-    // Transform gradients:
-
-    for( unsigned i = 0; i < FunctionCount ; ++i ) {
-      const float g0 = grad[0][i];
-      const float g1 = grad[1][i];
-      const float g2 = grad[2][i];
-
-      dpsidx[i] = g0 * invJ[j11] + g1 * invJ[j12] + g2 * invJ[j13];
-      dpsidy[i] = g0 * invJ[j21] + g1 * invJ[j22] + g2 * invJ[j23];
-      dpsidz[i] = g0 * invJ[j31] + g1 * invJ[j32] + g2 * invJ[j33];
-    }
-
-    return detJ ;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void contributeResidualJacobian(
-    const float coeff_k ,
-    const double dof_values[] ,
-    const float dpsidx[] ,
-    const float dpsidy[] ,
-    const float dpsidz[] ,
-    const float detJ ,
-    const float integ_weight ,
-    const float bases_vals[] ,
-    double elem_res[] ,
-    double elem_mat[][ FunctionCount ] ) const
-  {
-    double value_at_pt = 0 ;
-    double gradx_at_pt = 0 ;
-    double grady_at_pt = 0 ;
-    double gradz_at_pt = 0 ;
-
-    for ( unsigned m = 0 ; m < FunctionCount ; m++ ) {
-      value_at_pt += dof_values[m] * bases_vals[m] ;
-      gradx_at_pt += dof_values[m] * dpsidx[m] ;
-      grady_at_pt += dof_values[m] * dpsidy[m] ;
-      gradz_at_pt += dof_values[m] * dpsidz[m] ;
-    }
-
-    const scalar_type k_detJ_weight = coeff_k        * detJ * integ_weight ;
-    const double res_val = value_at_pt * value_at_pt * detJ * integ_weight ;
-    const double mat_val = 2.0 * value_at_pt         * detJ * integ_weight ;
-
-    // $$ R_i = \int_{\Omega} \nabla \phi_i \cdot (k \nabla T) + \phi_i T^2 d \Omega $$
-    // $$ J_{i,j} = \frac{\partial R_i}{\partial T_j} = \int_{\Omega} k \nabla \phi_i \cdot \nabla \phi_j + 2 \phi_i \phi_j T d \Omega $$
-
-    for ( unsigned m = 0; m < FunctionCount; m++) {
-      double * const mat = elem_mat[m] ;
-      const float bases_val_m = bases_vals[m];
-      const float dpsidx_m    = dpsidx[m] ;
-      const float dpsidy_m    = dpsidy[m] ;
-      const float dpsidz_m    = dpsidz[m] ;
-
-      elem_res[m] += k_detJ_weight * ( dpsidx_m * gradx_at_pt +
-                                       dpsidy_m * grady_at_pt +
-                                       dpsidz_m * gradz_at_pt ) +
-                     res_val * bases_val_m ;
-
-      for( unsigned n = 0; n < FunctionCount; n++) {
-
-        mat[n] += k_detJ_weight * ( dpsidx_m * dpsidx[n] +
-                                    dpsidy_m * dpsidy[n] +
-                                    dpsidz_m * dpsidz[n] ) +
-                  mat_val * bases_val_m * bases_vals[n];
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned ielem ) const
-  {
-    // Gather nodal coordinates and solution vector:
-
-    double x[ FunctionCount ] ;
-    double y[ FunctionCount ] ;
-    double z[ FunctionCount ] ;
-    double val[ FunctionCount ] ;
-
-    for ( unsigned i = 0 ; i < ElementNodeCount ; ++i ) {
-      const unsigned node_index = elem_node_ids( ielem , i );
-
-      x[i] = node_coords( node_index , 0 );
-      y[i] = node_coords( node_index , 1 );
-      z[i] = node_coords( node_index , 2 );
-
-      val[i] = nodal_values( node_index );
-    }
-
-    double elem_vec[ FunctionCount ] ;
-    double elem_mat[ FunctionCount ][ FunctionCount ] ;
-
-    for( unsigned i = 0; i < FunctionCount ; i++ ) {
-      elem_vec[i] = 0 ;
-      for( unsigned j = 0; j < FunctionCount ; j++){
-        elem_mat[i][j] = 0 ;
-      }
-    }
-
-    for ( unsigned i = 0 ; i < IntegrationCount ; ++i ) {
-      float dpsidx[ FunctionCount ] ;
-      float dpsidy[ FunctionCount ] ;
-      float dpsidz[ FunctionCount ] ;
-
-      const float detJ =
-        transform_gradients( elem_data.gradients[i] , x , y , z ,
-                             dpsidx , dpsidy , dpsidz );
-
-      contributeResidualJacobian( coeff_K ,
-                                  val , dpsidx , dpsidy , dpsidz ,
-                                  detJ ,
-                                  elem_data.weights[i] ,
-                                  elem_data.values[i] ,
-                                  elem_vec , elem_mat );
-    }
-
-    for( unsigned i = 0; i < FunctionCount ; i++){
-      element_vectors(ielem, i) = elem_vec[i] ;
-      for( unsigned j = 0; j < FunctionCount ; j++){
-        element_matrices(ielem, i, j) = elem_mat[i][j] ;
-      }
-    }
-  }
-
-}; /* ElementComputation */
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarCoordType , unsigned ElemNode , class DeviceType ,
-          typename ScalarType >
-struct DirichletSolution<
-  FEMesh< ScalarCoordType , ElemNode , DeviceType > ,
-  ScalarType >
-{
-  typedef DeviceType  execution_space;
-
-  static const unsigned ElementNodeCount = ElemNode ;
-
-  typedef Kokkos::View< ScalarType[] , execution_space >  vector_type ;
-
-  typedef FEMesh< ScalarCoordType , ElementNodeCount , execution_space > mesh_type ;
-
-  typename mesh_type::node_coords_type node_coords ;
-
-  vector_type     solution ;
-  ScalarCoordType bc_lower_z ;
-  ScalarCoordType bc_upper_z ;
-  ScalarType      bc_lower_value ;
-  ScalarType      bc_upper_value ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned inode ) const
-  {
-
-  // Apply dirichlet boundary condition on the Solution vector.
-  // Define boundary node values to be either bc_lower_value or
-  // bc_upper_value, depending on which boundary face they lie on.
-  // Non-boundary terms will be left at their previous value.
-
-    const ScalarCoordType z = node_coords(inode,2);
-    const bool bc_lower = z <= bc_lower_z ;
-    const bool bc_upper = bc_upper_z <= z ;
-
-    if ( bc_lower || bc_upper ) {
-      const ScalarType bc_value = bc_lower ? bc_lower_value
-                                           : bc_upper_value ;
-
-      solution(inode) = bc_value ; //  set the solution vector
-    }
-  }
-
-  static void apply( const vector_type    & solution ,
-                     const mesh_type      & mesh ,
-                     const ScalarCoordType  bc_lower_z ,
-                     const ScalarCoordType  bc_upper_z ,
-                     const ScalarType       bc_lower_value ,
-                     const ScalarType       bc_upper_value )
-  {
-    DirichletSolution op ;
-    op.node_coords    = mesh.node_coords ;
-    op.solution       = solution ;
-    op.bc_lower_z     = bc_lower_z ;
-    op.bc_upper_z     = bc_upper_z ;
-    op.bc_lower_value = bc_lower_value ;
-    op.bc_upper_value = bc_upper_value ;
-    parallel_for( solution.dimension_0() , op );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< typename ScalarCoordType , unsigned ElemNode , class DeviceType ,
-          typename ScalarType >
-struct DirichletResidual<
-  FEMesh< ScalarCoordType , ElemNode , DeviceType > , ScalarType >
-{
-  typedef DeviceType     execution_space;
-  typedef typename execution_space::size_type  size_type ;
-
-  static const unsigned ElementNodeCount = ElemNode ;
-
-  typedef Kokkos::CrsMatrix< ScalarType , execution_space >    matrix_type ;
-  typedef Kokkos::View< ScalarType[] , execution_space >  vector_type ;
-
-  typedef FEMesh< ScalarCoordType , ElementNodeCount , execution_space > mesh_type ;
-
-  typename mesh_type::node_coords_type node_coords ;
-  matrix_type     matrix ;
-  vector_type     rhs ;
-  ScalarCoordType bc_lower_z ;
-  ScalarCoordType bc_upper_z ;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const unsigned inode ) const
-  {
-    //  Apply a dirichlet boundary condition to 'irow'
-    //  to maintain the symmetry of the original
-    //  global stiffness matrix, zero out the columns
-    //  that correspond to boundary conditions, and
-    //  adjust the load vector accordingly
-
-    const size_type iBeg = matrix.graph.row_map[inode];
-    const size_type iEnd = matrix.graph.row_map[inode+1];
-
-    const ScalarCoordType z = node_coords(inode,2);
-    const bool bc_lower = z <= bc_lower_z ;
-    const bool bc_upper = bc_upper_z <= z ;
-
-    if ( bc_lower || bc_upper ) {
-      rhs(inode) = 0 ; //  set the residual vector
-
-      //  zero each value on the row, and leave a one
-      //  on the diagonal
-
-      for( size_type i = iBeg ; i < iEnd ; i++) {
-        matrix.coefficients(i) =
-          (int) inode == matrix.graph.entries(i) ? 1 : 0 ;
-      }
-    }
-    else {
-
-      //  Find any columns that are boundary conditions.
-      //  Clear them and adjust the load vector
-
-      for( size_type i = iBeg ; i < iEnd ; i++ ) {
-        const size_type cnode = matrix.graph.entries(i) ;
-
-        const ScalarCoordType zc = node_coords(cnode,2);
-        const bool c_bc_lower = zc <= bc_lower_z ;
-        const bool c_bc_upper = bc_upper_z <= zc ;
-
-        if ( c_bc_lower || c_bc_upper ) {
-
-	   matrix.coefficients(i) = 0 ;
-        }
-      }
-    }
-  }
-
-
-  static void apply( const matrix_type & linsys_matrix ,
-                     const vector_type & linsys_rhs ,
-                     const mesh_type   & mesh ,
-                     const ScalarCoordType  bc_lower_z ,
-                     const ScalarCoordType  bc_upper_z)
-  {
-    const size_t row_count = linsys_matrix.graph.row_map.dimension_0() - 1 ;
-
-    DirichletResidual op ;
-    op.node_coords    = mesh.node_coords ;
-    op.matrix         = linsys_matrix ;
-    op.rhs            = linsys_rhs ;
-    op.bc_lower_z     = bc_lower_z ;
-    op.bc_upper_z     = bc_upper_z ;
-    parallel_for( row_count , op );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-} /* namespace Nonlinear */
-} /* namespace HybridFEM */
-
-#endif /* #ifndef KOKKOS_NONLINEARFUNCTORS_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/ParallelComm.hpp b/lib/kokkos/example/multi_fem/ParallelComm.hpp
deleted file mode 100644
index 37fa6243c92cbf3adee6920d065b42cd9d2cfc89..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/ParallelComm.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef PARALLELCOMM_HPP
-#define PARALLELCOMM_HPP
-
-//------------------------------------------------------------------------
-
-#include <Kokkos_Macros.hpp>
-
-//------------------------------------------------------------------------
-
-#if defined( KOKKOS_ENABLE_MPI )
-
-#include <mpi.h>
-#include <string>
-
-namespace comm {
-
-struct Machine {
-  MPI_Comm mpi_comm ;
-
-  Machine() : mpi_comm( MPI_COMM_NULL ) {}
-
-  Machine( const Machine & rhs )
-    : mpi_comm( rhs.mpi_comm ) {}
-
-  Machine( MPI_Comm c ) : mpi_comm( c ) {}
-
-  static Machine init( int * argc , char *** argv )
-  {
-    MPI_Init( argc , argv );
-    return Machine( MPI_COMM_WORLD );
-  }
-
-  static void finalize() { MPI_Finalize(); }
-};
-
-inline
-unsigned  size( Machine machine )
-{
-  int np ; MPI_Comm_size( machine.mpi_comm , & np ); return np ;
-}
-
-inline
-unsigned  rank( Machine machine )
-{
-  int ip ; MPI_Comm_rank( machine.mpi_comm , & ip ); return ip ;
-}
-
-inline
-double max( Machine machine , double local )
-{
-  double global = 0;
-  MPI_Allreduce( & local , & global , 1 , MPI_DOUBLE , MPI_MAX , machine.mpi_comm );
-  return global ;
-}
-
-inline
-std::string command_line( Machine machine , const int argc , const char * const * const argv )
-{
-  std::string argline ;
-
-  if ( 0 == rank( machine ) ) {
-    for ( int i = 1 ; i < argc ; ++i ) {
-      argline.append(" ").append( argv[i] );
-    }
-  }
-
-  int length = argline.length();
-  MPI_Bcast( & length , 1 , MPI_INT , 0 , machine.mpi_comm );
-  argline.resize( length , ' ' );
-  MPI_Bcast( (void*) argline.data() , length , MPI_CHAR , 0 , machine.mpi_comm );
-
-  return argline ;
-}
-
-}
-
-#else /* ! defined( KOKKOS_ENABLE_MPI ) */
-
-#include <string>
-
-namespace comm {
-
-// Stub for non-parallel
-
-struct Machine {
-  static Machine init( int * , char *** )
-  { return Machine(); }
-
-  static void finalize() {}
-};
-
-inline
-unsigned  size( Machine ) { return 1 ; }
-
-inline
-unsigned  rank( Machine ) { return 0 ; }
-
-inline
-double max( Machine , double local )
-{ return local ; }
-
-inline
-std::string command_line( Machine machine , const int argc , const char * const * const argv )
-{
-  std::string argline ;
-
-  if ( 0 == rank( machine ) ) {
-    for ( int i = 1 ; i < argc ; ++i ) {
-      argline.append(" ").append( argv[i] );
-    }
-  }
-
-  return argline ;
-}
-
-}
-
-#endif /* ! defined( KOKKOS_ENABLE_MPI ) */
-
-//------------------------------------------------------------------------
-
-#endif /* #ifndef PARALLELCOMM_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/ParallelDataMap.hpp b/lib/kokkos/example/multi_fem/ParallelDataMap.hpp
deleted file mode 100644
index 12d7add5a55b7e095827033a03730df376ae9bac..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/ParallelDataMap.hpp
+++ /dev/null
@@ -1,517 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef KOKKOS_PARALLELDATAMAP_HPP
-#define KOKKOS_PARALLELDATAMAP_HPP
-
-#include <utility>
-#include <limits>
-#include <iostream>
-#include <sstream>
-#include <stdexcept>
-
-#include <Kokkos_Core.hpp>
-#include <ParallelComm.hpp>
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-/** \brief  Parallel distributed data mapping
- *
- *  ordering { interior : { owned items not sent elsewhere }
- *             send     : { owned items sent }
- *             receive  : { not-owned items received } }
- *
- *  recv { { N ghosted items from process P : ( P , N ) } }
- *
- *  send { { N send items to process P : ( P , N ) } }
- *
- *  send_item { send item offsets within 'send' range }
- */
-struct ParallelDataMap {
-  typedef View< unsigned*[2], HostSpace >  host_recv_type ;
-  typedef View< unsigned*[2], HostSpace >  host_send_type ;
-  typedef View< unsigned* ,   HostSpace >  host_send_item_type ;
-
-  comm::Machine        machine ;
-  host_recv_type       host_recv ;
-  host_send_type       host_send ;
-  host_send_item_type  host_send_item ;
-  unsigned             count_interior ;
-  unsigned             count_send ;
-  unsigned             count_owned ; // = count_interior + count_send
-  unsigned             count_receive ;
-
-  void assign( const unsigned arg_count_interior ,
-               const unsigned arg_count_owned ,
-               const unsigned arg_count_total ,
-               const unsigned arg_recv_msg ,
-               const unsigned arg_send_msg ,
-               const unsigned arg_send_count )
-  {
-    const std::string label("Kokkos::ParallelDataMap buffer");
-
-    count_interior = arg_count_interior ;
-    count_owned    = arg_count_owned ;
-    count_send     = arg_count_owned - arg_count_interior ;
-    count_receive  = arg_count_total - arg_count_owned ;
-
-    host_recv = host_recv_type( label , arg_recv_msg );
-    host_send = host_send_type( label , arg_send_msg );
-    host_send_item = host_send_item_type( label , arg_send_count );
-  }
-};
-
-//----------------------------------------------------------------------------
-//PackArray
-//----------------------------------------------------------------------------
-template< class ArrayType , class Rank = void >
-struct PackArray ;
-
-template< typename DeviceType, typename ValueType >
-struct PackArray< View< ValueType* , DeviceType > , void >
-{
-  typedef DeviceType                         execution_space ;
-  typedef typename DeviceType::size_type     size_type ;
-  typedef View< ValueType* , execution_space >  array_type ;
-  typedef View< ValueType* , execution_space >  buffer_type ;
-
-private:
-
-  buffer_type  output ;
-  array_type   input ;
-  size_type    base ;
-
-public:
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type i ) const
-  { output[i] = input(base+i); }
-
-  inline
-  static
-  void pack( const buffer_type & arg_output ,
-             const size_type     arg_begin ,
-             const size_type     arg_count ,
-             const array_type  & arg_input )
-  {
-    PackArray op ;
-    op.output = arg_output ;
-    op.input  = arg_input ;
-    op.base   = arg_begin ;
-    parallel_for( arg_count , op );
-  }
-};
-
-template< typename DeviceType, typename ValueType , unsigned N1 >
-struct PackArray< View< ValueType*[N1] , DeviceType > , void >
-{
-  typedef DeviceType                                  execution_space ;
-  typedef typename DeviceType::size_type              size_type ;
-  typedef View< ValueType*[N1] , execution_space >       array_type ;
-  typedef View< ValueType* , execution_space >           buffer_type ;
-
-private:
-
-  buffer_type  output ;
-  array_type   input ;
-  size_type    base ;
-
-public:
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type i ) const
-  {
-    for ( size_type j = 0 , k = i * N1 ; j < N1 ; ++j , ++k ) {
-      output[k] = input(base+i,j);
-    }
-  }
-
-  inline static
-  void pack( const buffer_type & arg_output ,
-             const size_type     arg_begin ,
-             const size_type     arg_count ,
-             const array_type  & arg_input )
-  {
-    if ( arg_count ) {
-      PackArray op ;
-      op.output = arg_output ;
-      op.input  = arg_input ;
-      op.base   = arg_begin ;
-      parallel_for( arg_count , op );
-    }
-  }
-};
-
-//----------------------------------------------------------------------------
-//UnpackArray
-//----------------------------------------------------------------------------
-template< class ArrayType , class Rank = void > struct UnpackArray ;
-
-template< typename DeviceType, typename ValueType >
-struct UnpackArray< View< ValueType* , DeviceType > , void >
-{
-  typedef DeviceType                         execution_space ;
-  typedef typename DeviceType::size_type     size_type ;
-  typedef View< ValueType* , execution_space >  array_type ;
-  typedef View< ValueType* , execution_space >  buffer_type ;
-
-private:
-
-  array_type   output ;
-  buffer_type  input ;
-  size_type    base ;
-
-public:
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type i ) const
-  { output(base+i) = input[i]; }
-
-  inline
-  static
-  void unpack( const array_type  & arg_output ,
-               const buffer_type & arg_input ,
-               const size_type     arg_begin ,
-               const size_type     arg_count )
-  {
-    UnpackArray op ;
-    op.output = arg_output ;
-    op.input  = arg_input ;
-    op.base   = arg_begin ;
-    parallel_for( arg_count , op );
-  }
-};
-
-template< typename DeviceType, typename ValueType , unsigned N1 >
-struct UnpackArray< View< ValueType*[N1] , DeviceType > , void >
-{
-  typedef DeviceType                                  execution_space ;
-  typedef typename DeviceType::size_type              size_type ;
-  typedef View< ValueType* , execution_space >           buffer_type ;
-  typedef View< ValueType*[N1] , execution_space >       array_type ;
-
-private:
-
-  array_type   output ;
-  buffer_type  input ;
-  size_type    base ;
-
-public:
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type i ) const
-  {
-    for ( size_type j = 0 , k = i * N1 ; j < N1 ; ++j , ++k ) {
-      output(base+i,j) = input(k);
-    }
-  }
-
-  inline
-  static
-  void unpack( const array_type  & arg_output ,
-               const buffer_type & arg_input ,
-               const size_type     arg_begin ,
-               const size_type     arg_count )
-  {
-    if ( arg_count ) {
-      UnpackArray op ;
-      op.output = arg_output ;
-      op.input  = arg_input ;
-      op.base   = arg_begin ;
-      parallel_for( arg_count , op );
-    }
-  }
-};
-//----------------------------------------------------------------------------
-template< class ValueType , class Device , class DataMap >
-class AsyncExchange ;
-
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-// Application call procedure:
-//
-// construct: AsyncExchange object
-// * pack send buffer on device
-// initiate: copy send buffer from device to host
-// * dispatch asynchronous local work
-// complete: send/receive on host, copy receive buffer to device
-// * unpack receive buffer on device
-// destroy: AsyncExchange object
-//
-//----------------------------------------------------------------------------
-
-#ifdef KOKKOS_ENABLE_MPI
-
-namespace Kokkos {
-
-template< class ValueType , class Device >
-class AsyncExchange< ValueType, Device , Kokkos::ParallelDataMap > {
-public:
-
-  typedef Device                                    execution_space ;
-  typedef Kokkos::ParallelDataMap                   data_map_type ;
-  typedef Kokkos::View< ValueType* , execution_space >  buffer_dev_type ;
-  typedef typename buffer_dev_type::HostMirror      buffer_host_type ;
-
-private:
-
-  static const int mpi_tag = 11 ;
-
-  const data_map_type  data_map ;
-  unsigned             chunk_size ;
-  unsigned             send_count_max ;
-  buffer_host_type     host_recv_buffer ;
-  buffer_host_type     host_send_buffer ;
-  buffer_host_type     send_msg_buffer ;
-  buffer_dev_type      dev_buffer ;
-  buffer_dev_type      dev_send_buffer ; // Subview for send
-  buffer_dev_type      dev_recv_buffer ; // Subview for receive
-  std::vector< MPI_Request > recv_request ;
-
-public:
-
-  const buffer_dev_type & buffer() const { return dev_buffer ; }
-
-  AsyncExchange( const data_map_type & arg_data_map ,
-                 const size_t          arg_chunk )
-  : data_map( arg_data_map )
-  , chunk_size( arg_chunk )
-  , send_count_max( 0 )
-  , host_recv_buffer()
-  , host_send_buffer()
-  , send_msg_buffer()
-  , dev_buffer()
-  , dev_send_buffer()
-  , dev_recv_buffer()
-  , recv_request()
-  {
-    const size_t send_msg_count = arg_data_map.host_send.dimension_0();
-    const size_t recv_msg_count = arg_data_map.host_recv.dimension_0();
-
-    const size_t send_msg_length = arg_chunk * arg_data_map.count_send ;
-    const size_t recv_msg_length = arg_chunk * arg_data_map.count_receive ;
-
-    for ( size_t i = 0 ; i < send_msg_count ; ++i ) {
-      send_count_max = std::max( send_count_max ,
-                                 (unsigned) arg_data_map.host_send(i,1) );
-    }
-
-    // A single shared buffer on the device can be used for
-    // send and receive message buffers.
-    dev_buffer = buffer_dev_type(
-                     std::string("AsyncExchange dev_buffer") ,
-                     std::max( send_msg_length , recv_msg_length ) );
-
-    // Total send subview of the device buffer
-    dev_send_buffer =
-      Kokkos::subview( dev_buffer , std::pair<size_t,size_t>( 0 , send_msg_length ) );
-
-    // Total receive subview of the device buffer
-    dev_recv_buffer =
-      Kokkos::subview( dev_buffer , std::pair<size_t,size_t>( 0 , recv_msg_length ) );
-
-    // Total receive message buffer on the host:
-    host_recv_buffer = buffer_host_type(
-                           std::string("AsyncExchange host_recv_buffer") ,
-                           recv_msg_length );
-
-    // Total send message buffer on the host:
-    host_send_buffer = buffer_host_type(
-                           std::string("AsyncExchange host_send_buffer") ,
-                           send_msg_length );
-
-    // Individual send message buffer on the host:
-    send_msg_buffer = buffer_host_type(
-                          std::string("AsyncExchange send_msg_buffer") ,
-                          arg_chunk * send_count_max );
-
-    // MPI asynchronous receive request handles:
-    recv_request.assign( recv_msg_count , MPI_REQUEST_NULL );
-  }
-
-  //------------------------------------------------------------------------
-
-  void setup()
-  {
-    { // Post receives:
-      const size_t recv_msg_count = data_map.host_recv.dimension_0();
-
-      ValueType * ptr = host_recv_buffer.ptr_on_device();
-
-      for ( size_t i = 0 ; i < recv_msg_count ; ++i ) {
-        const int proc  = data_map.host_recv(i,0);
-        const int count = data_map.host_recv(i,1) * chunk_size ;
-
-        MPI_Irecv( ptr , count * sizeof(ValueType) , MPI_BYTE ,
-                   proc , mpi_tag , data_map.machine.mpi_comm ,
-                   & recv_request[i] );
-
-        ptr += count ;
-      }
-    }
-
-    // Copy send buffer from the device to host memory for sending
-
-    Kokkos::deep_copy( host_send_buffer , dev_send_buffer );
-
-    // Done with the device until communication is complete.
-    // Application can dispatch asynchronous work on the device.
-  }
-
-  // Application can dispatch local work to device ...
-  // No communication progress until main thread calls 'send_receive'
-
-  void send_receive()
-  {
-    const size_t recv_msg_count = data_map.host_recv.dimension_0();
-    const size_t send_msg_count = data_map.host_send.dimension_0();
-
-    // Pack and send:
-
-    for ( size_t i = 0 , j = 0 ; i < send_msg_count ; ++i ) {
-      const int proc  = data_map.host_send(i,0);
-      const int count = data_map.host_send(i,1);
-
-      for ( int k = 0 , km = 0 ; k < count ; ++k , ++j ) {
-        const int km_end = km + chunk_size ;
-        int ki = chunk_size * data_map.host_send_item(j);
-
-        for ( ; km < km_end ; ++km , ++ki ) {
-          send_msg_buffer[km] = host_send_buffer[ki];
-        }
-      }
-
-      // MPI_Ssend blocks until
-      // (1) a receive is matched for the message and
-      // (2) the send buffer can be re-used.
-      //
-      // It is suggested that MPI_Ssend will have the best performance:
-      // http://www.mcs.anl.gov/research/projects/mpi/sendmode.html .
-
-      MPI_Ssend( send_msg_buffer.ptr_on_device(),
-                 count * chunk_size * sizeof(ValueType) , MPI_BYTE ,
-                 proc , mpi_tag , data_map.machine.mpi_comm );
-    }
-
-    // Wait for receives and verify:
-
-    for ( size_t i = 0 ; i < recv_msg_count ; ++i ) {
-      MPI_Status recv_status ;
-      int recv_which = 0 ;
-      int recv_size  = 0 ;
-
-      MPI_Waitany( recv_msg_count , & recv_request[0] ,
-                   & recv_which , & recv_status );
-
-      const int recv_proc = recv_status.MPI_SOURCE ;
-
-      MPI_Get_count( & recv_status , MPI_BYTE , & recv_size );
-
-      // Verify message properly received:
-
-      const int  expected_proc = data_map.host_recv(recv_which,0);
-      const int  expected_size = data_map.host_recv(recv_which,1) *
-                                 chunk_size * sizeof(ValueType);
-
-      if ( ( expected_proc != recv_proc ) ||
-           ( expected_size != recv_size ) ) {
-        std::ostringstream msg ;
-        msg << "AsyncExchange error:"
-            << " P" << comm::rank( data_map.machine )
-            << " received from P" << recv_proc
-            << " size "     << recv_size
-            << " expected " << expected_size
-            << " from P"    << expected_proc ;
-        throw std::runtime_error( msg.str() );
-      }
-    }
-
-    // Copy received data to device memory.
-
-    Kokkos::deep_copy( dev_recv_buffer , host_recv_buffer );
-  }
-};
-
-} // namespace Kokkos
-
-#else /* ! #ifdef KOKKOS_ENABLE_MPI */
-
-namespace Kokkos {
-
-template< class ValueType , class Device >
-class AsyncExchange< ValueType, Device , Kokkos::ParallelDataMap > {
-public:
-
-  typedef Device                                    execution_space ;
-  typedef Kokkos::ParallelDataMap                   data_map_type ;
-  typedef Kokkos::View< ValueType* , execution_space >  buffer_dev_type ;
-  typedef typename buffer_dev_type::HostMirror      buffer_host_type ;
-
-  buffer_dev_type      dev_buffer ;
-
-public:
-
-  const buffer_dev_type & buffer() const { return dev_buffer ; }
-
-  AsyncExchange( const data_map_type & , const size_t )
-  : dev_buffer()
-  { }
-
-  //------------------------------------------------------------------------
-
-  void setup() { }
-
-  void send_receive() { }
-};
-
-} // namespace Kokkos
-
-#endif /* ! #ifdef KOKKOS_ENABLE_MPI */
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_PARALLELDATAMAP_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/ParallelMachine.cpp b/lib/kokkos/example/multi_fem/ParallelMachine.cpp
deleted file mode 100644
index 49545e6a57f9e7d9e687d3dd36e8516ebe2d15cb..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/ParallelMachine.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#if 0
-
-#include <cstdlib>
-#include <cstring>
-
-#include <ParallelMachine.hpp>
-
-#include <Kokkos_Core.hpp>
-
-#if ! defined( KOKKOS_ENABLE_MPI )
-#define MPI_COMM_NULL 0
-#endif
-
-//------------------------------------------------------------------------
-
-namespace Parallel {
-
-Machine::Machine( int * argc , char *** argv )
-  : m_mpi_comm( MPI_COMM_NULL )
-  , m_mpi_size(0)
-  , m_mpi_rank(0)
-  , m_mpi_gpu(0)
-{
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  //------------------------------------
-  // Might be using a Cuda aware version of MPI.
-  // Must select Cuda device before initializing MPI.
-  {
-    int i = 1 ;
-    for ( ; i < *argc && strcmp((*argv)[i],"mpi_cuda") ; ++i );
-
-    if ( i < *argc ) {
-      // Determine, if possible, what will be the node-local
-      // rank of the MPI process once MPI has been initialized.
-      // This rank is needed to set the Cuda device before 'mvapich'
-      // is initialized.
-
-      const char * const mvapich_local_rank = getenv("MV2_COMM_WORLD_LOCAL_RANK");
-      const char * const slurm_local_rank   = getenv("SLURM_LOCALID");
-
-      const int pre_mpi_local_rank =
-        0 != mvapich_local_rank ? atoi( mvapich_local_rank ) : (
-        0 != slurm_local_rank   ? atoi( slurm_local_rank ) : (
-        -1 ) );
-
-      if ( 0 <= pre_mpi_local_rank ) {
-
-        const int ngpu = Kokkos::Cuda::detect_device_count();
-
-        const int cuda_device_rank = pre_mpi_local_rank % ngpu ;
-
-        Kokkos::Cuda::initialize( Kokkos::Cuda::SelectDevice( cuda_device_rank ) );
-
-        m_mpi_gpu = 1 ;
-      }
-    }
-  }
-#endif
-
-  //------------------------------------
-
-#if defined( KOKKOS_ENABLE_MPI )
-  MPI_Init( argc , argv );
-  m_mpi_comm = MPI_COMM_WORLD ;
-  MPI_Comm_size( m_mpi_comm , & m_mpi_size );
-  MPI_Comm_rank( m_mpi_comm , & m_mpi_rank );
-#endif
-
-  // Query hwloc after MPI initialization to allow MPI binding:
-  //------------------------------------
-  // Request to use host device:
-  {
-    int i = 1 ;
-    for ( ; i < *argc && strcmp((*argv)[i],"host") ; ++i );
-
-    if ( i < *argc ) {
-
-      unsigned team_count       = Kokkos::hwloc::get_available_numa_count();
-      unsigned threads_per_team = Kokkos::hwloc::get_available_cores_per_numa() *
-                                  Kokkos::hwloc::get_available_threads_per_core();
-
-      if ( i + 2 < *argc ) {
-        team_count       = atoi( (*argv)[i+1] );
-        threads_per_team = atoi( (*argv)[i+2] );
-      }
-
-      Kokkos::Threads::initialize( team_count * threads_per_team );
-    }
-  }
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  //------------------------------------
-  // Request to use Cuda device and not already initialized.
-  if ( ! m_mpi_gpu ) {
-    int i = 1 ;
-    for ( ; i < *argc && strcmp((*argv)[i],"mpi_cuda") && strcmp((*argv)[i],"cuda") ; ++i );
-
-    if ( i < *argc ) {
-
-      const int ngpu = Kokkos::Cuda::detect_device_count();
-
-      const int cuda_device_rank = m_mpi_rank % ngpu ;
-
-      Kokkos::Cuda::initialize( Kokkos::Cuda::SelectDevice( cuda_device_rank ) );
-    }
-  }
-#endif
-
-}
-
-Machine::~Machine()
-{
-  Kokkos::Threads::finalize();
-#if defined( KOKKOS_ENABLE_CUDA )
-  Kokkos::Cuda::finalize();
-#endif
-#if defined( KOKKOS_ENABLE_MPI )
-  MPI_Finalize();
-#endif
-}
-
-void Machine::print_configuration( std::ostream & msg ) const
-{
-  msg << "MPI [ " << m_mpi_rank << " / " << m_mpi_size << " ]" << std::endl ;
-  Kokkos::Threads::print_configuration( msg );
-#if defined( KOKKOS_ENABLE_CUDA )
-  Kokkos::Cuda::print_configuration( msg );
-#endif
-}
-
-}
-
-#endif /* #if 0 */
-
diff --git a/lib/kokkos/example/multi_fem/ParallelMachine.hpp b/lib/kokkos/example/multi_fem/ParallelMachine.hpp
deleted file mode 100644
index 14894f32138ed58814abfe69e78a515349fdc80f..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/ParallelMachine.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#error "ParallelMachine"
-
-#ifndef PARALLELMACHINE_HPP
-#define PARALLELMACHINE_HPP
-
-//------------------------------------------------------------------------
-
-#include <iosfwd>
-
-#include <Kokkos_Core.hpp>
-
-//------------------------------------------------------------------------
-
-#if defined( KOKKOS_ENABLE_MPI )
-#include <mpi.h>
-#else
-  typedef int MPI_Comm ;
-#endif
-
-//------------------------------------------------------------------------
-//------------------------------------------------------------------------
-
-namespace Parallel {
-
-/** \brief  Hybrid parallel machine with MPI+Kokkos::Threads or MPI+Kokkos::Cuda.
- *
- *  Initialization of MPI and Kokkos device has interdependencies which this
- *  class manages.  The command line and environment variables are queried to initialize
- *  the Threads or Cuda device:
- *
- *    1)  cuda               : initializes Cuda device
- *    2)  host               : initializes Threads device with all hwloc detected cores.
- *    3)  host #gang #worker : initializes Threads with specified
- */
-class Machine {
-private:
-
-  MPI_Comm m_mpi_comm ;
-  int      m_mpi_size ;
-  int      m_mpi_rank ;
-  unsigned m_mpi_gpu ;
-  unsigned m_gpu_arch ;
-
-  Machine();
-  Machine( const Machine & );
-  Machine & operator = ( const Machine & );
-
-public:
-
-  /** \brief  Coordinated initialize MPI, Cuda, or Threads devices from 'main'.  */
-  Machine( int * argc , char *** argv );
-
-  ~Machine();
-
-  MPI_Comm mpi_comm() const { return m_mpi_comm ; }
-
-  int mpi_size() const { return m_mpi_size ; }
-  int mpi_rank() const { return m_mpi_rank ; }
-
-  /** \brief  If using MPI that can directly operate on GPU memory */
-  bool mpi_gpu() const { return m_mpi_gpu ; }
-
-  /** \brief  If using GPU then what architecture */
-  unsigned gpu_arch() const { return m_gpu_arch ; }
-
-  void print_configuration( std::ostream & ) const ;
-};
-
-}
-
-//------------------------------------------------------------------------
-
-#endif /* #ifndef PARALLELMACHINE_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/SparseLinearSystem.hpp b/lib/kokkos/example/multi_fem/SparseLinearSystem.hpp
deleted file mode 100644
index c07ae21b7e41147d836d502973ddbd960e5a7abc..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/SparseLinearSystem.hpp
+++ /dev/null
@@ -1,404 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef SPARSELINEARSYSTEM_HPP
-#define SPARSELINEARSYSTEM_HPP
-
-#include <cmath>
-#include <impl/Kokkos_Timer.hpp>
-
-#include <Kokkos_Core.hpp>
-#include <Kokkos_StaticCrsGraph.hpp>
-
-#include <LinAlgBLAS.hpp>
-
-namespace Kokkos {
-
-template< typename ScalarType , class Device >
-struct CrsMatrix {
-  typedef Device      execution_space ;
-  typedef ScalarType  value_type ;
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
-  typedef StaticCrsGraph< int , execution_space , void , int , void >  graph_type ;
-#else
-  typedef StaticCrsGraph< int , execution_space , void , void , int >  graph_type ;
-#endif
-  typedef View< value_type* , execution_space >   coefficients_type ;
-
-  graph_type         graph ;
-  coefficients_type  coefficients ;
-};
-
-//----------------------------------------------------------------------------
-
-namespace Impl {
-
-template< class Matrix , class OutputVector , class InputVector >
-struct Multiply ;
-
-}
-}
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template< typename AScalarType ,
-          typename VScalarType ,
-          class DeviceType >
-struct Multiply< CrsMatrix<AScalarType,DeviceType> ,
-                 View<VScalarType*,DeviceType > ,
-                 View<VScalarType*,DeviceType > >
-{
-  typedef DeviceType                       execution_space ;
-  typedef typename execution_space::size_type  size_type ;
-
-  typedef View<       VScalarType*, execution_space, MemoryUnmanaged >  vector_type ;
-  typedef View< const VScalarType*, execution_space, MemoryUnmanaged >  vector_const_type ;
-
-  typedef CrsMatrix< AScalarType , execution_space >    matrix_type ;
-
-private:
-
-  matrix_type        m_A ;
-  vector_const_type  m_x ;
-  vector_type        m_y ;
-
-public:
-
-  //--------------------------------------------------------------------------
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type iRow ) const
-  {
-    const size_type iEntryBegin = m_A.graph.row_map[iRow];
-    const size_type iEntryEnd   = m_A.graph.row_map[iRow+1];
-
-    double sum = 0 ;
-
-#if defined( __INTEL_COMPILER )
-#pragma simd reduction(+:sum)
-#pragma ivdep
-    for ( size_type iEntry = iEntryBegin ; iEntry < iEntryEnd ; ++iEntry ) {
-      sum += m_A.coefficients(iEntry) * m_x( m_A.graph.entries(iEntry) );
-    }
-#else
-    for ( size_type iEntry = iEntryBegin ; iEntry < iEntryEnd ; ++iEntry ) {
-      sum += m_A.coefficients(iEntry) * m_x( m_A.graph.entries(iEntry) );
-    }
-#endif
-
-    m_y(iRow) = sum ;
-  }
-
-  Multiply( const matrix_type & A ,
-            const size_type nrow ,
-            const size_type , // ncol ,
-            const vector_type & x ,
-            const vector_type & y )
-    : m_A( A ), m_x( x ), m_y( y )
-  {
-    parallel_for( nrow , *this );
-  }
-};
-
-//----------------------------------------------------------------------------
-
-} // namespace Impl
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-template< typename AScalarType ,
-          typename VScalarType ,
-          class Device >
-class Operator {
-  typedef CrsMatrix<AScalarType,Device>  matrix_type ;
-  typedef View<VScalarType*,Device>     vector_type ;
-
-private:
-  const CrsMatrix<AScalarType,Device> A ;
-
-  ParallelDataMap                                         data_map ;
-  AsyncExchange< VScalarType , Device , ParallelDataMap > exchange ;
-
-public:
-
-  Operator( const ParallelDataMap                  & arg_data_map ,
-            const CrsMatrix<AScalarType,Device>    & arg_A )
-    : A( arg_A )
-    , data_map( arg_data_map )
-    , exchange( arg_data_map , 1 )
-    {}
-
-  void apply( const View<VScalarType*,Device>  & x ,
-              const View<VScalarType*,Device>  & y )
-  {
-    // Gather off-processor data for 'x'
-
-    PackArray< vector_type >::pack( exchange.buffer() ,
-                                    data_map.count_interior ,
-                                    data_map.count_send , x );
-
-    exchange.setup();
-
-    // If interior & boundary matrices then could launch interior multiply
-
-    exchange.send_receive();
-
-    UnpackArray< vector_type >::unpack( x , exchange.buffer() ,
-                                        data_map.count_owned ,
-                                        data_map.count_receive );
-
-    const typename Device::size_type nrow = data_map.count_owned ;
-    const typename Device::size_type ncol = data_map.count_owned +
-                                            data_map.count_receive ;
-
-    Impl::Multiply<matrix_type,vector_type,vector_type>( A, nrow, ncol, x, y);
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template< typename AScalarType , typename VScalarType , class Device >
-void cgsolve(
-  const ParallelDataMap                 data_map ,
-  const CrsMatrix<AScalarType,Device>   A ,
-  const View<VScalarType*,Device> b ,
-  const View<VScalarType*,Device> x ,
-  size_t & iteration ,
-  double & normr ,
-  double & iter_time ,
-  const size_t maximum_iteration = 200 ,
-  const double tolerance = std::numeric_limits<VScalarType>::epsilon() )
-{
-  typedef View<VScalarType*,Device> vector_type ;
-  //typedef View<VScalarType,  Device> value_type ; // unused
-
-  const size_t count_owned = data_map.count_owned ;
-  const size_t count_total = data_map.count_owned + data_map.count_receive ;
-
-  Operator<AScalarType,VScalarType,Device> matrix_operator( data_map , A );
-
-  // Need input vector to matvec to be owned + received
-  vector_type pAll ( "cg::p" , count_total );
-
-  vector_type p = Kokkos::subview( pAll , std::pair<size_t,size_t>(0,count_owned) );
-  vector_type r ( "cg::r" , count_owned );
-  vector_type Ap( "cg::Ap", count_owned );
-
-  /* r = b - A * x ; */
-
-  /* p  = x      */ deep_copy( p , x );
-  /* Ap = A * p  */ matrix_operator.apply( pAll , Ap );
-  /* r  = b - Ap */ waxpby( count_owned , 1.0 , b , -1.0 , Ap , r );
-  /* p  = r      */ deep_copy( p , r );
-
-  double old_rdot = dot( count_owned , r , data_map.machine );
-
-  normr     = std::sqrt( old_rdot );
-  iteration = 0 ;
-
-  Kokkos::Timer wall_clock ;
-
-  while ( tolerance < normr && iteration < maximum_iteration ) {
-
-    /* pAp_dot = dot( p , Ap = A * p ) */
-
-    /* Ap = A * p  */ matrix_operator.apply( pAll , Ap );
-
-    const double pAp_dot = dot( count_owned , p , Ap , data_map.machine );
-    const double alpha   = old_rdot / pAp_dot ;
-
-    /* x += alpha * p ;  */ axpy( count_owned,  alpha, p , x );
-    /* r -= alpha * Ap ; */ axpy( count_owned, -alpha, Ap, r );
-
-    const double r_dot = dot( count_owned , r , data_map.machine );
-    const double beta  = r_dot / old_rdot ;
-
-    /* p = r + beta * p ; */ xpby( count_owned , r , beta , p );
-
-    normr = std::sqrt( old_rdot = r_dot );
-    ++iteration ;
-  }
-
-  iter_time = wall_clock.seconds();
-}
-
-//----------------------------------------------------------------------------
-
-} // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#if defined( KOKKOS_ENABLE_CUDA )
-
-#if ( CUDA_VERSION < 6000 )
-#pragma message "cusparse_v2.h"
-#include <cusparse_v2.h>
-#else
-#pragma message "cusparse.h"
-#include <cusparse.h>
-#endif
-
-namespace Kokkos {
-namespace Impl {
-
-struct CudaSparseSingleton {
-  cusparseHandle_t   handle;
-  cusparseMatDescr_t descra;
-
-  CudaSparseSingleton()
-  {
-    cusparseCreate( & handle );
-    cusparseCreateMatDescr( & descra );
-    cusparseSetMatType(       descra , CUSPARSE_MATRIX_TYPE_GENERAL );
-    cusparseSetMatIndexBase(  descra , CUSPARSE_INDEX_BASE_ZERO );
-  }
-
-  static CudaSparseSingleton & singleton();
-
-};
-
-template<>
-struct Multiply< CrsMatrix<double,Cuda> ,
-                 View<double*,Cuda > ,
-                 View<double*,Cuda > >
-{
-  typedef Cuda                                      execution_space ;
-  typedef execution_space::size_type                    size_type ;
-  typedef double                                    scalar_type ;
-  typedef View< scalar_type* , execution_space >        vector_type ;
-  typedef CrsMatrix< scalar_type , execution_space >    matrix_type ;
-
-public:
-
-  Multiply( const matrix_type & A ,
-            const size_type nrow ,
-            const size_type ncol ,
-            const vector_type & x ,
-            const vector_type & y )
-  {
-    CudaSparseSingleton & s = CudaSparseSingleton::singleton();
-    const scalar_type alpha = 1 , beta = 0 ;
-
-    cusparseStatus_t status =
-      cusparseDcsrmv( s.handle ,
-                      CUSPARSE_OPERATION_NON_TRANSPOSE ,
-                      nrow , ncol , A.coefficients.dimension_0() ,
-                      &alpha ,
-                      s.descra ,
-                      A.coefficients.ptr_on_device() ,
-                      A.graph.row_map.ptr_on_device() ,
-                      A.graph.entries.ptr_on_device() ,
-                      x.ptr_on_device() ,
-                      &beta ,
-                      y.ptr_on_device() );
-
-    if ( CUSPARSE_STATUS_SUCCESS != status ) {
-      throw std::runtime_error( std::string("ERROR - cusparseDcsrmv " ) );
-    }
-  }
-};
-
-
-template<>
-struct Multiply< CrsMatrix<float,Cuda> ,
-                 View<float*,Cuda > ,
-                 View<float*,Cuda > >
-{
-  typedef Cuda                                      execution_space ;
-  typedef execution_space::size_type                    size_type ;
-  typedef float                                     scalar_type ;
-  typedef View< scalar_type* , execution_space >        vector_type ;
-  typedef CrsMatrix< scalar_type , execution_space >    matrix_type ;
-
-public:
-
-  Multiply( const matrix_type & A ,
-            const size_type nrow ,
-            const size_type ncol ,
-            const vector_type & x ,
-            const vector_type & y )
-  {
-    CudaSparseSingleton & s = CudaSparseSingleton::singleton();
-    const scalar_type alpha = 1 , beta = 0 ;
-
-    cusparseStatus_t status =
-      cusparseScsrmv( s.handle ,
-                      CUSPARSE_OPERATION_NON_TRANSPOSE ,
-                      nrow , ncol , A.coefficients.dimension_0() ,
-                      &alpha ,
-                      s.descra ,
-                      A.coefficients.ptr_on_device() ,
-                      A.graph.row_map.ptr_on_device() ,
-                      A.graph.entries.ptr_on_device() ,
-                      x.ptr_on_device() ,
-                      &beta ,
-                      y.ptr_on_device() );
-
-    if ( CUSPARSE_STATUS_SUCCESS != status ) {
-      throw std::runtime_error( std::string("ERROR - cusparseDcsrmv " ) );
-    }
-  }
-};
-
-} /* namespace Impl */
-} /* namespace Kokkos */
-
-#endif /* #if defined( KOKKOS_ENABLE_CUDA ) */
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef SPARSELINEARSYSTEM_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/SparseLinearSystemFill.hpp b/lib/kokkos/example/multi_fem/SparseLinearSystemFill.hpp
deleted file mode 100644
index 980f14ac1b1c31fa72ec1e45e18d7c9f190255fa..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/SparseLinearSystemFill.hpp
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef SPARSELINEARSYSTEMFILL_HPP
-#define SPARSELINEARSYSTEMFILL_HPP
-
-#include <vector>
-#include <algorithm>
-#include <limits>
-
-#include <FEMesh.hpp>
-#include <SparseLinearSystem.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace HybridFEM {
-
-template< class MatrixType , class MeshType ,
-          class elem_matrices_type ,
-          class elem_vectors_type > struct GatherFill ;
-
-
-template< typename ScalarType ,
-          class    DeviceType ,
-          unsigned ElemNode ,
-          typename CoordScalarType ,
-          class elem_matrices_type ,
-          class elem_vectors_type >
-struct GatherFill< 
-  Kokkos::CrsMatrix< ScalarType , DeviceType > ,
-  FEMesh< CoordScalarType , ElemNode , DeviceType > ,
-  elem_matrices_type , elem_vectors_type >
-{
-  typedef DeviceType     execution_space ;
-  typedef typename execution_space::size_type  size_type ;
-
-  static const size_type ElemNodeCount = ElemNode ;
-
-  typedef Kokkos::CrsMatrix< ScalarType , execution_space >    matrix_type ;
-  typedef typename matrix_type::coefficients_type   coefficients_type ;
-  typedef Kokkos::View< ScalarType[] , execution_space >  vector_type ;
-  typedef Kokkos::View< size_type[][ElemNodeCount][ElemNodeCount] , execution_space >       elem_graph_type ;
-
-  typedef FEMesh< CoordScalarType , ElemNodeCount , execution_space > mesh_type ;
-  typedef typename mesh_type::node_elem_ids_type node_elem_ids_type ;
-
-private:
-
-  node_elem_ids_type  node_elem_ids ;
-  elem_graph_type     elem_graph ;
-  elem_matrices_type  elem_matrices ;
-  elem_vectors_type   elem_vectors ;
-  coefficients_type   system_coeff ;
-  vector_type         system_rhs ;
-
-public:
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( size_type irow ) const
-  {
-    const size_type node_elem_begin = node_elem_ids.row_map[irow];
-    const size_type node_elem_end   = node_elem_ids.row_map[irow+1];
-
-    //  for each element that a node belongs to 
-
-    for ( size_type i = node_elem_begin ; i < node_elem_end ; i++ ) {
-
-      const size_type elem_id   = node_elem_ids.entries( i, 0);
-      const size_type row_index = node_elem_ids.entries( i, 1);
-
-      system_rhs(irow) += elem_vectors(elem_id, row_index);
-
-      //  for each node in a particular related element  
-      //  gather the contents of the element stiffness
-      //  matrix that belong in irow
-
-      for ( size_type j = 0 ; j < ElemNodeCount ; ++j ){
-        const size_type A_index = elem_graph( elem_id , row_index , j );
-
-        system_coeff( A_index ) += elem_matrices( elem_id, row_index, j );
-      }
-    }
-  }
-
-
-  static void apply( const matrix_type & matrix ,
-                     const vector_type & rhs ,
-                     const mesh_type   & mesh ,
-                     const elem_graph_type    & elem_graph ,
-                     const elem_matrices_type & elem_matrices ,
-                     const elem_vectors_type  & elem_vectors )
-  {
-    const size_t row_count = matrix.graph.row_map.dimension_0() - 1 ;
-    GatherFill op ;
-    op.node_elem_ids = mesh.node_elem_ids ;
-    op.elem_graph    = elem_graph ;
-    op.elem_matrices = elem_matrices ;
-    op.elem_vectors  = elem_vectors ;
-    op.system_coeff  = matrix.coefficients ;
-    op.system_rhs    = rhs ;
-
-    parallel_for( row_count , op );
-  }
-};
-
-} /* namespace HybridFEM */
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace HybridFEM {
-
-template< class GraphType , class MeshType >
-struct GraphFactory {
-  typedef GraphType                         graph_type ;
-  typedef MeshType                          mesh_type ;
-  typedef typename graph_type::execution_space  execution_space ;
-  typedef typename execution_space::size_type   size_type  ;
-
-  static const unsigned ElemNodeCount = mesh_type::element_node_count ;
-
-  typedef Kokkos::View< size_type[][ElemNodeCount][ElemNodeCount] , execution_space >         element_map_type ;
-
-  static
-  void
-  create( const mesh_type & mesh ,
-          graph_type & graph ,
-          element_map_type & elem_map )
-  {
-    typename mesh_type::node_elem_ids_type::HostMirror
-      node_elem_ids = create_mirror( mesh.node_elem_ids );
-
-    typename mesh_type::elem_node_ids_type::HostMirror
-      elem_node_ids = create_mirror( mesh.elem_node_ids );
-
-    typedef typename element_map_type::HostMirror element_map_host_type ;
-
-    deep_copy( elem_node_ids , mesh.elem_node_ids );
-    deep_copy( node_elem_ids.entries , mesh.node_elem_ids.entries );
-
-    const size_t owned_node = mesh.parallel_data_map.count_owned ;
-    const size_t total_elem = mesh.elem_node_ids.dimension_0();
-
-    if ( total_elem ) {
-      elem_map = element_map_type( std::string("element_map"), total_elem );
-    }
-
-    element_map_host_type elem_map_host = create_mirror( elem_map );
-
-    //------------------------------------
-    //  Node->node mapping for the CrsMatrix graph
-
-    std::vector< std::vector< unsigned > > node_node_ids( owned_node );
-    std::vector< unsigned > node_node_begin( owned_node );
-
-    size_t offset = 0 ;
-    for ( size_t i = 0 ; i < owned_node ; ++i ) {
-      const size_t j_end = node_elem_ids.row_map[i+1];
-            size_t j     = node_elem_ids.row_map[i];
-
-      node_node_begin[i] = offset ;
-
-      std::vector< unsigned > & work = node_node_ids[i] ;
-
-      for ( ; j < j_end ; ++j ) {
-        const size_t elem_id = node_elem_ids.entries(j,0);
-        for ( size_t k = 0 ; k < ElemNodeCount ; ++k ) {
-          work.push_back( elem_node_ids( elem_id , k ) );
-        }
-      }
-
-      std::sort( work.begin() , work.end() );
-
-      work.erase( std::unique( work.begin() , work.end() ) , work.end() );
-
-      offset += work.size();
-    }
-
-    graph = Kokkos::create_staticcrsgraph< graph_type >( "node_node_ids" , node_node_ids );
-
-    //------------------------------------
-    // ( element , node_row , node_column ) -> matrix_crs_column
-
-    for ( size_t elem_id = 0 ; elem_id < total_elem ; ++elem_id ) {
-      for ( size_t i = 0 ; i < ElemNodeCount ; ++i ) {
-
-        const size_t node_row = elem_node_ids( elem_id , i );
-        const size_t node_row_begin = node_node_begin[ node_row ];
-        const std::vector< unsigned > & column = node_node_ids[ node_row ] ;
-
-        if ( owned_node <= node_row ) {
-          for ( unsigned j = 0 ; j < ElemNodeCount ; ++j ) {
-            elem_map_host( elem_id , i , j ) = std::numeric_limits<size_type>::max();
-          }
-        }
-        else {
-
-          for ( unsigned j = 0 ; j < ElemNodeCount ; ++j ) {
-            const size_type node_col = elem_node_ids( elem_id , j );
-
-            int col_search = 0 ;
-
-            for ( int len = column.size() ; 0 < len ; ) {
-
-              const int half = len >> 1;
-              const int middle = col_search + half ;
-
-              if ( column[middle] < node_col ){
-                col_search = middle + 1 ;
-                len -= half + 1 ;
-              }
-              else {
-                len = half ;
-              }
-            }
-if ( node_col != column[col_search] ) {
-  throw std::runtime_error(std::string("Failed"));
-}
-            elem_map_host( elem_id , i , j ) = col_search + node_row_begin ;
-          }
-        }
-      }
-    }
-
-    deep_copy( elem_map , elem_map_host );
-  }
-};
-
-} // namespace HybridFEM
-
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef SPARSELINEARSYSTEMFILL_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/SparseLinearSystem_Cuda.hpp b/lib/kokkos/example/multi_fem/SparseLinearSystem_Cuda.hpp
deleted file mode 100644
index 8dfae4758d0dcf9e081dded8f80ff09e37f25363..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/SparseLinearSystem_Cuda.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef SPARSELINEARSYSTEM_CUDA_HPP
-#define SPARSELINEARSYSTEM_CUDA_HPP
-
-#if defined( BUILD_FROM_CU_FILE )
-
-#include <cusparse_v2.h>
-#include <Kokkos_Core.hpp>
-
-namespace Kokkos {
-namespace Impl {
-
-
-struct CudaSparseSingleton {
-  cusparseHandle_t   handle;
-  cusparseMatDescr_t descra;
-
-  CudaSparseSingleton()
-  {
-    cusparseCreate( & handle );
-    cusparseCreateMatDescr( & descra );
-    cusparseSetMatType(       descra , CUSPARSE_MATRIX_TYPE_GENERAL );
-    cusparseSetMatIndexBase(  descra , CUSPARSE_INDEX_BASE_ZERO );
-  }
-
-  static CudaSparseSingleton & singleton();
-
-};
-
-CudaSparseSingleton & CudaSparseSingleton::singleton()
-{ static CudaSparseSingleton s ; return s ; }
-
-
-template<>
-struct Multiply< CrsMatrix<double,Cuda> ,
-                 View<double*,Cuda > ,
-                 View<double*,Cuda > >
-{
-  typedef Cuda                                      execution_space ;
-  typedef execution_space::size_type                    size_type ;
-  typedef double                                    scalar_type ;
-  typedef View< scalar_type* , execution_space >        vector_type ;
-  typedef CrsMatrix< scalar_type , execution_space >    matrix_type ;
-
-public:
-
-  Multiply( const matrix_type & A ,
-            const size_type nrow ,
-            const size_type ncol ,
-            const vector_type & x ,
-            const vector_type & y )
-  {
-    CudaSparseSingleton & s = CudaSparseSingleton::singleton();
-    const scalar_type alpha = 1 , beta = 0 ;
-
-    cusparseStatus_t status =
-      cusparseDcsrmv( s.handle ,
-                      CUSPARSE_OPERATION_NON_TRANSPOSE ,
-                      nrow , ncol , A.coefficients.dimension_0() ,
-                      &alpha ,
-                      s.descra ,
-                      A.coefficients.ptr_on_device() ,
-                      A.graph.row_map.ptr_on_device() ,
-                      A.graph.entries.ptr_on_device() ,
-                      x.ptr_on_device() ,
-                      &beta ,
-                      y.ptr_on_device() );
-
-    if ( CUSPARSE_STATUS_SUCCESS != status ) {
-      throw std::runtime_error( std::string("ERROR - cusparseDcsrmv " ) );
-    }
-  }
-};
-
-
-template<>
-struct Multiply< CrsMatrix<float,Cuda> ,
-                 View<float*,Cuda > ,
-                 View<float*,Cuda > >
-{
-  typedef Cuda                                      execution_space ;
-  typedef execution_space::size_type                    size_type ;
-  typedef float                                     scalar_type ;
-  typedef View< scalar_type* , execution_space >        vector_type ;
-  typedef CrsMatrix< scalar_type , execution_space >    matrix_type ;
-
-public:
-
-  Multiply( const matrix_type & A ,
-            const size_type nrow ,
-            const size_type ncol ,
-            const vector_type & x ,
-            const vector_type & y )
-  {
-    CudaSparseSingleton & s = CudaSparseSingleton::singleton();
-    const scalar_type alpha = 1 , beta = 0 ;
-
-    cusparseStatus_t status =
-      cusparseScsrmv( s.handle ,
-                      CUSPARSE_OPERATION_NON_TRANSPOSE ,
-                      nrow , ncol , A.coefficients.dimension_0() ,
-                      &alpha ,
-                      s.descra ,
-                      A.coefficients.ptr_on_device() ,
-                      A.graph.row_map.ptr_on_device() ,
-                      A.graph.entries.ptr_on_device() ,
-                      x.ptr_on_device() ,
-                      &beta ,
-                      y.ptr_on_device() );
-
-    if ( CUSPARSE_STATUS_SUCCESS != status ) {
-      throw std::runtime_error( std::string("ERROR - cusparseDcsrmv " ) );
-    }
-  }
-};
-
-} /* namespace Impl */
-} /* namespace Kokkos */
-
-#endif /* #if defined( __CUDACC__ ) */
-#endif /* #ifndef SPARSELINEARSYSTEM_CUDA_HPP */
-
diff --git a/lib/kokkos/example/multi_fem/TestBoxMeshFixture.hpp b/lib/kokkos/example/multi_fem/TestBoxMeshFixture.hpp
deleted file mode 100644
index 9903c998fe63aece380cb34f5cb23d0b7440a4a0..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/TestBoxMeshFixture.hpp
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef TESTFEMESHBOXFIXTURE_HPP
-#define TESTFEMESHBOXFIXTURE_HPP
-
-#include <cstdio>
-#include <iostream>
-#include <stdexcept>
-#include <limits>
-#include <utility>
-#include <BoxMeshFixture.hpp>
-
-#include <ParallelComm.hpp>
-
-//----------------------------------------------------------------------------
-
-namespace TestFEMesh {
-
-template< class ViewType >
-struct VerifyUnpack  ;
-
-template< typename DeviceType, typename T >
-struct VerifyUnpack< Kokkos::View< T*[3] , DeviceType > >
-{
-  typedef DeviceType     execution_space ;
-  typedef typename execution_space::size_type  size_type ;
-  typedef size_type               value_type ;
-
-  typedef Kokkos::View< T* ,    execution_space > buffer_type ;
-  typedef Kokkos::View< T*[3] , execution_space > array_type ;
-
-private:
-
-  array_type  node_coords ;
-  buffer_type buffer ;
-  size_type   node_begin ;
-
-public:
-
-  KOKKOS_INLINE_FUNCTION
-  static void init( value_type & update )
-  { update = 0 ; }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join( volatile value_type & update ,
-                    const volatile value_type & source )
-  { update += source ; }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()( const size_type i , value_type & update ) const
-  {
-    const size_type node_id = i + node_begin ;
-    const size_type k = i * 3 ;
-
-    const long xb = buffer[k];
-    const long yb = buffer[k+1];
-    const long zb = buffer[k+2];
-    const long xn = node_coords(node_id,0);
-    const long yn = node_coords(node_id,1);
-    const long zn = node_coords(node_id,2);
-
-    if ( xb != xn || yb != yn || zb != zn ) {
-      printf("TestFEMesh::VerifyUnpack failed at %d : node %d : { %ld %ld %ld } != { %ld %ld %ld }\n",
-             (int)i,(int)node_id, xb,yb,zb, xn, yn, zn );
-      ++update ;
-    }
-  }
-
-  static inline
-  size_type unpack( const array_type  & arg_node_coords ,
-                    const size_type     arg_node_begin ,
-                    const size_type     arg_node_count ,
-                    const buffer_type & arg_buffer )
-  {
-    VerifyUnpack op ;
-    op.node_coords = arg_node_coords ;
-    op.buffer      = arg_buffer ;
-    op.node_begin  = arg_node_begin ;
-    size_type count = 0 ;
-    Kokkos::parallel_reduce( arg_node_count , op , count );
-    return count ;
-  }
-};
-
-}
-
-//----------------------------------------------------------------------------
-
-#ifdef KOKKOS_ENABLE_MPI
-
-namespace TestFEMesh {
-
-template< typename coordinate_scalar_type ,
-          unsigned ElemNodeCount ,
-          class Device >
-void verify_parallel(
-  const HybridFEM::FEMesh< coordinate_scalar_type ,
-                           ElemNodeCount ,
-                           Device > & mesh )
-{
-  typedef HybridFEM::FEMesh< coordinate_scalar_type, ElemNodeCount, Device > femesh_type ;
-  typedef typename femesh_type::node_coords_type node_coords_type ;
-
-  comm::Machine machine = mesh.parallel_data_map.machine ;
-
-  // Communicate node coordinates to verify communication and setup.
-
-  const size_t chunk_size = 3 ;
-
-  Kokkos::AsyncExchange< coordinate_scalar_type, Device, Kokkos::ParallelDataMap >
-    exchange( mesh.parallel_data_map , chunk_size );
-
-  const size_t send_begin = mesh.parallel_data_map.count_interior ;
-  const size_t send_count = mesh.parallel_data_map.count_send ;
-
-  const size_t recv_begin = mesh.parallel_data_map.count_owned ;
-  const size_t recv_count = mesh.parallel_data_map.count_receive ;
-
-  typedef Kokkos::PackArray< node_coords_type > pack_type ;
-
-  pack_type::pack( exchange.buffer(), send_begin, send_count, mesh.node_coords );
-
-  exchange.setup();
-
-  // Launch local-action device kernels
-
-  exchange.send_receive();
-
-  unsigned long local[3] ;
-  local[0] = mesh.parallel_data_map.count_owned ;
-  local[1] = mesh.parallel_data_map.count_receive ;
-  local[2] = TestFEMesh::VerifyUnpack< node_coords_type >::unpack( mesh.node_coords, recv_begin, recv_count, exchange.buffer() );
-
-  unsigned long global[3] = { 0 , 0 , 0 };
-
-  MPI_Allreduce( local , global ,
-                 3 , MPI_UNSIGNED_LONG , MPI_SUM , machine.mpi_comm );
-
-  if ( 0 == comm::rank( machine ) ) {
-    std::cout << ( global[2] ? "FAILED" : "PASSED" )
-              << ": TestFEMesh::verify_parallel "
-              << "NP(" << comm::size( machine )
-              << ") total_node(" << global[0]
-              << ") verified_nodes(" << global[1]
-              << ") failed_nodes(" << global[2]
-              << ")" << std::endl ;
-  }
-}
-
-} // namespace TestFEMesh
-
-#else /* ! #ifdef KOKKOS_ENABLE_MPI */
-
-namespace TestFEMesh {
-
-template< typename coordinate_scalar_type ,
-          unsigned ElemNodeCount ,
-          class Device >
-void verify_parallel(
-  const HybridFEM::FEMesh< coordinate_scalar_type ,
-                           ElemNodeCount ,
-                           Device > & )
-{}
-
-} // namespace TestFEMesh
-
-#endif /* ! #ifdef KOKKOS_ENABLE_MPI */
-
-//----------------------------------------------------------------------------
-
-template< class Device >
-void test_box_fixture( comm::Machine machine ,
-                       const size_t gang_count ,
-                       const size_t nodes_nx ,
-                       const size_t nodes_ny ,
-                       const size_t nodes_nz )
-{
-  typedef long                coordinate_scalar_type ;
-  typedef FixtureElementHex8  fixture_element_type ;
-
-  typedef BoxMeshFixture< coordinate_scalar_type ,
-                          Device ,
-                          fixture_element_type > fixture_type ;
-
-  typedef typename fixture_type::FEMeshType  mesh_type ;
-
-  const size_t proc_count = comm::size( machine );
-  const size_t proc_local = comm::rank( machine ) ;
-
-  mesh_type mesh =
-    fixture_type::create( proc_count , proc_local , gang_count ,
-                          nodes_nx - 1 , nodes_ny - 1 , nodes_nz - 1 );
-
-  mesh.parallel_data_map.machine = machine ;
-
-  TestFEMesh::verify_parallel( mesh );
-}
-
-#endif /* #ifndef TESTFEMESHBOXFIXTURE_HPP */
-
-
diff --git a/lib/kokkos/example/multi_fem/TestBoxMeshPartition.cpp b/lib/kokkos/example/multi_fem/TestBoxMeshPartition.cpp
deleted file mode 100644
index 93778c85841dfa81a62354b9ff6598e86b235e3d..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/TestBoxMeshPartition.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-
-#include <iostream>
-#include <stdexcept>
-#include <limits>
-#include <utility>
-#include <BoxMeshPartition.hpp>
-
-//----------------------------------------------------------------------------
-
-void test_box_partition( bool print )
-{
-  const size_t np_max = 10000 ;
-
-  const BoxBoundsLinear use_box ;
-
-  BoxType root_box ;
-
-  root_box[0][0] = 0 ; root_box[0][1] = 100 ;
-  root_box[1][0] = 0 ; root_box[1][1] = 200 ;
-  root_box[2][0] = 0 ; root_box[2][1] = 300 ;
-
-  const size_t cell_total =
-    ( root_box[0][1] - root_box[0][0] ) *
-    ( root_box[1][1] - root_box[1][0] ) *
-    ( root_box[2][1] - root_box[2][0] );
-
-  for ( size_t np = 2 ; np < np_max ; np = 2 * ( np + 1 ) ) {
-
-    std::vector<BoxType> part_boxes( np );
-
-    box_partition_rcb( root_box , part_boxes );
-
-    size_t cell_goal = ( cell_total + np - 1 ) / np ;
-    size_t cell_max = 0 ;
-
-    for ( size_t i = 0 ; i < np ; ++i ) {
-      cell_max = std::max( cell_max , count( part_boxes[i] ) );
-    }
-
-    if ( print ) {
-      std::cout << std::endl
-                << "box_part( " << np 
-                << " ) max( " << cell_max
-                << " ) goal( " << cell_goal
-                << " ) ratio( " << double(cell_max) / double(cell_goal)
-                << " )" << std::endl ;
-    }
-
-    const size_t nsample = std::min(np,(size_t)4);
-    const size_t stride = ( np + nsample - 1 ) / nsample ;
-
-    for ( size_t my_part = 0 ; my_part < np ; my_part += stride ) {
-      BoxType             my_use_box ;
-      std::vector<size_t> my_use_id_map ;
-      size_t              my_count_interior ;
-      size_t              my_count_owned ;
-      size_t              my_count_uses ;
-      std::vector<size_t> my_recv_counts ;
-      std::vector<std::vector<size_t> > my_send_map ;
-
-      size_t count_verify = 0 ;
-
-      box_partition_maps( root_box , part_boxes ,
-                          use_box , my_part ,
-                          my_use_box , my_use_id_map ,
-                          my_count_interior ,
-                          my_count_owned ,
-                          my_count_uses ,
-                          my_recv_counts ,
-                          my_send_map );
-
-      count_verify = my_count_owned ;
-
-      if ( print ) {
-        std::cout << "  my_part(" << my_part << ") layout { "
-                  << "P" << my_part
-                  << "(" << my_count_interior
-                  << "," << ( my_count_owned - my_count_interior )
-                  << ")" ;
-      }
-
-      for ( size_t i = 1 ; i < np ; ++i ) {
-        if ( my_recv_counts[i] ) {
-          count_verify += my_recv_counts[i] ;
-          const size_t ip = ( my_part + i ) % np ;
-
-          if ( print ) {
-            std::cout << " P" << ip << "(" << my_recv_counts[i] << ")" ;
-          }
-
-          // Compare recv & send lists
-
-          BoxType             ip_use_box ;
-          std::vector<size_t> ip_use_id_map ;
-          size_t              ip_count_interior ;
-          size_t              ip_count_owned ;
-          size_t              ip_count_uses ;
-          std::vector<size_t> ip_recv_counts ;
-          std::vector<std::vector<size_t> > ip_send_map ;
-
-          box_partition_maps( root_box , part_boxes ,
-                              use_box , ip ,
-                              ip_use_box , ip_use_id_map ,
-                              ip_count_interior ,
-                              ip_count_owned ,
-                              ip_count_uses ,
-                              ip_recv_counts ,
-                              ip_send_map );
-
-          // Sent by ip, received by my_part:
-
-          const BoxType recv_send = intersect( part_boxes[ip] , my_use_box );
-          const size_t recv_send_count = count( recv_send );
-
-          const size_t j = ( my_part + np - ip ) % np ;
-
-          if ( recv_send_count != my_recv_counts[i] ||
-               recv_send_count != ip_send_map[j].size() ) {
-            throw std::runtime_error( std::string("bad recv/send map") );
-          }
-        }
-      }
-      if ( print ) { std::cout << " }" << std::endl ; }
-
-      if ( count_verify != my_count_uses ) {
-        throw std::runtime_error( std::string("bad partition map") );
-      }
-    }
-  }
-}
-
-
diff --git a/lib/kokkos/example/multi_fem/TestCuda.cpp b/lib/kokkos/example/multi_fem/TestCuda.cpp
deleted file mode 100644
index d0e53283f36a3f85ed2721bc4d5d33c9fc668649..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/TestCuda.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-*/
-
-#include <Kokkos_Core.hpp>
-
-#include <TestBoxMeshFixture.hpp>
-#include <Implicit.hpp>
-#include <Nonlinear.hpp>
-#include <Explicit.hpp>
-
-#include <SparseLinearSystem.hpp>
-
-#if defined( KOKKOS_ENABLE_CUDA )
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-CudaSparseSingleton & CudaSparseSingleton::singleton()
-{ static CudaSparseSingleton s ; return s ; }
-
-}
-}
-
-//----------------------------------------------------------------------------
-
-void test_cuda_query( comm::Machine machine )
-{
-  const size_t comm_rank = comm::rank( machine );
-  std::cout << "P" << comm_rank
-            << ": Cuda device_count = "
-            << Kokkos::Cuda::detect_device_count()
-            << std::endl ;
-}
-
-//----------------------------------------------------------------------------
-
-void test_cuda_fixture( comm::Machine machine ,
-                        size_t nx , size_t ny , size_t nz )
-{
-  const size_t comm_rank = comm::rank( machine );
-  const size_t comm_size = comm::size( machine );
-  const size_t dev_count = Kokkos::Cuda::detect_device_count();
-  const size_t dev_rank =
-    dev_count && dev_count <= comm_size ? comm_rank % dev_count : 0 ;
-  const size_t gang_count = 0 ;
-
-  Kokkos::InitArguments args;
-  args.device_id = dev_rank;
-  Kokkos::initialize(args);
-
-  test_box_fixture<Kokkos::Cuda>( machine , gang_count , nx , ny , nz );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-
-void test_cuda_implicit( comm::Machine machine , 
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run )
-{
-  const size_t comm_rank = comm::rank( machine );
-  const size_t comm_size = comm::size( machine );
-  const size_t dev_count = Kokkos::Cuda::detect_device_count();
-  const size_t dev_rank =
-    dev_count && dev_count <= comm_size ? comm_rank % dev_count : 0 ;
-  const size_t gang_count = 0 ;
-
-  Kokkos::InitArguments args;
-  args.device_id = dev_rank;
-  Kokkos::initialize(args);
-  HybridFEM::Implicit::driver<double,Kokkos::Cuda>( "Cuda" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-
-void test_cuda_explicit( comm::Machine machine , 
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run )
-{
-  const size_t comm_rank = comm::rank( machine );
-  const size_t comm_size = comm::size( machine );
-  const size_t dev_count = Kokkos::Cuda::detect_device_count();
-  const size_t dev_rank =
-    dev_count && dev_count <= comm_size ? comm_rank % dev_count : 0 ;
-  const size_t gang_count = 0 ;
-
-  Kokkos::InitArguments args;
-  args.device_id = dev_rank;
-  Kokkos::initialize(args);
-  Explicit::driver<double,Kokkos::Cuda>( "Cuda" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-
-void test_cuda_nonlinear( comm::Machine machine , 
-                          size_t elem_count_begin ,
-                          size_t elem_count_end ,
-                          size_t count_run )
-{
-  const size_t comm_rank = comm::rank( machine );
-  const size_t comm_size = comm::size( machine );
-  const size_t dev_count = Kokkos::Cuda::detect_device_count();
-  const size_t dev_rank =
-    dev_count && dev_count <= comm_size ? comm_rank % dev_count : 0 ;
-  const size_t gang_count = 0 ;
-
-  Kokkos::InitArguments args;
-  args.device_id = dev_rank;
-  Kokkos::initialize(args);
-
-  typedef Kokkos::Cuda device ;
-  typedef FixtureElementHex8 hex8 ;
-  HybridFEM::Nonlinear::driver<double,device,hex8>( "Cuda" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-void test_cuda_nonlinear_quadratic( comm::Machine machine , 
-                                    size_t elem_count_begin ,
-                                    size_t elem_count_end ,
-                                    size_t count_run )
-{
-  const size_t comm_rank = comm::rank( machine );
-  const size_t comm_size = comm::size( machine );
-  const size_t dev_count = Kokkos::Cuda::detect_device_count();
-  const size_t dev_rank =
-    dev_count && dev_count <= comm_size ? comm_rank % dev_count : 0 ;
-  const size_t gang_count = 0 ;
-
-  Kokkos::InitArguments args;
-  args.device_id = dev_rank;
-  Kokkos::initialize(args);
-
-  typedef Kokkos::Cuda device ;
-  typedef FixtureElementHex27 hex27 ;
-  HybridFEM::Nonlinear::driver<double,device,hex27>( "Cuda" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-
-#endif  /* #if defined( KOKKOS_ENABLE_CUDA ) */
-
diff --git a/lib/kokkos/example/multi_fem/TestHost.cpp b/lib/kokkos/example/multi_fem/TestHost.cpp
deleted file mode 100644
index f0f0844812df1fabd32f27df26c67c315a957ee4..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/TestHost.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-
-// Must be included first on Intel-Phi systems due to
-// redefinition of SEEK_SET in <mpi.h>.
-
-#include <ParallelComm.hpp>
-
-#include <iostream>
-#include <stdexcept>
-#include <limits>
-#include <utility>
-
-//----------------------------------------------------------------------------
-
-#include <Kokkos_Core.hpp>
-
-#include <BoxMeshFixture.hpp>
-#include <TestBoxMeshFixture.hpp>
-#include <Implicit.hpp>
-#include <Nonlinear.hpp>
-#include <Explicit.hpp>
-#include <SparseLinearSystem.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-void test_host_fixture( comm::Machine machine ,
-                        size_t gang_count ,
-                        size_t gang_worker_count ,
-                        size_t nx , size_t ny , size_t nz )
-{
-  Kokkos::InitArguments args(gang_count * gang_worker_count);
-  Kokkos::initialize( args );
-  test_box_fixture<Kokkos::HostSpace::execution_space>( machine , gang_count , nx , ny , nz );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-
-void test_host_implicit( comm::Machine machine ,
-                         size_t gang_count ,
-                         size_t gang_worker_count ,
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run )
-{
-  Kokkos::InitArguments args(gang_count * gang_worker_count);
-  Kokkos::initialize( args );
-  HybridFEM::Implicit::driver<double,Kokkos::HostSpace::execution_space>( "Threads" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-
-void test_host_explicit( comm::Machine machine ,
-                         size_t gang_count ,
-                         size_t gang_worker_count ,
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run )
-{
-  Kokkos::InitArguments args(gang_count * gang_worker_count);
-  Kokkos::initialize( args );
-  Explicit::driver<double,Kokkos::HostSpace::execution_space>( "Threads" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-void test_host_nonlinear( comm::Machine machine ,
-                          size_t gang_count ,
-                          size_t gang_worker_count ,
-                          size_t elem_count_begin ,
-                          size_t elem_count_end ,
-                          size_t count_run )
-{
-  Kokkos::InitArguments args(gang_count * gang_worker_count);
-  Kokkos::initialize( args );
-  typedef FixtureElementHex8 hex8 ;
-  typedef Kokkos::HostSpace::execution_space             device ;
-  HybridFEM::Nonlinear::driver<double,device,hex8>( "Threads" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-void test_host_nonlinear_quadratic( comm::Machine machine ,
-                                    size_t gang_count ,
-                                    size_t gang_worker_count ,
-                                    size_t elem_count_begin ,
-                                    size_t elem_count_end ,
-                                    size_t count_run )
-{
-  Kokkos::InitArguments args(gang_count * gang_worker_count);
-  Kokkos::initialize( args );
-  typedef FixtureElementHex27 hex27 ;
-  typedef Kokkos::HostSpace::execution_space              device ;
-  HybridFEM::Nonlinear::driver<double,device,hex27>( "Threads" , machine , gang_count , elem_count_begin , elem_count_end , count_run );
-  Kokkos::finalize();
-}
-
-//----------------------------------------------------------------------------
-
-
diff --git a/lib/kokkos/example/multi_fem/TestHybridFEM.cpp b/lib/kokkos/example/multi_fem/TestHybridFEM.cpp
deleted file mode 100644
index 0be4e69973a6daed75cc5a110483390ecc227889..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/multi_fem/TestHybridFEM.cpp
+++ /dev/null
@@ -1,348 +0,0 @@
-//@HEADER
-// ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
-// ************************************************************************
-//@HEADER
-
-// Must be included first on Intel-Phi systems due to
-// redefinition of SEEK_SET in <mpi.h>.
-
-#include <ParallelComm.hpp>
-
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <Kokkos_hwloc.hpp>
-
-//----------------------------------------------------------------------------
-
-void test_box_partition( bool print );
-
-//----------------------------------------------------------------------------
-
-void test_host_fixture( comm::Machine machine ,
-                        size_t gang_count ,
-                        size_t gang_worker_count ,
-                        size_t nx , size_t ny , size_t nz );
-
-void test_host_implicit( comm::Machine machine ,
-                         size_t gang_count ,
-                         size_t gang_worker_count ,
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run );
-
-void test_host_explicit( comm::Machine machine ,
-                         size_t gang_count ,
-                         size_t gang_worker_count ,
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run );
-
-void test_host_nonlinear( comm::Machine machine ,
-                          size_t gang_count ,
-                          size_t gang_worker_count ,
-                          size_t elem_count_begin ,
-                          size_t elem_count_end ,
-                          size_t count_run );
-
-void test_host_nonlinear_quadratic( comm::Machine machine ,
-                                    size_t gang_count ,
-                                    size_t gang_worker_count ,
-                                    size_t elem_count_begin ,
-                                    size_t elem_count_end ,
-                                    size_t count_run );
-
-
-//----------------------------------------------------------------------------
-
-void test_cuda_query( comm::Machine );
-
-void test_cuda_fixture( comm::Machine machine ,
-                        size_t nx , size_t ny , size_t nz );
-
-void test_cuda_implicit( comm::Machine machine ,
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run );
-
-void test_cuda_explicit( comm::Machine machine ,
-                         size_t elem_count_begin ,
-                         size_t elem_count_end ,
-                         size_t count_run );
-
-void test_cuda_nonlinear( comm:: Machine machine ,
-                          size_t elem_count_begin ,
-                          size_t elem_count_end ,
-                          size_t count_run );
-
-void test_cuda_nonlinear_quadratic( comm::Machine machine ,
-                                    size_t elem_count_begin ,
-                                    size_t elem_count_end ,
-                                    size_t count_run );
-
-
-//----------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace {
-
-bool run_host( std::istream & input ,
-               comm::Machine machine ,
-               const size_t host_gang_count ,
-               const size_t host_gang_worker_count )
-{
-  bool cmd_error = false ;
-
-  std::string which ; input >> which ;
-
-  if ( which == std::string("fixture") ) {
-
-    size_t nx = 0 , ny = 0 , nz = 0 ;
-    input >> nx >> ny >> nz ;
-    test_host_fixture( machine , host_gang_count , host_gang_worker_count , nx , ny , nz );
-
-  }
-  else if ( which == std::string("explicit") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_host_explicit( machine , host_gang_count , host_gang_worker_count , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else if ( which == std::string("implicit") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_host_implicit( machine , host_gang_count , host_gang_worker_count , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else if ( which == std::string("nonlinear") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_host_nonlinear( machine , host_gang_count , host_gang_worker_count , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else if ( which == std::string("nonlinear_quadratic") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_host_nonlinear_quadratic( machine , host_gang_count , host_gang_worker_count , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else {
-    cmd_error = true ;
-  }
-
-  return cmd_error ;
-}
-
-#if defined( KOKKOS_ENABLE_CUDA )
-bool run_cuda( std::istream & input , comm::Machine machine )
-{
-  bool cmd_error = false ;
-
-  std::string which ; input >> which ;
-
-  if ( which == std::string("fixture") ) {
-
-    size_t nx = 0 , ny = 0 , nz = 0 ;
-    input >> nx >> ny >> nz ;
-    test_cuda_fixture( machine , nx , ny , nz );
-
-  }
-  else if ( which == std::string("explicit") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_cuda_explicit( machine , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else if ( which == std::string("implicit") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_cuda_implicit( machine , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else if ( which == std::string("nonlinear") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_cuda_nonlinear( machine , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else if ( which == std::string("nonlinear_quadratic") ) {
-
-    size_t mesh_node_begin = 100 ;
-    size_t mesh_node_end   = 300 ;
-    size_t run             =   1 ;
-    input >> mesh_node_begin >> mesh_node_end >> run ;
-    test_cuda_nonlinear_quadratic( machine , mesh_node_begin , mesh_node_end , run );
-
-  }
-  else {
-    cmd_error = true ;
-  }
-
-  return cmd_error ;
-}
-#endif
-
-void run( const std::string & argline , comm::Machine machine )
-{
-  const unsigned numa_count       = Kokkos::hwloc::get_available_numa_count();
-  const unsigned cores_per_numa   = Kokkos::hwloc::get_available_cores_per_numa();
-  const unsigned threads_per_core = Kokkos::hwloc::get_available_threads_per_core();
-
-  std::istringstream input( argline );
-
-  bool cmd_error = false ;
-
-  std::string which ; input >> which ;
-
-  if ( which == std::string("query") ) {
-    std::cout << "P" << comm::rank( machine )
-              << ": hwloc { NUMA[" << numa_count << "]"
-              << " CORE[" << cores_per_numa << "]"
-              << " PU[" << threads_per_core << "] }"
-              << std::endl ;
-#if defined( KOKKOS_ENABLE_CUDA )
-    test_cuda_query( machine );
-#endif
-  }
-  else if ( which == std::string("partition") ) {
-    if ( 0 == comm::rank( machine ) ) {
-      test_box_partition( false /* print flag */ );
-    }
-  }
-  else {
-    if ( which == std::string("host") ) {
-      size_t host_gang_count = 0 ;
-      size_t host_gang_worker_count = 1 ;
-
-      input >> host_gang_count ;
-      input >> host_gang_worker_count ;
-
-      cmd_error = run_host( input , machine , host_gang_count , host_gang_worker_count );
-    }
-    else if ( which == std::string("host-all") ) {
-      size_t host_gang_count        = numa_count ;
-      size_t host_gang_worker_count = cores_per_numa * threads_per_core ;
-
-      cmd_error = run_host( input , machine , host_gang_count , host_gang_worker_count );
-    }
-    else if ( which == std::string("host-most") ) {
-      size_t host_gang_count        = numa_count ;
-      size_t host_gang_worker_count = ( cores_per_numa - 1 ) * threads_per_core ;
-
-      cmd_error = run_host( input , machine , host_gang_count , host_gang_worker_count );
-    }
-#if defined( KOKKOS_ENABLE_CUDA )
-    else if ( which == std::string("cuda") ) {
-      cmd_error = run_cuda( input , machine );
-    }
-#endif
-    else {
-      cmd_error = true ;
-    }
-  }
-
-  if ( cmd_error && 0 == comm::rank( machine ) ) {
-    std::cout << "Expecting command line with" << std::endl
-              << "    query" << std::endl
-              << "    partition" << std::endl
-              << "    host NumNumaNode NumThreadPerNode <test>" << std::endl
-              << "    host-all <test>" << std::endl
-              << "    host-most <test>" << std::endl
-              << "    cuda <test>" << std::endl
-              << "where <test> is" << std::endl
-              << "    fixture   NumElemX NumElemY NumElemZ" << std::endl
-              << "    implicit  NumElemBegin NumElemEnd NumRun" << std::endl
-              << "    explicit  NumElemBegin NumElemEnd NumRun" << std::endl
-              << "    nonlinear NumElemBegin NumElemEnd NumRun" << std::endl
-              << "    nonlinear_quadratic NumElemBegin NumElemEnd NumRun" << std::endl ;
-
-  }
-}
-
-} // namespace
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-int main( int argc , char ** argv )
-{
-  comm::Machine machine = comm::Machine::init( & argc , & argv );
-
-  const unsigned comm_rank = comm::rank( machine );
-
-  const std::string argline = comm::command_line( machine , argc , argv );
-
-  try {
-    run( argline , machine );
-  }
-  catch( const std::exception & x ) {
-    std::cerr << "P" << comm_rank << " throw: " << x.what() << std::endl ;
-  }
-  catch( ... ) {
-    std::cerr << "P" << comm_rank << " throw: unknown exception" << std::endl ;
-  }
-
-  comm::Machine::finalize();
-
-  return 0 ;
-}
-
diff --git a/lib/kokkos/example/query_device/CMakeLists.txt b/lib/kokkos/example/query_device/CMakeLists.txt
index dade7f01fef5c935ab3e11bcffc5722ed4b9d1d5..86956ba3ba4855d0e769d92fd32e7b225c603157 100644
--- a/lib/kokkos/example/query_device/CMakeLists.txt
+++ b/lib/kokkos/example/query_device/CMakeLists.txt
@@ -1,14 +1,12 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 SET(SOURCES "")
-
 FILE(GLOB SOURCES *.cpp)
 
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   query_device
   SOURCES ${SOURCES}
-  COMM serial mpi
-  )
+)
 
diff --git a/lib/kokkos/example/query_device/query_device.cpp b/lib/kokkos/example/query_device/query_device.cpp
index 7dd2e0c7ebdc5bb7d5c2db8856213a792a5a526b..0ce7fc9eca9d79b21fa20afd3b458e6fa6aa3085 100644
--- a/lib/kokkos/example/query_device/query_device.cpp
+++ b/lib/kokkos/example/query_device/query_device.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -46,7 +47,7 @@
 
 #include <Kokkos_Macros.hpp>
 
-#if defined( KOKKOS_ENABLE_MPI )
+#if defined(KOKKOS_ENABLE_MPI)
 #include <mpi.h>
 #endif
 
@@ -55,46 +56,43 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-int main( int argc , char ** argv )
-{
-  std::ostringstream msg ;
+int main(int argc, char** argv) {
+  std::ostringstream msg;
 
-#if defined( KOKKOS_ENABLE_MPI )
+#if defined(KOKKOS_ENABLE_MPI)
 
-  MPI_Init( & argc , & argv );
+  MPI_Init(&argc, &argv);
 
-  int mpi_rank = 0 ;
+  int mpi_rank = 0;
 
-  MPI_Comm_rank( MPI_COMM_WORLD , & mpi_rank );
+  MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
-  msg << "MPI rank(" << mpi_rank << ") " ;
+  msg << "MPI rank(" << mpi_rank << ") ";
 
 #endif
 
-  msg << "{" << std::endl ;
+  msg << "{" << std::endl;
 
-  if ( Kokkos::hwloc::available() ) {
+  if (Kokkos::hwloc::available()) {
     msg << "hwloc( NUMA[" << Kokkos::hwloc::get_available_numa_count()
-        << "] x CORE["    << Kokkos::hwloc::get_available_cores_per_numa()
-        << "] x HT["      << Kokkos::hwloc::get_available_threads_per_core()
-        << "] )"
-        << std::endl ;
+        << "] x CORE[" << Kokkos::hwloc::get_available_cores_per_numa()
+        << "] x HT[" << Kokkos::hwloc::get_available_threads_per_core() << "] )"
+        << std::endl;
   }
 
-#if defined( KOKKOS_ENABLE_CUDA )
-  Kokkos::Cuda::print_configuration( msg );
+#if defined(KOKKOS_ENABLE_CUDA)
+  Kokkos::Cuda::print_configuration(msg);
 #endif
 
-  msg << "}" << std::endl ;
+  msg << "}" << std::endl;
 
   std::cout << msg.str();
 
-#if defined( KOKKOS_ENABLE_MPI )
+#if defined(KOKKOS_ENABLE_MPI)
 
   MPI_Finalize();
 
 #endif
 
-  return 0 ;
+  return 0;
 }
-
diff --git a/lib/kokkos/example/sort_array/CMakeLists.txt b/lib/kokkos/example/sort_array/CMakeLists.txt
deleted file mode 100644
index 0c7da74f4a9b94dbcdb2a2dc5d192203a319b048..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/sort_array/CMakeLists.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-SET(SOURCES "")
-
-FILE(GLOB SOURCES *.cpp)
-
-TRIBITS_ADD_EXECUTABLE(
-  sort_array
-  SOURCES ${SOURCES}
-  COMM serial mpi
-  )
-
diff --git a/lib/kokkos/example/sort_array/Makefile b/lib/kokkos/example/sort_array/Makefile
deleted file mode 100644
index 42b376ec7c5cf73537bf2d49340ce1ca963e3ad1..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/sort_array/Makefile
+++ /dev/null
@@ -1,46 +0,0 @@
-KOKKOS_PATH ?= ../..
-
-MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
-SRC_DIR := $(dir $(MAKEFILE_PATH))
-
-SRC = $(wildcard $(SRC_DIR)/*.cpp)
-OBJ = $(SRC:$(SRC_DIR)/%.cpp=%.o)
-
-#SRC = $(wildcard *.cpp)
-#OBJ = $(SRC:%.cpp=%.o)
-
-default: build
-	echo "Start Build"
-
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-  CXX = $(KOKKOS_PATH)/bin/nvcc_wrapper
-  EXE = $(addsuffix .cuda, $(shell basename $(SRC_DIR)))
-else
-  CXX = g++
-  EXE = $(addsuffix .host, $(shell basename $(SRC_DIR)))
-endif
-
-CXXFLAGS = -O3 -I$(SRC_DIR)
-LINK ?= $(CXX)
-LDFLAGS ?=
-
-include $(KOKKOS_PATH)/Makefile.kokkos
-
-DEPFLAGS = -M
-
-LIB =
-
-
-build: $(EXE)
-
-$(EXE): $(OBJ) $(KOKKOS_LINK_DEPENDS)
-	$(LINK) $(KOKKOS_LDFLAGS) $(LINKFLAGS) $(EXTRA_PATH) $(OBJ) $(KOKKOS_LIBS) $(LIB) -o $(EXE)
-
-clean: 
-	rm -f *.a *.o *.cuda *.host
-
-# Compilation rules
-
-%.o:$(SRC_DIR)/%.cpp $(KOKKOS_CPP_DEPENDS)
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) $(EXTRA_INC) -c $<
-
diff --git a/lib/kokkos/example/sort_array/main.cpp b/lib/kokkos/example/sort_array/main.cpp
deleted file mode 100644
index 331b2ef62d9619799308699d6a1c2c36477a8773..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/sort_array/main.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include <cstring>
-#include <cstdlib>
-#include <iostream>
-#include <sstream>
-
-#include <Kokkos_Core.hpp>
-
-#include <sort_array.hpp>
-
-
-int main( int argc , char ** argv )
-{
-#if defined( KOKKOS_ENABLE_CUDA ) || defined( KOKKOS_ENABLE_THREADS ) || defined( KOKKOS_ENABLE_OPENMP )
-  Kokkos::initialize( argc , argv );
-
-  int length_array = 100000 ;
-
-  for ( int i = 0 ; i < argc ; ++i ) {
-    if ( 0 == strcmp( argv[i] , "length_array" ) ) {
-      length_array = atoi( argv[i+1] );
-    }
-  }
-
-  int length_total_array  = length_array * 100;
-
-#if defined( KOKKOS_ENABLE_CUDA )
-  if ( Kokkos::Cuda::is_initialized() ) {
-    std::cout << "Kokkos::Cuda" << std::endl ;
-    Example::sort_array< Kokkos::Cuda >( length_array , length_total_array );
-  }
-#endif
-
-#if defined( KOKKOS_ENABLE_THREADS )
-  if ( Kokkos::Threads::is_initialized() ) {
-    std::cout << "Kokkos::Threads" << std::endl ;
-    Example::sort_array< Kokkos::Threads >( length_array , length_total_array );
-  }
-#endif
-
-#if defined( KOKKOS_ENABLE_OPENMP )
-  if ( Kokkos::OpenMP::is_initialized() ) {
-    std::cout << "Kokkos::OpenMP" << std::endl ;
-    Example::sort_array< Kokkos::OpenMP >( length_array , length_total_array );
-  }
-#endif
-
-  Kokkos::finalize();
-#endif
-
-  return 0 ;
-}
-
diff --git a/lib/kokkos/example/sort_array/sort_array.hpp b/lib/kokkos/example/sort_array/sort_array.hpp
deleted file mode 100644
index ae045b61af434d6f5cb9e64a71a10948b54fbd20..0000000000000000000000000000000000000000
--- a/lib/kokkos/example/sort_array/sort_array.hpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#ifndef EXAMPLE_SORT_ARRAY
-#define EXAMPLE_SORT_ARRAY
-
-#include <cstdlib>
-#include <algorithm>
-
-#include <Kokkos_Core.hpp>
-
-#include <impl/Kokkos_Timer.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Example {
-
-template< class Device >
-struct SortView {
-
-  template< typename ValueType >
-  SortView( const Kokkos::View<ValueType*,Device> v , int begin , int end )
-    {
-      std::sort( v.ptr_on_device() + begin , v.ptr_on_device() + end );
-    }
-};
-
-}
-
-#if defined(KOKKOS_ENABLE_CUDA)
-
-#include <thrust/device_ptr.h>
-#include <thrust/sort.h>
-
-namespace Example {
-
-template<>
-struct SortView< Kokkos::Cuda > {
-  template< typename ValueType >
-  SortView( const Kokkos::View<ValueType*,Kokkos::Cuda> v , int begin , int end )
-    {
-      thrust::sort( thrust::device_ptr<ValueType>( v.ptr_on_device() + begin )
-                  , thrust::device_ptr<ValueType>( v.ptr_on_device() + end ) );
-    }
-};
-
-}
-
-#endif
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Example {
-
-template< class Device >
-void sort_array( const size_t array_length /* length of spans of array to sort */
-               , const size_t total_length /* total length of array */
-               , const int print = 1 )
-{
-  typedef Device execution_space ;
-  typedef Kokkos::View<int*,Device>  device_array_type ;
-
-#if defined( KOKKOS_ENABLE_CUDA )
-
-  typedef typename
-    Kokkos::Impl::if_c< std::is_same< Device , Kokkos::Cuda >::value
-                      , Kokkos::View<int*,Kokkos::Cuda::array_layout,Kokkos::CudaHostPinnedSpace>
-                      , typename device_array_type::HostMirror
-                      >::type  host_array_type ;
-
-#else
-
-  typedef typename device_array_type::HostMirror  host_array_type ;
-
-#endif
-
-  Kokkos::Timer timer;
-
-  const device_array_type  work_array("work_array" , array_length );
-  const host_array_type    host_array("host_array" , total_length );
-
-  std::cout << "sort_array length( " << total_length << " )"
-            << " in chunks( " << array_length << " )"
-            << std::endl ;
-
-  double sec = timer.seconds();
-  std::cout << "declaring Views took "
-            << sec << " seconds" << std::endl;
-  timer.reset();
-
-  for ( size_t i = 0 ; i < total_length ; ++i ) {
-    host_array(i) = ( lrand48() * total_length ) >> 31 ;
-  }
-
-  sec = timer.seconds();
-  std::cout << "initializing " << total_length << " elements on host took "
-            << sec << " seconds" << std::endl;
-  timer.reset();
-
-  double sec_copy_in  = 0 ;
-  double sec_sort     = 0 ;
-  double sec_copy_out = 0 ;
-  double sec_error    = 0 ;
-  size_t error_count  = 0 ;
-
-  for ( size_t begin = 0 ; begin < total_length ; begin += array_length ) {
-
-    const size_t end = begin + array_length < total_length
-                     ? begin + array_length : total_length ;
-
-    const std::pair<size_t,size_t> host_range(begin,end);
-
-    const host_array_type host_subarray = Kokkos::subview( host_array , host_range );
-
-    timer.reset();
-
-    Kokkos::deep_copy( work_array , host_subarray );
-
-    sec_copy_in += timer.seconds(); timer.reset();
-
-    SortView< execution_space >( work_array , 0 , end - begin );
-
-    sec_sort += timer.seconds(); timer.reset();
-
-    Kokkos::deep_copy( host_subarray , work_array );
-
-    sec_copy_out += timer.seconds(); timer.reset();
-
-    for ( size_t i = begin + 1 ; i < end ; ++i ) {
-      if ( host_array(i) < host_array(i-1) ) ++error_count ;
-    }
-
-    sec_error += timer.seconds(); timer.reset();
-  }
-
-  std::cout << "copy to   device " << sec_copy_in  << " seconds" << std::endl
-            << "sort on   device " << sec_sort     << " seconds" << std::endl
-            << "copy from device " << sec_copy_out << " seconds" << std::endl
-            << "errors " << error_count << " took " << sec_error << " seconds" << std::endl
-            ;
-}
-
-} // namespace Example
-
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef EXAMPLE_SORT_ARRAY */
-
diff --git a/lib/kokkos/example/tutorial/01_hello_world/CMakeLists.txt b/lib/kokkos/example/tutorial/01_hello_world/CMakeLists.txt
index 5e5b1fcb46ffbdcb7dacf3bcb6627fa90c7a1157..e1b90b133ddec1dc8a848a9ab8d2253980edd301 100644
--- a/lib/kokkos/example/tutorial/01_hello_world/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/01_hello_world/CMakeLists.txt
@@ -1,11 +1,10 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_01_hello_world
   SOURCES hello_world.cpp
-  COMM serial mpi
-  )
+)
 
diff --git a/lib/kokkos/example/tutorial/01_hello_world/hello_world.cpp b/lib/kokkos/example/tutorial/01_hello_world/hello_world.cpp
index 3092b5a5746f08429ffa28304569552322754c66..00adbc78bc47a34e0911abdd5095b01aa28b6402 100644
--- a/lib/kokkos/example/tutorial/01_hello_world/hello_world.cpp
+++ b/lib/kokkos/example/tutorial/01_hello_world/hello_world.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -84,12 +85,10 @@ struct hello_world {
   // (as well as on the host).  If not building with CUDA, the macro
   // is unnecessary but harmless.
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i) const {
-    printf ("Hello from i = %i\n", i);
-  }
+  void operator()(const int i) const { printf("Hello from i = %i\n", i); }
 };
 
-int main (int argc, char* argv[]) {
+int main(int argc, char* argv[]) {
   // You must call initialize() before you may call Kokkos.
   //
   // With no arguments, this initializes the default execution space
@@ -97,13 +96,13 @@ int main (int argc, char* argv[]) {
   // parameters.  You may also pass in argc and argv, analogously to
   // MPI_Init().  It reads and removes command-line arguments that
   // start with "--kokkos-".
-  Kokkos::initialize (argc, argv);
+  Kokkos::initialize(argc, argv);
 
   // Print the name of Kokkos' default execution space.  We're using
   // typeid here, so the name might get a bit mangled by the linker,
   // but you should still be able to figure out what it is.
-  printf ("Hello World on Kokkos execution space %s\n",
-          typeid (Kokkos::DefaultExecutionSpace).name ());
+  printf("Hello World on Kokkos execution space %s\n",
+         typeid(Kokkos::DefaultExecutionSpace).name());
 
   // Run the above functor on the default Kokkos execution space in
   // parallel, with a parallel for loop count of 15.
@@ -122,9 +121,8 @@ int main (int argc, char* argv[]) {
   //
   // You may notice that the printed numbers do not print out in
   // order.  Parallel for loops may execute in any order.
-  Kokkos::parallel_for ("HelloWorld",15, hello_world ());
+  Kokkos::parallel_for("HelloWorld", 15, hello_world());
 
   // You must call finalize() after you are done using Kokkos.
-  Kokkos::finalize ();
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/01_hello_world_lambda/CMakeLists.txt b/lib/kokkos/example/tutorial/01_hello_world_lambda/CMakeLists.txt
index 3fcca4bceba577bf644f1929e1c62c1893b5d5a5..a939a5f0ded6d2953af557e6c62fe783ba7b559e 100644
--- a/lib/kokkos/example/tutorial/01_hello_world_lambda/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/01_hello_world_lambda/CMakeLists.txt
@@ -1,13 +1,10 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
-IF (Kokkos_ENABLE_CXX11)
-  # This is a tutorial, not a test, so we don't ask CTest to run it.
-  TRIBITS_ADD_EXECUTABLE(
-    tutorial_01_hello_world_lambda
-    SOURCES hello_world_lambda.cpp
-    COMM serial mpi
-    )
-ENDIF ()
+# This is a tutorial, not a test, so we don't ask CTest to run it.
+KOKKOS_ADD_EXECUTABLE(
+  tutorial_01_hello_world_lambda
+  SOURCES hello_world_lambda.cpp
+)
 
diff --git a/lib/kokkos/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp b/lib/kokkos/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp
index a304a0f3ab24059df0b1ced8c4ae4a2053a28bf5..c3bd00e7d40adbfd808643e939d58647a346b3b0 100644
--- a/lib/kokkos/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp
+++ b/lib/kokkos/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -58,7 +59,7 @@
 // lambdas have their places.
 //
 
-int main (int argc, char* argv[]) {
+int main(int argc, char* argv[]) {
   // You must call initialize() before you may call Kokkos.
   //
   // With no arguments, this initializes the default execution space
@@ -66,13 +67,13 @@ int main (int argc, char* argv[]) {
   // parameters.  You may also pass in argc and argv, analogously to
   // MPI_Init().  It reads and removes command-line arguments that
   // start with "--kokkos-".
-  Kokkos::initialize (argc, argv);
+  Kokkos::initialize(argc, argv);
 
   // Print the name of Kokkos' default execution space.  We're using
   // typeid here, so the name might get a bit mangled by the linker,
   // but you should still be able to figure out what it is.
-  printf ("Hello World on Kokkos execution space %s\n",
-          typeid (Kokkos::DefaultExecutionSpace).name ());
+  printf("Hello World on Kokkos execution space %s\n",
+         typeid(Kokkos::DefaultExecutionSpace).name());
 
   // Run lambda on the default Kokkos execution space in parallel,
   // with a parallel for loop count of 15.  The lambda's argument is
@@ -101,12 +102,12 @@ int main (int argc, char* argv[]) {
   // We also need to protect the usage of a lambda against compiling
   // with a backend which doesn't support it (i.e. Cuda 6.5/7.0).
 #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-  Kokkos::parallel_for (15, KOKKOS_LAMBDA (const int i) {
-      // printf works in a CUDA parallel kernel; std::ostream does not.
-      printf ("Hello from i = %i\n", i);
-    });
+  Kokkos::parallel_for(
+      15, KOKKOS_LAMBDA(const int i) {
+        // printf works in a CUDA parallel kernel; std::ostream does not.
+        printf("Hello from i = %i\n", i);
+      });
 #endif
   // You must call finalize() after you are done using Kokkos.
-  Kokkos::finalize ();
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/02_simple_reduce/CMakeLists.txt b/lib/kokkos/example/tutorial/02_simple_reduce/CMakeLists.txt
index 7c78db840f849fd9625676c6a73e8aa037b52b4d..21b0c38014b4cd923d9c8ecea07ed645a2775c6e 100644
--- a/lib/kokkos/example/tutorial/02_simple_reduce/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/02_simple_reduce/CMakeLists.txt
@@ -1,10 +1,9 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_02_simple_reduce
   SOURCES simple_reduce.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/02_simple_reduce/simple_reduce.cpp b/lib/kokkos/example/tutorial/02_simple_reduce/simple_reduce.cpp
index 04a3cfb9a02097a483086ca0a9d9e3de90a58e52..01abd3d3bfac03191583698f2d4ee41067743c16 100644
--- a/lib/kokkos/example/tutorial/02_simple_reduce/simple_reduce.cpp
+++ b/lib/kokkos/example/tutorial/02_simple_reduce/simple_reduce.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -72,30 +73,33 @@ struct squaresum {
   // (If the reduction type is an array like int[], indicating an
   // array reduction result, then the second argument is just int[].)
   KOKKOS_INLINE_FUNCTION
-  void operator () (const int i, int& lsum) const {
-    lsum += i*i; // compute the sum of squares
+  void operator()(const int i, int& lsum) const {
+    lsum += i * i;  // compute the sum of squares
   }
 };
 
-int main (int argc, char* argv[]) {
-  Kokkos::initialize (argc, argv);
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
   const int n = 10;
 
   // Compute the sum of squares of integers from 0 to n-1, in
   // parallel, using Kokkos.
   int sum = 0;
-  Kokkos::parallel_reduce (n, squaresum (), sum);
-  printf ("Sum of squares of integers from 0 to %i, "
-          "computed in parallel, is %i\n", n - 1, sum);
+  Kokkos::parallel_reduce(n, squaresum(), sum);
+  printf(
+      "Sum of squares of integers from 0 to %i, "
+      "computed in parallel, is %i\n",
+      n - 1, sum);
 
   // Compare to a sequential loop.
   int seqSum = 0;
   for (int i = 0; i < n; ++i) {
-    seqSum += i*i;
+    seqSum += i * i;
   }
-  printf ("Sum of squares of integers from 0 to %i, "
-          "computed sequentially, is %i\n", n - 1, seqSum);
-  Kokkos::finalize ();
+  printf(
+      "Sum of squares of integers from 0 to %i, "
+      "computed sequentially, is %i\n",
+      n - 1, seqSum);
+  Kokkos::finalize();
   return (sum == seqSum) ? 0 : -1;
 }
-
diff --git a/lib/kokkos/example/tutorial/02_simple_reduce_lambda/CMakeLists.txt b/lib/kokkos/example/tutorial/02_simple_reduce_lambda/CMakeLists.txt
index e2e3a929f1ade97ce639670a3f28c43bb9ce084f..82a87be4bdc46baec421c0363a1481e1ae07e001 100644
--- a/lib/kokkos/example/tutorial/02_simple_reduce_lambda/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/02_simple_reduce_lambda/CMakeLists.txt
@@ -1,12 +1,9 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+
+KOKKOS_ADD_EXECUTABLE(
+  tutorial_02_simple_reduce_lambda
+  SOURCES simple_reduce_lambda.cpp
+)
 
-IF (Kokkos_ENABLE_CXX11)
-  # This is a tutorial, not a test, so we don't ask CTest to run it.
-  TRIBITS_ADD_EXECUTABLE(
-    tutorial_02_simple_reduce_lambda
-    SOURCES simple_reduce_lambda.cpp
-    COMM serial mpi
-    )
-ENDIF ()
diff --git a/lib/kokkos/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp b/lib/kokkos/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp
index 8ed5d8f62dfb49400cf28d529c8907c7f653b298..7f4c356e0ce90896f709922cc10556a6fa08cd04 100644
--- a/lib/kokkos/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp
+++ b/lib/kokkos/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -56,8 +57,8 @@
 // of the parallel_reduce.
 //
 
-int main (int argc, char* argv[]) {
-  Kokkos::initialize (argc, argv);
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
   const int n = 10;
 
   // Compute the sum of squares of integers from 0 to n-1, in
@@ -65,30 +66,32 @@ int main (int argc, char* argv[]) {
   // functor.  The lambda takes the same arguments as the functor's
   // operator().
   int sum = 0;
-  // The KOKKOS_LAMBDA macro replaces the capture-by-value clause [=].
-  // It also handles any other syntax needed for CUDA.
-  // We also need to protect the usage of a lambda against compiling
-  // with a backend which doesn't support it (i.e. Cuda 6.5/7.0).
-  #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-  Kokkos::parallel_reduce (n, KOKKOS_LAMBDA (const int i, int& lsum) {
-      lsum += i*i;
-    }, sum);
-  #endif
-  printf ("Sum of squares of integers from 0 to %i, "
-          "computed in parallel, is %i\n", n - 1, sum);
+// The KOKKOS_LAMBDA macro replaces the capture-by-value clause [=].
+// It also handles any other syntax needed for CUDA.
+// We also need to protect the usage of a lambda against compiling
+// with a backend which doesn't support it (i.e. Cuda 6.5/7.0).
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+  Kokkos::parallel_reduce(
+      n, KOKKOS_LAMBDA(const int i, int& lsum) { lsum += i * i; }, sum);
+#endif
+  printf(
+      "Sum of squares of integers from 0 to %i, "
+      "computed in parallel, is %i\n",
+      n - 1, sum);
 
   // Compare to a sequential loop.
   int seqSum = 0;
   for (int i = 0; i < n; ++i) {
-    seqSum += i*i;
+    seqSum += i * i;
   }
-  printf ("Sum of squares of integers from 0 to %i, "
-          "computed sequentially, is %i\n", n - 1, seqSum);
-  Kokkos::finalize ();
+  printf(
+      "Sum of squares of integers from 0 to %i, "
+      "computed sequentially, is %i\n",
+      n - 1, seqSum);
+  Kokkos::finalize();
 #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
   return (sum == seqSum) ? 0 : -1;
 #else
   return 0;
 #endif
 }
-
diff --git a/lib/kokkos/example/tutorial/03_simple_view/CMakeLists.txt b/lib/kokkos/example/tutorial/03_simple_view/CMakeLists.txt
index 7475a99e492bcf88c6a3ca9b98cc698fa9a38b3d..99a7d39c17ad35dc82eaddbe7fe60f8df15544f6 100644
--- a/lib/kokkos/example/tutorial/03_simple_view/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/03_simple_view/CMakeLists.txt
@@ -1,10 +1,9 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_03_simple_view
   SOURCES simple_view.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/03_simple_view/simple_view.cpp b/lib/kokkos/example/tutorial/03_simple_view/simple_view.cpp
index de4b4ffd588634da18422b1c1ef40d12280da5f9..f4924c71fa9c6040555f68074cc30c8a5d806b96 100644
--- a/lib/kokkos/example/tutorial/03_simple_view/simple_view.cpp
+++ b/lib/kokkos/example/tutorial/03_simple_view/simple_view.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -66,7 +67,7 @@
 //
 // The first dimension of the View is the dimension over which it is
 // efficient for Kokkos to parallelize.
-typedef Kokkos::View<double*[3]> view_type;
+typedef Kokkos::View<double * [3]> view_type;
 
 // parallel_for functor that fills the View given to its constructor.
 // The View must already have been allocated.
@@ -78,20 +79,18 @@ struct InitView {
   // operator= only do shallow copies.  Thus, you can pass View
   // objects around by "value"; they won't do a deep copy unless you
   // explicitly ask for a deep copy.
-  InitView (view_type a_) :
-    a (a_)
-  {}
+  InitView(view_type a_) : a(a_) {}
 
   // Fill the View with some data.  The parallel_for loop will iterate
   // over the View's first dimension N.
   KOKKOS_INLINE_FUNCTION
-  void operator () (const int i) const {
+  void operator()(const int i) const {
     // Acesss the View just like a Fortran array.  The layout depends
     // on the View's memory space, so don't rely on the View's
     // physical memory layout unless you know what you're doing.
-    a(i,0) = 1.0*i;
-    a(i,1) = 1.0*i*i;
-    a(i,2) = 1.0*i*i*i;
+    a(i, 0) = 1.0 * i;
+    a(i, 1) = 1.0 * i * i;
+    a(i, 2) = 1.0 * i * i * i;
   }
 };
 
@@ -100,20 +99,20 @@ struct ReduceFunctor {
   view_type a;
 
   // Constructor takes View by "value"; this does a shallow copy.
-  ReduceFunctor (view_type a_) : a (a_) {}
+  ReduceFunctor(view_type a_) : a(a_) {}
 
   // If you write a functor to do a reduction, you must specify the
   // type of the reduction result via a public 'value_type' typedef.
   typedef double value_type;
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i, double &lsum) const {
-    lsum += a(i,0)*a(i,1)/(a(i,2)+0.1);
+  void operator()(int i, double& lsum) const {
+    lsum += a(i, 0) * a(i, 1) / (a(i, 2) + 0.1);
   }
 };
 
-int main (int argc, char* argv[]) {
-  Kokkos::initialize (argc, argv);
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
   {
     const int N = 10;
 
@@ -132,13 +131,12 @@ int main (int argc, char* argv[]) {
     //
     // The string "A" is just the label; it only matters for debugging.
     // Different Views may have the same label.
-    view_type a ("A", N);
+    view_type a("A", N);
 
-    Kokkos::parallel_for (N, InitView (a));
+    Kokkos::parallel_for(N, InitView(a));
     double sum = 0;
-    Kokkos::parallel_reduce (N, ReduceFunctor (a), sum);
-    printf ("Result: %f\n", sum);
-  } // use this scope to ensure the lifetime of "A" ends before finalize
-  Kokkos::finalize ();
+    Kokkos::parallel_reduce(N, ReduceFunctor(a), sum);
+    printf("Result: %f\n", sum);
+  }  // use this scope to ensure the lifetime of "A" ends before finalize
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/03_simple_view_lambda/CMakeLists.txt b/lib/kokkos/example/tutorial/03_simple_view_lambda/CMakeLists.txt
index 601fe452a4c90a1506aa012a6a99a617fbc1d9af..c0f33a61b9a9096602ba8ee51040b99ef9c6fceb 100644
--- a/lib/kokkos/example/tutorial/03_simple_view_lambda/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/03_simple_view_lambda/CMakeLists.txt
@@ -1,10 +1,10 @@
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 IF (Kokkos_ENABLE_CXX11)
   # This is a tutorial, not a test, so we don't ask CTest to run it.
-  TRIBITS_ADD_EXECUTABLE(
+  KOKKOS_ADD_EXECUTABLE(
     tutorial_03_simple_view_lambda
     SOURCES simple_view_lambda.cpp
     COMM serial mpi
diff --git a/lib/kokkos/example/tutorial/03_simple_view_lambda/simple_view_lambda.cpp b/lib/kokkos/example/tutorial/03_simple_view_lambda/simple_view_lambda.cpp
index 3faf73a65d1159d8fe4425945e19f01002a9ba2a..d5590e5ccd54d87c82b3dbab80a4cd362b73da52 100644
--- a/lib/kokkos/example/tutorial/03_simple_view_lambda/simple_view_lambda.cpp
+++ b/lib/kokkos/example/tutorial/03_simple_view_lambda/simple_view_lambda.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -65,10 +66,10 @@
 //
 // The first dimension of the View is the dimension over which it is
 // efficient for Kokkos to parallelize.
-typedef Kokkos::View<double*[3]> view_type;
+typedef Kokkos::View<double * [3]> view_type;
 
-int main (int argc, char* argv[]) {
-  Kokkos::initialize (argc, argv);
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
 
   {
     // Allocate the View.  The first dimension is a run-time parameter
@@ -86,37 +87,40 @@ int main (int argc, char* argv[]) {
     //
     // The string "A" is just the label; it only matters for debugging.
     // Different Views may have the same label.
-    view_type a ("A", 10);
+    view_type a("A", 10);
 
-    // Fill the View with some data.  The parallel_for loop will iterate
-    // over the View's first dimension N.
-    //
-    // Note that the View is passed by value into the lambda.  The macro
-    // KOKKOS_LAMBDA includes the "capture by value" clause [=].  This
-    // tells the lambda to "capture all variables in the enclosing scope
-    // by value."  Views have "view semantics"; they behave like
-    // pointers, not like std::vector.  Passing them by value does a
-    // shallow copy.  A deep copy never happens unless you explicitly
-    // ask for one.
-    // We also need to protect the usage of a lambda against compiling
-    // with a backend which doesn't support it (i.e. Cuda 6.5/7.0).
-    #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-    Kokkos::parallel_for (10, KOKKOS_LAMBDA (const int i) {
-      // Acesss the View just like a Fortran array.  The layout depends
-      // on the View's memory space, so don't rely on the View's
-      // physical memory layout unless you know what you're doing.
-      a(i,0) = 1.0*i;
-      a(i,1) = 1.0*i*i;
-      a(i,2) = 1.0*i*i*i;
-    });
+// Fill the View with some data.  The parallel_for loop will iterate
+// over the View's first dimension N.
+//
+// Note that the View is passed by value into the lambda.  The macro
+// KOKKOS_LAMBDA includes the "capture by value" clause [=].  This
+// tells the lambda to "capture all variables in the enclosing scope
+// by value."  Views have "view semantics"; they behave like
+// pointers, not like std::vector.  Passing them by value does a
+// shallow copy.  A deep copy never happens unless you explicitly
+// ask for one.
+// We also need to protect the usage of a lambda against compiling
+// with a backend which doesn't support it (i.e. Cuda 6.5/7.0).
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+    Kokkos::parallel_for(
+        10, KOKKOS_LAMBDA(const int i) {
+          // Acesss the View just like a Fortran array.  The layout depends
+          // on the View's memory space, so don't rely on the View's
+          // physical memory layout unless you know what you're doing.
+          a(i, 0) = 1.0 * i;
+          a(i, 1) = 1.0 * i * i;
+          a(i, 2) = 1.0 * i * i * i;
+        });
     // Reduction functor that reads the View given to its constructor.
     double sum = 0;
-    Kokkos::parallel_reduce (10, KOKKOS_LAMBDA (const int i, double& lsum) {
-      lsum += a(i,0)*a(i,1)/(a(i,2)+0.1);
-    }, sum);
-    printf ("Result: %f\n", sum);
-    #endif
+    Kokkos::parallel_reduce(
+        10,
+        KOKKOS_LAMBDA(const int i, double& lsum) {
+          lsum += a(i, 0) * a(i, 1) / (a(i, 2) + 0.1);
+        },
+        sum);
+    printf("Result: %f\n", sum);
+#endif
   }
-  Kokkos::finalize ();
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/04_simple_memoryspaces/CMakeLists.txt b/lib/kokkos/example/tutorial/04_simple_memoryspaces/CMakeLists.txt
index 09f209077a08d64c86454a59875ecda8d329e2f7..03fb97a133caf6039dd048cb0546f502457ddc34 100644
--- a/lib/kokkos/example/tutorial/04_simple_memoryspaces/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/04_simple_memoryspaces/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_04_simple_memoryspaces
   SOURCES simple_memoryspaces.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/04_simple_memoryspaces/simple_memoryspaces.cpp b/lib/kokkos/example/tutorial/04_simple_memoryspaces/simple_memoryspaces.cpp
index c909fbc23250ea9a6121e08670e8fec1b43fdca0..603d139df9ae9aa3bb21a4e58b1d40542f8933eb 100644
--- a/lib/kokkos/example/tutorial/04_simple_memoryspaces/simple_memoryspaces.cpp
+++ b/lib/kokkos/example/tutorial/04_simple_memoryspaces/simple_memoryspaces.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -46,7 +47,7 @@
 
 // The type of a two-dimensional N x 3 array of double.
 // It lives in Kokkos' default memory space.
-typedef Kokkos::View<double*[3]> view_type;
+typedef Kokkos::View<double * [3]> view_type;
 
 // The "HostMirror" type corresponding to view_type above is also a
 // two-dimensional N x 3 array of double.  However, it lives in the
@@ -64,12 +65,12 @@ typedef view_type::HostMirror host_view_type;
 
 struct ReduceFunctor {
   view_type a;
-  ReduceFunctor (view_type a_) : a (a_) {}
-  typedef int value_type; //Specify type for reduction value, lsum
+  ReduceFunctor(view_type a_) : a(a_) {}
+  typedef int value_type;  // Specify type for reduction value, lsum
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i, int &lsum) const {
-    lsum += a(i,0)-a(i,1)+a(i,2);
+  void operator()(int i, int &lsum) const {
+    lsum += a(i, 0) - a(i, 1) + a(i, 2);
   }
 };
 
@@ -77,27 +78,26 @@ int main() {
   Kokkos::initialize();
 
   {
-    view_type a ("A", 10);
+    view_type a("A", 10);
     // If view_type and host_mirror_type live in the same memory space,
     // a "mirror view" is just an alias, and deep_copy does nothing.
     // Otherwise, a mirror view of a device View lives in host memory,
     // and deep_copy does a deep copy.
-    host_view_type h_a = Kokkos::create_mirror_view (a);
+    host_view_type h_a = Kokkos::create_mirror_view(a);
 
     // The View h_a lives in host (CPU) memory, so it's legal to fill
     // the view sequentially using ordinary code, like this.
     for (int i = 0; i < 10; i++) {
       for (int j = 0; j < 3; j++) {
-        h_a(i,j) = i*10 + j;
+        h_a(i, j) = i * 10 + j;
       }
     }
-    Kokkos::deep_copy (a, h_a); // Copy from host to device.
+    Kokkos::deep_copy(a, h_a);  // Copy from host to device.
 
     int sum = 0;
-    Kokkos::parallel_reduce (10, ReduceFunctor (a), sum);
-    printf ("Result is %i\n",sum);
+    Kokkos::parallel_reduce(10, ReduceFunctor(a), sum);
+    printf("Result is %i\n", sum);
   }
 
-  Kokkos::finalize ();
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/05_simple_atomics/CMakeLists.txt b/lib/kokkos/example/tutorial/05_simple_atomics/CMakeLists.txt
index 5a5790fb0488be791112c3ef0c38655e6da78724..85870e5e504c1b74bfbccaa97e4b9f289d5a28c7 100644
--- a/lib/kokkos/example/tutorial/05_simple_atomics/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/05_simple_atomics/CMakeLists.txt
@@ -3,8 +3,8 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_05_simple_atomics
   SOURCES simple_atomics.cpp
-  COMM serial mpi
-  )
+)
+
diff --git a/lib/kokkos/example/tutorial/05_simple_atomics/simple_atomics.cpp b/lib/kokkos/example/tutorial/05_simple_atomics/simple_atomics.cpp
index 8dd2be5800ebd4925c4c74191a89a67aef45d59b..396b3968797f4440c0b328308f63deab630224e4 100644
--- a/lib/kokkos/example/tutorial/05_simple_atomics/simple_atomics.cpp
+++ b/lib/kokkos/example/tutorial/05_simple_atomics/simple_atomics.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -59,7 +60,6 @@ typedef view_type::HostMirror host_view_type;
 typedef Kokkos::View<int> count_type;
 typedef count_type::HostMirror host_count_type;
 
-
 // Functor for finding a list of primes in a given set of numbers.  If
 // run in parallel, the order of results is nondeterministic, because
 // hardware atomic updates do not guarantee an order of execution.
@@ -68,26 +68,25 @@ struct findprimes {
   view_type result;
   count_type count;
 
-  findprimes (view_type data_, view_type result_, count_type count_) :
-    data (data_), result (result_), count (count_)
-  {}
+  findprimes(view_type data_, view_type result_, count_type count_)
+      : data(data_), result(result_), count(count_) {}
 
   // Test if data(i) is prime.  If it is, increment the count of
   // primes (stored in the zero-dimensional View 'count') and add the
   // value to the current list of primes 'result'.
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i) const {
-    const int number = data(i); // the current number
+  void operator()(const int i) const {
+    const int number = data(i);  // the current number
 
     // Test all numbers from 3 to ceiling(sqrt(data(i))), to see if
     // they are factors of data(i).  It's not the most efficient prime
     // test, but it works.
-    const int upper_bound = std::sqrt(1.0*number)+1;
-    bool is_prime = !(number%2 == 0);
-    int k = 3;
+    const int upper_bound = std::sqrt(1.0 * number) + 1;
+    bool is_prime         = !(number % 2 == 0);
+    int k                 = 3;
     while (k < upper_bound && is_prime) {
-      is_prime = !(number%k == 0);
-      k += 2; // don't have to test even numbers
+      is_prime = !(number % k == 0);
+      k += 2;  // don't have to test even numbers
     }
 
     if (is_prime) {
@@ -98,42 +97,41 @@ struct findprimes {
       // atomic_fetch_add results the _current_ count, but increments
       // it (by 1 in this case).  The current count of primes indexes
       // into the first unoccupied position of the 'result' array.
-      const int idx = Kokkos::atomic_fetch_add (&count(), 1);
-      result(idx) = number;
+      const int idx = Kokkos::atomic_fetch_add(&count(), 1);
+      result(idx)   = number;
     }
   }
-
 };
 
-int main () {
-  Kokkos::initialize ();
+int main() {
+  Kokkos::initialize();
 
   {
-    srand (61391); // Set the random seed
+    srand(61391);  // Set the random seed
 
     int nnumbers = 100000;
-    view_type data ("RND", nnumbers);
-    view_type result ("Prime", nnumbers);
-    count_type count ("Count");
+    view_type data("RND", nnumbers);
+    view_type result("Prime", nnumbers);
+    count_type count("Count");
 
-    host_view_type h_data = Kokkos::create_mirror_view (data);
-    host_view_type h_result = Kokkos::create_mirror_view (result);
-    host_count_type h_count = Kokkos::create_mirror_view (count);
+    host_view_type h_data   = Kokkos::create_mirror_view(data);
+    host_view_type h_result = Kokkos::create_mirror_view(result);
+    host_count_type h_count = Kokkos::create_mirror_view(count);
 
     typedef view_type::size_type size_type;
     // Fill the 'data' array on the host with random numbers.  We assume
     // that they come from some process which is only implemented on the
     // host, via some library.  (That's true in this case.)
     for (size_type i = 0; i < data.extent(0); ++i) {
-      h_data(i) = rand () % nnumbers;
+      h_data(i) = rand() % nnumbers;
     }
-    Kokkos::deep_copy (data, h_data); // copy from host to device
+    Kokkos::deep_copy(data, h_data);  // copy from host to device
 
-    Kokkos::parallel_for (data.extent(0), findprimes (data, result, count));
-    Kokkos::deep_copy (h_count, count); // copy from device to host
+    Kokkos::parallel_for(data.extent(0), findprimes(data, result, count));
+    Kokkos::deep_copy(h_count, count);  // copy from device to host
 
-    printf ("Found %i prime numbers in %i random numbers\n", h_count(), nnumbers);
+    printf("Found %i prime numbers in %i random numbers\n", h_count(),
+           nnumbers);
   }
-  Kokkos::finalize ();
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/CMakeLists.txt b/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/CMakeLists.txt
index d18938a61f8b75db1c7cd4b5e9c42c4406429e89..ca9f0bf8da93f918cb07e825fb36f35c97619c11 100644
--- a/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/CMakeLists.txt
@@ -3,8 +3,8 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_06_simple_mdrangepolicy
   SOURCES simple_mdrangepolicy.cpp
-  COMM serial mpi
-  )
+)
+
diff --git a/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/simple_mdrangepolicy.cpp b/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/simple_mdrangepolicy.cpp
index 38cf00dd19409eb576e41481f95ffd11f5599fcb..62c087c32c65b90e6ce709886ba006b0f8ec27f3 100644
--- a/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/simple_mdrangepolicy.cpp
+++ b/lib/kokkos/example/tutorial/06_simple_mdrangepolicy/simple_mdrangepolicy.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -52,150 +53,163 @@
 //   3. Shut down Kokkos
 //
 // Two examples are provided:
-// Example 1: Rank 2 case with minimal default parameters and arguments used 
+// Example 1: Rank 2 case with minimal default parameters and arguments used
 //            in the MDRangePolicy
 //
 // Example 2: Rank 3 case with additional outer/inner iterate pattern parameters
 //            and tile dims passed to the ctor
 
-
 // Simple functor for computing/storing the product of indices in a View v
-template < class ViewType >
+template <class ViewType>
 struct MDFunctor {
-
   typedef long value_type;
 
   ViewType v;
-  size_t   size;
+  size_t size;
 
-  MDFunctor( const ViewType & v_, const size_t size_ )
-    : v(v_), size(size_) {}
+  MDFunctor(const ViewType& v_, const size_t size_) : v(v_), size(size_) {}
 
   // 2D case - used by parallel_for
   KOKKOS_INLINE_FUNCTION
-  void operator () (const int i, const int j) const {
-    v(i,j) = i*j; // compute the product of indices
+  void operator()(const int i, const int j) const {
+    v(i, j) = i * j;  // compute the product of indices
   }
 
   // 3D case - used by parallel_for
   KOKKOS_INLINE_FUNCTION
-  void operator () (const int i, const int j, const int k) const {
-    v(i,j,k) = i*j*k; // compute the product of indices
+  void operator()(const int i, const int j, const int k) const {
+    v(i, j, k) = i * j * k;  // compute the product of indices
   }
 
   // 2D case - reduction
   KOKKOS_INLINE_FUNCTION
-  void operator () (const int i, const int j, value_type & incorrect_count) const {
-    if ( v(i,j) != i*j ) {
+  void operator()(const int i, const int j, value_type& incorrect_count) const {
+    if (v(i, j) != i * j) {
       incorrect_count += 1;
     }
   }
 
   // 3D case - reduction
   KOKKOS_INLINE_FUNCTION
-  void operator () (const int i, const int j, const int k, value_type & incorrect_count) const {
-    if ( v(i,j,k) != i*j*k ) {
+  void operator()(const int i, const int j, const int k,
+                  value_type& incorrect_count) const {
+    if (v(i, j, k) != i * j * k) {
       incorrect_count += 1;
     }
   }
-
 };
 
-int main (int argc, char* argv[]) {
-  Kokkos::initialize (argc, argv);
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
 
-  // Bound(s) for MDRangePolicy 
+  // Bound(s) for MDRangePolicy
   const int n = 100;
 
   // ViewType typedefs for Rank<2>, Rank<3> for example usage
   typedef double ScalarType;
-  typedef typename Kokkos::View<ScalarType**>   ViewType_2D;
-  typedef typename Kokkos::View<ScalarType***>  ViewType_3D;
+  typedef typename Kokkos::View<ScalarType**> ViewType_2D;
+  typedef typename Kokkos::View<ScalarType***> ViewType_3D;
 
   /////////////////////////////////////////////////////////////////////////////
-  // Explanation of MDRangePolicy usage, template parameters, constructor arguments
+  // Explanation of MDRangePolicy usage, template parameters, constructor
+  // arguments
   //
   // MDRangePolicy typedefs for Rank<2>, Rank<3> cases
-  // Required template parameters: 
+  // Required template parameters:
   //   Kokkos::Rank<N>: where N=rank
   //
   // Optional template parameters to Rank<...>:
-  //   Kokkos::Iterate::{Default,Left,Right}: Outer iteration pattern across tiles; 
+  //   Kokkos::Iterate::{Default,Left,Right}: Outer iteration pattern across
+  //   tiles;
   //     defaults based on the execution space similar to Kokkos::Layout
-  //   Kokkos::Iterate::{Default,Left,Right}: Inner iteration pattern within tiles; 
+  //   Kokkos::Iterate::{Default,Left,Right}: Inner iteration pattern within
+  //   tiles;
   //     defaults based on the execution space similar to Kokkos::Layout
   //
   //   e.g. typedef Rank<2, Iterate::Left, Iterate::Left> rank2ll;
   //
   //
   // Optional template parameters to MDRangePolicy:
-  //   ExecutionSpace: Kokkos::Serial, Kokkos::OpenMP, Kokkos::Cuda, etc. 
+  //   ExecutionSpace: Kokkos::Serial, Kokkos::OpenMP, Kokkos::Cuda, etc.
   //
   //   Kokkos::IndexType< T >: where T = int, long, unsigned int, etc.
   //
   //   struct Tag{}: A user-provided tag for tagging functor operators
   //
-  //   e.g. 1:  MDRangePolicy< Kokkos::Serial, Rank<2, Iterate::Left, Iterate::Left>, IndexType<int>, Tag > mdpolicy;
-  //   e.g. 2:  MDRangePolicy< Kokkos::Serial, rank2ll, IndexType<int>, Tag > mdpolicy;
+  //   e.g. 1:  MDRangePolicy< Kokkos::Serial, Rank<2, Iterate::Left,
+  //   Iterate::Left>, IndexType<int>, Tag > mdpolicy; e.g. 2:  MDRangePolicy<
+  //   Kokkos::Serial, rank2ll, IndexType<int>, Tag > mdpolicy;
   //
   //
   // Required arguments to ctor:
-  //   {{ l0, l1, ... }}: Lower bounds, provided as Kokkos::Array or std::initializer_list
-  //   {{ u0, u1, ... }}: Upper bounds, provided as Kokkos::Array or std::initializer_list
+  //   {{ l0, l1, ... }}: Lower bounds, provided as Kokkos::Array or
+  //   std::initializer_list
+  //   {{ u0, u1, ... }}: Upper bounds, provided as Kokkos::Array or
+  //   std::initializer_list
   //
   // Optional arguments to ctor:
-  //   {{ t0, t1, ... }}: Tile dimensions, provided as Kokkos::Array or std::initializer_list
+  //   {{ t0, t1, ... }}: Tile dimensions, provided as Kokkos::Array or
+  //   std::initializer_list
   //                      defaults based on the execution space
   //
   //  e.g. mdpolicy( {{0,0}}, {{u0,u1}}, {{t0,t1}};
-  //   
+  //
   /////////////////////////////////////////////////////////////////////////////
 
-  // Example 1: 
+  // Example 1:
   long incorrect_count_2d = 0;
   {
     // Rank<2> Case: Rank is provided, all other parameters are default
-    typedef typename Kokkos::Experimental::MDRangePolicy< Kokkos::Experimental::Rank<2> > MDPolicyType_2D;
+    typedef typename Kokkos::Experimental::MDRangePolicy<
+        Kokkos::Experimental::Rank<2> >
+        MDPolicyType_2D;
 
-    // Construct 2D MDRangePolicy: lower and upper bounds provided, tile dims defaulted
-    MDPolicyType_2D mdpolicy_2d( {{0,0}}, {{n,n}} );
+    // Construct 2D MDRangePolicy: lower and upper bounds provided, tile dims
+    // defaulted
+    MDPolicyType_2D mdpolicy_2d({{0, 0}}, {{n, n}});
 
     // Construct a 2D view to store result of product of indices
     ViewType_2D v2("v2", n, n);
 
     // Execute parallel_for with rank 2 MDRangePolicy
-    Kokkos::parallel_for( "md2d", mdpolicy_2d, MDFunctor<ViewType_2D>(v2, n) );
+    Kokkos::parallel_for("md2d", mdpolicy_2d, MDFunctor<ViewType_2D>(v2, n));
 
     // Check results with a parallel_reduce using the MDRangePolicy
-    Kokkos::parallel_reduce( "md2dredux", mdpolicy_2d, MDFunctor<ViewType_2D>(v2, n), incorrect_count_2d );
+    Kokkos::parallel_reduce("md2dredux", mdpolicy_2d,
+                            MDFunctor<ViewType_2D>(v2, n), incorrect_count_2d);
 
-    printf("Rank 2 MDRangePolicy incorrect count: %ld\n", incorrect_count_2d); // should be 0
+    printf("Rank 2 MDRangePolicy incorrect count: %ld\n",
+           incorrect_count_2d);  // should be 0
   }
 
-
-  // Example 2: 
+  // Example 2:
   long incorrect_count_3d = 0;
   {
     // Rank<3> Case: Rank, inner iterate pattern, outer iterate pattern provided
-    typedef typename Kokkos::Experimental::MDRangePolicy< Kokkos::Experimental::Rank<3, Kokkos::Experimental::Iterate::Left, Kokkos::Experimental::Iterate::Left> > MDPolicyType_3D;
+    typedef typename Kokkos::Experimental::MDRangePolicy<
+        Kokkos::Experimental::Rank<3, Kokkos::Experimental::Iterate::Left,
+                                   Kokkos::Experimental::Iterate::Left> >
+        MDPolicyType_3D;
 
     // Construct 3D MDRangePolicy: lower, upper bounds, tile dims provided
-    MDPolicyType_3D mdpolicy_3d( {{0,0,0}}, {{n,n,n}}, {{4,4,4}} );
+    MDPolicyType_3D mdpolicy_3d({{0, 0, 0}}, {{n, n, n}}, {{4, 4, 4}});
 
     // Construct a 3D view to store result of product of indices
     ViewType_3D v3("v3", n, n, n);
 
     // Execute parallel_for with rank 3 MDRangePolicy
-    Kokkos::parallel_for( "md3d", mdpolicy_3d, MDFunctor<ViewType_3D>(v3, n) );
+    Kokkos::parallel_for("md3d", mdpolicy_3d, MDFunctor<ViewType_3D>(v3, n));
 
     // Check results with a parallel_reduce using the MDRangePolicy
-    Kokkos::parallel_reduce( "md3dredux", mdpolicy_3d, MDFunctor<ViewType_3D>(v3, n), incorrect_count_3d );
+    Kokkos::parallel_reduce("md3dredux", mdpolicy_3d,
+                            MDFunctor<ViewType_3D>(v3, n), incorrect_count_3d);
 
-    printf("Rank 3 MDRangePolicy incorrect count: %ld\n", incorrect_count_3d); // should be 0
+    printf("Rank 3 MDRangePolicy incorrect count: %ld\n",
+           incorrect_count_3d);  // should be 0
   }
 
-  Kokkos::finalize ();
+  Kokkos::finalize();
 
-  return (incorrect_count_2d == long(0) && incorrect_count_3d == long(0)) ? 0 : -1;
+  return (incorrect_count_2d == long(0) && incorrect_count_3d == long(0)) ? 0
+                                                                          : -1;
 }
-
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/CMakeLists.txt b/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/CMakeLists.txt
index 2eb3a8f6c98d69c394f83591e59aa7073f1e59e2..b0db41bf451708c361eb5a0cdeda3413c8532c8e 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_advancedviews_01_data_layouts
   SOURCES data_layouts.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/data_layouts.cpp b/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/data_layouts.cpp
index 3aacad2035ed9bd2b82a35b5f8e4878c1d538381..9bfa49456ab4ebae7b7581ec5cf02157dd61d2ff 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/data_layouts.cpp
+++ b/lib/kokkos/example/tutorial/Advanced_Views/01_data_layouts/data_layouts.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -62,19 +63,19 @@ typedef Kokkos::View<double*> view_type;
 // parallel_for functor that fills the given View with some data.  It
 // expects to access the View by rows in parallel: each call i of
 // operator() accesses a row.
-template<class ViewType>
+template <class ViewType>
 struct init_view {
   ViewType a;
-  init_view (ViewType a_) : a (a_) {}
+  init_view(ViewType a_) : a(a_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const typename ViewType::size_type i) const {
+  void operator()(const typename ViewType::size_type i) const {
     // On CPUs this loop could be vectorized so j should do stride 1
     // access on a for optimal performance. I.e. a should be LayoutRight.
     // On GPUs threads should do coalesced loads and stores. That means
     // that i should be the stride one access for optimal performance.
     for (typename ViewType::size_type j = 0; j < a.extent(1); ++j) {
-      a(i,j) = 1.0*a.extent(0)*i + 1.0*j;
+      a(i, j) = 1.0 * a.extent(0) * i + 1.0 * j;
     }
   }
 };
@@ -86,14 +87,13 @@ struct init_view {
 // Since the functor is templated on the ViewTypes itself it doesn't matter what
 // there layouts are. That means you can use different layouts on different
 // architectures.
-template<class ViewType1, class ViewType2>
+template <class ViewType1, class ViewType2>
 struct contraction {
   view_type a;
   typename ViewType1::const_type v1;
   typename ViewType2::const_type v2;
-  contraction (view_type a_, ViewType1 v1_, ViewType2 v2_) :
-    a (a_), v1 (v1_), v2 (v2_)
-  {}
+  contraction(view_type a_, ViewType1 v1_, ViewType2 v2_)
+      : a(a_), v1(v1_), v2(v2_) {}
 
   // As with the initialization functor the performance of this operator
   // depends on the architecture and the chosen data layouts.
@@ -103,9 +103,9 @@ struct contraction {
   // the thread Index, i must be the stride 1 dimension. That means v1 should be
   // LayoutLeft and v2 LayoutRight.
   KOKKOS_INLINE_FUNCTION
-  void operator() (const view_type::size_type i) const {
+  void operator()(const view_type::size_type i) const {
     for (view_type::size_type j = 0; j < v1.extent(1); ++j) {
-      a(i) = v1(i,j)*v2(j,i);
+      a(i) = v1(i, j) * v2(j, i);
     }
   }
 };
@@ -113,61 +113,61 @@ struct contraction {
 // Compute a dot product. This is used for result verification.
 struct dot {
   view_type a;
-  dot (view_type a_) : a (a_) {}
-  typedef double value_type; //Specify type for reduction target, lsum
+  dot(view_type a_) : a(a_) {}
+  typedef double value_type;  // Specify type for reduction target, lsum
   KOKKOS_INLINE_FUNCTION
-  void operator() (const view_type::size_type i, double &lsum) const {
-    lsum += a(i)*a(i);
+  void operator()(const view_type::size_type i, double& lsum) const {
+    lsum += a(i) * a(i);
   }
 };
 
-int main (int narg, char* arg[]) {
+int main(int narg, char* arg[]) {
   // When initializing Kokkos, you may pass in command-line arguments,
   // just like with MPI_Init().  Kokkos reserves the right to remove
   // arguments from the list that start with '--kokkos-'.
-  Kokkos::initialize (narg, arg);
+  Kokkos::initialize(narg, arg);
 
   {
     int size = 10000;
-    view_type a("A",size);
+    view_type a("A", size);
 
     // Define two views with LayoutLeft and LayoutRight.
-    left_type l("L",size,10000);
-    right_type r("R",size,10000);
+    left_type l("L", size, 10000);
+    right_type r("R", size, 10000);
 
     // Initialize the data in the views.
-    Kokkos::parallel_for(size,init_view<left_type>(l));
-    Kokkos::parallel_for(size,init_view<right_type>(r));
+    Kokkos::parallel_for(size, init_view<left_type>(l));
+    Kokkos::parallel_for(size, init_view<right_type>(r));
     Kokkos::fence();
 
     // Measure time to execute the contraction kernel when giving it a
     // LayoutLeft view for v1 and a LayoutRight view for v2. This should be
     // fast on GPUs and slow on CPUs
     Kokkos::Timer time1;
-    Kokkos::parallel_for(size,contraction<left_type,right_type>(a,l,r));
+    Kokkos::parallel_for(size, contraction<left_type, right_type>(a, l, r));
     Kokkos::fence();
     double sec1 = time1.seconds();
 
     double sum1 = 0;
-    Kokkos::parallel_reduce(size,dot(a),sum1);
+    Kokkos::parallel_reduce(size, dot(a), sum1);
     Kokkos::fence();
 
     // Measure time to execute the contraction kernel when giving it a
     // LayoutRight view for v1 and a LayoutLeft view for v2. This should be
     // fast on CPUs and slow on GPUs
     Kokkos::Timer time2;
-    Kokkos::parallel_for(size,contraction<right_type,left_type>(a,r,l));
+    Kokkos::parallel_for(size, contraction<right_type, left_type>(a, r, l));
     Kokkos::fence();
     double sec2 = time2.seconds();
 
     double sum2 = 0;
-    Kokkos::parallel_reduce(size,dot(a),sum2);
+    Kokkos::parallel_reduce(size, dot(a), sum2);
 
     // Kokkos' reductions are deterministic.
     // The results should always be equal.
-    printf("Result Left/Right %f Right/Left %f (equal result: %i)\n",sec1,sec2,sum2==sum1);
+    printf("Result Left/Right %f Right/Left %f (equal result: %i)\n", sec1,
+           sec2, sum2 == sum1);
   }
 
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/CMakeLists.txt b/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/CMakeLists.txt
index 1963e544d7a113e8b50cf3fa2444df2f95d983e2..0e50968b4bf2d856b0a1e4b1122929db5aab5326 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_advancedviews_02_memory_traits
   SOURCES memory_traits.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/memory_traits.cpp b/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/memory_traits.cpp
index 84ddac4bae3039bfffb68fe12ea58c05fbd63429..da6478a02e6206a2c81be5a2db337b788c7422e9 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/memory_traits.cpp
+++ b/lib/kokkos/example/tutorial/Advanced_Views/02_memory_traits/memory_traits.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -62,82 +63,85 @@ typedef Kokkos::View<double*> view_type;
 // cache.  This only works if the View is read-only, which we enforce
 // through the first template parameter.
 //
-// Note that we are still talking about views of the data, its not a new allocation.
-// For example you can have an atomic view of a default view. While you even
-// could use both in the same kernel, this could lead to undefined behaviour because
-// one of your access paths is not atomic. Think of it in the same way as you think of
-// pointers to const data and pointers to non-const data (i.e. const double* and double*).
-// While these pointers can point to the same data you should not use them together if that
-// brakes the const guarantee of the first pointer.
-typedef Kokkos::View<const double*, Kokkos::MemoryTraits<Kokkos::RandomAccess> > view_type_rnd;
+// Note that we are still talking about views of the data, its not a new
+// allocation. For example you can have an atomic view of a default view. While
+// you even could use both in the same kernel, this could lead to undefined
+// behaviour because one of your access paths is not atomic. Think of it in the
+// same way as you think of pointers to const data and pointers to non-const
+// data (i.e. const double* and double*). While these pointers can point to the
+// same data you should not use them together if that brakes the const guarantee
+// of the first pointer.
+typedef Kokkos::View<const double*, Kokkos::MemoryTraits<Kokkos::RandomAccess> >
+    view_type_rnd;
 typedef Kokkos::View<int**> idx_type;
 typedef idx_type::HostMirror idx_type_host;
 
-// We template this functor on the ViewTypes to show the effect of the RandomAccess trait.
-template<class DestType, class SrcType>
+// We template this functor on the ViewTypes to show the effect of the
+// RandomAccess trait.
+template <class DestType, class SrcType>
 struct localsum {
   idx_type::const_type idx;
   DestType dest;
   SrcType src;
-  localsum (idx_type idx_, DestType dest_, SrcType src_) :
-    idx (idx_), dest (dest_), src (src_)
-  {}
+  localsum(idx_type idx_, DestType dest_, SrcType src_)
+      : idx(idx_), dest(dest_), src(src_) {}
 
   // Calculate a local sum of values
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i) const {
+  void operator()(const int i) const {
     double tmp = 0.0;
-    for (int j = 0; j < (int) idx.extent(1); ++j) {
+    for (int j = 0; j < (int)idx.extent(1); ++j) {
       // This is an indirect access on src
-      const double val = src(idx(i,j));
-      tmp += val*val + 0.5*(idx.extent(0)*val -idx.extent(1)*val);
+      const double val = src(idx(i, j));
+      tmp += val * val + 0.5 * (idx.extent(0) * val - idx.extent(1) * val);
     }
     dest(i) = tmp;
   }
 };
 
 int main(int narg, char* arg[]) {
-  Kokkos::initialize (narg, arg);
+  Kokkos::initialize(narg, arg);
 
   {
     int size = 1000000;
 
-    idx_type idx("Idx",size,64);
-    idx_type_host h_idx = Kokkos::create_mirror_view (idx);
+    idx_type idx("Idx", size, 64);
+    idx_type_host h_idx = Kokkos::create_mirror_view(idx);
 
-    view_type dest ("Dest", size);
-    view_type src ("Src", size);
+    view_type dest("Dest", size);
+    view_type src("Src", size);
 
     srand(134231);
 
     for (int i = 0; i < size; i++) {
       for (view_type::size_type j = 0; j < h_idx.extent(1); ++j) {
-        h_idx(i,j) = (size + i + (rand () % 500 - 250)) % size;
+        h_idx(i, j) = (size + i + (rand() % 500 - 250)) % size;
       }
     }
 
     // Deep copy the initial data to the device
-    Kokkos::deep_copy(idx,h_idx);
+    Kokkos::deep_copy(idx, h_idx);
     // Run the first kernel to warmup caches
-    Kokkos::parallel_for(size,localsum<view_type,view_type_rnd>(idx,dest,src));
+    Kokkos::parallel_for(size,
+                         localsum<view_type, view_type_rnd>(idx, dest, src));
     Kokkos::fence();
 
-    // Run the localsum functor using the RandomAccess trait. On CPUs there should
-    // not be any different in performance to not using the RandomAccess trait.
-    // On GPUs where can be a dramatic difference
+    // Run the localsum functor using the RandomAccess trait. On CPUs there
+    // should not be any different in performance to not using the RandomAccess
+    // trait. On GPUs where can be a dramatic difference
     Kokkos::Timer time1;
-    Kokkos::parallel_for(size,localsum<view_type,view_type_rnd>(idx,dest,src));
+    Kokkos::parallel_for(size,
+                         localsum<view_type, view_type_rnd>(idx, dest, src));
     Kokkos::fence();
     double sec1 = time1.seconds();
 
     Kokkos::Timer time2;
-    Kokkos::parallel_for(size,localsum<view_type,view_type>(idx,dest,src));
+    Kokkos::parallel_for(size, localsum<view_type, view_type>(idx, dest, src));
     Kokkos::fence();
     double sec2 = time2.seconds();
 
-    printf("Time with Trait RandomAccess: %f with Plain: %f \n",sec1,sec2);
+    printf("Time with Trait RandomAccess: %f with Plain: %f \n", sec1, sec2);
   }
 
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/CMakeLists.txt b/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/CMakeLists.txt
index cbe394c78b832f7bee3bb659b2776d5b246adbd1..90270740c3c49927221ebca87a7c85f16afea074 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_advancedviews_03_subviews
   SOURCES subviews.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/subviews.cpp b/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/subviews.cpp
index d2472a1910c68ac098027dd97737b527b878636d..df6a09f828b809eeaece26e3cb986d50b5cb91bc 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/subviews.cpp
+++ b/lib/kokkos/example/tutorial/Advanced_Views/03_subviews/subviews.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -70,19 +71,17 @@ typedef Kokkos::View<double***, Kokkos::LayoutStride> inner_mesh_type;
 // Functor to set all entries of a boundary of the mesh to a constant
 // value.  The functor is templated on ViewType because different
 // boundaries may have different layouts.
-template<class ViewType>
+template <class ViewType>
 struct set_boundary {
   ViewType a;
   double value;
 
-  set_boundary (ViewType a_, double value_) :
-    a (a_), value (value_)
-  {}
+  set_boundary(ViewType a_, double value_) : a(a_), value(value_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const typename ViewType::size_type i) const {
+  void operator()(const typename ViewType::size_type i) const {
     for (typename ViewType::size_type j = 0; j < a.extent(1); ++j) {
-      a(i,j) = value;
+      a(i, j) = value;
     }
   }
 };
@@ -90,21 +89,19 @@ struct set_boundary {
 // Functor to set all entries of a boundary of the mesh to a constant
 // value.  The functor is templated on ViewType because different
 // boundaries may have different layouts.
-template<class ViewType>
+template <class ViewType>
 struct set_inner {
   ViewType a;
   double value;
 
-  set_inner (ViewType a_, double value_) :
-    a (a_), value (value_)
-  {}
+  set_inner(ViewType a_, double value_) : a(a_), value(value_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator () (const typename ViewType::size_type i) const {
+  void operator()(const typename ViewType::size_type i) const {
     typedef typename ViewType::size_type size_type;
     for (size_type j = 0; j < a.extent(1); ++j) {
       for (size_type k = 0; k < a.extent(2); ++k) {
-        a(i,j,k) = value;
+        a(i, j, k) = value;
       }
     }
   }
@@ -112,38 +109,34 @@ struct set_inner {
 
 // Update the interior of the mesh.  This simulates one timestep of a
 // finite-difference method.
-template<class ViewType>
+template <class ViewType>
 struct update {
   ViewType a;
   const double dt;
 
-  update (ViewType a_, const double dt_) :
-    a (a_), dt (dt_)
-  {}
+  update(ViewType a_, const double dt_) : a(a_), dt(dt_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (typename ViewType::size_type i) const {
+  void operator()(typename ViewType::size_type i) const {
     typedef typename ViewType::size_type size_type;
     i++;
-    for (size_type j = 1; j < a.extent(1)-1; j++) {
-      for (size_type k = 1; k < a.extent(2)-1; k++) {
-        a(i,j,k) += dt* (a(i,j,k+1) - a(i,j,k-1) +
-                         a(i,j+1,k) - a(i,j-1,k) +
-                         a(i+1,j,k) - a(i-1,j,k));
+    for (size_type j = 1; j < a.extent(1) - 1; j++) {
+      for (size_type k = 1; k < a.extent(2) - 1; k++) {
+        a(i, j, k) += dt * (a(i, j, k + 1) - a(i, j, k - 1) + a(i, j + 1, k) -
+                            a(i, j - 1, k) + a(i + 1, j, k) - a(i - 1, j, k));
       }
     }
   }
 };
 
-
-int main (int narg, char* arg[]) {
+int main(int narg, char* arg[]) {
   using Kokkos::ALL;
   using Kokkos::pair;
   using Kokkos::parallel_for;
   using Kokkos::subview;
   typedef mesh_type::size_type size_type;
 
-  Kokkos::initialize (narg, arg);
+  Kokkos::initialize(narg, arg);
 
   {
     // The number of mesh points along each dimension of the mesh, not
@@ -151,43 +144,48 @@ int main (int narg, char* arg[]) {
     const size_type size = 100;
 
     // A is the full cubic 3-D mesh, including the boundaries.
-    mesh_type A ("A", size+2, size+2, size+2);
+    mesh_type A("A", size + 2, size + 2, size + 2);
     // Ai is the "inner" part of A, _not_ including the boundaries.
     //
     // A pair of indices in a particular dimension means the contiguous
     // zero-based index range in that dimension, including the first
     // entry of the pair but _not_ including the second entry.
-    inner_mesh_type Ai = subview(A, pair<size_type, size_type> (1, size+1),
-                                    pair<size_type, size_type> (1, size+1),
-                                    pair<size_type, size_type> (1, size+1));
+    inner_mesh_type Ai = subview(A, pair<size_type, size_type>(1, size + 1),
+                                 pair<size_type, size_type>(1, size + 1),
+                                 pair<size_type, size_type>(1, size + 1));
     // A has six boundaries, one for each face of the cube.
     // Create a View of each of these boundaries.
     // ALL() means "select all indices in that dimension."
-    xy_plane_type Zneg_halo = subview(A, ALL (), ALL (), 0);
-    xy_plane_type Zpos_halo = subview(A, ALL (), ALL (), 101);
-    xz_plane_type Yneg_halo = subview(A, ALL (), 0, ALL ());
-    xz_plane_type Ypos_halo = subview(A, ALL (), 101, ALL ());
-    yz_plane_type Xneg_halo = subview(A, 0, ALL (), ALL ());
-    yz_plane_type Xpos_halo = subview(A, 101, ALL (), ALL ());
+    xy_plane_type Zneg_halo = subview(A, ALL(), ALL(), 0);
+    xy_plane_type Zpos_halo = subview(A, ALL(), ALL(), 101);
+    xz_plane_type Yneg_halo = subview(A, ALL(), 0, ALL());
+    xz_plane_type Ypos_halo = subview(A, ALL(), 101, ALL());
+    yz_plane_type Xneg_halo = subview(A, 0, ALL(), ALL());
+    yz_plane_type Xpos_halo = subview(A, 101, ALL(), ALL());
 
     // Set the boundaries to their initial conditions.
-    parallel_for (Zneg_halo.extent(0), set_boundary<xy_plane_type> (Zneg_halo,  1));
-    parallel_for (Zpos_halo.extent(0), set_boundary<xy_plane_type> (Zpos_halo, -1));
-    parallel_for (Yneg_halo.extent(0), set_boundary<xz_plane_type> (Yneg_halo,  2));
-    parallel_for (Ypos_halo.extent(0), set_boundary<xz_plane_type> (Ypos_halo, -2));
-    parallel_for (Xneg_halo.extent(0), set_boundary<yz_plane_type> (Xneg_halo,  3));
-    parallel_for (Xpos_halo.extent(0), set_boundary<yz_plane_type> (Xpos_halo, -3));
+    parallel_for(Zneg_halo.extent(0),
+                 set_boundary<xy_plane_type>(Zneg_halo, 1));
+    parallel_for(Zpos_halo.extent(0),
+                 set_boundary<xy_plane_type>(Zpos_halo, -1));
+    parallel_for(Yneg_halo.extent(0),
+                 set_boundary<xz_plane_type>(Yneg_halo, 2));
+    parallel_for(Ypos_halo.extent(0),
+                 set_boundary<xz_plane_type>(Ypos_halo, -2));
+    parallel_for(Xneg_halo.extent(0),
+                 set_boundary<yz_plane_type>(Xneg_halo, 3));
+    parallel_for(Xpos_halo.extent(0),
+                 set_boundary<yz_plane_type>(Xpos_halo, -3));
 
     // Set the interior of the mesh to its initial condition.
-    parallel_for (Ai.extent(0), set_inner<inner_mesh_type> (Ai, 0));
+    parallel_for(Ai.extent(0), set_inner<inner_mesh_type>(Ai, 0));
 
     // Update the interior of the mesh.
     // This simulates one timestep with dt = 0.1.
-    parallel_for (Ai.extent(0), update<mesh_type> (A, 0.1));
+    parallel_for(Ai.extent(0), update<mesh_type>(A, 0.1));
 
     Kokkos::fence();
-    printf ("Done\n");
+    printf("Done\n");
   }
-  Kokkos::finalize ();
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/CMakeLists.txt b/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/CMakeLists.txt
index 300dab128e45779002cf123d7e7238777abab4d5..4f9b9225d2114fa52141322993297a8ac92713c8 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_advancedviews_04_dualviews
   SOURCES dual_view.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/dual_view.cpp b/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/dual_view.cpp
index e0fa559587063337f70525e062d5d98c116c0310..86fe0162038daf5a1ad32da13b4ae05ddcacf62b 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/dual_view.cpp
+++ b/lib/kokkos/example/tutorial/Advanced_Views/04_dualviews/dual_view.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -68,16 +69,16 @@
 typedef Kokkos::DualView<double*> view_type;
 typedef Kokkos::DualView<int**> idx_type;
 
-
-template<class ExecutionSpace>
+template <class ExecutionSpace>
 struct localsum {
   // If the functor has a public 'execution_space' typedef, that defines
   // the functor's execution space (where it runs in parallel).  This
   // overrides Kokkos' default execution space.
   typedef ExecutionSpace execution_space;
 
-  typedef typename Kokkos::Impl::if_c<std::is_same<ExecutionSpace,Kokkos::DefaultExecutionSpace>::value ,
-     idx_type::memory_space, idx_type::host_mirror_space>::type memory_space;
+  typedef typename Kokkos::Impl::if_c<
+      std::is_same<ExecutionSpace, Kokkos::DefaultExecutionSpace>::value,
+      idx_type::memory_space, idx_type::host_mirror_space>::type memory_space;
 
   // Get the view types on the particular device for which the functor
   // is instantiated.
@@ -86,25 +87,28 @@ struct localsum {
   // the const version of the first template parameter of the View.
   // For example, the const_data_type version of double** is const
   // double**.
-  Kokkos::View<idx_type::const_data_type, idx_type::array_layout, memory_space> idx;
+  Kokkos::View<idx_type::const_data_type, idx_type::array_layout, memory_space>
+      idx;
   // "scalar_array_type" is a typedef in ViewTraits (and DualView) which is the
   // array version of the value(s) stored in the View.
-  Kokkos::View<view_type::scalar_array_type, view_type::array_layout, memory_space> dest;
+  Kokkos::View<view_type::scalar_array_type, view_type::array_layout,
+               memory_space>
+      dest;
   Kokkos::View<view_type::const_data_type, view_type::array_layout,
-               memory_space, Kokkos::MemoryRandomAccess> src;
+               memory_space, Kokkos::MemoryRandomAccess>
+      src;
 
   // Constructor takes DualViews, synchronizes them to the device,
   // then marks them as modified on the device.
-  localsum (idx_type dv_idx, view_type dv_dest, view_type dv_src)
-  {
+  localsum(idx_type dv_idx, view_type dv_dest, view_type dv_src) {
     // Extract the view on the correct Device (i.e., the correct
     // memory space) from the DualView.  DualView has a template
     // method, view(), which is templated on the memory space.  If the
     // DualView has a View from that memory space, view() returns the
     // View in that space.
-    idx = dv_idx.view<memory_space> ();
-    dest = dv_dest.template view<memory_space> ();
-    src = dv_src.template view<memory_space> ();
+    idx  = dv_idx.view<memory_space>();
+    dest = dv_dest.template view<memory_space>();
+    src  = dv_src.template view<memory_space>();
 
     // Synchronize the DualView to the correct Device.
     //
@@ -116,103 +120,106 @@ struct localsum {
     // determines this by the user manually marking one side or the
     // other as modified; see the modify() call below.
 
-    dv_idx.sync<memory_space> ();
-    dv_dest.template sync<memory_space> ();
-    dv_src.template sync<memory_space> ();
+    dv_idx.sync<memory_space>();
+    dv_dest.template sync<memory_space>();
+    dv_src.template sync<memory_space>();
 
     // Mark dest as modified on Device.
-    dv_dest.template modify<memory_space> ();
+    dv_dest.template modify<memory_space>();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int i) const {
+  void operator()(const int i) const {
     double tmp = 0.0;
-    for (int j = 0; j < (int) idx.extent(1); ++j) {
-      const double val = src(idx(i,j));
-      tmp += val*val + 0.5*(idx.extent(0)*val -idx.extent(1)*val);
+    for (int j = 0; j < (int)idx.extent(1); ++j) {
+      const double val = src(idx(i, j));
+      tmp += val * val + 0.5 * (idx.extent(0) * val - idx.extent(1) * val);
     }
     dest(i) += tmp;
   }
 };
 
 class ParticleType {
-  public:
-    double q;
-    double m;
-    double q_over_m;
-    KOKKOS_INLINE_FUNCTION
-    ParticleType(double q_ = -1, double m_ = 1):
-     q(q_), m(m_), q_over_m(q/m) {}
-protected:
-};
-
-  typedef Kokkos::DualView<ParticleType[10]> ParticleTypes;
-int main (int narg, char* arg[]) {
-  Kokkos::initialize (narg, arg);
-
-// If View is non-trivial constructible type then add braces so it is out of scope
-// before Kokkos::finalize() call
-{
-  ParticleTypes test("Test");
-  Kokkos::fence();
-  test.h_view(0) = ParticleType(-1e4,1);
-  Kokkos::fence();
-
-  int size = 1000000;
-
-  // Create DualViews. This will allocate on both the device and its
-  // host_mirror_device.
-  idx_type idx ("Idx",size,64);
-  view_type dest ("Dest",size);
-  view_type src ("Src",size);
+ public:
+  double q;
+  double m;
+  double q_over_m;
+  KOKKOS_INLINE_FUNCTION
+  ParticleType(double q_ = -1, double m_ = 1) : q(q_), m(m_), q_over_m(q / m) {}
 
+ protected:
+};
 
-  srand (134231);
+typedef Kokkos::DualView<ParticleType[10]> ParticleTypes;
+int main(int narg, char* arg[]) {
+  Kokkos::initialize(narg, arg);
 
-  // Get a reference to the host view of idx directly (equivalent to
-  // idx.view<idx_type::host_mirror_space>() )
-  idx_type::t_host h_idx = idx.h_view;
-  for (int i = 0; i < size; ++i) {
-    for (view_type::size_type j = 0; j < h_idx.extent(1); ++j) {
-      h_idx(i,j) = (size + i + (rand () % 500 - 250)) % size;
+  // If View is non-trivial constructible type then add braces so it is out of
+  // scope before Kokkos::finalize() call
+  {
+    ParticleTypes test("Test");
+    Kokkos::fence();
+    test.h_view(0) = ParticleType(-1e4, 1);
+    Kokkos::fence();
+
+    int size = 1000000;
+
+    // Create DualViews. This will allocate on both the device and its
+    // host_mirror_device.
+    idx_type idx("Idx", size, 64);
+    view_type dest("Dest", size);
+    view_type src("Src", size);
+
+    srand(134231);
+
+    // Get a reference to the host view of idx directly (equivalent to
+    // idx.view<idx_type::host_mirror_space>() )
+    idx_type::t_host h_idx = idx.h_view;
+    for (int i = 0; i < size; ++i) {
+      for (view_type::size_type j = 0; j < h_idx.extent(1); ++j) {
+        h_idx(i, j) = (size + i + (rand() % 500 - 250)) % size;
+      }
     }
-  }
 
-  // Mark idx as modified on the host_mirror_space so that a
-  // sync to the device will actually move data.  The sync happens in
-  // the functor's constructor.
-  idx.modify<idx_type::host_mirror_space> ();
-
-  // Run on the device.  This will cause a sync of idx to the device,
-  // since it was marked as modified on the host.
-  Kokkos::Timer timer;
-  Kokkos::parallel_for(size,localsum<view_type::execution_space>(idx,dest,src));
-  Kokkos::fence();
-  double sec1_dev = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_for(size,localsum<view_type::execution_space>(idx,dest,src));
-  Kokkos::fence();
-  double sec2_dev = timer.seconds();
-
-  // Run on the host's default execution space (could be the same as device).
-  // This will cause a sync back to the host of dest.  Note that if the Device is CUDA,
-  // the data layout will not be optimal on host, so performance is
-  // lower than what it would be for a pure host compilation.
-  timer.reset();
-  Kokkos::parallel_for(size,localsum<Kokkos::HostSpace::execution_space>(idx,dest,src));
-  Kokkos::fence();
-  double sec1_host = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_for(size,localsum<Kokkos::HostSpace::execution_space>(idx,dest,src));
-  Kokkos::fence();
-  double sec2_host = timer.seconds();
-
-  printf("Device Time with Sync: %f without Sync: %f \n",sec1_dev,sec2_dev);
-  printf("Host   Time with Sync: %f without Sync: %f \n",sec1_host,sec2_host);
-}
+    // Mark idx as modified on the host_mirror_space so that a
+    // sync to the device will actually move data.  The sync happens in
+    // the functor's constructor.
+    idx.modify<idx_type::host_mirror_space>();
+
+    // Run on the device.  This will cause a sync of idx to the device,
+    // since it was marked as modified on the host.
+    Kokkos::Timer timer;
+    Kokkos::parallel_for(size,
+                         localsum<view_type::execution_space>(idx, dest, src));
+    Kokkos::fence();
+    double sec1_dev = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_for(size,
+                         localsum<view_type::execution_space>(idx, dest, src));
+    Kokkos::fence();
+    double sec2_dev = timer.seconds();
+
+    // Run on the host's default execution space (could be the same as device).
+    // This will cause a sync back to the host of dest.  Note that if the Device
+    // is CUDA, the data layout will not be optimal on host, so performance is
+    // lower than what it would be for a pure host compilation.
+    timer.reset();
+    Kokkos::parallel_for(
+        size, localsum<Kokkos::HostSpace::execution_space>(idx, dest, src));
+    Kokkos::fence();
+    double sec1_host = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_for(
+        size, localsum<Kokkos::HostSpace::execution_space>(idx, dest, src));
+    Kokkos::fence();
+    double sec2_host = timer.seconds();
+
+    printf("Device Time with Sync: %f without Sync: %f \n", sec1_dev, sec2_dev);
+    printf("Host   Time with Sync: %f without Sync: %f \n", sec1_host,
+           sec2_host);
+  }
 
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/CMakeLists.txt b/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/CMakeLists.txt
index f0ed569f9f48a02ebcca091adced52a8c3a1f2ad..9e9af9872c907256f37de501e6c5783fe8074647 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/CMakeLists.txt
@@ -2,12 +2,10 @@
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
-IF (Kokkos_ENABLE_Cuda_UVM)
-  # This is a tutorial, not a test, so we don't ask CTest to run it.
-  TRIBITS_ADD_EXECUTABLE(
-    tutorial_advancedviews_05_nvidia_uvm
-    SOURCES uvm_example.cpp
-    COMM serial mpi
-    DEPLIBS kokkoscontainers kokkoscore
-    )
+IF (Kokkos_ENABLE_CUDA_UVM)
+# This is a tutorial, not a test, so we don't ask CTest to run it.
+KOKKOS_ADD_EXECUTABLE(
+  tutorial_advancedviews_05_nvidia_uvm
+  SOURCES uvm_example.cpp
+)
 ENDIF ()
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/uvm_example.cpp b/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/uvm_example.cpp
index d83077630cb58ae21faa18785361ad3a7ae24e0d..51b84cf1842ee1498fa871d796e6416f6b60387c 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/uvm_example.cpp
+++ b/lib/kokkos/example/tutorial/Advanced_Views/05_NVIDIA_UVM/uvm_example.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -51,92 +52,98 @@
 typedef Kokkos::View<double*, Kokkos::CudaUVMSpace> view_type;
 typedef Kokkos::View<int**, Kokkos::CudaUVMSpace> idx_type;
 #else
-typedef Kokkos::View<double*,Kokkos::HostSpace> view_type;
-typedef Kokkos::View<int**,Kokkos::HostSpace> idx_type;
+typedef Kokkos::View<double*, Kokkos::HostSpace> view_type;
+typedef Kokkos::View<int**, Kokkos::HostSpace> idx_type;
 #endif
 
-template<class Device>
+template <class Device>
 struct localsum {
-  // Define the execution space for the functor (overrides the DefaultExecutionSpace)
+  // Define the execution space for the functor (overrides the
+  // DefaultExecutionSpace)
   typedef Device execution_space;
 
   // Get the view types on the particular device the functor is instantiated for
   idx_type::const_type idx;
   view_type dest;
-  Kokkos::View<view_type::const_data_type, view_type::array_layout, view_type::device_type, Kokkos::MemoryRandomAccess > src;
+  Kokkos::View<view_type::const_data_type, view_type::array_layout,
+               view_type::device_type, Kokkos::MemoryRandomAccess>
+      src;
 
-  localsum(idx_type idx_, view_type dest_,
-      view_type src_):idx(idx_),dest(dest_),src(src_) {
-  }
+  localsum(idx_type idx_, view_type dest_, view_type src_)
+      : idx(idx_), dest(dest_), src(src_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i) const {
+  void operator()(int i) const {
     double tmp = 0.0;
-    for(int j = 0; j < int(idx.extent(1)); j++) {
-      const double val = src(idx(i,j));
-      tmp += val*val + 0.5*(idx.extent(0)*val -idx.extent(1)*val);
+    for (int j = 0; j < int(idx.extent(1)); j++) {
+      const double val = src(idx(i, j));
+      tmp += val * val + 0.5 * (idx.extent(0) * val - idx.extent(1) * val);
     }
     dest(i) += tmp;
   }
 };
 
 int main(int narg, char* arg[]) {
-  Kokkos::initialize(narg,arg);
+  Kokkos::initialize(narg, arg);
 
   {
     int size = 1000000;
 
     // Create Views
-    idx_type idx("Idx",size,64);
-    view_type dest("Dest",size);
-    view_type src("Src",size);
+    idx_type idx("Idx", size, 64);
+    view_type dest("Dest", size);
+    view_type src("Src", size);
 
     srand(134231);
 
     Kokkos::fence();
 
     // When using UVM Cuda views can be accessed on the Host directly
-    for(int i=0; i<size; i++) {
-      for(int j=0; j<int(idx.extent(1)); j++)
-        idx(i,j) = (size + i + (rand()%500 - 250))%size;
+    for (int i = 0; i < size; i++) {
+      for (int j = 0; j < int(idx.extent(1)); j++)
+        idx(i, j) = (size + i + (rand() % 500 - 250)) % size;
     }
 
     Kokkos::fence();
     // Run on the device
-    // This will cause a sync of idx to the device since it was modified on the host
+    // This will cause a sync of idx to the device since it was modified on the
+    // host
     Kokkos::Timer timer;
-    Kokkos::parallel_for(size,localsum<view_type::execution_space>(idx,dest,src));
+    Kokkos::parallel_for(size,
+                         localsum<view_type::execution_space>(idx, dest, src));
     Kokkos::fence();
     double sec1_dev = timer.seconds();
 
     // No data transfer will happen now, since nothing is accessed on the host
     timer.reset();
-    Kokkos::parallel_for(size,localsum<view_type::execution_space>(idx,dest,src));
+    Kokkos::parallel_for(size,
+                         localsum<view_type::execution_space>(idx, dest, src));
     Kokkos::fence();
     double sec2_dev = timer.seconds();
 
     // Run on the host
-    // This will cause a sync back to the host of dest which was changed on the device
-    // Compare runtime here with the dual_view example: dest will be copied back in 4k blocks
-    // when they are accessed the first time during the parallel_for. Due to the latency of a memcpy
-    // this gives lower effective bandwidth when doing a manual copy via dual views
+    // This will cause a sync back to the host of dest which was changed on the
+    // device Compare runtime here with the dual_view example: dest will be
+    // copied back in 4k blocks when they are accessed the first time during the
+    // parallel_for. Due to the latency of a memcpy this gives lower effective
+    // bandwidth when doing a manual copy via dual views
     timer.reset();
-    Kokkos::parallel_for(size,localsum<Kokkos::HostSpace::execution_space>(idx,dest,src));
+    Kokkos::parallel_for(
+        size, localsum<Kokkos::HostSpace::execution_space>(idx, dest, src));
     Kokkos::fence();
     double sec1_host = timer.seconds();
 
     // No data transfers will happen now
     timer.reset();
-    Kokkos::parallel_for(size,localsum<Kokkos::HostSpace::execution_space>(idx,dest,src));
+    Kokkos::parallel_for(
+        size, localsum<Kokkos::HostSpace::execution_space>(idx, dest, src));
     Kokkos::fence();
     double sec2_host = timer.seconds();
 
-
-
-    printf("Device Time with Sync: %e without Sync: %e \n",sec1_dev,sec2_dev);
-    printf("Host   Time with Sync: %e without Sync: %e \n",sec1_host,sec2_host);
+    printf("Device Time with Sync: %e without Sync: %e \n", sec1_dev, sec2_dev);
+    printf("Host   Time with Sync: %e without Sync: %e \n", sec1_host,
+           sec2_host);
   }
 
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/07_Overlapping_DeepCopy/overlapping_deepcopy.cpp b/lib/kokkos/example/tutorial/Advanced_Views/07_Overlapping_DeepCopy/overlapping_deepcopy.cpp
index e115dcbabd7a0836568a574d5813ac5d9f2eb590..4dac1c26e0dee6aee0e92f9b08a061328c24acc9 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/07_Overlapping_DeepCopy/overlapping_deepcopy.cpp
+++ b/lib/kokkos/example/tutorial/Advanced_Views/07_Overlapping_DeepCopy/overlapping_deepcopy.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -49,100 +50,100 @@
 
 struct FillDevice {
   double value;
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> a;
-  FillDevice(const double& val, const Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace>& d_a):
-     value(val),a(d_a){}
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> a;
+  FillDevice(
+      const double& val,
+      const Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace>& d_a)
+      : value(val), a(d_a) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int& i) const {
-    a(i) = value;
-  }
+  void operator()(const int& i) const { a(i) = value; }
 };
 
 struct ComputeADevice {
   int iter;
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> a;
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> b;
-  ComputeADevice(const int& iter_,
-                 const Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace>& d_a,
-                 const Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace>& d_b):
-     iter(iter_),a(d_a),b(d_b){}
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> a;
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> b;
+  ComputeADevice(
+      const int& iter_,
+      const Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace>& d_a,
+      const Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace>& d_b)
+      : iter(iter_), a(d_a), b(d_b) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int& i) const {
-    for(int j=1;j<iter;j++) {
-      a(i) += std::pow(b(i),1.0+1.0/iter);
+  void operator()(const int& i) const {
+    for (int j = 1; j < iter; j++) {
+      a(i) += std::pow(b(i), 1.0 + 1.0 / iter);
     }
   }
 };
 
 struct ComputeAHost {
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaHostPinnedSpace> a;
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaHostPinnedSpace> b;
-  ComputeAHost(  const Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaHostPinnedSpace>& d_a,
-                 const Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaHostPinnedSpace>& d_b):
-     a(d_a),b(d_b){}
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaHostPinnedSpace> a;
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaHostPinnedSpace> b;
+  ComputeAHost(const Kokkos::View<double*, Kokkos::LayoutLeft,
+                                  Kokkos::CudaHostPinnedSpace>& d_a,
+               const Kokkos::View<double*, Kokkos::LayoutLeft,
+                                  Kokkos::CudaHostPinnedSpace>& d_b)
+      : a(d_a), b(d_b) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int& i) const {
-    a(i) += b(i);
-  }
+  void operator()(const int& i) const { a(i) += b(i); }
 };
 
 struct MergeDevice {
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> a;
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> b;
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> a;
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> b;
   MergeDevice(
-                 const Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace>& d_a,
-                 const Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace>& d_b):
-     a(d_a),b(d_b){}
+      const Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace>& d_a,
+      const Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace>& d_b)
+      : a(d_a), b(d_b) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (const int& i) const {
-    a(i) += b(i);
-  }
+  void operator()(const int& i) const { a(i) += b(i); }
 };
 
-int main(int argc, char * argv[]) {
+int main(int argc, char* argv[]) {
   int size = 100000000;
   Kokkos::initialize();
   int synch = atoi(argv[1]);
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> d_a("Device A",size);
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> d_b("Device B",size);
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaSpace> d_tmp("Device tmp",size);
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaHostPinnedSpace> h_a("Host A",size);
-  Kokkos::View<double*,Kokkos::LayoutLeft,Kokkos::CudaHostPinnedSpace> h_b("Host B",size);
-
-  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0,size),FillDevice(0.0,d_a));
-  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0,size),FillDevice(1.3513,d_b));
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> d_a("Device A",
+                                                                   size);
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> d_b("Device B",
+                                                                   size);
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaSpace> d_tmp(
+      "Device tmp", size);
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaHostPinnedSpace> h_a(
+      "Host A", size);
+  Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::CudaHostPinnedSpace> h_b(
+      "Host B", size);
+
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0, size),
+                       FillDevice(0.0, d_a));
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0, size),
+                       FillDevice(1.3513, d_b));
   Kokkos::fence();
   Kokkos::Timer timer;
-  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0,size),ComputeADevice(20,d_a,d_b));
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0, size),
+                       ComputeADevice(20, d_a, d_b));
 
-  if(synch==1)
-    Kokkos::deep_copy(Kokkos::OpenMP(),h_b,d_b);
-  if(synch==2)
-    Kokkos::deep_copy(h_b,d_b);
+  if (synch == 1) Kokkos::deep_copy(Kokkos::OpenMP(), h_b, d_b);
+  if (synch == 2) Kokkos::deep_copy(h_b, d_b);
 
-
-  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::OpenMP>(0,size),[=] (const int& i) {
-    h_a(i) = 0.0;
-  });
-  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::OpenMP>(0,size),ComputeAHost(h_a,h_b));
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::OpenMP>(0, size),
+                       [=](const int& i) { h_a(i) = 0.0; });
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::OpenMP>(0, size),
+                       ComputeAHost(h_a, h_b));
   Kokkos::OpenMP().fence();
-  if(synch==1)
-    Kokkos::deep_copy(Kokkos::OpenMP(), d_tmp,h_a);
-  if(synch==2)
-    Kokkos::deep_copy(d_tmp,h_a);
+  if (synch == 1) Kokkos::deep_copy(Kokkos::OpenMP(), d_tmp, h_a);
+  if (synch == 2) Kokkos::deep_copy(d_tmp, h_a);
   Kokkos::fence();
 
   std::cout << "Time " << timer.seconds() << std::endl;
-  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0,size),MergeDevice(d_a,d_tmp));
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Cuda>(0, size),
+                       MergeDevice(d_a, d_tmp));
 
-  Kokkos::deep_copy(h_a,d_a);
+  Kokkos::deep_copy(h_a, d_a);
   std::cout << "h_a(0): " << h_a(0) << " ( Correct: 27.4154 )" << std::endl;
   Kokkos::finalize();
 }
-
-
-
diff --git a/lib/kokkos/example/tutorial/Advanced_Views/CMakeLists.txt b/lib/kokkos/example/tutorial/Advanced_Views/CMakeLists.txt
index f4f1addc5553d9ce7131456f02af664554757daa..11da617b8fa0bab71b80ffadae3d8f22b79dd510 100644
--- a/lib/kokkos/example/tutorial/Advanced_Views/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Advanced_Views/CMakeLists.txt
@@ -1,9 +1,9 @@
 
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(01_data_layouts)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(02_memory_traits)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(03_subviews)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(04_dualviews)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(01_data_layouts)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(02_memory_traits)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(03_subviews)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(04_dualviews)
 
-IF (Kokkos_ENABLE_Cuda_UVM)
-  TRIBITS_ADD_EXAMPLE_DIRECTORIES(05_NVIDIA_UVM)
+IF (Kokkos_ENABLE_CUDA_UVM)
+  KOKKOS_ADD_EXAMPLE_DIRECTORIES(05_NVIDIA_UVM)
 ENDIF ()
diff --git a/lib/kokkos/example/tutorial/Algorithms/01_random_numbers/random_numbers.cpp b/lib/kokkos/example/tutorial/Algorithms/01_random_numbers/random_numbers.cpp
index f2095e346ff98334ed8fda33d97fdb1c9011b2b2..a0771c4fcac33b461392168564e6e7981359b439 100644
--- a/lib/kokkos/example/tutorial/Algorithms/01_random_numbers/random_numbers.cpp
+++ b/lib/kokkos/example/tutorial/Algorithms/01_random_numbers/random_numbers.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -49,106 +50,109 @@
 
 typedef Kokkos::HostSpace::execution_space DefaultHostType;
 
-// Kokkos provides two different random number generators with a 64 bit and a 1024 bit state.
-// These generators are based on Vigna, Sebastiano (2014). "An experimental exploration of Marsaglia's xorshift generators, scrambled"
-// See: http://arxiv.org/abs/1402.6246
-// The generators can be used fully independently on each thread and have been tested to
-// produce good statistics for both inter and intra thread numbers.
-// Note that within a kernel NO random number operations are (team) collective operations.
-// Everything can be called within branches. This is a difference to the curand library where
-// certain operations are required to be called by all threads in a block.
+// Kokkos provides two different random number generators with a 64 bit and a
+// 1024 bit state. These generators are based on Vigna, Sebastiano (2014). "An
+// experimental exploration of Marsaglia's xorshift generators, scrambled" See:
+// http://arxiv.org/abs/1402.6246 The generators can be used fully independently
+// on each thread and have been tested to produce good statistics for both inter
+// and intra thread numbers. Note that within a kernel NO random number
+// operations are (team) collective operations. Everything can be called within
+// branches. This is a difference to the curand library where certain operations
+// are required to be called by all threads in a block.
 //
-// In Kokkos you are required to create a pool of generator states, so that threads can
-// grep their own. On CPU architectures the pool size is equal to the thread number,
-// on CUDA about 128k states are generated (enough to give every potentially simultaneously
-// running thread its own state). With a kernel a thread is required to acquire a state from the
-// pool and later return it.
-// On CPUs the Random number generator is deterministic if using the same number of threads.
-// On GPUs (i.e. using the CUDA backend it is not deterministic because threads acquire states via
-// atomics.
-
-// A Functor for generating uint64_t random numbers templated on the GeneratorPool type
-template<class GeneratorPool>
+// In Kokkos you are required to create a pool of generator states, so that
+// threads can grep their own. On CPU architectures the pool size is equal to
+// the thread number, on CUDA about 128k states are generated (enough to give
+// every potentially simultaneously running thread its own state). With a kernel
+// a thread is required to acquire a state from the pool and later return it. On
+// CPUs the Random number generator is deterministic if using the same number of
+// threads. On GPUs (i.e. using the CUDA backend it is not deterministic because
+// threads acquire states via atomics.
+
+// A Functor for generating uint64_t random numbers templated on the
+// GeneratorPool type
+template <class GeneratorPool>
 struct generate_random {
-
-
   // Output View for the random numbers
   Kokkos::View<uint64_t*> vals;
-  
+
   // The GeneratorPool
   GeneratorPool rand_pool;
-  
+
   int samples;
 
   // Initialize all members
-  generate_random(Kokkos::View<uint64_t*> vals_,
-                       GeneratorPool rand_pool_,
-                       int samples_):
-                       vals(vals_),rand_pool(rand_pool_),samples(samples_) {}
+  generate_random(Kokkos::View<uint64_t*> vals_, GeneratorPool rand_pool_,
+                  int samples_)
+      : vals(vals_), rand_pool(rand_pool_), samples(samples_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() (int i) const {
+  void operator()(int i) const {
     // Get a random number state from the pool for the active thread
     typename GeneratorPool::generator_type rand_gen = rand_pool.get_state();
 
-    // Draw samples numbers from the pool as urand64 between 0 and rand_pool.MAX_URAND64
-    // Note there are function calls to get other type of scalars, and also to specify
-    // Ranges or get a normal distributed float.
-    for(int k = 0;k<samples;k++)
-      vals(i*samples+k) = rand_gen.urand64();
+    // Draw samples numbers from the pool as urand64 between 0 and
+    // rand_pool.MAX_URAND64 Note there are function calls to get other type of
+    // scalars, and also to specify Ranges or get a normal distributed float.
+    for (int k = 0; k < samples; k++)
+      vals(i * samples + k) = rand_gen.urand64();
 
     // Give the state back, which will allow another thread to acquire it
     rand_pool.free_state(rand_gen);
   }
 };
 
-
-
-
 int main(int argc, char* args[]) {
-  if (argc != 3){
-	printf("Please pass two integers on the command line\n");
-  }
-  else {
-
-  // Initialize Kokkos
-  Kokkos::initialize(argc,args);
-  int size = atoi(args[1]);
-  int samples = atoi(args[2]);
-
-  // Create two random number generator pools one for 64bit states and one for 1024 bit states
-  // Both take an 64 bit unsigned integer seed to initialize a Random_XorShift64 generator which
-  // is used to fill the generators of the pool.
-  Kokkos::Random_XorShift64_Pool<> rand_pool64(5374857);
-  Kokkos::Random_XorShift1024_Pool<> rand_pool1024(5374857);
-  Kokkos::DualView<uint64_t*> vals("Vals",size*samples);
-
-  // Run some performance comparisons
-  Kokkos::Timer timer;
-  Kokkos::parallel_for(size,generate_random<Kokkos::Random_XorShift64_Pool<> >(vals.d_view,rand_pool64,samples));
-  Kokkos::fence();
-
-  timer.reset();
-  Kokkos::parallel_for(size,generate_random<Kokkos::Random_XorShift64_Pool<> >(vals.d_view,rand_pool64,samples));
-  Kokkos::fence();
-  double time_64 = timer.seconds();
-
-  Kokkos::parallel_for(size,generate_random<Kokkos::Random_XorShift1024_Pool<> >(vals.d_view,rand_pool1024,samples));
-  Kokkos::fence();
-
-  timer.reset();
-  Kokkos::parallel_for(size,generate_random<Kokkos::Random_XorShift1024_Pool<> >(vals.d_view,rand_pool1024,samples));
-  Kokkos::fence();
-  double time_1024 = timer.seconds();
-
-  printf("#Time XorShift64*:   %e %e\n",time_64,1.0e-9*samples*size/time_64 );
-  printf("#Time XorShift1024*: %e %e\n",time_1024,1.0e-9*samples*size/time_1024 );
-
-  Kokkos::deep_copy(vals.h_view,vals.d_view);
-
-  Kokkos::finalize();
+  if (argc != 3) {
+    printf("Please pass two integers on the command line\n");
+  } else {
+    // Initialize Kokkos
+    Kokkos::initialize(argc, args);
+    int size    = atoi(args[1]);
+    int samples = atoi(args[2]);
+
+    // Create two random number generator pools one for 64bit states and one for
+    // 1024 bit states Both take an 64 bit unsigned integer seed to initialize a
+    // Random_XorShift64 generator which is used to fill the generators of the
+    // pool.
+    Kokkos::Random_XorShift64_Pool<> rand_pool64(5374857);
+    Kokkos::Random_XorShift1024_Pool<> rand_pool1024(5374857);
+    Kokkos::DualView<uint64_t*> vals("Vals", size * samples);
+
+    // Run some performance comparisons
+    Kokkos::Timer timer;
+    Kokkos::parallel_for(size,
+                         generate_random<Kokkos::Random_XorShift64_Pool<> >(
+                             vals.d_view, rand_pool64, samples));
+    Kokkos::fence();
+
+    timer.reset();
+    Kokkos::parallel_for(size,
+                         generate_random<Kokkos::Random_XorShift64_Pool<> >(
+                             vals.d_view, rand_pool64, samples));
+    Kokkos::fence();
+    double time_64 = timer.seconds();
+
+    Kokkos::parallel_for(size,
+                         generate_random<Kokkos::Random_XorShift1024_Pool<> >(
+                             vals.d_view, rand_pool1024, samples));
+    Kokkos::fence();
+
+    timer.reset();
+    Kokkos::parallel_for(size,
+                         generate_random<Kokkos::Random_XorShift1024_Pool<> >(
+                             vals.d_view, rand_pool1024, samples));
+    Kokkos::fence();
+    double time_1024 = timer.seconds();
+
+    printf("#Time XorShift64*:   %e %e\n", time_64,
+           1.0e-9 * samples * size / time_64);
+    printf("#Time XorShift1024*: %e %e\n", time_1024,
+           1.0e-9 * samples * size / time_1024);
+
+    Kokkos::deep_copy(vals.h_view, vals.d_view);
+
+    Kokkos::finalize();
   }
   return 0;
 }
-
-
diff --git a/lib/kokkos/example/tutorial/CMakeLists.txt b/lib/kokkos/example/tutorial/CMakeLists.txt
index 613e460cad3c9762f1fb754693d4cd287c7b7a1e..2d8259506a40e3d25a5d650a08414f39afc78140 100644
--- a/lib/kokkos/example/tutorial/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/CMakeLists.txt
@@ -1,17 +1,17 @@
 
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(01_hello_world)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(02_simple_reduce)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(03_simple_view)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(04_simple_memoryspaces)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(05_simple_atomics)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(06_simple_mdrangepolicy)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(Advanced_Views)
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(Hierarchical_Parallelism)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(01_hello_world)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(02_simple_reduce)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(03_simple_view)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(04_simple_memoryspaces)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(05_simple_atomics)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(06_simple_mdrangepolicy)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(Advanced_Views)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(Hierarchical_Parallelism)
 
 IF (Kokkos_ENABLE_CXX11)
-  TRIBITS_ADD_EXAMPLE_DIRECTORIES(01_hello_world_lambda)
-  TRIBITS_ADD_EXAMPLE_DIRECTORIES(02_simple_reduce_lambda)
-  TRIBITS_ADD_EXAMPLE_DIRECTORIES(03_simple_view_lambda)
+  KOKKOS_ADD_EXAMPLE_DIRECTORIES(01_hello_world_lambda)
+  KOKKOS_ADD_EXAMPLE_DIRECTORIES(02_simple_reduce_lambda)
+  KOKKOS_ADD_EXAMPLE_DIRECTORIES(03_simple_view_lambda)
 ENDIF ()
 
 
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/CMakeLists.txt b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/CMakeLists.txt
index 2d8a514a4549aad63f735721b41e47516a570070..e7cd6dea07fc86821911e265ee276aee331f97d5 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_hierarchicalparallelism_01_thread_teams
   SOURCES thread_teams.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp
index e8c1550fc6aa0e1c7273ef1888e9152324d84726..77a5b4ce91ac02f34fa6417f45146952a689dbdf 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -51,16 +52,17 @@
 // to identify a thread uniquely and some team related function calls such as a
 // barrier (which will be used in a subsequent example).
 // A ThreadTeam consists of 1 to n threads where the maxmimum value of n is
-// determined by the hardware. On a dual socket CPU machine with 8 cores per socket
-// the maximum size of a team is 8. The number of teams (i.e. the league_size) is
-// not limited by physical constraints. Its a pure logical number.
+// determined by the hardware. On a dual socket CPU machine with 8 cores per
+// socket the maximum size of a team is 8. The number of teams (i.e. the
+// league_size) is not limited by physical constraints. Its a pure logical
+// number.
 
-typedef Kokkos::TeamPolicy<>              team_policy ;
-typedef team_policy::member_type team_member ;
+typedef Kokkos::TeamPolicy<> team_policy;
+typedef team_policy::member_type team_member;
 
 // Define a functor which can be launched using the TeamPolicy
 struct hello_world {
-  typedef int value_type; //Specify value type for reduction target, sum
+  typedef int value_type;  // Specify value type for reduction target, sum
 
   // This is a reduction operator which now takes as first argument the
   // TeamPolicy member_type. Every member of the team contributes to the
@@ -68,36 +70,39 @@ struct hello_world {
   // It is helpful to think of this operator as a parallel region for a team
   // (i.e. every team member is active and will execute the code).
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const team_member & thread, int& sum) const {
-    sum+=1;
+  void operator()(const team_member& thread, int& sum) const {
+    sum += 1;
     // The TeamPolicy<>::member_type provides functions to query the multi
-    // dimensional index of a thread as well as the number of thread-teams and the size
-    // of each team.
-    printf("Hello World: %i %i // %i %i\n",thread.league_rank(),thread.team_rank(),thread.league_size(),thread.team_size());
+    // dimensional index of a thread as well as the number of thread-teams and
+    // the size of each team.
+    printf("Hello World: %i %i // %i %i\n", thread.league_rank(),
+           thread.team_rank(), thread.league_size(), thread.team_size());
   }
 };
 
 int main(int narg, char* args[]) {
-  Kokkos::initialize(narg,args);
+  Kokkos::initialize(narg, args);
 
   // Launch 12 teams of the maximum number of threads per team
-  const int team_size_max = team_policy(1,1).team_size_max(hello_world(), Kokkos::ParallelReduceTag());
-  const team_policy policy_a( 12 , team_size_max );
+  const int team_size_max = team_policy(1, 1).team_size_max(
+      hello_world(), Kokkos::ParallelReduceTag());
+  const team_policy policy_a(12, team_size_max);
 
   int sum = 0;
-  Kokkos::parallel_reduce( policy_a , hello_world() , sum );
+  Kokkos::parallel_reduce(policy_a, hello_world(), sum);
 
   // The result will be 12*team_size_max
-  printf("Result A: %i == %i\n",sum, team_size_max*12);
+  printf("Result A: %i == %i\n", sum, team_size_max * 12);
 
   // In practice it is often better to let Kokkos decide on the team_size
-  const team_policy policy_b( 12 , Kokkos::AUTO );
+  const team_policy policy_b(12, Kokkos::AUTO);
 
-  Kokkos::parallel_reduce( policy_b , hello_world() , sum );
-  // The result will be 12*policy_b.team_size_recommended( hello_world(),  Kokkos::ParallelReduceTag())
-  const int team_size_recommended = policy_b.team_size_recommended( hello_world(),  Kokkos::ParallelReduceTag());
-  printf("Result B: %i %i\n",sum, team_size_recommended*12);
+  Kokkos::parallel_reduce(policy_b, hello_world(), sum);
+  // The result will be 12*policy_b.team_size_recommended( hello_world(),
+  // Kokkos::ParallelReduceTag())
+  const int team_size_recommended = policy_b.team_size_recommended(
+      hello_world(), Kokkos::ParallelReduceTag());
+  printf("Result B: %i %i\n", sum, team_size_recommended * 12);
 
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/CMakeLists.txt b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/CMakeLists.txt
index ec7f1e1159fcf7f12209defea154c494fb48540e..8c7f3853a014cfe71750060e6d077e1e4f0d777b 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/CMakeLists.txt
@@ -2,12 +2,9 @@
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
-IF (Kokkos_ENABLE_CXX11)
-  # This is a tutorial, not a test, so we don't ask CTest to run it.
-  TRIBITS_ADD_EXECUTABLE(
-    tutorial_hierarchical_01_thread_teams_lambda
-    SOURCES thread_teams_lambda.cpp
-    COMM serial mpi
-    )
-ENDIF ()
+# This is a tutorial, not a test, so we don't ask CTest to run it.
+KOKKOS_ADD_EXECUTABLE(
+  tutorial_hierarchical_01_thread_teams_lambda
+  SOURCES thread_teams_lambda.cpp
+)
 
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp
index d936699a5f9b165600283a193129894f4d6e8ba4..6e29d5c3d66d56f13d413a626cfa06201f5f8361 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -53,17 +54,17 @@
 // some reasonable bound, which eventually depends upon the hardware
 // and programming model implementation).
 
-int main (int narg, char* args[]) {
+int main(int narg, char* args[]) {
   using Kokkos::parallel_reduce;
-  typedef Kokkos::TeamPolicy<>               team_policy;
-  typedef typename team_policy::member_type  team_member;
+  typedef Kokkos::TeamPolicy<> team_policy;
+  typedef typename team_policy::member_type team_member;
 
-  Kokkos::initialize (narg, args);
+  Kokkos::initialize(narg, args);
 
   // Set up a policy that launches 12 teams, with the maximum number
   // of threads per team.
 
-  const team_policy policy (12, Kokkos::AUTO);
+  const team_policy policy(12, Kokkos::AUTO);
 
   // This is a reduction with a team policy.  The team policy changes
   // the first argument of the lambda.  Rather than an integer index
@@ -77,21 +78,23 @@ int main (int narg, char* args[]) {
   // region."  That is, every team member is active and will execute
   // the body of the lambda.
   int sum = 0;
-  // We also need to protect the usage of a lambda against compiling
-  // with a backend which doesn't support it (i.e. Cuda 6.5/7.0).
-  #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-  parallel_reduce (policy, KOKKOS_LAMBDA (const team_member& thread, int& lsum) {
-      lsum += 1;
-      // TeamPolicy<>::member_type provides functions to query the
-      // multidimensional index of a thread, as well as the number of
-      // thread teams and the size of each team.
-      printf ("Hello World: %i %i // %i %i\n", thread.league_rank (),
-              thread.team_rank (), thread.league_size (), thread.team_size ());
-    }, sum);
-  #endif
+// We also need to protect the usage of a lambda against compiling
+// with a backend which doesn't support it (i.e. Cuda 6.5/7.0).
+#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
+  parallel_reduce(
+      policy,
+      KOKKOS_LAMBDA(const team_member& thread, int& lsum) {
+        lsum += 1;
+        // TeamPolicy<>::member_type provides functions to query the
+        // multidimensional index of a thread, as well as the number of
+        // thread teams and the size of each team.
+        printf("Hello World: %i %i // %i %i\n", thread.league_rank(),
+               thread.team_rank(), thread.league_size(), thread.team_size());
+      },
+      sum);
+#endif
   // The result will be 12*team_policy::team_size_max([=]{})
-  printf ("Result %i\n",sum);
+  printf("Result %i\n", sum);
 
-  Kokkos::finalize ();
+  Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/CMakeLists.txt b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/CMakeLists.txt
index e660405345167858b985261362d6135d5e6d5c4d..92b701e4f430f1335c9f478ede4955b1b28626f6 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_hierarchicalparallelism_02_nested_parallel_for
   SOURCES nested_parallel_for.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp
index bbb1000e907a8ce65e064d054faf66f549561389..1c0b531c5c60bba143b2bc5135b8c281123ceae8 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -45,46 +46,50 @@
 #include <cstdio>
 
 // See 01_thread_teams for an explanation of a basic TeamPolicy
-typedef Kokkos::TeamPolicy<>              team_policy ;
-typedef typename team_policy::member_type team_member ;
+typedef Kokkos::TeamPolicy<> team_policy;
+typedef typename team_policy::member_type team_member;
 
 struct hello_world {
-  typedef int value_type; //Specify value type for reduction target, sum
+  typedef int value_type;  // Specify value type for reduction target, sum
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const team_member & thread, int& sum) const {
-    sum+=1;
+  void operator()(const team_member& thread, int& sum) const {
+    sum += 1;
     // When using the TeamPolicy Kokkos allows for nested parallel loops.
-    // All three Kokkos parallel patterns are allowed (for, reduce, scan) and they
-    // largely follow the same syntax as on the global level.
-    // The execution policy for the Thread level nesting (the Vector level is in the next
-    // tutorial example) is Kokkos::TeamThreadRange. This means the loop will be executed
-    // by all members of the team and the loop count will be split between threads of the
-    // team. Its arguments are the team_member, and a loop count.
-    // Not every thread will do the same amount of iterations. On a GPU for example with
-    // a team_size() larger than 31 only the first 31 threads would actually do anything.
-    // On a CPU with 8 threads 7 would execute 4 loop iterations, and 1 thread would do
-    // 3. Note also that the mode of splitting the count is architecture dependent similar
-    // to what the RangePolicy on a global level does.
-    // The call itself is not guaranteed to be synchronous. Also keep in mind that the
-    // operator using a team_policy acts like a parallel region for the team. That means
-    // that everything outside of the nested parallel_for is also executed by all threads
-    // of the team.
-    Kokkos::parallel_for(Kokkos::TeamThreadRange(thread,31), [&] (const int& i) {
-       printf("Hello World: (%i , %i) executed loop %i \n",thread.league_rank(),thread.team_rank(),i);
-    });
+    // All three Kokkos parallel patterns are allowed (for, reduce, scan) and
+    // they largely follow the same syntax as on the global level. The execution
+    // policy for the Thread level nesting (the Vector level is in the next
+    // tutorial example) is Kokkos::TeamThreadRange. This means the loop will be
+    // executed by all members of the team and the loop count will be split
+    // between threads of the team. Its arguments are the team_member, and a
+    // loop count. Not every thread will do the same amount of iterations. On a
+    // GPU for example with a team_size() larger than 31 only the first 31
+    // threads would actually do anything. On a CPU with 8 threads 7 would
+    // execute 4 loop iterations, and 1 thread would do
+    // 3. Note also that the mode of splitting the count is architecture
+    // dependent similar to what the RangePolicy on a global level does. The
+    // call itself is not guaranteed to be synchronous. Also keep in mind that
+    // the operator using a team_policy acts like a parallel region for the
+    // team. That means that everything outside of the nested parallel_for is
+    // also executed by all threads of the team.
+    Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, 31),
+                         [&](const int& i) {
+                           printf("Hello World: (%i , %i) executed loop %i \n",
+                                  thread.league_rank(), thread.team_rank(), i);
+                         });
   }
 };
 
 int main(int narg, char* args[]) {
-  Kokkos::initialize(narg,args);
+  Kokkos::initialize(narg, args);
 
   // Launch 3 teams of the maximum number of threads per team
-  const int team_size_max = team_policy(3,1).team_size_max( hello_world(), Kokkos::ParallelReduceTag());
-  const team_policy policy( 3 , team_size_max );
-  
+  const int team_size_max = team_policy(3, 1).team_size_max(
+      hello_world(), Kokkos::ParallelReduceTag());
+  const team_policy policy(3, team_size_max);
+
   int sum = 0;
-  Kokkos::parallel_reduce( policy , hello_world() , sum );
-  printf("Result %i\n",sum);
+  Kokkos::parallel_reduce(policy, hello_world(), sum);
+  printf("Result %i\n", sum);
 
   Kokkos::finalize();
 }
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/CMakeLists.txt b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/CMakeLists.txt
index ea6b0b1e42694c2b0b5994b54309e19647a09e5f..3907d1666486036b512440ea745beb75165104e8 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/CMakeLists.txt
@@ -3,14 +3,8 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-
-IF(Kokkos_ENABLE_CXX11)
-
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_hierarchicalparallelism_03_vectorization
   SOURCES vectorization.cpp
-  COMM serial mpi
-  )
-
-ENDIF()
+)
 
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp
index b97da0fe8708117d5f223aa212c5ce9c67dfd219..cb679f7f5ae77048c505e37e8291a81add78e0a3 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp
@@ -2,10 +2,11 @@
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -45,118 +46,131 @@
 #include <Kokkos_Random.hpp>
 #include <cstdio>
 
-
 // The TeamPolicy actually supports 3D parallelism: Teams, Threads, Vector
 // Kokkos::parallel_{for/reduce/scan} calls can be completely free nested.
 // The execution policies for the nested layers are TeamThreadRange and
 // ThreadVectorRange.
 // The only restriction on nesting is that a given level can only be nested in a
-// higher one. e.g. a ThreadVectorRange can be nested inside a TeamPolicy operator
-// and inside a TeamThreadRange, but you can not nest a ThreadVectorRange or a
-// TeamThreadRange inside another ThreadVectorRange.
-// As with the 2D execution of TeamPolicy the operator has to be considered as
-// a parallel region even with respect to VectorLanes. That means even outside
-// a TeamThread or VectorThread loop all threads of a team and all vector lanes
-// of a thread execute every line of the operator as long as there are no restricitons
-// on them.
-// Code lines can be restricted using Kokkos::single to either execute once PerThread
-// or execute once PerTeam.
-typedef typename Kokkos::TeamPolicy<>::member_type team_member ;
+// higher one. e.g. a ThreadVectorRange can be nested inside a TeamPolicy
+// operator and inside a TeamThreadRange, but you can not nest a
+// ThreadVectorRange or a TeamThreadRange inside another ThreadVectorRange. As
+// with the 2D execution of TeamPolicy the operator has to be considered as a
+// parallel region even with respect to VectorLanes. That means even outside a
+// TeamThread or VectorThread loop all threads of a team and all vector lanes of
+// a thread execute every line of the operator as long as there are no
+// restricitons on them. Code lines can be restricted using Kokkos::single to
+// either execute once PerThread or execute once PerTeam.
+typedef typename Kokkos::TeamPolicy<>::member_type team_member;
 
 struct SomeCorrelation {
-  typedef int value_type; //Specify value type for reduction target, sum
+  typedef int value_type;  // Specify value type for reduction target, sum
   typedef Kokkos::DefaultExecutionSpace::scratch_memory_space shared_space;
-  typedef Kokkos::View<int*,shared_space,Kokkos::MemoryUnmanaged> shared_1d_int;
+  typedef Kokkos::View<int*, shared_space, Kokkos::MemoryUnmanaged>
+      shared_1d_int;
 
-  Kokkos::View<const int***,Kokkos::LayoutRight> data;
+  Kokkos::View<const int***, Kokkos::LayoutRight> data;
   Kokkos::View<int> gsum;
 
-  SomeCorrelation(Kokkos::View<int***,Kokkos::LayoutRight> data_in,
-                  Kokkos::View<int> sum):data(data_in),gsum(sum){}
+  SomeCorrelation(Kokkos::View<int***, Kokkos::LayoutRight> data_in,
+                  Kokkos::View<int> sum)
+      : data(data_in), gsum(sum) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const team_member & thread) const {
+  void operator()(const team_member& thread) const {
     int i = thread.league_rank();
 
     // Allocate a shared array for the team.
-    shared_1d_int count(thread.team_shmem(),data.extent(1));
+    shared_1d_int count(thread.team_shmem(), data.extent(1));
 
     // With each team run a parallel_for with its threads
-    Kokkos::parallel_for(Kokkos::TeamThreadRange(thread,data.extent(1)), [=] (const int& j) {
-      int tsum;
-      // Run a vector loop reduction over the inner dimension of data
-      // Count how many values are multiples of 4
-      // Every vector lane gets the same reduction value (tsum) back, it is broadcast to all vector lanes
-      Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(thread,data.extent(2)), [=] (const int& k, int & vsum) {
-        vsum+= (data(i,j,k) % 4 == 0)?1:0;
-      },tsum);
-
-      // Make sure only one vector lane adds the reduction value to the shared array, i.e. execute
-      // the next line only once PerThread
-      Kokkos::single(Kokkos::PerThread(thread),[=] () {
-        count(j) = tsum;
-      });
-    });
-
-    // Wait for all threads to finish the parallel_for so that all shared memory writes are done
+    Kokkos::parallel_for(
+        Kokkos::TeamThreadRange(thread, data.extent(1)), [=](const int& j) {
+          int tsum;
+          // Run a vector loop reduction over the inner dimension of data
+          // Count how many values are multiples of 4
+          // Every vector lane gets the same reduction value (tsum) back, it is
+          // broadcast to all vector lanes
+          Kokkos::parallel_reduce(
+              Kokkos::ThreadVectorRange(thread, data.extent(2)),
+              [=](const int& k, int& vsum) {
+                vsum += (data(i, j, k) % 4 == 0) ? 1 : 0;
+              },
+              tsum);
+
+          // Make sure only one vector lane adds the reduction value to the
+          // shared array, i.e. execute the next line only once PerThread
+          Kokkos::single(Kokkos::PerThread(thread), [=]() { count(j) = tsum; });
+        });
+
+    // Wait for all threads to finish the parallel_for so that all shared memory
+    // writes are done
     thread.team_barrier();
 
     // Check with one vector lane from each thread how many consecutive
     // data segments have the same number of values divisible by 4
-    // The team reduction value is again broadcast to every team member (and every vector lane)
+    // The team reduction value is again broadcast to every team member (and
+    // every vector lane)
     int team_sum = 0;
-    Kokkos::parallel_reduce(Kokkos::TeamThreadRange(thread, data.extent(1)-1), [=] (const int& j, int& thread_sum) {
-      // It is not valid to directly add to thread_sum
-      // Use a single function with broadcast instead
-      // team_sum will be used as input to the operator (i.e. it is used to initialize sum)
-      // the end value of sum will be broadcast to all vector lanes in the thread.
-      Kokkos::single(Kokkos::PerThread(thread),[=] (int& sum) {
-        if(count(j)==count(j+1)) sum++;
-      },thread_sum);
-    },team_sum);
-
-    // Add with one thread and vectorlane of the team the team_sum to the global value
-    Kokkos::single(Kokkos::PerTeam(thread),[=] () {
-      Kokkos::atomic_add(&gsum(),team_sum);
-    });
+    Kokkos::parallel_reduce(
+        Kokkos::TeamThreadRange(thread, data.extent(1) - 1),
+        [=](const int& j, int& thread_sum) {
+          // It is not valid to directly add to thread_sum
+          // Use a single function with broadcast instead
+          // team_sum will be used as input to the operator (i.e. it is used to
+          // initialize sum) the end value of sum will be broadcast to all
+          // vector lanes in the thread.
+          Kokkos::single(
+              Kokkos::PerThread(thread),
+              [=](int& sum) {
+                if (count(j) == count(j + 1)) sum++;
+              },
+              thread_sum);
+        },
+        team_sum);
+
+    // Add with one thread and vectorlane of the team the team_sum to the global
+    // value
+    Kokkos::single(Kokkos::PerTeam(thread),
+                   [=]() { Kokkos::atomic_add(&gsum(), team_sum); });
   }
 
-  // The functor needs to define how much shared memory it requests given a team_size.
-  size_t team_shmem_size( int team_size ) const {
+  // The functor needs to define how much shared memory it requests given a
+  // team_size.
+  size_t team_shmem_size(int team_size) const {
     return shared_1d_int::shmem_size(data.extent(1));
   }
 };
 
 int main(int narg, char* args[]) {
-  Kokkos::initialize(narg,args);
+  Kokkos::initialize(narg, args);
 
   {
-    // Produce some 3D random data (see Algorithms/01_random_numbers for more info)
-    Kokkos::View<int***,Kokkos::LayoutRight> data("Data",512,512,32);
+    // Produce some 3D random data (see Algorithms/01_random_numbers for more
+    // info)
+    Kokkos::View<int***, Kokkos::LayoutRight> data("Data", 512, 512, 32);
     Kokkos::Random_XorShift64_Pool<> rand_pool64(5374857);
-    Kokkos::fill_random(data,rand_pool64,100);
+    Kokkos::fill_random(data, rand_pool64, 100);
 
     // A global value to put the result in
     Kokkos::View<int> gsum("Sum");
 
     // Each team handles a slice of the data
-    // Set up TeamPolicy with 512 teams with maximum number of threads per team and 16 vector lanes.
-    // Kokkos::AUTO will determine the number of threads
-    // The maximum vector length is hardware dependent but can always be smaller than the hardware allows.
-    // The vector length must be a power of 2.
+    // Set up TeamPolicy with 512 teams with maximum number of threads per team
+    // and 16 vector lanes. Kokkos::AUTO will determine the number of threads
+    // The maximum vector length is hardware dependent but can always be smaller
+    // than the hardware allows. The vector length must be a power of 2.
 
-    const Kokkos::TeamPolicy<> policy( 512 , Kokkos::AUTO , 16);
+    const Kokkos::TeamPolicy<> policy(512, Kokkos::AUTO, 16);
 
-    Kokkos::parallel_for( policy , SomeCorrelation(data,gsum) );
+    Kokkos::parallel_for(policy, SomeCorrelation(data, gsum));
 
     Kokkos::fence();
 
     // Copy result value back
     int sum = 0;
-    Kokkos::deep_copy(sum,gsum);
-    printf("Result %i\n",sum);
+    Kokkos::deep_copy(sum, gsum);
+    printf("Result %i\n", sum);
   }
 
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/CMakeLists.txt b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/CMakeLists.txt
index 15ad5d780340dd0e10c338530f7c88222e742169..d2f83a25eab38a0ed6386f97bf6efec915230593 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/CMakeLists.txt
@@ -3,8 +3,8 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_hierarchicalparallelism_04_team_scan
   SOURCES team_scan.cpp
-  COMM serial mpi
-  )
+)
+
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/team_scan.cpp b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/team_scan.cpp
index 92ef10ec768296efc87596fbdbd2e9229d8495c6..10c8971e5a14bab950f6041dd009e24c18c395a3 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/team_scan.cpp
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/04_team_scan/team_scan.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -47,13 +48,13 @@
 #include <cstdio>
 #include <cstdlib>
 
-typedef Kokkos::DefaultExecutionSpace       Device ;
-typedef Kokkos::HostSpace::execution_space  Host ;
+typedef Kokkos::DefaultExecutionSpace Device;
+typedef Kokkos::HostSpace::execution_space Host;
 
-typedef Kokkos::TeamPolicy< Device >      team_policy ;
-typedef team_policy::member_type team_member ;
+typedef Kokkos::TeamPolicy<Device> team_policy;
+typedef team_policy::member_type team_member;
 
-static const int TEAM_SIZE = 16 ;
+static const int TEAM_SIZE = 16;
 
 struct find_2_tuples {
   int chunk_size;
@@ -61,89 +62,91 @@ struct find_2_tuples {
   Kokkos::View<int**> histogram;
 
   find_2_tuples(int chunk_size_, Kokkos::DualView<int*> data_,
-                Kokkos::DualView<int**> histogram_):chunk_size(chunk_size_),
-                data(data_.d_view),histogram(histogram_.d_view) {
-      data_.sync<Device>();
-      histogram_.sync<Device>();
-      histogram_.modify<Device>();
+                Kokkos::DualView<int**> histogram_)
+      : chunk_size(chunk_size_),
+        data(data_.d_view),
+        histogram(histogram_.d_view) {
+    data_.sync<Device>();
+    histogram_.sync<Device>();
+    histogram_.modify<Device>();
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator() ( const team_member & dev) const {
-    Kokkos::View<int**,Kokkos::MemoryUnmanaged> l_histogram(dev.team_shmem(),TEAM_SIZE,TEAM_SIZE);
-    Kokkos::View<int*,Kokkos::MemoryUnmanaged> l_data(dev.team_shmem(),chunk_size+1);
+  void operator()(const team_member& dev) const {
+    Kokkos::View<int**, Kokkos::MemoryUnmanaged> l_histogram(
+        dev.team_shmem(), TEAM_SIZE, TEAM_SIZE);
+    Kokkos::View<int*, Kokkos::MemoryUnmanaged> l_data(dev.team_shmem(),
+                                                       chunk_size + 1);
 
     const int i = dev.league_rank() * chunk_size;
-    for(int j = dev.team_rank(); j<chunk_size+1; j+=dev.team_size())
-      l_data(j) = data(i+j);
+    for (int j = dev.team_rank(); j < chunk_size + 1; j += dev.team_size())
+      l_data(j) = data(i + j);
 
-    for(int k = dev.team_rank(); k < TEAM_SIZE; k+=dev.team_size())
-      for(int l = 0; l < TEAM_SIZE; l++)
-        l_histogram(k,l) = 0;
+    for (int k = dev.team_rank(); k < TEAM_SIZE; k += dev.team_size())
+      for (int l = 0; l < TEAM_SIZE; l++) l_histogram(k, l) = 0;
     dev.team_barrier();
 
-    for(int j = 0; j<chunk_size; j++) {
-      for(int k = dev.team_rank(); k < TEAM_SIZE; k+=dev.team_size())
-        for(int l = 0; l < TEAM_SIZE; l++) {
-          if((l_data(j) == k) && (l_data(j+1)==l))
-            l_histogram(k,l)++;
+    for (int j = 0; j < chunk_size; j++) {
+      for (int k = dev.team_rank(); k < TEAM_SIZE; k += dev.team_size())
+        for (int l = 0; l < TEAM_SIZE; l++) {
+          if ((l_data(j) == k) && (l_data(j + 1) == l)) l_histogram(k, l)++;
         }
     }
 
-    for(int k = dev.team_rank(); k < TEAM_SIZE; k+=dev.team_size())
-      for(int l = 0; l < TEAM_SIZE; l++) {
-        Kokkos::atomic_fetch_add(&histogram(k,l),l_histogram(k,l));
+    for (int k = dev.team_rank(); k < TEAM_SIZE; k += dev.team_size())
+      for (int l = 0; l < TEAM_SIZE; l++) {
+        Kokkos::atomic_fetch_add(&histogram(k, l), l_histogram(k, l));
       }
     dev.team_barrier();
   }
-  size_t team_shmem_size( int team_size ) const { 
-    return Kokkos::View<int**,Kokkos::MemoryUnmanaged>::shmem_size(TEAM_SIZE,TEAM_SIZE) +
-           Kokkos::View<int*,Kokkos::MemoryUnmanaged>::shmem_size(chunk_size+1);
+  size_t team_shmem_size(int team_size) const {
+    return Kokkos::View<int**, Kokkos::MemoryUnmanaged>::shmem_size(TEAM_SIZE,
+                                                                    TEAM_SIZE) +
+           Kokkos::View<int*, Kokkos::MemoryUnmanaged>::shmem_size(chunk_size +
+                                                                   1);
   }
 };
 
 int main(int narg, char* args[]) {
-  Kokkos::initialize(narg,args);
+  Kokkos::initialize(narg, args);
 
   {
-  int chunk_size = 1024;
-  int nchunks = 100000; //1024*1024;
-  Kokkos::DualView<int*> data("data",nchunks*chunk_size+1);
+    int chunk_size = 1024;
+    int nchunks    = 100000;  // 1024*1024;
+    Kokkos::DualView<int*> data("data", nchunks * chunk_size + 1);
 
-  srand(1231093);
+    srand(1231093);
 
-  for(int i = 0; i < (int) data.extent(0); i++) {
-    data.h_view(i) = rand()%TEAM_SIZE;
-  }
-  data.modify<Host>();
-  data.sync<Device>();
-
-  Kokkos::DualView<int**> histogram("histogram",TEAM_SIZE,TEAM_SIZE);
-
-
-  Kokkos::Timer timer;
-  // threads/team is automatically limited to maximum supported by the device.
-  int team_size = TEAM_SIZE;
-  if( team_size > Device::execution_space::concurrency() )
-    team_size = Device::execution_space::concurrency();
-  Kokkos::parallel_for( team_policy( nchunks , team_size )
-                      , find_2_tuples(chunk_size,data,histogram) );
-  Kokkos::fence();
-  double time = timer.seconds();
-
-  histogram.sync<Host>();
-
-  printf("Time: %f \n\n",time);
-  int sum = 0;
-  for(int k=0; k<TEAM_SIZE; k++) {
-    for(int l=0; l<TEAM_SIZE; l++) {
-      printf("%i ",histogram.h_view(k,l));
-      sum += histogram.h_view(k,l);
+    for (int i = 0; i < (int)data.extent(0); i++) {
+      data.h_view(i) = rand() % TEAM_SIZE;
     }
-    printf("\n");
-  }
-  printf("Result: %i %i\n",sum,chunk_size*nchunks);
+    data.modify<Host>();
+    data.sync<Device>();
+
+    Kokkos::DualView<int**> histogram("histogram", TEAM_SIZE, TEAM_SIZE);
+
+    Kokkos::Timer timer;
+    // threads/team is automatically limited to maximum supported by the device.
+    int team_size = TEAM_SIZE;
+    if (team_size > Device::execution_space::concurrency())
+      team_size = Device::execution_space::concurrency();
+    Kokkos::parallel_for(team_policy(nchunks, team_size),
+                         find_2_tuples(chunk_size, data, histogram));
+    Kokkos::fence();
+    double time = timer.seconds();
+
+    histogram.sync<Host>();
+
+    printf("Time: %f \n\n", time);
+    int sum = 0;
+    for (int k = 0; k < TEAM_SIZE; k++) {
+      for (int l = 0; l < TEAM_SIZE; l++) {
+        printf("%i ", histogram.h_view(k, l));
+        sum += histogram.h_view(k, l);
+      }
+      printf("\n");
+    }
+    printf("Result: %i %i\n", sum, chunk_size * nchunks);
   }
   Kokkos::finalize();
 }
-
diff --git a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/CMakeLists.txt b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/CMakeLists.txt
index e03d7aeb901871aec70c712808dea9c322cd6176..c892df34cd5067fa54b728624a654b9d65711761 100644
--- a/lib/kokkos/example/tutorial/Hierarchical_Parallelism/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/Hierarchical_Parallelism/CMakeLists.txt
@@ -1,8 +1,6 @@
 
-TRIBITS_ADD_EXAMPLE_DIRECTORIES(01_thread_teams)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(01_thread_teams)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(01_thread_teams_lambda)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(02_nested_parallel_for)
+KOKKOS_ADD_EXAMPLE_DIRECTORIES(03_vectorization)
 
-IF (Kokkos_ENABLE_CXX11)
-  TRIBITS_ADD_EXAMPLE_DIRECTORIES(01_thread_teams_lambda)
-  TRIBITS_ADD_EXAMPLE_DIRECTORIES(02_nested_parallel_for)
-  TRIBITS_ADD_EXAMPLE_DIRECTORIES(03_vectorization)
-ENDIF ()
diff --git a/lib/kokkos/example/tutorial/launch_bounds/CMakeLists.txt b/lib/kokkos/example/tutorial/launch_bounds/CMakeLists.txt
index 7c78db840f849fd9625676c6a73e8aa037b52b4d..3d9683500dd472c8f8a8dd95c6a641f861f94545 100644
--- a/lib/kokkos/example/tutorial/launch_bounds/CMakeLists.txt
+++ b/lib/kokkos/example/tutorial/launch_bounds/CMakeLists.txt
@@ -3,8 +3,7 @@ INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 # This is a tutorial, not a test, so we don't ask CTest to run it.
-TRIBITS_ADD_EXECUTABLE(
+KOKKOS_ADD_EXECUTABLE(
   tutorial_02_simple_reduce
   SOURCES simple_reduce.cpp
-  COMM serial mpi
-  )
+)
diff --git a/lib/kokkos/example/tutorial/launch_bounds/launch_bounds_reduce.cpp b/lib/kokkos/example/tutorial/launch_bounds/launch_bounds_reduce.cpp
index 5ff979e86e4bf5a930e353173df1a5f7681cc4b7..800904dbceffb5c10ef2cef36a435542ee834968 100644
--- a/lib/kokkos/example/tutorial/launch_bounds/launch_bounds_reduce.cpp
+++ b/lib/kokkos/example/tutorial/launch_bounds/launch_bounds_reduce.cpp
@@ -1,13 +1,14 @@
 /*
 //@HEADER
 // ************************************************************************
-// 
-//                        Kokkos v. 2.0
-//              Copyright (2014) Sandia Corporation
-// 
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//
+//                        Kokkos v. 3.0
+//       Copyright (2020) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -23,10 +24,10 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -36,7 +37,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-// 
+//
 // ************************************************************************
 //@HEADER
 */
@@ -52,96 +53,92 @@
 //   3. Shut down Kokkos
 //
 struct collision {
-// Reduction functor
-// For each i, we generate 10 hashes, look for and count collisions
-// We use parallel_reduce to count the total collisions
-// Note that we're just counting collisions within the 10 generated
-// one i.
-// This function was chosen as one that very simply can increase the
-// register count.
+  // Reduction functor
+  // For each i, we generate 10 hashes, look for and count collisions
+  // We use parallel_reduce to count the total collisions
+  // Note that we're just counting collisions within the 10 generated
+  // one i.
+  // This function was chosen as one that very simply can increase the
+  // register count.
   typedef int value_type;
 
   KOKKOS_INLINE_FUNCTION
   int hash(int q) const {
-	  // A simple hash by Justin Sobel
-	  // Thanks to Arash Partow (partow.net)
-	  char* fourchars = (char*)&q;
-	  int hash = 1315423911;
-	  for (int i=0; i<4; fourchars++, i++) {
-		  hash ^= ((hash<<5) + *fourchars + (hash >> 2));
-	  }
-	  return hash;
+    // A simple hash by Justin Sobel
+    // Thanks to Arash Partow (partow.net)
+    char* fourchars = (char*)&q;
+    int hash        = 1315423911;
+    for (int i = 0; i < 4; fourchars++, i++) {
+      hash ^= ((hash << 5) + *fourchars + (hash >> 2));
+    }
+    return hash;
   }
 
   KOKKOS_INLINE_FUNCTION
-  void operator () (const int i, int& lsum) const {
-	  //This is a silly function which generates 10 hashes
-	  // then checks for collisions
-	  int a = hash(i)%64;
-	  int b = hash(i*3)%64;
-	  int c = hash(i*5)%64;
-	  int d = hash(i*7)%64;
-	  int e = hash(i*11)%64;
-	  int f = hash(i*17)%64;
-	  int g = hash(i*23)%64;
-	  int h = hash(i*29)%64;
-	  int j = hash(i*31)%64;
-	  int k = hash(i*37)%64;
-
-
-	  if (a==b) lsum++;
-	  if (a==c) lsum++;
-	  if (a==d) lsum++;
-	  if (a==e) lsum++;
-	  if (a==f) lsum++;
-	  if (a==g) lsum++;
-	  if (a==h) lsum++;
-	  if (a==j) lsum++;
-	  if (a==k) lsum++;
-	  if (b==c) lsum++;
-	  if (b==d) lsum++;
-	  if (b==e) lsum++;
-	  if (b==f) lsum++;
-	  if (b==g) lsum++;
-	  if (b==h) lsum++;
-	  if (b==j) lsum++;
-	  if (b==k) lsum++;
-	  if (c==d) lsum++;
-	  if (c==e) lsum++;
-	  if (c==f) lsum++;
-	  if (c==g) lsum++;
-	  if (c==h) lsum++;
-	  if (c==j) lsum++;
-	  if (c==k) lsum++;
-	  if (d==e) lsum++;
-	  if (d==f) lsum++;
-	  if (d==g) lsum++;
-	  if (d==h) lsum++;
-	  if (d==j) lsum++;
-	  if (d==k) lsum++;
-	  if (e==f) lsum++;
-	  if (e==g) lsum++;
-	  if (e==h) lsum++;
-	  if (e==j) lsum++;
-	  if (e==k) lsum++;
-	  if (f==g) lsum++;
-	  if (f==h) lsum++;
-	  if (f==j) lsum++;
-	  if (f==k) lsum++;
-	  if (g==h) lsum++;
-	  if (g==j) lsum++;
-	  if (g==k) lsum++;
-	  if (h==j) lsum++;
-	  if (h==k) lsum++;
-	  if (j==k) lsum++;
+  void operator()(const int i, int& lsum) const {
+    // This is a silly function which generates 10 hashes
+    // then checks for collisions
+    int a = hash(i) % 64;
+    int b = hash(i * 3) % 64;
+    int c = hash(i * 5) % 64;
+    int d = hash(i * 7) % 64;
+    int e = hash(i * 11) % 64;
+    int f = hash(i * 17) % 64;
+    int g = hash(i * 23) % 64;
+    int h = hash(i * 29) % 64;
+    int j = hash(i * 31) % 64;
+    int k = hash(i * 37) % 64;
+
+    if (a == b) lsum++;
+    if (a == c) lsum++;
+    if (a == d) lsum++;
+    if (a == e) lsum++;
+    if (a == f) lsum++;
+    if (a == g) lsum++;
+    if (a == h) lsum++;
+    if (a == j) lsum++;
+    if (a == k) lsum++;
+    if (b == c) lsum++;
+    if (b == d) lsum++;
+    if (b == e) lsum++;
+    if (b == f) lsum++;
+    if (b == g) lsum++;
+    if (b == h) lsum++;
+    if (b == j) lsum++;
+    if (b == k) lsum++;
+    if (c == d) lsum++;
+    if (c == e) lsum++;
+    if (c == f) lsum++;
+    if (c == g) lsum++;
+    if (c == h) lsum++;
+    if (c == j) lsum++;
+    if (c == k) lsum++;
+    if (d == e) lsum++;
+    if (d == f) lsum++;
+    if (d == g) lsum++;
+    if (d == h) lsum++;
+    if (d == j) lsum++;
+    if (d == k) lsum++;
+    if (e == f) lsum++;
+    if (e == g) lsum++;
+    if (e == h) lsum++;
+    if (e == j) lsum++;
+    if (e == k) lsum++;
+    if (f == g) lsum++;
+    if (f == h) lsum++;
+    if (f == j) lsum++;
+    if (f == k) lsum++;
+    if (g == h) lsum++;
+    if (g == j) lsum++;
+    if (g == k) lsum++;
+    if (h == j) lsum++;
+    if (h == k) lsum++;
+    if (j == k) lsum++;
   }
-
-
-
 };
 
-int main (int argc, char* argv[]) {
-  Kokkos::initialize (argc, argv);
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
   const int n = 10000;
 
   // Compute and count hash collisions in
@@ -150,24 +147,26 @@ int main (int argc, char* argv[]) {
   // LaunchBounds functionality
   int sum1 = 0;
   int sum2 = 0;
-  
-  //Without LaunchBounds, the kernel uses 56 registers
-  Kokkos::parallel_reduce (n, collision (), sum1);
 
-  //With LaunchBounds, we can reduce the register usage to 32
-  Kokkos::parallel_reduce (Kokkos::RangePolicy<Kokkos::LaunchBounds<512,4>>(0,n), collision (), sum2);
+  // Without LaunchBounds, the kernel uses 56 registers
+  Kokkos::parallel_reduce(n, collision(), sum1);
 
-  printf ("Number of collisions, "
-          "computed in parallel, is %i\n", sum1);
+  // With LaunchBounds, we can reduce the register usage to 32
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<Kokkos::LaunchBounds<512, 4>>(0, n), collision(),
+      sum2);
+
+  printf(
+      "Number of collisions, "
+      "computed in parallel, is %i\n",
+      sum1);
 
   if (sum1 != sum2) {
-	  printf( "Uh-oh! Results do not match\n");
-	  return -1;
+    printf("Uh-oh! Results do not match\n");
+    return -1;
   }
 
   Kokkos::finalize();
-  
 
   return 0;
 }
-
diff --git a/lib/kokkos/example/virtual_functions/classes.cpp b/lib/kokkos/example/virtual_functions/classes.cpp
index 1b9d7cb385bb8ea7b576e7cd4fea4d7ff2434745..9041f980ed46e7b05cfe3f2f8c5432fba49890d8 100644
--- a/lib/kokkos/example/virtual_functions/classes.cpp
+++ b/lib/kokkos/example/virtual_functions/classes.cpp
@@ -1,26 +1,16 @@
-#include<classes.hpp>
+#include <classes.hpp>
 
 KOKKOS_FUNCTION
-Foo::Foo() {
-  val = 0;
-} 
+Foo::Foo() { val = 0; }
 
 KOKKOS_FUNCTION
-Foo_1::Foo_1() {
-  val = 1;
-}
+Foo_1::Foo_1() { val = 1; }
 
 KOKKOS_FUNCTION
-int Foo_1::value() {
-  return val;  
-}
+int Foo_1::value() { return val; }
 
 KOKKOS_FUNCTION
-Foo_2::Foo_2() {
-  val = 2;
-}
+Foo_2::Foo_2() { val = 2; }
 
 KOKKOS_FUNCTION
-int Foo_2::value() {
-  return val;  
-}
+int Foo_2::value() { return val; }
diff --git a/lib/kokkos/example/virtual_functions/classes.hpp b/lib/kokkos/example/virtual_functions/classes.hpp
index 362c473ce6d23a6814e158127352ba6af6d6e503..4fa9f595024fb5a18fce62e85edaf10e34ddc0c3 100644
--- a/lib/kokkos/example/virtual_functions/classes.hpp
+++ b/lib/kokkos/example/virtual_functions/classes.hpp
@@ -1,39 +1,39 @@
 #ifndef KOKKOS_EXAMPLE_VIRTUAL_FUNCTIONS_CLASSES_HPP
 #define KOKKOS_EXAMPLE_VIRTUAL_FUNCTIONS_CLASSES_HPP
 
-#include<Kokkos_Core.hpp>
+#include <Kokkos_Core.hpp>
 
 class Foo {
-  protected:
-    int val;
-  public:
-    KOKKOS_FUNCTION
-    Foo();
+ protected:
+  int val;
 
-    KOKKOS_FUNCTION
-    virtual int value() { return 0; };
+ public:
+  KOKKOS_FUNCTION
+  Foo();
 
-    KOKKOS_FUNCTION
-    virtual ~Foo() {}
+  KOKKOS_FUNCTION
+  virtual int value() { return 0; };
+
+  KOKKOS_FUNCTION
+  virtual ~Foo() {}
 };
 
-class Foo_1: public Foo {
-  public:
-    KOKKOS_FUNCTION
-    Foo_1();
+class Foo_1 : public Foo {
+ public:
+  KOKKOS_FUNCTION
+  Foo_1();
 
-    KOKKOS_FUNCTION
-    int value();
+  KOKKOS_FUNCTION
+  int value();
 };
 
-class Foo_2: public Foo {
-  public:
-    KOKKOS_FUNCTION
-    Foo_2();
+class Foo_2 : public Foo {
+ public:
+  KOKKOS_FUNCTION
+  Foo_2();
 
-    KOKKOS_FUNCTION
-    int value();
+  KOKKOS_FUNCTION
+  int value();
 };
 
-#endif //KOKKOS_EXAMPLE_VIRTUAL_FUNCTIONS_CLASSES_HPP
-
+#endif  // KOKKOS_EXAMPLE_VIRTUAL_FUNCTIONS_CLASSES_HPP
diff --git a/lib/kokkos/example/virtual_functions/main.cpp b/lib/kokkos/example/virtual_functions/main.cpp
index a16e0cf73fc0ca5ad3f91f713ea63d78746f7eb6..aaa7afb0340ba308caa84021300fec9e72643aee 100644
--- a/lib/kokkos/example/virtual_functions/main.cpp
+++ b/lib/kokkos/example/virtual_functions/main.cpp
@@ -1,32 +1,34 @@
-#include<classes.hpp>
+#include <classes.hpp>
 
 int main(int argc, char* argv[]) {
-  Kokkos::initialize(argc,argv);
+  Kokkos::initialize(argc, argv);
 
   {
-    Foo* f_1 = (Foo*) Kokkos::kokkos_malloc(sizeof(Foo_1));
-    Foo* f_2 = (Foo*) Kokkos::kokkos_malloc(sizeof(Foo_2));
-
-    Kokkos::parallel_for("CreateObjects",1, KOKKOS_LAMBDA (const int&) {
-      new ((Foo_1*)f_1) Foo_1();
-      new ((Foo_2*)f_2) Foo_2();
-    });
-
-    int value_1,value_2;
-    Kokkos::parallel_reduce("CheckValues",1, KOKKOS_LAMBDA (const int&, int& lsum) {
-      lsum = f_1->value();
-    },value_1);
-
-    Kokkos::parallel_reduce("CheckValues",1, KOKKOS_LAMBDA (const int&, int& lsum) {
-      lsum = f_2->value();
-    },value_2);
-
-    printf("Values: %i %i\n",value_1,value_2);
-
-    Kokkos::parallel_for("DestroyObjects",1, KOKKOS_LAMBDA (const int&) {
-      f_1->~Foo();
-      f_2->~Foo();
-    });
+    Foo* f_1 = (Foo*)Kokkos::kokkos_malloc(sizeof(Foo_1));
+    Foo* f_2 = (Foo*)Kokkos::kokkos_malloc(sizeof(Foo_2));
+
+    Kokkos::parallel_for(
+        "CreateObjects", 1, KOKKOS_LAMBDA(const int&) {
+          new ((Foo_1*)f_1) Foo_1();
+          new ((Foo_2*)f_2) Foo_2();
+        });
+
+    int value_1, value_2;
+    Kokkos::parallel_reduce(
+        "CheckValues", 1,
+        KOKKOS_LAMBDA(const int&, int& lsum) { lsum = f_1->value(); }, value_1);
+
+    Kokkos::parallel_reduce(
+        "CheckValues", 1,
+        KOKKOS_LAMBDA(const int&, int& lsum) { lsum = f_2->value(); }, value_2);
+
+    printf("Values: %i %i\n", value_1, value_2);
+
+    Kokkos::parallel_for(
+        "DestroyObjects", 1, KOKKOS_LAMBDA(const int&) {
+          f_1->~Foo();
+          f_2->~Foo();
+        });
 
     Kokkos::kokkos_free(f_1);
     Kokkos::kokkos_free(f_2);
diff --git a/lib/kokkos/generate_makefile.bash b/lib/kokkos/generate_makefile.bash
index d401998a7de63203463a039f3149314297e6b8f4..7ef477b9f20565687892702f2f50328cb8efc699 100755
--- a/lib/kokkos/generate_makefile.bash
+++ b/lib/kokkos/generate_makefile.bash
@@ -2,8 +2,6 @@
 
 KOKKOS_DEVICES=""
 
-KOKKOS_DO_EXAMPLES="1"
-
 while [[ $# > 0 ]]
 do
   key="$1"
@@ -12,9 +10,6 @@ do
     --kokkos-path*)
       KOKKOS_PATH="${key#*=}"
       ;;
-    --qthreads-path*)
-      QTHREADS_PATH="${key#*=}"
-      ;;
     --hpx-path*)
       HPX_PATH="${key#*=}"
       ;;
@@ -34,9 +29,6 @@ do
       KOKKOS_DEVICES="${KOKKOS_DEVICES},Cuda"
       CUDA_PATH="${key#*=}"
       ;;
-    --with-rocm)
-      KOKKOS_DEVICES="${KOKKOS_DEVICES},ROCm"
-      ;;
     --with-openmp)
       KOKKOS_DEVICES="${KOKKOS_DEVICES},OpenMP"
       ;;
@@ -46,12 +38,6 @@ do
     --with-serial)
       KOKKOS_DEVICES="${KOKKOS_DEVICES},Serial"
       ;;
-    --with-qthreads*)
-      KOKKOS_DEVICES="${KOKKOS_DEVICES},Qthreads"
-      if [ -z "$QTHREADS_PATH" ]; then
-        QTHREADS_PATH="${key#*=}"
-      fi
-      ;;
     --with-hpx-options*)
       KOKKOS_HPX_OPT="${key#*=}"
       ;;
@@ -93,9 +79,6 @@ do
       echo "Warning: ${key} is deprecated"
       echo "Call make with appropriate -j flag"
       ;;
-    --no-examples)
-      KOKKOS_DO_EXAMPLES="0"
-      ;;
     --compiler*)
       COMPILER="${key#*=}"
       CNUM=$(command -v ${COMPILER} 2>&1 >/dev/null | grep "no ${COMPILER}" | wc -l)
@@ -128,15 +111,12 @@ do
       echo "Kokkos configure options:"
       echo ""
       echo "--kokkos-path=/Path/To/Kokkos:        Path to the Kokkos root directory."
-      echo "--qthreads-path=/Path/To/Qthreads:    Path to Qthreads install directory."
-      echo "                                        Overrides path given by --with-qthreads."
       echo "--prefix=/Install/Path:               Path to install the Kokkos library."
       echo ""
       echo "--with-cuda[=/Path/To/Cuda]:          Enable Cuda and set path to Cuda Toolkit."
       echo "--with-openmp:                        Enable OpenMP backend."
       echo "--with-pthread:                       Enable Pthreads backend."
       echo "--with-serial:                        Enable Serial backend."
-      echo "--with-qthreads[=/Path/To/Qthreads]:  Enable Qthreads backend."
       echo "--with-devices:                       Explicitly add a set of backends."
       echo ""
       echo "--arch=[OPT]:  Set target architectures. Options are:"
@@ -197,7 +177,7 @@ do
       echo "                                disable_profiling = do not compile with profiling hooks"
       echo "                                "
       echo "--with-cuda-options=[OPT]:    Additional options to CUDA:"
-      echo "                                force_uvm, use_ldg, enable_lambda, rdc"
+      echo "                                force_uvm, use_ldg, enable_lambda, rdc, enable_constexpr"
       echo "--with-hpx-options=[OPT]:     Additional options to HPX:"
       echo "                                enable_async_dispatch"
       echo "--gcc-toolchain=/Path/To/GccRoot:  Set the gcc toolchain to use with clang (e.g. /usr)" 
@@ -232,7 +212,6 @@ fi
 KOKKOS_SRC_PATH=${KOKKOS_PATH}
 
 KOKKOS_SETTINGS="KOKKOS_SRC_PATH=${KOKKOS_SRC_PATH}"
-#KOKKOS_SETTINGS="KOKKOS_PATH=${KOKKOS_PATH}"
 
 # The double [[  ]] in the elif branch is not a typo
 if [ ${#COMPILER} -gt 0 ]; then
@@ -292,10 +271,6 @@ if [ ${#KOKKOS_USE_TPLS} -gt 0 ]; then
   KOKKOS_SETTINGS="${KOKKOS_SETTINGS} KOKKOS_USE_TPLS=${KOKKOS_USE_TPLS}"
 fi
 
-if [ ${#QTHREADS_PATH} -gt 0 ]; then
-  KOKKOS_SETTINGS="${KOKKOS_SETTINGS} QTHREADS_PATH=${QTHREADS_PATH}"
-fi
-
 if [ ${#HPX_PATH} -gt 0 ]; then
     KOKKOS_SETTINGS="${KOKKOS_SETTINGS} HPX_PATH=${HPX_PATH}"
 fi
@@ -318,18 +293,8 @@ fi
 
 KOKKOS_SETTINGS_NO_KOKKOS_PATH="${KOKKOS_SETTINGS}"
 
-KOKKOS_TEST_INSTALL_PATH="${PWD}/install"
-if [ ${#PREFIX} -gt 0 ]; then
-  KOKKOS_INSTALL_PATH="${PREFIX}"
-else
-  KOKKOS_INSTALL_PATH=${KOKKOS_TEST_INSTALL_PATH}
-fi
 
-mkdir -p install
 gen_makefile=Makefile.kokkos
-echo "#Makefile to satisfy existence of target kokkos-clean before installing the library" > install/${gen_makefile}
-echo "kokkos-clean:" >> install/${gen_makefile}
-echo "" >> install/${gen_makefile}
 mkdir -p core
 mkdir -p core/unit_test
 mkdir -p core/perf_test
@@ -346,10 +311,6 @@ mkdir -p example/fenl
 mkdir -p example/make_buildlink
 mkdir -p example/tutorial
 
-if [ ${#KOKKOS_ENABLE_EXAMPLE_ICHOL} -gt 0 ]; then
-  mkdir -p example/ichol
-fi
-
 KOKKOS_SETTINGS="${KOKKOS_SETTINGS_NO_KOKKOS_PATH} KOKKOS_PATH=${KOKKOS_PATH}"
 
 # Generate subdirectory makefiles.
@@ -408,8 +369,6 @@ echo "" >> algorithms/unit_tests/Makefile
 echo "clean:" >> algorithms/unit_tests/Makefile
 echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/algorithms/unit_tests/Makefile ${KOKKOS_SETTINGS} clean" >> algorithms/unit_tests/Makefile
 
-KOKKOS_SETTINGS="${KOKKOS_SETTINGS_NO_KOKKOS_PATH} KOKKOS_PATH=${KOKKOS_TEST_INSTALL_PATH}"
-
 echo "KOKKOS_SETTINGS=${KOKKOS_SETTINGS}" > example/fixture/Makefile
 echo "" >> example/fixture/Makefile
 echo "all:" >> example/fixture/Makefile
@@ -465,55 +424,16 @@ echo "" >> example/tutorial/Makefile
 echo "clean:" >> example/tutorial/Makefile
 echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/example/tutorial/Makefile KOKKOS_SETTINGS='${KOKKOS_SETTINGS}' KOKKOS_PATH=${KOKKOS_PATH} clean" >> example/tutorial/Makefile
 
-if [ ${#KOKKOS_ENABLE_EXAMPLE_ICHOL} -gt 0 ]; then
-echo "KOKKOS_SETTINGS=${KOKKOS_SETTINGS}" > example/ichol/Makefile
-echo "" >> example/ichol/Makefile
-echo "all:" >> example/ichol/Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/example/ichol/Makefile ${KOKKOS_SETTINGS}" >> example/ichol/Makefile
-echo "" >> example/ichol/Makefile
-echo "test: all" >> example/ichol/Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/example/ichol/Makefile ${KOKKOS_SETTINGS} test" >> example/ichol/Makefile
-echo "" >> example/ichol/Makefile
-echo "clean:" >> example/ichol/Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/example/ichol/Makefile ${KOKKOS_SETTINGS} clean" >> example/ichol/Makefile
-fi
-
-KOKKOS_SETTINGS="${KOKKOS_SETTINGS_NO_KOKKOS_PATH} KOKKOS_PATH=${KOKKOS_PATH}"
-
 # Generate top level directory makefile.
 echo "Generating Makefiles with options " ${KOKKOS_SETTINGS}
 echo "KOKKOS_SETTINGS=${KOKKOS_SETTINGS}" > Makefile
 echo "" >> Makefile
-echo "kokkoslib:" >> Makefile
-echo -e "\tcd core; \\" >> Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/core/src/Makefile ${KOKKOS_SETTINGS} PREFIX=${KOKKOS_INSTALL_PATH} build-lib" >> Makefile
-echo "" >> Makefile
-echo "install: kokkoslib" >> Makefile
-echo -e "\tcd core; \\" >> Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/core/src/Makefile ${KOKKOS_SETTINGS} PREFIX=${KOKKOS_INSTALL_PATH} install" >> Makefile
-echo "" >> Makefile
-echo "kokkoslib-test:" >> Makefile
-echo -e "\tcd core; \\" >> Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/core/src/Makefile ${KOKKOS_SETTINGS} PREFIX=${KOKKOS_TEST_INSTALL_PATH} build-lib" >> Makefile
-echo "" >> Makefile
-echo "install-test: kokkoslib-test" >> Makefile
-echo -e "\tcd core; \\" >> Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/core/src/Makefile ${KOKKOS_SETTINGS} PREFIX=${KOKKOS_TEST_INSTALL_PATH} install" >> Makefile
-echo "" >> Makefile
-echo "build-test: install-test" >> Makefile
+echo "build-test:" >> Makefile
 echo -e "\t\$(MAKE) -C core/unit_test" >> Makefile
 echo -e "\t\$(MAKE) -C core/perf_test" >> Makefile
 echo -e "\t\$(MAKE) -C containers/unit_tests" >> Makefile
 echo -e "\t\$(MAKE) -C containers/performance_tests" >> Makefile
 echo -e "\t\$(MAKE) -C algorithms/unit_tests" >> Makefile
-if [ ${KOKKOS_DO_EXAMPLES} -gt 0 ]; then
-$()
-echo -e "\t\$(MAKE) -C example/fixture" >> Makefile
-echo -e "\t\$(MAKE) -C example/feint" >> Makefile
-echo -e "\t\$(MAKE) -C example/fenl" >> Makefile
-echo -e "\t\$(MAKE) -C example/make_buildlink build" >> Makefile
-echo -e "\t\$(MAKE) -C example/tutorial build" >> Makefile
-fi
 echo "" >> Makefile
 echo "test: build-test" >> Makefile
 echo -e "\t\$(MAKE) -C core/unit_test test" >> Makefile
@@ -521,13 +441,6 @@ echo -e "\t\$(MAKE) -C core/perf_test test" >> Makefile
 echo -e "\t\$(MAKE) -C containers/unit_tests test" >> Makefile
 echo -e "\t\$(MAKE) -C containers/performance_tests test" >> Makefile
 echo -e "\t\$(MAKE) -C algorithms/unit_tests test" >> Makefile
-if [ ${KOKKOS_DO_EXAMPLES} -gt 0 ]; then
-echo -e "\t\$(MAKE) -C example/fixture test" >> Makefile
-echo -e "\t\$(MAKE) -C example/feint test" >> Makefile
-echo -e "\t\$(MAKE) -C example/fenl test" >> Makefile
-echo -e "\t\$(MAKE) -C example/make_buildlink test" >> Makefile
-echo -e "\t\$(MAKE) -C example/tutorial test" >> Makefile
-fi
 echo "" >> Makefile
 echo "unit-tests-only:" >> Makefile
 echo -e "\t\$(MAKE) -C core/unit_test test" >> Makefile
@@ -541,13 +454,4 @@ echo -e "\t\$(MAKE) -C core/perf_test clean" >> Makefile
 echo -e "\t\$(MAKE) -C containers/unit_tests clean" >> Makefile
 echo -e "\t\$(MAKE) -C containers/performance_tests clean" >> Makefile
 echo -e "\t\$(MAKE) -C algorithms/unit_tests clean" >> Makefile
-if [ ${KOKKOS_DO_EXAMPLES} -gt 0 ]; then
-echo -e "\t\$(MAKE) -C example/fixture clean" >> Makefile
-echo -e "\t\$(MAKE) -C example/feint clean" >> Makefile
-echo -e "\t\$(MAKE) -C example/fenl clean" >> Makefile
-echo -e "\t\$(MAKE) -C example/make_buildlink clean" >> Makefile
-echo -e "\t\$(MAKE) -C example/tutorial clean" >> Makefile
-fi
-echo -e "\tcd core; \\" >> Makefile
-echo -e "\t\$(MAKE) -f ${KOKKOS_PATH}/core/src/Makefile ${KOKKOS_SETTINGS} clean" >> Makefile
 
diff --git a/lib/kokkos/master_history.txt b/lib/kokkos/master_history.txt
index 3ec4306a9fe841b4751a1c35bb19fc3baf6a460e..ee5238be8c999a20ca371587eb0cf7e2e858a604 100644
--- a/lib/kokkos/master_history.txt
+++ b/lib/kokkos/master_history.txt
@@ -17,3 +17,4 @@ tag:  2.7.00     date: 05:24:2018    master: e01945d0    develop: 2d13f608
 tag:  2.7.24     date: 11:04:2018    master: d3a94192    develop: 7a06fc81
 tag:  2.8.00     date: 02:05:2019    master: 34931a36    develop: d1659d1d
 tag:  2.9.00     date: 06:24:2019    master: 5d6e7fb3    develop: 4c6cb80a
+tag:  3.0.00     date: 01:31:2020    master: 2983b80d    release-candidate-3.0: fdc904a6
diff --git a/src/CLASS2/bond_class2.cpp b/src/CLASS2/bond_class2.cpp
index 0651db75fb035687fad1e43e9b794efc4c592129..097c8fe387afe098bc8ab33e94d33c05ab45604f 100644
--- a/src/CLASS2/bond_class2.cpp
+++ b/src/CLASS2/bond_class2.cpp
@@ -15,6 +15,7 @@
    Contributing author: Eric Simon (Cray)
 ------------------------------------------------------------------------- */
 
+#include <cstring>
 #include "bond_class2.h"
 #include <mpi.h>
 #include <cmath>
@@ -220,3 +221,12 @@ double BondClass2::single(int type, double rsq, int /*i*/, int /*j*/, double &ff
   else fforce = 0.0;
   return (k2[type]*dr2 + k3[type]*dr3 + k4[type]*dr4);
 }
+
+/* ---------------------------------------------------------------------- */
+
+void *BondClass2::extract( char *str, int &dim )
+{
+  dim = 1;
+  if (strcmp(str,"r0")==0) return (void*) r0;
+  return NULL;
+}
diff --git a/src/CLASS2/bond_class2.h b/src/CLASS2/bond_class2.h
index f0fcc6825ef896a5cb6409d6bfb19b576d9b9369..fb7eb884dfa5024970242d8b96842d43ec2d9449 100644
--- a/src/CLASS2/bond_class2.h
+++ b/src/CLASS2/bond_class2.h
@@ -35,6 +35,7 @@ class BondClass2 : public Bond {
   virtual void read_restart(FILE *);
   void write_data(FILE *);
   double single(int, double, int, int, double &);
+  virtual void *extract(char *, int &);
 
  protected:
   double *r0,*k2,*k3,*k4;
diff --git a/src/KOKKOS/angle_charmm_kokkos.cpp b/src/KOKKOS/angle_charmm_kokkos.cpp
index fd9757aab38c9c923f743ac33314499125f38f66..245aead73e01cf7ac51664d959f4f744474c3d16 100644
--- a/src/KOKKOS/angle_charmm_kokkos.cpp
+++ b/src/KOKKOS/angle_charmm_kokkos.cpp
@@ -78,7 +78,7 @@ void AngleCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   if (vflag_atom) {
     //if(k_vatom.extent(0)<maxvatom) { // won't work without adding zero functor
       memoryKK->destroy_kokkos(k_vatom,vatom);
-      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"improper:vatom");
+      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"improper:vatom");
       d_vatom = k_vatom.template view<DeviceType>();
     //}
   }
diff --git a/src/KOKKOS/angle_charmm_kokkos.h b/src/KOKKOS/angle_charmm_kokkos.h
index e1681605627dbc86e0903bc2aca523c9cbb73f74..865439b83a2ceaf8cfa313ea38af1a17cf675c94 100644
--- a/src/KOKKOS/angle_charmm_kokkos.h
+++ b/src/KOKKOS/angle_charmm_kokkos.h
@@ -63,13 +63,13 @@ class AngleCharmmKokkos : public AngleCharmm {
 
   typedef ArrayTypes<DeviceType> AT;
   typename AT::t_x_array_randomread x;
-  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
+  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
   typename AT::t_int_2d anglelist;
 
   Kokkos::DualView<E_FLOAT*,Kokkos::LayoutRight,DeviceType> k_eatom;
   Kokkos::DualView<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType> k_vatom;
-  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
-  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
+  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
+  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
 
   int nlocal,newton_bond;
   int eflag,vflag;
diff --git a/src/KOKKOS/angle_class2_kokkos.cpp b/src/KOKKOS/angle_class2_kokkos.cpp
index 809ce7e7dd128bbf63b29b1c755d7026cdf299c8..50d7391ec56e1a29a244fc788ce37f7ee01e8725 100644
--- a/src/KOKKOS/angle_class2_kokkos.cpp
+++ b/src/KOKKOS/angle_class2_kokkos.cpp
@@ -75,7 +75,7 @@ void AngleClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"angle:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"angle:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -158,7 +158,7 @@ KOKKOS_INLINE_FUNCTION
 void AngleClass2Kokkos<DeviceType>::operator()(TagAngleClass2Compute<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = anglelist(n,0);
   const int i2 = anglelist(n,1);
@@ -495,8 +495,8 @@ void AngleClass2Kokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int i, const in
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.template view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.template view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.template view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.template view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/angle_cosine_kokkos.cpp b/src/KOKKOS/angle_cosine_kokkos.cpp
index da0ff398f19b2a94ad901a679bf407bff5bdfb4f..afb955694d3909f4f5302850455ab87c3440b236 100644
--- a/src/KOKKOS/angle_cosine_kokkos.cpp
+++ b/src/KOKKOS/angle_cosine_kokkos.cpp
@@ -75,7 +75,7 @@ void AngleCosineKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"angle:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"angle:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -141,7 +141,7 @@ KOKKOS_INLINE_FUNCTION
 void AngleCosineKokkos<DeviceType>::operator()(TagAngleCosineCompute<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = anglelist(n,0);
   const int i2 = anglelist(n,1);
@@ -284,8 +284,8 @@ void AngleCosineKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int i, const in
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.template view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.template view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.template view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.template view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/angle_harmonic_kokkos.cpp b/src/KOKKOS/angle_harmonic_kokkos.cpp
index fc274bb89400d97437d82b49ee2a420358feba15..4500e9b3134723101003b127deb11767392f4667 100644
--- a/src/KOKKOS/angle_harmonic_kokkos.cpp
+++ b/src/KOKKOS/angle_harmonic_kokkos.cpp
@@ -75,7 +75,7 @@ void AngleHarmonicKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"angle:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"angle:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -142,7 +142,7 @@ KOKKOS_INLINE_FUNCTION
 void AngleHarmonicKokkos<DeviceType>::operator()(TagAngleHarmonicCompute<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = anglelist(n,0);
   const int i2 = anglelist(n,1);
@@ -302,8 +302,8 @@ void AngleHarmonicKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int i, const
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.template view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.template view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.template view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.template view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/atom_kokkos.h b/src/KOKKOS/atom_kokkos.h
index a83b299ebdb8c16ae1a464369714797429d4c3b7..0ae032032a54e226911e7a5e2d6b068a9181b0ee 100644
--- a/src/KOKKOS/atom_kokkos.h
+++ b/src/KOKKOS/atom_kokkos.h
@@ -83,32 +83,32 @@ class SortFunctor {
   ViewType source;
   Kokkos::View<typename ViewType::non_const_data_type,typename ViewType::array_type,device_type> dest;
   IndexView index;
-  SortFunctor(ViewType src, typename Kokkos::Impl::enable_if<ViewType::dynamic_rank==1,IndexView>::type ind):source(src),index(ind){
+  SortFunctor(ViewType src, typename std::enable_if<ViewType::dynamic_rank==1,IndexView>::type ind):source(src),index(ind){
     dest = Kokkos::View<typename ViewType::non_const_data_type,typename ViewType::array_type,device_type>("",src.extent(0));
   }
-  SortFunctor(ViewType src, typename Kokkos::Impl::enable_if<ViewType::dynamic_rank==2,IndexView>::type ind):source(src),index(ind){
+  SortFunctor(ViewType src, typename std::enable_if<ViewType::dynamic_rank==2,IndexView>::type ind):source(src),index(ind){
     dest = Kokkos::View<typename ViewType::non_const_data_type,typename ViewType::array_type,device_type>("",src.extent(0),src.extent(1));
   }
-  SortFunctor(ViewType src, typename Kokkos::Impl::enable_if<ViewType::dynamic_rank==3,IndexView>::type ind):source(src),index(ind){
+  SortFunctor(ViewType src, typename std::enable_if<ViewType::dynamic_rank==3,IndexView>::type ind):source(src),index(ind){
     dest = Kokkos::View<typename ViewType::non_const_data_type,typename ViewType::array_type,device_type>("",src.extent(0),src.extent(1),src.extent(2));
   }
-  SortFunctor(ViewType src, typename Kokkos::Impl::enable_if<ViewType::dynamic_rank==4,IndexView>::type ind):source(src),index(ind){
+  SortFunctor(ViewType src, typename std::enable_if<ViewType::dynamic_rank==4,IndexView>::type ind):source(src),index(ind){
     dest = Kokkos::View<typename ViewType::non_const_data_type,typename ViewType::array_type,device_type>("",src.extent(0),src.extent(1),src.extent(2),src.extent(3));
   }
   KOKKOS_INLINE_FUNCTION
-  void operator()(const typename Kokkos::Impl::enable_if<ViewType::rank==1, int>::type& i) {
+  void operator()(const typename std::enable_if<ViewType::rank==1, int>::type& i) {
     dest(i) = source(index(i));
   }
-  void operator()(const typename Kokkos::Impl::enable_if<ViewType::rank==2, int>::type& i) {
+  void operator()(const typename std::enable_if<ViewType::rank==2, int>::type& i) {
     for(int j=0;j<source.extent(1);j++)
       dest(i,j) = source(index(i),j);
   }
-  void operator()(const typename Kokkos::Impl::enable_if<ViewType::rank==3, int>::type& i) {
+  void operator()(const typename std::enable_if<ViewType::rank==3, int>::type& i) {
     for(int j=0;j<source.extent(1);j++)
     for(int k=0;k<source.extent(2);k++)
       dest(i,j,k) = source(index(i),j,k);
   }
-  void operator()(const typename Kokkos::Impl::enable_if<ViewType::rank==4, int>::type& i) {
+  void operator()(const typename std::enable_if<ViewType::rank==4, int>::type& i) {
     for(int j=0;j<source.extent(1);j++)
     for(int k=0;k<source.extent(2);k++)
     for(int l=0;l<source.extent(3);l++)
diff --git a/src/KOKKOS/atom_vec_angle_kokkos.cpp b/src/KOKKOS/atom_vec_angle_kokkos.cpp
index 736e1c1fca434846f337bfc96c5e8a95a2d1eecd..5b934e24342d98013d0e709df1d2eabf0a7e46ca 100644
--- a/src/KOKKOS/atom_vec_angle_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_angle_kokkos.cpp
@@ -74,9 +74,9 @@ void AtomVecAngleKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
 
   memoryKK->grow_kokkos(atomKK->k_molecule,atomKK->molecule,nmax,"atom:molecule");
   memoryKK->grow_kokkos(atomKK->k_nspecial,atomKK->nspecial,nmax,3,"atom:nspecial");
diff --git a/src/KOKKOS/atom_vec_atomic_kokkos.cpp b/src/KOKKOS/atom_vec_atomic_kokkos.cpp
index 4fec5740d66d3bc83d54669dd22b64b5ede79178..df30b50dd07d27c7c0b0745661d5cb52118b0b29 100644
--- a/src/KOKKOS/atom_vec_atomic_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_atomic_kokkos.cpp
@@ -70,9 +70,9 @@ void AtomVecAtomicKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
 
   grow_reset();
   atomKK->sync(Host,ALL_MASK);
diff --git a/src/KOKKOS/atom_vec_bond_kokkos.cpp b/src/KOKKOS/atom_vec_bond_kokkos.cpp
index 4475131d77ae356748dcbc9718a690a192675ea0..b614d94bceaf286347a68fa82bcf3a8101b576cf 100644
--- a/src/KOKKOS/atom_vec_bond_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_bond_kokkos.cpp
@@ -73,9 +73,9 @@ void AtomVecBondKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
 
   memoryKK->grow_kokkos(atomKK->k_molecule,atomKK->molecule,nmax,"atom:molecule");
   memoryKK->grow_kokkos(atomKK->k_nspecial,atomKK->nspecial,nmax,3,"atom:nspecial");
diff --git a/src/KOKKOS/atom_vec_charge_kokkos.cpp b/src/KOKKOS/atom_vec_charge_kokkos.cpp
index 3f26b1e9ea4f3504bef56b6743e9e31f4336f025..a9cee3aca864716aad2d1ed24b15310be80b1c5a 100644
--- a/src/KOKKOS/atom_vec_charge_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_charge_kokkos.cpp
@@ -73,9 +73,9 @@ void AtomVecChargeKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
 
   memoryKK->grow_kokkos(atomKK->k_q,atomKK->q,nmax,"atom:q");
 
diff --git a/src/KOKKOS/atom_vec_dpd_kokkos.cpp b/src/KOKKOS/atom_vec_dpd_kokkos.cpp
index 144ef26f198b4033a55684917faf8183bcac04f0..dfc122b1ef931a43a464ef244a4389a3184d24ab 100644
--- a/src/KOKKOS/atom_vec_dpd_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_dpd_kokkos.cpp
@@ -75,9 +75,9 @@ void AtomVecDPDKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
 
 
   memoryKK->grow_kokkos(atomKK->k_rho,atomKK->rho,nmax,"atom:rho");
diff --git a/src/KOKKOS/atom_vec_full_kokkos.cpp b/src/KOKKOS/atom_vec_full_kokkos.cpp
index 1fdbcbec8c9378e2bc3f91145db340d5cba0fa82..b5239867fb7af7c1ff247f045b7567ca1eae02ec 100644
--- a/src/KOKKOS/atom_vec_full_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_full_kokkos.cpp
@@ -73,9 +73,9 @@ void AtomVecFullKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
 
   memoryKK->grow_kokkos(atomKK->k_q,atomKK->q,nmax,"atom:q");
   memoryKK->grow_kokkos(atomKK->k_molecule,atomKK->molecule,nmax,"atom:molecule");
diff --git a/src/KOKKOS/atom_vec_molecular_kokkos.cpp b/src/KOKKOS/atom_vec_molecular_kokkos.cpp
index f3b4ae98ca3da31484602340f1aa35a51bfc4ffd..fec0183971346a72a0ca179263432eff7289b2b3 100644
--- a/src/KOKKOS/atom_vec_molecular_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_molecular_kokkos.cpp
@@ -73,9 +73,9 @@ void AtomVecMolecularKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
 
   memoryKK->grow_kokkos(atomKK->k_molecule,atomKK->molecule,nmax,"atom:molecule");
   memoryKK->grow_kokkos(atomKK->k_nspecial,atomKK->nspecial,nmax,3,"atom:nspecial");
diff --git a/src/KOKKOS/atom_vec_sphere_kokkos.cpp b/src/KOKKOS/atom_vec_sphere_kokkos.cpp
index 67aaa32c219b422795ff4c8131743f770c619847..27a4bd0274a1cb338fa49679566daecfbfb6dba1 100644
--- a/src/KOKKOS/atom_vec_sphere_kokkos.cpp
+++ b/src/KOKKOS/atom_vec_sphere_kokkos.cpp
@@ -107,13 +107,13 @@ void AtomVecSphereKokkos::grow(int n)
   memoryKK->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
   memoryKK->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
-  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
-  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
-  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
+  memoryKK->grow_kokkos(atomKK->k_x,atomKK->x,nmax,"atom:x");
+  memoryKK->grow_kokkos(atomKK->k_v,atomKK->v,nmax,"atom:v");
+  memoryKK->grow_kokkos(atomKK->k_f,atomKK->f,nmax,"atom:f");
   memoryKK->grow_kokkos(atomKK->k_radius,atomKK->radius,nmax,"atom:radius");
   memoryKK->grow_kokkos(atomKK->k_rmass,atomKK->rmass,nmax,"atom:rmass");
-  memoryKK->grow_kokkos(atomKK->k_omega,atomKK->omega,nmax,3,"atom:omega");
-  memoryKK->grow_kokkos(atomKK->k_torque,atomKK->torque,nmax,3,"atom:torque");
+  memoryKK->grow_kokkos(atomKK->k_omega,atomKK->omega,nmax,"atom:omega");
+  memoryKK->grow_kokkos(atomKK->k_torque,atomKK->torque,nmax,"atom:torque");
 
   if (atom->nextra_grow)
     for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
diff --git a/src/KOKKOS/bond_class2_kokkos.cpp b/src/KOKKOS/bond_class2_kokkos.cpp
index 04281bfdd2f27792d3064d285834ea5658d8df59..514c80ddfba02e635ec492a89629a042e116a0bb 100644
--- a/src/KOKKOS/bond_class2_kokkos.cpp
+++ b/src/KOKKOS/bond_class2_kokkos.cpp
@@ -74,7 +74,7 @@ void BondClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   if (vflag_atom) {
     //if(k_vatom.extent(0)<maxvatom) { // won't work without adding zero functor
       memoryKK->destroy_kokkos(k_vatom,vatom);
-      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"improper:vatom");
+      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"improper:vatom");
       d_vatom = k_vatom.template view<DeviceType>();
     //}
   }
diff --git a/src/KOKKOS/bond_class2_kokkos.h b/src/KOKKOS/bond_class2_kokkos.h
index a31ae4b8ae3712896d91e4e35b581d008d88376d..b3c1d5f682bbe7a8a4932fa56a52bd3dbd0f4db9 100644
--- a/src/KOKKOS/bond_class2_kokkos.h
+++ b/src/KOKKOS/bond_class2_kokkos.h
@@ -63,13 +63,13 @@ class BondClass2Kokkos : public BondClass2 {
   class NeighborKokkos *neighborKK;
 
   typename AT::t_x_array_randomread x;
-  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
+  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
   typename AT::t_int_2d bondlist;
 
   Kokkos::DualView<E_FLOAT*,Kokkos::LayoutRight,DeviceType> k_eatom;
   Kokkos::DualView<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType> k_vatom;
-  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
-  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
+  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
+  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
 
   int nlocal,newton_bond;
   int eflag,vflag;
diff --git a/src/KOKKOS/bond_fene_kokkos.cpp b/src/KOKKOS/bond_fene_kokkos.cpp
index 361bb61f7e05312a5a8e56f139ad4aef0d5449ec..864873343d2f554a0949f14f805fcf4becad8eb0 100644
--- a/src/KOKKOS/bond_fene_kokkos.cpp
+++ b/src/KOKKOS/bond_fene_kokkos.cpp
@@ -80,7 +80,7 @@ void BondFENEKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"bond:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"bond:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -166,7 +166,7 @@ void BondFENEKokkos<DeviceType>::operator()(TagBondFENECompute<NEWTON_BOND,EVFLA
   if (d_error_flag()) return;
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = bondlist(n,0);
   const int i2 = bondlist(n,1);
@@ -320,8 +320,8 @@ void BondFENEKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const int
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/bond_harmonic_kokkos.cpp b/src/KOKKOS/bond_harmonic_kokkos.cpp
index 792d98fe88d2d968084f213320b297eb2b5c7279..e0d75dcd9ace7749ebe5322579901524cd73e932 100644
--- a/src/KOKKOS/bond_harmonic_kokkos.cpp
+++ b/src/KOKKOS/bond_harmonic_kokkos.cpp
@@ -75,7 +75,7 @@ void BondHarmonicKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   if (vflag_atom) {
     //if(k_vatom.extent(0)<maxvatom) { // won't work without adding zero functor
       memoryKK->destroy_kokkos(k_vatom,vatom);
-      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"improper:vatom");
+      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"improper:vatom");
       d_vatom = k_vatom.template view<DeviceType>();
     //}
   }
diff --git a/src/KOKKOS/bond_harmonic_kokkos.h b/src/KOKKOS/bond_harmonic_kokkos.h
index 2bf12f3766681064740314ff73117ac0b5226ec4..b5bee7e909f133056d947faf0b240347da1f4a4f 100644
--- a/src/KOKKOS/bond_harmonic_kokkos.h
+++ b/src/KOKKOS/bond_harmonic_kokkos.h
@@ -63,13 +63,13 @@ class BondHarmonicKokkos : public BondHarmonic {
 
   typedef ArrayTypes<DeviceType> AT;
   typename AT::t_x_array_randomread x;
-  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
+  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
   typename AT::t_int_2d bondlist;
 
   Kokkos::DualView<E_FLOAT*,Kokkos::LayoutRight,DeviceType> k_eatom;
   Kokkos::DualView<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType> k_vatom;
-  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
-  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
+  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
+  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
 
   int nlocal,newton_bond;
   int eflag,vflag;
diff --git a/src/KOKKOS/comm_kokkos.cpp b/src/KOKKOS/comm_kokkos.cpp
index a1ece37efd4843e24485f96b32ef0d66a4b3852a..3b9eeaf5833fa6b10c205ae57aa39f6ead6c8ce1 100644
--- a/src/KOKKOS/comm_kokkos.cpp
+++ b/src/KOKKOS/comm_kokkos.cpp
@@ -205,7 +205,7 @@ void CommKokkos::forward_comm_device(int dummy)
           }
           n = avec->pack_comm_kokkos(sendnum[iswap],k_sendlist,
                                      iswap,k_buf_send,pbc_flag[iswap],pbc[iswap]);
-          DeviceType::fence();
+          DeviceType().fence();
           if (n) {
             MPI_Send(k_buf_send.view<DeviceType>().data(),
                      n,MPI_DOUBLE,sendproc[iswap],0,world);
@@ -224,14 +224,14 @@ void CommKokkos::forward_comm_device(int dummy)
           }
           n = avec->pack_comm_vel_kokkos(sendnum[iswap],k_sendlist,iswap,
                                          k_buf_send,pbc_flag[iswap],pbc[iswap]);
-          DeviceType::fence();
+          DeviceType().fence();
           if (n) {
             MPI_Send(k_buf_send.view<DeviceType>().data(),n,
                      MPI_DOUBLE,sendproc[iswap],0,world);
           }
           if (size_forward_recv[iswap]) MPI_Wait(&request,MPI_STATUS_IGNORE);
           avec->unpack_comm_vel_kokkos(recvnum[iswap],firstrecv[iswap],k_buf_recv);
-          DeviceType::fence();
+          DeviceType().fence();
         } else {
           if (size_forward_recv[iswap])
             MPI_Irecv(k_buf_recv.view<DeviceType>().data(),
@@ -239,26 +239,26 @@ void CommKokkos::forward_comm_device(int dummy)
                       recvproc[iswap],0,world,&request);
           n = avec->pack_comm_kokkos(sendnum[iswap],k_sendlist,iswap,
                                      k_buf_send,pbc_flag[iswap],pbc[iswap]);
-          DeviceType::fence();
+          DeviceType().fence();
           if (n)
             MPI_Send(k_buf_send.view<DeviceType>().data(),n,
                      MPI_DOUBLE,sendproc[iswap],0,world);
           if (size_forward_recv[iswap]) MPI_Wait(&request,MPI_STATUS_IGNORE);
           avec->unpack_comm_kokkos(recvnum[iswap],firstrecv[iswap],k_buf_recv);
-          DeviceType::fence();
+          DeviceType().fence();
         }
       } else {
         if (!ghost_velocity) {
           if (sendnum[iswap])
             n = avec->pack_comm_self(sendnum[iswap],k_sendlist,iswap,
                                      firstrecv[iswap],pbc_flag[iswap],pbc[iswap]);
-          DeviceType::fence();
+          DeviceType().fence();
         } else {
           n = avec->pack_comm_vel_kokkos(sendnum[iswap],k_sendlist,iswap,
                                          k_buf_send,pbc_flag[iswap],pbc[iswap]);
-          DeviceType::fence();
+          DeviceType().fence();
           avec->unpack_comm_vel_kokkos(recvnum[iswap],firstrecv[iswap],k_buf_send);
-          DeviceType::fence();
+          DeviceType().fence();
         }
       }
     }
@@ -334,7 +334,7 @@ void CommKokkos::reverse_comm_device()
                     size_reverse_recv[iswap],MPI_DOUBLE,
                     sendproc[iswap],0,world,&request);
         n = avec->pack_reverse_kokkos(recvnum[iswap],firstrecv[iswap],k_buf_send);
-        DeviceType::fence();
+        DeviceType().fence();
         if (n)
           MPI_Send(k_buf_send.view<DeviceType>().data(),n,
                    MPI_DOUBLE,recvproc[iswap],0,world);
@@ -342,7 +342,7 @@ void CommKokkos::reverse_comm_device()
       }
       avec->unpack_reverse_kokkos(sendnum[iswap],k_sendlist,iswap,
                                 k_buf_recv);
-      DeviceType::fence();
+      DeviceType().fence();
     } else {
       if (sendnum[iswap])
         n = avec->unpack_reverse_self(sendnum[iswap],k_sendlist,iswap,
@@ -410,7 +410,7 @@ void CommKokkos::forward_comm_pair_device(Pair *pair)
 
     n = pairKKBase->pack_forward_comm_kokkos(sendnum[iswap],k_sendlist,
                                        iswap,k_buf_send_pair,pbc_flag[iswap],pbc[iswap]);
-    DeviceType::fence();
+    DeviceType().fence();
 
     // exchange with another proc
     // if self, set recv buffer to send buffer
@@ -445,7 +445,7 @@ void CommKokkos::forward_comm_pair_device(Pair *pair)
     // unpack buffer
 
     pairKKBase->unpack_forward_comm_kokkos(recvnum[iswap],firstrecv[iswap],k_buf_recv_pair);
-    DeviceType::fence();
+    DeviceType().fence();
   }
 }
 
@@ -647,7 +647,7 @@ void CommKokkos::exchange_device()
                                      k_exchange_sendlist,k_exchange_copylist,
                                      ExecutionSpaceFromDevice<DeviceType>::space,
                                      dim,lo,hi);
-        DeviceType::fence();
+        DeviceType().fence();
       } else {
         while (i < nlocal) {
           if (x[i][dim] < lo || x[i][dim] >= hi) {
@@ -671,7 +671,7 @@ void CommKokkos::exchange_device()
           atom->nlocal=avec->
             unpack_exchange_kokkos(k_buf_send,nrecv,atom->nlocal,dim,lo,hi,
                                    ExecutionSpaceFromDevice<DeviceType>::space);
-          DeviceType::fence();
+          DeviceType().fence();
         }
       } else {
         MPI_Sendrecv(&nsend,1,MPI_INT,procneigh[dim][0],0,
@@ -704,7 +704,7 @@ void CommKokkos::exchange_device()
           atom->nlocal = avec->
             unpack_exchange_kokkos(k_buf_recv,nrecv,atom->nlocal,dim,lo,hi,
                                    ExecutionSpaceFromDevice<DeviceType>::space);
-          DeviceType::fence();
+          DeviceType().fence();
         }
       }
 
@@ -830,6 +830,10 @@ void CommKokkos::borders_device() {
   ExecutionSpace exec_space = ExecutionSpaceFromDevice<DeviceType>::space;
   atomKK->sync(exec_space,ALL_MASK);
 
+  int team_size = 1;
+  if (exec_space == Device)
+    team_size = 128;
+
   // do swaps over all 3 dimensions
 
   iswap = 0;
@@ -883,7 +887,7 @@ void CommKokkos::borders_device() {
 
             BuildBorderListFunctor<DeviceType> f(atomKK->k_x,k_sendlist,
                 k_total_send,nfirst,nlast,dim,lo,hi,iswap,maxsendlist[iswap]);
-            Kokkos::TeamPolicy<DeviceType> config((nlast-nfirst+127)/128,128);
+            Kokkos::TeamPolicy<DeviceType> config((nlast-nfirst+team_size-1)/team_size,team_size);
             Kokkos::parallel_for(config,f);
 
             k_total_send.template modify<DeviceType>();
@@ -900,7 +904,7 @@ void CommKokkos::borders_device() {
 
               BuildBorderListFunctor<DeviceType> f(atomKK->k_x,k_sendlist,
                   k_total_send,nfirst,nlast,dim,lo,hi,iswap,maxsendlist[iswap]);
-              Kokkos::TeamPolicy<DeviceType> config((nlast-nfirst+127)/128,128);
+              Kokkos::TeamPolicy<DeviceType> config((nlast-nfirst+team_size-1)/team_size,team_size);
               Kokkos::parallel_for(config,f);
 
               k_total_send.template modify<DeviceType>();
@@ -964,13 +968,13 @@ void CommKokkos::borders_device() {
         n = avec->
           pack_border_vel_kokkos(nsend,k_sendlist,k_buf_send,iswap,
                                  pbc_flag[iswap],pbc[iswap],exec_space);
-        DeviceType::fence();
+        DeviceType().fence();
       }
       else {
         n = avec->
           pack_border_kokkos(nsend,k_sendlist,k_buf_send,iswap,
                              pbc_flag[iswap],pbc[iswap],exec_space);
-        DeviceType::fence();
+        DeviceType().fence();
       }
 
       // swap atoms with other proc
@@ -1000,21 +1004,21 @@ void CommKokkos::borders_device() {
         if (sendproc[iswap] != me) {
           avec->unpack_border_vel_kokkos(nrecv,atom->nlocal+atom->nghost,
                                          k_buf_recv,exec_space);
-          DeviceType::fence();
+          DeviceType().fence();
         } else {
           avec->unpack_border_vel_kokkos(nrecv,atom->nlocal+atom->nghost,
                                          k_buf_send,exec_space);
-          DeviceType::fence();
+          DeviceType().fence();
         }
       } else {
         if (sendproc[iswap] != me) {
           avec->unpack_border_kokkos(nrecv,atom->nlocal+atom->nghost,
                                      k_buf_recv,exec_space);
-          DeviceType::fence();
+          DeviceType().fence();
         } else {
           avec->unpack_border_kokkos(nrecv,atom->nlocal+atom->nghost,
                                      k_buf_send,exec_space);
-          DeviceType::fence();
+          DeviceType().fence();
         }
       }
       // set all pointers & counters
diff --git a/src/KOKKOS/dihedral_charmm_kokkos.cpp b/src/KOKKOS/dihedral_charmm_kokkos.cpp
index 94fd0b9bb721d1e1451f8ca1541acb81fbb3b24b..06f25ee0a2d4be7e16f37c115bc66a23e5994dd7 100644
--- a/src/KOKKOS/dihedral_charmm_kokkos.cpp
+++ b/src/KOKKOS/dihedral_charmm_kokkos.cpp
@@ -90,7 +90,7 @@ void DihedralCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   if (vflag_atom) {
     //if(k_vatom.extent(0)<maxvatom) { // won't work without adding zero functor
       memoryKK->destroy_kokkos(k_vatom,vatom);
-      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"dihedral:vatom");
+      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"dihedral:vatom");
       d_vatom = k_vatom.template view<DeviceType>();
       k_vatom_pair = Kokkos::DualView<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType>("dihedral:vatom_pair",maxvatom);
       d_vatom_pair = k_vatom.template view<DeviceType>();
@@ -201,7 +201,7 @@ KOKKOS_INLINE_FUNCTION
 void DihedralCharmmKokkos<DeviceType>::operator()(TagDihedralCharmmCompute<NEWTON_BOND,EVFLAG>, const int &n, EVM_FLOAT& evm) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = dihedrallist(n,0);
   const int i2 = dihedrallist(n,1);
diff --git a/src/KOKKOS/dihedral_charmm_kokkos.h b/src/KOKKOS/dihedral_charmm_kokkos.h
index 449f934533c1d07c84a83c8eab29fcc6f2134055..21bb6fd2e12ee52372dfd1cb3dfb1abee257889d 100644
--- a/src/KOKKOS/dihedral_charmm_kokkos.h
+++ b/src/KOKKOS/dihedral_charmm_kokkos.h
@@ -134,13 +134,13 @@ class DihedralCharmmKokkos : public DihedralCharmm {
 
   Kokkos::DualView<E_FLOAT*,Kokkos::LayoutRight,DeviceType> k_eatom;
   Kokkos::DualView<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType> k_vatom;
-  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
-  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
+  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
+  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
 
   Kokkos::DualView<E_FLOAT*,Kokkos::LayoutRight,DeviceType> k_eatom_pair;
   Kokkos::DualView<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType> k_vatom_pair;
-  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom_pair;
-  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom_pair;
+  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom_pair;
+  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom_pair;
 
   int nlocal,newton_bond;
   int eflag,vflag;
diff --git a/src/KOKKOS/dihedral_class2_kokkos.cpp b/src/KOKKOS/dihedral_class2_kokkos.cpp
index 0310053b5e35f9096972130220c97dd45ccb3f58..adda9c56a9e969c3c9dbe7c8075b4e36fa6d8a0a 100644
--- a/src/KOKKOS/dihedral_class2_kokkos.cpp
+++ b/src/KOKKOS/dihedral_class2_kokkos.cpp
@@ -80,7 +80,7 @@ void DihedralClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"dihedral:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"dihedral:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -197,7 +197,7 @@ KOKKOS_INLINE_FUNCTION
 void DihedralClass2Kokkos<DeviceType>::operator()(TagDihedralClass2Compute<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = dihedrallist(n,0);
   const int i2 = dihedrallist(n,1);
@@ -1015,8 +1015,8 @@ void DihedralClass2Kokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int i1, cons
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/dihedral_harmonic_kokkos.cpp b/src/KOKKOS/dihedral_harmonic_kokkos.cpp
index dd77bc605ba347073e20b90c1721e48f43524b96..15e459f0d5894015dc678497c4adb1fbf41e4165 100644
--- a/src/KOKKOS/dihedral_harmonic_kokkos.cpp
+++ b/src/KOKKOS/dihedral_harmonic_kokkos.cpp
@@ -80,7 +80,7 @@ void DihedralHarmonicKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"dihedral:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"dihedral:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -158,7 +158,7 @@ KOKKOS_INLINE_FUNCTION
 void DihedralHarmonicKokkos<DeviceType>::operator()(TagDihedralHarmonicCompute<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = dihedrallist(n,0);
   const int i2 = dihedrallist(n,1);
@@ -414,8 +414,8 @@ void DihedralHarmonicKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int i1, co
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/dihedral_opls_kokkos.cpp b/src/KOKKOS/dihedral_opls_kokkos.cpp
index 825d106e04c347cfe192498dc7bc0266f974d0ac..cc3cb321c041d75d4ffb7d690f0af122b3eac95a 100644
--- a/src/KOKKOS/dihedral_opls_kokkos.cpp
+++ b/src/KOKKOS/dihedral_opls_kokkos.cpp
@@ -80,7 +80,7 @@ void DihedralOPLSKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"dihedral:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"dihedral:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -157,7 +157,7 @@ KOKKOS_INLINE_FUNCTION
 void DihedralOPLSKokkos<DeviceType>::operator()(TagDihedralOPLSCompute<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   const int i1 = dihedrallist(n,0);
   const int i2 = dihedrallist(n,1);
@@ -419,8 +419,8 @@ void DihedralOPLSKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int i1, const
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/fft3d_kokkos.cpp b/src/KOKKOS/fft3d_kokkos.cpp
index 26e6e93ad9ed3f95f6da70f77da4b00a9df20e7b..fc88136e8cdebc01d8272dacbce1c5d1c9178d04 100644
--- a/src/KOKKOS/fft3d_kokkos.cpp
+++ b/src/KOKKOS/fft3d_kokkos.cpp
@@ -230,7 +230,7 @@ void FFT3dKokkos<DeviceType>::fft_3d_kokkos(typename FFT_AT::t_FFT_DATA_1d d_in,
     cufftExec(plan->plan_fast,d_data.data(),d_data.data(),flag);
   #else
     typename FFT_AT::t_FFT_DATA_1d d_tmp =
-     typename FFT_AT::t_FFT_DATA_1d(Kokkos::view_alloc("fft_3d:tmp",Kokkos::WithoutInitializing),d_in.dimension_0());
+     typename FFT_AT::t_FFT_DATA_1d(Kokkos::view_alloc("fft_3d:tmp",Kokkos::WithoutInitializing),d_in.extent(0));
     kiss_fft_functor<DeviceType> f;
     if (flag == -1)
       f = kiss_fft_functor<DeviceType>(d_data,d_tmp,plan->cfg_fast_forward,length);
@@ -238,7 +238,7 @@ void FFT3dKokkos<DeviceType>::fft_3d_kokkos(typename FFT_AT::t_FFT_DATA_1d d_in,
       f = kiss_fft_functor<DeviceType>(d_data,d_tmp,plan->cfg_fast_backward,length);
     Kokkos::parallel_for(total/length,f);
     d_data = d_tmp;
-    d_tmp = typename FFT_AT::t_FFT_DATA_1d(Kokkos::view_alloc("fft_3d:tmp",Kokkos::WithoutInitializing),d_in.dimension_0());
+    d_tmp = typename FFT_AT::t_FFT_DATA_1d(Kokkos::view_alloc("fft_3d:tmp",Kokkos::WithoutInitializing),d_in.extent(0));
   #endif
 
 
@@ -281,7 +281,7 @@ void FFT3dKokkos<DeviceType>::fft_3d_kokkos(typename FFT_AT::t_FFT_DATA_1d d_in,
       f = kiss_fft_functor<DeviceType>(d_data,d_tmp,plan->cfg_mid_backward,length);
     Kokkos::parallel_for(total/length,f);
     d_data = d_tmp;
-    d_tmp = typename FFT_AT::t_FFT_DATA_1d(Kokkos::view_alloc("fft_3d:tmp",Kokkos::WithoutInitializing),d_in.dimension_0());
+    d_tmp = typename FFT_AT::t_FFT_DATA_1d(Kokkos::view_alloc("fft_3d:tmp",Kokkos::WithoutInitializing),d_in.extent(0));
   #endif
 
   // 2nd mid-remap to prepare for 3rd FFTs
@@ -864,7 +864,7 @@ void FFT3dKokkos<DeviceType>::fft_3d_1d_only_kokkos(typename FFT_AT::t_FFT_DATA_
   cufftExec(plan->plan_slow,d_data.data(),d_data.data(),flag);
 #else
   kiss_fft_functor<DeviceType> f;
-  typename FFT_AT::t_FFT_DATA_1d d_tmp = typename FFT_AT::t_FFT_DATA_1d("fft_3d:tmp",d_data.dimension_0());
+  typename FFT_AT::t_FFT_DATA_1d d_tmp = typename FFT_AT::t_FFT_DATA_1d("fft_3d:tmp",d_data.extent(0));
   if (flag == -1) {
     f = kiss_fft_functor<DeviceType>(d_data,d_tmp,plan->cfg_fast_forward,length1);
     Kokkos::parallel_for(total1/length1,f);
@@ -900,7 +900,7 @@ void FFT3dKokkos<DeviceType>::fft_3d_1d_only_kokkos(typename FFT_AT::t_FFT_DATA_
 
 namespace LAMMPS_NS {
 template class FFT3dKokkos<LMPDeviceType>;
-#ifdef KOKKOS_HAVE_CUDA
+#ifdef KOKKOS_ENABLE_CUDA
 template class FFT3dKokkos<LMPHostType>;
 #endif
 }
diff --git a/src/KOKKOS/fix_qeq_reax_kokkos.cpp b/src/KOKKOS/fix_qeq_reax_kokkos.cpp
index e51fbacaaf90a7b82210400a0062d0bda7cb7b02..a0f4f3ec28ac4df9dccd673de7d5675a9b4973c4 100644
--- a/src/KOKKOS/fix_qeq_reax_kokkos.cpp
+++ b/src/KOKKOS/fix_qeq_reax_kokkos.cpp
@@ -91,10 +91,10 @@ void FixQEqReaxKokkos<DeviceType>::init()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->fix = 1;
@@ -223,7 +223,7 @@ void FixQEqReaxKokkos<DeviceType>::pre_force(int vflag)
 
   // compute_H
 
-  if (lmp->kokkos->ngpus == 0) { // CPU
+  if (execution_space == Host) { // CPU
     if (neighflag == FULL) {
       FixQEqReaxKokkosComputeHFunctor<DeviceType, FULL> computeH_functor(this);
       Kokkos::parallel_scan(inum,computeH_functor);
diff --git a/src/KOKKOS/fix_qeq_reax_kokkos.h b/src/KOKKOS/fix_qeq_reax_kokkos.h
index cd69aa9283da380882f8d8b9d528bf66ec2b4e2d..55dec64d3308fdb70a32353ab543c661d13c109f 100644
--- a/src/KOKKOS/fix_qeq_reax_kokkos.h
+++ b/src/KOKKOS/fix_qeq_reax_kokkos.h
@@ -200,8 +200,8 @@ class FixQEqReaxKokkos : public FixQEqReax {
   HAT::t_ffloat_2d h_s_hist, h_t_hist;
   typename AT::t_ffloat_2d_randomread r_s_hist, r_t_hist;
 
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename AT::t_ffloat_1d::array_layout, DeviceType, Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated> dup_o;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename AT::t_ffloat_1d::array_layout, DeviceType, Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated> ndup_o;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename AT::t_ffloat_1d::array_layout, typename KKDevice<DeviceType>::value, Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated> dup_o;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename AT::t_ffloat_1d::array_layout, typename KKDevice<DeviceType>::value, Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated> ndup_o;
 
   void init_shielding_k();
   void init_hist();
diff --git a/src/KOKKOS/fix_rx_kokkos.cpp b/src/KOKKOS/fix_rx_kokkos.cpp
index e06fc14585a2d4622d72329ea7b67ff796f8f2d2..9271cf1b884f14ab15a0ff6e16f67c2ad3638899 100644
--- a/src/KOKKOS/fix_rx_kokkos.cpp
+++ b/src/KOKKOS/fix_rx_kokkos.cpp
@@ -146,10 +146,10 @@ void FixRxKokkos<DeviceType>::init()
   int neighflag = lmp->kokkos->neighflag;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -1908,7 +1908,7 @@ void FixRxKokkos<DeviceType>::operator()(Tag_FixRxKokkos_firstPairOperator<WT_FL
 {
   // Create an atomic view of sumWeights and dpdThetaLocal. Only needed
   // for Half/thread scenarios.
-  typedef Kokkos::View< E_FLOAT*, typename DAT::t_efloat_1d::array_layout, DeviceType, Kokkos::MemoryTraits< AtomicF< NEIGHFLAG >::value> > AtomicViewType;
+  typedef Kokkos::View< E_FLOAT*, typename DAT::t_efloat_1d::array_layout, typename KKDevice<DeviceType>::value, Kokkos::MemoryTraits< AtomicF< NEIGHFLAG >::value> > AtomicViewType;
 
   AtomicViewType a_dpdThetaLocal = d_dpdThetaLocal;
   AtomicViewType a_sumWeights    = d_sumWeights;
@@ -2083,8 +2083,8 @@ void FixRxKokkos<DeviceType>::computeLocalTemperature()
         {
           // Create an atomic view of sumWeights and dpdThetaLocal. Only needed
           // for Half/thread scenarios.
-          //typedef Kokkos::View< E_FLOAT*, typename DAT::t_efloat_1d::array_layout, DeviceType, Kokkos::MemoryTraits< AtomicF< NEIGHFLAG >::value> > AtomicViewType;
-          typedef Kokkos::View< E_FLOAT*, typename DAT::t_efloat_1d::array_layout, DeviceType, Kokkos::MemoryTraits< AtomicF< NEIGHFLAG >::value> > AtomicViewType;
+          //typedef Kokkos::View< E_FLOAT*, typename DAT::t_efloat_1d::array_layout, typename KKDevice<DeviceType>::value, Kokkos::MemoryTraits< AtomicF< NEIGHFLAG >::value> > AtomicViewType;
+          typedef Kokkos::View< E_FLOAT*, typename DAT::t_efloat_1d::array_layout, typename KKDevice<DeviceType>::value, Kokkos::MemoryTraits< AtomicF< NEIGHFLAG >::value> > AtomicViewType;
 
           AtomicViewType a_dpdThetaLocal = d_dpdThetaLocal;
           AtomicViewType a_sumWeights    = d_sumWeights;
diff --git a/src/KOKKOS/fix_shardlow_kokkos.cpp b/src/KOKKOS/fix_shardlow_kokkos.cpp
index 9bd859434170ed02787ee73e56095a345a6914f8..c6ad47501ae1f71ecdb135f2dd5df5805b4eaa78 100644
--- a/src/KOKKOS/fix_shardlow_kokkos.cpp
+++ b/src/KOKKOS/fix_shardlow_kokkos.cpp
@@ -132,10 +132,10 @@ void FixShardlowKokkos<DeviceType>::init()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
 //  neighbor->requests[irequest]->pair = 0;
 //  neighbor->requests[irequest]->fix  = 1;
diff --git a/src/KOKKOS/gridcomm_kokkos.cpp b/src/KOKKOS/gridcomm_kokkos.cpp
index f1ccffe20dd753d29565149272fab8bce3b58dd9..bdf816b647617e6a81a33f67aa6d26a31150fb77 100644
--- a/src/KOKKOS/gridcomm_kokkos.cpp
+++ b/src/KOKKOS/gridcomm_kokkos.cpp
@@ -524,7 +524,7 @@ void GridCommKokkos<DeviceType>::forward_comm(KSpace *kspace, int which)
       kspaceKKBase->pack_forward_kspace_kokkos(which,k_buf2,swap[m].npack,k_packlist,m);
     else
       kspaceKKBase->pack_forward_kspace_kokkos(which,k_buf1,swap[m].npack,k_packlist,m);
-    DeviceType::fence();
+    DeviceType().fence();
 
     if (swap[m].sendproc != me) {
       FFT_SCALAR* buf1;
@@ -552,7 +552,7 @@ void GridCommKokkos<DeviceType>::forward_comm(KSpace *kspace, int which)
     }
 
     kspaceKKBase->unpack_forward_kspace_kokkos(which,k_buf2,swap[m].nunpack,k_unpacklist,m);
-    DeviceType::fence();
+    DeviceType().fence();
   }
 }
 
@@ -574,7 +574,7 @@ void GridCommKokkos<DeviceType>::reverse_comm(KSpace *kspace, int which)
       kspaceKKBase->pack_reverse_kspace_kokkos(which,k_buf2,swap[m].nunpack,k_unpacklist,m);
     else
       kspaceKKBase->pack_reverse_kspace_kokkos(which,k_buf1,swap[m].nunpack,k_unpacklist,m);
-    DeviceType::fence();
+    DeviceType().fence();
 
     if (swap[m].recvproc != me) {
       FFT_SCALAR* buf1;
@@ -602,7 +602,7 @@ void GridCommKokkos<DeviceType>::reverse_comm(KSpace *kspace, int which)
     }
 
     kspaceKKBase->unpack_reverse_kspace_kokkos(which,k_buf2,swap[m].npack,k_packlist,m);
-    DeviceType::fence();
+    DeviceType().fence();
   }
 }
 
diff --git a/src/KOKKOS/improper_class2_kokkos.cpp b/src/KOKKOS/improper_class2_kokkos.cpp
index defd5e16f5cbf0a97913d3c813847e4f9c0af0f2..fcc9592b19bfd19c5b150204c408dd8c219f4fe1 100644
--- a/src/KOKKOS/improper_class2_kokkos.cpp
+++ b/src/KOKKOS/improper_class2_kokkos.cpp
@@ -78,7 +78,7 @@ void ImproperClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   if (vflag_atom) {
     //if(k_vatom.extent(0)<maxvatom) { // won't work without adding zero functor
       memoryKK->destroy_kokkos(k_vatom,vatom);
-      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"improper:vatom");
+      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"improper:vatom");
       d_vatom = k_vatom.template view<DeviceType>();
     //}
   }
@@ -188,7 +188,7 @@ KOKKOS_INLINE_FUNCTION
 void ImproperClass2Kokkos<DeviceType>::operator()(TagImproperClass2Compute<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   int i, j, k;
   F_FLOAT delr[3][3],rmag[3],rinvmag[3],rmag2[3];
@@ -660,7 +660,7 @@ KOKKOS_INLINE_FUNCTION
 void ImproperClass2Kokkos<DeviceType>::operator()(TagImproperClass2AngleAngle<NEWTON_BOND,EVFLAG>, const int &n, EV_FLOAT& ev) const {
 
   // The f array is atomic
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_f = f;
 
   int i,j,k;
   F_FLOAT eimproper;
@@ -1010,8 +1010,8 @@ void ImproperClass2Kokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int i1, cons
   F_FLOAT v[6];
 
   // The eatom and vatom arrays are atomic
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > v_vatom = k_vatom.view<DeviceType>();
 
   if (eflag_either) {
     if (eflag_global) {
diff --git a/src/KOKKOS/improper_class2_kokkos.h b/src/KOKKOS/improper_class2_kokkos.h
index 0fbfab2beb954f29c7320e53511e9136d8f19501..11212249e76696f8e3d14e991b528758f402e3c3 100644
--- a/src/KOKKOS/improper_class2_kokkos.h
+++ b/src/KOKKOS/improper_class2_kokkos.h
@@ -75,7 +75,7 @@ class ImproperClass2Kokkos : public ImproperClass2 {
   class NeighborKokkos *neighborKK;
 
   typename AT::t_x_array_randomread x;
-  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
+  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
   typename AT::t_int_2d improperlist;
 
   DAT::tdual_efloat_1d k_eatom;
diff --git a/src/KOKKOS/improper_harmonic_kokkos.cpp b/src/KOKKOS/improper_harmonic_kokkos.cpp
index 7d6437dbf5b6c862ea05873e760268bece948bb4..6a32e8af4786af595c42cb4438222649ea65986a 100644
--- a/src/KOKKOS/improper_harmonic_kokkos.cpp
+++ b/src/KOKKOS/improper_harmonic_kokkos.cpp
@@ -79,7 +79,7 @@ void ImproperHarmonicKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   if (vflag_atom) {
     //if(k_vatom.extent(0)<maxvatom) { // won't work without adding zero functor
       memoryKK->destroy_kokkos(k_vatom,vatom);
-      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"improper:vatom");
+      memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"improper:vatom");
       d_vatom = k_vatom.template view<DeviceType>();
     //}
   }
diff --git a/src/KOKKOS/improper_harmonic_kokkos.h b/src/KOKKOS/improper_harmonic_kokkos.h
index 23ae0c71103b406f10c09a9b25f1be8d15f22a5b..fb44081928f194f149ae8c186d87d3c246b83cea 100644
--- a/src/KOKKOS/improper_harmonic_kokkos.h
+++ b/src/KOKKOS/improper_harmonic_kokkos.h
@@ -64,13 +64,13 @@ class ImproperHarmonicKokkos : public ImproperHarmonic {
   class NeighborKokkos *neighborKK;
 
   typename AT::t_x_array_randomread x;
-  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
+  typename Kokkos::View<double*[3],typename AT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > f;
   typename AT::t_int_2d improperlist;
 
   Kokkos::DualView<E_FLOAT*,Kokkos::LayoutRight,DeviceType> k_eatom;
   Kokkos::DualView<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType> k_vatom;
-  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
-  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
+  Kokkos::View<E_FLOAT*,Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_eatom;
+  Kokkos::View<F_FLOAT*[6],Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic> > d_vatom;
 
   int nlocal,newton_bond;
   int eflag,vflag;
diff --git a/src/KOKKOS/kissfft_kokkos.cpp b/src/KOKKOS/kissfft_kokkos.cpp
index a9e68fe723cea2e92cb4172dd20c4e5d1d2abd51..5cfb3aa64c0d442a11e65c5d6d64790ffcfc868a 100644
--- a/src/KOKKOS/kissfft_kokkos.cpp
+++ b/src/KOKKOS/kissfft_kokkos.cpp
@@ -14,7 +14,7 @@
 
 namespace LAMMPS_NS {
 template class KissFFTKokkos<LMPDeviceType>;
-#ifdef KOKKOS_HAVE_CUDA
+#ifdef KOKKOS_ENABLE_CUDA
 template class KissFFTKokkos<LMPHostType>;
 #endif
 }
diff --git a/src/KOKKOS/kokkos_type.h b/src/KOKKOS/kokkos_type.h
index d21b9eecd243b9b2d2771c1b0aeb18d92e08576c..b1d17b45c35aa3dce04d079b993fca9a4afdb6bf 100644
--- a/src/KOKKOS/kokkos_type.h
+++ b/src/KOKKOS/kokkos_type.h
@@ -163,6 +163,20 @@ t_scalar3<Scalar> operator *
 typedef Kokkos::DefaultExecutionSpace LMPDeviceType;
 typedef Kokkos::HostSpace::execution_space LMPHostType;
 
+
+// Need to use Cuda UVM memory space for Host execution space
+
+template<class DeviceType>
+class KKDevice {
+public:
+#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_CUDA_UVM)
+  typedef Kokkos::Device<DeviceType,LMPDeviceType::memory_space> value;
+#else
+  typedef Kokkos::Device<DeviceType,typename DeviceType::memory_space> value;
+#endif
+};
+
+
 // set ExecutionSpace stuct with variable "space"
 
 template<class Device>
@@ -980,17 +994,9 @@ typedef struct ArrayTypes<LMPHostType> HAT;
 template<class DeviceType, class BufferView, class DualView>
 void buffer_view(BufferView &buf, DualView &view,
                  const size_t n0,
-                 const size_t n1 = 0,
-                 const size_t n2 = 0,
-                 const size_t n3 = 0,
-                 const size_t n4 = 0,
-                 const size_t n5 = 0,
-                 const size_t n6 = 0,
-                 const size_t n7 = 0) {
-
-  buf = BufferView(
-          view.template view<DeviceType>().data(),
-          n0,n1,n2,n3,n4,n5,n6,n7);
+                 const size_t n1) {
+
+  buf = BufferView(view.template view<DeviceType>().data(),n0,n1);
 
 }
 
@@ -1012,7 +1018,7 @@ void memset_kokkos (ViewType &view) {
   #else
   Kokkos::parallel_for(view.span()*sizeof(typename ViewType::value_type)/4, f);
   #endif
-  ViewType::execution_space::fence();
+  ViewType::execution_space().fence();
 }
 
 struct params_lj_coul {
diff --git a/src/KOKKOS/npair_kokkos.cpp b/src/KOKKOS/npair_kokkos.cpp
index aa2a1fc5ff4fe08a3faddda5605fdaf43b8e6a64..57bc865c9d8966cb566c89708e0e5b44d3d801dc 100644
--- a/src/KOKKOS/npair_kokkos.cpp
+++ b/src/KOKKOS/npair_kokkos.cpp
@@ -214,7 +214,6 @@ void NPairKokkos<DeviceType,HALF_NEIGH,GHOST,TRI,SIZE>::build(NeighList *list_)
 #ifdef KOKKOS_ENABLE_CUDA
     #define BINS_PER_BLOCK 2
     const int factor = atoms_per_bin<64?2:1;
-    Kokkos::TeamPolicy<DeviceType> config((mbins+factor-1)/factor,atoms_per_bin*factor);
 #else
     const int factor = 1;
 #endif
@@ -227,9 +226,14 @@ void NPairKokkos<DeviceType,HALF_NEIGH,GHOST,TRI,SIZE>::build(NeighList *list_)
         if (SIZE) {
           NPairKokkosBuildFunctorSize<DeviceType,TRI?0:HALF_NEIGH,1,TRI> f(data,atoms_per_bin * 5 * sizeof(X_FLOAT) * factor);
 #ifdef KOKKOS_ENABLE_CUDA
-          if (ExecutionSpaceFromDevice<DeviceType>::space == Device)
-            Kokkos::parallel_for(config, f);
-          else
+          if (ExecutionSpaceFromDevice<DeviceType>::space == Device) {
+            int team_size = atoms_per_bin*factor;
+            int team_size_max = Kokkos::TeamPolicy<DeviceType>(team_size,Kokkos::AUTO).team_size_max(f,Kokkos::ParallelForTag());
+            if (team_size <= team_size_max) {
+              Kokkos::TeamPolicy<DeviceType> config((mbins+factor-1)/factor,team_size);
+              Kokkos::parallel_for(config, f);
+            } else Kokkos::parallel_for(nall, f); // fall back to flat method
+          } else
             Kokkos::parallel_for(nall, f);
 #else
           Kokkos::parallel_for(nall, f);
@@ -237,9 +241,14 @@ void NPairKokkos<DeviceType,HALF_NEIGH,GHOST,TRI,SIZE>::build(NeighList *list_)
         } else {
           NPairKokkosBuildFunctor<DeviceType,TRI?0:HALF_NEIGH,1,TRI> f(data,atoms_per_bin * 5 * sizeof(X_FLOAT) * factor);
 #ifdef KOKKOS_ENABLE_CUDA
-          if (ExecutionSpaceFromDevice<DeviceType>::space == Device)
-            Kokkos::parallel_for(config, f);
-          else
+          if (ExecutionSpaceFromDevice<DeviceType>::space == Device) {
+            int team_size = atoms_per_bin*factor;
+            int team_size_max = Kokkos::TeamPolicy<DeviceType>(team_size,Kokkos::AUTO).team_size_max(f,Kokkos::ParallelForTag());
+            if (team_size <= team_size_max) {
+              Kokkos::TeamPolicy<DeviceType> config((mbins+factor-1)/factor,team_size);
+              Kokkos::parallel_for(config, f);
+            } else Kokkos::parallel_for(nall, f); // fall back to flat method
+          } else
             Kokkos::parallel_for(nall, f);
 #else
           Kokkos::parallel_for(nall, f);
@@ -249,9 +258,14 @@ void NPairKokkos<DeviceType,HALF_NEIGH,GHOST,TRI,SIZE>::build(NeighList *list_)
         if (SIZE) {
           NPairKokkosBuildFunctorSize<DeviceType,HALF_NEIGH,0,0> f(data,atoms_per_bin * 5 * sizeof(X_FLOAT) * factor);
 #ifdef KOKKOS_ENABLE_CUDA
-          if (ExecutionSpaceFromDevice<DeviceType>::space == Device)
-            Kokkos::parallel_for(config, f);
-          else
+          if (ExecutionSpaceFromDevice<DeviceType>::space == Device) {
+            int team_size = atoms_per_bin*factor;
+            int team_size_max = Kokkos::TeamPolicy<DeviceType>(team_size,Kokkos::AUTO).team_size_max(f,Kokkos::ParallelForTag());
+            if (team_size <= team_size_max) {
+              Kokkos::TeamPolicy<DeviceType> config((mbins+factor-1)/factor,team_size);
+              Kokkos::parallel_for(config, f);
+            } else Kokkos::parallel_for(nall, f); // fall back to flat method
+          } else
             Kokkos::parallel_for(nall, f);
 #else
           Kokkos::parallel_for(nall, f);
@@ -259,9 +273,14 @@ void NPairKokkos<DeviceType,HALF_NEIGH,GHOST,TRI,SIZE>::build(NeighList *list_)
         } else {
           NPairKokkosBuildFunctor<DeviceType,HALF_NEIGH,0,0> f(data,atoms_per_bin * 5 * sizeof(X_FLOAT) * factor);
 #ifdef KOKKOS_ENABLE_CUDA
-          if (ExecutionSpaceFromDevice<DeviceType>::space == Device)
-            Kokkos::parallel_for(config, f);
-          else
+          if (ExecutionSpaceFromDevice<DeviceType>::space == Device) {
+            int team_size = atoms_per_bin*factor;
+            int team_size_max = Kokkos::TeamPolicy<DeviceType>(team_size,Kokkos::AUTO).team_size_max(f,Kokkos::ParallelForTag());
+            if (team_size <= team_size_max) {
+              Kokkos::TeamPolicy<DeviceType> config((mbins+factor-1)/factor,team_size);
+              Kokkos::parallel_for(config, f);
+            } else Kokkos::parallel_for(nall, f); // fall back to flat method 
+          } else
             Kokkos::parallel_for(nall, f);
 #else
           Kokkos::parallel_for(nall, f);
diff --git a/src/KOKKOS/pack_kokkos.h b/src/KOKKOS/pack_kokkos.h
index 62e7960999a331f36c0518e22f4585f9abb70151..400048b1f04ffb050aa987f10dabf501ee4d5601 100644
--- a/src/KOKKOS/pack_kokkos.h
+++ b/src/KOKKOS/pack_kokkos.h
@@ -86,7 +86,7 @@ static void pack_3d(typename FFT_AT::t_FFT_SCALAR_1d_um d_data, int data_offset,
   const int nfast = plan->nfast;
   pack_3d_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 
 /* ----------------------------------------------------------------------
@@ -140,7 +140,7 @@ static void unpack_3d(typename FFT_AT::t_FFT_SCALAR_1d_um d_buf, int buf_offset,
   const int nfast = plan->nfast;
   unpack_3d_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 
 /* ----------------------------------------------------------------------
@@ -195,7 +195,7 @@ static void unpack_3d_permute1_1(typename FFT_AT::t_FFT_SCALAR_1d_um d_buf, int
   const int nfast = plan->nfast;
   unpack_3d_permute1_1_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 /* ----------------------------------------------------------------------
    unpack from buf -> data, one axis permutation, 2 values/element
@@ -249,7 +249,7 @@ static void unpack_3d_permute1_2(typename FFT_AT::t_FFT_SCALAR_1d_um d_buf, int
   const int nfast = plan->nfast;
   unpack_3d_permute1_2_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 
 /* ----------------------------------------------------------------------
@@ -305,7 +305,7 @@ static void unpack_3d_permute1_n(typename FFT_AT::t_FFT_SCALAR_1d_um d_buf, int
   const int nfast = plan->nfast;
   unpack_3d_permute1_n_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 
 /* ----------------------------------------------------------------------
@@ -358,7 +358,7 @@ static void unpack_3d_permute2_1(typename FFT_AT::t_FFT_SCALAR_1d_um d_buf, int
   const int nfast = plan->nfast;
   unpack_3d_permute2_1_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 
 /* ----------------------------------------------------------------------
@@ -412,7 +412,7 @@ static void unpack_3d_permute2_2(typename FFT_AT::t_FFT_SCALAR_1d_um d_buf, int
   const int nfast = plan->nfast;
   unpack_3d_permute2_2_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 /* ----------------------------------------------------------------------
    unpack from buf -> data, two axis permutation, nqty values/element
@@ -466,7 +466,7 @@ static void unpack_3d_permute2_n(typename FFT_AT::t_FFT_SCALAR_1d_um d_buf, int
   const int nfast = plan->nfast;
   unpack_3d_permute2_n_functor f(d_buf,buf_offset,d_data,data_offset,plan);
   Kokkos::parallel_for(nslow*nmid*nfast,f);
-  DeviceType::fence();
+  DeviceType().fence();
 }
 
 };
diff --git a/src/KOKKOS/pair_buck_coul_cut_kokkos.cpp b/src/KOKKOS/pair_buck_coul_cut_kokkos.cpp
index 2a72617525f52d94ac1f2a45954cab28ebe6c4f7..b28bbebbebf113ac0bb6e7ed489ac4dc74636612 100644
--- a/src/KOKKOS/pair_buck_coul_cut_kokkos.cpp
+++ b/src/KOKKOS/pair_buck_coul_cut_kokkos.cpp
@@ -99,7 +99,7 @@ void PairBuckCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -296,10 +296,10 @@ void PairBuckCoulCutKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_buck_coul_long_kokkos.cpp b/src/KOKKOS/pair_buck_coul_long_kokkos.cpp
index fdf395684aae26781a0391b879891a9cad722a85..29aca38a77a660114de6113fa207ffe4294b8e79 100644
--- a/src/KOKKOS/pair_buck_coul_long_kokkos.cpp
+++ b/src/KOKKOS/pair_buck_coul_long_kokkos.cpp
@@ -116,7 +116,7 @@ void PairBuckCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -456,10 +456,10 @@ void PairBuckCoulLongKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_buck_kokkos.cpp b/src/KOKKOS/pair_buck_kokkos.cpp
index 375d0dc1eafd7fb7f13326c458a140ffdf332da9..990c9e94a62642d987d636002b9ae2df3ad6a8cd 100644
--- a/src/KOKKOS/pair_buck_kokkos.cpp
+++ b/src/KOKKOS/pair_buck_kokkos.cpp
@@ -86,7 +86,7 @@ void PairBuckKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -218,10 +218,10 @@ void PairBuckKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_coul_cut_kokkos.cpp b/src/KOKKOS/pair_coul_cut_kokkos.cpp
index 5a1a6eefac9178a628b8aaddcc96df826b47998e..2e3f76463d1732084de2faebcbf549c5c2da8c06 100644
--- a/src/KOKKOS/pair_coul_cut_kokkos.cpp
+++ b/src/KOKKOS/pair_coul_cut_kokkos.cpp
@@ -82,7 +82,7 @@ void PairCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -220,10 +220,10 @@ void PairCoulCutKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_coul_debye_kokkos.cpp b/src/KOKKOS/pair_coul_debye_kokkos.cpp
index 8dd7e4f3d2cbacd9ee518fdbe4526de7e71d73f6..b212bdc53ab4c15ed18274ab921b6cb2d4bf75f6 100644
--- a/src/KOKKOS/pair_coul_debye_kokkos.cpp
+++ b/src/KOKKOS/pair_coul_debye_kokkos.cpp
@@ -92,7 +92,7 @@ void PairCoulDebyeKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -265,10 +265,10 @@ void PairCoulDebyeKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_coul_dsf_kokkos.cpp b/src/KOKKOS/pair_coul_dsf_kokkos.cpp
index 836b12ba3943e0163b5e0e651a9a7b5da230b37a..62e205d8fd27dcd26d5ccf71a787523e9f6da223 100644
--- a/src/KOKKOS/pair_coul_dsf_kokkos.cpp
+++ b/src/KOKKOS/pair_coul_dsf_kokkos.cpp
@@ -84,7 +84,7 @@ void PairCoulDSFKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -202,10 +202,10 @@ void PairCoulDSFKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -227,8 +227,8 @@ KOKKOS_INLINE_FUNCTION
 void PairCoulDSFKokkos<DeviceType>::operator()(TagPairCoulDSFKernelA<NEIGHFLAG,NEWTON_PAIR,EVFLAG>, const int &ii, EV_FLOAT& ev) const {
 
   // The f array is atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
 
   const int i = d_ilist[ii];
   const X_FLOAT xtmp = x(i,0);
@@ -323,8 +323,8 @@ void PairCoulDSFKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const i
   const int VFLAG = vflag_either;
 
   // The eatom and vatom arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
   if (EFLAG) {
     if (eflag_atom) {
diff --git a/src/KOKKOS/pair_coul_long_kokkos.cpp b/src/KOKKOS/pair_coul_long_kokkos.cpp
index 84b89c6373c73d7a0086d6c00133f051d1f079b2..c1f630a7a13c8d1e355041f02cdb0e11cf87ef73 100644
--- a/src/KOKKOS/pair_coul_long_kokkos.cpp
+++ b/src/KOKKOS/pair_coul_long_kokkos.cpp
@@ -109,7 +109,7 @@ void PairCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -416,10 +416,10 @@ void PairCoulLongKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_coul_wolf_kokkos.cpp b/src/KOKKOS/pair_coul_wolf_kokkos.cpp
index 3ca8f16a790c509726ecab8a2537a46f9b3cad67..907d088348e258f22cb81d2998355c389507ac97 100644
--- a/src/KOKKOS/pair_coul_wolf_kokkos.cpp
+++ b/src/KOKKOS/pair_coul_wolf_kokkos.cpp
@@ -79,7 +79,7 @@ void PairCoulWolfKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -203,10 +203,10 @@ void PairCoulWolfKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -228,8 +228,8 @@ KOKKOS_INLINE_FUNCTION
 void PairCoulWolfKokkos<DeviceType>::operator()(TagPairCoulWolfKernelA<NEIGHFLAG,NEWTON_PAIR,EVFLAG>, const int &ii, EV_FLOAT& ev) const {
 
   // The f array is atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
 
   const int i = d_ilist[ii];
   const X_FLOAT xtmp = x(i,0);
@@ -325,8 +325,8 @@ void PairCoulWolfKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const
   const int VFLAG = vflag_either;
 
   // The eatom and vatom arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
   if (EFLAG) {
     if (eflag_atom) {
diff --git a/src/KOKKOS/pair_dpd_fdt_energy_kokkos.cpp b/src/KOKKOS/pair_dpd_fdt_energy_kokkos.cpp
index 21fd32a2c8ebb419037aaa8e2cb517fdf958ed35..61d2707888e9ca65d21865754aa8bc6fc58c226f 100644
--- a/src/KOKKOS/pair_dpd_fdt_energy_kokkos.cpp
+++ b/src/KOKKOS/pair_dpd_fdt_energy_kokkos.cpp
@@ -87,10 +87,10 @@ void PairDPDfdtEnergyKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -125,10 +125,10 @@ void PairDPDfdtEnergyKokkos<Kokkos::Cuda>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<Kokkos::Cuda,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<Kokkos::Cuda,LMPDeviceType>::value;
+    kokkos_host = std::is_same<Kokkos::Cuda,LMPHostType>::value &&
+    !std::is_same<Kokkos::Cuda,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<Kokkos::Cuda,LMPDeviceType>::value;
+    kokkos_device = std::is_same<Kokkos::Cuda,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -170,7 +170,7 @@ void PairDPDfdtEnergyKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -389,7 +389,7 @@ KOKKOS_INLINE_FUNCTION
 void PairDPDfdtEnergyKokkos<DeviceType>::operator()(TagPairDPDfdtEnergyComputeSplit<NEIGHFLAG,NEWTON_PAIR,EVFLAG,STACKPARAMS>, const int &ii, EV_FLOAT& ev) const {
 
   // The f array is atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
 
   int i,j,jj,jnum,itype,jtype;
   double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,fpair;
@@ -473,9 +473,9 @@ KOKKOS_INLINE_FUNCTION
 void PairDPDfdtEnergyKokkos<DeviceType>::operator()(TagPairDPDfdtEnergyComputeNoSplit<NEIGHFLAG,NEWTON_PAIR,EVFLAG,STACKPARAMS>, const int &ii, EV_FLOAT& ev) const {
 
   // These array are atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_duCond = d_duCond;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_duMech = d_duMech;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_duCond = d_duCond;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_duMech = d_duMech;
 
   int i,j,jj,jnum,itype,jtype;
   double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,fpair;
@@ -697,8 +697,8 @@ void PairDPDfdtEnergyKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, co
   const int VFLAG = vflag_either;
 
   // The eatom and vatom arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
   if (EFLAG) {
     if (eflag_atom) {
diff --git a/src/KOKKOS/pair_eam_alloy_kokkos.cpp b/src/KOKKOS/pair_eam_alloy_kokkos.cpp
index 48bf63386a70cb9b76ac57dc19ab3a28ab022448..1963722d866368893fdeb75b4dd55be7272a8c70 100644
--- a/src/KOKKOS/pair_eam_alloy_kokkos.cpp
+++ b/src/KOKKOS/pair_eam_alloy_kokkos.cpp
@@ -83,7 +83,7 @@ void PairEAMAlloyKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -302,10 +302,10 @@ void PairEAMAlloyKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_eam_alloy_kokkos.h b/src/KOKKOS/pair_eam_alloy_kokkos.h
index e1dd9ab47d880050a43a494c45176274e6cc3b25..5796bdd1d46c99c3951a9648c054a5fda7f8886f 100644
--- a/src/KOKKOS/pair_eam_alloy_kokkos.h
+++ b/src/KOKKOS/pair_eam_alloy_kokkos.h
@@ -129,14 +129,14 @@ class PairEAMAlloyKokkos : public PairEAM, public KokkosBase {
   typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   DAT::tdual_ffloat_1d k_rho;
   DAT::tdual_ffloat_1d k_fp;
diff --git a/src/KOKKOS/pair_eam_fs_kokkos.cpp b/src/KOKKOS/pair_eam_fs_kokkos.cpp
index 6536dd745aa27426e5f55e457ed1293547404be0..a33923887be58892c41344d56306d7fa8986f726 100644
--- a/src/KOKKOS/pair_eam_fs_kokkos.cpp
+++ b/src/KOKKOS/pair_eam_fs_kokkos.cpp
@@ -83,7 +83,7 @@ void PairEAMFSKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -302,10 +302,10 @@ void PairEAMFSKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_eam_fs_kokkos.h b/src/KOKKOS/pair_eam_fs_kokkos.h
index e93977869e8709bcaecdd68e5513d88441c9177f..64e1c78d560e6f6e3faeee34d51a78ae90b8d846 100644
--- a/src/KOKKOS/pair_eam_fs_kokkos.h
+++ b/src/KOKKOS/pair_eam_fs_kokkos.h
@@ -129,14 +129,14 @@ class PairEAMFSKokkos : public PairEAM, public KokkosBase {
   typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   DAT::tdual_ffloat_1d k_rho;
   DAT::tdual_ffloat_1d k_fp;
diff --git a/src/KOKKOS/pair_eam_kokkos.cpp b/src/KOKKOS/pair_eam_kokkos.cpp
index 3358fe709ca56d475f1ebf3fc546a18a55f63e9d..99a0756610d147f9148c1e3bd4831f2167678643 100644
--- a/src/KOKKOS/pair_eam_kokkos.cpp
+++ b/src/KOKKOS/pair_eam_kokkos.cpp
@@ -77,7 +77,7 @@ void PairEAMKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -296,10 +296,10 @@ void PairEAMKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_eam_kokkos.h b/src/KOKKOS/pair_eam_kokkos.h
index 3bf89c549acf108cea791f69964062ba098c0ad4..20bac4ed1691792dbe777e53ab19db74d17fb6b0 100644
--- a/src/KOKKOS/pair_eam_kokkos.h
+++ b/src/KOKKOS/pair_eam_kokkos.h
@@ -126,14 +126,14 @@ class PairEAMKokkos : public PairEAM, public KokkosBase {
   typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_ffloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   DAT::tdual_ffloat_1d k_rho;
   DAT::tdual_ffloat_1d k_fp;
diff --git a/src/KOKKOS/pair_exp6_rx_kokkos.cpp b/src/KOKKOS/pair_exp6_rx_kokkos.cpp
index f3f63c98b2ea61b3e254e193d9e8b6eaeeae8ee9..a64df08127c604aa577f01451d7afd52fc0e1eea 100644
--- a/src/KOKKOS/pair_exp6_rx_kokkos.cpp
+++ b/src/KOKKOS/pair_exp6_rx_kokkos.cpp
@@ -118,10 +118,10 @@ void PairExp6rxKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -158,7 +158,7 @@ void PairExp6rxKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -442,9 +442,9 @@ void PairExp6rxKokkos<DeviceType>::operator()(TagPairExp6rxCompute<NEIGHFLAG,NEW
   }
 
   // These arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCG = uCG;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCGnew = uCGnew;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCG = uCG;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCGnew = uCGnew;
 
   int i,jj,jnum,itype,jtype;
   double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,evdwlOld,fpair;
@@ -1183,9 +1183,9 @@ KOKKOS_INLINE_FUNCTION
 void PairExp6rxKokkos<DeviceType>::vectorized_operator(const int &ii, EV_FLOAT& ev) const
 {
   // These arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCG = uCG;
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCGnew = uCGnew;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCG = uCG;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_uCGnew = uCGnew;
 
   int tid = 0;
 #ifndef KOKKOS_ENABLE_CUDA
@@ -2562,8 +2562,8 @@ void PairExp6rxKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const in
   const int VFLAG = vflag_either;
 
   // The eatom and vatom arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
   if (EFLAG) {
     if (eflag_atom) {
diff --git a/src/KOKKOS/pair_exp6_rx_kokkos.h b/src/KOKKOS/pair_exp6_rx_kokkos.h
index f3801db631a7edc35625340b4203bc1b8babee4f..406353dd7c5e586ea157eaa3e0c203c58c122806 100644
--- a/src/KOKKOS/pair_exp6_rx_kokkos.h
+++ b/src/KOKKOS/pair_exp6_rx_kokkos.h
@@ -45,10 +45,7 @@ struct PairExp6ParamDataTypeKokkos
 
    // Default constructor -- nullify everything.
    PairExp6ParamDataTypeKokkos<DeviceType>(void)
-      : n(0), epsilon1(NULL), alpha1(NULL), rm1(NULL), mixWtSite1(NULL),
-              epsilon2(NULL), alpha2(NULL), rm2(NULL), mixWtSite2(NULL),
-              epsilonOld1(NULL), alphaOld1(NULL), rmOld1(NULL), mixWtSite1old(NULL),
-              epsilonOld2(NULL), alphaOld2(NULL), rmOld2(NULL), mixWtSite2old(NULL)
+      : n(0)
    {}
 };
 
@@ -66,12 +63,6 @@ struct PairExp6ParamDataTypeKokkosVect
 
    // Default constructor -- nullify everything.
    PairExp6ParamDataTypeKokkosVect<DeviceType>(void)
-      : epsilon(NULL), rm3(NULL), alpha(NULL), xMolei(NULL), epsilon_old(NULL), rm3_old(NULL),
-        alpha_old(NULL), xMolei_old(NULL), fractionOFA(NULL), fraction1(NULL),
-        fraction2(NULL), nMoleculesOFA(NULL), nMolecules1(NULL), nMolecules2(NULL),
-        nTotal(NULL), fractionOFAold(NULL), fractionOld1(NULL), fractionOld2(NULL),
-        nMoleculesOFAold(NULL), nMoleculesOld1(NULL), nMoleculesOld2(NULL),
-        nTotalold(NULL)
    {}
 };
 
diff --git a/src/KOKKOS/pair_gran_hooke_history_kokkos.cpp b/src/KOKKOS/pair_gran_hooke_history_kokkos.cpp
index 5071bae32faa970feaf9d4517dcc02b108be8ec0..1acfc0d6a68b17a3f348967b0de2f049d1e6f886 100644
--- a/src/KOKKOS/pair_gran_hooke_history_kokkos.cpp
+++ b/src/KOKKOS/pair_gran_hooke_history_kokkos.cpp
@@ -86,10 +86,10 @@ void PairGranHookeHistoryKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == HALF || neighflag == HALFTHREAD) {
     neighbor->requests[irequest]->full = 0;
@@ -125,7 +125,7 @@ void PairGranHookeHistoryKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -320,8 +320,8 @@ KOKKOS_INLINE_FUNCTION
 void PairGranHookeHistoryKokkos<DeviceType>::operator()(TagPairGranHookeHistoryCompute<NEIGHFLAG,NEWTON_PAIR,EVFLAG,SHEARUPDATE>, const int ii, EV_FLOAT &ev) const {
 
   // The f and torque arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_torque = torque;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_torque = torque;
 
   const int i = d_ilist[ii];
   const X_FLOAT xtmp = x(i,0);
@@ -549,7 +549,7 @@ void PairGranHookeHistoryKokkos<DeviceType>::ev_tally_xyz_atom(EV_FLOAT &ev, int
                                                                F_FLOAT fx, F_FLOAT fy, F_FLOAT fz,
                                                                X_FLOAT delx, X_FLOAT dely, X_FLOAT delz) const
 {
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
   F_FLOAT v[6];
 
diff --git a/src/KOKKOS/pair_kokkos.h b/src/KOKKOS/pair_kokkos.h
index 52a05b3991985820e92281505e66c75d76b5f43e..54035c54ebc2ffcb54b95e70dd4f564a2440c362 100644
--- a/src/KOKKOS/pair_kokkos.h
+++ b/src/KOKKOS/pair_kokkos.h
@@ -66,17 +66,17 @@ struct PairComputeFunctor  {
 
   // The force array is atomic for Half/Thread neighbor style
   //Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,
-  //             device_type,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > f;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,device_type,Kokkos::Experimental::ScatterSum,NeedDup<NEIGHFLAG,device_type>::value > dup_f;
+  //             typename KKDevice<device_type>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > f;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<device_type>::value,Kokkos::Experimental::ScatterSum,NeedDup<NEIGHFLAG,device_type>::value > dup_f;
 
   // The eatom and vatom arrays are atomic for Half/Thread neighbor style
   //Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,
-  //             device_type,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > eatom;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,device_type,Kokkos::Experimental::ScatterSum,NeedDup<NEIGHFLAG,device_type>::value > dup_eatom;
+  //             typename KKDevice<device_type>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > eatom;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<device_type>::value,Kokkos::Experimental::ScatterSum,NeedDup<NEIGHFLAG,device_type>::value > dup_eatom;
 
   //Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,
-  //             device_type,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,device_type,Kokkos::Experimental::ScatterSum,NeedDup<NEIGHFLAG,device_type>::value > dup_vatom;
+  //             typename KKDevice<device_type>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<device_type>::value,Kokkos::Experimental::ScatterSum,NeedDup<NEIGHFLAG,device_type>::value > dup_vatom;
 
 
 
@@ -444,7 +444,7 @@ struct PairComputeFunctor  {
           ev.evdwl += fev.evdwl;
 
         if (c.eflag_atom)
-          d_eatom(i,0) += fev.evdwl;
+          d_eatom(i) += fev.evdwl;
 
         if (c.vflag_global) {
           ev.v[0] += fev.v[0];
@@ -554,7 +554,7 @@ struct PairComputeFunctor  {
         }
 
         if (c.eflag_atom)
-          d_eatom(i,0) += fev.evdwl + fev.ecoul;
+          d_eatom(i) += fev.evdwl + fev.ecoul;
 
         if (c.vflag_global) {
           ev.v[0] += fev.v[0];
@@ -841,7 +841,7 @@ struct PairComputeFunctor<PairStyle,N2,STACKPARAMS,Specialisation>  {
 // pair_compute_neighlist will match - either the dummy version
 // or the real one further below.
 template<class PairStyle, unsigned NEIGHFLAG, class Specialisation>
-EV_FLOAT pair_compute_neighlist (PairStyle* fpair, typename Kokkos::Impl::enable_if<!((NEIGHFLAG&PairStyle::EnabledNeighFlags) != 0), NeighListKokkos<typename PairStyle::device_type>*>::type list) {
+EV_FLOAT pair_compute_neighlist (PairStyle* fpair, typename std::enable_if<!((NEIGHFLAG&PairStyle::EnabledNeighFlags) != 0), NeighListKokkos<typename PairStyle::device_type>*>::type list) {
   EV_FLOAT ev;
   (void) fpair;
   (void) list;
@@ -850,8 +850,13 @@ EV_FLOAT pair_compute_neighlist (PairStyle* fpair, typename Kokkos::Impl::enable
 }
 
 template<class FunctorStyle>
-int GetTeamSize(FunctorStyle& functor, int team_size, int vector_length) {
-    int team_size_max = Kokkos::TeamPolicy<>::team_size_max(functor);
+int GetTeamSize(FunctorStyle& functor, int inum, int reduce_flag, int team_size, int vector_length) {
+    int team_size_max;
+
+    if (reduce_flag)
+      team_size_max = Kokkos::TeamPolicy<>(inum,Kokkos::AUTO).team_size_max(functor,Kokkos::ParallelReduceTag());
+    else
+      team_size_max = Kokkos::TeamPolicy<>(inum,Kokkos::AUTO).team_size_max(functor,Kokkos::ParallelForTag());
 
 #ifdef KOKKOS_ENABLE_CUDA
     if(team_size*vector_length > team_size_max)
@@ -864,7 +869,7 @@ int GetTeamSize(FunctorStyle& functor, int team_size, int vector_length) {
 
 // Submit ParallelFor for NEIGHFLAG=HALF,HALFTHREAD,FULL,N2
 template<class PairStyle, unsigned NEIGHFLAG, class Specialisation>
-EV_FLOAT pair_compute_neighlist (PairStyle* fpair, typename Kokkos::Impl::enable_if<(NEIGHFLAG&PairStyle::EnabledNeighFlags) != 0, NeighListKokkos<typename PairStyle::device_type>*>::type list) {
+EV_FLOAT pair_compute_neighlist (PairStyle* fpair, typename std::enable_if<(NEIGHFLAG&PairStyle::EnabledNeighFlags) != 0, NeighListKokkos<typename PairStyle::device_type>*>::type list) {
   EV_FLOAT ev;
 
   if (!fpair->lmp->kokkos->neigh_thread_set)
@@ -877,13 +882,13 @@ EV_FLOAT pair_compute_neighlist (PairStyle* fpair, typename Kokkos::Impl::enable
 
     if(fpair->atom->ntypes > MAX_TYPES_STACKPARAMS) {
       PairComputeFunctor<PairStyle,NEIGHFLAG,false,Specialisation > ff(fpair,list);
-      atoms_per_team = GetTeamSize(ff, atoms_per_team, vector_length);
+      atoms_per_team = GetTeamSize(ff, list->inum, (fpair->eflag || fpair->vflag), atoms_per_team, vector_length);
       Kokkos::TeamPolicy<Kokkos::IndexType<int> > policy(list->inum,atoms_per_team,vector_length);
       if (fpair->eflag || fpair->vflag) Kokkos::parallel_reduce(policy,ff,ev);
       else                              Kokkos::parallel_for(policy,ff);
     } else {
       PairComputeFunctor<PairStyle,NEIGHFLAG,true,Specialisation > ff(fpair,list);
-      atoms_per_team = GetTeamSize(ff, atoms_per_team, vector_length);
+      atoms_per_team = GetTeamSize(ff, list->inum, (fpair->eflag || fpair->vflag), atoms_per_team, vector_length);
       Kokkos::TeamPolicy<Kokkos::IndexType<int> > policy(list->inum,atoms_per_team,vector_length);
       if (fpair->eflag || fpair->vflag) Kokkos::parallel_reduce(policy,ff,ev);
       else                              Kokkos::parallel_for(policy,ff);
diff --git a/src/KOKKOS/pair_lj_charmm_coul_charmm_implicit_kokkos.cpp b/src/KOKKOS/pair_lj_charmm_coul_charmm_implicit_kokkos.cpp
index ae6cb61b60cb41d569da9108af28f2f3ec1be17c..3996f49c295b73970e20578b362d000939619a8a 100644
--- a/src/KOKKOS/pair_lj_charmm_coul_charmm_implicit_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_charmm_coul_charmm_implicit_kokkos.cpp
@@ -116,7 +116,7 @@ void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::compute(int eflag_in, int
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -462,10 +462,10 @@ void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_charmm_coul_charmm_kokkos.cpp b/src/KOKKOS/pair_lj_charmm_coul_charmm_kokkos.cpp
index 9cdef267e2c37b3c5ce0d0b6621f275b995e1229..44ba78fa7d64c5ebc6ed665a16961c4304975ae5 100644
--- a/src/KOKKOS/pair_lj_charmm_coul_charmm_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_charmm_coul_charmm_kokkos.cpp
@@ -117,7 +117,7 @@ void PairLJCharmmCoulCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_i
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -464,10 +464,10 @@ void PairLJCharmmCoulCharmmKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_charmm_coul_long_kokkos.cpp b/src/KOKKOS/pair_lj_charmm_coul_long_kokkos.cpp
index 441070248da13f371ad3a1cdc465a548896a97ce..35724c70613fc37979c7ab4b782fb5cca84455e5 100644
--- a/src/KOKKOS/pair_lj_charmm_coul_long_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_charmm_coul_long_kokkos.cpp
@@ -117,7 +117,7 @@ void PairLJCharmmCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -471,10 +471,10 @@ void PairLJCharmmCoulLongKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_class2_coul_cut_kokkos.cpp b/src/KOKKOS/pair_lj_class2_coul_cut_kokkos.cpp
index 1f7642e96575965016b198c86c0ca2be6feeb4b0..37485c77f0da2a787611b12ee8f1917739682427 100644
--- a/src/KOKKOS/pair_lj_class2_coul_cut_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_class2_coul_cut_kokkos.cpp
@@ -95,7 +95,7 @@ void PairLJClass2CoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -298,10 +298,10 @@ void PairLJClass2CoulCutKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_class2_coul_long_kokkos.cpp b/src/KOKKOS/pair_lj_class2_coul_long_kokkos.cpp
index c88ff9378e4da87b029c12675d12a632bbccc1f8..1e01a275a4872e94f065e111a82bb01f6859362f 100644
--- a/src/KOKKOS/pair_lj_class2_coul_long_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_class2_coul_long_kokkos.cpp
@@ -102,7 +102,7 @@ void PairLJClass2CoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -453,10 +453,10 @@ void PairLJClass2CoulLongKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_class2_kokkos.cpp b/src/KOKKOS/pair_lj_class2_kokkos.cpp
index 9900e7361f9b663578fdb27ecd04db5c1972ba9b..dd99ea9ab5580afadcc434f10b640bc10aabfbf5 100644
--- a/src/KOKKOS/pair_lj_class2_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_class2_kokkos.cpp
@@ -94,7 +94,7 @@ void PairLJClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -236,10 +236,10 @@ void PairLJClass2Kokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_cut_coul_cut_kokkos.cpp b/src/KOKKOS/pair_lj_cut_coul_cut_kokkos.cpp
index 1601e4a4b2b4811002924ffabafa0b6359f93249..36fd960c981e6da358269b90d57c8259816bf4b1 100644
--- a/src/KOKKOS/pair_lj_cut_coul_cut_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_cut_coul_cut_kokkos.cpp
@@ -94,7 +94,7 @@ void PairLJCutCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -289,10 +289,10 @@ void PairLJCutCoulCutKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_cut_coul_debye_kokkos.cpp b/src/KOKKOS/pair_lj_cut_coul_debye_kokkos.cpp
index 6e7d1eeb8bfeed7647cc38eb817f04c93db7f336..3810a0140b528e5ae97b9b6a17b9f182bb6f2dc5 100644
--- a/src/KOKKOS/pair_lj_cut_coul_debye_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_cut_coul_debye_kokkos.cpp
@@ -98,7 +98,7 @@ void PairLJCutCoulDebyeKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -318,10 +318,10 @@ void PairLJCutCoulDebyeKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_cut_coul_dsf_kokkos.cpp b/src/KOKKOS/pair_lj_cut_coul_dsf_kokkos.cpp
index b7dc7cc26d75e491fdda552650a04fc8416deb2b..b8818b109815e05cd39482e3fa86a180bd5fb92f 100644
--- a/src/KOKKOS/pair_lj_cut_coul_dsf_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_cut_coul_dsf_kokkos.cpp
@@ -108,7 +108,7 @@ void PairLJCutCoulDSFKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -311,10 +311,10 @@ void PairLJCutCoulDSFKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_cut_coul_long_kokkos.cpp b/src/KOKKOS/pair_lj_cut_coul_long_kokkos.cpp
index 122d59af824294d4564b63768bf2b618be88056e..595f0188574051e6db0021b4ba57887b20d386e7 100644
--- a/src/KOKKOS/pair_lj_cut_coul_long_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_cut_coul_long_kokkos.cpp
@@ -109,7 +109,7 @@ void PairLJCutCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -452,10 +452,10 @@ void PairLJCutCoulLongKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_cut_kokkos.cpp b/src/KOKKOS/pair_lj_cut_kokkos.cpp
index df750b75240441d665258f9df859413d33f71ff5..a4b2e90e07026df2b0bead2b4d1411c6d7b36ce0 100644
--- a/src/KOKKOS/pair_lj_cut_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_cut_kokkos.cpp
@@ -93,7 +93,7 @@ void PairLJCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -230,10 +230,10 @@ void PairLJCutKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_expand_kokkos.cpp b/src/KOKKOS/pair_lj_expand_kokkos.cpp
index 38bebc364fe1a2f4bc8fabfb6073ff78dc658cc8..496a7a76accb3288fb12da5807aabd955e89dcae 100644
--- a/src/KOKKOS/pair_lj_expand_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_expand_kokkos.cpp
@@ -93,7 +93,7 @@ void PairLJExpandKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -238,10 +238,10 @@ void PairLJExpandKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_gromacs_coul_gromacs_kokkos.cpp b/src/KOKKOS/pair_lj_gromacs_coul_gromacs_kokkos.cpp
index a46a5c04418c18daf3b4b76c425078fed9466f88..de475fbc99757a78c1e1a89724fd0587fce74f08 100644
--- a/src/KOKKOS/pair_lj_gromacs_coul_gromacs_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_gromacs_coul_gromacs_kokkos.cpp
@@ -108,7 +108,7 @@ void PairLJGromacsCoulGromacsKokkos<DeviceType>::compute(int eflag_in, int vflag
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -447,10 +447,10 @@ void PairLJGromacsCoulGromacsKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_gromacs_kokkos.cpp b/src/KOKKOS/pair_lj_gromacs_kokkos.cpp
index 23ed5e5595a7b7333e58ce706102f4af573b9981..fa2ab64ece67a767b0b06ef828e49096b349817c 100644
--- a/src/KOKKOS/pair_lj_gromacs_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_gromacs_kokkos.cpp
@@ -105,7 +105,7 @@ void PairLJGromacsKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -285,10 +285,10 @@ void PairLJGromacsKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_lj_sdk_kokkos.cpp b/src/KOKKOS/pair_lj_sdk_kokkos.cpp
index 25f081d2558413631b1385152fe3df99ae8c9be3..645f8a9159a13546fb32f6c4c21d934c2c2d1126 100644
--- a/src/KOKKOS/pair_lj_sdk_kokkos.cpp
+++ b/src/KOKKOS/pair_lj_sdk_kokkos.cpp
@@ -94,7 +94,7 @@ void PairLJSDKKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -268,10 +268,10 @@ void PairLJSDKKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_morse_kokkos.cpp b/src/KOKKOS/pair_morse_kokkos.cpp
index d3e3042a340fe62f1a8d4fc74326e32869f72674..4e88c72518d24447c4b5698559765d3093d9c019 100644
--- a/src/KOKKOS/pair_morse_kokkos.cpp
+++ b/src/KOKKOS/pair_morse_kokkos.cpp
@@ -100,7 +100,7 @@ void PairMorseKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -247,10 +247,10 @@ void PairMorseKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_multi_lucy_rx_kokkos.cpp b/src/KOKKOS/pair_multi_lucy_rx_kokkos.cpp
index 75247859ed23fbd3a52bbd31ad3a580da9a3da1b..edf8bb38ae8ceac5f8b108081ae4558301d3365e 100644
--- a/src/KOKKOS/pair_multi_lucy_rx_kokkos.cpp
+++ b/src/KOKKOS/pair_multi_lucy_rx_kokkos.cpp
@@ -99,10 +99,10 @@ void PairMultiLucyRXKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -154,7 +154,7 @@ void PairMultiLucyRXKokkos<DeviceType>::compute_style(int eflag_in, int vflag_in
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -270,7 +270,7 @@ KOKKOS_INLINE_FUNCTION
 void PairMultiLucyRXKokkos<DeviceType>::operator()(TagPairMultiLucyRXCompute<NEIGHFLAG,NEWTON_PAIR,EVFLAG,TABSTYLE>, const int &ii, EV_FLOAT& ev) const {
 
   // The f array is atomic for Half/Thread neighbor style
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
 
   int i,jj,jnum,itype,jtype,itable;
   double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,evdwlOld,fpair;
@@ -532,7 +532,7 @@ void PairMultiLucyRXKokkos<DeviceType>::operator()(TagPairMultiLucyRXComputeLoca
 
 
   // The rho array is atomic for Half/Thread neighbor style
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_rho = rho;
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_rho = rho;
 
   const int i = d_ilist[ii];
 
@@ -771,8 +771,8 @@ void PairMultiLucyRXKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, con
   const int VFLAG = vflag_either;
 
   // The eatom and vatom arrays are atomic for Half/Thread neighbor style
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
   if (EFLAG) {
     if (eflag_atom) {
diff --git a/src/KOKKOS/pair_reaxc_kokkos.cpp b/src/KOKKOS/pair_reaxc_kokkos.cpp
index d0ad1f1b09a3aaacdd8acd1560b9cc90b691b514..bec3f2e655850ccca34d71d6908d1fc76f11a2c5 100644
--- a/src/KOKKOS/pair_reaxc_kokkos.cpp
+++ b/src/KOKKOS/pair_reaxc_kokkos.cpp
@@ -147,10 +147,10 @@ void PairReaxCKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -2477,7 +2477,7 @@ void PairReaxCKokkos<DeviceType>::operator()(PairReaxComputeAngular<NEIGHFLAG,EV
 
   auto v_f = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_f),decltype(ndup_f)>::get(dup_f,ndup_f);
   auto a_f = v_f.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();
-  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbo = d_Cdbo;
+  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbo = d_Cdbo;
 
   auto v_CdDelta = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_CdDelta),decltype(ndup_CdDelta)>::get(dup_CdDelta,ndup_CdDelta);
   auto a_CdDelta = v_CdDelta.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();
@@ -2792,7 +2792,7 @@ void PairReaxCKokkos<DeviceType>::operator()(PairReaxComputeTorsion<NEIGHFLAG,EV
 
   auto v_CdDelta = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_CdDelta),decltype(ndup_CdDelta)>::get(dup_CdDelta,ndup_CdDelta);
   auto a_CdDelta = v_CdDelta.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();
-  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbo = d_Cdbo;
+  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbo = d_Cdbo;
   //auto a_Cdbo = dup_Cdbo.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();
 
   // in reaxc_torsion_angles: j = i, k = j, i = k;
@@ -3311,9 +3311,9 @@ template<int NEIGHFLAG>
 KOKKOS_INLINE_FUNCTION
 void PairReaxCKokkos<DeviceType>::operator()(PairReaxUpdateBond<NEIGHFLAG>, const int &ii) const {
 
-  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbo = d_Cdbo;
-  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbopi = d_Cdbopi;
-  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbopi2 = d_Cdbopi2;
+  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbo = d_Cdbo;
+  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbopi = d_Cdbopi;
+  Kokkos::View<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_Cdbopi2 = d_Cdbopi2;
   //auto a_Cdbo = dup_Cdbo.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();
   //auto a_Cdbopi = dup_Cdbopi.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();
   //auto a_Cdbopi2 = dup_Cdbopi2.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();
@@ -4026,7 +4026,7 @@ void PairReaxCKokkos<DeviceType>::ev_setup(int eflag, int vflag, int)
   if (vflag_atom && atom->nmax > maxvatom) {
     maxvatom = atom->nmax;
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
diff --git a/src/KOKKOS/pair_reaxc_kokkos.h b/src/KOKKOS/pair_reaxc_kokkos.h
index 783ea33c4ec10bee54376311ebde5ca9fb242c7b..93ca4468ecf25a472f2a316ce573e4a24a7999a6 100644
--- a/src/KOKKOS/pair_reaxc_kokkos.h
+++ b/src/KOKKOS/pair_reaxc_kokkos.h
@@ -399,25 +399,25 @@ class PairReaxCKokkos : public PairReaxC {
   typename AT::t_ffloat_2d_dl d_C1dbopi2, d_C2dbopi2, d_C3dbopi2, d_C4dbopi2;
   typename AT::t_ffloat_2d_dl d_Cdbo, d_Cdbopi, d_Cdbopi2, d_dDeltap_self;
 
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_total_bo;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_CdDelta;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_dDeltap_self;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_Cdbo;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_Cdbopi;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_Cdbopi2;
-
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_total_bo;
-  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_CdDelta;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_dDeltap_self;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_Cdbo;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_Cdbopi;
-  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_Cdbopi2;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_total_bo;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_CdDelta;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_dDeltap_self;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_Cdbo;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_Cdbopi;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_Cdbopi2;
+
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_total_bo;
+  Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_float_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_CdDelta;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_dDeltap_self;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_Cdbo;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_Cdbopi;
+  Kokkos::Experimental::ScatterView<F_FLOAT**, typename DAT::t_ffloat_2d_dl::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_Cdbopi2;
 
   int need_dup;
 
diff --git a/src/KOKKOS/pair_snap_kokkos.h b/src/KOKKOS/pair_snap_kokkos.h
index b57ef2d9e5b8d3d8047e9c5b345045dcecacdd98..f5e5c63454797caa772411631102f01b6a490851 100644
--- a/src/KOKKOS/pair_snap_kokkos.h
+++ b/src/KOKKOS/pair_snap_kokkos.h
@@ -64,6 +64,12 @@ public:
   void compute(int, int);
   double memory_usage();
 
+  template<class TagStyle>
+  void check_team_size_for(int, int&, int);
+
+  template<class TagStyle>
+  void check_team_size_reduce(int, int&, int);
+
   template<int NEIGHFLAG, int EVFLAG>
   KOKKOS_INLINE_FUNCTION
   void operator() (TagPairSNAPComputeForce<NEIGHFLAG,EVFLAG>,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeForce<NEIGHFLAG,EVFLAG> >::member_type& team) const;
@@ -131,6 +137,7 @@ protected:
   SNAKokkos<DeviceType> snaKK;
 
   int inum,max_neighs,chunk_size,chunk_offset;
+  int host_flag;
 
   int eflag,vflag;
 
@@ -181,10 +188,10 @@ inline double dist2(double* x,double* y);
   typename AT::t_int_1d_randomread type;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   friend void pair_virial_fdotr_compute<PairSNAPKokkos>(PairSNAPKokkos*);
 
diff --git a/src/KOKKOS/pair_snap_kokkos_impl.h b/src/KOKKOS/pair_snap_kokkos_impl.h
index d807f149a903c27d0a1df3595bcf960e1a686def..e838b6a070a6ff58dcff72e8c0f7f900d828e6a9 100644
--- a/src/KOKKOS/pair_snap_kokkos_impl.h
+++ b/src/KOKKOS/pair_snap_kokkos_impl.h
@@ -61,6 +61,8 @@ PairSNAPKokkos<DeviceType>::PairSNAPKokkos(LAMMPS *lmp) : PairSNAP(lmp)
   k_cutsq = tdual_fparams("PairSNAPKokkos::cutsq",atom->ntypes+1,atom->ntypes+1);
   auto d_cutsq = k_cutsq.template view<DeviceType>();
   rnd_cutsq = d_cutsq;
+
+  host_flag = (execution_space == Host);
 }
 
 /* ---------------------------------------------------------------------- */
@@ -91,10 +93,10 @@ void PairSNAPKokkos<DeviceType>::init_style()
   int irequest = neighbor->request(this,instance_me);
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == HALF || neighflag == HALFTHREAD) { // still need atomics, even though using a full neigh list
     neighbor->requests[irequest]->full = 1;
@@ -145,7 +147,7 @@ void PairSNAPKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -182,16 +184,12 @@ void PairSNAPKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
     if (max_neighs<num_neighs) max_neighs = num_neighs;
   }*/
   max_neighs = 0;
-  Kokkos::parallel_reduce("PairSNAPKokkos::find_max_neighs",inum, FindMaxNumNeighs<DeviceType>(k_list), Kokkos::Experimental::Max<int>(max_neighs));
-
-  int vector_length = 1;
-  int team_size = 1;
-  int team_size_max = Kokkos::TeamPolicy<DeviceType>::team_size_max(*this);
-#ifdef KOKKOS_ENABLE_CUDA
-  team_size = 32;//max_neighs;
-  if (team_size*vector_length > team_size_max)
-    team_size = team_size_max/vector_length;
-#endif
+  Kokkos::parallel_reduce("PairSNAPKokkos::find_max_neighs",inum, FindMaxNumNeighs<DeviceType>(k_list), Kokkos::Max<int>(max_neighs));
+
+  int vector_length_default = 1;
+  int team_size_default = 1;
+  if (!host_flag)
+    team_size_default = 32;//max_neighs;
 
   if (beta_max < inum) {
     beta_max = inum;
@@ -216,57 +214,57 @@ void PairSNAPKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
       chunk_size = inum - chunk_offset;
 
     //ComputeNeigh
-    typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeNeigh> policy_neigh(chunk_size,team_size,vector_length);
-    Kokkos::parallel_for("ComputeNeigh",policy_neigh,*this);
+    {
+      int vector_length = vector_length_default;
+      int team_size = team_size_default;
+      check_team_size_for<TagPairSNAPComputeNeigh>(chunk_size,team_size,vector_length);
+      typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeNeigh> policy_neigh(chunk_size,team_size,vector_length);
+      Kokkos::parallel_for("ComputeNeigh",policy_neigh,*this);
+    }
 
     //PreUi
     {
-      int vector_length = 1;
-      int team_size = 1;
-      if (lmp->kokkos->ngpus != 0) {
+      int vector_length = vector_length_default;
+      int team_size = team_size_default;
+      if (!host_flag)
         vector_length = 32;
-        team_size = 32;//max_neighs;
-        int team_size_max = Kokkos::TeamPolicy<DeviceType, TagPairSNAPPreUi>::team_size_max(*this);
-        if (team_size*vector_length > team_size_max)
-          team_size = team_size_max/vector_length;
-      }
+      check_team_size_for<TagPairSNAPPreUi>(chunk_size,team_size,vector_length);
       typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPPreUi> policy_preui((chunk_size+team_size-1)/team_size,team_size,vector_length);
       Kokkos::parallel_for("PreUi",policy_preui,*this);
     }
 
     // ComputeUI
-    if (lmp->kokkos->ngpus == 0) { // CPU
-      // Run a fused calculation of ulist and accumulation into ulisttot using atomics
-      int vector_length = 1;
-      int team_size = 1;
+    {
+      int vector_length = vector_length_default;
+      int team_size = team_size_default;
+      if (host_flag) { // CPU
+        // Run a fused calculation of ulist and accumulation into ulisttot using atomics
 
-      typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeUiCPU> policy_ui_cpu(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
+        typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeUiCPU> policy_ui_cpu(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
 
-      Kokkos::parallel_for("ComputeUiCPU",policy_ui_cpu,*this);
-    } else { // GPU, vector parallelism, shared memory, separate ulist and ulisttot to avoid atomics
+        Kokkos::parallel_for("ComputeUiCPU",policy_ui_cpu,*this);
+      } else { // GPU, vector parallelism, shared memory, separate ulist and ulisttot to avoid atomics
 
-      // ComputeUi
-      int vector_length = 32;
-      int team_size = 4; // need to cap b/c of shared memory reqs
-      int team_size_max = Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeUi>::team_size_max(*this);
-      if (team_size*vector_length > team_size_max)
-        team_size = team_size_max/vector_length;
+        vector_length = 32;
+        team_size = 4; // need to cap b/c of shared memory reqs
+        check_team_size_for<TagPairSNAPComputeUi>(chunk_size,team_size,vector_length);
 
-      // scratch size: 2 * team_size * (twojmax+1)^2, to cover all `m1`,`m2` values
-        // 2 is for double buffer
+        // scratch size: 2 * team_size * (twojmax+1)^2, to cover all `m1`,`m2` values
+        //   2 is for double buffer
 
-      const int tile_size = (twojmax+1)*(twojmax+1);
-      typedef Kokkos::View< SNAcomplex*,
-                            Kokkos::DefaultExecutionSpace::scratch_memory_space,
-                            Kokkos::MemoryTraits<Kokkos::Unmanaged> >
-              ScratchViewType;
-      int scratch_size = ScratchViewType::shmem_size( 2 * team_size * tile_size );
+        const int tile_size = (twojmax+1)*(twojmax+1);
+        typedef Kokkos::View< SNAcomplex*,
+                              Kokkos::DefaultExecutionSpace::scratch_memory_space,
+                              Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+                ScratchViewType;
+        int scratch_size = ScratchViewType::shmem_size( 2 * team_size * tile_size );
 
-      typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeUi> policy_ui(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
-      policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam( scratch_size ));
+        typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeUi> policy_ui(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
+        policy_ui = policy_ui.set_scratch_size(0, Kokkos::PerTeam( scratch_size ));
 
-      Kokkos::parallel_for("ComputeUi",policy_ui,*this);
+        Kokkos::parallel_for("ComputeUi",policy_ui,*this);
 
+      }
     }
 
 
@@ -274,99 +272,109 @@ void PairSNAPKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
     if (quadraticflag || eflag) {
       //ComputeZi
       int idxz_max = snaKK.idxz_max;
-      typename Kokkos::RangePolicy<DeviceType, TagPairSNAPComputeZi> policy_zi(0,chunk_size*idxz_max);
+      typename Kokkos::RangePolicy<DeviceType,TagPairSNAPComputeZi> policy_zi(0,chunk_size*idxz_max);
       Kokkos::parallel_for("ComputeZi",policy_zi,*this);
 
       //ComputeBi
-      typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeBi> policy_bi(chunk_size,team_size,vector_length);
+      int vector_length = vector_length_default;
+      int team_size = team_size_default;
+      check_team_size_for<TagPairSNAPComputeBi>(chunk_size,team_size,vector_length);
+      typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeBi> policy_bi(chunk_size,team_size,vector_length);
       Kokkos::parallel_for("ComputeBi",policy_bi,*this);
-
     }
 
     //Compute beta = dE_i/dB_i for all i in list
-    typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPBeta> policy_beta(chunk_size,team_size,vector_length);
-    Kokkos::parallel_for("ComputeBeta",policy_beta,*this);
+    {
+      int vector_length = vector_length_default;
+      int team_size = team_size_default;
+      check_team_size_for<TagPairSNAPBeta>(chunk_size,team_size,vector_length);
+      typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPBeta> policy_beta(chunk_size,team_size,vector_length);
+      Kokkos::parallel_for("ComputeBeta",policy_beta,*this);
+    }
 
     //ZeroYi
     {
-      int vector_length = 1;
-      int team_size = 1;
-      int team_size_max = Kokkos::TeamPolicy<DeviceType, TagPairSNAPZeroYi>::team_size_max(*this);
-
-#ifdef KOKKOS_ENABLE_CUDA
-      team_size = 128;
-      if (team_size*vector_length > team_size_max)
-        team_size = team_size_max/vector_length;
-#endif
-
-      typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPZeroYi> policy_zero_yi(((idxu_max+team_size-1)/team_size)*chunk_size,team_size,vector_length);
+      int vector_length = vector_length_default;
+      int team_size = team_size_default;
+      if (!host_flag)
+        team_size = 128;
+      check_team_size_for<TagPairSNAPZeroYi>(chunk_size,team_size,vector_length);
+      typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPZeroYi> policy_zero_yi(((idxu_max+team_size-1)/team_size)*chunk_size,team_size,vector_length);
       Kokkos::parallel_for("ZeroYi",policy_zero_yi,*this);
     }
 
     //ComputeYi
     int idxz_max = snaKK.idxz_max;
-    typename Kokkos::RangePolicy<DeviceType, TagPairSNAPComputeYi> policy_yi(0,chunk_size*idxz_max);
+    typename Kokkos::RangePolicy<DeviceType,TagPairSNAPComputeYi> policy_yi(0,chunk_size*idxz_max);
     Kokkos::parallel_for("ComputeYi",policy_yi,*this);
 
     //ComputeDuidrj and Deidrj
-    if (lmp->kokkos->ngpus == 0) { // CPU
-      int vector_length = 1;
-      int team_size = 1;
+    {
+      int team_size = team_size_default;
+      int vector_length = vector_length_default;
+      if (host_flag) { // CPU
 
-      typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeDuidrjCPU> policy_duidrj_cpu(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
-      snaKK.set_dir(-1); // technically doesn't do anything
-      Kokkos::parallel_for("ComputeDuidrjCPU",policy_duidrj_cpu,*this);
+        typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeDuidrjCPU> policy_duidrj_cpu(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
+        snaKK.set_dir(-1); // technically doesn't do anything
+        Kokkos::parallel_for("ComputeDuidrjCPU",policy_duidrj_cpu,*this);
 
-      typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeDeidrjCPU> policy_deidrj_cpu(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
+        typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeDeidrjCPU> policy_deidrj_cpu(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
 
-      Kokkos::parallel_for("ComputeDeidrjCPU",policy_deidrj_cpu,*this);
-    } else { // GPU, utilize scratch memory and splitting over dimensions, fused dui and dei
+        Kokkos::parallel_for("ComputeDeidrjCPU",policy_deidrj_cpu,*this);
+      } else { // GPU, utilize scratch memory and splitting over dimensions, fused dui and dei
 
-      int team_size_max = Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeFusedDeidrj>::team_size_max(*this);
-      int vector_length = 32;
-      int team_size = 2; // need to cap b/c of shared memory reqs
-      if (team_size*vector_length > team_size_max)
-        team_size = team_size_max/vector_length;
+        vector_length = 32;
+        team_size = 2; // need to cap b/c of shared memory reqs
+        check_team_size_for<TagPairSNAPComputeFusedDeidrj>(chunk_size,team_size,vector_length);
 
-      // scratch size: 2 * 2 * team_size * (twojmax+1)*(twojmax/2+1), to cover half `m1`,`m2` values due to symmetry
-      // 2 is for double buffer
-      const int tile_size = (twojmax+1)*(twojmax/2+1);
+        // scratch size: 2 * 2 * team_size * (twojmax+1)*(twojmax/2+1), to cover half `m1`,`m2` values due to symmetry
+        // 2 is for double buffer
+        const int tile_size = (twojmax+1)*(twojmax/2+1);
 
-      typedef Kokkos::View< SNAcomplex*,
-                            Kokkos::DefaultExecutionSpace::scratch_memory_space,
-                            Kokkos::MemoryTraits<Kokkos::Unmanaged> >
-              ScratchViewType;
-      int scratch_size = ScratchViewType::shmem_size( 4 * team_size * tile_size);
+        typedef Kokkos::View< SNAcomplex*,
+                              Kokkos::DefaultExecutionSpace::scratch_memory_space,
+                              Kokkos::MemoryTraits<Kokkos::Unmanaged> >
+                ScratchViewType;
+        int scratch_size = ScratchViewType::shmem_size( 4 * team_size * tile_size);
 
-      typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeFusedDeidrj> policy_fused_deidrj(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
-      policy_fused_deidrj = policy_fused_deidrj.set_scratch_size(0, Kokkos::PerTeam( scratch_size ));
+        typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeFusedDeidrj> policy_fused_deidrj(((chunk_size+team_size-1)/team_size)*max_neighs,team_size,vector_length);
+        policy_fused_deidrj = policy_fused_deidrj.set_scratch_size(0, Kokkos::PerTeam( scratch_size ));
 
-      for (int k = 0; k < 3; k++) {
-        snaKK.set_dir(k);
-        Kokkos::parallel_for("ComputeFusedDeidrj",policy_fused_deidrj,*this);
+        for (int k = 0; k < 3; k++) {
+          snaKK.set_dir(k);
+          Kokkos::parallel_for("ComputeFusedDeidrj",policy_fused_deidrj,*this);
+        }
       }
     }
 
     //ComputeForce
-    if (eflag) {
-      if (neighflag == HALF) {
-        typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeForce<HALF,1> > policy_force(chunk_size,team_size,vector_length);
-        Kokkos::parallel_reduce(policy_force
-          ,*this,ev_tmp);
-      } else if (neighflag == HALFTHREAD) {
-        typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeForce<HALFTHREAD,1> > policy_force(chunk_size,team_size,vector_length);
-        Kokkos::parallel_reduce(policy_force
-          ,*this,ev_tmp);
-      }
-    } else {
-      if (neighflag == HALF) {
-        typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeForce<HALF,0> > policy_force(chunk_size,team_size,vector_length);
-        Kokkos::parallel_for(policy_force
-          ,*this);
-      } else if (neighflag == HALFTHREAD) {
-        typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeForce<HALFTHREAD,0> > policy_force(chunk_size,team_size,vector_length);
-        Kokkos::parallel_for(policy_force
-          ,*this);
+    {
+      int team_size = team_size_default;
+      int vector_length = vector_length_default;
+      if (eflag) {
+        if (neighflag == HALF) {
+          check_team_size_reduce<TagPairSNAPComputeForce<HALF,1> >(chunk_size,team_size,vector_length);
+          typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeForce<HALF,1> > policy_force(chunk_size,team_size,vector_length);
+          Kokkos::parallel_reduce(policy_force
+            ,*this,ev_tmp);
+        } else if (neighflag == HALFTHREAD) {
+          check_team_size_reduce<TagPairSNAPComputeForce<HALFTHREAD,1> >(chunk_size,team_size,vector_length);
+          typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeForce<HALFTHREAD,1> > policy_force(chunk_size,team_size,vector_length);
+          Kokkos::parallel_reduce(policy_force
+            ,*this,ev_tmp);
+        }
+      } else {
+        if (neighflag == HALF) {
+          check_team_size_for<TagPairSNAPComputeForce<HALF,0> >(chunk_size,team_size,vector_length);
+          typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeForce<HALF,0> > policy_force(chunk_size,team_size,vector_length);
+          Kokkos::parallel_for(policy_force
+            ,*this);
+        } else if (neighflag == HALFTHREAD) {
+          check_team_size_for<TagPairSNAPComputeForce<HALFTHREAD,0> >(chunk_size,team_size,vector_length);
+          typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeForce<HALFTHREAD,0> > policy_force(chunk_size,team_size,vector_length);
+          Kokkos::parallel_for(policy_force
+            ,*this);
+        }
       }
     }
     ev += ev_tmp;
@@ -416,7 +424,7 @@ void PairSNAPKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPBeta,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPBeta>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPBeta,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPBeta>::member_type& team) const {
 
   // TODO: use RangePolicy instead, or thread over ncoeff?
   int ii = team.league_rank();
@@ -522,7 +530,7 @@ void PairSNAPKokkos<DeviceType>::coeff(int narg, char **arg)
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeNeigh,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeNeigh>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeNeigh,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeNeigh>::member_type& team) const {
 
   int ii = team.league_rank();
   const int i = d_ilist[ii + chunk_offset];
@@ -591,7 +599,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeNeigh,const typen
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPPreUi,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPPreUi>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPPreUi,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPPreUi>::member_type& team) const {
   SNAKokkos<DeviceType> my_sna = snaKK;
 
   // Extract the atom number
@@ -603,7 +611,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPPreUi,const typename Kok
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeUi,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeUi>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeUi,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeUi>::member_type& team) const {
   SNAKokkos<DeviceType> my_sna = snaKK;
 
   // Extract the atom number
@@ -620,7 +628,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeUi,const typename
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeUiCPU,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeUiCPU>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeUiCPU,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeUiCPU>::member_type& team) const {
   SNAKokkos<DeviceType> my_sna = snaKK;
 
   // Extract the atom number
@@ -637,7 +645,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeUiCPU,const typen
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPZeroYi,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPZeroYi>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPZeroYi,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPZeroYi>::member_type& team) const {
   SNAKokkos<DeviceType> my_sna = snaKK;
 
   // Extract the quantum number
@@ -667,7 +675,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeZi,const int& ii)
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeBi,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeBi>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeBi,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeBi>::member_type& team) const {
   int ii = team.league_rank();
   SNAKokkos<DeviceType> my_sna = snaKK;
   my_sna.compute_bi(team,ii);
@@ -675,7 +683,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeBi,const typename
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeFusedDeidrj,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeFusedDeidrj>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeFusedDeidrj,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeFusedDeidrj>::member_type& team) const {
   SNAKokkos<DeviceType> my_sna = snaKK;
 
   // Extract the atom number
@@ -692,7 +700,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeFusedDeidrj,const
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeDuidrjCPU,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeDuidrjCPU>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeDuidrjCPU,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeDuidrjCPU>::member_type& team) const {
   SNAKokkos<DeviceType> my_sna = snaKK;
 
   // Extract the atom number
@@ -709,7 +717,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeDuidrjCPU,const t
 
 template<class DeviceType>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeDeidrjCPU,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeDeidrjCPU>::member_type& team) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeDeidrjCPU,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeDeidrjCPU>::member_type& team) const {
   SNAKokkos<DeviceType> my_sna = snaKK;
 
   // Extract the atom number
@@ -727,7 +735,7 @@ void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeDeidrjCPU,const t
 template<class DeviceType>
 template<int NEIGHFLAG, int EVFLAG>
 KOKKOS_INLINE_FUNCTION
-void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeForce<NEIGHFLAG,EVFLAG>,const typename Kokkos::TeamPolicy<DeviceType, TagPairSNAPComputeForce<NEIGHFLAG,EVFLAG> >::member_type& team, EV_FLOAT& ev) const {
+void PairSNAPKokkos<DeviceType>::operator() (TagPairSNAPComputeForce<NEIGHFLAG,EVFLAG>,const typename Kokkos::TeamPolicy<DeviceType,TagPairSNAPComputeForce<NEIGHFLAG,EVFLAG> >::member_type& team, EV_FLOAT& ev) const {
 
   // The f array is duplicated for OpenMP, atomic for CUDA, and neither for Serial
 
@@ -886,4 +894,28 @@ double PairSNAPKokkos<DeviceType>::memory_usage()
   return bytes;
 }
 
+/* ---------------------------------------------------------------------- */
+
+template<class DeviceType>
+template<class TagStyle>
+void PairSNAPKokkos<DeviceType>::check_team_size_for(int inum, int &team_size, int vector_length) {
+  int team_size_max;
+
+  team_size_max = Kokkos::TeamPolicy<DeviceType,TagStyle>(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelForTag());
+
+  if(team_size*vector_length > team_size_max)
+    team_size = team_size_max/vector_length;
+}
+
+template<class DeviceType>
+template<class TagStyle>
+void PairSNAPKokkos<DeviceType>::check_team_size_reduce(int inum, int &team_size, int vector_length) {
+  int team_size_max;
+
+  team_size_max = Kokkos::TeamPolicy<DeviceType,TagStyle>(inum,Kokkos::AUTO).team_size_max(*this,Kokkos::ParallelReduceTag());
+
+  if(team_size*vector_length > team_size_max)
+    team_size = team_size_max/vector_length;
+}
+
 }
diff --git a/src/KOKKOS/pair_sw_kokkos.cpp b/src/KOKKOS/pair_sw_kokkos.cpp
index e85afa362f9b1f599d95bbf2702256cbd2c5a5ff..4ca75ebd2e4043348ddd9c024bab4eb4f132c295 100644
--- a/src/KOKKOS/pair_sw_kokkos.cpp
+++ b/src/KOKKOS/pair_sw_kokkos.cpp
@@ -87,7 +87,7 @@ void PairSWKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -610,10 +610,10 @@ void PairSWKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   // always request a full neighbor list
 
diff --git a/src/KOKKOS/pair_sw_kokkos.h b/src/KOKKOS/pair_sw_kokkos.h
index 1a3f0b862f860d1c36a3db5df953ece351e620f6..2fc7f93c12587e11d12c905307631de8f2e3b2a0 100644
--- a/src/KOKKOS/pair_sw_kokkos.h
+++ b/src/KOKKOS/pair_sw_kokkos.h
@@ -135,12 +135,12 @@ class PairSWKokkos : public PairSW {
   typename AT::t_virial_array d_vatom;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   typename AT::t_int_1d_randomread d_type2frho;
   typename AT::t_int_2d_randomread d_type2rhor;
diff --git a/src/KOKKOS/pair_table_kokkos.cpp b/src/KOKKOS/pair_table_kokkos.cpp
index 5ee24ad4797c381702d65386d6baea5739e1140c..a86db70d4d542df0858fd9e17c793c5cd43f1924 100644
--- a/src/KOKKOS/pair_table_kokkos.cpp
+++ b/src/KOKKOS/pair_table_kokkos.cpp
@@ -93,7 +93,7 @@ void PairTableKokkos<DeviceType>::compute_style(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -514,10 +514,10 @@ void PairTableKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_table_rx_kokkos.cpp b/src/KOKKOS/pair_table_rx_kokkos.cpp
index daebeda8db97bc30fb8fcc1891aa4e7818583931..d65ea8bf1f6530e97a216796269ddcbc97cb9fdb 100644
--- a/src/KOKKOS/pair_table_rx_kokkos.cpp
+++ b/src/KOKKOS/pair_table_rx_kokkos.cpp
@@ -284,11 +284,11 @@ ev_tally(
     F_FLOAT delx, F_FLOAT dely, F_FLOAT delz,
     Kokkos::View<F_FLOAT*[6],
                  typename ArrayTypes<DeviceType>::t_virial_array::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > const& v_vatom,
     Kokkos::View<E_FLOAT*,
                  typename ArrayTypes<DeviceType>::t_efloat_1d::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > const& v_eatom)
 {
   if (eflag) {
@@ -399,15 +399,15 @@ compute_item(
     typename ArrayTypes<DeviceType>::t_ffloat_2d const& d_cutsq,
     Kokkos::View<F_FLOAT*[3],
       typename ArrayTypes<DeviceType>::t_f_array::array_layout,
-      DeviceType,
+      typename KKDevice<DeviceType>::value,
       Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > const& f,
     Kokkos::View<E_FLOAT*,
                  typename ArrayTypes<DeviceType>::t_efloat_1d::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > const& uCG,
     Kokkos::View<E_FLOAT*,
                  typename ArrayTypes<DeviceType>::t_efloat_1d::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > const& uCGnew,
     int isite1, int isite2,
     typename PairTableRXKokkos<DeviceType>::TableDeviceConst const& d_table_const,
@@ -418,11 +418,11 @@ compute_item(
     int vflag_atom,
     Kokkos::View<F_FLOAT*[6],
                  typename ArrayTypes<DeviceType>::t_virial_array::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > const& v_vatom,
     Kokkos::View<E_FLOAT*,
                  typename ArrayTypes<DeviceType>::t_efloat_1d::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > const& v_eatom) {
   EV_FLOAT ev;
   auto i = d_ilist(ii);
@@ -544,14 +544,16 @@ static void compute_all_items(
     typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq,
     Kokkos::View<F_FLOAT*[3],
       typename ArrayTypes<DeviceType>::t_f_array::array_layout,
-      DeviceType,
+      typename KKDevice<DeviceType>::value,
       Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > f,
     Kokkos::View<E_FLOAT*,
                  typename ArrayTypes<DeviceType>::t_efloat_1d::array_layout,
-                 DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > uCG,
+                 typename KKDevice<DeviceType>::value,
+                 Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > uCG,
     Kokkos::View<E_FLOAT*,
                  typename ArrayTypes<DeviceType>::t_efloat_1d::array_layout,
-                 DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > uCGnew,
+                 typename KKDevice<DeviceType>::value,
+                 Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > uCGnew,
     int isite1, int isite2,
     typename PairTableRXKokkos<DeviceType>::TableDeviceConst d_table_const,
     int eflag,
@@ -561,11 +563,11 @@ static void compute_all_items(
     int vflag_atom,
     Kokkos::View<F_FLOAT*[6],
                  typename ArrayTypes<DeviceType>::t_virial_array::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom,
     Kokkos::View<E_FLOAT*,
                  typename ArrayTypes<DeviceType>::t_efloat_1d::array_layout,
-                 DeviceType,
+                 typename KKDevice<DeviceType>::value,
                  Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom) {
   if (eflag || vflag) {
     Kokkos::parallel_reduce(inum,
@@ -627,7 +629,7 @@ void PairTableRXKokkos<DeviceType>::compute_style(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.template view<DeviceType>();
   }
 
@@ -1268,10 +1270,10 @@ void PairTableRXKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
diff --git a/src/KOKKOS/pair_tersoff_kokkos.cpp b/src/KOKKOS/pair_tersoff_kokkos.cpp
index b360b20ef3f5658f3919980e80fe910ea7160fec..134431aa4400b2cd762cd61f47f9e9ac33069ce4 100644
--- a/src/KOKKOS/pair_tersoff_kokkos.cpp
+++ b/src/KOKKOS/pair_tersoff_kokkos.cpp
@@ -88,10 +88,10 @@ void PairTersoffKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL)
     error->all(FLERR,"Cannot (yet) use full neighbor list style with tersoff/kk");
@@ -169,7 +169,7 @@ void PairTersoffKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
diff --git a/src/KOKKOS/pair_tersoff_kokkos.h b/src/KOKKOS/pair_tersoff_kokkos.h
index 7d41fe2346902f21b31acb703a69989e791997bf..0c57e21a6c808c3944b7e8a39f4630b03f472048 100644
--- a/src/KOKKOS/pair_tersoff_kokkos.h
+++ b/src/KOKKOS/pair_tersoff_kokkos.h
@@ -202,12 +202,12 @@ class PairTersoffKokkos : public PairTersoff {
   typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   typedef Kokkos::DualView<F_FLOAT**[7],Kokkos::LayoutRight,DeviceType> tdual_ffloat_2d_n7;
   typedef typename tdual_ffloat_2d_n7::t_dev_const_randomread t_ffloat_2d_n7_randomread;
diff --git a/src/KOKKOS/pair_tersoff_mod_kokkos.cpp b/src/KOKKOS/pair_tersoff_mod_kokkos.cpp
index 81ef48699995490a2542cb663ac5d05184351a16..ceb1ed1383a17b7ea9766820419a5fd671ed543b 100644
--- a/src/KOKKOS/pair_tersoff_mod_kokkos.cpp
+++ b/src/KOKKOS/pair_tersoff_mod_kokkos.cpp
@@ -88,10 +88,10 @@ void PairTersoffMODKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL)
     error->all(FLERR,"Cannot (yet) use full neighbor list style with tersoff/mod/kk");
@@ -169,7 +169,7 @@ void PairTersoffMODKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
diff --git a/src/KOKKOS/pair_tersoff_mod_kokkos.h b/src/KOKKOS/pair_tersoff_mod_kokkos.h
index 889e1eadfa103e6c36c6af03f28ea0bb2e1d8955..b47f11e02928ae73f73f80bb5fb8a6a923c77e61 100644
--- a/src/KOKKOS/pair_tersoff_mod_kokkos.h
+++ b/src/KOKKOS/pair_tersoff_mod_kokkos.h
@@ -202,12 +202,12 @@ class PairTersoffMODKokkos : public PairTersoffMOD {
   typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   typedef Kokkos::DualView<F_FLOAT**[7],Kokkos::LayoutRight,DeviceType> tdual_ffloat_2d_n7;
   typedef typename tdual_ffloat_2d_n7::t_dev_const_randomread t_ffloat_2d_n7_randomread;
diff --git a/src/KOKKOS/pair_tersoff_zbl_kokkos.cpp b/src/KOKKOS/pair_tersoff_zbl_kokkos.cpp
index 4593f32e3640951d3154c0e49d5680360c9a0f19..c7a08772c87261a1e5c682b7579b4200c4340151 100644
--- a/src/KOKKOS/pair_tersoff_zbl_kokkos.cpp
+++ b/src/KOKKOS/pair_tersoff_zbl_kokkos.cpp
@@ -101,10 +101,10 @@ void PairTersoffZBLKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL)
     error->all(FLERR,"Cannot (yet) use full neighbor list style with tersoff/zbl/kk");
@@ -185,7 +185,7 @@ void PairTersoffZBLKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
diff --git a/src/KOKKOS/pair_tersoff_zbl_kokkos.h b/src/KOKKOS/pair_tersoff_zbl_kokkos.h
index 0c7fa2e963843019e7d91fd02642f8e58ff935bd..bed2564da54d2040c0d2d8e56cd4535bf2e5be15 100644
--- a/src/KOKKOS/pair_tersoff_zbl_kokkos.h
+++ b/src/KOKKOS/pair_tersoff_zbl_kokkos.h
@@ -207,12 +207,12 @@ class PairTersoffZBLKokkos : public PairTersoffZBL {
   typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
 
   int need_dup;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
-  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
-  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
+  Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
+  Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;
 
   typedef Kokkos::DualView<F_FLOAT**[7],Kokkos::LayoutRight,DeviceType> tdual_ffloat_2d_n7;
   typedef typename tdual_ffloat_2d_n7::t_dev_const_randomread t_ffloat_2d_n7_randomread;
diff --git a/src/KOKKOS/pair_vashishta_kokkos.cpp b/src/KOKKOS/pair_vashishta_kokkos.cpp
index 614d3334d56c388d3a3d57598b51f04a5e312e64..1d46fe3cd2d7b9a2c0207e8258c614e993f7223b 100644
--- a/src/KOKKOS/pair_vashishta_kokkos.cpp
+++ b/src/KOKKOS/pair_vashishta_kokkos.cpp
@@ -86,7 +86,7 @@ void PairVashishtaKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -234,7 +234,7 @@ void PairVashishtaKokkos<DeviceType>::operator()(TagPairVashishtaComputeHalf<NEI
 
   // The f array is atomic
 
-  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
+  Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
 
   F_FLOAT delr1[3],delr2[3],fj[3],fk[3];
   F_FLOAT evdwl = 0.0;
@@ -585,10 +585,10 @@ void PairVashishtaKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   // always request a full neighbor list
 
@@ -780,8 +780,8 @@ void PairVashishtaKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const
 
   // The eatom and vatom arrays are atomic for half/thread neighbor list
 
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
 
   if (eflag_atom) {
@@ -856,8 +856,8 @@ void PairVashishtaKokkos<DeviceType>::ev_tally3(EV_FLOAT &ev, const int &i, cons
 
 // The eatom and vatom arrays are atomic for half/thread neighbor list
 
-  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
-  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
+  Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
+  Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
 
   if (eflag_atom) {
     epairthird = THIRD * (evdwl + ecoul);
diff --git a/src/KOKKOS/pair_yukawa_kokkos.cpp b/src/KOKKOS/pair_yukawa_kokkos.cpp
index 6dfffd4a5499c641693fb7a8b4c4f679b86f6a70..5b641791d3f09e6e28f199a89777b773457c1bbe 100644
--- a/src/KOKKOS/pair_yukawa_kokkos.cpp
+++ b/src/KOKKOS/pair_yukawa_kokkos.cpp
@@ -120,10 +120,10 @@ void PairYukawaKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -184,7 +184,7 @@ void PairYukawaKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
diff --git a/src/KOKKOS/pair_zbl_kokkos.cpp b/src/KOKKOS/pair_zbl_kokkos.cpp
index 5697dd5b00faca83dda7f32d73d1f85a046fabb7..fe34f58fa6f5c1333ae81dd0aede83d8c4085317 100644
--- a/src/KOKKOS/pair_zbl_kokkos.cpp
+++ b/src/KOKKOS/pair_zbl_kokkos.cpp
@@ -92,10 +92,10 @@ void PairZBLKokkos<DeviceType>::init_style()
   int irequest = neighbor->nrequest - 1;
 
   neighbor->requests[irequest]->
-    kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
-    !Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
+    !std::is_same<DeviceType,LMPDeviceType>::value;
   neighbor->requests[irequest]->
-    kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
+    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
 
   if (neighflag == FULL) {
     neighbor->requests[irequest]->full = 1;
@@ -134,7 +134,7 @@ void PairZBLKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
diff --git a/src/KOKKOS/pppm_kokkos.cpp b/src/KOKKOS/pppm_kokkos.cpp
index 08a0c18f9c7ab6ec528cad70a7f99cf43e8d0f4e..62d7ccc3cda9892495de4e0dff1418386ab999d4 100644
--- a/src/KOKKOS/pppm_kokkos.cpp
+++ b/src/KOKKOS/pppm_kokkos.cpp
@@ -620,7 +620,7 @@ void PPPMKokkos<DeviceType>::compute(int eflag, int vflag)
   }
   if (vflag_atom) {
     memoryKK->destroy_kokkos(k_vatom,vatom);
-    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
+    memoryKK->create_kokkos(k_vatom,vatom,maxvatom,"pair:vatom");
     d_vatom = k_vatom.view<DeviceType>();
   }
 
@@ -1670,7 +1670,7 @@ KOKKOS_INLINE_FUNCTION
 void PPPMKokkos<DeviceType>::operator()(TagPPPM_make_rho_atomic, const int &i) const
 {
   // The density_brick array is atomic for Half/Thread neighbor style
-  Kokkos::View<FFT_SCALAR***,Kokkos::LayoutRight,DeviceType,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_density_brick = d_density_brick;
+  Kokkos::View<FFT_SCALAR***,Kokkos::LayoutRight,typename KKDevice<DeviceType>::value,Kokkos::MemoryTraits<Kokkos::Atomic|Kokkos::Unmanaged> > a_density_brick = d_density_brick;
 
   int nx = d_part2grid(i,0);
   int ny = d_part2grid(i,1);
diff --git a/src/KOKKOS/remap_kokkos.cpp b/src/KOKKOS/remap_kokkos.cpp
index c809aa034c05a6317592364acf5ac63a3d894384..e94a4ddd9ff19283044409151f81a07c5e15ebca 100644
--- a/src/KOKKOS/remap_kokkos.cpp
+++ b/src/KOKKOS/remap_kokkos.cpp
@@ -120,7 +120,7 @@ void RemapKokkos<DeviceType>::remap_3d_kokkos(typename FFT_AT::t_FFT_SCALAR_1d d
   // post all recvs into scratch space
 
   for (irecv = 0; irecv < plan->nrecv; irecv++) {
-    FFT_SCALAR* scratch = d_scratch.ptr_on_device() + plan->recv_bufloc[irecv];
+    FFT_SCALAR* scratch = d_scratch.data() + plan->recv_bufloc[irecv];
     MPI_Irecv(scratch,plan->recv_size[irecv],
               MPI_FFT_SCALAR,plan->recv_proc[irecv],0,
               plan->comm,&plan->request[irecv]);
@@ -132,7 +132,7 @@ void RemapKokkos<DeviceType>::remap_3d_kokkos(typename FFT_AT::t_FFT_SCALAR_1d d
     int in_offset = plan->send_offset[isend];
     plan->pack(d_in,in_offset,
                plan->d_sendbuf,0,&plan->packplan[isend]);
-    MPI_Send(plan->d_sendbuf.ptr_on_device(),plan->send_size[isend],MPI_FFT_SCALAR,
+    MPI_Send(plan->d_sendbuf.data(),plan->send_size[isend],MPI_FFT_SCALAR,
              plan->send_proc[isend],0,plan->comm);
   }
 
@@ -505,7 +505,7 @@ void RemapKokkos<DeviceType>::remap_3d_destroy_plan_kokkos(struct remap_plan_3d_
 
 namespace LAMMPS_NS {
 template class RemapKokkos<LMPDeviceType>;
-#ifdef KOKKOS_HAVE_CUDA
+#ifdef KOKKOS_ENABLE_CUDA
 template class RemapKokkos<LMPHostType>;
 #endif
 }
diff --git a/src/KOKKOS/sna_kokkos.h b/src/KOKKOS/sna_kokkos.h
index a6d9db3218d698a460e02504bff4d2583a74def2..b7162cf8d6ef301790d9294f8e1ccc6af5a5ad99 100644
--- a/src/KOKKOS/sna_kokkos.h
+++ b/src/KOKKOS/sna_kokkos.h
@@ -89,7 +89,7 @@ class SNAKokkos {
 public:
   typedef Kokkos::View<int*, DeviceType> t_sna_1i;
   typedef Kokkos::View<double*, DeviceType> t_sna_1d;
-  typedef Kokkos::View<double*, DeviceType, Kokkos::MemoryTraits<Kokkos::Atomic> > t_sna_1d_atomic;
+  typedef Kokkos::View<double*, typename KKDevice<DeviceType>::value, Kokkos::MemoryTraits<Kokkos::Atomic> > t_sna_1d_atomic;
   typedef Kokkos::View<int**, DeviceType> t_sna_2i;
   typedef Kokkos::View<double**, DeviceType> t_sna_2d;
   typedef Kokkos::View<double**, Kokkos::LayoutLeft, DeviceType> t_sna_2d_ll;
@@ -99,7 +99,7 @@ public:
   typedef Kokkos::View<double*****, DeviceType> t_sna_5d;
 
   typedef Kokkos::View<SNAcomplex*, DeviceType> t_sna_1c;
-  typedef Kokkos::View<SNAcomplex*, DeviceType, Kokkos::MemoryTraits<Kokkos::Atomic> > t_sna_1c_atomic;
+  typedef Kokkos::View<SNAcomplex*, typename KKDevice<DeviceType>::value, Kokkos::MemoryTraits<Kokkos::Atomic> > t_sna_1c_atomic;
   typedef Kokkos::View<SNAcomplex**, DeviceType> t_sna_2c;
   typedef Kokkos::View<SNAcomplex**, Kokkos::LayoutLeft, DeviceType> t_sna_2c_ll;
   typedef Kokkos::View<SNAcomplex**, Kokkos::LayoutRight, DeviceType> t_sna_2c_lr;
diff --git a/src/KOKKOS/sna_kokkos_impl.h b/src/KOKKOS/sna_kokkos_impl.h
index dcedf333e531bb64d42ce44bd4470dc4b953c93d..4ed385ccc10768a392cb582565b8fd7f8b91fa17 100644
--- a/src/KOKKOS/sna_kokkos_impl.h
+++ b/src/KOKKOS/sna_kokkos_impl.h
@@ -1024,7 +1024,7 @@ void SNAKokkos<DeviceType>::compute_uarray_cpu(const typename Kokkos::TeamPolicy
         const int jju_index = jju+mb+mb*j+ma;
         const int jjup_index = jjup+mb*j+ma;
         rootpq = rootpqarray(j - ma,j - mb);
-        ulist(jju_index,iatom,jnbor,jju).re +=
+        ulist(jju_index,iatom,jnbor).re +=
           rootpq *
           (a_r * ulist(jjup_index,iatom,jnbor).re +
            a_i * ulist(jjup_index,iatom,jnbor).im);
@@ -1643,7 +1643,7 @@ double SNAKokkos<DeviceType>::memory_usage()
   }
 #endif
   bytes += natom * idxu_max * sizeof(double) * 2;        // ulisttot
-  if (!Kokkos::Impl::is_same<typename DeviceType::array_layout,Kokkos::LayoutRight>::value)
+  if (!std::is_same<typename DeviceType::array_layout,Kokkos::LayoutRight>::value)
     bytes += natom * idxu_max * sizeof(double) * 2;        // ulisttot_lr
 
   bytes += natom * idxz_max * sizeof(double) * 2;        // zlist
diff --git a/src/MOLECULE/bond_fene.cpp b/src/MOLECULE/bond_fene.cpp
index b8e197a3444b33ab79689c686c76d624084d3f68..e3c47b62414a7f2f71fb0a190e234184e5306005 100644
--- a/src/MOLECULE/bond_fene.cpp
+++ b/src/MOLECULE/bond_fene.cpp
@@ -14,6 +14,7 @@
 #include "bond_fene.h"
 #include <mpi.h>
 #include <cmath>
+#include <cstring>
 #include "atom.h"
 #include "neighbor.h"
 #include "comm.h"
@@ -272,3 +273,13 @@ double BondFENE::single(int type, double rsq, int /*i*/, int /*j*/,
 
   return eng;
 }
+
+/* ---------------------------------------------------------------------- */
+
+void *BondFENE::extract( char *str, int &dim )
+{
+  dim = 1;
+  if (strcmp(str,"kappa")==0) return (void*) k;
+  if (strcmp(str,"r0")==0) return (void*) r0;
+  return NULL;
+}
diff --git a/src/MOLECULE/bond_fene.h b/src/MOLECULE/bond_fene.h
index 1963e3ca2286a642e63001330dfe895d7aef066e..77c7db12008a91e5cfbacd183ab5029cc62a9c87 100644
--- a/src/MOLECULE/bond_fene.h
+++ b/src/MOLECULE/bond_fene.h
@@ -36,6 +36,7 @@ class BondFENE : public Bond {
   void read_restart(FILE *);
   void write_data(FILE *);
   double single(int, double, int, int, double &);
+  virtual void *extract(char *, int &);
 
  protected:
   double TWO_1_3;
diff --git a/src/MOLECULE/bond_morse.cpp b/src/MOLECULE/bond_morse.cpp
index 249f92928f384ec34df3640e8b21ad002a0338ac..0a9222987962c08276f1295278c183a2dfff96e1 100644
--- a/src/MOLECULE/bond_morse.cpp
+++ b/src/MOLECULE/bond_morse.cpp
@@ -18,6 +18,7 @@
 #include "bond_morse.h"
 #include <mpi.h>
 #include <cmath>
+#include <cstring>
 #include "atom.h"
 #include "neighbor.h"
 #include "comm.h"
@@ -205,3 +206,12 @@ double BondMorse::single(int type, double rsq, int /*i*/, int /*j*/,
   if (r > 0.0) fforce = -2.0*d0[type]*alpha[type]*(1-ralpha)*ralpha/r;
   return d0[type]*(1-ralpha)*(1-ralpha);
 }
+
+/* ---------------------------------------------------------------------- */
+
+void *BondMorse::extract(char *str, int &dim )
+{
+  dim = 1;
+  if (strcmp(str,"r0")==0) return (void*) r0;
+  return NULL;
+}
diff --git a/src/MOLECULE/bond_morse.h b/src/MOLECULE/bond_morse.h
index 030a94a8da964c764d72d80167933076aeb362e2..cbab0aed1dbb01482af8415cf668f4903883a159 100644
--- a/src/MOLECULE/bond_morse.h
+++ b/src/MOLECULE/bond_morse.h
@@ -35,6 +35,7 @@ class BondMorse : public Bond {
   void read_restart(FILE *);
   void write_data(FILE *);
   double single(int, double, int, int, double &);
+  virtual void *extract(char *, int &);
 
  protected:
   double *d0,*alpha,*r0;
diff --git a/src/MOLECULE/bond_nonlinear.cpp b/src/MOLECULE/bond_nonlinear.cpp
index ee943ad28f0495702f54b99f0261aee038798c97..8f0616e03e3b94623d20db971bba9338e0c3e6fc 100644
--- a/src/MOLECULE/bond_nonlinear.cpp
+++ b/src/MOLECULE/bond_nonlinear.cpp
@@ -14,6 +14,7 @@
 #include "bond_nonlinear.h"
 #include <mpi.h>
 #include <cmath>
+#include <cstring>
 #include "atom.h"
 #include "neighbor.h"
 #include "comm.h"
@@ -202,3 +203,13 @@ double BondNonlinear::single(int type, double rsq, int /*i*/, int /*j*/,
   fforce = -epsilon[type]/r * 2.0*dr*lamdasq/denomsq;
   return epsilon[type] * drsq / denom;
 }
+
+/* ---------------------------------------------------------------------- */
+
+void *BondNonlinear::extract( char *str, int &dim )
+{
+  dim = 1;
+  if (strcmp(str,"epsilon")==0) return (void*) epsilon;
+  if (strcmp(str,"r0")==0) return (void*) r0;
+  return NULL;
+}
diff --git a/src/MOLECULE/bond_nonlinear.h b/src/MOLECULE/bond_nonlinear.h
index 7782b937784869bc62b4a674d64bf0a847ce1906..76dffdba31f1843fe8e1b7368dcdaef0f97b1e57 100644
--- a/src/MOLECULE/bond_nonlinear.h
+++ b/src/MOLECULE/bond_nonlinear.h
@@ -35,6 +35,7 @@ class BondNonlinear : public Bond {
   void read_restart(FILE *);
   void write_data(FILE *);
   double single(int, double, int, int, double &);
+  virtual void *extract(char *, int &);
 
  protected:
   double *epsilon,*r0,*lamda;